/********************************************************************************************
-- 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 |