SQLite

  sqlite3_context *pCtx,       /* Report errors here */
  char *zJson,                 /* Input JSON text to be parsed */
  int bTakeJson                /* Assume ownership of zJson if true */
){
  int i;
  memset(pParse, 0, sizeof(*pParse));
  if( zJson==0 ) return 1;
//printf("PARSE %s\n", zJson);
  pParse->zJson = zJson;
  pParse->bOwnsJson = bTakeJson;
  pParse->nJPRef = 1;
  i = jsonParseValue(pParse, 0);
  if( pParse->oom ) i = -1;
  if( i>0 ){
    assert( pParse->iDepth==0 );

     && p->nJson==nJson
     && (p->hasMod==0 || bUnedited==0)
     && memcmp(p->zJson,zJson,nJson)==0
    ){
      p->nErr = 0;
      p->useMod = 0;
      pMatch = p;
//printf("HIT %s at %d\n", zJson, iKey);
    }else
    if( pMatch==0
     && p->zAlt!=0
     && bUnedited==0
     && p->nAlt==nJson
     && memcmp(p->zAlt, zJson, nJson)==0
    ){
      p->nErr = 0;
      p->useMod = 1;
      pMatch = p;
//printf("HIT %s at %d-alt\n", zJson, iKey);
    }else if( p->iHold<iMinHold ){
      iMinHold = p->iHold;
      iMinKey = iKey;
    }
    if( p->iHold>iMaxHold ){
      iMaxHold = p->iHold;
    }
  }
  if( pMatch ){
    /* The input JSON text was found in the cache.  Use the preexisting
    ** parse of this JSON */
    pMatch->nErr = 0;
    pMatch->iHold = iMaxHold+1;
    assert( pMatch->nJPRef>0 ); /* pMatch is owned by the cache */
    return pMatch;
  }

  /* The input JSON was not found anywhere in the cache.  We will need
  ** to parse it ourselves and generate a new JsonParse object.
  */
//printf("MISS %s\n", zJson);
  p = sqlite3_malloc64( sizeof(*p) );
  if( p==0 ){
    sqlite3_result_error_nomem(pCtx);
    return 0;
  }
  memset(p, 0, sizeof(*p));
  p->zJson = sqlite3RCStrNew( nJson );

** this routine is a no-op.  If JSON or PATH is malformed, throw an error.
*/
static void jsonReplaceFunc(
  sqlite3_context *ctx,
  int argc,
  sqlite3_value **argv
){
  JsonParse x;          /* The parse */
  JsonNode *pNode;
  const char *zPath;
  u32 i;

  if( argc<1 ) return;
  if( (argc&1)==0 ) {
    jsonWrongNumArgs(ctx, "replace");
    return;
  }
  if( jsonParse(&x, ctx, (char*)sqlite3_value_text(argv[0]), 0) ) return;
  assert( x.nNode );
  for(i=1; i<(u32)argc; i+=2){
    zPath = (const char*)sqlite3_value_text(argv[i]);

    pNode = jsonLookup(&x, zPath, 0, ctx);
    if( x.nErr ) goto replace_err;
    if( pNode ){
      jsonReplaceNode(ctx, &x, (u32)(pNode - x.aNode), argv[i+1]);
    }
  }
  jsonReturnJson(&x, x.aNode, ctx, 0);
replace_err:
  jsonDebugPrintParse(&x);
  jsonParseReset(&x);
}


/*
** json_set(JSON, PATH, VALUE, ...)
**
** Set the value at PATH to VALUE.  Create the PATH if it does not already
** exist.  Overwrite existing values that do exist.
** If JSON or PATH is malformed, throw an error.
**
** json_insert(JSON, PATH, VALUE, ...)
**
** Create PATH and initialize it to VALUE.  If PATH already exists, this
** routine is a no-op.  If JSON or PATH is malformed, throw an error.
*/
static void jsonSetFunc(
  sqlite3_context *ctx,
  int argc,
  sqlite3_value **argv
){
  JsonParse x;          /* The parse */
  JsonNode *pNode;
  const char *zPath;
  u32 i;
  int bApnd;
  int bIsSet = sqlite3_user_data(ctx)!=0;

  if( argc<1 ) return;
  if( (argc&1)==0 ) {
    jsonWrongNumArgs(ctx, bIsSet ? "set" : "insert");
    return;
  }
  if( jsonParse(&x, ctx, (char*)sqlite3_value_text(argv[0]), 0) ) return;
  assert( x.nNode );
  for(i=1; i<(u32)argc; i+=2){
    zPath = (const char*)sqlite3_value_text(argv[i]);
    bApnd = 0;
    x.useMod = 1;
    pNode = jsonLookup(&x, zPath, &bApnd, ctx);
    if( x.oom ){
      sqlite3_result_error_nomem(ctx);
      goto jsonSetDone;
    }else if( x.nErr ){
      goto jsonSetDone;
    }else if( pNode && (bApnd || bIsSet) ){
      jsonReplaceNode(ctx, &x, (u32)(pNode - x.aNode), argv[i+1]);
    }
  }
  jsonDebugPrintParse(&x);
  jsonReturnJson(&x, x.aNode, ctx, 0);

jsonSetDone:
  jsonParseReset(&x);
}

/*
** json_type(JSON)
** json_type(JSON, PATH)
**
** Return the top-level "type" of a JSON string.  json_type() raises an

** reference count reaches zero.
*/
void sqlite3RCStrUnref(char *z){
  RCStr *p = (RCStr*)z;
  assert( p!=0 );
  p--;
  assert( p->nRCRef>0 );
  assert( p->uMagic==SQLITE_RCSTR_MAGIC );
  if( p->nRCRef>=2 ){
    p->nRCRef--;
  }else{
    if( p->xFree ) p->xFree(p->pAttach);
#ifdef SQLITE_DEBUG
    p->uMagic = 0;
#endif
    sqlite3_free(p);
  }
}

#if 0
/*
** Return true if the reference count on the string is exactly one, meaning
** that the string can be modified.  Return false if the reference count
** is greater than one.
*/
int sqlite3RCStrIsWriteable(char *z){
  RCStr *p = (RCStr*)z;
  assert( p!=0 );
  p--;
  assert( p->nRCRef>0 );
  assert( p->uMagic==SQLITE_RCSTR_MAGIC );
  return p->nRCRef==1;
}
#endif

/*
** Create a new string that is capable of holding N bytes of text, not counting
** the zero byte at the end.  The string is uninitialized.
**
** The reference count is initially 1.  Call sqlite3RCStrUnref() to free the
** newly allocated string.
**
** This routine returns 0 on an OOM.
*/
char *sqlite3RCStrNew(u64 N){
  RCStr *p = sqlite3_malloc64( N + sizeof(*p) + 1 );
  if( p==0 ) return 0;
  p->nRCRef = 1;
  p->xFree = 0;
  p->pAttach = 0;
#ifdef SQLITE_DEBUG
  p->uMagic = SQLITE_RCSTR_MAGIC;
#endif
  return (char*)&p[1];
}

#if 0
/*
** Return the number of bytes allocated to the string.  The value returned
** does not include the space for the zero-terminator at the end.
*/
u64 sqlite3RCStrSize(char *z){
  RCStr *p = (RCStr*)z;
  u64 N;
  assert( p!=0 );
  p--;
  assert( p->nRCRef>0 );
  assert( p->uMagic==SQLITE_RCSTR_MAGIC );
  N = sqlite3_msize(p);
  N -= sizeof(p) + 1;
  return N;
}
#endif

/*
** Change the size of the string so that it is able to hold N bytes.
** The string might be reallocated, so return the new allocation.
*/
char *sqlite3RCStrResize(char *z, u64 N){
  RCStr *p = (RCStr*)z;
  RCStr *pNew;
  assert( p!=0 );
  p--;
  assert( p->nRCRef==1 );
  assert( p->uMagic==SQLITE_RCSTR_MAGIC );
  pNew = sqlite3_realloc64(p, N+sizeof(RCStr)+1);
  if( pNew==0 ){
    sqlite3_free(p);
    return 0;
  }else{
    return (char*)&pNew[1];
  }
}

#if 0
/*
** Add a new attachment to the string.
**
** A string may have no more than one attachment.  When a new attachment
** is added, any prior attachment is destroyed.  Remove an attachment
** by adding a zero-attachment.
*/
void sqlite3RCStrAttach(char *z, void *pAttach, void(*xFree)(void*)){
  RCStr *p = (RCStr*)z;
  assert( p!=0 );
  p--;
  assert( p->nRCRef>0 );
  assert( p->uMagic==SQLITE_RCSTR_MAGIC );
  if( p->xFree ) p->xFree(p->pAttach);
  p->xFree = xFree;
  p->pAttach = pAttach;
}
#endif

#if 0
/*
** Return the attachment associated with a string if the attachment
** has the destructure specified in the second argument.  If the
** string has no attachment or if the destructor does not match,
** then return a NULL pointr.
*/
void *sqlite3RCStrGetAttachment(char *z, void(*xFree)(void*)){
  RCStr *p = (RCStr*)z;
  assert( p!=0 );
  p--;
  assert( p->nRCRef>0 );
  assert( p->uMagic==SQLITE_RCSTR_MAGIC );
  return p->xFree==xFree ? p->pAttach : 0;
}
#endif

#define isMalloced(X)  (((X)->printfFlags & SQLITE_PRINTF_MALLOCED)!=0)

/*
** The following object is the header for an "RCStr" or "reference-counted
** string".  An RCStr is passed around and used like any other char*
** that has been dynamically allocated.  The important interface
** difference is that it uses sqlite3RCStrUnref() as its destructor
** rather than sqlite3_free().  Other than that the two are interchangeable.
**

** Thus to return an RCStr object as the result of an SQL function use:
** 
**    sqlite3_result_text64(ctx,z,sz,sqlite3RCStrUnref,SQLITE_UTF8)
**                                   ^^^^^^^^^^^^^^^^^
**                                   Instead of sqlite3_free() or similar
**
** An SQL function can check its arguments to see if they are RCStr
** strings using the sqlite3ValueIsOfClass() function:
**
**    sqlite3ValueIsOfClass(argv[i], sqlite3RCStrUnref);
**
** An RCStr string might be better than an ordinary string in some cases
** because:
**
**    (1)  You can duplicate it using sqlite3RCStrRef(x).
**
**    (2)  You can also add an associated object to the string.  For
**         example, if the string is JSON, perhaps the associated object
**         is a parse of that JSON.
**
** Methods for an RCStr string begin with "sqlite3RCStr...".
*/
struct RCStr {
  u32 nRCRef;            /* Number of references */
#ifdef SQLITE_DEBUG
  u32 uMagic;            /* Magic number for sanity checking */
#endif
  void *pAttach;         /* Attachment to this string */
  void (*xFree)(void*);  /* Destructor for the attachment */

};

/* The Magic number used by RCStr for sanity checking.  SQLITE_DEBUG only. */
#define SQLITE_RCSTR_MAGIC 0x3dc05d54


/*
** A pointer to this structure is used to communicate information
** from sqlite3Init and OP_ParseSchema into the sqlite3InitCallback.
*/
typedef struct {
  sqlite3 *db;        /* The database being initialized */

void sqlite3FileSuffix3(const char*, char*);
#else
# define sqlite3FileSuffix3(X,Y)
#endif
u8 sqlite3GetBoolean(const char *z,u8);

const void *sqlite3ValueText(sqlite3_value*, u8);
//int sqlite3ValueIsOfClass(const sqlite3_value*, void(*)(void*));
int sqlite3ValueBytes(sqlite3_value*, u8);
void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8,
                        void(*)(void*));
void sqlite3ValueSetNull(sqlite3_value*);
void sqlite3ValueFree(sqlite3_value*);
#ifndef SQLITE_UNTESTABLE
void sqlite3ResultIntReal(sqlite3_context*);

void sqlite3OomClear(sqlite3*);
int sqlite3ApiExit(sqlite3 *db, int);
int sqlite3OpenTempDatabase(Parse *);

char *sqlite3RCStrRef(char*);
void sqlite3RCStrUnref(char*);
char *sqlite3RCStrNew(u64);
//u64 sqlite3RCStrSize(char*);
char *sqlite3RCStrResize(char*,u64);
//int sqlite3RCStrIsWriteable(char*);
//void sqlite3RCStrAttach(char*, void*, void(*)(void*));
//void *sqlite3RCStrGetAttachment(char*,void(*)(void*));

void sqlite3StrAccumInit(StrAccum*, sqlite3*, char*, int, int);
int sqlite3StrAccumEnlarge(StrAccum*, i64);
char *sqlite3StrAccumFinish(StrAccum*);
void sqlite3StrAccumSetError(StrAccum*, u8);
void sqlite3ResultStrAccum(sqlite3_context*,StrAccum*);
void sqlite3SelectDestInit(SelectDest*,int,int);

  }
  if( pVal->flags&MEM_Null ){
    return 0;
  }
  return valueToText(pVal, enc);
}

#if 0
/* Return true if sqlit3_value object pVal is a string or blob value
** that uses the destructor specified in the second argument.
**
** TODO:  Maybe someday promote this interface into a published API so
** that third-party extensions can get access to it?
*/
int sqlite3ValueIsOfClass(const sqlite3_value *pVal, void(*xFree)(void*)){
  if( ALWAYS(pVal!=0)
   && (pVal->flags & (MEM_Str|MEM_Blob))!=0
   && (pVal->flags & MEM_Dyn)!=0
   && pVal->xDel==xFree
  ){
    return 1;
  }else{
    return 0;
  }
}
#endif

/*
** Create a new sqlite3_value object.
*/
sqlite3_value *sqlite3ValueNew(sqlite3 *db){
  Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
  if( p ){
    p->flags = MEM_Null;