binary(7nr)

Type Operator POSTGRES Function Prototype: Operation

abstime <> bool abstimene(abstime, abstime): inequality

+ abstime timepl(abstime, reltime): addition

− abstime timemi(abstime, reltime): subtraction

<= bool abstimele(abstime, abstime): less or equal

<?> bool ininterval(abstime, tinterval): abstime in tinterval?

< bool abstimelt(abstime, abstime): less than

= bool abstimeeq(abstime, abstime): equality

>= bool abstimege(abstime, abstime): greater or equal

> bool abstimegt(abstime, abstime): greater than

bool = bool booleq(bool, bool): equality

<> bool boolne(bool, bool): inequality

box && bool box_overlap(box, box): boxes overlap

&< bool box_overleft(box, box): box A overlaps box B, but does not extend to right of box B

&> bool box_overright(box, box): box A overlaps box B, but does not extend to left of box B

<< bool box_left(box, box): A is left of B

<= bool box_le(box, box): area less or equal

< bool box_lt(box, box): area less than

= bool box_eq(box, box): area equal

>= bool box_ge(box, box): area greater or equal

>> bool box_right(box, box): A is right of B

> bool box_gt(box, box): area greater than

@ bool box_contained(box, box): A is contained in B

~= bool box_same(box, box): box equality

~ bool box_contain(box, box): A contains B

char <> bool charne(char, char): inequality

* bool charmul(char, char): multiplication

+ bool charpl(char, char): addition

− bool charmi(char, char): subtraction

/ bool chardiv(char, char): division

<= bool charle(char, char): less or equal

< bool charlt(char, char): less than

= bool chareq(char, char): equality

>= bool charge(char, char): greater or equal

> bool chargt(char, char): greater than

char2 <> bool char2ne(char2, char2): inequality

!~ bool char2regexne(char2, text): A does not match regular expression B, case-sensitive

!~* bool char2icregexne(char2, text): A does not match regular expression B, case-insensitive

<= bool char2le(char2, char2): less or equal

< bool char2lt(char2, char2): less than

= bool char2eq(char2, char2): equality

>= bool char2ge(char2, char2): greater or equal

> bool char2gt(char2, char2): greater than

~ bool char2regexeq(char2, text): A matches regular expression B, case-sensitive.

~* bool char2icregexeq(char2, text): A matches regular expression B, case-insensitive.

char4 <> bool char4ne(char4, char4): inequality

!~ bool char4regexne(char4, text): A does not match regular expression B, case-sensitive

!~* bool char4icregexne(char4, text): A does not match regular expression B, case-insensitive

<= bool char4le(char4, char4): less or equal

< bool char4lt(char4, char4): less than

= bool char4eq(char4, char4): equality

>= bool char4ge(char4, char4): greater or equal

> bool char4gt(char4, char4): greater than

~ bool char4regexeq(char4, text): A matches regular expression B, case-sensitive

~* bool char4icregexeq(char4, text): A matches regular expression B, case-insensitive

char8 <> bool char8ne(char8, char8): inequality

!~ bool char8regexne(char8, text): A does not match regular expression B, case sensitive

!~* bool char8icregexne(char8, text): A does not match regular expression B, case insensitive

<= bool char8le(char8, char8): less or equal

< bool char8lt(char8, char8): less than

= bool char8eq(char8, char8): equality

>= bool char8ge(char8, char8): greater or equal

> bool char8gt(char8, char8): greater than

~ bool char8regexeq(char8, text): A matches regular expression B, case sensitive

~* bool char8icregexeq(char8, text): A matches regular expression B, case insensitive

char16 <> bool char16ne(char16, char16): inequality

!~ bool char16regexne(char16, text): A does not match regular expression B, case sensitive

!~* bool char16icregexne(char16, text): A does not match regular expression B, case insensitive

<= bool char16le(char16, char16): less or equal

< bool char16lt(char16, char16): less than

= bool char16eq(char16, char16): equality

>= bool char16ge(char16, char16): greater or equal

> bool char16gt(char16, char16): greater than

~ bool char16regexeq(char16, text): A matches regular expression B, case sensitive

~* bool char16regexeq(char16, text): A matches regular expression B, case insensitive

float4 <> bool float4ne(float4, float4): inequality

* float4 float4mul(float4, float4): multiplication

+ float4 float4pl(float4, float4): addition

− float4 float4mi(float4, float4): subtraction

/ float4 float4div(float4, float4): division

<= bool float4le(float4, float4): less or equal

< bool float4lt(float4, float4): less than

= bool float4eq(float4, float4): equality

>= bool float4ge(float4, float4): greater or equal

> bool float4gt(float4, float4): greater than

float8 <> bool float8ne(float8, float8): inequality

* float8 float8mul(float8, float8): multiplication

+ float8 float8pl(float8, float8): addition

− float8 float8mi(float8, float8): subtraction

/ float8 float8div(float8, float8): division

<= bool float8le(float8, float8): less or equal

< bool float8lt(float8, float8): less than1

= bool float8eq(float8, float8): equality

>= bool float8ge(float8, float8): greater or equal

> bool float8gt(float8, float8): greater than

^ float8 dpow(float8, float8): exponentiation

int2 <> bool int2ne(int2, int2): inequality

<> int4 int24ne(int2, int4): inequality

% int2 int2mod(int2, int2): modulus

% int4 int24mod(int2, int4): modulus

* int2 int2mul(int2, int2): multiplication

* int4 int24mul(int2, int4): multiplication

+ int2 int2pl(int2, int2): addition

+ int4 int24pl(int2, int4): addition

− int2 int2mi(int2, int2): subtraction

− int4 int24mi(int2, int4): subtraction

/ int2 int2div(int2, int2): division

/ int4 int24div(int2, int4): division

<= bool int2le(int2, int2): less or equal

<= bool int24le(int2, int4): less or equal

< bool int2lt(int2, int2): less than

< bool int24lt(int2, int4): less than

= bool int2eq(int2, int2): equality

= bool int24eq(int2, int4): equality

>= bool int2ge(int2, int2): greater or equal

>= bool int24ge(int2, int4): greater or equal

> bool int2gt(int2, int2): greater than

> bool int24gt(int2, int4): greater than

int4 <> bool int4ne(int4, int4): inequality

<> bool int42ne(int4, int2): inequality

% int4 int42mod(int4, int2): modulus

% int4 int4mod(int4, int4): modulus

* int4 int42mul(int4, int2): multiplication

* int4 int4mul(int4, int4): multiplication

+ int4 int42pl(int4, int2): addition

+ int4 int4pl(int4, int4): addition

− int4 int42mi(int4, int2): subtraction

− int4 int4mi(int4, int4): subtraction

/ int4 int42div(int4, int2): division

/ int4 int4div(int4, int4): division

<= bool int4le(int4, int4): less or equal

<= bool int42le(int4, int2): less or equal

< bool int4lt(int4, int4): less than

< bool int42lt(int4, int2): less than

= bool int4eq(int4, int4): equality

= bool int42eq(int4, int2): equality

= bool int4eqoid(int4, oid): equality

>= bool int4ge(int4, int4): greater or equal

>= bool int42ge(int4, int2): greater or equal

> bool int4gt(int4, int4): greater than

> bool int42lt(int4, int2): less than

name <> bool namene(name, name): inequality

!~ bool nameregexne(name, text): A does not match regular expression B, case sensitive

!~* bool nameicregexne(name, text): A does not match regular expression B, case insensitive

<= bool namele(name, name): less or equal

< bool namelt(name, name): less than

= bool nameeq(name, name): equality

>= bool namege(name, name): greater or equal

> bool namegt(name, name): greater than

~ bool nameregexeq(name, text): A matches regular expression B, case sensitive

~* bool nameregexeq(name, text): A matches regular expression B, case insensitive

oid <> bool oidne(oid, oid): inequality

<> bool oidne(oid, regproc): inequality

<= bool oidle(oid, oid): less or equal

< bool oidlt(oid, oid): less than

= bool oideq(oid, oid): equality

= bool oideqint4(oid, int4): equality

= bool oideq(oid, regproc): equality

>= bool oidge(oid, oid): greater or equal

> bool oidgt(oid, oid): greater than

oidname <> bool oidnamene(oidname, oidname): inequality

< bool oidnamelt(oidname, oidname): less than

<= bool oidnamele(oidname, oidname): less or equal

= bool oidnameeq(oidname, oidname): equality

> bool oidnamegt(oidname, oidname): greater than

>= bool oidnamege(oidname, oidname): greater or equal

oidint2 <> bool oidint2ne(oidint2, oidint2): inequality

< bool oidint2lt(oidint2, oidint2): less than

<= bool oidint2le(oidint2, oidint2): less or equal

= bool oidint2eq(oidint2, oidint2): equality

> bool oidint2gt(oidint2, oidint2): greater than

>= bool oidint2ge(oidint2, oidint2): greater or equal

oidint4 <> bool oidint4ne(oidint4, oidint4): inequality

< bool oidint4lt(oidint4, oidint4): less than

<= bool oidint4le(oidint4, oidint4): less or equal

= bool oidint4eq(oidint4, oidint4): equality

> bool oidint4gt(oidint4, oidint4): greater than

>= bool oidint4ge(oidint4, oidint4): greater or equal

point !< bool point_left(point, point): A is left of B

!> bool point_right(point, point): A is right of B

!^ bool point_above(point, point): A is above B

!| bool point_below(point, point): A is below B

=|= bool point_eq(point, point): equality

===> bool on_pb(point, box): point inside box

===` bool on_ppath(point, path): point on path

<===> int4 pointdist(point, point): distance between points

polygon && bool poly_overlap(polygon, polygon): polygons overlap

&< bool poly_overleft(polygon, polygon): A overlaps B but does not extend to right of B

&> bool poly_overright(polygon, polygon): A overlaps B but does not extend to left of B

<< bool poly_left(polygon, polygon): A is left of B

>> bool poly_right(polygon, polygon): A is right of B

@ bool poly_contained(polygon, polygon): A is contained by B

~= bool poly_same(polygon, polygon): equality

~ bool poly_contain(polygon, polygon): A contains B

reltime <> bool reltimene(reltime, reltime): inequality

<= bool reltimele(reltime, reltime): less or equal

< bool reltimelt(reltime, reltime): less than

= bool reltimeeq(reltime, reltime): equality

>= bool reltimege(reltime, reltime): greater or equal

> bool reltimegt(reltime, reltime): greater than

text <> bool textne(text, text): inequality

!~ bool textregexne(text, text): A does not contain the regular expression B, case sensitive

!~* bool texticregexne(text, text): A does not contain the regular expression B, case insensitive

<= bool text_le(text, text): less or equal

< bool text_lt(text, text): less than

= bool texteq(text, text): equality

>= bool text_ge(text, text): greater or equal

> bool text_gt(text, text): greater than

~ bool textregexeq(text, text): A contains the regular expression B. case sensitive

~* bool texticregexeq(text, text): A contains the regular expression B. case insensitive

tinterval #<> bool intervallenne(tinterval, reltime): interval length not equal to reltime.

#<= bool intervallenle(tinterval, reltime): interval length less or equal reltime

#< bool intervallenlt(tinterval, reltime): interval length less than reltime

#= bool intervalleneq(tinterval, reltime): interval length equal to reltime

#>= bool intervallenge(tinterval, reltime): interval length greater or equal reltime

#> bool intervallengt(tinterval, reltime): interval length greater than reltime

&& bool intervalov(tinterval, tinterval): intervals overlap

<< bool intervalct(tinterval, tinterval): A contains B

= bool intervaleq(tinterval, tinterval): equality

<> tinterval mktinterval(abstime, abstime): interval bounded by two abstimes