2001-01-12 08:16:26 +08:00
|
|
|
--
|
|
|
|
-- first, define the datatype. Turn off echoing so that expected file
|
2003-07-25 01:52:50 +08:00
|
|
|
-- does not depend on contents of _int.sql.
|
2001-01-12 08:16:26 +08:00
|
|
|
--
|
|
|
|
\set ECHO none
|
2003-08-01 10:38:09 +08:00
|
|
|
psql:_int.sql:13: NOTICE: type "query_int" is not yet defined
|
2003-07-25 01:52:50 +08:00
|
|
|
DETAIL: Creating a shell type definition.
|
|
|
|
psql:_int.sql:18: NOTICE: argument type query_int is only a shell
|
2003-08-01 10:38:09 +08:00
|
|
|
psql:_int.sql:367: NOTICE: type "intbig_gkey" is not yet defined
|
2003-07-25 01:52:50 +08:00
|
|
|
DETAIL: Creating a shell type definition.
|
|
|
|
psql:_int.sql:372: NOTICE: argument type intbig_gkey is only a shell
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT intset(1234);
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
intset
|
|
|
|
--------
|
|
|
|
{1234}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT icount('{1234234,234234}');
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
icount
|
|
|
|
--------
|
|
|
|
2
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT sort('{1234234,-30,234234}');
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
sort
|
|
|
|
----------------------
|
|
|
|
{-30,234234,1234234}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT sort('{1234234,-30,234234}','asc');
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
sort
|
|
|
|
----------------------
|
|
|
|
{-30,234234,1234234}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT sort('{1234234,-30,234234}','desc');
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
sort
|
|
|
|
----------------------
|
|
|
|
{1234234,234234,-30}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT sort_asc('{1234234,-30,234234}');
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
sort_asc
|
|
|
|
----------------------
|
|
|
|
{-30,234234,1234234}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT sort_desc('{1234234,-30,234234}');
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
sort_desc
|
|
|
|
----------------------
|
|
|
|
{1234234,234234,-30}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT uniq('{1234234,-30,-30,234234,-30}');
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
uniq
|
|
|
|
--------------------------
|
|
|
|
{1234234,-30,234234,-30}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT uniq(sort_asc('{1234234,-30,-30,234234,-30}'));
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
uniq
|
|
|
|
----------------------
|
|
|
|
{-30,234234,1234234}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT idx('{1234234,-30,-30,234234,-30}',-30);
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
idx
|
|
|
|
-----
|
|
|
|
2
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT subarray('{1234234,-30,-30,234234,-30}',2,3);
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
subarray
|
|
|
|
------------------
|
|
|
|
{-30,-30,234234}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT subarray('{1234234,-30,-30,234234,-30}',-1,1);
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
subarray
|
|
|
|
----------
|
|
|
|
{-30}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT subarray('{1234234,-30,-30,234234,-30}',0,-1);
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
subarray
|
|
|
|
--------------------------
|
|
|
|
{1234234,-30,-30,234234}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT #'{1234234,234234}'::int[];
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
2
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '{123,623,445}'::int[] + 1245;
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
?column?
|
|
|
|
--------------------
|
|
|
|
{123,623,445,1245}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '{123,623,445}'::int[] + 445;
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
?column?
|
|
|
|
-------------------
|
|
|
|
{123,623,445,445}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '{123,623,445}'::int[] + '{1245,87,445}';
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
?column?
|
|
|
|
---------------------------
|
|
|
|
{123,623,445,1245,87,445}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '{123,623,445}'::int[] - 623;
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
?column?
|
|
|
|
-----------
|
|
|
|
{123,445}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '{123,623,445}'::int[] - '{1623,623}';
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
?column?
|
|
|
|
-----------
|
|
|
|
{123,445}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '{123,623,445}'::int[] | 623;
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
?column?
|
|
|
|
---------------
|
|
|
|
{123,445,623}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '{123,623,445}'::int[] | 1623;
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
?column?
|
|
|
|
--------------------
|
|
|
|
{123,445,623,1623}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '{123,623,445}'::int[] | '{1623,623}';
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
?column?
|
|
|
|
--------------------
|
|
|
|
{123,445,623,1623}
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '{123,623,445}'::int[] & '{1623,623}';
|
August 6, 2002
1. Reworked patch from Andrey Oktyabrski (ano@spider.ru) with
functions: icount, sort, sort_asc, uniq, idx, subarray
operations: #, +, -, |, &
FUNCTIONS:
int icount(int[]) - the number of elements in intarray
int[] sort(int[], 'asc' | 'desc') - sort intarray
int[] sort(int[]) - sort in ascending order
int[] sort_asc(int[]),sort_desc(int[]) - shortcuts for sort
int[] uniq(int[]) - returns unique elements
int idx(int[], int item) - returns index of first intarray matching element
to item, or '0' if matching failed.
int[] subarray(int[],int START [, int LEN]) - returns part of intarray
starting from element number START (from 1)
and length LEN.
OPERATIONS:
int[] && int[] - overlap - returns TRUE if arrays has at least one common elements.
int[] @ int[] - contains - returns TRUE if left array contains right array
int[] ~ int[] - contained - returns TRUE if left array is contained in right array
# int[] - return the number of elements in array
int[] + int - push element to array ( add to end of array)
int[] + int[] - merge of arrays (right array added to the end of left one)
int[] - int - remove entries matched by right argument from array
int[] - int[] - remove left array from right
int[] | int - returns intarray - union of arguments
int[] | int[] - returns intarray as a union of two arrays
int[] & int[] - returns intersection of arrays
Oleg Bartunov
2002-08-11 04:38:29 +08:00
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
{623}
|
|
|
|
(1 row)
|
|
|
|
|
2001-09-23 12:16:16 +08:00
|
|
|
--test query_int
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT ' 1'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1 '::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT ' 1 '::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT ' ! 1 '::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
!1
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '!1'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
!1
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1|2'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
1 | 2
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1|!2'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
1 | !2
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '!1|2'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
!1 | 2
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '!1|!2'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
!1 | !2
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '!(!1|!2)'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
--------------
|
|
|
|
!( !1 | !2 )
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '!(!1|2)'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
-------------
|
|
|
|
!( !1 | 2 )
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '!(1|!2)'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
-------------
|
|
|
|
!( 1 | !2 )
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '!(1|2)'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
------------
|
|
|
|
!( 1 | 2 )
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1&2'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
1 & 2
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '!1&2'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
!1 & 2
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1&!2'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
1 & !2
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '!1&!2'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
!1 & !2
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '(1&2)'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
1 & 2
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1&(2)'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
1 & 2
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '!(1)&2'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
|
|
|
-----------
|
2001-09-23 12:16:16 +08:00
|
|
|
!1 & 2
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '!(1&2)'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
------------
|
|
|
|
!( 1 & 2 )
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1|2&3'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
-----------
|
|
|
|
1 | 2 & 3
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1|(2&3)'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
-----------
|
|
|
|
1 | 2 & 3
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '(1|2)&3'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
---------------
|
|
|
|
( 1 | 2 ) & 3
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1|2&!3'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
------------
|
|
|
|
1 | 2 & !3
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1|!2&3'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
------------
|
|
|
|
1 | !2 & 3
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '!1|2&3'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
------------
|
|
|
|
!1 | 2 & 3
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '!1|(2&3)'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
------------
|
|
|
|
!1 | 2 & 3
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '!(1|2)&3'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
----------------
|
|
|
|
!( 1 | 2 ) & 3
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '(!1|2)&3'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
----------------
|
|
|
|
( !1 | 2 ) & 3
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1|(2|(4|(5|6)))'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
-------------------------------
|
|
|
|
1 | ( 2 | ( 4 | ( 5 | 6 ) ) )
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1|2|4|5|6'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
-------------------------------
|
|
|
|
( ( ( 1 | 2 ) | 4 ) | 5 ) | 6
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1&(2&(4&(5&6)))'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
-------------------
|
|
|
|
1 & 2 & 4 & 5 & 6
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1&2&4&5&6'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
-------------------
|
|
|
|
1 & 2 & 4 & 5 & 6
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1&(2&(4&(5|6)))'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
-----------------------
|
|
|
|
1 & 2 & 4 & ( 5 | 6 )
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
SELECT '1&(2&(4&(5|!6)))'::query_int;
|
2001-10-01 00:15:59 +08:00
|
|
|
query_int
|
2001-09-23 12:16:16 +08:00
|
|
|
------------------------
|
|
|
|
1 & 2 & 4 & ( 5 | !6 )
|
|
|
|
(1 row)
|
|
|
|
|
2001-01-12 08:16:26 +08:00
|
|
|
CREATE TABLE test__int( a int[] );
|
|
|
|
\copy test__int from 'data/test__int.data'
|
|
|
|
SELECT count(*) from test__int WHERE a && '{23,50}';
|
|
|
|
count
|
|
|
|
-------
|
2001-03-20 11:08:12 +08:00
|
|
|
403
|
2001-01-12 08:16:26 +08:00
|
|
|
(1 row)
|
|
|
|
|
2001-09-23 12:16:16 +08:00
|
|
|
SELECT count(*) from test__int WHERE a @@ '23|50';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
403
|
|
|
|
(1 row)
|
|
|
|
|
2001-01-12 08:16:26 +08:00
|
|
|
SELECT count(*) from test__int WHERE a @ '{23,50}';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
12
|
|
|
|
(1 row)
|
|
|
|
|
2001-09-23 12:16:16 +08:00
|
|
|
SELECT count(*) from test__int WHERE a @@ '23&50';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
12
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT count(*) from test__int WHERE a @ '{20,23}';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
12
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT count(*) from test__int WHERE a @@ '50&68';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
9
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT count(*) from test__int WHERE a @ '{20,23}' or a @ '{50,68}';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
21
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT count(*) from test__int WHERE a @@ '(20&23)|(50&68)';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
21
|
|
|
|
(1 row)
|
|
|
|
|
2001-08-22 00:36:06 +08:00
|
|
|
CREATE INDEX text_idx on test__int using gist ( a gist__int_ops );
|
2001-03-18 05:59:42 +08:00
|
|
|
SELECT count(*) from test__int WHERE a && '{23,50}';
|
|
|
|
count
|
|
|
|
-------
|
2001-03-20 11:08:12 +08:00
|
|
|
403
|
2001-03-18 05:59:42 +08:00
|
|
|
(1 row)
|
|
|
|
|
2001-09-23 12:16:16 +08:00
|
|
|
SELECT count(*) from test__int WHERE a @@ '23|50';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
403
|
|
|
|
(1 row)
|
|
|
|
|
2001-03-18 05:59:42 +08:00
|
|
|
SELECT count(*) from test__int WHERE a @ '{23,50}';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
12
|
|
|
|
(1 row)
|
|
|
|
|
2001-09-23 12:16:16 +08:00
|
|
|
SELECT count(*) from test__int WHERE a @@ '23&50';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
12
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT count(*) from test__int WHERE a @ '{20,23}';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
12
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT count(*) from test__int WHERE a @@ '50&68';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
9
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT count(*) from test__int WHERE a @ '{20,23}' or a @ '{50,68}';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
21
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT count(*) from test__int WHERE a @@ '(20&23)|(50&68)';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
21
|
|
|
|
(1 row)
|
|
|
|
|
2002-10-19 02:41:22 +08:00
|
|
|
DROP INDEX text_idx;
|
2001-08-22 00:36:06 +08:00
|
|
|
CREATE INDEX text_idx on test__int using gist ( a gist__intbig_ops );
|
2001-03-18 05:59:42 +08:00
|
|
|
SELECT count(*) from test__int WHERE a && '{23,50}';
|
|
|
|
count
|
|
|
|
-------
|
2001-03-20 11:08:12 +08:00
|
|
|
403
|
2001-03-18 05:59:42 +08:00
|
|
|
(1 row)
|
|
|
|
|
2001-09-23 12:16:16 +08:00
|
|
|
SELECT count(*) from test__int WHERE a @@ '23|50';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
403
|
|
|
|
(1 row)
|
|
|
|
|
2001-03-18 05:59:42 +08:00
|
|
|
SELECT count(*) from test__int WHERE a @ '{23,50}';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
12
|
|
|
|
(1 row)
|
|
|
|
|
2001-09-23 12:16:16 +08:00
|
|
|
SELECT count(*) from test__int WHERE a @@ '23&50';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
12
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT count(*) from test__int WHERE a @ '{20,23}';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
12
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT count(*) from test__int WHERE a @@ '50&68';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
9
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT count(*) from test__int WHERE a @ '{20,23}' or a @ '{50,68}';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
21
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT count(*) from test__int WHERE a @@ '(20&23)|(50&68)';
|
|
|
|
count
|
|
|
|
-------
|
|
|
|
21
|
|
|
|
(1 row)
|
|
|
|
|