blob: 327ad5750038dc9274e8cb921bf4f77d16d72cdc [file] [log] [blame]
drh5fa5c102015-08-12 16:49:40 +00001/*
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 extension implements JSON functions. The interface is
14** modeled after MySQL JSON functions:
15**
16** https://dev.mysql.com/doc/refman/5.7/en/json.html
17**
drh5634cc02015-08-17 11:28:03 +000018** 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
drhcb6c6c62015-08-19 22:47:17 +000020** 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.)
drh5fa5c102015-08-12 16:49:40 +000023*/
drh50065652015-10-08 19:29:18 +000024#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_JSON1)
drhf2df7e72015-08-28 20:07:40 +000025#if !defined(_SQLITEINT_H_)
drh5fa5c102015-08-12 16:49:40 +000026#include "sqlite3ext.h"
drhf2df7e72015-08-28 20:07:40 +000027#endif
drh5fa5c102015-08-12 16:49:40 +000028SQLITE_EXTENSION_INIT1
29#include <assert.h>
30#include <string.h>
drh987eb1f2015-08-17 15:17:37 +000031#include <stdlib.h>
drh4af352d2015-08-21 20:02:48 +000032#include <stdarg.h>
drh5fa5c102015-08-12 16:49:40 +000033
drhdf3a9072016-02-11 15:37:18 +000034/* Mark a function parameter as unused, to suppress nuisance compiler
35** warnings. */
36#ifndef UNUSED_PARAM
37# define UNUSED_PARAM(X) (void)(X)
38#endif
drh6fd5c1e2015-08-21 20:37:12 +000039
drh8deb4b82015-10-09 18:21:43 +000040#ifndef LARGEST_INT64
41# define LARGEST_INT64 (0xffffffff|(((sqlite3_int64)0x7fffffff)<<32))
42# define SMALLEST_INT64 (((sqlite3_int64)-1) - LARGEST_INT64)
43#endif
44
dan2e8f5512015-09-17 17:21:09 +000045/*
46** Versions of isspace(), isalnum() and isdigit() to which it is safe
47** to pass signed char values.
48*/
drh49472652015-10-16 15:35:39 +000049#ifdef sqlite3Isdigit
50 /* Use the SQLite core versions if this routine is part of the
51 ** SQLite amalgamation */
drhad875e72016-11-07 13:37:28 +000052# define safe_isdigit(x) sqlite3Isdigit(x)
53# define safe_isalnum(x) sqlite3Isalnum(x)
54# define safe_isxdigit(x) sqlite3Isxdigit(x)
drh49472652015-10-16 15:35:39 +000055#else
56 /* Use the standard library for separate compilation */
57#include <ctype.h> /* amalgamator: keep */
drhad875e72016-11-07 13:37:28 +000058# define safe_isdigit(x) isdigit((unsigned char)(x))
59# define safe_isalnum(x) isalnum((unsigned char)(x))
60# define safe_isxdigit(x) isxdigit((unsigned char)(x))
drh49472652015-10-16 15:35:39 +000061#endif
dan2e8f5512015-09-17 17:21:09 +000062
drh95677942015-09-24 01:06:37 +000063/*
64** Growing our own isspace() routine this way is twice as fast as
65** the library isspace() function, resulting in a 7% overall performance
66** increase for the parser. (Ubuntu14.10 gcc 4.8.4 x64 with -Os).
67*/
68static const char jsonIsSpace[] = {
drhb9e8f592015-10-16 15:16:06 +000069 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0,
drh95677942015-09-24 01:06:37 +000070 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
71 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
72 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
73 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
74 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
75 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
76 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
77 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
78 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
79 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
80 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
81 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
82 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
83 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
84 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
85};
86#define safe_isspace(x) (jsonIsSpace[(unsigned char)x])
87
drh9a4718f2015-10-10 14:00:37 +000088#ifndef SQLITE_AMALGAMATION
89 /* Unsigned integer types. These are already defined in the sqliteInt.h,
90 ** but the definitions need to be repeated for separate compilation. */
91 typedef sqlite3_uint64 u64;
92 typedef unsigned int u32;
93 typedef unsigned char u8;
94#endif
drh5fa5c102015-08-12 16:49:40 +000095
drh52216ad2015-08-18 02:28:03 +000096/* Objects */
drh505ad2c2015-08-21 17:33:11 +000097typedef struct JsonString JsonString;
drh52216ad2015-08-18 02:28:03 +000098typedef struct JsonNode JsonNode;
99typedef struct JsonParse JsonParse;
100
drh5634cc02015-08-17 11:28:03 +0000101/* An instance of this object represents a JSON string
102** under construction. Really, this is a generic string accumulator
103** that can be and is used to create strings other than JSON.
drh5fa5c102015-08-12 16:49:40 +0000104*/
drh505ad2c2015-08-21 17:33:11 +0000105struct JsonString {
drh5fa5c102015-08-12 16:49:40 +0000106 sqlite3_context *pCtx; /* Function context - put error messages here */
drh5634cc02015-08-17 11:28:03 +0000107 char *zBuf; /* Append JSON content here */
drh5fa5c102015-08-12 16:49:40 +0000108 u64 nAlloc; /* Bytes of storage available in zBuf[] */
109 u64 nUsed; /* Bytes of zBuf[] currently used */
110 u8 bStatic; /* True if zBuf is static space */
drhd0960592015-08-17 21:22:32 +0000111 u8 bErr; /* True if an error has been encountered */
drh5fa5c102015-08-12 16:49:40 +0000112 char zSpace[100]; /* Initial static space */
113};
114
drhe9c37f32015-08-15 21:25:36 +0000115/* JSON type values
drhbd0621b2015-08-13 13:54:59 +0000116*/
drhe9c37f32015-08-15 21:25:36 +0000117#define JSON_NULL 0
118#define JSON_TRUE 1
119#define JSON_FALSE 2
120#define JSON_INT 3
121#define JSON_REAL 4
122#define JSON_STRING 5
123#define JSON_ARRAY 6
124#define JSON_OBJECT 7
125
drhf5ddb9c2015-09-11 00:06:41 +0000126/* The "subtype" set for JSON values */
127#define JSON_SUBTYPE 74 /* Ascii for "J" */
128
drh987eb1f2015-08-17 15:17:37 +0000129/*
130** Names of the various JSON types:
131*/
132static const char * const jsonType[] = {
133 "null", "true", "false", "integer", "real", "text", "array", "object"
134};
135
drh301eecc2015-08-17 20:14:19 +0000136/* Bit values for the JsonNode.jnFlag field
137*/
138#define JNODE_RAW 0x01 /* Content is raw, not JSON encoded */
139#define JNODE_ESCAPE 0x02 /* Content is text with \ escapes */
140#define JNODE_REMOVE 0x04 /* Do not output */
drhd0960592015-08-17 21:22:32 +0000141#define JNODE_REPLACE 0x08 /* Replace with JsonNode.iVal */
drh52216ad2015-08-18 02:28:03 +0000142#define JNODE_APPEND 0x10 /* More ARRAY/OBJECT entries at u.iAppend */
drhf5ddb9c2015-09-11 00:06:41 +0000143#define JNODE_LABEL 0x20 /* Is a label of an object */
drh301eecc2015-08-17 20:14:19 +0000144
drh987eb1f2015-08-17 15:17:37 +0000145
drhe9c37f32015-08-15 21:25:36 +0000146/* A single node of parsed JSON
147*/
drhe9c37f32015-08-15 21:25:36 +0000148struct JsonNode {
drh5634cc02015-08-17 11:28:03 +0000149 u8 eType; /* One of the JSON_ type values */
drh301eecc2015-08-17 20:14:19 +0000150 u8 jnFlags; /* JNODE flags */
drhd0960592015-08-17 21:22:32 +0000151 u8 iVal; /* Replacement value when JNODE_REPLACE */
drhe9c37f32015-08-15 21:25:36 +0000152 u32 n; /* Bytes of content, or number of sub-nodes */
drh52216ad2015-08-18 02:28:03 +0000153 union {
drh0042a972015-08-18 12:59:58 +0000154 const char *zJContent; /* Content for INT, REAL, and STRING */
155 u32 iAppend; /* More terms for ARRAY and OBJECT */
drh505ad2c2015-08-21 17:33:11 +0000156 u32 iKey; /* Key for ARRAY objects in json_tree() */
drh52216ad2015-08-18 02:28:03 +0000157 } u;
drhe9c37f32015-08-15 21:25:36 +0000158};
159
160/* A completely parsed JSON string
161*/
drhe9c37f32015-08-15 21:25:36 +0000162struct JsonParse {
163 u32 nNode; /* Number of slots of aNode[] used */
164 u32 nAlloc; /* Number of slots of aNode[] allocated */
165 JsonNode *aNode; /* Array of nodes containing the parse */
166 const char *zJson; /* Original JSON string */
drh505ad2c2015-08-21 17:33:11 +0000167 u32 *aUp; /* Index of parent of each node */
drhe9c37f32015-08-15 21:25:36 +0000168 u8 oom; /* Set to true if out of memory */
drha7714022015-08-29 00:54:49 +0000169 u8 nErr; /* Number of errors seen */
drhe9c37f32015-08-15 21:25:36 +0000170};
171
drh505ad2c2015-08-21 17:33:11 +0000172/**************************************************************************
173** Utility routines for dealing with JsonString objects
174**************************************************************************/
drh301eecc2015-08-17 20:14:19 +0000175
drh505ad2c2015-08-21 17:33:11 +0000176/* Set the JsonString object to an empty string
drh5fa5c102015-08-12 16:49:40 +0000177*/
drh505ad2c2015-08-21 17:33:11 +0000178static void jsonZero(JsonString *p){
drh5fa5c102015-08-12 16:49:40 +0000179 p->zBuf = p->zSpace;
180 p->nAlloc = sizeof(p->zSpace);
181 p->nUsed = 0;
182 p->bStatic = 1;
183}
184
drh505ad2c2015-08-21 17:33:11 +0000185/* Initialize the JsonString object
drh5fa5c102015-08-12 16:49:40 +0000186*/
drh505ad2c2015-08-21 17:33:11 +0000187static void jsonInit(JsonString *p, sqlite3_context *pCtx){
drh5fa5c102015-08-12 16:49:40 +0000188 p->pCtx = pCtx;
drhd0960592015-08-17 21:22:32 +0000189 p->bErr = 0;
drh5fa5c102015-08-12 16:49:40 +0000190 jsonZero(p);
191}
192
193
drh505ad2c2015-08-21 17:33:11 +0000194/* Free all allocated memory and reset the JsonString object back to its
drh5fa5c102015-08-12 16:49:40 +0000195** initial state.
196*/
drh505ad2c2015-08-21 17:33:11 +0000197static void jsonReset(JsonString *p){
drh5fa5c102015-08-12 16:49:40 +0000198 if( !p->bStatic ) sqlite3_free(p->zBuf);
199 jsonZero(p);
200}
201
202
203/* Report an out-of-memory (OOM) condition
204*/
drh505ad2c2015-08-21 17:33:11 +0000205static void jsonOom(JsonString *p){
drh3d1d2a92015-09-22 01:15:49 +0000206 p->bErr = 1;
207 sqlite3_result_error_nomem(p->pCtx);
208 jsonReset(p);
drh5fa5c102015-08-12 16:49:40 +0000209}
210
211/* Enlarge pJson->zBuf so that it can hold at least N more bytes.
212** Return zero on success. Return non-zero on an OOM error
213*/
drh505ad2c2015-08-21 17:33:11 +0000214static int jsonGrow(JsonString *p, u32 N){
drh301eecc2015-08-17 20:14:19 +0000215 u64 nTotal = N<p->nAlloc ? p->nAlloc*2 : p->nAlloc+N+10;
drh5fa5c102015-08-12 16:49:40 +0000216 char *zNew;
217 if( p->bStatic ){
drhd0960592015-08-17 21:22:32 +0000218 if( p->bErr ) return 1;
drh5fa5c102015-08-12 16:49:40 +0000219 zNew = sqlite3_malloc64(nTotal);
220 if( zNew==0 ){
221 jsonOom(p);
222 return SQLITE_NOMEM;
223 }
drh6fd5c1e2015-08-21 20:37:12 +0000224 memcpy(zNew, p->zBuf, (size_t)p->nUsed);
drh5fa5c102015-08-12 16:49:40 +0000225 p->zBuf = zNew;
226 p->bStatic = 0;
227 }else{
228 zNew = sqlite3_realloc64(p->zBuf, nTotal);
229 if( zNew==0 ){
230 jsonOom(p);
231 return SQLITE_NOMEM;
232 }
233 p->zBuf = zNew;
234 }
235 p->nAlloc = nTotal;
236 return SQLITE_OK;
237}
238
drh505ad2c2015-08-21 17:33:11 +0000239/* Append N bytes from zIn onto the end of the JsonString string.
drh5fa5c102015-08-12 16:49:40 +0000240*/
drh505ad2c2015-08-21 17:33:11 +0000241static void jsonAppendRaw(JsonString *p, const char *zIn, u32 N){
drh5fa5c102015-08-12 16:49:40 +0000242 if( (N+p->nUsed >= p->nAlloc) && jsonGrow(p,N)!=0 ) return;
243 memcpy(p->zBuf+p->nUsed, zIn, N);
244 p->nUsed += N;
245}
246
drh4af352d2015-08-21 20:02:48 +0000247/* Append formatted text (not to exceed N bytes) to the JsonString.
248*/
249static void jsonPrintf(int N, JsonString *p, const char *zFormat, ...){
250 va_list ap;
251 if( (p->nUsed + N >= p->nAlloc) && jsonGrow(p, N) ) return;
252 va_start(ap, zFormat);
253 sqlite3_vsnprintf(N, p->zBuf+p->nUsed, zFormat, ap);
254 va_end(ap);
255 p->nUsed += (int)strlen(p->zBuf+p->nUsed);
256}
257
drh5634cc02015-08-17 11:28:03 +0000258/* Append a single character
259*/
drh505ad2c2015-08-21 17:33:11 +0000260static void jsonAppendChar(JsonString *p, char c){
drh5634cc02015-08-17 11:28:03 +0000261 if( p->nUsed>=p->nAlloc && jsonGrow(p,1)!=0 ) return;
262 p->zBuf[p->nUsed++] = c;
263}
264
drh301eecc2015-08-17 20:14:19 +0000265/* Append a comma separator to the output buffer, if the previous
266** character is not '[' or '{'.
267*/
drh505ad2c2015-08-21 17:33:11 +0000268static void jsonAppendSeparator(JsonString *p){
drh301eecc2015-08-17 20:14:19 +0000269 char c;
270 if( p->nUsed==0 ) return;
271 c = p->zBuf[p->nUsed-1];
272 if( c!='[' && c!='{' ) jsonAppendChar(p, ',');
273}
274
drh505ad2c2015-08-21 17:33:11 +0000275/* Append the N-byte string in zIn to the end of the JsonString string
drh5fa5c102015-08-12 16:49:40 +0000276** under construction. Enclose the string in "..." and escape
277** any double-quotes or backslash characters contained within the
278** string.
279*/
drh505ad2c2015-08-21 17:33:11 +0000280static void jsonAppendString(JsonString *p, const char *zIn, u32 N){
drh5fa5c102015-08-12 16:49:40 +0000281 u32 i;
282 if( (N+p->nUsed+2 >= p->nAlloc) && jsonGrow(p,N+2)!=0 ) return;
283 p->zBuf[p->nUsed++] = '"';
284 for(i=0; i<N; i++){
drh3b7f9a62016-02-04 10:28:57 +0000285 unsigned char c = ((unsigned const char*)zIn)[i];
drh5fa5c102015-08-12 16:49:40 +0000286 if( c=='"' || c=='\\' ){
drh3b7f9a62016-02-04 10:28:57 +0000287 json_simple_escape:
drh4977ccf2015-09-19 11:57:26 +0000288 if( (p->nUsed+N+3-i > p->nAlloc) && jsonGrow(p,N+3-i)!=0 ) return;
drh5fa5c102015-08-12 16:49:40 +0000289 p->zBuf[p->nUsed++] = '\\';
drh3b7f9a62016-02-04 10:28:57 +0000290 }else if( c<=0x1f ){
291 static const char aSpecial[] = {
292 0, 0, 0, 0, 0, 0, 0, 0, 'b', 't', 'n', 0, 'f', 'r', 0, 0,
293 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
294 };
295 assert( sizeof(aSpecial)==32 );
296 assert( aSpecial['\b']=='b' );
297 assert( aSpecial['\f']=='f' );
298 assert( aSpecial['\n']=='n' );
299 assert( aSpecial['\r']=='r' );
300 assert( aSpecial['\t']=='t' );
301 if( aSpecial[c] ){
302 c = aSpecial[c];
303 goto json_simple_escape;
304 }
305 if( (p->nUsed+N+7+i > p->nAlloc) && jsonGrow(p,N+7-i)!=0 ) return;
306 p->zBuf[p->nUsed++] = '\\';
307 p->zBuf[p->nUsed++] = 'u';
308 p->zBuf[p->nUsed++] = '0';
309 p->zBuf[p->nUsed++] = '0';
310 p->zBuf[p->nUsed++] = '0' + (c>>4);
311 c = "0123456789abcdef"[c&0xf];
drh5fa5c102015-08-12 16:49:40 +0000312 }
313 p->zBuf[p->nUsed++] = c;
314 }
315 p->zBuf[p->nUsed++] = '"';
drh4977ccf2015-09-19 11:57:26 +0000316 assert( p->nUsed<p->nAlloc );
drh5fa5c102015-08-12 16:49:40 +0000317}
318
drhd0960592015-08-17 21:22:32 +0000319/*
320** Append a function parameter value to the JSON string under
321** construction.
322*/
323static void jsonAppendValue(
drh505ad2c2015-08-21 17:33:11 +0000324 JsonString *p, /* Append to this JSON string */
drhf5ddb9c2015-09-11 00:06:41 +0000325 sqlite3_value *pValue /* Value to append */
drhd0960592015-08-17 21:22:32 +0000326){
327 switch( sqlite3_value_type(pValue) ){
328 case SQLITE_NULL: {
329 jsonAppendRaw(p, "null", 4);
330 break;
331 }
332 case SQLITE_INTEGER:
333 case SQLITE_FLOAT: {
334 const char *z = (const char*)sqlite3_value_text(pValue);
335 u32 n = (u32)sqlite3_value_bytes(pValue);
336 jsonAppendRaw(p, z, n);
337 break;
338 }
339 case SQLITE_TEXT: {
340 const char *z = (const char*)sqlite3_value_text(pValue);
341 u32 n = (u32)sqlite3_value_bytes(pValue);
drhf5ddb9c2015-09-11 00:06:41 +0000342 if( sqlite3_value_subtype(pValue)==JSON_SUBTYPE ){
drhecb5fed2015-08-28 03:33:50 +0000343 jsonAppendRaw(p, z, n);
344 }else{
345 jsonAppendString(p, z, n);
346 }
drhd0960592015-08-17 21:22:32 +0000347 break;
348 }
349 default: {
350 if( p->bErr==0 ){
351 sqlite3_result_error(p->pCtx, "JSON cannot hold BLOB values", -1);
drh4a642b62016-02-05 01:55:27 +0000352 p->bErr = 2;
drhd0960592015-08-17 21:22:32 +0000353 jsonReset(p);
354 }
355 break;
356 }
357 }
358}
359
360
drhbd0621b2015-08-13 13:54:59 +0000361/* Make the JSON in p the result of the SQL function.
drh5fa5c102015-08-12 16:49:40 +0000362*/
drh505ad2c2015-08-21 17:33:11 +0000363static void jsonResult(JsonString *p){
drhd0960592015-08-17 21:22:32 +0000364 if( p->bErr==0 ){
drh5fa5c102015-08-12 16:49:40 +0000365 sqlite3_result_text64(p->pCtx, p->zBuf, p->nUsed,
366 p->bStatic ? SQLITE_TRANSIENT : sqlite3_free,
367 SQLITE_UTF8);
368 jsonZero(p);
369 }
370 assert( p->bStatic );
371}
372
drh505ad2c2015-08-21 17:33:11 +0000373/**************************************************************************
374** Utility routines for dealing with JsonNode and JsonParse objects
375**************************************************************************/
376
377/*
378** Return the number of consecutive JsonNode slots need to represent
379** the parsed JSON at pNode. The minimum answer is 1. For ARRAY and
380** OBJECT types, the number might be larger.
381**
382** Appended elements are not counted. The value returned is the number
383** by which the JsonNode counter should increment in order to go to the
384** next peer value.
385*/
386static u32 jsonNodeSize(JsonNode *pNode){
387 return pNode->eType>=JSON_ARRAY ? pNode->n+1 : 1;
388}
389
390/*
391** Reclaim all memory allocated by a JsonParse object. But do not
392** delete the JsonParse object itself.
393*/
394static void jsonParseReset(JsonParse *pParse){
395 sqlite3_free(pParse->aNode);
396 pParse->aNode = 0;
397 pParse->nNode = 0;
398 pParse->nAlloc = 0;
399 sqlite3_free(pParse->aUp);
400 pParse->aUp = 0;
401}
402
drh5634cc02015-08-17 11:28:03 +0000403/*
404** Convert the JsonNode pNode into a pure JSON string and
405** append to pOut. Subsubstructure is also included. Return
406** the number of JsonNode objects that are encoded.
drhbd0621b2015-08-13 13:54:59 +0000407*/
drh52216ad2015-08-18 02:28:03 +0000408static void jsonRenderNode(
drhd0960592015-08-17 21:22:32 +0000409 JsonNode *pNode, /* The node to render */
drh505ad2c2015-08-21 17:33:11 +0000410 JsonString *pOut, /* Write JSON here */
drhd0960592015-08-17 21:22:32 +0000411 sqlite3_value **aReplace /* Replacement values */
412){
drh5634cc02015-08-17 11:28:03 +0000413 switch( pNode->eType ){
drha8f39a92015-09-21 22:53:16 +0000414 default: {
415 assert( pNode->eType==JSON_NULL );
drh5634cc02015-08-17 11:28:03 +0000416 jsonAppendRaw(pOut, "null", 4);
417 break;
418 }
419 case JSON_TRUE: {
420 jsonAppendRaw(pOut, "true", 4);
421 break;
422 }
423 case JSON_FALSE: {
424 jsonAppendRaw(pOut, "false", 5);
425 break;
426 }
427 case JSON_STRING: {
drh301eecc2015-08-17 20:14:19 +0000428 if( pNode->jnFlags & JNODE_RAW ){
drh52216ad2015-08-18 02:28:03 +0000429 jsonAppendString(pOut, pNode->u.zJContent, pNode->n);
drh5634cc02015-08-17 11:28:03 +0000430 break;
431 }
432 /* Fall through into the next case */
433 }
434 case JSON_REAL:
435 case JSON_INT: {
drh52216ad2015-08-18 02:28:03 +0000436 jsonAppendRaw(pOut, pNode->u.zJContent, pNode->n);
drh5634cc02015-08-17 11:28:03 +0000437 break;
438 }
439 case JSON_ARRAY: {
drh52216ad2015-08-18 02:28:03 +0000440 u32 j = 1;
drh5634cc02015-08-17 11:28:03 +0000441 jsonAppendChar(pOut, '[');
drh52216ad2015-08-18 02:28:03 +0000442 for(;;){
443 while( j<=pNode->n ){
444 if( pNode[j].jnFlags & (JNODE_REMOVE|JNODE_REPLACE) ){
445 if( pNode[j].jnFlags & JNODE_REPLACE ){
446 jsonAppendSeparator(pOut);
drhf5ddb9c2015-09-11 00:06:41 +0000447 jsonAppendValue(pOut, aReplace[pNode[j].iVal]);
drh52216ad2015-08-18 02:28:03 +0000448 }
449 }else{
drhd0960592015-08-17 21:22:32 +0000450 jsonAppendSeparator(pOut);
drh52216ad2015-08-18 02:28:03 +0000451 jsonRenderNode(&pNode[j], pOut, aReplace);
drhd0960592015-08-17 21:22:32 +0000452 }
drh505ad2c2015-08-21 17:33:11 +0000453 j += jsonNodeSize(&pNode[j]);
drh301eecc2015-08-17 20:14:19 +0000454 }
drh52216ad2015-08-18 02:28:03 +0000455 if( (pNode->jnFlags & JNODE_APPEND)==0 ) break;
456 pNode = &pNode[pNode->u.iAppend];
457 j = 1;
drh5634cc02015-08-17 11:28:03 +0000458 }
459 jsonAppendChar(pOut, ']');
460 break;
461 }
462 case JSON_OBJECT: {
drh52216ad2015-08-18 02:28:03 +0000463 u32 j = 1;
drh5634cc02015-08-17 11:28:03 +0000464 jsonAppendChar(pOut, '{');
drh52216ad2015-08-18 02:28:03 +0000465 for(;;){
466 while( j<=pNode->n ){
467 if( (pNode[j+1].jnFlags & JNODE_REMOVE)==0 ){
468 jsonAppendSeparator(pOut);
469 jsonRenderNode(&pNode[j], pOut, aReplace);
470 jsonAppendChar(pOut, ':');
471 if( pNode[j+1].jnFlags & JNODE_REPLACE ){
drhf5ddb9c2015-09-11 00:06:41 +0000472 jsonAppendValue(pOut, aReplace[pNode[j+1].iVal]);
drh52216ad2015-08-18 02:28:03 +0000473 }else{
474 jsonRenderNode(&pNode[j+1], pOut, aReplace);
475 }
drhd0960592015-08-17 21:22:32 +0000476 }
drh505ad2c2015-08-21 17:33:11 +0000477 j += 1 + jsonNodeSize(&pNode[j+1]);
drh301eecc2015-08-17 20:14:19 +0000478 }
drh52216ad2015-08-18 02:28:03 +0000479 if( (pNode->jnFlags & JNODE_APPEND)==0 ) break;
480 pNode = &pNode[pNode->u.iAppend];
481 j = 1;
drh5634cc02015-08-17 11:28:03 +0000482 }
483 jsonAppendChar(pOut, '}');
484 break;
485 }
drhbd0621b2015-08-13 13:54:59 +0000486 }
drh5634cc02015-08-17 11:28:03 +0000487}
488
489/*
drhf2df7e72015-08-28 20:07:40 +0000490** Return a JsonNode and all its descendents as a JSON string.
491*/
492static void jsonReturnJson(
493 JsonNode *pNode, /* Node to return */
494 sqlite3_context *pCtx, /* Return value for this function */
495 sqlite3_value **aReplace /* Array of replacement values */
496){
497 JsonString s;
498 jsonInit(&s, pCtx);
499 jsonRenderNode(pNode, &s, aReplace);
500 jsonResult(&s);
drhf5ddb9c2015-09-11 00:06:41 +0000501 sqlite3_result_subtype(pCtx, JSON_SUBTYPE);
drhf2df7e72015-08-28 20:07:40 +0000502}
503
504/*
drh5634cc02015-08-17 11:28:03 +0000505** Make the JsonNode the return value of the function.
506*/
drhd0960592015-08-17 21:22:32 +0000507static void jsonReturn(
508 JsonNode *pNode, /* Node to return */
509 sqlite3_context *pCtx, /* Return value for this function */
510 sqlite3_value **aReplace /* Array of replacement values */
511){
drh5634cc02015-08-17 11:28:03 +0000512 switch( pNode->eType ){
drha8f39a92015-09-21 22:53:16 +0000513 default: {
514 assert( pNode->eType==JSON_NULL );
drh5634cc02015-08-17 11:28:03 +0000515 sqlite3_result_null(pCtx);
516 break;
517 }
518 case JSON_TRUE: {
519 sqlite3_result_int(pCtx, 1);
520 break;
521 }
522 case JSON_FALSE: {
523 sqlite3_result_int(pCtx, 0);
524 break;
525 }
drh987eb1f2015-08-17 15:17:37 +0000526 case JSON_INT: {
527 sqlite3_int64 i = 0;
drh52216ad2015-08-18 02:28:03 +0000528 const char *z = pNode->u.zJContent;
drh987eb1f2015-08-17 15:17:37 +0000529 if( z[0]=='-' ){ z++; }
drh8deb4b82015-10-09 18:21:43 +0000530 while( z[0]>='0' && z[0]<='9' ){
531 unsigned v = *(z++) - '0';
532 if( i>=LARGEST_INT64/10 ){
drha0882fa2015-10-09 20:40:44 +0000533 if( i>LARGEST_INT64/10 ) goto int_as_real;
drh8deb4b82015-10-09 18:21:43 +0000534 if( z[0]>='0' && z[0]<='9' ) goto int_as_real;
535 if( v==9 ) goto int_as_real;
536 if( v==8 ){
537 if( pNode->u.zJContent[0]=='-' ){
538 sqlite3_result_int64(pCtx, SMALLEST_INT64);
539 goto int_done;
540 }else{
541 goto int_as_real;
542 }
543 }
544 }
545 i = i*10 + v;
546 }
drh52216ad2015-08-18 02:28:03 +0000547 if( pNode->u.zJContent[0]=='-' ){ i = -i; }
drh987eb1f2015-08-17 15:17:37 +0000548 sqlite3_result_int64(pCtx, i);
drh8deb4b82015-10-09 18:21:43 +0000549 int_done:
550 break;
551 int_as_real: /* fall through to real */;
552 }
553 case JSON_REAL: {
drh49472652015-10-16 15:35:39 +0000554 double r;
555#ifdef SQLITE_AMALGAMATION
556 const char *z = pNode->u.zJContent;
557 sqlite3AtoF(z, &r, sqlite3Strlen30(z), SQLITE_UTF8);
558#else
559 r = strtod(pNode->u.zJContent, 0);
560#endif
drh8deb4b82015-10-09 18:21:43 +0000561 sqlite3_result_double(pCtx, r);
drh987eb1f2015-08-17 15:17:37 +0000562 break;
563 }
drh5634cc02015-08-17 11:28:03 +0000564 case JSON_STRING: {
drha8f39a92015-09-21 22:53:16 +0000565#if 0 /* Never happens because JNODE_RAW is only set by json_set(),
566 ** json_insert() and json_replace() and those routines do not
567 ** call jsonReturn() */
drh301eecc2015-08-17 20:14:19 +0000568 if( pNode->jnFlags & JNODE_RAW ){
drh52216ad2015-08-18 02:28:03 +0000569 sqlite3_result_text(pCtx, pNode->u.zJContent, pNode->n,
570 SQLITE_TRANSIENT);
drha8f39a92015-09-21 22:53:16 +0000571 }else
572#endif
573 assert( (pNode->jnFlags & JNODE_RAW)==0 );
574 if( (pNode->jnFlags & JNODE_ESCAPE)==0 ){
drh987eb1f2015-08-17 15:17:37 +0000575 /* JSON formatted without any backslash-escapes */
drh52216ad2015-08-18 02:28:03 +0000576 sqlite3_result_text(pCtx, pNode->u.zJContent+1, pNode->n-2,
drh987eb1f2015-08-17 15:17:37 +0000577 SQLITE_TRANSIENT);
drh5634cc02015-08-17 11:28:03 +0000578 }else{
579 /* Translate JSON formatted string into raw text */
drh987eb1f2015-08-17 15:17:37 +0000580 u32 i;
581 u32 n = pNode->n;
drh52216ad2015-08-18 02:28:03 +0000582 const char *z = pNode->u.zJContent;
drh987eb1f2015-08-17 15:17:37 +0000583 char *zOut;
584 u32 j;
585 zOut = sqlite3_malloc( n+1 );
586 if( zOut==0 ){
587 sqlite3_result_error_nomem(pCtx);
588 break;
589 }
590 for(i=1, j=0; i<n-1; i++){
591 char c = z[i];
drh80d87402015-08-24 12:42:41 +0000592 if( c!='\\' ){
drh987eb1f2015-08-17 15:17:37 +0000593 zOut[j++] = c;
594 }else{
595 c = z[++i];
drh80d87402015-08-24 12:42:41 +0000596 if( c=='u' ){
drh987eb1f2015-08-17 15:17:37 +0000597 u32 v = 0, k;
drh27b2d1b2016-11-07 15:15:42 +0000598 for(k=0; k<4; i++, k++){
599 assert( i<n-2 );
drh8784eca2015-08-23 02:42:30 +0000600 c = z[i+1];
drh27b2d1b2016-11-07 15:15:42 +0000601 assert( safe_isxdigit(c) );
602 if( c<='9' ) v = v*16 + c - '0';
603 else if( c<='F' ) v = v*16 + c - 'A' + 10;
604 else v = v*16 + c - 'a' + 10;
drh987eb1f2015-08-17 15:17:37 +0000605 }
drh80d87402015-08-24 12:42:41 +0000606 if( v==0 ) break;
drh987eb1f2015-08-17 15:17:37 +0000607 if( v<=0x7f ){
mistachkin16a93122015-09-11 18:05:01 +0000608 zOut[j++] = (char)v;
drh987eb1f2015-08-17 15:17:37 +0000609 }else if( v<=0x7ff ){
mistachkin16a93122015-09-11 18:05:01 +0000610 zOut[j++] = (char)(0xc0 | (v>>6));
drh987eb1f2015-08-17 15:17:37 +0000611 zOut[j++] = 0x80 | (v&0x3f);
drh80d87402015-08-24 12:42:41 +0000612 }else{
mistachkin16a93122015-09-11 18:05:01 +0000613 zOut[j++] = (char)(0xe0 | (v>>12));
drh987eb1f2015-08-17 15:17:37 +0000614 zOut[j++] = 0x80 | ((v>>6)&0x3f);
615 zOut[j++] = 0x80 | (v&0x3f);
drh987eb1f2015-08-17 15:17:37 +0000616 }
617 }else{
618 if( c=='b' ){
619 c = '\b';
620 }else if( c=='f' ){
621 c = '\f';
622 }else if( c=='n' ){
623 c = '\n';
624 }else if( c=='r' ){
625 c = '\r';
626 }else if( c=='t' ){
627 c = '\t';
628 }
629 zOut[j++] = c;
630 }
631 }
632 }
633 zOut[j] = 0;
634 sqlite3_result_text(pCtx, zOut, j, sqlite3_free);
drh5634cc02015-08-17 11:28:03 +0000635 }
636 break;
637 }
638 case JSON_ARRAY:
639 case JSON_OBJECT: {
drhf2df7e72015-08-28 20:07:40 +0000640 jsonReturnJson(pNode, pCtx, aReplace);
drh5634cc02015-08-17 11:28:03 +0000641 break;
642 }
643 }
drhbd0621b2015-08-13 13:54:59 +0000644}
645
drh95677942015-09-24 01:06:37 +0000646/* Forward reference */
647static int jsonParseAddNode(JsonParse*,u32,u32,const char*);
648
649/*
650** A macro to hint to the compiler that a function should not be
651** inlined.
652*/
653#if defined(__GNUC__)
654# define JSON_NOINLINE __attribute__((noinline))
655#elif defined(_MSC_VER) && _MSC_VER>=1310
656# define JSON_NOINLINE __declspec(noinline)
657#else
658# define JSON_NOINLINE
659#endif
660
661
662static JSON_NOINLINE int jsonParseAddNodeExpand(
663 JsonParse *pParse, /* Append the node to this object */
664 u32 eType, /* Node type */
665 u32 n, /* Content size or sub-node count */
666 const char *zContent /* Content */
667){
668 u32 nNew;
669 JsonNode *pNew;
670 assert( pParse->nNode>=pParse->nAlloc );
671 if( pParse->oom ) return -1;
672 nNew = pParse->nAlloc*2 + 10;
673 pNew = sqlite3_realloc(pParse->aNode, sizeof(JsonNode)*nNew);
674 if( pNew==0 ){
675 pParse->oom = 1;
676 return -1;
677 }
678 pParse->nAlloc = nNew;
679 pParse->aNode = pNew;
680 assert( pParse->nNode<pParse->nAlloc );
681 return jsonParseAddNode(pParse, eType, n, zContent);
682}
683
drh5fa5c102015-08-12 16:49:40 +0000684/*
drhe9c37f32015-08-15 21:25:36 +0000685** Create a new JsonNode instance based on the arguments and append that
686** instance to the JsonParse. Return the index in pParse->aNode[] of the
687** new node, or -1 if a memory allocation fails.
688*/
689static int jsonParseAddNode(
690 JsonParse *pParse, /* Append the node to this object */
691 u32 eType, /* Node type */
692 u32 n, /* Content size or sub-node count */
693 const char *zContent /* Content */
694){
695 JsonNode *p;
696 if( pParse->nNode>=pParse->nAlloc ){
drh95677942015-09-24 01:06:37 +0000697 return jsonParseAddNodeExpand(pParse, eType, n, zContent);
drhe9c37f32015-08-15 21:25:36 +0000698 }
699 p = &pParse->aNode[pParse->nNode];
drh5634cc02015-08-17 11:28:03 +0000700 p->eType = (u8)eType;
drh301eecc2015-08-17 20:14:19 +0000701 p->jnFlags = 0;
drhd0960592015-08-17 21:22:32 +0000702 p->iVal = 0;
drhe9c37f32015-08-15 21:25:36 +0000703 p->n = n;
drh52216ad2015-08-18 02:28:03 +0000704 p->u.zJContent = zContent;
drhe9c37f32015-08-15 21:25:36 +0000705 return pParse->nNode++;
706}
707
708/*
drhad875e72016-11-07 13:37:28 +0000709** Return true if z[] begins with 4 (or more) hexadecimal digits
710*/
711static int jsonIs4Hex(const char *z){
712 int i;
713 for(i=0; i<4; i++) if( !safe_isxdigit(z[i]) ) return 0;
714 return 1;
715}
716
717/*
drhe9c37f32015-08-15 21:25:36 +0000718** Parse a single JSON value which begins at pParse->zJson[i]. Return the
719** index of the first character past the end of the value parsed.
720**
721** Return negative for a syntax error. Special cases: return -2 if the
722** first non-whitespace character is '}' and return -3 if the first
723** non-whitespace character is ']'.
724*/
725static int jsonParseValue(JsonParse *pParse, u32 i){
726 char c;
727 u32 j;
drhbc8f0922015-08-22 19:39:04 +0000728 int iThis;
drhe9c37f32015-08-15 21:25:36 +0000729 int x;
drh852944e2015-09-10 03:29:11 +0000730 JsonNode *pNode;
dan2e8f5512015-09-17 17:21:09 +0000731 while( safe_isspace(pParse->zJson[i]) ){ i++; }
drh8cb15cc2015-09-24 01:40:45 +0000732 if( (c = pParse->zJson[i])=='{' ){
drhe9c37f32015-08-15 21:25:36 +0000733 /* Parse object */
734 iThis = jsonParseAddNode(pParse, JSON_OBJECT, 0, 0);
drhbc8f0922015-08-22 19:39:04 +0000735 if( iThis<0 ) return -1;
drhe9c37f32015-08-15 21:25:36 +0000736 for(j=i+1;;j++){
dan2e8f5512015-09-17 17:21:09 +0000737 while( safe_isspace(pParse->zJson[j]) ){ j++; }
drhe9c37f32015-08-15 21:25:36 +0000738 x = jsonParseValue(pParse, j);
739 if( x<0 ){
drhf27cd1f2015-09-23 01:10:29 +0000740 if( x==(-2) && pParse->nNode==(u32)iThis+1 ) return j+1;
drhe9c37f32015-08-15 21:25:36 +0000741 return -1;
742 }
drhbe9474e2015-08-22 03:05:54 +0000743 if( pParse->oom ) return -1;
drh852944e2015-09-10 03:29:11 +0000744 pNode = &pParse->aNode[pParse->nNode-1];
745 if( pNode->eType!=JSON_STRING ) return -1;
746 pNode->jnFlags |= JNODE_LABEL;
drhe9c37f32015-08-15 21:25:36 +0000747 j = x;
dan2e8f5512015-09-17 17:21:09 +0000748 while( safe_isspace(pParse->zJson[j]) ){ j++; }
drhe9c37f32015-08-15 21:25:36 +0000749 if( pParse->zJson[j]!=':' ) return -1;
750 j++;
751 x = jsonParseValue(pParse, j);
752 if( x<0 ) return -1;
753 j = x;
dan2e8f5512015-09-17 17:21:09 +0000754 while( safe_isspace(pParse->zJson[j]) ){ j++; }
drhe9c37f32015-08-15 21:25:36 +0000755 c = pParse->zJson[j];
756 if( c==',' ) continue;
757 if( c!='}' ) return -1;
758 break;
759 }
drhbc8f0922015-08-22 19:39:04 +0000760 pParse->aNode[iThis].n = pParse->nNode - (u32)iThis - 1;
drhe9c37f32015-08-15 21:25:36 +0000761 return j+1;
762 }else if( c=='[' ){
763 /* Parse array */
764 iThis = jsonParseAddNode(pParse, JSON_ARRAY, 0, 0);
drhbc8f0922015-08-22 19:39:04 +0000765 if( iThis<0 ) return -1;
drhe9c37f32015-08-15 21:25:36 +0000766 for(j=i+1;;j++){
dan2e8f5512015-09-17 17:21:09 +0000767 while( safe_isspace(pParse->zJson[j]) ){ j++; }
drhe9c37f32015-08-15 21:25:36 +0000768 x = jsonParseValue(pParse, j);
769 if( x<0 ){
drhf27cd1f2015-09-23 01:10:29 +0000770 if( x==(-3) && pParse->nNode==(u32)iThis+1 ) return j+1;
drhe9c37f32015-08-15 21:25:36 +0000771 return -1;
772 }
773 j = x;
dan2e8f5512015-09-17 17:21:09 +0000774 while( safe_isspace(pParse->zJson[j]) ){ j++; }
drhe9c37f32015-08-15 21:25:36 +0000775 c = pParse->zJson[j];
776 if( c==',' ) continue;
777 if( c!=']' ) return -1;
778 break;
779 }
drhbc8f0922015-08-22 19:39:04 +0000780 pParse->aNode[iThis].n = pParse->nNode - (u32)iThis - 1;
drhe9c37f32015-08-15 21:25:36 +0000781 return j+1;
782 }else if( c=='"' ){
783 /* Parse string */
drh301eecc2015-08-17 20:14:19 +0000784 u8 jnFlags = 0;
drhe9c37f32015-08-15 21:25:36 +0000785 j = i+1;
786 for(;;){
787 c = pParse->zJson[j];
788 if( c==0 ) return -1;
789 if( c=='\\' ){
790 c = pParse->zJson[++j];
drhad875e72016-11-07 13:37:28 +0000791 if( c=='"' || c=='\\' || c=='/' || c=='b' || c=='f'
792 || c=='n' || c=='r' || c=='t'
793 || (c=='u' && jsonIs4Hex(pParse->zJson+j+1)) ){
794 jnFlags = JNODE_ESCAPE;
795 }else{
796 return -1;
797 }
drhe9c37f32015-08-15 21:25:36 +0000798 }else if( c=='"' ){
799 break;
800 }
801 j++;
802 }
803 jsonParseAddNode(pParse, JSON_STRING, j+1-i, &pParse->zJson[i]);
drhbe9474e2015-08-22 03:05:54 +0000804 if( !pParse->oom ) pParse->aNode[pParse->nNode-1].jnFlags = jnFlags;
drhe9c37f32015-08-15 21:25:36 +0000805 return j+1;
806 }else if( c=='n'
807 && strncmp(pParse->zJson+i,"null",4)==0
dan2e8f5512015-09-17 17:21:09 +0000808 && !safe_isalnum(pParse->zJson[i+4]) ){
drhe9c37f32015-08-15 21:25:36 +0000809 jsonParseAddNode(pParse, JSON_NULL, 0, 0);
810 return i+4;
811 }else if( c=='t'
812 && strncmp(pParse->zJson+i,"true",4)==0
dan2e8f5512015-09-17 17:21:09 +0000813 && !safe_isalnum(pParse->zJson[i+4]) ){
drhe9c37f32015-08-15 21:25:36 +0000814 jsonParseAddNode(pParse, JSON_TRUE, 0, 0);
815 return i+4;
816 }else if( c=='f'
817 && strncmp(pParse->zJson+i,"false",5)==0
dan2e8f5512015-09-17 17:21:09 +0000818 && !safe_isalnum(pParse->zJson[i+5]) ){
drhe9c37f32015-08-15 21:25:36 +0000819 jsonParseAddNode(pParse, JSON_FALSE, 0, 0);
820 return i+5;
821 }else if( c=='-' || (c>='0' && c<='9') ){
822 /* Parse number */
823 u8 seenDP = 0;
824 u8 seenE = 0;
825 j = i+1;
826 for(;; j++){
827 c = pParse->zJson[j];
828 if( c>='0' && c<='9' ) continue;
829 if( c=='.' ){
830 if( pParse->zJson[j-1]=='-' ) return -1;
831 if( seenDP ) return -1;
832 seenDP = 1;
833 continue;
834 }
835 if( c=='e' || c=='E' ){
836 if( pParse->zJson[j-1]<'0' ) return -1;
837 if( seenE ) return -1;
838 seenDP = seenE = 1;
839 c = pParse->zJson[j+1];
drh8784eca2015-08-23 02:42:30 +0000840 if( c=='+' || c=='-' ){
841 j++;
842 c = pParse->zJson[j+1];
843 }
drhd1f00682015-08-29 16:02:37 +0000844 if( c<'0' || c>'9' ) return -1;
drhe9c37f32015-08-15 21:25:36 +0000845 continue;
846 }
847 break;
848 }
849 if( pParse->zJson[j-1]<'0' ) return -1;
850 jsonParseAddNode(pParse, seenDP ? JSON_REAL : JSON_INT,
851 j - i, &pParse->zJson[i]);
852 return j;
853 }else if( c=='}' ){
854 return -2; /* End of {...} */
855 }else if( c==']' ){
856 return -3; /* End of [...] */
drh8cb15cc2015-09-24 01:40:45 +0000857 }else if( c==0 ){
858 return 0; /* End of file */
drhe9c37f32015-08-15 21:25:36 +0000859 }else{
860 return -1; /* Syntax error */
861 }
862}
863
864/*
865** Parse a complete JSON string. Return 0 on success or non-zero if there
866** are any errors. If an error occurs, free all memory associated with
867** pParse.
868**
869** pParse is uninitialized when this routine is called.
870*/
drhbc8f0922015-08-22 19:39:04 +0000871static int jsonParse(
872 JsonParse *pParse, /* Initialize and fill this JsonParse object */
873 sqlite3_context *pCtx, /* Report errors here */
874 const char *zJson /* Input JSON text to be parsed */
875){
drhe9c37f32015-08-15 21:25:36 +0000876 int i;
drhe9c37f32015-08-15 21:25:36 +0000877 memset(pParse, 0, sizeof(*pParse));
drhc3722b22015-08-23 20:44:59 +0000878 if( zJson==0 ) return 1;
drhe9c37f32015-08-15 21:25:36 +0000879 pParse->zJson = zJson;
880 i = jsonParseValue(pParse, 0);
drhc3722b22015-08-23 20:44:59 +0000881 if( pParse->oom ) i = -1;
drhe9c37f32015-08-15 21:25:36 +0000882 if( i>0 ){
dan2e8f5512015-09-17 17:21:09 +0000883 while( safe_isspace(zJson[i]) ) i++;
drhe9c37f32015-08-15 21:25:36 +0000884 if( zJson[i] ) i = -1;
885 }
drhd1f00682015-08-29 16:02:37 +0000886 if( i<=0 ){
drhf2df7e72015-08-28 20:07:40 +0000887 if( pCtx!=0 ){
888 if( pParse->oom ){
889 sqlite3_result_error_nomem(pCtx);
890 }else{
891 sqlite3_result_error(pCtx, "malformed JSON", -1);
892 }
893 }
drh505ad2c2015-08-21 17:33:11 +0000894 jsonParseReset(pParse);
drhe9c37f32015-08-15 21:25:36 +0000895 return 1;
896 }
897 return 0;
898}
drh301eecc2015-08-17 20:14:19 +0000899
drh505ad2c2015-08-21 17:33:11 +0000900/* Mark node i of pParse as being a child of iParent. Call recursively
901** to fill in all the descendants of node i.
902*/
903static void jsonParseFillInParentage(JsonParse *pParse, u32 i, u32 iParent){
904 JsonNode *pNode = &pParse->aNode[i];
905 u32 j;
906 pParse->aUp[i] = iParent;
907 switch( pNode->eType ){
908 case JSON_ARRAY: {
909 for(j=1; j<=pNode->n; j += jsonNodeSize(pNode+j)){
910 jsonParseFillInParentage(pParse, i+j, i);
911 }
912 break;
913 }
914 case JSON_OBJECT: {
915 for(j=1; j<=pNode->n; j += jsonNodeSize(pNode+j+1)+1){
916 pParse->aUp[i+j] = i;
917 jsonParseFillInParentage(pParse, i+j+1, i);
918 }
919 break;
920 }
921 default: {
922 break;
923 }
924 }
925}
926
927/*
928** Compute the parentage of all nodes in a completed parse.
929*/
930static int jsonParseFindParents(JsonParse *pParse){
931 u32 *aUp;
932 assert( pParse->aUp==0 );
933 aUp = pParse->aUp = sqlite3_malloc( sizeof(u32)*pParse->nNode );
drhc3722b22015-08-23 20:44:59 +0000934 if( aUp==0 ){
935 pParse->oom = 1;
936 return SQLITE_NOMEM;
937 }
drh505ad2c2015-08-21 17:33:11 +0000938 jsonParseFillInParentage(pParse, 0, 0);
939 return SQLITE_OK;
940}
941
drh8cb0c832015-09-22 00:21:03 +0000942/*
943** Compare the OBJECT label at pNode against zKey,nKey. Return true on
944** a match.
945*/
mistachkinf2c26ed2015-10-12 22:20:29 +0000946static int jsonLabelCompare(JsonNode *pNode, const char *zKey, u32 nKey){
drh8cb0c832015-09-22 00:21:03 +0000947 if( pNode->jnFlags & JNODE_RAW ){
948 if( pNode->n!=nKey ) return 0;
949 return strncmp(pNode->u.zJContent, zKey, nKey)==0;
950 }else{
951 if( pNode->n!=nKey+2 ) return 0;
952 return strncmp(pNode->u.zJContent+1, zKey, nKey)==0;
953 }
954}
955
drh52216ad2015-08-18 02:28:03 +0000956/* forward declaration */
drha7714022015-08-29 00:54:49 +0000957static JsonNode *jsonLookupAppend(JsonParse*,const char*,int*,const char**);
drh52216ad2015-08-18 02:28:03 +0000958
drh987eb1f2015-08-17 15:17:37 +0000959/*
960** Search along zPath to find the node specified. Return a pointer
961** to that node, or NULL if zPath is malformed or if there is no such
962** node.
drh52216ad2015-08-18 02:28:03 +0000963**
964** If pApnd!=0, then try to append new nodes to complete zPath if it is
965** possible to do so and if no existing node corresponds to zPath. If
966** new nodes are appended *pApnd is set to 1.
drh987eb1f2015-08-17 15:17:37 +0000967*/
drha7714022015-08-29 00:54:49 +0000968static JsonNode *jsonLookupStep(
drh52216ad2015-08-18 02:28:03 +0000969 JsonParse *pParse, /* The JSON to search */
970 u32 iRoot, /* Begin the search at this node */
971 const char *zPath, /* The path to search */
drha7714022015-08-29 00:54:49 +0000972 int *pApnd, /* Append nodes to complete path if not NULL */
973 const char **pzErr /* Make *pzErr point to any syntax error in zPath */
drh52216ad2015-08-18 02:28:03 +0000974){
drhbc8f0922015-08-22 19:39:04 +0000975 u32 i, j, nKey;
drh6b43cc82015-08-19 23:02:49 +0000976 const char *zKey;
drh52216ad2015-08-18 02:28:03 +0000977 JsonNode *pRoot = &pParse->aNode[iRoot];
drh987eb1f2015-08-17 15:17:37 +0000978 if( zPath[0]==0 ) return pRoot;
979 if( zPath[0]=='.' ){
980 if( pRoot->eType!=JSON_OBJECT ) return 0;
981 zPath++;
drh6b43cc82015-08-19 23:02:49 +0000982 if( zPath[0]=='"' ){
983 zKey = zPath + 1;
984 for(i=1; zPath[i] && zPath[i]!='"'; i++){}
985 nKey = i-1;
drha8f39a92015-09-21 22:53:16 +0000986 if( zPath[i] ){
987 i++;
988 }else{
989 *pzErr = zPath;
990 return 0;
991 }
drh6b43cc82015-08-19 23:02:49 +0000992 }else{
993 zKey = zPath;
994 for(i=0; zPath[i] && zPath[i]!='.' && zPath[i]!='['; i++){}
995 nKey = i;
996 }
drha7714022015-08-29 00:54:49 +0000997 if( nKey==0 ){
998 *pzErr = zPath;
999 return 0;
1000 }
drh987eb1f2015-08-17 15:17:37 +00001001 j = 1;
drh52216ad2015-08-18 02:28:03 +00001002 for(;;){
1003 while( j<=pRoot->n ){
drh8cb0c832015-09-22 00:21:03 +00001004 if( jsonLabelCompare(pRoot+j, zKey, nKey) ){
drha7714022015-08-29 00:54:49 +00001005 return jsonLookupStep(pParse, iRoot+j+1, &zPath[i], pApnd, pzErr);
drh52216ad2015-08-18 02:28:03 +00001006 }
1007 j++;
drh505ad2c2015-08-21 17:33:11 +00001008 j += jsonNodeSize(&pRoot[j]);
drh987eb1f2015-08-17 15:17:37 +00001009 }
drh52216ad2015-08-18 02:28:03 +00001010 if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break;
1011 iRoot += pRoot->u.iAppend;
1012 pRoot = &pParse->aNode[iRoot];
1013 j = 1;
1014 }
1015 if( pApnd ){
drhbc8f0922015-08-22 19:39:04 +00001016 u32 iStart, iLabel;
1017 JsonNode *pNode;
1018 iStart = jsonParseAddNode(pParse, JSON_OBJECT, 2, 0);
1019 iLabel = jsonParseAddNode(pParse, JSON_STRING, i, zPath);
drh52216ad2015-08-18 02:28:03 +00001020 zPath += i;
drha7714022015-08-29 00:54:49 +00001021 pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr);
drhbc8f0922015-08-22 19:39:04 +00001022 if( pParse->oom ) return 0;
1023 if( pNode ){
1024 pRoot = &pParse->aNode[iRoot];
1025 pRoot->u.iAppend = iStart - iRoot;
1026 pRoot->jnFlags |= JNODE_APPEND;
1027 pParse->aNode[iLabel].jnFlags |= JNODE_RAW;
1028 }
1029 return pNode;
drh987eb1f2015-08-17 15:17:37 +00001030 }
dan2e8f5512015-09-17 17:21:09 +00001031 }else if( zPath[0]=='[' && safe_isdigit(zPath[1]) ){
drh987eb1f2015-08-17 15:17:37 +00001032 if( pRoot->eType!=JSON_ARRAY ) return 0;
1033 i = 0;
drh3d1d2a92015-09-22 01:15:49 +00001034 j = 1;
1035 while( safe_isdigit(zPath[j]) ){
1036 i = i*10 + zPath[j] - '0';
1037 j++;
drh987eb1f2015-08-17 15:17:37 +00001038 }
drh3d1d2a92015-09-22 01:15:49 +00001039 if( zPath[j]!=']' ){
drha7714022015-08-29 00:54:49 +00001040 *pzErr = zPath;
1041 return 0;
1042 }
drh3d1d2a92015-09-22 01:15:49 +00001043 zPath += j + 1;
drh987eb1f2015-08-17 15:17:37 +00001044 j = 1;
drh52216ad2015-08-18 02:28:03 +00001045 for(;;){
drhbc8f0922015-08-22 19:39:04 +00001046 while( j<=pRoot->n && (i>0 || (pRoot[j].jnFlags & JNODE_REMOVE)!=0) ){
1047 if( (pRoot[j].jnFlags & JNODE_REMOVE)==0 ) i--;
drh505ad2c2015-08-21 17:33:11 +00001048 j += jsonNodeSize(&pRoot[j]);
drh52216ad2015-08-18 02:28:03 +00001049 }
1050 if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break;
1051 iRoot += pRoot->u.iAppend;
1052 pRoot = &pParse->aNode[iRoot];
1053 j = 1;
drh987eb1f2015-08-17 15:17:37 +00001054 }
1055 if( j<=pRoot->n ){
drha7714022015-08-29 00:54:49 +00001056 return jsonLookupStep(pParse, iRoot+j, zPath, pApnd, pzErr);
drh52216ad2015-08-18 02:28:03 +00001057 }
1058 if( i==0 && pApnd ){
drhbc8f0922015-08-22 19:39:04 +00001059 u32 iStart;
1060 JsonNode *pNode;
1061 iStart = jsonParseAddNode(pParse, JSON_ARRAY, 1, 0);
drha7714022015-08-29 00:54:49 +00001062 pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr);
drhbc8f0922015-08-22 19:39:04 +00001063 if( pParse->oom ) return 0;
1064 if( pNode ){
1065 pRoot = &pParse->aNode[iRoot];
1066 pRoot->u.iAppend = iStart - iRoot;
1067 pRoot->jnFlags |= JNODE_APPEND;
1068 }
1069 return pNode;
drh987eb1f2015-08-17 15:17:37 +00001070 }
drh3d1d2a92015-09-22 01:15:49 +00001071 }else{
drha7714022015-08-29 00:54:49 +00001072 *pzErr = zPath;
drh987eb1f2015-08-17 15:17:37 +00001073 }
1074 return 0;
1075}
1076
drh52216ad2015-08-18 02:28:03 +00001077/*
drhbc8f0922015-08-22 19:39:04 +00001078** Append content to pParse that will complete zPath. Return a pointer
1079** to the inserted node, or return NULL if the append fails.
drh52216ad2015-08-18 02:28:03 +00001080*/
1081static JsonNode *jsonLookupAppend(
1082 JsonParse *pParse, /* Append content to the JSON parse */
1083 const char *zPath, /* Description of content to append */
drha7714022015-08-29 00:54:49 +00001084 int *pApnd, /* Set this flag to 1 */
1085 const char **pzErr /* Make this point to any syntax error */
drh52216ad2015-08-18 02:28:03 +00001086){
1087 *pApnd = 1;
1088 if( zPath[0]==0 ){
1089 jsonParseAddNode(pParse, JSON_NULL, 0, 0);
1090 return pParse->oom ? 0 : &pParse->aNode[pParse->nNode-1];
1091 }
1092 if( zPath[0]=='.' ){
1093 jsonParseAddNode(pParse, JSON_OBJECT, 0, 0);
1094 }else if( strncmp(zPath,"[0]",3)==0 ){
1095 jsonParseAddNode(pParse, JSON_ARRAY, 0, 0);
1096 }else{
1097 return 0;
1098 }
1099 if( pParse->oom ) return 0;
drha7714022015-08-29 00:54:49 +00001100 return jsonLookupStep(pParse, pParse->nNode-1, zPath, pApnd, pzErr);
drh52216ad2015-08-18 02:28:03 +00001101}
1102
drhbc8f0922015-08-22 19:39:04 +00001103/*
drha7714022015-08-29 00:54:49 +00001104** Return the text of a syntax error message on a JSON path. Space is
1105** obtained from sqlite3_malloc().
1106*/
1107static char *jsonPathSyntaxError(const char *zErr){
1108 return sqlite3_mprintf("JSON path error near '%q'", zErr);
1109}
1110
1111/*
1112** Do a node lookup using zPath. Return a pointer to the node on success.
1113** Return NULL if not found or if there is an error.
1114**
1115** On an error, write an error message into pCtx and increment the
1116** pParse->nErr counter.
1117**
1118** If pApnd!=NULL then try to append missing nodes and set *pApnd = 1 if
1119** nodes are appended.
drha7714022015-08-29 00:54:49 +00001120*/
1121static JsonNode *jsonLookup(
1122 JsonParse *pParse, /* The JSON to search */
1123 const char *zPath, /* The path to search */
1124 int *pApnd, /* Append nodes to complete path if not NULL */
drhf5ddb9c2015-09-11 00:06:41 +00001125 sqlite3_context *pCtx /* Report errors here, if not NULL */
drha7714022015-08-29 00:54:49 +00001126){
1127 const char *zErr = 0;
1128 JsonNode *pNode = 0;
drha8f39a92015-09-21 22:53:16 +00001129 char *zMsg;
drha7714022015-08-29 00:54:49 +00001130
1131 if( zPath==0 ) return 0;
1132 if( zPath[0]!='$' ){
1133 zErr = zPath;
1134 goto lookup_err;
1135 }
1136 zPath++;
drha7714022015-08-29 00:54:49 +00001137 pNode = jsonLookupStep(pParse, 0, zPath, pApnd, &zErr);
drha8f39a92015-09-21 22:53:16 +00001138 if( zErr==0 ) return pNode;
drha7714022015-08-29 00:54:49 +00001139
1140lookup_err:
1141 pParse->nErr++;
drha8f39a92015-09-21 22:53:16 +00001142 assert( zErr!=0 && pCtx!=0 );
1143 zMsg = jsonPathSyntaxError(zErr);
1144 if( zMsg ){
1145 sqlite3_result_error(pCtx, zMsg, -1);
1146 sqlite3_free(zMsg);
1147 }else{
1148 sqlite3_result_error_nomem(pCtx);
drha7714022015-08-29 00:54:49 +00001149 }
drha7714022015-08-29 00:54:49 +00001150 return 0;
1151}
1152
1153
1154/*
drhbc8f0922015-08-22 19:39:04 +00001155** Report the wrong number of arguments for json_insert(), json_replace()
1156** or json_set().
1157*/
1158static void jsonWrongNumArgs(
1159 sqlite3_context *pCtx,
1160 const char *zFuncName
1161){
1162 char *zMsg = sqlite3_mprintf("json_%s() needs an odd number of arguments",
1163 zFuncName);
1164 sqlite3_result_error(pCtx, zMsg, -1);
1165 sqlite3_free(zMsg);
1166}
drh52216ad2015-08-18 02:28:03 +00001167
drha7714022015-08-29 00:54:49 +00001168
drh987eb1f2015-08-17 15:17:37 +00001169/****************************************************************************
1170** SQL functions used for testing and debugging
1171****************************************************************************/
drhe9c37f32015-08-15 21:25:36 +00001172
drh301eecc2015-08-17 20:14:19 +00001173#ifdef SQLITE_DEBUG
drhe9c37f32015-08-15 21:25:36 +00001174/*
drh5634cc02015-08-17 11:28:03 +00001175** The json_parse(JSON) function returns a string which describes
drhe9c37f32015-08-15 21:25:36 +00001176** a parse of the JSON provided. Or it returns NULL if JSON is not
1177** well-formed.
1178*/
drh5634cc02015-08-17 11:28:03 +00001179static void jsonParseFunc(
drhbc8f0922015-08-22 19:39:04 +00001180 sqlite3_context *ctx,
drhe9c37f32015-08-15 21:25:36 +00001181 int argc,
1182 sqlite3_value **argv
1183){
drh505ad2c2015-08-21 17:33:11 +00001184 JsonString s; /* Output string - not real JSON */
1185 JsonParse x; /* The parse */
drhe9c37f32015-08-15 21:25:36 +00001186 u32 i;
drhe9c37f32015-08-15 21:25:36 +00001187
1188 assert( argc==1 );
drhbc8f0922015-08-22 19:39:04 +00001189 if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
drh8784eca2015-08-23 02:42:30 +00001190 jsonParseFindParents(&x);
drhbc8f0922015-08-22 19:39:04 +00001191 jsonInit(&s, ctx);
drhe9c37f32015-08-15 21:25:36 +00001192 for(i=0; i<x.nNode; i++){
drh852944e2015-09-10 03:29:11 +00001193 const char *zType;
1194 if( x.aNode[i].jnFlags & JNODE_LABEL ){
1195 assert( x.aNode[i].eType==JSON_STRING );
1196 zType = "label";
1197 }else{
1198 zType = jsonType[x.aNode[i].eType];
drhe9c37f32015-08-15 21:25:36 +00001199 }
drh852944e2015-09-10 03:29:11 +00001200 jsonPrintf(100, &s,"node %3u: %7s n=%-4d up=%-4d",
1201 i, zType, x.aNode[i].n, x.aUp[i]);
1202 if( x.aNode[i].u.zJContent!=0 ){
1203 jsonAppendRaw(&s, " ", 1);
1204 jsonAppendRaw(&s, x.aNode[i].u.zJContent, x.aNode[i].n);
1205 }
1206 jsonAppendRaw(&s, "\n", 1);
drhe9c37f32015-08-15 21:25:36 +00001207 }
drh505ad2c2015-08-21 17:33:11 +00001208 jsonParseReset(&x);
drhe9c37f32015-08-15 21:25:36 +00001209 jsonResult(&s);
1210}
1211
drh5634cc02015-08-17 11:28:03 +00001212/*
drhf5ddb9c2015-09-11 00:06:41 +00001213** The json_test1(JSON) function return true (1) if the input is JSON
1214** text generated by another json function. It returns (0) if the input
1215** is not known to be JSON.
drh5634cc02015-08-17 11:28:03 +00001216*/
1217static void jsonTest1Func(
drhbc8f0922015-08-22 19:39:04 +00001218 sqlite3_context *ctx,
drh5634cc02015-08-17 11:28:03 +00001219 int argc,
1220 sqlite3_value **argv
1221){
mistachkin16a93122015-09-11 18:05:01 +00001222 UNUSED_PARAM(argc);
drhf5ddb9c2015-09-11 00:06:41 +00001223 sqlite3_result_int(ctx, sqlite3_value_subtype(argv[0])==JSON_SUBTYPE);
drh5634cc02015-08-17 11:28:03 +00001224}
drh301eecc2015-08-17 20:14:19 +00001225#endif /* SQLITE_DEBUG */
drh5634cc02015-08-17 11:28:03 +00001226
drh987eb1f2015-08-17 15:17:37 +00001227/****************************************************************************
drhff135ae2015-12-30 01:07:02 +00001228** Scalar SQL function implementations
drh987eb1f2015-08-17 15:17:37 +00001229****************************************************************************/
1230
1231/*
drh2ad96f52016-06-17 13:01:51 +00001232** Implementation of the json_QUOTE(VALUE) function. Return a JSON value
1233** corresponding to the SQL value input. Mostly this means putting
1234** double-quotes around strings and returning the unquoted string "null"
1235** when given a NULL input.
1236*/
1237static void jsonQuoteFunc(
1238 sqlite3_context *ctx,
1239 int argc,
1240 sqlite3_value **argv
1241){
1242 JsonString jx;
drhb0df5402016-08-01 17:06:44 +00001243 UNUSED_PARAM(argc);
drh2ad96f52016-06-17 13:01:51 +00001244
1245 jsonInit(&jx, ctx);
1246 jsonAppendValue(&jx, argv[0]);
1247 jsonResult(&jx);
1248 sqlite3_result_subtype(ctx, JSON_SUBTYPE);
1249}
1250
1251/*
drh987eb1f2015-08-17 15:17:37 +00001252** Implementation of the json_array(VALUE,...) function. Return a JSON
1253** array that contains all values given in arguments. Or if any argument
1254** is a BLOB, throw an error.
1255*/
1256static void jsonArrayFunc(
drhbc8f0922015-08-22 19:39:04 +00001257 sqlite3_context *ctx,
drh987eb1f2015-08-17 15:17:37 +00001258 int argc,
1259 sqlite3_value **argv
1260){
1261 int i;
drh505ad2c2015-08-21 17:33:11 +00001262 JsonString jx;
drh987eb1f2015-08-17 15:17:37 +00001263
drhbc8f0922015-08-22 19:39:04 +00001264 jsonInit(&jx, ctx);
drhd0960592015-08-17 21:22:32 +00001265 jsonAppendChar(&jx, '[');
drh987eb1f2015-08-17 15:17:37 +00001266 for(i=0; i<argc; i++){
drhd0960592015-08-17 21:22:32 +00001267 jsonAppendSeparator(&jx);
drhf5ddb9c2015-09-11 00:06:41 +00001268 jsonAppendValue(&jx, argv[i]);
drh987eb1f2015-08-17 15:17:37 +00001269 }
drhd0960592015-08-17 21:22:32 +00001270 jsonAppendChar(&jx, ']');
drh987eb1f2015-08-17 15:17:37 +00001271 jsonResult(&jx);
drhf5ddb9c2015-09-11 00:06:41 +00001272 sqlite3_result_subtype(ctx, JSON_SUBTYPE);
drh987eb1f2015-08-17 15:17:37 +00001273}
1274
1275
1276/*
1277** json_array_length(JSON)
1278** json_array_length(JSON, PATH)
1279**
1280** Return the number of elements in the top-level JSON array.
1281** Return 0 if the input is not a well-formed JSON array.
1282*/
1283static void jsonArrayLengthFunc(
drhbc8f0922015-08-22 19:39:04 +00001284 sqlite3_context *ctx,
drh987eb1f2015-08-17 15:17:37 +00001285 int argc,
1286 sqlite3_value **argv
1287){
1288 JsonParse x; /* The parse */
1289 sqlite3_int64 n = 0;
1290 u32 i;
drha8f39a92015-09-21 22:53:16 +00001291 JsonNode *pNode;
drh987eb1f2015-08-17 15:17:37 +00001292
drhf2df7e72015-08-28 20:07:40 +00001293 if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
drha8f39a92015-09-21 22:53:16 +00001294 assert( x.nNode );
1295 if( argc==2 ){
1296 const char *zPath = (const char*)sqlite3_value_text(argv[1]);
1297 pNode = jsonLookup(&x, zPath, 0, ctx);
1298 }else{
1299 pNode = x.aNode;
1300 }
1301 if( pNode==0 ){
1302 x.nErr = 1;
1303 }else if( pNode->eType==JSON_ARRAY ){
1304 assert( (pNode->jnFlags & JNODE_APPEND)==0 );
1305 for(i=1; i<=pNode->n; n++){
1306 i += jsonNodeSize(&pNode[i]);
drh987eb1f2015-08-17 15:17:37 +00001307 }
drh987eb1f2015-08-17 15:17:37 +00001308 }
drha7714022015-08-29 00:54:49 +00001309 if( x.nErr==0 ) sqlite3_result_int64(ctx, n);
drhf6ec8d42015-08-28 03:48:04 +00001310 jsonParseReset(&x);
1311}
1312
1313/*
drh3ad93bb2015-08-29 19:41:45 +00001314** json_extract(JSON, PATH, ...)
drh987eb1f2015-08-17 15:17:37 +00001315**
drh3ad93bb2015-08-29 19:41:45 +00001316** Return the element described by PATH. Return NULL if there is no
1317** PATH element. If there are multiple PATHs, then return a JSON array
1318** with the result from each path. Throw an error if the JSON or any PATH
1319** is malformed.
drh987eb1f2015-08-17 15:17:37 +00001320*/
1321static void jsonExtractFunc(
drhbc8f0922015-08-22 19:39:04 +00001322 sqlite3_context *ctx,
drh987eb1f2015-08-17 15:17:37 +00001323 int argc,
1324 sqlite3_value **argv
1325){
1326 JsonParse x; /* The parse */
1327 JsonNode *pNode;
1328 const char *zPath;
drh3ad93bb2015-08-29 19:41:45 +00001329 JsonString jx;
1330 int i;
1331
1332 if( argc<2 ) return;
drhbc8f0922015-08-22 19:39:04 +00001333 if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
drh3ad93bb2015-08-29 19:41:45 +00001334 jsonInit(&jx, ctx);
1335 jsonAppendChar(&jx, '[');
1336 for(i=1; i<argc; i++){
1337 zPath = (const char*)sqlite3_value_text(argv[i]);
drhf5ddb9c2015-09-11 00:06:41 +00001338 pNode = jsonLookup(&x, zPath, 0, ctx);
drh3ad93bb2015-08-29 19:41:45 +00001339 if( x.nErr ) break;
1340 if( argc>2 ){
1341 jsonAppendSeparator(&jx);
1342 if( pNode ){
1343 jsonRenderNode(pNode, &jx, 0);
1344 }else{
1345 jsonAppendRaw(&jx, "null", 4);
1346 }
1347 }else if( pNode ){
1348 jsonReturn(pNode, ctx, 0);
1349 }
drh987eb1f2015-08-17 15:17:37 +00001350 }
drh3ad93bb2015-08-29 19:41:45 +00001351 if( argc>2 && i==argc ){
1352 jsonAppendChar(&jx, ']');
1353 jsonResult(&jx);
drhf5ddb9c2015-09-11 00:06:41 +00001354 sqlite3_result_subtype(ctx, JSON_SUBTYPE);
drh3ad93bb2015-08-29 19:41:45 +00001355 }
1356 jsonReset(&jx);
drh505ad2c2015-08-21 17:33:11 +00001357 jsonParseReset(&x);
drh987eb1f2015-08-17 15:17:37 +00001358}
1359
1360/*
1361** Implementation of the json_object(NAME,VALUE,...) function. Return a JSON
1362** object that contains all name/value given in arguments. Or if any name
1363** is not a string or if any value is a BLOB, throw an error.
1364*/
1365static void jsonObjectFunc(
drhbc8f0922015-08-22 19:39:04 +00001366 sqlite3_context *ctx,
drh987eb1f2015-08-17 15:17:37 +00001367 int argc,
1368 sqlite3_value **argv
1369){
1370 int i;
drh505ad2c2015-08-21 17:33:11 +00001371 JsonString jx;
drh987eb1f2015-08-17 15:17:37 +00001372 const char *z;
1373 u32 n;
1374
1375 if( argc&1 ){
drhbc8f0922015-08-22 19:39:04 +00001376 sqlite3_result_error(ctx, "json_object() requires an even number "
drh987eb1f2015-08-17 15:17:37 +00001377 "of arguments", -1);
1378 return;
1379 }
drhbc8f0922015-08-22 19:39:04 +00001380 jsonInit(&jx, ctx);
drhd0960592015-08-17 21:22:32 +00001381 jsonAppendChar(&jx, '{');
drh987eb1f2015-08-17 15:17:37 +00001382 for(i=0; i<argc; i+=2){
drh987eb1f2015-08-17 15:17:37 +00001383 if( sqlite3_value_type(argv[i])!=SQLITE_TEXT ){
drhbc8f0922015-08-22 19:39:04 +00001384 sqlite3_result_error(ctx, "json_object() labels must be TEXT", -1);
drhdc384952015-09-19 18:54:39 +00001385 jsonReset(&jx);
drh987eb1f2015-08-17 15:17:37 +00001386 return;
1387 }
drhd0960592015-08-17 21:22:32 +00001388 jsonAppendSeparator(&jx);
drh987eb1f2015-08-17 15:17:37 +00001389 z = (const char*)sqlite3_value_text(argv[i]);
1390 n = (u32)sqlite3_value_bytes(argv[i]);
1391 jsonAppendString(&jx, z, n);
drhd0960592015-08-17 21:22:32 +00001392 jsonAppendChar(&jx, ':');
drhf5ddb9c2015-09-11 00:06:41 +00001393 jsonAppendValue(&jx, argv[i+1]);
drh987eb1f2015-08-17 15:17:37 +00001394 }
drhd0960592015-08-17 21:22:32 +00001395 jsonAppendChar(&jx, '}');
drh987eb1f2015-08-17 15:17:37 +00001396 jsonResult(&jx);
drhf5ddb9c2015-09-11 00:06:41 +00001397 sqlite3_result_subtype(ctx, JSON_SUBTYPE);
drh987eb1f2015-08-17 15:17:37 +00001398}
1399
1400
1401/*
drh301eecc2015-08-17 20:14:19 +00001402** json_remove(JSON, PATH, ...)
1403**
drh3ad93bb2015-08-29 19:41:45 +00001404** Remove the named elements from JSON and return the result. malformed
1405** JSON or PATH arguments result in an error.
drh301eecc2015-08-17 20:14:19 +00001406*/
1407static void jsonRemoveFunc(
drhbc8f0922015-08-22 19:39:04 +00001408 sqlite3_context *ctx,
drh301eecc2015-08-17 20:14:19 +00001409 int argc,
1410 sqlite3_value **argv
1411){
1412 JsonParse x; /* The parse */
1413 JsonNode *pNode;
1414 const char *zPath;
1415 u32 i;
1416
1417 if( argc<1 ) return;
drhbc8f0922015-08-22 19:39:04 +00001418 if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
drha8f39a92015-09-21 22:53:16 +00001419 assert( x.nNode );
1420 for(i=1; i<(u32)argc; i++){
1421 zPath = (const char*)sqlite3_value_text(argv[i]);
1422 if( zPath==0 ) goto remove_done;
1423 pNode = jsonLookup(&x, zPath, 0, ctx);
1424 if( x.nErr ) goto remove_done;
1425 if( pNode ) pNode->jnFlags |= JNODE_REMOVE;
1426 }
1427 if( (x.aNode[0].jnFlags & JNODE_REMOVE)==0 ){
1428 jsonReturnJson(x.aNode, ctx, 0);
drhd0960592015-08-17 21:22:32 +00001429 }
drha7714022015-08-29 00:54:49 +00001430remove_done:
drh505ad2c2015-08-21 17:33:11 +00001431 jsonParseReset(&x);
drhd0960592015-08-17 21:22:32 +00001432}
1433
1434/*
1435** json_replace(JSON, PATH, VALUE, ...)
1436**
1437** Replace the value at PATH with VALUE. If PATH does not already exist,
drh3ad93bb2015-08-29 19:41:45 +00001438** this routine is a no-op. If JSON or PATH is malformed, throw an error.
drhd0960592015-08-17 21:22:32 +00001439*/
1440static void jsonReplaceFunc(
drhbc8f0922015-08-22 19:39:04 +00001441 sqlite3_context *ctx,
drhd0960592015-08-17 21:22:32 +00001442 int argc,
1443 sqlite3_value **argv
1444){
1445 JsonParse x; /* The parse */
1446 JsonNode *pNode;
1447 const char *zPath;
1448 u32 i;
1449
1450 if( argc<1 ) return;
1451 if( (argc&1)==0 ) {
drhbc8f0922015-08-22 19:39:04 +00001452 jsonWrongNumArgs(ctx, "replace");
drhd0960592015-08-17 21:22:32 +00001453 return;
1454 }
drhbc8f0922015-08-22 19:39:04 +00001455 if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
drha8f39a92015-09-21 22:53:16 +00001456 assert( x.nNode );
1457 for(i=1; i<(u32)argc; i+=2){
1458 zPath = (const char*)sqlite3_value_text(argv[i]);
1459 pNode = jsonLookup(&x, zPath, 0, ctx);
1460 if( x.nErr ) goto replace_err;
1461 if( pNode ){
1462 pNode->jnFlags |= (u8)JNODE_REPLACE;
1463 pNode->iVal = (u8)(i+1);
drhd0960592015-08-17 21:22:32 +00001464 }
drha8f39a92015-09-21 22:53:16 +00001465 }
1466 if( x.aNode[0].jnFlags & JNODE_REPLACE ){
1467 sqlite3_result_value(ctx, argv[x.aNode[0].iVal]);
1468 }else{
1469 jsonReturnJson(x.aNode, ctx, argv);
drh301eecc2015-08-17 20:14:19 +00001470 }
drha7714022015-08-29 00:54:49 +00001471replace_err:
drh505ad2c2015-08-21 17:33:11 +00001472 jsonParseReset(&x);
drh301eecc2015-08-17 20:14:19 +00001473}
drh505ad2c2015-08-21 17:33:11 +00001474
drh52216ad2015-08-18 02:28:03 +00001475/*
1476** json_set(JSON, PATH, VALUE, ...)
1477**
1478** Set the value at PATH to VALUE. Create the PATH if it does not already
1479** exist. Overwrite existing values that do exist.
drh3ad93bb2015-08-29 19:41:45 +00001480** If JSON or PATH is malformed, throw an error.
drh52216ad2015-08-18 02:28:03 +00001481**
1482** json_insert(JSON, PATH, VALUE, ...)
1483**
1484** Create PATH and initialize it to VALUE. If PATH already exists, this
drh3ad93bb2015-08-29 19:41:45 +00001485** routine is a no-op. If JSON or PATH is malformed, throw an error.
drh52216ad2015-08-18 02:28:03 +00001486*/
1487static void jsonSetFunc(
drhbc8f0922015-08-22 19:39:04 +00001488 sqlite3_context *ctx,
drh52216ad2015-08-18 02:28:03 +00001489 int argc,
1490 sqlite3_value **argv
1491){
1492 JsonParse x; /* The parse */
1493 JsonNode *pNode;
1494 const char *zPath;
1495 u32 i;
1496 int bApnd;
drhbc8f0922015-08-22 19:39:04 +00001497 int bIsSet = *(int*)sqlite3_user_data(ctx);
drh52216ad2015-08-18 02:28:03 +00001498
1499 if( argc<1 ) return;
1500 if( (argc&1)==0 ) {
drhbc8f0922015-08-22 19:39:04 +00001501 jsonWrongNumArgs(ctx, bIsSet ? "set" : "insert");
drh52216ad2015-08-18 02:28:03 +00001502 return;
1503 }
drhbc8f0922015-08-22 19:39:04 +00001504 if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
drha8f39a92015-09-21 22:53:16 +00001505 assert( x.nNode );
1506 for(i=1; i<(u32)argc; i+=2){
1507 zPath = (const char*)sqlite3_value_text(argv[i]);
1508 bApnd = 0;
1509 pNode = jsonLookup(&x, zPath, &bApnd, ctx);
1510 if( x.oom ){
1511 sqlite3_result_error_nomem(ctx);
1512 goto jsonSetDone;
1513 }else if( x.nErr ){
1514 goto jsonSetDone;
1515 }else if( pNode && (bApnd || bIsSet) ){
1516 pNode->jnFlags |= (u8)JNODE_REPLACE;
1517 pNode->iVal = (u8)(i+1);
drh52216ad2015-08-18 02:28:03 +00001518 }
drha8f39a92015-09-21 22:53:16 +00001519 }
1520 if( x.aNode[0].jnFlags & JNODE_REPLACE ){
1521 sqlite3_result_value(ctx, argv[x.aNode[0].iVal]);
1522 }else{
1523 jsonReturnJson(x.aNode, ctx, argv);
drh52216ad2015-08-18 02:28:03 +00001524 }
drhbc8f0922015-08-22 19:39:04 +00001525jsonSetDone:
drh505ad2c2015-08-21 17:33:11 +00001526 jsonParseReset(&x);
drh52216ad2015-08-18 02:28:03 +00001527}
drh301eecc2015-08-17 20:14:19 +00001528
1529/*
drh987eb1f2015-08-17 15:17:37 +00001530** json_type(JSON)
1531** json_type(JSON, PATH)
1532**
drh3ad93bb2015-08-29 19:41:45 +00001533** Return the top-level "type" of a JSON string. Throw an error if
1534** either the JSON or PATH inputs are not well-formed.
drh987eb1f2015-08-17 15:17:37 +00001535*/
1536static void jsonTypeFunc(
drhbc8f0922015-08-22 19:39:04 +00001537 sqlite3_context *ctx,
drh987eb1f2015-08-17 15:17:37 +00001538 int argc,
1539 sqlite3_value **argv
1540){
1541 JsonParse x; /* The parse */
1542 const char *zPath;
drha8f39a92015-09-21 22:53:16 +00001543 JsonNode *pNode;
drh987eb1f2015-08-17 15:17:37 +00001544
drhbc8f0922015-08-22 19:39:04 +00001545 if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
drha8f39a92015-09-21 22:53:16 +00001546 assert( x.nNode );
1547 if( argc==2 ){
1548 zPath = (const char*)sqlite3_value_text(argv[1]);
1549 pNode = jsonLookup(&x, zPath, 0, ctx);
1550 }else{
1551 pNode = x.aNode;
1552 }
1553 if( pNode ){
1554 sqlite3_result_text(ctx, jsonType[pNode->eType], -1, SQLITE_STATIC);
drh987eb1f2015-08-17 15:17:37 +00001555 }
drh505ad2c2015-08-21 17:33:11 +00001556 jsonParseReset(&x);
drh987eb1f2015-08-17 15:17:37 +00001557}
drh5634cc02015-08-17 11:28:03 +00001558
drhbc8f0922015-08-22 19:39:04 +00001559/*
1560** json_valid(JSON)
1561**
drh3ad93bb2015-08-29 19:41:45 +00001562** Return 1 if JSON is a well-formed JSON string according to RFC-7159.
1563** Return 0 otherwise.
drhbc8f0922015-08-22 19:39:04 +00001564*/
1565static void jsonValidFunc(
1566 sqlite3_context *ctx,
1567 int argc,
1568 sqlite3_value **argv
1569){
1570 JsonParse x; /* The parse */
1571 int rc = 0;
1572
mistachkin16a93122015-09-11 18:05:01 +00001573 UNUSED_PARAM(argc);
drha8f39a92015-09-21 22:53:16 +00001574 if( jsonParse(&x, 0, (const char*)sqlite3_value_text(argv[0]))==0 ){
drhbc8f0922015-08-22 19:39:04 +00001575 rc = 1;
1576 }
1577 jsonParseReset(&x);
1578 sqlite3_result_int(ctx, rc);
1579}
1580
drhff135ae2015-12-30 01:07:02 +00001581
1582/****************************************************************************
1583** Aggregate SQL function implementations
1584****************************************************************************/
1585/*
1586** json_group_array(VALUE)
1587**
1588** Return a JSON array composed of all values in the aggregate.
1589*/
1590static void jsonArrayStep(
1591 sqlite3_context *ctx,
1592 int argc,
1593 sqlite3_value **argv
1594){
1595 JsonString *pStr;
drhdf3a9072016-02-11 15:37:18 +00001596 UNUSED_PARAM(argc);
drhff135ae2015-12-30 01:07:02 +00001597 pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr));
1598 if( pStr ){
1599 if( pStr->zBuf==0 ){
1600 jsonInit(pStr, ctx);
1601 jsonAppendChar(pStr, '[');
1602 }else{
1603 jsonAppendChar(pStr, ',');
1604 pStr->pCtx = ctx;
1605 }
1606 jsonAppendValue(pStr, argv[0]);
1607 }
1608}
1609static void jsonArrayFinal(sqlite3_context *ctx){
1610 JsonString *pStr;
1611 pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0);
1612 if( pStr ){
1613 pStr->pCtx = ctx;
1614 jsonAppendChar(pStr, ']');
1615 if( pStr->bErr ){
drh4a642b62016-02-05 01:55:27 +00001616 if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx);
drh23079262016-01-01 00:15:59 +00001617 assert( pStr->bStatic );
drhff135ae2015-12-30 01:07:02 +00001618 }else{
1619 sqlite3_result_text(ctx, pStr->zBuf, pStr->nUsed,
1620 pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free);
1621 pStr->bStatic = 1;
1622 }
1623 }else{
1624 sqlite3_result_text(ctx, "[]", 2, SQLITE_STATIC);
1625 }
1626 sqlite3_result_subtype(ctx, JSON_SUBTYPE);
1627}
1628
1629/*
1630** json_group_obj(NAME,VALUE)
1631**
1632** Return a JSON object composed of all names and values in the aggregate.
1633*/
1634static void jsonObjectStep(
1635 sqlite3_context *ctx,
1636 int argc,
1637 sqlite3_value **argv
1638){
1639 JsonString *pStr;
1640 const char *z;
1641 u32 n;
drhdf3a9072016-02-11 15:37:18 +00001642 UNUSED_PARAM(argc);
drhff135ae2015-12-30 01:07:02 +00001643 pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr));
1644 if( pStr ){
1645 if( pStr->zBuf==0 ){
1646 jsonInit(pStr, ctx);
1647 jsonAppendChar(pStr, '{');
1648 }else{
1649 jsonAppendChar(pStr, ',');
1650 pStr->pCtx = ctx;
1651 }
1652 z = (const char*)sqlite3_value_text(argv[0]);
1653 n = (u32)sqlite3_value_bytes(argv[0]);
1654 jsonAppendString(pStr, z, n);
1655 jsonAppendChar(pStr, ':');
1656 jsonAppendValue(pStr, argv[1]);
1657 }
1658}
1659static void jsonObjectFinal(sqlite3_context *ctx){
1660 JsonString *pStr;
1661 pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0);
1662 if( pStr ){
1663 jsonAppendChar(pStr, '}');
1664 if( pStr->bErr ){
drh6850a632016-11-07 18:18:08 +00001665 if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx);
drh23079262016-01-01 00:15:59 +00001666 assert( pStr->bStatic );
drhff135ae2015-12-30 01:07:02 +00001667 }else{
1668 sqlite3_result_text(ctx, pStr->zBuf, pStr->nUsed,
1669 pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free);
1670 pStr->bStatic = 1;
1671 }
1672 }else{
1673 sqlite3_result_text(ctx, "{}", 2, SQLITE_STATIC);
1674 }
1675 sqlite3_result_subtype(ctx, JSON_SUBTYPE);
1676}
1677
1678
drhd2975922015-08-29 17:22:33 +00001679#ifndef SQLITE_OMIT_VIRTUALTABLE
drhcb6c6c62015-08-19 22:47:17 +00001680/****************************************************************************
1681** The json_each virtual table
1682****************************************************************************/
1683typedef struct JsonEachCursor JsonEachCursor;
1684struct JsonEachCursor {
1685 sqlite3_vtab_cursor base; /* Base class - must be first */
drh505ad2c2015-08-21 17:33:11 +00001686 u32 iRowid; /* The rowid */
drh852944e2015-09-10 03:29:11 +00001687 u32 iBegin; /* The first node of the scan */
drh505ad2c2015-08-21 17:33:11 +00001688 u32 i; /* Index in sParse.aNode[] of current row */
1689 u32 iEnd; /* EOF when i equals or exceeds this value */
1690 u8 eType; /* Type of top-level element */
1691 u8 bRecursive; /* True for json_tree(). False for json_each() */
1692 char *zJson; /* Input JSON */
drh383de692015-09-10 17:20:57 +00001693 char *zRoot; /* Path by which to filter zJson */
drh505ad2c2015-08-21 17:33:11 +00001694 JsonParse sParse; /* Parse of the input JSON */
drhcb6c6c62015-08-19 22:47:17 +00001695};
1696
1697/* Constructor for the json_each virtual table */
1698static int jsonEachConnect(
1699 sqlite3 *db,
1700 void *pAux,
1701 int argc, const char *const*argv,
1702 sqlite3_vtab **ppVtab,
1703 char **pzErr
1704){
1705 sqlite3_vtab *pNew;
drh505ad2c2015-08-21 17:33:11 +00001706 int rc;
drhcb6c6c62015-08-19 22:47:17 +00001707
1708/* Column numbers */
drh4af352d2015-08-21 20:02:48 +00001709#define JEACH_KEY 0
1710#define JEACH_VALUE 1
1711#define JEACH_TYPE 2
1712#define JEACH_ATOM 3
1713#define JEACH_ID 4
1714#define JEACH_PARENT 5
1715#define JEACH_FULLKEY 6
drh383de692015-09-10 17:20:57 +00001716#define JEACH_PATH 7
1717#define JEACH_JSON 8
1718#define JEACH_ROOT 9
drhcb6c6c62015-08-19 22:47:17 +00001719
drh6fd5c1e2015-08-21 20:37:12 +00001720 UNUSED_PARAM(pzErr);
1721 UNUSED_PARAM(argv);
1722 UNUSED_PARAM(argc);
1723 UNUSED_PARAM(pAux);
drh505ad2c2015-08-21 17:33:11 +00001724 rc = sqlite3_declare_vtab(db,
drh383de692015-09-10 17:20:57 +00001725 "CREATE TABLE x(key,value,type,atom,id,parent,fullkey,path,"
1726 "json HIDDEN,root HIDDEN)");
drh505ad2c2015-08-21 17:33:11 +00001727 if( rc==SQLITE_OK ){
1728 pNew = *ppVtab = sqlite3_malloc( sizeof(*pNew) );
1729 if( pNew==0 ) return SQLITE_NOMEM;
1730 memset(pNew, 0, sizeof(*pNew));
1731 }
1732 return rc;
drhcb6c6c62015-08-19 22:47:17 +00001733}
1734
1735/* destructor for json_each virtual table */
1736static int jsonEachDisconnect(sqlite3_vtab *pVtab){
1737 sqlite3_free(pVtab);
1738 return SQLITE_OK;
1739}
1740
drh505ad2c2015-08-21 17:33:11 +00001741/* constructor for a JsonEachCursor object for json_each(). */
1742static int jsonEachOpenEach(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){
drhcb6c6c62015-08-19 22:47:17 +00001743 JsonEachCursor *pCur;
drh6fd5c1e2015-08-21 20:37:12 +00001744
1745 UNUSED_PARAM(p);
drhcb6c6c62015-08-19 22:47:17 +00001746 pCur = sqlite3_malloc( sizeof(*pCur) );
1747 if( pCur==0 ) return SQLITE_NOMEM;
1748 memset(pCur, 0, sizeof(*pCur));
1749 *ppCursor = &pCur->base;
1750 return SQLITE_OK;
1751}
1752
drh505ad2c2015-08-21 17:33:11 +00001753/* constructor for a JsonEachCursor object for json_tree(). */
1754static int jsonEachOpenTree(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){
1755 int rc = jsonEachOpenEach(p, ppCursor);
1756 if( rc==SQLITE_OK ){
1757 JsonEachCursor *pCur = (JsonEachCursor*)*ppCursor;
1758 pCur->bRecursive = 1;
1759 }
1760 return rc;
1761}
1762
drhcb6c6c62015-08-19 22:47:17 +00001763/* Reset a JsonEachCursor back to its original state. Free any memory
1764** held. */
1765static void jsonEachCursorReset(JsonEachCursor *p){
1766 sqlite3_free(p->zJson);
drh383de692015-09-10 17:20:57 +00001767 sqlite3_free(p->zRoot);
drh505ad2c2015-08-21 17:33:11 +00001768 jsonParseReset(&p->sParse);
drhcb6c6c62015-08-19 22:47:17 +00001769 p->iRowid = 0;
1770 p->i = 0;
1771 p->iEnd = 0;
1772 p->eType = 0;
drhcb6c6c62015-08-19 22:47:17 +00001773 p->zJson = 0;
drh383de692015-09-10 17:20:57 +00001774 p->zRoot = 0;
drhcb6c6c62015-08-19 22:47:17 +00001775}
1776
1777/* Destructor for a jsonEachCursor object */
1778static int jsonEachClose(sqlite3_vtab_cursor *cur){
1779 JsonEachCursor *p = (JsonEachCursor*)cur;
1780 jsonEachCursorReset(p);
1781 sqlite3_free(cur);
1782 return SQLITE_OK;
1783}
1784
1785/* Return TRUE if the jsonEachCursor object has been advanced off the end
1786** of the JSON object */
1787static int jsonEachEof(sqlite3_vtab_cursor *cur){
1788 JsonEachCursor *p = (JsonEachCursor*)cur;
1789 return p->i >= p->iEnd;
1790}
1791
drh505ad2c2015-08-21 17:33:11 +00001792/* Advance the cursor to the next element for json_tree() */
drh4af352d2015-08-21 20:02:48 +00001793static int jsonEachNext(sqlite3_vtab_cursor *cur){
drh505ad2c2015-08-21 17:33:11 +00001794 JsonEachCursor *p = (JsonEachCursor*)cur;
drh4af352d2015-08-21 20:02:48 +00001795 if( p->bRecursive ){
drh852944e2015-09-10 03:29:11 +00001796 if( p->sParse.aNode[p->i].jnFlags & JNODE_LABEL ) p->i++;
1797 p->i++;
drh4af352d2015-08-21 20:02:48 +00001798 p->iRowid++;
drh852944e2015-09-10 03:29:11 +00001799 if( p->i<p->iEnd ){
drh8784eca2015-08-23 02:42:30 +00001800 u32 iUp = p->sParse.aUp[p->i];
1801 JsonNode *pUp = &p->sParse.aNode[iUp];
drh4af352d2015-08-21 20:02:48 +00001802 p->eType = pUp->eType;
drh8784eca2015-08-23 02:42:30 +00001803 if( pUp->eType==JSON_ARRAY ){
1804 if( iUp==p->i-1 ){
1805 pUp->u.iKey = 0;
1806 }else{
1807 pUp->u.iKey++;
1808 }
drh4af352d2015-08-21 20:02:48 +00001809 }
1810 }
drh505ad2c2015-08-21 17:33:11 +00001811 }else{
drh4af352d2015-08-21 20:02:48 +00001812 switch( p->eType ){
1813 case JSON_ARRAY: {
1814 p->i += jsonNodeSize(&p->sParse.aNode[p->i]);
1815 p->iRowid++;
1816 break;
1817 }
1818 case JSON_OBJECT: {
1819 p->i += 1 + jsonNodeSize(&p->sParse.aNode[p->i+1]);
1820 p->iRowid++;
1821 break;
1822 }
1823 default: {
1824 p->i = p->iEnd;
1825 break;
1826 }
drh505ad2c2015-08-21 17:33:11 +00001827 }
1828 }
1829 return SQLITE_OK;
1830}
1831
drh4af352d2015-08-21 20:02:48 +00001832/* Append the name of the path for element i to pStr
1833*/
1834static void jsonEachComputePath(
1835 JsonEachCursor *p, /* The cursor */
1836 JsonString *pStr, /* Write the path here */
1837 u32 i /* Path to this element */
1838){
1839 JsonNode *pNode, *pUp;
1840 u32 iUp;
1841 if( i==0 ){
1842 jsonAppendChar(pStr, '$');
1843 return;
drhcb6c6c62015-08-19 22:47:17 +00001844 }
drh4af352d2015-08-21 20:02:48 +00001845 iUp = p->sParse.aUp[i];
1846 jsonEachComputePath(p, pStr, iUp);
1847 pNode = &p->sParse.aNode[i];
1848 pUp = &p->sParse.aNode[iUp];
1849 if( pUp->eType==JSON_ARRAY ){
1850 jsonPrintf(30, pStr, "[%d]", pUp->u.iKey);
1851 }else{
1852 assert( pUp->eType==JSON_OBJECT );
drh852944e2015-09-10 03:29:11 +00001853 if( (pNode->jnFlags & JNODE_LABEL)==0 ) pNode--;
drh4af352d2015-08-21 20:02:48 +00001854 assert( pNode->eType==JSON_STRING );
drh852944e2015-09-10 03:29:11 +00001855 assert( pNode->jnFlags & JNODE_LABEL );
drh4af352d2015-08-21 20:02:48 +00001856 jsonPrintf(pNode->n+1, pStr, ".%.*s", pNode->n-2, pNode->u.zJContent+1);
1857 }
drhcb6c6c62015-08-19 22:47:17 +00001858}
1859
1860/* Return the value of a column */
1861static int jsonEachColumn(
1862 sqlite3_vtab_cursor *cur, /* The cursor */
1863 sqlite3_context *ctx, /* First argument to sqlite3_result_...() */
1864 int i /* Which column to return */
1865){
1866 JsonEachCursor *p = (JsonEachCursor*)cur;
drh505ad2c2015-08-21 17:33:11 +00001867 JsonNode *pThis = &p->sParse.aNode[p->i];
drhcb6c6c62015-08-19 22:47:17 +00001868 switch( i ){
1869 case JEACH_KEY: {
drh8784eca2015-08-23 02:42:30 +00001870 if( p->i==0 ) break;
drhcb6c6c62015-08-19 22:47:17 +00001871 if( p->eType==JSON_OBJECT ){
drh505ad2c2015-08-21 17:33:11 +00001872 jsonReturn(pThis, ctx, 0);
1873 }else if( p->eType==JSON_ARRAY ){
1874 u32 iKey;
1875 if( p->bRecursive ){
1876 if( p->iRowid==0 ) break;
drh8784eca2015-08-23 02:42:30 +00001877 iKey = p->sParse.aNode[p->sParse.aUp[p->i]].u.iKey;
drh505ad2c2015-08-21 17:33:11 +00001878 }else{
1879 iKey = p->iRowid;
1880 }
drh6fd5c1e2015-08-21 20:37:12 +00001881 sqlite3_result_int64(ctx, (sqlite3_int64)iKey);
drhcb6c6c62015-08-19 22:47:17 +00001882 }
1883 break;
1884 }
1885 case JEACH_VALUE: {
drh852944e2015-09-10 03:29:11 +00001886 if( pThis->jnFlags & JNODE_LABEL ) pThis++;
drh505ad2c2015-08-21 17:33:11 +00001887 jsonReturn(pThis, ctx, 0);
1888 break;
1889 }
1890 case JEACH_TYPE: {
drh852944e2015-09-10 03:29:11 +00001891 if( pThis->jnFlags & JNODE_LABEL ) pThis++;
drh505ad2c2015-08-21 17:33:11 +00001892 sqlite3_result_text(ctx, jsonType[pThis->eType], -1, SQLITE_STATIC);
1893 break;
1894 }
1895 case JEACH_ATOM: {
drh852944e2015-09-10 03:29:11 +00001896 if( pThis->jnFlags & JNODE_LABEL ) pThis++;
drh505ad2c2015-08-21 17:33:11 +00001897 if( pThis->eType>=JSON_ARRAY ) break;
1898 jsonReturn(pThis, ctx, 0);
1899 break;
1900 }
1901 case JEACH_ID: {
drh852944e2015-09-10 03:29:11 +00001902 sqlite3_result_int64(ctx,
1903 (sqlite3_int64)p->i + ((pThis->jnFlags & JNODE_LABEL)!=0));
drh505ad2c2015-08-21 17:33:11 +00001904 break;
1905 }
1906 case JEACH_PARENT: {
drh852944e2015-09-10 03:29:11 +00001907 if( p->i>p->iBegin && p->bRecursive ){
drh6fd5c1e2015-08-21 20:37:12 +00001908 sqlite3_result_int64(ctx, (sqlite3_int64)p->sParse.aUp[p->i]);
drhcb6c6c62015-08-19 22:47:17 +00001909 }
1910 break;
1911 }
drh4af352d2015-08-21 20:02:48 +00001912 case JEACH_FULLKEY: {
1913 JsonString x;
1914 jsonInit(&x, ctx);
1915 if( p->bRecursive ){
1916 jsonEachComputePath(p, &x, p->i);
1917 }else{
drh383de692015-09-10 17:20:57 +00001918 if( p->zRoot ){
1919 jsonAppendRaw(&x, p->zRoot, (int)strlen(p->zRoot));
drh4af352d2015-08-21 20:02:48 +00001920 }else{
1921 jsonAppendChar(&x, '$');
1922 }
1923 if( p->eType==JSON_ARRAY ){
1924 jsonPrintf(30, &x, "[%d]", p->iRowid);
1925 }else{
1926 jsonPrintf(pThis->n, &x, ".%.*s", pThis->n-2, pThis->u.zJContent+1);
1927 }
1928 }
1929 jsonResult(&x);
1930 break;
1931 }
drhcb6c6c62015-08-19 22:47:17 +00001932 case JEACH_PATH: {
drh383de692015-09-10 17:20:57 +00001933 if( p->bRecursive ){
1934 JsonString x;
1935 jsonInit(&x, ctx);
1936 jsonEachComputePath(p, &x, p->sParse.aUp[p->i]);
1937 jsonResult(&x);
1938 break;
drh4af352d2015-08-21 20:02:48 +00001939 }
drh383de692015-09-10 17:20:57 +00001940 /* For json_each() path and root are the same so fall through
1941 ** into the root case */
1942 }
drh6850a632016-11-07 18:18:08 +00001943 default: {
drh383de692015-09-10 17:20:57 +00001944 const char *zRoot = p->zRoot;
drh6850a632016-11-07 18:18:08 +00001945 if( zRoot==0 ) zRoot = "$";
drh383de692015-09-10 17:20:57 +00001946 sqlite3_result_text(ctx, zRoot, -1, SQLITE_STATIC);
drhcb6c6c62015-08-19 22:47:17 +00001947 break;
1948 }
drh3d1d2a92015-09-22 01:15:49 +00001949 case JEACH_JSON: {
drh505ad2c2015-08-21 17:33:11 +00001950 assert( i==JEACH_JSON );
drhcb6c6c62015-08-19 22:47:17 +00001951 sqlite3_result_text(ctx, p->sParse.zJson, -1, SQLITE_STATIC);
1952 break;
1953 }
1954 }
1955 return SQLITE_OK;
1956}
1957
1958/* Return the current rowid value */
1959static int jsonEachRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
1960 JsonEachCursor *p = (JsonEachCursor*)cur;
1961 *pRowid = p->iRowid;
1962 return SQLITE_OK;
1963}
1964
1965/* The query strategy is to look for an equality constraint on the json
1966** column. Without such a constraint, the table cannot operate. idxNum is
drh383de692015-09-10 17:20:57 +00001967** 1 if the constraint is found, 3 if the constraint and zRoot are found,
drhcb6c6c62015-08-19 22:47:17 +00001968** and 0 otherwise.
1969*/
1970static int jsonEachBestIndex(
1971 sqlite3_vtab *tab,
1972 sqlite3_index_info *pIdxInfo
1973){
1974 int i;
1975 int jsonIdx = -1;
drh383de692015-09-10 17:20:57 +00001976 int rootIdx = -1;
drhcb6c6c62015-08-19 22:47:17 +00001977 const struct sqlite3_index_constraint *pConstraint;
drh6fd5c1e2015-08-21 20:37:12 +00001978
1979 UNUSED_PARAM(tab);
drhcb6c6c62015-08-19 22:47:17 +00001980 pConstraint = pIdxInfo->aConstraint;
1981 for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
1982 if( pConstraint->usable==0 ) continue;
1983 if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
1984 switch( pConstraint->iColumn ){
1985 case JEACH_JSON: jsonIdx = i; break;
drh383de692015-09-10 17:20:57 +00001986 case JEACH_ROOT: rootIdx = i; break;
drhcb6c6c62015-08-19 22:47:17 +00001987 default: /* no-op */ break;
1988 }
1989 }
1990 if( jsonIdx<0 ){
1991 pIdxInfo->idxNum = 0;
drh505ad2c2015-08-21 17:33:11 +00001992 pIdxInfo->estimatedCost = 1e99;
drhcb6c6c62015-08-19 22:47:17 +00001993 }else{
drh505ad2c2015-08-21 17:33:11 +00001994 pIdxInfo->estimatedCost = 1.0;
drhcb6c6c62015-08-19 22:47:17 +00001995 pIdxInfo->aConstraintUsage[jsonIdx].argvIndex = 1;
1996 pIdxInfo->aConstraintUsage[jsonIdx].omit = 1;
drh383de692015-09-10 17:20:57 +00001997 if( rootIdx<0 ){
drhcb6c6c62015-08-19 22:47:17 +00001998 pIdxInfo->idxNum = 1;
1999 }else{
drh383de692015-09-10 17:20:57 +00002000 pIdxInfo->aConstraintUsage[rootIdx].argvIndex = 2;
2001 pIdxInfo->aConstraintUsage[rootIdx].omit = 1;
drhcb6c6c62015-08-19 22:47:17 +00002002 pIdxInfo->idxNum = 3;
2003 }
2004 }
2005 return SQLITE_OK;
2006}
2007
2008/* Start a search on a new JSON string */
2009static int jsonEachFilter(
2010 sqlite3_vtab_cursor *cur,
2011 int idxNum, const char *idxStr,
2012 int argc, sqlite3_value **argv
2013){
2014 JsonEachCursor *p = (JsonEachCursor*)cur;
2015 const char *z;
mistachkin16a93122015-09-11 18:05:01 +00002016 const char *zRoot = 0;
drhcb6c6c62015-08-19 22:47:17 +00002017 sqlite3_int64 n;
2018
drh6fd5c1e2015-08-21 20:37:12 +00002019 UNUSED_PARAM(idxStr);
2020 UNUSED_PARAM(argc);
drhcb6c6c62015-08-19 22:47:17 +00002021 jsonEachCursorReset(p);
2022 if( idxNum==0 ) return SQLITE_OK;
2023 z = (const char*)sqlite3_value_text(argv[0]);
2024 if( z==0 ) return SQLITE_OK;
drhcb6c6c62015-08-19 22:47:17 +00002025 n = sqlite3_value_bytes(argv[0]);
drh6fd5c1e2015-08-21 20:37:12 +00002026 p->zJson = sqlite3_malloc64( n+1 );
drhcb6c6c62015-08-19 22:47:17 +00002027 if( p->zJson==0 ) return SQLITE_NOMEM;
drh6fd5c1e2015-08-21 20:37:12 +00002028 memcpy(p->zJson, z, (size_t)n+1);
drha7714022015-08-29 00:54:49 +00002029 if( jsonParse(&p->sParse, 0, p->zJson) ){
2030 int rc = SQLITE_NOMEM;
2031 if( p->sParse.oom==0 ){
2032 sqlite3_free(cur->pVtab->zErrMsg);
2033 cur->pVtab->zErrMsg = sqlite3_mprintf("malformed JSON");
2034 if( cur->pVtab->zErrMsg ) rc = SQLITE_ERROR;
2035 }
drhcb6c6c62015-08-19 22:47:17 +00002036 jsonEachCursorReset(p);
drha7714022015-08-29 00:54:49 +00002037 return rc;
2038 }else if( p->bRecursive && jsonParseFindParents(&p->sParse) ){
2039 jsonEachCursorReset(p);
2040 return SQLITE_NOMEM;
drhcb6c6c62015-08-19 22:47:17 +00002041 }else{
drh95677942015-09-24 01:06:37 +00002042 JsonNode *pNode = 0;
drhcb6c6c62015-08-19 22:47:17 +00002043 if( idxNum==3 ){
drha7714022015-08-29 00:54:49 +00002044 const char *zErr = 0;
drha8f39a92015-09-21 22:53:16 +00002045 zRoot = (const char*)sqlite3_value_text(argv[1]);
2046 if( zRoot==0 ) return SQLITE_OK;
drhcb6c6c62015-08-19 22:47:17 +00002047 n = sqlite3_value_bytes(argv[1]);
drh383de692015-09-10 17:20:57 +00002048 p->zRoot = sqlite3_malloc64( n+1 );
2049 if( p->zRoot==0 ) return SQLITE_NOMEM;
2050 memcpy(p->zRoot, zRoot, (size_t)n+1);
drha8f39a92015-09-21 22:53:16 +00002051 if( zRoot[0]!='$' ){
2052 zErr = zRoot;
2053 }else{
2054 pNode = jsonLookupStep(&p->sParse, 0, p->zRoot+1, 0, &zErr);
2055 }
2056 if( zErr ){
drha7714022015-08-29 00:54:49 +00002057 sqlite3_free(cur->pVtab->zErrMsg);
2058 cur->pVtab->zErrMsg = jsonPathSyntaxError(zErr);
drhcb6c6c62015-08-19 22:47:17 +00002059 jsonEachCursorReset(p);
drha7714022015-08-29 00:54:49 +00002060 return cur->pVtab->zErrMsg ? SQLITE_ERROR : SQLITE_NOMEM;
2061 }else if( pNode==0 ){
drhcb6c6c62015-08-19 22:47:17 +00002062 return SQLITE_OK;
2063 }
2064 }else{
2065 pNode = p->sParse.aNode;
2066 }
drh852944e2015-09-10 03:29:11 +00002067 p->iBegin = p->i = (int)(pNode - p->sParse.aNode);
drhcb6c6c62015-08-19 22:47:17 +00002068 p->eType = pNode->eType;
2069 if( p->eType>=JSON_ARRAY ){
drh8784eca2015-08-23 02:42:30 +00002070 pNode->u.iKey = 0;
drhc3722b22015-08-23 20:44:59 +00002071 p->iEnd = p->i + pNode->n + 1;
drh852944e2015-09-10 03:29:11 +00002072 if( p->bRecursive ){
drh3d1d2a92015-09-22 01:15:49 +00002073 p->eType = p->sParse.aNode[p->sParse.aUp[p->i]].eType;
drh852944e2015-09-10 03:29:11 +00002074 if( p->i>0 && (p->sParse.aNode[p->i-1].jnFlags & JNODE_LABEL)!=0 ){
2075 p->i--;
2076 }
2077 }else{
2078 p->i++;
2079 }
drhcb6c6c62015-08-19 22:47:17 +00002080 }else{
2081 p->iEnd = p->i+1;
2082 }
2083 }
drha8f39a92015-09-21 22:53:16 +00002084 return SQLITE_OK;
drhcb6c6c62015-08-19 22:47:17 +00002085}
2086
2087/* The methods of the json_each virtual table */
2088static sqlite3_module jsonEachModule = {
2089 0, /* iVersion */
2090 0, /* xCreate */
2091 jsonEachConnect, /* xConnect */
2092 jsonEachBestIndex, /* xBestIndex */
2093 jsonEachDisconnect, /* xDisconnect */
2094 0, /* xDestroy */
drh505ad2c2015-08-21 17:33:11 +00002095 jsonEachOpenEach, /* xOpen - open a cursor */
drhcb6c6c62015-08-19 22:47:17 +00002096 jsonEachClose, /* xClose - close a cursor */
2097 jsonEachFilter, /* xFilter - configure scan constraints */
drh4af352d2015-08-21 20:02:48 +00002098 jsonEachNext, /* xNext - advance a cursor */
drhcb6c6c62015-08-19 22:47:17 +00002099 jsonEachEof, /* xEof - check for end of scan */
2100 jsonEachColumn, /* xColumn - read data */
2101 jsonEachRowid, /* xRowid - read data */
2102 0, /* xUpdate */
2103 0, /* xBegin */
2104 0, /* xSync */
2105 0, /* xCommit */
2106 0, /* xRollback */
2107 0, /* xFindMethod */
2108 0, /* xRename */
drh6fd5c1e2015-08-21 20:37:12 +00002109 0, /* xSavepoint */
2110 0, /* xRelease */
2111 0 /* xRollbackTo */
drhcb6c6c62015-08-19 22:47:17 +00002112};
2113
drh505ad2c2015-08-21 17:33:11 +00002114/* The methods of the json_tree virtual table. */
2115static sqlite3_module jsonTreeModule = {
2116 0, /* iVersion */
2117 0, /* xCreate */
2118 jsonEachConnect, /* xConnect */
2119 jsonEachBestIndex, /* xBestIndex */
2120 jsonEachDisconnect, /* xDisconnect */
2121 0, /* xDestroy */
2122 jsonEachOpenTree, /* xOpen - open a cursor */
2123 jsonEachClose, /* xClose - close a cursor */
2124 jsonEachFilter, /* xFilter - configure scan constraints */
drh4af352d2015-08-21 20:02:48 +00002125 jsonEachNext, /* xNext - advance a cursor */
drh505ad2c2015-08-21 17:33:11 +00002126 jsonEachEof, /* xEof - check for end of scan */
2127 jsonEachColumn, /* xColumn - read data */
2128 jsonEachRowid, /* xRowid - read data */
2129 0, /* xUpdate */
2130 0, /* xBegin */
2131 0, /* xSync */
2132 0, /* xCommit */
2133 0, /* xRollback */
2134 0, /* xFindMethod */
2135 0, /* xRename */
drh6fd5c1e2015-08-21 20:37:12 +00002136 0, /* xSavepoint */
2137 0, /* xRelease */
2138 0 /* xRollbackTo */
drh505ad2c2015-08-21 17:33:11 +00002139};
drhd2975922015-08-29 17:22:33 +00002140#endif /* SQLITE_OMIT_VIRTUALTABLE */
drh505ad2c2015-08-21 17:33:11 +00002141
2142/****************************************************************************
drh2f20e132015-09-26 17:44:59 +00002143** The following routines are the only publically visible identifiers in this
2144** file. Call the following routines in order to register the various SQL
drh505ad2c2015-08-21 17:33:11 +00002145** functions and the virtual table implemented by this file.
2146****************************************************************************/
drhcb6c6c62015-08-19 22:47:17 +00002147
drh2f20e132015-09-26 17:44:59 +00002148int sqlite3Json1Init(sqlite3 *db){
drh5fa5c102015-08-12 16:49:40 +00002149 int rc = SQLITE_OK;
drh6fd5c1e2015-08-21 20:37:12 +00002150 unsigned int i;
drh5fa5c102015-08-12 16:49:40 +00002151 static const struct {
2152 const char *zName;
2153 int nArg;
drh52216ad2015-08-18 02:28:03 +00002154 int flag;
drh5fa5c102015-08-12 16:49:40 +00002155 void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
2156 } aFunc[] = {
drhf5ddb9c2015-09-11 00:06:41 +00002157 { "json", 1, 0, jsonRemoveFunc },
drh52216ad2015-08-18 02:28:03 +00002158 { "json_array", -1, 0, jsonArrayFunc },
2159 { "json_array_length", 1, 0, jsonArrayLengthFunc },
2160 { "json_array_length", 2, 0, jsonArrayLengthFunc },
drh3ad93bb2015-08-29 19:41:45 +00002161 { "json_extract", -1, 0, jsonExtractFunc },
drh52216ad2015-08-18 02:28:03 +00002162 { "json_insert", -1, 0, jsonSetFunc },
2163 { "json_object", -1, 0, jsonObjectFunc },
drh2ad96f52016-06-17 13:01:51 +00002164 { "json_quote", 1, 0, jsonQuoteFunc },
drh52216ad2015-08-18 02:28:03 +00002165 { "json_remove", -1, 0, jsonRemoveFunc },
2166 { "json_replace", -1, 0, jsonReplaceFunc },
2167 { "json_set", -1, 1, jsonSetFunc },
2168 { "json_type", 1, 0, jsonTypeFunc },
2169 { "json_type", 2, 0, jsonTypeFunc },
drhbc8f0922015-08-22 19:39:04 +00002170 { "json_valid", 1, 0, jsonValidFunc },
drh987eb1f2015-08-17 15:17:37 +00002171
drh301eecc2015-08-17 20:14:19 +00002172#if SQLITE_DEBUG
drh987eb1f2015-08-17 15:17:37 +00002173 /* DEBUG and TESTING functions */
drh52216ad2015-08-18 02:28:03 +00002174 { "json_parse", 1, 0, jsonParseFunc },
2175 { "json_test1", 1, 0, jsonTest1Func },
drh301eecc2015-08-17 20:14:19 +00002176#endif
drh5fa5c102015-08-12 16:49:40 +00002177 };
drhff135ae2015-12-30 01:07:02 +00002178 static const struct {
2179 const char *zName;
2180 int nArg;
2181 void (*xStep)(sqlite3_context*,int,sqlite3_value**);
2182 void (*xFinal)(sqlite3_context*);
2183 } aAgg[] = {
2184 { "json_group_array", 1, jsonArrayStep, jsonArrayFinal },
2185 { "json_group_object", 2, jsonObjectStep, jsonObjectFinal },
2186 };
drhd2975922015-08-29 17:22:33 +00002187#ifndef SQLITE_OMIT_VIRTUALTABLE
drh505ad2c2015-08-21 17:33:11 +00002188 static const struct {
2189 const char *zName;
2190 sqlite3_module *pModule;
2191 } aMod[] = {
2192 { "json_each", &jsonEachModule },
2193 { "json_tree", &jsonTreeModule },
2194 };
drhd2975922015-08-29 17:22:33 +00002195#endif
drh5fa5c102015-08-12 16:49:40 +00002196 for(i=0; i<sizeof(aFunc)/sizeof(aFunc[0]) && rc==SQLITE_OK; i++){
2197 rc = sqlite3_create_function(db, aFunc[i].zName, aFunc[i].nArg,
drh52216ad2015-08-18 02:28:03 +00002198 SQLITE_UTF8 | SQLITE_DETERMINISTIC,
2199 (void*)&aFunc[i].flag,
drh5fa5c102015-08-12 16:49:40 +00002200 aFunc[i].xFunc, 0, 0);
2201 }
drhff135ae2015-12-30 01:07:02 +00002202 for(i=0; i<sizeof(aAgg)/sizeof(aAgg[0]) && rc==SQLITE_OK; i++){
2203 rc = sqlite3_create_function(db, aAgg[i].zName, aAgg[i].nArg,
2204 SQLITE_UTF8 | SQLITE_DETERMINISTIC, 0,
2205 0, aAgg[i].xStep, aAgg[i].xFinal);
2206 }
drhd2975922015-08-29 17:22:33 +00002207#ifndef SQLITE_OMIT_VIRTUALTABLE
drh505ad2c2015-08-21 17:33:11 +00002208 for(i=0; i<sizeof(aMod)/sizeof(aMod[0]) && rc==SQLITE_OK; i++){
2209 rc = sqlite3_create_module(db, aMod[i].zName, aMod[i].pModule, 0);
drhcb6c6c62015-08-19 22:47:17 +00002210 }
drhd2975922015-08-29 17:22:33 +00002211#endif
drh5fa5c102015-08-12 16:49:40 +00002212 return rc;
2213}
drh2f20e132015-09-26 17:44:59 +00002214
2215
dan8d32e802015-10-14 18:45:42 +00002216#ifndef SQLITE_CORE
drh2f20e132015-09-26 17:44:59 +00002217#ifdef _WIN32
2218__declspec(dllexport)
2219#endif
2220int sqlite3_json_init(
2221 sqlite3 *db,
2222 char **pzErrMsg,
2223 const sqlite3_api_routines *pApi
2224){
2225 SQLITE_EXTENSION_INIT2(pApi);
2226 (void)pzErrMsg; /* Unused parameter */
2227 return sqlite3Json1Init(db);
2228}
dan8d32e802015-10-14 18:45:42 +00002229#endif
drh50065652015-10-08 19:29:18 +00002230#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_JSON1) */