2198 lines
No EOL
58 KiB
C#
2198 lines
No EOL
58 KiB
C#
using System;
|
|
using System.Diagnostics;
|
|
using System.Text;
|
|
using i64 = System.Int64;
|
|
|
|
using sqlite3_int64 = System.Int64;
|
|
|
|
using u32 = System.UInt32;
|
|
using u8 = System.Byte;
|
|
|
|
namespace Community.CsharpSqlite
|
|
{
|
|
using sqlite_int64 = System.Int64;
|
|
using sqlite3_value = Sqlite3.Mem;
|
|
|
|
public partial class Sqlite3
|
|
{
|
|
/*
|
|
** 2002 February 23
|
|
**
|
|
** The author disclaims copyright to this source code. In place of
|
|
** a legal notice, here is a blessing:
|
|
**
|
|
** May you do good and not evil.
|
|
** May you find forgiveness for yourself and forgive others.
|
|
** May you share freely, never taking more than you give.
|
|
**
|
|
*************************************************************************
|
|
** This file contains the C functions that implement various SQL
|
|
** functions of SQLite.
|
|
**
|
|
** There is only one exported symbol in this file - the function
|
|
** sqliteRegisterBuildinFunctions() found at the bottom of the file.
|
|
** All other code has file scope.
|
|
*************************************************************************
|
|
** Included in SQLite3 port to C#-SQLite; 2008 Noah B Hart
|
|
** C#-SQLite is an independent reimplementation of the SQLite software library
|
|
**
|
|
** SQLITE_SOURCE_ID: 2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2
|
|
**
|
|
*************************************************************************
|
|
*/
|
|
//#include "sqliteInt.h"
|
|
//#include <stdlib.h>
|
|
//#include <assert.h>
|
|
//#include "vdbeInt.h"
|
|
|
|
/*
|
|
** Return the collating function associated with a function.
|
|
*/
|
|
|
|
private static CollSeq sqlite3GetFuncCollSeq(sqlite3_context context)
|
|
{
|
|
return context.pColl;
|
|
}
|
|
|
|
/*
|
|
** Implementation of the non-aggregate min() and max() functions
|
|
*/
|
|
|
|
private static void minmaxFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
int i;
|
|
int mask; /* 0 for min() or 0xffffffff for max() */
|
|
int iBest;
|
|
CollSeq pColl;
|
|
|
|
Debug.Assert(argc > 1);
|
|
mask = (int)sqlite3_user_data(context) == 0 ? 0 : -1;
|
|
pColl = sqlite3GetFuncCollSeq(context);
|
|
Debug.Assert(pColl != null);
|
|
Debug.Assert(mask == -1 || mask == 0);
|
|
testcase(mask == 0);
|
|
iBest = 0;
|
|
if (sqlite3_value_type(argv[0]) == SQLITE_NULL)
|
|
return;
|
|
for (i = 1; i < argc; i++)
|
|
{
|
|
if (sqlite3_value_type(argv[i]) == SQLITE_NULL)
|
|
return;
|
|
if ((sqlite3MemCompare(argv[iBest], argv[i], pColl) ^ mask) >= 0)
|
|
{
|
|
iBest = i;
|
|
}
|
|
}
|
|
sqlite3_result_value(context, argv[iBest]);
|
|
}
|
|
|
|
/*
|
|
** Return the type of the argument.
|
|
*/
|
|
|
|
private static void typeofFunc(
|
|
sqlite3_context context,
|
|
int NotUsed,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
string z = "";
|
|
UNUSED_PARAMETER(NotUsed);
|
|
switch (sqlite3_value_type(argv[0]))
|
|
{
|
|
case SQLITE_INTEGER:
|
|
z = "integer";
|
|
break;
|
|
|
|
case SQLITE_TEXT:
|
|
z = "text";
|
|
break;
|
|
|
|
case SQLITE_FLOAT:
|
|
z = "real";
|
|
break;
|
|
|
|
case SQLITE_BLOB:
|
|
z = "blob";
|
|
break;
|
|
|
|
default:
|
|
z = "null";
|
|
break;
|
|
}
|
|
sqlite3_result_text(context, z, -1, SQLITE_STATIC);
|
|
}
|
|
|
|
/*
|
|
** Implementation of the length() function
|
|
*/
|
|
|
|
private static void lengthFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
int len;
|
|
|
|
Debug.Assert(argc == 1);
|
|
UNUSED_PARAMETER(argc);
|
|
switch (sqlite3_value_type(argv[0]))
|
|
{
|
|
case SQLITE_BLOB:
|
|
case SQLITE_INTEGER:
|
|
case SQLITE_FLOAT:
|
|
{
|
|
sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
|
|
break;
|
|
}
|
|
case SQLITE_TEXT:
|
|
{
|
|
byte[] z = sqlite3_value_blob(argv[0]);
|
|
if (z == null)
|
|
return;
|
|
len = 0;
|
|
int iz = 0;
|
|
while (iz < z.Length && z[iz] != '\0')
|
|
{
|
|
len++;
|
|
SQLITE_SKIP_UTF8(z, ref iz);
|
|
}
|
|
sqlite3_result_int(context, len);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
sqlite3_result_null(context);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Implementation of the abs() function.
|
|
**
|
|
** IMP: R-23979-26855 The abs(X) function returns the absolute value of
|
|
** the numeric argument X.
|
|
*/
|
|
|
|
private static void absFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
Debug.Assert(argc == 1);
|
|
UNUSED_PARAMETER(argc);
|
|
switch (sqlite3_value_type(argv[0]))
|
|
{
|
|
case SQLITE_INTEGER:
|
|
{
|
|
i64 iVal = sqlite3_value_int64(argv[0]);
|
|
if (iVal < 0)
|
|
{
|
|
if ((iVal << 1) == 0)
|
|
{
|
|
/* IMP: R-35460-15084 If X is the integer -9223372036854775807 then
|
|
** abs(X) throws an integer overflow error since there is no
|
|
** equivalent positive 64-bit two complement value. */
|
|
sqlite3_result_error(context, "integer overflow", -1);
|
|
return;
|
|
}
|
|
iVal = -iVal;
|
|
}
|
|
sqlite3_result_int64(context, iVal);
|
|
break;
|
|
}
|
|
case SQLITE_NULL:
|
|
{
|
|
/* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */
|
|
sqlite3_result_null(context);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
/* Because sqlite3_value_double() returns 0.0 if the argument is not
|
|
** something that can be converted into a number, we have:
|
|
** IMP: R-57326-31541 Abs(X) return 0.0 if X is a string or blob that
|
|
** cannot be converted to a numeric value.
|
|
*/
|
|
double rVal = sqlite3_value_double(argv[0]);
|
|
if (rVal < 0)
|
|
rVal = -rVal;
|
|
sqlite3_result_double(context, rVal);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Implementation of the substr() function.
|
|
**
|
|
** substr(x,p1,p2) returns p2 characters of x[] beginning with p1.
|
|
** p1 is 1-indexed. So substr(x,1,1) returns the first character
|
|
** of x. If x is text, then we actually count UTF-8 characters.
|
|
** If x is a blob, then we count bytes.
|
|
**
|
|
** If p1 is negative, then we begin abs(p1) from the end of x[].
|
|
**
|
|
** If p2 is negative, return the p2 characters preceeding p1.
|
|
*/
|
|
|
|
private static void substrFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
string z = "";
|
|
byte[] zBLOB = null;
|
|
string z2;
|
|
int len;
|
|
int p0type;
|
|
int p1, p2;
|
|
int negP2 = 0;
|
|
|
|
Debug.Assert(argc == 3 || argc == 2);
|
|
if (sqlite3_value_type(argv[1]) == SQLITE_NULL
|
|
|| (argc == 3 && sqlite3_value_type(argv[2]) == SQLITE_NULL)
|
|
)
|
|
{
|
|
return;
|
|
}
|
|
p0type = sqlite3_value_type(argv[0]);
|
|
p1 = sqlite3_value_int(argv[1]);
|
|
if (p0type == SQLITE_BLOB)
|
|
{
|
|
len = sqlite3_value_bytes(argv[0]);
|
|
zBLOB = argv[0].zBLOB;
|
|
if (zBLOB == null)
|
|
return;
|
|
Debug.Assert(len == zBLOB.Length);
|
|
}
|
|
else
|
|
{
|
|
z = sqlite3_value_text(argv[0]);
|
|
if (String.IsNullOrEmpty(z))
|
|
return;
|
|
len = 0;
|
|
if (p1 < 0)
|
|
{
|
|
len = z.Length;
|
|
//for ( z2 = z ; z2 != "" ; len++ )
|
|
//{
|
|
// SQLITE_SKIP_UTF8( ref z2 );
|
|
//}
|
|
}
|
|
}
|
|
if (argc == 3)
|
|
{
|
|
p2 = sqlite3_value_int(argv[2]);
|
|
if (p2 < 0)
|
|
{
|
|
p2 = -p2;
|
|
negP2 = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p2 = (sqlite3_context_db_handle(context)).aLimit[SQLITE_LIMIT_LENGTH];
|
|
}
|
|
if (p1 < 0)
|
|
{
|
|
p1 += len;
|
|
if (p1 < 0)
|
|
{
|
|
p2 += p1;
|
|
if (p2 < 0)
|
|
p2 = 0;
|
|
p1 = 0;
|
|
}
|
|
}
|
|
else if (p1 > 0)
|
|
{
|
|
p1--;
|
|
}
|
|
else if (p2 > 0)
|
|
{
|
|
p2--;
|
|
}
|
|
if (negP2 != 0)
|
|
{
|
|
p1 -= p2;
|
|
if (p1 < 0)
|
|
{
|
|
p2 += p1;
|
|
p1 = 0;
|
|
}
|
|
}
|
|
Debug.Assert(p1 >= 0 && p2 >= 0);
|
|
if (p0type != SQLITE_BLOB)
|
|
{
|
|
//while ( z != "" && p1 != 0 )
|
|
//{
|
|
// SQLITE_SKIP_UTF8( ref z );
|
|
// p1--;
|
|
//}
|
|
//for ( z2 = z ; z2 != "" && p2 != 0 ; p2-- )
|
|
//{
|
|
// SQLITE_SKIP_UTF8( ref z2 );
|
|
//}
|
|
sqlite3_result_text(context, z, p1, p2 <= z.Length - p1 ? p2 : z.Length - p1, SQLITE_TRANSIENT);
|
|
}
|
|
else
|
|
{
|
|
if (p1 + p2 > len)
|
|
{
|
|
p2 = len - p1;
|
|
if (p2 < 0)
|
|
p2 = 0;
|
|
}
|
|
StringBuilder sb = new StringBuilder(zBLOB.Length);
|
|
if (zBLOB.Length == 0 || p1 > zBLOB.Length)
|
|
sb.Length = 0;
|
|
else
|
|
{
|
|
for (int i = p1; i < p1 + p2; i++)
|
|
{
|
|
sb.Append((char)zBLOB[i]);
|
|
}
|
|
}
|
|
|
|
sqlite3_result_blob(context, sb.ToString(), (int)p2, SQLITE_TRANSIENT);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Implementation of the round() function
|
|
*/
|
|
#if !SQLITE_OMIT_FLOATING_POINT
|
|
|
|
private static void roundFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
int n = 0;
|
|
double r;
|
|
string zBuf = "";
|
|
Debug.Assert(argc == 1 || argc == 2);
|
|
if (argc == 2)
|
|
{
|
|
if (SQLITE_NULL == sqlite3_value_type(argv[1]))
|
|
return;
|
|
n = sqlite3_value_int(argv[1]);
|
|
if (n > 30)
|
|
n = 30;
|
|
if (n < 0)
|
|
n = 0;
|
|
}
|
|
if (sqlite3_value_type(argv[0]) == SQLITE_NULL)
|
|
return;
|
|
r = sqlite3_value_double(argv[0]);
|
|
/* If Y==0 and X will fit in a 64-bit int,
|
|
** handle the rounding directly,
|
|
** otherwise use printf.
|
|
*/
|
|
if (n == 0 && r >= 0 && r < LARGEST_INT64 - 1)
|
|
{
|
|
r = (double)((sqlite_int64)(r + 0.5));
|
|
}
|
|
else if (n == 0 && r < 0 && (-r) < LARGEST_INT64 - 1)
|
|
{
|
|
r = -(double)((sqlite_int64)((-r) + 0.5));
|
|
}
|
|
else
|
|
{
|
|
zBuf = sqlite3_mprintf("%.*f", n, r);
|
|
if (zBuf == null)
|
|
{
|
|
sqlite3_result_error_nomem(context);
|
|
return;
|
|
}
|
|
sqlite3AtoF(zBuf, ref r, sqlite3Strlen30(zBuf), SQLITE_UTF8);
|
|
//sqlite3_free( ref zBuf );
|
|
}
|
|
sqlite3_result_double(context, r);
|
|
}
|
|
|
|
#endif
|
|
|
|
/*
|
|
** Allocate nByte bytes of space using sqlite3_malloc(). If the
|
|
** allocation fails, call sqlite3_result_error_nomem() to notify
|
|
** the database handle that malloc() has failed and return NULL.
|
|
** If nByte is larger than the maximum string or blob length, then
|
|
** raise an SQLITE_TOOBIG exception and return NULL.
|
|
*/
|
|
//static void* contextMalloc( sqlite3_context* context, i64 nByte )
|
|
//{
|
|
// char* z;
|
|
// sqlite3* db = sqlite3_context_db_handle( context );
|
|
// assert( nByte > 0 );
|
|
// testcase( nByte == db->aLimit[SQLITE_LIMIT_LENGTH] );
|
|
// testcase( nByte == db->aLimit[SQLITE_LIMIT_LENGTH] + 1 );
|
|
// if ( nByte > db->aLimit[SQLITE_LIMIT_LENGTH] )
|
|
// {
|
|
// sqlite3_result_error_toobig( context );
|
|
// z = 0;
|
|
// }
|
|
// else
|
|
// {
|
|
// z = sqlite3Malloc( (int)nByte );
|
|
// if ( !z )
|
|
// {
|
|
// sqlite3_result_error_nomem( context );
|
|
// }
|
|
// }
|
|
// return z;
|
|
//}
|
|
|
|
/*
|
|
** Implementation of the upper() and lower() SQL functions.
|
|
*/
|
|
|
|
private static void upperFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
string z1;
|
|
string z2;
|
|
int i, n;
|
|
UNUSED_PARAMETER(argc);
|
|
z2 = sqlite3_value_text(argv[0]);
|
|
n = sqlite3_value_bytes(argv[0]);
|
|
/* Verify that the call to _bytes() does not invalidate the _text() pointer */
|
|
//Debug.Assert( z2 == sqlite3_value_text( argv[0] ) );
|
|
if (z2 != null)
|
|
{
|
|
//z1 = new byte[n];// contextMalloc(context, ((i64)n)+1);
|
|
//if ( z1 !=null)
|
|
//{
|
|
// memcpy( z1, z2, n + 1 );
|
|
//for ( i = 0 ; i< z1.Length ; i++ )
|
|
//{
|
|
//(char)sqlite3Toupper( z1[i] );
|
|
//}
|
|
sqlite3_result_text(context, z2.Length == 0 ? "" : z2.Substring(0, n).ToUpper(), -1, null); //sqlite3_free );
|
|
// }
|
|
}
|
|
}
|
|
|
|
private static void lowerFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
string z1;
|
|
string z2;
|
|
int i, n;
|
|
UNUSED_PARAMETER(argc);
|
|
z2 = sqlite3_value_text(argv[0]);
|
|
n = sqlite3_value_bytes(argv[0]);
|
|
/* Verify that the call to _bytes() does not invalidate the _text() pointer */
|
|
//Debug.Assert( z2 == sqlite3_value_text( argv[0] ) );
|
|
if (z2 != null)
|
|
{
|
|
//z1 = contextMalloc(context, ((i64)n)+1);
|
|
//if ( z1 )
|
|
//{
|
|
// memcpy( z1, z2, n + 1 );
|
|
// for ( i = 0 ; z1[i] ; i++ )
|
|
// {
|
|
// z1[i] = (char)sqlite3Tolower( z1[i] );
|
|
// }
|
|
sqlite3_result_text(context, z2.Length == 0 ? "" : z2.Substring(0, n).ToLower(), -1, null);//sqlite3_free );
|
|
//}
|
|
}
|
|
}
|
|
|
|
#if FALSE //* This function is never used. */
|
|
/*
|
|
** The COALESCE() and IFNULL() functions used to be implemented as shown
|
|
** here. But now they are implemented as VDBE code so that unused arguments
|
|
** do not have to be computed. This legacy implementation is retained as
|
|
** comment.
|
|
*/
|
|
/*
|
|
** Implementation of the IFNULL(), NVL(), and COALESCE() functions.
|
|
** All three do the same thing. They return the first non-NULL
|
|
** argument.
|
|
*/
|
|
static void ifnullFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
int i;
|
|
for ( i = 0 ; i < argc ; i++ )
|
|
{
|
|
if ( SQLITE_NULL != sqlite3_value_type( argv[i] ) )
|
|
{
|
|
sqlite3_result_value( context, argv[i] );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif //* NOT USED */
|
|
//#define ifnullFunc versionFunc /* Substitute function - never called */
|
|
|
|
/*
|
|
** Implementation of random(). Return a random integer.
|
|
*/
|
|
|
|
private static void randomFunc(
|
|
sqlite3_context context,
|
|
int NotUsed,
|
|
sqlite3_value[] NotUsed2
|
|
)
|
|
{
|
|
sqlite_int64 r = 0;
|
|
UNUSED_PARAMETER2(NotUsed, NotUsed2);
|
|
sqlite3_randomness(sizeof(sqlite_int64), ref r);
|
|
if (r < 0)
|
|
{
|
|
/* We need to prevent a random number of 0x8000000000000000
|
|
** (or -9223372036854775808) since when you do abs() of that
|
|
** number of you get the same value back again. To do this
|
|
** in a way that is testable, mask the sign bit off of negative
|
|
** values, resulting in a positive value. Then take the
|
|
** 2s complement of that positive value. The end result can
|
|
** therefore be no less than -9223372036854775807.
|
|
*/
|
|
r = -(r ^ (((sqlite3_int64)1) << 63));
|
|
}
|
|
sqlite3_result_int64(context, r);
|
|
}
|
|
|
|
/*
|
|
** Implementation of randomblob(N). Return a random blob
|
|
** that is N bytes long.
|
|
*/
|
|
|
|
private static void randomBlob(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
int n;
|
|
char[] p;
|
|
Debug.Assert(argc == 1);
|
|
UNUSED_PARAMETER(argc);
|
|
n = sqlite3_value_int(argv[0]);
|
|
if (n < 1)
|
|
{
|
|
n = 1;
|
|
}
|
|
if (n > sqlite3_context_db_handle(context).aLimit[SQLITE_LIMIT_LENGTH])
|
|
{
|
|
sqlite3_result_error_toobig(context);
|
|
p = null;
|
|
}
|
|
else
|
|
{
|
|
p = new char[n]; //contextMalloc( context, n );
|
|
}
|
|
if (p != null)
|
|
{
|
|
i64 _p = 0;
|
|
for (int i = 0; i < n; i++)
|
|
{
|
|
sqlite3_randomness(sizeof(u8), ref _p);
|
|
p[i] = (char)(_p & 0x7F);
|
|
}
|
|
sqlite3_result_blob(context, new string(p), n, null);//sqlite3_free );
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Implementation of the last_insert_rowid() SQL function. The return
|
|
** value is the same as the sqlite3_last_insert_rowid() API function.
|
|
*/
|
|
|
|
private static void last_insert_rowid(
|
|
sqlite3_context context,
|
|
int NotUsed,
|
|
sqlite3_value[] NotUsed2
|
|
)
|
|
{
|
|
sqlite3 db = sqlite3_context_db_handle(context);
|
|
UNUSED_PARAMETER2(NotUsed, NotUsed2);
|
|
/* IMP: R-51513-12026 The last_insert_rowid() SQL function is a
|
|
** wrapper around the sqlite3_last_insert_rowid() C/C++ interface
|
|
** function. */
|
|
sqlite3_result_int64(context, sqlite3_last_insert_rowid(db));
|
|
}
|
|
|
|
/*
|
|
** Implementation of the changes() SQL function.
|
|
**
|
|
** IMP: R-62073-11209 The changes() SQL function is a wrapper
|
|
** around the sqlite3_changes() C/C++ function and hence follows the same
|
|
** rules for counting changes.
|
|
*/
|
|
|
|
private static void changes(
|
|
sqlite3_context context,
|
|
int NotUsed,
|
|
sqlite3_value[] NotUsed2
|
|
)
|
|
{
|
|
sqlite3 db = sqlite3_context_db_handle(context);
|
|
UNUSED_PARAMETER2(NotUsed, NotUsed2);
|
|
sqlite3_result_int(context, sqlite3_changes(db));
|
|
}
|
|
|
|
/*
|
|
** Implementation of the total_changes() SQL function. The return value is
|
|
** the same as the sqlite3_total_changes() API function.
|
|
*/
|
|
|
|
private static void total_changes(
|
|
sqlite3_context context,
|
|
int NotUsed,
|
|
sqlite3_value[] NotUsed2
|
|
)
|
|
{
|
|
sqlite3 db = (sqlite3)sqlite3_context_db_handle(context);
|
|
UNUSED_PARAMETER2(NotUsed, NotUsed2);
|
|
/* IMP: R-52756-41993 This function is a wrapper around the
|
|
** sqlite3_total_changes() C/C++ interface. */
|
|
sqlite3_result_int(context, sqlite3_total_changes(db));
|
|
}
|
|
|
|
/*
|
|
** A structure defining how to do GLOB-style comparisons.
|
|
*/
|
|
|
|
private struct compareInfo
|
|
{
|
|
public char matchAll;
|
|
public char matchOne;
|
|
public char matchSet;
|
|
public bool noCase;
|
|
|
|
public compareInfo(char matchAll, char matchOne, char matchSet, bool noCase)
|
|
{
|
|
this.matchAll = matchAll;
|
|
this.matchOne = matchOne;
|
|
this.matchSet = matchSet;
|
|
this.noCase = noCase;
|
|
}
|
|
};
|
|
|
|
/*
|
|
** For LIKE and GLOB matching on EBCDIC machines, assume that every
|
|
** character is exactly one byte in size. Also, all characters are
|
|
** able to participate in upper-case-to-lower-case mappings in EBCDIC
|
|
** whereas only characters less than 0x80 do in ASCII.
|
|
*/
|
|
//#if defined(SQLITE_EBCDIC)
|
|
//# define sqlite3Utf8Read(A,C) (*(A++))
|
|
//# define GlogUpperToLower(A) A = sqlite3UpperToLower[A]
|
|
//#else
|
|
//# define GlogUpperToLower(A) if( !((A)&~0x7f) ){ A = sqlite3UpperToLower[A]; }
|
|
//#endif
|
|
|
|
private static compareInfo globInfo = new compareInfo('*', '?', '[', false);
|
|
/* The correct SQL-92 behavior is for the LIKE operator to ignore
|
|
** case. Thus 'a' LIKE 'A' would be true. */
|
|
private static compareInfo likeInfoNorm = new compareInfo('%', '_', '\0', true);
|
|
/* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
|
|
** is case sensitive causing 'a' LIKE 'A' to be false */
|
|
private static compareInfo likeInfoAlt = new compareInfo('%', '_', '\0', false);
|
|
|
|
/*
|
|
** Compare two UTF-8 strings for equality where the first string can
|
|
** potentially be a "glob" expression. Return true (1) if they
|
|
** are the same and false (0) if they are different.
|
|
**
|
|
** Globbing rules:
|
|
**
|
|
** '*' Matches any sequence of zero or more characters.
|
|
**
|
|
** '?' Matches exactly one character.
|
|
**
|
|
** [...] Matches one character from the enclosed list of
|
|
** characters.
|
|
**
|
|
** [^...] Matches one character not in the enclosed list.
|
|
**
|
|
** With the [...] and [^...] matching, a ']' character can be included
|
|
** in the list by making it the first character after '[' or '^'. A
|
|
** range of characters can be specified using '-'. Example:
|
|
** "[a-z]" matches any single lower-case letter. To match a '-', make
|
|
** it the last character in the list.
|
|
**
|
|
** This routine is usually quick, but can be N**2 in the worst case.
|
|
**
|
|
** Hints: to match '*' or '?', put them in "[]". Like this:
|
|
**
|
|
** abc[*]xyz Matches "abc*xyz" only
|
|
*/
|
|
|
|
private static bool patternCompare(
|
|
string zPattern, /* The glob pattern */
|
|
string zString, /* The string to compare against the glob */
|
|
compareInfo pInfo, /* Information about how to do the compare */
|
|
u32 esc /* The escape character */
|
|
)
|
|
{
|
|
u32 c, c2;
|
|
int invert;
|
|
int seen;
|
|
int matchOne = (int)pInfo.matchOne;
|
|
int matchAll = (int)pInfo.matchAll;
|
|
int matchSet = (int)pInfo.matchSet;
|
|
bool noCase = pInfo.noCase;
|
|
bool prevEscape = false; /* True if the previous character was 'escape' */
|
|
string inPattern = zPattern; //Entered Pattern
|
|
|
|
while ((c = sqlite3Utf8Read(zPattern, ref zPattern)) != 0)
|
|
{
|
|
if (!prevEscape && c == matchAll)
|
|
{
|
|
while ((c = sqlite3Utf8Read(zPattern, ref zPattern)) == matchAll
|
|
|| c == matchOne)
|
|
{
|
|
if (c == matchOne && sqlite3Utf8Read(zString, ref zString) == 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
if (c == 0)
|
|
{
|
|
return true;
|
|
}
|
|
else if (c == esc)
|
|
{
|
|
c = sqlite3Utf8Read(zPattern, ref zPattern);
|
|
if (c == 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else if (c == matchSet)
|
|
{
|
|
Debug.Assert(esc == 0); /* This is GLOB, not LIKE */
|
|
Debug.Assert(matchSet < 0x80); /* '[' is a single-byte character */
|
|
int len = 0;
|
|
while (len < zString.Length && patternCompare(inPattern.Substring(inPattern.Length - zPattern.Length - 1), zString.Substring(len), pInfo, esc) == false)
|
|
{
|
|
SQLITE_SKIP_UTF8(zString, ref len);
|
|
}
|
|
return len < zString.Length;
|
|
}
|
|
while ((c2 = sqlite3Utf8Read(zString, ref zString)) != 0)
|
|
{
|
|
if (noCase)
|
|
{
|
|
if (0 == ((c2) & ~0x7f))
|
|
c2 = (u32)sqlite3UpperToLower[c2]; //GlogUpperToLower(c2);
|
|
if (0 == ((c) & ~0x7f))
|
|
c = (u32)sqlite3UpperToLower[c]; //GlogUpperToLower(c);
|
|
while (c2 != 0 && c2 != c)
|
|
{
|
|
c2 = sqlite3Utf8Read(zString, ref zString);
|
|
if (0 == ((c2) & ~0x7f))
|
|
c2 = (u32)sqlite3UpperToLower[c2]; //GlogUpperToLower(c2);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (c2 != 0 && c2 != c)
|
|
{
|
|
c2 = sqlite3Utf8Read(zString, ref zString);
|
|
}
|
|
}
|
|
if (c2 == 0)
|
|
return false;
|
|
if (patternCompare(zPattern, zString, pInfo, esc))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
else if (!prevEscape && c == matchOne)
|
|
{
|
|
if (sqlite3Utf8Read(zString, ref zString) == 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else if (c == matchSet)
|
|
{
|
|
u32 prior_c = 0;
|
|
Debug.Assert(esc == 0); /* This only occurs for GLOB, not LIKE */
|
|
seen = 0;
|
|
invert = 0;
|
|
c = sqlite3Utf8Read(zString, ref zString);
|
|
if (c == 0)
|
|
return false;
|
|
c2 = sqlite3Utf8Read(zPattern, ref zPattern);
|
|
if (c2 == '^')
|
|
{
|
|
invert = 1;
|
|
c2 = sqlite3Utf8Read(zPattern, ref zPattern);
|
|
}
|
|
if (c2 == ']')
|
|
{
|
|
if (c == ']')
|
|
seen = 1;
|
|
c2 = sqlite3Utf8Read(zPattern, ref zPattern);
|
|
}
|
|
while (c2 != 0 && c2 != ']')
|
|
{
|
|
if (c2 == '-' && zPattern[0] != ']' && zPattern[0] != 0 && prior_c > 0)
|
|
{
|
|
c2 = sqlite3Utf8Read(zPattern, ref zPattern);
|
|
if (c >= prior_c && c <= c2)
|
|
seen = 1;
|
|
prior_c = 0;
|
|
}
|
|
else
|
|
{
|
|
if (c == c2)
|
|
{
|
|
seen = 1;
|
|
}
|
|
prior_c = c2;
|
|
}
|
|
c2 = sqlite3Utf8Read(zPattern, ref zPattern);
|
|
}
|
|
if (c2 == 0 || (seen ^ invert) == 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else if (esc == c && !prevEscape)
|
|
{
|
|
prevEscape = true;
|
|
}
|
|
else
|
|
{
|
|
c2 = sqlite3Utf8Read(zString, ref zString);
|
|
if (noCase)
|
|
{
|
|
if (c < 0x80)
|
|
c = (u32)sqlite3UpperToLower[c]; //GlogUpperToLower(c);
|
|
if (c2 < 0x80)
|
|
c2 = (u32)sqlite3UpperToLower[c2]; //GlogUpperToLower(c2);
|
|
}
|
|
if (c != c2)
|
|
{
|
|
return false;
|
|
}
|
|
prevEscape = false;
|
|
}
|
|
}
|
|
return zString.Length == 0;
|
|
}
|
|
|
|
/*
|
|
** Count the number of times that the LIKE operator (or GLOB which is
|
|
** just a variation of LIKE) gets called. This is used for testing
|
|
** only.
|
|
*/
|
|
#if SQLITE_TEST
|
|
#if !TCLSH
|
|
static int sqlite3_like_count = 0;
|
|
#else
|
|
static tcl.lang.Var.SQLITE3_GETSET sqlite3_like_count = new tcl.lang.Var.SQLITE3_GETSET( "sqlite3_like_count" );
|
|
#endif
|
|
#endif
|
|
|
|
/*
|
|
** Implementation of the like() SQL function. This function implements
|
|
** the build-in LIKE operator. The first argument to the function is the
|
|
** pattern and the second argument is the string. So, the SQL statements:
|
|
**
|
|
** A LIKE B
|
|
**
|
|
** is implemented as like(B,A).
|
|
**
|
|
** This same function (with a different compareInfo structure) computes
|
|
** the GLOB operator.
|
|
*/
|
|
|
|
private static void likeFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
string zA, zB;
|
|
u32 escape = 0;
|
|
int nPat;
|
|
sqlite3 db = sqlite3_context_db_handle(context);
|
|
|
|
zB = sqlite3_value_text(argv[0]);
|
|
zA = sqlite3_value_text(argv[1]);
|
|
|
|
/* Limit the length of the LIKE or GLOB pattern to avoid problems
|
|
** of deep recursion and N*N behavior in patternCompare().
|
|
*/
|
|
nPat = sqlite3_value_bytes(argv[0]);
|
|
testcase(nPat == db.aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]);
|
|
testcase(nPat == db.aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] + 1);
|
|
if (nPat > db.aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH])
|
|
{
|
|
sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
|
|
return;
|
|
}
|
|
//Debug.Assert( zB == sqlite3_value_text( argv[0] ) ); /* Encoding did not change */
|
|
|
|
if (argc == 3)
|
|
{
|
|
/* The escape character string must consist of a single UTF-8 character.
|
|
** Otherwise, return an error.
|
|
*/
|
|
string zEsc = sqlite3_value_text(argv[2]);
|
|
if (zEsc == null)
|
|
return;
|
|
if (sqlite3Utf8CharLen(zEsc, -1) != 1)
|
|
{
|
|
sqlite3_result_error(context,
|
|
"ESCAPE expression must be a single character", -1);
|
|
return;
|
|
}
|
|
escape = sqlite3Utf8Read(zEsc, ref zEsc);
|
|
}
|
|
if (zA != null && zB != null)
|
|
{
|
|
compareInfo pInfo = (compareInfo)sqlite3_user_data(context);
|
|
#if SQLITE_TEST
|
|
#if !TCLSH
|
|
sqlite3_like_count++;
|
|
#else
|
|
sqlite3_like_count.iValue++;
|
|
#endif
|
|
#endif
|
|
sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape) ? 1 : 0);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Implementation of the NULLIF(x,y) function. The result is the first
|
|
** argument if the arguments are different. The result is NULL if the
|
|
** arguments are equal to each other.
|
|
*/
|
|
|
|
private static void nullifFunc(
|
|
sqlite3_context context,
|
|
int NotUsed,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
CollSeq pColl = sqlite3GetFuncCollSeq(context);
|
|
UNUSED_PARAMETER(NotUsed);
|
|
if (sqlite3MemCompare(argv[0], argv[1], pColl) != 0)
|
|
{
|
|
sqlite3_result_value(context, argv[0]);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Implementation of the sqlite_version() function. The result is the version
|
|
** of the SQLite library that is running.
|
|
*/
|
|
|
|
private static void versionFunc(
|
|
sqlite3_context context,
|
|
int NotUsed,
|
|
sqlite3_value[] NotUsed2
|
|
)
|
|
{
|
|
UNUSED_PARAMETER2(NotUsed, NotUsed2);
|
|
/* IMP: R-48699-48617 This function is an SQL wrapper around the
|
|
** sqlite3_libversion() C-interface. */
|
|
sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC);
|
|
}
|
|
|
|
/*
|
|
** Implementation of the sqlite_source_id() function. The result is a string
|
|
** that identifies the particular version of the source code used to build
|
|
** SQLite.
|
|
*/
|
|
|
|
private static void sourceidFunc(
|
|
sqlite3_context context,
|
|
int NotUsed,
|
|
sqlite3_value[] NotUsed2
|
|
)
|
|
{
|
|
UNUSED_PARAMETER2(NotUsed, NotUsed2);
|
|
/* IMP: R-24470-31136 This function is an SQL wrapper around the
|
|
** sqlite3_sourceid() C interface. */
|
|
sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC);
|
|
}
|
|
|
|
/*
|
|
** Implementation of the sqlite_log() function. This is a wrapper around
|
|
** sqlite3_log(). The return value is NULL. The function exists purely for
|
|
** its side-effects.
|
|
*/
|
|
|
|
private static void errlogFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
UNUSED_PARAMETER(argc);
|
|
UNUSED_PARAMETER(context);
|
|
sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1]));
|
|
}
|
|
|
|
/*
|
|
** Implementation of the sqlite_compileoption_used() function.
|
|
** The result is an integer that identifies if the compiler option
|
|
** was used to build SQLite.
|
|
*/
|
|
#if !SQLITE_OMIT_COMPILEOPTION_DIAGS
|
|
|
|
private static void compileoptionusedFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
string zOptName;
|
|
Debug.Assert(argc == 1);
|
|
UNUSED_PARAMETER(argc);
|
|
/* IMP: R-39564-36305 The sqlite_compileoption_used() SQL
|
|
** function is a wrapper around the sqlite3_compileoption_used() C/C++
|
|
** function.
|
|
*/
|
|
if ((zOptName = sqlite3_value_text(argv[0])) != null)
|
|
{
|
|
sqlite3_result_int(context, sqlite3_compileoption_used(zOptName));
|
|
}
|
|
}
|
|
|
|
#endif //* SQLITE_OMIT_COMPILEOPTION_DIAGS */
|
|
|
|
/*
|
|
** Implementation of the sqlite_compileoption_get() function.
|
|
** The result is a string that identifies the compiler options
|
|
** used to build SQLite.
|
|
*/
|
|
#if !SQLITE_OMIT_COMPILEOPTION_DIAGS
|
|
|
|
private static void compileoptiongetFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
int n;
|
|
Debug.Assert(argc == 1);
|
|
UNUSED_PARAMETER(argc);
|
|
/* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function
|
|
** is a wrapper around the sqlite3_compileoption_get() C/C++ function.
|
|
*/
|
|
n = sqlite3_value_int(argv[0]);
|
|
sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC);
|
|
}
|
|
|
|
#endif //* SQLITE_OMIT_COMPILEOPTION_DIAGS */
|
|
|
|
/* Array for converting from half-bytes (nybbles) into ASCII hex
|
|
** digits. */
|
|
|
|
private static char[] hexdigits = new char[] {
|
|
'0', '1', '2', '3', '4', '5', '6', '7',
|
|
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
|
|
};
|
|
|
|
/*
|
|
** EXPERIMENTAL - This is not an official function. The interface may
|
|
** change. This function may disappear. Do not write code that depends
|
|
** on this function.
|
|
**
|
|
** Implementation of the QUOTE() function. This function takes a single
|
|
** argument. If the argument is numeric, the return value is the same as
|
|
** the argument. If the argument is NULL, the return value is the string
|
|
** "NULL". Otherwise, the argument is enclosed in single quotes with
|
|
** single-quote escapes.
|
|
*/
|
|
|
|
private static void quoteFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
Debug.Assert(argc == 1);
|
|
UNUSED_PARAMETER(argc);
|
|
|
|
switch (sqlite3_value_type(argv[0]))
|
|
{
|
|
case SQLITE_INTEGER:
|
|
case SQLITE_FLOAT:
|
|
{
|
|
sqlite3_result_value(context, argv[0]);
|
|
break;
|
|
}
|
|
case SQLITE_BLOB:
|
|
{
|
|
StringBuilder zText;
|
|
byte[] zBlob = sqlite3_value_blob(argv[0]);
|
|
int nBlob = sqlite3_value_bytes(argv[0]);
|
|
Debug.Assert(zBlob.Length == sqlite3_value_blob(argv[0]).Length); /* No encoding change */
|
|
zText = new StringBuilder(2 * nBlob + 4);//(char*)contextMalloc(context, (2*(i64)nBlob)+4);
|
|
zText.Append("X'");
|
|
if (zText != null)
|
|
{
|
|
int i;
|
|
for (i = 0; i < nBlob; i++)
|
|
{
|
|
zText.Append(hexdigits[(zBlob[i] >> 4) & 0x0F]);
|
|
zText.Append(hexdigits[(zBlob[i]) & 0x0F]);
|
|
}
|
|
zText.Append("'");
|
|
//zText[( nBlob * 2 ) + 2] = '\'';
|
|
//zText[( nBlob * 2 ) + 3] = '\0';
|
|
//zText[0] = 'X';
|
|
//zText[1] = '\'';
|
|
sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT);
|
|
//sqlite3_free( zText );
|
|
}
|
|
break;
|
|
}
|
|
case SQLITE_TEXT:
|
|
{
|
|
int i, j;
|
|
int n;
|
|
string zArg = sqlite3_value_text(argv[0]);
|
|
StringBuilder z;
|
|
|
|
if (zArg == null || zArg.Length == 0)
|
|
return;
|
|
for (i = 0, n = 0; i < zArg.Length; i++)
|
|
{
|
|
if (zArg[i] == '\'')
|
|
n++;
|
|
}
|
|
z = new StringBuilder(i + n + 3);// contextMalloc(context, ((i64)i)+((i64)n)+3);
|
|
if (z != null)
|
|
{
|
|
z.Append('\'');
|
|
for (i = 0, j = 1; i < zArg.Length && zArg[i] != 0; i++)
|
|
{
|
|
z.Append((char)zArg[i]);
|
|
j++;
|
|
if (zArg[i] == '\'')
|
|
{
|
|
z.Append('\'');
|
|
j++;
|
|
}
|
|
}
|
|
z.Append('\'');
|
|
j++;
|
|
//z[j] = '\0';
|
|
sqlite3_result_text(context, z, j, null);//sqlite3_free );
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
Debug.Assert(sqlite3_value_type(argv[0]) == SQLITE_NULL);
|
|
sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** The hex() function. Interpret the argument as a blob. Return
|
|
** a hexadecimal rendering as text.
|
|
*/
|
|
|
|
private static void hexFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
int i, n;
|
|
byte[] pBlob;
|
|
//string zHex, z;
|
|
Debug.Assert(argc == 1);
|
|
UNUSED_PARAMETER(argc);
|
|
pBlob = sqlite3_value_blob(argv[0]);
|
|
n = sqlite3_value_bytes(argv[0]);
|
|
Debug.Assert(n == (pBlob == null ? 0 : pBlob.Length)); /* No encoding change */
|
|
StringBuilder zHex = new StringBuilder(n * 2 + 1);
|
|
// z = zHex = contextMalloc(context, ((i64)n)*2 + 1);
|
|
if (zHex != null)
|
|
{
|
|
for (i = 0; i < n; i++)
|
|
{//, pBlob++){
|
|
byte c = pBlob[i];
|
|
zHex.Append(hexdigits[(c >> 4) & 0xf]);
|
|
zHex.Append(hexdigits[c & 0xf]);
|
|
}
|
|
sqlite3_result_text(context, zHex, n * 2, null); //sqlite3_free );
|
|
}
|
|
}
|
|
|
|
/*
|
|
** The zeroblob(N) function returns a zero-filled blob of size N bytes.
|
|
*/
|
|
|
|
private static void zeroblobFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
i64 n;
|
|
sqlite3 db = sqlite3_context_db_handle(context);
|
|
Debug.Assert(argc == 1);
|
|
UNUSED_PARAMETER(argc);
|
|
n = sqlite3_value_int64(argv[0]);
|
|
testcase(n == db.aLimit[SQLITE_LIMIT_LENGTH]);
|
|
testcase(n == db.aLimit[SQLITE_LIMIT_LENGTH] + 1);
|
|
if (n > db.aLimit[SQLITE_LIMIT_LENGTH])
|
|
{
|
|
sqlite3_result_error_toobig(context);
|
|
}
|
|
else
|
|
{
|
|
sqlite3_result_zeroblob(context, (int)n);/* IMP: R-00293-64994 */
|
|
}
|
|
}
|
|
|
|
/*
|
|
** The replace() function. Three arguments are all strings: call
|
|
** them A, B, and C. The result is also a string which is derived
|
|
** from A by replacing every occurance of B with C. The match
|
|
** must be exact. Collating sequences are not used.
|
|
*/
|
|
|
|
private static void replaceFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
string zStr; /* The input string A */
|
|
string zPattern; /* The pattern string B */
|
|
string zRep; /* The replacement string C */
|
|
string zOut = null; /* The output */
|
|
int nStr; /* Size of zStr */
|
|
int nOut; /* Maximum size of zOut */
|
|
//int loopLimit; /* Last zStr[] that might match zPattern[] */
|
|
int i, j = 0; /* Loop counters */
|
|
|
|
Debug.Assert(argc == 3);
|
|
UNUSED_PARAMETER(argc);
|
|
zStr = sqlite3_value_text(argv[0]);
|
|
if (zStr == null)
|
|
return;
|
|
nStr = sqlite3_value_bytes(argv[0]);
|
|
Debug.Assert(zStr == sqlite3_value_text(argv[0])); /* No encoding change */
|
|
zPattern = sqlite3_value_text(argv[1]);
|
|
if (zPattern == null)
|
|
{
|
|
Debug.Assert(sqlite3_value_type(argv[1]) == SQLITE_NULL
|
|
//|| sqlite3_context_db_handle( context ).mallocFailed != 0
|
|
);
|
|
return;
|
|
}
|
|
if (zPattern == "")
|
|
{
|
|
Debug.Assert(sqlite3_value_type(argv[1]) != SQLITE_NULL);
|
|
sqlite3_result_value(context, argv[0]);
|
|
return;
|
|
}
|
|
////nPattern = sqlite3_value_bytes( argv[1] );
|
|
Debug.Assert(zPattern == sqlite3_value_text(argv[1])); /* No encoding change */
|
|
zRep = sqlite3_value_text(argv[2]);
|
|
if (zRep == null)
|
|
return;
|
|
////nRep = sqlite3_value_bytes( argv[2] );
|
|
Debug.Assert(zRep == sqlite3_value_text(argv[2]));
|
|
nOut = nStr + 1;
|
|
Debug.Assert(nOut < SQLITE_MAX_LENGTH);
|
|
if (nOut <= sqlite3_context_db_handle(context).aLimit[SQLITE_LIMIT_LENGTH])
|
|
{
|
|
//int nPattern; /* Size of zPattern */
|
|
//int nRep; /* Size of zRep */
|
|
//zOut = contextMalloc(context, (i64)nOut);
|
|
//if( zOut==0 ){
|
|
// return;
|
|
//}
|
|
//loopLimit = nStr - nPattern;
|
|
//for(i=j=0; i<=loopLimit; i++){
|
|
// if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){
|
|
// zOut[j++] = zStr[i];
|
|
// }else{
|
|
// u8 *zOld;
|
|
// sqlite3 db = sqlite3_context_db_handle( context );
|
|
// nOut += nRep - nPattern;
|
|
//testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );
|
|
//testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
|
|
//if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
|
|
// sqlite3_result_error_toobig(context);
|
|
// sqlite3_free(zOut);
|
|
// return;
|
|
// }
|
|
// zOld = zOut;
|
|
// zOut = sqlite3_realloc(zOut, (int)nOut);
|
|
// if( zOut==0 ){
|
|
// sqlite3_result_error_nomem(context);
|
|
// sqlite3_free(zOld);
|
|
// return;
|
|
// }
|
|
// memcpy(&zOut[j], zRep, nRep);
|
|
// j += nRep;
|
|
// i += nPattern-1;
|
|
// }
|
|
//}
|
|
//Debug.Assert( j+nStr-i+1==nOut );
|
|
//memcpy(&zOut[j], zStr[i], nStr-i);
|
|
//j += nStr - i;
|
|
//Debug.Assert( j<=nOut );
|
|
//zOut[j] = 0;
|
|
try
|
|
{
|
|
zOut = zStr.Replace(zPattern, zRep);
|
|
j = zOut.Length;
|
|
}
|
|
catch
|
|
{
|
|
j = 0;
|
|
}
|
|
}
|
|
if (j == 0 || j > sqlite3_context_db_handle(context).aLimit[SQLITE_LIMIT_LENGTH])
|
|
{
|
|
sqlite3_result_error_toobig(context);
|
|
}
|
|
else
|
|
{
|
|
sqlite3_result_text(context, zOut, j, null);//sqlite3_free );
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Implementation of the TRIM(), LTRIM(), and RTRIM() functions.
|
|
** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both.
|
|
*/
|
|
|
|
private static void trimFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
string zIn; /* Input string */
|
|
string zCharSet; /* Set of characters to trim */
|
|
int nIn; /* Number of bytes in input */
|
|
int izIn = 0; /* C# string pointer */
|
|
int flags; /* 1: trimleft 2: trimright 3: trim */
|
|
int i; /* Loop counter */
|
|
int[] aLen = null; /* Length of each character in zCharSet */
|
|
byte[][] azChar = null; /* Individual characters in zCharSet */
|
|
int nChar = 0; /* Number of characters in zCharSet */
|
|
byte[] zBytes = null;
|
|
byte[] zBlob = null;
|
|
|
|
if (sqlite3_value_type(argv[0]) == SQLITE_NULL)
|
|
{
|
|
return;
|
|
}
|
|
zIn = sqlite3_value_text(argv[0]);
|
|
if (zIn == null)
|
|
return;
|
|
nIn = sqlite3_value_bytes(argv[0]);
|
|
zBlob = sqlite3_value_blob(argv[0]);
|
|
//Debug.Assert( zIn == sqlite3_value_text( argv[0] ) );
|
|
if (argc == 1)
|
|
{
|
|
int[] lenOne = new int[] { 1 };
|
|
byte[] azOne = new byte[] { (u8)' ' };//static unsigned char * const azOne[] = { (u8*)" " };
|
|
nChar = 1;
|
|
aLen = lenOne;
|
|
azChar = new byte[1][];
|
|
azChar[0] = azOne;
|
|
zCharSet = null;
|
|
}
|
|
else if ((zCharSet = sqlite3_value_text(argv[1])) == null)
|
|
{
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if ((zBytes = sqlite3_value_blob(argv[1])) != null)
|
|
{
|
|
int iz = 0;
|
|
for (nChar = 0; iz < zBytes.Length; nChar++)
|
|
{
|
|
SQLITE_SKIP_UTF8(zBytes, ref iz);
|
|
}
|
|
if (nChar > 0)
|
|
{
|
|
azChar = new byte[nChar][];//contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1));
|
|
if (azChar == null)
|
|
{
|
|
return;
|
|
}
|
|
aLen = new int[nChar];
|
|
|
|
int iz0 = 0;
|
|
int iz1 = 0;
|
|
for (int ii = 0; ii < nChar; ii++)
|
|
{
|
|
SQLITE_SKIP_UTF8(zBytes, ref iz1);
|
|
aLen[ii] = iz1 - iz0;
|
|
azChar[ii] = new byte[aLen[ii]];
|
|
Buffer.BlockCopy(zBytes, iz0, azChar[ii], 0, azChar[ii].Length);
|
|
iz0 = iz1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (nChar > 0)
|
|
{
|
|
flags = (int)sqlite3_user_data(context); // flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
|
|
if ((flags & 1) != 0)
|
|
{
|
|
while (nIn > 0)
|
|
{
|
|
int len = 0;
|
|
for (i = 0; i < nChar; i++)
|
|
{
|
|
len = aLen[i];
|
|
if (len <= nIn && memcmp(zBlob, izIn, azChar[i], len) == 0)
|
|
break;
|
|
}
|
|
if (i >= nChar)
|
|
break;
|
|
izIn += len;
|
|
nIn -= len;
|
|
}
|
|
}
|
|
if ((flags & 2) != 0)
|
|
{
|
|
while (nIn > 0)
|
|
{
|
|
int len = 0;
|
|
for (i = 0; i < nChar; i++)
|
|
{
|
|
len = aLen[i];
|
|
if (len <= nIn && memcmp(zBlob, izIn + nIn - len, azChar[i], len) == 0)
|
|
break;
|
|
}
|
|
if (i >= nChar)
|
|
break;
|
|
nIn -= len;
|
|
}
|
|
}
|
|
if (zCharSet != null)
|
|
{
|
|
//sqlite3_free( ref azChar );
|
|
}
|
|
}
|
|
StringBuilder sb = new StringBuilder(nIn);
|
|
for (i = 0; i < nIn; i++)
|
|
sb.Append((char)zBlob[izIn + i]);
|
|
sqlite3_result_text(context, sb, nIn, SQLITE_TRANSIENT);
|
|
}
|
|
|
|
/* IMP: R-25361-16150 This function is omitted from SQLite by default. It
|
|
** is only available if the SQLITE_SOUNDEX compile-time option is used
|
|
** when SQLite is built.
|
|
*/
|
|
#if SQLITE_SOUNDEX
|
|
/*
|
|
** Compute the soundex encoding of a word.
|
|
**
|
|
** IMP: R-59782-00072 The soundex(X) function returns a string that is the
|
|
** soundex encoding of the string X.
|
|
*/
|
|
static void soundexFunc(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
Debug.Assert(false); // TODO -- func_c
|
|
char zResult[8];
|
|
const u8 *zIn;
|
|
int i, j;
|
|
static const unsigned char iCode[] = {
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
|
|
1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
|
|
0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
|
|
1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
|
|
};
|
|
Debug.Assert( argc==1 );
|
|
zIn = (u8*)sqlite3_value_text(argv[0]);
|
|
if( zIn==0 ) zIn = (u8*)"";
|
|
for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){}
|
|
if( zIn[i] ){
|
|
u8 prevcode = iCode[zIn[i]&0x7f];
|
|
zResult[0] = sqlite3Toupper(zIn[i]);
|
|
for(j=1; j<4 && zIn[i]; i++){
|
|
int code = iCode[zIn[i]&0x7f];
|
|
if( code>0 ){
|
|
if( code!=prevcode ){
|
|
prevcode = code;
|
|
zResult[j++] = code + '0';
|
|
}
|
|
}else{
|
|
prevcode = 0;
|
|
}
|
|
}
|
|
while( j<4 ){
|
|
zResult[j++] = '0';
|
|
}
|
|
zResult[j] = 0;
|
|
sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT);
|
|
}else{
|
|
/* IMP: R-64894-50321 The string "?000" is returned if the argument
|
|
** is NULL or contains no ASCII alphabetic characters. */
|
|
sqlite3_result_text(context, "?000", 4, SQLITE_STATIC);
|
|
}
|
|
}
|
|
#endif //* SQLITE_SOUNDEX */
|
|
|
|
#if !SQLITE_OMIT_LOAD_EXTENSION
|
|
/*
|
|
** A function that loads a shared-library extension then returns NULL.
|
|
*/
|
|
|
|
private static void loadExt(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
string zFile = sqlite3_value_text(argv[0]);
|
|
string zProc;
|
|
sqlite3 db = (sqlite3)sqlite3_context_db_handle(context);
|
|
string zErrMsg = "";
|
|
|
|
if (argc == 2)
|
|
{
|
|
zProc = sqlite3_value_text(argv[1]);
|
|
}
|
|
else
|
|
{
|
|
zProc = "";
|
|
}
|
|
if (zFile != null && sqlite3_load_extension(db, zFile, zProc, ref zErrMsg) != 0)
|
|
{
|
|
sqlite3_result_error(context, zErrMsg, -1);
|
|
sqlite3DbFree(db, ref zErrMsg);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
/*
|
|
** An instance of the following structure holds the context of a
|
|
** sum() or avg() aggregate computation.
|
|
*/
|
|
|
|
//typedef struct SumCtx SumCtx;
|
|
public class SumCtx
|
|
{
|
|
public double rSum; /* Floating point sum */
|
|
public i64 iSum; /* Integer sum */
|
|
public i64 cnt; /* Number of elements summed */
|
|
public int overflow; /* True if integer overflow seen */
|
|
public bool approx; /* True if non-integer value was input to the sum */
|
|
public Mem _M;
|
|
|
|
public Mem Context
|
|
{
|
|
get
|
|
{
|
|
return _M;
|
|
}
|
|
set
|
|
{
|
|
_M = value;
|
|
if (_M == null || _M.z == null)
|
|
iSum = 0;
|
|
else
|
|
iSum = Convert.ToInt64(_M.z);
|
|
}
|
|
}
|
|
};
|
|
|
|
/*
|
|
** Routines used to compute the sum, average, and total.
|
|
**
|
|
** The SUM() function follows the (broken) SQL standard which means
|
|
** that it returns NULL if it sums over no inputs. TOTAL returns
|
|
** 0.0 in that case. In addition, TOTAL always returns a float where
|
|
** SUM might return an integer if it never encounters a floating point
|
|
** value. TOTAL never fails, but SUM might through an exception if
|
|
** it overflows an integer.
|
|
*/
|
|
|
|
private static void sumStep(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
SumCtx p;
|
|
|
|
int type;
|
|
Debug.Assert(argc == 1);
|
|
UNUSED_PARAMETER(argc);
|
|
Mem pMem = sqlite3_aggregate_context(context, 1);//sizeof(*p));
|
|
if (pMem._SumCtx == null)
|
|
pMem._SumCtx = new SumCtx();
|
|
p = pMem._SumCtx;
|
|
if (p.Context == null)
|
|
p.Context = pMem;
|
|
type = sqlite3_value_numeric_type(argv[0]);
|
|
if (p != null && type != SQLITE_NULL)
|
|
{
|
|
p.cnt++;
|
|
if (type == SQLITE_INTEGER)
|
|
{
|
|
i64 v = sqlite3_value_int64(argv[0]);
|
|
p.rSum += v;
|
|
if (!(p.approx | p.overflow != 0) && 0 != sqlite3AddInt64(ref p.iSum, v))
|
|
{
|
|
p.overflow = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p.rSum += sqlite3_value_double(argv[0]);
|
|
p.approx = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void sumFinalize(sqlite3_context context)
|
|
{
|
|
SumCtx p = null;
|
|
Mem pMem = sqlite3_aggregate_context(context, 0);
|
|
if (pMem != null)
|
|
p = pMem._SumCtx;
|
|
if (p != null && p.cnt > 0)
|
|
{
|
|
if (p.overflow != 0)
|
|
{
|
|
sqlite3_result_error(context, "integer overflow", -1);
|
|
}
|
|
else if (p.approx)
|
|
{
|
|
sqlite3_result_double(context, p.rSum);
|
|
}
|
|
else
|
|
{
|
|
sqlite3_result_int64(context, p.iSum);
|
|
}
|
|
p.cnt = 0; // Reset for C#
|
|
}
|
|
}
|
|
|
|
private static void avgFinalize(sqlite3_context context)
|
|
{
|
|
SumCtx p = null;
|
|
Mem pMem = sqlite3_aggregate_context(context, 0);
|
|
if (pMem != null)
|
|
p = pMem._SumCtx;
|
|
if (p != null && p.cnt > 0)
|
|
{
|
|
sqlite3_result_double(context, p.rSum / (double)p.cnt);
|
|
}
|
|
}
|
|
|
|
private static void totalFinalize(sqlite3_context context)
|
|
{
|
|
SumCtx p = null;
|
|
Mem pMem = sqlite3_aggregate_context(context, 0);
|
|
if (pMem != null)
|
|
p = pMem._SumCtx;
|
|
/* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
|
|
sqlite3_result_double(context, p != null ? p.rSum : (double)0);
|
|
}
|
|
|
|
/*
|
|
** The following structure keeps track of state information for the
|
|
** count() aggregate function.
|
|
*/
|
|
|
|
//typedef struct CountCtx CountCtx;
|
|
public class CountCtx
|
|
{
|
|
private i64 _n;
|
|
private Mem _M;
|
|
|
|
public Mem Context
|
|
{
|
|
get
|
|
{
|
|
return _M;
|
|
}
|
|
set
|
|
{
|
|
_M = value;
|
|
if (_M == null || _M.z == null)
|
|
_n = 0;
|
|
else
|
|
_n = Convert.ToInt64(_M.z);
|
|
}
|
|
}
|
|
|
|
public i64 n
|
|
{
|
|
get
|
|
{
|
|
return _n;
|
|
}
|
|
set
|
|
{
|
|
_n = value;
|
|
if (_M != null)
|
|
_M.z = _n.ToString();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Routines to implement the count() aggregate function.
|
|
*/
|
|
|
|
private static void countStep(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
CountCtx p = new CountCtx();
|
|
p.Context = sqlite3_aggregate_context(context, 1);//sizeof(*p));
|
|
if ((argc == 0 || SQLITE_NULL != sqlite3_value_type(argv[0])) && p.Context != null)
|
|
{
|
|
p.n++;
|
|
}
|
|
#if !SQLITE_OMIT_DEPRECATED
|
|
/* The sqlite3_aggregate_count() function is deprecated. But just to make
|
|
** sure it still operates correctly, verify that its count agrees with our
|
|
** internal count when using count(*) and when the total count can be
|
|
** expressed as a 32-bit integer. */
|
|
Debug.Assert( argc == 1 || p == null || p.n > 0x7fffffff
|
|
|| p.n == sqlite3_aggregate_count( context ) );
|
|
#endif
|
|
}
|
|
|
|
private static void countFinalize(sqlite3_context context)
|
|
{
|
|
CountCtx p = new CountCtx();
|
|
p.Context = sqlite3_aggregate_context(context, 0);
|
|
sqlite3_result_int64(context, p != null ? p.n : 0);
|
|
}
|
|
|
|
/*
|
|
** Routines to implement min() and max() aggregate functions.
|
|
*/
|
|
|
|
private static void minmaxStep(
|
|
sqlite3_context context,
|
|
int NotUsed,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
Mem pArg = (Mem)argv[0];
|
|
Mem pBest;
|
|
UNUSED_PARAMETER(NotUsed);
|
|
|
|
if (sqlite3_value_type(argv[0]) == SQLITE_NULL)
|
|
return;
|
|
pBest = (Mem)sqlite3_aggregate_context(context, 1);//sizeof(*pBest));
|
|
//if ( pBest == null ) return;
|
|
|
|
if (pBest.flags != 0)
|
|
{
|
|
bool max;
|
|
int cmp;
|
|
CollSeq pColl = sqlite3GetFuncCollSeq(context);
|
|
/* This step function is used for both the min() and max() aggregates,
|
|
** the only difference between the two being that the sense of the
|
|
** comparison is inverted. For the max() aggregate, the
|
|
** sqlite3_context_db_handle() function returns (void *)-1. For min() it
|
|
** returns (void *)db, where db is the sqlite3* database pointer.
|
|
** Therefore the next statement sets variable 'max' to 1 for the max()
|
|
** aggregate, or 0 for min().
|
|
*/
|
|
max = sqlite3_context_db_handle(context) != null && (int)sqlite3_user_data(context) != 0;
|
|
cmp = sqlite3MemCompare(pBest, pArg, pColl);
|
|
if ((max && cmp < 0) || (!max && cmp > 0))
|
|
{
|
|
sqlite3VdbeMemCopy(pBest, pArg);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sqlite3VdbeMemCopy(pBest, pArg);
|
|
}
|
|
}
|
|
|
|
private static void minMaxFinalize(sqlite3_context context)
|
|
{
|
|
sqlite3_value pRes;
|
|
pRes = (sqlite3_value)sqlite3_aggregate_context(context, 0);
|
|
if (pRes != null)
|
|
{
|
|
if (ALWAYS(pRes.flags != 0))
|
|
{
|
|
sqlite3_result_value(context, pRes);
|
|
}
|
|
sqlite3VdbeMemRelease(pRes);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** group_concat(EXPR, ?SEPARATOR?)
|
|
*/
|
|
|
|
private static void groupConcatStep(
|
|
sqlite3_context context,
|
|
int argc,
|
|
sqlite3_value[] argv
|
|
)
|
|
{
|
|
string zVal;
|
|
//StrAccum pAccum;
|
|
string zSep;
|
|
int nVal, nSep;
|
|
Debug.Assert(argc == 1 || argc == 2);
|
|
if (sqlite3_value_type(argv[0]) == SQLITE_NULL)
|
|
return;
|
|
Mem pMem = sqlite3_aggregate_context(context, 1);//sizeof(*pAccum));
|
|
if (pMem._StrAccum == null)
|
|
pMem._StrAccum = new StrAccum(100);
|
|
//pAccum = pMem._StrAccum;
|
|
|
|
//if ( pMem._StrAccum != null )
|
|
//{
|
|
sqlite3 db = sqlite3_context_db_handle(context);
|
|
//int firstTerm = pMem._StrAccum.useMalloc == 0 ? 1 : 0;
|
|
//pMem._StrAccum.useMalloc = 2;
|
|
pMem._StrAccum.mxAlloc = db.aLimit[SQLITE_LIMIT_LENGTH];
|
|
if (pMem._StrAccum.Context == null) // first term
|
|
pMem._StrAccum.Context = pMem;
|
|
else
|
|
{
|
|
if (argc == 2)
|
|
{
|
|
zSep = sqlite3_value_text(argv[1]);
|
|
nSep = sqlite3_value_bytes(argv[1]);
|
|
}
|
|
else
|
|
{
|
|
zSep = ",";
|
|
nSep = 1;
|
|
}
|
|
sqlite3StrAccumAppend(pMem._StrAccum, zSep, nSep);
|
|
}
|
|
zVal = sqlite3_value_text(argv[0]);
|
|
nVal = sqlite3_value_bytes(argv[0]);
|
|
sqlite3StrAccumAppend(pMem._StrAccum, zVal, nVal);
|
|
//}
|
|
}
|
|
|
|
private static void groupConcatFinalize(sqlite3_context context)
|
|
{
|
|
//StrAccum pAccum = null;
|
|
Mem pMem = sqlite3_aggregate_context(context, 0);
|
|
if (pMem != null)
|
|
{
|
|
if (pMem._StrAccum == null)
|
|
pMem._StrAccum = new StrAccum(100);
|
|
StrAccum pAccum = pMem._StrAccum;
|
|
//}
|
|
//if ( pAccum != null )
|
|
//{
|
|
if (pAccum.tooBig)
|
|
{
|
|
sqlite3_result_error_toobig(context);
|
|
}
|
|
//else if ( pAccum.mallocFailed != 0 )
|
|
//{
|
|
// sqlite3_result_error_nomem( context );
|
|
//}
|
|
else
|
|
{
|
|
sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1,
|
|
null); //sqlite3_free );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** This routine does per-connection function registration. Most
|
|
** of the built-in functions above are part of the global function set.
|
|
** This routine only deals with those that are not global.
|
|
*/
|
|
|
|
public struct sFuncs
|
|
{
|
|
public string zName;
|
|
public sbyte nArg;
|
|
public u8 argType; /* 1: 0, 2: 1, 3: 2,... N: N-1. */
|
|
public u8 eTextRep; /* 1: UTF-16. 0: UTF-8 */
|
|
public u8 needCollSeq;
|
|
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;
|
|
}
|
|
};
|
|
|
|
public struct sAggs
|
|
{
|
|
public string zName;
|
|
public sbyte nArg;
|
|
public u8 argType;
|
|
public u8 needCollSeq;
|
|
public dxStep xStep; //(sqlite3_context*,int,sqlite3_value**);
|
|
public dxFinal xFinalize; //(sqlite3_context*);
|
|
|
|
// Constructor
|
|
public sAggs(string zName, sbyte nArg, u8 argType, u8 needCollSeq, dxStep xStep, dxFinal xFinalize)
|
|
{
|
|
this.zName = zName;
|
|
this.nArg = nArg;
|
|
this.argType = argType;
|
|
this.needCollSeq = needCollSeq;
|
|
this.xStep = xStep;
|
|
this.xFinalize = xFinalize;
|
|
}
|
|
}
|
|
|
|
private static void sqlite3RegisterBuiltinFunctions(sqlite3 db)
|
|
{
|
|
int rc = sqlite3_overload_function(db, "MATCH", 2);
|
|
Debug.Assert(rc == SQLITE_NOMEM || rc == SQLITE_OK);
|
|
if (rc == SQLITE_NOMEM)
|
|
{
|
|
//// db.mallocFailed = 1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Set the LIKEOPT flag on the 2-argument function with the given name.
|
|
*/
|
|
|
|
private static void setLikeOptFlag(sqlite3 db, string zName, int flagVal)
|
|
{
|
|
FuncDef pDef;
|
|
pDef = sqlite3FindFunction(db, zName, sqlite3Strlen30(zName),
|
|
2, SQLITE_UTF8, 0);
|
|
if (ALWAYS(pDef != null))
|
|
{
|
|
pDef.flags = (byte)flagVal;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Register the built-in LIKE and GLOB functions. The caseSensitive
|
|
** parameter determines whether or not the LIKE operator is case
|
|
** sensitive. GLOB is always case sensitive.
|
|
*/
|
|
|
|
private static void sqlite3RegisterLikeFunctions(sqlite3 db, int caseSensitive)
|
|
{
|
|
compareInfo pInfo;
|
|
if (caseSensitive != 0)
|
|
{
|
|
pInfo = likeInfoAlt;
|
|
}
|
|
else
|
|
{
|
|
pInfo = likeInfoNorm;
|
|
}
|
|
sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, (dxFunc)likeFunc, null, null, null);
|
|
sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, (dxFunc)likeFunc, null, null, null);
|
|
sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8,
|
|
globInfo, (dxFunc)likeFunc, null, null, null);
|
|
setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE);
|
|
setLikeOptFlag(db, "like",
|
|
caseSensitive != 0 ? (SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE) : SQLITE_FUNC_LIKE);
|
|
}
|
|
|
|
/*
|
|
** pExpr points to an expression which implements a function. If
|
|
** it is appropriate to apply the LIKE optimization to that function
|
|
** then set aWc[0] through aWc[2] to the wildcard characters and
|
|
** return TRUE. If the function is not a LIKE-style function then
|
|
** return FALSE.
|
|
*/
|
|
|
|
private static bool sqlite3IsLikeFunction(sqlite3 db, Expr pExpr, ref bool pIsNocase, char[] aWc)
|
|
{
|
|
FuncDef pDef;
|
|
if (pExpr.op != TK_FUNCTION
|
|
|| null == pExpr.x.pList
|
|
|| pExpr.x.pList.nExpr != 2
|
|
)
|
|
{
|
|
return false;
|
|
}
|
|
Debug.Assert(!ExprHasProperty(pExpr, EP_xIsSelect));
|
|
pDef = sqlite3FindFunction(db, pExpr.u.zToken, sqlite3Strlen30(pExpr.u.zToken),
|
|
2, SQLITE_UTF8, 0);
|
|
if (NEVER(pDef == null) || (pDef.flags & SQLITE_FUNC_LIKE) == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/* The memcpy() statement assumes that the wildcard characters are
|
|
** the first three statements in the compareInfo structure. The
|
|
** Debug.Asserts() that follow verify that assumption
|
|
*/
|
|
//memcpy( aWc, pDef.pUserData, 3 );
|
|
aWc[0] = ((compareInfo)pDef.pUserData).matchAll;
|
|
aWc[1] = ((compareInfo)pDef.pUserData).matchOne;
|
|
aWc[2] = ((compareInfo)pDef.pUserData).matchSet;
|
|
// Debug.Assert((char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll);
|
|
// Debug.Assert(&((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne);
|
|
// Debug.Assert(&((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet);
|
|
pIsNocase = (pDef.flags & SQLITE_FUNC_CASE) == 0;
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
** All all of the FuncDef structures in the aBuiltinFunc[] array above
|
|
** to the global function hash table. This occurs at start-time (as
|
|
** a consequence of calling sqlite3_initialize()).
|
|
**
|
|
** After this routine runs
|
|
*/
|
|
|
|
private static void sqlite3RegisterGlobalFunctions()
|
|
{
|
|
/*
|
|
** The following array holds FuncDef structures for all of the functions
|
|
** defined in this file.
|
|
**
|
|
** The array cannot be constant since changes are made to the
|
|
** FuncDef.pHash elements at start-time. The elements of this array
|
|
** are read-only after initialization is complete.
|
|
*/
|
|
FuncDef[] aBuiltinFunc = {
|
|
FUNCTION("ltrim", 1, 1, 0, trimFunc ),
|
|
FUNCTION("ltrim", 2, 1, 0, trimFunc ),
|
|
FUNCTION("rtrim", 1, 2, 0, trimFunc ),
|
|
FUNCTION("rtrim", 2, 2, 0, trimFunc ),
|
|
FUNCTION("trim", 1, 3, 0, trimFunc ),
|
|
FUNCTION("trim", 2, 3, 0, trimFunc ),
|
|
FUNCTION("min", -1, 0, 1, minmaxFunc ),
|
|
FUNCTION("min", 0, 0, 1, null ),
|
|
AGGREGATE("min", 1, 0, 1, minmaxStep, minMaxFinalize ),
|
|
FUNCTION("max", -1, 1, 1, minmaxFunc ),
|
|
FUNCTION("max", 0, 1, 1, null ),
|
|
AGGREGATE("max", 1, 1, 1, minmaxStep, minMaxFinalize ),
|
|
FUNCTION("typeof", 1, 0, 0, typeofFunc ),
|
|
FUNCTION("length", 1, 0, 0, lengthFunc ),
|
|
FUNCTION("substr", 2, 0, 0, substrFunc ),
|
|
FUNCTION("substr", 3, 0, 0, substrFunc ),
|
|
FUNCTION("abs", 1, 0, 0, absFunc ),
|
|
#if !SQLITE_OMIT_FLOATING_POINT
|
|
FUNCTION("round", 1, 0, 0, roundFunc ),
|
|
FUNCTION("round", 2, 0, 0, roundFunc ),
|
|
#endif
|
|
FUNCTION("upper", 1, 0, 0, upperFunc ),
|
|
FUNCTION("lower", 1, 0, 0, lowerFunc ),
|
|
FUNCTION("coalesce", 1, 0, 0, null ),
|
|
FUNCTION("coalesce", 0, 0, 0, null ),
|
|
/* FUNCTION(coalesce, -1, 0, 0, ifnullFunc ), */
|
|
// use versionFunc here just for a dummy placeholder
|
|
new FuncDef(-1,SQLITE_UTF8,SQLITE_FUNC_COALESCE,null,null,versionFunc,null,null,"coalesce",null,null),
|
|
FUNCTION("hex", 1, 0, 0, hexFunc ),
|
|
/* FUNCTION(ifnull, 2, 0, 0, ifnullFunc ), */
|
|
// use versionFunc here just for a dummy placeholder
|
|
new FuncDef(2,SQLITE_UTF8,SQLITE_FUNC_COALESCE,null,null,versionFunc,null,null,"ifnull",null,null),
|
|
FUNCTION("random", 0, 0, 0, randomFunc ),
|
|
FUNCTION("randomblob", 1, 0, 0, randomBlob ),
|
|
FUNCTION("nullif", 2, 0, 1, nullifFunc ),
|
|
FUNCTION("sqlite_version", 0, 0, 0, versionFunc ),
|
|
FUNCTION("sqlite_source_id", 0, 0, 0, sourceidFunc ),
|
|
FUNCTION("sqlite_log", 2, 0, 0, errlogFunc ),
|
|
#if !SQLITE_OMIT_COMPILEOPTION_DIAGS
|
|
FUNCTION("sqlite_compileoption_used",1, 0, 0, compileoptionusedFunc ),
|
|
FUNCTION("sqlite_compileoption_get", 1, 0, 0, compileoptiongetFunc ),
|
|
#endif //* SQLITE_OMIT_COMPILEOPTION_DIAGS */
|
|
FUNCTION("quote", 1, 0, 0, quoteFunc ),
|
|
FUNCTION("last_insert_rowid", 0, 0, 0, last_insert_rowid),
|
|
FUNCTION("changes", 0, 0, 0, changes ),
|
|
FUNCTION("total_changes", 0, 0, 0, total_changes ),
|
|
FUNCTION("replace", 3, 0, 0, replaceFunc ),
|
|
FUNCTION("zeroblob", 1, 0, 0, zeroblobFunc ),
|
|
#if SQLITE_SOUNDEX
|
|
FUNCTION("soundex", 1, 0, 0, soundexFunc ),
|
|
#endif
|
|
#if !SQLITE_OMIT_LOAD_EXTENSION
|
|
FUNCTION("load_extension", 1, 0, 0, loadExt ),
|
|
FUNCTION("load_extension", 2, 0, 0, loadExt ),
|
|
#endif
|
|
AGGREGATE("sum", 1, 0, 0, sumStep, sumFinalize ),
|
|
AGGREGATE("total", 1, 0, 0, sumStep, totalFinalize ),
|
|
AGGREGATE("avg", 1, 0, 0, sumStep, avgFinalize ),
|
|
/*AGGREGATE("count", 0, 0, 0, countStep, countFinalize ), */
|
|
/* AGGREGATE(count, 0, 0, 0, countStep, countFinalize ), */
|
|
new FuncDef( 0,SQLITE_UTF8,SQLITE_FUNC_COUNT,null,null,null,countStep,countFinalize,"count",null,null),
|
|
AGGREGATE("count", 1, 0, 0, countStep, countFinalize ),
|
|
AGGREGATE("group_concat", 1, 0, 0, groupConcatStep, groupConcatFinalize),
|
|
AGGREGATE("group_concat", 2, 0, 0, groupConcatStep, groupConcatFinalize),
|
|
|
|
LIKEFUNC("glob", 2, globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
|
|
#if SQLITE_CASE_SENSITIVE_LIKE
|
|
LIKEFUNC("like", 2, likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
|
|
LIKEFUNC("like", 3, likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
|
|
#else
|
|
LIKEFUNC("like", 2, likeInfoNorm, SQLITE_FUNC_LIKE),
|
|
LIKEFUNC("like", 3, likeInfoNorm, SQLITE_FUNC_LIKE),
|
|
#endif
|
|
FUNCTION("regexp", 2, 0, 0, regexpFunc ),};
|
|
int i;
|
|
#if SQLITE_OMIT_WSD
|
|
FuncDefHash pHash = GLOBAL( FuncDefHash, sqlite3GlobalFunctions );
|
|
FuncDef[] aFunc = (FuncDef[])GLOBAL( FuncDef, aBuiltinFunc );
|
|
#else
|
|
FuncDefHash pHash = sqlite3GlobalFunctions;
|
|
FuncDef[] aFunc = aBuiltinFunc;
|
|
#endif
|
|
for (i = 0; i < ArraySize(aBuiltinFunc); i++)
|
|
{
|
|
sqlite3FuncDefInsert(pHash, aFunc[i]);
|
|
}
|
|
sqlite3RegisterDateTimeFunctions();
|
|
#if !SQLITE_OMIT_ALTERTABLE
|
|
sqlite3AlterFunctions();
|
|
#endif
|
|
}
|
|
}
|
|
} |