---
name: "binary"
section: "7nr"
platform: "linux"
package: "postgres95"
version: "1.01-1"
release: "Debian 1.2 (Rex)"
platforms: ["linux"]
url: "https://new.carta.tech/binary/7nr"
---

# 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