1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
|
/*-------------------------------------------------------------------------
*
* jsonpath.h
* Definitions for jsonpath datatype
*
* Copyright (c) 2019-2022, PostgreSQL Global Development Group
*
* IDENTIFICATION
* src/include/utils/jsonpath.h
*
*-------------------------------------------------------------------------
*/
#ifndef JSONPATH_H
#define JSONPATH_H
#include "fmgr.h"
#include "nodes/pg_list.h"
#include "utils/jsonb.h"
typedef struct
{
int32 vl_len_; /* varlena header (do not touch directly!) */
uint32 header; /* version and flags (see below) */
char data[FLEXIBLE_ARRAY_MEMBER];
} JsonPath;
#define JSONPATH_VERSION (0x01)
#define JSONPATH_LAX (0x80000000)
#define JSONPATH_HDRSZ (offsetof(JsonPath, data))
#define DatumGetJsonPathP(d) ((JsonPath *) DatumGetPointer(PG_DETOAST_DATUM(d)))
#define DatumGetJsonPathPCopy(d) ((JsonPath *) DatumGetPointer(PG_DETOAST_DATUM_COPY(d)))
#define PG_GETARG_JSONPATH_P(x) DatumGetJsonPathP(PG_GETARG_DATUM(x))
#define PG_GETARG_JSONPATH_P_COPY(x) DatumGetJsonPathPCopy(PG_GETARG_DATUM(x))
#define PG_RETURN_JSONPATH_P(p) PG_RETURN_POINTER(p)
#define jspIsScalar(type) ((type) >= jpiNull && (type) <= jpiBool)
/*
* All node's type of jsonpath expression
*/
typedef enum JsonPathItemType
{
jpiNull = jbvNull, /* NULL literal */
jpiString = jbvString, /* string literal */
jpiNumeric = jbvNumeric, /* numeric literal */
jpiBool = jbvBool, /* boolean literal: TRUE or FALSE */
jpiAnd, /* predicate && predicate */
jpiOr, /* predicate || predicate */
jpiNot, /* ! predicate */
jpiIsUnknown, /* (predicate) IS UNKNOWN */
jpiEqual, /* expr == expr */
jpiNotEqual, /* expr != expr */
jpiLess, /* expr < expr */
jpiGreater, /* expr > expr */
jpiLessOrEqual, /* expr <= expr */
jpiGreaterOrEqual, /* expr >= expr */
jpiAdd, /* expr + expr */
jpiSub, /* expr - expr */
jpiMul, /* expr * expr */
jpiDiv, /* expr / expr */
jpiMod, /* expr % expr */
jpiPlus, /* + expr */
jpiMinus, /* - expr */
jpiAnyArray, /* [*] */
jpiAnyKey, /* .* */
jpiIndexArray, /* [subscript, ...] */
jpiAny, /* .** */
jpiKey, /* .key */
jpiCurrent, /* @ */
jpiRoot, /* $ */
jpiVariable, /* $variable */
jpiFilter, /* ? (predicate) */
jpiExists, /* EXISTS (expr) predicate */
jpiType, /* .type() item method */
jpiSize, /* .size() item method */
jpiAbs, /* .abs() item method */
jpiFloor, /* .floor() item method */
jpiCeiling, /* .ceiling() item method */
jpiDouble, /* .double() item method */
jpiDatetime, /* .datetime() item method */
jpiKeyValue, /* .keyvalue() item method */
jpiSubscript, /* array subscript: 'expr' or 'expr TO expr' */
jpiLast, /* LAST array subscript */
jpiStartsWith, /* STARTS WITH predicate */
jpiLikeRegex, /* LIKE_REGEX predicate */
} JsonPathItemType;
/* XQuery regex mode flags for LIKE_REGEX predicate */
#define JSP_REGEX_ICASE 0x01 /* i flag, case insensitive */
#define JSP_REGEX_DOTALL 0x02 /* s flag, dot matches newline */
#define JSP_REGEX_MLINE 0x04 /* m flag, ^/$ match at newlines */
#define JSP_REGEX_WSPACE 0x08 /* x flag, ignore whitespace in pattern */
#define JSP_REGEX_QUOTE 0x10 /* q flag, no special characters */
/*
* Support functions to parse/construct binary value.
* Unlike many other representation of expression the first/main
* node is not an operation but left operand of expression. That
* allows to implement cheap follow-path descending in jsonb
* structure and then execute operator with right operand
*/
typedef struct JsonPathItem
{
JsonPathItemType type;
/* position form base to next node */
int32 nextPos;
/*
* pointer into JsonPath value to current node, all positions of current
* are relative to this base
*/
char *base;
union
{
/* classic operator with two operands: and, or etc */
struct
{
int32 left;
int32 right;
} args;
/* any unary operation */
int32 arg;
/* storage for jpiIndexArray: indexes of array */
struct
{
int32 nelems;
struct
{
int32 from;
int32 to;
} *elems;
} array;
/* jpiAny: levels */
struct
{
uint32 first;
uint32 last;
} anybounds;
struct
{
char *data; /* for bool, numeric and string/key */
int32 datalen; /* filled only for string/key */
} value;
struct
{
int32 expr;
char *pattern;
int32 patternlen;
uint32 flags;
} like_regex;
} content;
} JsonPathItem;
#define jspHasNext(jsp) ((jsp)->nextPos > 0)
extern void jspInit(JsonPathItem *v, JsonPath *js);
extern void jspInitByBuffer(JsonPathItem *v, char *base, int32 pos);
extern bool jspGetNext(JsonPathItem *v, JsonPathItem *a);
extern void jspGetArg(JsonPathItem *v, JsonPathItem *a);
extern void jspGetLeftArg(JsonPathItem *v, JsonPathItem *a);
extern void jspGetRightArg(JsonPathItem *v, JsonPathItem *a);
extern Numeric jspGetNumeric(JsonPathItem *v);
extern bool jspGetBool(JsonPathItem *v);
extern char *jspGetString(JsonPathItem *v, int32 *len);
extern bool jspGetArraySubscript(JsonPathItem *v, JsonPathItem *from,
JsonPathItem *to, int i);
extern const char *jspOperationName(JsonPathItemType type);
/*
* Parsing support data structures.
*/
typedef struct JsonPathParseItem JsonPathParseItem;
struct JsonPathParseItem
{
JsonPathItemType type;
JsonPathParseItem *next; /* next in path */
union
{
/* classic operator with two operands: and, or etc */
struct
{
JsonPathParseItem *left;
JsonPathParseItem *right;
} args;
/* any unary operation */
JsonPathParseItem *arg;
/* storage for jpiIndexArray: indexes of array */
struct
{
int nelems;
struct
{
JsonPathParseItem *from;
JsonPathParseItem *to;
} *elems;
} array;
/* jpiAny: levels */
struct
{
uint32 first;
uint32 last;
} anybounds;
struct
{
JsonPathParseItem *expr;
char *pattern; /* could not be not null-terminated */
uint32 patternlen;
uint32 flags;
} like_regex;
/* scalars */
Numeric numeric;
bool boolean;
struct
{
uint32 len;
char *val; /* could not be not null-terminated */
} string;
} value;
};
typedef struct JsonPathParseResult
{
JsonPathParseItem *expr;
bool lax;
} JsonPathParseResult;
extern JsonPathParseResult *parsejsonpath(const char *str, int len);
extern int jspConvertRegexFlags(uint32 xflags);
#endif
|
