} // Call w/o offset

		private static int sqlite3VdbeMemSetStr(
		Mem pMem,           /* Memory cell to set to string value */
		string z,           /* String pointer */
		int offset,         /* offset into string */
		int n,              /* Bytes in string, or negative */
		u8 enc,             /* Encoding of z.  0 for BLOBs */
		dxDel xDel//)(void*)/* Destructor function */
		)
		{
			int nByte = n;      /* New value for pMem->n */
			int iLimit;         /* Maximum allowed string or blob size */
			u16 flags = 0;      /* New value for pMem->flags */

			Debug.Assert(pMem.db == null || sqlite3_mutex_held(pMem.db.mutex));
			Debug.Assert((pMem.flags & MEM_RowSet) == 0);

			/* If z is a NULL pointer, set pMem to contain an SQL NULL. */
			if (z == null || z.Length < offset)
			{
				sqlite3VdbeMemSetNull(pMem);
				return SQLITE_OK;
			}

			if (pMem.db != null)
			{
				iLimit = pMem.db.aLimit[SQLITE_LIMIT_LENGTH];
			}
			else
			{
				iLimit = SQLITE_MAX_LENGTH;
			}
			flags = (u16)(enc == 0 ? MEM_Blob : MEM_Str);
			if (nByte < 0)
			{
				Debug.Assert(enc != 0);
				if (enc == SQLITE_UTF8)
				{
					for (nByte = 0; nByte <= iLimit && nByte < z.Length - offset && z[offset + nByte] != 0; nByte++)
					{
					}
				}
				else
				{
					for (nByte = 0; nByte <= iLimit && z[nByte + offset] != 0 || z[offset + nByte + 1] != 0; nByte += 2)
					{
					}
				}
				flags |= MEM_Term;
			}

			/* The following block sets the new values of Mem.z and Mem.xDel. It
			** also sets a flag in local variable "flags" to indicate the memory
			** management (one of MEM_Dyn or MEM_Static).
			*/
			if (xDel == SQLITE_TRANSIENT)
			{
				u32 nAlloc = (u32)nByte;
				if ((flags & MEM_Term) != 0)
				{
					nAlloc += (u32)(enc == SQLITE_UTF8 ? 1 : 2);
				}
				if (nByte > iLimit)
				{
					return SQLITE_TOOBIG;
				}
				if (sqlite3VdbeMemGrow(pMem, (int)nAlloc, 0) != 0)
				{
					return SQLITE_NOMEM;
				}
				//if ( nAlloc < z.Length )
				//pMem.z = new byte[nAlloc]; Buffer.BlockCopy( z, 0, pMem.z, 0, (int)nAlloc ); }
				//else
				if (enc == 0)
				{
					pMem.z = null;
					pMem.zBLOB = sqlite3Malloc(n);
					for (int i = 0; i < n && i < z.Length - offset; i++)
						pMem.zBLOB[i] = (byte)z[offset + i];
				}
				else
				{
					pMem.z = n > 0 && z.Length - offset > n ? z.Substring(offset, n) : z.Substring(offset);//memcpy(pMem.z, z, nAlloc);
					sqlite3_free(ref pMem.zBLOB);
				}
			}
			else if (xDel == SQLITE_DYNAMIC)
			{
				sqlite3VdbeMemRelease(pMem);
				//pMem.zMalloc = pMem.z = (char*)z;
				if (enc == 0)
				{
					pMem.z = null;
					if (pMem.zBLOB != null)
						sqlite3_free(ref pMem.zBLOB);
					pMem.zBLOB = Encoding.UTF8.GetBytes(offset == 0 ? z : z.Length + offset < n ? z.Substring(offset, n) : z.Substring(offset));
				}
				else
				{
//.........这里部分代码省略.........

		} // Call w/o offset

		private static int sqlite3VdbeMemSetBlob(
		Mem pMem,           /* Memory cell to set to string value */
		byte[] zBlob,       /* Blob pointer */
		int offset,         /* offset into string */
		int n,              /* Bytes in string, or negative */
		u8 enc,             /* Encoding of z.  0 for BLOBs */
		dxDel xDel//)(void*)/* Destructor function */
		)
		{
			int nByte = n;      /* New value for pMem->n */
			int iLimit;         /* Maximum allowed string or blob size */

			Debug.Assert(pMem.db == null || sqlite3_mutex_held(pMem.db.mutex));
			Debug.Assert((pMem.flags & MEM_RowSet) == 0);

			/* If zBlob is a NULL pointer, set pMem to contain an SQL NULL. */
			if (zBlob == null || zBlob.Length < offset)
			{
				sqlite3VdbeMemSetNull(pMem);
				return SQLITE_OK;
			}

			if (pMem.db != null)
			{
				iLimit = pMem.db.aLimit[SQLITE_LIMIT_LENGTH];
			}
			else
			{
				iLimit = SQLITE_MAX_LENGTH;
			}
			if (nByte < 0)
			{
				Debug.Assert(enc != 0);
				if (enc == SQLITE_UTF8)
				{
					for (nByte = 0; nByte <= iLimit && nByte < zBlob.Length - offset && zBlob[offset + nByte] != 0; nByte++)
					{
					}
				}
				else
				{
					for (nByte = 0; nByte <= iLimit && zBlob[nByte + offset] != 0 || zBlob[offset + nByte + 1] != 0; nByte += 2)
					{
					}
				}
			}

			/* The following block sets the new values of Mem.z and Mem.xDel. It
			** also sets a flag in local variable "flags" to indicate the memory
			** management (one of MEM_Dyn or MEM_Static).
			*/
			Debug.Assert(enc == 0);
			{
				pMem.z = null;
				pMem.zBLOB = sqlite3Malloc(n);
				Buffer.BlockCopy(zBlob, offset, pMem.zBLOB, 0, n);
			}
			pMem.n = nByte;
			pMem.flags = MEM_Blob | MEM_Term;
			pMem.enc = (enc == 0 ? SQLITE_UTF8 : enc);
			pMem.type = (enc == 0 ? SQLITE_BLOB : SQLITE_TEXT);

			if (nByte > iLimit)
			{
				return SQLITE_TOOBIG;
			}

			return SQLITE_OK;
		}

		/*
		** Change the string value of an sqlite3_value object
		*/

		private static void sqlite3ValueSetStr(
		sqlite3_value v,     /* Value to be set */
		int n,               /* Length of string z */
		string z,            /* Text of the new string */
		u8 enc,              /* Encoding to use */
		dxDel xDel//)(void*) /* Destructor for the string */
		)
		{
			if (v != null)
				sqlite3VdbeMemSetStr(v, z, n, enc, xDel);
		}

void sqlite3_result_text16le(
sqlite3_context pCtx,
string z,
int n,
dxDel xDel
){
Debug.Assert( sqlite3_mutex_held(pCtx.s.db.mutex) );
sqlite3VdbeMemSetStr(pCtx.s, z, n, SQLITE_UTF16LE, xDel);
}

 //# define sqlite3_open16                 0
 //# define sqlite3_prepare16              0
 //# define sqlite3_prepare16_v2           0
 //# define sqlite3_result_error16         0
 //# define sqlite3_result_text16          0
 static void sqlite3_result_text16( sqlite3_context pCtx, string z, int n, dxDel xDel )
 {
 }

 public static void sqlite3_result_blob(
 sqlite3_context pCtx,
 string z,
 int n,
 dxDel xDel
 )
 {
   Debug.Assert( n >= 0 );
   Debug.Assert( sqlite3_mutex_held( pCtx.s.db.mutex ) );
   setResultStrOrError( pCtx, z, n, 0, xDel );
 }

 public static void sqlite3_result_text(
 sqlite3_context pCtx,
 string z,
 int n,
 dxDel xDel
 )
 {
   Debug.Assert( sqlite3_mutex_held( pCtx.s.db.mutex ) );
   setResultStrOrError( pCtx, z, n, SQLITE_UTF8, xDel );
 }

    /*
    ** Set the auxillary data pointer and delete function, for the iArg'th
    ** argument to the user-function defined by pCtx. Any previous value is
    ** deleted by calling the delete function specified when it was set.
    */
    public static void sqlite3_set_auxdata(
    sqlite3_context pCtx,
    int iArg,
    string pAux,
    dxDel xDelete//void (*xDelete)(void*)
    )
    {
      AuxData pAuxData;
      VdbeFunc pVdbeFunc;
      if (iArg < 0) goto failed;

      Debug.Assert(sqlite3_mutex_held(pCtx.s.db.mutex));
      pVdbeFunc = pCtx.pVdbeFunc;
      if (null == pVdbeFunc || pVdbeFunc.nAux <= iArg)
      {
        int nAux = (pVdbeFunc != null ? pVdbeFunc.nAux : 0);
        int nMalloc = iArg; ;//VdbeFunc+ sizeof(struct AuxData)*iArg;
        if (pVdbeFunc == null)
        {
          //pVdbeFunc = (VdbeFunc)sqlite3DbRealloc( pCtx.s.db, pVdbeFunc, nMalloc );
          pVdbeFunc = new VdbeFunc();
          if (null == pVdbeFunc)
          {
            goto failed;
          }
          pCtx.pVdbeFunc = pVdbeFunc;
        }
        pVdbeFunc.apAux[nAux] = new AuxData();//memset(pVdbeFunc.apAux[nAux], 0, sizeof(struct AuxData)*(iArg+1-nAux));
        pVdbeFunc.nAux = iArg + 1;
        pVdbeFunc.pFunc = pCtx.pFunc;
      }

      pAuxData = pVdbeFunc.apAux[iArg];
      if (pAuxData.pAux != null && pAuxData.xDelete != null)
      {
        pAuxData.xDelete(ref pAuxData.pAux);
      }
      pAuxData.pAux = pAux;
      pAuxData.xDelete = xDelete;
      return;

    failed:
      if (xDelete != null)
      {
        xDelete(ref pAux);
      }
    }

 static void setResultStrOrError(
 sqlite3_context pCtx,   /* Function context */
 string z,               /* String pointer */
 int n,                  /* Bytes in string, or negative */
 u8 enc,                 /* Encoding of z.  0 for BLOBs */
 dxDel xDel //void (*xDel)(void)     /* Destructor function */
 )
 {
   if ( sqlite3VdbeMemSetStr( pCtx.s, z, n, enc, xDel ) == SQLITE_TOOBIG )
   {
     sqlite3_result_error_toobig( pCtx );
   }
 }

    /*
    ** Set the name of the idx'th column to be returned by the SQL statement.
    ** zName must be a pointer to a nul terminated string.
    **
    ** This call must be made after a call to sqlite3VdbeSetNumCols().
    **
    ** The final parameter, xDel, must be one of SQLITE_DYNAMIC, SQLITE_STATIC
    ** or SQLITE_TRANSIENT. If it is SQLITE_DYNAMIC, then the buffer pointed
    ** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed.
    */


    static int sqlite3VdbeSetColName(
    Vdbe p,                 /* Vdbe being configured */
    int idx,                /* Index of column zName applies to */
    int var,                /* One of the COLNAME_* constants */
    string zName,           /* Pointer to buffer containing name */
    dxDel xDel              /* Memory management strategy for zName */
    )
    {
      int rc;
      Mem pColName;
      Debug.Assert( idx < p.nResColumn );
      Debug.Assert( var < COLNAME_N );
      //if ( p.db.mallocFailed != 0 )
      //{
      //  Debug.Assert( null == zName || xDel != SQLITE_DYNAMIC );
      //  return SQLITE_NOMEM;
      //}
      Debug.Assert( p.aColName != null );
      pColName = p.aColName[idx + var * p.nResColumn];
      rc = sqlite3VdbeMemSetStr( pColName, zName, -1, SQLITE_UTF8, xDel );
      Debug.Assert( rc != 0 || null == zName || ( pColName.flags & MEM_Term ) != 0 );
      return rc;
    }

    //STRING

    //STRING + Type
    static void sqlite3VdbeChangeP4( Vdbe p, int addr, string z, dxDel P4_Type )
    {
      union_p4 _p4 = new union_p4();
      _p4.z = z;
      sqlite3VdbeChangeP4( p, addr, _p4, P4_DYNAMIC );
    }

		/// <summary>
		/// The following routines are used by user-defined functions to specify
		/// the function result.
		///
		/// The setStrOrError() funtion calls sqlite3VdbeMemSetStr() to store the
		/// result as a string or blob but if the string or blob is too large, it
		/// then sets the error code to SQLITE_TOOBIG
		/// </summary>
		/// <param name='pCtx'>
		/// Function context
		/// </param>
		/// <param name='z'>
		/// String pointer
		/// </param>
		/// <param name='o'
		/// <param name='n'>
		/// Bytes in string, or negative
		/// </param>
		/// <param name='enc'>
		/// Encoding of z.  0 for BLOBs
		/// </param>
		/// <param name='xDel'>
		/// Destructor function
		/// </param>
		static void setResultStrOrError(
		sqlite3_context pCtx,
		string z,
		int n,
		u8 enc,
		dxDel xDel
		)
		{
			if (sqlite3VdbeMemSetStr(pCtx.s, z, n, enc, xDel) == SQLITE_TOOBIG)
			{
				sqlite3_result_error_toobig(pCtx);
			}
		}

        /// <summary>
        /// Sqlite3s the vdbe mem set string.
        /// </summary>
        /// <param name='pMem'>
        /// Memory cell to set to string value
        /// </param>
        /// <param name='z'>
        /// String pointer
        /// </param>
        /// <param name='n'>
        /// Bytes in string, or negative
        /// </param>
        /// <param name='enc'>
        /// Encoding of z.  0 for BLOBs.
        /// </param>
        /// <param name='xDel'>
        /// Destructor function
        /// </param>
        static int sqlite3VdbeMemSetStr(
		Mem pMem,
		string z,
		int n,
		u8 enc,
		dxDel xDel
		)
        {
            return sqlite3VdbeMemSetStr(pMem, z, 0, n, enc, xDel);
        }

        /// <summary>
        /// Change the value of a Mem to be a string or a BLOB.
        ///
        /// The memory management strategy depends on the value of the xDel
        /// parameter. If the value passed is SQLITE_TRANSIENT, then the
        /// string is copied into a (possibly existing) buffer managed by the
        /// Mem structure. Otherwise, any existing buffer is freed and the
        /// pointer copied.
        ///
        /// If the string is too large (if it exceeds the SQLITE_LIMIT_LENGTH
        /// size limit) then no memory allocation occurs.  If the string can be
        /// stored without allocating memory, then it is.  If a memory allocation
        /// is required to store the string, then value of pMem is unchanged.  In
        /// either case, SQLITE_TOOBIG is returned.
        /// </summary>
        /// <param name='pMem'>
        /// Memory cell to set to string value.
        /// </param>
        /// <param name='zBlob'>
        /// Blob pointer
        /// </param>
        /// <param name='n'>
        /// Bytes in Blob
        /// </param>
        /// <param name='enc'>
        /// 0 for BLOBs
        /// </param>
        /// <param name='xDel'>
        /// Destructor function
        /// </param>
        static int sqlite3VdbeMemSetBlob(
		Mem pMem,
		byte[] zBlob,
		int n,
		u8 enc,
		dxDel xDel
		)
        {
            return sqlite3VdbeMemSetBlob(pMem, zBlob, 0, n >= 0 ? n : zBlob.Length, enc, xDel);
        }