Annotation of embedaddon/sqlite3/src/callback.c, revision 1.1.1.1
1.1 misho 1: /*
2: ** 2005 May 23
3: **
4: ** The author disclaims copyright to this source code. In place of
5: ** a legal notice, here is a blessing:
6: **
7: ** May you do good and not evil.
8: ** May you find forgiveness for yourself and forgive others.
9: ** May you share freely, never taking more than you give.
10: **
11: *************************************************************************
12: **
13: ** This file contains functions used to access the internal hash tables
14: ** of user defined functions and collation sequences.
15: */
16:
17: #include "sqliteInt.h"
18:
19: /*
20: ** Invoke the 'collation needed' callback to request a collation sequence
21: ** in the encoding enc of name zName, length nName.
22: */
23: static void callCollNeeded(sqlite3 *db, int enc, const char *zName){
24: assert( !db->xCollNeeded || !db->xCollNeeded16 );
25: if( db->xCollNeeded ){
26: char *zExternal = sqlite3DbStrDup(db, zName);
27: if( !zExternal ) return;
28: db->xCollNeeded(db->pCollNeededArg, db, enc, zExternal);
29: sqlite3DbFree(db, zExternal);
30: }
31: #ifndef SQLITE_OMIT_UTF16
32: if( db->xCollNeeded16 ){
33: char const *zExternal;
34: sqlite3_value *pTmp = sqlite3ValueNew(db);
35: sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);
36: zExternal = sqlite3ValueText(pTmp, SQLITE_UTF16NATIVE);
37: if( zExternal ){
38: db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal);
39: }
40: sqlite3ValueFree(pTmp);
41: }
42: #endif
43: }
44:
45: /*
46: ** This routine is called if the collation factory fails to deliver a
47: ** collation function in the best encoding but there may be other versions
48: ** of this collation function (for other text encodings) available. Use one
49: ** of these instead if they exist. Avoid a UTF-8 <-> UTF-16 conversion if
50: ** possible.
51: */
52: static int synthCollSeq(sqlite3 *db, CollSeq *pColl){
53: CollSeq *pColl2;
54: char *z = pColl->zName;
55: int i;
56: static const u8 aEnc[] = { SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8 };
57: for(i=0; i<3; i++){
58: pColl2 = sqlite3FindCollSeq(db, aEnc[i], z, 0);
59: if( pColl2->xCmp!=0 ){
60: memcpy(pColl, pColl2, sizeof(CollSeq));
61: pColl->xDel = 0; /* Do not copy the destructor */
62: return SQLITE_OK;
63: }
64: }
65: return SQLITE_ERROR;
66: }
67:
68: /*
69: ** This function is responsible for invoking the collation factory callback
70: ** or substituting a collation sequence of a different encoding when the
71: ** requested collation sequence is not available in the desired encoding.
72: **
73: ** If it is not NULL, then pColl must point to the database native encoding
74: ** collation sequence with name zName, length nName.
75: **
76: ** The return value is either the collation sequence to be used in database
77: ** db for collation type name zName, length nName, or NULL, if no collation
78: ** sequence can be found.
79: **
80: ** See also: sqlite3LocateCollSeq(), sqlite3FindCollSeq()
81: */
82: CollSeq *sqlite3GetCollSeq(
83: sqlite3* db, /* The database connection */
84: u8 enc, /* The desired encoding for the collating sequence */
85: CollSeq *pColl, /* Collating sequence with native encoding, or NULL */
86: const char *zName /* Collating sequence name */
87: ){
88: CollSeq *p;
89:
90: p = pColl;
91: if( !p ){
92: p = sqlite3FindCollSeq(db, enc, zName, 0);
93: }
94: if( !p || !p->xCmp ){
95: /* No collation sequence of this type for this encoding is registered.
96: ** Call the collation factory to see if it can supply us with one.
97: */
98: callCollNeeded(db, enc, zName);
99: p = sqlite3FindCollSeq(db, enc, zName, 0);
100: }
101: if( p && !p->xCmp && synthCollSeq(db, p) ){
102: p = 0;
103: }
104: assert( !p || p->xCmp );
105: return p;
106: }
107:
108: /*
109: ** This routine is called on a collation sequence before it is used to
110: ** check that it is defined. An undefined collation sequence exists when
111: ** a database is loaded that contains references to collation sequences
112: ** that have not been defined by sqlite3_create_collation() etc.
113: **
114: ** If required, this routine calls the 'collation needed' callback to
115: ** request a definition of the collating sequence. If this doesn't work,
116: ** an equivalent collating sequence that uses a text encoding different
117: ** from the main database is substituted, if one is available.
118: */
119: int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){
120: if( pColl ){
121: const char *zName = pColl->zName;
122: sqlite3 *db = pParse->db;
123: CollSeq *p = sqlite3GetCollSeq(db, ENC(db), pColl, zName);
124: if( !p ){
125: sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
126: pParse->nErr++;
127: return SQLITE_ERROR;
128: }
129: assert( p==pColl );
130: }
131: return SQLITE_OK;
132: }
133:
134:
135:
136: /*
137: ** Locate and return an entry from the db.aCollSeq hash table. If the entry
138: ** specified by zName and nName is not found and parameter 'create' is
139: ** true, then create a new entry. Otherwise return NULL.
140: **
141: ** Each pointer stored in the sqlite3.aCollSeq hash table contains an
142: ** array of three CollSeq structures. The first is the collation sequence
143: ** prefferred for UTF-8, the second UTF-16le, and the third UTF-16be.
144: **
145: ** Stored immediately after the three collation sequences is a copy of
146: ** the collation sequence name. A pointer to this string is stored in
147: ** each collation sequence structure.
148: */
149: static CollSeq *findCollSeqEntry(
150: sqlite3 *db, /* Database connection */
151: const char *zName, /* Name of the collating sequence */
152: int create /* Create a new entry if true */
153: ){
154: CollSeq *pColl;
155: int nName = sqlite3Strlen30(zName);
156: pColl = sqlite3HashFind(&db->aCollSeq, zName, nName);
157:
158: if( 0==pColl && create ){
159: pColl = sqlite3DbMallocZero(db, 3*sizeof(*pColl) + nName + 1 );
160: if( pColl ){
161: CollSeq *pDel = 0;
162: pColl[0].zName = (char*)&pColl[3];
163: pColl[0].enc = SQLITE_UTF8;
164: pColl[1].zName = (char*)&pColl[3];
165: pColl[1].enc = SQLITE_UTF16LE;
166: pColl[2].zName = (char*)&pColl[3];
167: pColl[2].enc = SQLITE_UTF16BE;
168: memcpy(pColl[0].zName, zName, nName);
169: pColl[0].zName[nName] = 0;
170: pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, nName, pColl);
171:
172: /* If a malloc() failure occurred in sqlite3HashInsert(), it will
173: ** return the pColl pointer to be deleted (because it wasn't added
174: ** to the hash table).
175: */
176: assert( pDel==0 || pDel==pColl );
177: if( pDel!=0 ){
178: db->mallocFailed = 1;
179: sqlite3DbFree(db, pDel);
180: pColl = 0;
181: }
182: }
183: }
184: return pColl;
185: }
186:
187: /*
188: ** Parameter zName points to a UTF-8 encoded string nName bytes long.
189: ** Return the CollSeq* pointer for the collation sequence named zName
190: ** for the encoding 'enc' from the database 'db'.
191: **
192: ** If the entry specified is not found and 'create' is true, then create a
193: ** new entry. Otherwise return NULL.
194: **
195: ** A separate function sqlite3LocateCollSeq() is a wrapper around
196: ** this routine. sqlite3LocateCollSeq() invokes the collation factory
197: ** if necessary and generates an error message if the collating sequence
198: ** cannot be found.
199: **
200: ** See also: sqlite3LocateCollSeq(), sqlite3GetCollSeq()
201: */
202: CollSeq *sqlite3FindCollSeq(
203: sqlite3 *db,
204: u8 enc,
205: const char *zName,
206: int create
207: ){
208: CollSeq *pColl;
209: if( zName ){
210: pColl = findCollSeqEntry(db, zName, create);
211: }else{
212: pColl = db->pDfltColl;
213: }
214: assert( SQLITE_UTF8==1 && SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
215: assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE );
216: if( pColl ) pColl += enc-1;
217: return pColl;
218: }
219:
220: /* During the search for the best function definition, this procedure
221: ** is called to test how well the function passed as the first argument
222: ** matches the request for a function with nArg arguments in a system
223: ** that uses encoding enc. The value returned indicates how well the
224: ** request is matched. A higher value indicates a better match.
225: **
226: ** The returned value is always between 0 and 6, as follows:
227: **
228: ** 0: Not a match, or if nArg<0 and the function is has no implementation.
229: ** 1: A variable arguments function that prefers UTF-8 when a UTF-16
230: ** encoding is requested, or vice versa.
231: ** 2: A variable arguments function that uses UTF-16BE when UTF-16LE is
232: ** requested, or vice versa.
233: ** 3: A variable arguments function using the same text encoding.
234: ** 4: A function with the exact number of arguments requested that
235: ** prefers UTF-8 when a UTF-16 encoding is requested, or vice versa.
236: ** 5: A function with the exact number of arguments requested that
237: ** prefers UTF-16LE when UTF-16BE is requested, or vice versa.
238: ** 6: An exact match.
239: **
240: */
241: static int matchQuality(FuncDef *p, int nArg, u8 enc){
242: int match = 0;
243: if( p->nArg==-1 || p->nArg==nArg
244: || (nArg==-1 && (p->xFunc!=0 || p->xStep!=0))
245: ){
246: match = 1;
247: if( p->nArg==nArg || nArg==-1 ){
248: match = 4;
249: }
250: if( enc==p->iPrefEnc ){
251: match += 2;
252: }
253: else if( (enc==SQLITE_UTF16LE && p->iPrefEnc==SQLITE_UTF16BE) ||
254: (enc==SQLITE_UTF16BE && p->iPrefEnc==SQLITE_UTF16LE) ){
255: match += 1;
256: }
257: }
258: return match;
259: }
260:
261: /*
262: ** Search a FuncDefHash for a function with the given name. Return
263: ** a pointer to the matching FuncDef if found, or 0 if there is no match.
264: */
265: static FuncDef *functionSearch(
266: FuncDefHash *pHash, /* Hash table to search */
267: int h, /* Hash of the name */
268: const char *zFunc, /* Name of function */
269: int nFunc /* Number of bytes in zFunc */
270: ){
271: FuncDef *p;
272: for(p=pHash->a[h]; p; p=p->pHash){
273: if( sqlite3StrNICmp(p->zName, zFunc, nFunc)==0 && p->zName[nFunc]==0 ){
274: return p;
275: }
276: }
277: return 0;
278: }
279:
280: /*
281: ** Insert a new FuncDef into a FuncDefHash hash table.
282: */
283: void sqlite3FuncDefInsert(
284: FuncDefHash *pHash, /* The hash table into which to insert */
285: FuncDef *pDef /* The function definition to insert */
286: ){
287: FuncDef *pOther;
288: int nName = sqlite3Strlen30(pDef->zName);
289: u8 c1 = (u8)pDef->zName[0];
290: int h = (sqlite3UpperToLower[c1] + nName) % ArraySize(pHash->a);
291: pOther = functionSearch(pHash, h, pDef->zName, nName);
292: if( pOther ){
293: assert( pOther!=pDef && pOther->pNext!=pDef );
294: pDef->pNext = pOther->pNext;
295: pOther->pNext = pDef;
296: }else{
297: pDef->pNext = 0;
298: pDef->pHash = pHash->a[h];
299: pHash->a[h] = pDef;
300: }
301: }
302:
303:
304:
305: /*
306: ** Locate a user function given a name, a number of arguments and a flag
307: ** indicating whether the function prefers UTF-16 over UTF-8. Return a
308: ** pointer to the FuncDef structure that defines that function, or return
309: ** NULL if the function does not exist.
310: **
311: ** If the createFlag argument is true, then a new (blank) FuncDef
312: ** structure is created and liked into the "db" structure if a
313: ** no matching function previously existed. When createFlag is true
314: ** and the nArg parameter is -1, then only a function that accepts
315: ** any number of arguments will be returned.
316: **
317: ** If createFlag is false and nArg is -1, then the first valid
318: ** function found is returned. A function is valid if either xFunc
319: ** or xStep is non-zero.
320: **
321: ** If createFlag is false, then a function with the required name and
322: ** number of arguments may be returned even if the eTextRep flag does not
323: ** match that requested.
324: */
325: FuncDef *sqlite3FindFunction(
326: sqlite3 *db, /* An open database */
327: const char *zName, /* Name of the function. Not null-terminated */
328: int nName, /* Number of characters in the name */
329: int nArg, /* Number of arguments. -1 means any number */
330: u8 enc, /* Preferred text encoding */
331: int createFlag /* Create new entry if true and does not otherwise exist */
332: ){
333: FuncDef *p; /* Iterator variable */
334: FuncDef *pBest = 0; /* Best match found so far */
335: int bestScore = 0; /* Score of best match */
336: int h; /* Hash value */
337:
338:
339: assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
340: h = (sqlite3UpperToLower[(u8)zName[0]] + nName) % ArraySize(db->aFunc.a);
341:
342: /* First search for a match amongst the application-defined functions.
343: */
344: p = functionSearch(&db->aFunc, h, zName, nName);
345: while( p ){
346: int score = matchQuality(p, nArg, enc);
347: if( score>bestScore ){
348: pBest = p;
349: bestScore = score;
350: }
351: p = p->pNext;
352: }
353:
354: /* If no match is found, search the built-in functions.
355: **
356: ** If the SQLITE_PreferBuiltin flag is set, then search the built-in
357: ** functions even if a prior app-defined function was found. And give
358: ** priority to built-in functions.
359: **
360: ** Except, if createFlag is true, that means that we are trying to
361: ** install a new function. Whatever FuncDef structure is returned it will
362: ** have fields overwritten with new information appropriate for the
363: ** new function. But the FuncDefs for built-in functions are read-only.
364: ** So we must not search for built-ins when creating a new function.
365: */
366: if( !createFlag && (pBest==0 || (db->flags & SQLITE_PreferBuiltin)!=0) ){
367: FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
368: bestScore = 0;
369: p = functionSearch(pHash, h, zName, nName);
370: while( p ){
371: int score = matchQuality(p, nArg, enc);
372: if( score>bestScore ){
373: pBest = p;
374: bestScore = score;
375: }
376: p = p->pNext;
377: }
378: }
379:
380: /* If the createFlag parameter is true and the search did not reveal an
381: ** exact match for the name, number of arguments and encoding, then add a
382: ** new entry to the hash table and return it.
383: */
384: if( createFlag && (bestScore<6 || pBest->nArg!=nArg) &&
385: (pBest = sqlite3DbMallocZero(db, sizeof(*pBest)+nName+1))!=0 ){
386: pBest->zName = (char *)&pBest[1];
387: pBest->nArg = (u16)nArg;
388: pBest->iPrefEnc = enc;
389: memcpy(pBest->zName, zName, nName);
390: pBest->zName[nName] = 0;
391: sqlite3FuncDefInsert(&db->aFunc, pBest);
392: }
393:
394: if( pBest && (pBest->xStep || pBest->xFunc || createFlag) ){
395: return pBest;
396: }
397: return 0;
398: }
399:
400: /*
401: ** Free all resources held by the schema structure. The void* argument points
402: ** at a Schema struct. This function does not call sqlite3DbFree(db, ) on the
403: ** pointer itself, it just cleans up subsidiary resources (i.e. the contents
404: ** of the schema hash tables).
405: **
406: ** The Schema.cache_size variable is not cleared.
407: */
408: void sqlite3SchemaClear(void *p){
409: Hash temp1;
410: Hash temp2;
411: HashElem *pElem;
412: Schema *pSchema = (Schema *)p;
413:
414: temp1 = pSchema->tblHash;
415: temp2 = pSchema->trigHash;
416: sqlite3HashInit(&pSchema->trigHash);
417: sqlite3HashClear(&pSchema->idxHash);
418: for(pElem=sqliteHashFirst(&temp2); pElem; pElem=sqliteHashNext(pElem)){
419: sqlite3DeleteTrigger(0, (Trigger*)sqliteHashData(pElem));
420: }
421: sqlite3HashClear(&temp2);
422: sqlite3HashInit(&pSchema->tblHash);
423: for(pElem=sqliteHashFirst(&temp1); pElem; pElem=sqliteHashNext(pElem)){
424: Table *pTab = sqliteHashData(pElem);
425: sqlite3DeleteTable(0, pTab);
426: }
427: sqlite3HashClear(&temp1);
428: sqlite3HashClear(&pSchema->fkeyHash);
429: pSchema->pSeqTab = 0;
430: if( pSchema->flags & DB_SchemaLoaded ){
431: pSchema->iGeneration++;
432: pSchema->flags &= ~DB_SchemaLoaded;
433: }
434: }
435:
436: /*
437: ** Find and return the schema associated with a BTree. Create
438: ** a new one if necessary.
439: */
440: Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){
441: Schema * p;
442: if( pBt ){
443: p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear);
444: }else{
445: p = (Schema *)sqlite3DbMallocZero(0, sizeof(Schema));
446: }
447: if( !p ){
448: db->mallocFailed = 1;
449: }else if ( 0==p->file_format ){
450: sqlite3HashInit(&p->tblHash);
451: sqlite3HashInit(&p->idxHash);
452: sqlite3HashInit(&p->trigHash);
453: sqlite3HashInit(&p->fkeyHash);
454: p->enc = SQLITE_UTF8;
455: }
456: return p;
457: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to callback.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src