반응형
/********************************************************************************************
-- Title : [PGS9.2] pg_catalog.function 리스트
-- Reference : pgAdmin III
-- Key word : pg_catalog functioin 함수
********************************************************************************************/
함수 | 오너 | 주석 |
---|---|---|
abbrev(inet) | postgres | abbreviated display of inet value |
abbrev(cidr) | postgres | abbreviated display of cidr value |
abs(real) | postgres | absolute value |
abs(numeric) | postgres | absolute value |
abs(double precision) | postgres | absolute value |
abs(bigint) | postgres | absolute value |
abs(integer) | postgres | absolute value |
abs(smallint) | postgres | absolute value |
abstime(timestamp without time zone) | postgres | convert timestamp to abstime |
abstime(timestamp with time zone) | postgres | convert timestamp with time zone to abstime |
abstimeeq(abstime, abstime) | postgres | implementation of = operator |
abstimege(abstime, abstime) | postgres | implementation of >= operator |
abstimegt(abstime, abstime) | postgres | implementation of > operator |
abstimein(cstring) | postgres | I/O |
abstimele(abstime, abstime) | postgres | implementation of <= operator |
abstimelt(abstime, abstime) | postgres | implementation of < operator |
abstimene(abstime, abstime) | postgres | implementation of <> operator |
abstimeout(abstime) | postgres | I/O |
abstimerecv(internal) | postgres | I/O |
abstimesend(abstime) | postgres | I/O |
aclcontains(aclitem[], aclitem) | postgres | contains |
acldefault("char", oid) | postgres | TODO |
aclexplode(aclitem[]) | postgres | convert ACL item array to table, for use by information schema |
aclinsert(aclitem[], aclitem) | postgres | add/update ACL item |
aclitemeq(aclitem, aclitem) | postgres | implementation of = operator |
aclitemin(cstring) | postgres | I/O |
aclitemout(aclitem) | postgres | I/O |
aclremove(aclitem[], aclitem) | postgres | remove ACL item |
acos(double precision) | postgres | arccosine |
age(xid) | postgres | age of a transaction ID, in transactions before current transaction |
age(timestamp with time zone, timestamp with time zone) | postgres | date difference preserving months and years |
age(timestamp without time zone, timestamp without time zone) | postgres | date difference preserving months and years |
age(timestamp without time zone) | postgres | date difference from today preserving months and years |
age(timestamp with time zone) | postgres | date difference from today preserving months and years |
any_in(cstring) | postgres | I/O |
any_out("any") | postgres | I/O |
anyarray_in(cstring) | postgres | I/O |
anyarray_out(anyarray) | postgres | I/O |
anyarray_recv(internal) | postgres | I/O |
anyarray_send(anyarray) | postgres | I/O |
anyelement_in(cstring) | postgres | I/O |
anyelement_out(anyelement) | postgres | I/O |
anyenum_in(cstring) | postgres | I/O |
anyenum_out(anyenum) | postgres | I/O |
anynonarray_in(cstring) | postgres | I/O |
anynonarray_out(anynonarray) | postgres | I/O |
anyrange_in(cstring, oid, integer) | postgres | I/O |
anyrange_out(anyrange) | postgres | I/O |
anytextcat(anynonarray, text) | postgres | implementation of || operator |
area(path) | postgres | area of a closed path |
area(box) | postgres | box area |
area(circle) | postgres | area of circle |
areajoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity for area-comparison operators |
areasel(internal, oid, internal, integer) | postgres | restriction selectivity for area-comparison operators |
array_agg_finalfn(internal) | postgres | aggregate final function |
array_agg_transfn(internal, anyelement) | postgres | aggregate transition function |
array_append(anyarray, anyelement) | postgres | append element onto end of array |
array_cat(anyarray, anyarray) | postgres | implementation of || operator |
array_dims(anyarray) | postgres | array dimensions |
array_eq(anyarray, anyarray) | postgres | implementation of = operator |
array_fill(anyelement, integer[]) | postgres | array constructor with value |
array_fill(anyelement, integer[], integer[]) | postgres | array constructor with value |
array_ge(anyarray, anyarray) | postgres | implementation of >= operator |
array_gt(anyarray, anyarray) | postgres | implementation of > operator |
array_in(cstring, oid, integer) | postgres | I/O |
array_larger(anyarray, anyarray) | postgres | larger of two |
array_le(anyarray, anyarray) | postgres | implementation of <= operator |
array_length(anyarray, integer) | postgres | array length |
array_lower(anyarray, integer) | postgres | array lower dimension |
array_lt(anyarray, anyarray) | postgres | implementation of < operator |
array_ndims(anyarray) | postgres | number of array dimensions |
array_ne(anyarray, anyarray) | postgres | implementation of <> operator |
array_out(anyarray) | postgres | I/O |
array_prepend(anyelement, anyarray) | postgres | prepend element onto front of array |
array_recv(internal, oid, integer) | postgres | I/O |
array_send(anyarray) | postgres | I/O |
array_smaller(anyarray, anyarray) | postgres | smaller of two |
array_to_json(anyarray) | postgres | map array to json |
array_to_json(anyarray, boolean) | postgres | map array to json with optional pretty printing |
array_to_string(anyarray, text) | postgres | concatenate array elements, using delimiter, into text |
array_to_string(anyarray, text, text) | postgres | concatenate array elements, using delimiter and null string, into text |
array_typanalyze(internal) | postgres | array typanalyze |
array_upper(anyarray, integer) | postgres | array upper dimension |
arraycontained(anyarray, anyarray) | postgres | implementation of <@ operator |
arraycontains(anyarray, anyarray) | postgres | implementation of @> operator |
arraycontjoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity for array-containment operators |
arraycontsel(internal, oid, internal, integer) | postgres | restriction selectivity for array-containment operators |
arrayoverlap(anyarray, anyarray) | postgres | implementation of && operator |
ascii(text) | postgres | convert first char to int4 |
ascii_to_mic(integer, integer, cstring, internal, integer) | postgres | internal conversion function for SQL_ASCII to MULE_INTERNAL |
ascii_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for SQL_ASCII to UTF8 |
asin(double precision) | postgres | arcsine |
atan(double precision) | postgres | arctangent |
atan2(double precision, double precision) | postgres | arctangent, two arguments |
big5_to_euc_tw(integer, integer, cstring, internal, integer) | postgres | internal conversion function for BIG5 to EUC_TW |
big5_to_mic(integer, integer, cstring, internal, integer) | postgres | internal conversion function for BIG5 to MULE_INTERNAL |
big5_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for BIG5 to UTF8 |
bit(integer, integer) | postgres | convert int4 to bitstring |
bit(bit, integer, boolean) | postgres | adjust bit() to typmod length |
bit(bigint, integer) | postgres | convert int8 to bitstring |
bit_in(cstring, oid, integer) | postgres | I/O |
bit_length(bytea) | postgres | length in bits |
bit_length(text) | postgres | length in bits |
bit_length(bit) | postgres | length in bits |
bit_out(bit) | postgres | I/O |
bit_recv(internal, oid, integer) | postgres | I/O |
bit_send(bit) | postgres | I/O |
bitand(bit, bit) | postgres | implementation of & operator |
bitcat(bit varying, bit varying) | postgres | implementation of || operator |
bitcmp(bit, bit) | postgres | less-equal-greater |
biteq(bit, bit) | postgres | implementation of = operator |
bitge(bit, bit) | postgres | implementation of >= operator |
bitgt(bit, bit) | postgres | implementation of > operator |
bitle(bit, bit) | postgres | implementation of <= operator |
bitlt(bit, bit) | postgres | implementation of < operator |
bitne(bit, bit) | postgres | implementation of <> operator |
bitnot(bit) | postgres | implementation of ~ operator |
bitor(bit, bit) | postgres | implementation of | operator |
bitshiftleft(bit, integer) | postgres | implementation of << operator |
bitshiftright(bit, integer) | postgres | implementation of >> operator |
bittypmodin(cstring[]) | postgres | I/O typmod |
bittypmodout(integer) | postgres | I/O typmod |
bitxor(bit, bit) | postgres | implementation of # operator |
bool(integer) | postgres | convert int4 to boolean |
booland_statefunc(boolean, boolean) | postgres | aggregate transition function |
booleq(boolean, boolean) | postgres | implementation of = operator |
boolge(boolean, boolean) | postgres | implementation of >= operator |
boolgt(boolean, boolean) | postgres | implementation of > operator |
boolin(cstring) | postgres | I/O |
boolle(boolean, boolean) | postgres | implementation of <= operator |
boollt(boolean, boolean) | postgres | implementation of < operator |
boolne(boolean, boolean) | postgres | implementation of <> operator |
boolor_statefunc(boolean, boolean) | postgres | aggregate transition function |
boolout(boolean) | postgres | I/O |
boolrecv(internal) | postgres | I/O |
boolsend(boolean) | postgres | I/O |
box(point, point) | postgres | convert points to box |
box(polygon) | postgres | convert polygon to bounding box |
box(circle) | postgres | convert circle to box |
box_above(box, box) | postgres | implementation of |>> operator |
box_above_eq(box, box) | postgres | implementation of >^ operator |
box_add(box, point) | postgres | implementation of + operator |
box_below(box, box) | postgres | implementation of <<| operator |
box_below_eq(box, box) | postgres | implementation of <^ operator |
box_center(box) | postgres | implementation of @@ operator |
box_contain(box, box) | postgres | implementation of @> operator |
box_contain_pt(box, point) | postgres | implementation of @> operator |
box_contained(box, box) | postgres | implementation of <@ operator |
box_distance(box, box) | postgres | implementation of <-> operator |
box_div(box, point) | postgres | implementation of / operator |
box_eq(box, box) | postgres | implementation of = operator |
box_ge(box, box) | postgres | implementation of >= operator |
box_gt(box, box) | postgres | implementation of > operator |
box_in(cstring) | postgres | I/O |
box_intersect(box, box) | postgres | implementation of # operator |
box_le(box, box) | postgres | implementation of <= operator |
box_left(box, box) | postgres | implementation of << operator |
box_lt(box, box) | postgres | implementation of < operator |
box_mul(box, point) | postgres | implementation of * operator |
box_out(box) | postgres | I/O |
box_overabove(box, box) | postgres | implementation of |&> operator |
box_overbelow(box, box) | postgres | implementation of &<| operator |
box_overlap(box, box) | postgres | implementation of && operator |
box_overleft(box, box) | postgres | implementation of &< operator |
box_overright(box, box) | postgres | implementation of &> operator |
box_recv(internal) | postgres | I/O |
box_right(box, box) | postgres | implementation of >> operator |
box_same(box, box) | postgres | implementation of ~= operator |
box_send(box) | postgres | I/O |
box_sub(box, point) | postgres | implementation of - operator |
bpchar(name) | postgres | convert name to char(n) |
bpchar(character, integer, boolean) | postgres | adjust char() to typmod length |
bpchar("char") | postgres | convert char to char(n) |
bpchar_larger(character, character) | postgres | larger of two |
bpchar_pattern_ge(character, character) | postgres | implementation of ~>=~ operator |
bpchar_pattern_gt(character, character) | postgres | implementation of ~>~ operator |
bpchar_pattern_le(character, character) | postgres | implementation of ~<=~ operator |
bpchar_pattern_lt(character, character) | postgres | implementation of ~<~ operator |
bpchar_smaller(character, character) | postgres | smaller of two |
bpcharcmp(character, character) | postgres | less-equal-greater |
bpchareq(character, character) | postgres | implementation of = operator |
bpcharge(character, character) | postgres | implementation of >= operator |
bpchargt(character, character) | postgres | implementation of > operator |
bpchariclike(character, text) | postgres | implementation of ~~* operator |
bpcharicnlike(character, text) | postgres | implementation of !~~* operator |
bpcharicregexeq(character, text) | postgres | implementation of ~* operator |
bpcharicregexne(character, text) | postgres | implementation of !~* operator |
bpcharin(cstring, oid, integer) | postgres | I/O |
bpcharle(character, character) | postgres | implementation of <= operator |
bpcharlike(character, text) | postgres | implementation of ~~ operator |
bpcharlt(character, character) | postgres | implementation of < operator |
bpcharne(character, character) | postgres | implementation of <> operator |
bpcharnlike(character, text) | postgres | implementation of !~~ operator |
bpcharout(character) | postgres | I/O |
bpcharrecv(internal, oid, integer) | postgres | I/O |
bpcharregexeq(character, text) | postgres | implementation of ~ operator |
bpcharregexne(character, text) | postgres | implementation of !~ operator |
bpcharsend(character) | postgres | I/O |
bpchartypmodin(cstring[]) | postgres | I/O typmod |
bpchartypmodout(integer) | postgres | I/O typmod |
broadcast(inet) | postgres | broadcast address of network |
btabstimecmp(abstime, abstime) | postgres | less-equal-greater |
btarraycmp(anyarray, anyarray) | postgres | less-equal-greater |
btbeginscan(internal, internal, internal) | postgres | btree(internal) |
btboolcmp(boolean, boolean) | postgres | less-equal-greater |
btbpchar_pattern_cmp(character, character) | postgres | less-equal-greater |
btbuild(internal, internal, internal) | postgres | btree(internal) |
btbuildempty(internal) | postgres | btree(internal) |
btbulkdelete(internal, internal, internal, internal) | postgres | btree(internal) |
btcanreturn(internal) | postgres | btree(internal) |
btcharcmp("char", "char") | postgres | less-equal-greater |
btcostestimate(internal, internal, internal, internal, internal, internal, internal) | postgres | btree(internal) |
btendscan(internal) | postgres | btree(internal) |
btfloat48cmp(real, double precision) | postgres | less-equal-greater |
btfloat4cmp(real, real) | postgres | less-equal-greater |
btfloat4sortsupport(internal) | postgres | sort support |
btfloat84cmp(double precision, real) | postgres | less-equal-greater |
btfloat8cmp(double precision, double precision) | postgres | less-equal-greater |
btfloat8sortsupport(internal) | postgres | sort support |
btgetbitmap(internal, internal) | postgres | btree(internal) |
btgettuple(internal, internal) | postgres | btree(internal) |
btinsert(internal, internal, internal, internal, internal, internal) | postgres | btree(internal) |
btint24cmp(smallint, integer) | postgres | less-equal-greater |
btint28cmp(smallint, bigint) | postgres | less-equal-greater |
btint2cmp(smallint, smallint) | postgres | less-equal-greater |
btint2sortsupport(internal) | postgres | sort support |
btint42cmp(integer, smallint) | postgres | less-equal-greater |
btint48cmp(integer, bigint) | postgres | less-equal-greater |
btint4cmp(integer, integer) | postgres | less-equal-greater |
btint4sortsupport(internal) | postgres | sort support |
btint82cmp(bigint, smallint) | postgres | less-equal-greater |
btint84cmp(bigint, integer) | postgres | less-equal-greater |
btint8cmp(bigint, bigint) | postgres | less-equal-greater |
btint8sortsupport(internal) | postgres | sort support |
btmarkpos(internal) | postgres | btree(internal) |
btnamecmp(name, name) | postgres | less-equal-greater |
btnamesortsupport(internal) | postgres | sort support |
btoidcmp(oid, oid) | postgres | less-equal-greater |
btoidsortsupport(internal) | postgres | sort support |
btoidvectorcmp(oidvector, oidvector) | postgres | less-equal-greater |
btoptions(text[], boolean) | postgres | btree(internal) |
btrecordcmp(record, record) | postgres | less-equal-greater |
btreltimecmp(reltime, reltime) | postgres | less-equal-greater |
btrescan(internal, internal, internal, internal, internal) | postgres | btree(internal) |
btrestrpos(internal) | postgres | btree(internal) |
btrim(bytea, bytea) | postgres | trim both ends of string |
btrim(text, text) | postgres | trim selected characters from both ends of string |
btrim(text) | postgres | trim spaces from both ends of string |
bttext_pattern_cmp(text, text) | postgres | less-equal-greater |
bttextcmp(text, text) | postgres | less-equal-greater |
bttidcmp(tid, tid) | postgres | less-equal-greater |
bttintervalcmp(tinterval, tinterval) | postgres | less-equal-greater |
btvacuumcleanup(internal, internal) | postgres | btree(internal) |
bytea_string_agg_finalfn(internal) | postgres | aggregate final function |
bytea_string_agg_transfn(internal, bytea, bytea) | postgres | aggregate transition function |
byteacat(bytea, bytea) | postgres | implementation of || operator |
byteacmp(bytea, bytea) | postgres | less-equal-greater |
byteaeq(bytea, bytea) | postgres | implementation of = operator |
byteage(bytea, bytea) | postgres | implementation of >= operator |
byteagt(bytea, bytea) | postgres | implementation of > operator |
byteain(cstring) | postgres | I/O |
byteale(bytea, bytea) | postgres | implementation of <= operator |
bytealike(bytea, bytea) | postgres | implementation of ~~ operator |
bytealt(bytea, bytea) | postgres | implementation of < operator |
byteane(bytea, bytea) | postgres | implementation of <> operator |
byteanlike(bytea, bytea) | postgres | implementation of !~~ operator |
byteaout(bytea) | postgres | I/O |
bytearecv(internal) | postgres | I/O |
byteasend(bytea) | postgres | I/O |
cash_cmp(money, money) | postgres | less-equal-greater |
cash_div_cash(money, money) | postgres | implementation of / operator |
cash_div_flt4(money, real) | postgres | implementation of / operator |
cash_div_flt8(money, double precision) | postgres | implementation of / operator |
cash_div_int2(money, smallint) | postgres | implementation of / operator |
cash_div_int4(money, integer) | postgres | implementation of / operator |
cash_eq(money, money) | postgres | implementation of = operator |
cash_ge(money, money) | postgres | implementation of >= operator |
cash_gt(money, money) | postgres | implementation of > operator |
cash_in(cstring) | postgres | I/O |
cash_le(money, money) | postgres | implementation of <= operator |
cash_lt(money, money) | postgres | implementation of < operator |
cash_mi(money, money) | postgres | implementation of - operator |
cash_mul_flt4(money, real) | postgres | implementation of * operator |
cash_mul_flt8(money, double precision) | postgres | implementation of * operator |
cash_mul_int2(money, smallint) | postgres | implementation of * operator |
cash_mul_int4(money, integer) | postgres | implementation of * operator |
cash_ne(money, money) | postgres | implementation of <> operator |
cash_out(money) | postgres | I/O |
cash_pl(money, money) | postgres | implementation of + operator |
cash_recv(internal) | postgres | I/O |
cash_send(money) | postgres | I/O |
cash_words(money) | postgres | output money amount as words |
cashlarger(money, money) | postgres | larger of two |
cashsmaller(money, money) | postgres | smaller of two |
cbrt(double precision) | postgres | cube root |
ceil(numeric) | postgres | smallest integer >= value |
ceil(double precision) | postgres | smallest integer >= value |
ceiling(numeric) | postgres | smallest integer >= value |
ceiling(double precision) | postgres | smallest integer >= value |
center(box) | postgres | center of |
center(circle) | postgres | center of |
char(text) | postgres | convert text to char |
char(integer) | postgres | convert int4 to char |
char_length(character) | postgres | character length |
char_length(text) | postgres | character length |
character_length(text) | postgres | character length |
character_length(character) | postgres | character length |
chareq("char", "char") | postgres | implementation of = operator |
charge("char", "char") | postgres | implementation of >= operator |
chargt("char", "char") | postgres | implementation of > operator |
charin(cstring) | postgres | I/O |
charle("char", "char") | postgres | implementation of <= operator |
charlt("char", "char") | postgres | implementation of < operator |
charne("char", "char") | postgres | implementation of <> operator |
charout("char") | postgres | I/O |
charrecv(internal) | postgres | I/O |
charsend("char") | postgres | I/O |
chr(integer) | postgres | convert int4 to char |
cideq(cid, cid) | postgres | implementation of = operator |
cidin(cstring) | postgres | I/O |
cidout(cid) | postgres | I/O |
cidr(inet) | postgres | convert inet to cidr |
cidr_in(cstring) | postgres | I/O |
cidr_out(cidr) | postgres | I/O |
cidr_recv(internal) | postgres | I/O |
cidr_send(cidr) | postgres | I/O |
cidrecv(internal) | postgres | I/O |
cidsend(cid) | postgres | I/O |
circle(point, double precision) | postgres | convert point and radius to circle |
circle(polygon) | postgres | convert polygon to circle |
circle(box) | postgres | convert box to circle |
circle_above(circle, circle) | postgres | implementation of |>> operator |
circle_add_pt(circle, point) | postgres | implementation of + operator |
circle_below(circle, circle) | postgres | implementation of <<| operator |
circle_center(circle) | postgres | implementation of @@ operator |
circle_contain(circle, circle) | postgres | implementation of @> operator |
circle_contain_pt(circle, point) | postgres | implementation of @> operator |
circle_contained(circle, circle) | postgres | implementation of <@ operator |
circle_distance(circle, circle) | postgres | implementation of <-> operator |
circle_div_pt(circle, point) | postgres | implementation of / operator |
circle_eq(circle, circle) | postgres | implementation of = operator |
circle_ge(circle, circle) | postgres | implementation of >= operator |
circle_gt(circle, circle) | postgres | implementation of > operator |
circle_in(cstring) | postgres | I/O |
circle_le(circle, circle) | postgres | implementation of <= operator |
circle_left(circle, circle) | postgres | implementation of << operator |
circle_lt(circle, circle) | postgres | implementation of < operator |
circle_mul_pt(circle, point) | postgres | implementation of * operator |
circle_ne(circle, circle) | postgres | implementation of <> operator |
circle_out(circle) | postgres | I/O |
circle_overabove(circle, circle) | postgres | implementation of |&> operator |
circle_overbelow(circle, circle) | postgres | implementation of &<| operator |
circle_overlap(circle, circle) | postgres | implementation of && operator |
circle_overleft(circle, circle) | postgres | implementation of &< operator |
circle_overright(circle, circle) | postgres | implementation of &> operator |
circle_recv(internal) | postgres | I/O |
circle_right(circle, circle) | postgres | implementation of >> operator |
circle_same(circle, circle) | postgres | implementation of ~= operator |
circle_send(circle) | postgres | I/O |
circle_sub_pt(circle, point) | postgres | implementation of - operator |
clock_timestamp() | postgres | current clock time |
close_lb(line, box) | postgres | implementation of ## operator |
close_ls(line, lseg) | postgres | implementation of ## operator |
close_lseg(lseg, lseg) | postgres | implementation of ## operator |
close_pb(point, box) | postgres | implementation of ## operator |
close_pl(point, line) | postgres | implementation of ## operator |
close_ps(point, lseg) | postgres | implementation of ## operator |
close_sb(lseg, box) | postgres | implementation of ## operator |
close_sl(lseg, line) | postgres | implementation of ## operator |
col_description(oid, integer) | postgres | get description for table column |
concat("any") | postgres | concatenate values |
concat_ws(text, "any") | postgres | concatenate values with separators |
contjoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity for containment comparison operators |
contsel(internal, oid, internal, integer) | postgres | restriction selectivity for containment comparison operators |
convert(bytea, name, name) | postgres | convert string with specified encoding names |
convert_from(bytea, name) | postgres | convert string with specified source encoding name |
convert_to(text, name) | postgres | convert string with specified destination encoding name |
cos(double precision) | postgres | cosine |
cot(double precision) | postgres | cotangent |
cstring_in(cstring) | postgres | I/O |
cstring_out(cstring) | postgres | I/O |
cstring_recv(internal) | postgres | I/O |
cstring_send(cstring) | postgres | I/O |
cume_dist() | postgres | fractional row number within partition |
current_database() | postgres | name of the current database |
current_query() | postgres | get the currently executing query |
current_schema() | postgres | current schema name |
current_schemas(boolean) | postgres | current schema search list |
current_setting(text) | postgres | SHOW X as a function |
current_user() | postgres | current user name |
currtid(oid, tid) | postgres | latest tid of a tuple |
currtid2(text, tid) | postgres | latest tid of a tuple |
currval(regclass) | postgres | sequence current value |
cursor_to_xml(refcursor, integer, boolean, boolean, text) | postgres | map rows from cursor to XML |
cursor_to_xmlschema(refcursor, boolean, boolean, text) | postgres | map cursor structure to XML Schema |
database_to_xml(boolean, boolean, text) | postgres | map database contents to XML |
database_to_xml_and_xmlschema(boolean, boolean, text) | postgres | map database contents and structure to XML and XML Schema |
database_to_xmlschema(boolean, boolean, text) | postgres | map database structure to XML Schema |
date(timestamp with time zone) | postgres | convert timestamp with time zone to date |
date(abstime) | postgres | convert abstime to date |
date(timestamp without time zone) | postgres | convert timestamp to date |
date_cmp(date, date) | postgres | less-equal-greater |
date_cmp_timestamp(date, timestamp without time zone) | postgres | less-equal-greater |
date_cmp_timestamptz(date, timestamp with time zone) | postgres | less-equal-greater |
date_eq(date, date) | postgres | implementation of = operator |
date_eq_timestamp(date, timestamp without time zone) | postgres | implementation of = operator |
date_eq_timestamptz(date, timestamp with time zone) | postgres | implementation of = operator |
date_ge(date, date) | postgres | implementation of >= operator |
date_ge_timestamp(date, timestamp without time zone) | postgres | implementation of >= operator |
date_ge_timestamptz(date, timestamp with time zone) | postgres | implementation of >= operator |
date_gt(date, date) | postgres | implementation of > operator |
date_gt_timestamp(date, timestamp without time zone) | postgres | implementation of > operator |
date_gt_timestamptz(date, timestamp with time zone) | postgres | implementation of > operator |
date_in(cstring) | postgres | I/O |
date_larger(date, date) | postgres | larger of two |
date_le(date, date) | postgres | implementation of <= operator |
date_le_timestamp(date, timestamp without time zone) | postgres | implementation of <= operator |
date_le_timestamptz(date, timestamp with time zone) | postgres | implementation of <= operator |
date_lt(date, date) | postgres | implementation of < operator |
date_lt_timestamp(date, timestamp without time zone) | postgres | implementation of < operator |
date_lt_timestamptz(date, timestamp with time zone) | postgres | implementation of < operator |
date_mi(date, date) | postgres | implementation of - operator |
date_mi_interval(date, interval) | postgres | implementation of - operator |
date_mii(date, integer) | postgres | implementation of - operator |
date_ne(date, date) | postgres | implementation of <> operator |
date_ne_timestamp(date, timestamp without time zone) | postgres | implementation of <> operator |
date_ne_timestamptz(date, timestamp with time zone) | postgres | implementation of <> operator |
date_out(date) | postgres | I/O |
date_part(text, timestamp with time zone) | postgres | extract field from timestamp with time zone |
date_part(text, interval) | postgres | extract field from interval |
date_part(text, time with time zone) | postgres | extract field from time with time zone |
date_part(text, timestamp without time zone) | postgres | extract field from timestamp |
date_part(text, abstime) | postgres | extract field from abstime |
date_part(text, reltime) | postgres | extract field from reltime |
date_part(text, date) | postgres | extract field from date |
date_part(text, time without time zone) | postgres | extract field from time |
date_pl_interval(date, interval) | postgres | implementation of + operator |
date_pli(date, integer) | postgres | implementation of + operator |
date_recv(internal) | postgres | I/O |
date_send(date) | postgres | I/O |
date_smaller(date, date) | postgres | smaller of two |
date_sortsupport(internal) | postgres | sort support |
date_trunc(text, timestamp with time zone) | postgres | truncate timestamp with time zone to specified units |
date_trunc(text, interval) | postgres | truncate interval to specified units |
date_trunc(text, timestamp without time zone) | postgres | truncate timestamp to specified units |
daterange(date, date) | postgres | daterange constructor |
daterange(date, date, text) | postgres | daterange constructor |
daterange_canonical(daterange) | postgres | convert a date range to canonical form |
daterange_subdiff(date, date) | postgres | float8 difference of two date values |
datetime_pl(date, time without time zone) | postgres | implementation of + operator |
datetimetz_pl(date, time with time zone) | postgres | implementation of + operator |
dcbrt(double precision) | postgres | implementation of ||/ operator |
decode(text, text) | postgres | convert ascii-encoded text string into bytea value |
degrees(double precision) | postgres | radians to degrees |
dense_rank() | postgres | integer rank without gaps |
dexp(double precision) | postgres | natural exponential (e^x) |
diagonal(box) | postgres | box diagonal |
diameter(circle) | postgres | diameter of circle |
dispell_init(internal) | postgres | (internal) |
dispell_lexize(internal, internal, internal, internal) | postgres | (internal) |
dist_cpoly(circle, polygon) | postgres | implementation of <-> operator |
dist_lb(line, box) | postgres | implementation of <-> operator |
dist_pb(point, box) | postgres | implementation of <-> operator |
dist_pc(point, circle) | postgres | implementation of <-> operator |
dist_pl(point, line) | postgres | implementation of <-> operator |
dist_ppath(point, path) | postgres | implementation of <-> operator |
dist_ps(point, lseg) | postgres | implementation of <-> operator |
dist_sb(lseg, box) | postgres | implementation of <-> operator |
dist_sl(lseg, line) | postgres | implementation of <-> operator |
div(numeric, numeric) | postgres | trunc(x/y) |
dlog1(double precision) | postgres | natural logarithm |
dlog10(double precision) | postgres | base 10 logarithm |
domain_in(cstring, oid, integer) | postgres | I/O |
domain_recv(internal, oid, integer) | postgres | I/O |
dpow(double precision, double precision) | postgres | implementation of ^ operator |
dround(double precision) | postgres | round to nearest integer |
dsimple_init(internal) | postgres | (internal) |
dsimple_lexize(internal, internal, internal, internal) | postgres | (internal) |
dsnowball_init(internal) | postgres | |
dsnowball_lexize(internal, internal, internal, internal) | postgres | |
dsqrt(double precision) | postgres | implementation of |/ operator |
dsynonym_init(internal) | postgres | (internal) |
dsynonym_lexize(internal, internal, internal, internal) | postgres | (internal) |
dtrunc(double precision) | postgres | truncate to integer |
elem_contained_by_range(anyelement, anyrange) | postgres | implementation of <@ operator |
encode(bytea, text) | postgres | convert bytea value into some ascii-only text string |
enum_cmp(anyenum, anyenum) | postgres | less-equal-greater |
enum_eq(anyenum, anyenum) | postgres | implementation of = operator |
enum_first(anyenum) | postgres | first value of the input enum type |
enum_ge(anyenum, anyenum) | postgres | implementation of >= operator |
enum_gt(anyenum, anyenum) | postgres | implementation of > operator |
enum_in(cstring, oid) | postgres | I/O |
enum_larger(anyenum, anyenum) | postgres | larger of two |
enum_last(anyenum) | postgres | last value of the input enum type |
enum_le(anyenum, anyenum) | postgres | implementation of <= operator |
enum_lt(anyenum, anyenum) | postgres | implementation of < operator |
enum_ne(anyenum, anyenum) | postgres | implementation of <> operator |
enum_out(anyenum) | postgres | I/O |
enum_range(anyenum) | postgres | range of the given enum type, as an ordered array |
enum_range(anyenum, anyenum) | postgres | range between the two given enum values, as an ordered array |
enum_recv(cstring, oid) | postgres | I/O |
enum_send(anyenum) | postgres | I/O |
enum_smaller(anyenum, anyenum) | postgres | smaller of two |
eqjoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity of = and related operators |
eqsel(internal, oid, internal, integer) | postgres | restriction selectivity of = and related operators |
euc_cn_to_mic(integer, integer, cstring, internal, integer) | postgres | internal conversion function for EUC_CN to MULE_INTERNAL |
euc_cn_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for EUC_CN to UTF8 |
euc_jis_2004_to_shift_jis_2004(integer, integer, cstring, internal, integer) | postgres | internal conversion function for EUC_JIS_2004 to SHIFT_JIS_2004 |
euc_jis_2004_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for EUC_JIS_2004 to UTF8 |
euc_jp_to_mic(integer, integer, cstring, internal, integer) | postgres | internal conversion function for EUC_JP to MULE_INTERNAL |
euc_jp_to_sjis(integer, integer, cstring, internal, integer) | postgres | internal conversion function for EUC_JP to SJIS |
euc_jp_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for EUC_JP to UTF8 |
euc_kr_to_mic(integer, integer, cstring, internal, integer) | postgres | internal conversion function for EUC_KR to MULE_INTERNAL |
euc_kr_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for EUC_KR to UTF8 |
euc_tw_to_big5(integer, integer, cstring, internal, integer) | postgres | internal conversion function for EUC_TW to BIG5 |
euc_tw_to_mic(integer, integer, cstring, internal, integer) | postgres | internal conversion function for EUC_TW to MULE_INTERNAL |
euc_tw_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for EUC_TW to UTF8 |
exp(numeric) | postgres | natural exponential (e^x) |
exp(double precision) | postgres | natural exponential (e^x) |
factorial(bigint) | postgres | factorial |
family(inet) | postgres | address family (4 for IPv4, 6 for IPv6) |
fdw_handler_in(cstring) | postgres | I/O |
fdw_handler_out(fdw_handler) | postgres | I/O |
first_value(anyelement) | postgres | fetch the first row value |
float4(double precision) | postgres | convert float8 to float4 |
float4(integer) | postgres | convert int4 to float4 |
float4(numeric) | postgres | convert numeric to float4 |
float4(smallint) | postgres | convert int2 to float4 |
float4(bigint) | postgres | convert int8 to float4 |
float48div(real, double precision) | postgres | implementation of / operator |
float48eq(real, double precision) | postgres | implementation of = operator |
float48ge(real, double precision) | postgres | implementation of >= operator |
float48gt(real, double precision) | postgres | implementation of > operator |
float48le(real, double precision) | postgres | implementation of <= operator |
float48lt(real, double precision) | postgres | implementation of < operator |
float48mi(real, double precision) | postgres | implementation of - operator |
float48mul(real, double precision) | postgres | implementation of * operator |
float48ne(real, double precision) | postgres | implementation of <> operator |
float48pl(real, double precision) | postgres | implementation of + operator |
float4_accum(double precision[], real) | postgres | aggregate transition function |
float4abs(real) | postgres | implementation of @ operator |
float4div(real, real) | postgres | implementation of / operator |
float4eq(real, real) | postgres | implementation of = operator |
float4ge(real, real) | postgres | implementation of >= operator |
float4gt(real, real) | postgres | implementation of > operator |
float4in(cstring) | postgres | I/O |
float4larger(real, real) | postgres | larger of two |
float4le(real, real) | postgres | implementation of <= operator |
float4lt(real, real) | postgres | implementation of < operator |
float4mi(real, real) | postgres | implementation of - operator |
float4mul(real, real) | postgres | implementation of * operator |
float4ne(real, real) | postgres | implementation of <> operator |
float4out(real) | postgres | I/O |
float4pl(real, real) | postgres | implementation of + operator |
float4recv(internal) | postgres | I/O |
float4send(real) | postgres | I/O |
float4smaller(real, real) | postgres | smaller of two |
float4um(real) | postgres | implementation of - operator |
float4up(real) | postgres | implementation of + operator |
float8(real) | postgres | convert float4 to float8 |
float8(integer) | postgres | convert int4 to float8 |
float8(numeric) | postgres | convert numeric to float8 |
float8(smallint) | postgres | convert int2 to float8 |
float8(bigint) | postgres | convert int8 to float8 |
float84div(double precision, real) | postgres | implementation of / operator |
float84eq(double precision, real) | postgres | implementation of = operator |
float84ge(double precision, real) | postgres | implementation of >= operator |
float84gt(double precision, real) | postgres | implementation of > operator |
float84le(double precision, real) | postgres | implementation of <= operator |
float84lt(double precision, real) | postgres | implementation of < operator |
float84mi(double precision, real) | postgres | implementation of - operator |
float84mul(double precision, real) | postgres | implementation of * operator |
float84ne(double precision, real) | postgres | implementation of <> operator |
float84pl(double precision, real) | postgres | implementation of + operator |
float8_accum(double precision[], double precision) | postgres | aggregate transition function |
float8_avg(double precision[]) | postgres | aggregate final function |
float8_corr(double precision[]) | postgres | aggregate final function |
float8_covar_pop(double precision[]) | postgres | aggregate final function |
float8_covar_samp(double precision[]) | postgres | aggregate final function |
float8_regr_accum(double precision[], double precision, double precision) | postgres | aggregate transition function |
float8_regr_avgx(double precision[]) | postgres | aggregate final function |
float8_regr_avgy(double precision[]) | postgres | aggregate final function |
float8_regr_intercept(double precision[]) | postgres | aggregate final function |
float8_regr_r2(double precision[]) | postgres | aggregate final function |
float8_regr_slope(double precision[]) | postgres | aggregate final function |
float8_regr_sxx(double precision[]) | postgres | aggregate final function |
float8_regr_sxy(double precision[]) | postgres | aggregate final function |
float8_regr_syy(double precision[]) | postgres | aggregate final function |
float8_stddev_pop(double precision[]) | postgres | aggregate final function |
float8_stddev_samp(double precision[]) | postgres | aggregate final function |
float8_var_pop(double precision[]) | postgres | aggregate final function |
float8_var_samp(double precision[]) | postgres | aggregate final function |
float8abs(double precision) | postgres | implementation of @ operator |
float8div(double precision, double precision) | postgres | implementation of / operator |
float8eq(double precision, double precision) | postgres | implementation of = operator |
float8ge(double precision, double precision) | postgres | implementation of >= operator |
float8gt(double precision, double precision) | postgres | implementation of > operator |
float8in(cstring) | postgres | I/O |
float8larger(double precision, double precision) | postgres | larger of two |
float8le(double precision, double precision) | postgres | implementation of <= operator |
float8lt(double precision, double precision) | postgres | implementation of < operator |
float8mi(double precision, double precision) | postgres | implementation of - operator |
float8mul(double precision, double precision) | postgres | implementation of * operator |
float8ne(double precision, double precision) | postgres | implementation of <> operator |
float8out(double precision) | postgres | I/O |
float8pl(double precision, double precision) | postgres | implementation of + operator |
float8recv(internal) | postgres | I/O |
float8send(double precision) | postgres | I/O |
float8smaller(double precision, double precision) | postgres | smaller of two |
float8um(double precision) | postgres | implementation of - operator |
float8up(double precision) | postgres | implementation of + operator |
floor(numeric) | postgres | largest integer <= value |
floor(double precision) | postgres | largest integer <= value |
flt4_mul_cash(real, money) | postgres | implementation of * operator |
flt8_mul_cash(double precision, money) | postgres | implementation of * operator |
fmgr_c_validator(oid) | postgres | (internal) |
fmgr_internal_validator(oid) | postgres | (internal) |
fmgr_sql_validator(oid) | postgres | (internal) |
format(text, "any") | postgres | format text message |
format(text) | postgres | format text message |
format_type(oid, integer) | postgres | format a type oid and atttypmod to canonical SQL |
gb18030_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for GB18030 to UTF8 |
gbk_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for GBK to UTF8 |
generate_series(integer, integer, integer) | postgres | non-persistent series generator |
generate_series(integer, integer) | postgres | non-persistent series generator |
generate_series(bigint, bigint, bigint) | postgres | non-persistent series generator |
generate_series(bigint, bigint) | postgres | non-persistent series generator |
generate_series(timestamp without time zone, timestamp without time zone, interval) | postgres | non-persistent series generator |
generate_series(timestamp with time zone, timestamp with time zone, interval) | postgres | non-persistent series generator |
generate_subscripts(anyarray, integer, boolean) | postgres | array subscripts generator |
generate_subscripts(anyarray, integer) | postgres | array subscripts generator |
get_bit(bit, integer) | postgres | get bit |
get_bit(bytea, integer) | postgres | get bit |
get_byte(bytea, integer) | postgres | get byte |
get_current_ts_config() | postgres | get current tsearch configuration |
getdatabaseencoding() | postgres | encoding name of current database |
getpgusername() | postgres | deprecated, use current_user instead |
gin_cmp_prefix(text, text, smallint, internal) | postgres | GIN tsvector support |
gin_cmp_tslexeme(text, text) | postgres | GIN tsvector support |
gin_extract_tsquery(tsquery, internal, smallint, internal, internal, internal, internal) | postgres | GIN tsvector support |
gin_extract_tsquery(tsquery, internal, smallint, internal, internal) | postgres | GIN tsvector support (obsolete) |
gin_extract_tsvector(tsvector, internal) | postgres | GIN tsvector support (obsolete) |
gin_extract_tsvector(tsvector, internal, internal) | postgres | GIN tsvector support |
gin_tsquery_consistent(internal, smallint, tsquery, integer, internal, internal, internal, internal) | postgres | GIN tsvector support |
gin_tsquery_consistent(internal, smallint, tsquery, integer, internal, internal) | postgres | GIN tsvector support (obsolete) |
ginarrayconsistent(internal, smallint, anyarray, integer, internal, internal, internal, internal) | postgres | GIN array support |
ginarrayextract(anyarray, internal) | postgres | GIN array support (obsolete) |
ginarrayextract(anyarray, internal, internal) | postgres | GIN array support |
ginbeginscan(internal, internal, internal) | postgres | gin(internal) |
ginbuild(internal, internal, internal) | postgres | gin(internal) |
ginbuildempty(internal) | postgres | gin(internal) |
ginbulkdelete(internal, internal, internal, internal) | postgres | gin(internal) |
gincostestimate(internal, internal, internal, internal, internal, internal, internal) | postgres | gin(internal) |
ginendscan(internal) | postgres | gin(internal) |
gingetbitmap(internal, internal) | postgres | gin(internal) |
gininsert(internal, internal, internal, internal, internal, internal) | postgres | gin(internal) |
ginmarkpos(internal) | postgres | gin(internal) |
ginoptions(text[], boolean) | postgres | gin(internal) |
ginqueryarrayextract(anyarray, internal, smallint, internal, internal, internal, internal) | postgres | GIN array support |
ginrescan(internal, internal, internal, internal, internal) | postgres | gin(internal) |
ginrestrpos(internal) | postgres | gin(internal) |
ginvacuumcleanup(internal, internal) | postgres | gin(internal) |
gist_box_compress(internal) | postgres | GiST support |
gist_box_consistent(internal, box, integer, oid, internal) | postgres | GiST support |
gist_box_decompress(internal) | postgres | GiST support |
gist_box_penalty(internal, internal, internal) | postgres | GiST support |
gist_box_picksplit(internal, internal) | postgres | GiST support |
gist_box_same(box, box, internal) | postgres | GiST support |
gist_box_union(internal, internal) | postgres | GiST support |
gist_circle_compress(internal) | postgres | GiST support |
gist_circle_consistent(internal, circle, integer, oid, internal) | postgres | GiST support |
gist_point_compress(internal) | postgres | GiST support |
gist_point_consistent(internal, point, integer, oid, internal) | postgres | GiST support |
gist_point_distance(internal, point, integer, oid) | postgres | GiST support |
gist_poly_compress(internal) | postgres | GiST support |
gist_poly_consistent(internal, polygon, integer, oid, internal) | postgres | GiST support |
gistbeginscan(internal, internal, internal) | postgres | gist(internal) |
gistbuild(internal, internal, internal) | postgres | gist(internal) |
gistbuildempty(internal) | postgres | gist(internal) |
gistbulkdelete(internal, internal, internal, internal) | postgres | gist(internal) |
gistcostestimate(internal, internal, internal, internal, internal, internal, internal) | postgres | gist(internal) |
gistendscan(internal) | postgres | gist(internal) |
gistgetbitmap(internal, internal) | postgres | gist(internal) |
gistgettuple(internal, internal) | postgres | gist(internal) |
gistinsert(internal, internal, internal, internal, internal, internal) | postgres | gist(internal) |
gistmarkpos(internal) | postgres | gist(internal) |
gistoptions(text[], boolean) | postgres | gist(internal) |
gistrescan(internal, internal, internal, internal, internal) | postgres | gist(internal) |
gistrestrpos(internal) | postgres | gist(internal) |
gistvacuumcleanup(internal, internal) | postgres | gist(internal) |
gtsquery_compress(internal) | postgres | GiST tsquery support |
gtsquery_consistent(internal, internal, integer, oid, internal) | postgres | GiST tsquery support |
gtsquery_decompress(internal) | postgres | GiST tsquery support |
gtsquery_penalty(internal, internal, internal) | postgres | GiST tsquery support |
gtsquery_picksplit(internal, internal) | postgres | GiST tsquery support |
gtsquery_same(bigint, bigint, internal) | postgres | GiST tsquery support |
gtsquery_union(internal, internal) | postgres | GiST tsquery support |
gtsvector_compress(internal) | postgres | GiST tsvector support |
gtsvector_consistent(internal, gtsvector, integer, oid, internal) | postgres | GiST tsvector support |
gtsvector_decompress(internal) | postgres | GiST tsvector support |
gtsvector_penalty(internal, internal, internal) | postgres | GiST tsvector support |
gtsvector_picksplit(internal, internal) | postgres | GiST tsvector support |
gtsvector_same(gtsvector, gtsvector, internal) | postgres | GiST tsvector support |
gtsvector_union(internal, internal) | postgres | GiST tsvector support |
gtsvectorin(cstring) | postgres | I/O |
gtsvectorout(gtsvector) | postgres | I/O |
has_any_column_privilege(name, text, text) | postgres | user privilege on any column by username, rel name |
has_any_column_privilege(name, oid, text) | postgres | user privilege on any column by username, rel oid |
has_any_column_privilege(oid, text, text) | postgres | user privilege on any column by user oid, rel name |
has_any_column_privilege(oid, oid, text) | postgres | user privilege on any column by user oid, rel oid |
has_any_column_privilege(text, text) | postgres | current user privilege on any column by rel name |
has_any_column_privilege(oid, text) | postgres | current user privilege on any column by rel oid |
has_column_privilege(name, text, text, text) | postgres | user privilege on column by username, rel name, col name |
has_column_privilege(name, text, smallint, text) | postgres | user privilege on column by username, rel name, col attnum |
has_column_privilege(name, oid, text, text) | postgres | user privilege on column by username, rel oid, col name |
has_column_privilege(name, oid, smallint, text) | postgres | user privilege on column by username, rel oid, col attnum |
has_column_privilege(oid, text, text, text) | postgres | user privilege on column by user oid, rel name, col name |
has_column_privilege(oid, text, smallint, text) | postgres | user privilege on column by user oid, rel name, col attnum |
has_column_privilege(oid, oid, text, text) | postgres | user privilege on column by user oid, rel oid, col name |
has_column_privilege(oid, oid, smallint, text) | postgres | user privilege on column by user oid, rel oid, col attnum |
has_column_privilege(text, text, text) | postgres | current user privilege on column by rel name, col name |
has_column_privilege(text, smallint, text) | postgres | current user privilege on column by rel name, col attnum |
has_column_privilege(oid, text, text) | postgres | current user privilege on column by rel oid, col name |
has_column_privilege(oid, smallint, text) | postgres | current user privilege on column by rel oid, col attnum |
has_database_privilege(oid, text, text) | postgres | user privilege on database by user oid, database name |
has_database_privilege(oid, text) | postgres | current user privilege on database by database oid |
has_database_privilege(text, text) | postgres | current user privilege on database by database name |
has_database_privilege(name, text, text) | postgres | user privilege on database by username, database name |
has_database_privilege(name, oid, text) | postgres | user privilege on database by username, database oid |
has_database_privilege(oid, oid, text) | postgres | user privilege on database by user oid, database oid |
has_foreign_data_wrapper_privilege(name, text, text) | postgres | user privilege on foreign data wrapper by username, foreign data wrapper name |
has_foreign_data_wrapper_privilege(name, oid, text) | postgres | user privilege on foreign data wrapper by username, foreign data wrapper oid |
has_foreign_data_wrapper_privilege(oid, text, text) | postgres | user privilege on foreign data wrapper by user oid, foreign data wrapper name |
has_foreign_data_wrapper_privilege(text, text) | postgres | current user privilege on foreign data wrapper by foreign data wrapper name |
has_foreign_data_wrapper_privilege(oid, text) | postgres | current user privilege on foreign data wrapper by foreign data wrapper oid |
has_foreign_data_wrapper_privilege(oid, oid, text) | postgres | user privilege on foreign data wrapper by user oid, foreign data wrapper oid |
has_function_privilege(text, text) | postgres | current user privilege on function by function name |
has_function_privilege(oid, text) | postgres | current user privilege on function by function oid |
has_function_privilege(oid, text, text) | postgres | user privilege on function by user oid, function name |
has_function_privilege(name, oid, text) | postgres | user privilege on function by username, function oid |
has_function_privilege(name, text, text) | postgres | user privilege on function by username, function name |
has_function_privilege(oid, oid, text) | postgres | user privilege on function by user oid, function oid |
has_language_privilege(oid, text, text) | postgres | user privilege on language by user oid, language name |
has_language_privilege(oid, oid, text) | postgres | user privilege on language by user oid, language oid |
has_language_privilege(text, text) | postgres | current user privilege on language by language name |
has_language_privilege(name, text, text) | postgres | user privilege on language by username, language name |
has_language_privilege(oid, text) | postgres | current user privilege on language by language oid |
has_language_privilege(name, oid, text) | postgres | user privilege on language by username, language oid |
has_schema_privilege(name, text, text) | postgres | user privilege on schema by username, schema name |
has_schema_privilege(name, oid, text) | postgres | user privilege on schema by username, schema oid |
has_schema_privilege(oid, text, text) | postgres | user privilege on schema by user oid, schema name |
has_schema_privilege(text, text) | postgres | current user privilege on schema by schema name |
has_schema_privilege(oid, oid, text) | postgres | user privilege on schema by user oid, schema oid |
has_schema_privilege(oid, text) | postgres | current user privilege on schema by schema oid |
has_sequence_privilege(name, text, text) | postgres | user privilege on sequence by username, seq name |
has_sequence_privilege(name, oid, text) | postgres | user privilege on sequence by username, seq oid |
has_sequence_privilege(oid, text, text) | postgres | user privilege on sequence by user oid, seq name |
has_sequence_privilege(oid, oid, text) | postgres | user privilege on sequence by user oid, seq oid |
has_sequence_privilege(text, text) | postgres | current user privilege on sequence by seq name |
has_sequence_privilege(oid, text) | postgres | current user privilege on sequence by seq oid |
has_server_privilege(oid, oid, text) | postgres | user privilege on server by user oid, server oid |
has_server_privilege(name, text, text) | postgres | user privilege on server by username, server name |
has_server_privilege(oid, text, text) | postgres | user privilege on server by user oid, server name |
has_server_privilege(text, text) | postgres | current user privilege on server by server name |
has_server_privilege(oid, text) | postgres | current user privilege on server by server oid |
has_server_privilege(name, oid, text) | postgres | user privilege on server by username, server oid |
has_table_privilege(name, text, text) | postgres | user privilege on relation by username, rel name |
has_table_privilege(name, oid, text) | postgres | user privilege on relation by username, rel oid |
has_table_privilege(oid, text, text) | postgres | user privilege on relation by user oid, rel name |
has_table_privilege(oid, oid, text) | postgres | user privilege on relation by user oid, rel oid |
has_table_privilege(oid, text) | postgres | current user privilege on relation by rel oid |
has_table_privilege(text, text) | postgres | current user privilege on relation by rel name |
has_tablespace_privilege(name, oid, text) | postgres | user privilege on tablespace by username, tablespace oid |
has_tablespace_privilege(name, text, text) | postgres | user privilege on tablespace by username, tablespace name |
has_tablespace_privilege(oid, text, text) | postgres | user privilege on tablespace by user oid, tablespace name |
has_tablespace_privilege(oid, oid, text) | postgres | user privilege on tablespace by user oid, tablespace oid |
has_tablespace_privilege(text, text) | postgres | current user privilege on tablespace by tablespace name |
has_tablespace_privilege(oid, text) | postgres | current user privilege on tablespace by tablespace oid |
has_type_privilege(oid, oid, text) | postgres | user privilege on type by user oid, type oid |
has_type_privilege(name, text, text) | postgres | user privilege on type by username, type name |
has_type_privilege(name, oid, text) | postgres | user privilege on type by username, type oid |
has_type_privilege(oid, text, text) | postgres | user privilege on type by user oid, type name |
has_type_privilege(text, text) | postgres | current user privilege on type by type name |
has_type_privilege(oid, text) | postgres | current user privilege on type by type oid |
hash_aclitem(aclitem) | postgres | hash |
hash_array(anyarray) | postgres | hash |
hash_numeric(numeric) | postgres | hash |
hash_range(anyrange) | postgres | hash a range |
hashbeginscan(internal, internal, internal) | postgres | hash(internal) |
hashbpchar(character) | postgres | hash |
hashbuild(internal, internal, internal) | postgres | hash(internal) |
hashbuildempty(internal) | postgres | hash(internal) |
hashbulkdelete(internal, internal, internal, internal) | postgres | hash(internal) |
hashchar("char") | postgres | hash |
hashcostestimate(internal, internal, internal, internal, internal, internal, internal) | postgres | hash(internal) |
hashendscan(internal) | postgres | hash(internal) |
hashenum(anyenum) | postgres | hash |
hashfloat4(real) | postgres | hash |
hashfloat8(double precision) | postgres | hash |
hashgetbitmap(internal, internal) | postgres | hash(internal) |
hashgettuple(internal, internal) | postgres | hash(internal) |
hashinet(inet) | postgres | hash |
hashinsert(internal, internal, internal, internal, internal, internal) | postgres | hash(internal) |
hashint2(smallint) | postgres | hash |
hashint2vector(int2vector) | postgres | hash |
hashint4(integer) | postgres | hash |
hashint8(bigint) | postgres | hash |
hashmacaddr(macaddr) | postgres | hash |
hashmarkpos(internal) | postgres | hash(internal) |
hashname(name) | postgres | hash |
hashoid(oid) | postgres | hash |
hashoidvector(oidvector) | postgres | hash |
hashoptions(text[], boolean) | postgres | hash(internal) |
hashrescan(internal, internal, internal, internal, internal) | postgres | hash(internal) |
hashrestrpos(internal) | postgres | hash(internal) |
hashtext(text) | postgres | hash |
hashvacuumcleanup(internal, internal) | postgres | hash(internal) |
hashvarlena(internal) | postgres | hash |
height(box) | postgres | box height |
host(inet) | postgres | show address octets only |
hostmask(inet) | postgres | hostmask of address |
iclikejoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity of ILIKE |
iclikesel(internal, oid, internal, integer) | postgres | restriction selectivity of ILIKE |
icnlikejoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity of NOT ILIKE |
icnlikesel(internal, oid, internal, integer) | postgres | restriction selectivity of NOT ILIKE |
icregexeqjoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity of case-insensitive regex match |
icregexeqsel(internal, oid, internal, integer) | postgres | restriction selectivity of case-insensitive regex match |
icregexnejoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity of case-insensitive regex non-match |
icregexnesel(internal, oid, internal, integer) | postgres | restriction selectivity of case-insensitive regex non-match |
inet_client_addr() | postgres | inet address of the client |
inet_client_port() | postgres | client's port number for this connection |
inet_in(cstring) | postgres | I/O |
inet_out(inet) | postgres | I/O |
inet_recv(internal) | postgres | I/O |
inet_send(inet) | postgres | I/O |
inet_server_addr() | postgres | inet address of the server |
inet_server_port() | postgres | server's port number for this connection |
inetand(inet, inet) | postgres | implementation of & operator |
inetmi(inet, inet) | postgres | implementation of - operator |
inetmi_int8(inet, bigint) | postgres | implementation of - operator |
inetnot(inet) | postgres | implementation of ~ operator |
inetor(inet, inet) | postgres | implementation of | operator |
inetpl(inet, bigint) | postgres | implementation of + operator |
initcap(text) | postgres | capitalize each word |
int2(integer) | postgres | convert int4 to int2 |
int2(numeric) | postgres | convert numeric to int2 |
int2(double precision) | postgres | convert float8 to int2 |
int2(real) | postgres | convert float4 to int2 |
int2(bigint) | postgres | convert int8 to int2 |
int24div(smallint, integer) | postgres | implementation of / operator |
int24eq(smallint, integer) | postgres | implementation of = operator |
int24ge(smallint, integer) | postgres | implementation of >= operator |
int24gt(smallint, integer) | postgres | implementation of > operator |
int24le(smallint, integer) | postgres | implementation of <= operator |
int24lt(smallint, integer) | postgres | implementation of < operator |
int24mi(smallint, integer) | postgres | implementation of - operator |
int24mul(smallint, integer) | postgres | implementation of * operator |
int24ne(smallint, integer) | postgres | implementation of <> operator |
int24pl(smallint, integer) | postgres | implementation of + operator |
int28div(smallint, bigint) | postgres | implementation of / operator |
int28eq(smallint, bigint) | postgres | implementation of = operator |
int28ge(smallint, bigint) | postgres | implementation of >= operator |
int28gt(smallint, bigint) | postgres | implementation of > operator |
int28le(smallint, bigint) | postgres | implementation of <= operator |
int28lt(smallint, bigint) | postgres | implementation of < operator |
int28mi(smallint, bigint) | postgres | implementation of - operator |
int28mul(smallint, bigint) | postgres | implementation of * operator |
int28ne(smallint, bigint) | postgres | implementation of <> operator |
int28pl(smallint, bigint) | postgres | implementation of + operator |
int2_accum(numeric[], smallint) | postgres | aggregate transition function |
int2_avg_accum(bigint[], smallint) | postgres | aggregate transition function |
int2_mul_cash(smallint, money) | postgres | implementation of * operator |
int2_sum(bigint, smallint) | postgres | aggregate transition function |
int2abs(smallint) | postgres | implementation of @ operator |
int2and(smallint, smallint) | postgres | implementation of & operator |
int2div(smallint, smallint) | postgres | implementation of / operator |
int2eq(smallint, smallint) | postgres | implementation of = operator |
int2ge(smallint, smallint) | postgres | implementation of >= operator |
int2gt(smallint, smallint) | postgres | implementation of > operator |
int2in(cstring) | postgres | I/O |
int2larger(smallint, smallint) | postgres | larger of two |
int2le(smallint, smallint) | postgres | implementation of <= operator |
int2lt(smallint, smallint) | postgres | implementation of < operator |
int2mi(smallint, smallint) | postgres | implementation of - operator |
int2mod(smallint, smallint) | postgres | implementation of % operator |
int2mul(smallint, smallint) | postgres | implementation of * operator |
int2ne(smallint, smallint) | postgres | implementation of <> operator |
int2not(smallint) | postgres | implementation of ~ operator |
int2or(smallint, smallint) | postgres | implementation of | operator |
int2out(smallint) | postgres | I/O |
int2pl(smallint, smallint) | postgres | implementation of + operator |
int2recv(internal) | postgres | I/O |
int2send(smallint) | postgres | I/O |
int2shl(smallint, integer) | postgres | implementation of << operator |
int2shr(smallint, integer) | postgres | implementation of >> operator |
int2smaller(smallint, smallint) | postgres | smaller of two |
int2um(smallint) | postgres | implementation of - operator |
int2up(smallint) | postgres | implementation of + operator |
int2vectoreq(int2vector, int2vector) | postgres | implementation of = operator |
int2vectorin(cstring) | postgres | I/O |
int2vectorout(int2vector) | postgres | I/O |
int2vectorrecv(internal) | postgres | I/O |
int2vectorsend(int2vector) | postgres | I/O |
int2xor(smallint, smallint) | postgres | implementation of # operator |
int4(smallint) | postgres | convert int2 to int4 |
int4(double precision) | postgres | convert float8 to int4 |
int4(bit) | postgres | convert bitstring to int4 |
int4(real) | postgres | convert float4 to int4 |
int4(numeric) | postgres | convert numeric to int4 |
int4("char") | postgres | convert char to int4 |
int4(bigint) | postgres | convert int8 to int4 |
int4(boolean) | postgres | convert boolean to int4 |
int42div(integer, smallint) | postgres | implementation of / operator |
int42eq(integer, smallint) | postgres | implementation of = operator |
int42ge(integer, smallint) | postgres | implementation of >= operator |
int42gt(integer, smallint) | postgres | implementation of > operator |
int42le(integer, smallint) | postgres | implementation of <= operator |
int42lt(integer, smallint) | postgres | implementation of < operator |
int42mi(integer, smallint) | postgres | implementation of - operator |
int42mul(integer, smallint) | postgres | implementation of * operator |
int42ne(integer, smallint) | postgres | implementation of <> operator |
int42pl(integer, smallint) | postgres | implementation of + operator |
int48div(integer, bigint) | postgres | implementation of / operator |
int48eq(integer, bigint) | postgres | implementation of = operator |
int48ge(integer, bigint) | postgres | implementation of >= operator |
int48gt(integer, bigint) | postgres | implementation of > operator |
int48le(integer, bigint) | postgres | implementation of <= operator |
int48lt(integer, bigint) | postgres | implementation of < operator |
int48mi(integer, bigint) | postgres | implementation of - operator |
int48mul(integer, bigint) | postgres | implementation of * operator |
int48ne(integer, bigint) | postgres | implementation of <> operator |
int48pl(integer, bigint) | postgres | implementation of + operator |
int4_accum(numeric[], integer) | postgres | aggregate transition function |
int4_avg_accum(bigint[], integer) | postgres | aggregate transition function |
int4_mul_cash(integer, money) | postgres | implementation of * operator |
int4_sum(bigint, integer) | postgres | aggregate transition function |
int4abs(integer) | postgres | implementation of @ operator |
int4and(integer, integer) | postgres | implementation of & operator |
int4div(integer, integer) | postgres | implementation of / operator |
int4eq(integer, integer) | postgres | implementation of = operator |
int4ge(integer, integer) | postgres | implementation of >= operator |
int4gt(integer, integer) | postgres | implementation of > operator |
int4in(cstring) | postgres | I/O |
int4inc(integer) | postgres | increment |
int4larger(integer, integer) | postgres | larger of two |
int4le(integer, integer) | postgres | implementation of <= operator |
int4lt(integer, integer) | postgres | implementation of < operator |
int4mi(integer, integer) | postgres | implementation of - operator |
int4mod(integer, integer) | postgres | implementation of % operator |
int4mul(integer, integer) | postgres | implementation of * operator |
int4ne(integer, integer) | postgres | implementation of <> operator |
int4not(integer) | postgres | implementation of ~ operator |
int4or(integer, integer) | postgres | implementation of | operator |
int4out(integer) | postgres | I/O |
int4pl(integer, integer) | postgres | implementation of + operator |
int4range(integer, integer, text) | postgres | int4range constructor |
int4range(integer, integer) | postgres | int4range constructor |
int4range_canonical(int4range) | postgres | convert an int4 range to canonical form |
int4range_subdiff(integer, integer) | postgres | float8 difference of two int4 values |
int4recv(internal) | postgres | I/O |
int4send(integer) | postgres | I/O |
int4shl(integer, integer) | postgres | implementation of << operator |
int4shr(integer, integer) | postgres | implementation of >> operator |
int4smaller(integer, integer) | postgres | smaller of two |
int4um(integer) | postgres | implementation of - operator |
int4up(integer) | postgres | implementation of + operator |
int4xor(integer, integer) | postgres | implementation of # operator |
int8(numeric) | postgres | convert numeric to int8 |
int8(oid) | postgres | convert oid to int8 |
int8(bit) | postgres | convert bitstring to int8 |
int8(integer) | postgres | convert int4 to int8 |
int8(double precision) | postgres | convert float8 to int8 |
int8(real) | postgres | convert float4 to int8 |
int8(smallint) | postgres | convert int2 to int8 |
int82div(bigint, smallint) | postgres | implementation of / operator |
int82eq(bigint, smallint) | postgres | implementation of = operator |
int82ge(bigint, smallint) | postgres | implementation of >= operator |
int82gt(bigint, smallint) | postgres | implementation of > operator |
int82le(bigint, smallint) | postgres | implementation of <= operator |
int82lt(bigint, smallint) | postgres | implementation of < operator |
int82mi(bigint, smallint) | postgres | implementation of - operator |
int82mul(bigint, smallint) | postgres | implementation of * operator |
int82ne(bigint, smallint) | postgres | implementation of <> operator |
int82pl(bigint, smallint) | postgres | implementation of + operator |
int84div(bigint, integer) | postgres | implementation of / operator |
int84eq(bigint, integer) | postgres | implementation of = operator |
int84ge(bigint, integer) | postgres | implementation of >= operator |
int84gt(bigint, integer) | postgres | implementation of > operator |
int84le(bigint, integer) | postgres | implementation of <= operator |
int84lt(bigint, integer) | postgres | implementation of < operator |
int84mi(bigint, integer) | postgres | implementation of - operator |
int84mul(bigint, integer) | postgres | implementation of * operator |
int84ne(bigint, integer) | postgres | implementation of <> operator |
int84pl(bigint, integer) | postgres | implementation of + operator |
int8_accum(numeric[], bigint) | postgres | aggregate transition function |
int8_avg(bigint[]) | postgres | aggregate final function |
int8_avg_accum(numeric[], bigint) | postgres | aggregate transition function |
int8_sum(numeric, bigint) | postgres | aggregate transition function |
int8abs(bigint) | postgres | implementation of @ operator |
int8and(bigint, bigint) | postgres | implementation of & operator |
int8div(bigint, bigint) | postgres | implementation of / operator |
int8eq(bigint, bigint) | postgres | implementation of = operator |
int8ge(bigint, bigint) | postgres | implementation of >= operator |
int8gt(bigint, bigint) | postgres | implementation of > operator |
int8in(cstring) | postgres | I/O |
int8inc(bigint) | postgres | increment |
int8inc_any(bigint, "any") | postgres | increment, ignores second argument |
int8inc_float8_float8(bigint, double precision, double precision) | postgres | aggregate transition function |
int8larger(bigint, bigint) | postgres | larger of two |
int8le(bigint, bigint) | postgres | implementation of <= operator |
int8lt(bigint, bigint) | postgres | implementation of < operator |
int8mi(bigint, bigint) | postgres | implementation of - operator |
int8mod(bigint, bigint) | postgres | implementation of % operator |
int8mul(bigint, bigint) | postgres | implementation of * operator |
int8ne(bigint, bigint) | postgres | implementation of <> operator |
int8not(bigint) | postgres | implementation of ~ operator |
int8or(bigint, bigint) | postgres | implementation of | operator |
int8out(bigint) | postgres | I/O |
int8pl(bigint, bigint) | postgres | implementation of + operator |
int8pl_inet(bigint, inet) | postgres | implementation of + operator |
int8range(bigint, bigint, text) | postgres | int8range constructor |
int8range(bigint, bigint) | postgres | int8range constructor |
int8range_canonical(int8range) | postgres | convert an int8 range to canonical form |
int8range_subdiff(bigint, bigint) | postgres | float8 difference of two int8 values |
int8recv(internal) | postgres | I/O |
int8send(bigint) | postgres | I/O |
int8shl(bigint, integer) | postgres | implementation of << operator |
int8shr(bigint, integer) | postgres | implementation of >> operator |
int8smaller(bigint, bigint) | postgres | smaller of two |
int8um(bigint) | postgres | implementation of - operator |
int8up(bigint) | postgres | implementation of + operator |
int8xor(bigint, bigint) | postgres | implementation of # operator |
integer_pl_date(integer, date) | postgres | implementation of + operator |
inter_lb(line, box) | postgres | implementation of ?# operator |
inter_sb(lseg, box) | postgres | implementation of ?# operator |
inter_sl(lseg, line) | postgres | implementation of ?# operator |
internal_in(cstring) | postgres | I/O |
internal_out(internal) | postgres | I/O |
interval(reltime) | postgres | convert reltime to interval |
interval(interval, integer) | postgres | adjust interval precision |
interval(time without time zone) | postgres | convert time to interval |
interval_accum(interval[], interval) | postgres | aggregate transition function |
interval_avg(interval[]) | postgres | aggregate final function |
interval_cmp(interval, interval) | postgres | less-equal-greater |
interval_div(interval, double precision) | postgres | implementation of / operator |
interval_eq(interval, interval) | postgres | implementation of = operator |
interval_ge(interval, interval) | postgres | implementation of >= operator |
interval_gt(interval, interval) | postgres | implementation of > operator |
interval_hash(interval) | postgres | hash |
interval_in(cstring, oid, integer) | postgres | I/O |
interval_larger(interval, interval) | postgres | larger of two |
interval_le(interval, interval) | postgres | implementation of <= operator |
interval_lt(interval, interval) | postgres | implementation of < operator |
interval_mi(interval, interval) | postgres | implementation of - operator |
interval_mul(interval, double precision) | postgres | implementation of * operator |
interval_ne(interval, interval) | postgres | implementation of <> operator |
interval_out(interval) | postgres | I/O |
interval_pl(interval, interval) | postgres | implementation of + operator |
interval_pl_date(interval, date) | postgres | implementation of + operator |
interval_pl_time(interval, time without time zone) | postgres | implementation of + operator |
interval_pl_timestamp(interval, timestamp without time zone) | postgres | implementation of + operator |
interval_pl_timestamptz(interval, timestamp with time zone) | postgres | implementation of + operator |
interval_pl_timetz(interval, time with time zone) | postgres | implementation of + operator |
interval_recv(internal, oid, integer) | postgres | I/O |
interval_send(interval) | postgres | I/O |
interval_smaller(interval, interval) | postgres | smaller of two |
interval_transform(internal) | postgres | transform an interval length coercion |
interval_um(interval) | postgres | implementation of - operator |
intervaltypmodin(cstring[]) | postgres | I/O typmod |
intervaltypmodout(integer) | postgres | I/O typmod |
intinterval(abstime, tinterval) | postgres | implementation of <?> operator |
isclosed(path) | postgres | path closed? |
isempty(anyrange) | postgres | is the range empty? |
isfinite(interval) | postgres | finite interval? |
isfinite(timestamp with time zone) | postgres | finite timestamp? |
isfinite(timestamp without time zone) | postgres | finite timestamp? |
isfinite(date) | postgres | finite date? |
isfinite(abstime) | postgres | finite abstime? |
ishorizontal(point, point) | postgres | horizontally aligned |
ishorizontal(lseg) | postgres | horizontal |
ishorizontal(line) | postgres | horizontal |
iso8859_1_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for LATIN1 to UTF8 |
iso8859_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for ISO-8859-8 to UTF8 |
iso_to_koi8r(integer, integer, cstring, internal, integer) | postgres | internal conversion function for ISO-8859-5 to KOI8R |
iso_to_mic(integer, integer, cstring, internal, integer) | postgres | internal conversion function for ISO-8859-5 to MULE_INTERNAL |
iso_to_win1251(integer, integer, cstring, internal, integer) | postgres | internal conversion function for ISO-8859-5 to WIN1251 |
iso_to_win866(integer, integer, cstring, internal, integer) | postgres | internal conversion function for ISO-8859-5 to WIN866 |
isopen(path) | postgres | path open? |
isparallel(lseg, lseg) | postgres | parallel |
isparallel(line, line) | postgres | parallel |
isperp(lseg, lseg) | postgres | perpendicular |
isperp(line, line) | postgres | perpendicular |
isvertical(point, point) | postgres | vertically aligned |
isvertical(lseg) | postgres | vertical |
isvertical(line) | postgres | vertical |
johab_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for JOHAB to UTF8 |
json_in(cstring) | postgres | I/O |
json_out(json) | postgres | I/O |
json_recv(internal) | postgres | I/O |
json_send(json) | postgres | I/O |
justify_days(interval) | postgres | promote groups of 30 days to numbers of months |
justify_hours(interval) | postgres | promote groups of 24 hours to numbers of days |
justify_interval(interval) | postgres | promote groups of 24 hours to numbers of days and promote groups of 30 days to numbers of months |
koi8r_to_iso(integer, integer, cstring, internal, integer) | postgres | internal conversion function for KOI8R to ISO-8859-5 |
koi8r_to_mic(integer, integer, cstring, internal, integer) | postgres | internal conversion function for KOI8R to MULE_INTERNAL |
koi8r_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for KOI8R to UTF8 |
koi8r_to_win1251(integer, integer, cstring, internal, integer) | postgres | internal conversion function for KOI8R to WIN1251 |
koi8r_to_win866(integer, integer, cstring, internal, integer) | postgres | internal conversion function for KOI8R to WIN866 |
koi8u_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for KOI8U to UTF8 |
lag(anyelement) | postgres | fetch the preceding row value |
lag(anyelement, integer) | postgres | fetch the Nth preceding row value |
lag(anyelement, integer, anyelement) | postgres | fetch the Nth preceding row value with default |
language_handler_in(cstring) | postgres | I/O |
language_handler_out(language_handler) | postgres | I/O |
last_value(anyelement) | postgres | fetch the last row value |
lastval() | postgres | current value from last used sequence |
latin1_to_mic(integer, integer, cstring, internal, integer) | postgres | internal conversion function for LATIN1 to MULE_INTERNAL |
latin2_to_mic(integer, integer, cstring, internal, integer) | postgres | internal conversion function for LATIN2 to MULE_INTERNAL |
latin2_to_win1250(integer, integer, cstring, internal, integer) | postgres | internal conversion function for LATIN2 to WIN1250 |
latin3_to_mic(integer, integer, cstring, internal, integer) | postgres | internal conversion function for LATIN3 to MULE_INTERNAL |
latin4_to_mic(integer, integer, cstring, internal, integer) | postgres | internal conversion function for LATIN4 to MULE_INTERNAL |
lead(anyelement, integer) | postgres | fetch the Nth following row value |
lead(anyelement) | postgres | fetch the following row value |
lead(anyelement, integer, anyelement) | postgres | fetch the Nth following row value with default |
left(text, integer) | postgres | extract the first n characters |
length(bit) | postgres | bitstring length |
length(tsvector) | postgres | number of lexemes |
length(bytea) | postgres | octet length |
length(text) | postgres | length |
length(character) | postgres | character length |
length(lseg) | postgres | distance between endpoints |
length(path) | postgres | sum of path segments |
length(bytea, name) | postgres | length of string in specified encoding |
like(text, text) | postgres | matches LIKE expression |
like(bytea, bytea) | postgres | matches LIKE expression |
like(name, text) | postgres | matches LIKE expression |
like_escape(bytea, bytea) | postgres | convert LIKE pattern to use backslash escapes |
like_escape(text, text) | postgres | convert LIKE pattern to use backslash escapes |
likejoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity of LIKE |
likesel(internal, oid, internal, integer) | postgres | restriction selectivity of LIKE |
line(point, point) | postgres | construct line from points |
line_distance(line, line) | postgres | implementation of <-> operator |
line_eq(line, line) | postgres | implementation of = operator |
line_horizontal(line) | postgres | implementation of ?- operator |
line_in(cstring) | postgres | I/O |
line_interpt(line, line) | postgres | implementation of # operator |
line_intersect(line, line) | postgres | implementation of ?# operator |
line_out(line) | postgres | I/O |
line_parallel(line, line) | postgres | implementation of ?|| operator |
line_perp(line, line) | postgres | implementation of ?-| operator |
line_recv(internal) | postgres | I/O |
line_send(line) | postgres | I/O |
line_vertical(line) | postgres | implementation of ?| operator |
ln(numeric) | postgres | natural logarithm |
ln(double precision) | postgres | natural logarithm |
lo_close(integer) | postgres | large object close |
lo_creat(integer) | postgres | large object create |
lo_create(oid) | postgres | large object create |
lo_export(oid, text) | postgres | large object export |
lo_import(text, oid) | postgres | large object import |
lo_import(text) | postgres | large object import |
lo_lseek(integer, integer, integer) | postgres | large object seek |
lo_open(oid, integer) | postgres | large object open |
lo_tell(integer) | postgres | large object position |
lo_truncate(integer, integer) | postgres | truncate large object |
lo_unlink(oid) | postgres | large object unlink (delete) |
log(numeric, numeric) | postgres | logarithm base m of n |
log(numeric) | postgres | base 10 logarithm |
log(double precision) | postgres | base 10 logarithm |
loread(integer, integer) | postgres | large object read |
lower(anyrange) | postgres | lower bound of range |
lower(text) | postgres | lowercase |
lower_inc(anyrange) | postgres | is the range's lower bound inclusive? |
lower_inf(anyrange) | postgres | is the range's lower bound infinite? |
lowrite(integer, bytea) | postgres | large object write |
lpad(text, integer, text) | postgres | left-pad string to length |
lpad(text, integer) | postgres | left-pad string to length |
lseg(point, point) | postgres | convert points to line segment |
lseg(box) | postgres | diagonal of |
lseg_center(lseg) | postgres | implementation of @@ operator |
lseg_distance(lseg, lseg) | postgres | implementation of <-> operator |
lseg_eq(lseg, lseg) | postgres | implementation of = operator |
lseg_ge(lseg, lseg) | postgres | implementation of >= operator |
lseg_gt(lseg, lseg) | postgres | implementation of > operator |
lseg_horizontal(lseg) | postgres | implementation of ?- operator |
lseg_in(cstring) | postgres | I/O |
lseg_interpt(lseg, lseg) | postgres | implementation of # operator |
lseg_intersect(lseg, lseg) | postgres | implementation of ?# operator |
lseg_le(lseg, lseg) | postgres | implementation of <= operator |
lseg_length(lseg) | postgres | implementation of @-@ operator |
lseg_lt(lseg, lseg) | postgres | implementation of < operator |
lseg_ne(lseg, lseg) | postgres | implementation of <> operator |
lseg_out(lseg) | postgres | I/O |
lseg_parallel(lseg, lseg) | postgres | implementation of ?|| operator |
lseg_perp(lseg, lseg) | postgres | implementation of ?-| operator |
lseg_recv(internal) | postgres | I/O |
lseg_send(lseg) | postgres | I/O |
lseg_vertical(lseg) | postgres | implementation of ?| operator |
ltrim(text, text) | postgres | trim selected characters from left end of string |
ltrim(text) | postgres | trim spaces from left end of string |
macaddr_and(macaddr, macaddr) | postgres | implementation of & operator |
macaddr_cmp(macaddr, macaddr) | postgres | less-equal-greater |
macaddr_eq(macaddr, macaddr) | postgres | implementation of = operator |
macaddr_ge(macaddr, macaddr) | postgres | implementation of >= operator |
macaddr_gt(macaddr, macaddr) | postgres | implementation of > operator |
macaddr_in(cstring) | postgres | I/O |
macaddr_le(macaddr, macaddr) | postgres | implementation of <= operator |
macaddr_lt(macaddr, macaddr) | postgres | implementation of < operator |
macaddr_ne(macaddr, macaddr) | postgres | implementation of <> operator |
macaddr_not(macaddr) | postgres | implementation of ~ operator |
macaddr_or(macaddr, macaddr) | postgres | implementation of | operator |
macaddr_out(macaddr) | postgres | I/O |
macaddr_recv(internal) | postgres | I/O |
macaddr_send(macaddr) | postgres | I/O |
makeaclitem(oid, oid, text, boolean) | postgres | make ACL item |
masklen(inet) | postgres | netmask length |
md5(text) | postgres | MD5 hash |
md5(bytea) | postgres | MD5 hash |
mic_to_ascii(integer, integer, cstring, internal, integer) | postgres | internal conversion function for MULE_INTERNAL to SQL_ASCII |
mic_to_big5(integer, integer, cstring, internal, integer) | postgres | internal conversion function for MULE_INTERNAL to BIG5 |
mic_to_euc_cn(integer, integer, cstring, internal, integer) | postgres | internal conversion function for MULE_INTERNAL to EUC_CN |
mic_to_euc_jp(integer, integer, cstring, internal, integer) | postgres | internal conversion function for MULE_INTERNAL to EUC_JP |
mic_to_euc_kr(integer, integer, cstring, internal, integer) | postgres | internal conversion function for MULE_INTERNAL to EUC_KR |
mic_to_euc_tw(integer, integer, cstring, internal, integer) | postgres | internal conversion function for MULE_INTERNAL to EUC_TW |
mic_to_iso(integer, integer, cstring, internal, integer) | postgres | internal conversion function for MULE_INTERNAL to ISO-8859-5 |
mic_to_koi8r(integer, integer, cstring, internal, integer) | postgres | internal conversion function for MULE_INTERNAL to KOI8R |
mic_to_latin1(integer, integer, cstring, internal, integer) | postgres | internal conversion function for MULE_INTERNAL to LATIN1 |
mic_to_latin2(integer, integer, cstring, internal, integer) | postgres | internal conversion function for MULE_INTERNAL to LATIN2 |
mic_to_latin3(integer, integer, cstring, internal, integer) | postgres | internal conversion function for MULE_INTERNAL to LATIN3 |
mic_to_latin4(integer, integer, cstring, internal, integer) | postgres | internal conversion function for MULE_INTERNAL to LATIN4 |
mic_to_sjis(integer, integer, cstring, internal, integer) | postgres | internal conversion function for MULE_INTERNAL to SJIS |
mic_to_win1250(integer, integer, cstring, internal, integer) | postgres | internal conversion function for MULE_INTERNAL to WIN1250 |
mic_to_win1251(integer, integer, cstring, internal, integer) | postgres | internal conversion function for MULE_INTERNAL to WIN1251 |
mic_to_win866(integer, integer, cstring, internal, integer) | postgres | internal conversion function for MULE_INTERNAL to WIN866 |
mktinterval(abstime, abstime) | postgres | implementation of <#> operator |
mod(smallint, smallint) | postgres | modulus |
mod(integer, integer) | postgres | modulus |
mod(bigint, bigint) | postgres | modulus |
mod(numeric, numeric) | postgres | modulus |
money(numeric) | postgres | convert numeric to money |
money(integer) | postgres | convert int4 to money |
money(bigint) | postgres | convert int8 to money |
mul_d_interval(double precision, interval) | postgres | implementation of * operator |
name(text) | postgres | convert text to name |
name(character varying) | postgres | convert varchar to name |
name(character) | postgres | convert char(n) to name |
nameeq(name, name) | postgres | implementation of = operator |
namege(name, name) | postgres | implementation of >= operator |
namegt(name, name) | postgres | implementation of > operator |
nameiclike(name, text) | postgres | implementation of ~~* operator |
nameicnlike(name, text) | postgres | implementation of !~~* operator |
nameicregexeq(name, text) | postgres | implementation of ~* operator |
nameicregexne(name, text) | postgres | implementation of !~* operator |
namein(cstring) | postgres | I/O |
namele(name, name) | postgres | implementation of <= operator |
namelike(name, text) | postgres | implementation of ~~ operator |
namelt(name, name) | postgres | implementation of < operator |
namene(name, name) | postgres | implementation of <> operator |
namenlike(name, text) | postgres | implementation of !~~ operator |
nameout(name) | postgres | I/O |
namerecv(internal) | postgres | I/O |
nameregexeq(name, text) | postgres | implementation of ~ operator |
nameregexne(name, text) | postgres | implementation of !~ operator |
namesend(name) | postgres | I/O |
neqjoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity of <> and related operators |
neqsel(internal, oid, internal, integer) | postgres | restriction selectivity of <> and related operators |
netmask(inet) | postgres | netmask of address |
network(inet) | postgres | network part of address |
network_cmp(inet, inet) | postgres | less-equal-greater |
network_eq(inet, inet) | postgres | implementation of = operator |
network_ge(inet, inet) | postgres | implementation of >= operator |
network_gt(inet, inet) | postgres | implementation of > operator |
network_le(inet, inet) | postgres | implementation of <= operator |
network_lt(inet, inet) | postgres | implementation of < operator |
network_ne(inet, inet) | postgres | implementation of <> operator |
network_sub(inet, inet) | postgres | implementation of << operator |
network_subeq(inet, inet) | postgres | implementation of <<= operator |
network_sup(inet, inet) | postgres | implementation of >> operator |
network_supeq(inet, inet) | postgres | implementation of >>= operator |
nextval(regclass) | postgres | sequence next value |
nlikejoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity of NOT LIKE |
nlikesel(internal, oid, internal, integer) | postgres | restriction selectivity of NOT LIKE |
notlike(name, text) | postgres | does not match LIKE expression |
notlike(text, text) | postgres | does not match LIKE expression |
notlike(bytea, bytea) | postgres | does not match LIKE expression |
now() | postgres | current transaction time |
npoints(polygon) | postgres | number of points |
npoints(path) | postgres | number of points |
nth_value(anyelement, integer) | postgres | fetch the Nth row value |
ntile(integer) | postgres | split rows into N groups |
numeric(money) | postgres | convert money to numeric |
numeric(numeric, integer) | postgres | adjust numeric to typmod precision/scale |
numeric(integer) | postgres | convert int4 to numeric |
numeric(real) | postgres | convert float4 to numeric |
numeric(double precision) | postgres | convert float8 to numeric |
numeric(bigint) | postgres | convert int8 to numeric |
numeric(smallint) | postgres | convert int2 to numeric |
numeric_abs(numeric) | postgres | implementation of @ operator |
numeric_accum(numeric[], numeric) | postgres | aggregate transition function |
numeric_add(numeric, numeric) | postgres | implementation of + operator |
numeric_avg(numeric[]) | postgres | aggregate final function |
numeric_avg_accum(numeric[], numeric) | postgres | aggregate transition function |
numeric_cmp(numeric, numeric) | postgres | less-equal-greater |
numeric_div(numeric, numeric) | postgres | implementation of / operator |
numeric_div_trunc(numeric, numeric) | postgres | trunc(x/y) |
numeric_eq(numeric, numeric) | postgres | implementation of = operator |
numeric_exp(numeric) | postgres | natural exponential (e^x) |
numeric_fac(bigint) | postgres | implementation of ! operator |
numeric_ge(numeric, numeric) | postgres | implementation of >= operator |
numeric_gt(numeric, numeric) | postgres | implementation of > operator |
numeric_in(cstring, oid, integer) | postgres | I/O |
numeric_inc(numeric) | postgres | increment by one |
numeric_larger(numeric, numeric) | postgres | larger of two |
numeric_le(numeric, numeric) | postgres | implementation of <= operator |
numeric_ln(numeric) | postgres | natural logarithm |
numeric_log(numeric, numeric) | postgres | logarithm base m of n |
numeric_lt(numeric, numeric) | postgres | implementation of < operator |
numeric_mod(numeric, numeric) | postgres | implementation of % operator |
numeric_mul(numeric, numeric) | postgres | implementation of * operator |
numeric_ne(numeric, numeric) | postgres | implementation of <> operator |
numeric_out(numeric) | postgres | I/O |
numeric_power(numeric, numeric) | postgres | implementation of ^ operator |
numeric_recv(internal, oid, integer) | postgres | I/O |
numeric_send(numeric) | postgres | I/O |
numeric_smaller(numeric, numeric) | postgres | smaller of two |
numeric_sqrt(numeric) | postgres | square root |
numeric_stddev_pop(numeric[]) | postgres | aggregate final function |
numeric_stddev_samp(numeric[]) | postgres | aggregate final function |
numeric_sub(numeric, numeric) | postgres | implementation of - operator |
numeric_transform(internal) | postgres | transform a numeric length coercion |
numeric_uminus(numeric) | postgres | implementation of - operator |
numeric_uplus(numeric) | postgres | implementation of + operator |
numeric_var_pop(numeric[]) | postgres | aggregate final function |
numeric_var_samp(numeric[]) | postgres | aggregate final function |
numerictypmodin(cstring[]) | postgres | I/O typmod |
numerictypmodout(integer) | postgres | I/O typmod |
numnode(tsquery) | postgres | number of nodes |
numrange(numeric, numeric, text) | postgres | numrange constructor |
numrange(numeric, numeric) | postgres | numrange constructor |
numrange_subdiff(numeric, numeric) | postgres | float8 difference of two numeric values |
obj_description(oid, name) | postgres | get description for object id and catalog name |
obj_description(oid) | postgres | deprecated, use two-argument form instead |
octet_length(bit) | postgres | octet length |
octet_length(character) | postgres | octet length |
octet_length(text) | postgres | octet length |
octet_length(bytea) | postgres | octet length |
oid(bigint) | postgres | convert int8 to oid |
oideq(oid, oid) | postgres | implementation of = operator |
oidge(oid, oid) | postgres | implementation of >= operator |
oidgt(oid, oid) | postgres | implementation of > operator |
oidin(cstring) | postgres | I/O |
oidlarger(oid, oid) | postgres | larger of two |
oidle(oid, oid) | postgres | implementation of <= operator |
oidlt(oid, oid) | postgres | implementation of < operator |
oidne(oid, oid) | postgres | implementation of <> operator |
oidout(oid) | postgres | I/O |
oidrecv(internal) | postgres | I/O |
oidsend(oid) | postgres | I/O |
oidsmaller(oid, oid) | postgres | smaller of two |
oidvectoreq(oidvector, oidvector) | postgres | implementation of = operator |
oidvectorge(oidvector, oidvector) | postgres | implementation of >= operator |
oidvectorgt(oidvector, oidvector) | postgres | implementation of > operator |
oidvectorin(cstring) | postgres | I/O |
oidvectorle(oidvector, oidvector) | postgres | implementation of <= operator |
oidvectorlt(oidvector, oidvector) | postgres | implementation of < operator |
oidvectorne(oidvector, oidvector) | postgres | implementation of <> operator |
oidvectorout(oidvector) | postgres | I/O |
oidvectorrecv(internal) | postgres | I/O |
oidvectorsend(oidvector) | postgres | I/O |
oidvectortypes(oidvector) | postgres | print type names of oidvector field |
on_pb(point, box) | postgres | implementation of <@ operator |
on_pl(point, line) | postgres | implementation of <@ operator |
on_ppath(point, path) | postgres | implementation of <@ operator |
on_ps(point, lseg) | postgres | implementation of <@ operator |
on_sb(lseg, box) | postgres | implementation of <@ operator |
on_sl(lseg, line) | postgres | implementation of <@ operator |
opaque_in(cstring) | postgres | I/O |
opaque_out(opaque) | postgres | I/O |
overlaps(timestamp without time zone, interval, timestamp without time zone, timestamp without time zone) | postgres | intervals overlap? |
overlaps(timestamp without time zone, interval, timestamp without time zone, interval) | postgres | intervals overlap? |
overlaps(time with time zone, time with time zone, time with time zone, time with time zone) | postgres | intervals overlap? |
overlaps(timestamp without time zone, timestamp without time zone, timestamp without time zone, timestamp without time zone) | postgres | intervals overlap? |
overlaps(timestamp without time zone, timestamp without time zone, timestamp without time zone, interval) | postgres | intervals overlap? |
overlaps(timestamp with time zone, timestamp with time zone, timestamp with time zone, timestamp with time zone) | postgres | intervals overlap? |
overlaps(timestamp with time zone, interval, timestamp with time zone, interval) | postgres | intervals overlap? |
overlaps(timestamp with time zone, interval, timestamp with time zone, timestamp with time zone) | postgres | intervals overlap? |
overlaps(time without time zone, time without time zone, time without time zone, time without time zone) | postgres | intervals overlap? |
overlaps(time without time zone, interval, time without time zone, interval) | postgres | intervals overlap? |
overlaps(time without time zone, time without time zone, time without time zone, interval) | postgres | intervals overlap? |
overlaps(time without time zone, interval, time without time zone, time without time zone) | postgres | intervals overlap? |
overlaps(timestamp with time zone, timestamp with time zone, timestamp with time zone, interval) | postgres | intervals overlap? |
overlay(bit, bit, integer, integer) | postgres | substitute portion of bitstring |
overlay(bit, bit, integer) | postgres | substitute portion of bitstring |
overlay(text, text, integer, integer) | postgres | substitute portion of string |
overlay(text, text, integer) | postgres | substitute portion of string |
overlay(bytea, bytea, integer, integer) | postgres | substitute portion of string |
overlay(bytea, bytea, integer) | postgres | substitute portion of string |
path(polygon) | postgres | convert polygon to path |
path_add(path, path) | postgres | implementation of + operator |
path_add_pt(path, point) | postgres | implementation of + operator |
path_center(path) | postgres | implementation of @@ operator |
path_contain_pt(path, point) | postgres | implementation of @> operator |
path_distance(path, path) | postgres | implementation of <-> operator |
path_div_pt(path, point) | postgres | implementation of / operator |
path_in(cstring) | postgres | I/O |
path_inter(path, path) | postgres | implementation of ?# operator |
path_length(path) | postgres | implementation of @-@ operator |
path_mul_pt(path, point) | postgres | implementation of * operator |
path_n_eq(path, path) | postgres | implementation of = operator |
path_n_ge(path, path) | postgres | implementation of >= operator |
path_n_gt(path, path) | postgres | implementation of > operator |
path_n_le(path, path) | postgres | implementation of <= operator |
path_n_lt(path, path) | postgres | implementation of < operator |
path_npoints(path) | postgres | implementation of # operator |
path_out(path) | postgres | I/O |
path_recv(internal) | postgres | I/O |
path_send(path) | postgres | I/O |
path_sub_pt(path, point) | postgres | implementation of - operator |
pclose(path) | postgres | close path |
percent_rank() | postgres | fractional rank within partition |
pg_advisory_lock(bigint) | postgres | obtain exclusive advisory lock |
pg_advisory_lock(integer, integer) | postgres | obtain exclusive advisory lock |
pg_advisory_lock_shared(bigint) | postgres | obtain shared advisory lock |
pg_advisory_lock_shared(integer, integer) | postgres | obtain shared advisory lock |
pg_advisory_unlock(integer, integer) | postgres | release exclusive advisory lock |
pg_advisory_unlock(bigint) | postgres | release exclusive advisory lock |
pg_advisory_unlock_all() | postgres | release all advisory locks |
pg_advisory_unlock_shared(bigint) | postgres | release shared advisory lock |
pg_advisory_unlock_shared(integer, integer) | postgres | release shared advisory lock |
pg_advisory_xact_lock(bigint) | postgres | obtain exclusive advisory lock |
pg_advisory_xact_lock(integer, integer) | postgres | obtain exclusive advisory lock |
pg_advisory_xact_lock_shared(bigint) | postgres | obtain shared advisory lock |
pg_advisory_xact_lock_shared(integer, integer) | postgres | obtain shared advisory lock |
pg_available_extension_versions() | postgres | list available extension versions |
pg_available_extensions() | postgres | list available extensions |
pg_backend_pid() | postgres | statistics: current backend PID |
pg_cancel_backend(integer) | postgres | cancel a server process' current query |
pg_char_to_encoding(name) | postgres | convert encoding name to encoding id |
pg_client_encoding() | postgres | encoding name of current database |
pg_collation_for("any") | postgres | collation of the argument; implementation of the COLLATION FOR expression |
pg_collation_is_visible(oid) | postgres | is collation visible in search path? |
pg_column_size("any") | postgres | bytes required to store the value, perhaps with compression |
pg_conf_load_time() | postgres | configuration load time |
pg_conversion_is_visible(oid) | postgres | is conversion visible in search path? |
pg_create_restore_point(text) | postgres | create a named restore point |
pg_current_xlog_insert_location() | postgres | current xlog insert location |
pg_current_xlog_location() | postgres | current xlog write location |
pg_cursor() | postgres | get the open cursors for this session |
pg_database_size(oid) | postgres | total disk space usage for the specified database |
pg_database_size(name) | postgres | total disk space usage for the specified database |
pg_describe_object(oid, oid, integer) | postgres | get identification of SQL object |
pg_encoding_max_length(integer) | postgres | maximum octet length of a character in given encoding |
pg_encoding_to_char(integer) | postgres | convert encoding id to encoding name |
pg_export_snapshot() | postgres | export a snapshot |
pg_extension_config_dump(regclass, text) | postgres | flag an extension's table contents to be emitted by pg_dump |
pg_extension_update_paths(name) | postgres | list an extension's version update paths |
pg_function_is_visible(oid) | postgres | is function visible in search path? |
pg_get_constraintdef(oid) | postgres | constraint description |
pg_get_constraintdef(oid, boolean) | postgres | constraint description with pretty-print option |
pg_get_expr(pg_node_tree, oid) | postgres | deparse an encoded expression |
pg_get_expr(pg_node_tree, oid, boolean) | postgres | deparse an encoded expression with pretty-print option |
pg_get_function_arguments(oid) | postgres | argument list of a function |
pg_get_function_identity_arguments(oid) | postgres | identity argument list of a function |
pg_get_function_result(oid) | postgres | result type of a function |
pg_get_functiondef(oid) | postgres | definition of a function |
pg_get_indexdef(oid) | postgres | index description |
pg_get_indexdef(oid, integer, boolean) | postgres | index description (full create statement or single expression) with pretty-print option |
pg_get_keywords() | postgres | list of SQL keywords |
pg_get_ruledef(oid) | postgres | source text of a rule |
pg_get_ruledef(oid, boolean) | postgres | source text of a rule with pretty-print option |
pg_get_serial_sequence(text, text) | postgres | name of sequence for a serial column |
pg_get_triggerdef(oid) | postgres | trigger description |
pg_get_triggerdef(oid, boolean) | postgres | trigger description with pretty-print option |
pg_get_userbyid(oid) | postgres | role name by OID (with fallback) |
pg_get_viewdef(text) | postgres | select statement of a view |
pg_get_viewdef(oid, integer) | postgres | select statement of a view with pretty-printing and specified line wrapping |
pg_get_viewdef(oid) | postgres | select statement of a view |
pg_get_viewdef(text, boolean) | postgres | select statement of a view with pretty-print option |
pg_get_viewdef(oid, boolean) | postgres | select statement of a view with pretty-print option |
pg_has_role(name, name, text) | postgres | user privilege on role by username, role name |
pg_has_role(name, oid, text) | postgres | user privilege on role by username, role oid |
pg_has_role(oid, text) | postgres | current user privilege on role by role oid |
pg_has_role(oid, name, text) | postgres | user privilege on role by user oid, role name |
pg_has_role(name, text) | postgres | current user privilege on role by role name |
pg_has_role(oid, oid, text) | postgres | user privilege on role by user oid, role oid |
pg_indexes_size(regclass) | postgres | disk space usage for all indexes attached to the specified table |
pg_is_in_recovery() | postgres | true if server is in recovery |
pg_is_other_temp_schema(oid) | postgres | is schema another session's temp schema? |
pg_is_xlog_replay_paused() | postgres | true if xlog replay is paused |
pg_last_xact_replay_timestamp() | postgres | timestamp of last replay xact |
pg_last_xlog_receive_location() | postgres | current xlog flush location |
pg_last_xlog_replay_location() | postgres | last xlog replay location |
pg_listening_channels() | postgres | get the channels that the current backend listens to |
pg_lock_status() | postgres | view system lock information |
pg_ls_dir(text) | postgres | list all files in a directory |
pg_my_temp_schema() | postgres | get OID of current session's temp schema, if any |
pg_node_tree_in(cstring) | postgres | I/O |
pg_node_tree_out(pg_node_tree) | postgres | I/O |
pg_node_tree_recv(internal) | postgres | I/O |
pg_node_tree_send(pg_node_tree) | postgres | I/O |
pg_notify(text, text) | postgres | send a notification event |
pg_opclass_is_visible(oid) | postgres | is opclass visible in search path? |
pg_operator_is_visible(oid) | postgres | is operator visible in search path? |
pg_opfamily_is_visible(oid) | postgres | is opfamily visible in search path? |
pg_options_to_table(text[]) | postgres | convert generic options array to name/value table |
pg_postmaster_start_time() | postgres | postmaster start time |
pg_prepared_statement() | postgres | get the prepared statements for this session |
pg_prepared_xact() | postgres | view two-phase transactions |
pg_read_binary_file(text) | postgres | read bytea from a file |
pg_read_binary_file(text, bigint, bigint) | postgres | read bytea from a file |
pg_read_file(text, bigint, bigint) | postgres | read text from a file |
pg_read_file(text) | postgres | read text from a file |
pg_relation_filenode(regclass) | postgres | filenode identifier of relation |
pg_relation_filepath(regclass) | postgres | file path of relation |
pg_relation_size(regclass) | postgres | disk space usage for the main fork of the specified table or index |
pg_relation_size(regclass, text) | postgres | disk space usage for the specified fork of a table or index |
pg_reload_conf() | postgres | reload configuration files |
pg_rotate_logfile() | postgres | rotate log file |
pg_sequence_parameters(integer) | postgres | sequence parameters, for use by information schema |
pg_show_all_settings() | postgres | SHOW ALL as a function |
pg_size_pretty(bigint) | postgres | convert a long int to a human readable text using size units |
pg_size_pretty(numeric) | postgres | convert a numeric to a human readable text using size units |
pg_sleep(double precision) | postgres | sleep for the specified time in seconds |
pg_start_backup(text, boolean) | postgres | prepare for taking an online backup |
pg_stat_clear_snapshot() | postgres | statistics: discard current transaction's statistics snapshot |
pg_stat_file(text) | postgres | get information about file |
pg_stat_get_activity(integer) | postgres | statistics: information about currently active backends |
pg_stat_get_analyze_count(oid) | postgres | statistics: number of manual analyzes for a table |
pg_stat_get_autoanalyze_count(oid) | postgres | statistics: number of auto analyzes for a table |
pg_stat_get_autovacuum_count(oid) | postgres | statistics: number of auto vacuums for a table |
pg_stat_get_backend_activity(integer) | postgres | statistics: current query of backend |
pg_stat_get_backend_activity_start(integer) | postgres | statistics: start time for current query of backend |
pg_stat_get_backend_client_addr(integer) | postgres | statistics: address of client connected to backend |
pg_stat_get_backend_client_port(integer) | postgres | statistics: port number of client connected to backend |
pg_stat_get_backend_dbid(integer) | postgres | statistics: database ID of backend |
pg_stat_get_backend_idset() | postgres | statistics: currently active backend IDs |
pg_stat_get_backend_pid(integer) | postgres | statistics: PID of backend |
pg_stat_get_backend_start(integer) | postgres | statistics: start time for current backend session |
pg_stat_get_backend_userid(integer) | postgres | statistics: user ID of backend |
pg_stat_get_backend_waiting(integer) | postgres | statistics: is backend currently waiting for a lock |
pg_stat_get_backend_xact_start(integer) | postgres | statistics: start time for backend's current transaction |
pg_stat_get_bgwriter_buf_written_checkpoints() | postgres | statistics: number of buffers written by the bgwriter during checkpoints |
pg_stat_get_bgwriter_buf_written_clean() | postgres | statistics: number of buffers written by the bgwriter for cleaning dirty buffers |
pg_stat_get_bgwriter_maxwritten_clean() | postgres | statistics: number of times the bgwriter stopped processing when it had written too many buffers while cleaning |
pg_stat_get_bgwriter_requested_checkpoints() | postgres | statistics: number of backend requested checkpoints started by the bgwriter |
pg_stat_get_bgwriter_stat_reset_time() | postgres | statistics: last reset for the bgwriter |
pg_stat_get_bgwriter_timed_checkpoints() | postgres | statistics: number of timed checkpoints started by the bgwriter |
pg_stat_get_blocks_fetched(oid) | postgres | statistics: number of blocks fetched |
pg_stat_get_blocks_hit(oid) | postgres | statistics: number of blocks found in cache |
pg_stat_get_buf_alloc() | postgres | statistics: number of buffer allocations |
pg_stat_get_buf_fsync_backend() | postgres | statistics: number of backend buffer writes that did their own fsync |
pg_stat_get_buf_written_backend() | postgres | statistics: number of buffers written by backends |
pg_stat_get_checkpoint_sync_time() | postgres | statistics: checkpoint time spent synchronizing buffers to disk, in msec |
pg_stat_get_checkpoint_write_time() | postgres | statistics: checkpoint time spent writing buffers to disk, in msec |
pg_stat_get_db_blk_read_time(oid) | postgres | statistics: block read time, in msec |
pg_stat_get_db_blk_write_time(oid) | postgres | statistics: block write time, in msec |
pg_stat_get_db_blocks_fetched(oid) | postgres | statistics: blocks fetched for database |
pg_stat_get_db_blocks_hit(oid) | postgres | statistics: blocks found in cache for database |
pg_stat_get_db_conflict_all(oid) | postgres | statistics: recovery conflicts in database |
pg_stat_get_db_conflict_bufferpin(oid) | postgres | statistics: recovery conflicts in database caused by shared buffer pin |
pg_stat_get_db_conflict_lock(oid) | postgres | statistics: recovery conflicts in database caused by relation lock |
pg_stat_get_db_conflict_snapshot(oid) | postgres | statistics: recovery conflicts in database caused by snapshot expiry |
pg_stat_get_db_conflict_startup_deadlock(oid) | postgres | statistics: recovery conflicts in database caused by buffer deadlock |
pg_stat_get_db_conflict_tablespace(oid) | postgres | statistics: recovery conflicts in database caused by drop tablespace |
pg_stat_get_db_deadlocks(oid) | postgres | statistics: deadlocks detected in database |
pg_stat_get_db_numbackends(oid) | postgres | statistics: number of backends in database |
pg_stat_get_db_stat_reset_time(oid) | postgres | statistics: last reset for a database |
pg_stat_get_db_temp_bytes(oid) | postgres | statistics: number of bytes in temporary files written |
pg_stat_get_db_temp_files(oid) | postgres | statistics: number of temporary files written |
pg_stat_get_db_tuples_deleted(oid) | postgres | statistics: tuples deleted in database |
pg_stat_get_db_tuples_fetched(oid) | postgres | statistics: tuples fetched for database |
pg_stat_get_db_tuples_inserted(oid) | postgres | statistics: tuples inserted in database |
pg_stat_get_db_tuples_returned(oid) | postgres | statistics: tuples returned for database |
pg_stat_get_db_tuples_updated(oid) | postgres | statistics: tuples updated in database |
pg_stat_get_db_xact_commit(oid) | postgres | statistics: transactions committed |
pg_stat_get_db_xact_rollback(oid) | postgres | statistics: transactions rolled back |
pg_stat_get_dead_tuples(oid) | postgres | statistics: number of dead tuples |
pg_stat_get_function_calls(oid) | postgres | statistics: number of function calls |
pg_stat_get_function_self_time(oid) | postgres | statistics: self execution time of function, in msec |
pg_stat_get_function_total_time(oid) | postgres | statistics: total execution time of function, in msec |
pg_stat_get_last_analyze_time(oid) | postgres | statistics: last manual analyze time for a table |
pg_stat_get_last_autoanalyze_time(oid) | postgres | statistics: last auto analyze time for a table |
pg_stat_get_last_autovacuum_time(oid) | postgres | statistics: last auto vacuum time for a table |
pg_stat_get_last_vacuum_time(oid) | postgres | statistics: last manual vacuum time for a table |
pg_stat_get_live_tuples(oid) | postgres | statistics: number of live tuples |
pg_stat_get_numscans(oid) | postgres | statistics: number of scans done for table/index |
pg_stat_get_tuples_deleted(oid) | postgres | statistics: number of tuples deleted |
pg_stat_get_tuples_fetched(oid) | postgres | statistics: number of tuples fetched by idxscan |
pg_stat_get_tuples_hot_updated(oid) | postgres | statistics: number of tuples hot updated |
pg_stat_get_tuples_inserted(oid) | postgres | statistics: number of tuples inserted |
pg_stat_get_tuples_returned(oid) | postgres | statistics: number of tuples read by seqscan |
pg_stat_get_tuples_updated(oid) | postgres | statistics: number of tuples updated |
pg_stat_get_vacuum_count(oid) | postgres | statistics: number of manual vacuums for a table |
pg_stat_get_wal_senders() | postgres | statistics: information about currently active replication |
pg_stat_get_xact_blocks_fetched(oid) | postgres | statistics: number of blocks fetched in current transaction |
pg_stat_get_xact_blocks_hit(oid) | postgres | statistics: number of blocks found in cache in current transaction |
pg_stat_get_xact_function_calls(oid) | postgres | statistics: number of function calls in current transaction |
pg_stat_get_xact_function_self_time(oid) | postgres | statistics: self execution time of function in current transaction, in msec |
pg_stat_get_xact_function_total_time(oid) | postgres | statistics: total execution time of function in current transaction, in msec |
pg_stat_get_xact_numscans(oid) | postgres | statistics: number of scans done for table/index in current transaction |
pg_stat_get_xact_tuples_deleted(oid) | postgres | statistics: number of tuples deleted in current transaction |
pg_stat_get_xact_tuples_fetched(oid) | postgres | statistics: number of tuples fetched by idxscan in current transaction |
pg_stat_get_xact_tuples_hot_updated(oid) | postgres | statistics: number of tuples hot updated in current transaction |
pg_stat_get_xact_tuples_inserted(oid) | postgres | statistics: number of tuples inserted in current transaction |
pg_stat_get_xact_tuples_returned(oid) | postgres | statistics: number of tuples read by seqscan in current transaction |
pg_stat_get_xact_tuples_updated(oid) | postgres | statistics: number of tuples updated in current transaction |
pg_stat_reset() | postgres | statistics: reset collected statistics for current database |
pg_stat_reset_shared(text) | postgres | statistics: reset collected statistics shared across the cluster |
pg_stat_reset_single_function_counters(oid) | postgres | statistics: reset collected statistics for a single function in the current database |
pg_stat_reset_single_table_counters(oid) | postgres | statistics: reset collected statistics for a single table or index in the current database |
pg_stop_backup() | postgres | finish taking an online backup |
pg_switch_xlog() | postgres | switch to new xlog file |
pg_table_is_visible(oid) | postgres | is table visible in search path? |
pg_table_size(regclass) | postgres | disk space usage for the specified table, including TOAST, free space and visibility map |
pg_tablespace_databases(oid) | postgres | get OIDs of databases in a tablespace |
pg_tablespace_location(oid) | postgres | tablespace location |
pg_tablespace_size(name) | postgres | total disk space usage for the specified tablespace |
pg_tablespace_size(oid) | postgres | total disk space usage for the specified tablespace |
pg_terminate_backend(integer) | postgres | terminate a server process |
pg_timezone_abbrevs() | postgres | get the available time zone abbreviations |
pg_timezone_names() | postgres | get the available time zone names |
pg_total_relation_size(regclass) | postgres | total disk space usage for the specified table and associated indexes |
pg_trigger_depth() | postgres | current trigger depth |
pg_try_advisory_lock(integer, integer) | postgres | obtain exclusive advisory lock if available |
pg_try_advisory_lock(bigint) | postgres | obtain exclusive advisory lock if available |
pg_try_advisory_lock_shared(bigint) | postgres | obtain shared advisory lock if available |
pg_try_advisory_lock_shared(integer, integer) | postgres | obtain shared advisory lock if available |
pg_try_advisory_xact_lock(bigint) | postgres | obtain exclusive advisory lock if available |
pg_try_advisory_xact_lock(integer, integer) | postgres | obtain exclusive advisory lock if available |
pg_try_advisory_xact_lock_shared(integer, integer) | postgres | obtain shared advisory lock if available |
pg_try_advisory_xact_lock_shared(bigint) | postgres | obtain shared advisory lock if available |
pg_ts_config_is_visible(oid) | postgres | is text search configuration visible in search path? |
pg_ts_dict_is_visible(oid) | postgres | is text search dictionary visible in search path? |
pg_ts_parser_is_visible(oid) | postgres | is text search parser visible in search path? |
pg_ts_template_is_visible(oid) | postgres | is text search template visible in search path? |
pg_type_is_visible(oid) | postgres | is type visible in search path? |
pg_typeof("any") | postgres | type of the argument |
pg_xlog_location_diff(text, text) | postgres | difference in bytes, given two xlog locations |
pg_xlog_replay_pause() | postgres | pause xlog replay |
pg_xlog_replay_resume() | postgres | resume xlog replay, if it was paused |
pg_xlogfile_name(text) | postgres | xlog filename, given an xlog location |
pg_xlogfile_name_offset(text) | postgres | xlog filename and byte offset, given an xlog location |
pi() | postgres | PI |
plainto_tsquery(text) | postgres | transform to tsquery |
plainto_tsquery(regconfig, text) | postgres | transform to tsquery |
plpgsql_call_handler() | postgres | |
plpgsql_inline_handler(internal) | postgres | |
plpgsql_validator(oid) | postgres | |
point(circle) | postgres | center of |
point(path) | postgres | center of |
point(polygon) | postgres | center of |
point(box) | postgres | center of |
point(double precision, double precision) | postgres | convert x, y to point |
point(lseg) | postgres | center of |
point_above(point, point) | postgres | implementation of >^ operator |
point_add(point, point) | postgres | implementation of + operator |
point_below(point, point) | postgres | implementation of <^ operator |
point_distance(point, point) | postgres | implementation of <-> operator |
point_div(point, point) | postgres | implementation of / operator |
point_eq(point, point) | postgres | implementation of ~= operator |
point_horiz(point, point) | postgres | implementation of ?- operator |
point_in(cstring) | postgres | I/O |
point_left(point, point) | postgres | implementation of << operator |
point_mul(point, point) | postgres | implementation of * operator |
point_ne(point, point) | postgres | implementation of <> operator |
point_out(point) | postgres | I/O |
point_recv(internal) | postgres | I/O |
point_right(point, point) | postgres | implementation of >> operator |
point_send(point) | postgres | I/O |
point_sub(point, point) | postgres | implementation of - operator |
point_vert(point, point) | postgres | implementation of ?| operator |
poly_above(polygon, polygon) | postgres | implementation of |>> operator |
poly_below(polygon, polygon) | postgres | implementation of <<| operator |
poly_center(polygon) | postgres | implementation of @@ operator |
poly_contain(polygon, polygon) | postgres | implementation of @> operator |
poly_contain_pt(polygon, point) | postgres | implementation of @> operator |
poly_contained(polygon, polygon) | postgres | implementation of <@ operator |
poly_distance(polygon, polygon) | postgres | implementation of <-> operator |
poly_in(cstring) | postgres | I/O |
poly_left(polygon, polygon) | postgres | implementation of << operator |
poly_npoints(polygon) | postgres | implementation of # operator |
poly_out(polygon) | postgres | I/O |
poly_overabove(polygon, polygon) | postgres | implementation of |&> operator |
poly_overbelow(polygon, polygon) | postgres | implementation of &<| operator |
poly_overlap(polygon, polygon) | postgres | implementation of && operator |
poly_overleft(polygon, polygon) | postgres | implementation of &< operator |
poly_overright(polygon, polygon) | postgres | implementation of &> operator |
poly_recv(internal) | postgres | I/O |
poly_right(polygon, polygon) | postgres | implementation of >> operator |
poly_same(polygon, polygon) | postgres | implementation of ~= operator |
poly_send(polygon) | postgres | I/O |
polygon(box) | postgres | convert box to polygon |
polygon(path) | postgres | convert path to polygon |
polygon(integer, circle) | postgres | convert vertex count and circle to polygon |
polygon(circle) | postgres | convert circle to 12-vertex polygon |
popen(path) | postgres | open path |
position(bit, bit) | postgres | position of sub-bitstring |
position(bytea, bytea) | postgres | position of substring |
position(text, text) | postgres | position of substring |
positionjoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity for position-comparison operators |
positionsel(internal, oid, internal, integer) | postgres | restriction selectivity for position-comparison operators |
postgresql_fdw_validator(text[], oid) | postgres | (internal) |
pow(double precision, double precision) | postgres | exponentiation |
pow(numeric, numeric) | postgres | exponentiation |
power(double precision, double precision) | postgres | exponentiation |
power(numeric, numeric) | postgres | exponentiation |
prsd_end(internal) | postgres | (internal) |
prsd_headline(internal, internal, tsquery) | postgres | (internal) |
prsd_lextype(internal) | postgres | (internal) |
prsd_nexttoken(internal, internal, internal) | postgres | (internal) |
prsd_start(internal, integer) | postgres | (internal) |
pt_contained_circle(point, circle) | postgres | implementation of <@ operator |
pt_contained_poly(point, polygon) | postgres | implementation of <@ operator |
query_to_xml(text, boolean, boolean, text) | postgres | map query result to XML |
query_to_xml_and_xmlschema(text, boolean, boolean, text) | postgres | map query result and structure to XML and XML Schema |
query_to_xmlschema(text, boolean, boolean, text) | postgres | map query result structure to XML Schema |
querytree(tsquery) | postgres | show real useful query for GiST index |
quote_ident(text) | postgres | quote an identifier for usage in a querystring |
quote_literal(text) | postgres | quote a literal for usage in a querystring |
quote_literal(anyelement) | postgres | quote a data value for usage in a querystring |
quote_nullable(text) | postgres | quote a possibly-null literal for usage in a querystring |
quote_nullable(anyelement) | postgres | quote a possibly-null data value for usage in a querystring |
radians(double precision) | postgres | degrees to radians |
radius(circle) | postgres | radius of circle |
random() | postgres | random value |
range_adjacent(anyrange, anyrange) | postgres | implementation of -|- operator |
range_after(anyrange, anyrange) | postgres | implementation of >> operator |
range_before(anyrange, anyrange) | postgres | implementation of << operator |
range_cmp(anyrange, anyrange) | postgres | less-equal-greater |
range_contained_by(anyrange, anyrange) | postgres | implementation of <@ operator |
range_contains(anyrange, anyrange) | postgres | implementation of @> operator |
range_contains_elem(anyrange, anyelement) | postgres | implementation of @> operator |
range_eq(anyrange, anyrange) | postgres | implementation of = operator |
range_ge(anyrange, anyrange) | postgres | implementation of >= operator |
range_gist_compress(internal) | postgres | GiST support |
range_gist_consistent(internal, anyrange, integer, oid, internal) | postgres | GiST support |
range_gist_decompress(internal) | postgres | GiST support |
range_gist_penalty(internal, internal, internal) | postgres | GiST support |
range_gist_picksplit(internal, internal) | postgres | GiST support |
range_gist_same(anyrange, anyrange, internal) | postgres | GiST support |
range_gist_union(internal, internal) | postgres | GiST support |
range_gt(anyrange, anyrange) | postgres | implementation of > operator |
range_in(cstring, oid, integer) | postgres | I/O |
range_intersect(anyrange, anyrange) | postgres | implementation of * operator |
range_le(anyrange, anyrange) | postgres | implementation of <= operator |
range_lt(anyrange, anyrange) | postgres | implementation of < operator |
range_minus(anyrange, anyrange) | postgres | implementation of - operator |
range_ne(anyrange, anyrange) | postgres | implementation of <> operator |
range_out(anyrange) | postgres | I/O |
range_overlaps(anyrange, anyrange) | postgres | implementation of && operator |
range_overleft(anyrange, anyrange) | postgres | implementation of &< operator |
range_overright(anyrange, anyrange) | postgres | implementation of &> operator |
range_recv(internal, oid, integer) | postgres | I/O |
range_send(anyrange) | postgres | I/O |
range_typanalyze(internal) | postgres | range typanalyze |
range_union(anyrange, anyrange) | postgres | implementation of + operator |
rank() | postgres | integer rank with gaps |
record_eq(record, record) | postgres | implementation of = operator |
record_ge(record, record) | postgres | implementation of >= operator |
record_gt(record, record) | postgres | implementation of > operator |
record_in(cstring, oid, integer) | postgres | I/O |
record_le(record, record) | postgres | implementation of <= operator |
record_lt(record, record) | postgres | implementation of < operator |
record_ne(record, record) | postgres | implementation of <> operator |
record_out(record) | postgres | I/O |
record_recv(internal, oid, integer) | postgres | I/O |
record_send(record) | postgres | I/O |
regclass(text) | postgres | convert text to regclass |
regclassin(cstring) | postgres | I/O |
regclassout(regclass) | postgres | I/O |
regclassrecv(internal) | postgres | I/O |
regclasssend(regclass) | postgres | I/O |
regconfigin(cstring) | postgres | I/O |
regconfigout(regconfig) | postgres | I/O |
regconfigrecv(internal) | postgres | I/O |
regconfigsend(regconfig) | postgres | I/O |
regdictionaryin(cstring) | postgres | I/O |
regdictionaryout(regdictionary) | postgres | I/O |
regdictionaryrecv(internal) | postgres | I/O |
regdictionarysend(regdictionary) | postgres | I/O |
regexeqjoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity of regex match |
regexeqsel(internal, oid, internal, integer) | postgres | restriction selectivity of regex match |
regexnejoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity of regex non-match |
regexnesel(internal, oid, internal, integer) | postgres | restriction selectivity of regex non-match |
regexp_matches(text, text) | postgres | find all match groups for regexp |
regexp_matches(text, text, text) | postgres | find all match groups for regexp |
regexp_replace(text, text, text, text) | postgres | replace text using regexp |
regexp_replace(text, text, text) | postgres | replace text using regexp |
regexp_split_to_array(text, text, text) | postgres | split string by pattern |
regexp_split_to_array(text, text) | postgres | split string by pattern |
regexp_split_to_table(text, text) | postgres | split string by pattern |
regexp_split_to_table(text, text, text) | postgres | split string by pattern |
regoperatorin(cstring) | postgres | I/O |
regoperatorout(regoperator) | postgres | I/O |
regoperatorrecv(internal) | postgres | I/O |
regoperatorsend(regoperator) | postgres | I/O |
regoperin(cstring) | postgres | I/O |
regoperout(regoper) | postgres | I/O |
regoperrecv(internal) | postgres | I/O |
regopersend(regoper) | postgres | I/O |
regprocedurein(cstring) | postgres | I/O |
regprocedureout(regprocedure) | postgres | I/O |
regprocedurerecv(internal) | postgres | I/O |
regproceduresend(regprocedure) | postgres | I/O |
regprocin(cstring) | postgres | I/O |
regprocout(regproc) | postgres | I/O |
regprocrecv(internal) | postgres | I/O |
regprocsend(regproc) | postgres | I/O |
regtypein(cstring) | postgres | I/O |
regtypeout(regtype) | postgres | I/O |
regtyperecv(internal) | postgres | I/O |
regtypesend(regtype) | postgres | I/O |
reltime(interval) | postgres | convert interval to reltime |
reltimeeq(reltime, reltime) | postgres | implementation of = operator |
reltimege(reltime, reltime) | postgres | implementation of >= operator |
reltimegt(reltime, reltime) | postgres | implementation of > operator |
reltimein(cstring) | postgres | I/O |
reltimele(reltime, reltime) | postgres | implementation of <= operator |
reltimelt(reltime, reltime) | postgres | implementation of < operator |
reltimene(reltime, reltime) | postgres | implementation of <> operator |
reltimeout(reltime) | postgres | I/O |
reltimerecv(internal) | postgres | I/O |
reltimesend(reltime) | postgres | I/O |
repeat(text, integer) | postgres | replicate string n times |
replace(text, text, text) | postgres | replace all occurrences in string of old_substr with new_substr |
reverse(text) | postgres | reverse text |
right(text, integer) | postgres | extract the last n characters |
round(double precision) | postgres | round to nearest integer |
round(numeric, integer) | postgres | value rounded to 'scale' |
round(numeric) | postgres | value rounded to 'scale' of zero |
row_number() | postgres | row number within partition |
row_to_json(record, boolean) | postgres | map row to json with optional pretty printing |
row_to_json(record) | postgres | map row to json |
rpad(text, integer, text) | postgres | right-pad string to length |
rpad(text, integer) | postgres | right-pad string to length |
rtrim(text, text) | postgres | trim selected characters from right end of string |
rtrim(text) | postgres | trim spaces from right end of string |
scalargtjoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity of > and related operators on scalar datatypes |
scalargtsel(internal, oid, internal, integer) | postgres | restriction selectivity of > and related operators on scalar datatypes |
scalarltjoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity of < and related operators on scalar datatypes |
scalarltsel(internal, oid, internal, integer) | postgres | restriction selectivity of < and related operators on scalar datatypes |
schema_to_xml(name, boolean, boolean, text) | postgres | map schema contents to XML |
schema_to_xml_and_xmlschema(name, boolean, boolean, text) | postgres | map schema contents and structure to XML and XML Schema |
schema_to_xmlschema(name, boolean, boolean, text) | postgres | map schema structure to XML Schema |
session_user() | postgres | session user name |
set_bit(bit, integer, integer) | postgres | set bit |
set_bit(bytea, integer, integer) | postgres | set bit |
set_byte(bytea, integer, integer) | postgres | set byte |
set_config(text, text, boolean) | postgres | SET X as a function |
set_masklen(inet, integer) | postgres | change netmask of inet |
set_masklen(cidr, integer) | postgres | change netmask of cidr |
setseed(double precision) | postgres | set random seed |
setval(regclass, bigint, boolean) | postgres | set sequence value and is_called status |
setval(regclass, bigint) | postgres | set sequence value |
setweight(tsvector, "char") | postgres | set weight of lexeme's entries |
shell_in(cstring) | postgres | I/O |
shell_out(opaque) | postgres | I/O |
shift_jis_2004_to_euc_jis_2004(integer, integer, cstring, internal, integer) | postgres | internal conversion function for SHIFT_JIS_2004 to EUC_JIS_2004 |
shift_jis_2004_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for SHIFT_JIS_2004 to UTF8 |
shobj_description(oid, name) | postgres | get description for object id and shared catalog name |
sign(double precision) | postgres | sign of value |
sign(numeric) | postgres | sign of value |
similar_escape(text, text) | postgres | convert SQL99 regexp pattern to POSIX style |
sin(double precision) | postgres | sine |
sjis_to_euc_jp(integer, integer, cstring, internal, integer) | postgres | internal conversion function for SJIS to EUC_JP |
sjis_to_mic(integer, integer, cstring, internal, integer) | postgres | internal conversion function for SJIS to MULE_INTERNAL |
sjis_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for SJIS to UTF8 |
slope(point, point) | postgres | slope between points |
smgreq(smgr, smgr) | postgres | storage manager |
smgrin(cstring) | postgres | I/O |
smgrne(smgr, smgr) | postgres | storage manager |
smgrout(smgr) | postgres | I/O |
spg_kd_choose(internal, internal) | postgres | SP-GiST support for k-d tree over point |
spg_kd_config(internal, internal) | postgres | SP-GiST support for k-d tree over point |
spg_kd_inner_consistent(internal, internal) | postgres | SP-GiST support for k-d tree over point |
spg_kd_picksplit(internal, internal) | postgres | SP-GiST support for k-d tree over point |
spg_quad_choose(internal, internal) | postgres | SP-GiST support for quad tree over point |
spg_quad_config(internal, internal) | postgres | SP-GiST support for quad tree over point |
spg_quad_inner_consistent(internal, internal) | postgres | SP-GiST support for quad tree over point |
spg_quad_leaf_consistent(internal, internal) | postgres | SP-GiST support for quad tree and k-d tree over point |
spg_quad_picksplit(internal, internal) | postgres | SP-GiST support for quad tree over point |
spg_text_choose(internal, internal) | postgres | SP-GiST support for suffix tree over text |
spg_text_config(internal, internal) | postgres | SP-GiST support for suffix tree over text |
spg_text_inner_consistent(internal, internal) | postgres | SP-GiST support for suffix tree over text |
spg_text_leaf_consistent(internal, internal) | postgres | SP-GiST support for suffix tree over text |
spg_text_picksplit(internal, internal) | postgres | SP-GiST support for suffix tree over text |
spgbeginscan(internal, internal, internal) | postgres | spgist(internal) |
spgbuild(internal, internal, internal) | postgres | spgist(internal) |
spgbuildempty(internal) | postgres | spgist(internal) |
spgbulkdelete(internal, internal, internal, internal) | postgres | spgist(internal) |
spgcanreturn(internal) | postgres | spgist(internal) |
spgcostestimate(internal, internal, internal, internal, internal, internal, internal) | postgres | spgist(internal) |
spgendscan(internal) | postgres | spgist(internal) |
spggetbitmap(internal, internal) | postgres | spgist(internal) |
spggettuple(internal, internal) | postgres | spgist(internal) |
spginsert(internal, internal, internal, internal, internal, internal) | postgres | spgist(internal) |
spgmarkpos(internal) | postgres | spgist(internal) |
spgoptions(text[], boolean) | postgres | spgist(internal) |
spgrescan(internal, internal, internal, internal, internal) | postgres | spgist(internal) |
spgrestrpos(internal) | postgres | spgist(internal) |
spgvacuumcleanup(internal, internal) | postgres | spgist(internal) |
split_part(text, text, integer) | postgres | split string by field_sep and return field_num |
sqrt(double precision) | postgres | square root |
sqrt(numeric) | postgres | square root |
statement_timestamp() | postgres | current statement time |
string_agg_finalfn(internal) | postgres | aggregate final function |
string_agg_transfn(internal, text, text) | postgres | aggregate transition function |
string_to_array(text, text, text) | postgres | split delimited text into text[], with null string |
string_to_array(text, text) | postgres | split delimited text into text[] |
strip(tsvector) | postgres | strip position information |
strpos(text, text) | postgres | position of substring |
substr(bytea, integer, integer) | postgres | extract portion of string |
substr(text, integer) | postgres | extract portion of string |
substr(text, integer, integer) | postgres | extract portion of string |
substr(bytea, integer) | postgres | extract portion of string |
substring(text, text) | postgres | extract text matching regular expression |
substring(bit, integer, integer) | postgres | extract portion of bitstring |
substring(bytea, integer) | postgres | extract portion of string |
substring(bit, integer) | postgres | extract portion of bitstring |
substring(text, text, text) | postgres | extract text matching SQL99 regular expression |
substring(bytea, integer, integer) | postgres | extract portion of string |
substring(text, integer) | postgres | extract portion of string |
substring(text, integer, integer) | postgres | extract portion of string |
table_to_xml(regclass, boolean, boolean, text) | postgres | map table contents to XML |
table_to_xml_and_xmlschema(regclass, boolean, boolean, text) | postgres | map table contents and structure to XML and XML Schema |
table_to_xmlschema(regclass, boolean, boolean, text) | postgres | map table structure to XML Schema |
tan(double precision) | postgres | tangent |
text("char") | postgres | convert char to text |
text(inet) | postgres | show all parts of inet/cidr value |
text(name) | postgres | convert name to text |
text(character) | postgres | convert char(n) to text |
text(boolean) | postgres | convert boolean to text |
text(xml) | postgres | serialize an XML value to a character string |
text_ge(text, text) | postgres | implementation of >= operator |
text_gt(text, text) | postgres | implementation of > operator |
text_larger(text, text) | postgres | larger of two |
text_le(text, text) | postgres | implementation of <= operator |
text_lt(text, text) | postgres | implementation of < operator |
text_pattern_ge(text, text) | postgres | implementation of ~>=~ operator |
text_pattern_gt(text, text) | postgres | implementation of ~>~ operator |
text_pattern_le(text, text) | postgres | implementation of ~<=~ operator |
text_pattern_lt(text, text) | postgres | implementation of ~<~ operator |
text_smaller(text, text) | postgres | smaller of two |
textanycat(text, anynonarray) | postgres | implementation of || operator |
textcat(text, text) | postgres | implementation of || operator |
texteq(text, text) | postgres | implementation of = operator |
texticlike(text, text) | postgres | implementation of ~~* operator |
texticnlike(text, text) | postgres | implementation of !~~* operator |
texticregexeq(text, text) | postgres | implementation of ~* operator |
texticregexne(text, text) | postgres | implementation of !~* operator |
textin(cstring) | postgres | I/O |
textlen(text) | postgres | length |
textlike(text, text) | postgres | implementation of ~~ operator |
textne(text, text) | postgres | implementation of <> operator |
textnlike(text, text) | postgres | implementation of !~~ operator |
textout(text) | postgres | I/O |
textrecv(internal) | postgres | I/O |
textregexeq(text, text) | postgres | implementation of ~ operator |
textregexne(text, text) | postgres | implementation of !~ operator |
textsend(text) | postgres | I/O |
thesaurus_init(internal) | postgres | (internal) |
thesaurus_lexize(internal, internal, internal, internal) | postgres | (internal) |
tideq(tid, tid) | postgres | implementation of = operator |
tidge(tid, tid) | postgres | implementation of >= operator |
tidgt(tid, tid) | postgres | implementation of > operator |
tidin(cstring) | postgres | I/O |
tidlarger(tid, tid) | postgres | larger of two |
tidle(tid, tid) | postgres | implementation of <= operator |
tidlt(tid, tid) | postgres | implementation of < operator |
tidne(tid, tid) | postgres | implementation of <> operator |
tidout(tid) | postgres | I/O |
tidrecv(internal) | postgres | I/O |
tidsend(tid) | postgres | I/O |
tidsmaller(tid, tid) | postgres | smaller of two |
time(time with time zone) | postgres | convert time with time zone to time |
time(time without time zone, integer) | postgres | adjust time precision |
time(interval) | postgres | convert interval to time |
time(abstime) | postgres | convert abstime to time |
time(timestamp without time zone) | postgres | convert timestamp to time |
time(timestamp with time zone) | postgres | convert timestamp with time zone to time |
time_cmp(time without time zone, time without time zone) | postgres | less-equal-greater |
time_eq(time without time zone, time without time zone) | postgres | implementation of = operator |
time_ge(time without time zone, time without time zone) | postgres | implementation of >= operator |
time_gt(time without time zone, time without time zone) | postgres | implementation of > operator |
time_hash(time without time zone) | postgres | hash |
time_in(cstring, oid, integer) | postgres | I/O |
time_larger(time without time zone, time without time zone) | postgres | larger of two |
time_le(time without time zone, time without time zone) | postgres | implementation of <= operator |
time_lt(time without time zone, time without time zone) | postgres | implementation of < operator |
time_mi_interval(time without time zone, interval) | postgres | implementation of - operator |
time_mi_time(time without time zone, time without time zone) | postgres | implementation of - operator |
time_ne(time without time zone, time without time zone) | postgres | implementation of <> operator |
time_out(time without time zone) | postgres | I/O |
time_pl_interval(time without time zone, interval) | postgres | implementation of + operator |
time_recv(internal, oid, integer) | postgres | I/O |
time_send(time without time zone) | postgres | I/O |
time_smaller(time without time zone, time without time zone) | postgres | smaller of two |
time_transform(internal) | postgres | transform a time length coercion |
timedate_pl(time without time zone, date) | postgres | implementation of + operator |
timemi(abstime, reltime) | postgres | implementation of - operator |
timenow() | postgres | current date and time (abstime) |
timeofday() | postgres | current date and time - increments during transactions |
timepl(abstime, reltime) | postgres | implementation of + operator |
timestamp(timestamp without time zone, integer) | postgres | adjust timestamp precision |
timestamp(timestamp with time zone) | postgres | convert timestamp with time zone to timestamp |
timestamp(date) | postgres | convert date to timestamp |
timestamp(date, time without time zone) | postgres | convert date and time to timestamp |
timestamp(abstime) | postgres | convert abstime to timestamp |
timestamp_cmp(timestamp without time zone, timestamp without time zone) | postgres | less-equal-greater |
timestamp_cmp_date(timestamp without time zone, date) | postgres | less-equal-greater |
timestamp_cmp_timestamptz(timestamp without time zone, timestamp with time zone) | postgres | less-equal-greater |
timestamp_eq(timestamp without time zone, timestamp without time zone) | postgres | implementation of = operator |
timestamp_eq_date(timestamp without time zone, date) | postgres | implementation of = operator |
timestamp_eq_timestamptz(timestamp without time zone, timestamp with time zone) | postgres | implementation of = operator |
timestamp_ge(timestamp without time zone, timestamp without time zone) | postgres | implementation of >= operator |
timestamp_ge_date(timestamp without time zone, date) | postgres | implementation of >= operator |
timestamp_ge_timestamptz(timestamp without time zone, timestamp with time zone) | postgres | implementation of >= operator |
timestamp_gt(timestamp without time zone, timestamp without time zone) | postgres | implementation of > operator |
timestamp_gt_date(timestamp without time zone, date) | postgres | implementation of > operator |
timestamp_gt_timestamptz(timestamp without time zone, timestamp with time zone) | postgres | implementation of > operator |
timestamp_hash(timestamp without time zone) | postgres | hash |
timestamp_in(cstring, oid, integer) | postgres | I/O |
timestamp_larger(timestamp without time zone, timestamp without time zone) | postgres | larger of two |
timestamp_le(timestamp without time zone, timestamp without time zone) | postgres | implementation of <= operator |
timestamp_le_date(timestamp without time zone, date) | postgres | implementation of <= operator |
timestamp_le_timestamptz(timestamp without time zone, timestamp with time zone) | postgres | implementation of <= operator |
timestamp_lt(timestamp without time zone, timestamp without time zone) | postgres | implementation of < operator |
timestamp_lt_date(timestamp without time zone, date) | postgres | implementation of < operator |
timestamp_lt_timestamptz(timestamp without time zone, timestamp with time zone) | postgres | implementation of < operator |
timestamp_mi(timestamp without time zone, timestamp without time zone) | postgres | implementation of - operator |
timestamp_mi_interval(timestamp without time zone, interval) | postgres | implementation of - operator |
timestamp_ne(timestamp without time zone, timestamp without time zone) | postgres | implementation of <> operator |
timestamp_ne_date(timestamp without time zone, date) | postgres | implementation of <> operator |
timestamp_ne_timestamptz(timestamp without time zone, timestamp with time zone) | postgres | implementation of <> operator |
timestamp_out(timestamp without time zone) | postgres | I/O |
timestamp_pl_interval(timestamp without time zone, interval) | postgres | implementation of + operator |
timestamp_recv(internal, oid, integer) | postgres | I/O |
timestamp_send(timestamp without time zone) | postgres | I/O |
timestamp_smaller(timestamp without time zone, timestamp without time zone) | postgres | smaller of two |
timestamp_sortsupport(internal) | postgres | sort support |
timestamp_transform(internal) | postgres | transform a timestamp length coercion |
timestamptypmodin(cstring[]) | postgres | I/O typmod |
timestamptypmodout(integer) | postgres | I/O typmod |
timestamptz(abstime) | postgres | convert abstime to timestamp with time zone |
timestamptz(date, time with time zone) | postgres | convert date and time with time zone to timestamp with time zone |
timestamptz(timestamp with time zone, integer) | postgres | adjust timestamptz precision |
timestamptz(date, time without time zone) | postgres | convert date and time to timestamp with time zone |
timestamptz(timestamp without time zone) | postgres | convert timestamp to timestamp with time zone |
timestamptz(date) | postgres | convert date to timestamp with time zone |
timestamptz_cmp(timestamp with time zone, timestamp with time zone) | postgres | less-equal-greater |
timestamptz_cmp_date(timestamp with time zone, date) | postgres | less-equal-greater |
timestamptz_cmp_timestamp(timestamp with time zone, timestamp without time zone) | postgres | less-equal-greater |
timestamptz_eq(timestamp with time zone, timestamp with time zone) | postgres | implementation of = operator |
timestamptz_eq_date(timestamp with time zone, date) | postgres | implementation of = operator |
timestamptz_eq_timestamp(timestamp with time zone, timestamp without time zone) | postgres | implementation of = operator |
timestamptz_ge(timestamp with time zone, timestamp with time zone) | postgres | implementation of >= operator |
timestamptz_ge_date(timestamp with time zone, date) | postgres | implementation of >= operator |
timestamptz_ge_timestamp(timestamp with time zone, timestamp without time zone) | postgres | implementation of >= operator |
timestamptz_gt(timestamp with time zone, timestamp with time zone) | postgres | implementation of > operator |
timestamptz_gt_date(timestamp with time zone, date) | postgres | implementation of > operator |
timestamptz_gt_timestamp(timestamp with time zone, timestamp without time zone) | postgres | implementation of > operator |
timestamptz_in(cstring, oid, integer) | postgres | I/O |
timestamptz_larger(timestamp with time zone, timestamp with time zone) | postgres | larger of two |
timestamptz_le(timestamp with time zone, timestamp with time zone) | postgres | implementation of <= operator |
timestamptz_le_date(timestamp with time zone, date) | postgres | implementation of <= operator |
timestamptz_le_timestamp(timestamp with time zone, timestamp without time zone) | postgres | implementation of <= operator |
timestamptz_lt(timestamp with time zone, timestamp with time zone) | postgres | implementation of < operator |
timestamptz_lt_date(timestamp with time zone, date) | postgres | implementation of < operator |
timestamptz_lt_timestamp(timestamp with time zone, timestamp without time zone) | postgres | implementation of < operator |
timestamptz_mi(timestamp with time zone, timestamp with time zone) | postgres | implementation of - operator |
timestamptz_mi_interval(timestamp with time zone, interval) | postgres | implementation of - operator |
timestamptz_ne(timestamp with time zone, timestamp with time zone) | postgres | implementation of <> operator |
timestamptz_ne_date(timestamp with time zone, date) | postgres | implementation of <> operator |
timestamptz_ne_timestamp(timestamp with time zone, timestamp without time zone) | postgres | implementation of <> operator |
timestamptz_out(timestamp with time zone) | postgres | I/O |
timestamptz_pl_interval(timestamp with time zone, interval) | postgres | implementation of + operator |
timestamptz_recv(internal, oid, integer) | postgres | I/O |
timestamptz_send(timestamp with time zone) | postgres | I/O |
timestamptz_smaller(timestamp with time zone, timestamp with time zone) | postgres | smaller of two |
timestamptztypmodin(cstring[]) | postgres | I/O typmod |
timestamptztypmodout(integer) | postgres | I/O typmod |
timetypmodin(cstring[]) | postgres | I/O typmod |
timetypmodout(integer) | postgres | I/O typmod |
timetz(time with time zone, integer) | postgres | adjust time with time zone precision |
timetz(time without time zone) | postgres | convert time to time with time zone |
timetz(timestamp with time zone) | postgres | convert timestamp with time zone to time with time zone |
timetz_cmp(time with time zone, time with time zone) | postgres | less-equal-greater |
timetz_eq(time with time zone, time with time zone) | postgres | implementation of = operator |
timetz_ge(time with time zone, time with time zone) | postgres | implementation of >= operator |
timetz_gt(time with time zone, time with time zone) | postgres | implementation of > operator |
timetz_hash(time with time zone) | postgres | hash |
timetz_in(cstring, oid, integer) | postgres | I/O |
timetz_larger(time with time zone, time with time zone) | postgres | larger of two |
timetz_le(time with time zone, time with time zone) | postgres | implementation of <= operator |
timetz_lt(time with time zone, time with time zone) | postgres | implementation of < operator |
timetz_mi_interval(time with time zone, interval) | postgres | implementation of - operator |
timetz_ne(time with time zone, time with time zone) | postgres | implementation of <> operator |
timetz_out(time with time zone) | postgres | I/O |
timetz_pl_interval(time with time zone, interval) | postgres | implementation of + operator |
timetz_recv(internal, oid, integer) | postgres | I/O |
timetz_send(time with time zone) | postgres | I/O |
timetz_smaller(time with time zone, time with time zone) | postgres | smaller of two |
timetzdate_pl(time with time zone, date) | postgres | implementation of + operator |
timetztypmodin(cstring[]) | postgres | I/O typmod |
timetztypmodout(integer) | postgres | I/O typmod |
timezone(text, time with time zone) | postgres | adjust time with time zone to new zone |
timezone(interval, timestamp with time zone) | postgres | adjust timestamp to new time zone |
timezone(text, timestamp without time zone) | postgres | adjust timestamp to new time zone |
timezone(text, timestamp with time zone) | postgres | adjust timestamp to new time zone |
timezone(interval, time with time zone) | postgres | adjust time with time zone to new zone |
timezone(interval, timestamp without time zone) | postgres | adjust timestamp to new time zone |
tinterval(abstime, abstime) | postgres | convert to tinterval |
tintervalct(tinterval, tinterval) | postgres | implementation of << operator |
tintervalend(tinterval) | postgres | end of interval |
tintervaleq(tinterval, tinterval) | postgres | implementation of = operator |
tintervalge(tinterval, tinterval) | postgres | implementation of >= operator |
tintervalgt(tinterval, tinterval) | postgres | implementation of > operator |
tintervalin(cstring) | postgres | I/O |
tintervalle(tinterval, tinterval) | postgres | implementation of <= operator |
tintervalleneq(tinterval, reltime) | postgres | implementation of #= operator |
tintervallenge(tinterval, reltime) | postgres | implementation of #>= operator |
tintervallengt(tinterval, reltime) | postgres | implementation of #> operator |
tintervallenle(tinterval, reltime) | postgres | implementation of #<= operator |
tintervallenlt(tinterval, reltime) | postgres | implementation of #< operator |
tintervallenne(tinterval, reltime) | postgres | implementation of #<> operator |
tintervallt(tinterval, tinterval) | postgres | implementation of < operator |
tintervalne(tinterval, tinterval) | postgres | implementation of <> operator |
tintervalout(tinterval) | postgres | I/O |
tintervalov(tinterval, tinterval) | postgres | implementation of && operator |
tintervalrecv(internal) | postgres | I/O |
tintervalrel(tinterval) | postgres | tinterval to reltime |
tintervalsame(tinterval, tinterval) | postgres | implementation of ~= operator |
tintervalsend(tinterval) | postgres | I/O |
tintervalstart(tinterval) | postgres | implementation of | operator |
to_ascii(text) | postgres | encode text from DB encoding to ASCII text |
to_ascii(text, name) | postgres | encode text from encoding to ASCII text |
to_ascii(text, integer) | postgres | encode text from encoding to ASCII text |
to_char(timestamp with time zone, text) | postgres | format timestamp with time zone to text |
to_char(integer, text) | postgres | format int4 to text |
to_char(real, text) | postgres | format float4 to text |
to_char(interval, text) | postgres | format interval to text |
to_char(double precision, text) | postgres | format float8 to text |
to_char(numeric, text) | postgres | format numeric to text |
to_char(bigint, text) | postgres | format int8 to text |
to_char(timestamp without time zone, text) | postgres | format timestamp to text |
to_date(text, text) | postgres | convert text to date |
to_hex(integer) | postgres | convert int4 number to hex |
to_hex(bigint) | postgres | convert int8 number to hex |
to_number(text, text) | postgres | convert text to numeric |
to_timestamp(double precision) | postgres | convert UNIX epoch to timestamptz |
to_timestamp(text, text) | postgres | convert text to timestamp with time zone |
to_tsquery(text) | postgres | make tsquery |
to_tsquery(regconfig, text) | postgres | make tsquery |
to_tsvector(text) | postgres | transform to tsvector |
to_tsvector(regconfig, text) | postgres | transform to tsvector |
transaction_timestamp() | postgres | current transaction time |
translate(text, text, text) | postgres | map a set of characters appearing in string |
trigger_out(trigger) | postgres | I/O |
trunc(macaddr) | postgres | MAC manufacturer fields |
trunc(double precision) | postgres | truncate to integer |
trunc(numeric, integer) | postgres | value truncated to 'scale' |
trunc(numeric) | postgres | value truncated to 'scale' of zero |
ts_debug(regconfig, text) | postgres | debug function for text search configuration |
ts_debug(text) | postgres | debug function for current text search configuration |
ts_headline(text, tsquery, text) | postgres | generate headline |
ts_headline(text, tsquery) | postgres | generate headline |
ts_headline(regconfig, text, tsquery, text) | postgres | generate headline |
ts_headline(regconfig, text, tsquery) | postgres | generate headline |
ts_lexize(regdictionary, text) | postgres | normalize one word by dictionary |
ts_match_qv(tsquery, tsvector) | postgres | implementation of @@ operator |
ts_match_tq(text, tsquery) | postgres | implementation of @@ operator |
ts_match_tt(text, text) | postgres | implementation of @@ operator |
ts_match_vq(tsvector, tsquery) | postgres | implementation of @@ operator |
ts_parse(text, text) | postgres | parse text to tokens |
ts_parse(oid, text) | postgres | parse text to tokens |
ts_rank(real[], tsvector, tsquery) | postgres | relevance |
ts_rank(tsvector, tsquery, integer) | postgres | relevance |
ts_rank(real[], tsvector, tsquery, integer) | postgres | relevance |
ts_rank(tsvector, tsquery) | postgres | relevance |
ts_rank_cd(tsvector, tsquery, integer) | postgres | relevance |
ts_rank_cd(real[], tsvector, tsquery) | postgres | relevance |
ts_rank_cd(tsvector, tsquery) | postgres | relevance |
ts_rank_cd(real[], tsvector, tsquery, integer) | postgres | relevance |
ts_rewrite(tsquery, tsquery, tsquery) | postgres | rewrite tsquery |
ts_rewrite(tsquery, text) | postgres | rewrite tsquery |
ts_stat(text, text) | postgres | statistics of tsvector column |
ts_stat(text) | postgres | statistics of tsvector column |
ts_token_type(oid) | postgres | get parser's token types |
ts_token_type(text) | postgres | get parser's token types |
ts_typanalyze(internal) | postgres | tsvector typanalyze |
tsmatchjoinsel(internal, oid, internal, smallint, internal) | postgres | join selectivity of tsvector @@ tsquery |
tsmatchsel(internal, oid, internal, integer) | postgres | restriction selectivity of tsvector @@ tsquery |
tsq_mcontained(tsquery, tsquery) | postgres | implementation of <@ operator |
tsq_mcontains(tsquery, tsquery) | postgres | implementation of @> operator |
tsquery_and(tsquery, tsquery) | postgres | implementation of && operator |
tsquery_cmp(tsquery, tsquery) | postgres | less-equal-greater |
tsquery_eq(tsquery, tsquery) | postgres | implementation of = operator |
tsquery_ge(tsquery, tsquery) | postgres | implementation of >= operator |
tsquery_gt(tsquery, tsquery) | postgres | implementation of > operator |
tsquery_le(tsquery, tsquery) | postgres | implementation of <= operator |
tsquery_lt(tsquery, tsquery) | postgres | implementation of < operator |
tsquery_ne(tsquery, tsquery) | postgres | implementation of <> operator |
tsquery_not(tsquery) | postgres | implementation of !! operator |
tsquery_or(tsquery, tsquery) | postgres | implementation of || operator |
tsqueryin(cstring) | postgres | I/O |
tsqueryout(tsquery) | postgres | I/O |
tsqueryrecv(internal) | postgres | I/O |
tsquerysend(tsquery) | postgres | I/O |
tsrange(timestamp without time zone, timestamp without time zone, text) | postgres | tsrange constructor |
tsrange(timestamp without time zone, timestamp without time zone) | postgres | tsrange constructor |
tsrange_subdiff(timestamp without time zone, timestamp without time zone) | postgres | float8 difference of two timestamp values |
tstzrange(timestamp with time zone, timestamp with time zone, text) | postgres | tstzrange constructor |
tstzrange(timestamp with time zone, timestamp with time zone) | postgres | tstzrange constructor |
tstzrange_subdiff(timestamp with time zone, timestamp with time zone) | postgres | float8 difference of two timestamp with time zone values |
tsvector_cmp(tsvector, tsvector) | postgres | less-equal-greater |
tsvector_concat(tsvector, tsvector) | postgres | implementation of || operator |
tsvector_eq(tsvector, tsvector) | postgres | implementation of = operator |
tsvector_ge(tsvector, tsvector) | postgres | implementation of >= operator |
tsvector_gt(tsvector, tsvector) | postgres | implementation of > operator |
tsvector_le(tsvector, tsvector) | postgres | implementation of <= operator |
tsvector_lt(tsvector, tsvector) | postgres | implementation of < operator |
tsvector_ne(tsvector, tsvector) | postgres | implementation of <> operator |
tsvectorin(cstring) | postgres | I/O |
tsvectorout(tsvector) | postgres | I/O |
tsvectorrecv(internal) | postgres | I/O |
tsvectorsend(tsvector) | postgres | I/O |
txid_current() | postgres | get current transaction ID |
txid_current_snapshot() | postgres | get current snapshot |
txid_snapshot_in(cstring) | postgres | I/O |
txid_snapshot_out(txid_snapshot) | postgres | I/O |
txid_snapshot_recv(internal) | postgres | I/O |
txid_snapshot_send(txid_snapshot) | postgres | I/O |
txid_snapshot_xip(txid_snapshot) | postgres | get set of in-progress txids in snapshot |
txid_snapshot_xmax(txid_snapshot) | postgres | get xmax of snapshot |
txid_snapshot_xmin(txid_snapshot) | postgres | get xmin of snapshot |
txid_visible_in_snapshot(bigint, txid_snapshot) | postgres | is txid visible in snapshot? |
uhc_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UHC to UTF8 |
unknownin(cstring) | postgres | I/O |
unknownout(unknown) | postgres | I/O |
unknownrecv(internal) | postgres | I/O |
unknownsend(unknown) | postgres | I/O |
unnest(anyarray) | postgres | expand array to set of rows |
upper(text) | postgres | uppercase |
upper(anyrange) | postgres | upper bound of range |
upper_inc(anyrange) | postgres | is the range's upper bound inclusive? |
upper_inf(anyrange) | postgres | is the range's upper bound infinite? |
utf8_to_ascii(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to SQL_ASCII |
utf8_to_big5(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to BIG5 |
utf8_to_euc_cn(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to EUC_CN |
utf8_to_euc_jis_2004(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to EUC_JIS_2004 |
utf8_to_euc_jp(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to EUC_JP |
utf8_to_euc_kr(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to EUC_KR |
utf8_to_euc_tw(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to EUC_TW |
utf8_to_gb18030(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to GB18030 |
utf8_to_gbk(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to GBK |
utf8_to_iso8859(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to ISO-8859-8 |
utf8_to_iso8859_1(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to LATIN1 |
utf8_to_johab(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to JOHAB |
utf8_to_koi8r(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to KOI8R |
utf8_to_koi8u(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to KOI8U |
utf8_to_shift_jis_2004(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to SHIFT_JIS_2004 |
utf8_to_sjis(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to SJIS |
utf8_to_uhc(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to UHC |
utf8_to_win(integer, integer, cstring, internal, integer) | postgres | internal conversion function for UTF8 to WIN1258 |
uuid_cmp(uuid, uuid) | postgres | less-equal-greater |
uuid_eq(uuid, uuid) | postgres | implementation of = operator |
uuid_ge(uuid, uuid) | postgres | implementation of >= operator |
uuid_gt(uuid, uuid) | postgres | implementation of > operator |
uuid_hash(uuid) | postgres | hash |
uuid_in(cstring) | postgres | I/O |
uuid_le(uuid, uuid) | postgres | implementation of <= operator |
uuid_lt(uuid, uuid) | postgres | implementation of < operator |
uuid_ne(uuid, uuid) | postgres | implementation of <> operator |
uuid_out(uuid) | postgres | I/O |
uuid_recv(internal) | postgres | I/O |
uuid_send(uuid) | postgres | I/O |
varbit(bit varying, integer, boolean) | postgres | adjust varbit() to typmod length |
varbit_in(cstring, oid, integer) | postgres | I/O |
varbit_out(bit varying) | postgres | I/O |
varbit_recv(internal, oid, integer) | postgres | I/O |
varbit_send(bit varying) | postgres | I/O |
varbit_transform(internal) | postgres | transform a varbit length coercion |
varbitcmp(bit varying, bit varying) | postgres | less-equal-greater |
varbiteq(bit varying, bit varying) | postgres | implementation of = operator |
varbitge(bit varying, bit varying) | postgres | implementation of >= operator |
varbitgt(bit varying, bit varying) | postgres | implementation of > operator |
varbitle(bit varying, bit varying) | postgres | implementation of <= operator |
varbitlt(bit varying, bit varying) | postgres | implementation of < operator |
varbitne(bit varying, bit varying) | postgres | implementation of <> operator |
varbittypmodin(cstring[]) | postgres | I/O typmod |
varbittypmodout(integer) | postgres | I/O typmod |
varchar(name) | postgres | convert name to varchar |
varchar(character varying, integer, boolean) | postgres | adjust varchar() to typmod length |
varchar_transform(internal) | postgres | transform a varchar length coercion |
varcharin(cstring, oid, integer) | postgres | I/O |
varcharout(character varying) | postgres | I/O |
varcharrecv(internal, oid, integer) | postgres | I/O |
varcharsend(character varying) | postgres | I/O |
varchartypmodin(cstring[]) | postgres | I/O typmod |
varchartypmodout(integer) | postgres | I/O typmod |
version() | postgres | PostgreSQL version string |
void_in(cstring) | postgres | I/O |
void_out(void) | postgres | I/O |
void_recv(internal) | postgres | I/O |
void_send(void) | postgres | I/O |
width(box) | postgres | box width |
width_bucket(double precision, double precision, double precision, integer) | postgres | bucket number of operand in equidepth histogram |
width_bucket(numeric, numeric, numeric, integer) | postgres | bucket number of operand in equidepth histogram |
win1250_to_latin2(integer, integer, cstring, internal, integer) | postgres | internal conversion function for WIN1250 to LATIN2 |
win1250_to_mic(integer, integer, cstring, internal, integer) | postgres | internal conversion function for WIN1250 to MULE_INTERNAL |
win1251_to_iso(integer, integer, cstring, internal, integer) | postgres | internal conversion function for WIN1251 to ISO-8859-5 |
win1251_to_koi8r(integer, integer, cstring, internal, integer) | postgres | internal conversion function for WIN1251 to KOI8R |
win1251_to_mic(integer, integer, cstring, internal, integer) | postgres | internal conversion function for WIN1251 to MULE_INTERNAL |
win1251_to_win866(integer, integer, cstring, internal, integer) | postgres | internal conversion function for WIN1251 to WIN866 |
win866_to_iso(integer, integer, cstring, internal, integer) | postgres | internal conversion function for WIN866 to ISO-8859-5 |
win866_to_koi8r(integer, integer, cstring, internal, integer) | postgres | internal conversion function for WIN866 to KOI8R |
win866_to_mic(integer, integer, cstring, internal, integer) | postgres | internal conversion function for WIN866 to MULE_INTERNAL |
win866_to_win1251(integer, integer, cstring, internal, integer) | postgres | internal conversion function for WIN866 to WIN1251 |
win_to_utf8(integer, integer, cstring, internal, integer) | postgres | internal conversion function for WIN1258 to UTF8 |
xideq(xid, xid) | postgres | implementation of = operator |
xideqint4(xid, integer) | postgres | implementation of = operator |
xidin(cstring) | postgres | I/O |
xidout(xid) | postgres | I/O |
xidrecv(internal) | postgres | I/O |
xidsend(xid) | postgres | I/O |
xml(text) | postgres | perform a non-validating parse of a character string to produce an XML value |
xml_in(cstring) | postgres | I/O |
xml_is_well_formed(text) | postgres | determine if a string is well formed XML |
xml_is_well_formed_content(text) | postgres | determine if a string is well formed XML content |
xml_is_well_formed_document(text) | postgres | determine if a string is well formed XML document |
xml_out(xml) | postgres | I/O |
xml_recv(internal) | postgres | I/O |
xml_send(xml) | postgres | I/O |
xmlcomment(text) | postgres | generate XML comment |
xmlconcat2(xml, xml) | postgres | aggregate transition function |
xmlexists(text, xml) | postgres | test XML value against XPath expression |
xmlvalidate(xml, text) | postgres | validate an XML value |
xpath(text, xml) | postgres | evaluate XPath expression |
xpath(text, xml, text[]) | postgres | evaluate XPath expression, with namespaces support |
xpath_exists(text, xml, text[]) | postgres | test XML value against XPath expression, with namespace support |
xpath_exists(text, xml) | postgres | test XML value against XPath expression |
반응형