From 6185c9737cf48c9540782d88f12bd2912d6ca1cc Mon Sep 17 00:00:00 2001 From: Amit Langote Date: Thu, 21 Mar 2024 17:06:27 +0900 Subject: Add SQL/JSON query functions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This introduces the following SQL/JSON functions for querying JSON data using jsonpath expressions: JSON_EXISTS(), which can be used to apply a jsonpath expression to a JSON value to check if it yields any values. JSON_QUERY(), which can be used to to apply a jsonpath expression to a JSON value to get a JSON object, an array, or a string. There are various options to control whether multi-value result uses array wrappers and whether the singleton scalar strings are quoted or not. JSON_VALUE(), which can be used to apply a jsonpath expression to a JSON value to return a single scalar value, producing an error if it multiple values are matched. Both JSON_VALUE() and JSON_QUERY() functions have options for handling EMPTY and ERROR conditions, which can be used to specify the behavior when no values are matched and when an error occurs during jsonpath evaluation, respectively. Author: Nikita Glukhov Author: Teodor Sigaev Author: Oleg Bartunov Author: Alexander Korotkov Author: Andrew Dunstan Author: Amit Langote Author: Peter Eisentraut Author: Jian He Reviewers have included (in no particular order): Andres Freund, Alexander Korotkov, Pavel Stehule, Andrew Alsup, Erik Rijkers, Zihong Yu, Himanshu Upadhyaya, Daniel Gustafsson, Justin Pryzby, Álvaro Herrera, Jian He, Anton A. Melnikov, Nikita Malakhov, Peter Eisentraut, Tomas Vondra Discussion: https://postgr.es/m/cd0bb935-0158-78a7-08b5-904886deac4b@postgrespro.ru Discussion: https://postgr.es/m/20220616233130.rparivafipt6doj3@alap3.anarazel.de Discussion: https://postgr.es/m/abd9b83b-aa66-f230-3d6d-734817f0995d%40postgresql.org Discussion: https://postgr.es/m/CA+HiwqHROpf9e644D8BRqYvaAPmgBZVup-xKMDPk-nd4EpgzHw@mail.gmail.com Discussion: https://postgr.es/m/CA+HiwqE4XTdfb1nW=Ojoy_tQSRhYt-q_kb6i5d4xcKyrLC1Nbg@mail.gmail.com --- src/backend/jit/llvm/llvmjit_expr.c | 108 +++++++++++++++++++++++++++++++++++ src/backend/jit/llvm/llvmjit_types.c | 3 + 2 files changed, 111 insertions(+) (limited to 'src/backend/jit/llvm') diff --git a/src/backend/jit/llvm/llvmjit_expr.c b/src/backend/jit/llvm/llvmjit_expr.c index 2a7d84f046b..9e0efd26687 100644 --- a/src/backend/jit/llvm/llvmjit_expr.c +++ b/src/backend/jit/llvm/llvmjit_expr.c @@ -1930,6 +1930,114 @@ llvm_compile_expr(ExprState *state) LLVMBuildBr(b, opblocks[opno + 1]); break; + case EEOP_JSONEXPR_PATH: + { + JsonExprState *jsestate = op->d.jsonexpr.jsestate; + LLVMValueRef v_ret; + + /* + * Call ExecEvalJsonExprPath(). It returns the address of + * the step to perform next. + */ + v_ret = build_EvalXFunc(b, mod, "ExecEvalJsonExprPath", + v_state, op, v_econtext); + + /* + * Build a switch to map the return value (v_ret above), + * which is a runtime value of the step address to perform + * next, to either jump_empty, jump_error, + * jump_eval_coercion, or jump_end. + */ + if (jsestate->jump_empty >= 0 || + jsestate->jump_error >= 0 || + jsestate->jump_eval_coercion >= 0) + { + LLVMValueRef v_jump_empty; + LLVMValueRef v_jump_error; + LLVMValueRef v_jump_coercion; + LLVMValueRef v_switch; + LLVMBasicBlockRef b_done, + b_empty, + b_error, + b_coercion; + + b_empty = + l_bb_before_v(opblocks[opno + 1], + "op.%d.jsonexpr_empty", opno); + b_error = + l_bb_before_v(opblocks[opno + 1], + "op.%d.jsonexpr_error", opno); + b_coercion = + l_bb_before_v(opblocks[opno + 1], + "op.%d.jsonexpr_coercion", opno); + b_done = + l_bb_before_v(opblocks[opno + 1], + "op.%d.jsonexpr_done", opno); + + v_switch = LLVMBuildSwitch(b, + v_ret, + b_done, + 3); + /* Returned jsestate->jump_empty? */ + if (jsestate->jump_empty >= 0) + { + v_jump_empty = l_int32_const(lc, jsestate->jump_empty); + LLVMAddCase(v_switch, v_jump_empty, b_empty); + } + /* ON EMPTY code */ + LLVMPositionBuilderAtEnd(b, b_empty); + if (jsestate->jump_empty >= 0) + LLVMBuildBr(b, opblocks[jsestate->jump_empty]); + else + LLVMBuildUnreachable(b); + + /* Returned jsestate->jump_error? */ + if (jsestate->jump_error >= 0) + { + v_jump_error = l_int32_const(lc, jsestate->jump_error); + LLVMAddCase(v_switch, v_jump_error, b_error); + } + /* ON ERROR code */ + LLVMPositionBuilderAtEnd(b, b_error); + if (jsestate->jump_error >= 0) + LLVMBuildBr(b, opblocks[jsestate->jump_error]); + else + LLVMBuildUnreachable(b); + + /* Returned jsestate->jump_eval_coercion? */ + if (jsestate->jump_eval_coercion >= 0) + { + v_jump_coercion = l_int32_const(lc, jsestate->jump_eval_coercion); + LLVMAddCase(v_switch, v_jump_coercion, b_coercion); + } + /* coercion_expr code */ + LLVMPositionBuilderAtEnd(b, b_coercion); + if (jsestate->jump_eval_coercion >= 0) + LLVMBuildBr(b, opblocks[jsestate->jump_eval_coercion]); + else + LLVMBuildUnreachable(b); + + LLVMPositionBuilderAtEnd(b, b_done); + } + + LLVMBuildBr(b, opblocks[jsestate->jump_end]); + break; + } + + case EEOP_JSONEXPR_COERCION: + build_EvalXFunc(b, mod, "ExecEvalJsonCoercion", + v_state, op, v_econtext); + + LLVMBuildBr(b, opblocks[opno + 1]); + break; + + case EEOP_JSONEXPR_COERCION_FINISH: + build_EvalXFunc(b, mod, "ExecEvalJsonCoercionFinish", + v_state, op); + + LLVMBuildBr(b, opblocks[opno + 1]); + break; + case EEOP_AGGREF: { LLVMValueRef v_aggno; diff --git a/src/backend/jit/llvm/llvmjit_types.c b/src/backend/jit/llvm/llvmjit_types.c index 7d7aeee1f2b..f93c383fd52 100644 --- a/src/backend/jit/llvm/llvmjit_types.c +++ b/src/backend/jit/llvm/llvmjit_types.c @@ -173,6 +173,9 @@ void *referenced_functions[] = ExecEvalXmlExpr, ExecEvalJsonConstructor, ExecEvalJsonIsPredicate, + ExecEvalJsonCoercion, + ExecEvalJsonCoercionFinish, + ExecEvalJsonExprPath, MakeExpandedObjectReadOnlyInternal, slot_getmissingattrs, slot_getsomeattrs_int, -- cgit v1.2.3