</para>
<para>
Role can log in. That is, this role can be given as the initial
- session authorization identifier
+ session authorization identifier.
</para></entry>
</row>
</term>
<listitem>
<para>
- If set, do not trace locks for tables below this OID. (use to avoid
- output on system tables)
+ If set, do not trace locks for tables below this OID (used to avoid
+ output on system tables).
</para>
<para>
This parameter is only available if the <symbol>LOCK_DEBUG</symbol>
OK
(1 row)
-SELECT * FROM dblink('myconn','SELECT * FROM foo') AS t(a int, b text, c text[]);
+SELECT * FROM dblink('myconn', 'SELECT * FROM foo') AS t(a int, b text, c text[]);
a | b | c
----+---+---------------
0 | a | {a0,b0,c0}
<para>
The SQL command that you wish to execute in the remote database,
for example
- <literal>insert into foo values(0,'a','{"a0","b0","c0"}')</literal>.
+ <literal>insert into foo values(0, 'a', '{"a0","b0","c0"}')</literal>.
</para>
</listitem>
</varlistentry>
OK
(1 row)
-SELECT dblink_exec('insert into foo values(21,''z'',''{"a0","b0","c0"}'');');
+SELECT dblink_exec('insert into foo values(21, ''z'', ''{"a0","b0","c0"}'');');
dblink_exec
-----------------
INSERT 943366 1
OK
(1 row)
-SELECT dblink_exec('myconn', 'insert into foo values(21,''z'',''{"a0","b0","c0"}'');');
+SELECT dblink_exec('myconn', 'insert into foo values(21, ''z'', ''{"a0","b0","c0"}'');');
dblink_exec
------------------
INSERT 6432584 1
per <function>to_json</function> or <function>to_jsonb</function>.
</para>
<para>
- <literal>json_build_array(1,2,'foo',4,5)</literal>
+ <literal>json_build_array(1, 2, 'foo', 4, 5)</literal>
<returnvalue>[1, 2, "foo", 4, 5]</returnvalue>
</para></entry>
</row>
per <function>to_json</function> or <function>to_jsonb</function>.
</para>
<para>
- <literal>json_build_object('foo',1,2,row(3,'bar'))</literal>
+ <literal>json_build_object('foo', 1, 2, row(3,'bar'))</literal>
<returnvalue>{"foo" : 1, "2" : {"f1":3,"f2":"bar"}}</returnvalue>
</para></entry>
</row>
<literal>json_object('{a, 1, b, "def", c, 3.5}')</literal>
<returnvalue>{"a" : "1", "b" : "def", "c" : "3.5"}</returnvalue>
</para>
- <para><literal>json_object('{{a, 1},{b, "def"},{c, 3.5}}')</literal>
+ <para><literal>json_object('{{a, 1}, {b, "def"}, {c, 3.5}}')</literal>
<returnvalue>{"a" : "1", "b" : "def", "c" : "3.5"}</returnvalue>
</para></entry>
</row>
the one-argument form.
</para>
<para>
- <literal>json_object('{a, b}', '{1,2}')</literal>
+ <literal>json_object('{a,b}', '{1,2}')</literal>
<returnvalue>{"a": "1", "b": "2"}</returnvalue>
</para></entry>
</row>
<literal>create type twoints as (a int, b int);</literal>
</para>
<para>
- <literal>select * from json_populate_recordset(null::twoints, '[{"a":1,"b":2},{"a":3,"b":4}]')</literal>
+ <literal>select * from json_populate_recordset(null::twoints, '[{"a":1,"b":2}, {"a":3,"b":4}]')</literal>
<returnvalue></returnvalue>
<programlisting>
a | b
for <function>json[b]_populate_record</function>.
</para>
<para>
- <literal>select * from json_to_recordset('[{"a":1,"b":"foo"},{"a":"2","c":"bar"}]') as x(a int, b text)</literal>
+ <literal>select * from json_to_recordset('[{"a":1,"b":"foo"}, {"a":"2","c":"bar"}]') as x(a int, b text)</literal>
<returnvalue></returnvalue>
<programlisting>
a | b
or at the end of the array if it is positive.
</para>
<para>
- <literal>jsonb_set('[{"f1":1,"f2":null},2,null,3]', '{0,f1}','[2,3,4]', false)</literal>
+ <literal>jsonb_set('[{"f1":1,"f2":null},2,null,3]', '{0,f1}', '[2,3,4]', false)</literal>
<returnvalue>[{"f1": [2, 3, 4], "f2": null}, 2, null, 3]</returnvalue>
</para>
<para>
- <literal>jsonb_set('[{"f1":1,"f2":null},2]', '{0,f3}','[2,3,4]')</literal>
+ <literal>jsonb_set('[{"f1":1,"f2":null},2]', '{0,f3}', '[2,3,4]')</literal>
<returnvalue>[{"f1": 1, "f2": null, "f3": [2, 3, 4]}, 2]</returnvalue>
</para></entry>
</row>
untouched.
</para>
<para>
- <literal>json_strip_nulls('[{"f1":1,"f2":null},2,null,3]')</literal>
+ <literal>json_strip_nulls('[{"f1":1, "f2":null}, 2, null, 3]')</literal>
<returnvalue>[{"f1":1},2,null,3]</returnvalue>
</para></entry>
</row>
as the <literal>@?</literal> and <literal>@@</literal> operators do.
</para>
<para>
- <literal>jsonb_path_exists('{"a":[1,2,3,4,5]}', '$.a[*] ? (@ >= $min && @ <= $max)', '{"min":2,"max":4}')</literal>
+ <literal>jsonb_path_exists('{"a":[1,2,3,4,5]}', '$.a[*] ? (@ >= $min && @ <= $max)', '{"min":2, "max":4}')</literal>
<returnvalue>t</returnvalue>
</para></entry>
</row>
for <function>jsonb_path_exists</function>.
</para>
<para>
- <literal>jsonb_path_match('{"a":[1,2,3,4,5]}', 'exists($.a[*] ? (@ >= $min && @ <= $max))', '{"min":2,"max":4}')</literal>
+ <literal>jsonb_path_match('{"a":[1,2,3,4,5]}', 'exists($.a[*] ? (@ >= $min && @ <= $max))', '{"min":2, "max":4}')</literal>
<returnvalue>t</returnvalue>
</para></entry>
</row>
for <function>jsonb_path_exists</function>.
</para>
<para>
- <literal>select * from jsonb_path_query('{"a":[1,2,3,4,5]}', '$.a[*] ? (@ >= $min && @ <= $max)', '{"min":2,"max":4}')</literal>
+ <literal>select * from jsonb_path_query('{"a":[1,2,3,4,5]}', '$.a[*] ? (@ >= $min && @ <= $max)', '{"min":2, "max":4}')</literal>
<returnvalue></returnvalue>
<programlisting>
jsonb_path_query
for <function>jsonb_path_exists</function>.
</para>
<para>
- <literal>jsonb_path_query_array('{"a":[1,2,3,4,5]}', '$.a[*] ? (@ >= $min && @ <= $max)', '{"min":2,"max":4}')</literal>
+ <literal>jsonb_path_query_array('{"a":[1,2,3,4,5]}', '$.a[*] ? (@ >= $min && @ <= $max)', '{"min":2, "max":4}')</literal>
<returnvalue>[2, 3, 4]</returnvalue>
</para></entry>
</row>
for <function>jsonb_path_exists</function>.
</para>
<para>
- <literal>jsonb_path_query_first('{"a":[1,2,3,4,5]}', '$.a[*] ? (@ >= $min && @ <= $max)', '{"min":2,"max":4}')</literal>
+ <literal>jsonb_path_query_first('{"a":[1,2,3,4,5]}', '$.a[*] ? (@ >= $min && @ <= $max)', '{"min":2, "max":4}')</literal>
<returnvalue>2</returnvalue>
</para></entry>
</row>
Converts the given JSON value to pretty-printed, indented text.
</para>
<para>
- <literal>jsonb_pretty('[{"f1":1,"f2":null},2]')</literal>
+ <literal>jsonb_pretty('[{"f1":1,"f2":null}, 2]')</literal>
<returnvalue></returnvalue>
<programlisting>
[
obj.object_name,
obj.object_identity;
END LOOP;
-END
+END;
$$;
CREATE EVENT TRIGGER test_event_trigger_for_drops
ON sql_drop
</para>
<para>
<varname>gin_pending_list_limit</varname> can be overridden for individual
- GIN indexes by changing storage parameters, and which allows each
+ GIN indexes by changing storage parameters, which allows each
GIN index to have its own cleanup threshold.
For example, it's possible to increase the threshold only for the GIN
index which can be updated heavily, and decrease it otherwise.
Note that in this mode, the server will apply WAL one file at a
time, so if you use the standby server for queries (see Hot Standby),
there is a delay between an action in the primary and when the
- action becomes visible in the standby, corresponding the time it takes
+ action becomes visible in the standby, corresponding to the time it takes
to fill up the WAL file. <varname>archive_timeout</varname> can be used to make that delay
shorter. Also note that you can't combine streaming replication with
this method.
Does <type>hstore</type> contain key?
</para>
<para>
- <literal>exist('a=>1','a')</literal>
+ <literal>exist('a=>1', 'a')</literal>
<returnvalue>t</returnvalue>
</para></entry>
</row>
for key?
</para>
<para>
- <literal>defined('a=>NULL','a')</literal>
+ <literal>defined('a=>NULL', 'a')</literal>
<returnvalue>f</returnvalue>
</para></entry>
</row>
Deletes pair with matching key.
</para>
<para>
- <literal>delete('a=>1,b=>2','b')</literal>
+ <literal>delete('a=>1,b=>2', 'b')</literal>
<returnvalue>"a"=>"1"</returnvalue>
</para></entry>
</row>
Deletes pairs with matching keys.
</para>
<para>
- <literal>delete('a=>1,b=>2,c=>3',ARRAY['a','b'])</literal>
+ <literal>delete('a=>1,b=>2,c=>3', ARRAY['a','b'])</literal>
<returnvalue>"c"=>"3"</returnvalue>
</para></entry>
</row>
Deletes pairs matching those in the second argument.
</para>
<para>
- <literal>delete('a=>1,b=>2','a=>4,b=>2'::hstore)</literal>
+ <literal>delete('a=>1,b=>2', 'a=>4,b=>2'::hstore)</literal>
<returnvalue>"a"=>"1"</returnvalue>
</para></entry>
</row>
will pass the caller's snapshot test. On success, <function>amgettuple</function>
must also set <literal>scan->xs_recheck</literal> to true or false.
False means it is certain that the index entry matches the scan keys.
- true means this is not certain, and the conditions represented by the
+ True means this is not certain, and the conditions represented by the
scan keys must be rechecked against the heap tuple after fetching it.
This provision supports <quote>lossy</quote> index operators.
Note that rechecking will extend only to the scan conditions; a partial
hard-coded list of prefixes; this list of prefixes is also used to hyphenate
numbers on output. Since new prefixes are assigned from time to time, the
list of prefixes may be out of date. It is hoped that a future version of
- this module will obtained the prefix list from one or more tables that
+ this module will obtain the prefix list from one or more tables that
can be easily updated by users as needed; however, at present, the
list can only be updated by modifying the source code and recompiling.
Alternatively, prefix validation and hyphenation support may be
position <parameter>end</parameter>-1 (counting from 0).
</para>
<para>
- <literal>subltree('Top.Child1.Child2',1,2)</literal>
+ <literal>subltree('Top.Child1.Child2', 1, 2)</literal>
<returnvalue>Child1</returnvalue>
</para></entry>
</row>
the end of the path.
</para>
<para>
- <literal>subpath('Top.Child1.Child2',0,2)</literal>
+ <literal>subpath('Top.Child1.Child2', 0, 2)</literal>
<returnvalue>Top.Child1</returnvalue>
</para></entry>
</row>
from the end of the path.
</para>
<para>
- <literal>subpath('Top.Child1.Child2',1)</literal>
+ <literal>subpath('Top.Child1.Child2', 1)</literal>
<returnvalue>Child1.Child2</returnvalue>
</para></entry>
</row>
<parameter>a</parameter>, or -1 if not found.
</para>
<para>
- <literal>index('0.1.2.3.5.4.5.6.8.5.6.8','5.6')</literal>
+ <literal>index('0.1.2.3.5.4.5.6.8.5.6.8', '5.6')</literal>
<returnvalue>6</returnvalue>
</para></entry>
</row>
start <parameter>-offset</parameter> labels from the end of the path.
</para>
<para>
- <literal>index('0.1.2.3.5.4.5.6.8.5.6.8','5.6',-4)</literal>
+ <literal>index('0.1.2.3.5.4.5.6.8.5.6.8', '5.6', -4)</literal>
<returnvalue>9</returnvalue>
</para></entry>
</row>
(up to 8 arguments are supported).
</para>
<para>
- <literal>lca('1.2.3','1.2.3.4.5.6')</literal>
+ <literal>lca('1.2.3', '1.2.3.4.5.6')</literal>
<returnvalue>1.2</returnvalue>
</para></entry>
</row>
<para>
The <literal>FOR UPDATE</literal> lock mode
is also acquired by any <command>DELETE</command> on a row, and also by an
- <command>UPDATE</command> that modifies the values on certain columns. Currently,
+ <command>UPDATE</command> that modifies the values of certain columns. Currently,
the set of columns considered for the <command>UPDATE</command> case are those that
have a unique index on them that can be used in a foreign key (so partial
indexes and expressional indexes are not considered), but this may change
</para>
<para>
- The following operations are always parallel restricted.
+ The following operations are always parallel restricted:
</para>
<itemizedlist>
SELECT users.userid INTO STRICT userid
FROM users WHERE users.username = get_userid.username;
RETURN userid;
-END
+END;
$$ LANGUAGE plpgsql;
</programlisting>
On failure, this function might produce an error message such as
RETURN NEXT r; -- return current row of SELECT
END LOOP;
RETURN;
-END
+END;
$BODY$
LANGUAGE plpgsql;
END IF;
RETURN;
- END
+ END;
$BODY$
LANGUAGE plpgsql;
BEGIN
CALL triple(myvar);
RAISE NOTICE 'myvar = %', myvar; -- prints 15
-END
+END;
$$;
</programlisting>
</para>
ROLLBACK;
END IF;
END LOOP;
-END
+END;
$$;
CALL transaction_test1();
f1 int;
BEGIN
RETURN f1;
-END
+END;
$$ LANGUAGE plpgsql;
WARNING: variable "f1" shadows a previously defined variable
LINE 3: f1 int;
<para>
Every sent transaction contains zero or more DML messages (Insert,
Update, Delete). In case of a cascaded setup it can also contain Origin
- messages. The origin message indicated that the transaction originated on
+ messages. The origin message indicates that the transaction originated on
different replication node. Since a replication node in the scope of logical
replication protocol can be pretty much anything, the only identifier
is the origin name. It's downstream's responsibility to handle this as
[ FROM <replaceable class="parameter">from_item</replaceable> [, ...] ]
[ WHERE <replaceable class="parameter">condition</replaceable> ]
[ GROUP BY <replaceable class="parameter">grouping_element</replaceable> [, ...] ]
- [ HAVING <replaceable class="parameter">condition</replaceable> [, ...] ]
+ [ HAVING <replaceable class="parameter">condition</replaceable> ]
[ WINDOW <replaceable class="parameter">window_name</replaceable> AS ( <replaceable class="parameter">window_definition</replaceable> ) [, ...] ]
[ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] <replaceable class="parameter">select</replaceable> ]
[ ORDER BY <replaceable class="parameter">expression</replaceable> [ ASC | DESC | USING <replaceable class="parameter">operator</replaceable> ] [ NULLS { FIRST | LAST } ] [, ...] ]
[ FROM <replaceable class="parameter">from_item</replaceable> [, ...] ]
[ WHERE <replaceable class="parameter">condition</replaceable> ]
[ GROUP BY <replaceable class="parameter">expression</replaceable> [, ...] ]
- [ HAVING <replaceable class="parameter">condition</replaceable> [, ...] ]
+ [ HAVING <replaceable class="parameter">condition</replaceable> ]
[ WINDOW <replaceable class="parameter">window_name</replaceable> AS ( <replaceable class="parameter">window_definition</replaceable> ) [, ...] ]
[ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] <replaceable class="parameter">select</replaceable> ]
[ ORDER BY <replaceable class="parameter">expression</replaceable> [ ASC | DESC | USING <replaceable class="parameter">operator</replaceable> ] [ NULLS { FIRST | LAST } ] [, ...] ]
</para>
<para>
- The benefit of implementing views with the rule system is,
+ The benefit of implementing views with the rule system is
that the planner has all
the information about which tables have to be scanned plus the
relationships between these tables plus the restrictive
the best path to execute the query, and the more information
the planner has, the better this decision can be. And
the rule system as implemented in <productname>PostgreSQL</productname>
- ensures, that this is all information available about the query
+ ensures that this is all information available about the query
up to that point.
</para>
</sect2>
BEGIN
RAISE NOTICE '% => %', $1, $2;
RETURN true;
-END
+END;
$$ LANGUAGE plpgsql COST 0.0000000000000000000001;
SELECT * FROM phone_number WHERE tricky(person, phone);
</table>
<para>
- Because <literal>...</literal> is widely used in data sources, it is allowed
- as an alternative spelling of <literal>..</literal>. Unfortunately, this
+ Because the <literal>...</literal> operator is widely used in data sources, it is allowed
+ as an alternative spelling of the <literal>..</literal> operator. Unfortunately, this
creates a parsing ambiguity: it is not clear whether the upper bound
in <literal>0...23</literal> is meant to be <literal>23</literal> or <literal>0.23</literal>.
This is resolved by requiring at least one digit before the decimal
positions in <type>tsvector</type>, which in turn affect ranking:
<screen>
-SELECT to_tsvector('english','in the list of stop words');
+SELECT to_tsvector('english', 'in the list of stop words');
to_tsvector
----------------------------
'list':3 'stop':5 'word':6
calculated for documents with and without stop words are quite different:
<screen>
-SELECT ts_rank_cd (to_tsvector('english','in the list of stop words'), to_tsquery('list & stop'));
+SELECT ts_rank_cd (to_tsvector('english', 'in the list of stop words'), to_tsquery('list & stop'));
ts_rank_cd
------------
0.05
-SELECT ts_rank_cd (to_tsvector('english','list stop words'), to_tsquery('list & stop'));
+SELECT ts_rank_cd (to_tsvector('english', 'list stop words'), to_tsquery('list & stop'));
ts_rank_cd
------------
0.1
Now we can test our dictionary:
<screen>
-SELECT ts_lexize('public.simple_dict','YeS');
+SELECT ts_lexize('public.simple_dict', 'YeS');
ts_lexize
-----------
{yes}
-SELECT ts_lexize('public.simple_dict','The');
+SELECT ts_lexize('public.simple_dict', 'The');
ts_lexize
-----------
{}
<screen>
ALTER TEXT SEARCH DICTIONARY public.simple_dict ( Accept = false );
-SELECT ts_lexize('public.simple_dict','YeS');
+SELECT ts_lexize('public.simple_dict', 'YeS');
ts_lexize
-----------
-SELECT ts_lexize('public.simple_dict','The');
+SELECT ts_lexize('public.simple_dict', 'The');
ts_lexize
-----------
{}
Then we will get these results:
<screen>
mydb=# CREATE TEXT SEARCH DICTIONARY syn (template=synonym, synonyms='synonym_sample');
-mydb=# SELECT ts_lexize('syn','indices');
+mydb=# SELECT ts_lexize('syn', 'indices');
ts_lexize
-----------
{index}
mydb=# CREATE TEXT SEARCH CONFIGURATION tst (copy=simple);
mydb=# ALTER TEXT SEARCH CONFIGURATION tst ALTER MAPPING FOR asciiword WITH syn;
-mydb=# SELECT to_tsvector('tst','indices');
+mydb=# SELECT to_tsvector('tst', 'indices');
to_tsvector
-------------
'index':1
(1 row)
-mydb=# SELECT to_tsquery('tst','indices');
+mydb=# SELECT to_tsquery('tst', 'indices');
to_tsquery
------------
'index':*
'are' 'indexes' 'useful' 'very'
(1 row)
-mydb=# SELECT 'indexes are very useful'::tsvector @@ to_tsquery('tst','indices');
+mydb=# SELECT 'indexes are very useful'::tsvector @@ to_tsquery('tst', 'indices');
?column?
----------
t
Here is a simple example:
<screen>
-SELECT * FROM ts_debug('english','a fat cat sat on a mat - it ate a fat rats');
+SELECT * FROM ts_debug('english', 'a fat cat sat on a mat - it ate a fat rats');
alias | description | token | dictionaries | dictionary | lexemes
-----------+-----------------+-------+----------------+--------------+---------
asciiword | Word, all ASCII | a | {english_stem} | english_stem | {}
</programlisting>
<screen>
-SELECT * FROM ts_debug('public.english','The Brightest supernovaes');
+SELECT * FROM ts_debug('public.english', 'The Brightest supernovaes');
alias | description | token | dictionaries | dictionary | lexemes
-----------+-----------------+-------------+-------------------------------+----------------+-------------
asciiword | Word, all ASCII | The | {english_ispell,english_stem} | english_ispell | {}
<screen>
SELECT alias, token, dictionary, lexemes
-FROM ts_debug('public.english','The Brightest supernovaes');
+FROM ts_debug('public.english', 'The Brightest supernovaes');
alias | token | dictionary | lexemes
-----------+-------------+----------------+-------------
asciiword | The | english_ispell | {}
where this can be confusing:
<screen>
-SELECT ts_lexize('thesaurus_astro','supernovae stars') is null;
+SELECT ts_lexize('thesaurus_astro', 'supernovae stars') is null;
?column?
----------
t
projects / postgresql.git / commitdiff