Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Remove the 'encoding' argument from sqlite4_create_function(). |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
f88d080127433d005246ccf6f3378313 |
User & Date: | dan 2013-06-13 15:24:05.369 |
Context
2013-06-13
| ||
16:32 | Remove the no longer required FuncDestructor object. check-in: e5d82c92f0 user: dan tags: trunk | |
15:24 | Remove the 'encoding' argument from sqlite4_create_function(). check-in: f88d080127 user: dan tags: trunk | |
2013-06-12
| ||
19:20 | Add file selectF.test. check-in: 9678daa99f user: dan tags: trunk | |
Changes
Changes to src/attach.c.
︙ | ︙ | |||
330 331 332 333 334 335 336 | ** Called by the parser to compile a DETACH statement. ** ** DETACH pDbname */ void sqlite4Detach(Parse *pParse, Expr *pDbname){ static const FuncDef detach_func = { 1, /* nArg */ | < | 330 331 332 333 334 335 336 337 338 339 340 341 342 343 | ** Called by the parser to compile a DETACH statement. ** ** DETACH pDbname */ void sqlite4Detach(Parse *pParse, Expr *pDbname){ static const FuncDef detach_func = { 1, /* nArg */ 0, /* flags */ 0, /* pUserData */ 0, /* pNext */ detachFunc, /* xFunc */ 0, /* xStep */ 0, /* xFinalize */ "sqlite_detach", /* zName */ |
︙ | ︙ | |||
352 353 354 355 356 357 358 | ** Called by the parser to compile an ATTACH statement. ** ** ATTACH p AS pDbname KEY pKey */ void sqlite4Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){ static const FuncDef attach_func = { 3, /* nArg */ | < | 351 352 353 354 355 356 357 358 359 360 361 362 363 364 | ** Called by the parser to compile an ATTACH statement. ** ** ATTACH p AS pDbname KEY pKey */ void sqlite4Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){ static const FuncDef attach_func = { 3, /* nArg */ 0, /* flags */ 0, /* pUserData */ 0, /* pNext */ attachFunc, /* xFunc */ 0, /* xStep */ 0, /* xFinalize */ "sqlite_attach", /* zName */ |
︙ | ︙ |
Changes to src/callback.c.
︙ | ︙ | |||
219 220 221 222 223 224 225 | /* During the search for the best function definition, this procedure ** is called to test how well the function passed as the first argument ** matches the request for a function with nArg arguments in a system ** that uses encoding enc. The value returned indicates how well the ** request is matched. A higher value indicates a better match. ** | | | | < < < < < < < < | < | < < | < < | < < | < < < < < < < | | 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 | /* During the search for the best function definition, this procedure ** is called to test how well the function passed as the first argument ** matches the request for a function with nArg arguments in a system ** that uses encoding enc. The value returned indicates how well the ** request is matched. A higher value indicates a better match. ** ** The returned value is as follows: ** ** 0: Not a match, or nArg<0 and the function has no implementation. ** 1: A variable arguments function. ** 2: An exact match. */ static int matchQuality(FuncDef *p, int nArg){ if( nArg<0 && (p->xFunc || p->xStep) ) return 2; if( p->nArg==nArg ) return 2; if( p->nArg<0 ) return 1; return 0; } /* ** Search a FuncDefTable for a function with the given name. Return ** a pointer to the matching FuncDef if found, or 0 if there is no match. */ static FuncDef *functionSearch( |
︙ | ︙ | |||
318 319 320 321 322 323 324 | /* ** Locate a user function given a name, a number of arguments and a flag ** indicating whether the function prefers UTF-16 over UTF-8. Return a ** pointer to the FuncDef structure that defines that function, or return ** NULL if the function does not exist. ** | | | < < < < | | 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 | /* ** Locate a user function given a name, a number of arguments and a flag ** indicating whether the function prefers UTF-16 over UTF-8. Return a ** pointer to the FuncDef structure that defines that function, or return ** NULL if the function does not exist. ** ** If the createFlag argument is true, then a new (zeroed) FuncDef ** structure is created and linked into the "db" structure if a ** no matching function previously existed. When createFlag is true ** and the nArg parameter is -1, then only a function that accepts ** any number of arguments will be returned. ** ** If createFlag is false and nArg is -1, then the first valid ** function found is returned. A function is valid if either xFunc ** or xStep is non-zero. ** ** If createFlag is false, then a function with the required name and ** number of arguments may be returned even if the eTextRep flag does not ** match that requested. */ FuncDef *sqlite4FindFunction( sqlite4 *db, /* An open database */ const char *zName, /* Name of the function. Not null-terminated */ int nName, /* Number of characters in the name */ int nArg, /* Number of arguments. -1 means any number */ int createFlag /* Create new entry if true and does not otherwise exist */ ){ FuncDef *p; /* Iterator variable */ FuncDef *pBest = 0; /* Best match found so far */ int bestScore = 0; /* Score of best match */ /* First search for a match amongst the application-defined functions. */ p = functionSearch(&db->aFunc, zName, nName); while( p ){ int score = matchQuality(p, nArg); if( score>bestScore ){ pBest = p; bestScore = score; } p = p->pSameName; } |
︙ | ︙ | |||
376 377 378 379 380 381 382 | ** So we must not search for built-ins when creating a new function. */ if( !createFlag && (pBest==0 || (db->flags & SQLITE4_PreferBuiltin)!=0) ){ FuncDefTable *pFuncTab = &db->pEnv->aGlobalFuncs; bestScore = 0; p = functionSearch(pFuncTab, zName, nName); while( p ){ | | | < | 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 | ** So we must not search for built-ins when creating a new function. */ if( !createFlag && (pBest==0 || (db->flags & SQLITE4_PreferBuiltin)!=0) ){ FuncDefTable *pFuncTab = &db->pEnv->aGlobalFuncs; bestScore = 0; p = functionSearch(pFuncTab, zName, nName); while( p ){ int score = matchQuality(p, nArg); if( score>bestScore ){ pBest = p; bestScore = score; } p = p->pSameName; } } /* If the createFlag parameter is true and the search did not reveal an ** exact match for the name, number of arguments and encoding, then add a ** new entry to the hash table and return it. */ if( createFlag && (bestScore<2 || pBest->nArg!=nArg) && (pBest = sqlite4DbMallocZero(db, sizeof(*pBest)+nName+1))!=0 ){ pBest->zName = (char *)&pBest[1]; pBest->nArg = (u16)nArg; memcpy(pBest->zName, zName, nName); pBest->zName[nName] = 0; sqlite4FuncDefInsert(&db->aFunc, pBest, 0); } if( pBest && (pBest->xStep || pBest->xFunc || createFlag) ){ return pBest; |
︙ | ︙ |
Changes to src/expr.c.
︙ | ︙ | |||
2487 2488 2489 2490 2491 2492 2493 | ExprList *pFarg; /* List of function arguments */ int nFarg; /* Number of function arguments */ FuncDef *pDef; /* The function definition object */ int nId; /* Length of the function name in bytes */ const char *zId; /* The function name */ int constMask = 0; /* Mask of function arguments that are constant */ int i; /* Loop counter */ | < | | 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 | ExprList *pFarg; /* List of function arguments */ int nFarg; /* Number of function arguments */ FuncDef *pDef; /* The function definition object */ int nId; /* Length of the function name in bytes */ const char *zId; /* The function name */ int constMask = 0; /* Mask of function arguments that are constant */ int i; /* Loop counter */ CollSeq *pColl = 0; /* A collating sequence */ assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); testcase( op==TK_CONST_FUNC ); testcase( op==TK_FUNCTION ); if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ){ pFarg = 0; }else{ pFarg = pExpr->x.pList; } nFarg = pFarg ? pFarg->nExpr : 0; assert( !ExprHasProperty(pExpr, EP_IntValue) ); zId = pExpr->u.zToken; nId = sqlite4Strlen30(zId); pDef = sqlite4FindFunction(db, zId, nId, nFarg, 0); if( pDef==0 ){ sqlite4ErrorMsg(pParse, "unknown function: %.*s()", nId, zId); break; } /* Attempt a direct implementation of the built-in COALESCE() and ** IFNULL() functions. This avoids unnecessary evalation of |
︙ | ︙ | |||
3843 3844 3845 3846 3847 3848 3849 | if( sqlite4ExprCompare(pItem->pExpr, pExpr)==0 ){ break; } } if( i>=pAggInfo->nFunc ){ /* pExpr is original. Make a new entry in pAggInfo->aFunc[] */ | < | | 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 | if( sqlite4ExprCompare(pItem->pExpr, pExpr)==0 ){ break; } } if( i>=pAggInfo->nFunc ){ /* pExpr is original. Make a new entry in pAggInfo->aFunc[] */ i = addAggInfoFunc(pParse->db, pAggInfo); if( i>=0 ){ assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); pItem = &pAggInfo->aFunc[i]; pItem->pExpr = pExpr; pItem->iMem = ++pParse->nMem; assert( !ExprHasProperty(pExpr, EP_IntValue) ); pItem->pFunc = sqlite4FindFunction(pParse->db, pExpr->u.zToken, sqlite4Strlen30(pExpr->u.zToken), pExpr->x.pList ? pExpr->x.pList->nExpr : 0, 0); if( pExpr->flags & EP_Distinct ){ pItem->iDistinct = pParse->nTab++; }else{ pItem->iDistinct = -1; } } } |
︙ | ︙ |
Changes to src/fts5.c.
︙ | ︙ | |||
3407 3408 3409 3410 3411 3412 3413 | /* ** Register the default FTS5 tokenizer and functions with handle db. */ int sqlite4InitFts5(sqlite4 *db){ #ifdef SQLITE4_TEST int rc = sqlite4_create_function( | | | 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 | /* ** Register the default FTS5 tokenizer and functions with handle db. */ int sqlite4InitFts5(sqlite4 *db){ #ifdef SQLITE4_TEST int rc = sqlite4_create_function( db, "fts5_parse_expr", 3, 0, fts5_parse_expr, 0, 0, 0 ); if( rc!=SQLITE4_OK ) return rc; #endif return sqlite4InitFts5Func(db); } |
Changes to src/func.c.
︙ | ︙ | |||
1360 1361 1362 1363 1364 1365 1366 | } /* ** Set the LIKEOPT flag on the 2-argument function with the given name. */ static void setLikeOptFlag(sqlite4 *db, const char *zName, u8 flagVal){ FuncDef *pDef; | | < | | | | 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 | } /* ** Set the LIKEOPT flag on the 2-argument function with the given name. */ static void setLikeOptFlag(sqlite4 *db, const char *zName, u8 flagVal){ FuncDef *pDef; pDef = sqlite4FindFunction(db, zName, sqlite4Strlen30(zName), 2, 0); if( ALWAYS(pDef) ){ pDef->flags = 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. */ void sqlite4RegisterLikeFunctions(sqlite4 *db, int caseSensitive){ struct compareInfo *pInfo; if( caseSensitive ){ pInfo = (struct compareInfo*)&likeInfoAlt; }else{ pInfo = (struct compareInfo*)&likeInfoNorm; } sqlite4CreateFunc(db, "like", 2, pInfo, likeFunc, 0, 0, 0); sqlite4CreateFunc(db, "like", 3, pInfo, likeFunc, 0, 0, 0); sqlite4CreateFunc(db, "glob", 2, (struct compareInfo*)&globInfo, likeFunc, 0, 0, 0); setLikeOptFlag(db, "glob", SQLITE4_FUNC_LIKE | SQLITE4_FUNC_CASE); setLikeOptFlag(db, "like", caseSensitive ? (SQLITE4_FUNC_LIKE | SQLITE4_FUNC_CASE) : SQLITE4_FUNC_LIKE); } /* |
︙ | ︙ | |||
1405 1406 1407 1408 1409 1410 1411 | || !pExpr->x.pList || pExpr->x.pList->nExpr!=2 ){ return 0; } assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); pDef = sqlite4FindFunction(db, pExpr->u.zToken, | | < | 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 | || !pExpr->x.pList || pExpr->x.pList->nExpr!=2 ){ return 0; } assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); pDef = sqlite4FindFunction(db, pExpr->u.zToken, sqlite4Strlen30(pExpr->u.zToken), 2, 0); if( NEVER(pDef==0) || (pDef->flags & SQLITE4_FUNC_LIKE)==0 ){ return 0; } /* The memcpy() statement assumes that the wildcard characters are ** the first three statements in the compareInfo structure. The ** asserts() that follow verify that assumption |
︙ | ︙ | |||
1463 1464 1465 1466 1467 1468 1469 | FUNCTION(round, 1, 0, 0, roundFunc ), FUNCTION(round, 2, 0, 0, roundFunc ), FUNCTION(upper, 1, 0, 0, upperFunc ), FUNCTION(lower, 1, 0, 0, lowerFunc ), FUNCTION(coalesce, 1, 0, 0, 0 ), FUNCTION(coalesce, 0, 0, 0, 0 ), /* FUNCTION(coalesce, -1, 0, 0, ifnullFunc ), */ | | | | 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 | FUNCTION(round, 1, 0, 0, roundFunc ), FUNCTION(round, 2, 0, 0, roundFunc ), FUNCTION(upper, 1, 0, 0, upperFunc ), FUNCTION(lower, 1, 0, 0, lowerFunc ), FUNCTION(coalesce, 1, 0, 0, 0 ), FUNCTION(coalesce, 0, 0, 0, 0 ), /* FUNCTION(coalesce, -1, 0, 0, ifnullFunc ), */ {-1,SQLITE4_FUNC_COALESCE,0,0,ifnullFunc,0,0,"coalesce",0,0}, FUNCTION(hex, 1, 0, 0, hexFunc ), /* FUNCTION(ifnull, 2, 0, 0, ifnullFunc ), */ {2,SQLITE4_FUNC_COALESCE,0,0,ifnullFunc,0,0,"ifnull",0,0}, 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 ), #ifndef SQLITE4_OMIT_COMPILEOPTION_DIAGS |
︙ | ︙ | |||
1492 1493 1494 1495 1496 1497 1498 | 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 ), */ | | | 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 | 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 ), */ {0,SQLITE4_FUNC_COUNT,0,0,0,countStep,countFinalize,"count",0,0}, 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, SQLITE4_FUNC_LIKE|SQLITE4_FUNC_CASE), #ifdef SQLITE4_CASE_SENSITIVE_LIKE LIKEFUNC(like, 2, &likeInfoAlt, SQLITE4_FUNC_LIKE|SQLITE4_FUNC_CASE), |
︙ | ︙ |
Changes to src/main.c.
︙ | ︙ | |||
538 539 540 541 542 543 544 | ** that if a malloc() fails in sqlite4_create_function(), an error code ** is returned and the mallocFailed flag cleared. */ int sqlite4CreateFunc( sqlite4 *db, const char *zFunctionName, int nArg, | < < < < < < < < < < < < < < < < < < < < < < < < < < < < | | | | 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 | ** that if a malloc() fails in sqlite4_create_function(), an error code ** is returned and the mallocFailed flag cleared. */ int sqlite4CreateFunc( sqlite4 *db, const char *zFunctionName, int nArg, void *pUserData, void (*xFunc)(sqlite4_context*,int,sqlite4_value **), void (*xStep)(sqlite4_context*,int,sqlite4_value **), void (*xFinal)(sqlite4_context*), FuncDestructor *pDestructor ){ FuncDef *p; int nName; assert( sqlite4_mutex_held(db->mutex) ); if( zFunctionName==0 || (xFunc && (xFinal || xStep)) || (!xFunc && (xFinal && !xStep)) || (!xFunc && (!xFinal && xStep)) || (nArg<-1 || nArg>SQLITE4_MAX_FUNCTION_ARG) || (255<(nName = sqlite4Strlen30( zFunctionName))) ){ return SQLITE4_MISUSE_BKPT; } /* Check if an existing function is being overridden or deleted. If so, ** and there are active VMs, then return SQLITE4_BUSY. If a function ** is being overridden/deleted but there are no active VMs, allow the ** operation to continue but invalidate all precompiled statements. */ p = sqlite4FindFunction(db, zFunctionName, nName, nArg, 0); if( p && p->nArg==nArg ){ if( db->activeVdbeCnt ){ sqlite4Error(db, SQLITE4_BUSY, "unable to delete/modify user-function due to active statements"); assert( !db->mallocFailed ); return SQLITE4_BUSY; }else{ sqlite4ExpirePreparedStatements(db); } } p = sqlite4FindFunction(db, zFunctionName, nName, nArg, 1); assert(p || db->mallocFailed); if( !p ){ return SQLITE4_NOMEM; } /* If an older version of the function with a configured destructor is ** being replaced invoke the destructor function here. */ |
︙ | ︙ | |||
633 634 635 636 637 638 639 | ** This function is the same as sqlite4_create_function(), except that ** it does not grab the database handle mutex or call sqlite4ApiExit(). */ static int createFunctionDestructor( sqlite4 *db, const char *zFunc, int nArg, | < | < | | | | 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 | ** This function is the same as sqlite4_create_function(), except that ** it does not grab the database handle mutex or call sqlite4ApiExit(). */ static int createFunctionDestructor( sqlite4 *db, const char *zFunc, int nArg, void *p, void (*xFunc)(sqlite4_context*,int,sqlite4_value **), void (*xStep)(sqlite4_context*,int,sqlite4_value **), void (*xFinal)(sqlite4_context*), void (*xDestroy)(void *) ){ int rc; FuncDestructor *pArg = 0; if( xDestroy ){ pArg = (FuncDestructor *)sqlite4DbMallocZero(db, sizeof(FuncDestructor)); if( !pArg ){ xDestroy(p); return SQLITE4_NOMEM; } pArg->xDestroy = xDestroy; pArg->pUserData = p; } rc = sqlite4CreateFunc(db, zFunc, nArg, p, xFunc, xStep, xFinal, pArg); if( pArg && pArg->nRef==0 ){ assert( rc!=SQLITE4_OK ); xDestroy(p); sqlite4DbFree(db, pArg); } return rc; } /* ** Create new user functions. */ int sqlite4_create_function( sqlite4 *db, const char *zFunc, int nArg, void *p, void (*xFunc)(sqlite4_context*,int,sqlite4_value **), void (*xStep)(sqlite4_context*,int,sqlite4_value **), void (*xFinal)(sqlite4_context*), void (*xDestroy)(void *) ){ int rc; sqlite4_mutex_enter(db->mutex); rc = createFunctionDestructor( db, zFunc, nArg, p, xFunc, xStep, xFinal, xDestroy ); rc = sqlite4ApiExit(db, rc); sqlite4_mutex_leave(db->mutex); return rc; } int sqlite4_create_mi_function( sqlite4 *db, const char *zFunc, int nArg, int enc, void *p, void (*xFunc)(sqlite4_context*,int,sqlite4_value **), void (*xDestroy)(void *) ){ int rc; int n; n = nArg + (nArg>=0); sqlite4_mutex_enter(db->mutex); rc = sqlite4_create_function(db, zFunc, n, p, xFunc, 0, 0, xDestroy); if( rc==SQLITE4_OK ){ FuncDef *p = sqlite4FindFunction(db, zFunc, -1, n, 0); p->bMatchinfo = 1; } rc = sqlite4ApiExit(db, rc); sqlite4_mutex_leave(db->mutex); return rc; } |
︙ | ︙ | |||
730 731 732 733 734 735 736 | sqlite4 *db, const char *zName, int nArg ){ int nName = sqlite4Strlen30(zName); int rc = SQLITE4_OK; sqlite4_mutex_enter(db->mutex); | | | | 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 | sqlite4 *db, const char *zName, int nArg ){ int nName = sqlite4Strlen30(zName); int rc = SQLITE4_OK; sqlite4_mutex_enter(db->mutex); if( sqlite4FindFunction(db, zName, nName, nArg, 0)==0 ){ rc = sqlite4CreateFunc(db, zName, nArg, 0, sqlite4InvalidFunction, 0, 0, 0); } rc = sqlite4ApiExit(db, rc); sqlite4_mutex_leave(db->mutex); return rc; } |
︙ | ︙ |
Changes to src/pragma.c.
︙ | ︙ | |||
746 747 748 749 750 751 752 | zErr = sqlite4MPrintf( db, "entry missing from index %s: ", pIdx->zName ); sqlite4VdbeAddOp4(v, OP_String8, 0, regTmp, 0, zErr, 0); sqlite4VdbeAddOp3(v, OP_Concat, regTmp, regErrstr, regErrstr); sqlite4VdbeAddOp3(v, OP_Function, 0, regKey, regTmp); sqlite4VdbeChangeP4(v, -1, | | | 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 | zErr = sqlite4MPrintf( db, "entry missing from index %s: ", pIdx->zName ); sqlite4VdbeAddOp4(v, OP_String8, 0, regTmp, 0, zErr, 0); sqlite4VdbeAddOp3(v, OP_Concat, regTmp, regErrstr, regErrstr); sqlite4VdbeAddOp3(v, OP_Function, 0, regKey, regTmp); sqlite4VdbeChangeP4(v, -1, (char *)sqlite4FindFunction(db, "hex", 3, 1, 0), P4_FUNCDEF ); sqlite4VdbeChangeP5(v, 1); sqlite4VdbeAddOp3(v, OP_Concat, regTmp, regErrstr, regErrstr); sqlite4VdbeAddOp4(v, OP_String8, 0, regTmp, 0, "\n", 0); sqlite4VdbeAddOp3(v, OP_Concat, regTmp, regErrstr, regErrstr); sqlite4VdbeJumpHere(v, jmp); |
︙ | ︙ | |||
1378 1379 1380 1381 1382 1383 1384 | zErr = sqlite4MPrintf( db, "entry missing from index %s: ", pIdx->zName ); sqlite4VdbeAddOp4(v, OP_String8, 0, regTmp, 0, zErr, 0); sqlite4VdbeAddOp3(v, OP_Concat, regTmp, regErrstr, regErrstr); sqlite4VdbeAddOp3(v, OP_Function, 0, regKey, regTmp); sqlite4VdbeChangeP4(v, -1, | | | 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 | zErr = sqlite4MPrintf( db, "entry missing from index %s: ", pIdx->zName ); sqlite4VdbeAddOp4(v, OP_String8, 0, regTmp, 0, zErr, 0); sqlite4VdbeAddOp3(v, OP_Concat, regTmp, regErrstr, regErrstr); sqlite4VdbeAddOp3(v, OP_Function, 0, regKey, regTmp); sqlite4VdbeChangeP4(v, -1, (char *)sqlite4FindFunction(db, "hex", 3, 1, 0), P4_FUNCDEF ); sqlite4VdbeChangeP5(v, 1); sqlite4VdbeAddOp3(v, OP_Concat, regTmp, regErrstr, regErrstr); sqlite4VdbeAddOp4(v, OP_String8, 0, regTmp, 0, "\n", 0); sqlite4VdbeAddOp3(v, OP_Concat, regTmp, regErrstr, regErrstr); sqlite4VdbeJumpHere(v, jmp); |
︙ | ︙ |
Changes to src/resolve.c.
︙ | ︙ | |||
582 583 584 585 586 587 588 | FuncDef *pDef; /* Information about the function */ u8 enc = ENC(pParse->db); /* The database encoding */ testcase( pExpr->op==TK_CONST_FUNC ); assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); zId = pExpr->u.zToken; nId = sqlite4Strlen30(zId); | | | | 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 | FuncDef *pDef; /* Information about the function */ u8 enc = ENC(pParse->db); /* The database encoding */ testcase( pExpr->op==TK_CONST_FUNC ); assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); zId = pExpr->u.zToken; nId = sqlite4Strlen30(zId); pDef = sqlite4FindFunction(pParse->db, zId, nId, n, 0); if( pDef==0 ){ pDef = sqlite4FindFunction(pParse->db, zId, nId, -1, 0); if( pDef==0 ){ no_such_func = 1; }else{ wrong_num_args = 1; } }else{ is_agg = pDef->xFunc==0; |
︙ | ︙ |
Changes to src/shell.c.
︙ | ︙ | |||
1332 1333 1334 1335 1336 1337 1338 | ** the database fails to open, print an error message and exit. */ static void open_db(struct callback_data *p){ if( p->db==0 ){ sqlite4_open(0, p->zDbFilename, &p->db, 0); db = p->db; if( db && sqlite4_errcode(db)==SQLITE4_OK ){ | | | 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 | ** the database fails to open, print an error message and exit. */ static void open_db(struct callback_data *p){ if( p->db==0 ){ sqlite4_open(0, p->zDbFilename, &p->db, 0); db = p->db; if( db && sqlite4_errcode(db)==SQLITE4_OK ){ sqlite4_create_function(db, "shellstatic", 0, 0, shellstaticFunc, 0, 0, 0); } if( db==0 || SQLITE4_OK!=sqlite4_errcode(db) ){ fprintf(stderr,"Error: unable to open database \"%s\": %s\n", p->zDbFilename, sqlite4_errmsg(db)); exit(1); } |
︙ | ︙ |
Changes to src/sqlite.h.in.
︙ | ︙ | |||
2283 2284 2285 2286 2287 2288 2289 | ** ^The third parameter (nArg) is the number of arguments that the SQL ** function or aggregate takes. ^If this parameter is -1, then the SQL ** function or aggregate may take any number of arguments between 0 and ** the limit set by [sqlite4_limit]([SQLITE4_LIMIT_FUNCTION_ARG]). If ** the third parameter is less than -1 or greater than 127 then the ** behavior is undefined. ** | | < < < < < < < < < < < < | | | < | | < < < < < < | 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 | ** ^The third parameter (nArg) is the number of arguments that the SQL ** function or aggregate takes. ^If this parameter is -1, then the SQL ** function or aggregate may take any number of arguments between 0 and ** the limit set by [sqlite4_limit]([SQLITE4_LIMIT_FUNCTION_ARG]). If ** the third parameter is less than -1 or greater than 127 then the ** behavior is undefined. ** ** ^(The fourth parameter is a context pointer. The implementation of the ** function can gain access to this pointer using [sqlite4_context_appdata()].)^ ** ** ^The fifth, sixth and seventh parameters, xFunc, xStep and xFinal, are ** pointers to C-language functions that implement the SQL function or ** aggregate. ^A scalar SQL function requires an implementation of the xFunc ** callback only; NULL pointers must be passed as the xStep and xFinal ** parameters. ^An aggregate SQL function requires an implementation of xStep ** and xFinal and NULL pointer must be passed for xFunc. ^To delete an existing ** SQL function or aggregate, pass NULL pointers for all three function ** callbacks. ** ** ^(If the eighth parameter is not NULL, then it is destructor for the ** application data pointer. The destructor is invoked when the function ** is deleted, either by being overloaded or when the database connection ** closes.)^ ^The destructor is also invoked if the call to ** sqlite4_create_function() fails. ^When the destructor callback ** is invoked, it is passed a single argument which is a copy of the ** application data pointer which was the fifth parameter to ** sqlite4_create_function(). ** ** ^It is permitted to register multiple implementations of the same ** functions with the same name but differing numbers of arguments. ^SQLite ** will use the implementation that most closely matches the way in which the ** SQL function is used. ^A function implementation with a non-negative ** nArg parameter is a better match than a function implementation with ** a negative nArg. ** ** ^Built-in functions may be overloaded by new application-defined functions. ** ** ^An application-defined function is permitted to call other ** SQLite interfaces. However, such calls must not ** close the database connection nor finalize or reset the prepared ** statement in which the function is running. */ int sqlite4_create_function( sqlite4 *db, const char *zFunctionName, int nArg, void *pApp, void (*xFunc)(sqlite4_context*,int,sqlite4_value**), void (*xStep)(sqlite4_context*,int,sqlite4_value**), void (*xFinal)(sqlite4_context*), void(*xDestroy)(void*) ); |
︙ | ︙ |
Changes to src/sqliteInt.h.
︙ | ︙ | |||
636 637 638 639 640 641 642 | ** Each SQL function is defined by an instance of the following ** structure. A pointer to this structure is stored in the sqlite.aFunc ** hash table. When multiple functions have the same name, the hash table ** points to a linked list of these structures. */ struct FuncDef { i16 nArg; /* Number of arguments. -1 means unlimited */ | < | 636 637 638 639 640 641 642 643 644 645 646 647 648 649 | ** Each SQL function is defined by an instance of the following ** structure. A pointer to this structure is stored in the sqlite.aFunc ** hash table. When multiple functions have the same name, the hash table ** points to a linked list of these structures. */ struct FuncDef { i16 nArg; /* Number of arguments. -1 means unlimited */ u8 flags; /* Some combination of SQLITE4_FUNC_* */ void *pUserData; /* User data parameter */ FuncDef *pSameName; /* Next with a different name but the same hash */ void (*xFunc)(sqlite4_context*,int,sqlite4_value**); /* Regular function */ void (*xStep)(sqlite4_context*,int,sqlite4_value**); /* Aggregate step */ void (*xFinalize)(sqlite4_context*); /* Aggregate finalizer */ char *zName; /* SQL name of the function. */ |
︙ | ︙ | |||
988 989 990 991 992 993 994 | ** that accepts nArg arguments and is implemented by a call to C ** function likeFunc. Argument pArg is cast to a (void *) and made ** available as the function user-data (sqlite4_context_appdata()). The ** FuncDef.flags variable is set to the value passed as the flags ** parameter. */ #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \ | | | | | | 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 | ** that accepts nArg arguments and is implemented by a call to C ** function likeFunc. Argument pArg is cast to a (void *) and made ** available as the function user-data (sqlite4_context_appdata()). The ** FuncDef.flags variable is set to the value passed as the flags ** parameter. */ #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \ {nArg, bNC*SQLITE4_FUNC_NEEDCOLL, \ SQLITE4_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0} #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \ {nArg, bNC*SQLITE4_FUNC_NEEDCOLL, \ pArg, 0, xFunc, 0, 0, #zName, 0, 0} #define LIKEFUNC(zName, nArg, arg, flags) \ {nArg, flags, (void *)arg, 0, likeFunc, 0, 0, #zName, 0, 0} #define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \ {nArg, nc*SQLITE4_FUNC_NEEDCOLL, \ SQLITE4_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0} /* ** All current savepoints are stored in a linked list starting at ** sqlite4.pSavepoint. The first element in the list is the most recently ** opened savepoint. Savepoints are added to the list by the vdbe ** OP_Savepoint instruction. |
︙ | ︙ | |||
2814 2815 2816 2817 2818 2819 2820 | void sqlite4HaltConstraint(Parse*, int, char*, int); Expr *sqlite4ExprDup(sqlite4*,Expr*,int); ExprList *sqlite4ExprListDup(sqlite4*,ExprList*,int); SrcList *sqlite4SrcListDup(sqlite4*,SrcList*,int); IdList *sqlite4IdListDup(sqlite4*,IdList*); Select *sqlite4SelectDup(sqlite4*,Select*,int); void sqlite4FuncDefInsert(FuncDefTable*, FuncDef*, int); | | | 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 | void sqlite4HaltConstraint(Parse*, int, char*, int); Expr *sqlite4ExprDup(sqlite4*,Expr*,int); ExprList *sqlite4ExprListDup(sqlite4*,ExprList*,int); SrcList *sqlite4SrcListDup(sqlite4*,SrcList*,int); IdList *sqlite4IdListDup(sqlite4*,IdList*); Select *sqlite4SelectDup(sqlite4*,Select*,int); void sqlite4FuncDefInsert(FuncDefTable*, FuncDef*, int); FuncDef *sqlite4FindFunction(sqlite4*,const char*,int,int,int); void sqlite4RegisterBuiltinFunctions(sqlite4*); void sqlite4RegisterDateTimeFunctions(sqlite4_env*); void sqlite4RegisterGlobalFunctions(sqlite4_env*); int sqlite4SafetyCheckOk(sqlite4*); int sqlite4SafetyCheckSickOrOk(sqlite4*); void sqlite4ChangeCookie(Parse*, int); |
︙ | ︙ | |||
3015 3016 3017 3018 3019 3020 3021 | void sqlite4DefaultRowEst(Index*); void sqlite4RegisterLikeFunctions(sqlite4*, int); int sqlite4IsLikeFunction(sqlite4*,Expr*,int*,char*); void sqlite4SchemaClear(sqlite4_env*,Schema*); Schema *sqlite4SchemaGet(sqlite4*); int sqlite4SchemaToIndex(sqlite4 *db, Schema *); KeyInfo *sqlite4IndexKeyinfo(Parse *, Index *); | | | 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 | void sqlite4DefaultRowEst(Index*); void sqlite4RegisterLikeFunctions(sqlite4*, int); int sqlite4IsLikeFunction(sqlite4*,Expr*,int*,char*); void sqlite4SchemaClear(sqlite4_env*,Schema*); Schema *sqlite4SchemaGet(sqlite4*); int sqlite4SchemaToIndex(sqlite4 *db, Schema *); KeyInfo *sqlite4IndexKeyinfo(Parse *, Index *); int sqlite4CreateFunc(sqlite4 *, const char *, int, void *, void (*)(sqlite4_context*,int,sqlite4_value **), void (*)(sqlite4_context*,int,sqlite4_value **), void (*)(sqlite4_context*), FuncDestructor *pDestructor ); int sqlite4ApiExit(sqlite4 *db, int); int sqlite4OpenTempDatabase(Parse *); |
︙ | ︙ |
Changes to src/tclsqlite.c.
︙ | ︙ | |||
1812 1813 1814 1815 1816 1817 1818 | if( pFunc==0 ) return TCL_ERROR; if( pFunc->pScript ){ Tcl_DecrRefCount(pFunc->pScript); } pFunc->pScript = pScript; Tcl_IncrRefCount(pScript); pFunc->useEvalObjv = safeToUseEvalObjv(interp, pScript); | | | 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 | if( pFunc==0 ) return TCL_ERROR; if( pFunc->pScript ){ Tcl_DecrRefCount(pFunc->pScript); } pFunc->pScript = pScript; Tcl_IncrRefCount(pScript); pFunc->useEvalObjv = safeToUseEvalObjv(interp, pScript); rc = sqlite4_create_function(pDb->db, zName, nArg, pFunc, tclSqlFunc, 0, 0, 0); if( rc!=SQLITE4_OK ){ rc = TCL_ERROR; Tcl_SetResult(interp, (char *)sqlite4_errmsg(pDb->db), TCL_VOLATILE); } break; } |
︙ | ︙ | |||
2712 2713 2714 2715 2716 2717 2718 | char zBuf[33]; p = sqlite4_aggregate_context(context, sizeof(*p)); MD5Final(digest,p); MD5DigestToBase16(digest, zBuf); sqlite4_result_text(context, zBuf, -1, SQLITE4_TRANSIENT, 0); } int Md5_Register(sqlite4 *db){ | | | 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 | char zBuf[33]; p = sqlite4_aggregate_context(context, sizeof(*p)); MD5Final(digest,p); MD5DigestToBase16(digest, zBuf); sqlite4_result_text(context, zBuf, -1, SQLITE4_TRANSIENT, 0); } int Md5_Register(sqlite4 *db){ int rc = sqlite4_create_function(db, "md5sum", -1, 0, 0, md5step, md5finalize, 0); sqlite4_overload_function(db, "md5sum", -1); /* To exercise this API */ return rc; } #endif /* defined(SQLITE4_TEST) */ |
︙ | ︙ |
Changes to test/func3.test.
︙ | ︙ | |||
13 14 15 16 17 18 19 | # with functions created using sqlite4_create_function_v2() is # correctly invoked. # set testdir [file dirname $argv0] source $testdir/tester.tcl | < < < < < < < < < < < < < < < < < < < < < | 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | # with functions created using sqlite4_create_function_v2() is # correctly invoked. # set testdir [file dirname $argv0] source $testdir/tester.tcl do_test func3-2.1 { set destroyed 0 proc destroy {} { set ::destroyed 1 } sqlite4_create_function_v2 db f3 -1 utf8 -func f3 -destroy destroy set destroyed } 0 do_test func3-2.2 { |
︙ | ︙ |
Changes to test/permutations.test.
︙ | ︙ | |||
187 188 189 190 191 192 193 | printf.test quote.test savepoint.test savepoint5.test select1.test select2.test select3.test select4.test select5.test select6.test select7.test select8.test select9.test selectA.test | | | 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 | printf.test quote.test savepoint.test savepoint5.test select1.test select2.test select3.test select4.test select5.test select6.test select7.test select8.test select9.test selectA.test selectB.test selectC.test selectF.test sort.test storage1.test subquery.test subquery2.test substr.test |
︙ | ︙ |
Changes to test/selectF.test.
︙ | ︙ | |||
92 93 94 95 96 97 98 99 100 101 | 4 0 "SELECT (a/2) FROM t1 GROUP BY (a/2)" {0 1 2 3} 5 0 "SELECT a+b FROM t1 GROUP BY (a+b)" {12 15 18 3 6 9} 6 1 "SELECT a+b FROM t1 GROUP BY (a+b) ORDER BY 1" {3 6 9 12 15 18} 7 0 "SELECT a*b FROM t1 WHERE (c%2)" {18 2 50} 8 0 "SELECT count(*) FROM t1, t1 AS t2 WHERE t1.a=t2.a" {6} 9 0 "SELECT * FROM t1 WHERE a=1 AND b=2" {{1 2 3}} 10 0 "SELECT * FROM t1 WHERE a>3 AND b<12" {{4 8 12} {5 10 15}} } finish_test | > > > > > < < < | 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 | 4 0 "SELECT (a/2) FROM t1 GROUP BY (a/2)" {0 1 2 3} 5 0 "SELECT a+b FROM t1 GROUP BY (a+b)" {12 15 18 3 6 9} 6 1 "SELECT a+b FROM t1 GROUP BY (a+b) ORDER BY 1" {3 6 9 12 15 18} 7 0 "SELECT a*b FROM t1 WHERE (c%2)" {18 2 50} 8 0 "SELECT count(*) FROM t1, t1 AS t2 WHERE t1.a=t2.a" {6} 9 0 "SELECT * FROM t1 WHERE a=1 AND b=2" {{1 2 3}} 10 0 "SELECT * FROM t1 WHERE a>3 AND b<12" {{4 8 12} {5 10 15}} 11 1 "SELECT a FROM t1 ORDER BY a" {1 2 3 4 5 6} 12 1 "SELECT a FROM t1 ORDER BY +a" {1 2 3 4 5 6} 13 1 "SELECT a FROM t1 ORDER BY b DESC" {6 5 4 3 2 1} } finish_test |
Changes to test/test_func.c.
︙ | ︙ | |||
448 449 450 451 452 453 454 | { "test_isolation", 2, SQLITE4_UTF8, test_isolation}, { "test_counter", 1, SQLITE4_UTF8, counterFunc}, }; int i; for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ sqlite4_create_function(db, aFuncs[i].zName, aFuncs[i].nArg, | | | 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 | { "test_isolation", 2, SQLITE4_UTF8, test_isolation}, { "test_counter", 1, SQLITE4_UTF8, counterFunc}, }; int i; for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ sqlite4_create_function(db, aFuncs[i].zName, aFuncs[i].nArg, 0, aFuncs[i].xFunc, 0, 0, 0); } return SQLITE4_OK; } /* ** A bogus step function and finalizer function. |
︙ | ︙ | |||
481 482 483 484 485 486 487 | sqlite4 *db; int rc; int mxArg; if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; rc = sqlite4_create_function( | | | | | | | | | | | 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 | sqlite4 *db; int rc; int mxArg; if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; rc = sqlite4_create_function( db, "tx", 1, 0, tStep, tStep, tFinal, 0); if( rc!=SQLITE4_MISUSE ) goto abuse_err; rc = sqlite4_create_function(db, "tx", 1, 0, tStep, tStep, 0,0); if( rc!=SQLITE4_MISUSE ) goto abuse_err; rc = sqlite4_create_function(db, "tx", 1, 0, tStep, 0,tFinal,0); if( rc!=SQLITE4_MISUSE) goto abuse_err; rc = sqlite4_create_function(db, "tx", 1, 0, 0, 0, tFinal, 0); if( rc!=SQLITE4_MISUSE ) goto abuse_err; rc = sqlite4_create_function(db, "tx", 1, 0, 0, tStep, 0, 0); if( rc!=SQLITE4_MISUSE ) goto abuse_err; rc = sqlite4_create_function(db, "tx", -2, 0, tStep, 0, 0, 0); if( rc!=SQLITE4_MISUSE ) goto abuse_err; rc = sqlite4_create_function(db, "tx", 128, 0, tStep, 0, 0, 0); if( rc!=SQLITE4_MISUSE ) goto abuse_err; rc = sqlite4_create_function(db, "funcxx" "_123456789_123456789_123456789_123456789_123456789" "_123456789_123456789_123456789_123456789_123456789" "_123456789_123456789_123456789_123456789_123456789" "_123456789_123456789_123456789_123456789_123456789" "_123456789_123456789_123456789_123456789_123456789", 1, 0, tStep, 0, 0, 0); if( rc!=SQLITE4_MISUSE ) goto abuse_err; /* This last function registration should actually work. Generate ** a no-op function (that always returns NULL) and which has the ** maximum-length function name and the maximum number of parameters. */ sqlite4_limit(db, SQLITE4_LIMIT_FUNCTION_ARG, 10000); mxArg = sqlite4_limit(db, SQLITE4_LIMIT_FUNCTION_ARG, -1); rc = sqlite4_create_function(db, "nullx" "_123456789_123456789_123456789_123456789_123456789" "_123456789_123456789_123456789_123456789_123456789" "_123456789_123456789_123456789_123456789_123456789" "_123456789_123456789_123456789_123456789_123456789" "_123456789_123456789_123456789_123456789_123456789", mxArg, 0, tStep, 0, 0, 0); if( rc!=SQLITE4_OK ) goto abuse_err; return TCL_OK; abuse_err: Tcl_AppendResult(interp, "sqlite4_create_function abused test failed", (char*)0); |
︙ | ︙ |
Changes to test/test_main.c.
︙ | ︙ | |||
849 850 851 852 853 854 855 | if( argc!=2 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB\"", 0); return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; | | < | < | < | | | 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 | if( argc!=2 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB\"", 0); return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; rc = sqlite4_create_function(db, "x_coalesce", -1, 0, t1_ifnullFunc, 0, 0, 0); if( rc==SQLITE4_OK ){ rc = sqlite4_create_function(db, "hex8", 1, 0, hex8Func, 0, 0, 0); } #ifndef SQLITE4_OMIT_UTF16 if( rc==SQLITE4_OK ){ rc = sqlite4_create_function(db, "hex16", 1, 0, hex16Func, 0, 0, 0); } #endif if( rc==SQLITE4_OK ){ rc = sqlite4_create_function(db, "tkt2213func", 1, 0, tkt2213Function, 0, 0, 0); } if( rc==SQLITE4_OK ){ rc = sqlite4_create_function( db, "x_sqlite_exec", 1, db, sqlite4ExecFunc, 0, 0, 0 ); } if( sqlite4TestErrCode(interp, db, rc) ) return TCL_ERROR; Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0); return TCL_OK; } |
︙ | ︙ | |||
959 960 961 962 963 964 965 | int rc; if( argc!=2 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " FILENAME\"", 0); return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; | | | | 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 | int rc; if( argc!=2 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " FILENAME\"", 0); return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; rc = sqlite4_create_function(db, "x_count", 0, 0, 0, t1CountStep, t1CountFinalize, 0); if( rc==SQLITE4_OK ){ rc = sqlite4_create_function(db, "x_count", 1, 0, 0, t1CountStep, t1CountFinalize, 0); } if( sqlite4TestErrCode(interp, db, rc) ) return TCL_ERROR; Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0); return TCL_OK; } |
︙ | ︙ | |||
1535 1536 1537 1538 1539 1540 1541 | if( p->pDestroy ) p->pDestroy = Tcl_DuplicateObj(p->pDestroy); if( p->pFunc ) Tcl_IncrRefCount(p->pFunc); if( p->pStep ) Tcl_IncrRefCount(p->pStep); if( p->pFinal ) Tcl_IncrRefCount(p->pFinal); if( p->pDestroy ) Tcl_IncrRefCount(p->pDestroy); | | | 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 | if( p->pDestroy ) p->pDestroy = Tcl_DuplicateObj(p->pDestroy); if( p->pFunc ) Tcl_IncrRefCount(p->pFunc); if( p->pStep ) Tcl_IncrRefCount(p->pStep); if( p->pFinal ) Tcl_IncrRefCount(p->pFinal); if( p->pDestroy ) Tcl_IncrRefCount(p->pDestroy); rc = sqlite4_create_function(db, zFunc, nArg, (void *)p, (p->pFunc ? cf2Func : 0), (p->pStep ? cf2Step : 0), (p->pFinal ? cf2Final : 0), cf2Destroy ); if( rc!=SQLITE4_OK ){ Tcl_ResetResult(interp); |
︙ | ︙ | |||
1630 1631 1632 1633 1634 1635 1636 | int rc; if( argc!=3 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB FUNCTION-NAME", 0); return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; | | < | 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 | int rc; if( argc!=3 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB FUNCTION-NAME", 0); return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; rc = sqlite4_create_function(db, argv[2], -1, 0, testFunc, 0, 0, 0); if( rc!=0 ){ Tcl_AppendResult(interp, sqlite4ErrStr(rc), 0); return TCL_ERROR; } if( sqlite4TestErrCode(interp, db, rc) ) return TCL_ERROR; return TCL_OK; } |
︙ | ︙ | |||
2290 2291 2292 2293 2294 2295 2296 | int val; if( objc!=5 ) goto bad_args; if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR; if( val ){ | | | | | 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 | int val; if( objc!=5 ) goto bad_args; if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR; if( val ){ sqlite4_create_function(db, "test_function", 1, interp, test_function_utf8, 0, 0, 0); } if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[3], &val) ) return TCL_ERROR; if( val ){ sqlite4_create_function(db, "test_function", 1, interp, test_function_utf16le, 0, 0, 0); } if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[4], &val) ) return TCL_ERROR; if( val ){ sqlite4_create_function(db, "test_function", 1, interp, test_function_utf16be, 0, 0, 0); } return TCL_OK; bad_args: Tcl_AppendResult(interp, "wrong # args: should be \"", Tcl_GetStringFromObj(objv[0], 0), " <DB> <utf8> <utf16le> <utf16be>", 0); |
︙ | ︙ | |||
3454 3455 3456 3457 3458 3459 3460 | sqlite4 *db; if( argc!=3 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB function-name", 0); return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; | | | 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 | sqlite4 *db; if( argc!=3 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " DB function-name", 0); return TCL_ERROR; } if( getDbPointer(interp, argv[1], &db) ) return TCL_ERROR; rc = sqlite4_create_function(db, argv[2], -1, 0, 0, 0, 0, 0); Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC); return TCL_OK; } /* ** Usage: sqlite_delete_collation DB collation-name ** |
︙ | ︙ |