/*------------------------------------------------------------------------- * * jsonpath_exec.c * Routines for SQL/JSON path execution. * * Jsonpath is executed in the global context stored in JsonPathExecContext, * which is passed to almost every function involved into execution. Entry * point for jsonpath execution is executeJsonPath() function, which * initializes execution context including initial JsonPathItem and JsonbValue, * flags, stack for calculation of @ in filters. * * The result of jsonpath query execution is enum JsonPathExecResult and * if succeeded sequence of JsonbValue, written to JsonValueList *found, which * is passed through the jsonpath items. When found == NULL, we're inside * exists-query and we're interested only in whether result is empty. In this * case execution is stopped once first result item is found, and the only * execution result is JsonPathExecResult. The values of JsonPathExecResult * are following: * - jperOk -- result sequence is not empty * - jperNotFound -- result sequence is empty * - jperError -- error occurred during execution * * Jsonpath is executed recursively (see executeItem()) starting form the * first path item (which in turn might be, for instance, an arithmetic * expression evaluated separately). On each step single JsonbValue obtained * from previous path item is processed. The result of processing is a * sequence of JsonbValue (probably empty), which is passed to the next path * item one by one. When there is no next path item, then JsonbValue is added * to the 'found' list. When found == NULL, then execution functions just * return jperOk (see executeNextItem()). * * Many of jsonpath operations require automatic unwrapping of arrays in lax * mode. So, if input value is array, then corresponding operation is * processed not on array itself, but on all of its members one by one. * executeItemOptUnwrapTarget() function have 'unwrap' argument, which indicates * whether unwrapping of array is needed. When unwrap == true, each of array * members is passed to executeItemOptUnwrapTarget() again but with unwrap == false * in order to avoid subsequent array unwrapping. * * All boolean expressions (predicates) are evaluated by executeBoolItem() * function, which returns tri-state JsonPathBool. When error is occurred * during predicate execution, it returns jpbUnknown. According to standard * predicates can be only inside filters. But we support their usage as * jsonpath expression. This helps us to implement @@ operator. In this case * resulting JsonPathBool is transformed into jsonb bool or null. * * Arithmetic and boolean expression are evaluated recursively from expression * tree top down to the leaves. Therefore, for binary arithmetic expressions * we calculate operands first. Then we check that results are numeric * singleton lists, calculate the result and pass it to the next path item. * * Copyright (c) 2019-2021, PostgreSQL Global Development Group * * IDENTIFICATION * src/backend/utils/adt/jsonpath_exec.c * *------------------------------------------------------------------------- */ #include "postgres.h" #include "catalog/pg_collation.h" #include "catalog/pg_type.h" #include "funcapi.h" #include "lib/stringinfo.h" #include "miscadmin.h" #include "regex/regex.h" #include "utils/builtins.h" #include "utils/date.h" #include "utils/datetime.h" #include "utils/datum.h" #include "utils/float.h" #include "utils/formatting.h" #include "utils/guc.h" #include "utils/json.h" #include "utils/jsonpath.h" #include "utils/timestamp.h" #include "utils/varlena.h" /* * Represents "base object" and it's "id" for .keyvalue() evaluation. */ typedef struct JsonBaseObjectInfo { JsonbContainer *jbc; int id; } JsonBaseObjectInfo; /* * Context of jsonpath execution. */ typedef struct JsonPathExecContext { Jsonb *vars; /* variables to substitute into jsonpath */ JsonbValue *root; /* for $ evaluation */ JsonbValue *current; /* for @ evaluation */ JsonBaseObjectInfo baseObject; /* "base object" for .keyvalue() * evaluation */ int lastGeneratedObjectId; /* "id" counter for .keyvalue() * evaluation */ int innermostArraySize; /* for LAST array index evaluation */ bool laxMode; /* true for "lax" mode, false for "strict" * mode */ bool ignoreStructuralErrors; /* with "true" structural errors such * as absence of required json item or * unexpected json item type are * ignored */ bool throwErrors; /* with "false" all suppressible errors are * suppressed */ bool useTz; } JsonPathExecContext; /* Context for LIKE_REGEX execution. */ typedef struct JsonLikeRegexContext { text *regex; int cflags; } JsonLikeRegexContext; /* Result of jsonpath predicate evaluation */ typedef enum JsonPathBool { jpbFalse = 0, jpbTrue = 1, jpbUnknown = 2 } JsonPathBool; /* Result of jsonpath expression evaluation */ typedef enum JsonPathExecResult { jperOk = 0, jperNotFound = 1, jperError = 2 } JsonPathExecResult; #define jperIsError(jper) ((jper) == jperError) /* * List of jsonb values with shortcut for single-value list. */ typedef struct JsonValueList { JsonbValue *singleton; List *list; } JsonValueList; typedef struct JsonValueListIterator { JsonbValue *value; List *list; ListCell *next; } JsonValueListIterator; /* strict/lax flags is decomposed into four [un]wrap/error flags */ #define jspStrictAbsenseOfErrors(cxt) (!(cxt)->laxMode) #define jspAutoUnwrap(cxt) ((cxt)->laxMode) #define jspAutoWrap(cxt) ((cxt)->laxMode) #define jspIgnoreStructuralErrors(cxt) ((cxt)->ignoreStructuralErrors) #define jspThrowErrors(cxt) ((cxt)->throwErrors) /* Convenience macro: return or throw error depending on context */ #define RETURN_ERROR(throw_error) \ do { \ if (jspThrowErrors(cxt)) \ throw_error; \ else \ return jperError; \ } while (0) typedef JsonPathBool (*JsonPathPredicateCallback) (JsonPathItem *jsp, JsonbValue *larg, JsonbValue *rarg, void *param); typedef Numeric (*BinaryArithmFunc) (Numeric num1, Numeric num2, bool *error); static JsonPathExecResult executeJsonPath(JsonPath *path, Jsonb *vars, Jsonb *json, bool throwErrors, JsonValueList *result, bool useTz); static JsonPathExecResult executeItem(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found); static JsonPathExecResult executeItemOptUnwrapTarget(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found, bool unwrap); static JsonPathExecResult executeItemUnwrapTargetArray(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found, bool unwrapElements); static JsonPathExecResult executeNextItem(JsonPathExecContext *cxt, JsonPathItem *cur, JsonPathItem *next, JsonbValue *v, JsonValueList *found, bool copy); static JsonPathExecResult executeItemOptUnwrapResult(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, bool unwrap, JsonValueList *found); static JsonPathExecResult executeItemOptUnwrapResultNoThrow(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, bool unwrap, JsonValueList *found); static JsonPathBool executeBoolItem(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, bool canHaveNext); static JsonPathBool executeNestedBoolItem(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb); static JsonPathExecResult executeAnyItem(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbContainer *jbc, JsonValueList *found, uint32 level, uint32 first, uint32 last, bool ignoreStructuralErrors, bool unwrapNext); static JsonPathBool executePredicate(JsonPathExecContext *cxt, JsonPathItem *pred, JsonPathItem *larg, JsonPathItem *rarg, JsonbValue *jb, bool unwrapRightArg, JsonPathPredicateCallback exec, void *param); static JsonPathExecResult executeBinaryArithmExpr(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, BinaryArithmFunc func, JsonValueList *found); static JsonPathExecResult executeUnaryArithmExpr(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, PGFunction func, JsonValueList *found); static JsonPathBool executeStartsWith(JsonPathItem *jsp, JsonbValue *whole, JsonbValue *initial, void *param); static JsonPathBool executeLikeRegex(JsonPathItem *jsp, JsonbValue *str, JsonbValue *rarg, void *param); static JsonPathExecResult executeNumericItemMethod(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, bool unwrap, PGFunction func, JsonValueList *found); static JsonPathExecResult executeDateTimeMethod(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found); static JsonPathExecResult executeKeyValueMethod(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found); static JsonPathExecResult appendBoolResult(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonValueList *found, JsonPathBool res); static void getJsonPathItem(JsonPathExecContext *cxt, JsonPathItem *item, JsonbValue *value); static void getJsonPathVariable(JsonPathExecContext *cxt, JsonPathItem *variable, Jsonb *vars, JsonbValue *value); static int JsonbArraySize(JsonbValue *jb); static JsonPathBool executeComparison(JsonPathItem *cmp, JsonbValue *lv, JsonbValue *rv, void *p); static JsonPathBool compareItems(int32 op, JsonbValue *jb1, JsonbValue *jb2, bool useTz); static int compareNumeric(Numeric a, Numeric b); static JsonbValue *copyJsonbValue(JsonbValue *src); static JsonPathExecResult getArrayIndex(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, int32 *index); static JsonBaseObjectInfo setBaseObject(JsonPathExecContext *cxt, JsonbValue *jbv, int32 id); static void JsonValueListAppend(JsonValueList *jvl, JsonbValue *jbv); static int JsonValueListLength(const JsonValueList *jvl); static bool JsonValueListIsEmpty(JsonValueList *jvl); static JsonbValue *JsonValueListHead(JsonValueList *jvl); static List *JsonValueListGetList(JsonValueList *jvl); static void JsonValueListInitIterator(const JsonValueList *jvl, JsonValueListIterator *it); static JsonbValue *JsonValueListNext(const JsonValueList *jvl, JsonValueListIterator *it); static int JsonbType(JsonbValue *jb); static JsonbValue *JsonbInitBinary(JsonbValue *jbv, Jsonb *jb); static int JsonbType(JsonbValue *jb); static JsonbValue *getScalar(JsonbValue *scalar, enum jbvType type); static JsonbValue *wrapItemsInArray(const JsonValueList *items); static int compareDatetime(Datum val1, Oid typid1, Datum val2, Oid typid2, bool useTz, bool *have_error); /****************** User interface to JsonPath executor ********************/ /* * jsonb_path_exists * Returns true if jsonpath returns at least one item for the specified * jsonb value. This function and jsonb_path_match() are used to * implement @? and @@ operators, which in turn are intended to have an * index support. Thus, it's desirable to make it easier to achieve * consistency between index scan results and sequential scan results. * So, we throw as few errors as possible. Regarding this function, * such behavior also matches behavior of JSON_EXISTS() clause of * SQL/JSON. Regarding jsonb_path_match(), this function doesn't have * an analogy in SQL/JSON, so we define its behavior on our own. */ static Datum jsonb_path_exists_internal(FunctionCallInfo fcinfo, bool tz) { Jsonb *jb = PG_GETARG_JSONB_P(0); JsonPath *jp = PG_GETARG_JSONPATH_P(1); JsonPathExecResult res; Jsonb *vars = NULL; bool silent = true; if (PG_NARGS() == 4) { vars = PG_GETARG_JSONB_P(2); silent = PG_GETARG_BOOL(3); } res = executeJsonPath(jp, vars, jb, !silent, NULL, tz); PG_FREE_IF_COPY(jb, 0); PG_FREE_IF_COPY(jp, 1); if (jperIsError(res)) PG_RETURN_NULL(); PG_RETURN_BOOL(res == jperOk); } Datum jsonb_path_exists(PG_FUNCTION_ARGS) { return jsonb_path_exists_internal(fcinfo, false); } Datum jsonb_path_exists_tz(PG_FUNCTION_ARGS) { return jsonb_path_exists_internal(fcinfo, true); } /* * jsonb_path_exists_opr * Implementation of operator "jsonb @? jsonpath" (2-argument version of * jsonb_path_exists()). */ Datum jsonb_path_exists_opr(PG_FUNCTION_ARGS) { /* just call the other one -- it can handle both cases */ return jsonb_path_exists_internal(fcinfo, false); } /* * jsonb_path_match * Returns jsonpath predicate result item for the specified jsonb value. * See jsonb_path_exists() comment for details regarding error handling. */ static Datum jsonb_path_match_internal(FunctionCallInfo fcinfo, bool tz) { Jsonb *jb = PG_GETARG_JSONB_P(0); JsonPath *jp = PG_GETARG_JSONPATH_P(1); JsonValueList found = {0}; Jsonb *vars = NULL; bool silent = true; if (PG_NARGS() == 4) { vars = PG_GETARG_JSONB_P(2); silent = PG_GETARG_BOOL(3); } (void) executeJsonPath(jp, vars, jb, !silent, &found, tz); PG_FREE_IF_COPY(jb, 0); PG_FREE_IF_COPY(jp, 1); if (JsonValueListLength(&found) == 1) { JsonbValue *jbv = JsonValueListHead(&found); if (jbv->type == jbvBool) PG_RETURN_BOOL(jbv->val.boolean); if (jbv->type == jbvNull) PG_RETURN_NULL(); } if (!silent) ereport(ERROR, (errcode(ERRCODE_SINGLETON_SQL_JSON_ITEM_REQUIRED), errmsg("single boolean result is expected"))); PG_RETURN_NULL(); } Datum jsonb_path_match(PG_FUNCTION_ARGS) { return jsonb_path_match_internal(fcinfo, false); } Datum jsonb_path_match_tz(PG_FUNCTION_ARGS) { return jsonb_path_match_internal(fcinfo, true); } /* * jsonb_path_match_opr * Implementation of operator "jsonb @@ jsonpath" (2-argument version of * jsonb_path_match()). */ Datum jsonb_path_match_opr(PG_FUNCTION_ARGS) { /* just call the other one -- it can handle both cases */ return jsonb_path_match_internal(fcinfo, false); } /* * jsonb_path_query * Executes jsonpath for given jsonb document and returns result as * rowset. */ static Datum jsonb_path_query_internal(FunctionCallInfo fcinfo, bool tz) { FuncCallContext *funcctx; List *found; JsonbValue *v; ListCell *c; if (SRF_IS_FIRSTCALL()) { JsonPath *jp; Jsonb *jb; MemoryContext oldcontext; Jsonb *vars; bool silent; JsonValueList found = {0}; funcctx = SRF_FIRSTCALL_INIT(); oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); jb = PG_GETARG_JSONB_P_COPY(0); jp = PG_GETARG_JSONPATH_P_COPY(1); vars = PG_GETARG_JSONB_P_COPY(2); silent = PG_GETARG_BOOL(3); (void) executeJsonPath(jp, vars, jb, !silent, &found, tz); funcctx->user_fctx = JsonValueListGetList(&found); MemoryContextSwitchTo(oldcontext); } funcctx = SRF_PERCALL_SETUP(); found = funcctx->user_fctx; c = list_head(found); if (c == NULL) SRF_RETURN_DONE(funcctx); v = lfirst(c); funcctx->user_fctx = list_delete_first(found); SRF_RETURN_NEXT(funcctx, JsonbPGetDatum(JsonbValueToJsonb(v))); } Datum jsonb_path_query(PG_FUNCTION_ARGS) { return jsonb_path_query_internal(fcinfo, false); } Datum jsonb_path_query_tz(PG_FUNCTION_ARGS) { return jsonb_path_query_internal(fcinfo, true); } /* * jsonb_path_query_array * Executes jsonpath for given jsonb document and returns result as * jsonb array. */ static Datum jsonb_path_query_array_internal(FunctionCallInfo fcinfo, bool tz) { Jsonb *jb = PG_GETARG_JSONB_P(0); JsonPath *jp = PG_GETARG_JSONPATH_P(1); JsonValueList found = {0}; Jsonb *vars = PG_GETARG_JSONB_P(2); bool silent = PG_GETARG_BOOL(3); (void) executeJsonPath(jp, vars, jb, !silent, &found, tz); PG_RETURN_JSONB_P(JsonbValueToJsonb(wrapItemsInArray(&found))); } Datum jsonb_path_query_array(PG_FUNCTION_ARGS) { return jsonb_path_query_array_internal(fcinfo, false); } Datum jsonb_path_query_array_tz(PG_FUNCTION_ARGS) { return jsonb_path_query_array_internal(fcinfo, true); } /* * jsonb_path_query_first * Executes jsonpath for given jsonb document and returns first result * item. If there are no items, NULL returned. */ static Datum jsonb_path_query_first_internal(FunctionCallInfo fcinfo, bool tz) { Jsonb *jb = PG_GETARG_JSONB_P(0); JsonPath *jp = PG_GETARG_JSONPATH_P(1); JsonValueList found = {0}; Jsonb *vars = PG_GETARG_JSONB_P(2); bool silent = PG_GETARG_BOOL(3); (void) executeJsonPath(jp, vars, jb, !silent, &found, tz); if (JsonValueListLength(&found) >= 1) PG_RETURN_JSONB_P(JsonbValueToJsonb(JsonValueListHead(&found))); else PG_RETURN_NULL(); } Datum jsonb_path_query_first(PG_FUNCTION_ARGS) { return jsonb_path_query_first_internal(fcinfo, false); } Datum jsonb_path_query_first_tz(PG_FUNCTION_ARGS) { return jsonb_path_query_first_internal(fcinfo, true); } /********************Execute functions for JsonPath**************************/ /* * Interface to jsonpath executor * * 'path' - jsonpath to be executed * 'vars' - variables to be substituted to jsonpath * 'json' - target document for jsonpath evaluation * 'throwErrors' - whether we should throw suppressible errors * 'result' - list to store result items into * * Returns an error if a recoverable error happens during processing, or NULL * on no error. * * Note, jsonb and jsonpath values should be available and untoasted during * work because JsonPathItem, JsonbValue and result item could have pointers * into input values. If caller needs to just check if document matches * jsonpath, then it doesn't provide a result arg. In this case executor * works till first positive result and does not check the rest if possible. * In other case it tries to find all the satisfied result items. */ static JsonPathExecResult executeJsonPath(JsonPath *path, Jsonb *vars, Jsonb *json, bool throwErrors, JsonValueList *result, bool useTz) { JsonPathExecContext cxt; JsonPathExecResult res; JsonPathItem jsp; JsonbValue jbv; jspInit(&jsp, path); if (!JsonbExtractScalar(&json->root, &jbv)) JsonbInitBinary(&jbv, json); if (vars && !JsonContainerIsObject(&vars->root)) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("\"vars\" argument is not an object"), errdetail("Jsonpath parameters should be encoded as key-value pairs of \"vars\" object."))); } cxt.vars = vars; cxt.laxMode = (path->header & JSONPATH_LAX) != 0; cxt.ignoreStructuralErrors = cxt.laxMode; cxt.root = &jbv; cxt.current = &jbv; cxt.baseObject.jbc = NULL; cxt.baseObject.id = 0; cxt.lastGeneratedObjectId = vars ? 2 : 1; cxt.innermostArraySize = -1; cxt.throwErrors = throwErrors; cxt.useTz = useTz; if (jspStrictAbsenseOfErrors(&cxt) && !result) { /* * In strict mode we must get a complete list of values to check that * there are no errors at all. */ JsonValueList vals = {0}; res = executeItem(&cxt, &jsp, &jbv, &vals); if (jperIsError(res)) return res; return JsonValueListIsEmpty(&vals) ? jperNotFound : jperOk; } res = executeItem(&cxt, &jsp, &jbv, result); Assert(!throwErrors || !jperIsError(res)); return res; } /* * Execute jsonpath with automatic unwrapping of current item in lax mode. */ static JsonPathExecResult executeItem(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found) { return executeItemOptUnwrapTarget(cxt, jsp, jb, found, jspAutoUnwrap(cxt)); } /* * Main jsonpath executor function: walks on jsonpath structure, finds * relevant parts of jsonb and evaluates expressions over them. * When 'unwrap' is true current SQL/JSON item is unwrapped if it is an array. */ static JsonPathExecResult executeItemOptUnwrapTarget(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found, bool unwrap) { JsonPathItem elem; JsonPathExecResult res = jperNotFound; JsonBaseObjectInfo baseObject; check_stack_depth(); CHECK_FOR_INTERRUPTS(); switch (jsp->type) { /* all boolean item types: */ case jpiAnd: case jpiOr: case jpiNot: case jpiIsUnknown: case jpiEqual: case jpiNotEqual: case jpiLess: case jpiGreater: case jpiLessOrEqual: case jpiGreaterOrEqual: case jpiExists: case jpiStartsWith: case jpiLikeRegex: { JsonPathBool st = executeBoolItem(cxt, jsp, jb, true); res = appendBoolResult(cxt, jsp, found, st); break; } case jpiKey: if (JsonbType(jb) == jbvObject) { JsonbValue *v; JsonbValue key; key.type = jbvString; key.val.string.val = jspGetString(jsp, &key.val.string.len); v = findJsonbValueFromContainer(jb->val.binary.data, JB_FOBJECT, &key); if (v != NULL) { res = executeNextItem(cxt, jsp, NULL, v, found, false); /* free value if it was not added to found list */ if (jspHasNext(jsp) || !found) pfree(v); } else if (!jspIgnoreStructuralErrors(cxt)) { Assert(found); if (!jspThrowErrors(cxt)) return jperError; ereport(ERROR, (errcode(ERRCODE_SQL_JSON_MEMBER_NOT_FOUND), \ errmsg("JSON object does not contain key \"%s\"", pnstrdup(key.val.string.val, key.val.string.len)))); } } else if (unwrap && JsonbType(jb) == jbvArray) return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false); else if (!jspIgnoreStructuralErrors(cxt)) { Assert(found); RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_SQL_JSON_MEMBER_NOT_FOUND), errmsg("jsonpath member accessor can only be applied to an object")))); } break; case jpiRoot: jb = cxt->root; baseObject = setBaseObject(cxt, jb, 0); res = executeNextItem(cxt, jsp, NULL, jb, found, true); cxt->baseObject = baseObject; break; case jpiCurrent: res = executeNextItem(cxt, jsp, NULL, cxt->current, found, true); break; case jpiAnyArray: if (JsonbType(jb) == jbvArray) { bool hasNext = jspGetNext(jsp, &elem); res = executeItemUnwrapTargetArray(cxt, hasNext ? &elem : NULL, jb, found, jspAutoUnwrap(cxt)); } else if (jspAutoWrap(cxt)) res = executeNextItem(cxt, jsp, NULL, jb, found, true); else if (!jspIgnoreStructuralErrors(cxt)) RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_SQL_JSON_ARRAY_NOT_FOUND), errmsg("jsonpath wildcard array accessor can only be applied to an array")))); break; case jpiIndexArray: if (JsonbType(jb) == jbvArray || jspAutoWrap(cxt)) { int innermostArraySize = cxt->innermostArraySize; int i; int size = JsonbArraySize(jb); bool singleton = size < 0; bool hasNext = jspGetNext(jsp, &elem); if (singleton) size = 1; cxt->innermostArraySize = size; /* for LAST evaluation */ for (i = 0; i < jsp->content.array.nelems; i++) { JsonPathItem from; JsonPathItem to; int32 index; int32 index_from; int32 index_to; bool range = jspGetArraySubscript(jsp, &from, &to, i); res = getArrayIndex(cxt, &from, jb, &index_from); if (jperIsError(res)) break; if (range) { res = getArrayIndex(cxt, &to, jb, &index_to); if (jperIsError(res)) break; } else index_to = index_from; if (!jspIgnoreStructuralErrors(cxt) && (index_from < 0 || index_from > index_to || index_to >= size)) RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT), errmsg("jsonpath array subscript is out of bounds")))); if (index_from < 0) index_from = 0; if (index_to >= size) index_to = size - 1; res = jperNotFound; for (index = index_from; index <= index_to; index++) { JsonbValue *v; bool copy; if (singleton) { v = jb; copy = true; } else { v = getIthJsonbValueFromContainer(jb->val.binary.data, (uint32) index); if (v == NULL) continue; copy = false; } if (!hasNext && !found) return jperOk; res = executeNextItem(cxt, jsp, &elem, v, found, copy); if (jperIsError(res)) break; if (res == jperOk && !found) break; } if (jperIsError(res)) break; if (res == jperOk && !found) break; } cxt->innermostArraySize = innermostArraySize; } else if (!jspIgnoreStructuralErrors(cxt)) { RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_SQL_JSON_ARRAY_NOT_FOUND), errmsg("jsonpath array accessor can only be applied to an array")))); } break; case jpiLast: { JsonbValue tmpjbv; JsonbValue *lastjbv; int last; bool hasNext = jspGetNext(jsp, &elem); if (cxt->innermostArraySize < 0) elog(ERROR, "evaluating jsonpath LAST outside of array subscript"); if (!hasNext && !found) { res = jperOk; break; } last = cxt->innermostArraySize - 1; lastjbv = hasNext ? &tmpjbv : palloc(sizeof(*lastjbv)); lastjbv->type = jbvNumeric; lastjbv->val.numeric = int64_to_numeric(last); res = executeNextItem(cxt, jsp, &elem, lastjbv, found, hasNext); } break; case jpiAnyKey: if (JsonbType(jb) == jbvObject) { bool hasNext = jspGetNext(jsp, &elem); if (jb->type != jbvBinary) elog(ERROR, "invalid jsonb object type: %d", jb->type); return executeAnyItem (cxt, hasNext ? &elem : NULL, jb->val.binary.data, found, 1, 1, 1, false, jspAutoUnwrap(cxt)); } else if (unwrap && JsonbType(jb) == jbvArray) return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false); else if (!jspIgnoreStructuralErrors(cxt)) { Assert(found); RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_SQL_JSON_OBJECT_NOT_FOUND), errmsg("jsonpath wildcard member accessor can only be applied to an object")))); } break; case jpiAdd: return executeBinaryArithmExpr(cxt, jsp, jb, numeric_add_opt_error, found); case jpiSub: return executeBinaryArithmExpr(cxt, jsp, jb, numeric_sub_opt_error, found); case jpiMul: return executeBinaryArithmExpr(cxt, jsp, jb, numeric_mul_opt_error, found); case jpiDiv: return executeBinaryArithmExpr(cxt, jsp, jb, numeric_div_opt_error, found); case jpiMod: return executeBinaryArithmExpr(cxt, jsp, jb, numeric_mod_opt_error, found); case jpiPlus: return executeUnaryArithmExpr(cxt, jsp, jb, NULL, found); case jpiMinus: return executeUnaryArithmExpr(cxt, jsp, jb, numeric_uminus, found); case jpiFilter: { JsonPathBool st; if (unwrap && JsonbType(jb) == jbvArray) return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false); jspGetArg(jsp, &elem); st = executeNestedBoolItem(cxt, &elem, jb); if (st != jpbTrue) res = jperNotFound; else res = executeNextItem(cxt, jsp, NULL, jb, found, true); break; } case jpiAny: { bool hasNext = jspGetNext(jsp, &elem); /* first try without any intermediate steps */ if (jsp->content.anybounds.first == 0) { bool savedIgnoreStructuralErrors; savedIgnoreStructuralErrors = cxt->ignoreStructuralErrors; cxt->ignoreStructuralErrors = true; res = executeNextItem(cxt, jsp, &elem, jb, found, true); cxt->ignoreStructuralErrors = savedIgnoreStructuralErrors; if (res == jperOk && !found) break; } if (jb->type == jbvBinary) res = executeAnyItem (cxt, hasNext ? &elem : NULL, jb->val.binary.data, found, 1, jsp->content.anybounds.first, jsp->content.anybounds.last, true, jspAutoUnwrap(cxt)); break; } case jpiNull: case jpiBool: case jpiNumeric: case jpiString: case jpiVariable: { JsonbValue vbuf; JsonbValue *v; bool hasNext = jspGetNext(jsp, &elem); if (!hasNext && !found) { res = jperOk; /* skip evaluation */ break; } v = hasNext ? &vbuf : palloc(sizeof(*v)); baseObject = cxt->baseObject; getJsonPathItem(cxt, jsp, v); res = executeNextItem(cxt, jsp, &elem, v, found, hasNext); cxt->baseObject = baseObject; } break; case jpiType: { JsonbValue *jbv = palloc(sizeof(*jbv)); jbv->type = jbvString; jbv->val.string.val = pstrdup(JsonbTypeName(jb)); jbv->val.string.len = strlen(jbv->val.string.val); res = executeNextItem(cxt, jsp, NULL, jbv, found, false); } break; case jpiSize: { int size = JsonbArraySize(jb); if (size < 0) { if (!jspAutoWrap(cxt)) { if (!jspIgnoreStructuralErrors(cxt)) RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_SQL_JSON_ARRAY_NOT_FOUND), errmsg("jsonpath item method .%s() can only be applied to an array", jspOperationName(jsp->type))))); break; } size = 1; } jb = palloc(sizeof(*jb)); jb->type = jbvNumeric; jb->val.numeric = int64_to_numeric(size); res = executeNextItem(cxt, jsp, NULL, jb, found, false); } break; case jpiAbs: return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_abs, found); case jpiFloor: return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_floor, found); case jpiCeiling: return executeNumericItemMethod(cxt, jsp, jb, unwrap, numeric_ceil, found); case jpiDouble: { JsonbValue jbv; if (unwrap && JsonbType(jb) == jbvArray) return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false); if (jb->type == jbvNumeric) { char *tmp = DatumGetCString(DirectFunctionCall1(numeric_out, NumericGetDatum(jb->val.numeric))); double val; bool have_error = false; val = float8in_internal_opt_error(tmp, NULL, "double precision", tmp, &have_error); if (have_error || isinf(val) || isnan(val)) RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM), errmsg("numeric argument of jsonpath item method .%s() is out of range for type double precision", jspOperationName(jsp->type))))); res = jperOk; } else if (jb->type == jbvString) { /* cast string as double */ double val; char *tmp = pnstrdup(jb->val.string.val, jb->val.string.len); bool have_error = false; val = float8in_internal_opt_error(tmp, NULL, "double precision", tmp, &have_error); if (have_error || isinf(val) || isnan(val)) RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM), errmsg("string argument of jsonpath item method .%s() is not a valid representation of a double precision number", jspOperationName(jsp->type))))); jb = &jbv; jb->type = jbvNumeric; jb->val.numeric = DatumGetNumeric(DirectFunctionCall1(float8_numeric, Float8GetDatum(val))); res = jperOk; } if (res == jperNotFound) RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM), errmsg("jsonpath item method .%s() can only be applied to a string or numeric value", jspOperationName(jsp->type))))); res = executeNextItem(cxt, jsp, NULL, jb, found, true); } break; case jpiDatetime: if (unwrap && JsonbType(jb) == jbvArray) return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false); return executeDateTimeMethod(cxt, jsp, jb, found); case jpiKeyValue: if (unwrap && JsonbType(jb) == jbvArray) return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false); return executeKeyValueMethod(cxt, jsp, jb, found); default: elog(ERROR, "unrecognized jsonpath item type: %d", jsp->type); } return res; } /* * Unwrap current array item and execute jsonpath for each of its elements. */ static JsonPathExecResult executeItemUnwrapTargetArray(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found, bool unwrapElements) { if (jb->type != jbvBinary) { Assert(jb->type != jbvArray); elog(ERROR, "invalid jsonb array value type: %d", jb->type); } return executeAnyItem (cxt, jsp, jb->val.binary.data, found, 1, 1, 1, false, unwrapElements); } /* * Execute next jsonpath item if exists. Otherwise put "v" to the "found" * list if provided. */ static JsonPathExecResult executeNextItem(JsonPathExecContext *cxt, JsonPathItem *cur, JsonPathItem *next, JsonbValue *v, JsonValueList *found, bool copy) { JsonPathItem elem; bool hasNext; if (!cur) hasNext = next != NULL; else if (next) hasNext = jspHasNext(cur); else { next = &elem; hasNext = jspGetNext(cur, next); } if (hasNext) return executeItem(cxt, next, v, found); if (found) JsonValueListAppend(found, copy ? copyJsonbValue(v) : v); return jperOk; } /* * Same as executeItem(), but when "unwrap == true" automatically unwraps * each array item from the resulting sequence in lax mode. */ static JsonPathExecResult executeItemOptUnwrapResult(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, bool unwrap, JsonValueList *found) { if (unwrap && jspAutoUnwrap(cxt)) { JsonValueList seq = {0}; JsonValueListIterator it; JsonPathExecResult res = executeItem(cxt, jsp, jb, &seq); JsonbValue *item; if (jperIsError(res)) return res; JsonValueListInitIterator(&seq, &it); while ((item = JsonValueListNext(&seq, &it))) { Assert(item->type != jbvArray); if (JsonbType(item) == jbvArray) executeItemUnwrapTargetArray(cxt, NULL, item, found, false); else JsonValueListAppend(found, item); } return jperOk; } return executeItem(cxt, jsp, jb, found); } /* * Same as executeItemOptUnwrapResult(), but with error suppression. */ static JsonPathExecResult executeItemOptUnwrapResultNoThrow(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, bool unwrap, JsonValueList *found) { JsonPathExecResult res; bool throwErrors = cxt->throwErrors; cxt->throwErrors = false; res = executeItemOptUnwrapResult(cxt, jsp, jb, unwrap, found); cxt->throwErrors = throwErrors; return res; } /* Execute boolean-valued jsonpath expression. */ static JsonPathBool executeBoolItem(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, bool canHaveNext) { JsonPathItem larg; JsonPathItem rarg; JsonPathBool res; JsonPathBool res2; if (!canHaveNext && jspHasNext(jsp)) elog(ERROR, "boolean jsonpath item cannot have next item"); switch (jsp->type) { case jpiAnd: jspGetLeftArg(jsp, &larg); res = executeBoolItem(cxt, &larg, jb, false); if (res == jpbFalse) return jpbFalse; /* * SQL/JSON says that we should check second arg in case of * jperError */ jspGetRightArg(jsp, &rarg); res2 = executeBoolItem(cxt, &rarg, jb, false); return res2 == jpbTrue ? res : res2; case jpiOr: jspGetLeftArg(jsp, &larg); res = executeBoolItem(cxt, &larg, jb, false); if (res == jpbTrue) return jpbTrue; jspGetRightArg(jsp, &rarg); res2 = executeBoolItem(cxt, &rarg, jb, false); return res2 == jpbFalse ? res : res2; case jpiNot: jspGetArg(jsp, &larg); res = executeBoolItem(cxt, &larg, jb, false); if (res == jpbUnknown) return jpbUnknown; return res == jpbTrue ? jpbFalse : jpbTrue; case jpiIsUnknown: jspGetArg(jsp, &larg); res = executeBoolItem(cxt, &larg, jb, false); return res == jpbUnknown ? jpbTrue : jpbFalse; case jpiEqual: case jpiNotEqual: case jpiLess: case jpiGreater: case jpiLessOrEqual: case jpiGreaterOrEqual: jspGetLeftArg(jsp, &larg); jspGetRightArg(jsp, &rarg); return executePredicate(cxt, jsp, &larg, &rarg, jb, true, executeComparison, cxt); case jpiStartsWith: /* 'whole STARTS WITH initial' */ jspGetLeftArg(jsp, &larg); /* 'whole' */ jspGetRightArg(jsp, &rarg); /* 'initial' */ return executePredicate(cxt, jsp, &larg, &rarg, jb, false, executeStartsWith, NULL); case jpiLikeRegex: /* 'expr LIKE_REGEX pattern FLAGS flags' */ { /* * 'expr' is a sequence-returning expression. 'pattern' is a * regex string literal. SQL/JSON standard requires XQuery * regexes, but we use Postgres regexes here. 'flags' is a * string literal converted to integer flags at compile-time. */ JsonLikeRegexContext lrcxt = {0}; jspInitByBuffer(&larg, jsp->base, jsp->content.like_regex.expr); return executePredicate(cxt, jsp, &larg, NULL, jb, false, executeLikeRegex, &lrcxt); } case jpiExists: jspGetArg(jsp, &larg); if (jspStrictAbsenseOfErrors(cxt)) { /* * In strict mode we must get a complete list of values to * check that there are no errors at all. */ JsonValueList vals = {0}; JsonPathExecResult res = executeItemOptUnwrapResultNoThrow(cxt, &larg, jb, false, &vals); if (jperIsError(res)) return jpbUnknown; return JsonValueListIsEmpty(&vals) ? jpbFalse : jpbTrue; } else { JsonPathExecResult res = executeItemOptUnwrapResultNoThrow(cxt, &larg, jb, false, NULL); if (jperIsError(res)) return jpbUnknown; return res == jperOk ? jpbTrue : jpbFalse; } default: elog(ERROR, "invalid boolean jsonpath item type: %d", jsp->type); return jpbUnknown; } } /* * Execute nested (filters etc.) boolean expression pushing current SQL/JSON * item onto the stack. */ static JsonPathBool executeNestedBoolItem(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb) { JsonbValue *prev; JsonPathBool res; prev = cxt->current; cxt->current = jb; res = executeBoolItem(cxt, jsp, jb, false); cxt->current = prev; return res; } /* * Implementation of several jsonpath nodes: * - jpiAny (.** accessor), * - jpiAnyKey (.* accessor), * - jpiAnyArray ([*] accessor) */ static JsonPathExecResult executeAnyItem(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbContainer *jbc, JsonValueList *found, uint32 level, uint32 first, uint32 last, bool ignoreStructuralErrors, bool unwrapNext) { JsonPathExecResult res = jperNotFound; JsonbIterator *it; int32 r; JsonbValue v; check_stack_depth(); if (level > last) return res; it = JsonbIteratorInit(jbc); /* * Recursively iterate over jsonb objects/arrays */ while ((r = JsonbIteratorNext(&it, &v, true)) != WJB_DONE) { if (r == WJB_KEY) { r = JsonbIteratorNext(&it, &v, true); Assert(r == WJB_VALUE); } if (r == WJB_VALUE || r == WJB_ELEM) { if (level >= first || (first == PG_UINT32_MAX && last == PG_UINT32_MAX && v.type != jbvBinary)) /* leaves only requested */ { /* check expression */ if (jsp) { if (ignoreStructuralErrors) { bool savedIgnoreStructuralErrors; savedIgnoreStructuralErrors = cxt->ignoreStructuralErrors; cxt->ignoreStructuralErrors = true; res = executeItemOptUnwrapTarget(cxt, jsp, &v, found, unwrapNext); cxt->ignoreStructuralErrors = savedIgnoreStructuralErrors; } else res = executeItemOptUnwrapTarget(cxt, jsp, &v, found, unwrapNext); if (jperIsError(res)) break; if (res == jperOk && !found) break; } else if (found) JsonValueListAppend(found, copyJsonbValue(&v)); else return jperOk; } if (level < last && v.type == jbvBinary) { res = executeAnyItem (cxt, jsp, v.val.binary.data, found, level + 1, first, last, ignoreStructuralErrors, unwrapNext); if (jperIsError(res)) break; if (res == jperOk && found == NULL) break; } } } return res; } /* * Execute unary or binary predicate. * * Predicates have existence semantics, because their operands are item * sequences. Pairs of items from the left and right operand's sequences are * checked. TRUE returned only if any pair satisfying the condition is found. * In strict mode, even if the desired pair has already been found, all pairs * still need to be examined to check the absence of errors. If any error * occurs, UNKNOWN (analogous to SQL NULL) is returned. */ static JsonPathBool executePredicate(JsonPathExecContext *cxt, JsonPathItem *pred, JsonPathItem *larg, JsonPathItem *rarg, JsonbValue *jb, bool unwrapRightArg, JsonPathPredicateCallback exec, void *param) { JsonPathExecResult res; JsonValueListIterator lseqit; JsonValueList lseq = {0}; JsonValueList rseq = {0}; JsonbValue *lval; bool error = false; bool found = false; /* Left argument is always auto-unwrapped. */ res = executeItemOptUnwrapResultNoThrow(cxt, larg, jb, true, &lseq); if (jperIsError(res)) return jpbUnknown; if (rarg) { /* Right argument is conditionally auto-unwrapped. */ res = executeItemOptUnwrapResultNoThrow(cxt, rarg, jb, unwrapRightArg, &rseq); if (jperIsError(res)) return jpbUnknown; } JsonValueListInitIterator(&lseq, &lseqit); while ((lval = JsonValueListNext(&lseq, &lseqit))) { JsonValueListIterator rseqit; JsonbValue *rval; bool first = true; JsonValueListInitIterator(&rseq, &rseqit); if (rarg) rval = JsonValueListNext(&rseq, &rseqit); else rval = NULL; /* Loop over right arg sequence or do single pass otherwise */ while (rarg ? (rval != NULL) : first) { JsonPathBool res = exec(pred, lval, rval, param); if (res == jpbUnknown) { if (jspStrictAbsenseOfErrors(cxt)) return jpbUnknown; error = true; } else if (res == jpbTrue) { if (!jspStrictAbsenseOfErrors(cxt)) return jpbTrue; found = true; } first = false; if (rarg) rval = JsonValueListNext(&rseq, &rseqit); } } if (found) /* possible only in strict mode */ return jpbTrue; if (error) /* possible only in lax mode */ return jpbUnknown; return jpbFalse; } /* * Execute binary arithmetic expression on singleton numeric operands. * Array operands are automatically unwrapped in lax mode. */ static JsonPathExecResult executeBinaryArithmExpr(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, BinaryArithmFunc func, JsonValueList *found) { JsonPathExecResult jper; JsonPathItem elem; JsonValueList lseq = {0}; JsonValueList rseq = {0}; JsonbValue *lval; JsonbValue *rval; Numeric res; jspGetLeftArg(jsp, &elem); /* * XXX: By standard only operands of multiplicative expressions are * unwrapped. We extend it to other binary arithmetic expressions too. */ jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &lseq); if (jperIsError(jper)) return jper; jspGetRightArg(jsp, &elem); jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &rseq); if (jperIsError(jper)) return jper; if (JsonValueListLength(&lseq) != 1 || !(lval = getScalar(JsonValueListHead(&lseq), jbvNumeric))) RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_SINGLETON_SQL_JSON_ITEM_REQUIRED), errmsg("left operand of jsonpath operator %s is not a single numeric value", jspOperationName(jsp->type))))); if (JsonValueListLength(&rseq) != 1 || !(rval = getScalar(JsonValueListHead(&rseq), jbvNumeric))) RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_SINGLETON_SQL_JSON_ITEM_REQUIRED), errmsg("right operand of jsonpath operator %s is not a single numeric value", jspOperationName(jsp->type))))); if (jspThrowErrors(cxt)) { res = func(lval->val.numeric, rval->val.numeric, NULL); } else { bool error = false; res = func(lval->val.numeric, rval->val.numeric, &error); if (error) return jperError; } if (!jspGetNext(jsp, &elem) && !found) return jperOk; lval = palloc(sizeof(*lval)); lval->type = jbvNumeric; lval->val.numeric = res; return executeNextItem(cxt, jsp, &elem, lval, found, false); } /* * Execute unary arithmetic expression for each numeric item in its operand's * sequence. Array operand is automatically unwrapped in lax mode. */ static JsonPathExecResult executeUnaryArithmExpr(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, PGFunction func, JsonValueList *found) { JsonPathExecResult jper; JsonPathExecResult jper2; JsonPathItem elem; JsonValueList seq = {0}; JsonValueListIterator it; JsonbValue *val; bool hasNext; jspGetArg(jsp, &elem); jper = executeItemOptUnwrapResult(cxt, &elem, jb, true, &seq); if (jperIsError(jper)) return jper; jper = jperNotFound; hasNext = jspGetNext(jsp, &elem); JsonValueListInitIterator(&seq, &it); while ((val = JsonValueListNext(&seq, &it))) { if ((val = getScalar(val, jbvNumeric))) { if (!found && !hasNext) return jperOk; } else { if (!found && !hasNext) continue; /* skip non-numerics processing */ RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_SQL_JSON_NUMBER_NOT_FOUND), errmsg("operand of unary jsonpath operator %s is not a numeric value", jspOperationName(jsp->type))))); } if (func) val->val.numeric = DatumGetNumeric(DirectFunctionCall1(func, NumericGetDatum(val->val.numeric))); jper2 = executeNextItem(cxt, jsp, &elem, val, found, false); if (jperIsError(jper2)) return jper2; if (jper2 == jperOk) { if (!found) return jperOk; jper = jperOk; } } return jper; } /* * STARTS_WITH predicate callback. * * Check if the 'whole' string starts from 'initial' string. */ static JsonPathBool executeStartsWith(JsonPathItem *jsp, JsonbValue *whole, JsonbValue *initial, void *param) { if (!(whole = getScalar(whole, jbvString))) return jpbUnknown; /* error */ if (!(initial = getScalar(initial, jbvString))) return jpbUnknown; /* error */ if (whole->val.string.len >= initial->val.string.len && !memcmp(whole->val.string.val, initial->val.string.val, initial->val.string.len)) return jpbTrue; return jpbFalse; } /* * LIKE_REGEX predicate callback. * * Check if the string matches regex pattern. */ static JsonPathBool executeLikeRegex(JsonPathItem *jsp, JsonbValue *str, JsonbValue *rarg, void *param) { JsonLikeRegexContext *cxt = param; if (!(str = getScalar(str, jbvString))) return jpbUnknown; /* Cache regex text and converted flags. */ if (!cxt->regex) { cxt->regex = cstring_to_text_with_len(jsp->content.like_regex.pattern, jsp->content.like_regex.patternlen); cxt->cflags = jspConvertRegexFlags(jsp->content.like_regex.flags); } if (RE_compile_and_execute(cxt->regex, str->val.string.val, str->val.string.len, cxt->cflags, DEFAULT_COLLATION_OID, 0, NULL)) return jpbTrue; return jpbFalse; } /* * Execute numeric item methods (.abs(), .floor(), .ceil()) using the specified * user function 'func'. */ static JsonPathExecResult executeNumericItemMethod(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, bool unwrap, PGFunction func, JsonValueList *found) { JsonPathItem next; Datum datum; if (unwrap && JsonbType(jb) == jbvArray) return executeItemUnwrapTargetArray(cxt, jsp, jb, found, false); if (!(jb = getScalar(jb, jbvNumeric))) RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_NON_NUMERIC_SQL_JSON_ITEM), errmsg("jsonpath item method .%s() can only be applied to a numeric value", jspOperationName(jsp->type))))); datum = DirectFunctionCall1(func, NumericGetDatum(jb->val.numeric)); if (!jspGetNext(jsp, &next) && !found) return jperOk; jb = palloc(sizeof(*jb)); jb->type = jbvNumeric; jb->val.numeric = DatumGetNumeric(datum); return executeNextItem(cxt, jsp, &next, jb, found, false); } /* * Implementation of the .datetime() method. * * Converts a string into a date/time value. The actual type is determined at run time. * If an argument is provided, this argument is used as a template string. * Otherwise, the first fitting ISO format is selected. */ static JsonPathExecResult executeDateTimeMethod(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found) { JsonbValue jbvbuf; Datum value; text *datetime; Oid collid; Oid typid; int32 typmod = -1; int tz = 0; bool hasNext; JsonPathExecResult res = jperNotFound; JsonPathItem elem; if (!(jb = getScalar(jb, jbvString))) RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION), errmsg("jsonpath item method .%s() can only be applied to a string", jspOperationName(jsp->type))))); datetime = cstring_to_text_with_len(jb->val.string.val, jb->val.string.len); /* * At some point we might wish to have callers supply the collation to * use, but right now it's unclear that they'd be able to do better than * DEFAULT_COLLATION_OID anyway. */ collid = DEFAULT_COLLATION_OID; if (jsp->content.arg) { text *template; char *template_str; int template_len; bool have_error = false; jspGetArg(jsp, &elem); if (elem.type != jpiString) elog(ERROR, "invalid jsonpath item type for .datetime() argument"); template_str = jspGetString(&elem, &template_len); template = cstring_to_text_with_len(template_str, template_len); value = parse_datetime(datetime, template, collid, true, &typid, &typmod, &tz, jspThrowErrors(cxt) ? NULL : &have_error); if (have_error) res = jperError; else res = jperOk; } else { /* * According to SQL/JSON standard enumerate ISO formats for: date, * timetz, time, timestamptz, timestamp. * * We also support ISO 8601 for timestamps, because to_json[b]() * functions use this format. */ static const char *fmt_str[] = { "yyyy-mm-dd", "HH24:MI:SSTZH:TZM", "HH24:MI:SSTZH", "HH24:MI:SS", "yyyy-mm-dd HH24:MI:SSTZH:TZM", "yyyy-mm-dd HH24:MI:SSTZH", "yyyy-mm-dd HH24:MI:SS", "yyyy-mm-dd\"T\"HH24:MI:SSTZH:TZM", "yyyy-mm-dd\"T\"HH24:MI:SSTZH", "yyyy-mm-dd\"T\"HH24:MI:SS" }; /* cache for format texts */ static text *fmt_txt[lengthof(fmt_str)] = {0}; int i; /* loop until datetime format fits */ for (i = 0; i < lengthof(fmt_str); i++) { bool have_error = false; if (!fmt_txt[i]) { MemoryContext oldcxt = MemoryContextSwitchTo(TopMemoryContext); fmt_txt[i] = cstring_to_text(fmt_str[i]); MemoryContextSwitchTo(oldcxt); } value = parse_datetime(datetime, fmt_txt[i], collid, true, &typid, &typmod, &tz, &have_error); if (!have_error) { res = jperOk; break; } } if (res == jperNotFound) RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_INVALID_ARGUMENT_FOR_SQL_JSON_DATETIME_FUNCTION), errmsg("datetime format is not recognized: \"%s\"", text_to_cstring(datetime)), errhint("Use a datetime template argument to specify the input data format.")))); } pfree(datetime); if (jperIsError(res)) return res; hasNext = jspGetNext(jsp, &elem); if (!hasNext && !found) return res; jb = hasNext ? &jbvbuf : palloc(sizeof(*jb)); jb->type = jbvDatetime; jb->val.datetime.value = value; jb->val.datetime.typid = typid; jb->val.datetime.typmod = typmod; jb->val.datetime.tz = tz; return executeNextItem(cxt, jsp, &elem, jb, found, hasNext); } /* * Implementation of .keyvalue() method. * * .keyvalue() method returns a sequence of object's key-value pairs in the * following format: '{ "key": key, "value": value, "id": id }'. * * "id" field is an object identifier which is constructed from the two parts: * base object id and its binary offset in base object's jsonb: * id = 10000000000 * base_object_id + obj_offset_in_base_object * * 10000000000 (10^10) -- is a first round decimal number greater than 2^32 * (maximal offset in jsonb). Decimal multiplier is used here to improve the * readability of identifiers. * * Base object is usually a root object of the path: context item '$' or path * variable '$var', literals can't produce objects for now. But if the path * contains generated objects (.keyvalue() itself, for example), then they * become base object for the subsequent .keyvalue(). * * Id of '$' is 0. Id of '$var' is its ordinal (positive) number in the list * of variables (see getJsonPathVariable()). Ids for generated objects * are assigned using global counter JsonPathExecContext.lastGeneratedObjectId. */ static JsonPathExecResult executeKeyValueMethod(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, JsonValueList *found) { JsonPathExecResult res = jperNotFound; JsonPathItem next; JsonbContainer *jbc; JsonbValue key; JsonbValue val; JsonbValue idval; JsonbValue keystr; JsonbValue valstr; JsonbValue idstr; JsonbIterator *it; JsonbIteratorToken tok; int64 id; bool hasNext; if (JsonbType(jb) != jbvObject || jb->type != jbvBinary) RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_SQL_JSON_OBJECT_NOT_FOUND), errmsg("jsonpath item method .%s() can only be applied to an object", jspOperationName(jsp->type))))); jbc = jb->val.binary.data; if (!JsonContainerSize(jbc)) return jperNotFound; /* no key-value pairs */ hasNext = jspGetNext(jsp, &next); keystr.type = jbvString; keystr.val.string.val = "key"; keystr.val.string.len = 3; valstr.type = jbvString; valstr.val.string.val = "value"; valstr.val.string.len = 5; idstr.type = jbvString; idstr.val.string.val = "id"; idstr.val.string.len = 2; /* construct object id from its base object and offset inside that */ id = jb->type != jbvBinary ? 0 : (int64) ((char *) jbc - (char *) cxt->baseObject.jbc); id += (int64) cxt->baseObject.id * INT64CONST(10000000000); idval.type = jbvNumeric; idval.val.numeric = int64_to_numeric(id); it = JsonbIteratorInit(jbc); while ((tok = JsonbIteratorNext(&it, &key, true)) != WJB_DONE) { JsonBaseObjectInfo baseObject; JsonbValue obj; JsonbParseState *ps; JsonbValue *keyval; Jsonb *jsonb; if (tok != WJB_KEY) continue; res = jperOk; if (!hasNext && !found) break; tok = JsonbIteratorNext(&it, &val, true); Assert(tok == WJB_VALUE); ps = NULL; pushJsonbValue(&ps, WJB_BEGIN_OBJECT, NULL); pushJsonbValue(&ps, WJB_KEY, &keystr); pushJsonbValue(&ps, WJB_VALUE, &key); pushJsonbValue(&ps, WJB_KEY, &valstr); pushJsonbValue(&ps, WJB_VALUE, &val); pushJsonbValue(&ps, WJB_KEY, &idstr); pushJsonbValue(&ps, WJB_VALUE, &idval); keyval = pushJsonbValue(&ps, WJB_END_OBJECT, NULL); jsonb = JsonbValueToJsonb(keyval); JsonbInitBinary(&obj, jsonb); baseObject = setBaseObject(cxt, &obj, cxt->lastGeneratedObjectId++); res = executeNextItem(cxt, jsp, &next, &obj, found, true); cxt->baseObject = baseObject; if (jperIsError(res)) return res; if (res == jperOk && !found) break; } return res; } /* * Convert boolean execution status 'res' to a boolean JSON item and execute * next jsonpath. */ static JsonPathExecResult appendBoolResult(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonValueList *found, JsonPathBool res) { JsonPathItem next; JsonbValue jbv; if (!jspGetNext(jsp, &next) && !found) return jperOk; /* found singleton boolean value */ if (res == jpbUnknown) { jbv.type = jbvNull; } else { jbv.type = jbvBool; jbv.val.boolean = res == jpbTrue; } return executeNextItem(cxt, jsp, &next, &jbv, found, true); } /* * Convert jsonpath's scalar or variable node to actual jsonb value. * * If node is a variable then its id returned, otherwise 0 returned. */ static void getJsonPathItem(JsonPathExecContext *cxt, JsonPathItem *item, JsonbValue *value) { switch (item->type) { case jpiNull: value->type = jbvNull; break; case jpiBool: value->type = jbvBool; value->val.boolean = jspGetBool(item); break; case jpiNumeric: value->type = jbvNumeric; value->val.numeric = jspGetNumeric(item); break; case jpiString: value->type = jbvString; value->val.string.val = jspGetString(item, &value->val.string.len); break; case jpiVariable: getJsonPathVariable(cxt, item, cxt->vars, value); return; default: elog(ERROR, "unexpected jsonpath item type"); } } /* * Get the value of variable passed to jsonpath executor */ static void getJsonPathVariable(JsonPathExecContext *cxt, JsonPathItem *variable, Jsonb *vars, JsonbValue *value) { char *varName; int varNameLength; JsonbValue tmp; JsonbValue *v; if (!vars) { value->type = jbvNull; return; } Assert(variable->type == jpiVariable); varName = jspGetString(variable, &varNameLength); tmp.type = jbvString; tmp.val.string.val = varName; tmp.val.string.len = varNameLength; v = findJsonbValueFromContainer(&vars->root, JB_FOBJECT, &tmp); if (v) { *value = *v; pfree(v); } else { ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("could not find jsonpath variable \"%s\"", pnstrdup(varName, varNameLength)))); } JsonbInitBinary(&tmp, vars); setBaseObject(cxt, &tmp, 1); } /**************** Support functions for JsonPath execution *****************/ /* * Returns the size of an array item, or -1 if item is not an array. */ static int JsonbArraySize(JsonbValue *jb) { Assert(jb->type != jbvArray); if (jb->type == jbvBinary) { JsonbContainer *jbc = jb->val.binary.data; if (JsonContainerIsArray(jbc) && !JsonContainerIsScalar(jbc)) return JsonContainerSize(jbc); } return -1; } /* Comparison predicate callback. */ static JsonPathBool executeComparison(JsonPathItem *cmp, JsonbValue *lv, JsonbValue *rv, void *p) { JsonPathExecContext *cxt = (JsonPathExecContext *) p; return compareItems(cmp->type, lv, rv, cxt->useTz); } /* * Perform per-byte comparison of two strings. */ static int binaryCompareStrings(const char *s1, int len1, const char *s2, int len2) { int cmp; cmp = memcmp(s1, s2, Min(len1, len2)); if (cmp != 0) return cmp; if (len1 == len2) return 0; return len1 < len2 ? -1 : 1; } /* * Compare two strings in the current server encoding using Unicode codepoint * collation. */ static int compareStrings(const char *mbstr1, int mblen1, const char *mbstr2, int mblen2) { if (GetDatabaseEncoding() == PG_SQL_ASCII || GetDatabaseEncoding() == PG_UTF8) { /* * It's known property of UTF-8 strings that their per-byte comparison * result matches codepoints comparison result. ASCII can be * considered as special case of UTF-8. */ return binaryCompareStrings(mbstr1, mblen1, mbstr2, mblen2); } else { char *utf8str1, *utf8str2; int cmp, utf8len1, utf8len2; /* * We have to convert other encodings to UTF-8 first, then compare. * Input strings may be not null-terminated and pg_server_to_any() may * return them "as is". So, use strlen() only if there is real * conversion. */ utf8str1 = pg_server_to_any(mbstr1, mblen1, PG_UTF8); utf8str2 = pg_server_to_any(mbstr2, mblen2, PG_UTF8); utf8len1 = (mbstr1 == utf8str1) ? mblen1 : strlen(utf8str1); utf8len2 = (mbstr2 == utf8str2) ? mblen2 : strlen(utf8str2); cmp = binaryCompareStrings(utf8str1, utf8len1, utf8str2, utf8len2); /* * If pg_server_to_any() did no real conversion, then we actually * compared original strings. So, we already done. */ if (mbstr1 == utf8str1 && mbstr2 == utf8str2) return cmp; /* Free memory if needed */ if (mbstr1 != utf8str1) pfree(utf8str1); if (mbstr2 != utf8str2) pfree(utf8str2); /* * When all Unicode codepoints are equal, return result of binary * comparison. In some edge cases, same characters may have different * representations in encoding. Then our behavior could diverge from * standard. However, that allow us to do simple binary comparison * for "==" operator, which is performance critical in typical cases. * In future to implement strict standard conformance, we can do * normalization of input JSON strings. */ if (cmp == 0) return binaryCompareStrings(mbstr1, mblen1, mbstr2, mblen2); else return cmp; } } /* * Compare two SQL/JSON items using comparison operation 'op'. */ static JsonPathBool compareItems(int32 op, JsonbValue *jb1, JsonbValue *jb2, bool useTz) { int cmp; bool res; if (jb1->type != jb2->type) { if (jb1->type == jbvNull || jb2->type == jbvNull) /* * Equality and order comparison of nulls to non-nulls returns * always false, but inequality comparison returns true. */ return op == jpiNotEqual ? jpbTrue : jpbFalse; /* Non-null items of different types are not comparable. */ return jpbUnknown; } switch (jb1->type) { case jbvNull: cmp = 0; break; case jbvBool: cmp = jb1->val.boolean == jb2->val.boolean ? 0 : jb1->val.boolean ? 1 : -1; break; case jbvNumeric: cmp = compareNumeric(jb1->val.numeric, jb2->val.numeric); break; case jbvString: if (op == jpiEqual) return jb1->val.string.len != jb2->val.string.len || memcmp(jb1->val.string.val, jb2->val.string.val, jb1->val.string.len) ? jpbFalse : jpbTrue; cmp = compareStrings(jb1->val.string.val, jb1->val.string.len, jb2->val.string.val, jb2->val.string.len); break; case jbvDatetime: { bool cast_error; cmp = compareDatetime(jb1->val.datetime.value, jb1->val.datetime.typid, jb2->val.datetime.value, jb2->val.datetime.typid, useTz, &cast_error); if (cast_error) return jpbUnknown; } break; case jbvBinary: case jbvArray: case jbvObject: return jpbUnknown; /* non-scalars are not comparable */ default: elog(ERROR, "invalid jsonb value type %d", jb1->type); } switch (op) { case jpiEqual: res = (cmp == 0); break; case jpiNotEqual: res = (cmp != 0); break; case jpiLess: res = (cmp < 0); break; case jpiGreater: res = (cmp > 0); break; case jpiLessOrEqual: res = (cmp <= 0); break; case jpiGreaterOrEqual: res = (cmp >= 0); break; default: elog(ERROR, "unrecognized jsonpath operation: %d", op); return jpbUnknown; } return res ? jpbTrue : jpbFalse; } /* Compare two numerics */ static int compareNumeric(Numeric a, Numeric b) { return DatumGetInt32(DirectFunctionCall2(numeric_cmp, NumericGetDatum(a), NumericGetDatum(b))); } static JsonbValue * copyJsonbValue(JsonbValue *src) { JsonbValue *dst = palloc(sizeof(*dst)); *dst = *src; return dst; } /* * Execute array subscript expression and convert resulting numeric item to * the integer type with truncation. */ static JsonPathExecResult getArrayIndex(JsonPathExecContext *cxt, JsonPathItem *jsp, JsonbValue *jb, int32 *index) { JsonbValue *jbv; JsonValueList found = {0}; JsonPathExecResult res = executeItem(cxt, jsp, jb, &found); Datum numeric_index; bool have_error = false; if (jperIsError(res)) return res; if (JsonValueListLength(&found) != 1 || !(jbv = getScalar(JsonValueListHead(&found), jbvNumeric))) RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT), errmsg("jsonpath array subscript is not a single numeric value")))); numeric_index = DirectFunctionCall2(numeric_trunc, NumericGetDatum(jbv->val.numeric), Int32GetDatum(0)); *index = numeric_int4_opt_error(DatumGetNumeric(numeric_index), &have_error); if (have_error) RETURN_ERROR(ereport(ERROR, (errcode(ERRCODE_INVALID_SQL_JSON_SUBSCRIPT), errmsg("jsonpath array subscript is out of integer range")))); return jperOk; } /* Save base object and its id needed for the execution of .keyvalue(). */ static JsonBaseObjectInfo setBaseObject(JsonPathExecContext *cxt, JsonbValue *jbv, int32 id) { JsonBaseObjectInfo baseObject = cxt->baseObject; cxt->baseObject.jbc = jbv->type != jbvBinary ? NULL : (JsonbContainer *) jbv->val.binary.data; cxt->baseObject.id = id; return baseObject; } static void JsonValueListAppend(JsonValueList *jvl, JsonbValue *jbv) { if (jvl->singleton) { jvl->list = list_make2(jvl->singleton, jbv); jvl->singleton = NULL; } else if (!jvl->list) jvl->singleton = jbv; else jvl->list = lappend(jvl->list, jbv); } static int JsonValueListLength(const JsonValueList *jvl) { return jvl->singleton ? 1 : list_length(jvl->list); } static bool JsonValueListIsEmpty(JsonValueList *jvl) { return !jvl->singleton && list_length(jvl->list) <= 0; } static JsonbValue * JsonValueListHead(JsonValueList *jvl) { return jvl->singleton ? jvl->singleton : linitial(jvl->list); } static List * JsonValueListGetList(JsonValueList *jvl) { if (jvl->singleton) return list_make1(jvl->singleton); return jvl->list; } static void JsonValueListInitIterator(const JsonValueList *jvl, JsonValueListIterator *it) { if (jvl->singleton) { it->value = jvl->singleton; it->list = NIL; it->next = NULL; } else if (jvl->list != NIL) { it->value = (JsonbValue *) linitial(jvl->list); it->list = jvl->list; it->next = list_second_cell(jvl->list); } else { it->value = NULL; it->list = NIL; it->next = NULL; } } /* * Get the next item from the sequence advancing iterator. */ static JsonbValue * JsonValueListNext(const JsonValueList *jvl, JsonValueListIterator *it) { JsonbValue *result = it->value; if (it->next) { it->value = lfirst(it->next); it->next = lnext(it->list, it->next); } else { it->value = NULL; } return result; } /* * Initialize a binary JsonbValue with the given jsonb container. */ static JsonbValue * JsonbInitBinary(JsonbValue *jbv, Jsonb *jb) { jbv->type = jbvBinary; jbv->val.binary.data = &jb->root; jbv->val.binary.len = VARSIZE_ANY_EXHDR(jb); return jbv; } /* * Returns jbv* type of JsonbValue. Note, it never returns jbvBinary as is. */ static int JsonbType(JsonbValue *jb) { int type = jb->type; if (jb->type == jbvBinary) { JsonbContainer *jbc = (void *) jb->val.binary.data; /* Scalars should be always extracted during jsonpath execution. */ Assert(!JsonContainerIsScalar(jbc)); if (JsonContainerIsObject(jbc)) type = jbvObject; else if (JsonContainerIsArray(jbc)) type = jbvArray; else elog(ERROR, "invalid jsonb container type: 0x%08x", jbc->header); } return type; } /* Get scalar of given type or NULL on type mismatch */ static JsonbValue * getScalar(JsonbValue *scalar, enum jbvType type) { /* Scalars should be always extracted during jsonpath execution. */ Assert(scalar->type != jbvBinary || !JsonContainerIsScalar(scalar->val.binary.data)); return scalar->type == type ? scalar : NULL; } /* Construct a JSON array from the item list */ static JsonbValue * wrapItemsInArray(const JsonValueList *items) { JsonbParseState *ps = NULL; JsonValueListIterator it; JsonbValue *jbv; pushJsonbValue(&ps, WJB_BEGIN_ARRAY, NULL); JsonValueListInitIterator(items, &it); while ((jbv = JsonValueListNext(items, &it))) pushJsonbValue(&ps, WJB_ELEM, jbv); return pushJsonbValue(&ps, WJB_END_ARRAY, NULL); } /* Check if the timezone required for casting from type1 to type2 is used */ static void checkTimezoneIsUsedForCast(bool useTz, const char *type1, const char *type2) { if (!useTz) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot convert value from %s to %s without time zone usage", type1, type2), errhint("Use *_tz() function for time zone support."))); } /* Convert time datum to timetz datum */ static Datum castTimeToTimeTz(Datum time, bool useTz) { checkTimezoneIsUsedForCast(useTz, "time", "timetz"); return DirectFunctionCall1(time_timetz, time); } /* * Compare date to timestamp. * Note that this doesn't involve any timezone considerations. */ static int cmpDateToTimestamp(DateADT date1, Timestamp ts2, bool useTz) { return date_cmp_timestamp_internal(date1, ts2); } /* * Compare date to timestamptz. */ static int cmpDateToTimestampTz(DateADT date1, TimestampTz tstz2, bool useTz) { checkTimezoneIsUsedForCast(useTz, "date", "timestamptz"); return date_cmp_timestamptz_internal(date1, tstz2); } /* * Compare timestamp to timestamptz. */ static int cmpTimestampToTimestampTz(Timestamp ts1, TimestampTz tstz2, bool useTz) { checkTimezoneIsUsedForCast(useTz, "timestamp", "timestamptz"); return timestamp_cmp_timestamptz_internal(ts1, tstz2); } /* * Cross-type comparison of two datetime SQL/JSON items. If items are * uncomparable *cast_error flag is set, otherwise *cast_error is unset. * If the cast requires timezone and it is not used, then explicit error is thrown. */ static int compareDatetime(Datum val1, Oid typid1, Datum val2, Oid typid2, bool useTz, bool *cast_error) { PGFunction cmpfunc; *cast_error = false; switch (typid1) { case DATEOID: switch (typid2) { case DATEOID: cmpfunc = date_cmp; break; case TIMESTAMPOID: return cmpDateToTimestamp(DatumGetDateADT(val1), DatumGetTimestamp(val2), useTz); case TIMESTAMPTZOID: return cmpDateToTimestampTz(DatumGetDateADT(val1), DatumGetTimestampTz(val2), useTz); case TIMEOID: case TIMETZOID: *cast_error = true; /* uncomparable types */ return 0; default: elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u", typid2); } break; case TIMEOID: switch (typid2) { case TIMEOID: cmpfunc = time_cmp; break; case TIMETZOID: val1 = castTimeToTimeTz(val1, useTz); cmpfunc = timetz_cmp; break; case DATEOID: case TIMESTAMPOID: case TIMESTAMPTZOID: *cast_error = true; /* uncomparable types */ return 0; default: elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u", typid2); } break; case TIMETZOID: switch (typid2) { case TIMEOID: val2 = castTimeToTimeTz(val2, useTz); cmpfunc = timetz_cmp; break; case TIMETZOID: cmpfunc = timetz_cmp; break; case DATEOID: case TIMESTAMPOID: case TIMESTAMPTZOID: *cast_error = true; /* uncomparable types */ return 0; default: elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u", typid2); } break; case TIMESTAMPOID: switch (typid2) { case DATEOID: return -cmpDateToTimestamp(DatumGetDateADT(val2), DatumGetTimestamp(val1), useTz); case TIMESTAMPOID: cmpfunc = timestamp_cmp; break; case TIMESTAMPTZOID: return cmpTimestampToTimestampTz(DatumGetTimestamp(val1), DatumGetTimestampTz(val2), useTz); case TIMEOID: case TIMETZOID: *cast_error = true; /* uncomparable types */ return 0; default: elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u", typid2); } break; case TIMESTAMPTZOID: switch (typid2) { case DATEOID: return -cmpDateToTimestampTz(DatumGetDateADT(val2), DatumGetTimestampTz(val1), useTz); case TIMESTAMPOID: return -cmpTimestampToTimestampTz(DatumGetTimestamp(val2), DatumGetTimestampTz(val1), useTz); case TIMESTAMPTZOID: cmpfunc = timestamp_cmp; break; case TIMEOID: case TIMETZOID: *cast_error = true; /* uncomparable types */ return 0; default: elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u", typid2); } break; default: elog(ERROR, "unrecognized SQL/JSON datetime type oid: %u", typid1); } if (*cast_error) return 0; /* cast error */ return DatumGetInt32(DirectFunctionCall2(cmpfunc, val1, val2)); }