/*
* regexp_split_to_array()
* Split the string at matches of the pattern, returning the
* split-out substrings as an array.
*/
Datum
regexp_split_to_array(PG_FUNCTION_ARGS)
{
ArrayBuildState *astate = NULL;
regexp_matches_ctx *splitctx;
splitctx = setup_regexp_matches(PG_GETARG_TEXT_PP(0),
PG_GETARG_TEXT_PP(1),
PG_GETARG_TEXT_PP_IF_EXISTS(2),
PG_GET_COLLATION(),
true, false, true);
while (splitctx->next_match <= splitctx->nmatches)
{
astate = accumArrayResult(astate,
build_regexp_split_result(splitctx),
false,
TEXTOID,
CurrentMemoryContext);
splitctx->next_match++;
}
/*
* We don't call cleanup_regexp_matches here; it would try to pfree the
* input string, which we didn't copy. The space is not in a long-lived
* memory context anyway.
*/
PG_RETURN_ARRAYTYPE_P(makeArrayResult(astate, CurrentMemoryContext));
}
Datum
dbms_output_get_lines(PG_FUNCTION_ARGS)
{
TupleDesc tupdesc;
Datum result;
HeapTuple tuple;
Datum values[2];
bool nulls[2] = { false, false };
text *line;
int32 max_lines = PG_GETARG_INT32(0);
int32 n;
ArrayBuildState *astate = NULL;
/* Build a tuple descriptor for our result type */
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
elog(ERROR, "return type must be a row type");
for (n = 0; n < max_lines && (line = dbms_output_next()) != NULL; n++)
{
astate = accumArrayResult(astate, PointerGetDatum(line), false,
TEXTOID, CurrentMemoryContext);
}
/* 0: lines as text array */
if (n > 0)
values[0] = makeArrayResult(astate, CurrentMemoryContext);
else
{
int16 typlen;
bool typbyval;
char typalign;
ArrayType *arr;
get_typlenbyvalalign(TEXTOID, &typlen, &typbyval, &typalign);
arr = construct_md_array(
NULL,
#if PG_VERSION_NUM >= 80200
NULL,
#endif
0, NULL, NULL, TEXTOID, typlen, typbyval, typalign);
values[0] = PointerGetDatum(arr);
}
/* 1: # of lines as integer */
values[1] = Int32GetDatum(n);
tuple = heap_form_tuple(tupdesc, values, nulls);
result = HeapTupleGetDatum(tuple);
PG_RETURN_DATUM(result);
}
static Datum
int32_to_array(FunctionCallInfo fcinfo, int32 * d, int len) {
ArrayBuildState *astate = NULL;
int i;
for (i = 0; i < len; i++) {
/* stash away this field */
astate = accumArrayResult(astate,
Int32GetDatum(d[i]),
false,
INT4OID,
CurrentMemoryContext);
}
PG_RETURN_ARRAYTYPE_P(makeArrayResult(astate,
CurrentMemoryContext));
}
/*
* regexp_split_to_array()
* Split the string at matches of the pattern, returning the
* split-out substrings as an array.
*/
Datum
regexp_split_to_array(PG_FUNCTION_ARGS)
{
ArrayBuildState *astate = NULL;
regexp_matches_ctx *splitctx;
splitctx = setup_regexp_matches(PG_GETARG_TEXT_PP(0),
PG_GETARG_TEXT_PP(1),
PG_GETARG_TEXT_PP_IF_EXISTS(2),
PG_GET_COLLATION(),
true, false, true, true);
while (splitctx->next_match <= splitctx->nmatches)
{
astate = accumArrayResult(astate,
build_regexp_split_result(splitctx),
false,
TEXTOID,
CurrentMemoryContext);
splitctx->next_match++;
}
PG_RETURN_ARRAYTYPE_P(makeArrayResult(astate, CurrentMemoryContext));
}
/*
* tuple_data_split_internal
*
* Split raw tuple data taken directly from a page into an array of bytea
* elements. This routine does a lookup on NULL values and creates array
* elements accordingly. This is a reimplementation of nocachegetattr()
* in heaptuple.c simplified for educational purposes.
*/
static Datum
tuple_data_split_internal(Oid relid, char *tupdata,
uint16 tupdata_len, uint16 t_infomask,
uint16 t_infomask2, bits8 *t_bits,
bool do_detoast)
{
ArrayBuildState *raw_attrs;
int nattrs;
int i;
int off = 0;
Relation rel;
TupleDesc tupdesc;
/* Get tuple descriptor from relation OID */
rel = relation_open(relid, AccessShareLock);
tupdesc = RelationGetDescr(rel);
raw_attrs = initArrayResult(BYTEAOID, CurrentMemoryContext, false);
nattrs = tupdesc->natts;
if (nattrs < (t_infomask2 & HEAP_NATTS_MASK))
ereport(ERROR,
(errcode(ERRCODE_DATA_CORRUPTED),
errmsg("number of attributes in tuple header is greater than number of attributes in tuple descriptor")));
for (i = 0; i < nattrs; i++)
{
Form_pg_attribute attr;
bool is_null;
bytea *attr_data = NULL;
attr = TupleDescAttr(tupdesc, i);
/*
* Tuple header can specify less attributes than tuple descriptor as
* ALTER TABLE ADD COLUMN without DEFAULT keyword does not actually
* change tuples in pages, so attributes with numbers greater than
* (t_infomask2 & HEAP_NATTS_MASK) should be treated as NULL.
*/
if (i >= (t_infomask2 & HEAP_NATTS_MASK))
is_null = true;
else
is_null = (t_infomask & HEAP_HASNULL) && att_isnull(i, t_bits);
if (!is_null)
{
int len;
if (attr->attlen == -1)
{
off = att_align_pointer(off, attr->attalign, -1,
tupdata + off);
/*
* As VARSIZE_ANY throws an exception if it can't properly
* detect the type of external storage in macros VARTAG_SIZE,
* this check is repeated to have a nicer error handling.
*/
if (VARATT_IS_EXTERNAL(tupdata + off) &&
!VARATT_IS_EXTERNAL_ONDISK(tupdata + off) &&
!VARATT_IS_EXTERNAL_INDIRECT(tupdata + off))
ereport(ERROR,
(errcode(ERRCODE_DATA_CORRUPTED),
errmsg("first byte of varlena attribute is incorrect for attribute %d", i)));
len = VARSIZE_ANY(tupdata + off);
}
else
{
off = att_align_nominal(off, attr->attalign);
len = attr->attlen;
}
if (tupdata_len < off + len)
ereport(ERROR,
(errcode(ERRCODE_DATA_CORRUPTED),
errmsg("unexpected end of tuple data")));
if (attr->attlen == -1 && do_detoast)
attr_data = DatumGetByteaPCopy(tupdata + off);
else
{
attr_data = (bytea *) palloc(len + VARHDRSZ);
SET_VARSIZE(attr_data, len + VARHDRSZ);
memcpy(VARDATA(attr_data), tupdata + off, len);
}
off = att_addlength_pointer(off, attr->attlen,
tupdata + off);
}
raw_attrs = accumArrayResult(raw_attrs, PointerGetDatum(attr_data),
is_null, BYTEAOID, CurrentMemoryContext);
if (attr_data)
pfree(attr_data);
}
if (tupdata_len != off)
ereport(ERROR,
(errcode(ERRCODE_DATA_CORRUPTED),
errmsg("end of tuple reached without looking at all its data")));
relation_close(rel, AccessShareLock);
return makeArrayResult(raw_attrs, CurrentMemoryContext);
}
/*-----------------------------------------------------------------------------
* array_positions :
* return an array of positions of a value in an array.
*
* IS NOT DISTINCT FROM semantics are used for comparisons. Returns NULL when
* the input array is NULL. When the value is not found in the array, returns
* an empty array.
*
* This is not strict so we have to test for null inputs explicitly.
*-----------------------------------------------------------------------------
*/
Datum
array_positions(PG_FUNCTION_ARGS)
{
ArrayType *array;
Oid collation = PG_GET_COLLATION();
Oid element_type;
Datum searched_element,
value;
bool isnull;
int position;
TypeCacheEntry *typentry;
ArrayMetaState *my_extra;
bool null_search;
ArrayIterator array_iterator;
ArrayBuildState *astate = NULL;
if (PG_ARGISNULL(0))
PG_RETURN_NULL();
array = PG_GETARG_ARRAYTYPE_P(0);
element_type = ARR_ELEMTYPE(array);
position = (ARR_LBOUND(array))[0] - 1;
/*
* We refuse to search for elements in multi-dimensional arrays, since we
* have no good way to report the element's location in the array.
*/
if (ARR_NDIM(array) > 1)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("searching for elements in multidimensional arrays is not supported")));
astate = initArrayResult(INT4OID, CurrentMemoryContext, false);
if (PG_ARGISNULL(1))
{
/* fast return when the array doesn't have nulls */
if (!array_contains_nulls(array))
PG_RETURN_DATUM(makeArrayResult(astate, CurrentMemoryContext));
searched_element = (Datum) 0;
null_search = true;
}
else
{
searched_element = PG_GETARG_DATUM(1);
null_search = false;
}
/*
* We arrange to look up type info for array_create_iterator only once per
* series of calls, assuming the element type doesn't change underneath
* us.
*/
my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
if (my_extra == NULL)
{
fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
sizeof(ArrayMetaState));
my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
my_extra->element_type = ~element_type;
}
if (my_extra->element_type != element_type)
{
get_typlenbyvalalign(element_type,
&my_extra->typlen,
&my_extra->typbyval,
&my_extra->typalign);
typentry = lookup_type_cache(element_type, TYPECACHE_EQ_OPR_FINFO);
if (!OidIsValid(typentry->eq_opr_finfo.fn_oid))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_FUNCTION),
errmsg("could not identify an equality operator for type %s",
format_type_be(element_type))));
my_extra->element_type = element_type;
fmgr_info_cxt(typentry->eq_opr_finfo.fn_oid, &my_extra->proc,
fcinfo->flinfo->fn_mcxt);
}
/*
* Accumulate each array position iff the element matches the given
* element.
*/
array_iterator = array_create_iterator(array, 0, my_extra);
while (array_iterate(array_iterator, &value, &isnull))
{
position += 1;
/*
* Can't look at the array element's value if it's null; but if we
* search for null, we have a hit.
*/
if (isnull || null_search)
{
if (isnull && null_search)
astate =
accumArrayResult(astate, Int32GetDatum(position), false,
INT4OID, CurrentMemoryContext);
continue;
}
/* not nulls, so run the operator */
if (DatumGetBool(FunctionCall2Coll(&my_extra->proc, collation,
searched_element, value)))
astate =
accumArrayResult(astate, Int32GetDatum(position), false,
INT4OID, CurrentMemoryContext);
}
array_free_iterator(array_iterator);
/* Avoid leaking memory when handed toasted input */
PG_FREE_IF_COPY(array, 0);
PG_RETURN_DATUM(makeArrayResult(astate, CurrentMemoryContext));
}
/*
* Return a datum that is array of "name=value" strings for each
* appendonly storage option in opts. This datum is used to populate
* pg_class.reloptions during relation creation.
*
* To avoid catalog bloat, we only create "name=value" item for those
* values in opts that are not specified in WITH clause and are
* different from their initial defaults.
*/
Datum
transformAOStdRdOptions(StdRdOptions *opts, Datum withOpts)
{
char *strval;
char intval[MAX_SOPT_VALUE_LEN];
Datum *withDatums = NULL;
text *t;
int len,
i,
withLen,
soptLen,
nWithOpts = 0;
ArrayType *withArr;
ArrayBuildState *astate = NULL;
bool foundAO = false,
foundBlksz = false,
foundComptype = false,
foundComplevel = false,
foundChecksum = false,
foundOrientation = false;
/*
* withOpts must be parsed to see if an option was spcified in WITH()
* clause.
*/
if (DatumGetPointer(withOpts) != NULL)
{
withArr = DatumGetArrayTypeP(withOpts);
Assert(ARR_ELEMTYPE(withArr) == TEXTOID);
deconstruct_array(withArr, TEXTOID, -1, false, 'i', &withDatums,
NULL, &nWithOpts);
/*
* Include options specified in WITH() clause in the same order as
* they are specified. Otherwise we will end up with regression
* failures due to diff with respect to answer file.
*/
for (i = 0; i < nWithOpts; ++i)
{
t = DatumGetTextP(withDatums[i]);
strval = VARDATA(t);
/*
* Text datums are usually not null terminated. We must never
* access beyond their length.
*/
withLen = VARSIZE(t) - VARHDRSZ;
/*
* withDatums[i] may not be used directly. It may be e.g.
* "aPPendOnly=tRue". Therefore we don't set it as reloptions as
* is.
*/
soptLen = strlen(SOPT_APPENDONLY);
if (withLen > soptLen &&
pg_strncasecmp(strval, SOPT_APPENDONLY, soptLen) == 0)
{
foundAO = true;
strval = opts->appendonly ? "true" : "false";
len = VARHDRSZ + strlen(SOPT_APPENDONLY) + 1 + strlen(strval);
/* +1 leaves room for sprintf's trailing null */
t = (text *) palloc(len + 1);
SET_VARSIZE(t, len);
sprintf(VARDATA(t), "%s=%s", SOPT_APPENDONLY, strval);
astate = accumArrayResult(astate, PointerGetDatum(t), false,
TEXTOID, CurrentMemoryContext);
}
soptLen = strlen(SOPT_BLOCKSIZE);
if (withLen > soptLen &&
pg_strncasecmp(strval, SOPT_BLOCKSIZE, soptLen) == 0)
{
foundBlksz = true;
snprintf(intval, MAX_SOPT_VALUE_LEN, "%d", opts->blocksize);
len = VARHDRSZ + strlen(SOPT_BLOCKSIZE) + 1 + strlen(intval);
/* +1 leaves room for sprintf's trailing null */
t = (text *) palloc(len + 1);
SET_VARSIZE(t, len);
sprintf(VARDATA(t), "%s=%s", SOPT_BLOCKSIZE, intval);
astate = accumArrayResult(astate, PointerGetDatum(t), false,
TEXTOID, CurrentMemoryContext);
}
soptLen = strlen(SOPT_COMPTYPE);
if (withLen > soptLen &&
pg_strncasecmp(strval, SOPT_COMPTYPE, soptLen) == 0)
{
foundComptype = true;
/*
* Record "none" as compresstype in reloptions if it was
* explicitly specified in WITH clause.
*/
strval = (opts->compresstype != NULL) ?
opts->compresstype : "none";
len = VARHDRSZ + strlen(SOPT_COMPTYPE) + 1 + strlen(strval);
/* +1 leaves room for sprintf's trailing null */
t = (text *) palloc(len + 1);
SET_VARSIZE(t, len);
sprintf(VARDATA(t), "%s=%s", SOPT_COMPTYPE, strval);
astate = accumArrayResult(astate, PointerGetDatum(t), false,
TEXTOID, CurrentMemoryContext);
}
soptLen = strlen(SOPT_COMPLEVEL);
if (withLen > soptLen &&
pg_strncasecmp(strval, SOPT_COMPLEVEL, soptLen) == 0)
{
foundComplevel = true;
snprintf(intval, MAX_SOPT_VALUE_LEN, "%d", opts->compresslevel);
len = VARHDRSZ + strlen(SOPT_COMPLEVEL) + 1 + strlen(intval);
/* +1 leaves room for sprintf's trailing null */
t = (text *) palloc(len + 1);
SET_VARSIZE(t, len);
sprintf(VARDATA(t), "%s=%s", SOPT_COMPLEVEL, intval);
astate = accumArrayResult(astate, PointerGetDatum(t), false,
TEXTOID, CurrentMemoryContext);
}
soptLen = strlen(SOPT_CHECKSUM);
if (withLen > soptLen &&
pg_strncasecmp(strval, SOPT_CHECKSUM, soptLen) == 0)
{
foundChecksum = true;
strval = opts->checksum ? "true" : "false";
len = VARHDRSZ + strlen(SOPT_CHECKSUM) + 1 + strlen(strval);
/* +1 leaves room for sprintf's trailing null */
t = (text *) palloc(len + 1);
SET_VARSIZE(t, len);
sprintf(VARDATA(t), "%s=%s", SOPT_CHECKSUM, strval);
astate = accumArrayResult(astate, PointerGetDatum(t), false,
TEXTOID, CurrentMemoryContext);
}
soptLen = strlen(SOPT_ORIENTATION);
if (withLen > soptLen &&
pg_strncasecmp(strval, SOPT_ORIENTATION, soptLen) == 0)
{
foundOrientation = true;
strval = opts->columnstore ? "column" : "row";
len = VARHDRSZ + strlen(SOPT_ORIENTATION) + 1 + strlen(strval);
/* +1 leaves room for sprintf's trailing null */
t = (text *) palloc(len + 1);
SET_VARSIZE(t, len);
sprintf(VARDATA(t), "%s=%s", SOPT_ORIENTATION, strval);
astate = accumArrayResult(astate, PointerGetDatum(t), false,
TEXTOID, CurrentMemoryContext);
}
/*
* Record fillfactor only if it's specified in WITH clause.
* Default fillfactor is assumed otherwise.
*/
soptLen = strlen(SOPT_FILLFACTOR);
if (withLen > soptLen &&
pg_strncasecmp(strval, SOPT_FILLFACTOR, soptLen) == 0)
{
snprintf(intval, MAX_SOPT_VALUE_LEN, "%d", opts->fillfactor);
len = VARHDRSZ + strlen(SOPT_FILLFACTOR) + 1 + strlen(intval);
/* +1 leaves room for sprintf's trailing null */
t = (text *) palloc(len + 1);
SET_VARSIZE(t, len);
sprintf(VARDATA(t), "%s=%s", SOPT_FILLFACTOR, intval);
astate = accumArrayResult(astate, PointerGetDatum(t), false,
TEXTOID, CurrentMemoryContext);
}
}
}
/* Include options that are not defaults and not already included. */
if ((opts->appendonly != AO_DEFAULT_APPENDONLY) && !foundAO)
{
/* appendonly */
strval = opts->appendonly ? "true" : "false";
len = VARHDRSZ + strlen(SOPT_APPENDONLY) + 1 + strlen(strval);
/* +1 leaves room for sprintf's trailing null */
t = (text *) palloc(len + 1);
SET_VARSIZE(t, len);
sprintf(VARDATA(t), "%s=%s", SOPT_APPENDONLY, strval);
astate = accumArrayResult(astate, PointerGetDatum(t),
false, TEXTOID,
CurrentMemoryContext);
}
if ((opts->blocksize != AO_DEFAULT_BLOCKSIZE) && !foundBlksz)
{
/* blocksize */
snprintf(intval, MAX_SOPT_VALUE_LEN, "%d", opts->blocksize);
len = VARHDRSZ + strlen(SOPT_BLOCKSIZE) + 1 + strlen(intval);
/* +1 leaves room for sprintf's trailing null */
t = (text *) palloc(len + 1);
SET_VARSIZE(t, len);
sprintf(VARDATA(t), "%s=%s", SOPT_BLOCKSIZE, intval);
astate = accumArrayResult(astate, PointerGetDatum(t),
false, TEXTOID,
CurrentMemoryContext);
}
/*
* Record compression options only if compression is enabled. No need to
* check compresstype here as by the time we get here, "opts" should have
* been set by default_reloptions() correctly.
*/
if (opts->compresslevel > AO_DEFAULT_COMPRESSLEVEL &&
opts->compresstype != NULL)
{
if (!foundComptype && (
(pg_strcasecmp(opts->compresstype, AO_DEFAULT_COMPRESSTYPE) == 0
&& opts->compresslevel == 1 && !foundComplevel) ||
pg_strcasecmp(opts->compresstype,
AO_DEFAULT_COMPRESSTYPE) != 0))
{
/* compress type */
strval = opts->compresstype;
len = VARHDRSZ + strlen(SOPT_COMPTYPE) + 1 + strlen(strval);
/* +1 leaves room for sprintf's trailing null */
t = (text *) palloc(len + 1);
SET_VARSIZE(t, len);
sprintf(VARDATA(t), "%s=%s", SOPT_COMPTYPE, strval);
astate = accumArrayResult(astate, PointerGetDatum(t),
false, TEXTOID,
CurrentMemoryContext);
}
/* When compression is enabled, default compresslevel is 1. */
if ((opts->compresslevel != 1) &&
!foundComplevel)
{
/* compress level */
snprintf(intval, MAX_SOPT_VALUE_LEN, "%d", opts->compresslevel);
len = VARHDRSZ + strlen(SOPT_COMPLEVEL) + 1 + strlen(intval);
/* +1 leaves room for sprintf's trailing null */
t = (text *) palloc(len + 1);
SET_VARSIZE(t, len);
sprintf(VARDATA(t), "%s=%s", SOPT_COMPLEVEL, intval);
astate = accumArrayResult(astate, PointerGetDatum(t),
false, TEXTOID,
CurrentMemoryContext);
}
}
if ((opts->checksum != AO_DEFAULT_CHECKSUM) && !foundChecksum)
{
/* checksum */
strval = opts->checksum ? "true" : "false";
len = VARHDRSZ + strlen(SOPT_CHECKSUM) + 1 + strlen(strval);
/* +1 leaves room for sprintf's trailing null */
t = (text *) palloc(len + 1);
SET_VARSIZE(t, len);
sprintf(VARDATA(t), "%s=%s", SOPT_CHECKSUM, strval);
astate = accumArrayResult(astate, PointerGetDatum(t),
false, TEXTOID,
CurrentMemoryContext);
}
if ((opts->columnstore != AO_DEFAULT_COLUMNSTORE) && !foundOrientation)
{
/* orientation */
strval = opts->columnstore ? "column" : "row";
len = VARHDRSZ + strlen(SOPT_ORIENTATION) + 1 + strlen(strval);
/* +1 leaves room for sprintf's trailing null */
t = (text *) palloc(len + 1);
SET_VARSIZE(t, len);
sprintf(VARDATA(t), "%s=%s", SOPT_ORIENTATION, strval);
astate = accumArrayResult(astate, PointerGetDatum(t),
false, TEXTOID,
CurrentMemoryContext);
}
return astate ?
makeArrayResult(astate, CurrentMemoryContext) :
PointerGetDatum(NULL);
}
