-
+
Arrays
INSERT INTO sal_emp
VALUES ('Bill',
'{10000, 10000, 10000, 10000}',
- '{{"meeting", "lunch"}, {}}');
+ '{{"meeting", "lunch"}, {"meeting"}}');
+ERROR: multidimensional arrays must have array expressions with matching dimensions
+
+
+ Note that multidimensional arrays must have matching extents for each
+ dimension. A mismatch causes an error report.
+
+INSERT INTO sal_emp
+ VALUES ('Bill',
+ '{10000, 10000, 10000, 10000}',
+ '{{"meeting", "lunch"}, {"training", "presentation"}}');
INSERT INTO sal_emp
VALUES ('Carol',
'{20000, 25000, 25000, 25000}',
- '{{"talk", "consult"}, {"meeting"}}');
+ '{{"breakfast", "consulting"}, {"meeting", "lunch"}}');
- This can lead to surprising results. For example, the result of the
- previous two inserts looks like this:
+ The result of the previous two inserts looks like this:
SELECT * FROM sal_emp;
- name | pay_by_quarter | schedule
--------+---------------------------+--------------------
- Bill | {10000,10000,10000,10000} | {{meeting},{""}}
- Carol | {20000,25000,25000,25000} | {{talk},{meeting}}
+ name | pay_by_quarter | schedule
+-------+---------------------------+-------------------------------------------
+ Bill | {10000,10000,10000,10000} | {{meeting,lunch},{training,presentation}}
+ Carol | {20000,25000,25000,25000} | {{breakfast,consulting},{meeting,lunch}}
(2 rows)
- Because the [2][2] element of
- schedule is missing in each of the
- INSERT statements, the [1][2]
- element is discarded.
-
- Fixing this is on the to-do list.
-
-
-
The ARRAY expression syntax may also be used:
INSERT INTO sal_emp
VALUES ('Bill',
ARRAY[10000, 10000, 10000, 10000],
- ARRAY[['meeting', 'lunch'], ['','']]);
+ ARRAY[['meeting', 'lunch'], ['training', 'presentation']]);
INSERT INTO sal_emp
VALUES ('Carol',
ARRAY[20000, 25000, 25000, 25000],
- ARRAY[['talk', 'consult'], ['meeting', '']]);
-SELECT * FROM sal_emp;
- name | pay_by_quarter | schedule
--------+---------------------------+-------------------------------
- Bill | {10000,10000,10000,10000} | {{meeting,lunch},{"",""}}
- Carol | {20000,25000,25000,25000} | {{talk,consult},{meeting,""}}
-(2 rows)
+ ARRAY[['breakfast', 'consulting'], ['meeting', 'lunch']]);
- Note that with this syntax, multidimensional arrays must have matching
- extents for each dimension. A mismatch causes an error report, rather than
- silently discarding values as in the previous case.
- For example:
-INSERT INTO sal_emp
- VALUES ('Carol',
- ARRAY[20000, 25000, 25000, 25000],
- ARRAY[['talk', 'consult'], ['meeting']]);
-ERROR: multidimensional arrays must have array expressions with matching dimensions
-
- Also notice that the array elements are ordinary SQL constants or
+ Notice that the array elements are ordinary SQL constants or
expressions; for instance, string literals are single quoted, instead of
double quoted as they would be in an array literal. The ARRAY
expression syntax is discussed in more detail in
SELECT schedule[1:2][1:1] FROM sal_emp WHERE name = 'Bill';
- schedule
---------------------
- {{meeting},{""}}
+ schedule
+------------------------
+ {{meeting},{training}}
(1 row)
is specified, as in this example:
SELECT schedule[1:2][2] FROM sal_emp WHERE name = 'Bill';
- schedule
----------------------------
- {{meeting,lunch},{"",""}}
+
+ schedule
+-------------------------------------------
+ {{meeting,lunch},{training,presentation}}
(1 row)
up to the next right brace or delimiter is taken as the item value.
+ By default, the lower bound index value of an array's dimensions is
+ set to one. If any of an array's dimensions has a lower bound index not
+ equal to one, an additional decoration that indicates the actual
+ array dimensions will precede the array structure decoration.
+ The decoration consists of square braces ([ and ])
+ around each array dimension's lower and upper bound indicies, plus
+ a colon (:) delimiter character inbetween. Delimiting the
+ array dimension decoration from the array structure decoration is a
+ single assignment operator (=). For example:
+SELECT 1 || ARRAY[2,3] AS array;
+
+ array
+---------------
+ [0:2]={1,2,3}
+(1 row)
+
+SELECT ARRAY[1,2] || ARRAY[[3,4]] AS array;
+
+ array
+--------------------------
+ [0:1][1:2]={{1,2},{3,4}}
+(1 row)
+
+
+
+ In a similar fashion, an array with non-default indicies may be specified
+ using the same literal syntax. For example:
+SELECT f1[1][-2][3] AS e1, f1[1][-1][5] AS e2
+ FROM (SELECT '[1:1][-2:-1][3:5]={{{1,2,3},{4,5,6}}}'::int[] AS f1) AS ss;
+
+ e1 | e2
+----+----
+ 1 | 6
+(1 row)
+
+
+
As shown previously, when writing an array value you may write double
quotes around any individual array
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.105 2004/06/16 01:26:47 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.106 2004/08/05 03:29:37 joe Exp $
*
*-------------------------------------------------------------------------
*/
errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
ndim, MAXDIM)));
- for (q = p; isdigit((unsigned char) *q); q++);
+ for (q = p; isdigit((unsigned char) *q) || (*q == '-') || (*q == '+'); q++);
if (q == p) /* no digits? */
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
*q = '\0';
lBound[ndim] = atoi(p);
p = q + 1;
- for (q = p; isdigit((unsigned char) *q); q++);
+ for (q = p; isdigit((unsigned char) *q) || (*q == '-') || (*q == '+'); q++);
if (q == p) /* no digits? */
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
}
else
{
+ int ndim_braces,
+ dim_braces[MAXDIM];
+
/* If array dimensions are given, expect '=' operator */
if (strncmp(p, ASSGN, strlen(ASSGN)) != 0)
ereport(ERROR,
p += strlen(ASSGN);
while (isspace((unsigned char) *p))
p++;
+
+ /*
+ * intuit dimensions from brace structure -- it better match what
+ * we were given
+ */
+ if (*p != '{')
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("array value must start with \"{\" or dimension information")));
+ ndim_braces = ArrayCount(p, dim_braces, typdelim);
+ if (ndim_braces != ndim)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("array dimensions incompatible with array literal")));
+ for (i = 0; i < ndim; ++i)
+ {
+ if (dim[i] != dim_braces[i])
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("array dimensions incompatible with array literal")));
+ }
}
#ifdef ARRAYDEBUG
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("missing left brace")));
-
dataPtr = ReadArrayStr(p, nitems, ndim, dim, &my_extra->proc, typioparam,
typmod, typdelim, typlen, typbyval, typalign,
&nbytes);
int nest_level = 0,
i;
int ndim = 1,
- temp[MAXDIM];
+ temp[MAXDIM],
+ nelems[MAXDIM],
+ nelems_last[MAXDIM];
bool scanning_string = false;
bool eoArray = false;
char *ptr;
for (i = 0; i < MAXDIM; ++i)
+ {
temp[i] = dim[i] = 0;
+ nelems_last[i] = nelems[i] = 1;
+ }
if (strncmp(str, "{}", 2) == 0)
return 0;
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("malformed array literal: \"%s\"", str)));
nest_level--;
+
+ if ((nelems_last[nest_level] != 1) &&
+ (nelems[nest_level] != nelems_last[nest_level]))
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+ errmsg("multidimensional arrays must have "
+ "array expressions with matching "
+ "dimensions")));
+ nelems_last[nest_level] = nelems[nest_level];
+ nelems[nest_level] = 1;
if (nest_level == 0)
eoArray = itemdone = true;
else
break;
default:
if (*ptr == typdelim && !scanning_string)
+ {
itemdone = true;
+ nelems[nest_level - 1]++;
+ }
break;
}
if (!itemdone)
char *p,
*tmp,
*retval,
- **values;
- bool *needquotes;
+ **values,
+ /*
+ * 33 per dim since we assume 15 digits per number + ':' +'[]'
+ *
+ * +2 allows for assignment operator + trailing null
+ */
+ dims_str[(MAXDIM * 33) + 2];
+ bool *needquotes,
+ needdims = false;
int nitems,
overall_length,
i,
k,
indx[MAXDIM];
int ndim,
- *dim;
+ *dim,
+ *lb;
ArrayMetaState *my_extra;
element_type = ARR_ELEMTYPE(v);
ndim = ARR_NDIM(v);
dim = ARR_DIMS(v);
+ lb = ARR_LBOUND(v);
nitems = ArrayGetNItems(ndim, dim);
if (nitems == 0)
PG_RETURN_CSTRING(retval);
}
+ /*
+ * we will need to add explicit dimensions if any dimension
+ * has a lower bound other than one
+ */
+ for (i = 0; i < ndim; i++)
+ {
+ if (lb[i] != 1)
+ {
+ needdims = true;
+ break;
+ }
+ }
+
/*
* Convert all values to string form, count total space needed
* (including any overhead such as escaping backslashes), and detect
*/
for (i = j = 0, k = 1; i < ndim; k *= dim[i++], j += k);
- retval = (char *) palloc(overall_length + 2 * j);
+ /* add explicit dimensions if required */
+ if (needdims)
+ {
+ char *ptr = dims_str;
+
+ for (i = 0; i < ndim; i++)
+ {
+ sprintf(ptr, "[%d:%d]", lb[i], lb[i] + dim[i] - 1);
+ ptr += strlen(ptr);
+ }
+ *ptr++ = *ASSGN;
+ *ptr = '\0';
+ }
+
+ retval = (char *) palloc(strlen(dims_str) + overall_length + 2 * j);
p = retval;
#define APPENDSTR(str) (strcpy(p, (str)), p += strlen(p))
#define APPENDCHAR(ch) (*p++ = (ch), *p = '\0')
+ if (needdims)
+ APPENDSTR(dims_str);
APPENDCHAR('{');
for (i = 0; i < ndim; indx[i++] = 0);
j = 0;
INSERT INTO arrtest (a, b[1:2], c, d[1:2])
VALUES ('{}', '{3,4}', '{foo,bar}', '{bar,foo}');
SELECT * FROM arrtest;
- a | b | c | d | e | f | g
--------------+-----------------+-----------+---------------+-----------+-----------------+-------------
- {1,2,3,4,5} | {{{0,0},{1,2}}} | {} | {} | {1.1,2.2} | {} | {}
- {11,12,23} | {{3,4},{4,5}} | {foobar} | {{elt1,elt2}} | {3.4,6.7} | {"abc ",abcde} | {abc,abcde}
- {} | {3,4} | {foo,bar} | {bar,foo} | | |
+ a | b | c | d | e | f | g
+-------------+-----------------+-----------+---------------+-----------------+-----------------+-------------
+ {1,2,3,4,5} | {{{0,0},{1,2}}} | {} | {} | [0:1]={1.1,2.2} | {} | {}
+ {11,12,23} | {{3,4},{4,5}} | {foobar} | {{elt1,elt2}} | {3.4,6.7} | {"abc ",abcde} | {abc,abcde}
+ {} | {3,4} | {foo,bar} | {bar,foo} | | |
(3 rows)
SELECT arrtest.a[1],
(1 row)
SELECT array_prepend(6, array[42]) AS "{6,42}";
- {6,42}
---------
- {6,42}
+ {6,42}
+--------------
+ [0:1]={6,42}
(1 row)
SELECT array_cat(ARRAY[1,2], ARRAY[3,4]) AS "{1,2,3,4}";
(1 row)
SELECT array_cat(ARRAY[1,2], ARRAY[[3,4],[5,6]]) AS "{{1,2},{3,4},{5,6}}";
- {{1,2},{3,4},{5,6}}
----------------------
- {{1,2},{3,4},{5,6}}
+ {{1,2},{3,4},{5,6}}
+--------------------------------
+ [0:2][1:2]={{1,2},{3,4},{5,6}}
(1 row)
SELECT array_cat(ARRAY[[3,4],[5,6]], ARRAY[1,2]) AS "{{3,4},{5,6},{1,2}}";
(1 row)
SELECT 0 || ARRAY[1,2] AS "{0,1,2}";
- {0,1,2}
----------
- {0,1,2}
+ {0,1,2}
+---------------
+ [0:2]={0,1,2}
(1 row)
SELECT ARRAY[1,2] || ARRAY[3,4] AS "{1,2,3,4}";
(1 row)
SELECT 0 || ARRAY[1,2] || 3 AS "{0,1,2,3}";
- {0,1,2,3}
------------
- {0,1,2,3}
+ {0,1,2,3}
+-----------------
+ [0:3]={0,1,2,3}
(1 row)
-- array casts
( testint4arr domainint4arr
, testtextarr domaintextarr
);
-INSERT INTO domarrtest values ('{2,2}', '{{"a","b"}{"c","d"}}');
-INSERT INTO domarrtest values ('{{2,2}{2,2}}', '{{"a","b"}}');
-INSERT INTO domarrtest values ('{2,2}', '{{"a","b"}{"c","d"}{"e"}}');
-INSERT INTO domarrtest values ('{2,2}', '{{"a"}{"c"}}');
-INSERT INTO domarrtest values (NULL, '{{"a","b"}{"c","d","e"}}');
+INSERT INTO domarrtest values ('{2,2}', '{{"a","b"},{"c","d"}}');
+INSERT INTO domarrtest values ('{{2,2},{2,2}}', '{{"a","b"}}');
+INSERT INTO domarrtest values ('{2,2}', '{{"a","b"},{"c","d"},{"e","f"}}');
+INSERT INTO domarrtest values ('{2,2}', '{{"a"},{"c"}}');
+INSERT INTO domarrtest values (NULL, '{{"a","b","c"},{"d","e","f"}}');
select * from domarrtest;
testint4arr | testtextarr
---------------+---------------------
- {2,2} | {{a,c},{"",d}}
- {{2,2},{0,2}} | {{a,b}}
- {2,2} | {{a},{c},{e}}
- {2,2} | {{c},{""}}
- | {{a,c,""},{"",d,e}}
+ {2,2} | {{a,b},{c,d}}
+ {{2,2},{2,2}} | {{a,b}}
+ {2,2} | {{a,b},{c,d},{e,f}}
+ {2,2} | {{a},{c}}
+ | {{a,b,c},{d,e,f}}
(5 rows)
select testint4arr[1], testtextarr[2:2] from domarrtest;
testint4arr | testtextarr
-------------+-------------
- 2 | {{"",d}}
+ 2 | {{c,d}}
|
+ 2 | {{c,d}}
2 | {{c}}
- 2 | {{""}}
- | {{"",d,e}}
+ | {{d,e,f}}
(5 rows)
drop table domarrtest;
( testint4arr domainint4arr
, testtextarr domaintextarr
);
-INSERT INTO domarrtest values ('{2,2}', '{{"a","b"}{"c","d"}}');
-INSERT INTO domarrtest values ('{{2,2}{2,2}}', '{{"a","b"}}');
-INSERT INTO domarrtest values ('{2,2}', '{{"a","b"}{"c","d"}{"e"}}');
-INSERT INTO domarrtest values ('{2,2}', '{{"a"}{"c"}}');
-INSERT INTO domarrtest values (NULL, '{{"a","b"}{"c","d","e"}}');
+INSERT INTO domarrtest values ('{2,2}', '{{"a","b"},{"c","d"}}');
+INSERT INTO domarrtest values ('{{2,2},{2,2}}', '{{"a","b"}}');
+INSERT INTO domarrtest values ('{2,2}', '{{"a","b"},{"c","d"},{"e","f"}}');
+INSERT INTO domarrtest values ('{2,2}', '{{"a"},{"c"}}');
+INSERT INTO domarrtest values (NULL, '{{"a","b","c"},{"d","e","f"}}');
select * from domarrtest;
select testint4arr[1], testtextarr[2:2] from domarrtest;
projects / postgresql.git / commitdiff