DBD-SQLite
view release on metacpan or search on metacpan
The callback will be called as$code_ref->($statement)where$statementis a UTF-8 rendering of the SQL statement text as thestatement first begins executing.Additional callbacks might occur aseachtriggered subprogram isentered. The callbacksfortriggers contain a UTF-8 SQL commentthat identifies the trigger.See also"TRACING"in DBIforbetter tracing options.$dbh->sqlite_profile($code_ref)This method registers a profile callback to be invoked whenever aSQL statement finishes.The callback will be called as
DBD::SQLite::strlike($pattern,$string,$escape_char), DBD::SQLite::strglob($pattern,$string)seeifa string matches a pattern. These may be usefulwhenyoucreate a virtual table or a custom function. SeeDRIVER CONSTANTSA subset of SQLite C constants are made available to Perl, becausethey may be neededwhenwriting hooks or authorizer callbacks. Foraccessing such constants, the"DBD::SQLite"module must beexplicitly"use"d at compiletime. For example, an authorizer thatforbids any DELETE operation would be written as follows :$dbh->sqlite_set_authorizer(sub{my$action_code=shift;return$action_code== DBD::SQLite::DELETE ? DBD::SQLite::DENY: DBD::SQLite::OK;});
AND maxLat >= ? AND minLat <= ?my$contained=$dbh->selectcol_arrayref($contained_sql,undef,$minLong,$maxLong,$minLat,$maxLat);my$overlapping=$dbh->selectcol_arrayref($overlap_sql,undef,$minLong,$maxLong,$minLat,$maxLat);For more detail, please see the SQLite R-Tree page(<http://www.sqlite.org/rtree.html>). Note that custom R-Treequeries using callbacks, as mentioned in the priorlink, have notbeen implemented yet.VIRTUAL TABLES IMPLEMENTED IN PERLSQLitehasa concept of"virtual tables"which look like regulartables but are implemented internally through specific functions.The fulltext or R* tree features described in the previouschapters are examples of such virtual tables, implemented in Ccode."DBD::SQLite"also supports virtual tables implemented in*Perl
Leak DetectionImplement one or more leak detection tests that only run duringAUTOMATED_TESTING and RELEASE_TESTING and validate that none ofthe C code we workwithleaks.Stream APIforBlobsReading/writing into blobs using"sqlite2_blob_open"/"sqlite2_blob_close".Supportforcustom callbacksforR-Tree queriesCustom queries of a R-Treeindexusing a callback are possiblebased on a specific need, such as queryingforoverlappingcircles.SUPPORTBugs should be reported via the CPAN bug tracker at
lib/DBD/SQLite.pm view on Meta::CPAN
$dbh->{sqlite_string_mode} = DBD_SQLITE_STRING_MODE_UNICODE_FALLBACK;my$sth=$dbh->prepare("INSERT INTO mytable (blobcolumn) VALUES (?)");# Binary_data will be stored as is.$sth->bind_param(1,$binary_data, SQL_BLOB);Defining the column type as C<BLOB> in the DDL is B<not> sufficient.=item * DBD_SQLITE_STRING_MODE_UNICODE_STRICT: LikeDBD_SQLITE_STRING_MODE_UNICODE_FALLBACK but usually throws an exceptionrather than a warning if SQLite sends invalid UTF-8. (In Perl callbacksfrom SQLite we still warn instead.)=item * DBD_SQLITE_STRING_MODE_UNICODE_NAIVE: LikeDBD_SQLITE_STRING_MODE_UNICODE_FALLBACK but uses a "naïve" UTF-8 decodingmethod that forgoes validation. This is marginally faster than a validateddecode, but it can also B<corrupt> B<Perl> B<itself!>=item * DBD_SQLITE_STRING_MODE_PV (default, but B<DO> B<NOT> B<USE>): LikeDBD_SQLITE_STRING_MODE_BYTES, but when translating Perl strings to SQLitethe Perl string's internal byte buffer is given to SQLite. B<This> B<is>
lib/DBD/SQLite.pm view on Meta::CPAN
=over=item $statementis a UTF-8 rendering of the SQL statement text as the statementfirst begins executing.=backAdditional callbacks might occur as each triggered subprogram isentered. The callbacks for triggers contain a UTF-8 SQL commentthat identifies the trigger.See also L<DBI/TRACING> for better tracing options.=head2 $dbh->sqlite_profile( $code_ref )This method registers a profile callback to be invoked whenevera SQL statement finishes.The callback will be called as
lib/DBD/SQLite.pm view on Meta::CPAN
seeifa string matches a pattern. These may be usefulwhenyoucreate a virtual table or a custom function.See L<http://sqlite.org/c3ref/strlike.html> and=head1 DRIVER CONSTANTSA subset of SQLite C constants are made available to Perl,because they may be needed when writinghooks or authorizer callbacks. For accessing such constants,the C<DBD::SQLite> module must be explicitly C<use>d at compiletime. For example, an authorizer that forbids anyDELETE operation would be written as follows :use DBD::SQLite;$dbh->sqlite_set_authorizer(sub {my $action_code = shift;return $action_code == DBD::SQLite::DELETE ? DBD::SQLite::DENY: DBD::SQLite::OK;});
lib/DBD/SQLite.pm view on Meta::CPAN
AND maxLat >= ? AND minLat <= ?my$contained=$dbh->selectcol_arrayref($contained_sql,undef,$minLong,$maxLong,$minLat,$maxLat);my$overlapping=$dbh->selectcol_arrayref($overlap_sql,undef,$minLong,$maxLong,$minLat,$maxLat);For more detail, please see the SQLite R-Tree page(L<https://www.sqlite.org/rtree.html>). Note that custom R-Treequeries using callbacks, as mentioned in the priorlink, have not beenimplemented yet.=head1 VIRTUAL TABLES IMPLEMENTED IN PERLSQLite has a concept of "virtual tables" which look like regulartables but are implemented internally through specific functions.The fulltext or R* tree features described in the previous chaptersare examples of such virtual tables, implemented in C code.C<DBD::SQLite> also supports virtual tables implemented in I<Perl code>:
lib/DBD/SQLite.pm view on Meta::CPAN
=head2 Leak DetectionImplement one or more leak detection tests that only run duringAUTOMATED_TESTING and RELEASE_TESTING and validate that none of the Ccode we work with leaks.=head2 Stream API for BlobsReading/writing into blobs using C<sqlite2_blob_open> / C<sqlite2_blob_close>.=head2 Support for custom callbacks for R-Tree queriesCustom queries of a R-Tree index using a callback are possible withthe SQLite C API (L<https://www.sqlite.org/rtree.html>), so one couldpotentially use a callback that narrowed the result set down basedon a specific need, such as querying for overlapping circles.=head1 SUPPORTBugs should be reported to GitHub issues:
lib/DBD/SQLite/VirtualTable.pm view on Meta::CPAN
the B<cursor> class implements methodsforperforming a specificSQL statement=back=head2 MethodsMost methods in both classes are not called directly from Perlcode : instead, they are callbacks, called from the sqlite kernel.Following common Perl conventions, such methods have names inuppercase.=head1 TABLE METHODS=head2 Class methods for registering the module=head3 CREATE_MODULE
** These routines are deprecated. Use the [sqlite3_trace_v2()] interface** instead of the routines described here.**** These routines register callback functions that can be usedfor** tracing and profiling the execution of SQL statements.**** ^The callback function registered by sqlite3_trace() is invoked at** varioustimeswhenan SQL statement is being run by [sqlite3_step()].** ^The sqlite3_trace() callback is invokedwitha UTF-8 rendering of the** SQL statement text as the statement first begins executing.** ^(Additional sqlite3_trace() callbacks might occur** aseachtriggered subprogram is entered. The callbacksfortriggers** contain a UTF-8 SQL comment that identifies the trigger.)^**** The [SQLITE_TRACE_SIZE_LIMIT] compile-timeoption can be used to limit** thelengthof [bound parameter] expansion in the output of sqlite3_trace().**** ^The callback function registered by sqlite3_profile() is invoked** aseachSQL statement finishes. ^The profile callback contains** the original statement text and an estimate of wall-clocktime** of how long that statement took to run. ^The profile callback**timeis in units of nanoseconds, however the current implementation
** function can gain access to this pointer using [sqlite3_user_data()].)^**** ^The sixth, seventh and eighth parameters passed to the three**"sqlite3_create_function*"functions, xFunc, xStep and xFinal, are** pointers to C-language functions that implement the SQL function or** aggregate. ^AscalarSQL 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 passedforxFunc. ^Todeletean existing** SQL function or aggregate, pass NULL pointersforall three function** callbacks.**** ^The sixth, seventh, eighth and ninth parameters (xStep, xFinal, xValue** and xInverse) passed to sqlite3_create_window_function are pointers to** C-language callbacks that implement the new function. xStep and xFinal** must both be non-NULL. xValue and xInverse may either both be NULL, in** which case a regular aggregate function is created, or must both be** non-NULL, in which case the new function may be used as either an aggregate** or aggregate window function. More details regarding the implementation** of aggregate window functions are** [user-definedwindow functions|available here].**** ^(If the final parameter to sqlite3_create_function_v2() or** sqlite3_create_window_function() is not NULL, then it is destructorfor** the application data pointer. The destructor is invokedwhenthe function
** C++ compilers.*/typedef void (*sqlite3_destructor_type)(void*);#define SQLITE_STATIC ((sqlite3_destructor_type)0)#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1)/*** CAPI3REF: Setting The Result Of An SQL Function** METHOD: sqlite3_context**** These routines are used by the xFunc or xFinal callbacks that** implement SQL functions and aggregates. See** [sqlite3_create_function()] and [sqlite3_create_function16()]**foradditional information.**** These functions work very much like the [parameter binding] family of** functions used tobindvaluesto host parameters in prepared statements.** Refer to the [SQL parameter] documentationforadditional information.**** ^The sqlite3_result_blob() interface sets the result from** an application-definedfunction to be the BLOB whose content is pointed
**forthe same database connection is overridden.** ^The pArg argument is passed through to the callback.** ^If the callback on a commit hook function returns non-zero,** then the commit is converted into a rollback.**** ^The sqlite3_commit_hook(D,C,P) and sqlite3_rollback_hook(D,C,P) functions**returnthe P argument from the previous call of the same function** on the same [database connection] D, or NULLfor** the first callforeachfunction on D.**** The commit and rollback hook callbacks are not reentrant.** The callback implementation must notdoanything that will modify** the database connection that invoked the callback. Any actions** to modify the database connection must be deferreduntilafterthe** completion of the [sqlite3_step()] call that triggered the commit** or rollback hook in the first place.** Note that running any other SQL statements, including SELECT statements,** or merely calling [sqlite3_prepare_v2()] and [sqlite3_step()] will modify** the database connectionsforthe meaning of"modify"in this paragraph.**** ^Registering a NULL function disables the callback.
**** ^The [sqlite3_preupdate_hook()] interface registers a callback function** that is invoked prior toeach[INSERT], [UPDATE], and [DELETE] operation** on a database table.** ^At most one preupdate hook may be registered at atimeon a single** [database connection];eachcall to [sqlite3_preupdate_hook()] overrides** the previous setting.** ^The preupdate hook is disabled by invoking [sqlite3_preupdate_hook()]**witha NULL pointer as the second parameter.** ^The third parameter to [sqlite3_preupdate_hook()] is passed through as** the first parameter to callbacks.**** ^The preupdate hook only firesforchanges to real database tables; the** preupdate hook is not invokedforchanges to [virtual tables] or to**systemtables like sqlite_sequence or sqlite_stat1.**** ^The second parameter to the preupdate callback is a pointer to** the [database connection] that registered the preupdate hook.** ^The third parameter to the preupdate callback is one of the constants** [SQLITE_INSERT], [SQLITE_DELETE], or [SQLITE_UPDATE] to identify the** kind of update operation that is about to occur.
** behavior.**** ^The [sqlite3_preupdate_count(D)] interface returns the number of columns** in the row that is being inserted, updated, or deleted.**** ^The [sqlite3_preupdate_old(D,N,P)] interface writes into P a pointer to** a [protected sqlite3_value] that contains the value of the Nth column of** the table rowbeforeit is updated. The N parameter must be between 0** and one less than the number of columns or the behavior will be** undefined. This must only be used within SQLITE_UPDATE and SQLITE_DELETE** preupdate callbacks;ifit is used by an SQLITE_INSERT callback then the** behavior is undefined. The [sqlite3_value] that P points to** will be destroyedwhenthe preupdate callback returns.**** ^The [sqlite3_preupdate_new(D,N,P)] interface writes into P a pointer to** a [protected sqlite3_value] that contains the value of the Nth column of** the table rowafterit is updated. The N parameter must be between 0** and one less than the number of columns or the behavior will be** undefined. This must only be used within SQLITE_INSERT and SQLITE_UPDATE** preupdate callbacks;ifit is used by an SQLITE_DELETE callback then the** behavior is undefined. The [sqlite3_value] that P points to** will be destroyedwhenthe preupdate callback returns.**** ^The [sqlite3_preupdate_depth(D)] interface returns 0ifthe preupdate** callback was invoked as a result of a direct insert, update, ordelete** operation; or 1forinserts, updates, or deletes invoked by top-level** triggers; or 2forchanges resulting from triggers called by top-level** triggers; and so forth.**** When the [sqlite3_blob_write()] API is used to update a blob column,
SQLITE_APIintsqlite3_rtree_geometry_callback(sqlite3*db,const char*zGeom,int(*xGeom)(sqlite3_rtree_geometry*,int, sqlite3_rtree_dbl*,int*),void*pContext);/*** A pointer to a structure of the following type is passed as the first** argument to callbacks registered using rtree_geometry_callback().*/struct sqlite3_rtree_geometry {void*pContext; /* Copy of pContext passed to s_r_g_c() */intnParam; /* Size of array aParam[] */sqlite3_rtree_dbl*aParam; /* Parameters passed to SQL geom function */void*pUser; /* Callback implementation user data */void (*xDelUser)(void *); /* Called by SQLite to clean up pUser */};/*
**** VFUNCTION(zName, nArg, iArg, bNC, xFunc)** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag.**** SFUNCTION(zName, nArg, iArg, bNC, xFunc)** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and** adds the SQLITE_DIRECTONLY flag.**** INLINE_FUNC(zName, nArg, iFuncId, mFlags)** zName is the name of a function that is implemented by in-line** byte code rather than by the usual callbacks. The iFuncId** parameter determines the function id. The mFlags parameter is** optional SQLITE_FUNC_ flagsforthis function.**** TEST_FUNC(zName, nArg, iFuncId, mFlags)** zName is the name of a test-only function implemented by in-line** byte code rather than by the usual callbacks. The iFuncId** parameter determines the function id. The mFlags parameter is** optional SQLITE_FUNC_ flagsforthis function.**** DFUNCTION(zName, nArg, iArg, bNC, xFunc)** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and** adds the SQLITE_FUNC_SLOCHNG flag. Usedfordate &timefunctions** and functions like sqlite_version() that can change, but not during** a single query. The iArg is ignored. The user-data is always set** to a NULL pointer. The bNC parameter is not used.**
intaddrExplain; /* Address of current OP_Explain opcode */#endifVList*pVList; /* Mapping between variable names and numbers */Vdbe*pReprepare; /* VM being reprepared (sqlite3Reprepare()) */const char*zTail; /* All SQL text past thelastsemicolon parsed */Table*pNewTable; /* A table being constructed by CREATE TABLE */Index*pNewIndex; /* Anindexbeing constructed by CREATE INDEX.** Also used to hold redundant UNIQUE constraints** during a RENAME COLUMN */Trigger*pNewTrigger; /* Trigger under construct by a CREATE TRIGGER */const char*zAuthContext; /* The 6th parameter to db->xAuth callbacks */#ifndef SQLITE_OMIT_VIRTUALTABLEToken sArg; /* Complete text of a module argument */Table **apVtabLock; /* Pointer to virtual tables needing locking */#endifWith*pWith; /* Current WITH clause, or NULL */#ifndef SQLITE_OMIT_ALTERTABLERenameToken*pRename; /* Tokens subject to renaming by ALTER TABLE */#endif};
#endif#ifndef SQLITE_OMIT_CTESQLITE_PRIVATE void sqlite3SelectPopWith(Walker*, Select*);#else# define sqlite3SelectPopWith 0#endif/*** Return code from the parse-tree walking primitives and their** callbacks.*/#define WRC_Continue 0 /* Continue down into children */#define WRC_Prune 1 /* Omit children but continue walking siblings */#define WRC_Abort 2 /* Abandon the tree walk *//*** A single common table expression*/struct Cte {char*zName; /* Name of this CTE */
i64 iCurrent;intrc = sqlite3OsFileSize(pFile,&iCurrent);if( rc==SQLITE_OK && iCurrent>iSize ){rc = sqlite3OsTruncate(pFile, iSize);}returnrc;}/*** Register this backup objectwiththe associated source pagerfor** callbackswhenpages are changed or the cache invalidated.*/static void attachBackupObject(sqlite3_backup*p){sqlite3_backup **pp;assert( sqlite3BtreeHoldsMutex(p->pSrc) );pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc));p->pNext =*pp;*pp= p;p->isAttached = 1;}
assert( db->nVdbeRead>=db->nVdbeWrite );assert( db->nVdbeWrite>=0 );p->eVdbeState = VDBE_HALT_STATE;checkActiveVdbeCnt(db);if( db->mallocFailed ){p->rc = SQLITE_NOMEM_BKPT;}/* If the auto-commit flag is set to true, then any locks that were held** by connection db have now been released. Call sqlite3ConnectionUnlocked()** to invoke any required unlock-notify callbacks.*/if( db->autoCommit ){sqlite3ConnectionUnlocked(db);}assert( db->nVdbeActive>0 || db->autoCommit==0 || db->nStatement==0 );return(p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK);}
if( pCtx->pOut->flags & MEM_Int ){pCtx->pOut->flags &= ~MEM_Int;pCtx->pOut->flags |= MEM_IntReal;}}#endif/*** This function is calledaftera transactionhasbeen committed. It** invokes callbacks registeredwithsqlite3_wal_hook() as required.*/staticintdoWalCallbacks(sqlite3*db){intrc = SQLITE_OK;#ifndef SQLITE_OMIT_WALinti;for(i=0; i<db->nDb; i++){Btree*pBt= db->aDb[i].pBt;if( pBt ){intnEntry;sqlite3BtreeEnter(pBt);
/* A new savepoint cannot be createdifthere are activewrite** statements (i.e.openread/writeincremental blob handles).*/sqlite3VdbeError(p,"cannot open savepoint - SQL statements in progress");rc = SQLITE_BUSY;}else{nName = sqlite3Strlen30(zName);#ifndef SQLITE_OMIT_VIRTUALTABLE/* This call is Ok evenifthis savepoint is actually a transaction** savepoint (and therefore should not prompt xSavepoint()) callbacks.** If this is a transaction savepoint being opened, it is guaranteed** that the db->aVTrans[] array is empty. */assert( db->autoCommit==0 || db->nVTrans==0 );rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN,db->nStatement+db->nSavepoint);if( rc!=SQLITE_OK )gotoabort_due_to_error;#endif/* Create a new savepoint structure. */pNew = sqlite3DbMallocRawNN(db, sizeof(Savepoint)+nName+1);
pOut->u.i = pgno;break;}/* Opcode: SqlExec P1 P2 * P4 ***** Run the SQL statement or statements specified in the P4 string.**** The P1 parameter is a bitmask of options:**** 0x0001 Disable Auth and Trace callbackswhilethe statements** in P4 are running.**** 0x0002 Set db->nAnalysisLimit to P2whilethe statements in** P4 are running.***/case OP_SqlExec: {char*zErr;#ifndef SQLITE_OMIT_AUTHORIZATIONsqlite3_xauth xAuth;
** is invokedbeforevisiting children.)**** Thereturnvalue from the callback should be one of the WRC_*** constants to specify how to proceedwiththe walk.**** WRC_Continue Continue descending down the tree.**** WRC_Prune Do not descend into child nodes, but allow** the walk tocontinuewithsibling nodes.**** WRC_Abort Donomore callbacks. Unwind the stack and**returnfrom the top-level walk call.**** Thereturnvalue from this routine is WRC_Abort to abandon the tree walk** and WRC_Continue tocontinue.*/SQLITE_PRIVATE SQLITE_NOINLINEintsqlite3WalkExprNN(Walker*pWalker, Expr*pExpr){intrc;testcase( ExprHasProperty(pExpr, EP_TokenOnly) );testcase( ExprHasProperty(pExpr, EP_Reduced) );while(1){
*/SQLITE_PRIVATE void sqlite3WalkWinDefnDummyCallback(Walker*pWalker, Select*p){UNUSED_PARAMETER(pWalker);UNUSED_PARAMETER(p);/* No-op */}/*** Walk all expressions associatedwithSELECT statement p. Do** not invoke the SELECT callback on p, butdo(of course) invoke** any expr callbacks and SELECT callbacks that come from subqueries.** Return WRC_Abort or WRC_Continue.*/SQLITE_PRIVATEintsqlite3WalkSelectExpr(Walker*pWalker, Select*p){if( sqlite3WalkExprList(pWalker, p->pEList) )returnWRC_Abort;if( sqlite3WalkExpr(pWalker, p->pWhere) )returnWRC_Abort;if( sqlite3WalkExprList(pWalker, p->pGroupBy) )returnWRC_Abort;if( sqlite3WalkExpr(pWalker, p->pHaving) )returnWRC_Abort;if( sqlite3WalkExprList(pWalker, p->pOrderBy) )returnWRC_Abort;if( sqlite3WalkExpr(pWalker, p->pLimit) )returnWRC_Abort;#if !defined(SQLITE_OMIT_WINDOWFUNC)
|| ExprHasProperty(pExpr, EP_WinFunc)){pWalker->eCode = 0;returnWRC_Abort;}returnWRC_Prune;}/*** These routines are Walker callbacks used to check expressions to** seeifthey are"constant"forsome definition of constant. The** Walker.eCode value determines the type of"constant"we are looking**for.**** These callback routines are used to implement the following:**** sqlite3ExprIsConstant() pWalker->eCode==1** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2** sqlite3ExprIsTableConstant() pWalker->eCode==3** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5**** In all cases, the callbacks set Walker.eCode=0 and abortifthe expression** is found to not be a constant.**** The sqlite3ExprIsConstantOrFunction() is usedforevaluating DEFAULT** expressions in a CREATE TABLE statement. The Walker.eCode value is 5**whenparsing an existing schema out of the sqlite_schema table and 4**whenprocessing a new CREATE TABLE statement. A bound parameter raises** an errorfornew statements, but is silently converted** to NULLforexisting schemas. This allows sqlite_schema tables that** contain a bound parameter because they were generated by older versions** of SQLite to be parsed by newer versions of SQLite without raising a
** so that a subsequent copy will not be merged into this one.*/static void setDoNotMergeFlagOnCopy(Vdbe*v){if( sqlite3VdbeGetLastOp(v)->opcode==OP_Copy ){sqlite3VdbeChangeP5(v, 1); /* Tag trailing OP_Copy as not mergeable */}}/*** Generate code to implement special SQL functions that are implemented** in-line rather than by using the usual callbacks.*/staticintexprCodeInlineFunction(Parse*pParse, /* Parsing context */ExprList*pFarg, /* List of function arguments */intiFuncId, /* Function ID. One of the INTFUNC_...values*/inttarget /* Store function result in this register */){intnFarg;Vdbe*v= pParse->pVdbe;assert( v!=0 );
** implement sqlite3ReferencesSrcList().*/struct RefSrcList {sqlite3*db; /* Database connection usedforsqlite3DbRealloc() */SrcList*pRef; /* Lookingforreferences to these tables */i64 nExclude; /* Number of tables to exclude from the search */int*aiExclude; /* Cursor IDsfortables to exclude from the search */};/*** Walker SELECT callbacksforsqlite3ReferencesSrcList().**** When entering a new subquery on the pExpr argument, add all FROM clause** entriesforthat subquery to the exclude list.**** When leaving the subquery, remove those entries from the exclude list.*/staticintselectRefEnter(Walker*pWalker, Select*pSelect){struct RefSrcList*p= pWalker->u.pRefSrcList;SrcList*pSrc= pSelect->pSrc;i64 i, j;
pParse->rc = SQLITE_AUTH;}elseif( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){rc = SQLITE_DENY;sqliteAuthBadReturnCode(pParse);}returnrc;}/*** Push an authorization context. After this routine is called, the** zArg3 argument to authorization callbacks will be zContextuntil** popped. OrifpParse==0, this routine is ano-op.*/SQLITE_PRIVATE void sqlite3AuthContextPush(Parse*pParse,AuthContext*pContext,const char*zContext){assert( pParse );pContext->pParse = pParse;pContext->zAuthContext = pParse->zAuthContext;
#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER){/* zName: */"defer_foreign_keys",/* ePragTyp: */ PragTyp_FLAG,/* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1,/* ColNames: */ 0, 0,/* iArg: */ SQLITE_DeferFKs },#endif#endif#if !defined(SQLITE_OMIT_FLAG_PRAGMAS){/* zName: */"empty_result_callbacks",/* ePragTyp: */ PragTyp_FLAG,/* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1,/* ColNames: */ 0, 0,/* iArg: */ SQLITE_NullCallback },#endif#if !defined(SQLITE_OMIT_UTF16){/* zName: */"encoding",/* ePragTyp: */ PragTyp_ENCODING,/* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1,/* ColNames: */ 0, 0,
** Examples of where these kinds of null SQLITE_READ authorizations** would occur:**** SELECT count(*) FROM t1; -- SQLITE_READ t1.""** SELECT t1.* FROM t1, t2; -- SQLITE_READ t2.""**** The fake column name is an empty string. It is possiblefora table to** have a column named by the empty string, in which case there isnoway to** distinguish between an unreferenced table and an actual reference to the**""column. The original design wasforthe fake column name to be a NULL,** which would be unambiguous. But legacy authorization callbacks might** stringforthe fake column name seems safer.*/if( pItem->colUsed==0 && pItem->zName!=0 ){sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName,"", pItem->zDatabase);}#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)/* Generate codeforallsub-queries in the FROM clause*/
returnrc;}/*** This function invokes either the xRollback or xCommit method** ofeachof the virtual tables in the sqlite3.aVTrans array. The method** called is identified by the second argument,"offset", which is** the offset of the method to call in the sqlite3_module structure.**** The array is clearedafterinvoking the callbacks.*/static void callFinaliser(sqlite3*db,intoffset){inti;if( db->aVTrans ){VTable **aVTrans= db->aVTrans;db->aVTrans = 0;for(i=0; i<db->nVTrans; i++){VTable*pVTab= aVTrans[i];sqlite3_vtab*p= pVTab->pVtab;if( p ){
** that it processes in a temporary table. If it is not zero, this** variable indicateswhenrows may be removed from the temp table (in** order to reduce memory requirements - it would always be safe just** to leave them there). PossiblevaluesforeDelete are:**** WINDOW_RETURN_ROW:** An input row can be discardedafterit is returned to thecaller.**** WINDOW_AGGINVERSE:** An input row can be discardedafterthe window functions xInverse()** callbacks have been invoked in it.**** WINDOW_AGGSTEP:** An input row can be discardedafterthe window functions xStep()** callbacks have been invoked in it.**** start,current,end** Consider a window-frame similar to the following:**** (ORDER BY a, b GROUPS BETWEEN 2 PRECEDING AND 2 FOLLOWING)**** The windows functions implementation caches the input rows in a temp** table, sorted by"a, b"(it actually populates the cache lazily, and** aggressively removes rows once they arenolonger required, but that's** a mere detail). It keeps three cursorsopenon the temp table. One
sqlite3SchemaClear(db->aDb[1].pSchema);}sqlite3VtabUnlockList(db);/* Free up the array of auxiliary databases */sqlite3CollapseDatabaseArray(db);assert( db->nDb<=2 );assert( db->aDb==db->aDbStatic );/* Tell the code in notify.c that the connectionnolonger holds any*/sqlite3ConnectionClosed(db);for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){FuncDef*pNext,*p;p = sqliteHashData(i);do{functionDestroy(db, p);pNext = p->pNext;sqlite3DbFree(db, p);
**** If there isnoblocking connection, the callback is invoked immediately,**beforethis routine returns.**** If pOther is already blocked on db, then report SQLITE_LOCKED, to indicate** a deadlock.**** Otherwise, make arrangements to invoke xNotifywhenpOther drops** its locks.**** Each call to this routine overrides any prior callbacks registered** on the same"db". If xNotify==0 then any prior callbacks are immediately** cancelled.*/SQLITE_APIintsqlite3_unlock_notify(sqlite3*db,void (*xNotify)(void **,int),void*pArg){intrc = SQLITE_OK;#ifdef SQLITE_ENABLE_API_ARMOR
aDyn = aArg = pNew;}else{/* This occurswhenthe array of context pointers that need to** be passed to the unlock-notify callback is larger than the** aStatic[] array allocated on the stack and the attempt to** allocate a larger array from the heaphasfailed.**** This is a difficult situation to handle. Returning an error** code to thecalleris insufficient, as evenifan error code** is returned the transaction on connection db will still be** closed and the unlock-notify callbacks on blocked connections** will go unissued. This might cause the application towait** indefinitelyforan unlock-notify callback that will never** arrive.**** Instead, invoke the unlock-notify callbackwiththe context** array already accumulated. We can then clear the array and** begin accumulating any further context pointers without** requiring any dynamic allocation. This issub-optimal because** it means that instead of one callbackwitha large array of** context pointers the application will receive two or more** callbackswithsmaller arrays of context pointers, which will** reduce the applications ability to prioritize multiple** connections. But it is the best that can be done under the** circumstances.*/xUnlockNotify(aArg, nArg);nArg = 0;}}sqlite3EndBenignMalloc();
/* If all the seg-readers are at EOF, we're finished.returnSQLITE_OK. */assert( rc==SQLITE_OK );if( apSegment[0]->aNode==0 ) break;pCsr->nTerm = apSegment[0]->nTerm;pCsr->zTerm = apSegment[0]->zTerm;/* If this is a prefix-search, andifthe term that apSegment[0] points** to does not share a suffixwithpFilter->zTerm/nTerm, then all** required callbacks have been made. In this caseexitearly.**** Similarly,ifthis is a searchforan exact match, and the first term** of segment apSegment[0] is not a match,exitearly.*/if( pFilter->zTerm && !isScan ){if( pCsr->nTerm<pFilter->nTerm|| (!isPrefix && pCsr->nTerm>pFilter->nTerm)|| memcmp(pCsr->zTerm, pFilter->zTerm, pFilter->nTerm)){break;
** arguments passed to it are, in order:**** void*pCtx// Copy of 4th argument to sqlite3Fts5Tokenize()** const char*pToken// Pointer to buffer containing token**intnToken // Size of token in bytes**intiStart // Byte offset of start of token within input text**intiEnd // Byte offset of end of token within input text**intiPos // Position of token in input (first token is 0)**** If the callback returns a non-zero value the tokenization is abandoned** andnofurther callbacks are issued.**** This function returns SQLITE_OKifsuccessful or an SQLite error code**ifan error occurs. If the tokenization was abandoned early because** the callback returned SQLITE_DONE, this is not an error and this function** still returns SQLITE_OK. Or,ifthe tokenization was abandoned early** because the callback returned another non-zero value, it is assumed** to be an SQLite error code and returned to thecaller.*/staticintsqlite3Fts5Tokenize(Fts5Config*pConfig, /* FTS5 Configuration object */
** These routines are deprecated. Use the [sqlite3_trace_v2()] interface** instead of the routines described here.**** These routines register callback functions that can be usedfor** tracing and profiling the execution of SQL statements.**** ^The callback function registered by sqlite3_trace() is invoked at** varioustimeswhenan SQL statement is being run by [sqlite3_step()].** ^The sqlite3_trace() callback is invokedwitha UTF-8 rendering of the** SQL statement text as the statement first begins executing.** ^(Additional sqlite3_trace() callbacks might occur** aseachtriggered subprogram is entered. The callbacksfortriggers** contain a UTF-8 SQL comment that identifies the trigger.)^**** The [SQLITE_TRACE_SIZE_LIMIT] compile-timeoption can be used to limit** thelengthof [bound parameter] expansion in the output of sqlite3_trace().**** ^The callback function registered by sqlite3_profile() is invoked** aseachSQL statement finishes. ^The profile callback contains** the original statement text and an estimate of wall-clocktime** of how long that statement took to run. ^The profile callback**timeis in units of nanoseconds, however the current implementation
** function can gain access to this pointer using [sqlite3_user_data()].)^**** ^The sixth, seventh and eighth parameters passed to the three**"sqlite3_create_function*"functions, xFunc, xStep and xFinal, are** pointers to C-language functions that implement the SQL function or** aggregate. ^AscalarSQL 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 passedforxFunc. ^Todeletean existing** SQL function or aggregate, pass NULL pointersforall three function** callbacks.**** ^The sixth, seventh, eighth and ninth parameters (xStep, xFinal, xValue** and xInverse) passed to sqlite3_create_window_function are pointers to** C-language callbacks that implement the new function. xStep and xFinal** must both be non-NULL. xValue and xInverse may either both be NULL, in** which case a regular aggregate function is created, or must both be** non-NULL, in which case the new function may be used as either an aggregate** or aggregate window function. More details regarding the implementation** of aggregate window functions are** [user-definedwindow functions|available here].**** ^(If the final parameter to sqlite3_create_function_v2() or** sqlite3_create_window_function() is not NULL, then it is destructorfor** the application data pointer. The destructor is invokedwhenthe function
** C++ compilers.*/typedef void (*sqlite3_destructor_type)(void*);#define SQLITE_STATIC ((sqlite3_destructor_type)0)#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1)/*** CAPI3REF: Setting The Result Of An SQL Function** METHOD: sqlite3_context**** These routines are used by the xFunc or xFinal callbacks that** implement SQL functions and aggregates. See** [sqlite3_create_function()] and [sqlite3_create_function16()]**foradditional information.**** These functions work very much like the [parameter binding] family of** functions used tobindvaluesto host parameters in prepared statements.** Refer to the [SQL parameter] documentationforadditional information.**** ^The sqlite3_result_blob() interface sets the result from** an application-definedfunction to be the BLOB whose content is pointed
**forthe same database connection is overridden.** ^The pArg argument is passed through to the callback.** ^If the callback on a commit hook function returns non-zero,** then the commit is converted into a rollback.**** ^The sqlite3_commit_hook(D,C,P) and sqlite3_rollback_hook(D,C,P) functions**returnthe P argument from the previous call of the same function** on the same [database connection] D, or NULLfor** the first callforeachfunction on D.**** The commit and rollback hook callbacks are not reentrant.** The callback implementation must notdoanything that will modify** the database connection that invoked the callback. Any actions** to modify the database connection must be deferreduntilafterthe** completion of the [sqlite3_step()] call that triggered the commit** or rollback hook in the first place.** Note that running any other SQL statements, including SELECT statements,** or merely calling [sqlite3_prepare_v2()] and [sqlite3_step()] will modify** the database connectionsforthe meaning of"modify"in this paragraph.**** ^Registering a NULL function disables the callback.
**** ^The [sqlite3_preupdate_hook()] interface registers a callback function** that is invoked prior toeach[INSERT], [UPDATE], and [DELETE] operation** on a database table.** ^At most one preupdate hook may be registered at atimeon a single** [database connection];eachcall to [sqlite3_preupdate_hook()] overrides** the previous setting.** ^The preupdate hook is disabled by invoking [sqlite3_preupdate_hook()]**witha NULL pointer as the second parameter.** ^The third parameter to [sqlite3_preupdate_hook()] is passed through as** the first parameter to callbacks.**** ^The preupdate hook only firesforchanges to real database tables; the** preupdate hook is not invokedforchanges to [virtual tables] or to**systemtables like sqlite_sequence or sqlite_stat1.**** ^The second parameter to the preupdate callback is a pointer to** the [database connection] that registered the preupdate hook.** ^The third parameter to the preupdate callback is one of the constants** [SQLITE_INSERT], [SQLITE_DELETE], or [SQLITE_UPDATE] to identify the** kind of update operation that is about to occur.
** behavior.**** ^The [sqlite3_preupdate_count(D)] interface returns the number of columns** in the row that is being inserted, updated, or deleted.**** ^The [sqlite3_preupdate_old(D,N,P)] interface writes into P a pointer to** a [protected sqlite3_value] that contains the value of the Nth column of** the table rowbeforeit is updated. The N parameter must be between 0** and one less than the number of columns or the behavior will be** undefined. This must only be used within SQLITE_UPDATE and SQLITE_DELETE** preupdate callbacks;ifit is used by an SQLITE_INSERT callback then the** behavior is undefined. The [sqlite3_value] that P points to** will be destroyedwhenthe preupdate callback returns.**** ^The [sqlite3_preupdate_new(D,N,P)] interface writes into P a pointer to** a [protected sqlite3_value] that contains the value of the Nth column of** the table rowafterit is updated. The N parameter must be between 0** and one less than the number of columns or the behavior will be** undefined. This must only be used within SQLITE_INSERT and SQLITE_UPDATE** preupdate callbacks;ifit is used by an SQLITE_DELETE callback then the** behavior is undefined. The [sqlite3_value] that P points to** will be destroyedwhenthe preupdate callback returns.**** ^The [sqlite3_preupdate_depth(D)] interface returns 0ifthe preupdate** callback was invoked as a result of a direct insert, update, ordelete** operation; or 1forinserts, updates, or deletes invoked by top-level** triggers; or 2forchanges resulting from triggers called by top-level** triggers; and so forth.**** When the [sqlite3_blob_write()] API is used to update a blob column,
SQLITE_APIintsqlite3_rtree_geometry_callback(sqlite3*db,const char*zGeom,int(*xGeom)(sqlite3_rtree_geometry*,int, sqlite3_rtree_dbl*,int*),void*pContext);/*** A pointer to a structure of the following type is passed as the first** argument to callbacks registered using rtree_geometry_callback().*/struct sqlite3_rtree_geometry {void*pContext; /* Copy of pContext passed to s_r_g_c() */intnParam; /* Size of array aParam[] */sqlite3_rtree_dbl*aParam; /* Parameters passed to SQL geom function */void*pUser; /* Callback implementation user data */void (*xDelUser)(void *); /* Called by SQLite to clean up pUser */};/*
( run in 0.281 second using v1.01-cache-2.11-cpan-0f795438458 )