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*/
23static 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*/
52static 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 routine is called on a collation sequence before it is used to
70** check that it is defined. An undefined collation sequence exists when
71** a database is loaded that contains references to collation sequences
72** that have not been defined by sqlite3_create_collation() etc.
73**
74** If required, this routine calls the 'collation needed' callback to
75** request a definition of the collating sequence. If this doesn't work,
76** an equivalent collating sequence that uses a text encoding different
77** from the main database is substituted, if one is available.
78*/
79int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){
80 if( pColl && pColl->xCmp==0 ){
81 const char *zName = pColl->zName;
82 sqlite3 *db = pParse->db;
83 CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName);
84 if( !p ){
85 return SQLITE_ERROR;
86 }
87 assert( p==pColl );
88 }
89 return SQLITE_OK;
90}
91
92
93
94/*
95** Locate and return an entry from the db.aCollSeq hash table. If the entry
96** specified by zName and nName is not found and parameter 'create' is
97** true, then create a new entry. Otherwise return NULL.
98**
99** Each pointer stored in the sqlite3.aCollSeq hash table contains an
100** array of three CollSeq structures. The first is the collation sequence
101** preferred for UTF-8, the second UTF-16le, and the third UTF-16be.
102**
103** Stored immediately after the three collation sequences is a copy of
104** the collation sequence name. A pointer to this string is stored in
105** each collation sequence structure.
106*/
107static CollSeq *findCollSeqEntry(
108 sqlite3 *db, /* Database connection */
109 const char *zName, /* Name of the collating sequence */
110 int create /* Create a new entry if true */
111){
112 CollSeq *pColl;
113 pColl = sqlite3HashFind(&db->aCollSeq, zName);
114
115 if( 0==pColl && create ){
116 int nName = sqlite3Strlen30(zName) + 1;
117 pColl = sqlite3DbMallocZero(db, 3*sizeof(*pColl) + nName);
118 if( pColl ){
119 CollSeq *pDel = 0;
120 pColl[0].zName = (char*)&pColl[3];
121 pColl[0].enc = SQLITE_UTF8;
122 pColl[1].zName = (char*)&pColl[3];
123 pColl[1].enc = SQLITE_UTF16LE;
124 pColl[2].zName = (char*)&pColl[3];
125 pColl[2].enc = SQLITE_UTF16BE;
126 memcpy(pColl[0].zName, zName, nName);
127 pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, pColl);
128
129 /* If a malloc() failure occurred in sqlite3HashInsert(), it will
130 ** return the pColl pointer to be deleted (because it wasn't added
131 ** to the hash table).
132 */
133 assert( pDel==0 || pDel==pColl );
134 if( pDel!=0 ){
135 sqlite3OomFault(db);
136 sqlite3DbFree(db, pDel);
137 pColl = 0;
138 }
139 }
140 }
141 return pColl;
142}
143
144/*
145** Parameter zName points to a UTF-8 encoded string nName bytes long.
146** Return the CollSeq* pointer for the collation sequence named zName
147** for the encoding 'enc' from the database 'db'.
148**
149** If the entry specified is not found and 'create' is true, then create a
150** new entry. Otherwise return NULL.
151**
152** A separate function sqlite3LocateCollSeq() is a wrapper around
153** this routine. sqlite3LocateCollSeq() invokes the collation factory
154** if necessary and generates an error message if the collating sequence
155** cannot be found.
156**
157** See also: sqlite3LocateCollSeq(), sqlite3GetCollSeq()
158*/
159CollSeq *sqlite3FindCollSeq(
160 sqlite3 *db, /* Database connection to search */
161 u8 enc, /* Desired text encoding */
162 const char *zName, /* Name of the collating sequence. Might be NULL */
163 int create /* True to create CollSeq if doesn't already exist */
164){
165 CollSeq *pColl;
166 assert( SQLITE_UTF8==1 && SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
167 assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE );
168 if( zName ){
169 pColl = findCollSeqEntry(db, zName, create);
170 if( pColl ) pColl += enc-1;
171 }else{
172 pColl = db->pDfltColl;
173 }
174 return pColl;
175}
176
177/*
178** Change the text encoding for a database connection. This means that
179** the pDfltColl must change as well.
180*/
181void sqlite3SetTextEncoding(sqlite3 *db, u8 enc){
182 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
183 db->enc = enc;
184 /* EVIDENCE-OF: R-08308-17224 The default collating function for all
185 ** strings is BINARY.
186 */
187 db->pDfltColl = sqlite3FindCollSeq(db, enc, sqlite3StrBINARY, 0);
188}
189
190/*
191** This function is responsible for invoking the collation factory callback
192** or substituting a collation sequence of a different encoding when the
193** requested collation sequence is not available in the desired encoding.
194**
195** If it is not NULL, then pColl must point to the database native encoding
196** collation sequence with name zName, length nName.
197**
198** The return value is either the collation sequence to be used in database
199** db for collation type name zName, length nName, or NULL, if no collation
200** sequence can be found. If no collation is found, leave an error message.
201**
202** See also: sqlite3LocateCollSeq(), sqlite3FindCollSeq()
203*/
204CollSeq *sqlite3GetCollSeq(
205 Parse *pParse, /* Parsing context */
206 u8 enc, /* The desired encoding for the collating sequence */
207 CollSeq *pColl, /* Collating sequence with native encoding, or NULL */
208 const char *zName /* Collating sequence name */
209){
210 CollSeq *p;
211 sqlite3 *db = pParse->db;
212
213 p = pColl;
214 if( !p ){
215 p = sqlite3FindCollSeq(db, enc, zName, 0);
216 }
217 if( !p || !p->xCmp ){
218 /* No collation sequence of this type for this encoding is registered.
219 ** Call the collation factory to see if it can supply us with one.
220 */
221 callCollNeeded(db, enc, zName);
222 p = sqlite3FindCollSeq(db, enc, zName, 0);
223 }
224 if( p && !p->xCmp && synthCollSeq(db, p) ){
225 p = 0;
226 }
227 assert( !p || p->xCmp );
228 if( p==0 ){
229 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
230 pParse->rc = SQLITE_ERROR_MISSING_COLLSEQ;
231 }
232 return p;
233}
234
235/*
236** This function returns the collation sequence for database native text
237** encoding identified by the string zName.
238**
239** If the requested collation sequence is not available, or not available
240** in the database native encoding, the collation factory is invoked to
241** request it. If the collation factory does not supply such a sequence,
242** and the sequence is available in another text encoding, then that is
243** returned instead.
244**
245** If no versions of the requested collations sequence are available, or
246** another error occurs, NULL is returned and an error message written into
247** pParse.
248**
249** This routine is a wrapper around sqlite3FindCollSeq(). This routine
250** invokes the collation factory if the named collation cannot be found
251** and generates an error message.
252**
253** See also: sqlite3FindCollSeq(), sqlite3GetCollSeq()
254*/
255CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
256 sqlite3 *db = pParse->db;
257 u8 enc = ENC(db);
258 u8 initbusy = db->init.busy;
259 CollSeq *pColl;
260
261 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
262 if( !initbusy && (!pColl || !pColl->xCmp) ){
263 pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName);
264 }
265
266 return pColl;
267}
268
269/* During the search for the best function definition, this procedure
270** is called to test how well the function passed as the first argument
271** matches the request for a function with nArg arguments in a system
272** that uses encoding enc. The value returned indicates how well the
273** request is matched. A higher value indicates a better match.
274**
275** If nArg is -1 that means to only return a match (non-zero) if p->nArg
276** is also -1. In other words, we are searching for a function that
277** takes a variable number of arguments.
278**
279** If nArg is -2 that means that we are searching for any function
280** regardless of the number of arguments it uses, so return a positive
281** match score for any
282**
283** The returned value is always between 0 and 6, as follows:
284**
285** 0: Not a match.
286** 1: UTF8/16 conversion required and function takes any number of arguments.
287** 2: UTF16 byte order change required and function takes any number of args.
288** 3: encoding matches and function takes any number of arguments
289** 4: UTF8/16 conversion required - argument count matches exactly
290** 5: UTF16 byte order conversion required - argument count matches exactly
291** 6: Perfect match: encoding and argument count match exactly.
292**
293** If nArg==(-2) then any function with a non-null xSFunc is
294** a perfect match and any function with xSFunc NULL is
295** a non-match.
296*/
297#define FUNC_PERFECT_MATCH 6 /* The score for a perfect match */
298static int matchQuality(
299 FuncDef *p, /* The function we are evaluating for match quality */
300 int nArg, /* Desired number of arguments. (-1)==any */
301 u8 enc /* Desired text encoding */
302){
303 int match;
304 assert( p->nArg>=-1 );
305
306 /* Wrong number of arguments means "no match" */
307 if( p->nArg!=nArg ){
308 if( nArg==(-2) ) return (p->xSFunc==0) ? 0 : FUNC_PERFECT_MATCH;
309 if( p->nArg>=0 ) return 0;
310 }
311
312 /* Give a better score to a function with a specific number of arguments
313 ** than to function that accepts any number of arguments. */
314 if( p->nArg==nArg ){
315 match = 4;
316 }else{
317 match = 1;
318 }
319
320 /* Bonus points if the text encoding matches */
321 if( enc==(p->funcFlags & SQLITE_FUNC_ENCMASK) ){
322 match += 2; /* Exact encoding match */
323 }else if( (enc & p->funcFlags & 2)!=0 ){
324 match += 1; /* Both are UTF16, but with different byte orders */
325 }
326
327 return match;
328}
329
330/*
331** Search a FuncDefHash for a function with the given name. Return
332** a pointer to the matching FuncDef if found, or 0 if there is no match.
333*/
334FuncDef *sqlite3FunctionSearch(
335 int h, /* Hash of the name */
336 const char *zFunc /* Name of function */
337){
338 FuncDef *p;
339 for(p=sqlite3BuiltinFunctions.a[h]; p; p=p->u.pHash){
340 assert( p->funcFlags & SQLITE_FUNC_BUILTIN );
341 if( sqlite3StrICmp(p->zName, zFunc)==0 ){
342 return p;
343 }
344 }
345 return 0;
346}
347
348/*
349** Insert a new FuncDef into a FuncDefHash hash table.
350*/
351void sqlite3InsertBuiltinFuncs(
352 FuncDef *aDef, /* List of global functions to be inserted */
353 int nDef /* Length of the apDef[] list */
354){
355 int i;
356 for(i=0; i<nDef; i++){
357 FuncDef *pOther;
358 const char *zName = aDef[i].zName;
359 int nName = sqlite3Strlen30(zName);
360 int h = SQLITE_FUNC_HASH(zName[0], nName);
361 assert( aDef[i].funcFlags & SQLITE_FUNC_BUILTIN );
362 pOther = sqlite3FunctionSearch(h, zName);
363 if( pOther ){
364 assert( pOther!=&aDef[i] && pOther->pNext!=&aDef[i] );
365 aDef[i].pNext = pOther->pNext;
366 pOther->pNext = &aDef[i];
367 }else{
368 aDef[i].pNext = 0;
369 aDef[i].u.pHash = sqlite3BuiltinFunctions.a[h];
370 sqlite3BuiltinFunctions.a[h] = &aDef[i];
371 }
372 }
373}
374
375
376
377/*
378** Locate a user function given a name, a number of arguments and a flag
379** indicating whether the function prefers UTF-16 over UTF-8. Return a
380** pointer to the FuncDef structure that defines that function, or return
381** NULL if the function does not exist.
382**
383** If the createFlag argument is true, then a new (blank) FuncDef
384** structure is created and liked into the "db" structure if a
385** no matching function previously existed.
386**
387** If nArg is -2, then the first valid function found is returned. A
388** function is valid if xSFunc is non-zero. The nArg==(-2)
389** case is used to see if zName is a valid function name for some number
390** of arguments. If nArg is -2, then createFlag must be 0.
391**
392** If createFlag is false, then a function with the required name and
393** number of arguments may be returned even if the eTextRep flag does not
394** match that requested.
395*/
396FuncDef *sqlite3FindFunction(
397 sqlite3 *db, /* An open database */
398 const char *zName, /* Name of the function. zero-terminated */
399 int nArg, /* Number of arguments. -1 means any number */
400 u8 enc, /* Preferred text encoding */
401 u8 createFlag /* Create new entry if true and does not otherwise exist */
402){
403 FuncDef *p; /* Iterator variable */
404 FuncDef *pBest = 0; /* Best match found so far */
405 int bestScore = 0; /* Score of best match */
406 int h; /* Hash value */
407 int nName; /* Length of the name */
408
409 assert( nArg>=(-2) );
410 assert( nArg>=(-1) || createFlag==0 );
411 nName = sqlite3Strlen30(zName);
412
413 /* First search for a match amongst the application-defined functions.
414 */
415 p = (FuncDef*)sqlite3HashFind(&db->aFunc, zName);
416 while( p ){
417 int score = matchQuality(p, nArg, enc);
418 if( score>bestScore ){
419 pBest = p;
420 bestScore = score;
421 }
422 p = p->pNext;
423 }
424
425 /* If no match is found, search the built-in functions.
426 **
427 ** If the DBFLAG_PreferBuiltin flag is set, then search the built-in
428 ** functions even if a prior app-defined function was found. And give
429 ** priority to built-in functions.
430 **
431 ** Except, if createFlag is true, that means that we are trying to
432 ** install a new function. Whatever FuncDef structure is returned it will
433 ** have fields overwritten with new information appropriate for the
434 ** new function. But the FuncDefs for built-in functions are read-only.
435 ** So we must not search for built-ins when creating a new function.
436 */
437 if( !createFlag && (pBest==0 || (db->mDbFlags & DBFLAG_PreferBuiltin)!=0) ){
438 bestScore = 0;
439 h = SQLITE_FUNC_HASH(sqlite3UpperToLower[(u8)zName[0]], nName);
440 p = sqlite3FunctionSearch(h, zName);
441 while( p ){
442 int score = matchQuality(p, nArg, enc);
443 if( score>bestScore ){
444 pBest = p;
445 bestScore = score;
446 }
447 p = p->pNext;
448 }
449 }
450
451 /* If the createFlag parameter is true and the search did not reveal an
452 ** exact match for the name, number of arguments and encoding, then add a
453 ** new entry to the hash table and return it.
454 */
455 if( createFlag && bestScore<FUNC_PERFECT_MATCH &&
456 (pBest = sqlite3DbMallocZero(db, sizeof(*pBest)+nName+1))!=0 ){
457 FuncDef *pOther;
458 u8 *z;
459 pBest->zName = (const char*)&pBest[1];
460 pBest->nArg = (u16)nArg;
461 pBest->funcFlags = enc;
462 memcpy((char*)&pBest[1], zName, nName+1);
463 for(z=(u8*)pBest->zName; *z; z++) *z = sqlite3UpperToLower[*z];
464 pOther = (FuncDef*)sqlite3HashInsert(&db->aFunc, pBest->zName, pBest);
465 if( pOther==pBest ){
466 sqlite3DbFree(db, pBest);
467 sqlite3OomFault(db);
468 return 0;
469 }else{
470 pBest->pNext = pOther;
471 }
472 }
473
474 if( pBest && (pBest->xSFunc || createFlag) ){
475 return pBest;
476 }
477 return 0;
478}
479
480/*
481** Free all resources held by the schema structure. The void* argument points
482** at a Schema struct. This function does not call sqlite3DbFree(db, ) on the
483** pointer itself, it just cleans up subsidiary resources (i.e. the contents
484** of the schema hash tables).
485**
486** The Schema.cache_size variable is not cleared.
487*/
488void sqlite3SchemaClear(void *p){
489 Hash temp1;
490 Hash temp2;
491 HashElem *pElem;
492 Schema *pSchema = (Schema *)p;
493 sqlite3 xdb;
494
495 memset(&xdb, 0, sizeof(xdb));
496 temp1 = pSchema->tblHash;
497 temp2 = pSchema->trigHash;
498 sqlite3HashInit(&pSchema->trigHash);
499 sqlite3HashClear(&pSchema->idxHash);
500 for(pElem=sqliteHashFirst(&temp2); pElem; pElem=sqliteHashNext(pElem)){
501 sqlite3DeleteTrigger(&xdb, (Trigger*)sqliteHashData(pElem));
502 }
503 sqlite3HashClear(&temp2);
504 sqlite3HashInit(&pSchema->tblHash);
505 for(pElem=sqliteHashFirst(&temp1); pElem; pElem=sqliteHashNext(pElem)){
506 Table *pTab = sqliteHashData(pElem);
507 sqlite3DeleteTable(&xdb, pTab);
508 }
509 sqlite3HashClear(&temp1);
510 sqlite3HashClear(&pSchema->fkeyHash);
511 pSchema->pSeqTab = 0;
512 if( pSchema->schemaFlags & DB_SchemaLoaded ){
513 pSchema->iGeneration++;
514 }
515 pSchema->schemaFlags &= ~(DB_SchemaLoaded|DB_ResetWanted);
516}
517
518/*
519** Find and return the schema associated with a BTree. Create
520** a new one if necessary.
521*/
522Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){
523 Schema * p;
524 if( pBt ){
525 p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear);
526 }else{
527 p = (Schema *)sqlite3DbMallocZero(0, sizeof(Schema));
528 }
529 if( !p ){
530 sqlite3OomFault(db);
531 }else if ( 0==p->file_format ){
532 sqlite3HashInit(&p->tblHash);
533 sqlite3HashInit(&p->idxHash);
534 sqlite3HashInit(&p->trigHash);
535 sqlite3HashInit(&p->fkeyHash);
536 p->enc = SQLITE_UTF8;
537 }
538 return p;
539}
540