head	1.6;
access;
symbols;
locks; strict;
comment	@# @;


1.6
date	93.12.22.21.16.30;	author jolly;	state Exp;
branches;
next	1.5;

1.5
date	93.10.07.21.50.12;	author marcel;	state Exp;
branches;
next	1.4;

1.4
date	93.07.27.23.28.21;	author avi;	state Exp;
branches;
next	1.3;

1.3
date	93.02.19.00.44.39;	author aoki;	state Exp;
branches;
next	1.2;

1.2
date	93.02.19.00.32.21;	author aoki;	state Exp;
branches;
next	1.1;

1.1
date	93.01.26.02.43.13;	author aoki;	state Exp;
branches;
next	;


desc
@binary operator table
@


1.6
log
@fixed typo in intervalleneq description
@
text
@.\" This is -*-nroff-*-
.TS
center expand;
l l c l
c l l lw(2i).
\fBType\fP	\fBOperator\fP	\fBPOSTGRES Function Prototype\fP	\fBOperation\fP
_
abstime	!\(eq	bool abstimene(abstime, abstime)	inequality
	+	abstime timepl(abstime, reltime)	addition
	\(mi	abstime timemi(abstime, reltime)	subtraction
	<\(eq	bool abstimele(abstime, abstime)	less or equal
	<?>	bool ininterval(abstime, tinterval)	abstime in tinterval?
	<	bool abstimelt(abstime, abstime)	less than
	\(eq	bool abstimeeq(abstime, abstime)	equality
	>\(eq	bool abstimege(abstime, abstime)	greater or equal
	>	bool abstimegt(abstime, abstime)	greater than
_
bool	\(eq	bool booleq(bool, bool)	equality
	!\(eq	bool boolne(bool, bool)	inequality
_
box	&&	bool box_overlap(box, box)	boxes overlap
	&<	bool box_overleft(box, box)	T{
box A overlaps box B,
but does not extend to right
of box B
T}
	&>	bool box_overright(box, box)	T{
box A overlaps box B,
but does not extend to left
of box B
T}
	<<	bool box_left(box, box)	A is left of B
	<\(eq	bool box_le(box, box)	area less or equal
	<	bool box_lt(box, box)	area less than
	\(eq	bool box_eq(box, box)	area equal
	>\(eq	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
	~\(eq	bool box_same(box, box)	box equality
	~	bool box_contain(box, box)	A contains B
_
char	!\(eq	bool charne(char, char)	inequality
	*	bool charmul(char, char)	multiplication
	+	bool charpl(char, char)	addition
	\(mi	bool charmi(char, char)	subtraction
	/	bool chardiv(char, char)	division
	<\(eq	bool charle(char, char)	less or equal
	<	bool charlt(char, char)	less than
	\(eq	bool chareq(char, char)	equality
	>\(eq	bool charge(char, char)	greater or equal
	>	bool chargt(char, char)	greater than
_
char2	!\(eq	bool char2ne(char2, char2)	inequality
	!~	bool char2regexne(char2, text)	T{
A does not match regular expression B
(\*(PG uses the libc regexp calls for this
operation)
T}
	<\(eq	bool char2le(char2, char2)	less or equal
	<	bool char2lt(char2, char2)	less than
	\(eq	bool char2eq(char2, char2)	equality
	>\(eq	bool char2ge(char2, char2)	greater or equal
	>	bool char2gt(char2, char2)	greater than
	~	bool char2regexeq(char2, text)	T{
A matches regular expression B
(\*(PG uses the libc regexp calls for this
operation)
T}
_
char4	!\(eq	bool char4ne(char4, char4)	inequality
	!~	bool char4regexne(char4, text)	T{
A does not match regular expression B
(\*(PG uses the libc regexp calls for this
operation)
T}
	<\(eq	bool char4le(char4, char4)	less or equal
	<	bool char4lt(char4, char4)	less than
	\(eq	bool char4eq(char4, char4)	equality
	>\(eq	bool char4ge(char4, char4)	greater or equal
	>	bool char4gt(char4, char4)	greater than
	~	bool char4regexeq(char4, text)	T{
A matches regular expression B
(\*(PG uses the libc regexp calls for this
operation)
T}
_
char8	!\(eq	bool char8ne(char8, char8)	inequality
	!~	bool char8regexne(char8, text)	T{
A does not match regular expression B
(\*(PG uses the libc regexp calls for this
operation)
T}
	<\(eq	bool char8le(char8, char8)	less or equal
	<	bool char8lt(char8, char8)	less than
	\(eq	bool char8eq(char8, char8)	equality
	>\(eq	bool char8ge(char8, char8)	greater or equal
	>	bool char8gt(char8, char8)	greater than
	~	bool char8regexeq(char8, text)	T{
A matches regular expression B
(\*(PG uses the libc regexp calls for this
operation)
T}
_
char16	!\(eq	bool char16ne(char16, char16)	inequality
	!~	bool char16regexne(char16, text)	T{
A does not match regular expression B
(\*(PG uses the libc regexp calls for this
operation)
T}
	<\(eq	bool char16le(char16, char16)	less or equal
	<	bool char16lt(char16, char16)	less than
	\(eq	bool char16eq(char16, char16)	equality
	>\(eq	bool char16ge(char16, char16)	greater or equal
	>	bool char16gt(char16, char16)	greater than
	~	bool char16regexeq(char16, text)	T{
A matches regular expression B
(\*(PG uses the libc regexp calls for this
operation)
T}
_
float4	!\(eq	bool float4ne(float4, float4)	inequality
	*	float4 float4mul(float4, float4)	multiplication
	+	float4 float4pl(float4, float4)	addition
	\(mi	float4 float4mi(float4, float4)	subtraction
	/	float4 float4div(float4, float4)	division
	<\(eq	bool float4le(float4, float4)	less or equal
	<	bool float4lt(float4, float4)	less than
	\(eq	bool float4eq(float4, float4)	equality
	>\(eq	bool float4ge(float4, float4)	greater or equal
	>	bool float4gt(float4, float4)	greater than
_
float8	!\(eq	bool float8ne(float8, float8)	inequality
	*	float8 float8mul(float8, float8)	multiplication
	+	float8 float8pl(float8, float8)	addition
	\(mi	float8 float8mi(float8, float8)	subtraction
	/	float8 float8div(float8, float8)	division
	<\(eq	bool float8le(float8, float8)	less or equal
	<	bool float8lt(float8, float8)	less than1
	\(eq	bool float8eq(float8, float8)	equality
	>\(eq	bool float8ge(float8, float8)	greater or equal
	>	bool float8gt(float8, float8)	greater than
	^	float8 dpow(float8, float8)	exponentiation
_
int2	!\(eq	bool int2ne(int2, int2)	inequality
	!\(eq	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
	\(mi	int2 int2mi(int2, int2)	subtraction
	\(mi	int4 int24mi(int2, int4)	subtraction
	/	int2 int2div(int2, int2)	division
	/	int4 int24div(int2, int4)	division
	<\(eq	bool int2le(int2, int2)	less or equal
	<\(eq	int4 int24le(int2, int4)	less or equal
	<	bool int2lt(int2, int2)	less than
	<	int4 int24lt(int2, int4)	less than
	\(eq	bool int2eq(int2, int2)	equality
	\(eq	int4 int24eq(int2, int4)	equality
	>\(eq	bool int2ge(int2, int2)	greater or equal
	>\(eq	int4 int24ge(int2, int4)	greater or equal
	>	bool int2gt(int2, int2)	greater than
	>	int4 int24gt(int2, int4)	greater than
		int2 int2inc(int2)	increment
_
int4	!!\(eq	bool int4notin(int4, char16)	T{
This is the relational ``not in'' operator,
and is not intended for public use.
T}
	!\(eq	bool int4ne(int4, int4)	inequality
	!\(eq	int4 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
	\(mi	int4 int42mi(int4, int2)	subtraction
	\(mi	int4 int4mi(int4, int4)	subtraction
	/	int4 int42div(int4, int2)	division
	/	int4 int4div(int4, int4)	division
	<\(eq	bool int4le(int4, int4)	less or equal
	<\(eq	int4 int42le(int4, int2)	less or equal
	<	bool int4lt(int4, int4)	less than
	<	int4 int42lt(int4, int2)	less than
	\(eq	bool int4eq(int4, int4)	equality
	\(eq	int4 int42eq(int4, int2)	equality
	>\(eq	bool int4ge(int4, int4)	greater or equal
	>\(eq	int4 int42ge(int4, int2)	greater or equal
	>	bool int4gt(int4, int4)	greater than
	>	int4 int42lt(int4, int2)	less than
		int4 int4inc(int4)	increment
_
oid	!!\(eq	bool oidnotin(oid, char16)	T{
This is the relational ``not in'' operator,
and is not intended for public use.
T}
	!\(eq	bool oidne(oid, oid)	inequality
	!\(eq	bool oidne(oid, regproc)	inequality
	<\(eq	bool oidle(oid, oid)	less or equal
	<	bool oidlt(oid, oid)	less than
	\(eq	bool oideq(oid, oid)	equality
	\(eq	bool oideq(oid, regproc)	equality
	>\(eq	bool oidge(oid, oid)	greater or equal
	>	bool oidgt(oid, oid)	greater than
_
oidchar16	!\(eq	bool oidchar16ne(oidchar16, oidchar16)	inequality
	<	bool oidchar16lt(oidchar16, oidchar16)	less than
	<\(eq	bool oidchar16le(oidchar16, oidchar16)	less or equal
	\(eq	bool oidchar16eq(oidchar16, oidchar16)	equality
	>	bool oidchar16gt(oidchar16, oidchar16)	greater than
	>\(eq	bool oidchar16ge(oidchar16, oidchar16)	greater or equal
_
oidint2	!\(eq	bool oidint2ne(oidint2, oidint2)	inequality
	<	bool oidint2lt(oidint2, oidint2)	less than
	<\(eq	bool oidint2le(oidint2, oidint2)	less or equal
	\(eq	bool oidint2eq(oidint2, oidint2)	equality
	>	bool oidint2gt(oidint2, oidint2)	greater than
	>\(eq	bool oidint2ge(oidint2, oidint2)	greater or equal
_
oidint4	!\(eq	bool oidint4ne(oidint4, oidint4)	inequality
	<	bool oidint4lt(oidint4, oidint4)	less than
	<\(eq	bool oidint4le(oidint4, oidint4)	less or equal
	\(eq	bool oidint4eq(oidint4, oidint4)	equality
	>	bool oidint4gt(oidint4, oidint4)	greater than
	>\(eq	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
	\(eq|\(eq	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)	T{
A overlaps B but does not extend to
right of B
T}
	&>	bool poly_overright(polygon, polygon)	T{
A overlaps B but does not extend to
left of B
T}
	<<	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
	~\(eq	bool poly_same(polygon, polygon)	equality
	~	bool poly_contain(polygon, polygon)	A contains B
_
reltime	!\(eq	bool reltimene(reltime, reltime)	inequality
	<\(eq	bool reltimele(reltime, reltime)	less or equal
	<	bool reltimelt(reltime, reltime)	less than
	\(eq	bool reltimeeq(reltime, reltime)	equality
	>\(eq	bool reltimege(reltime, reltime)	greater or equal
	>	bool reltimegt(reltime, reltime)	greater than
_
text	!\(eq	bool textne(text, text)	inequality
	!~	bool textregexne(text, text)	T{
A does not contain the regular expression B.
\*(PG uses the libc regexp interface for this
operator.
T}
	<\(eq	bool text_le(text, text)	less or equal
	<	bool text_lt(text, text)	less than
	\(eq	bool texteq(text, text)	equality
	>\(eq	bool text_ge(text, text)	greater or equal
	>	bool text_gt(text, text)	greater than
	~	bool textregexeq(text, text)	T{
A contains the regular expression B.
\*(PG uses the libc regexp interface for this
operator.
T}
_
tinterval	#!\(eq	bool intervallenne(tinterval, reltime)	T{
interval length not equal to reltime.
T}
	#<\(eq	bool intervallenle(tinterval, reltime)	T{
interval length less or equal reltime
T}
	#<	bool intervallenlt(tinterval, reltime)	T{
interval length less than reltime
T}
	#\(eq	bool intervalleneq(tinterval, reltime)	T{
interval length equal to reltime
T}
	#>\(eq	bool intervallenge(tinterval, reltime)	T{
interval length greater or equal reltime
T}
	#>	bool intervallengt(tinterval, reltime)	T{
interval length greater than reltime
T}
	&&	bool intervalov(tinterval, tinterval)	intervals overlap
	<<	bool intervalct(tinterval, tinterval)	A contains B
	\(eq	bool intervaleq(tinterval, tinterval)	equality
	<>	tinterval mktinterval(abstime, abstime)	T{
interval bounded by two abstimes
T}
.TE
@


1.5
log
@added operators for char2, -4, -8
@
text
@d289 1
a289 1
interval length not equal to reltime
@


1.4
log
@mktinterval <> operator, and oidint2 operators
@
text
@d54 51
d106 1
a106 1
	!~	bool char16regexne(char16, char16)	T{
d116 1
a116 1
	~	bool char16regexeq(char16, char16)	T{
@


1.3
log
@added oid composition functions
@
text
@d166 7
d249 3
@


1.2
log
@updated oid* composed types to reflect reality
@
text
@d159 6
a164 6
oidchar16	!\(eq	bool	oidchar16ne(oidchar16, oidchar16)	inequality
	<	bool	oidchar16lt(oidchar16, oidchar16)	less than
	<\(eq	bool	oidchar16le(oidchar16, oidchar16)	less or equal
	\(eq	bool	oidchar16eq(oidchar16, oidchar16)	equality
	>	bool	oidchar16gt(oidchar16, oidchar16)	greater than
	>\(eq	bool	oidchar16ge(oidchar16, oidchar16)	greater or equal
d166 6
a171 6
oidint4	!\(eq	bool	oidint4ne(oidint4, oidint4)	inequality
	<	bool	oidint4lt(oidint4, oidint4)	less than
	<\(eq	bool	oidint4le(oidint4, oidint4)	less or equal
	\(eq	bool	oidint4eq(oidint4, oidint4)	equality
	>	bool	oidint4gt(oidint4, oidint4)	greater than
	>\(eq	bool	oidint4ge(oidint4, oidint4)	greater or equal
@


1.1
log
@Initial revision
@
text
@d19 1
d43 11
a70 11
char	!\(eq	bool charne(char, char)	inequality
	*	bool charmul(char, char)	multiplication
	+	bool charpl(char, char)	addition
	\(mi	bool charmi(char, char)	subtraction
	/	bool chardiv(char, char)	division
	<\(eq	bool charle(char, char)	less or equal
	<	bool charlt(char, char)	less than
	\(eq	bool chareq(char, char)	equality
	>\(eq	bool charge(char, char)	greater or equal
	>	bool chargt(char, char)	greater than
_
d150 4
a153 4
	!\(eq	bool oidneq(oid, oid)	inequality
	!\(eq	bool oidneq(oid, regproc)	inequality
	<\(eq	bool int4le(oid, oid)	less or equal
	<	bool int4lt(oid, oid)	less than
d156 16
a171 2
	>\(eq	bool int4ge(oid, oid)	greater or equal
	>	bool int4gt(oid, oid)	greater than
a195 3
_
regproc	!\(eq	bool oidneq(regproc, oid)	inequality
	\(eq	bool oideq(regproc, oid)	equality
@