jsonb_util.c Source File (original) (raw)

21#include "utils/fmgrprotos.h"

36#define JSONB_MAX_ELEMS (Min(MaxAllocSize / sizeof(JsonbValue), JB_CMASK))

37#define JSONB_MAX_PAIRS (Min(MaxAllocSize / sizeof(JsonbPair), JB_CMASK))

40 char *base_addr, uint32 offset,

63 const char *val2, int len2);

66 bool skip_nulls);

71void

73{

75 val->val.binary.data = &jsonb->root;

77}

93{

97 {

102

104 scalarArray.val.array.rawScalar = true;

105 scalarArray.val.array.nElems = 1;

106

110

112 }

114 {

116 }

117 else

118 {

122 memcpy(VARDATA(out), val->val.binary.data, val->val.binary.len);

123 }

124

125 return out;

126}

127

128

129

130

131

132

135{

137 int i;

138

139

140

141

142

143

144 for (i = index - 1; i >= 0; i--)

145 {

148 break;

149 }

150

151 return offset;

152}

153

154

155

156

157

160{

163

164

165

166

167

168

170 {

173 }

174 else

176

177 return len;

178}

179

180

181

182

183

184

185

186

187

188

189

190int

192{

194 *itb;

195 int res = 0;

196

199

200 do

201 {

203 vb;

205 rb;

206

209

210 if (ra == rb)

211 {

213 {

214

215 break;

216 }

217

219 {

220

221

222

223

224

225

226 continue;

227 }

228

230 {

231 switch (va.type)

232 {

238 break;

240

241

242

243

244

245

246

247 if (va.val.array.rawScalar != vb.val.array.rawScalar)

248 res = (va.val.array.rawScalar) ? -1 : 1;

249

250

251

252

253

254

255

256 if (va.val.array.nElems != vb.val.array.nElems)

257 res = (va.val.array.nElems > vb.val.array.nElems) ? 1 : -1;

258 break;

260 if (va.val.object.nPairs != vb.val.object.nPairs)

261 res = (va.val.object.nPairs > vb.val.object.nPairs) ? 1 : -1;

262 break;

264 elog(ERROR, "unexpected jbvBinary value");

265 break;

267 elog(ERROR, "unexpected jbvDatetime value");

268 break;

269 }

270 }

271 else

272 {

273

274 res = (va.type > vb.type) ? 1 : -1;

275 }

276 }

277 else

278 {

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

296

300

301 res = (va.type > vb.type) ? 1 : -1;

302 }

303 }

304 while (res == 0);

305

306 while (ita != NULL)

307 {

309

311 ita = i;

312 }

313 while (itb != NULL)

314 {

316

318 itb = i;

319 }

320

321 return res;

322}

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

353{

356

358

359

360 if (count <= 0)

361 return NULL;

362

364 {

366 char *base_addr = (char *) (children + count);

368 int i;

369

370 for (i = 0; i < count; i++)

371 {

373

374 if (key->type == result->type)

375 {

377 return result;

378 }

379

381 }

382

384 }

386 {

387

389

391 key->val.string.len, NULL);

392 }

393

394

395 return NULL;

396}

397

398

399

400

401

402

403

406 const char *keyVal, int keyLen, JsonbValue *res)

407{

410 char *baseAddr;

412 stopHigh;

413

415

416

417 if (count <= 0)

418 return NULL;

419

420

421

422

423

424 baseAddr = (char *) (children + count * 2);

425 stopLow = 0;

426 stopHigh = count;

427 while (stopLow < stopHigh)

428 {

431 const char *candidateVal;

432 int candidateLen;

433

434 stopMiddle = stopLow + (stopHigh - stopLow) / 2;

435

436 candidateVal = baseAddr + getJsonbOffset(container, stopMiddle);

437 candidateLen = getJsonbLength(container, stopMiddle);

438

440 keyVal, keyLen);

441

443 {

444

445 int index = stopMiddle + count;

446

447 if (!res)

449

452 res);

453

454 return res;

455 }

456 else

457 {

459 stopLow = stopMiddle + 1;

460 else

461 stopHigh = stopMiddle;

462 }

463 }

464

465

466 return NULL;

467}

468

469

470

471

472

473

476{

478 char *base_addr;

480

482 elog(ERROR, "not a jsonb array");

483

485 base_addr = (char *) &container->children[nelements];

486

487 if (i >= nelements)

488 return NULL;

489

491

494 result);

495

496 return result;

497}

498

499

500

501

502

503

504

505

506

507

508

509

510

511static void

513 char *base_addr, uint32 offset,

515{

517

519 {

521 }

523 {

525 result->val.string.val = base_addr + offset;

527 Assert(result->val.string.len >= 0);

528 }

530 {

533 }

535 {

537 result->val.boolean = true;

538 }

540 {

542 result->val.boolean = false;

543 }

544 else

545 {

548

552 }

553}

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

575{

580 int i;

581

583 {

585 for (i = 0; i < jbval->val.object.nPairs; i++)

586 {

589 }

590

592 }

593

595 {

597 for (i = 0; i < jbval->val.array.nElems; i++)

598 {

600 }

601

603 }

604

607 {

608

610 }

611

612

614

615 if ((jbval->val.binary.data->header & JB_FSCALAR) && *pstate)

616 {

620

623

625

629

630 return res;

631 }

632

637 v.val.array.rawScalar) ? &v : NULL);

638

639 return res;

640}

641

642

643

644

645

649{

651

652 switch (seq)

653 {

655 Assert(!scalarVal || scalarVal->val.array.rawScalar);

657 result = &(*pstate)->contVal;

659 (*pstate)->contVal.val.array.nElems = 0;

660 (*pstate)->contVal.val.array.rawScalar = (scalarVal &&

661 scalarVal->val.array.rawScalar);

662 if (scalarVal && scalarVal->val.array.nElems > 0)

663 {

664

666 (*pstate)->size = scalarVal->val.array.nElems;

667 }

668 else

669 {

670 (*pstate)->size = 4;

671 }

672 (*pstate)->contVal.val.array.elems = palloc(sizeof(JsonbValue) *

673 (*pstate)->size);

674 break;

678 result = &(*pstate)->contVal;

680 (*pstate)->contVal.val.object.nPairs = 0;

681 (*pstate)->size = 4;

682 (*pstate)->contVal.val.object.pairs = palloc(sizeof(JsonbPair) *

683 (*pstate)->size);

684 break;

688 break;

692 break;

696 break;

699 (*pstate)->unique_keys,

700 (*pstate)->skip_nulls);

701

703

705 result = &(*pstate)->contVal;

706

707

708

709

710

711 *pstate = (*pstate)->next;

712 if (*pstate)

713 {

714 switch ((*pstate)->contVal.type)

715 {

718 break;

721 break;

722 default:

723 elog(ERROR, "invalid jsonb container type");

724 }

725 }

726 break;

727 default:

728 elog(ERROR, "unrecognized jsonb sequential processing token");

729 }

730

731 return result;

732}

733

734

735

736

739{

741

742 ns->next = *pstate;

745

746 return ns;

747}

748

749

750

751

752static void

754{

756

759

762 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),

763 errmsg("number of jsonb object pairs exceeds the maximum allowed (%zu)",

765

766 if (object->val.object.nPairs >= pstate->size)

767 {

768 pstate->size *= 2;

769 object->val.object.pairs = repalloc(object->val.object.pairs,

771 }

772

773 object->val.object.pairs[object->val.object.nPairs].key = *string;

774 object->val.object.pairs[object->val.object.nPairs].order = object->val.object.nPairs;

775}

776

777

778

779

780

781static void

783{

785

787

788 object->val.object.pairs[object->val.object.nPairs++].value = *scalarVal;

789}

790

791

792

793

794static void

796{

798

800

803 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),

804 errmsg("number of jsonb array elements exceeds the maximum allowed (%zu)",

806

807 if (array->val.array.nElems >= pstate->size)

808 {

809 pstate->size *= 2;

810 array->val.array.elems = repalloc(array->val.array.elems,

812 }

813

814 array->val.array.elems[array->val.array.nElems++] = *scalarVal;

815}

816

817

818

819

820

821

822

825{

827}

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

861{

862 if (*it == NULL)

864

865

866

867

868

869

870

871recurse:

872 switch ((*it)->state)

873 {

875

877 val->val.array.nElems = (*it)->nElems;

878

879

880

881

882

883 val->val.array.rawScalar = (*it)->isScalar;

884 (*it)->curIndex = 0;

885 (*it)->curDataOffset = 0;

886 (*it)->curValueOffset = 0;

887

890

892 if ((*it)->curIndex >= (*it)->nElems)

893 {

894

895

896

897

898

899

902 }

903

905 (*it)->dataProper, (*it)->curDataOffset,

907

909 (*it)->children[(*it)->curIndex]);

910 (*it)->curIndex++;

911

913 {

914

916 goto recurse;

917 }

918 else

919 {

920

921

922

923

925 }

926

928

930 val->val.object.nPairs = (*it)->nElems;

931

932

933

934

935

936 (*it)->curIndex = 0;

937 (*it)->curDataOffset = 0;

938 (*it)->curValueOffset = getJsonbOffset((*it)->container,

939 (*it)->nElems);

940

943

945 if ((*it)->curIndex >= (*it)->nElems)

946 {

947

948

949

950

951

952

955 }

956 else

957 {

958

960 (*it)->dataProper, (*it)->curDataOffset,

963 elog(ERROR, "unexpected jsonb type as object key");

964

965

968 }

969

971

973

974 fillJsonbValue((*it)->container, (*it)->curIndex + (*it)->nElems,

975 (*it)->dataProper, (*it)->curValueOffset,

977

979 (*it)->children[(*it)->curIndex]);

981 (*it)->children[(*it)->curIndex + (*it)->nElems]);

982 (*it)->curIndex++;

983

984

985

986

987

988

990 {

992 goto recurse;

993 }

994 else

996 }

997

998 elog(ERROR, "invalid iterator state");

999 return -1;

1000}

1001

1002

1003

1004

1007{

1009

1012 it->parent = parent;

1014

1015

1017

1019 {

1024

1026

1028 break;

1029

1034 break;

1035

1036 default:

1037 elog(ERROR, "unknown type of jsonb container");

1038 }

1039

1040 return it;

1041}

1042

1043

1044

1045

1046

1049{

1051

1053 return v;

1054}

1055

1056

1057

1058

1059

1060

1061

1062

1063

1064

1065

1066

1067

1068bool

1070{

1072 vcontained;

1074 rcont;

1075

1076

1077

1078

1079

1080

1081

1083

1086

1087 if (rval != rcont)

1088 {

1089

1090

1091

1092

1093

1094

1097 return false;

1098 }

1100 {

1103

1104

1105

1106

1107

1108

1109

1110

1111 if (vval.val.object.nPairs < vcontained.val.object.nPairs)

1112 return false;

1113

1114

1115 for (;;)

1116 {

1117 JsonbValue *lhsVal;

1119

1121

1122

1123

1124

1125

1126

1128 return true;

1129

1132

1133

1134 lhsVal =

1136 vcontained.val.string.val,

1137 vcontained.val.string.len,

1138 &lhsValBuf);

1139 if (!lhsVal)

1140 return false;

1141

1142

1143

1144

1145

1147

1149

1150

1151

1152

1153

1154 if (lhsVal->type != vcontained.type)

1155 {

1156 return false;

1157 }

1159 {

1161 return false;

1162 }

1163 else

1164 {

1165

1167 *nestContained;

1168

1171

1174

1175

1176

1177

1178

1179

1180

1181

1182

1183

1184

1185

1186

1187

1188

1189

1190

1191

1192

1193

1194

1196 return false;

1197 }

1198 }

1199 }

1201 {

1203 uint32 nLhsElems = vval.val.array.nElems;

1204

1207

1208

1209

1210

1211

1212

1213

1214

1215

1216

1217

1218 if (vval.val.array.rawScalar && !vcontained.val.array.rawScalar)

1219 return false;

1220

1221

1222 for (;;)

1223 {

1225

1226

1227

1228

1229

1230

1232 return true;

1233

1235

1237 {

1240 &vcontained))

1241 return false;

1242 }

1243 else

1244 {

1246

1247

1248

1249

1250

1251 if (lhsConts == NULL)

1252 {

1254

1255

1257

1258 for (i = 0; i < nLhsElems; i++)

1259 {

1260

1263

1265 lhsConts[j++] = vval;

1266 }

1267

1268

1269 if (j == 0)

1270 return false;

1271

1272

1273 nLhsElems = j;

1274 }

1275

1276

1277 for (i = 0; i < nLhsElems; i++)

1278 {

1279

1281 *nestContained;

1282 bool contains;

1283

1286

1288

1289 if (nestval)

1291 if (nestContained)

1292 pfree(nestContained);

1293 if (contains)

1294 break;

1295 }

1296

1297

1298

1299

1300

1301 if (i == nLhsElems)

1302 return false;

1303 }

1304 }

1305 }

1306 else

1307 {

1308 elog(ERROR, "invalid jsonb container type");

1309 }

1310

1311 elog(ERROR, "unexpectedly fell off end of jsonb container");

1312 return false;

1313}

1314

1315

1316

1317

1318

1319

1320

1321

1322void

1324{

1326

1327

1328 switch (scalarVal->type)

1329 {

1331 tmp = 0x01;

1332 break;

1335 scalarVal->val.string.len));

1336 break;

1338

1341 break;

1343 tmp = scalarVal->val.boolean ? 0x02 : 0x04;

1344

1345 break;

1346 default:

1347 elog(ERROR, "invalid jsonb scalar type");

1348 tmp = 0;

1349 break;

1350 }

1351

1352

1353

1354

1355

1356

1358 *hash ^= tmp;

1359}

1360

1361

1362

1363

1364

1365void

1368{

1370

1371 switch (scalarVal->type)

1372 {

1374 tmp = seed + 0x01;

1375 break;

1378 scalarVal->val.string.len,

1379 seed));

1380 break;

1385 break;

1387 if (seed)

1391 else

1392 tmp = scalarVal->val.boolean ? 0x02 : 0x04;

1393

1394 break;

1395 default:

1396 elog(ERROR, "invalid jsonb scalar type");

1397 break;

1398 }

1399

1401 *hash ^= tmp;

1402}

1403

1404

1405

1406

1407static bool

1409{

1410 if (a->type == b->type)

1411 {

1412 switch (a->type)

1413 {

1415 return true;

1423 return a->val.boolean == b->val.boolean;

1424

1425 default:

1426 elog(ERROR, "invalid jsonb scalar type");

1427 }

1428 }

1429 elog(ERROR, "jsonb scalar type mismatch");

1430 return false;

1431}

1432

1433

1434

1435

1436

1437

1438

1439static int

1441{

1442 if (a->type == b->type)

1443 {

1444 switch (a->type)

1445 {

1447 return 0;

1450 a->val.string.len,

1451 b->val.string.val,

1452 b->val.string.len,

1453 DEFAULT_COLLATION_OID);

1459 if (a->val.boolean == b->val.boolean)

1460 return 0;

1461 else if (a->val.boolean > b->val.boolean)

1462 return 1;

1463 else

1464 return -1;

1465 default:

1466 elog(ERROR, "invalid jsonb scalar type");

1467 }

1468 }

1469 elog(ERROR, "jsonb scalar type mismatch");

1470 return -1;

1471}

1472

1473

1474

1475

1476

1477

1478

1479

1480

1481

1482

1483

1484static int

1486{

1487 int offset;

1488

1489

1491

1492

1493 offset = buffer->len;

1494

1495

1497

1498

1499

1500

1501

1502 buffer->data[buffer->len] = '\0';

1503

1504 return offset;

1505}

1506

1507

1508

1509

1510static void

1512{

1513 memcpy(buffer->data + offset, data, len);

1514}

1515

1516

1517

1518

1519static void

1521{

1522 int offset;

1523

1526}

1527

1528

1529

1530

1531

1532

1533static short

1535{

1536 int padlen,

1537 p,

1538 offset;

1539

1541

1543

1544

1545 for (p = 0; p < padlen; p++)

1546 buffer->data[offset + p] = '\0';

1547

1548 return padlen;

1549}

1550

1551

1552

1553

1556{

1560

1561

1563

1564

1566

1567

1569

1571

1572

1573

1574

1575

1576

1577

1579

1581

1582 return res;

1583}

1584

1585

1586

1587

1588

1589

1590

1591

1592

1593

1594

1595

1596static void

1598{

1600

1601 if ( val )

1602 return;

1603

1604

1605

1606

1607

1608

1609

1610

1617 else

1618 elog(ERROR, "unknown type of jsonb container to convert");

1619}

1620

1621static void

1623{

1624 int base_offset;

1625 int jentry_offset;

1626 int i;

1627 int totallen;

1628 uint32 containerhead;

1629 int nElems = val->val.array.nElems;

1630

1631

1632 base_offset = buffer->len;

1633

1634

1636

1637

1638

1639

1640

1641 containerhead = nElems | JB_FARRAY;

1642 if (val->val.array.rawScalar)

1643 {

1644 Assert(nElems == 1);

1647 }

1648

1650

1651

1653

1654 totallen = 0;

1655 for (i = 0; i < nElems; i++)

1656 {

1658 int len;

1660

1661

1662

1663

1664

1666

1668 totallen += len;

1669

1670

1671

1672

1673

1674

1677 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),

1678 errmsg("total size of jsonb array elements exceeds the maximum of %d bytes",

1680

1681

1682

1683

1686

1688 jentry_offset += sizeof(JEntry);

1689 }

1690

1691

1692 totallen = buffer->len - base_offset;

1693

1694

1697 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),

1698 errmsg("total size of jsonb array elements exceeds the maximum of %d bytes",

1700

1701

1703}

1704

1705static void

1707{

1708 int base_offset;

1709 int jentry_offset;

1710 int i;

1711 int totallen;

1712 uint32 containerheader;

1713 int nPairs = val->val.object.nPairs;

1714

1715

1716 base_offset = buffer->len;

1717

1718

1720

1721

1722

1723

1724

1725 containerheader = nPairs | JB_FOBJECT;

1727

1728

1730

1731

1732

1733

1734

1735 totallen = 0;

1736 for (i = 0; i < nPairs; i++)

1737 {

1739 int len;

1741

1742

1743

1744

1745

1747

1749 totallen += len;

1750

1751

1752

1753

1754

1755

1758 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),

1759 errmsg("total size of jsonb object elements exceeds the maximum of %d bytes",

1761

1762

1763

1764

1767

1769 jentry_offset += sizeof(JEntry);

1770 }

1771 for (i = 0; i < nPairs; i++)

1772 {

1774 int len;

1776

1777

1778

1779

1780

1782

1784 totallen += len;

1785

1786

1787

1788

1789

1790

1793 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),

1794 errmsg("total size of jsonb object elements exceeds the maximum of %d bytes",

1796

1797

1798

1799

1802

1804 jentry_offset += sizeof(JEntry);

1805 }

1806

1807

1808 totallen = buffer->len - base_offset;

1809

1810

1813 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),

1814 errmsg("total size of jsonb object elements exceeds the maximum of %d bytes",

1816

1817

1819}

1820

1821static void

1823{

1824 int numlen;

1825 short padlen;

1826

1827 switch (scalarVal->type)

1828 {

1831 break;

1832

1834 appendToBuffer(buffer, scalarVal->val.string.val, scalarVal->val.string.len);

1835

1836 *header = scalarVal->val.string.len;

1837 break;

1838

1842

1844

1846 break;

1847

1849 *header = (scalarVal->val.boolean) ?

1851 break;

1852

1854 {

1856 size_t len;

1857

1859 scalarVal->val.datetime.value,

1860 scalarVal->val.datetime.typid,

1861 &scalarVal->val.datetime.tz);

1864

1865 *header = len;

1866 }

1867 break;

1868

1869 default:

1870 elog(ERROR, "invalid jsonb scalar type");

1871 }

1872}

1873

1874

1875

1876

1877

1878

1879

1880

1881

1882

1883

1884

1885

1886static int

1888{

1891

1894

1896 vb->val.string.val, vb->val.string.len);

1897}

1898

1899

1900

1901

1902

1903

1904

1905static int

1907{

1908 if (len1 == len2)

1909 return memcmp(val1, val2, len1);

1910 else

1911 return len1 > len2 ? 1 : -1;

1912}

1913

1914

1915

1916

1917

1918

1919

1920

1921

1922

1923

1924

1925static int

1927{

1930 int res;

1931

1933 if (res == 0 && binequal)

1934 *((bool *) binequal) = true;

1935

1936

1937

1938

1939

1940 if (res == 0)

1941 res = (pa->order > pb->order) ? -1 : 1;

1942

1943 return res;

1944}

1945

1946

1947

1948

1949static void

1951{

1952 bool hasNonUniq = false;

1953

1955

1956 if (object->val.object.nPairs > 1)

1959

1960 if (hasNonUniq && unique_keys)

1962 errcode(ERRCODE_DUPLICATE_JSON_OBJECT_KEY_VALUE),

1963 errmsg("duplicate JSON object key value"));

1964

1965 if (hasNonUniq || skip_nulls)

1966 {

1968 *res;

1969

1970 while (skip_nulls && object->val.object.nPairs > 0 &&

1971 object->val.object.pairs->value.type == jbvNull)

1972 {

1973

1974 object->val.object.pairs++;

1975 object->val.object.nPairs--;

1976 }

1977

1978 if (object->val.object.nPairs > 0)

1979 {

1980 ptr = object->val.object.pairs + 1;

1981 res = object->val.object.pairs;

1982

1983 while (ptr - object->val.object.pairs < object->val.object.nPairs)

1984 {

1985

1988 {

1989 res++;

1990 if (ptr != res)

1991 memcpy(res, ptr, sizeof(JsonbPair));

1992 }

1993 ptr++;

1994 }

1995

1996 object->val.object.nPairs = res + 1 - object->val.object.pairs;

1997 }

1998 }

1999}

Datum hash_numeric(PG_FUNCTION_ARGS)

Datum hash_numeric_extended(PG_FUNCTION_ARGS)

Datum numeric_cmp(PG_FUNCTION_ARGS)

Datum numeric_eq(PG_FUNCTION_ARGS)

int errcode(int sqlerrcode)

int errmsg(const char *fmt,...)

#define ereport(elevel,...)

#define DirectFunctionCall2(func, arg1, arg2)

#define DirectFunctionCall1(func, arg1)

Datum difference(PG_FUNCTION_ARGS)

#define ROTATE_HIGH_AND_LOW_32BITS(v)

static Datum hash_any_extended(const unsigned char *k, int keylen, uint64 seed)

static Datum hash_any(const unsigned char *k, int keylen)

Assert(PointerIsAligned(start, uint64))

Datum hashcharextended(PG_FUNCTION_ARGS)

if(TABLE==NULL||TABLE_index==NULL)

char * JsonEncodeDateTime(char *buf, Datum value, Oid typid, const int *tzp)

#define JsonContainerIsScalar(jc)

#define JsonContainerIsArray(jc)

#define JsonContainerSize(jc)

#define JBE_ISBOOL_TRUE(je_)

#define IsAJsonbScalar(jsonbval)

#define JENTRY_OFFLENMASK

#define JBE_ISNUMERIC(je_)

#define JBE_ISBOOL_FALSE(je_)

#define JENTRY_ISCONTAINER

#define JBE_ISSTRING(je_)

#define JENTRY_ISBOOL_FALSE

#define JBE_OFFLENFLD(je_)

#define JsonContainerIsObject(jc)

#define JENTRY_ISBOOL_TRUE

#define JBE_ISCONTAINER(je_)

#define JBE_ADVANCE_OFFSET(offset, je)

static int lengthCompareJsonbString(const char *val1, int len1, const char *val2, int len2)

static void appendElement(JsonbParseState *pstate, JsonbValue *scalarVal)

static void convertJsonbScalar(StringInfo buffer, JEntry *header, JsonbValue *scalarVal)

static void convertJsonbObject(StringInfo buffer, JEntry *header, JsonbValue *val, int level)

static int lengthCompareJsonbStringValue(const void *a, const void *b)

static JsonbIterator * iteratorFromContainer(JsonbContainer *container, JsonbIterator *parent)

static void fillJsonbValue(JsonbContainer *container, int index, char *base_addr, uint32 offset, JsonbValue *result)

static void copyToBuffer(StringInfo buffer, int offset, const void *data, int len)

static void convertJsonbArray(StringInfo buffer, JEntry *header, JsonbValue *val, int level)

static void appendToBuffer(StringInfo buffer, const void *data, int len)

static void uniqueifyJsonbObject(JsonbValue *object, bool unique_keys, bool skip_nulls)

static void appendValue(JsonbParseState *pstate, JsonbValue *scalarVal)

static JsonbValue * pushJsonbValueScalar(JsonbParseState **pstate, JsonbIteratorToken seq, JsonbValue *scalarVal)

JsonbValue * getKeyJsonValueFromContainer(JsonbContainer *container, const char *keyVal, int keyLen, JsonbValue *res)

int compareJsonbContainers(JsonbContainer *a, JsonbContainer *b)

uint32 getJsonbLength(const JsonbContainer *jc, int index)

static short padBufferToInt(StringInfo buffer)

JsonbValue * pushJsonbValue(JsonbParseState **pstate, JsonbIteratorToken seq, JsonbValue *jbval)

JsonbIterator * JsonbIteratorInit(JsonbContainer *container)

void JsonbHashScalarValue(const JsonbValue *scalarVal, uint32 *hash)

static JsonbParseState * pushState(JsonbParseState **pstate)

void JsonbToJsonbValue(Jsonb *jsonb, JsonbValue *val)

JsonbValue * findJsonbValueFromContainer(JsonbContainer *container, uint32 flags, JsonbValue *key)

JsonbIteratorToken JsonbIteratorNext(JsonbIterator **it, JsonbValue *val, bool skipNested)

static int compareJsonbScalarValue(JsonbValue *a, JsonbValue *b)

static void appendKey(JsonbParseState *pstate, JsonbValue *string)

static bool equalsJsonbScalarValue(JsonbValue *a, JsonbValue *b)

uint32 getJsonbOffset(const JsonbContainer *jc, int index)

void JsonbHashScalarValueExtended(const JsonbValue *scalarVal, uint64 *hash, uint64 seed)

static Jsonb * convertToJsonb(JsonbValue *val)

JsonbValue * getIthJsonbValueFromContainer(JsonbContainer *container, uint32 i)

Jsonb * JsonbValueToJsonb(JsonbValue *val)

static int lengthCompareJsonbPair(const void *a, const void *b, void *binequal)

bool JsonbDeepContains(JsonbIterator **val, JsonbIterator **mContained)

static JsonbIterator * freeAndGetParent(JsonbIterator *it)

static void convertJsonbValue(StringInfo buffer, JEntry *header, JsonbValue *val, int level)

static int reserveFromBuffer(StringInfo buffer, int len)

void * repalloc(void *pointer, Size size)

void pfree(void *pointer)

void * palloc0(Size size)

struct NumericData * Numeric

static Datum NumericGetDatum(Numeric X)

static uint32 pg_rotate_left32(uint32 word, int n)

void qsort_arg(void *base, size_t nel, size_t elsize, qsort_arg_comparator cmp, void *arg)

static uint32 DatumGetUInt32(Datum X)

static uint64 DatumGetUInt64(Datum X)

static bool DatumGetBool(Datum X)

static Datum PointerGetDatum(const void *X)

static Datum UInt64GetDatum(uint64 X)

static Datum BoolGetDatum(bool X)

static int32 DatumGetInt32(Datum X)

static unsigned hash(unsigned *uv, int n)

void check_stack_depth(void)

void enlargeStringInfo(StringInfo str, int needed)

void initStringInfo(StringInfo str)

JEntry children[FLEXIBLE_ARRAY_MEMBER]

struct JsonbIterator * parent

JsonbContainer * container

struct JsonbParseState * next

#define SET_VARSIZE(PTR, len)

int varstr_cmp(const char *arg1, int len1, const char *arg2, int len2, Oid collid)