j;
text *item;
- deconstruct_array(query,
- TEXTOID, -1, false, TYPALIGN_INT,
- &key_datums, &key_nulls, &key_count);
+ deconstruct_array_builtin(query, TEXTOID, &key_datums, &key_nulls, &key_count);
entries = (Datum *) palloc(sizeof(Datum) * key_count);
int key_count;
int i;
- deconstruct_array(query,
- TEXTOID, -1, false, TYPALIGN_INT,
- &key_datums, &key_nulls, &key_count);
+ deconstruct_array_builtin(query, TEXTOID, &key_datums, &key_nulls, &key_count);
for (i = 0; res && i < key_count; ++i)
{
int key_count;
int i;
- deconstruct_array(query,
- TEXTOID, -1, false, TYPALIGN_INT,
- &key_datums, &key_nulls, &key_count);
+ deconstruct_array_builtin(query, TEXTOID, &key_datums, &key_nulls, &key_count);
res = false;
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("wrong number of array subscripts")));
- deconstruct_array(key_array,
- TEXTOID, -1, false, TYPALIGN_INT,
- &key_datums, &key_nulls, &key_count);
+ deconstruct_array_builtin(key_array, TEXTOID, &key_datums, &key_nulls, &key_count);
/* see discussion in hstoreArrayToPairs() */
if (key_count > MaxAllocSize / sizeof(Pairs))
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("arrays must have same bounds")));
- deconstruct_array(value_array,
- TEXTOID, -1, false, TYPALIGN_INT,
- &value_datums, &value_nulls, &value_count);
+ deconstruct_array_builtin(value_array, TEXTOID, &value_datums, &value_nulls, &value_count);
Assert(key_count == value_count);
}
errmsg("wrong number of array subscripts")));
}
- deconstruct_array(in_array,
- TEXTOID, -1, false, TYPALIGN_INT,
- &in_datums, &in_nulls, &in_count);
+ deconstruct_array_builtin(in_array, TEXTOID, &in_datums, &in_nulls, &in_count);
count = in_count / 2;
int i,
j;
- deconstruct_array(a,
- TEXTOID, -1, false, TYPALIGN_INT,
- &key_datums, &key_nulls, &key_count);
+ deconstruct_array_builtin(a, TEXTOID, &key_datums, &key_nulls, &key_count);
if (key_count == 0)
{
int key_count;
int i;
- deconstruct_array(key_array,
- TEXTOID, -1, false, TYPALIGN_INT,
- &key_datums, &key_nulls, &key_count);
+ deconstruct_array_builtin(key_array, TEXTOID, &key_datums, &key_nulls, &key_count);
if (key_count == 0)
{
d[i] = PointerGetDatum(t);
}
- a = construct_array(d, count,
- TEXTOID, -1, false, TYPALIGN_INT);
+ a = construct_array_builtin(d, count, TEXTOID);
PG_RETURN_POINTER(a);
}
tids_datum = (Datum *) palloc(nposting * sizeof(Datum));
for (int i = 0; i < nposting; i++)
tids_datum[i] = ItemPointerGetDatum(&tids[i]);
- values[j++] = PointerGetDatum(construct_array(tids_datum,
- nposting,
- TIDOID,
- sizeof(ItemPointerData),
- false, TYPALIGN_SHORT));
+ values[j++] = PointerGetDatum(construct_array_builtin(tids_datum, nposting, TIDOID));
pfree(tids_datum);
}
else
values[0] = Int64GetDatum(opaq->rightlink);
values[1] = Int32GetDatum(opaq->maxoff);
- values[2] = PointerGetDatum(construct_array(flags, nflags,
- TEXTOID,
- -1, false, TYPALIGN_INT));
+ values[2] = PointerGetDatum(construct_array_builtin(flags, nflags, TEXTOID));
/* Build and return the result tuple. */
resultTuple = heap_form_tuple(tupdesc, values, nulls);
tids_datum = (Datum *) palloc(ndecoded * sizeof(Datum));
for (i = 0; i < ndecoded; i++)
tids_datum[i] = ItemPointerGetDatum(&tids[i]);
- values[2] = PointerGetDatum(construct_array(tids_datum,
- ndecoded,
- TIDOID,
- sizeof(ItemPointerData),
- false, TYPALIGN_SHORT));
+ values[2] = PointerGetDatum(construct_array_builtin(tids_datum, ndecoded, TIDOID));
pfree(tids_datum);
pfree(tids);
values[0] = LSNGetDatum(PageGetLSN(page));
values[1] = LSNGetDatum(GistPageGetNSN(page));
values[2] = Int64GetDatum(opaq->rightlink);
- values[3] = PointerGetDatum(construct_array(flags, nflags,
- TEXTOID,
- -1, false, TYPALIGN_INT));
+ values[3] = PointerGetDatum(construct_array_builtin(flags, nflags, TEXTOID));
/* Build and return the result tuple. */
resultTuple = heap_form_tuple(tupdesc, values, nulls);
for (i = 0; i < HASH_MAX_SPLITPOINTS; i++)
spares[i] = Int64GetDatum((int64) metad->hashm_spares[i]);
- values[j++] = PointerGetDatum(construct_array(spares,
- HASH_MAX_SPLITPOINTS,
- INT8OID,
- sizeof(int64),
- FLOAT8PASSBYVAL,
- TYPALIGN_DOUBLE));
+ values[j++] = PointerGetDatum(construct_array_builtin(spares, HASH_MAX_SPLITPOINTS, INT8OID));
for (i = 0; i < HASH_MAX_BITMAPS; i++)
mapp[i] = Int64GetDatum((int64) metad->hashm_mapp[i]);
- values[j++] = PointerGetDatum(construct_array(mapp,
- HASH_MAX_BITMAPS,
- INT8OID,
- sizeof(int64),
- FLOAT8PASSBYVAL,
- TYPALIGN_DOUBLE));
+ values[j++] = PointerGetDatum(construct_array_builtin(mapp, HASH_MAX_BITMAPS, INT8OID));
tuple = heap_form_tuple(tupleDesc, values, nulls);
/* build value */
Assert(cnt <= bitcnt);
- a = construct_array(flags, cnt, TEXTOID, -1, false, TYPALIGN_INT);
+ a = construct_array_builtin(flags, cnt, TEXTOID);
values[0] = PointerGetDatum(a);
/*
if (cnt == 0)
a = construct_empty_array(TEXTOID);
else
- a = construct_array(flags, cnt, TEXTOID, -1, false, TYPALIGN_INT);
+ a = construct_array_builtin(flags, cnt, TEXTOID);
pfree(flags);
values[1] = PointerGetDatum(a);
d[i] = PointerGetDatum(item);
}
- a = construct_array(d,
- ARRNELEM(trg),
- TEXTOID,
- -1,
- false,
- TYPALIGN_INT);
+ a = construct_array_builtin(d, ARRNELEM(trg), TEXTOID);
for (i = 0; i < ARRNELEM(trg); i++)
pfree(DatumGetPointer(d[i]));
if (nkdims == 0)
return 0;
- deconstruct_array(key_array,
- TEXTOID, -1, false, TYPALIGN_INT,
- &key_datums, &key_nulls, &key_count);
-
- deconstruct_array(val_array,
- TEXTOID, -1, false, TYPALIGN_INT,
- &val_datums, &val_nulls, &val_count);
+ deconstruct_array_builtin(key_array, TEXTOID, &key_datums, &key_nulls, &key_count);
+ deconstruct_array_builtin(val_array, TEXTOID, &val_datums, &val_nulls, &val_count);
if (key_count != val_count)
ereport(ERROR,
int noldoptions;
int i;
- deconstruct_array(array, TEXTOID, -1, false, TYPALIGN_INT,
- &oldoptions, NULL, &noldoptions);
+ deconstruct_array_builtin(array, TEXTOID, &oldoptions, NULL, &noldoptions);
for (i = 0; i < noldoptions; i++)
{
array = DatumGetArrayTypeP(options);
- deconstruct_array(array, TEXTOID, -1, false, TYPALIGN_INT,
- &optiondatums, NULL, &noptions);
+ deconstruct_array_builtin(array, TEXTOID, &optiondatums, NULL, &noptions);
for (i = 0; i < noptions; i++)
{
int noptions;
int i;
- deconstruct_array(array, TEXTOID, -1, false, TYPALIGN_INT,
- &optiondatums, NULL, &noptions);
+ deconstruct_array_builtin(array, TEXTOID, &optiondatums, NULL, &noptions);
for (i = 0; i < noptions; i++)
{
List *list = NIL;
int i;
- deconstruct_array(arr, TEXTOID, -1, false, TYPALIGN_INT,
- &elems, &nulls, &nelems);
+ deconstruct_array_builtin(arr, TEXTOID, &elems, &nulls, &nelems);
for (i = 0; i < nelems; i++)
{
bool *nulls;
int nelems;
- deconstruct_array(namearr, TEXTOID, -1, false, TYPALIGN_INT,
- &elems, &nulls, &nelems);
+ deconstruct_array_builtin(namearr, TEXTOID, &elems, &nulls, &nelems);
if (nelems != 1)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
bool *nulls;
int nelems;
- deconstruct_array(namearr, TEXTOID, -1, false, TYPALIGN_INT,
- &elems, &nulls, &nelems);
+ deconstruct_array_builtin(namearr, TEXTOID, &elems, &nulls, &nelems);
if (nelems != 1)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
int nelems;
int i;
- deconstruct_array(argsarr, TEXTOID, -1, false, TYPALIGN_INT,
- &elems, &nulls, &nelems);
+ deconstruct_array_builtin(argsarr, TEXTOID, &elems, &nulls, &nelems);
args = NIL;
for (i = 0; i < nelems; i++)
conkey = (Datum *) palloc(constraintNKeys * sizeof(Datum));
for (i = 0; i < constraintNKeys; i++)
conkey[i] = Int16GetDatum(constraintKey[i]);
- conkeyArray = construct_array(conkey, constraintNKeys,
- INT2OID, 2, true, TYPALIGN_SHORT);
+ conkeyArray = construct_array_builtin(conkey, constraintNKeys, INT2OID);
}
else
conkeyArray = NULL;
fkdatums = (Datum *) palloc(foreignNKeys * sizeof(Datum));
for (i = 0; i < foreignNKeys; i++)
fkdatums[i] = Int16GetDatum(foreignKey[i]);
- confkeyArray = construct_array(fkdatums, foreignNKeys,
- INT2OID, 2, true, TYPALIGN_SHORT);
+ confkeyArray = construct_array_builtin(fkdatums, foreignNKeys, INT2OID);
for (i = 0; i < foreignNKeys; i++)
fkdatums[i] = ObjectIdGetDatum(pfEqOp[i]);
- conpfeqopArray = construct_array(fkdatums, foreignNKeys,
- OIDOID, sizeof(Oid), true, TYPALIGN_INT);
+ conpfeqopArray = construct_array_builtin(fkdatums, foreignNKeys, OIDOID);
for (i = 0; i < foreignNKeys; i++)
fkdatums[i] = ObjectIdGetDatum(ppEqOp[i]);
- conppeqopArray = construct_array(fkdatums, foreignNKeys,
- OIDOID, sizeof(Oid), true, TYPALIGN_INT);
+ conppeqopArray = construct_array_builtin(fkdatums, foreignNKeys, OIDOID);
for (i = 0; i < foreignNKeys; i++)
fkdatums[i] = ObjectIdGetDatum(ffEqOp[i]);
- conffeqopArray = construct_array(fkdatums, foreignNKeys,
- OIDOID, sizeof(Oid), true, TYPALIGN_INT);
+ conffeqopArray = construct_array_builtin(fkdatums, foreignNKeys, OIDOID);
if (numFkDeleteSetCols > 0)
{
for (i = 0; i < numFkDeleteSetCols; i++)
fkdatums[i] = Int16GetDatum(fkDeleteSetCols[i]);
- confdelsetcolsArray = construct_array(fkdatums, numFkDeleteSetCols,
- INT2OID, 2, true, TYPALIGN_SHORT);
+ confdelsetcolsArray = construct_array_builtin(fkdatums, numFkDeleteSetCols, INT2OID);
}
else
confdelsetcolsArray = NULL;
opdatums = (Datum *) palloc(constraintNKeys * sizeof(Datum));
for (i = 0; i < constraintNKeys; i++)
opdatums[i] = ObjectIdGetDatum(exclOp[i]);
- conexclopArray = construct_array(opdatums, constraintNKeys,
- OIDOID, sizeof(Oid), true, TYPALIGN_INT);
+ conexclopArray = construct_array_builtin(opdatums, constraintNKeys, OIDOID);
}
else
conexclopArray = NULL;
int i;
List *result = NIL;
- deconstruct_array(array,
- OIDOID,
- sizeof(Oid), true, TYPALIGN_INT,
- &values, NULL, &nelems);
+ deconstruct_array_builtin(array, OIDOID, &values, NULL, &nelems);
for (i = 0; i < nelems; i++)
result = lappend_oid(result, values[i]);
return result;
i;
List *res = NIL;
- deconstruct_array(textarray,
- TEXTOID, -1, false, TYPALIGN_INT,
- &elems, NULL, &nelems);
+ deconstruct_array_builtin(textarray, TEXTOID, &elems, NULL, &nelems);
if (nelems == 0)
return NIL;
for (n = 0; n < nnum; n++)
numdatums[n] = Float4GetDatum(stats->stanumbers[k][n]);
- /* XXX knows more than it should about type float4: */
- arry = construct_array(numdatums, nnum,
- FLOAT4OID,
- sizeof(float4), true, TYPALIGN_INT);
+ arry = construct_array_builtin(numdatums, nnum, FLOAT4OID);
values[i++] = PointerGetDatum(arry); /* stanumbersN */
}
else
pfree(result);
}
- return PointerGetDatum(construct_array(data, l, TEXTOID,
- -1, false, TYPALIGN_INT));
+ return PointerGetDatum(construct_array_builtin(data, l, TEXTOID));
}
/*
datums[ndatums++] =
DirectFunctionCall1(namein, CStringGetDatum(curreq));
}
- a = construct_array(datums, ndatums,
- NAMEOID,
- NAMEDATALEN, false, TYPALIGN_CHAR);
+ a = construct_array_builtin(datums, ndatums, NAMEOID);
return PointerGetDatum(a);
}
arrayLength = 0;
arrayIndex = 1;
- a = construct_array(&elementDatum, 1,
- OIDOID,
- sizeof(Oid), true, TYPALIGN_INT);
+ a = construct_array_builtin(&elementDatum, 1, OIDOID);
}
else
{
if (arrayLength != 0)
elog(ERROR, "extconfig and extcondition arrays do not match");
- a = construct_array(&elementDatum, 1,
- TEXTOID,
- -1, false, TYPALIGN_INT);
+ a = construct_array_builtin(&elementDatum, 1, TEXTOID);
}
else
{
int i;
/* We already checked there are no nulls */
- deconstruct_array(a, OIDOID, sizeof(Oid), true, TYPALIGN_INT,
- &dvalues, NULL, &nelems);
+ deconstruct_array_builtin(a, OIDOID, &dvalues, NULL, &nelems);
for (i = arrayIndex; i < arrayLength - 1; i++)
dvalues[i] = dvalues[i + 1];
- a = construct_array(dvalues, arrayLength - 1,
- OIDOID, sizeof(Oid), true, TYPALIGN_INT);
+ a = construct_array_builtin(dvalues, arrayLength - 1, OIDOID);
repl_val[Anum_pg_extension_extconfig - 1] = PointerGetDatum(a);
}
int i;
/* We already checked there are no nulls */
- deconstruct_array(a, TEXTOID, -1, false, TYPALIGN_INT,
- &dvalues, NULL, &nelems);
+ deconstruct_array_builtin(a, TEXTOID, &dvalues, NULL, &nelems);
for (i = arrayIndex; i < arrayLength - 1; i++)
dvalues[i] = dvalues[i + 1];
- a = construct_array(dvalues, arrayLength - 1,
- TEXTOID, -1, false, TYPALIGN_INT);
+ a = construct_array_builtin(dvalues, arrayLength - 1, TEXTOID);
repl_val[Anum_pg_extension_extcondition - 1] = PointerGetDatum(a);
}
if (outCount > 0 || varCount > 0)
{
- *allParameterTypes = construct_array(allTypes, parameterCount, OIDOID,
- sizeof(Oid), true, TYPALIGN_INT);
- *parameterModes = construct_array(paramModes, parameterCount, CHAROID,
- 1, true, TYPALIGN_CHAR);
+ *allParameterTypes = construct_array_builtin(allTypes, parameterCount, OIDOID);
+ *parameterModes = construct_array_builtin(paramModes, parameterCount, CHAROID);
if (outCount > 1)
*requiredResultType = RECORDOID;
/* otherwise we set requiredResultType correctly above */
if (paramNames[i] == PointerGetDatum(NULL))
paramNames[i] = CStringGetTextDatum("");
}
- *parameterNames = construct_array(paramNames, parameterCount, TEXTOID,
- -1, false, TYPALIGN_INT);
+ *parameterNames = construct_array_builtin(paramNames, parameterCount, TEXTOID);
}
else
*parameterNames = NULL;
i = 0;
foreach(lc, trftypes_list)
arr[i++] = ObjectIdGetDatum(lfirst_oid(lc));
- trftypes = construct_array(arr, list_length(trftypes_list),
- OIDOID, sizeof(Oid), true, TYPALIGN_INT);
+ trftypes = construct_array_builtin(arr, list_length(trftypes_list), OIDOID);
}
else
{
memset(isnull, 0, sizeof(isnull));
/* This is the array for the new tuple */
- role_ids = construct_array(role_oids, num_roles, OIDOID,
- sizeof(Oid), true, TYPALIGN_INT);
+ role_ids = construct_array_builtin(role_oids, num_roles, OIDOID);
replaces[Anum_pg_policy_polroles - 1] = true;
values[Anum_pg_policy_polroles - 1] = PointerGetDatum(role_ids);
/* Collect role ids */
role_oids = policy_role_list_to_array(stmt->roles, &nitems);
- role_ids = construct_array(role_oids, nitems, OIDOID,
- sizeof(Oid), true, TYPALIGN_INT);
+ role_ids = construct_array_builtin(role_oids, nitems, OIDOID);
/* Parse the supplied clause */
qual_pstate = make_parsestate(NULL);
if (stmt->roles != NULL)
{
role_oids = policy_role_list_to_array(stmt->roles, &nitems);
- role_ids = construct_array(role_oids, nitems, OIDOID,
- sizeof(Oid), true, TYPALIGN_INT);
+ role_ids = construct_array_builtin(role_oids, nitems, OIDOID);
}
/* Get id of table. Also handles permissions checks. */
for (i = 0; i < num_params; i++)
tmp_ary[i] = ObjectIdGetDatum(param_types[i]);
- /* XXX: this hardcodes assumptions about the regtype type */
- result = construct_array(tmp_ary, num_params, REGTYPEOID,
- 4, true, TYPALIGN_INT);
+ result = construct_array_builtin(tmp_ary, num_params, REGTYPEOID);
return PointerGetDatum(result);
}
if (build_expressions)
types[ntypes++] = CharGetDatum(STATS_EXT_EXPRESSIONS);
Assert(ntypes > 0 && ntypes <= lengthof(types));
- stxkind = construct_array(types, ntypes, CHAROID, 1, true, TYPALIGN_CHAR);
+ stxkind = construct_array_builtin(types, ntypes, CHAROID);
/* convert the expressions (if any) to a text datum */
if (stxexprs != NIL)
MemoryContextSwitchTo(oldcxt);
- arr = construct_array(datums, list_length(publist),
- TEXTOID, -1, false, TYPALIGN_INT);
+ arr = construct_array_builtin(datums, list_length(publist), TEXTOID);
MemoryContextDelete(memcxt);
/* n-arg constructor - vararg */
argtypes = buildoidvector(&rangeArrayOid, 1);
allParamTypes = ObjectIdGetDatum(rangeArrayOid);
- allParameterTypes = construct_array(&allParamTypes,
- 1, OIDOID,
- sizeof(Oid), true, TYPALIGN_INT);
+ allParameterTypes = construct_array_builtin(&allParamTypes, 1, OIDOID);
paramModes = CharGetDatum(FUNC_PARAM_VARIADIC);
- parameterModes = construct_array(¶mModes, 1, CHAROID,
- 1, true, TYPALIGN_CHAR);
+ parameterModes = construct_array_builtin(¶mModes, 1, CHAROID);
myself = ProcedureCreate(name, /* name: same as multirange type */
namespace,
false, /* replace */
if (isNull)
continue;
itemarray = DatumGetArrayTypeP(arraydatum);
- deconstruct_array(itemarray,
- TIDOID, sizeof(ItemPointerData), false, TYPALIGN_SHORT,
- &ipdatums, &ipnulls, &ndatums);
+ deconstruct_array_builtin(itemarray, TIDOID, &ipdatums, &ipnulls, &ndatums);
if (numTids + ndatums > numAllocTids)
{
numAllocTids = numTids + ndatums;
datums[n++] = CStringGetDatum(cstr);
}
- /* hardwired knowledge about cstring's representation details here */
- arrtypmod = construct_array(datums, n, CSTRINGOID,
- -2, false, TYPALIGN_CHAR);
+ arrtypmod = construct_array_builtin(datums, n, CSTRINGOID);
/* arrange to report location if type's typmodin function fails */
setup_parser_errposition_callback(&pcbstate, pstate, typeName->location);
elog(ERROR, "null conexclop for constraint %u",
constraintId);
- deconstruct_array(DatumGetArrayTypeP(datum),
- OIDOID, sizeof(Oid), true, TYPALIGN_INT,
- &elems, NULL, &nElems);
+ deconstruct_array_builtin(DatumGetArrayTypeP(datum), OIDOID, &elems, NULL, &nElems);
for (i = 0; i < nElems; i++)
{
Assert(ARR_ELEMTYPE(arr) == TEXTOID);
- deconstruct_array(arr, TEXTOID, -1, false, TYPALIGN_INT,
- &datum_opts, NULL, &nelems);
+ deconstruct_array_builtin(arr, TEXTOID, &datum_opts, NULL, &nelems);
if (nelems % 2 != 0)
ereport(ERROR,
for (n = 0; n < nnum; n++)
numdatums[n] = Float4GetDatum(stats->stanumbers[k][n]);
- /* XXX knows more than it should about type float4: */
- arry = construct_array(numdatums, nnum,
- FLOAT4OID,
- sizeof(float4), true, TYPALIGN_INT);
+ arry = construct_array_builtin(numdatums, nnum, FLOAT4OID);
values[i++] = PointerGetDatum(arry); /* stanumbersN */
}
else
ptr++;
}
- a = construct_array(da,
- ptr - res,
- TEXTOID,
- -1,
- false,
- TYPALIGN_INT);
+ a = construct_array_builtin(da, ptr - res, TEXTOID);
ptr = res;
while (ptr->lexeme)
elmtype, elmlen, elmbyval, elmalign);
}
+/*
+ * Like construct_array(), where elmtype must be a built-in type, and
+ * elmlen/elmbyval/elmalign is looked up from hardcoded data. This is often
+ * useful when manipulating arrays from/for system catalogs.
+ */
+ArrayType *
+construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
+{
+ int elmlen;
+ bool elmbyval;
+ char elmalign;
+
+ switch (elmtype)
+ {
+ case CHAROID:
+ elmlen = 1;
+ elmbyval = true;
+ elmalign = TYPALIGN_CHAR;
+ break;
+
+ case CSTRINGOID:
+ elmlen = -2;
+ elmbyval = false;
+ elmalign = TYPALIGN_CHAR;
+ break;
+
+ case FLOAT4OID:
+ elmlen = sizeof(float4);
+ elmbyval = true;
+ elmalign = TYPALIGN_INT;
+ break;
+
+ case INT2OID:
+ elmlen = sizeof(int16);
+ elmbyval = true;
+ elmalign = TYPALIGN_SHORT;
+ break;
+
+ case INT4OID:
+ elmlen = sizeof(int32);
+ elmbyval = true;
+ elmalign = TYPALIGN_INT;
+ break;
+
+ case INT8OID:
+ elmlen = sizeof(int64);
+ elmbyval = FLOAT8PASSBYVAL;
+ elmalign = TYPALIGN_DOUBLE;
+ break;
+
+ case NAMEOID:
+ elmlen = NAMEDATALEN;
+ elmbyval = false;
+ elmalign = TYPALIGN_CHAR;
+ break;
+
+ case OIDOID:
+ case REGTYPEOID:
+ elmlen = sizeof(Oid);
+ elmbyval = true;
+ elmalign = TYPALIGN_INT;
+ break;
+
+ case TEXTOID:
+ elmlen = -1;
+ elmbyval = false;
+ elmalign = TYPALIGN_INT;
+ break;
+
+ case TIDOID:
+ elmlen = sizeof(ItemPointerData);
+ elmbyval = false;
+ elmalign = TYPALIGN_SHORT;
+ break;
+
+ default:
+ elog(ERROR, "type %u not supported by construct_array_builtin()", elmtype);
+ /* keep compiler quiet */
+ elmlen = 0;
+ elmbyval = false;
+ elmalign = 0;
+ }
+
+ return construct_array(elems, nelems, elmtype, elmlen, elmbyval, elmalign);
+}
+
/*
* construct_md_array --- simple method for constructing an array object
* with arbitrary dimensions and possible NULLs
* be pointers into the array object.
*
* NOTE: it would be cleaner to look up the elmlen/elmbval/elmalign info
- * from the system catalogs, given the elmtype. However, in most current
- * uses the type is hard-wired into the caller and so we can save a lookup
- * cycle by hard-wiring the type info as well.
+ * from the system catalogs, given the elmtype. However, the caller is
+ * in a better position to cache this info across multiple uses, or even
+ * to hard-wire values if the element type is hard-wired.
*/
void
deconstruct_array(ArrayType *array,
}
}
+/*
+ * Like deconstruct_array(), where elmtype must be a built-in type, and
+ * elmlen/elmbyval/elmalign is looked up from hardcoded data. This is often
+ * useful when manipulating arrays from/for system catalogs.
+ */
+void
+deconstruct_array_builtin(ArrayType *array,
+ Oid elmtype,
+ Datum **elemsp, bool **nullsp, int *nelemsp)
+{
+ int elmlen;
+ bool elmbyval;
+ char elmalign;
+
+ switch (elmtype)
+ {
+ case CHAROID:
+ elmlen = 1;
+ elmbyval = true;
+ elmalign = TYPALIGN_CHAR;
+ break;
+
+ case CSTRINGOID:
+ elmlen = -2;
+ elmbyval = false;
+ elmalign = TYPALIGN_CHAR;
+ break;
+
+ case FLOAT8OID:
+ elmlen = sizeof(float8);
+ elmbyval = FLOAT8PASSBYVAL;
+ elmalign = TYPALIGN_DOUBLE;
+ break;
+
+ case INT2OID:
+ elmlen = sizeof(int16);
+ elmbyval = true;
+ elmalign = TYPALIGN_SHORT;
+ break;
+
+ case OIDOID:
+ elmlen = sizeof(Oid);
+ elmbyval = true;
+ elmalign = TYPALIGN_INT;
+ break;
+
+ case TEXTOID:
+ elmlen = -1;
+ elmbyval = false;
+ elmalign = TYPALIGN_INT;
+ break;
+
+ case TIDOID:
+ elmlen = sizeof(ItemPointerData);
+ elmbyval = false;
+ elmalign = TYPALIGN_SHORT;
+ break;
+
+ default:
+ elog(ERROR, "type %u not supported by deconstruct_array_builtin()", elmtype);
+ /* keep compiler quiet */
+ elmlen = 0;
+ elmbyval = false;
+ elmalign = 0;
+ }
+
+ deconstruct_array(array, elmtype, elmlen, elmbyval, elmalign, elemsp, nullsp, nelemsp);
+}
+
/*
* array_contains_nulls --- detect whether an array has any null elements
*
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("typmod array must not contain nulls")));
- /* hardwired knowledge about cstring's representation details here */
- deconstruct_array(arr, CSTRINGOID,
- -2, false, TYPALIGN_CHAR,
- &elem_values, NULL, n);
+ deconstruct_array_builtin(arr, CSTRINGOID, &elem_values, NULL, n);
result = (int32 *) palloc(*n * sizeof(int32));
Assert(noptions <= MAX_HBA_OPTIONS);
if (noptions > 0)
- return construct_array(options, noptions, TEXTOID, -1, false, TYPALIGN_INT);
+ return construct_array_builtin(options, noptions, TEXTOID);
else
return NULL;
}
errmsg("wrong number of array subscripts")));
}
- deconstruct_array(in_array,
- TEXTOID, -1, false, TYPALIGN_INT,
- &in_datums, &in_nulls, &in_count);
+ deconstruct_array_builtin(in_array, TEXTOID, &in_datums, &in_nulls, &in_count);
count = in_count / 2;
if (nkdims == 0)
PG_RETURN_DATUM(CStringGetTextDatum("{}"));
- deconstruct_array(key_array,
- TEXTOID, -1, false, TYPALIGN_INT,
- &key_datums, &key_nulls, &key_count);
-
- deconstruct_array(val_array,
- TEXTOID, -1, false, TYPALIGN_INT,
- &val_datums, &val_nulls, &val_count);
+ deconstruct_array_builtin(key_array, TEXTOID, &key_datums, &key_nulls, &key_count);
+ deconstruct_array_builtin(val_array, TEXTOID, &val_datums, &val_nulls, &val_count);
if (key_count != val_count)
ereport(ERROR,
errmsg("wrong number of array subscripts")));
}
- deconstruct_array(in_array,
- TEXTOID, -1, false, TYPALIGN_INT,
- &in_datums, &in_nulls, &in_count);
+ deconstruct_array_builtin(in_array, TEXTOID, &in_datums, &in_nulls, &in_count);
count = in_count / 2;
if (nkdims == 0)
goto close_object;
- deconstruct_array(key_array,
- TEXTOID, -1, false, TYPALIGN_INT,
- &key_datums, &key_nulls, &key_count);
-
- deconstruct_array(val_array,
- TEXTOID, -1, false, TYPALIGN_INT,
- &val_datums, &val_nulls, &val_count);
+ deconstruct_array_builtin(key_array, TEXTOID, &key_datums, &key_nulls, &key_count);
+ deconstruct_array_builtin(val_array, TEXTOID, &val_datums, &val_nulls, &val_count);
if (key_count != val_count)
ereport(ERROR,
int i,
j;
- deconstruct_array(query,
- TEXTOID, -1, false, TYPALIGN_INT,
- &key_datums, &key_nulls, &key_count);
+ deconstruct_array_builtin(query, TEXTOID, &key_datums, &key_nulls, &key_count);
entries = (Datum *) palloc(sizeof(Datum) * key_count);
bool *key_nulls;
int elem_count;
- deconstruct_array(keys, TEXTOID, -1, false, TYPALIGN_INT,
- &key_datums, &key_nulls, &elem_count);
+ deconstruct_array_builtin(keys, TEXTOID, &key_datums, &key_nulls, &elem_count);
for (i = 0; i < elem_count; i++)
{
bool *key_nulls;
int elem_count;
- deconstruct_array(keys, TEXTOID, -1, false, TYPALIGN_INT,
- &key_datums, &key_nulls, &elem_count);
+ deconstruct_array_builtin(keys, TEXTOID, &key_datums, &key_nulls, &elem_count);
for (i = 0; i < elem_count; i++)
{
if (array_contains_nulls(path))
PG_RETURN_NULL();
- deconstruct_array(path, TEXTOID, -1, false, TYPALIGN_INT,
- &pathtext, &pathnulls, &npath);
+ deconstruct_array_builtin(path, TEXTOID, &pathtext, &pathnulls, &npath);
tpath = palloc(npath * sizeof(char *));
ipath = palloc(npath * sizeof(int));
if (array_contains_nulls(path))
PG_RETURN_NULL();
- deconstruct_array(path, TEXTOID, -1, false, TYPALIGN_INT,
- &pathtext, &pathnulls, &npath);
+ deconstruct_array_builtin(path, TEXTOID, &pathtext, &pathnulls, &npath);
res = jsonb_get_element(jb, pathtext, npath, &isnull, as_text);
if (JB_ROOT_COUNT(in) == 0)
PG_RETURN_JSONB_P(in);
- deconstruct_array(keys, TEXTOID, -1, false, TYPALIGN_INT,
- &keys_elems, &keys_nulls, &keys_len);
+ deconstruct_array_builtin(keys, TEXTOID, &keys_elems, &keys_nulls, &keys_len);
if (keys_len == 0)
PG_RETURN_JSONB_P(in);
if (JB_ROOT_COUNT(in) == 0 && !create)
PG_RETURN_JSONB_P(in);
- deconstruct_array(path, TEXTOID, -1, false, TYPALIGN_INT,
- &path_elems, &path_nulls, &path_len);
+ deconstruct_array_builtin(path, TEXTOID, &path_elems, &path_nulls, &path_len);
if (path_len == 0)
PG_RETURN_JSONB_P(in);
if (JB_ROOT_COUNT(in) == 0)
PG_RETURN_JSONB_P(in);
- deconstruct_array(path, TEXTOID, -1, false, TYPALIGN_INT,
- &path_elems, &path_nulls, &path_len);
+ deconstruct_array_builtin(path, TEXTOID, &path_elems, &path_nulls, &path_len);
if (path_len == 0)
PG_RETURN_JSONB_P(in);
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("cannot set path in scalar")));
- deconstruct_array(path, TEXTOID, -1, false, TYPALIGN_INT,
- &path_elems, &path_nulls, &path_len);
+ deconstruct_array_builtin(path, TEXTOID, &path_elems, &path_nulls, &path_len);
if (path_len == 0)
PG_RETURN_JSONB_P(in);
/* Assert we didn't overrun arrayelems[] */
Assert(narrayelems <= lockData->nlocks);
- /* Construct array, using hardwired knowledge about int4 type */
- PG_RETURN_ARRAYTYPE_P(construct_array(arrayelems, narrayelems,
- INT4OID,
- sizeof(int32), true, TYPALIGN_INT));
+ PG_RETURN_ARRAYTYPE_P(construct_array_builtin(arrayelems, narrayelems, INT4OID));
}
else
blocker_datums = NULL;
- /* Construct array, using hardwired knowledge about int4 type */
- PG_RETURN_ARRAYTYPE_P(construct_array(blocker_datums, num_blockers,
- INT4OID,
- sizeof(int32), true, TYPALIGN_INT));
+ PG_RETURN_ARRAYTYPE_P(construct_array_builtin(blocker_datums, num_blockers, INT4OID));
}
}
list_free(search_path);
- array = construct_array(names, i,
- NAMEOID,
- NAMEDATALEN, /* sizeof(Name) */
- false, /* Name is not by-val */
- TYPALIGN_CHAR); /* alignment of Name */
+ array = construct_array_builtin(names, i, NAMEOID);
PG_RETURN_POINTER(array);
}
PG_RETURN_NULL();
param = PG_GETARG_ARRAYTYPE_P(1);
- deconstruct_array(param, FLOAT8OID,
- /* hard-wired info on type float8 */
- sizeof(float8), FLOAT8PASSBYVAL, TYPALIGN_DOUBLE,
- &percentiles_datum,
- &percentiles_null,
- &num_percentiles);
+ deconstruct_array_builtin(param, FLOAT8OID,
+ &percentiles_datum,
+ &percentiles_null,
+ &num_percentiles);
if (num_percentiles == 0)
PG_RETURN_POINTER(construct_empty_array(osastate->qstate->sortColType));
PG_RETURN_NULL();
param = PG_GETARG_ARRAYTYPE_P(1);
- deconstruct_array(param, FLOAT8OID,
- /* hard-wired info on type float8 */
- sizeof(float8), FLOAT8PASSBYVAL, TYPALIGN_DOUBLE,
- &percentiles_datum,
- &percentiles_null,
- &num_percentiles);
+ deconstruct_array_builtin(param, FLOAT8OID,
+ &percentiles_datum,
+ &percentiles_null,
+ &num_percentiles);
if (num_percentiles == 0)
PG_RETURN_POINTER(construct_empty_array(osastate->qstate->sortColType));
int ndatums;
int i;
- deconstruct_array(textArray,
- TEXTOID, -1, false, TYPALIGN_INT,
- &textDatums, NULL, &ndatums);
+ deconstruct_array_builtin(textArray, TEXTOID, &textDatums, NULL, &ndatums);
for (i = 0; i < ndatums; i++)
{
char *extName = TextDatumGetCString(textDatums[i]);
if (isnull)
elog(ERROR, "null indkey for index %u", indexId);
- deconstruct_array(DatumGetArrayTypeP(cols),
- INT2OID, 2, true, TYPALIGN_SHORT,
- &keys, NULL, &nKeys);
+ deconstruct_array_builtin(DatumGetArrayTypeP(cols), INT2OID,
+ &keys, NULL, &nKeys);
for (j = keyatts; j < nKeys; j++)
{
elog(ERROR, "null conexclop for constraint %u",
constraintId);
- deconstruct_array(DatumGetArrayTypeP(val),
- OIDOID, sizeof(Oid), true, TYPALIGN_INT,
- &elems, NULL, &nElems);
+ deconstruct_array_builtin(DatumGetArrayTypeP(val), OIDOID,
+ &elems, NULL, &nElems);
operators = (Oid *) palloc(nElems * sizeof(Oid));
for (i = 0; i < nElems; i++)
int j;
/* Extract data from array of int16 */
- deconstruct_array(DatumGetArrayTypeP(column_index_array),
- INT2OID, 2, true, TYPALIGN_SHORT,
- &keys, NULL, &nKeys);
+ deconstruct_array_builtin(DatumGetArrayTypeP(column_index_array), INT2OID,
+ &keys, NULL, &nKeys);
for (j = 0; j < nKeys; j++)
{
int noptions;
int i;
- deconstruct_array(DatumGetArrayTypeP(reloptions),
- TEXTOID, -1, false, TYPALIGN_INT,
- &options, NULL, &noptions);
+ deconstruct_array_builtin(DatumGetArrayTypeP(reloptions), TEXTOID,
+ &options, NULL, &noptions);
for (i = 0; i < noptions; i++)
{
memcpy(tsout, tsin, VARSIZE(tsin));
entry = ARRPTR(tsout);
- deconstruct_array(lexemes, TEXTOID, -1, false, TYPALIGN_INT,
- &dlexemes, &nulls, &nlexemes);
+ deconstruct_array_builtin(lexemes, TEXTOID, &dlexemes, &nulls, &nlexemes);
/*
* Assuming that lexemes array is significantly shorter than tsvector we
Datum *dlexemes;
bool *nulls;
- deconstruct_array(lexemes, TEXTOID, -1, false, TYPALIGN_INT,
- &dlexemes, &nulls, &nlex);
+ deconstruct_array_builtin(lexemes, TEXTOID, &dlexemes, &nulls, &nlex);
/*
* In typical use case array of lexemes to delete is relatively small. So
1));
}
- values[1] = PointerGetDatum(construct_array(positions, posv->npos,
- INT2OID, 2, true, TYPALIGN_SHORT));
- values[2] = PointerGetDatum(construct_array(weights, posv->npos,
- TEXTOID, -1, false, TYPALIGN_INT));
+ values[1] = PointerGetDatum(construct_array_builtin(positions, posv->npos, INT2OID));
+ values[2] = PointerGetDatum(construct_array_builtin(weights, posv->npos, TEXTOID));
}
else
{
arrin[i].len));
}
- array = construct_array(elements, tsin->size, TEXTOID, -1, false, TYPALIGN_INT);
+ array = construct_array_builtin(elements, tsin->size, TEXTOID);
pfree(elements);
PG_FREE_IF_COPY(tsin, 0);
datalen = 0;
char *cur;
- deconstruct_array(v, TEXTOID, -1, false, TYPALIGN_INT, &dlexemes, &nulls, &nitems);
+ deconstruct_array_builtin(v, TEXTOID, &dlexemes, &nulls, &nitems);
/*
* Reject nulls and zero length strings (maybe we should just ignore them,
int cur_pos = 0;
char mask = 0;
- deconstruct_array(weights, CHAROID, 1, true, TYPALIGN_CHAR,
- &dweights, &nulls, &nweights);
+ deconstruct_array_builtin(weights, CHAROID, &dweights, &nulls, &nweights);
for (i = 0; i < nweights; i++)
{
Assert(ARR_ELEMTYPE(namespaces) == TEXTOID);
- deconstruct_array(namespaces, TEXTOID, -1, false, TYPALIGN_INT,
- &ns_names_uris, &ns_names_uris_nulls,
- &ns_count);
+ deconstruct_array_builtin(namespaces, TEXTOID,
+ &ns_names_uris, &ns_names_uris_nulls,
+ &ns_count);
Assert((ns_count % 2) == 0); /* checked above */
ns_count /= 2; /* count pairs only */
if (ARR_NDIM(arr) != 1 || ARR_HASNULL(arr) || ARR_ELEMTYPE(arr) != TEXTOID)
elog(ERROR, "expected 1-D text array");
- deconstruct_array(arr, TEXTOID, -1, false, TYPALIGN_INT,
- &elems, NULL, &nelems);
+ deconstruct_array_builtin(arr, TEXTOID, &elems, NULL, &nelems);
for (bms = NULL, i = 0; i < nelems; ++i)
{
*p_argnames = NULL;
else
{
- deconstruct_array(DatumGetArrayTypeP(proargnames),
- TEXTOID, -1, false, TYPALIGN_INT,
- &elems, NULL, &nelems);
+ deconstruct_array_builtin(DatumGetArrayTypeP(proargnames), TEXTOID,
+ &elems, NULL, &nelems);
if (nelems != numargs) /* should not happen */
elog(ERROR, "proargnames must have the same number of elements as the function has arguments");
*p_argnames = (char **) palloc(sizeof(char *) * numargs);
ARR_HASNULL(arr) ||
ARR_ELEMTYPE(arr) != TEXTOID)
elog(ERROR, "proargnames is not a 1-D text array or it contains nulls");
- deconstruct_array(arr, TEXTOID, -1, false, TYPALIGN_INT,
- &argnames, NULL, &numargs);
+ deconstruct_array_builtin(arr, TEXTOID, &argnames, NULL, &numargs);
if (proargmodes != PointerGetDatum(NULL))
{
arr = DatumGetArrayTypeP(proargmodes); /* ensure not toasted */
ARR_ELEMTYPE(arr) != TEXTOID)
elog(ERROR, "proargnames is not a 1-D text array of length %d or it contains nulls",
numargs);
- deconstruct_array(arr, TEXTOID, -1, false, TYPALIGN_INT,
- &argnames, NULL, &nargnames);
+ deconstruct_array_builtin(arr, TEXTOID, &argnames, NULL, &nargnames);
Assert(nargnames == numargs);
/* scan for output argument(s) */
ARR_ELEMTYPE(arr) != TEXTOID)
elog(ERROR, "proargnames is not a 1-D text array of length %d or it contains nulls",
numargs);
- deconstruct_array(arr, TEXTOID, -1, false, TYPALIGN_INT,
- &argnames, NULL, &nargnames);
+ deconstruct_array_builtin(arr, TEXTOID, &argnames, NULL, &nargnames);
Assert(nargnames == numargs);
}
Assert(cnt <= MAX_GUC_FLAGS);
/* Returns the record as Datum */
- a = construct_array(flags, cnt, TEXTOID, -1, false, TYPALIGN_INT);
+ a = construct_array_builtin(flags, cnt, TEXTOID);
PG_RETURN_ARRAYTYPE_P(a);
}
TYPALIGN_INT /* TEXT's typalign */ );
}
else
- a = construct_array(&datum, 1,
- TEXTOID,
- -1, false, TYPALIGN_INT);
+ a = construct_array_builtin(&datum, 1, TEXTOID);
return a;
}
false /* TEXT's typbyval */ ,
TYPALIGN_INT /* TEXT's typalign */ );
else
- newarray = construct_array(&d, 1,
- TEXTOID,
- -1, false, TYPALIGN_INT);
+ newarray = construct_array_builtin(&d, 1, TEXTOID);
index++;
}
false /* TEXT's typbyval */ ,
TYPALIGN_INT /* TEXT's typalign */ );
else
- newarray = construct_array(&d, 1,
- TEXTOID,
- -1, false, TYPALIGN_INT);
+ newarray = construct_array_builtin(&d, 1, TEXTOID);
index++;
pfree(val);
extern ArrayType *construct_array(Datum *elems, int nelems,
Oid elmtype,
int elmlen, bool elmbyval, char elmalign);
+extern ArrayType *construct_array_builtin(Datum *elems, int nelems, Oid elmtype);
extern ArrayType *construct_md_array(Datum *elems,
bool *nulls,
int ndims,
Oid elmtype,
int elmlen, bool elmbyval, char elmalign,
Datum **elemsp, bool **nullsp, int *nelemsp);
+extern void deconstruct_array_builtin(ArrayType *array,
+ Oid elmtype,
+ Datum **elemsp, bool **nullsp, int *nelemsp);
extern bool array_contains_nulls(ArrayType *array);
extern ArrayBuildState *initArrayResult(Oid element_type,
policy->policy_name = pstrdup("extension policy");
policy->polcmd = '*';
- policy->roles = construct_array(&role, 1, OIDOID, sizeof(Oid), true, TYPALIGN_INT);
+ policy->roles = construct_array_builtin(&role, 1, OIDOID);
/*
* policy->qual = (Expr *) makeConst(BOOLOID, -1, InvalidOid,
policy->policy_name = pstrdup("extension policy");
policy->polcmd = '*';
- policy->roles = construct_array(&role, 1, OIDOID, sizeof(Oid), true, TYPALIGN_INT);
+ policy->roles = construct_array_builtin(&role, 1, OIDOID);
n = makeFuncCall(list_make2(makeString("pg_catalog"),
makeString("current_user")),
projects / postgresql.git / commitdiff