: conn(conn), cancel_obj(nullptr) {

if (smh && conn) {

// Get a cancel object that can be used from another thread

PGcancel* co = PQgetCancel(conn);

cancel_obj.store(co, std::memory_order_release);

if (co) {

// Register cancel callback

smh->registerCancelCallback(this, [this]() -> bool {

// Load pointer atomically - it may be set to nullptr by destructor

PGcancel* co = this->cancel_obj.load(std::memory_order_acquire);

if (co) {

char errbuf[256];

int result = PQcancel(co, errbuf, sizeof(errbuf));

return result != 0;

}

return false;

});

}

}

ndigits = ntohs(ndigits);

weight = ntohs(weight);

sign = ntohs(sign);

dscale = ntohs(dscale);

#ifdef DEBUG_1

printd(0, "qpg_data_numeric::convertToHost() ndigits: %hd weight: %hd sign: %hd dscale: %hd\n", ndigits, weight, sign, dscale);

for (unsigned i = 0; i < ndigits; ++i)

printd(0, " + %hu\n", ntohs(digits[i]));

#endif

QoreString str;

toStr(str);

//printd(5, "qore_pg_numeric::toOptimal() processing %s ndigits: %d weight: %d sign: %d cmp: %d\n", str.c_str(), ndigits, weight, sign, strcmp(str.c_str(), "-9223372036854775808"));

// return an integer if the number can be converted to a 64-bit integer

if ((ndigits <= (weight + 1)) && (ndigits < 4

|| (ndigits == 5 &&

((!sign && strcmp(str.c_str(), "9223372036854775807") <= 0)

||(sign && strcmp(str.c_str(), "-9223372036854775808") <= 0)))))

return str.toBigInt();

return new QoreNumberNode(str.c_str());

if (!ndigits) {

str.concat('0');

return;

}

if (sign)

str.concat('-');

//printd(5, "qore_pg_numeric::toStr() ndigits: %d dscale: %d\n", ndigits, dscale);

int i;

for (i = 0; i < ndigits; ++i) {

if (i == weight + 1)

str.concat('.');

if (i || weight < 0)

str.sprintf("%04d", ntohs(digits[i]));

else

str.sprintf("%d", ntohs(digits[i]));

//printd(5, "qore_pg_numeric::toStr() digit %d: %d\n", i, ntohs(digits[i]));

}

//printd(5, "qore_pg_numeric::toStr() i: %d weight: %d str: %s\n", i, weight, str.c_str());

// now add significant zeros for remaining decimal places

if (weight >= i)

str.addch('0', (weight - i + 1) * 4);

else if (weight < -1) {

for (int i = weight; i < -1; ++i)

str.insert("0000", 0);

str.prepend(".");

}

//printd(5, "qore_pg_numeric::toStr() str: '%s'\n", str.c_str());

QoreString str;

n->getStringRepresentation(str);

//printd(5, "qore_pg_numeric_out::qore_pg_numeric_out() this %p str: '%s'\n", this, str.c_str());

// populate structure

int nsign = n->sign();

if (nsign < 0) {

// this is what the server sends for negative numbers

sign = 0x4000;

// remove the minus sign from the string

str.trim_leading('-');

}

qore_offset_t di = str.find('.');

if (di == -1)

di = str.strlen();

//printd(5, "find: '%s' di: %lld\n", str.c_str(), di);

char buf[5];

int i = 0;

if (di != 1 || str[0] != '0') {

while (i < di) {

// get the remaining number of digits up to the decimal place

int nd = (di - i) % 4;

if (!nd)

nd = 4;

for (int j = 0; j < nd; ++j)

buf[j] = (str.c_str() + i)[j];

buf[nd] = '\0';

digits[ndigits++] = atoi(buf);

if (ndigits > 1)

++weight;

//printd(5, "adding digits: '%s' (%d)\n", buf, atoi(buf));

i += nd;

}

} else {

weight = -1;

i = 1;

}

// now add digits after the decimal point

if (i != (int)str.size()) {

// skip decimal point

++i;

di = str.size();

while (i < di) {

int nd = di - i;

dscale += nd;

if (nd > 4)

nd = 4;

for (int j = 0; j < nd; ++j)

buf[j] = (str.c_str() + i)[j];

while (nd < 4)

buf[nd++] = '0';

buf[nd] = '\0';

digits[ndigits++] = atoi(buf);

//printd(5, "adding (after decimal point) digits: '%s' (%d)\n", buf, atoi(buf));

i += 4;

}

} else if (ndigits) {

// trim off trailing zeros when there are no digits after the decimal point

while (!digits[ndigits - 1]) {

--ndigits;

}

}

convertToNet();

size = sizeof(short) * (4 + ndigits);

printd(5, "qore_pg_numeric_out::convertToNet() ndigits: %hd weight: %hd sign: %hd dscale: %hd size: %d\n",

ndigits, weight, sign, dscale, size);

assert(ndigits >= 0 && ndigits < QORE_MAX_DIGITS);

for (unsigned i = 0; i < (unsigned)ndigits; ++i) {

//printd(5, " + %hu\n", digits[i]);

digits[i] = htons(digits[i]);

}

ndigits = htons(ndigits);

weight = htons(weight);

sign = htons(sign);

dscale = htons(dscale);

//do_output((char*)this, size);

void* dc = malloc(len);

memcpy(dc, data, len);

return new BinaryNode(dc, len);

QoreStringNode* rv = new QoreStringNode(data, len);

rv->trim_trailing();

return rv;

// skip initial 0x01 byte at the beginning of JSONB data returned

if (data[0] == 1) {

++data;

--len;

}

return new QoreStringNode((char*)data, len, enc);

if (conn->has_integer_datetimes()) {

int64 val = MSBi8(*((uint64_t *)data));

int64 secs = val / 1000000;

int us = val % 1000000;

secs += PGSQL_EPOCH_OFFSET;

return DateTimeNode::makeAbsolute(conn->getTZ(), secs, us);

}

double fv = MSBf8(*((double *)data));

int64 nv = (int64)fv;

int us = (int)((fv - (double)nv) * 1000000.0);

nv += PGSQL_EPOCH_OFFSET;

return DateTimeNode::makeAbsolute(conn->getTZ(), nv, us);

if (conn->has_integer_datetimes()) {

int64 val = MSBi8(*((uint64_t *)data));

// convert from u-secs to seconds and milliseconds

int64 secs = val / 1000000;

int us = val % 1000000;

secs += PGSQL_EPOCH_OFFSET;

return DateTimeNode::makeAbsoluteLocal(conn->getTZ(), secs, us);

}

double fv = MSBf8(*((double *)data));

int64 nv = (int64)fv;

int us = (int)((fv - (double)nv) * 1000000.0);

nv += PGSQL_EPOCH_OFFSET;

return DateTimeNode::makeAbsolute(conn->getTZ(), nv, us);

int32_t val = ntohl(*((int32_t*)data));

int64 v = (static_cast<int64>(val) + 10957) * 86400;

return new DateTimeNode(v);

int64 secs;

int hours;

int minutes;

qore_pg_interval *iv = (qore_pg_interval *)data;

// create interval with microsecond resolution

int64 us;

if (conn->has_integer_datetimes()) {

us = MSBi8(iv->time.i);

secs = us / 1000000;

us %= 1000000;

//printd(5, "got interval %lld: secs: %lld us: %lld (day: %d)\n", MSBi8(iv->time.i), secs, us, conn->has_interval_day());

} else {

double f = MSBf8(iv->time.f);

secs = (int64)f;

us = (int)((f - (double)secs) * 1000000.0);

}

hours = secs / 3600;

if (hours)

secs -= hours * 3600;

minutes = secs / 60;

if (minutes)

secs -= minutes* 60;

if (conn->has_interval_day())

return DateTimeNode::makeRelative(0, ntohl(iv->rest.with_day.month), ntohl(iv->rest.with_day.day), hours, minutes, secs, us);

return DateTimeNode::makeRelative(0, ntohl(iv->rest.month), 0, hours, minutes, secs, us);

int64 secs;

int us;

if (conn->has_integer_datetimes()) {

int64 val = MSBi8(*((uint64_t *)data));

secs = val / 1000000;

us = val % 1000000;

} else {

double val = MSBf8(*((double *)data));

secs = (int64)val;

us = (int)((val - (double)secs) * 1000000.0);

}

//printd(5, "qpg_data_time() %lld.%06d\n", secs, us);

// create the date/time value from an offset in the current time zone

return DateTimeNode::makeAbsoluteLocal(conn->getTZ(), secs, us);

qore_pg_time_tz_adt *tm = (qore_pg_time_tz_adt *)data;

int64 secs;

// postgresql gives the time zone in seconds west of UTC

int zone = ntohl(tm->zone);

int us;

if (conn->has_integer_datetimes()) {

int64 val = MSBi8(tm->time.i);

secs = val / 1000000;

us = val % 1000000;

} else {

double val = MSBf8(tm->time.f);

secs = (int64)val;

us = (int)((val - (double)secs) * 1000000.0);

}

//printd(5, "zone: %d secs: %lld.%06d\n", zone, secs, us);

return DateTimeNode::makeAbsoluteLocal(findCreateOffsetZone(-zone), secs, us);

//printd(5, "qpg_data_tinterval(row: %d, col: %d, type: %d) this: %p len: %d\n", row, col, type, this, len);

TimeIntervalData *td = (TimeIntervalData*)data;

int64 i = (int64)(int)ntohl(td->data[0]);

DateTime dt(i);

QoreStringNode* str = new QoreStringNode();

str->sprintf("[\"%04d-%02d-%02d %02d:%02d:%02d\" ", dt.getYear(), dt.getMonth(), dt.getDay(), dt.getHour(), dt.getMinute(), dt.getSecond());

dt.setDate((int64)ntohl(td->data[1]));

str->sprintf("\"%04d-%02d-%02d %02d:%02d:%02d\"]", dt.getYear(), dt.getMonth(), dt.getDay(), dt.getHour(), dt.getMinute(), dt.getSecond());

// NOTE: ignoring tinverval->status, it is assumed that any value here will be valid

//printd(5, "status: %d s0: %d s1: %d\n", ntohl(td->status), s0, s1);

return str;

// issue #4249: we cannot write directly to the data, as we may be called multiple times on the same data

qore_pg_numeric* num = reinterpret_cast<qore_pg_numeric*>(data);

size_t size = num->rawSize();

qore_pg_numeric* nd = (qore_pg_numeric*)malloc(size);

ON_BLOCK_EXIT(free, nd);

memcpy(nd, num, size);

nd->convertToHost();

int nc = conn->getNumeric();

if (nc == OPT_NUM_OPTIMAL)

return nd->toOptimal();

if (nc == OPT_NUM_NUMERIC)

return nd->toNumber();

assert(nc == OPT_NUM_STRING);

return nd->toString();

double f = (double)ntohl(*((uint32_t*)data)) / 100.0;

//printd(5, "qpg_data_cash() f: %g\n", f);

return f;

QoreStringNode* str = new QoreStringNode;

for (int i = 0; i < 5; i++) {

str->concatHex((char*)data + i, 1);

str->concat(':');

}

str->concatHex((char*)data+5, 1);

return str;

qore_pg_inet_struct *is = (qore_pg_inet_struct *)data;

QoreStringNode* str = new QoreStringNode();

if (is->family == PGSQL_AF_INET) {

for (int i = 0, e = is->length - 1; i < e; i++)

str->sprintf("%d.", is->ipaddr[i]);

str->sprintf("%d/%d", is->ipaddr[3], is->bits);

} else {

short *sp;

int i, val, e, last = 0;

if (type == CIDROID)

e = is->bits / 8;

else

e = is->length;

if (e == 16) {

e -= 2;

last = 1;

}

for (i = 0; i < e; i += 2) {

sp = (short *)&is->ipaddr[i];

val = ntohs(*sp);

str->sprintf("%x:", val);

}

if (last) {

sp = (short *)&is->ipaddr[i];

val = ntohs(*sp);

str->sprintf("%x", val);

} else

str->concat(':');

str->sprintf("/%d", is->bits);

}

return str;

qore_pg_tuple_id *ti = (qore_pg_tuple_id *)data;

unsigned block = ntohl(ti->block);

unsigned index = ntohs(ti->index);

QoreStringNode* str = new QoreStringNode;

str->sprintf("(%u,%u)", block, index);

return str;

qore_pg_bit *bp = (qore_pg_bit *)data;

int num = (ntohl(bp->size) - 1) / 8 + 1;

BinaryNode* b = new BinaryNode;

b->append(bp->data, num);

return b;

Point p;

assign_point(p, (Point*)data);

QoreStringNode* str = new QoreStringNode;

str->sprintf("%g,%g", p.x, p.y);

return str;

Point p;

assign_point(p, &((LSEG *)data)->p[0]);

QoreStringNode* str = new QoreStringNode;

str->sprintf("(%g,%g),", p.x, p.y);

assign_point(p, &((LSEG *)data)->p[1]);

str->sprintf("(%g,%g)", p.x, p.y);

return str;

Point p0, p1;

assign_point(p0, &((BOX *)data)->high);

assign_point(p1, &((BOX *)data)->low);

QoreStringNode* str = new QoreStringNode;

str->sprintf("(%g,%g),(%g,%g)", p0.x, p0.y, p1.x, p1.y);

return str;

unsigned npts = ntohl(*((int*)((char*)data + 1)));

bool closed = ntohl(*((char*)data));

//printd(5, "npts: %d closed: %d\n", npts, closed);

QoreStringNode* str = new QoreStringNode();

str->concat(closed ? '(' : '[');

Point p;

for (unsigned i = 0; i < npts; ++i) {

assign_point(p, (Point*)(((char*)data) + 5 + (sizeof(Point)) * i));

str->sprintf("(%g,%g)", p.x, p.y);

if (i != (npts - 1))

str->concat(',');

}

str->concat(closed ? ')' : ']');

return str;

unsigned npts = ntohl(*((int*)data));

QoreStringNode* str = new QoreStringNode('(');

Point p;

for (unsigned i = 0; i < npts; ++i) {

assign_point(p, (Point*)(((char*)data) + 4 + (sizeof(Point)) * i));

str->sprintf("(%g,%g)", p.x, p.y);

if (i != (npts - 1))

str->concat(',');

}

str->concat(')');

return str;

//printd(5, "qpg_data_circle(row: %d, col: %d, type: %d) this: %p len: %d\n", row, col, type, this, len);

QoreStringNode* str = new QoreStringNode;

Point p;

assign_point(p, &((CIRCLE *)data)->center);

double radius = MSBf8(((CIRCLE *)data)->radius);

str->sprintf("<(%g,%g),%g>", p.x, p.y, radius);

return str;

// UUID is 16 bytes in binary format

if (len != 16) {

return new QoreStringNode(data, len, enc);

}

unsigned char* uuid = (unsigned char*)data;

QoreStringNode* str = new QoreStringNode;

str->sprintf("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",

uuid[0], uuid[1], uuid[2], uuid[3],

uuid[4], uuid[5],

uuid[6], uuid[7],

uuid[8], uuid[9],

uuid[10], uuid[11], uuid[12], uuid[13], uuid[14], uuid[15]);

return str;

uint32_t sign = (h >> 15) & 0x1;

uint32_t exponent = (h >> 10) & 0x1f;

uint32_t mantissa = h & 0x3ff;

double result;

if (exponent == 0) {

// subnormal or zero

result = std::ldexp((double)mantissa, -24);

} else if (exponent == 31) {

// inf or NaN

if (mantissa == 0) {

result = std::numeric_limits<double>::infinity();

} else {

result = std::numeric_limits<double>::quiet_NaN();

}

} else {

// normalized

result = std::ldexp((double)(mantissa + 1024), exponent - 25);

}

return sign ? -result : result;

if (len < 4) {

return new QoreStringNode(data, len, enc);

}

int16_t dim = ntohs(*((int16_t*)data));

// skip unused field at data + 2

if (dim < 0) {

return new QoreStringNode(data, len, enc);

}

int expected_len = 4 + dim * (int)sizeof(float);

if (len < expected_len) {

return new QoreStringNode(data, len, enc);

}

ReferenceHolder<QoreListNode> l(new QoreListNode(floatTypeInfo), nullptr);

float* elements = (float*)(data + 4);

for (int i = 0; i < dim; ++i) {

float val = MSBf4(elements[i]);

l->push((double)val, nullptr);

}

return l.release();

if (len < 4) {

return new QoreStringNode(data, len, enc);

}

int16_t dim = ntohs(*((int16_t*)data));

// skip unused field at data + 2

if (dim < 0) {

return new QoreStringNode(data, len, enc);

}

int expected_len = 4 + dim * 2;

if (len < expected_len) {

return new QoreStringNode(data, len, enc);

}

ReferenceHolder<QoreListNode> l(new QoreListNode(floatTypeInfo), nullptr);

uint16_t* elements = (uint16_t*)(data + 4);

for (int i = 0; i < dim; ++i) {

uint16_t raw = ntohs(elements[i]);

double val = half_to_double(raw);

l->push(val, nullptr);

}

return l.release();

if (len < 8) {

return new QoreStringNode(data, len, enc);

}

int32_t dim = ntohl(*((int32_t*)data));

int32_t nnz = ntohl(*((int32_t*)(data + 4)));

if (nnz < 0) {

return new QoreStringNode(data, len, enc);

}

int expected_len = 8 + nnz * (int)(sizeof(int32_t) + sizeof(float));

if (len < expected_len) {

return new QoreStringNode(data, len, enc);

}

ReferenceHolder<QoreHashNode> h(new QoreHashNode(autoTypeInfo), nullptr);

h->setKeyValue("dim", (int64)dim, nullptr);

h->setKeyValue("nnz", (int64)nnz, nullptr);

ReferenceHolder<QoreListNode> indices(new QoreListNode(bigIntTypeInfo), nullptr);

ReferenceHolder<QoreListNode> values(new QoreListNode(floatTypeInfo), nullptr);

int32_t* idx_ptr = (int32_t*)(data + 8);

float* val_ptr = (float*)(data + 8 + nnz * sizeof(int32_t));

for (int i = 0; i < nnz; ++i) {

indices->push((int64)ntohl(idx_ptr[i]), nullptr);

float val = MSBf4(val_ptr[i]);

values->push((double)val, nullptr);

}

h->setKeyValue("indices", indices.release(), nullptr);

h->setKeyValue("values", values.release(), nullptr);

return h.release();

data_map[BOOLOID] = qpg_data_bool;

data_map[BYTEAOID] = qpg_data_bytea;

data_map[CHAROID] = qpg_data_char;

data_map[BPCHAROID] = qpg_data_char;

// treat UNKNOWNOID as string

data_map[UNKNOWNOID] = qpg_data_char;

data_map[INT8OID] = qpg_data_int8;

data_map[INT4OID] = qpg_data_int4;

data_map[OIDOID] = qpg_data_int4;

data_map[XIDOID] = qpg_data_int4;

data_map[CIDOID] = qpg_data_int4;

//data_map[REGPROCOID] = qpg_data_int4;

data_map[INT2OID] = qpg_data_int2;

data_map[TEXTOID] = qpg_data_text;

data_map[VARCHAROID] = qpg_data_text;

data_map[NAMEOID] = qpg_data_text;

data_map[FLOAT4OID] = qpg_data_float4;

data_map[FLOAT8OID] = qpg_data_float8;

data_map[ABSTIMEOID] = qpg_data_abstime;

data_map[RELTIMEOID] = qpg_data_reltime;

data_map[TIMESTAMPOID] = qpg_data_timestamp;

data_map[TIMESTAMPTZOID] = qpg_data_timestamptz;

data_map[DATEOID] = qpg_data_date;

data_map[INTERVALOID] = qpg_data_interval;

data_map[TIMEOID] = qpg_data_time;

data_map[TIMETZOID] = qpg_data_timetz;

data_map[TINTERVALOID] = qpg_data_tinterval;

data_map[NUMERICOID] = qpg_data_numeric;

data_map[CASHOID] = qpg_data_cash;

data_map[MACADDROID] = qpg_data_macaddr;

data_map[INETOID] = qpg_data_inet;

data_map[CIDROID] = qpg_data_inet;

data_map[TIDOID] = qpg_data_tid;

data_map[BITOID] = qpg_data_bit;

data_map[VARBITOID] = qpg_data_bit;

data_map[POINTOID] = qpg_data_point;

data_map[LSEGOID] = qpg_data_lseg;

data_map[BOXOID] = qpg_data_box;

data_map[PATHOID] = qpg_data_path;

data_map[POLYGONOID] = qpg_data_polygon;

data_map[CIRCLEOID] = qpg_data_circle;

data_map[XMLOID] = qpg_data_text;

data_map[JSONOID] = qpg_data_text;

data_map[JSONBOID] = qpg_data_jsonb;

data_map[UUIDOID] = qpg_data_uuid;

//data_map[INT2VECTOROID] = qpg_data_int2vector;

//data_map[OIDVECTOROID] = qpg_data_oidvector;

//array_data_map[INT2VECTOROID] = std::make_pair(INT2OID, qpg_data_int2);

// NOTE: the casts are necessary with SunPro CC 5.8...

array_data_map[QPGT_INT4ARRAYOID] = std::make_pair(INT4OID, (qore_pg_data_func_t)qpg_data_int4);

array_data_map[QPGT_CIRCLEARRAYOID] = std::make_pair(CIRCLEOID, (qore_pg_data_func_t)qpg_data_circle);

array_data_map[QPGT_MONEYARRAYOID] = std::make_pair(CASHOID, (qore_pg_data_func_t)qpg_data_cash);

array_data_map[QPGT_BOOLARRAYOID] = std::make_pair(BOOLOID, (qore_pg_data_func_t)qpg_data_bool);

array_data_map[QPGT_BYTEAARRAYOID] = std::make_pair(BYTEAOID, (qore_pg_data_func_t)qpg_data_bytea);

array_data_map[QPGT_NAMEARRAYOID] = std::make_pair(NAMEOID, (qore_pg_data_func_t)qpg_data_text);

array_data_map[QPGT_INT2ARRAYOID] = std::make_pair(INT2OID, (qore_pg_data_func_t)qpg_data_int2);

//array_data_map[QPGT_INT2VECTORARRAYOID] = std::make_pair(OID, (qore_pg_data_func_t)qpg_data_);

//array_data_map[QPGT_REGPROCARRAYOID] = std::make_pair(OID, (qore_pg_data_func_t)qpg_data_);

array_data_map[QPGT_TEXTARRAYOID] = std::make_pair(TEXTOID, (qore_pg_data_func_t)qpg_data_text);

array_data_map[QPGT_OIDARRAYOID] = std::make_pair(OIDOID, (qore_pg_data_func_t)qpg_data_int4);

array_data_map[QPGT_TIDARRAYOID] = std::make_pair(TIDOID, (qore_pg_data_func_t)qpg_data_tid);

array_data_map[QPGT_XIDARRAYOID] = std::make_pair(XIDOID, (qore_pg_data_func_t)qpg_data_int4);

array_data_map[QPGT_CIDARRAYOID] = std::make_pair(CIDOID, (qore_pg_data_func_t)qpg_data_int4);

//array_data_map[QPGT_OIDVECTORARRAYOID] = std::make_pair(OID, (qore_pg_data_func_t)qpg_data_);

array_data_map[QPGT_BPCHARARRAYOID] = std::make_pair(BPCHAROID, (qore_pg_data_func_t)qpg_data_char);

array_data_map[QPGT_VARCHARARRAYOID] = std::make_pair(VARCHAROID, (qore_pg_data_func_t)qpg_data_text);

array_data_map[QPGT_INT8ARRAYOID] = std::make_pair(INT8OID, (qore_pg_data_func_t)qpg_data_int8);

array_data_map[QPGT_POINTARRAYOID] = std::make_pair(POINTOID, (qore_pg_data_func_t)qpg_data_point);

array_data_map[QPGT_LSEGARRAYOID] = std::make_pair(LSEGOID, (qore_pg_data_func_t)qpg_data_lseg);

array_data_map[QPGT_PATHARRAYOID] = std::make_pair(PATHOID, (qore_pg_data_func_t)qpg_data_path);

array_data_map[QPGT_BOXARRAYOID] = std::make_pair(BOXOID, (qore_pg_data_func_t)qpg_data_box);

array_data_map[QPGT_FLOAT4ARRAYOID] = std::make_pair(FLOAT4OID, (qore_pg_data_func_t)qpg_data_float4);

array_data_map[QPGT_FLOAT8ARRAYOID] = std::make_pair(FLOAT8OID, (qore_pg_data_func_t)qpg_data_float8);

array_data_map[QPGT_ABSTIMEARRAYOID] = std::make_pair(ABSTIMEOID, (qore_pg_data_func_t)qpg_data_abstime);

array_data_map[QPGT_RELTIMEARRAYOID] = std::make_pair(RELTIMEOID, (qore_pg_data_func_t)qpg_data_reltime);

array_data_map[QPGT_TINTERVALARRAYOID] = std::make_pair(TINTERVALOID, (qore_pg_data_func_t)qpg_data_tinterval);

array_data_map[QPGT_POLYGONARRAYOID] = std::make_pair(POLYGONOID, (qore_pg_data_func_t)qpg_data_polygon);

//array_data_map[QPGT_ACLITEMARRAYOID] = std::make_pair(OID, (qore_pg_data_func_t)qpg_data_);

array_data_map[QPGT_MACADDRARRAYOID] = std::make_pair(MACADDROID, (qore_pg_data_func_t)qpg_data_macaddr);

array_data_map[QPGT_INETARRAYOID] = std::make_pair(INETOID, (qore_pg_data_func_t)qpg_data_inet);

array_data_map[QPGT_CIDRARRAYOID] = std::make_pair(CIDROID, (qore_pg_data_func_t)qpg_data_inet);

array_data_map[QPGT_TIMESTAMPARRAYOID] = std::make_pair(TIMESTAMPOID, (qore_pg_data_func_t)qpg_data_timestamp);

array_data_map[QPGT_DATEARRAYOID] = std::make_pair(DATEOID, (qore_pg_data_func_t)qpg_data_date);

array_data_map[QPGT_TIMEARRAYOID] = std::make_pair(TIMEOID, (qore_pg_data_func_t)qpg_data_time);

array_data_map[QPGT_TIMESTAMPTZARRAYOID] = std::make_pair(TIMESTAMPTZOID, (qore_pg_data_func_t)qpg_data_timestamptz);

array_data_map[QPGT_INTERVALARRAYOID] = std::make_pair(INTERVALOID, (qore_pg_data_func_t)qpg_data_interval);

array_data_map[QPGT_NUMERICARRAYOID] = std::make_pair(NUMERICOID, (qore_pg_data_func_t)qpg_data_numeric);

array_data_map[QPGT_TIMETZARRAYOID] = std::make_pair(TIMETZOID, (qore_pg_data_func_t)qpg_data_timetz);

array_data_map[QPGT_BITARRAYOID] = std::make_pair(BITOID, (qore_pg_data_func_t)qpg_data_bit);

array_data_map[QPGT_VARBITARRAYOID] = std::make_pair(VARBITOID, (qore_pg_data_func_t)qpg_data_bit);

//array_data_map[QPGT_REFCURSORARRAYOID] = std::make_pair(OID, (qore_pg_data_func_t)qpg_data_);

//array_data_map[QPGT_REGPROCEDUREARRAYOID] = std::make_pair(OID, (qore_pg_data_func_t)qpg_data_);

//array_data_map[QPGT_REGOPERARRAYOID] = std::make_pair(OID, (qore_pg_data_func_t)qpg_data_);

//array_data_map[QPGT_REGOPERATORARRAYOID] = std::make_pair(OID, (qore_pg_data_func_t)qpg_data_);

//array_data_map[QPGT_REGCLASSARRAYOID] = std::make_pair(OID, (qore_pg_data_func_t)qpg_data_);

//array_data_map[QPGT_REGTYPEARRAYOID] = std::make_pair(OID, (qore_pg_data_func_t)qpg_data_);

//array_data_map[QPGT_ANYARRAYOID] = std::make_pair(OID, (qore_pg_data_func_t)qpg_data_);

array_data_map[XMLARRAYOID] = std::make_pair(XMLOID, (qore_pg_data_func_t)qpg_data_text);

array_data_map[JSONARRAYOID] = std::make_pair(JSONOID, (qore_pg_data_func_t)qpg_data_text);

array_data_map[JSONBARRAYOID] = std::make_pair(JSONBOID, (qore_pg_data_func_t)qpg_data_jsonb);

array_data_map[QPGT_UUIDARRAYOID] = std::make_pair(UUIDOID, (qore_pg_data_func_t)qpg_data_uuid);

array_type_map[INT4OID] = QPGT_INT4ARRAYOID;

array_type_map[CIRCLEOID] = QPGT_CIRCLEARRAYOID;

array_type_map[CASHOID] = QPGT_MONEYARRAYOID;

array_type_map[BOOLOID] = QPGT_BOOLARRAYOID;

array_type_map[BYTEAOID] = QPGT_BYTEAARRAYOID;

array_type_map[NAMEOID] = QPGT_NAMEARRAYOID;

array_type_map[INT2OID] = QPGT_INT2ARRAYOID;

array_type_map[TEXTOID] = QPGT_TEXTARRAYOID;

array_type_map[OIDOID] = QPGT_OIDARRAYOID;

array_type_map[TIDOID] = QPGT_TIDARRAYOID;

array_type_map[XIDOID] = QPGT_XIDARRAYOID;

array_type_map[CIDOID] = QPGT_CIDARRAYOID;

array_type_map[BPCHAROID] = QPGT_BPCHARARRAYOID;

array_type_map[VARCHAROID] = QPGT_VARCHARARRAYOID;

array_type_map[INT8OID] = QPGT_INT8ARRAYOID;

array_type_map[POINTOID] = QPGT_POINTARRAYOID;

array_type_map[LSEGOID] = QPGT_LSEGARRAYOID;

array_type_map[PATHOID] = QPGT_PATHARRAYOID;

array_type_map[BOXOID] = QPGT_BOXARRAYOID;

array_type_map[FLOAT4OID] = QPGT_FLOAT4ARRAYOID;

array_type_map[FLOAT8OID] = QPGT_FLOAT8ARRAYOID;

array_type_map[ABSTIMEOID] = QPGT_ABSTIMEARRAYOID;

array_type_map[RELTIMEOID] = QPGT_RELTIMEARRAYOID;

array_type_map[TINTERVALOID] = QPGT_TINTERVALARRAYOID;

array_type_map[POLYGONOID] = QPGT_POLYGONARRAYOID;

array_type_map[MACADDROID] = QPGT_MACADDRARRAYOID;

array_type_map[INETOID] = QPGT_INETARRAYOID;

array_type_map[CIDROID] = QPGT_CIDRARRAYOID;

array_type_map[TIMESTAMPOID] = QPGT_TIMESTAMPARRAYOID;

array_type_map[DATEOID] = QPGT_DATEARRAYOID;

array_type_map[TIMEOID] = QPGT_TIMEARRAYOID;

array_type_map[TIMESTAMPTZOID] = QPGT_TIMESTAMPTZARRAYOID;

array_type_map[INTERVALOID] = QPGT_INTERVALARRAYOID;

array_type_map[NUMERICOID] = QPGT_NUMERICARRAYOID;

array_type_map[TIMETZOID] = QPGT_TIMETZARRAYOID;

array_type_map[BITOID] = QPGT_BITARRAYOID;

array_type_map[VARBITOID] = QPGT_VARBITARRAYOID;

array_type_map[XMLOID] = XMLARRAYOID;

array_type_map[JSONOID] = JSONARRAYOID;

array_type_map[JSONBOID] = JSONBARRAYOID;

array_type_map[UUIDOID] = QPGT_UUIDARRAYOID;

: res(0), nParams(0), allocated(0), paramTypes(0), paramValues(0),

paramLengths(0), paramFormats(0), paramArray(0), conn((QorePGConnection*)ds->getPrivateData()),

enc(ds->getQoreEncoding()), array_size(-1) {

if (res) {

PQclear(res);

res = 0;

}

if (allocated) {

parambuf_list_t::iterator i = parambuf_list.begin();

for (int j = 0; j < nParams; ++i, ++j) {

//printd(5, "QorePgsqlStatement::reset() deleting type %d (NUMERICOID = %d)\n", paramTypes[j], NUMERICOID);

if (paramFormats[j] == 0 && !paramArray[j] && (*i)->str) {

// free text-format scalar bind string buffers (TEXTOID, typed text binds, etc.)

free((*i)->str);

} else if (paramTypes[j] == NUMERICOID && (*i)->num) {

//printd(5, "QorePgsqlStatement::reset() deleting num: %p\n", (*i)->num);

delete (*i)->num;

} else if (paramArray[j] && (*i)->ptr) {

free((*i)->ptr);

}

delete *i;

}

// delete any remaining parambufs beyond nParams (e.g. from an error in add())

while (i != parambuf_list.end()) {

delete *i;

++i;

}

parambuf_list.clear();

free(paramTypes);

paramTypes = 0;

free(paramValues);

paramValues = 0;

free(paramLengths);

paramLengths = 0;

free(paramFormats);

paramFormats = 0;

free(paramArray);

paramArray = 0;

allocated = 0;

nParams = 0;

}

array_size = -1;