*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.141 2003/08/08 21:41:39 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.142 2003/08/17 23:43:25 tgl Exp $
*
*-------------------------------------------------------------------------
*/
ArrayType *result;
List *element;
Oid element_type = arrayExpr->element_typeid;
- int ndims = arrayExpr->ndims;
+ int ndims = 0;
int dims[MAXDIM];
int lbs[MAXDIM];
- if (ndims == 1)
+ if (!arrayExpr->multidims)
{
+ /* Elements are presumably of scalar type */
int nelems;
Datum *dvalues;
int i = 0;
+ ndims = 1;
nelems = length(astate->elements);
/* Shouldn't happen here, but if length is 0, return NULL */
}
else
{
+ /* Must be nested array expressions */
char *dat = NULL;
Size ndatabytes = 0;
int nbytes;
bool firstone = true;
int i;
- if (ndims <= 0 || ndims > MAXDIM)
- ereport(ERROR,
- (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
- errmsg("number of array dimensions exceeds the maximum allowed, %d",
- MAXDIM)));
-
/* loop through and get data area from each element */
foreach(element, astate->elements)
{
array = DatumGetArrayTypeP(arraydatum);
+ /* run-time double-check on element type */
+ if (element_type != ARR_ELEMTYPE(array))
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("cannot merge incompatible arrays"),
+ errdetail("Array with element type %s cannot be "
+ "included in ARRAY construct with element type %s.",
+ format_type_be(ARR_ELEMTYPE(array)),
+ format_type_be(element_type))));
+
if (firstone)
{
/* Get sub-array details from first member */
elem_ndims = ARR_NDIM(array);
+ ndims = elem_ndims + 1;
+ if (ndims <= 0 || ndims > MAXDIM)
+ ereport(ERROR,
+ (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+ errmsg("number of array dimensions exceeds " \
+ "the maximum allowed, %d", MAXDIM)));
+
elem_dims = (int *) palloc(elem_ndims * sizeof(int));
memcpy(elem_dims, ARR_DIMS(array), elem_ndims * sizeof(int));
elem_lbs = (int *) palloc(elem_ndims * sizeof(int));
memcpy(elem_lbs, ARR_LBOUND(array), elem_ndims * sizeof(int));
+
firstone = false;
}
else
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.264 2003/08/17 19:58:05 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.265 2003/08/17 23:43:25 tgl Exp $
*
*-------------------------------------------------------------------------
*/
COPY_SCALAR_FIELD(array_typeid);
COPY_SCALAR_FIELD(element_typeid);
COPY_NODE_FIELD(elements);
- COPY_SCALAR_FIELD(ndims);
+ COPY_SCALAR_FIELD(multidims);
return newnode;
}
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.208 2003/08/17 19:58:05 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.209 2003/08/17 23:43:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
COMPARE_SCALAR_FIELD(array_typeid);
COMPARE_SCALAR_FIELD(element_typeid);
COMPARE_NODE_FIELD(elements);
- COMPARE_SCALAR_FIELD(ndims);
+ COMPARE_SCALAR_FIELD(multidims);
return true;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.217 2003/08/08 21:41:44 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.218 2003/08/17 23:43:26 tgl Exp $
*
* NOTES
* Every node type that can appear in stored rules' parsetrees *must*
WRITE_OID_FIELD(array_typeid);
WRITE_OID_FIELD(element_typeid);
WRITE_NODE_FIELD(elements);
- WRITE_INT_FIELD(ndims);
+ WRITE_BOOL_FIELD(multidims);
}
static void
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.161 2003/08/04 02:39:59 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.162 2003/08/17 23:43:26 tgl Exp $
*
* NOTES
* Path and Plan nodes do not have any readfuncs support, because we
READ_OID_FIELD(array_typeid);
READ_OID_FIELD(element_typeid);
READ_NODE_FIELD(elements);
- READ_INT_FIELD(ndims);
+ READ_BOOL_FIELD(multidims);
READ_DONE();
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.152 2003/08/08 21:41:55 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.153 2003/08/17 23:43:26 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
newarray->array_typeid = arrayexpr->array_typeid;
newarray->element_typeid = arrayexpr->element_typeid;
newarray->elements = FastListValue(&newelems);
- newarray->ndims = arrayexpr->ndims;
+ newarray->multidims = arrayexpr->multidims;
if (all_const)
return (Node *) evaluate_expr((Expr *) newarray,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.160 2003/08/04 02:40:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.161 2003/08/17 23:43:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
List *element;
Oid array_type;
Oid element_type;
- int ndims;
/* Transform the element expressions */
foreach(element, a->elements)
if (array_type != InvalidOid)
{
/* Elements are presumably of scalar type */
- ndims = 1;
+ newa->multidims = false;
}
else
{
/* Must be nested array expressions */
+ newa->multidims = true;
+
array_type = element_type;
element_type = get_element_type(array_type);
if (!OidIsValid(element_type))
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("could not find array type for datatype %s",
format_type_be(array_type))));
-
- /*
- * make sure the element expressions all have the same
- * number of dimensions
- */
- ndims = 0;
- foreach(element, newcoercedelems)
- {
- ArrayExpr *e = (ArrayExpr *) lfirst(element);
-
- if (!IsA(e, ArrayExpr))
- ereport(ERROR,
- (errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("multidimensional ARRAY[] must be built from nested array expressions")));
- if (ndims == 0)
- ndims = e->ndims;
- else if (e->ndims != ndims)
- ereport(ERROR,
- (errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("nested array expressions must have common number of dimensions")));
- if (e->element_typeid != element_type)
- ereport(ERROR,
- (errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("nested array expressions must have common element type")));
-
- }
- /* increment the number of dimensions */
- ndims++;
-
- /* make sure we don't have too many dimensions now */
- if (ndims > MAXDIM)
- ereport(ERROR,
- (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
- errmsg("number of array dimensions exceeds the maximum allowed, %d",
- MAXDIM)));
}
newa->array_typeid = array_type;
newa->element_typeid = element_type;
newa->elements = newcoercedelems;
- newa->ndims = ndims;
result = (Node *) newa;
break;
* Copyright (c) 2003, PostgreSQL Global Development Group
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/array_userfuncs.c,v 1.7 2003/08/04 00:43:25 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/array_userfuncs.c,v 1.8 2003/08/17 23:43:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*-----------------------------------------------------------------------------
* array_cat :
- * concatenate two nD arrays to form an (n+1)D array, or
+ * concatenate two nD arrays to form an nD array, or
* push an (n-1)D array onto the end of an nD array
*----------------------------------------------------------------------------
*/
*lbs2,
ndims2,
ndatabytes2;
+ int i;
char *dat1,
*dat2;
Oid element_type;
v1 = PG_GETARG_ARRAYTYPE_P(0);
v2 = PG_GETARG_ARRAYTYPE_P(1);
- /*
- * We must have one of the following combinations of inputs: 1) one
- * empty array, and one non-empty array 2) both arrays empty 3) two
- * arrays with ndims1 == ndims2 4) ndims1 == ndims2 - 1 5) ndims1 ==
- * ndims2 + 1
+ /*----------
+ * We must have one of the following combinations of inputs:
+ * 1) one empty array, and one non-empty array
+ * 2) both arrays empty
+ * 3) two arrays with ndims1 == ndims2
+ * 4) ndims1 == ndims2 - 1
+ * 5) ndims1 == ndims2 + 1
+ *----------
*/
ndims1 = ARR_NDIM(v1);
ndims2 = ARR_NDIM(v2);
if (ndims2 == 0)
PG_RETURN_ARRAYTYPE_P(v1);
- /* the rest fall into combo 2, 3, or 4 */
- if (ndims1 != ndims2 && ndims1 != ndims2 - 1 && ndims1 != ndims2 + 1)
+ /* the rest fall under rule 3, 4, or 5 */
+ if (ndims1 != ndims2 &&
+ ndims1 != ndims2 - 1 &&
+ ndims1 != ndims2 + 1)
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("cannot concatenate incompatible arrays"),
element_type1 = ARR_ELEMTYPE(v1);
element_type2 = ARR_ELEMTYPE(v2);
- /* Do we have a matching element types */
+ /* Check we have matching element types */
if (element_type1 != element_type2)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
if (ndims1 == ndims2)
{
/*
- * resulting array has two element outer array made up of input
- * argument arrays
+ * resulting array is made up of the elements (possibly arrays
+ * themselves) of the input argument arrays
*/
- int i;
-
- ndims = ndims1 + 1;
+ ndims = ndims1;
dims = (int *) palloc(ndims * sizeof(int));
lbs = (int *) palloc(ndims * sizeof(int));
- dims[0] = 2; /* outer array made up of two input arrays */
- lbs[0] = 1; /* start lower bound at 1 */
+ dims[0] = dims1[0] + dims2[0];
+ lbs[0] = lbs1[0];
- for (i = 0; i < ndims1; i++)
+ for (i = 1; i < ndims; i++)
{
if (dims1[i] != dims2[i] || lbs1[i] != lbs2[i])
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("cannot concatenate incompatible arrays"),
- errdetail("Arrays with differing dimensions are not "
- "compatible for concatenation.")));
+ errdetail("Arrays with differing element dimensions are "
+ "not compatible for concatenation.")));
- dims[i + 1] = dims1[i];
- lbs[i + 1] = lbs1[i];
+ dims[i] = dims1[i];
+ lbs[i] = lbs1[i];
}
}
else if (ndims1 == ndims2 - 1)
* with the first argument appended to the front of the outer
* dimension
*/
- int i;
-
ndims = ndims2;
- dims = dims2;
- lbs = lbs2;
+ dims = (int *) palloc(ndims * sizeof(int));
+ lbs = (int *) palloc(ndims * sizeof(int));
+ memcpy(dims, dims2, ndims * sizeof(int));
+ memcpy(lbs, lbs2, ndims * sizeof(int));
/* increment number of elements in outer array */
dims[0] += 1;
+ /* decrement outer array lower bound */
+ lbs[0] -= 1;
+
/* make sure the added element matches our existing elements */
for (i = 0; i < ndims1; i++)
{
}
}
else
-/* (ndims1 == ndims2 + 1) */
{
/*
+ * (ndims1 == ndims2 + 1)
+ *
* resulting array has the first argument as the outer array, with
* the second argument appended to the end of the outer dimension
*/
- int i;
-
ndims = ndims1;
- dims = dims1;
- lbs = lbs1;
+ dims = (int *) palloc(ndims * sizeof(int));
+ lbs = (int *) palloc(ndims * sizeof(int));
+ memcpy(dims, dims1, ndims * sizeof(int));
+ memcpy(lbs, lbs1, ndims * sizeof(int));
/* increment number of elements in outer array */
dims[0] += 1;
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: catversion.h,v 1.207 2003/08/17 19:58:06 tgl Exp $
+ * $Id: catversion.h,v 1.208 2003/08/17 23:43:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*/
/* yyyymmddN */
-#define CATALOG_VERSION_NO 200308171
+#define CATALOG_VERSION_NO 200308172
#endif
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: primnodes.h,v 1.91 2003/08/11 23:04:50 tgl Exp $
+ * $Id: primnodes.h,v 1.92 2003/08/17 23:43:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* ArrayExpr - an ARRAY[] expression
*
- * Note: if ndims > 1, then the array elements are all ArrayExprs of the
- * same type and ndims one less.
+ * Note: if multidims is false, the constituent expressions all yield the
+ * scalar type identified by element_typeid. If multidims is true, the
+ * constituent expressions all yield arrays of element_typeid (ie, the same
+ * type as array_typeid); at runtime we must check for compatible subscripts.
*/
typedef struct ArrayExpr
{
Expr xpr;
Oid array_typeid; /* type of expression result */
- Oid element_typeid; /* common type of expression elements */
- List *elements; /* the array elements */
- int ndims; /* number of array dimensions */
+ Oid element_typeid; /* common type of array elements */
+ List *elements; /* the array elements or sub-arrays */
+ bool multidims; /* true if elements are sub-arrays */
} ArrayExpr;
/*
{6,42}
(1 row)
-SELECT array_cat(ARRAY[1,2], ARRAY[3,4]) AS "{{1,2},{3,4}}";
- {{1,2},{3,4}}
----------------
- {{1,2},{3,4}}
+SELECT array_cat(ARRAY[1,2], ARRAY[3,4]) AS "{1,2,3,4}";
+ {1,2,3,4}
+-----------
+ {1,2,3,4}
(1 row)
SELECT array_cat(ARRAY[1,2], ARRAY[[3,4],[5,6]]) AS "{{1,2},{3,4},{5,6}}";
{0,1,2}
(1 row)
-SELECT ARRAY[1,2] || ARRAY[3,4] AS "{{1,2},{3,4}}";
- {{1,2},{3,4}}
----------------
- {{1,2},{3,4}}
+SELECT ARRAY[1,2] || ARRAY[3,4] AS "{1,2,3,4}";
+ {1,2,3,4}
+-----------
+ {1,2,3,4}
(1 row)
SELECT ARRAY[[['hello','world']]] || ARRAY[[['happy','birthday']]] AS "ARRAY";
- ARRAY
-------------------------------------------
- {{{{hello,world}}},{{{happy,birthday}}}}
+ ARRAY
+--------------------------------------
+ {{{hello,world}},{{happy,birthday}}}
(1 row)
SELECT ARRAY[[1,2],[3,4]] || ARRAY[5,6] AS "{{1,2},{3,4},{5,6}}";
{{1,2},{3,4},{5,6}}
(1 row)
-SELECT ARRAY[0,0] || ARRAY[1,1] || ARRAY[2,2] AS "{{0,0},{1,1},{2,2}}";
- {{0,0},{1,1},{2,2}}
----------------------
- {{0,0},{1,1},{2,2}}
+SELECT ARRAY[0,0] || ARRAY[1,1] || ARRAY[2,2] AS "{0,0,1,1,2,2}";
+ {0,0,1,1,2,2}
+---------------
+ {0,0,1,1,2,2}
(1 row)
SELECT 0 || ARRAY[1,2] || 3 AS "{0,1,2,3}";
-- functions
SELECT array_append(array[42], 6) AS "{42,6}";
SELECT array_prepend(6, array[42]) AS "{6,42}";
-SELECT array_cat(ARRAY[1,2], ARRAY[3,4]) AS "{{1,2},{3,4}}";
+SELECT array_cat(ARRAY[1,2], ARRAY[3,4]) AS "{1,2,3,4}";
SELECT array_cat(ARRAY[1,2], ARRAY[[3,4],[5,6]]) AS "{{1,2},{3,4},{5,6}}";
SELECT array_cat(ARRAY[[3,4],[5,6]], ARRAY[1,2]) AS "{{3,4},{5,6},{1,2}}";
SELECT NOT ARRAY[1.1,1.2,1.3] = ARRAY[1.1,1.2,1.3] AS "FALSE";
SELECT ARRAY[1,2] || 3 AS "{1,2,3}";
SELECT 0 || ARRAY[1,2] AS "{0,1,2}";
-SELECT ARRAY[1,2] || ARRAY[3,4] AS "{{1,2},{3,4}}";
+SELECT ARRAY[1,2] || ARRAY[3,4] AS "{1,2,3,4}";
SELECT ARRAY[[['hello','world']]] || ARRAY[[['happy','birthday']]] AS "ARRAY";
SELECT ARRAY[[1,2],[3,4]] || ARRAY[5,6] AS "{{1,2},{3,4},{5,6}}";
-SELECT ARRAY[0,0] || ARRAY[1,1] || ARRAY[2,2] AS "{{0,0},{1,1},{2,2}}";
+SELECT ARRAY[0,0] || ARRAY[1,1] || ARRAY[2,2] AS "{0,0,1,1,2,2}";
SELECT 0 || ARRAY[1,2] || 3 AS "{0,1,2,3}";
-- array casts
projects / postgresql.git / commitdiff