Datum __cmsketch_merge(PG_FUNCTION_ARGS)
{
bytea * counterblob1 = PG_GETARG_BYTEA_P(0);
bytea * counterblob2 = PG_GETARG_BYTEA_P(1);
cmtransval *transval1 = (cmtransval *)VARDATA(counterblob1);
cmtransval *transval2 = (cmtransval *)VARDATA(counterblob2);
cmtransval *newtrans;
countmin * sketches2 = (countmin *)
((cmtransval *)(VARDATA(counterblob2)))->sketches;
bytea * newblob;
countmin * newsketches;
uint32 i, j, k;
int sz;
/* make sure they're initialized! */
if (!CM_TRANSVAL_INITIALIZED(counterblob1)
&& !CM_TRANSVAL_INITIALIZED(counterblob2))
/* if both are empty can return one of them */
PG_RETURN_DATUM(PointerGetDatum(counterblob1));
else if (!CM_TRANSVAL_INITIALIZED(counterblob1)) {
counterblob1 = cmsketch_init_transval(transval2->typOid);
transval1 = (cmtransval *)VARDATA(counterblob1);
}
else if (!CM_TRANSVAL_INITIALIZED(counterblob2)) {
counterblob2 = cmsketch_init_transval(transval1->typOid);
transval2 = (cmtransval *)VARDATA(counterblob2);
}
sz = VARSIZE(counterblob1);
/* allocate a new transval as a copy of counterblob1 */
newblob = (bytea *)palloc(sz);
memcpy(newblob, counterblob1, sz);
newtrans = (cmtransval *)(VARDATA(newblob));
newsketches = (countmin *)(newtrans)->sketches;
/* add in values from counterblob2 */
for (i = 0; i < RANGES; i++)
for (j = 0; j < DEPTH; j++)
for (k = 0; k < NUMCOUNTERS; k++)
newsketches[i][j][k] += sketches2[i][j][k];
if (newtrans->nargs == -1) {
/* transfer in the args from the other input */
newtrans->nargs = transval2->nargs;
for (i = 0; (int)i < transval2->nargs; i++)
newtrans->args[i] = transval2->args[i];
}
PG_RETURN_DATUM(PointerGetDatum(newblob));
}
Datum
pg_decrypt_iv(PG_FUNCTION_ARGS)
{
int err;
bytea *data,
*key,
*iv,
*res;
text *type;
PX_Combo *c;
unsigned dlen,
klen,
rlen,
ivlen;
type = PG_GETARG_TEXT_P(3);
c = find_provider(type, (PFN) px_find_combo, "Cipher", 0);
data = PG_GETARG_BYTEA_P(0);
key = PG_GETARG_BYTEA_P(1);
iv = PG_GETARG_BYTEA_P(2);
dlen = VARSIZE(data) - VARHDRSZ;
klen = VARSIZE(key) - VARHDRSZ;
ivlen = VARSIZE(iv) - VARHDRSZ;
rlen = px_combo_decrypt_len(c, dlen);
res = palloc(VARHDRSZ + rlen);
err = px_combo_init(c, (uint8 *) VARDATA(key), klen,
(uint8 *) VARDATA(iv), ivlen);
if (!err)
px_combo_decrypt(c, (uint8 *) VARDATA(data), dlen,
(uint8 *) VARDATA(res), &rlen);
px_combo_free(c);
if (err)
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_INVOCATION_EXCEPTION),
errmsg("decrypt_iv error: %s", px_strerror(err))));
SET_VARSIZE(res, VARHDRSZ + rlen);
PG_FREE_IF_COPY(data, 0);
PG_FREE_IF_COPY(key, 1);
PG_FREE_IF_COPY(iv, 2);
PG_FREE_IF_COPY(type, 3);
PG_RETURN_BYTEA_P(res);
}
Datum
pg_encrypt(PG_FUNCTION_ARGS)
{
int err;
bytea *data,
*key,
*res;
text *type;
PX_Combo *c;
unsigned dlen,
klen,
rlen;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2))
PG_RETURN_NULL();
type = PG_GETARG_TEXT_P(2);
c = find_provider(type, (PFN) px_find_combo, "Cipher", 0);
data = PG_GETARG_BYTEA_P(0);
key = PG_GETARG_BYTEA_P(1);
dlen = VARSIZE(data) - VARHDRSZ;
klen = VARSIZE(key) - VARHDRSZ;
rlen = px_combo_encrypt_len(c, dlen);
res = palloc(VARHDRSZ + rlen);
err = px_combo_init(c, (uint8 *) VARDATA(key), klen, NULL, 0);
if (!err)
err = px_combo_encrypt(c, (uint8 *) VARDATA(data), dlen,
(uint8 *) VARDATA(res), &rlen);
px_combo_free(c);
PG_FREE_IF_COPY(data, 0);
PG_FREE_IF_COPY(key, 1);
PG_FREE_IF_COPY(type, 2);
if (err)
{
pfree(res);
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_INVOCATION_EXCEPTION),
errmsg("encrypt error: %s", px_strerror(err))));
}
VARATT_SIZEP(res) = VARHDRSZ + rlen;
PG_RETURN_BYTEA_P(res);
}
Datum
adaptive_counter_update(PG_FUNCTION_ARGS)
{
bytea * data;
AdaptiveCounter ac;
/* is the counter created (if not, create it - error 1%, 10mil items) */
if (PG_ARGISNULL(0)) {
ac = as_create(0.01, 4);
data = (bytea*)palloc(ac->length + VARHDRSZ);
SET_VARSIZE(data, ac->length);
memcpy(VARDATA(data), ac, ac->length);
elog(NOTICE, "Adaptive Counter: %d bytes", ac->length);
} else {
data = PG_GETARG_BYTEA_P(0);
}
ac = (AdaptiveCounter)VARDATA(data);
/* get the new item */
text * item = PG_GETARG_TEXT_P(1);
/* in-place update works only if executed as aggregate */
as_add_element(ac, VARDATA(item), VARSIZE(item) - VARHDRSZ);
/* return the updated bytea */
PG_RETURN_BYTEA_P(data);
}
Datum
lowrite(PG_FUNCTION_ARGS)
{
int32 fd = PG_GETARG_INT32(0);
bytea *wbuf = PG_GETARG_BYTEA_P(1);
int bytestowrite;
int totalwritten;
#ifdef PGXC
#ifdef XCP
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("Postgres-XL does not yet support large objects"),
errdetail("The feature is not currently supported")));
#else
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("Postgres-XC does not support large object yet"),
errdetail("The feature is not currently supported")));
#endif
#endif
bytestowrite = VARSIZE(wbuf) - VARHDRSZ;
totalwritten = lo_write(fd, VARDATA(wbuf), bytestowrite);
PG_RETURN_INT32(totalwritten);
}
Datum
brin_page_type(PG_FUNCTION_ARGS)
{
bytea *raw_page = PG_GETARG_BYTEA_P(0);
Page page = VARDATA(raw_page);
BrinSpecialSpace *special;
char *type;
special = (BrinSpecialSpace *) PageGetSpecialPointer(page);
switch (special->type)
{
case BRIN_PAGETYPE_META:
type = "meta";
break;
case BRIN_PAGETYPE_REVMAP:
type = "revmap";
break;
case BRIN_PAGETYPE_REGULAR:
type = "regular";
break;
default:
type = psprintf("unknown (%02x)", special->type);
break;
}
PG_RETURN_TEXT_P(cstring_to_text(type));
}
Datum
brin_page_type(PG_FUNCTION_ARGS)
{
bytea *raw_page = PG_GETARG_BYTEA_P(0);
Page page = VARDATA(raw_page);
char *type;
switch (BrinPageType(page))
{
case BRIN_PAGETYPE_META:
type = "meta";
break;
case BRIN_PAGETYPE_REVMAP:
type = "revmap";
break;
case BRIN_PAGETYPE_REGULAR:
type = "regular";
break;
default:
type = psprintf("unknown (%02x)", BrinPageType(page));
break;
}
PG_RETURN_TEXT_P(cstring_to_text(type));
}
/*
* This is the UDF interface. It does sanity checks and preps values
* for the interesting logic in countmin_dyadic_trans_c
*/
Datum __cmsketch_int8_trans(PG_FUNCTION_ARGS)
{
bytea * transblob = NULL;
cmtransval *transval;
/*
* This function makes destructive updates to its arguments.
* Make sure it's being called in an agg context.
*/
if (!(fcinfo->context &&
(IsA(fcinfo->context, AggState)
#ifdef NOTGP
|| IsA(fcinfo->context, WindowAggState)
#endif
)))
elog(ERROR,
"destructive pass by reference outside agg");
/* get the provided element, being careful in case it's NULL */
if (!PG_ARGISNULL(1)) {
transblob = cmsketch_check_transval(fcinfo, true);
transval = (cmtransval *)(VARDATA(transblob));
/* the following line modifies the contents of transval, and hence transblob */
countmin_dyadic_trans_c(transval, PG_GETARG_DATUM(1));
PG_RETURN_DATUM(PointerGetDatum(transblob));
}
else PG_RETURN_DATUM(PointerGetDatum(PG_GETARG_BYTEA_P(0)));
}
Datum
pg_armor(PG_FUNCTION_ARGS)
{
bytea *data;
text *res;
int data_len,
res_len,
guess_len;
data = PG_GETARG_BYTEA_P(0);
data_len = VARSIZE(data) - VARHDRSZ;
guess_len = pgp_armor_enc_len(data_len);
res = palloc(VARHDRSZ + guess_len);
res_len = pgp_armor_encode((uint8 *) VARDATA(data), data_len,
(uint8 *) VARDATA(res));
if (res_len > guess_len)
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_INVOCATION_EXCEPTION),
errmsg("Overflow - encode estimate too small")));
SET_VARSIZE(res, VARHDRSZ + res_len);
PG_FREE_IF_COPY(data, 0);
PG_RETURN_TEXT_P(res);
}
/*
* bytea_size
*
* Return the size of a bytea field, this data is useful to pass for
* to a function doing decompression like decompress_data() above.
*/
Datum
bytea_size(PG_FUNCTION_ARGS)
{
bytea *data = PG_GETARG_BYTEA_P(0);
PG_RETURN_INT32(VARSIZE(data) - VARHDRSZ);
}
Datum HASHAPI_Hash_1_Bytea(PG_FUNCTION_ARGS)
{
int32 num_segs; /* number of segments */
bytea *val1; /* bytea value */
unsigned int targetbucket; /* 0-based */
int16 algorithm; /* hashing algorithm */
Datum d1;
Oid oid;
/* Get number of segments */
num_segs = PG_GETARG_INT32(0);
/* Get hashing algoriithm */
algorithm = PG_GETARG_INT16(1);
/* Get the value to hash */
val1 = PG_GETARG_BYTEA_P(2);
d1 = PointerGetDatum(val1);
/* create a CdbHash for this hash test. */
h = makeCdbHash(num_segs, algorithm);
cdbhashinit(h);
oid = BYTEAOID;
cdbhash(h, d1, oid);
/* reduce the result hash value */
targetbucket = cdbhashreduce(h);
/* Avoid leaking memory for toasted inputs */
PG_FREE_IF_COPY(val1, 2);
PG_RETURN_INT32(targetbucket); /* return target bucket (segID) */
}
Datum
pg_digest(PG_FUNCTION_ARGS)
{
bytea *arg;
text *name;
unsigned len,
hlen;
PX_MD *md;
bytea *res;
name = PG_GETARG_TEXT_P(1);
/* will give error if fails */
md = find_provider(name, (PFN) px_find_digest, "Digest", 0);
hlen = px_md_result_size(md);
res = (text *) palloc(hlen + VARHDRSZ);
SET_VARSIZE(res, hlen + VARHDRSZ);
arg = PG_GETARG_BYTEA_P(0);
len = VARSIZE(arg) - VARHDRSZ;
px_md_update(md, (uint8 *) VARDATA(arg), len);
px_md_finish(md, (uint8 *) VARDATA(res));
px_md_free(md);
PG_FREE_IF_COPY(arg, 0);
PG_FREE_IF_COPY(name, 1);
PG_RETURN_BYTEA_P(res);
}
Datum
brin_metapage_info(PG_FUNCTION_ARGS)
{
bytea *raw_page = PG_GETARG_BYTEA_P(0);
Page page;
BrinMetaPageData *meta;
TupleDesc tupdesc;
Datum values[4];
bool nulls[4];
HeapTuple htup;
page = verify_brin_page(raw_page, BRIN_PAGETYPE_META, "metapage");
/* 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");
tupdesc = BlessTupleDesc(tupdesc);
/* Extract values from the metapage */
meta = (BrinMetaPageData *) PageGetContents(page);
MemSet(nulls, 0, sizeof(nulls));
values[0] = CStringGetTextDatum(psprintf("0x%08X", meta->brinMagic));
values[1] = Int32GetDatum(meta->brinVersion);
values[2] = Int32GetDatum(meta->pagesPerRange);
values[3] = Int64GetDatum(meta->lastRevmapPage);
htup = heap_form_tuple(tupdesc, values, nulls);
PG_RETURN_DATUM(HeapTupleGetDatum(htup));
}
Datum
binary_encode(PG_FUNCTION_ARGS)
{
bytea *data = PG_GETARG_BYTEA_P(0);
Datum name = PG_GETARG_DATUM(1);
text *result;
char *namebuf;
int datalen,
resultlen,
res;
const struct pg_encoding *enc;
datalen = VARSIZE(data) - VARHDRSZ;
namebuf = TextDatumGetCString(name);
enc = pg_find_encoding(namebuf);
if (enc == NULL)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("unrecognized encoding: \"%s\"", namebuf)));
resultlen = enc->encode_len(VARDATA(data), datalen);
result = palloc(VARHDRSZ + resultlen);
res = enc->encode(VARDATA(data), datalen, VARDATA(result));
/* Make this FATAL 'cause we've trodden on memory ... */
if (res > resultlen)
elog(FATAL, "overflow - encode estimate too small");
SET_VARSIZE(result, VARHDRSZ + res);
PG_RETURN_TEXT_P(result);
}
Datum x509_get_serial_number(PG_FUNCTION_ARGS) {
bytea *raw;
bytea *result;
BIGNUM *bn;
X509 *cert;
// check for null value.
raw = PG_GETARG_BYTEA_P(0);
if (raw == NULL || VARSIZE(raw) == VARHDRSZ) {
PG_RETURN_NULL();
}
cert = x509_from_bytea(raw);
if (cert == NULL) {
ereport(ERROR,
(errcode(ERRCODE_DATA_CORRUPTED), errmsg(
"unable to decode X509 record")));
}
bn = ASN1_INTEGER_to_BN(X509_get_serialNumber(cert), NULL);
result = bn_to_bytea(bn);
BN_free(bn);
X509_free(cert);
PG_RETURN_BYTEA_P(result);
}
Datum
fsm_page_contents(PG_FUNCTION_ARGS)
{
bytea *raw_page = PG_GETARG_BYTEA_P(0);
StringInfoData sinfo;
FSMPage fsmpage;
int i;
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
(errmsg("must be superuser to use raw page functions"))));
fsmpage = (FSMPage) PageGetContents(VARDATA(raw_page));
initStringInfo(&sinfo);
for (i = 0; i < NodesPerPage; i++)
{
if (fsmpage->fp_nodes[i] != 0)
appendStringInfo(&sinfo, "%d: %d\n", i, fsmpage->fp_nodes[i]);
}
appendStringInfo(&sinfo, "fp_next_slot: %d\n", fsmpage->fp_next_slot);
PG_RETURN_TEXT_P(cstring_to_text_with_len(sinfo.data, sinfo.len));
}
Datum LWGEOM_from_WKB(PG_FUNCTION_ARGS)
{
bytea *bytea_wkb = (bytea*)PG_GETARG_BYTEA_P(0);
int32 srid = 0;
GSERIALIZED *geom;
LWGEOM *lwgeom;
uint8_t *wkb = (uint8_t*)VARDATA(bytea_wkb);
lwgeom = lwgeom_from_wkb(wkb, VARSIZE(bytea_wkb)-VARHDRSZ, LW_PARSER_CHECK_ALL);
if ( lwgeom_needs_bbox(lwgeom) )
lwgeom_add_bbox(lwgeom);
geom = geometry_serialize(lwgeom);
lwgeom_free(lwgeom);
PG_FREE_IF_COPY(bytea_wkb, 0);
if ( gserialized_get_srid(geom) != SRID_UNKNOWN )
{
elog(WARNING, "OGC WKB expected, EWKB provided - use GeometryFromEWKB() for this");
}
if ( PG_NARGS() > 1 )
{
srid = PG_GETARG_INT32(1);
if ( srid != gserialized_get_srid(geom) )
gserialized_set_srid(geom, srid);
}
PG_RETURN_POINTER(geom);
}
Datum is_valid_mol_pkl(PG_FUNCTION_ARGS) {
bytea *data = PG_GETARG_BYTEA_P(0);
int len = VARSIZE(data) - VARHDRSZ;
bool res = isValidMolBlob(VARDATA(data), len);
PG_FREE_IF_COPY(data, 0);
PG_RETURN_BOOL(res);
}
Datum
gin_metapage_info(PG_FUNCTION_ARGS)
{
bytea *raw_page = PG_GETARG_BYTEA_P(0);
int raw_page_size;
TupleDesc tupdesc;
Page page;
GinPageOpaque opaq;
GinMetaPageData *metadata;
HeapTuple resultTuple;
Datum values[10];
bool nulls[10];
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
(errmsg("must be superuser to use raw page functions"))));
raw_page_size = VARSIZE(raw_page) - VARHDRSZ;
if (raw_page_size < BLCKSZ)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("input page too small (%d bytes)", raw_page_size)));
page = VARDATA(raw_page);
opaq = (GinPageOpaque) PageGetSpecialPointer(page);
if (opaq->flags != GIN_META)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("input page is not a GIN metapage"),
errdetail("Flags %04X, expected %04X",
opaq->flags, GIN_META)));
/* 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");
metadata = GinPageGetMeta(page);
memset(nulls, 0, sizeof(nulls));
values[0] = Int64GetDatum(metadata->head);
values[1] = Int64GetDatum(metadata->tail);
values[2] = Int32GetDatum(metadata->tailFreeSize);
values[3] = Int64GetDatum(metadata->nPendingPages);
values[4] = Int64GetDatum(metadata->nPendingHeapTuples);
/* statistics, updated by VACUUM */
values[5] = Int64GetDatum(metadata->nTotalPages);
values[6] = Int64GetDatum(metadata->nEntryPages);
values[7] = Int64GetDatum(metadata->nDataPages);
values[8] = Int64GetDatum(metadata->nEntries);
values[9] = Int32GetDatum(metadata->ginVersion);
/* Build and return the result tuple. */
resultTuple = heap_form_tuple(tupdesc, values, nulls);
return HeapTupleGetDatum(resultTuple);
}
Datum
adaptive_get_error(PG_FUNCTION_ARGS)
{
/* return the error rate of the counter */
PG_RETURN_FLOAT4(((AdaptiveCounter)PG_GETARG_BYTEA_P(0))->error);
}
Datum hll_merge(PG_FUNCTION_ARGS) {
bytea *state;
uint32_t *sdata;
bytea *value = PG_GETARG_BYTEA_P(1);
uint32_t *vdata = (uint32_t *) VARDATA(value);
if ( PG_ARGISNULL(0) ) {
PG_RETURN_BYTEA_P(value);
} else {
state = PG_GETARG_BYTEA_P(0);
sdata = (uint32_t *) VARDATA(state);
}
merge_sets(1 << sdata[0], vdata + 2, sdata + 2);
PG_RETURN_BYTEA_P(state);
}
Datum
tdigest_add(PG_FUNCTION_ARGS)
{
TDigest *t = tdigest_unpack(PG_GETARG_BYTEA_P(0));
float8 incoming = PG_GETARG_FLOAT8(1);
TDigestAdd(t, incoming, 1);
fcinfo->nargs = 1;
fcinfo->arg[0] = PointerGetDatum(t);
return tdigest_send(fcinfo);
}
Datum
adaptive_get_ndistinct(PG_FUNCTION_ARGS)
{
AdaptiveCounter ac = (AdaptiveCounter)PG_GETARG_BYTEA_P(0);
/* return the updated bytea */
PG_RETURN_INT32(ac->ndistinct);
}
Datum
probabilistic_merge_simple(PG_FUNCTION_ARGS)
{
ProbabilisticCounter counter1 = (ProbabilisticCounter)PG_GETARG_BYTEA_P(0);
ProbabilisticCounter counter2 = (ProbabilisticCounter)PG_GETARG_BYTEA_P(1);
/* is the counter created (if not, create it - error 1%, 10mil items) */
if (PG_ARGISNULL(0) && PG_ARGISNULL(1)) {
PG_RETURN_NULL();
} else if (PG_ARGISNULL(0)) {
PG_RETURN_BYTEA_P(pc_copy(counter2));
} else if (PG_ARGISNULL(1)) {
PG_RETURN_BYTEA_P(pc_copy(counter1));
} else {
PG_RETURN_BYTEA_P(pc_merge(counter1, counter2, false));
}
}
Datum pgbloomfun_add(PG_FUNCTION_ARGS)
{
bytea *newbloomba, *bloomba = PG_GETARG_BYTEA_P(0);
text *key = PG_GETARG_TEXT_P(1);
pgbloom_t *pgbloom = get_pgbloom(bloomba);
bloom_t newbloom, *bloom = NULL;
size_t newbloom_size;
int space_left, i;
space_left = (pgbloom->last_capacity > pgbloom->last_entries) ||
(pgbloom->growth_factor == 0);
for (i=0; i<pgbloom->filters; i++)
{
bloom = next_bloom(bloomba, bloom);
if (bloom == NULL)
{
elog(ERROR, "pgbloomfun: missing filter in bloom object");
}
if (i == pgbloom->filters - 1 && space_left)
{
if (bloom_add(bloom, VARDATA(key), VARSIZE(key) - VARHDRSZ) == 0)
{
pgbloom->total_entries ++;
pgbloom->last_entries ++;
}
PG_RETURN_BYTEA_P(bloomba);
}
else if (bloom_check(bloom, VARDATA(key), VARSIZE(key) - VARHDRSZ))
{
PG_RETURN_BYTEA_P(bloomba); /* key already exists */
}
}
/* create a new filter */
pgbloom->filters += 1;
pgbloom->total_entries += 1;
pgbloom->last_entries = 1;
pgbloom->last_capacity *= pgbloom->growth_factor;
pgbloom->total_capacity += pgbloom->last_capacity;
/* calculate and allocate space */
bloom_init(&newbloom, pgbloom->last_capacity, pgbloom->error_rate);
newbloom_size = sizeof(newbloom) + newbloom.bits / 8;
newbloomba = palloc(VARSIZE(bloomba) + newbloom_size);
memcpy(newbloomba, bloomba, VARSIZE(bloomba));
SET_VARSIZE(newbloomba, VARSIZE(bloomba) + newbloom_size);
/* initialize the new bloom filter and add the new key to it */
bloom = (bloom_t *) (((unsigned char *) newbloomba) + VARSIZE(bloomba));
memset(bloom, 0, newbloom_size);
memcpy(bloom, &newbloom, sizeof(newbloom));
bloom_add(bloom, VARDATA(key), VARSIZE(key) - VARHDRSZ);
PG_RETURN_BYTEA_P(newbloomba);
}
Datum
tdigest_out(PG_FUNCTION_ARGS)
{
StringInfoData buf;
TDigest *t = tdigest_unpack(PG_GETARG_BYTEA_P(0));
initStringInfo(&buf);
appendStringInfo(&buf, "{ count = %ld, k = %d, centroids: %d }", t->total_weight, (int) t->compression, t->num_centroids);
PG_RETURN_CSTRING(buf.data);
}
Datum
dbms_pipe_pack_message_bytea(PG_FUNCTION_ARGS)
{
bytea *data = PG_GETARG_BYTEA_P(0);
output_buffer = check_buffer(output_buffer, LOCALMSGSZ);
pack_field(output_buffer, IT_BYTEA,
VARSIZE_ANY_EXHDR(data), VARDATA_ANY(data), InvalidOid);
PG_RETURN_VOID();
}
Datum
pg_hmac(PG_FUNCTION_ARGS)
{
bytea *arg;
bytea *key;
text *name;
unsigned len,
hlen,
klen;
PX_HMAC *h;
bytea *res;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2))
PG_RETURN_NULL();
name = PG_GETARG_TEXT_P(2);
/* will give error if fails */
h = find_provider(name, (PFN) px_find_hmac, "HMAC", 0);
hlen = px_hmac_result_size(h);
res = (text *) palloc(hlen + VARHDRSZ);
VARATT_SIZEP(res) = hlen + VARHDRSZ;
arg = PG_GETARG_BYTEA_P(0);
key = PG_GETARG_BYTEA_P(1);
len = VARSIZE(arg) - VARHDRSZ;
klen = VARSIZE(key) - VARHDRSZ;
px_hmac_init(h, (uint8 *) VARDATA(key), klen);
px_hmac_update(h, (uint8 *) VARDATA(arg), len);
px_hmac_finish(h, (uint8 *) VARDATA(res));
px_hmac_free(h);
PG_FREE_IF_COPY(arg, 0);
PG_FREE_IF_COPY(key, 1);
PG_FREE_IF_COPY(name, 2);
PG_RETURN_BYTEA_P(res);
}
Datum
pgp_pub_encrypt_text(PG_FUNCTION_ARGS)
{
bytea *data,
*key;
text *arg = NULL;
text *res;
data = PG_GETARG_BYTEA_P(0);
key = PG_GETARG_BYTEA_P(1);
if (PG_NARGS() > 2)
arg = PG_GETARG_BYTEA_P(2);
res = encrypt_internal(1, 1, data, key, arg);
PG_FREE_IF_COPY(data, 0);
PG_FREE_IF_COPY(key, 1);
if (PG_NARGS() > 2)
PG_FREE_IF_COPY(arg, 2);
PG_RETURN_TEXT_P(res);
}
Datum
lowrite(PG_FUNCTION_ARGS)
{
int32 fd = PG_GETARG_INT32(0);
bytea *wbuf = PG_GETARG_BYTEA_P(1);
int bytestowrite;
int totalwritten;
bytestowrite = VARSIZE(wbuf) - VARHDRSZ;
totalwritten = lo_write(fd, VARDATA(wbuf), bytestowrite);
PG_RETURN_INT32(totalwritten);
}