public FuncDef(short nArg, byte iPrefEnc, FUNC iflags, object pUserData, FuncDef pNext, dxFunc xFunc, dxStep xStep, dxFinal xFinalize, string zName, FuncDef pHash, FuncDestructor pDestructor)
{
this.nArg = nArg;
this.iPrefEnc = iPrefEnc;
this.flags = iflags;
this.pUserData = pUserData;
this.pNext = pNext;
this.xFunc = xFunc;
this.xStep = xStep;
this.xFinalize = xFinalize;
this.zName = zName;
this.pHash = pHash;
this.pDestructor = pDestructor;
}
public _aFuncs(string zName, int nArg, u8 eTextRep, dxFunc xFunc)
{
this.zName = zName;
this.nArg = nArg;
this.eTextRep = eTextRep;
this.xFunc = xFunc;
}
public FuncDef(string zName, byte iPrefEnc, short nArg, int iArg, FUNC iflags, dxFunc xFunc)
{
this.nArg = nArg;
this.iPrefEnc = iPrefEnc;
this.flags = iflags;
this.pUserData = iArg;
this.pNext = null;
this.xFunc = xFunc;
this.xStep = null;
this.xFinalize = null;
this.zName = zName;
}
public FuncDef(string zName, byte iPrefEnc, short nArg, object arg, dxFunc xFunc, FUNC flags)
{
this.nArg = nArg;
this.iPrefEnc = iPrefEnc;
this.flags = flags;
this.pUserData = arg;
this.pNext = null;
this.xFunc = xFunc;
this.xStep = null;
this.xFinalize = null;
this.zName = zName;
}
public FuncDef(string zName, byte iPrefEnc, short nArg, int iArg, FUNC iflags, dxFunc xFunc)
{
this.nArg = nArg;
this.iPrefEnc = iPrefEnc;
this.flags = iflags;
this.pUserData = iArg;
this.pNext = null;
this.xFunc = xFunc;
this.xStep = null;
this.xFinalize = null;
this.zName = zName;
}
public FuncDef(short nArg, byte iPrefEnc, FUNC iflags, object pUserData, FuncDef pNext, dxFunc xFunc, dxStep xStep, dxFinal xFinalize, string zName, FuncDef pHash, FuncDestructor pDestructor)
{
this.nArg = nArg;
this.iPrefEnc = iPrefEnc;
this.flags = iflags;
this.pUserData = pUserData;
this.pNext = pNext;
this.xFunc = xFunc;
this.xStep = xStep;
this.xFinalize = xFinalize;
this.zName = zName;
this.pHash = pHash;
this.pDestructor = pDestructor;
}
/*
** This is the xFindFunction implementation for the echo module.
** SQLite calls this routine when the first argument of a function
** is a column of an echo virtual table. This routine can optionally
** override the implementation of that function. It will choose to
** do so if the function is named "glob", and a TCL command named
** ::echo_glob_overload exists.
*/
static int echoFindFunction(
sqlite3_vtab vtab,
int nArg,
string zFuncName,
ref dxFunc pxFunc, //void (**pxFunc)(sqlite3_context*,int,sqlite3_value),
ref object ppArg
)
{
echo_vtab pVtab = (echo_vtab)vtab;
Tcl_Interp interp = pVtab.interp;
Tcl_CmdInfo info;
if ( !zFuncName.StartsWith( "glob", StringComparison.InvariantCultureIgnoreCase ) )
{
return 0;
}
TCL.Tcl_GetCommandInfo( interp, "::echo_glob_overload", out info );
if ( info ==null)
{
return 0;
}
pxFunc = overloadedGlobFunction;
ppArg = interp;
return 1;
}
public dxFunc xFunc; //(sqlite3_context*,int,sqlite3_value **);
// Constructor
public sFuncs(string zName, sbyte nArg, u8 argType, u8 eTextRep, u8 needCollSeq, dxFunc xFunc)
{
this.zName = zName;
this.nArg = nArg;
this.argType = argType;
this.eTextRep = eTextRep;
this.needCollSeq = needCollSeq;
this.xFunc = xFunc;
}
static int sqlite3_create_function16(
sqlite3 db,
string zFunctionName,
int nArg,
int eTextRep,
object p,
dxFunc xFunc, //)(sqlite3_context*,int,sqlite3_value*),
dxStep xStep, //)(sqlite3_context*,int,sqlite3_value*),
dxFinal xFinal //)(sqlite3_context)
){
int rc;
string zFunc8;
sqlite3_mutex_enter(db.mutex);
Debug.Assert( 0==db.mallocFailed );
zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1, SQLITE_UTF16NATIVE);
rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal, null);
sqlite3DbFree(db,ref zFunc8);
rc = sqlite3ApiExit(db, rc);
sqlite3_mutex_leave(db.mutex);
return rc;
}
static int sqlite3_create_function_v2(
sqlite3 db,
string zFunc,
int nArg,
int enc,
object p,
dxFunc xFunc, //)(sqlite3_context*,int,sqlite3_value *),
dxStep xStep,//)(sqlite3_context*,int,sqlite3_value *),
dxFinal xFinal,//)(sqlite3_context)
dxFDestroy xDestroy//)(void )
)
{
int rc = SQLITE_ERROR;
FuncDestructor pArg = null;
sqlite3_mutex_enter( db.mutex );
if ( xDestroy != null )
{
pArg = new FuncDestructor();//(FuncDestructor )sqlite3DbMallocZero(db, sizeof(FuncDestructor));
//if( null==pArg ){
// xDestroy(p);
// goto out;
//}
pArg.xDestroy = xDestroy;
pArg.pUserData = p;
}
rc = sqlite3CreateFunc( db, zFunc, nArg, (byte)enc, p, xFunc, xStep, xFinal, pArg );
if ( pArg != null && pArg.nRef == 0 )
{
Debug.Assert( rc != SQLITE_OK );
//xDestroy(p);
sqlite3DbFree( db, ref pArg );
}
//_out:
rc = sqlite3ApiExit( db, rc );
sqlite3_mutex_leave( db.mutex );
return rc;
}
/*
** Create new user functions.
*/
static public int sqlite3_create_function(
sqlite3 db,
string zFunc,
int nArg,
u8 enc,
object p,
dxFunc xFunc, //)(sqlite3_context*,int,sqlite3_value *),
dxStep xStep,//)(sqlite3_context*,int,sqlite3_value *),
dxFinal xFinal//)(sqlite3_context)
)
{
return sqlite3_create_function_v2( db, zFunc, nArg, enc, p, xFunc, xStep,
xFinal, null );
}
/*
** This function is exactly the same as sqlite3_create_function(), except
** that it is designed to be called by internal code. The difference is
** that if a malloc() fails in sqlite3_create_function(), an error code
** is returned and the mallocFailed flag cleared.
*/
static int sqlite3CreateFunc(
sqlite3 db,
string zFunctionName,
int nArg,
u8 enc,
object pUserData,
dxFunc xFunc, //)(sqlite3_context*,int,sqlite3_value *),
dxStep xStep,//)(sqlite3_context*,int,sqlite3_value *),
dxFinal xFinal, //)(sqlite3_context),
FuncDestructor pDestructor
)
{
FuncDef p;
int nName;
Debug.Assert( sqlite3_mutex_held( db.mutex ) );
if ( zFunctionName == null ||
( xFunc != null && ( xFinal != null || xStep != null ) ) ||
( xFunc == null && ( xFinal != null && xStep == null ) ) ||
( xFunc == null && ( xFinal == null && xStep != null ) ) ||
( nArg < -1 || nArg > SQLITE_MAX_FUNCTION_ARG ) ||
( 255 < ( nName = sqlite3Strlen30( zFunctionName ) ) ) )
{
return SQLITE_MISUSE_BKPT();
}
#if !SQLITE_OMIT_UTF16
/* If SQLITE_UTF16 is specified as the encoding type, transform this
** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
**
** If SQLITE_ANY is specified, add three versions of the function
** to the hash table.
*/
if( enc==SQLITE_UTF16 ){
enc = SQLITE_UTF16NATIVE;
}else if( enc==SQLITE_ANY ){
int rc;
rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8,
pUserData, xFunc, xStep, xFinal, pDestructor);
if( rc==SQLITE_OK ){
rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE,
pUserData, xFunc, xStep, xFinal, pDestructor);
}
if( rc!=SQLITE_OK ){
return rc;
}
enc = SQLITE_UTF16BE;
}
#else
enc = SQLITE_UTF8;
#endif
/* Check if an existing function is being overridden or deleted. If so,
** and there are active VMs, then return SQLITE_BUSY. If a function
** is being overridden/deleted but there are no active VMs, allow the
** operation to continue but invalidate all precompiled statements.
*/
p = sqlite3FindFunction( db, zFunctionName, nName, nArg, enc, 0 );
if ( p != null && p.iPrefEnc == enc && p.nArg == nArg )
{
if ( db.activeVdbeCnt != 0 )
{
sqlite3Error( db, SQLITE_BUSY,
"unable to delete/modify user-function due to active statements" );
//Debug.Assert( 0 == db.mallocFailed );
return SQLITE_BUSY;
}
else
{
sqlite3ExpirePreparedStatements( db );
}
}
p = sqlite3FindFunction( db, zFunctionName, nName, nArg, enc, 1 );
Debug.Assert( p != null /*|| db.mallocFailed != 0 */ );
//if ( p == null )
//{
// return SQLITE_NOMEM;
//}
/* If an older version of the function with a configured destructor is
** being replaced invoke the destructor function here. */
functionDestroy( db, p );
if ( pDestructor != null )
{
pDestructor.nRef++;
}
p.pDestructor = pDestructor;
p.flags = 0;
p.xFunc = xFunc;
p.xStep = xStep;
p.xFinalize = xFinal;
p.pUserData = pUserData;
p.nArg = (i16)nArg;
return SQLITE_OK;
}
/*
** The first parameter (pDef) is a function implementation. The
** second parameter (pExpr) is the first argument to this function.
** If pExpr is a column in a virtual table, then let the virtual
** table implementation have an opportunity to overload the function.
**
** This routine is used to allow virtual table implementations to
** overload MATCH, LIKE, GLOB, and REGEXP operators.
**
** Return either the pDef argument (indicating no change) or a
** new FuncDef structure that is marked as ephemeral using the
** SQLITE_FUNC_EPHEM flag.
*/
static FuncDef sqlite3VtabOverloadFunction(
sqlite3 db, /* Database connection for reporting malloc problems */
FuncDef pDef, /* Function to possibly overload */
int nArg, /* Number of arguments to the function */
Expr pExpr /* First argument to the function */
)
{
Table pTab;
sqlite3_vtab pVtab;
sqlite3_module pMod;
dxFunc xFunc = null;//void (*xFunc)(sqlite3_context*,int,sqlite3_value*) = 0;
object pArg = null;
FuncDef pNew;
int rc = 0;
string zLowerName;
string z;
/* Check to see the left operand is a column in a virtual table */
if (NEVER(pExpr == null))
{
return(pDef);
}
if (pExpr.op != TK_COLUMN)
{
return(pDef);
}
pTab = pExpr.pTab;
if (NEVER(pTab == null))
{
return(pDef);
}
if ((pTab.tabFlags & TF_Virtual) == 0)
{
return(pDef);
}
pVtab = sqlite3GetVTable(db, pTab).pVtab;
Debug.Assert(pVtab != null);
Debug.Assert(pVtab.pModule != null);
pMod = (sqlite3_module)pVtab.pModule;
if (pMod.xFindFunction == null)
{
return(pDef);
}
/* Call the xFindFunction method on the virtual table implementation
** to see if the implementation wants to overload this function
*/
zLowerName = pDef.zName;//sqlite3DbStrDup(db, pDef.zName);
if (zLowerName != null)
{
//for(z=(unsigned char)zLowerName; *z; z++){
// *z = sqlite3UpperToLower[*z];
//}
rc = pMod.xFindFunction(pVtab, nArg, zLowerName.ToLowerInvariant(), ref xFunc, ref pArg);
sqlite3DbFree(db, ref zLowerName);
}
if (rc == 0)
{
return(pDef);
}
/* Create a new ephemeral function definition for the overloaded
** function */
//sqlite3DbMallocZero(db, sizeof(*pNew)
// + sqlite3Strlen30(pDef.zName) + 1);
//if ( pNew == null )
//{
// return pDef;
//}
pNew = pDef.Copy();
pNew.zName = pDef.zName;
//pNew.zName = (char )&pNew[1];
//memcpy(pNew.zName, pDef.zName, sqlite3Strlen30(pDef.zName)+1);
pNew.xFunc = xFunc;
pNew.pUserData = pArg;
pNew.flags |= SQLITE_FUNC_EPHEM;
return(pNew);
}
/*
** Create new user functions.
*/
static public int sqlite3_create_function(
sqlite3 db,
string zFunctionName,
int nArg,
u8 enc,
object p,
dxFunc xFunc, //)(sqlite3_context*,int,sqlite3_value **),
dxStep xStep,//)(sqlite3_context*,int,sqlite3_value **),
dxFinal xFinal//)(sqlite3_context*)
)
{
int rc;
sqlite3_mutex_enter( db.mutex );
rc = sqlite3CreateFunc( db, zFunctionName, nArg, enc, p, xFunc, xStep, xFinal );
rc = sqlite3ApiExit( db, rc );
sqlite3_mutex_leave( db.mutex );
return rc;
}
public _aFuncs( string zName, int nArg, u8 eTextRep, dxFunc xFunc )
{
this.zName = zName;
this.nArg = nArg;
this.eTextRep = eTextRep;
this.xFunc = xFunc;
}
public FuncDef(string zName, byte iPrefEnc, short nArg, object arg, dxFunc xFunc, FUNC flags)
{
this.nArg = nArg;
this.iPrefEnc = iPrefEnc;
this.flags = flags;
this.pUserData = arg;
this.pNext = null;
this.xFunc = xFunc;
this.xStep = null;
this.xFinalize = null;
this.zName = zName;
}
