JsonbValue scalarArray;
scalarArray.type = jbvArray;
- scalarArray.array.rawScalar = true;
- scalarArray.array.nElems = 1;
+ scalarArray.val.array.rawScalar = true;
+ scalarArray.val.array.nElems = 1;
pushJsonbValue(&pstate, WJB_BEGIN_ARRAY, &scalarArray);
pushJsonbValue(&pstate, WJB_ELEM, val);
else
{
Assert(val->type == jbvBinary);
- out = palloc(VARHDRSZ + val->binary.len);
- SET_VARSIZE(out, VARHDRSZ + val->binary.len);
- memcpy(VARDATA(out), val->binary.data, val->binary.len);
+ out = palloc(VARHDRSZ + val->val.binary.len);
+ SET_VARSIZE(out, VARHDRSZ + val->val.binary.len);
+ memcpy(VARDATA(out), val->val.binary.data, val->val.binary.len);
}
return out;
* general type-based comparisons to apply, and as far
* as we're concerned a pseudo array is just a scalar.
*/
- if (va.array.rawScalar != vb.array.rawScalar)
- res = (va.array.rawScalar) ? -1 : 1;
- if (va.array.nElems != vb.array.nElems)
- res = (va.array.nElems > vb.array.nElems) ? 1 : -1;
+ if (va.val.array.rawScalar != vb.val.array.rawScalar)
+ res = (va.val.array.rawScalar) ? -1 : 1;
+ if (va.val.array.nElems != vb.val.array.nElems)
+ res = (va.val.array.nElems > vb.val.array.nElems) ? 1 : -1;
break;
case jbvObject:
- if (va.object.nPairs != vb.object.nPairs)
- res = (va.object.nPairs > vb.object.nPairs) ? 1 : -1;
+ if (va.val.object.nPairs != vb.val.object.nPairs)
+ res = (va.val.object.nPairs > vb.val.object.nPairs) ? 1 : -1;
break;
case jbvBinary:
elog(ERROR, "unexpected jbvBinary value");
else if (JBE_ISSTRING(*e) && key->type == jbvString)
{
result->type = jbvString;
- result->string.val = data + JBE_OFF(*e);
- result->string.len = JBE_LEN(*e);
- result->estSize = sizeof(JEntry) + result->string.len;
+ result->val.string.val = data + JBE_OFF(*e);
+ result->val.string.len = JBE_LEN(*e);
+ result->estSize = sizeof(JEntry) + result->val.string.len;
}
else if (JBE_ISNUMERIC(*e) && key->type == jbvNumeric)
{
result->type = jbvNumeric;
- result->numeric = (Numeric) (data + INTALIGN(JBE_OFF(*e)));
+ result->val.numeric = (Numeric) (data + INTALIGN(JBE_OFF(*e)));
result->estSize = 2 * sizeof(JEntry) +
- VARSIZE_ANY(result->numeric);
+ VARSIZE_ANY(result->val.numeric);
}
else if (JBE_ISBOOL(*e) && key->type == jbvBool)
{
result->type = jbvBool;
- result->boolean = JBE_ISBOOL_TRUE(*e) != 0;
+ result->val.boolean = JBE_ISBOOL_TRUE(*e) != 0;
result->estSize = sizeof(JEntry);
}
else
entry = array + stopMiddle * 2;
candidate.type = jbvString;
- candidate.string.val = data + JBE_OFF(*entry);
- candidate.string.len = JBE_LEN(*entry);
- candidate.estSize = sizeof(JEntry) + candidate.string.len;
+ candidate.val.string.val = data + JBE_OFF(*entry);
+ candidate.val.string.len = JBE_LEN(*entry);
+ candidate.estSize = sizeof(JEntry) + candidate.val.string.len;
difference = lengthCompareJsonbStringValue(&candidate, key, NULL);
else if (JBE_ISSTRING(*v))
{
result->type = jbvString;
- result->string.val = data + JBE_OFF(*v);
- result->string.len = JBE_LEN(*v);
- result->estSize = sizeof(JEntry) + result->string.len;
+ result->val.string.val = data + JBE_OFF(*v);
+ result->val.string.len = JBE_LEN(*v);
+ result->estSize = sizeof(JEntry) + result->val.string.len;
}
else if (JBE_ISNUMERIC(*v))
{
result->type = jbvNumeric;
- result->numeric = (Numeric) (data + INTALIGN(JBE_OFF(*v)));
+ result->val.numeric = (Numeric) (data + INTALIGN(JBE_OFF(*v)));
result->estSize = 2 * sizeof(JEntry) +
- VARSIZE_ANY(result->numeric);
+ VARSIZE_ANY(result->val.numeric);
}
else if (JBE_ISBOOL(*v))
{
result->type = jbvBool;
- result->boolean = JBE_ISBOOL_TRUE(*v) != 0;
+ result->val.boolean = JBE_ISBOOL_TRUE(*v) != 0;
result->estSize = sizeof(JEntry);
}
else
* with arrays
*/
result->type = jbvBinary;
- result->binary.data = data + INTALIGN(JBE_OFF(*v));
- result->binary.len = JBE_LEN(*v) -
+ result->val.binary.data = data + INTALIGN(JBE_OFF(*v));
+ result->val.binary.len = JBE_LEN(*v) -
(INTALIGN(JBE_OFF(*v)) - JBE_OFF(*v));
- result->estSize = 2 * sizeof(JEntry) + result->binary.len;
+ result->estSize = 2 * sizeof(JEntry) + result->val.binary.len;
}
return result;
else if (JBE_ISSTRING(*e))
{
result->type = jbvString;
- result->string.val = data + JBE_OFF(*e);
- result->string.len = JBE_LEN(*e);
- result->estSize = sizeof(JEntry) + result->string.len;
+ result->val.string.val = data + JBE_OFF(*e);
+ result->val.string.len = JBE_LEN(*e);
+ result->estSize = sizeof(JEntry) + result->val.string.len;
}
else if (JBE_ISNUMERIC(*e))
{
result->type = jbvNumeric;
- result->numeric = (Numeric) (data + INTALIGN(JBE_OFF(*e)));
- result->estSize = 2 * sizeof(JEntry) + VARSIZE_ANY(result->numeric);
+ result->val.numeric = (Numeric) (data + INTALIGN(JBE_OFF(*e)));
+ result->estSize = 2 * sizeof(JEntry) + VARSIZE_ANY(result->val.numeric);
}
else if (JBE_ISBOOL(*e))
{
result->type = jbvBool;
- result->boolean = JBE_ISBOOL_TRUE(*e) != 0;
+ result->val.boolean = JBE_ISBOOL_TRUE(*e) != 0;
result->estSize = sizeof(JEntry);
}
else
{
result->type = jbvBinary;
- result->binary.data = data + INTALIGN(JBE_OFF(*e));
- result->binary.len = JBE_LEN(*e) - (INTALIGN(JBE_OFF(*e)) - JBE_OFF(*e));
- result->estSize = result->binary.len + 2 * sizeof(JEntry);
+ result->val.binary.data = data + INTALIGN(JBE_OFF(*e));
+ result->val.binary.len = JBE_LEN(*e) - (INTALIGN(JBE_OFF(*e)) - JBE_OFF(*e));
+ result->estSize = result->val.binary.len + 2 * sizeof(JEntry);
}
return result;
switch (seq)
{
case WJB_BEGIN_ARRAY:
- Assert(!scalarVal || scalarVal->array.rawScalar);
+ Assert(!scalarVal || scalarVal->val.array.rawScalar);
*pstate = pushState(pstate);
result = &(*pstate)->contVal;
(*pstate)->contVal.type = jbvArray;
(*pstate)->contVal.estSize = 3 * sizeof(JEntry);
- (*pstate)->contVal.array.nElems = 0;
- (*pstate)->contVal.array.rawScalar = (scalarVal &&
- scalarVal->array.rawScalar);
- if (scalarVal && scalarVal->array.nElems > 0)
+ (*pstate)->contVal.val.array.nElems = 0;
+ (*pstate)->contVal.val.array.rawScalar = (scalarVal &&
+ scalarVal->val.array.rawScalar);
+ if (scalarVal && scalarVal->val.array.nElems > 0)
{
/* Assume that this array is still really a scalar */
Assert(scalarVal->type == jbvArray);
- (*pstate)->size = scalarVal->array.nElems;
+ (*pstate)->size = scalarVal->val.array.nElems;
}
else
{
(*pstate)->size = 4;
}
- (*pstate)->contVal.array.elems = palloc(sizeof(JsonbValue) *
+ (*pstate)->contVal.val.array.elems = palloc(sizeof(JsonbValue) *
(*pstate)->size);
break;
case WJB_BEGIN_OBJECT:
result = &(*pstate)->contVal;
(*pstate)->contVal.type = jbvObject;
(*pstate)->contVal.estSize = 3 * sizeof(JEntry);
- (*pstate)->contVal.object.nPairs = 0;
+ (*pstate)->contVal.val.object.nPairs = 0;
(*pstate)->size = 4;
- (*pstate)->contVal.object.pairs = palloc(sizeof(JsonbPair) *
+ (*pstate)->contVal.val.object.pairs = palloc(sizeof(JsonbPair) *
(*pstate)->size);
break;
case WJB_KEY:
{
/* Set v to array on first array call */
val->type = jbvArray;
- val->array.nElems = (*it)->nElems;
+ val->val.array.nElems = (*it)->nElems;
/*
- * v->array.elems is not actually set, because we aren't doing a
+ * v->val.array.elems is not actually set, because we aren't doing a
* full conversion
*/
- val->array.rawScalar = (*it)->isScalar;
+ val->val.array.rawScalar = (*it)->isScalar;
(*it)->i = 0;
/* Set state for next call */
(*it)->state = jbi_elem;
{
/* Set v to object on first object call */
val->type = jbvObject;
- val->object.nPairs = (*it)->nElems;
+ val->val.object.nPairs = (*it)->nElems;
/*
- * v->object.pairs is not actually set, because we aren't doing a
- * full conversion
+ * v->val.object.pairs is not actually set, because we aren't
+ * doing a full conversion
*/
(*it)->i = 0;
/* Set state for next call */
Assert(lhsVal->type == jbvBinary);
Assert(vcontained.type == jbvBinary);
- nestval = JsonbIteratorInit(lhsVal->binary.data);
- nestContained = JsonbIteratorInit(vcontained.binary.data);
+ nestval = JsonbIteratorInit(lhsVal->val.binary.data);
+ nestContained = JsonbIteratorInit(vcontained.val.binary.data);
/*
* Match "value" side of rhs datum object's pair recursively.
else if (rcont == WJB_BEGIN_ARRAY)
{
JsonbValue *lhsConts = NULL;
- uint32 nLhsElems = vval.array.nElems;
+ uint32 nLhsElems = vval.val.array.nElems;
Assert(vcontained.type == jbvArray);
* only contain pairs, never raw scalars (a pair is represented by an
* rhs object argument with a single contained pair).
*/
- if (vval.array.rawScalar && !vcontained.array.rawScalar)
+ if (vval.val.array.rawScalar && !vcontained.val.array.rawScalar)
return false;
/* Work through rhs "is it contained within?" array */
JsonbIterator *nestval, *nestContained;
bool contains;
- nestval = JsonbIteratorInit(lhsConts[i].binary.data);
- nestContained = JsonbIteratorInit(vcontained.binary.data);
+ nestval = JsonbIteratorInit(lhsConts[i].val.binary.data);
+ nestContained = JsonbIteratorInit(vcontained.val.binary.data);
contains = JsonbDeepContains(&nestval, &nestContained);
result = palloc(sizeof(JsonbValue));
result->type = jbvArray;
- result->array.rawScalar = false;
- result->array.elems = palloc(sizeof(JsonbPair) * elem_count);
+ result->val.array.rawScalar = false;
+ result->val.array.elems = palloc(sizeof(JsonbPair) * elem_count);
for (i = 0, j = 0; i < elem_count; i++)
{
if (!key_nulls[i])
{
- result->array.elems[j].type = jbvString;
- result->array.elems[j].string.val = VARDATA(key_datums[i]);
- result->array.elems[j].string.len = VARSIZE(key_datums[i]) - VARHDRSZ;
+ result->val.array.elems[j].type = jbvString;
+ result->val.array.elems[j].val.string.val = VARDATA(key_datums[i]);
+ result->val.array.elems[j].val.string.len = VARSIZE(key_datums[i]) - VARHDRSZ;
j++;
}
}
- result->array.nElems = j;
+ result->val.array.nElems = j;
uniqueifyJsonbArray(result);
return result;
*hash ^= 0x01;
return;
case jbvString:
- tmp = hash_any((unsigned char *) scalarVal->string.val,
- scalarVal->string.len);
+ tmp = hash_any((unsigned char *) scalarVal->val.string.val,
+ scalarVal->val.string.len);
*hash ^= tmp;
return;
case jbvNumeric:
/* Must be unaffected by trailing zeroes */
tmp = DatumGetInt32(DirectFunctionCall1(hash_numeric,
- NumericGetDatum(scalarVal->numeric)));
+ NumericGetDatum(scalarVal->val.numeric)));
*hash ^= tmp;
return;
case jbvBool:
- *hash ^= scalarVal->boolean? 0x02:0x04;
+ *hash ^= scalarVal->val.boolean? 0x02:0x04;
return;
default:
elog(ERROR, "invalid jsonb scalar type");
return lengthCompareJsonbStringValue(aScalar, bScalar, NULL);
case jbvNumeric:
return DatumGetInt32(DirectFunctionCall2(numeric_cmp,
- PointerGetDatum(aScalar->numeric),
- PointerGetDatum(bScalar->numeric)));
+ PointerGetDatum(aScalar->val.numeric),
+ PointerGetDatum(bScalar->val.numeric)));
case jbvBool:
- if (aScalar->boolean != bScalar->boolean)
- return (aScalar->boolean > bScalar->boolean) ? 1 : -1;
+ if (aScalar->val.boolean != bScalar->val.boolean)
+ return (aScalar->val.boolean > bScalar->val.boolean) ? 1 : -1;
else
return 0;
default:
Assert(va->type == jbvString);
Assert(vb->type == jbvString);
- return varstr_cmp(va->string.val, va->string.len, vb->string.val,
- vb->string.len, DEFAULT_COLLATION_OID);
+ return varstr_cmp(va->val.string.val, va->val.string.len, vb->val.string.val,
+ vb->val.string.len, DEFAULT_COLLATION_OID);
}
/*
case jbvArray:
putJsonbValueConversion(cstate, val, WJB_BEGIN_ARRAY, nestlevel);
- for (i = 0; i < val->array.nElems; i++)
+ for (i = 0; i < val->val.array.nElems; i++)
{
- if (IsAJsonbScalar(&val->array.elems[i]) ||
- val->array.elems[i].type == jbvBinary)
- putJsonbValueConversion(cstate, val->array.elems + i,
+ if (IsAJsonbScalar(&val->val.array.elems[i]) ||
+ val->val.array.elems[i].type == jbvBinary)
+ putJsonbValueConversion(cstate, val->val.array.elems + i,
WJB_ELEM, nestlevel);
else
- walkJsonbValueConversion(val->array.elems + i, cstate,
+ walkJsonbValueConversion(val->val.array.elems + i, cstate,
nestlevel + 1);
}
putJsonbValueConversion(cstate, val, WJB_END_ARRAY, nestlevel);
case jbvObject:
putJsonbValueConversion(cstate, val, WJB_BEGIN_OBJECT, nestlevel);
- for (i = 0; i < val->object.nPairs; i++)
+ for (i = 0; i < val->val.object.nPairs; i++)
{
- putJsonbValueConversion(cstate, &val->object.pairs[i].key,
+ putJsonbValueConversion(cstate, &val->val.object.pairs[i].key,
WJB_KEY, nestlevel);
- if (IsAJsonbScalar(&val->object.pairs[i].value) ||
- val->object.pairs[i].value.type == jbvBinary)
+ if (IsAJsonbScalar(&val->val.object.pairs[i].value) ||
+ val->val.object.pairs[i].value.type == jbvBinary)
putJsonbValueConversion(cstate,
- &val->object.pairs[i].value,
+ &val->val.object.pairs[i].value,
WJB_VALUE, nestlevel);
else
- walkJsonbValueConversion(&val->object.pairs[i].value,
+ walkJsonbValueConversion(&val->val.object.pairs[i].value,
cstate, nestlevel + 1);
}
putJsonbValueConversion(cstate, val, WJB_END_OBJECT, nestlevel);
if (val->type == jbvArray)
{
- *cstate->contPtr->header = val->array.nElems | JB_FARRAY;
- cstate->ptr += sizeof(JEntry) * val->array.nElems;
+ *cstate->contPtr->header = val->val.array.nElems | JB_FARRAY;
+ cstate->ptr += sizeof(JEntry) * val->val.array.nElems;
- if (val->array.rawScalar)
+ if (val->val.array.rawScalar)
{
- Assert(val->array.nElems == 1);
+ Assert(val->val.array.nElems == 1);
Assert(level == 0);
*cstate->contPtr->header |= JB_FSCALAR;
}
}
else
{
- *cstate->contPtr->header = val->object.nPairs | JB_FOBJECT;
- cstate->ptr += sizeof(JEntry) * val->object.nPairs * 2;
+ *cstate->contPtr->header = val->val.object.nPairs | JB_FOBJECT;
+ cstate->ptr += sizeof(JEntry) * val->val.object.nPairs * 2;
}
}
else if (flags & WJB_ELEM)
cstate->contPtr->meta[i - 1].header & JENTRY_POSMASK;
break;
case jbvString:
- memcpy(cstate->ptr, scalarVal->string.val, scalarVal->string.len);
- cstate->ptr += scalarVal->string.len;
+ memcpy(cstate->ptr, scalarVal->val.string.val, scalarVal->val.string.len);
+ cstate->ptr += scalarVal->val.string.len;
if (i == 0)
- cstate->contPtr->meta[0].header |= scalarVal->string.len;
+ cstate->contPtr->meta[0].header |= scalarVal->val.string.len;
else
cstate->contPtr->meta[i].header |=
(cstate->contPtr->meta[i - 1].header & JENTRY_POSMASK) +
- scalarVal->string.len;
+ scalarVal->val.string.len;
break;
case jbvNumeric:
- numlen = VARSIZE_ANY(scalarVal->numeric);
+ numlen = VARSIZE_ANY(scalarVal->val.numeric);
padlen = addPaddingInt(cstate);
- memcpy(cstate->ptr, scalarVal->numeric, numlen);
+ memcpy(cstate->ptr, scalarVal->val.numeric, numlen);
cstate->ptr += numlen;
cstate->contPtr->meta[i].header |= JENTRY_ISNUMERIC;
+ padlen + numlen;
break;
case jbvBool:
- cstate->contPtr->meta[i].header |= (scalarVal->boolean) ?
+ cstate->contPtr->meta[i].header |= (scalarVal->val.boolean) ?
JENTRY_ISTRUE : JENTRY_ISFALSE;
if (i > 0)
else if (JBE_ISSTRING(*ent))
{
val->type = jbvString;
- val->string.val = (*it)->dataProper + JBE_OFF(*ent);
- val->string.len = JBE_LEN(*ent);
- val->estSize = sizeof(JEntry) + val->string.len;
+ val->val.string.val = (*it)->dataProper + JBE_OFF(*ent);
+ val->val.string.len = JBE_LEN(*ent);
+ val->estSize = sizeof(JEntry) + val->val.string.len;
return false;
}
else if (JBE_ISNUMERIC(*ent))
{
val->type = jbvNumeric;
- val->numeric = (Numeric) ((*it)->dataProper + INTALIGN(JBE_OFF(*ent)));
- val->estSize = 2 * sizeof(JEntry) + VARSIZE_ANY(val->numeric);
+ val->val.numeric = (Numeric) ((*it)->dataProper + INTALIGN(JBE_OFF(*ent)));
+ val->estSize = 2 * sizeof(JEntry) + VARSIZE_ANY(val->val.numeric);
return false;
}
else if (JBE_ISBOOL(*ent))
{
val->type = jbvBool;
- val->boolean = JBE_ISBOOL_TRUE(*ent) != 0;
+ val->val.boolean = JBE_ISBOOL_TRUE(*ent) != 0;
val->estSize = sizeof(JEntry);
return false;
else if (skipNested)
{
val->type = jbvBinary;
- val->binary.data = (*it)->dataProper + INTALIGN(JBE_OFF(*ent));
- val->binary.len = JBE_LEN(*ent) - (INTALIGN(JBE_OFF(*ent)) - JBE_OFF(*ent));
- val->estSize = val->binary.len + 2 * sizeof(JEntry);
+ val->val.binary.data = (*it)->dataProper + INTALIGN(JBE_OFF(*ent));
+ val->val.binary.len = JBE_LEN(*ent) - (INTALIGN(JBE_OFF(*ent)) - JBE_OFF(*ent));
+ val->estSize = val->val.binary.len + 2 * sizeof(JEntry);
return false;
}
Assert(object->type == jbvObject);
Assert(string->type == jbvString);
- if (object->object.nPairs >= JSONB_MAX_PAIRS)
+ if (object->val.object.nPairs >= JSONB_MAX_PAIRS)
ereport(ERROR,
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
errmsg("number of jsonb object pairs exceeds the maximum allowed (%zu)",
JSONB_MAX_PAIRS)));
- if (object->object.nPairs >= pstate->size)
+ if (object->val.object.nPairs >= pstate->size)
{
pstate->size *= 2;
- object->object.pairs = repalloc(object->object.pairs,
+ object->val.object.pairs = repalloc(object->val.object.pairs,
sizeof(JsonbPair) * pstate->size);
}
- object->object.pairs[object->object.nPairs].key = *string;
- object->object.pairs[object->object.nPairs].order = object->object.nPairs;
+ object->val.object.pairs[object->val.object.nPairs].key = *string;
+ object->val.object.pairs[object->val.object.nPairs].order = object->val.object.nPairs;
object->estSize += string->estSize;
}
Assert(object->type == jbvObject);
- object->object.pairs[object->object.nPairs++].value = *scalarVal;
+ object->val.object.pairs[object->val.object.nPairs++].value = *scalarVal;
object->estSize += scalarVal->estSize;
}
Assert(array->type == jbvArray);
- if (array->array.nElems >= JSONB_MAX_ELEMS)
+ if (array->val.array.nElems >= JSONB_MAX_ELEMS)
ereport(ERROR,
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
errmsg("number of jsonb array elements exceeds the maximum allowed (%zu)",
JSONB_MAX_ELEMS)));
- if (array->array.nElems >= pstate->size)
+ if (array->val.array.nElems >= pstate->size)
{
pstate->size *= 2;
- array->array.elems = repalloc(array->array.elems,
+ array->val.array.elems = repalloc(array->val.array.elems,
sizeof(JsonbValue) * pstate->size);
}
- array->array.elems[array->array.nElems++] = *scalarVal;
+ array->val.array.elems[array->val.array.nElems++] = *scalarVal;
array->estSize += scalarVal->estSize;
}
Assert(va->type == jbvString);
Assert(vb->type == jbvString);
- if (va->string.len == vb->string.len)
+ if (va->val.string.len == vb->val.string.len)
{
- res = memcmp(va->string.val, vb->string.val, va->string.len);
+ res = memcmp(va->val.string.val, vb->val.string.val, va->val.string.len);
if (res == 0 && binequal)
*((bool *) binequal) = true;
}
else
{
- res = (va->string.len > vb->string.len) ? 1 : -1;
+ res = (va->val.string.len > vb->val.string.len) ? 1 : -1;
}
return res;
Assert(object->type == jbvObject);
- if (object->object.nPairs > 1)
- qsort_arg(object->object.pairs, object->object.nPairs, sizeof(JsonbPair),
+ if (object->val.object.nPairs > 1)
+ qsort_arg(object->val.object.pairs, object->val.object.nPairs, sizeof(JsonbPair),
lengthCompareJsonbPair, &hasNonUniq);
if (hasNonUniq)
{
- JsonbPair *ptr = object->object.pairs + 1,
- *res = object->object.pairs;
+ JsonbPair *ptr = object->val.object.pairs + 1,
+ *res = object->val.object.pairs;
- while (ptr - object->object.pairs < object->object.nPairs)
+ while (ptr - object->val.object.pairs < object->val.object.nPairs)
{
/* Avoid copying over duplicate */
if (lengthCompareJsonbStringValue(ptr, res, NULL) == 0)
ptr++;
}
- object->object.nPairs = res + 1 - object->object.pairs;
+ object->val.object.nPairs = res + 1 - object->val.object.pairs;
}
}
* Actually sort values, determining if any were equal on the basis of full
* binary equality (rather than just having the same string length).
*/
- if (array->array.nElems > 1)
- qsort_arg(array->array.elems, array->array.nElems,
+ if (array->val.array.nElems > 1)
+ qsort_arg(array->val.array.elems, array->val.array.nElems,
sizeof(JsonbValue), lengthCompareJsonbStringValue,
&hasNonUniq);
if (hasNonUniq)
{
- JsonbValue *ptr = array->array.elems + 1,
- *res = array->array.elems;
+ JsonbValue *ptr = array->val.array.elems + 1,
+ *res = array->val.array.elems;
- while (ptr - array->array.elems < array->array.nElems)
+ while (ptr - array->val.array.elems < array->val.array.nElems)
{
/* Avoid copying over duplicate */
if (lengthCompareJsonbStringValue(ptr, res, NULL) != 0)
ptr++;
}
- array->array.nElems = res + 1 - array->array.elems;
+ array->val.array.nElems = res + 1 - array->val.array.elems;
}
}
{
char *cstr;
- cstr = palloc(v.string.len + 1 * sizeof(char));
- memcpy(cstr, v.string.val, v.string.len);
- cstr[v.string.len] = '\0';
+ cstr = palloc(v.val.string.len + 1 * sizeof(char));
+ memcpy(cstr, v.val.string.val, v.val.string.len);
+ cstr[v.val.string.len] = '\0';
state->result[state->result_count++] = cstr;
}
}
if (r == WJB_KEY)
{
- if (klen == v.string.len && strncmp(key, v.string.val, klen) == 0)
+ if (klen == v.val.string.len && strncmp(key, v.val.string.val, klen) == 0)
{
/*
* The next thing the iterator fetches should be the value, no
if (r == WJB_KEY)
{
- if (klen == v.string.len && strncmp(key, v.string.val, klen) == 0)
+ if (klen == v.val.string.len && strncmp(key, v.val.string.val, klen) == 0)
{
text *result;
*/
if (v.type == jbvString)
{
- result = cstring_to_text_with_len(v.string.val, v.string.len);
+ result = cstring_to_text_with_len(v.val.string.val, v.val.string.len);
}
else if (v.type == jbvNull)
{
if (v.type == jbvString)
{
- result = cstring_to_text_with_len(v.string.val, v.string.len);
+ result = cstring_to_text_with_len(v.val.string.val, v.val.string.len);
}
else if (v.type == jbvNull)
{
if (jbvp->type == jbvBinary)
{
- JsonbIterator *it = JsonbIteratorInit(jbvp->binary.data);
+ JsonbIterator *it = JsonbIteratorInit(jbvp->val.binary.data);
int r;
r = JsonbIteratorNext(&it, &tv, true);
- superHeader = (JsonbSuperHeader) jbvp->binary.data;
+ superHeader = (JsonbSuperHeader) jbvp->val.binary.data;
have_object = r == WJB_BEGIN_OBJECT;
have_array = r == WJB_BEGIN_ARRAY;
}
if (as_text)
{
if (jbvp->type == jbvString)
- PG_RETURN_TEXT_P(cstring_to_text_with_len(jbvp->string.val, jbvp->string.len));
+ PG_RETURN_TEXT_P(cstring_to_text_with_len(jbvp->val.string.val, jbvp->val.string.len));
else if (jbvp->type == jbvNull)
PG_RETURN_NULL();
}
/* Use the tmp context so we can clean up after each tuple is done */
old_cxt = MemoryContextSwitchTo(tmp_cxt);
- key = cstring_to_text_with_len(v.string.val, v.string.len);
+ key = cstring_to_text_with_len(v.val.string.val, v.val.string.len);
/*
* The next thing the iterator fetches should be the value, no
if (v.type == jbvString)
{
/* In text mode, scalar strings should be dequoted */
- sv = cstring_to_text_with_len(v.string.val, v.string.len);
+ sv = cstring_to_text_with_len(v.val.string.val, v.val.string.len);
}
else
{
if (v.type == jbvString)
{
/* in text mode scalar strings should be dequoted */
- sv = cstring_to_text_with_len(v.string.val, v.string.len);
+ sv = cstring_to_text_with_len(v.val.string.val, v.val.string.len);
}
else
{
else
{
if (v->type == jbvString)
- s = pnstrdup(v->string.val, v->string.len);
+ s = pnstrdup(v->val.string.val, v->val.string.len);
else if (v->type == jbvBool)
- s = pnstrdup((v->boolean) ? "t" : "f", 1);
+ s = pnstrdup((v->val.boolean) ? "t" : "f", 1);
else if (v->type == jbvNumeric)
s = DatumGetCString(DirectFunctionCall1(numeric_out,
- PointerGetDatum(v->numeric)));
+ PointerGetDatum(v->val.numeric)));
else if (!use_json_as_text)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("cannot populate with a nested object unless use_json_as_text is true")));
else if (v->type == jbvBinary)
- s = JsonbToCString(NULL, v->binary.data, v->binary.len);
+ s = JsonbToCString(NULL, v->val.binary.data, v->val.binary.len);
else
elog(ERROR, "invalid jsonb type");
}
char *s = NULL;
if (v->type == jbvString)
- s = pnstrdup(v->string.val, v->string.len);
+ s = pnstrdup(v->val.string.val, v->val.string.len);
else if (v->type == jbvBool)
- s = pnstrdup((v->boolean) ? "t" : "f", 1);
+ s = pnstrdup((v->val.boolean) ? "t" : "f", 1);
else if (v->type == jbvNumeric)
s = DatumGetCString(DirectFunctionCall1(numeric_out,
- PointerGetDatum(v->numeric)));
+ PointerGetDatum(v->val.numeric)));
else if (!state->use_json_as_text)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("cannot populate with a nested object unless use_json_as_text is true")));
else if (v->type == jbvBinary)
- s = JsonbToCString(NULL, v->binary.data, v->binary.len);
+ s = JsonbToCString(NULL, v->val.binary.data, v->val.binary.len);
else
elog(ERROR, "invalid jsonb type");
JsonbValue k;
k.type = jbvString;
- k.string.val = key;
- k.string.len = keylen;
+ k.val.string.val = key;
+ k.val.string.len = keylen;
return findJsonbValueFromSuperHeader(sheader, flags, NULL, &k);
}
projects / postgresql.git / commitdiff