Symaptic: os/persistentdata/persistentstorage/sql/SQLite/func.c@bde4ae8d615e (annotated)

sl@0	1	/*
sl@0	2	** 2002 February 23
sl@0	3	**
sl@0	4	** The author disclaims copyright to this source code. In place of
sl@0	5	** a legal notice, here is a blessing:
sl@0	6	**
sl@0	7	** May you do good and not evil.
sl@0	8	** May you find forgiveness for yourself and forgive others.
sl@0	9	** May you share freely, never taking more than you give.
sl@0	10	**
sl@0	11	*************************************************************************
sl@0	12	** This file contains the C functions that implement various SQL
sl@0	13	** functions of SQLite.
sl@0	14	**
sl@0	15	** There is only one exported symbol in this file - the function
sl@0	16	** sqliteRegisterBuildinFunctions() found at the bottom of the file.
sl@0	17	** All other code has file scope.
sl@0	18	**
sl@0	19	** $Id: func.c,v 1.196 2008/07/28 19:34:53 drh Exp $
sl@0	20	*/
sl@0	21	#include "sqliteInt.h"
sl@0	22	#include <ctype.h>
sl@0	23	#include <stdlib.h>
sl@0	24	#include <assert.h>
sl@0	25	#include "vdbeInt.h"
sl@0	26
sl@0	27
sl@0	28	/*
sl@0	29	** Return the collating function associated with a function.
sl@0	30	*/
sl@0	31	static CollSeq sqlite3GetFuncCollSeq(sqlite3_context context){
sl@0	32	return context->pColl;
sl@0	33	}
sl@0	34
sl@0	35	/*
sl@0	36	** Implementation of the non-aggregate min() and max() functions
sl@0	37	*/
sl@0	38	static void minmaxFunc(
sl@0	39	sqlite3_context *context,
sl@0	40	int argc,
sl@0	41	sqlite3_value **argv
sl@0	42	){
sl@0	43	int i;
sl@0	44	int mask; /* 0 for min() or 0xffffffff for max() */
sl@0	45	int iBest;
sl@0	46	CollSeq *pColl;
sl@0	47
sl@0	48	if( argc==0 ) return;
sl@0	49	mask = sqlite3_user_data(context)==0 ? 0 : -1;
sl@0	50	pColl = sqlite3GetFuncCollSeq(context);
sl@0	51	assert( pColl );
sl@0	52	assert( mask==-1 \|\| mask==0 );
sl@0	53	iBest = 0;
sl@0	54	if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
sl@0	55	for(i=1; i<argc; i++){
sl@0	56	if( sqlite3_value_type(argv[i])==SQLITE_NULL ) return;
sl@0	57	if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){
sl@0	58	iBest = i;
sl@0	59	}
sl@0	60	}
sl@0	61	sqlite3_result_value(context, argv[iBest]);
sl@0	62	}
sl@0	63
sl@0	64	/*
sl@0	65	** Return the type of the argument.
sl@0	66	*/
sl@0	67	static void typeofFunc(
sl@0	68	sqlite3_context *context,
sl@0	69	int argc,
sl@0	70	sqlite3_value **argv
sl@0	71	){
sl@0	72	const char *z = 0;
sl@0	73	switch( sqlite3_value_type(argv[0]) ){
sl@0	74	case SQLITE_NULL: z = "null"; break;
sl@0	75	case SQLITE_INTEGER: z = "integer"; break;
sl@0	76	case SQLITE_TEXT: z = "text"; break;
sl@0	77	case SQLITE_FLOAT: z = "real"; break;
sl@0	78	case SQLITE_BLOB: z = "blob"; break;
sl@0	79	}
sl@0	80	sqlite3_result_text(context, z, -1, SQLITE_STATIC);
sl@0	81	}
sl@0	82
sl@0	83
sl@0	84	/*
sl@0	85	** Implementation of the length() function
sl@0	86	*/
sl@0	87	static void lengthFunc(
sl@0	88	sqlite3_context *context,
sl@0	89	int argc,
sl@0	90	sqlite3_value **argv
sl@0	91	){
sl@0	92	int len;
sl@0	93
sl@0	94	assert( argc==1 );
sl@0	95	switch( sqlite3_value_type(argv[0]) ){
sl@0	96	case SQLITE_BLOB:
sl@0	97	case SQLITE_INTEGER:
sl@0	98	case SQLITE_FLOAT: {
sl@0	99	sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
sl@0	100	break;
sl@0	101	}
sl@0	102	case SQLITE_TEXT: {
sl@0	103	const unsigned char *z = sqlite3_value_text(argv[0]);
sl@0	104	if( z==0 ) return;
sl@0	105	len = 0;
sl@0	106	while( *z ){
sl@0	107	len++;
sl@0	108	SQLITE_SKIP_UTF8(z);
sl@0	109	}
sl@0	110	sqlite3_result_int(context, len);
sl@0	111	break;
sl@0	112	}
sl@0	113	default: {
sl@0	114	sqlite3_result_null(context);
sl@0	115	break;
sl@0	116	}
sl@0	117	}
sl@0	118	}
sl@0	119
sl@0	120	/*
sl@0	121	** Implementation of the abs() function
sl@0	122	*/
sl@0	123	static void absFunc(sqlite3_context context, int argc, sqlite3_value *argv){
sl@0	124	assert( argc==1 );
sl@0	125	switch( sqlite3_value_type(argv[0]) ){
sl@0	126	case SQLITE_INTEGER: {
sl@0	127	i64 iVal = sqlite3_value_int64(argv[0]);
sl@0	128	if( iVal<0 ){
sl@0	129	if( (iVal<<1)==0 ){
sl@0	130	sqlite3_result_error(context, "integer overflow", -1);
sl@0	131	return;
sl@0	132	}
sl@0	133	iVal = -iVal;
sl@0	134	}
sl@0	135	sqlite3_result_int64(context, iVal);
sl@0	136	break;
sl@0	137	}
sl@0	138	case SQLITE_NULL: {
sl@0	139	sqlite3_result_null(context);
sl@0	140	break;
sl@0	141	}
sl@0	142	default: {
sl@0	143	double rVal = sqlite3_value_double(argv[0]);
sl@0	144	if( rVal<0 ) rVal = -rVal;
sl@0	145	sqlite3_result_double(context, rVal);
sl@0	146	break;
sl@0	147	}
sl@0	148	}
sl@0	149	}
sl@0	150
sl@0	151	/*
sl@0	152	** Implementation of the substr() function.
sl@0	153	**
sl@0	154	** substr(x,p1,p2) returns p2 characters of x[] beginning with p1.
sl@0	155	** p1 is 1-indexed. So substr(x,1,1) returns the first character
sl@0	156	** of x. If x is text, then we actually count UTF-8 characters.
sl@0	157	** If x is a blob, then we count bytes.
sl@0	158	**
sl@0	159	** If p1 is negative, then we begin abs(p1) from the end of x[].
sl@0	160	*/
sl@0	161	static void substrFunc(
sl@0	162	sqlite3_context *context,
sl@0	163	int argc,
sl@0	164	sqlite3_value **argv
sl@0	165	){
sl@0	166	const unsigned char *z;
sl@0	167	const unsigned char *z2;
sl@0	168	int len;
sl@0	169	int p0type;
sl@0	170	i64 p1, p2;
sl@0	171
sl@0	172	assert( argc==3 \|\| argc==2 );
sl@0	173	p0type = sqlite3_value_type(argv[0]);
sl@0	174	if( p0type==SQLITE_BLOB ){
sl@0	175	len = sqlite3_value_bytes(argv[0]);
sl@0	176	z = sqlite3_value_blob(argv[0]);
sl@0	177	if( z==0 ) return;
sl@0	178	assert( len==sqlite3_value_bytes(argv[0]) );
sl@0	179	}else{
sl@0	180	z = sqlite3_value_text(argv[0]);
sl@0	181	if( z==0 ) return;
sl@0	182	len = 0;
sl@0	183	for(z2=z; *z2; len++){
sl@0	184	SQLITE_SKIP_UTF8(z2);
sl@0	185	}
sl@0	186	}
sl@0	187	p1 = sqlite3_value_int(argv[1]);
sl@0	188	if( argc==3 ){
sl@0	189	p2 = sqlite3_value_int(argv[2]);
sl@0	190	}else{
sl@0	191	p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH];
sl@0	192	}
sl@0	193	if( p1<0 ){
sl@0	194	p1 += len;
sl@0	195	if( p1<0 ){
sl@0	196	p2 += p1;
sl@0	197	p1 = 0;
sl@0	198	}
sl@0	199	}else if( p1>0 ){
sl@0	200	p1--;
sl@0	201	}
sl@0	202	if( p1+p2>len ){
sl@0	203	p2 = len-p1;
sl@0	204	}
sl@0	205	if( p0type!=SQLITE_BLOB ){
sl@0	206	while( *z && p1 ){
sl@0	207	SQLITE_SKIP_UTF8(z);
sl@0	208	p1--;
sl@0	209	}
sl@0	210	for(z2=z; *z2 && p2; p2--){
sl@0	211	SQLITE_SKIP_UTF8(z2);
sl@0	212	}
sl@0	213	sqlite3_result_text(context, (char*)z, z2-z, SQLITE_TRANSIENT);
sl@0	214	}else{
sl@0	215	if( p2<0 ) p2 = 0;
sl@0	216	sqlite3_result_blob(context, (char*)&z[p1], p2, SQLITE_TRANSIENT);
sl@0	217	}
sl@0	218	}
sl@0	219
sl@0	220	/*
sl@0	221	** Implementation of the round() function
sl@0	222	*/
sl@0	223	static void roundFunc(sqlite3_context context, int argc, sqlite3_value *argv){
sl@0	224	int n = 0;
sl@0	225	double r;
sl@0	226	char zBuf[500]; /* larger than the %f representation of the largest double */
sl@0	227	assert( argc==1 \|\| argc==2 );
sl@0	228	if( argc==2 ){
sl@0	229	if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return;
sl@0	230	n = sqlite3_value_int(argv[1]);
sl@0	231	if( n>30 ) n = 30;
sl@0	232	if( n<0 ) n = 0;
sl@0	233	}
sl@0	234	if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
sl@0	235	r = sqlite3_value_double(argv[0]);
sl@0	236	sqlite3_snprintf(sizeof(zBuf),zBuf,"%.*f",n,r);
sl@0	237	sqlite3AtoF(zBuf, &r);
sl@0	238	sqlite3_result_double(context, r);
sl@0	239	}
sl@0	240
sl@0	241	/*
sl@0	242	** Allocate nByte bytes of space using sqlite3_malloc(). If the
sl@0	243	** allocation fails, call sqlite3_result_error_nomem() to notify
sl@0	244	** the database handle that malloc() has failed.
sl@0	245	*/
sl@0	246	static void contextMalloc(sqlite3_context context, i64 nByte){
sl@0	247	char *z;
sl@0	248	if( nByte>sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH] ){
sl@0	249	sqlite3_result_error_toobig(context);
sl@0	250	z = 0;
sl@0	251	}else{
sl@0	252	z = sqlite3Malloc(nByte);
sl@0	253	if( !z && nByte>0 ){
sl@0	254	sqlite3_result_error_nomem(context);
sl@0	255	}
sl@0	256	}
sl@0	257	return z;
sl@0	258	}
sl@0	259
sl@0	260	/*
sl@0	261	** Implementation of the upper() and lower() SQL functions.
sl@0	262	*/
sl@0	263	static void upperFunc(sqlite3_context context, int argc, sqlite3_value *argv){
sl@0	264	char *z1;
sl@0	265	const char *z2;
sl@0	266	int i, n;
sl@0	267	if( argc<1 \|\| SQLITE_NULL==sqlite3_value_type(argv[0]) ) return;
sl@0	268	z2 = (char*)sqlite3_value_text(argv[0]);
sl@0	269	n = sqlite3_value_bytes(argv[0]);
sl@0	270	/* Verify that the call to _bytes() does not invalidate the _text() pointer */
sl@0	271	assert( z2==(char*)sqlite3_value_text(argv[0]) );
sl@0	272	if( z2 ){
sl@0	273	z1 = contextMalloc(context, ((i64)n)+1);
sl@0	274	if( z1 ){
sl@0	275	memcpy(z1, z2, n+1);
sl@0	276	for(i=0; z1[i]; i++){
sl@0	277	z1[i] = toupper(z1[i]);
sl@0	278	}
sl@0	279	sqlite3_result_text(context, z1, -1, sqlite3_free);
sl@0	280	}
sl@0	281	}
sl@0	282	}
sl@0	283	static void lowerFunc(sqlite3_context context, int argc, sqlite3_value *argv){
sl@0	284	char *z1;
sl@0	285	const char *z2;
sl@0	286	int i, n;
sl@0	287	if( argc<1 \|\| SQLITE_NULL==sqlite3_value_type(argv[0]) ) return;
sl@0	288	z2 = (char*)sqlite3_value_text(argv[0]);
sl@0	289	n = sqlite3_value_bytes(argv[0]);
sl@0	290	/* Verify that the call to _bytes() does not invalidate the _text() pointer */
sl@0	291	assert( z2==(char*)sqlite3_value_text(argv[0]) );
sl@0	292	if( z2 ){
sl@0	293	z1 = contextMalloc(context, ((i64)n)+1);
sl@0	294	if( z1 ){
sl@0	295	memcpy(z1, z2, n+1);
sl@0	296	for(i=0; z1[i]; i++){
sl@0	297	z1[i] = tolower(z1[i]);
sl@0	298	}
sl@0	299	sqlite3_result_text(context, z1, -1, sqlite3_free);
sl@0	300	}
sl@0	301	}
sl@0	302	}
sl@0	303
sl@0	304	/*
sl@0	305	** Implementation of the IFNULL(), NVL(), and COALESCE() functions.
sl@0	306	** All three do the same thing. They return the first non-NULL
sl@0	307	** argument.
sl@0	308	*/
sl@0	309	static void ifnullFunc(
sl@0	310	sqlite3_context *context,
sl@0	311	int argc,
sl@0	312	sqlite3_value **argv
sl@0	313	){
sl@0	314	int i;
sl@0	315	for(i=0; i<argc; i++){
sl@0	316	if( SQLITE_NULL!=sqlite3_value_type(argv[i]) ){
sl@0	317	sqlite3_result_value(context, argv[i]);
sl@0	318	break;
sl@0	319	}
sl@0	320	}
sl@0	321	}
sl@0	322
sl@0	323	/*
sl@0	324	** Implementation of random(). Return a random integer.
sl@0	325	*/
sl@0	326	static void randomFunc(
sl@0	327	sqlite3_context *context,
sl@0	328	int argc,
sl@0	329	sqlite3_value **argv
sl@0	330	){
sl@0	331	sqlite_int64 r;
sl@0	332	sqlite3_randomness(sizeof(r), &r);
sl@0	333	if( (r<<1)==0 ) r = 0; /* Prevent 0x8000.... as the result so that we */
sl@0	334	/* can always do abs() of the result */
sl@0	335	sqlite3_result_int64(context, r);
sl@0	336	}
sl@0	337
sl@0	338	/*
sl@0	339	** Implementation of randomblob(N). Return a random blob
sl@0	340	** that is N bytes long.
sl@0	341	*/
sl@0	342	static void randomBlob(
sl@0	343	sqlite3_context *context,
sl@0	344	int argc,
sl@0	345	sqlite3_value **argv
sl@0	346	){
sl@0	347	int n;
sl@0	348	unsigned char *p;
sl@0	349	assert( argc==1 );
sl@0	350	n = sqlite3_value_int(argv[0]);
sl@0	351	if( n<1 ){
sl@0	352	n = 1;
sl@0	353	}
sl@0	354	p = contextMalloc(context, n);
sl@0	355	if( p ){
sl@0	356	sqlite3_randomness(n, p);
sl@0	357	sqlite3_result_blob(context, (char*)p, n, sqlite3_free);
sl@0	358	}
sl@0	359	}
sl@0	360
sl@0	361	/*
sl@0	362	** Implementation of the last_insert_rowid() SQL function. The return
sl@0	363	** value is the same as the sqlite3_last_insert_rowid() API function.
sl@0	364	*/
sl@0	365	static void last_insert_rowid(
sl@0	366	sqlite3_context *context,
sl@0	367	int arg,
sl@0	368	sqlite3_value **argv
sl@0	369	){
sl@0	370	sqlite3 *db = sqlite3_context_db_handle(context);
sl@0	371	sqlite3_result_int64(context, sqlite3_last_insert_rowid(db));
sl@0	372	}
sl@0	373
sl@0	374	/*
sl@0	375	** Implementation of the changes() SQL function. The return value is the
sl@0	376	** same as the sqlite3_changes() API function.
sl@0	377	*/
sl@0	378	static void changes(
sl@0	379	sqlite3_context *context,
sl@0	380	int arg,
sl@0	381	sqlite3_value **argv
sl@0	382	){
sl@0	383	sqlite3 *db = sqlite3_context_db_handle(context);
sl@0	384	sqlite3_result_int(context, sqlite3_changes(db));
sl@0	385	}
sl@0	386
sl@0	387	/*
sl@0	388	** Implementation of the total_changes() SQL function. The return value is
sl@0	389	** the same as the sqlite3_total_changes() API function.
sl@0	390	*/
sl@0	391	static void total_changes(
sl@0	392	sqlite3_context *context,
sl@0	393	int arg,
sl@0	394	sqlite3_value **argv
sl@0	395	){
sl@0	396	sqlite3 *db = sqlite3_context_db_handle(context);
sl@0	397	sqlite3_result_int(context, sqlite3_total_changes(db));
sl@0	398	}
sl@0	399
sl@0	400	/*
sl@0	401	** A structure defining how to do GLOB-style comparisons.
sl@0	402	*/
sl@0	403	struct compareInfo {
sl@0	404	u8 matchAll;
sl@0	405	u8 matchOne;
sl@0	406	u8 matchSet;
sl@0	407	u8 noCase;
sl@0	408	};
sl@0	409
sl@0	410	/*
sl@0	411	** For LIKE and GLOB matching on EBCDIC machines, assume that every
sl@0	412	** character is exactly one byte in size. Also, all characters are
sl@0	413	** able to participate in upper-case-to-lower-case mappings in EBCDIC
sl@0	414	** whereas only characters less than 0x80 do in ASCII.
sl@0	415	*/
sl@0	416	#if defined(SQLITE_EBCDIC)
sl@0	417	# define sqlite3Utf8Read(A,B,C) (*(A++))
sl@0	418	# define GlogUpperToLower(A) A = sqlite3UpperToLower[A]
sl@0	419	#else
sl@0	420	# define GlogUpperToLower(A) if( A<0x80 ){ A = sqlite3UpperToLower[A]; }
sl@0	421	#endif
sl@0	422
sl@0	423	static const struct compareInfo globInfo = { '*', '?', '[', 0 };
sl@0	424	/* The correct SQL-92 behavior is for the LIKE operator to ignore
sl@0	425	** case. Thus 'a' LIKE 'A' would be true. */
sl@0	426	static const struct compareInfo likeInfoNorm = { '%', '_', 0, 1 };
sl@0	427	/* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
sl@0	428	** is case sensitive causing 'a' LIKE 'A' to be false */
sl@0	429	static const struct compareInfo likeInfoAlt = { '%', '_', 0, 0 };
sl@0	430
sl@0	431	/*
sl@0	432	** Compare two UTF-8 strings for equality where the first string can
sl@0	433	** potentially be a "glob" expression. Return true (1) if they
sl@0	434	** are the same and false (0) if they are different.
sl@0	435	**
sl@0	436	** Globbing rules:
sl@0	437	**
sl@0	438	** '*' Matches any sequence of zero or more characters.
sl@0	439	**
sl@0	440	** '?' Matches exactly one character.
sl@0	441	**
sl@0	442	** [...] Matches one character from the enclosed list of
sl@0	443	** characters.
sl@0	444	**
sl@0	445	** [^...] Matches one character not in the enclosed list.
sl@0	446	**
sl@0	447	** With the [...] and [^...] matching, a ']' character can be included
sl@0	448	** in the list by making it the first character after '[' or '^'. A
sl@0	449	** range of characters can be specified using '-'. Example:
sl@0	450	** "[a-z]" matches any single lower-case letter. To match a '-', make
sl@0	451	** it the last character in the list.
sl@0	452	**
sl@0	453	This routine is usually quick, but can be N2 in the worst case.
sl@0	454	**
sl@0	455	** Hints: to match '*' or '?', put them in "[]". Like this:
sl@0	456	**
sl@0	457	** abc[]xyz Matches "abcxyz" only
sl@0	458	*/
sl@0	459	static int patternCompare(
sl@0	460	const u8 zPattern, / The glob pattern */
sl@0	461	const u8 zString, / The string to compare against the glob */
sl@0	462	const struct compareInfo pInfo, / Information about how to do the compare */
sl@0	463	const int esc /* The escape character */
sl@0	464	){
sl@0	465	int c, c2;
sl@0	466	int invert;
sl@0	467	int seen;
sl@0	468	u8 matchOne = pInfo->matchOne;
sl@0	469	u8 matchAll = pInfo->matchAll;
sl@0	470	u8 matchSet = pInfo->matchSet;
sl@0	471	u8 noCase = pInfo->noCase;
sl@0	472	int prevEscape = 0; /* True if the previous character was 'escape' */
sl@0	473
sl@0	474	while( (c = sqlite3Utf8Read(zPattern,0,&zPattern))!=0 ){
sl@0	475	if( !prevEscape && c==matchAll ){
sl@0	476	while( (c=sqlite3Utf8Read(zPattern,0,&zPattern)) == matchAll
sl@0	477	\|\| c == matchOne ){
sl@0	478	if( c==matchOne && sqlite3Utf8Read(zString, 0, &zString)==0 ){
sl@0	479	return 0;
sl@0	480	}
sl@0	481	}
sl@0	482	if( c==0 ){
sl@0	483	return 1;
sl@0	484	}else if( c==esc ){
sl@0	485	c = sqlite3Utf8Read(zPattern, 0, &zPattern);
sl@0	486	if( c==0 ){
sl@0	487	return 0;
sl@0	488	}
sl@0	489	}else if( c==matchSet ){
sl@0	490	assert( esc==0 ); /* This is GLOB, not LIKE */
sl@0	491	assert( matchSet<0x80 ); /* '[' is a single-byte character */
sl@0	492	while( *zString && patternCompare(&zPattern[-1],zString,pInfo,esc)==0 ){
sl@0	493	SQLITE_SKIP_UTF8(zString);
sl@0	494	}
sl@0	495	return *zString!=0;
sl@0	496	}
sl@0	497	while( (c2 = sqlite3Utf8Read(zString,0,&zString))!=0 ){
sl@0	498	if( noCase ){
sl@0	499	GlogUpperToLower(c2);
sl@0	500	GlogUpperToLower(c);
sl@0	501	while( c2 != 0 && c2 != c ){
sl@0	502	c2 = sqlite3Utf8Read(zString, 0, &zString);
sl@0	503	GlogUpperToLower(c2);
sl@0	504	}
sl@0	505	}else{
sl@0	506	while( c2 != 0 && c2 != c ){
sl@0	507	c2 = sqlite3Utf8Read(zString, 0, &zString);
sl@0	508	}
sl@0	509	}
sl@0	510	if( c2==0 ) return 0;
sl@0	511	if( patternCompare(zPattern,zString,pInfo,esc) ) return 1;
sl@0	512	}
sl@0	513	return 0;
sl@0	514	}else if( !prevEscape && c==matchOne ){
sl@0	515	if( sqlite3Utf8Read(zString, 0, &zString)==0 ){
sl@0	516	return 0;
sl@0	517	}
sl@0	518	}else if( c==matchSet ){
sl@0	519	int prior_c = 0;
sl@0	520	assert( esc==0 ); /* This only occurs for GLOB, not LIKE */
sl@0	521	seen = 0;
sl@0	522	invert = 0;
sl@0	523	c = sqlite3Utf8Read(zString, 0, &zString);
sl@0	524	if( c==0 ) return 0;
sl@0	525	c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
sl@0	526	if( c2=='^' ){
sl@0	527	invert = 1;
sl@0	528	c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
sl@0	529	}
sl@0	530	if( c2==']' ){
sl@0	531	if( c==']' ) seen = 1;
sl@0	532	c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
sl@0	533	}
sl@0	534	while( c2 && c2!=']' ){
sl@0	535	if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){
sl@0	536	c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
sl@0	537	if( c>=prior_c && c<=c2 ) seen = 1;
sl@0	538	prior_c = 0;
sl@0	539	}else{
sl@0	540	if( c==c2 ){
sl@0	541	seen = 1;
sl@0	542	}
sl@0	543	prior_c = c2;
sl@0	544	}
sl@0	545	c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
sl@0	546	}
sl@0	547	if( c2==0 \|\| (seen ^ invert)==0 ){
sl@0	548	return 0;
sl@0	549	}
sl@0	550	}else if( esc==c && !prevEscape ){
sl@0	551	prevEscape = 1;
sl@0	552	}else{
sl@0	553	c2 = sqlite3Utf8Read(zString, 0, &zString);
sl@0	554	if( noCase ){
sl@0	555	GlogUpperToLower(c);
sl@0	556	GlogUpperToLower(c2);
sl@0	557	}
sl@0	558	if( c!=c2 ){
sl@0	559	return 0;
sl@0	560	}
sl@0	561	prevEscape = 0;
sl@0	562	}
sl@0	563	}
sl@0	564	return *zString==0;
sl@0	565	}
sl@0	566
sl@0	567	/*
sl@0	568	** Count the number of times that the LIKE operator (or GLOB which is
sl@0	569	** just a variation of LIKE) gets called. This is used for testing
sl@0	570	** only.
sl@0	571	*/
sl@0	572	#ifdef SQLITE_TEST
sl@0	573	int sqlite3_like_count = 0;
sl@0	574	#endif
sl@0	575
sl@0	576
sl@0	577	/*
sl@0	578	** Implementation of the like() SQL function. This function implements
sl@0	579	** the build-in LIKE operator. The first argument to the function is the
sl@0	580	** pattern and the second argument is the string. So, the SQL statements:
sl@0	581	**
sl@0	582	** A LIKE B
sl@0	583	**
sl@0	584	** is implemented as like(B,A).
sl@0	585	**
sl@0	586	** This same function (with a different compareInfo structure) computes
sl@0	587	** the GLOB operator.
sl@0	588	*/
sl@0	589	static void likeFunc(
sl@0	590	sqlite3_context *context,
sl@0	591	int argc,
sl@0	592	sqlite3_value **argv
sl@0	593	){
sl@0	594	const unsigned char zA, zB;
sl@0	595	int escape = 0;
sl@0	596	sqlite3 *db = sqlite3_context_db_handle(context);
sl@0	597
sl@0	598	zB = sqlite3_value_text(argv[0]);
sl@0	599	zA = sqlite3_value_text(argv[1]);
sl@0	600
sl@0	601	/* Limit the length of the LIKE or GLOB pattern to avoid problems
sl@0	602	** of deep recursion and N*N behavior in patternCompare().
sl@0	603	*/
sl@0	604	if( sqlite3_value_bytes(argv[0]) >
sl@0	605	db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){
sl@0	606	sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
sl@0	607	return;
sl@0	608	}
sl@0	609	assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */
sl@0	610
sl@0	611	if( argc==3 ){
sl@0	612	/* The escape character string must consist of a single UTF-8 character.
sl@0	613	** Otherwise, return an error.
sl@0	614	*/
sl@0	615	const unsigned char *zEsc = sqlite3_value_text(argv[2]);
sl@0	616	if( zEsc==0 ) return;
sl@0	617	if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){
sl@0	618	sqlite3_result_error(context,
sl@0	619	"ESCAPE expression must be a single character", -1);
sl@0	620	return;
sl@0	621	}
sl@0	622	escape = sqlite3Utf8Read(zEsc, 0, &zEsc);
sl@0	623	}
sl@0	624	if( zA && zB ){
sl@0	625	struct compareInfo *pInfo = sqlite3_user_data(context);
sl@0	626	#ifdef SQLITE_TEST
sl@0	627	sqlite3_like_count++;
sl@0	628	#endif
sl@0	629
sl@0	630	sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape));
sl@0	631	}
sl@0	632	}
sl@0	633
sl@0	634	/*
sl@0	635	** Implementation of the NULLIF(x,y) function. The result is the first
sl@0	636	** argument if the arguments are different. The result is NULL if the
sl@0	637	** arguments are equal to each other.
sl@0	638	*/
sl@0	639	static void nullifFunc(
sl@0	640	sqlite3_context *context,
sl@0	641	int argc,
sl@0	642	sqlite3_value **argv
sl@0	643	){
sl@0	644	CollSeq *pColl = sqlite3GetFuncCollSeq(context);
sl@0	645	if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){
sl@0	646	sqlite3_result_value(context, argv[0]);
sl@0	647	}
sl@0	648	}
sl@0	649
sl@0	650	/*
sl@0	651	** Implementation of the VERSION(*) function. The result is the version
sl@0	652	** of the SQLite library that is running.
sl@0	653	*/
sl@0	654	static void versionFunc(
sl@0	655	sqlite3_context *context,
sl@0	656	int argc,
sl@0	657	sqlite3_value **argv
sl@0	658	){
sl@0	659	sqlite3_result_text(context, sqlite3_version, -1, SQLITE_STATIC);
sl@0	660	}
sl@0	661
sl@0	662	/* Array for converting from half-bytes (nybbles) into ASCII hex
sl@0	663	** digits. */
sl@0	664	static const char hexdigits[] = {
sl@0	665	'0', '1', '2', '3', '4', '5', '6', '7',
sl@0	666	'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
sl@0	667	};
sl@0	668
sl@0	669	/*
sl@0	670	** EXPERIMENTAL - This is not an official function. The interface may
sl@0	671	** change. This function may disappear. Do not write code that depends
sl@0	672	** on this function.
sl@0	673	**
sl@0	674	** Implementation of the QUOTE() function. This function takes a single
sl@0	675	** argument. If the argument is numeric, the return value is the same as
sl@0	676	** the argument. If the argument is NULL, the return value is the string
sl@0	677	** "NULL". Otherwise, the argument is enclosed in single quotes with
sl@0	678	** single-quote escapes.
sl@0	679	*/
sl@0	680	static void quoteFunc(sqlite3_context context, int argc, sqlite3_value *argv){
sl@0	681	if( argc<1 ) return;
sl@0	682	switch( sqlite3_value_type(argv[0]) ){
sl@0	683	case SQLITE_NULL: {
sl@0	684	sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC);
sl@0	685	break;
sl@0	686	}
sl@0	687	case SQLITE_INTEGER:
sl@0	688	case SQLITE_FLOAT: {
sl@0	689	sqlite3_result_value(context, argv[0]);
sl@0	690	break;
sl@0	691	}
sl@0	692	case SQLITE_BLOB: {
sl@0	693	char *zText = 0;
sl@0	694	char const *zBlob = sqlite3_value_blob(argv[0]);
sl@0	695	int nBlob = sqlite3_value_bytes(argv[0]);
sl@0	696	assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
sl@0	697	zText = (char )contextMalloc(context, (2(i64)nBlob)+4);
sl@0	698	if( zText ){
sl@0	699	int i;
sl@0	700	for(i=0; i<nBlob; i++){
sl@0	701	zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F];
sl@0	702	zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F];
sl@0	703	}
sl@0	704	zText[(nBlob*2)+2] = '\'';
sl@0	705	zText[(nBlob*2)+3] = '\0';
sl@0	706	zText[0] = 'X';
sl@0	707	zText[1] = '\'';
sl@0	708	sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT);
sl@0	709	sqlite3_free(zText);
sl@0	710	}
sl@0	711	break;
sl@0	712	}
sl@0	713	case SQLITE_TEXT: {
sl@0	714	int i,j;
sl@0	715	u64 n;
sl@0	716	const unsigned char *zArg = sqlite3_value_text(argv[0]);
sl@0	717	char *z;
sl@0	718
sl@0	719	if( zArg==0 ) return;
sl@0	720	for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; }
sl@0	721	z = contextMalloc(context, ((i64)i)+((i64)n)+3);
sl@0	722	if( z ){
sl@0	723	z[0] = '\'';
sl@0	724	for(i=0, j=1; zArg[i]; i++){
sl@0	725	z[j++] = zArg[i];
sl@0	726	if( zArg[i]=='\'' ){
sl@0	727	z[j++] = '\'';
sl@0	728	}
sl@0	729	}
sl@0	730	z[j++] = '\'';
sl@0	731	z[j] = 0;
sl@0	732	sqlite3_result_text(context, z, j, sqlite3_free);
sl@0	733	}
sl@0	734	}
sl@0	735	}
sl@0	736	}
sl@0	737
sl@0	738	/*
sl@0	739	** The hex() function. Interpret the argument as a blob. Return
sl@0	740	** a hexadecimal rendering as text.
sl@0	741	*/
sl@0	742	static void hexFunc(
sl@0	743	sqlite3_context *context,
sl@0	744	int argc,
sl@0	745	sqlite3_value **argv
sl@0	746	){
sl@0	747	int i, n;
sl@0	748	const unsigned char *pBlob;
sl@0	749	char zHex, z;
sl@0	750	assert( argc==1 );
sl@0	751	pBlob = sqlite3_value_blob(argv[0]);
sl@0	752	n = sqlite3_value_bytes(argv[0]);
sl@0	753	assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
sl@0	754	z = zHex = contextMalloc(context, ((i64)n)*2 + 1);
sl@0	755	if( zHex ){
sl@0	756	for(i=0; i<n; i++, pBlob++){
sl@0	757	unsigned char c = *pBlob;
sl@0	758	*(z++) = hexdigits[(c>>4)&0xf];
sl@0	759	*(z++) = hexdigits[c&0xf];
sl@0	760	}
sl@0	761	*z = 0;
sl@0	762	sqlite3_result_text(context, zHex, n*2, sqlite3_free);
sl@0	763	}
sl@0	764	}
sl@0	765
sl@0	766	/*
sl@0	767	** The zeroblob(N) function returns a zero-filled blob of size N bytes.
sl@0	768	*/
sl@0	769	static void zeroblobFunc(
sl@0	770	sqlite3_context *context,
sl@0	771	int argc,
sl@0	772	sqlite3_value **argv
sl@0	773	){
sl@0	774	i64 n;
sl@0	775	assert( argc==1 );
sl@0	776	n = sqlite3_value_int64(argv[0]);
sl@0	777	if( n>SQLITE_MAX_LENGTH ){
sl@0	778	sqlite3_result_error_toobig(context);
sl@0	779	}else{
sl@0	780	sqlite3_result_zeroblob(context, n);
sl@0	781	}
sl@0	782	}
sl@0	783
sl@0	784	/*
sl@0	785	** The replace() function. Three arguments are all strings: call
sl@0	786	** them A, B, and C. The result is also a string which is derived
sl@0	787	** from A by replacing every occurance of B with C. The match
sl@0	788	** must be exact. Collating sequences are not used.
sl@0	789	*/
sl@0	790	static void replaceFunc(
sl@0	791	sqlite3_context *context,
sl@0	792	int argc,
sl@0	793	sqlite3_value **argv
sl@0	794	){
sl@0	795	const unsigned char zStr; / The input string A */
sl@0	796	const unsigned char zPattern; / The pattern string B */
sl@0	797	const unsigned char zRep; / The replacement string C */
sl@0	798	unsigned char zOut; / The output */
sl@0	799	int nStr; /* Size of zStr */
sl@0	800	int nPattern; /* Size of zPattern */
sl@0	801	int nRep; /* Size of zRep */
sl@0	802	i64 nOut; /* Maximum size of zOut */
sl@0	803	int loopLimit; /* Last zStr[] that might match zPattern[] */
sl@0	804	int i, j; /* Loop counters */
sl@0	805
sl@0	806	assert( argc==3 );
sl@0	807	zStr = sqlite3_value_text(argv[0]);
sl@0	808	if( zStr==0 ) return;
sl@0	809	nStr = sqlite3_value_bytes(argv[0]);
sl@0	810	assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */
sl@0	811	zPattern = sqlite3_value_text(argv[1]);
sl@0	812	if( zPattern==0 \|\| zPattern[0]==0 ) return;
sl@0	813	nPattern = sqlite3_value_bytes(argv[1]);
sl@0	814	assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */
sl@0	815	zRep = sqlite3_value_text(argv[2]);
sl@0	816	if( zRep==0 ) return;
sl@0	817	nRep = sqlite3_value_bytes(argv[2]);
sl@0	818	assert( zRep==sqlite3_value_text(argv[2]) );
sl@0	819	nOut = nStr + 1;
sl@0	820	assert( nOut<SQLITE_MAX_LENGTH );
sl@0	821	zOut = contextMalloc(context, (i64)nOut);
sl@0	822	if( zOut==0 ){
sl@0	823	return;
sl@0	824	}
sl@0	825	loopLimit = nStr - nPattern;
sl@0	826	for(i=j=0; i<=loopLimit; i++){
sl@0	827	if( zStr[i]!=zPattern[0] \|\| memcmp(&zStr[i], zPattern, nPattern) ){
sl@0	828	zOut[j++] = zStr[i];
sl@0	829	}else{
sl@0	830	u8 *zOld;
sl@0	831	sqlite3 *db = sqlite3_context_db_handle(context);
sl@0	832	nOut += nRep - nPattern;
sl@0	833	if( nOut>=db->aLimit[SQLITE_LIMIT_LENGTH] ){
sl@0	834	sqlite3_result_error_toobig(context);
sl@0	835	sqlite3DbFree(db, zOut);
sl@0	836	return;
sl@0	837	}
sl@0	838	zOld = zOut;
sl@0	839	zOut = sqlite3_realloc(zOut, (int)nOut);
sl@0	840	if( zOut==0 ){
sl@0	841	sqlite3_result_error_nomem(context);
sl@0	842	sqlite3DbFree(db, zOld);
sl@0	843	return;
sl@0	844	}
sl@0	845	memcpy(&zOut[j], zRep, nRep);
sl@0	846	j += nRep;
sl@0	847	i += nPattern-1;
sl@0	848	}
sl@0	849	}
sl@0	850	assert( j+nStr-i+1==nOut );
sl@0	851	memcpy(&zOut[j], &zStr[i], nStr-i);
sl@0	852	j += nStr - i;
sl@0	853	assert( j<=nOut );
sl@0	854	zOut[j] = 0;
sl@0	855	sqlite3_result_text(context, (char*)zOut, j, sqlite3_free);
sl@0	856	}
sl@0	857
sl@0	858	/*
sl@0	859	** Implementation of the TRIM(), LTRIM(), and RTRIM() functions.
sl@0	860	** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both.
sl@0	861	*/
sl@0	862	static void trimFunc(
sl@0	863	sqlite3_context *context,
sl@0	864	int argc,
sl@0	865	sqlite3_value **argv
sl@0	866	){
sl@0	867	const unsigned char zIn; / Input string */
sl@0	868	const unsigned char zCharSet; / Set of characters to trim */
sl@0	869	int nIn; /* Number of bytes in input */
sl@0	870	int flags; /* 1: trimleft 2: trimright 3: trim */
sl@0	871	int i; /* Loop counter */
sl@0	872	unsigned char aLen; / Length of each character in zCharSet */
sl@0	873	unsigned char *azChar; / Individual characters in zCharSet */
sl@0	874	int nChar; /* Number of characters in zCharSet */
sl@0	875
sl@0	876	if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
sl@0	877	return;
sl@0	878	}
sl@0	879	zIn = sqlite3_value_text(argv[0]);
sl@0	880	if( zIn==0 ) return;
sl@0	881	nIn = sqlite3_value_bytes(argv[0]);
sl@0	882	assert( zIn==sqlite3_value_text(argv[0]) );
sl@0	883	if( argc==1 ){
sl@0	884	static const unsigned char lenOne[] = { 1 };
sl@0	885	static const unsigned char azOne[] = { (u8)" " };
sl@0	886	nChar = 1;
sl@0	887	aLen = (u8*)lenOne;
sl@0	888	azChar = (unsigned char **)azOne;
sl@0	889	zCharSet = 0;
sl@0	890	}else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){
sl@0	891	return;
sl@0	892	}else{
sl@0	893	const unsigned char *z;
sl@0	894	for(z=zCharSet, nChar=0; *z; nChar++){
sl@0	895	SQLITE_SKIP_UTF8(z);
sl@0	896	}
sl@0	897	if( nChar>0 ){
sl@0	898	azChar = contextMalloc(context, ((i64)nChar)(sizeof(char)+1));
sl@0	899	if( azChar==0 ){
sl@0	900	return;
sl@0	901	}
sl@0	902	aLen = (unsigned char*)&azChar[nChar];
sl@0	903	for(z=zCharSet, nChar=0; *z; nChar++){
sl@0	904	azChar[nChar] = (unsigned char *)z;
sl@0	905	SQLITE_SKIP_UTF8(z);
sl@0	906	aLen[nChar] = z - azChar[nChar];
sl@0	907	}
sl@0	908	}
sl@0	909	}
sl@0	910	if( nChar>0 ){
sl@0	911	flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
sl@0	912	if( flags & 1 ){
sl@0	913	while( nIn>0 ){
sl@0	914	int len = 0; /* Initialized to placate warning. */
sl@0	915	for(i=0; i<nChar; i++){
sl@0	916	len = aLen[i];
sl@0	917	if( memcmp(zIn, azChar[i], len)==0 ) break;
sl@0	918	}
sl@0	919	if( i>=nChar ) break;
sl@0	920	zIn += len;
sl@0	921	nIn -= len;
sl@0	922	}
sl@0	923	}
sl@0	924	if( flags & 2 ){
sl@0	925	while( nIn>0 ){
sl@0	926	int len = 0; /* Initialized to placate warning. */
sl@0	927	for(i=0; i<nChar; i++){
sl@0	928	len = aLen[i];
sl@0	929	if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
sl@0	930	}
sl@0	931	if( i>=nChar ) break;
sl@0	932	nIn -= len;
sl@0	933	}
sl@0	934	}
sl@0	935	if( zCharSet ){
sl@0	936	sqlite3_free(azChar);
sl@0	937	}
sl@0	938	}
sl@0	939	sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT);
sl@0	940	}
sl@0	941
sl@0	942	#ifdef SQLITE_SOUNDEX
sl@0	943	/*
sl@0	944	** Compute the soundex encoding of a word.
sl@0	945	*/
sl@0	946	static void soundexFunc(
sl@0	947	sqlite3_context *context,
sl@0	948	int argc,
sl@0	949	sqlite3_value **argv
sl@0	950	){
sl@0	951	char zResult[8];
sl@0	952	const u8 *zIn;
sl@0	953	int i, j;
sl@0	954	static const unsigned char iCode[] = {
sl@0	955	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
sl@0	956	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
sl@0	957	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
sl@0	958	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
sl@0	959	0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
sl@0	960	1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
sl@0	961	0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
sl@0	962	1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
sl@0	963	};
sl@0	964	assert( argc==1 );
sl@0	965	zIn = (u8*)sqlite3_value_text(argv[0]);
sl@0	966	if( zIn==0 ) zIn = (u8*)"";
sl@0	967	for(i=0; zIn[i] && !isalpha(zIn[i]); i++){}
sl@0	968	if( zIn[i] ){
sl@0	969	u8 prevcode = iCode[zIn[i]&0x7f];
sl@0	970	zResult[0] = toupper(zIn[i]);
sl@0	971	for(j=1; j<4 && zIn[i]; i++){
sl@0	972	int code = iCode[zIn[i]&0x7f];
sl@0	973	if( code>0 ){
sl@0	974	if( code!=prevcode ){
sl@0	975	prevcode = code;
sl@0	976	zResult[j++] = code + '0';
sl@0	977	}
sl@0	978	}else{
sl@0	979	prevcode = 0;
sl@0	980	}
sl@0	981	}
sl@0	982	while( j<4 ){
sl@0	983	zResult[j++] = '0';
sl@0	984	}
sl@0	985	zResult[j] = 0;
sl@0	986	sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT);
sl@0	987	}else{
sl@0	988	sqlite3_result_text(context, "?000", 4, SQLITE_STATIC);
sl@0	989	}
sl@0	990	}
sl@0	991	#endif
sl@0	992
sl@0	993	#ifndef SQLITE_OMIT_LOAD_EXTENSION
sl@0	994	/*
sl@0	995	** A function that loads a shared-library extension then returns NULL.
sl@0	996	*/
sl@0	997	static void loadExt(sqlite3_context context, int argc, sqlite3_value *argv){
sl@0	998	const char zFile = (const char )sqlite3_value_text(argv[0]);
sl@0	999	const char *zProc;
sl@0	1000	sqlite3 *db = sqlite3_context_db_handle(context);
sl@0	1001	char *zErrMsg = 0;
sl@0	1002
sl@0	1003	if( argc==2 ){
sl@0	1004	zProc = (const char *)sqlite3_value_text(argv[1]);
sl@0	1005	}else{
sl@0	1006	zProc = 0;
sl@0	1007	}
sl@0	1008	if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){
sl@0	1009	sqlite3_result_error(context, zErrMsg, -1);
sl@0	1010	sqlite3_free(zErrMsg);
sl@0	1011	}
sl@0	1012	}
sl@0	1013	#endif
sl@0	1014
sl@0	1015
sl@0	1016	/*
sl@0	1017	** An instance of the following structure holds the context of a
sl@0	1018	** sum() or avg() aggregate computation.
sl@0	1019	*/
sl@0	1020	typedef struct SumCtx SumCtx;
sl@0	1021	struct SumCtx {
sl@0	1022	double rSum; /* Floating point sum */
sl@0	1023	i64 iSum; /* Integer sum */
sl@0	1024	i64 cnt; /* Number of elements summed */
sl@0	1025	u8 overflow; /* True if integer overflow seen */
sl@0	1026	u8 approx; /* True if non-integer value was input to the sum */
sl@0	1027	};
sl@0	1028
sl@0	1029	/*
sl@0	1030	** Routines used to compute the sum, average, and total.
sl@0	1031	**
sl@0	1032	** The SUM() function follows the (broken) SQL standard which means
sl@0	1033	** that it returns NULL if it sums over no inputs. TOTAL returns
sl@0	1034	** 0.0 in that case. In addition, TOTAL always returns a float where
sl@0	1035	** SUM might return an integer if it never encounters a floating point
sl@0	1036	** value. TOTAL never fails, but SUM might through an exception if
sl@0	1037	** it overflows an integer.
sl@0	1038	*/
sl@0	1039	static void sumStep(sqlite3_context context, int argc, sqlite3_value *argv){
sl@0	1040	SumCtx *p;
sl@0	1041	int type;
sl@0	1042	assert( argc==1 );
sl@0	1043	p = sqlite3_aggregate_context(context, sizeof(*p));
sl@0	1044	type = sqlite3_value_numeric_type(argv[0]);
sl@0	1045	if( p && type!=SQLITE_NULL ){
sl@0	1046	p->cnt++;
sl@0	1047	if( type==SQLITE_INTEGER ){
sl@0	1048	i64 v = sqlite3_value_int64(argv[0]);
sl@0	1049	p->rSum += v;
sl@0	1050	if( (p->approx\|p->overflow)==0 ){
sl@0	1051	i64 iNewSum = p->iSum + v;
sl@0	1052	int s1 = p->iSum >> (sizeof(i64)*8-1);
sl@0	1053	int s2 = v >> (sizeof(i64)*8-1);
sl@0	1054	int s3 = iNewSum >> (sizeof(i64)*8-1);
sl@0	1055	p->overflow = (s1&s2&~s3) \| (~s1&~s2&s3);
sl@0	1056	p->iSum = iNewSum;
sl@0	1057	}
sl@0	1058	}else{
sl@0	1059	p->rSum += sqlite3_value_double(argv[0]);
sl@0	1060	p->approx = 1;
sl@0	1061	}
sl@0	1062	}
sl@0	1063	}
sl@0	1064	static void sumFinalize(sqlite3_context *context){
sl@0	1065	SumCtx *p;
sl@0	1066	p = sqlite3_aggregate_context(context, 0);
sl@0	1067	if( p && p->cnt>0 ){
sl@0	1068	if( p->overflow ){
sl@0	1069	sqlite3_result_error(context,"integer overflow",-1);
sl@0	1070	}else if( p->approx ){
sl@0	1071	sqlite3_result_double(context, p->rSum);
sl@0	1072	}else{
sl@0	1073	sqlite3_result_int64(context, p->iSum);
sl@0	1074	}
sl@0	1075	}
sl@0	1076	}
sl@0	1077	static void avgFinalize(sqlite3_context *context){
sl@0	1078	SumCtx *p;
sl@0	1079	p = sqlite3_aggregate_context(context, 0);
sl@0	1080	if( p && p->cnt>0 ){
sl@0	1081	sqlite3_result_double(context, p->rSum/(double)p->cnt);
sl@0	1082	}
sl@0	1083	}
sl@0	1084	static void totalFinalize(sqlite3_context *context){
sl@0	1085	SumCtx *p;
sl@0	1086	p = sqlite3_aggregate_context(context, 0);
sl@0	1087	sqlite3_result_double(context, p ? p->rSum : 0.0);
sl@0	1088	}
sl@0	1089
sl@0	1090	/*
sl@0	1091	** The following structure keeps track of state information for the
sl@0	1092	** count() aggregate function.
sl@0	1093	*/
sl@0	1094	typedef struct CountCtx CountCtx;
sl@0	1095	struct CountCtx {
sl@0	1096	i64 n;
sl@0	1097	};
sl@0	1098
sl@0	1099	/*
sl@0	1100	** Routines to implement the count() aggregate function.
sl@0	1101	*/
sl@0	1102	static void countStep(sqlite3_context context, int argc, sqlite3_value *argv){
sl@0	1103	CountCtx *p;
sl@0	1104	p = sqlite3_aggregate_context(context, sizeof(*p));
sl@0	1105	if( (argc==0 \|\| SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){
sl@0	1106	p->n++;
sl@0	1107	}
sl@0	1108	}
sl@0	1109	static void countFinalize(sqlite3_context *context){
sl@0	1110	CountCtx *p;
sl@0	1111	p = sqlite3_aggregate_context(context, 0);
sl@0	1112	sqlite3_result_int64(context, p ? p->n : 0);
sl@0	1113	}
sl@0	1114
sl@0	1115	/*
sl@0	1116	** Routines to implement min() and max() aggregate functions.
sl@0	1117	*/
sl@0	1118	static void minmaxStep(sqlite3_context context, int argc, sqlite3_value *argv){
sl@0	1119	Mem pArg = (Mem )argv[0];
sl@0	1120	Mem *pBest;
sl@0	1121
sl@0	1122	if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
sl@0	1123	pBest = (Mem )sqlite3_aggregate_context(context, sizeof(pBest));
sl@0	1124	if( !pBest ) return;
sl@0	1125
sl@0	1126	if( pBest->flags ){
sl@0	1127	int max;
sl@0	1128	int cmp;
sl@0	1129	CollSeq *pColl = sqlite3GetFuncCollSeq(context);
sl@0	1130	/* This step function is used for both the min() and max() aggregates,
sl@0	1131	** the only difference between the two being that the sense of the
sl@0	1132	** comparison is inverted. For the max() aggregate, the
sl@0	1133	** sqlite3_user_data() function returns (void *)-1. For min() it
sl@0	1134	** returns (void )db, where db is the sqlite3 database pointer.
sl@0	1135	** Therefore the next statement sets variable 'max' to 1 for the max()
sl@0	1136	** aggregate, or 0 for min().
sl@0	1137	*/
sl@0	1138	max = sqlite3_user_data(context)!=0;
sl@0	1139	cmp = sqlite3MemCompare(pBest, pArg, pColl);
sl@0	1140	if( (max && cmp<0) \|\| (!max && cmp>0) ){
sl@0	1141	sqlite3VdbeMemCopy(pBest, pArg);
sl@0	1142	}
sl@0	1143	}else{
sl@0	1144	sqlite3VdbeMemCopy(pBest, pArg);
sl@0	1145	}
sl@0	1146	}
sl@0	1147	static void minMaxFinalize(sqlite3_context *context){
sl@0	1148	sqlite3_value *pRes;
sl@0	1149	pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0);
sl@0	1150	if( pRes ){
sl@0	1151	if( pRes->flags ){
sl@0	1152	sqlite3_result_value(context, pRes);
sl@0	1153	}
sl@0	1154	sqlite3VdbeMemRelease(pRes);
sl@0	1155	}
sl@0	1156	}
sl@0	1157
sl@0	1158	/*
sl@0	1159	** group_concat(EXPR, ?SEPARATOR?)
sl@0	1160	*/
sl@0	1161	static void groupConcatStep(
sl@0	1162	sqlite3_context *context,
sl@0	1163	int argc,
sl@0	1164	sqlite3_value **argv
sl@0	1165	){
sl@0	1166	const char *zVal;
sl@0	1167	StrAccum *pAccum;
sl@0	1168	const char *zSep;
sl@0	1169	int nVal, nSep, i;
sl@0	1170	if( argc==0 \|\| sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
sl@0	1171	pAccum = (StrAccum)sqlite3_aggregate_context(context, sizeof(pAccum));
sl@0	1172
sl@0	1173	if( pAccum ){
sl@0	1174	sqlite3 *db = sqlite3_context_db_handle(context);
sl@0	1175	pAccum->useMalloc = 1;
sl@0	1176	pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
sl@0	1177	if( pAccum->nChar ){
sl@0	1178	if( argc>1 ){
sl@0	1179	zSep = (char*)sqlite3_value_text(argv[argc-1]);
sl@0	1180	nSep = sqlite3_value_bytes(argv[argc-1]);
sl@0	1181	}else{
sl@0	1182	zSep = ",";
sl@0	1183	nSep = 1;
sl@0	1184	}
sl@0	1185	sqlite3StrAccumAppend(pAccum, zSep, nSep);
sl@0	1186	}
sl@0	1187	i = 0;
sl@0	1188	do{
sl@0	1189	zVal = (char*)sqlite3_value_text(argv[i]);
sl@0	1190	nVal = sqlite3_value_bytes(argv[i]);
sl@0	1191	sqlite3StrAccumAppend(pAccum, zVal, nVal);
sl@0	1192	i++;
sl@0	1193	}while( i<argc-1 );
sl@0	1194	}
sl@0	1195	}
sl@0	1196	static void groupConcatFinalize(sqlite3_context *context){
sl@0	1197	StrAccum *pAccum;
sl@0	1198	pAccum = sqlite3_aggregate_context(context, 0);
sl@0	1199	if( pAccum ){
sl@0	1200	if( pAccum->tooBig ){
sl@0	1201	sqlite3_result_error_toobig(context);
sl@0	1202	}else if( pAccum->mallocFailed ){
sl@0	1203	sqlite3_result_error_nomem(context);
sl@0	1204	}else{
sl@0	1205	sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1,
sl@0	1206	sqlite3_free);
sl@0	1207	}
sl@0	1208	}
sl@0	1209	}
sl@0	1210
sl@0	1211	/*
sl@0	1212	** This function registered all of the above C functions as SQL
sl@0	1213	** functions. This should be the only routine in this file with
sl@0	1214	** external linkage.
sl@0	1215	*/
sl@0	1216	void sqlite3RegisterBuiltinFunctions(sqlite3 *db){
sl@0	1217	static const struct {
sl@0	1218	char *zName;
sl@0	1219	signed char nArg;
sl@0	1220	u8 argType; /* 1: 0, 2: 1, 3: 2,... N: N-1. */
sl@0	1221	u8 eTextRep; /* 1: UTF-16. 0: UTF-8 */
sl@0	1222	u8 needCollSeq;
sl@0	1223	void (xFunc)(sqlite3_context,int,sqlite3_value **);
sl@0	1224	} aFuncs[] = {
sl@0	1225	{ "min", -1, 0, SQLITE_UTF8, 1, minmaxFunc },
sl@0	1226	{ "min", 0, 0, SQLITE_UTF8, 1, 0 },
sl@0	1227	{ "max", -1, 1, SQLITE_UTF8, 1, minmaxFunc },
sl@0	1228	{ "max", 0, 1, SQLITE_UTF8, 1, 0 },
sl@0	1229	{ "typeof", 1, 0, SQLITE_UTF8, 0, typeofFunc },
sl@0	1230	{ "length", 1, 0, SQLITE_UTF8, 0, lengthFunc },
sl@0	1231	{ "substr", 2, 0, SQLITE_UTF8, 0, substrFunc },
sl@0	1232	{ "substr", 3, 0, SQLITE_UTF8, 0, substrFunc },
sl@0	1233	{ "abs", 1, 0, SQLITE_UTF8, 0, absFunc },
sl@0	1234	{ "round", 1, 0, SQLITE_UTF8, 0, roundFunc },
sl@0	1235	{ "round", 2, 0, SQLITE_UTF8, 0, roundFunc },
sl@0	1236	{ "upper", 1, 0, SQLITE_UTF8, 0, upperFunc },
sl@0	1237	{ "lower", 1, 0, SQLITE_UTF8, 0, lowerFunc },
sl@0	1238	{ "coalesce", -1, 0, SQLITE_UTF8, 0, ifnullFunc },
sl@0	1239	{ "coalesce", 0, 0, SQLITE_UTF8, 0, 0 },
sl@0	1240	{ "coalesce", 1, 0, SQLITE_UTF8, 0, 0 },
sl@0	1241	{ "hex", 1, 0, SQLITE_UTF8, 0, hexFunc },
sl@0	1242	{ "ifnull", 2, 0, SQLITE_UTF8, 1, ifnullFunc },
sl@0	1243	{ "random", -1, 0, SQLITE_UTF8, 0, randomFunc },
sl@0	1244	{ "randomblob", 1, 0, SQLITE_UTF8, 0, randomBlob },
sl@0	1245	{ "nullif", 2, 0, SQLITE_UTF8, 1, nullifFunc },
sl@0	1246	{ "sqlite_version", 0, 0, SQLITE_UTF8, 0, versionFunc},
sl@0	1247	{ "quote", 1, 0, SQLITE_UTF8, 0, quoteFunc },
sl@0	1248	{ "last_insert_rowid", 0, 0, SQLITE_UTF8, 0, last_insert_rowid },
sl@0	1249	{ "changes", 0, 0, SQLITE_UTF8, 0, changes },
sl@0	1250	{ "total_changes", 0, 0, SQLITE_UTF8, 0, total_changes },
sl@0	1251	{ "replace", 3, 0, SQLITE_UTF8, 0, replaceFunc },
sl@0	1252	{ "ltrim", 1, 1, SQLITE_UTF8, 0, trimFunc },
sl@0	1253	{ "ltrim", 2, 1, SQLITE_UTF8, 0, trimFunc },
sl@0	1254	{ "rtrim", 1, 2, SQLITE_UTF8, 0, trimFunc },
sl@0	1255	{ "rtrim", 2, 2, SQLITE_UTF8, 0, trimFunc },
sl@0	1256	{ "trim", 1, 3, SQLITE_UTF8, 0, trimFunc },
sl@0	1257	{ "trim", 2, 3, SQLITE_UTF8, 0, trimFunc },
sl@0	1258	{ "zeroblob", 1, 0, SQLITE_UTF8, 0, zeroblobFunc },
sl@0	1259	#ifdef SQLITE_SOUNDEX
sl@0	1260	{ "soundex", 1, 0, SQLITE_UTF8, 0, soundexFunc},
sl@0	1261	#endif
sl@0	1262	#ifndef SQLITE_OMIT_LOAD_EXTENSION
sl@0	1263	{ "load_extension", 1, 0, SQLITE_UTF8, 0, loadExt },
sl@0	1264	{ "load_extension", 2, 0, SQLITE_UTF8, 0, loadExt },
sl@0	1265	#endif
sl@0	1266	};
sl@0	1267	static const struct {
sl@0	1268	char *zName;
sl@0	1269	signed char nArg;
sl@0	1270	u8 argType;
sl@0	1271	u8 needCollSeq;
sl@0	1272	void (xStep)(sqlite3_context,int,sqlite3_value**);
sl@0	1273	void (xFinalize)(sqlite3_context);
sl@0	1274	} aAggs[] = {
sl@0	1275	{ "min", 1, 0, 1, minmaxStep, minMaxFinalize },
sl@0	1276	{ "max", 1, 1, 1, minmaxStep, minMaxFinalize },
sl@0	1277	{ "sum", 1, 0, 0, sumStep, sumFinalize },
sl@0	1278	{ "total", 1, 0, 0, sumStep, totalFinalize },
sl@0	1279	{ "avg", 1, 0, 0, sumStep, avgFinalize },
sl@0	1280	{ "count", 0, 0, 0, countStep, countFinalize },
sl@0	1281	{ "count", 1, 0, 0, countStep, countFinalize },
sl@0	1282	{ "group_concat", -1, 0, 0, groupConcatStep, groupConcatFinalize },
sl@0	1283	};
sl@0	1284	int i;
sl@0	1285
sl@0	1286	for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
sl@0	1287	void *pArg;
sl@0	1288	u8 argType = aFuncs[i].argType;
sl@0	1289	pArg = SQLITE_INT_TO_PTR(argType);
sl@0	1290	sqlite3CreateFunc(db, aFuncs[i].zName, aFuncs[i].nArg,
sl@0	1291	aFuncs[i].eTextRep, pArg, aFuncs[i].xFunc, 0, 0);
sl@0	1292	if( aFuncs[i].needCollSeq ){
sl@0	1293	FuncDef *pFunc = sqlite3FindFunction(db, aFuncs[i].zName,
sl@0	1294	strlen(aFuncs[i].zName), aFuncs[i].nArg, aFuncs[i].eTextRep, 0);
sl@0	1295	if( pFunc && aFuncs[i].needCollSeq ){
sl@0	1296	pFunc->needCollSeq = 1;
sl@0	1297	}
sl@0	1298	}
sl@0	1299	}
sl@0	1300	#ifndef SQLITE_OMIT_ALTERTABLE
sl@0	1301	sqlite3AlterFunctions(db);
sl@0	1302	#endif
sl@0	1303	#ifndef SQLITE_OMIT_PARSER
sl@0	1304	sqlite3AttachFunctions(db);
sl@0	1305	#endif
sl@0	1306	for(i=0; i<sizeof(aAggs)/sizeof(aAggs[0]); i++){
sl@0	1307	void *pArg = SQLITE_INT_TO_PTR(aAggs[i].argType);
sl@0	1308	sqlite3CreateFunc(db, aAggs[i].zName, aAggs[i].nArg, SQLITE_UTF8,
sl@0	1309	pArg, 0, aAggs[i].xStep, aAggs[i].xFinalize);
sl@0	1310	if( aAggs[i].needCollSeq ){
sl@0	1311	FuncDef *pFunc = sqlite3FindFunction( db, aAggs[i].zName,
sl@0	1312	strlen(aAggs[i].zName), aAggs[i].nArg, SQLITE_UTF8, 0);
sl@0	1313	if( pFunc && aAggs[i].needCollSeq ){
sl@0	1314	pFunc->needCollSeq = 1;
sl@0	1315	}
sl@0	1316	}
sl@0	1317	}
sl@0	1318	sqlite3RegisterDateTimeFunctions(db);
sl@0	1319	if( !db->mallocFailed ){
sl@0	1320	int rc = sqlite3_overload_function(db, "MATCH", 2);
sl@0	1321	assert( rc==SQLITE_NOMEM \|\| rc==SQLITE_OK );
sl@0	1322	if( rc==SQLITE_NOMEM ){
sl@0	1323	db->mallocFailed = 1;
sl@0	1324	}
sl@0	1325	}
sl@0	1326	#ifdef SQLITE_SSE
sl@0	1327	(void)sqlite3SseFunctions(db);
sl@0	1328	#endif
sl@0	1329	#ifdef SQLITE_CASE_SENSITIVE_LIKE
sl@0	1330	sqlite3RegisterLikeFunctions(db, 1);
sl@0	1331	#else
sl@0	1332	sqlite3RegisterLikeFunctions(db, 0);
sl@0	1333	#endif
sl@0	1334	}
sl@0	1335
sl@0	1336	/*
sl@0	1337	** Set the LIKEOPT flag on the 2-argument function with the given name.
sl@0	1338	*/
sl@0	1339	static void setLikeOptFlag(sqlite3 db, const char zName, int flagVal){
sl@0	1340	FuncDef *pDef;
sl@0	1341	pDef = sqlite3FindFunction(db, zName, strlen(zName), 2, SQLITE_UTF8, 0);
sl@0	1342	if( pDef ){
sl@0	1343	pDef->flags = flagVal;
sl@0	1344	}
sl@0	1345	}
sl@0	1346
sl@0	1347	/*
sl@0	1348	** Register the built-in LIKE and GLOB functions. The caseSensitive
sl@0	1349	** parameter determines whether or not the LIKE operator is case
sl@0	1350	** sensitive. GLOB is always case sensitive.
sl@0	1351	*/
sl@0	1352	void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){
sl@0	1353	struct compareInfo *pInfo;
sl@0	1354	if( caseSensitive ){
sl@0	1355	pInfo = (struct compareInfo*)&likeInfoAlt;
sl@0	1356	}else{
sl@0	1357	pInfo = (struct compareInfo*)&likeInfoNorm;
sl@0	1358	}
sl@0	1359	sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0);
sl@0	1360	sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0);
sl@0	1361	sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8,
sl@0	1362	(struct compareInfo*)&globInfo, likeFunc, 0,0);
sl@0	1363	setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE \| SQLITE_FUNC_CASE);
sl@0	1364	setLikeOptFlag(db, "like",
sl@0	1365	caseSensitive ? (SQLITE_FUNC_LIKE \| SQLITE_FUNC_CASE) : SQLITE_FUNC_LIKE);
sl@0	1366	}
sl@0	1367
sl@0	1368	/*
sl@0	1369	** pExpr points to an expression which implements a function. If
sl@0	1370	** it is appropriate to apply the LIKE optimization to that function
sl@0	1371	** then set aWc[0] through aWc[2] to the wildcard characters and
sl@0	1372	** return TRUE. If the function is not a LIKE-style function then
sl@0	1373	** return FALSE.
sl@0	1374	*/
sl@0	1375	int sqlite3IsLikeFunction(sqlite3 db, Expr pExpr, int pIsNocase, char aWc){
sl@0	1376	FuncDef *pDef;
sl@0	1377	if( pExpr->op!=TK_FUNCTION \|\| !pExpr->pList ){
sl@0	1378	return 0;
sl@0	1379	}
sl@0	1380	if( pExpr->pList->nExpr!=2 ){
sl@0	1381	return 0;
sl@0	1382	}
sl@0	1383	pDef = sqlite3FindFunction(db, (char*)pExpr->token.z, pExpr->token.n, 2,
sl@0	1384	SQLITE_UTF8, 0);
sl@0	1385	if( pDef==0 \|\| (pDef->flags & SQLITE_FUNC_LIKE)==0 ){
sl@0	1386	return 0;
sl@0	1387	}
sl@0	1388
sl@0	1389	/* The memcpy() statement assumes that the wildcard characters are
sl@0	1390	** the first three statements in the compareInfo structure. The
sl@0	1391	** asserts() that follow verify that assumption
sl@0	1392	*/
sl@0	1393	memcpy(aWc, pDef->pUserData, 3);
sl@0	1394	assert( (char)&likeInfoAlt == (char)&likeInfoAlt.matchAll );
sl@0	1395	assert( &((char)&likeInfoAlt)[1] == (char)&likeInfoAlt.matchOne );
sl@0	1396	assert( &((char)&likeInfoAlt)[2] == (char)&likeInfoAlt.matchSet );
sl@0	1397	*pIsNocase = (pDef->flags & SQLITE_FUNC_CASE)==0;
sl@0	1398	return 1;
sl@0	1399	}

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--