1 | /* |
2 | ** 2015-08-12 |
3 | ** |
4 | ** The author disclaims copyright to this source code. In place of |
5 | ** a legal notice, here is a blessing: |
6 | ** |
7 | ** May you do good and not evil. |
8 | ** May you find forgiveness for yourself and forgive others. |
9 | ** May you share freely, never taking more than you give. |
10 | ** |
11 | ****************************************************************************** |
12 | ** |
13 | ** This SQLite JSON functions. |
14 | ** |
15 | ** This file began as an extension in ext/misc/json1.c in 2015. That |
16 | ** extension proved so useful that it has now been moved into the core. |
17 | ** |
18 | ** For the time being, all JSON is stored as pure text. (We might add |
19 | ** a JSONB type in the future which stores a binary encoding of JSON in |
20 | ** a BLOB, but there is no support for JSONB in the current implementation. |
21 | ** This implementation parses JSON text at 250 MB/s, so it is hard to see |
22 | ** how JSONB might improve on that.) |
23 | */ |
24 | #ifndef SQLITE_OMIT_JSON |
25 | #include "sqliteInt.h" |
26 | |
27 | /* |
28 | ** Growing our own isspace() routine this way is twice as fast as |
29 | ** the library isspace() function, resulting in a 7% overall performance |
30 | ** increase for the parser. (Ubuntu14.10 gcc 4.8.4 x64 with -Os). |
31 | */ |
32 | static const char jsonIsSpace[] = { |
33 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, |
34 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
35 | 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
36 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
37 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
38 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
39 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
40 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
41 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
42 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
43 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
44 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
45 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
46 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
47 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
48 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
49 | }; |
50 | #define fast_isspace(x) (jsonIsSpace[(unsigned char)x]) |
51 | |
52 | #if !defined(SQLITE_DEBUG) && !defined(SQLITE_COVERAGE_TEST) |
53 | # define VVA(X) |
54 | #else |
55 | # define VVA(X) X |
56 | #endif |
57 | |
58 | /* Objects */ |
59 | typedef struct JsonString JsonString; |
60 | typedef struct JsonNode JsonNode; |
61 | typedef struct JsonParse JsonParse; |
62 | |
63 | /* An instance of this object represents a JSON string |
64 | ** under construction. Really, this is a generic string accumulator |
65 | ** that can be and is used to create strings other than JSON. |
66 | */ |
67 | struct JsonString { |
68 | sqlite3_context *pCtx; /* Function context - put error messages here */ |
69 | char *zBuf; /* Append JSON content here */ |
70 | u64 nAlloc; /* Bytes of storage available in zBuf[] */ |
71 | u64 nUsed; /* Bytes of zBuf[] currently used */ |
72 | u8 bStatic; /* True if zBuf is static space */ |
73 | u8 bErr; /* True if an error has been encountered */ |
74 | char zSpace[100]; /* Initial static space */ |
75 | }; |
76 | |
77 | /* JSON type values |
78 | */ |
79 | #define JSON_NULL 0 |
80 | #define JSON_TRUE 1 |
81 | #define JSON_FALSE 2 |
82 | #define JSON_INT 3 |
83 | #define JSON_REAL 4 |
84 | #define JSON_STRING 5 |
85 | #define JSON_ARRAY 6 |
86 | #define JSON_OBJECT 7 |
87 | |
88 | /* The "subtype" set for JSON values */ |
89 | #define JSON_SUBTYPE 74 /* Ascii for "J" */ |
90 | |
91 | /* |
92 | ** Names of the various JSON types: |
93 | */ |
94 | static const char * const jsonType[] = { |
95 | "null" , "true" , "false" , "integer" , "real" , "text" , "array" , "object" |
96 | }; |
97 | |
98 | /* Bit values for the JsonNode.jnFlag field |
99 | */ |
100 | #define JNODE_RAW 0x01 /* Content is raw, not JSON encoded */ |
101 | #define JNODE_ESCAPE 0x02 /* Content is text with \ escapes */ |
102 | #define JNODE_REMOVE 0x04 /* Do not output */ |
103 | #define JNODE_REPLACE 0x08 /* Replace with JsonNode.u.iReplace */ |
104 | #define JNODE_PATCH 0x10 /* Patch with JsonNode.u.pPatch */ |
105 | #define JNODE_APPEND 0x20 /* More ARRAY/OBJECT entries at u.iAppend */ |
106 | #define JNODE_LABEL 0x40 /* Is a label of an object */ |
107 | |
108 | |
109 | /* A single node of parsed JSON |
110 | */ |
111 | struct JsonNode { |
112 | u8 eType; /* One of the JSON_ type values */ |
113 | u8 jnFlags; /* JNODE flags */ |
114 | u8 eU; /* Which union element to use */ |
115 | u32 n; /* Bytes of content, or number of sub-nodes */ |
116 | union { |
117 | const char *zJContent; /* 1: Content for INT, REAL, and STRING */ |
118 | u32 iAppend; /* 2: More terms for ARRAY and OBJECT */ |
119 | u32 iKey; /* 3: Key for ARRAY objects in json_tree() */ |
120 | u32 iReplace; /* 4: Replacement content for JNODE_REPLACE */ |
121 | JsonNode *pPatch; /* 5: Node chain of patch for JNODE_PATCH */ |
122 | } u; |
123 | }; |
124 | |
125 | /* A completely parsed JSON string |
126 | */ |
127 | struct JsonParse { |
128 | u32 nNode; /* Number of slots of aNode[] used */ |
129 | u32 nAlloc; /* Number of slots of aNode[] allocated */ |
130 | JsonNode *aNode; /* Array of nodes containing the parse */ |
131 | const char *zJson; /* Original JSON string */ |
132 | u32 *aUp; /* Index of parent of each node */ |
133 | u8 oom; /* Set to true if out of memory */ |
134 | u8 nErr; /* Number of errors seen */ |
135 | u16 iDepth; /* Nesting depth */ |
136 | int nJson; /* Length of the zJson string in bytes */ |
137 | u32 iHold; /* Replace cache line with the lowest iHold value */ |
138 | }; |
139 | |
140 | /* |
141 | ** Maximum nesting depth of JSON for this implementation. |
142 | ** |
143 | ** This limit is needed to avoid a stack overflow in the recursive |
144 | ** descent parser. A depth of 2000 is far deeper than any sane JSON |
145 | ** should go. |
146 | */ |
147 | #define JSON_MAX_DEPTH 2000 |
148 | |
149 | /************************************************************************** |
150 | ** Utility routines for dealing with JsonString objects |
151 | **************************************************************************/ |
152 | |
153 | /* Set the JsonString object to an empty string |
154 | */ |
155 | static void jsonZero(JsonString *p){ |
156 | p->zBuf = p->zSpace; |
157 | p->nAlloc = sizeof(p->zSpace); |
158 | p->nUsed = 0; |
159 | p->bStatic = 1; |
160 | } |
161 | |
162 | /* Initialize the JsonString object |
163 | */ |
164 | static void jsonInit(JsonString *p, sqlite3_context *pCtx){ |
165 | p->pCtx = pCtx; |
166 | p->bErr = 0; |
167 | jsonZero(p); |
168 | } |
169 | |
170 | |
171 | /* Free all allocated memory and reset the JsonString object back to its |
172 | ** initial state. |
173 | */ |
174 | static void jsonReset(JsonString *p){ |
175 | if( !p->bStatic ) sqlite3_free(p->zBuf); |
176 | jsonZero(p); |
177 | } |
178 | |
179 | |
180 | /* Report an out-of-memory (OOM) condition |
181 | */ |
182 | static void jsonOom(JsonString *p){ |
183 | p->bErr = 1; |
184 | sqlite3_result_error_nomem(p->pCtx); |
185 | jsonReset(p); |
186 | } |
187 | |
188 | /* Enlarge pJson->zBuf so that it can hold at least N more bytes. |
189 | ** Return zero on success. Return non-zero on an OOM error |
190 | */ |
191 | static int jsonGrow(JsonString *p, u32 N){ |
192 | u64 nTotal = N<p->nAlloc ? p->nAlloc*2 : p->nAlloc+N+10; |
193 | char *zNew; |
194 | if( p->bStatic ){ |
195 | if( p->bErr ) return 1; |
196 | zNew = sqlite3_malloc64(nTotal); |
197 | if( zNew==0 ){ |
198 | jsonOom(p); |
199 | return SQLITE_NOMEM; |
200 | } |
201 | memcpy(zNew, p->zBuf, (size_t)p->nUsed); |
202 | p->zBuf = zNew; |
203 | p->bStatic = 0; |
204 | }else{ |
205 | zNew = sqlite3_realloc64(p->zBuf, nTotal); |
206 | if( zNew==0 ){ |
207 | jsonOom(p); |
208 | return SQLITE_NOMEM; |
209 | } |
210 | p->zBuf = zNew; |
211 | } |
212 | p->nAlloc = nTotal; |
213 | return SQLITE_OK; |
214 | } |
215 | |
216 | /* Append N bytes from zIn onto the end of the JsonString string. |
217 | */ |
218 | static void jsonAppendRaw(JsonString *p, const char *zIn, u32 N){ |
219 | if( N==0 ) return; |
220 | if( (N+p->nUsed >= p->nAlloc) && jsonGrow(p,N)!=0 ) return; |
221 | memcpy(p->zBuf+p->nUsed, zIn, N); |
222 | p->nUsed += N; |
223 | } |
224 | |
225 | /* Append formatted text (not to exceed N bytes) to the JsonString. |
226 | */ |
227 | static void jsonPrintf(int N, JsonString *p, const char *zFormat, ...){ |
228 | va_list ap; |
229 | if( (p->nUsed + N >= p->nAlloc) && jsonGrow(p, N) ) return; |
230 | va_start(ap, zFormat); |
231 | sqlite3_vsnprintf(N, p->zBuf+p->nUsed, zFormat, ap); |
232 | va_end(ap); |
233 | p->nUsed += (int)strlen(p->zBuf+p->nUsed); |
234 | } |
235 | |
236 | /* Append a single character |
237 | */ |
238 | static void jsonAppendChar(JsonString *p, char c){ |
239 | if( p->nUsed>=p->nAlloc && jsonGrow(p,1)!=0 ) return; |
240 | p->zBuf[p->nUsed++] = c; |
241 | } |
242 | |
243 | /* Append a comma separator to the output buffer, if the previous |
244 | ** character is not '[' or '{'. |
245 | */ |
246 | static void jsonAppendSeparator(JsonString *p){ |
247 | char c; |
248 | if( p->nUsed==0 ) return; |
249 | c = p->zBuf[p->nUsed-1]; |
250 | if( c!='[' && c!='{' ) jsonAppendChar(p, ','); |
251 | } |
252 | |
253 | /* Append the N-byte string in zIn to the end of the JsonString string |
254 | ** under construction. Enclose the string in "..." and escape |
255 | ** any double-quotes or backslash characters contained within the |
256 | ** string. |
257 | */ |
258 | static void jsonAppendString(JsonString *p, const char *zIn, u32 N){ |
259 | u32 i; |
260 | if( zIn==0 || ((N+p->nUsed+2 >= p->nAlloc) && jsonGrow(p,N+2)!=0) ) return; |
261 | p->zBuf[p->nUsed++] = '"'; |
262 | for(i=0; i<N; i++){ |
263 | unsigned char c = ((unsigned const char*)zIn)[i]; |
264 | if( c=='"' || c=='\\' ){ |
265 | json_simple_escape: |
266 | if( (p->nUsed+N+3-i > p->nAlloc) && jsonGrow(p,N+3-i)!=0 ) return; |
267 | p->zBuf[p->nUsed++] = '\\'; |
268 | }else if( c<=0x1f ){ |
269 | static const char aSpecial[] = { |
270 | 0, 0, 0, 0, 0, 0, 0, 0, 'b', 't', 'n', 0, 'f', 'r', 0, 0, |
271 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
272 | }; |
273 | assert( sizeof(aSpecial)==32 ); |
274 | assert( aSpecial['\b']=='b' ); |
275 | assert( aSpecial['\f']=='f' ); |
276 | assert( aSpecial['\n']=='n' ); |
277 | assert( aSpecial['\r']=='r' ); |
278 | assert( aSpecial['\t']=='t' ); |
279 | if( aSpecial[c] ){ |
280 | c = aSpecial[c]; |
281 | goto json_simple_escape; |
282 | } |
283 | if( (p->nUsed+N+7+i > p->nAlloc) && jsonGrow(p,N+7-i)!=0 ) return; |
284 | p->zBuf[p->nUsed++] = '\\'; |
285 | p->zBuf[p->nUsed++] = 'u'; |
286 | p->zBuf[p->nUsed++] = '0'; |
287 | p->zBuf[p->nUsed++] = '0'; |
288 | p->zBuf[p->nUsed++] = '0' + (c>>4); |
289 | c = "0123456789abcdef" [c&0xf]; |
290 | } |
291 | p->zBuf[p->nUsed++] = c; |
292 | } |
293 | p->zBuf[p->nUsed++] = '"'; |
294 | assert( p->nUsed<p->nAlloc ); |
295 | } |
296 | |
297 | /* |
298 | ** Append a function parameter value to the JSON string under |
299 | ** construction. |
300 | */ |
301 | static void jsonAppendValue( |
302 | JsonString *p, /* Append to this JSON string */ |
303 | sqlite3_value *pValue /* Value to append */ |
304 | ){ |
305 | switch( sqlite3_value_type(pValue) ){ |
306 | case SQLITE_NULL: { |
307 | jsonAppendRaw(p, "null" , 4); |
308 | break; |
309 | } |
310 | case SQLITE_INTEGER: |
311 | case SQLITE_FLOAT: { |
312 | const char *z = (const char*)sqlite3_value_text(pValue); |
313 | u32 n = (u32)sqlite3_value_bytes(pValue); |
314 | jsonAppendRaw(p, z, n); |
315 | break; |
316 | } |
317 | case SQLITE_TEXT: { |
318 | const char *z = (const char*)sqlite3_value_text(pValue); |
319 | u32 n = (u32)sqlite3_value_bytes(pValue); |
320 | if( sqlite3_value_subtype(pValue)==JSON_SUBTYPE ){ |
321 | jsonAppendRaw(p, z, n); |
322 | }else{ |
323 | jsonAppendString(p, z, n); |
324 | } |
325 | break; |
326 | } |
327 | default: { |
328 | if( p->bErr==0 ){ |
329 | sqlite3_result_error(p->pCtx, "JSON cannot hold BLOB values" , -1); |
330 | p->bErr = 2; |
331 | jsonReset(p); |
332 | } |
333 | break; |
334 | } |
335 | } |
336 | } |
337 | |
338 | |
339 | /* Make the JSON in p the result of the SQL function. |
340 | */ |
341 | static void jsonResult(JsonString *p){ |
342 | if( p->bErr==0 ){ |
343 | sqlite3_result_text64(p->pCtx, p->zBuf, p->nUsed, |
344 | p->bStatic ? SQLITE_TRANSIENT : sqlite3_free, |
345 | SQLITE_UTF8); |
346 | jsonZero(p); |
347 | } |
348 | assert( p->bStatic ); |
349 | } |
350 | |
351 | /************************************************************************** |
352 | ** Utility routines for dealing with JsonNode and JsonParse objects |
353 | **************************************************************************/ |
354 | |
355 | /* |
356 | ** Return the number of consecutive JsonNode slots need to represent |
357 | ** the parsed JSON at pNode. The minimum answer is 1. For ARRAY and |
358 | ** OBJECT types, the number might be larger. |
359 | ** |
360 | ** Appended elements are not counted. The value returned is the number |
361 | ** by which the JsonNode counter should increment in order to go to the |
362 | ** next peer value. |
363 | */ |
364 | static u32 jsonNodeSize(JsonNode *pNode){ |
365 | return pNode->eType>=JSON_ARRAY ? pNode->n+1 : 1; |
366 | } |
367 | |
368 | /* |
369 | ** Reclaim all memory allocated by a JsonParse object. But do not |
370 | ** delete the JsonParse object itself. |
371 | */ |
372 | static void jsonParseReset(JsonParse *pParse){ |
373 | sqlite3_free(pParse->aNode); |
374 | pParse->aNode = 0; |
375 | pParse->nNode = 0; |
376 | pParse->nAlloc = 0; |
377 | sqlite3_free(pParse->aUp); |
378 | pParse->aUp = 0; |
379 | } |
380 | |
381 | /* |
382 | ** Free a JsonParse object that was obtained from sqlite3_malloc(). |
383 | */ |
384 | static void jsonParseFree(JsonParse *pParse){ |
385 | jsonParseReset(pParse); |
386 | sqlite3_free(pParse); |
387 | } |
388 | |
389 | /* |
390 | ** Convert the JsonNode pNode into a pure JSON string and |
391 | ** append to pOut. Subsubstructure is also included. Return |
392 | ** the number of JsonNode objects that are encoded. |
393 | */ |
394 | static void jsonRenderNode( |
395 | JsonNode *pNode, /* The node to render */ |
396 | JsonString *pOut, /* Write JSON here */ |
397 | sqlite3_value **aReplace /* Replacement values */ |
398 | ){ |
399 | assert( pNode!=0 ); |
400 | if( pNode->jnFlags & (JNODE_REPLACE|JNODE_PATCH) ){ |
401 | if( (pNode->jnFlags & JNODE_REPLACE)!=0 && ALWAYS(aReplace!=0) ){ |
402 | assert( pNode->eU==4 ); |
403 | jsonAppendValue(pOut, aReplace[pNode->u.iReplace]); |
404 | return; |
405 | } |
406 | assert( pNode->eU==5 ); |
407 | pNode = pNode->u.pPatch; |
408 | } |
409 | switch( pNode->eType ){ |
410 | default: { |
411 | assert( pNode->eType==JSON_NULL ); |
412 | jsonAppendRaw(pOut, "null" , 4); |
413 | break; |
414 | } |
415 | case JSON_TRUE: { |
416 | jsonAppendRaw(pOut, "true" , 4); |
417 | break; |
418 | } |
419 | case JSON_FALSE: { |
420 | jsonAppendRaw(pOut, "false" , 5); |
421 | break; |
422 | } |
423 | case JSON_STRING: { |
424 | if( pNode->jnFlags & JNODE_RAW ){ |
425 | assert( pNode->eU==1 ); |
426 | jsonAppendString(pOut, pNode->u.zJContent, pNode->n); |
427 | break; |
428 | } |
429 | /* no break */ deliberate_fall_through |
430 | } |
431 | case JSON_REAL: |
432 | case JSON_INT: { |
433 | assert( pNode->eU==1 ); |
434 | jsonAppendRaw(pOut, pNode->u.zJContent, pNode->n); |
435 | break; |
436 | } |
437 | case JSON_ARRAY: { |
438 | u32 j = 1; |
439 | jsonAppendChar(pOut, '['); |
440 | for(;;){ |
441 | while( j<=pNode->n ){ |
442 | if( (pNode[j].jnFlags & JNODE_REMOVE)==0 ){ |
443 | jsonAppendSeparator(pOut); |
444 | jsonRenderNode(&pNode[j], pOut, aReplace); |
445 | } |
446 | j += jsonNodeSize(&pNode[j]); |
447 | } |
448 | if( (pNode->jnFlags & JNODE_APPEND)==0 ) break; |
449 | assert( pNode->eU==2 ); |
450 | pNode = &pNode[pNode->u.iAppend]; |
451 | j = 1; |
452 | } |
453 | jsonAppendChar(pOut, ']'); |
454 | break; |
455 | } |
456 | case JSON_OBJECT: { |
457 | u32 j = 1; |
458 | jsonAppendChar(pOut, '{'); |
459 | for(;;){ |
460 | while( j<=pNode->n ){ |
461 | if( (pNode[j+1].jnFlags & JNODE_REMOVE)==0 ){ |
462 | jsonAppendSeparator(pOut); |
463 | jsonRenderNode(&pNode[j], pOut, aReplace); |
464 | jsonAppendChar(pOut, ':'); |
465 | jsonRenderNode(&pNode[j+1], pOut, aReplace); |
466 | } |
467 | j += 1 + jsonNodeSize(&pNode[j+1]); |
468 | } |
469 | if( (pNode->jnFlags & JNODE_APPEND)==0 ) break; |
470 | assert( pNode->eU==2 ); |
471 | pNode = &pNode[pNode->u.iAppend]; |
472 | j = 1; |
473 | } |
474 | jsonAppendChar(pOut, '}'); |
475 | break; |
476 | } |
477 | } |
478 | } |
479 | |
480 | /* |
481 | ** Return a JsonNode and all its descendents as a JSON string. |
482 | */ |
483 | static void jsonReturnJson( |
484 | JsonNode *pNode, /* Node to return */ |
485 | sqlite3_context *pCtx, /* Return value for this function */ |
486 | sqlite3_value **aReplace /* Array of replacement values */ |
487 | ){ |
488 | JsonString s; |
489 | jsonInit(&s, pCtx); |
490 | jsonRenderNode(pNode, &s, aReplace); |
491 | jsonResult(&s); |
492 | sqlite3_result_subtype(pCtx, JSON_SUBTYPE); |
493 | } |
494 | |
495 | /* |
496 | ** Translate a single byte of Hex into an integer. |
497 | ** This routine only works if h really is a valid hexadecimal |
498 | ** character: 0..9a..fA..F |
499 | */ |
500 | static u8 jsonHexToInt(int h){ |
501 | assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') ); |
502 | #ifdef SQLITE_EBCDIC |
503 | h += 9*(1&~(h>>4)); |
504 | #else |
505 | h += 9*(1&(h>>6)); |
506 | #endif |
507 | return (u8)(h & 0xf); |
508 | } |
509 | |
510 | /* |
511 | ** Convert a 4-byte hex string into an integer |
512 | */ |
513 | static u32 jsonHexToInt4(const char *z){ |
514 | u32 v; |
515 | assert( sqlite3Isxdigit(z[0]) ); |
516 | assert( sqlite3Isxdigit(z[1]) ); |
517 | assert( sqlite3Isxdigit(z[2]) ); |
518 | assert( sqlite3Isxdigit(z[3]) ); |
519 | v = (jsonHexToInt(z[0])<<12) |
520 | + (jsonHexToInt(z[1])<<8) |
521 | + (jsonHexToInt(z[2])<<4) |
522 | + jsonHexToInt(z[3]); |
523 | return v; |
524 | } |
525 | |
526 | /* |
527 | ** Make the JsonNode the return value of the function. |
528 | */ |
529 | static void jsonReturn( |
530 | JsonNode *pNode, /* Node to return */ |
531 | sqlite3_context *pCtx, /* Return value for this function */ |
532 | sqlite3_value **aReplace /* Array of replacement values */ |
533 | ){ |
534 | switch( pNode->eType ){ |
535 | default: { |
536 | assert( pNode->eType==JSON_NULL ); |
537 | sqlite3_result_null(pCtx); |
538 | break; |
539 | } |
540 | case JSON_TRUE: { |
541 | sqlite3_result_int(pCtx, 1); |
542 | break; |
543 | } |
544 | case JSON_FALSE: { |
545 | sqlite3_result_int(pCtx, 0); |
546 | break; |
547 | } |
548 | case JSON_INT: { |
549 | sqlite3_int64 i = 0; |
550 | const char *z; |
551 | assert( pNode->eU==1 ); |
552 | z = pNode->u.zJContent; |
553 | if( z[0]=='-' ){ z++; } |
554 | while( z[0]>='0' && z[0]<='9' ){ |
555 | unsigned v = *(z++) - '0'; |
556 | if( i>=LARGEST_INT64/10 ){ |
557 | if( i>LARGEST_INT64/10 ) goto int_as_real; |
558 | if( z[0]>='0' && z[0]<='9' ) goto int_as_real; |
559 | if( v==9 ) goto int_as_real; |
560 | if( v==8 ){ |
561 | if( pNode->u.zJContent[0]=='-' ){ |
562 | sqlite3_result_int64(pCtx, SMALLEST_INT64); |
563 | goto int_done; |
564 | }else{ |
565 | goto int_as_real; |
566 | } |
567 | } |
568 | } |
569 | i = i*10 + v; |
570 | } |
571 | if( pNode->u.zJContent[0]=='-' ){ i = -i; } |
572 | sqlite3_result_int64(pCtx, i); |
573 | int_done: |
574 | break; |
575 | int_as_real: ; /* no break */ deliberate_fall_through |
576 | } |
577 | case JSON_REAL: { |
578 | double r; |
579 | #ifdef SQLITE_AMALGAMATION |
580 | const char *z; |
581 | assert( pNode->eU==1 ); |
582 | z = pNode->u.zJContent; |
583 | sqlite3AtoF(z, &r, sqlite3Strlen30(z), SQLITE_UTF8); |
584 | #else |
585 | assert( pNode->eU==1 ); |
586 | r = strtod(pNode->u.zJContent, 0); |
587 | #endif |
588 | sqlite3_result_double(pCtx, r); |
589 | break; |
590 | } |
591 | case JSON_STRING: { |
592 | #if 0 /* Never happens because JNODE_RAW is only set by json_set(), |
593 | ** json_insert() and json_replace() and those routines do not |
594 | ** call jsonReturn() */ |
595 | if( pNode->jnFlags & JNODE_RAW ){ |
596 | assert( pNode->eU==1 ); |
597 | sqlite3_result_text(pCtx, pNode->u.zJContent, pNode->n, |
598 | SQLITE_TRANSIENT); |
599 | }else |
600 | #endif |
601 | assert( (pNode->jnFlags & JNODE_RAW)==0 ); |
602 | if( (pNode->jnFlags & JNODE_ESCAPE)==0 ){ |
603 | /* JSON formatted without any backslash-escapes */ |
604 | assert( pNode->eU==1 ); |
605 | sqlite3_result_text(pCtx, pNode->u.zJContent+1, pNode->n-2, |
606 | SQLITE_TRANSIENT); |
607 | }else{ |
608 | /* Translate JSON formatted string into raw text */ |
609 | u32 i; |
610 | u32 n = pNode->n; |
611 | const char *z; |
612 | char *zOut; |
613 | u32 j; |
614 | assert( pNode->eU==1 ); |
615 | z = pNode->u.zJContent; |
616 | zOut = sqlite3_malloc( n+1 ); |
617 | if( zOut==0 ){ |
618 | sqlite3_result_error_nomem(pCtx); |
619 | break; |
620 | } |
621 | for(i=1, j=0; i<n-1; i++){ |
622 | char c = z[i]; |
623 | if( c!='\\' ){ |
624 | zOut[j++] = c; |
625 | }else{ |
626 | c = z[++i]; |
627 | if( c=='u' ){ |
628 | u32 v = jsonHexToInt4(z+i+1); |
629 | i += 4; |
630 | if( v==0 ) break; |
631 | if( v<=0x7f ){ |
632 | zOut[j++] = (char)v; |
633 | }else if( v<=0x7ff ){ |
634 | zOut[j++] = (char)(0xc0 | (v>>6)); |
635 | zOut[j++] = 0x80 | (v&0x3f); |
636 | }else{ |
637 | u32 vlo; |
638 | if( (v&0xfc00)==0xd800 |
639 | && i<n-6 |
640 | && z[i+1]=='\\' |
641 | && z[i+2]=='u' |
642 | && ((vlo = jsonHexToInt4(z+i+3))&0xfc00)==0xdc00 |
643 | ){ |
644 | /* We have a surrogate pair */ |
645 | v = ((v&0x3ff)<<10) + (vlo&0x3ff) + 0x10000; |
646 | i += 6; |
647 | zOut[j++] = 0xf0 | (v>>18); |
648 | zOut[j++] = 0x80 | ((v>>12)&0x3f); |
649 | zOut[j++] = 0x80 | ((v>>6)&0x3f); |
650 | zOut[j++] = 0x80 | (v&0x3f); |
651 | }else{ |
652 | zOut[j++] = 0xe0 | (v>>12); |
653 | zOut[j++] = 0x80 | ((v>>6)&0x3f); |
654 | zOut[j++] = 0x80 | (v&0x3f); |
655 | } |
656 | } |
657 | }else{ |
658 | if( c=='b' ){ |
659 | c = '\b'; |
660 | }else if( c=='f' ){ |
661 | c = '\f'; |
662 | }else if( c=='n' ){ |
663 | c = '\n'; |
664 | }else if( c=='r' ){ |
665 | c = '\r'; |
666 | }else if( c=='t' ){ |
667 | c = '\t'; |
668 | } |
669 | zOut[j++] = c; |
670 | } |
671 | } |
672 | } |
673 | zOut[j] = 0; |
674 | sqlite3_result_text(pCtx, zOut, j, sqlite3_free); |
675 | } |
676 | break; |
677 | } |
678 | case JSON_ARRAY: |
679 | case JSON_OBJECT: { |
680 | jsonReturnJson(pNode, pCtx, aReplace); |
681 | break; |
682 | } |
683 | } |
684 | } |
685 | |
686 | /* Forward reference */ |
687 | static int jsonParseAddNode(JsonParse*,u32,u32,const char*); |
688 | |
689 | /* |
690 | ** A macro to hint to the compiler that a function should not be |
691 | ** inlined. |
692 | */ |
693 | #if defined(__GNUC__) |
694 | # define JSON_NOINLINE __attribute__((noinline)) |
695 | #elif defined(_MSC_VER) && _MSC_VER>=1310 |
696 | # define JSON_NOINLINE __declspec(noinline) |
697 | #else |
698 | # define JSON_NOINLINE |
699 | #endif |
700 | |
701 | |
702 | static JSON_NOINLINE int jsonParseAddNodeExpand( |
703 | JsonParse *pParse, /* Append the node to this object */ |
704 | u32 eType, /* Node type */ |
705 | u32 n, /* Content size or sub-node count */ |
706 | const char *zContent /* Content */ |
707 | ){ |
708 | u32 nNew; |
709 | JsonNode *pNew; |
710 | assert( pParse->nNode>=pParse->nAlloc ); |
711 | if( pParse->oom ) return -1; |
712 | nNew = pParse->nAlloc*2 + 10; |
713 | pNew = sqlite3_realloc64(pParse->aNode, sizeof(JsonNode)*nNew); |
714 | if( pNew==0 ){ |
715 | pParse->oom = 1; |
716 | return -1; |
717 | } |
718 | pParse->nAlloc = nNew; |
719 | pParse->aNode = pNew; |
720 | assert( pParse->nNode<pParse->nAlloc ); |
721 | return jsonParseAddNode(pParse, eType, n, zContent); |
722 | } |
723 | |
724 | /* |
725 | ** Create a new JsonNode instance based on the arguments and append that |
726 | ** instance to the JsonParse. Return the index in pParse->aNode[] of the |
727 | ** new node, or -1 if a memory allocation fails. |
728 | */ |
729 | static int jsonParseAddNode( |
730 | JsonParse *pParse, /* Append the node to this object */ |
731 | u32 eType, /* Node type */ |
732 | u32 n, /* Content size or sub-node count */ |
733 | const char *zContent /* Content */ |
734 | ){ |
735 | JsonNode *p; |
736 | if( pParse->aNode==0 || pParse->nNode>=pParse->nAlloc ){ |
737 | return jsonParseAddNodeExpand(pParse, eType, n, zContent); |
738 | } |
739 | p = &pParse->aNode[pParse->nNode]; |
740 | p->eType = (u8)eType; |
741 | p->jnFlags = 0; |
742 | VVA( p->eU = zContent ? 1 : 0 ); |
743 | p->n = n; |
744 | p->u.zJContent = zContent; |
745 | return pParse->nNode++; |
746 | } |
747 | |
748 | /* |
749 | ** Return true if z[] begins with 4 (or more) hexadecimal digits |
750 | */ |
751 | static int jsonIs4Hex(const char *z){ |
752 | int i; |
753 | for(i=0; i<4; i++) if( !sqlite3Isxdigit(z[i]) ) return 0; |
754 | return 1; |
755 | } |
756 | |
757 | /* |
758 | ** Parse a single JSON value which begins at pParse->zJson[i]. Return the |
759 | ** index of the first character past the end of the value parsed. |
760 | ** |
761 | ** Return negative for a syntax error. Special cases: return -2 if the |
762 | ** first non-whitespace character is '}' and return -3 if the first |
763 | ** non-whitespace character is ']'. |
764 | */ |
765 | static int jsonParseValue(JsonParse *pParse, u32 i){ |
766 | char c; |
767 | u32 j; |
768 | int iThis; |
769 | int x; |
770 | JsonNode *pNode; |
771 | const char *z = pParse->zJson; |
772 | while( fast_isspace(z[i]) ){ i++; } |
773 | if( (c = z[i])=='{' ){ |
774 | /* Parse object */ |
775 | iThis = jsonParseAddNode(pParse, JSON_OBJECT, 0, 0); |
776 | if( iThis<0 ) return -1; |
777 | for(j=i+1;;j++){ |
778 | while( fast_isspace(z[j]) ){ j++; } |
779 | if( ++pParse->iDepth > JSON_MAX_DEPTH ) return -1; |
780 | x = jsonParseValue(pParse, j); |
781 | if( x<0 ){ |
782 | pParse->iDepth--; |
783 | if( x==(-2) && pParse->nNode==(u32)iThis+1 ) return j+1; |
784 | return -1; |
785 | } |
786 | if( pParse->oom ) return -1; |
787 | pNode = &pParse->aNode[pParse->nNode-1]; |
788 | if( pNode->eType!=JSON_STRING ) return -1; |
789 | pNode->jnFlags |= JNODE_LABEL; |
790 | j = x; |
791 | while( fast_isspace(z[j]) ){ j++; } |
792 | if( z[j]!=':' ) return -1; |
793 | j++; |
794 | x = jsonParseValue(pParse, j); |
795 | pParse->iDepth--; |
796 | if( x<0 ) return -1; |
797 | j = x; |
798 | while( fast_isspace(z[j]) ){ j++; } |
799 | c = z[j]; |
800 | if( c==',' ) continue; |
801 | if( c!='}' ) return -1; |
802 | break; |
803 | } |
804 | pParse->aNode[iThis].n = pParse->nNode - (u32)iThis - 1; |
805 | return j+1; |
806 | }else if( c=='[' ){ |
807 | /* Parse array */ |
808 | iThis = jsonParseAddNode(pParse, JSON_ARRAY, 0, 0); |
809 | if( iThis<0 ) return -1; |
810 | memset(&pParse->aNode[iThis].u, 0, sizeof(pParse->aNode[iThis].u)); |
811 | for(j=i+1;;j++){ |
812 | while( fast_isspace(z[j]) ){ j++; } |
813 | if( ++pParse->iDepth > JSON_MAX_DEPTH ) return -1; |
814 | x = jsonParseValue(pParse, j); |
815 | pParse->iDepth--; |
816 | if( x<0 ){ |
817 | if( x==(-3) && pParse->nNode==(u32)iThis+1 ) return j+1; |
818 | return -1; |
819 | } |
820 | j = x; |
821 | while( fast_isspace(z[j]) ){ j++; } |
822 | c = z[j]; |
823 | if( c==',' ) continue; |
824 | if( c!=']' ) return -1; |
825 | break; |
826 | } |
827 | pParse->aNode[iThis].n = pParse->nNode - (u32)iThis - 1; |
828 | return j+1; |
829 | }else if( c=='"' ){ |
830 | /* Parse string */ |
831 | u8 jnFlags = 0; |
832 | j = i+1; |
833 | for(;;){ |
834 | c = z[j]; |
835 | if( (c & ~0x1f)==0 ){ |
836 | /* Control characters are not allowed in strings */ |
837 | return -1; |
838 | } |
839 | if( c=='\\' ){ |
840 | c = z[++j]; |
841 | if( c=='"' || c=='\\' || c=='/' || c=='b' || c=='f' |
842 | || c=='n' || c=='r' || c=='t' |
843 | || (c=='u' && jsonIs4Hex(z+j+1)) ){ |
844 | jnFlags = JNODE_ESCAPE; |
845 | }else{ |
846 | return -1; |
847 | } |
848 | }else if( c=='"' ){ |
849 | break; |
850 | } |
851 | j++; |
852 | } |
853 | jsonParseAddNode(pParse, JSON_STRING, j+1-i, &z[i]); |
854 | if( !pParse->oom ) pParse->aNode[pParse->nNode-1].jnFlags = jnFlags; |
855 | return j+1; |
856 | }else if( c=='n' |
857 | && strncmp(z+i,"null" ,4)==0 |
858 | && !sqlite3Isalnum(z[i+4]) ){ |
859 | jsonParseAddNode(pParse, JSON_NULL, 0, 0); |
860 | return i+4; |
861 | }else if( c=='t' |
862 | && strncmp(z+i,"true" ,4)==0 |
863 | && !sqlite3Isalnum(z[i+4]) ){ |
864 | jsonParseAddNode(pParse, JSON_TRUE, 0, 0); |
865 | return i+4; |
866 | }else if( c=='f' |
867 | && strncmp(z+i,"false" ,5)==0 |
868 | && !sqlite3Isalnum(z[i+5]) ){ |
869 | jsonParseAddNode(pParse, JSON_FALSE, 0, 0); |
870 | return i+5; |
871 | }else if( c=='-' || (c>='0' && c<='9') ){ |
872 | /* Parse number */ |
873 | u8 seenDP = 0; |
874 | u8 seenE = 0; |
875 | assert( '-' < '0' ); |
876 | if( c<='0' ){ |
877 | j = c=='-' ? i+1 : i; |
878 | if( z[j]=='0' && z[j+1]>='0' && z[j+1]<='9' ) return -1; |
879 | } |
880 | j = i+1; |
881 | for(;; j++){ |
882 | c = z[j]; |
883 | if( c>='0' && c<='9' ) continue; |
884 | if( c=='.' ){ |
885 | if( z[j-1]=='-' ) return -1; |
886 | if( seenDP ) return -1; |
887 | seenDP = 1; |
888 | continue; |
889 | } |
890 | if( c=='e' || c=='E' ){ |
891 | if( z[j-1]<'0' ) return -1; |
892 | if( seenE ) return -1; |
893 | seenDP = seenE = 1; |
894 | c = z[j+1]; |
895 | if( c=='+' || c=='-' ){ |
896 | j++; |
897 | c = z[j+1]; |
898 | } |
899 | if( c<'0' || c>'9' ) return -1; |
900 | continue; |
901 | } |
902 | break; |
903 | } |
904 | if( z[j-1]<'0' ) return -1; |
905 | jsonParseAddNode(pParse, seenDP ? JSON_REAL : JSON_INT, |
906 | j - i, &z[i]); |
907 | return j; |
908 | }else if( c=='}' ){ |
909 | return -2; /* End of {...} */ |
910 | }else if( c==']' ){ |
911 | return -3; /* End of [...] */ |
912 | }else if( c==0 ){ |
913 | return 0; /* End of file */ |
914 | }else{ |
915 | return -1; /* Syntax error */ |
916 | } |
917 | } |
918 | |
919 | /* |
920 | ** Parse a complete JSON string. Return 0 on success or non-zero if there |
921 | ** are any errors. If an error occurs, free all memory associated with |
922 | ** pParse. |
923 | ** |
924 | ** pParse is uninitialized when this routine is called. |
925 | */ |
926 | static int jsonParse( |
927 | JsonParse *pParse, /* Initialize and fill this JsonParse object */ |
928 | sqlite3_context *pCtx, /* Report errors here */ |
929 | const char *zJson /* Input JSON text to be parsed */ |
930 | ){ |
931 | int i; |
932 | memset(pParse, 0, sizeof(*pParse)); |
933 | if( zJson==0 ) return 1; |
934 | pParse->zJson = zJson; |
935 | i = jsonParseValue(pParse, 0); |
936 | if( pParse->oom ) i = -1; |
937 | if( i>0 ){ |
938 | assert( pParse->iDepth==0 ); |
939 | while( fast_isspace(zJson[i]) ) i++; |
940 | if( zJson[i] ) i = -1; |
941 | } |
942 | if( i<=0 ){ |
943 | if( pCtx!=0 ){ |
944 | if( pParse->oom ){ |
945 | sqlite3_result_error_nomem(pCtx); |
946 | }else{ |
947 | sqlite3_result_error(pCtx, "malformed JSON" , -1); |
948 | } |
949 | } |
950 | jsonParseReset(pParse); |
951 | return 1; |
952 | } |
953 | return 0; |
954 | } |
955 | |
956 | /* Mark node i of pParse as being a child of iParent. Call recursively |
957 | ** to fill in all the descendants of node i. |
958 | */ |
959 | static void jsonParseFillInParentage(JsonParse *pParse, u32 i, u32 iParent){ |
960 | JsonNode *pNode = &pParse->aNode[i]; |
961 | u32 j; |
962 | pParse->aUp[i] = iParent; |
963 | switch( pNode->eType ){ |
964 | case JSON_ARRAY: { |
965 | for(j=1; j<=pNode->n; j += jsonNodeSize(pNode+j)){ |
966 | jsonParseFillInParentage(pParse, i+j, i); |
967 | } |
968 | break; |
969 | } |
970 | case JSON_OBJECT: { |
971 | for(j=1; j<=pNode->n; j += jsonNodeSize(pNode+j+1)+1){ |
972 | pParse->aUp[i+j] = i; |
973 | jsonParseFillInParentage(pParse, i+j+1, i); |
974 | } |
975 | break; |
976 | } |
977 | default: { |
978 | break; |
979 | } |
980 | } |
981 | } |
982 | |
983 | /* |
984 | ** Compute the parentage of all nodes in a completed parse. |
985 | */ |
986 | static int jsonParseFindParents(JsonParse *pParse){ |
987 | u32 *aUp; |
988 | assert( pParse->aUp==0 ); |
989 | aUp = pParse->aUp = sqlite3_malloc64( sizeof(u32)*pParse->nNode ); |
990 | if( aUp==0 ){ |
991 | pParse->oom = 1; |
992 | return SQLITE_NOMEM; |
993 | } |
994 | jsonParseFillInParentage(pParse, 0, 0); |
995 | return SQLITE_OK; |
996 | } |
997 | |
998 | /* |
999 | ** Magic number used for the JSON parse cache in sqlite3_get_auxdata() |
1000 | */ |
1001 | #define JSON_CACHE_ID (-429938) /* First cache entry */ |
1002 | #define JSON_CACHE_SZ 4 /* Max number of cache entries */ |
1003 | |
1004 | /* |
1005 | ** Obtain a complete parse of the JSON found in the first argument |
1006 | ** of the argv array. Use the sqlite3_get_auxdata() cache for this |
1007 | ** parse if it is available. If the cache is not available or if it |
1008 | ** is no longer valid, parse the JSON again and return the new parse, |
1009 | ** and also register the new parse so that it will be available for |
1010 | ** future sqlite3_get_auxdata() calls. |
1011 | */ |
1012 | static JsonParse *jsonParseCached( |
1013 | sqlite3_context *pCtx, |
1014 | sqlite3_value **argv, |
1015 | sqlite3_context *pErrCtx |
1016 | ){ |
1017 | const char *zJson = (const char*)sqlite3_value_text(argv[0]); |
1018 | int nJson = sqlite3_value_bytes(argv[0]); |
1019 | JsonParse *p; |
1020 | JsonParse *pMatch = 0; |
1021 | int iKey; |
1022 | int iMinKey = 0; |
1023 | u32 iMinHold = 0xffffffff; |
1024 | u32 iMaxHold = 0; |
1025 | if( zJson==0 ) return 0; |
1026 | for(iKey=0; iKey<JSON_CACHE_SZ; iKey++){ |
1027 | p = (JsonParse*)sqlite3_get_auxdata(pCtx, JSON_CACHE_ID+iKey); |
1028 | if( p==0 ){ |
1029 | iMinKey = iKey; |
1030 | break; |
1031 | } |
1032 | if( pMatch==0 |
1033 | && p->nJson==nJson |
1034 | && memcmp(p->zJson,zJson,nJson)==0 |
1035 | ){ |
1036 | p->nErr = 0; |
1037 | pMatch = p; |
1038 | }else if( p->iHold<iMinHold ){ |
1039 | iMinHold = p->iHold; |
1040 | iMinKey = iKey; |
1041 | } |
1042 | if( p->iHold>iMaxHold ){ |
1043 | iMaxHold = p->iHold; |
1044 | } |
1045 | } |
1046 | if( pMatch ){ |
1047 | pMatch->nErr = 0; |
1048 | pMatch->iHold = iMaxHold+1; |
1049 | return pMatch; |
1050 | } |
1051 | p = sqlite3_malloc64( sizeof(*p) + nJson + 1 ); |
1052 | if( p==0 ){ |
1053 | sqlite3_result_error_nomem(pCtx); |
1054 | return 0; |
1055 | } |
1056 | memset(p, 0, sizeof(*p)); |
1057 | p->zJson = (char*)&p[1]; |
1058 | memcpy((char*)p->zJson, zJson, nJson+1); |
1059 | if( jsonParse(p, pErrCtx, p->zJson) ){ |
1060 | sqlite3_free(p); |
1061 | return 0; |
1062 | } |
1063 | p->nJson = nJson; |
1064 | p->iHold = iMaxHold+1; |
1065 | sqlite3_set_auxdata(pCtx, JSON_CACHE_ID+iMinKey, p, |
1066 | (void(*)(void*))jsonParseFree); |
1067 | return (JsonParse*)sqlite3_get_auxdata(pCtx, JSON_CACHE_ID+iMinKey); |
1068 | } |
1069 | |
1070 | /* |
1071 | ** Compare the OBJECT label at pNode against zKey,nKey. Return true on |
1072 | ** a match. |
1073 | */ |
1074 | static int jsonLabelCompare(JsonNode *pNode, const char *zKey, u32 nKey){ |
1075 | assert( pNode->eU==1 ); |
1076 | if( pNode->jnFlags & JNODE_RAW ){ |
1077 | if( pNode->n!=nKey ) return 0; |
1078 | return strncmp(pNode->u.zJContent, zKey, nKey)==0; |
1079 | }else{ |
1080 | if( pNode->n!=nKey+2 ) return 0; |
1081 | return strncmp(pNode->u.zJContent+1, zKey, nKey)==0; |
1082 | } |
1083 | } |
1084 | |
1085 | /* forward declaration */ |
1086 | static JsonNode *jsonLookupAppend(JsonParse*,const char*,int*,const char**); |
1087 | |
1088 | /* |
1089 | ** Search along zPath to find the node specified. Return a pointer |
1090 | ** to that node, or NULL if zPath is malformed or if there is no such |
1091 | ** node. |
1092 | ** |
1093 | ** If pApnd!=0, then try to append new nodes to complete zPath if it is |
1094 | ** possible to do so and if no existing node corresponds to zPath. If |
1095 | ** new nodes are appended *pApnd is set to 1. |
1096 | */ |
1097 | static JsonNode *jsonLookupStep( |
1098 | JsonParse *pParse, /* The JSON to search */ |
1099 | u32 iRoot, /* Begin the search at this node */ |
1100 | const char *zPath, /* The path to search */ |
1101 | int *pApnd, /* Append nodes to complete path if not NULL */ |
1102 | const char **pzErr /* Make *pzErr point to any syntax error in zPath */ |
1103 | ){ |
1104 | u32 i, j, nKey; |
1105 | const char *zKey; |
1106 | JsonNode *pRoot = &pParse->aNode[iRoot]; |
1107 | if( zPath[0]==0 ) return pRoot; |
1108 | if( pRoot->jnFlags & JNODE_REPLACE ) return 0; |
1109 | if( zPath[0]=='.' ){ |
1110 | if( pRoot->eType!=JSON_OBJECT ) return 0; |
1111 | zPath++; |
1112 | if( zPath[0]=='"' ){ |
1113 | zKey = zPath + 1; |
1114 | for(i=1; zPath[i] && zPath[i]!='"'; i++){} |
1115 | nKey = i-1; |
1116 | if( zPath[i] ){ |
1117 | i++; |
1118 | }else{ |
1119 | *pzErr = zPath; |
1120 | return 0; |
1121 | } |
1122 | testcase( nKey==0 ); |
1123 | }else{ |
1124 | zKey = zPath; |
1125 | for(i=0; zPath[i] && zPath[i]!='.' && zPath[i]!='['; i++){} |
1126 | nKey = i; |
1127 | if( nKey==0 ){ |
1128 | *pzErr = zPath; |
1129 | return 0; |
1130 | } |
1131 | } |
1132 | j = 1; |
1133 | for(;;){ |
1134 | while( j<=pRoot->n ){ |
1135 | if( jsonLabelCompare(pRoot+j, zKey, nKey) ){ |
1136 | return jsonLookupStep(pParse, iRoot+j+1, &zPath[i], pApnd, pzErr); |
1137 | } |
1138 | j++; |
1139 | j += jsonNodeSize(&pRoot[j]); |
1140 | } |
1141 | if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break; |
1142 | assert( pRoot->eU==2 ); |
1143 | iRoot += pRoot->u.iAppend; |
1144 | pRoot = &pParse->aNode[iRoot]; |
1145 | j = 1; |
1146 | } |
1147 | if( pApnd ){ |
1148 | u32 iStart, iLabel; |
1149 | JsonNode *pNode; |
1150 | iStart = jsonParseAddNode(pParse, JSON_OBJECT, 2, 0); |
1151 | iLabel = jsonParseAddNode(pParse, JSON_STRING, nKey, zKey); |
1152 | zPath += i; |
1153 | pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr); |
1154 | if( pParse->oom ) return 0; |
1155 | if( pNode ){ |
1156 | pRoot = &pParse->aNode[iRoot]; |
1157 | assert( pRoot->eU==0 ); |
1158 | pRoot->u.iAppend = iStart - iRoot; |
1159 | pRoot->jnFlags |= JNODE_APPEND; |
1160 | VVA( pRoot->eU = 2 ); |
1161 | pParse->aNode[iLabel].jnFlags |= JNODE_RAW; |
1162 | } |
1163 | return pNode; |
1164 | } |
1165 | }else if( zPath[0]=='[' ){ |
1166 | i = 0; |
1167 | j = 1; |
1168 | while( sqlite3Isdigit(zPath[j]) ){ |
1169 | i = i*10 + zPath[j] - '0'; |
1170 | j++; |
1171 | } |
1172 | if( j<2 || zPath[j]!=']' ){ |
1173 | if( zPath[1]=='#' ){ |
1174 | JsonNode *pBase = pRoot; |
1175 | int iBase = iRoot; |
1176 | if( pRoot->eType!=JSON_ARRAY ) return 0; |
1177 | for(;;){ |
1178 | while( j<=pBase->n ){ |
1179 | if( (pBase[j].jnFlags & JNODE_REMOVE)==0 ) i++; |
1180 | j += jsonNodeSize(&pBase[j]); |
1181 | } |
1182 | if( (pBase->jnFlags & JNODE_APPEND)==0 ) break; |
1183 | assert( pBase->eU==2 ); |
1184 | iBase += pBase->u.iAppend; |
1185 | pBase = &pParse->aNode[iBase]; |
1186 | j = 1; |
1187 | } |
1188 | j = 2; |
1189 | if( zPath[2]=='-' && sqlite3Isdigit(zPath[3]) ){ |
1190 | unsigned int x = 0; |
1191 | j = 3; |
1192 | do{ |
1193 | x = x*10 + zPath[j] - '0'; |
1194 | j++; |
1195 | }while( sqlite3Isdigit(zPath[j]) ); |
1196 | if( x>i ) return 0; |
1197 | i -= x; |
1198 | } |
1199 | if( zPath[j]!=']' ){ |
1200 | *pzErr = zPath; |
1201 | return 0; |
1202 | } |
1203 | }else{ |
1204 | *pzErr = zPath; |
1205 | return 0; |
1206 | } |
1207 | } |
1208 | if( pRoot->eType!=JSON_ARRAY ) return 0; |
1209 | zPath += j + 1; |
1210 | j = 1; |
1211 | for(;;){ |
1212 | while( j<=pRoot->n && (i>0 || (pRoot[j].jnFlags & JNODE_REMOVE)!=0) ){ |
1213 | if( (pRoot[j].jnFlags & JNODE_REMOVE)==0 ) i--; |
1214 | j += jsonNodeSize(&pRoot[j]); |
1215 | } |
1216 | if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break; |
1217 | assert( pRoot->eU==2 ); |
1218 | iRoot += pRoot->u.iAppend; |
1219 | pRoot = &pParse->aNode[iRoot]; |
1220 | j = 1; |
1221 | } |
1222 | if( j<=pRoot->n ){ |
1223 | return jsonLookupStep(pParse, iRoot+j, zPath, pApnd, pzErr); |
1224 | } |
1225 | if( i==0 && pApnd ){ |
1226 | u32 iStart; |
1227 | JsonNode *pNode; |
1228 | iStart = jsonParseAddNode(pParse, JSON_ARRAY, 1, 0); |
1229 | pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr); |
1230 | if( pParse->oom ) return 0; |
1231 | if( pNode ){ |
1232 | pRoot = &pParse->aNode[iRoot]; |
1233 | assert( pRoot->eU==0 ); |
1234 | pRoot->u.iAppend = iStart - iRoot; |
1235 | pRoot->jnFlags |= JNODE_APPEND; |
1236 | VVA( pRoot->eU = 2 ); |
1237 | } |
1238 | return pNode; |
1239 | } |
1240 | }else{ |
1241 | *pzErr = zPath; |
1242 | } |
1243 | return 0; |
1244 | } |
1245 | |
1246 | /* |
1247 | ** Append content to pParse that will complete zPath. Return a pointer |
1248 | ** to the inserted node, or return NULL if the append fails. |
1249 | */ |
1250 | static JsonNode *jsonLookupAppend( |
1251 | JsonParse *pParse, /* Append content to the JSON parse */ |
1252 | const char *zPath, /* Description of content to append */ |
1253 | int *pApnd, /* Set this flag to 1 */ |
1254 | const char **pzErr /* Make this point to any syntax error */ |
1255 | ){ |
1256 | *pApnd = 1; |
1257 | if( zPath[0]==0 ){ |
1258 | jsonParseAddNode(pParse, JSON_NULL, 0, 0); |
1259 | return pParse->oom ? 0 : &pParse->aNode[pParse->nNode-1]; |
1260 | } |
1261 | if( zPath[0]=='.' ){ |
1262 | jsonParseAddNode(pParse, JSON_OBJECT, 0, 0); |
1263 | }else if( strncmp(zPath,"[0]" ,3)==0 ){ |
1264 | jsonParseAddNode(pParse, JSON_ARRAY, 0, 0); |
1265 | }else{ |
1266 | return 0; |
1267 | } |
1268 | if( pParse->oom ) return 0; |
1269 | return jsonLookupStep(pParse, pParse->nNode-1, zPath, pApnd, pzErr); |
1270 | } |
1271 | |
1272 | /* |
1273 | ** Return the text of a syntax error message on a JSON path. Space is |
1274 | ** obtained from sqlite3_malloc(). |
1275 | */ |
1276 | static char *jsonPathSyntaxError(const char *zErr){ |
1277 | return sqlite3_mprintf("JSON path error near '%q'" , zErr); |
1278 | } |
1279 | |
1280 | /* |
1281 | ** Do a node lookup using zPath. Return a pointer to the node on success. |
1282 | ** Return NULL if not found or if there is an error. |
1283 | ** |
1284 | ** On an error, write an error message into pCtx and increment the |
1285 | ** pParse->nErr counter. |
1286 | ** |
1287 | ** If pApnd!=NULL then try to append missing nodes and set *pApnd = 1 if |
1288 | ** nodes are appended. |
1289 | */ |
1290 | static JsonNode *jsonLookup( |
1291 | JsonParse *pParse, /* The JSON to search */ |
1292 | const char *zPath, /* The path to search */ |
1293 | int *pApnd, /* Append nodes to complete path if not NULL */ |
1294 | sqlite3_context *pCtx /* Report errors here, if not NULL */ |
1295 | ){ |
1296 | const char *zErr = 0; |
1297 | JsonNode *pNode = 0; |
1298 | char *zMsg; |
1299 | |
1300 | if( zPath==0 ) return 0; |
1301 | if( zPath[0]!='$' ){ |
1302 | zErr = zPath; |
1303 | goto lookup_err; |
1304 | } |
1305 | zPath++; |
1306 | pNode = jsonLookupStep(pParse, 0, zPath, pApnd, &zErr); |
1307 | if( zErr==0 ) return pNode; |
1308 | |
1309 | lookup_err: |
1310 | pParse->nErr++; |
1311 | assert( zErr!=0 && pCtx!=0 ); |
1312 | zMsg = jsonPathSyntaxError(zErr); |
1313 | if( zMsg ){ |
1314 | sqlite3_result_error(pCtx, zMsg, -1); |
1315 | sqlite3_free(zMsg); |
1316 | }else{ |
1317 | sqlite3_result_error_nomem(pCtx); |
1318 | } |
1319 | return 0; |
1320 | } |
1321 | |
1322 | |
1323 | /* |
1324 | ** Report the wrong number of arguments for json_insert(), json_replace() |
1325 | ** or json_set(). |
1326 | */ |
1327 | static void jsonWrongNumArgs( |
1328 | sqlite3_context *pCtx, |
1329 | const char *zFuncName |
1330 | ){ |
1331 | char *zMsg = sqlite3_mprintf("json_%s() needs an odd number of arguments" , |
1332 | zFuncName); |
1333 | sqlite3_result_error(pCtx, zMsg, -1); |
1334 | sqlite3_free(zMsg); |
1335 | } |
1336 | |
1337 | /* |
1338 | ** Mark all NULL entries in the Object passed in as JNODE_REMOVE. |
1339 | */ |
1340 | static void jsonRemoveAllNulls(JsonNode *pNode){ |
1341 | int i, n; |
1342 | assert( pNode->eType==JSON_OBJECT ); |
1343 | n = pNode->n; |
1344 | for(i=2; i<=n; i += jsonNodeSize(&pNode[i])+1){ |
1345 | switch( pNode[i].eType ){ |
1346 | case JSON_NULL: |
1347 | pNode[i].jnFlags |= JNODE_REMOVE; |
1348 | break; |
1349 | case JSON_OBJECT: |
1350 | jsonRemoveAllNulls(&pNode[i]); |
1351 | break; |
1352 | } |
1353 | } |
1354 | } |
1355 | |
1356 | |
1357 | /**************************************************************************** |
1358 | ** SQL functions used for testing and debugging |
1359 | ****************************************************************************/ |
1360 | |
1361 | #ifdef SQLITE_DEBUG |
1362 | /* |
1363 | ** The json_parse(JSON) function returns a string which describes |
1364 | ** a parse of the JSON provided. Or it returns NULL if JSON is not |
1365 | ** well-formed. |
1366 | */ |
1367 | static void jsonParseFunc( |
1368 | sqlite3_context *ctx, |
1369 | int argc, |
1370 | sqlite3_value **argv |
1371 | ){ |
1372 | JsonString s; /* Output string - not real JSON */ |
1373 | JsonParse x; /* The parse */ |
1374 | u32 i; |
1375 | |
1376 | assert( argc==1 ); |
1377 | if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; |
1378 | jsonParseFindParents(&x); |
1379 | jsonInit(&s, ctx); |
1380 | for(i=0; i<x.nNode; i++){ |
1381 | const char *zType; |
1382 | if( x.aNode[i].jnFlags & JNODE_LABEL ){ |
1383 | assert( x.aNode[i].eType==JSON_STRING ); |
1384 | zType = "label" ; |
1385 | }else{ |
1386 | zType = jsonType[x.aNode[i].eType]; |
1387 | } |
1388 | jsonPrintf(100, &s,"node %3u: %7s n=%-4d up=%-4d" , |
1389 | i, zType, x.aNode[i].n, x.aUp[i]); |
1390 | assert( x.aNode[i].eU==0 || x.aNode[i].eU==1 ); |
1391 | if( x.aNode[i].u.zJContent!=0 ){ |
1392 | assert( x.aNode[i].eU==1 ); |
1393 | jsonAppendRaw(&s, " " , 1); |
1394 | jsonAppendRaw(&s, x.aNode[i].u.zJContent, x.aNode[i].n); |
1395 | }else{ |
1396 | assert( x.aNode[i].eU==0 ); |
1397 | } |
1398 | jsonAppendRaw(&s, "\n" , 1); |
1399 | } |
1400 | jsonParseReset(&x); |
1401 | jsonResult(&s); |
1402 | } |
1403 | |
1404 | /* |
1405 | ** The json_test1(JSON) function return true (1) if the input is JSON |
1406 | ** text generated by another json function. It returns (0) if the input |
1407 | ** is not known to be JSON. |
1408 | */ |
1409 | static void jsonTest1Func( |
1410 | sqlite3_context *ctx, |
1411 | int argc, |
1412 | sqlite3_value **argv |
1413 | ){ |
1414 | UNUSED_PARAMETER(argc); |
1415 | sqlite3_result_int(ctx, sqlite3_value_subtype(argv[0])==JSON_SUBTYPE); |
1416 | } |
1417 | #endif /* SQLITE_DEBUG */ |
1418 | |
1419 | /**************************************************************************** |
1420 | ** Scalar SQL function implementations |
1421 | ****************************************************************************/ |
1422 | |
1423 | /* |
1424 | ** Implementation of the json_QUOTE(VALUE) function. Return a JSON value |
1425 | ** corresponding to the SQL value input. Mostly this means putting |
1426 | ** double-quotes around strings and returning the unquoted string "null" |
1427 | ** when given a NULL input. |
1428 | */ |
1429 | static void jsonQuoteFunc( |
1430 | sqlite3_context *ctx, |
1431 | int argc, |
1432 | sqlite3_value **argv |
1433 | ){ |
1434 | JsonString jx; |
1435 | UNUSED_PARAMETER(argc); |
1436 | |
1437 | jsonInit(&jx, ctx); |
1438 | jsonAppendValue(&jx, argv[0]); |
1439 | jsonResult(&jx); |
1440 | sqlite3_result_subtype(ctx, JSON_SUBTYPE); |
1441 | } |
1442 | |
1443 | /* |
1444 | ** Implementation of the json_array(VALUE,...) function. Return a JSON |
1445 | ** array that contains all values given in arguments. Or if any argument |
1446 | ** is a BLOB, throw an error. |
1447 | */ |
1448 | static void jsonArrayFunc( |
1449 | sqlite3_context *ctx, |
1450 | int argc, |
1451 | sqlite3_value **argv |
1452 | ){ |
1453 | int i; |
1454 | JsonString jx; |
1455 | |
1456 | jsonInit(&jx, ctx); |
1457 | jsonAppendChar(&jx, '['); |
1458 | for(i=0; i<argc; i++){ |
1459 | jsonAppendSeparator(&jx); |
1460 | jsonAppendValue(&jx, argv[i]); |
1461 | } |
1462 | jsonAppendChar(&jx, ']'); |
1463 | jsonResult(&jx); |
1464 | sqlite3_result_subtype(ctx, JSON_SUBTYPE); |
1465 | } |
1466 | |
1467 | |
1468 | /* |
1469 | ** json_array_length(JSON) |
1470 | ** json_array_length(JSON, PATH) |
1471 | ** |
1472 | ** Return the number of elements in the top-level JSON array. |
1473 | ** Return 0 if the input is not a well-formed JSON array. |
1474 | */ |
1475 | static void jsonArrayLengthFunc( |
1476 | sqlite3_context *ctx, |
1477 | int argc, |
1478 | sqlite3_value **argv |
1479 | ){ |
1480 | JsonParse *p; /* The parse */ |
1481 | sqlite3_int64 n = 0; |
1482 | u32 i; |
1483 | JsonNode *pNode; |
1484 | |
1485 | p = jsonParseCached(ctx, argv, ctx); |
1486 | if( p==0 ) return; |
1487 | assert( p->nNode ); |
1488 | if( argc==2 ){ |
1489 | const char *zPath = (const char*)sqlite3_value_text(argv[1]); |
1490 | pNode = jsonLookup(p, zPath, 0, ctx); |
1491 | }else{ |
1492 | pNode = p->aNode; |
1493 | } |
1494 | if( pNode==0 ){ |
1495 | return; |
1496 | } |
1497 | if( pNode->eType==JSON_ARRAY ){ |
1498 | assert( (pNode->jnFlags & JNODE_APPEND)==0 ); |
1499 | for(i=1; i<=pNode->n; n++){ |
1500 | i += jsonNodeSize(&pNode[i]); |
1501 | } |
1502 | } |
1503 | sqlite3_result_int64(ctx, n); |
1504 | } |
1505 | |
1506 | /* |
1507 | ** Bit values for the flags passed into jsonExtractFunc() or |
1508 | ** jsonSetFunc() via the user-data value. |
1509 | */ |
1510 | #define JSON_JSON 0x01 /* Result is always JSON */ |
1511 | #define JSON_SQL 0x02 /* Result is always SQL */ |
1512 | #define JSON_ABPATH 0x03 /* Allow abbreviated JSON path specs */ |
1513 | #define JSON_ISSET 0x04 /* json_set(), not json_insert() */ |
1514 | |
1515 | /* |
1516 | ** json_extract(JSON, PATH, ...) |
1517 | ** "->"(JSON,PATH) |
1518 | ** "->>"(JSON,PATH) |
1519 | ** |
1520 | ** Return the element described by PATH. Return NULL if that PATH element |
1521 | ** is not found. |
1522 | ** |
1523 | ** If JSON_JSON is set or if more that one PATH argument is supplied then |
1524 | ** always return a JSON representation of the result. If JSON_SQL is set, |
1525 | ** then always return an SQL representation of the result. If neither flag |
1526 | ** is present and argc==2, then return JSON for objects and arrays and SQL |
1527 | ** for all other values. |
1528 | ** |
1529 | ** When multiple PATH arguments are supplied, the result is a JSON array |
1530 | ** containing the result of each PATH. |
1531 | ** |
1532 | ** Abbreviated JSON path expressions are allows if JSON_ABPATH, for |
1533 | ** compatibility with PG. |
1534 | */ |
1535 | static void ( |
1536 | sqlite3_context *ctx, |
1537 | int argc, |
1538 | sqlite3_value **argv |
1539 | ){ |
1540 | JsonParse *p; /* The parse */ |
1541 | JsonNode *pNode; |
1542 | const char *zPath; |
1543 | int flags = SQLITE_PTR_TO_INT(sqlite3_user_data(ctx)); |
1544 | JsonString jx; |
1545 | |
1546 | if( argc<2 ) return; |
1547 | p = jsonParseCached(ctx, argv, ctx); |
1548 | if( p==0 ) return; |
1549 | if( argc==2 ){ |
1550 | /* With a single PATH argument */ |
1551 | zPath = (const char*)sqlite3_value_text(argv[1]); |
1552 | if( zPath==0 ) return; |
1553 | if( flags & JSON_ABPATH ){ |
1554 | if( zPath[0]!='$' ){ |
1555 | /* The -> and ->> operators accept abbreviated PATH arguments. This |
1556 | ** is mostly for compatibility with PostgreSQL, but also for |
1557 | ** convenience. |
1558 | ** |
1559 | ** NUMBER ==> $[NUMBER] // PG compatible |
1560 | ** LABEL ==> $.LABEL // PG compatible |
1561 | ** [NUMBER] ==> $[NUMBER] // Not PG. Purely for convenience |
1562 | */ |
1563 | jsonInit(&jx, ctx); |
1564 | if( sqlite3Isdigit(zPath[0]) ){ |
1565 | jsonAppendRaw(&jx, "$[" , 2); |
1566 | jsonAppendRaw(&jx, zPath, (int)strlen(zPath)); |
1567 | jsonAppendRaw(&jx, "]" , 2); |
1568 | }else{ |
1569 | jsonAppendRaw(&jx, "$." , 1 + (zPath[0]!='[')); |
1570 | jsonAppendRaw(&jx, zPath, (int)strlen(zPath)); |
1571 | jsonAppendChar(&jx, 0); |
1572 | } |
1573 | pNode = jx.bErr ? 0 : jsonLookup(p, jx.zBuf, 0, ctx); |
1574 | jsonReset(&jx); |
1575 | }else{ |
1576 | pNode = jsonLookup(p, zPath, 0, ctx); |
1577 | } |
1578 | if( pNode ){ |
1579 | if( flags & JSON_JSON ){ |
1580 | jsonReturnJson(pNode, ctx, 0); |
1581 | }else{ |
1582 | jsonReturn(pNode, ctx, 0); |
1583 | sqlite3_result_subtype(ctx, 0); |
1584 | } |
1585 | } |
1586 | }else{ |
1587 | pNode = jsonLookup(p, zPath, 0, ctx); |
1588 | if( p->nErr==0 && pNode ) jsonReturn(pNode, ctx, 0); |
1589 | } |
1590 | }else{ |
1591 | /* Two or more PATH arguments results in a JSON array with each |
1592 | ** element of the array being the value selected by one of the PATHs */ |
1593 | int i; |
1594 | jsonInit(&jx, ctx); |
1595 | jsonAppendChar(&jx, '['); |
1596 | for(i=1; i<argc; i++){ |
1597 | zPath = (const char*)sqlite3_value_text(argv[i]); |
1598 | pNode = jsonLookup(p, zPath, 0, ctx); |
1599 | if( p->nErr ) break; |
1600 | jsonAppendSeparator(&jx); |
1601 | if( pNode ){ |
1602 | jsonRenderNode(pNode, &jx, 0); |
1603 | }else{ |
1604 | jsonAppendRaw(&jx, "null" , 4); |
1605 | } |
1606 | } |
1607 | if( i==argc ){ |
1608 | jsonAppendChar(&jx, ']'); |
1609 | jsonResult(&jx); |
1610 | sqlite3_result_subtype(ctx, JSON_SUBTYPE); |
1611 | } |
1612 | jsonReset(&jx); |
1613 | } |
1614 | } |
1615 | |
1616 | /* This is the RFC 7396 MergePatch algorithm. |
1617 | */ |
1618 | static JsonNode *jsonMergePatch( |
1619 | JsonParse *pParse, /* The JSON parser that contains the TARGET */ |
1620 | u32 iTarget, /* Node of the TARGET in pParse */ |
1621 | JsonNode *pPatch /* The PATCH */ |
1622 | ){ |
1623 | u32 i, j; |
1624 | u32 iRoot; |
1625 | JsonNode *pTarget; |
1626 | if( pPatch->eType!=JSON_OBJECT ){ |
1627 | return pPatch; |
1628 | } |
1629 | assert( iTarget<pParse->nNode ); |
1630 | pTarget = &pParse->aNode[iTarget]; |
1631 | assert( (pPatch->jnFlags & JNODE_APPEND)==0 ); |
1632 | if( pTarget->eType!=JSON_OBJECT ){ |
1633 | jsonRemoveAllNulls(pPatch); |
1634 | return pPatch; |
1635 | } |
1636 | iRoot = iTarget; |
1637 | for(i=1; i<pPatch->n; i += jsonNodeSize(&pPatch[i+1])+1){ |
1638 | u32 nKey; |
1639 | const char *zKey; |
1640 | assert( pPatch[i].eType==JSON_STRING ); |
1641 | assert( pPatch[i].jnFlags & JNODE_LABEL ); |
1642 | assert( pPatch[i].eU==1 ); |
1643 | nKey = pPatch[i].n; |
1644 | zKey = pPatch[i].u.zJContent; |
1645 | assert( (pPatch[i].jnFlags & JNODE_RAW)==0 ); |
1646 | for(j=1; j<pTarget->n; j += jsonNodeSize(&pTarget[j+1])+1 ){ |
1647 | assert( pTarget[j].eType==JSON_STRING ); |
1648 | assert( pTarget[j].jnFlags & JNODE_LABEL ); |
1649 | assert( (pPatch[i].jnFlags & JNODE_RAW)==0 ); |
1650 | if( pTarget[j].n==nKey && strncmp(pTarget[j].u.zJContent,zKey,nKey)==0 ){ |
1651 | if( pTarget[j+1].jnFlags & (JNODE_REMOVE|JNODE_PATCH) ) break; |
1652 | if( pPatch[i+1].eType==JSON_NULL ){ |
1653 | pTarget[j+1].jnFlags |= JNODE_REMOVE; |
1654 | }else{ |
1655 | JsonNode *pNew = jsonMergePatch(pParse, iTarget+j+1, &pPatch[i+1]); |
1656 | if( pNew==0 ) return 0; |
1657 | pTarget = &pParse->aNode[iTarget]; |
1658 | if( pNew!=&pTarget[j+1] ){ |
1659 | assert( pTarget[j+1].eU==0 |
1660 | || pTarget[j+1].eU==1 |
1661 | || pTarget[j+1].eU==2 ); |
1662 | testcase( pTarget[j+1].eU==1 ); |
1663 | testcase( pTarget[j+1].eU==2 ); |
1664 | VVA( pTarget[j+1].eU = 5 ); |
1665 | pTarget[j+1].u.pPatch = pNew; |
1666 | pTarget[j+1].jnFlags |= JNODE_PATCH; |
1667 | } |
1668 | } |
1669 | break; |
1670 | } |
1671 | } |
1672 | if( j>=pTarget->n && pPatch[i+1].eType!=JSON_NULL ){ |
1673 | int iStart, iPatch; |
1674 | iStart = jsonParseAddNode(pParse, JSON_OBJECT, 2, 0); |
1675 | jsonParseAddNode(pParse, JSON_STRING, nKey, zKey); |
1676 | iPatch = jsonParseAddNode(pParse, JSON_TRUE, 0, 0); |
1677 | if( pParse->oom ) return 0; |
1678 | jsonRemoveAllNulls(pPatch); |
1679 | pTarget = &pParse->aNode[iTarget]; |
1680 | assert( pParse->aNode[iRoot].eU==0 || pParse->aNode[iRoot].eU==2 ); |
1681 | testcase( pParse->aNode[iRoot].eU==2 ); |
1682 | pParse->aNode[iRoot].jnFlags |= JNODE_APPEND; |
1683 | VVA( pParse->aNode[iRoot].eU = 2 ); |
1684 | pParse->aNode[iRoot].u.iAppend = iStart - iRoot; |
1685 | iRoot = iStart; |
1686 | assert( pParse->aNode[iPatch].eU==0 ); |
1687 | VVA( pParse->aNode[iPatch].eU = 5 ); |
1688 | pParse->aNode[iPatch].jnFlags |= JNODE_PATCH; |
1689 | pParse->aNode[iPatch].u.pPatch = &pPatch[i+1]; |
1690 | } |
1691 | } |
1692 | return pTarget; |
1693 | } |
1694 | |
1695 | /* |
1696 | ** Implementation of the json_mergepatch(JSON1,JSON2) function. Return a JSON |
1697 | ** object that is the result of running the RFC 7396 MergePatch() algorithm |
1698 | ** on the two arguments. |
1699 | */ |
1700 | static void jsonPatchFunc( |
1701 | sqlite3_context *ctx, |
1702 | int argc, |
1703 | sqlite3_value **argv |
1704 | ){ |
1705 | JsonParse x; /* The JSON that is being patched */ |
1706 | JsonParse y; /* The patch */ |
1707 | JsonNode *pResult; /* The result of the merge */ |
1708 | |
1709 | UNUSED_PARAMETER(argc); |
1710 | if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; |
1711 | if( jsonParse(&y, ctx, (const char*)sqlite3_value_text(argv[1])) ){ |
1712 | jsonParseReset(&x); |
1713 | return; |
1714 | } |
1715 | pResult = jsonMergePatch(&x, 0, y.aNode); |
1716 | assert( pResult!=0 || x.oom ); |
1717 | if( pResult ){ |
1718 | jsonReturnJson(pResult, ctx, 0); |
1719 | }else{ |
1720 | sqlite3_result_error_nomem(ctx); |
1721 | } |
1722 | jsonParseReset(&x); |
1723 | jsonParseReset(&y); |
1724 | } |
1725 | |
1726 | |
1727 | /* |
1728 | ** Implementation of the json_object(NAME,VALUE,...) function. Return a JSON |
1729 | ** object that contains all name/value given in arguments. Or if any name |
1730 | ** is not a string or if any value is a BLOB, throw an error. |
1731 | */ |
1732 | static void jsonObjectFunc( |
1733 | sqlite3_context *ctx, |
1734 | int argc, |
1735 | sqlite3_value **argv |
1736 | ){ |
1737 | int i; |
1738 | JsonString jx; |
1739 | const char *z; |
1740 | u32 n; |
1741 | |
1742 | if( argc&1 ){ |
1743 | sqlite3_result_error(ctx, "json_object() requires an even number " |
1744 | "of arguments" , -1); |
1745 | return; |
1746 | } |
1747 | jsonInit(&jx, ctx); |
1748 | jsonAppendChar(&jx, '{'); |
1749 | for(i=0; i<argc; i+=2){ |
1750 | if( sqlite3_value_type(argv[i])!=SQLITE_TEXT ){ |
1751 | sqlite3_result_error(ctx, "json_object() labels must be TEXT" , -1); |
1752 | jsonReset(&jx); |
1753 | return; |
1754 | } |
1755 | jsonAppendSeparator(&jx); |
1756 | z = (const char*)sqlite3_value_text(argv[i]); |
1757 | n = (u32)sqlite3_value_bytes(argv[i]); |
1758 | jsonAppendString(&jx, z, n); |
1759 | jsonAppendChar(&jx, ':'); |
1760 | jsonAppendValue(&jx, argv[i+1]); |
1761 | } |
1762 | jsonAppendChar(&jx, '}'); |
1763 | jsonResult(&jx); |
1764 | sqlite3_result_subtype(ctx, JSON_SUBTYPE); |
1765 | } |
1766 | |
1767 | |
1768 | /* |
1769 | ** json_remove(JSON, PATH, ...) |
1770 | ** |
1771 | ** Remove the named elements from JSON and return the result. malformed |
1772 | ** JSON or PATH arguments result in an error. |
1773 | */ |
1774 | static void jsonRemoveFunc( |
1775 | sqlite3_context *ctx, |
1776 | int argc, |
1777 | sqlite3_value **argv |
1778 | ){ |
1779 | JsonParse x; /* The parse */ |
1780 | JsonNode *pNode; |
1781 | const char *zPath; |
1782 | u32 i; |
1783 | |
1784 | if( argc<1 ) return; |
1785 | if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; |
1786 | assert( x.nNode ); |
1787 | for(i=1; i<(u32)argc; i++){ |
1788 | zPath = (const char*)sqlite3_value_text(argv[i]); |
1789 | if( zPath==0 ) goto remove_done; |
1790 | pNode = jsonLookup(&x, zPath, 0, ctx); |
1791 | if( x.nErr ) goto remove_done; |
1792 | if( pNode ) pNode->jnFlags |= JNODE_REMOVE; |
1793 | } |
1794 | if( (x.aNode[0].jnFlags & JNODE_REMOVE)==0 ){ |
1795 | jsonReturnJson(x.aNode, ctx, 0); |
1796 | } |
1797 | remove_done: |
1798 | jsonParseReset(&x); |
1799 | } |
1800 | |
1801 | /* |
1802 | ** json_replace(JSON, PATH, VALUE, ...) |
1803 | ** |
1804 | ** Replace the value at PATH with VALUE. If PATH does not already exist, |
1805 | ** this routine is a no-op. If JSON or PATH is malformed, throw an error. |
1806 | */ |
1807 | static void jsonReplaceFunc( |
1808 | sqlite3_context *ctx, |
1809 | int argc, |
1810 | sqlite3_value **argv |
1811 | ){ |
1812 | JsonParse x; /* The parse */ |
1813 | JsonNode *pNode; |
1814 | const char *zPath; |
1815 | u32 i; |
1816 | |
1817 | if( argc<1 ) return; |
1818 | if( (argc&1)==0 ) { |
1819 | jsonWrongNumArgs(ctx, "replace" ); |
1820 | return; |
1821 | } |
1822 | if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; |
1823 | assert( x.nNode ); |
1824 | for(i=1; i<(u32)argc; i+=2){ |
1825 | zPath = (const char*)sqlite3_value_text(argv[i]); |
1826 | pNode = jsonLookup(&x, zPath, 0, ctx); |
1827 | if( x.nErr ) goto replace_err; |
1828 | if( pNode ){ |
1829 | assert( pNode->eU==0 || pNode->eU==1 || pNode->eU==4 ); |
1830 | testcase( pNode->eU!=0 && pNode->eU!=1 ); |
1831 | pNode->jnFlags |= (u8)JNODE_REPLACE; |
1832 | VVA( pNode->eU = 4 ); |
1833 | pNode->u.iReplace = i + 1; |
1834 | } |
1835 | } |
1836 | if( x.aNode[0].jnFlags & JNODE_REPLACE ){ |
1837 | assert( x.aNode[0].eU==4 ); |
1838 | sqlite3_result_value(ctx, argv[x.aNode[0].u.iReplace]); |
1839 | }else{ |
1840 | jsonReturnJson(x.aNode, ctx, argv); |
1841 | } |
1842 | replace_err: |
1843 | jsonParseReset(&x); |
1844 | } |
1845 | |
1846 | |
1847 | /* |
1848 | ** json_set(JSON, PATH, VALUE, ...) |
1849 | ** |
1850 | ** Set the value at PATH to VALUE. Create the PATH if it does not already |
1851 | ** exist. Overwrite existing values that do exist. |
1852 | ** If JSON or PATH is malformed, throw an error. |
1853 | ** |
1854 | ** json_insert(JSON, PATH, VALUE, ...) |
1855 | ** |
1856 | ** Create PATH and initialize it to VALUE. If PATH already exists, this |
1857 | ** routine is a no-op. If JSON or PATH is malformed, throw an error. |
1858 | */ |
1859 | static void jsonSetFunc( |
1860 | sqlite3_context *ctx, |
1861 | int argc, |
1862 | sqlite3_value **argv |
1863 | ){ |
1864 | JsonParse x; /* The parse */ |
1865 | JsonNode *pNode; |
1866 | const char *zPath; |
1867 | u32 i; |
1868 | int bApnd; |
1869 | int bIsSet = sqlite3_user_data(ctx)!=0; |
1870 | |
1871 | if( argc<1 ) return; |
1872 | if( (argc&1)==0 ) { |
1873 | jsonWrongNumArgs(ctx, bIsSet ? "set" : "insert" ); |
1874 | return; |
1875 | } |
1876 | if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; |
1877 | assert( x.nNode ); |
1878 | for(i=1; i<(u32)argc; i+=2){ |
1879 | zPath = (const char*)sqlite3_value_text(argv[i]); |
1880 | bApnd = 0; |
1881 | pNode = jsonLookup(&x, zPath, &bApnd, ctx); |
1882 | if( x.oom ){ |
1883 | sqlite3_result_error_nomem(ctx); |
1884 | goto jsonSetDone; |
1885 | }else if( x.nErr ){ |
1886 | goto jsonSetDone; |
1887 | }else if( pNode && (bApnd || bIsSet) ){ |
1888 | testcase( pNode->eU!=0 && pNode->eU!=1 ); |
1889 | assert( pNode->eU!=3 && pNode->eU!=5 ); |
1890 | VVA( pNode->eU = 4 ); |
1891 | pNode->jnFlags |= (u8)JNODE_REPLACE; |
1892 | pNode->u.iReplace = i + 1; |
1893 | } |
1894 | } |
1895 | if( x.aNode[0].jnFlags & JNODE_REPLACE ){ |
1896 | assert( x.aNode[0].eU==4 ); |
1897 | sqlite3_result_value(ctx, argv[x.aNode[0].u.iReplace]); |
1898 | }else{ |
1899 | jsonReturnJson(x.aNode, ctx, argv); |
1900 | } |
1901 | jsonSetDone: |
1902 | jsonParseReset(&x); |
1903 | } |
1904 | |
1905 | /* |
1906 | ** json_type(JSON) |
1907 | ** json_type(JSON, PATH) |
1908 | ** |
1909 | ** Return the top-level "type" of a JSON string. json_type() raises an |
1910 | ** error if either the JSON or PATH inputs are not well-formed. |
1911 | */ |
1912 | static void jsonTypeFunc( |
1913 | sqlite3_context *ctx, |
1914 | int argc, |
1915 | sqlite3_value **argv |
1916 | ){ |
1917 | JsonParse *p; /* The parse */ |
1918 | const char *zPath; |
1919 | JsonNode *pNode; |
1920 | |
1921 | p = jsonParseCached(ctx, argv, ctx); |
1922 | if( p==0 ) return; |
1923 | if( argc==2 ){ |
1924 | zPath = (const char*)sqlite3_value_text(argv[1]); |
1925 | pNode = jsonLookup(p, zPath, 0, ctx); |
1926 | }else{ |
1927 | pNode = p->aNode; |
1928 | } |
1929 | if( pNode ){ |
1930 | sqlite3_result_text(ctx, jsonType[pNode->eType], -1, SQLITE_STATIC); |
1931 | } |
1932 | } |
1933 | |
1934 | /* |
1935 | ** json_valid(JSON) |
1936 | ** |
1937 | ** Return 1 if JSON is a well-formed JSON string according to RFC-7159. |
1938 | ** Return 0 otherwise. |
1939 | */ |
1940 | static void jsonValidFunc( |
1941 | sqlite3_context *ctx, |
1942 | int argc, |
1943 | sqlite3_value **argv |
1944 | ){ |
1945 | JsonParse *p; /* The parse */ |
1946 | UNUSED_PARAMETER(argc); |
1947 | p = jsonParseCached(ctx, argv, 0); |
1948 | sqlite3_result_int(ctx, p!=0); |
1949 | } |
1950 | |
1951 | |
1952 | /**************************************************************************** |
1953 | ** Aggregate SQL function implementations |
1954 | ****************************************************************************/ |
1955 | /* |
1956 | ** json_group_array(VALUE) |
1957 | ** |
1958 | ** Return a JSON array composed of all values in the aggregate. |
1959 | */ |
1960 | static void jsonArrayStep( |
1961 | sqlite3_context *ctx, |
1962 | int argc, |
1963 | sqlite3_value **argv |
1964 | ){ |
1965 | JsonString *pStr; |
1966 | UNUSED_PARAMETER(argc); |
1967 | pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr)); |
1968 | if( pStr ){ |
1969 | if( pStr->zBuf==0 ){ |
1970 | jsonInit(pStr, ctx); |
1971 | jsonAppendChar(pStr, '['); |
1972 | }else if( pStr->nUsed>1 ){ |
1973 | jsonAppendChar(pStr, ','); |
1974 | } |
1975 | pStr->pCtx = ctx; |
1976 | jsonAppendValue(pStr, argv[0]); |
1977 | } |
1978 | } |
1979 | static void jsonArrayCompute(sqlite3_context *ctx, int isFinal){ |
1980 | JsonString *pStr; |
1981 | pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0); |
1982 | if( pStr ){ |
1983 | pStr->pCtx = ctx; |
1984 | jsonAppendChar(pStr, ']'); |
1985 | if( pStr->bErr ){ |
1986 | if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx); |
1987 | assert( pStr->bStatic ); |
1988 | }else if( isFinal ){ |
1989 | sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, |
1990 | pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free); |
1991 | pStr->bStatic = 1; |
1992 | }else{ |
1993 | sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, SQLITE_TRANSIENT); |
1994 | pStr->nUsed--; |
1995 | } |
1996 | }else{ |
1997 | sqlite3_result_text(ctx, "[]" , 2, SQLITE_STATIC); |
1998 | } |
1999 | sqlite3_result_subtype(ctx, JSON_SUBTYPE); |
2000 | } |
2001 | static void jsonArrayValue(sqlite3_context *ctx){ |
2002 | jsonArrayCompute(ctx, 0); |
2003 | } |
2004 | static void jsonArrayFinal(sqlite3_context *ctx){ |
2005 | jsonArrayCompute(ctx, 1); |
2006 | } |
2007 | |
2008 | #ifndef SQLITE_OMIT_WINDOWFUNC |
2009 | /* |
2010 | ** This method works for both json_group_array() and json_group_object(). |
2011 | ** It works by removing the first element of the group by searching forward |
2012 | ** to the first comma (",") that is not within a string and deleting all |
2013 | ** text through that comma. |
2014 | */ |
2015 | static void jsonGroupInverse( |
2016 | sqlite3_context *ctx, |
2017 | int argc, |
2018 | sqlite3_value **argv |
2019 | ){ |
2020 | unsigned int i; |
2021 | int inStr = 0; |
2022 | int nNest = 0; |
2023 | char *z; |
2024 | char c; |
2025 | JsonString *pStr; |
2026 | UNUSED_PARAMETER(argc); |
2027 | UNUSED_PARAMETER(argv); |
2028 | pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0); |
2029 | #ifdef NEVER |
2030 | /* pStr is always non-NULL since jsonArrayStep() or jsonObjectStep() will |
2031 | ** always have been called to initalize it */ |
2032 | if( NEVER(!pStr) ) return; |
2033 | #endif |
2034 | z = pStr->zBuf; |
2035 | for(i=1; i<pStr->nUsed && ((c = z[i])!=',' || inStr || nNest); i++){ |
2036 | if( c=='"' ){ |
2037 | inStr = !inStr; |
2038 | }else if( c=='\\' ){ |
2039 | i++; |
2040 | }else if( !inStr ){ |
2041 | if( c=='{' || c=='[' ) nNest++; |
2042 | if( c=='}' || c==']' ) nNest--; |
2043 | } |
2044 | } |
2045 | if( i<pStr->nUsed ){ |
2046 | pStr->nUsed -= i; |
2047 | memmove(&z[1], &z[i+1], (size_t)pStr->nUsed-1); |
2048 | z[pStr->nUsed] = 0; |
2049 | }else{ |
2050 | pStr->nUsed = 1; |
2051 | } |
2052 | } |
2053 | #else |
2054 | # define jsonGroupInverse 0 |
2055 | #endif |
2056 | |
2057 | |
2058 | /* |
2059 | ** json_group_obj(NAME,VALUE) |
2060 | ** |
2061 | ** Return a JSON object composed of all names and values in the aggregate. |
2062 | */ |
2063 | static void jsonObjectStep( |
2064 | sqlite3_context *ctx, |
2065 | int argc, |
2066 | sqlite3_value **argv |
2067 | ){ |
2068 | JsonString *pStr; |
2069 | const char *z; |
2070 | u32 n; |
2071 | UNUSED_PARAMETER(argc); |
2072 | pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr)); |
2073 | if( pStr ){ |
2074 | if( pStr->zBuf==0 ){ |
2075 | jsonInit(pStr, ctx); |
2076 | jsonAppendChar(pStr, '{'); |
2077 | }else if( pStr->nUsed>1 ){ |
2078 | jsonAppendChar(pStr, ','); |
2079 | } |
2080 | pStr->pCtx = ctx; |
2081 | z = (const char*)sqlite3_value_text(argv[0]); |
2082 | n = (u32)sqlite3_value_bytes(argv[0]); |
2083 | jsonAppendString(pStr, z, n); |
2084 | jsonAppendChar(pStr, ':'); |
2085 | jsonAppendValue(pStr, argv[1]); |
2086 | } |
2087 | } |
2088 | static void jsonObjectCompute(sqlite3_context *ctx, int isFinal){ |
2089 | JsonString *pStr; |
2090 | pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0); |
2091 | if( pStr ){ |
2092 | jsonAppendChar(pStr, '}'); |
2093 | if( pStr->bErr ){ |
2094 | if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx); |
2095 | assert( pStr->bStatic ); |
2096 | }else if( isFinal ){ |
2097 | sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, |
2098 | pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free); |
2099 | pStr->bStatic = 1; |
2100 | }else{ |
2101 | sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, SQLITE_TRANSIENT); |
2102 | pStr->nUsed--; |
2103 | } |
2104 | }else{ |
2105 | sqlite3_result_text(ctx, "{}" , 2, SQLITE_STATIC); |
2106 | } |
2107 | sqlite3_result_subtype(ctx, JSON_SUBTYPE); |
2108 | } |
2109 | static void jsonObjectValue(sqlite3_context *ctx){ |
2110 | jsonObjectCompute(ctx, 0); |
2111 | } |
2112 | static void jsonObjectFinal(sqlite3_context *ctx){ |
2113 | jsonObjectCompute(ctx, 1); |
2114 | } |
2115 | |
2116 | |
2117 | |
2118 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
2119 | /**************************************************************************** |
2120 | ** The json_each virtual table |
2121 | ****************************************************************************/ |
2122 | typedef struct JsonEachCursor JsonEachCursor; |
2123 | struct JsonEachCursor { |
2124 | sqlite3_vtab_cursor base; /* Base class - must be first */ |
2125 | u32 iRowid; /* The rowid */ |
2126 | u32 iBegin; /* The first node of the scan */ |
2127 | u32 i; /* Index in sParse.aNode[] of current row */ |
2128 | u32 iEnd; /* EOF when i equals or exceeds this value */ |
2129 | u8 eType; /* Type of top-level element */ |
2130 | u8 bRecursive; /* True for json_tree(). False for json_each() */ |
2131 | char *zJson; /* Input JSON */ |
2132 | char *zRoot; /* Path by which to filter zJson */ |
2133 | JsonParse sParse; /* Parse of the input JSON */ |
2134 | }; |
2135 | |
2136 | /* Constructor for the json_each virtual table */ |
2137 | static int jsonEachConnect( |
2138 | sqlite3 *db, |
2139 | void *pAux, |
2140 | int argc, const char *const*argv, |
2141 | sqlite3_vtab **ppVtab, |
2142 | char **pzErr |
2143 | ){ |
2144 | sqlite3_vtab *pNew; |
2145 | int rc; |
2146 | |
2147 | /* Column numbers */ |
2148 | #define JEACH_KEY 0 |
2149 | #define JEACH_VALUE 1 |
2150 | #define JEACH_TYPE 2 |
2151 | #define JEACH_ATOM 3 |
2152 | #define JEACH_ID 4 |
2153 | #define JEACH_PARENT 5 |
2154 | #define JEACH_FULLKEY 6 |
2155 | #define JEACH_PATH 7 |
2156 | /* The xBestIndex method assumes that the JSON and ROOT columns are |
2157 | ** the last two columns in the table. Should this ever changes, be |
2158 | ** sure to update the xBestIndex method. */ |
2159 | #define JEACH_JSON 8 |
2160 | #define JEACH_ROOT 9 |
2161 | |
2162 | UNUSED_PARAMETER(pzErr); |
2163 | UNUSED_PARAMETER(argv); |
2164 | UNUSED_PARAMETER(argc); |
2165 | UNUSED_PARAMETER(pAux); |
2166 | rc = sqlite3_declare_vtab(db, |
2167 | "CREATE TABLE x(key,value,type,atom,id,parent,fullkey,path," |
2168 | "json HIDDEN,root HIDDEN)" ); |
2169 | if( rc==SQLITE_OK ){ |
2170 | pNew = *ppVtab = sqlite3_malloc( sizeof(*pNew) ); |
2171 | if( pNew==0 ) return SQLITE_NOMEM; |
2172 | memset(pNew, 0, sizeof(*pNew)); |
2173 | sqlite3_vtab_config(db, SQLITE_VTAB_INNOCUOUS); |
2174 | } |
2175 | return rc; |
2176 | } |
2177 | |
2178 | /* destructor for json_each virtual table */ |
2179 | static int jsonEachDisconnect(sqlite3_vtab *pVtab){ |
2180 | sqlite3_free(pVtab); |
2181 | return SQLITE_OK; |
2182 | } |
2183 | |
2184 | /* constructor for a JsonEachCursor object for json_each(). */ |
2185 | static int jsonEachOpenEach(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ |
2186 | JsonEachCursor *pCur; |
2187 | |
2188 | UNUSED_PARAMETER(p); |
2189 | pCur = sqlite3_malloc( sizeof(*pCur) ); |
2190 | if( pCur==0 ) return SQLITE_NOMEM; |
2191 | memset(pCur, 0, sizeof(*pCur)); |
2192 | *ppCursor = &pCur->base; |
2193 | return SQLITE_OK; |
2194 | } |
2195 | |
2196 | /* constructor for a JsonEachCursor object for json_tree(). */ |
2197 | static int jsonEachOpenTree(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ |
2198 | int rc = jsonEachOpenEach(p, ppCursor); |
2199 | if( rc==SQLITE_OK ){ |
2200 | JsonEachCursor *pCur = (JsonEachCursor*)*ppCursor; |
2201 | pCur->bRecursive = 1; |
2202 | } |
2203 | return rc; |
2204 | } |
2205 | |
2206 | /* Reset a JsonEachCursor back to its original state. Free any memory |
2207 | ** held. */ |
2208 | static void jsonEachCursorReset(JsonEachCursor *p){ |
2209 | sqlite3_free(p->zJson); |
2210 | sqlite3_free(p->zRoot); |
2211 | jsonParseReset(&p->sParse); |
2212 | p->iRowid = 0; |
2213 | p->i = 0; |
2214 | p->iEnd = 0; |
2215 | p->eType = 0; |
2216 | p->zJson = 0; |
2217 | p->zRoot = 0; |
2218 | } |
2219 | |
2220 | /* Destructor for a jsonEachCursor object */ |
2221 | static int jsonEachClose(sqlite3_vtab_cursor *cur){ |
2222 | JsonEachCursor *p = (JsonEachCursor*)cur; |
2223 | jsonEachCursorReset(p); |
2224 | sqlite3_free(cur); |
2225 | return SQLITE_OK; |
2226 | } |
2227 | |
2228 | /* Return TRUE if the jsonEachCursor object has been advanced off the end |
2229 | ** of the JSON object */ |
2230 | static int jsonEachEof(sqlite3_vtab_cursor *cur){ |
2231 | JsonEachCursor *p = (JsonEachCursor*)cur; |
2232 | return p->i >= p->iEnd; |
2233 | } |
2234 | |
2235 | /* Advance the cursor to the next element for json_tree() */ |
2236 | static int jsonEachNext(sqlite3_vtab_cursor *cur){ |
2237 | JsonEachCursor *p = (JsonEachCursor*)cur; |
2238 | if( p->bRecursive ){ |
2239 | if( p->sParse.aNode[p->i].jnFlags & JNODE_LABEL ) p->i++; |
2240 | p->i++; |
2241 | p->iRowid++; |
2242 | if( p->i<p->iEnd ){ |
2243 | u32 iUp = p->sParse.aUp[p->i]; |
2244 | JsonNode *pUp = &p->sParse.aNode[iUp]; |
2245 | p->eType = pUp->eType; |
2246 | if( pUp->eType==JSON_ARRAY ){ |
2247 | assert( pUp->eU==0 || pUp->eU==3 ); |
2248 | testcase( pUp->eU==3 ); |
2249 | VVA( pUp->eU = 3 ); |
2250 | if( iUp==p->i-1 ){ |
2251 | pUp->u.iKey = 0; |
2252 | }else{ |
2253 | pUp->u.iKey++; |
2254 | } |
2255 | } |
2256 | } |
2257 | }else{ |
2258 | switch( p->eType ){ |
2259 | case JSON_ARRAY: { |
2260 | p->i += jsonNodeSize(&p->sParse.aNode[p->i]); |
2261 | p->iRowid++; |
2262 | break; |
2263 | } |
2264 | case JSON_OBJECT: { |
2265 | p->i += 1 + jsonNodeSize(&p->sParse.aNode[p->i+1]); |
2266 | p->iRowid++; |
2267 | break; |
2268 | } |
2269 | default: { |
2270 | p->i = p->iEnd; |
2271 | break; |
2272 | } |
2273 | } |
2274 | } |
2275 | return SQLITE_OK; |
2276 | } |
2277 | |
2278 | /* Append an object label to the JSON Path being constructed |
2279 | ** in pStr. |
2280 | */ |
2281 | static void jsonAppendObjectPathElement( |
2282 | JsonString *pStr, |
2283 | JsonNode *pNode |
2284 | ){ |
2285 | int jj, nn; |
2286 | const char *z; |
2287 | assert( pNode->eType==JSON_STRING ); |
2288 | assert( pNode->jnFlags & JNODE_LABEL ); |
2289 | assert( pNode->eU==1 ); |
2290 | z = pNode->u.zJContent; |
2291 | nn = pNode->n; |
2292 | assert( nn>=2 ); |
2293 | assert( z[0]=='"' ); |
2294 | assert( z[nn-1]=='"' ); |
2295 | if( nn>2 && sqlite3Isalpha(z[1]) ){ |
2296 | for(jj=2; jj<nn-1 && sqlite3Isalnum(z[jj]); jj++){} |
2297 | if( jj==nn-1 ){ |
2298 | z++; |
2299 | nn -= 2; |
2300 | } |
2301 | } |
2302 | jsonPrintf(nn+2, pStr, ".%.*s" , nn, z); |
2303 | } |
2304 | |
2305 | /* Append the name of the path for element i to pStr |
2306 | */ |
2307 | static void jsonEachComputePath( |
2308 | JsonEachCursor *p, /* The cursor */ |
2309 | JsonString *pStr, /* Write the path here */ |
2310 | u32 i /* Path to this element */ |
2311 | ){ |
2312 | JsonNode *pNode, *pUp; |
2313 | u32 iUp; |
2314 | if( i==0 ){ |
2315 | jsonAppendChar(pStr, '$'); |
2316 | return; |
2317 | } |
2318 | iUp = p->sParse.aUp[i]; |
2319 | jsonEachComputePath(p, pStr, iUp); |
2320 | pNode = &p->sParse.aNode[i]; |
2321 | pUp = &p->sParse.aNode[iUp]; |
2322 | if( pUp->eType==JSON_ARRAY ){ |
2323 | assert( pUp->eU==3 || (pUp->eU==0 && pUp->u.iKey==0) ); |
2324 | testcase( pUp->eU==0 ); |
2325 | jsonPrintf(30, pStr, "[%d]" , pUp->u.iKey); |
2326 | }else{ |
2327 | assert( pUp->eType==JSON_OBJECT ); |
2328 | if( (pNode->jnFlags & JNODE_LABEL)==0 ) pNode--; |
2329 | jsonAppendObjectPathElement(pStr, pNode); |
2330 | } |
2331 | } |
2332 | |
2333 | /* Return the value of a column */ |
2334 | static int jsonEachColumn( |
2335 | sqlite3_vtab_cursor *cur, /* The cursor */ |
2336 | sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ |
2337 | int i /* Which column to return */ |
2338 | ){ |
2339 | JsonEachCursor *p = (JsonEachCursor*)cur; |
2340 | JsonNode *pThis = &p->sParse.aNode[p->i]; |
2341 | switch( i ){ |
2342 | case JEACH_KEY: { |
2343 | if( p->i==0 ) break; |
2344 | if( p->eType==JSON_OBJECT ){ |
2345 | jsonReturn(pThis, ctx, 0); |
2346 | }else if( p->eType==JSON_ARRAY ){ |
2347 | u32 iKey; |
2348 | if( p->bRecursive ){ |
2349 | if( p->iRowid==0 ) break; |
2350 | assert( p->sParse.aNode[p->sParse.aUp[p->i]].eU==3 ); |
2351 | iKey = p->sParse.aNode[p->sParse.aUp[p->i]].u.iKey; |
2352 | }else{ |
2353 | iKey = p->iRowid; |
2354 | } |
2355 | sqlite3_result_int64(ctx, (sqlite3_int64)iKey); |
2356 | } |
2357 | break; |
2358 | } |
2359 | case JEACH_VALUE: { |
2360 | if( pThis->jnFlags & JNODE_LABEL ) pThis++; |
2361 | jsonReturn(pThis, ctx, 0); |
2362 | break; |
2363 | } |
2364 | case JEACH_TYPE: { |
2365 | if( pThis->jnFlags & JNODE_LABEL ) pThis++; |
2366 | sqlite3_result_text(ctx, jsonType[pThis->eType], -1, SQLITE_STATIC); |
2367 | break; |
2368 | } |
2369 | case JEACH_ATOM: { |
2370 | if( pThis->jnFlags & JNODE_LABEL ) pThis++; |
2371 | if( pThis->eType>=JSON_ARRAY ) break; |
2372 | jsonReturn(pThis, ctx, 0); |
2373 | break; |
2374 | } |
2375 | case JEACH_ID: { |
2376 | sqlite3_result_int64(ctx, |
2377 | (sqlite3_int64)p->i + ((pThis->jnFlags & JNODE_LABEL)!=0)); |
2378 | break; |
2379 | } |
2380 | case JEACH_PARENT: { |
2381 | if( p->i>p->iBegin && p->bRecursive ){ |
2382 | sqlite3_result_int64(ctx, (sqlite3_int64)p->sParse.aUp[p->i]); |
2383 | } |
2384 | break; |
2385 | } |
2386 | case JEACH_FULLKEY: { |
2387 | JsonString x; |
2388 | jsonInit(&x, ctx); |
2389 | if( p->bRecursive ){ |
2390 | jsonEachComputePath(p, &x, p->i); |
2391 | }else{ |
2392 | if( p->zRoot ){ |
2393 | jsonAppendRaw(&x, p->zRoot, (int)strlen(p->zRoot)); |
2394 | }else{ |
2395 | jsonAppendChar(&x, '$'); |
2396 | } |
2397 | if( p->eType==JSON_ARRAY ){ |
2398 | jsonPrintf(30, &x, "[%d]" , p->iRowid); |
2399 | }else if( p->eType==JSON_OBJECT ){ |
2400 | jsonAppendObjectPathElement(&x, pThis); |
2401 | } |
2402 | } |
2403 | jsonResult(&x); |
2404 | break; |
2405 | } |
2406 | case JEACH_PATH: { |
2407 | if( p->bRecursive ){ |
2408 | JsonString x; |
2409 | jsonInit(&x, ctx); |
2410 | jsonEachComputePath(p, &x, p->sParse.aUp[p->i]); |
2411 | jsonResult(&x); |
2412 | break; |
2413 | } |
2414 | /* For json_each() path and root are the same so fall through |
2415 | ** into the root case */ |
2416 | /* no break */ deliberate_fall_through |
2417 | } |
2418 | default: { |
2419 | const char *zRoot = p->zRoot; |
2420 | if( zRoot==0 ) zRoot = "$" ; |
2421 | sqlite3_result_text(ctx, zRoot, -1, SQLITE_STATIC); |
2422 | break; |
2423 | } |
2424 | case JEACH_JSON: { |
2425 | assert( i==JEACH_JSON ); |
2426 | sqlite3_result_text(ctx, p->sParse.zJson, -1, SQLITE_STATIC); |
2427 | break; |
2428 | } |
2429 | } |
2430 | return SQLITE_OK; |
2431 | } |
2432 | |
2433 | /* Return the current rowid value */ |
2434 | static int jsonEachRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ |
2435 | JsonEachCursor *p = (JsonEachCursor*)cur; |
2436 | *pRowid = p->iRowid; |
2437 | return SQLITE_OK; |
2438 | } |
2439 | |
2440 | /* The query strategy is to look for an equality constraint on the json |
2441 | ** column. Without such a constraint, the table cannot operate. idxNum is |
2442 | ** 1 if the constraint is found, 3 if the constraint and zRoot are found, |
2443 | ** and 0 otherwise. |
2444 | */ |
2445 | static int jsonEachBestIndex( |
2446 | sqlite3_vtab *tab, |
2447 | sqlite3_index_info *pIdxInfo |
2448 | ){ |
2449 | int i; /* Loop counter or computed array index */ |
2450 | int aIdx[2]; /* Index of constraints for JSON and ROOT */ |
2451 | int unusableMask = 0; /* Mask of unusable JSON and ROOT constraints */ |
2452 | int idxMask = 0; /* Mask of usable == constraints JSON and ROOT */ |
2453 | const struct sqlite3_index_constraint *pConstraint; |
2454 | |
2455 | /* This implementation assumes that JSON and ROOT are the last two |
2456 | ** columns in the table */ |
2457 | assert( JEACH_ROOT == JEACH_JSON+1 ); |
2458 | UNUSED_PARAMETER(tab); |
2459 | aIdx[0] = aIdx[1] = -1; |
2460 | pConstraint = pIdxInfo->aConstraint; |
2461 | for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){ |
2462 | int iCol; |
2463 | int iMask; |
2464 | if( pConstraint->iColumn < JEACH_JSON ) continue; |
2465 | iCol = pConstraint->iColumn - JEACH_JSON; |
2466 | assert( iCol==0 || iCol==1 ); |
2467 | testcase( iCol==0 ); |
2468 | iMask = 1 << iCol; |
2469 | if( pConstraint->usable==0 ){ |
2470 | unusableMask |= iMask; |
2471 | }else if( pConstraint->op==SQLITE_INDEX_CONSTRAINT_EQ ){ |
2472 | aIdx[iCol] = i; |
2473 | idxMask |= iMask; |
2474 | } |
2475 | } |
2476 | if( (unusableMask & ~idxMask)!=0 ){ |
2477 | /* If there are any unusable constraints on JSON or ROOT, then reject |
2478 | ** this entire plan */ |
2479 | return SQLITE_CONSTRAINT; |
2480 | } |
2481 | if( aIdx[0]<0 ){ |
2482 | /* No JSON input. Leave estimatedCost at the huge value that it was |
2483 | ** initialized to to discourage the query planner from selecting this |
2484 | ** plan. */ |
2485 | pIdxInfo->idxNum = 0; |
2486 | }else{ |
2487 | pIdxInfo->estimatedCost = 1.0; |
2488 | i = aIdx[0]; |
2489 | pIdxInfo->aConstraintUsage[i].argvIndex = 1; |
2490 | pIdxInfo->aConstraintUsage[i].omit = 1; |
2491 | if( aIdx[1]<0 ){ |
2492 | pIdxInfo->idxNum = 1; /* Only JSON supplied. Plan 1 */ |
2493 | }else{ |
2494 | i = aIdx[1]; |
2495 | pIdxInfo->aConstraintUsage[i].argvIndex = 2; |
2496 | pIdxInfo->aConstraintUsage[i].omit = 1; |
2497 | pIdxInfo->idxNum = 3; /* Both JSON and ROOT are supplied. Plan 3 */ |
2498 | } |
2499 | } |
2500 | return SQLITE_OK; |
2501 | } |
2502 | |
2503 | /* Start a search on a new JSON string */ |
2504 | static int jsonEachFilter( |
2505 | sqlite3_vtab_cursor *cur, |
2506 | int idxNum, const char *idxStr, |
2507 | int argc, sqlite3_value **argv |
2508 | ){ |
2509 | JsonEachCursor *p = (JsonEachCursor*)cur; |
2510 | const char *z; |
2511 | const char *zRoot = 0; |
2512 | sqlite3_int64 n; |
2513 | |
2514 | UNUSED_PARAMETER(idxStr); |
2515 | UNUSED_PARAMETER(argc); |
2516 | jsonEachCursorReset(p); |
2517 | if( idxNum==0 ) return SQLITE_OK; |
2518 | z = (const char*)sqlite3_value_text(argv[0]); |
2519 | if( z==0 ) return SQLITE_OK; |
2520 | n = sqlite3_value_bytes(argv[0]); |
2521 | p->zJson = sqlite3_malloc64( n+1 ); |
2522 | if( p->zJson==0 ) return SQLITE_NOMEM; |
2523 | memcpy(p->zJson, z, (size_t)n+1); |
2524 | if( jsonParse(&p->sParse, 0, p->zJson) ){ |
2525 | int rc = SQLITE_NOMEM; |
2526 | if( p->sParse.oom==0 ){ |
2527 | sqlite3_free(cur->pVtab->zErrMsg); |
2528 | cur->pVtab->zErrMsg = sqlite3_mprintf("malformed JSON" ); |
2529 | if( cur->pVtab->zErrMsg ) rc = SQLITE_ERROR; |
2530 | } |
2531 | jsonEachCursorReset(p); |
2532 | return rc; |
2533 | }else if( p->bRecursive && jsonParseFindParents(&p->sParse) ){ |
2534 | jsonEachCursorReset(p); |
2535 | return SQLITE_NOMEM; |
2536 | }else{ |
2537 | JsonNode *pNode = 0; |
2538 | if( idxNum==3 ){ |
2539 | const char *zErr = 0; |
2540 | zRoot = (const char*)sqlite3_value_text(argv[1]); |
2541 | if( zRoot==0 ) return SQLITE_OK; |
2542 | n = sqlite3_value_bytes(argv[1]); |
2543 | p->zRoot = sqlite3_malloc64( n+1 ); |
2544 | if( p->zRoot==0 ) return SQLITE_NOMEM; |
2545 | memcpy(p->zRoot, zRoot, (size_t)n+1); |
2546 | if( zRoot[0]!='$' ){ |
2547 | zErr = zRoot; |
2548 | }else{ |
2549 | pNode = jsonLookupStep(&p->sParse, 0, p->zRoot+1, 0, &zErr); |
2550 | } |
2551 | if( zErr ){ |
2552 | sqlite3_free(cur->pVtab->zErrMsg); |
2553 | cur->pVtab->zErrMsg = jsonPathSyntaxError(zErr); |
2554 | jsonEachCursorReset(p); |
2555 | return cur->pVtab->zErrMsg ? SQLITE_ERROR : SQLITE_NOMEM; |
2556 | }else if( pNode==0 ){ |
2557 | return SQLITE_OK; |
2558 | } |
2559 | }else{ |
2560 | pNode = p->sParse.aNode; |
2561 | } |
2562 | p->iBegin = p->i = (int)(pNode - p->sParse.aNode); |
2563 | p->eType = pNode->eType; |
2564 | if( p->eType>=JSON_ARRAY ){ |
2565 | assert( pNode->eU==0 ); |
2566 | VVA( pNode->eU = 3 ); |
2567 | pNode->u.iKey = 0; |
2568 | p->iEnd = p->i + pNode->n + 1; |
2569 | if( p->bRecursive ){ |
2570 | p->eType = p->sParse.aNode[p->sParse.aUp[p->i]].eType; |
2571 | if( p->i>0 && (p->sParse.aNode[p->i-1].jnFlags & JNODE_LABEL)!=0 ){ |
2572 | p->i--; |
2573 | } |
2574 | }else{ |
2575 | p->i++; |
2576 | } |
2577 | }else{ |
2578 | p->iEnd = p->i+1; |
2579 | } |
2580 | } |
2581 | return SQLITE_OK; |
2582 | } |
2583 | |
2584 | /* The methods of the json_each virtual table */ |
2585 | static sqlite3_module jsonEachModule = { |
2586 | 0, /* iVersion */ |
2587 | 0, /* xCreate */ |
2588 | jsonEachConnect, /* xConnect */ |
2589 | jsonEachBestIndex, /* xBestIndex */ |
2590 | jsonEachDisconnect, /* xDisconnect */ |
2591 | 0, /* xDestroy */ |
2592 | jsonEachOpenEach, /* xOpen - open a cursor */ |
2593 | jsonEachClose, /* xClose - close a cursor */ |
2594 | jsonEachFilter, /* xFilter - configure scan constraints */ |
2595 | jsonEachNext, /* xNext - advance a cursor */ |
2596 | jsonEachEof, /* xEof - check for end of scan */ |
2597 | jsonEachColumn, /* xColumn - read data */ |
2598 | jsonEachRowid, /* xRowid - read data */ |
2599 | 0, /* xUpdate */ |
2600 | 0, /* xBegin */ |
2601 | 0, /* xSync */ |
2602 | 0, /* xCommit */ |
2603 | 0, /* xRollback */ |
2604 | 0, /* xFindMethod */ |
2605 | 0, /* xRename */ |
2606 | 0, /* xSavepoint */ |
2607 | 0, /* xRelease */ |
2608 | 0, /* xRollbackTo */ |
2609 | 0 /* xShadowName */ |
2610 | }; |
2611 | |
2612 | /* The methods of the json_tree virtual table. */ |
2613 | static sqlite3_module jsonTreeModule = { |
2614 | 0, /* iVersion */ |
2615 | 0, /* xCreate */ |
2616 | jsonEachConnect, /* xConnect */ |
2617 | jsonEachBestIndex, /* xBestIndex */ |
2618 | jsonEachDisconnect, /* xDisconnect */ |
2619 | 0, /* xDestroy */ |
2620 | jsonEachOpenTree, /* xOpen - open a cursor */ |
2621 | jsonEachClose, /* xClose - close a cursor */ |
2622 | jsonEachFilter, /* xFilter - configure scan constraints */ |
2623 | jsonEachNext, /* xNext - advance a cursor */ |
2624 | jsonEachEof, /* xEof - check for end of scan */ |
2625 | jsonEachColumn, /* xColumn - read data */ |
2626 | jsonEachRowid, /* xRowid - read data */ |
2627 | 0, /* xUpdate */ |
2628 | 0, /* xBegin */ |
2629 | 0, /* xSync */ |
2630 | 0, /* xCommit */ |
2631 | 0, /* xRollback */ |
2632 | 0, /* xFindMethod */ |
2633 | 0, /* xRename */ |
2634 | 0, /* xSavepoint */ |
2635 | 0, /* xRelease */ |
2636 | 0, /* xRollbackTo */ |
2637 | 0 /* xShadowName */ |
2638 | }; |
2639 | #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
2640 | #endif /* !defined(SQLITE_OMIT_JSON) */ |
2641 | |
2642 | /* |
2643 | ** Register JSON functions. |
2644 | */ |
2645 | void sqlite3RegisterJsonFunctions(void){ |
2646 | #ifndef SQLITE_OMIT_JSON |
2647 | static FuncDef aJsonFunc[] = { |
2648 | JFUNCTION(json, 1, 0, jsonRemoveFunc), |
2649 | JFUNCTION(json_array, -1, 0, jsonArrayFunc), |
2650 | JFUNCTION(json_array_length, 1, 0, jsonArrayLengthFunc), |
2651 | JFUNCTION(json_array_length, 2, 0, jsonArrayLengthFunc), |
2652 | JFUNCTION(json_extract, -1, 0, jsonExtractFunc), |
2653 | JFUNCTION(->, 2, JSON_JSON, jsonExtractFunc), |
2654 | JFUNCTION(->>, 2, JSON_SQL, jsonExtractFunc), |
2655 | JFUNCTION(json_insert, -1, 0, jsonSetFunc), |
2656 | JFUNCTION(json_object, -1, 0, jsonObjectFunc), |
2657 | JFUNCTION(json_patch, 2, 0, jsonPatchFunc), |
2658 | JFUNCTION(json_quote, 1, 0, jsonQuoteFunc), |
2659 | JFUNCTION(json_remove, -1, 0, jsonRemoveFunc), |
2660 | JFUNCTION(json_replace, -1, 0, jsonReplaceFunc), |
2661 | JFUNCTION(json_set, -1, JSON_ISSET, jsonSetFunc), |
2662 | JFUNCTION(json_type, 1, 0, jsonTypeFunc), |
2663 | JFUNCTION(json_type, 2, 0, jsonTypeFunc), |
2664 | JFUNCTION(json_valid, 1, 0, jsonValidFunc), |
2665 | #if SQLITE_DEBUG |
2666 | JFUNCTION(json_parse, 1, 0, jsonParseFunc), |
2667 | JFUNCTION(json_test1, 1, 0, jsonTest1Func), |
2668 | #endif |
2669 | WAGGREGATE(json_group_array, 1, 0, 0, |
2670 | jsonArrayStep, jsonArrayFinal, jsonArrayValue, jsonGroupInverse, |
2671 | SQLITE_SUBTYPE|SQLITE_UTF8|SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS), |
2672 | WAGGREGATE(json_group_object, 2, 0, 0, |
2673 | jsonObjectStep, jsonObjectFinal, jsonObjectValue, jsonGroupInverse, |
2674 | SQLITE_SUBTYPE|SQLITE_UTF8|SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS) |
2675 | }; |
2676 | sqlite3InsertBuiltinFuncs(aJsonFunc, ArraySize(aJsonFunc)); |
2677 | #endif |
2678 | } |
2679 | |
2680 | #if !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_JSON) |
2681 | /* |
2682 | ** Register the JSON table-valued functions |
2683 | */ |
2684 | int sqlite3JsonTableFunctions(sqlite3 *db){ |
2685 | int rc = SQLITE_OK; |
2686 | static const struct { |
2687 | const char *zName; |
2688 | sqlite3_module *pModule; |
2689 | } aMod[] = { |
2690 | { "json_each" , &jsonEachModule }, |
2691 | { "json_tree" , &jsonTreeModule }, |
2692 | }; |
2693 | unsigned int i; |
2694 | for(i=0; i<sizeof(aMod)/sizeof(aMod[0]) && rc==SQLITE_OK; i++){ |
2695 | rc = sqlite3_create_module(db, aMod[i].zName, aMod[i].pModule, 0); |
2696 | } |
2697 | return rc; |
2698 | } |
2699 | #endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_JSON) */ |
2700 | |