Lines Matching refs:pStmt
5000 SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);
5001 SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt);
5003 SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt);
5053 SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
5065 SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt);
5100 SQLITE_API int sqlite3_stmt_explain(sqlite3_stmt *pStmt, int eMode);
5435 SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt);
5652 SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
5936 SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt);
5975 SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
7419 ** pStmt associated with the [database connection] pDb. ^If pStmt is NULL
7428 SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
11025 ** performance for pStmt. Advanced applications can use this
11059 sqlite3_stmt *pStmt, /* Prepared statement for which info desired */
11065 sqlite3_stmt *pStmt, /* Prepared statement for which info desired */
11626 sqlite3_stmt *pStmt, /* Statement to be bound */
11635 sqlite3_stmt *pStmt, /* Statement to be bound */
56019 sqlite3_stmt *pStmt = 0;
56052 rc = zSql ? sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0) : SQLITE_NOMEM;
56055 rc = sqlite3_step(pStmt);
56059 sz = sqlite3_column_int64(pStmt, 0)*szPage;
56061 sqlite3_reset(pStmt);
56063 rc = sqlite3_step(pStmt);
56065 sz = sqlite3_column_int64(pStmt, 0)*szPage;
56074 int nPage = sqlite3_column_int(pStmt, 0);
56091 sqlite3_finalize(pStmt);
56107 sqlite3_stmt *pStmt = 0;
56131 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
56137 rc = sqlite3_step(pStmt);
56161 sqlite3_finalize(pStmt);
93557 SQLITE_API int sqlite3_expired(sqlite3_stmt *pStmt){
93558 Vdbe *p = (Vdbe*)pStmt;
93627 SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt){
93629 if( pStmt==0 ){
93634 Vdbe *v = (Vdbe*)pStmt;
93656 SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt){
93658 if( pStmt==0 ){
93661 Vdbe *v = (Vdbe*)pStmt;
93677 SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
93680 Vdbe *p = (Vdbe*)pStmt;
93685 if( pStmt==0 ){
94291 ** Execute the statement pStmt, either until a row of data is ready, the
94441 SQLITE_API int sqlite3_step(sqlite3_stmt *pStmt){
94443 Vdbe *v = (Vdbe*)pStmt; /* the prepared statement */
94476 sqlite3_reset(pStmt);
94792 ** Return the number of columns in the result set for the statement pStmt.
94794 SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt){
94795 Vdbe *pVm = (Vdbe *)pStmt;
94802 ** currently executing statement pStmt.
94804 SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt){
94805 Vdbe *pVm = (Vdbe *)pStmt;
94854 static Mem *columnMem(sqlite3_stmt *pStmt, int i){
94858 pVm = (Vdbe *)pStmt;
94876 ** code of statement pStmt set to SQLITE_NOMEM.
94889 static void columnMallocFailure(sqlite3_stmt *pStmt)
94896 Vdbe *p = (Vdbe *)pStmt;
94909 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
94911 val = sqlite3_value_blob( columnMem(pStmt,i) );
94916 columnMallocFailure(pStmt);
94919 SQLITE_API int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
94920 int val = sqlite3_value_bytes( columnMem(pStmt,i) );
94921 columnMallocFailure(pStmt);
94924 SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
94925 int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
94926 columnMallocFailure(pStmt);
94929 SQLITE_API double sqlite3_column_double(sqlite3_stmt *pStmt, int i){
94930 double val = sqlite3_value_double( columnMem(pStmt,i) );
94931 columnMallocFailure(pStmt);
94934 SQLITE_API int sqlite3_column_int(sqlite3_stmt *pStmt, int i){
94935 int val = sqlite3_value_int( columnMem(pStmt,i) );
94936 columnMallocFailure(pStmt);
94939 SQLITE_API sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){
94940 sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
94941 columnMallocFailure(pStmt);
94944 SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){
94945 const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
94946 columnMallocFailure(pStmt);
94949 SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
94950 Mem *pOut = columnMem(pStmt, i);
94955 columnMallocFailure(pStmt);
94959 SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
94960 const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
94961 columnMallocFailure(pStmt);
94965 SQLITE_API int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
94966 int iType = sqlite3_value_type( columnMem(pStmt,i) );
94967 columnMallocFailure(pStmt);
94998 ** Convert the N-th element of pStmt->pColName[] into a string using
95014 sqlite3_stmt *pStmt, /* The statement */
95024 if( pStmt==0 ){
95031 p = (Vdbe *)pStmt;
95076 ** statement pStmt.
95078 SQLITE_API const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
95079 return columnName(pStmt, N, 0, COLNAME_NAME);
95082 SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
95083 return columnName(pStmt, N, 1, COLNAME_NAME);
95099 ** of the result set of SQL statement pStmt.
95101 SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
95102 return columnName(pStmt, N, 0, COLNAME_DECLTYPE);
95105 SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
95106 return columnName(pStmt, N, 1, COLNAME_DECLTYPE);
95117 SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){
95118 return columnName(pStmt, N, 0, COLNAME_DATABASE);
95121 SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
95122 return columnName(pStmt, N, 1, COLNAME_DATABASE);
95131 SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){
95132 return columnName(pStmt, N, 0, COLNAME_TABLE);
95135 SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
95136 return columnName(pStmt, N, 1, COLNAME_TABLE);
95145 SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){
95146 return columnName(pStmt, N, 0, COLNAME_COLUMN);
95149 SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
95150 return columnName(pStmt, N, 1, COLNAME_COLUMN);
95225 sqlite3_stmt *pStmt, /* The statement to bind against */
95232 Vdbe *p = (Vdbe *)pStmt;
95278 sqlite3_stmt *pStmt,
95287 return bindText(pStmt, i, zData, nData, xDel, 0);
95290 sqlite3_stmt *pStmt,
95297 return bindText(pStmt, i, zData, nData, xDel, 0);
95299 SQLITE_API int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
95301 Vdbe *p = (Vdbe *)pStmt;
95313 SQLITE_API int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
95315 Vdbe *p = (Vdbe *)pStmt;
95324 SQLITE_API int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
95326 Vdbe *p = (Vdbe*)pStmt;
95335 sqlite3_stmt *pStmt,
95342 Vdbe *p = (Vdbe*)pStmt;
95354 sqlite3_stmt *pStmt,
95360 return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
95363 sqlite3_stmt *pStmt,
95375 return bindText(pStmt, i, zData, nData, xDel, enc);
95379 sqlite3_stmt *pStmt,
95385 return bindText(pStmt, i, zData, n & ~(u64)1, xDel, SQLITE_UTF16NATIVE);
95388 SQLITE_API int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
95392 rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
95397 rc = sqlite3_bind_double(pStmt, i,
95404 rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
95406 rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT);
95411 pStmt,i, pValue->z, pValue->n, SQLITE_TRANSIENT,
95416 rc = sqlite3_bind_null(pStmt, i);
95422 SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
95424 Vdbe *p = (Vdbe *)pStmt;
95437 SQLITE_API int sqlite3_bind_zeroblob64(sqlite3_stmt *pStmt, int i, sqlite3_uint64 n){
95439 Vdbe *p = (Vdbe *)pStmt;
95448 rc = sqlite3_bind_zeroblob(pStmt, i, n);
95459 SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){
95460 Vdbe *p = (Vdbe*)pStmt;
95470 SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){
95471 Vdbe *p = (Vdbe*)pStmt;
95485 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
95486 return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
95543 SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){
95544 return pStmt ? ((Vdbe*)pStmt)->db : 0;
95551 SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt){
95552 return pStmt ? ((Vdbe*)pStmt)->readOnly : 1;
95559 SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt){
95560 return pStmt ? ((Vdbe*)pStmt)->explain : 0;
95566 SQLITE_API int sqlite3_stmt_explain(sqlite3_stmt *pStmt, int eMode){
95567 Vdbe *v = (Vdbe*)pStmt;
95570 if( pStmt==0 ) return SQLITE_MISUSE_BKPT;
95602 SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt *pStmt){
95603 Vdbe *v = (Vdbe*)pStmt;
95608 ** Return a pointer to the next prepared statement after pStmt associated
95609 ** with database connection pDb. If pStmt is NULL, return the first
95613 SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){
95622 if( pStmt==0 ){
95625 pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pVNext;
95634 SQLITE_API int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
95635 Vdbe *pVdbe = (Vdbe*)pStmt;
95638 if( !pStmt
95666 SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt){
95667 Vdbe *p = (Vdbe *)pStmt;
95680 SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt){
95685 const char *zSql = sqlite3_sql(pStmt);
95687 Vdbe *p = (Vdbe *)pStmt;
95700 SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt){
95701 Vdbe *p = (Vdbe *)pStmt;
95983 ** Return status data for a single loop within query pStmt.
95986 sqlite3_stmt *pStmt, /* Prepared statement being queried */
95992 Vdbe *p = (Vdbe*)pStmt;
96137 ** Return status data for a single loop within query pStmt.
96140 sqlite3_stmt *pStmt, /* Prepared statement being queried */
96145 return sqlite3_stmt_scanstatus_v2(pStmt, iScan, iScanStatusOp, 0, pOut);
96151 SQLITE_API void sqlite3_stmt_scanstatus_reset(sqlite3_stmt *pStmt){
96152 Vdbe *p = (Vdbe*)pStmt;
105861 sqlite3_stmt *pStmt; /* Statement holding cursor open */
105888 Vdbe *v = (Vdbe *)p->pStmt;
105904 rc = sqlite3_step(p->pStmt);
105919 sqlite3_finalize(p->pStmt);
105920 p->pStmt = 0;
105931 }else if( p->pStmt ){
105932 rc = sqlite3_finalize(p->pStmt);
105933 p->pStmt = 0;
106081 pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(&sParse);
106082 assert( pBlob->pStmt || db->mallocFailed );
106083 if( pBlob->pStmt ){
106110 Vdbe *v = (Vdbe *)pBlob->pStmt;
106176 if( pBlob && pBlob->pStmt ) sqlite3VdbeFinalize((Vdbe *)pBlob->pStmt);
106197 sqlite3_stmt *pStmt = p->pStmt;
106202 rc = sqlite3_finalize(pStmt);
106227 v = (Vdbe*)p->pStmt;
106288 p->pStmt = 0;
106321 return (p && p->pStmt) ? p->nByte : 0;
106343 if( p->pStmt==0 ){
106350 ((Vdbe*)p->pStmt)->rc = SQLITE_OK;
106360 assert( rc==SQLITE_OK || p->pStmt==0 );
109201 sqlite3_stmt *pStmt; /* The statement whose bytecode is displayed */
109204 int needFinalize; /* Cursors owns pStmt and must finalize it */
109302 sqlite3_finalize(pCur->pStmt);
109304 pCur->pStmt = 0;
109339 (Vdbe*)pCur->pStmt,
109520 rc = sqlite3_prepare_v2(pVTab->db, zSql, -1, &pCur->pStmt, 0);
109524 pCur->pStmt = (sqlite3_stmt*)sqlite3_value_pointer(argv[0],"stmt-pointer");
109526 if( pCur->pStmt==0 ){
125183 sqlite3_stmt *pStmt = 0; /* An SQL statement being run */
125193 rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
125197 while( sqlite3_step(pStmt)==SQLITE_ROW ){
125208 zIndex = (char *)sqlite3_column_text(pStmt, 0);
125210 nSample = sqlite3_column_int(pStmt, 1);
125232 sqlite3_finalize(pStmt);
125248 rc = sqlite3_finalize(pStmt);
125255 rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
125259 while( sqlite3_step(pStmt)==SQLITE_ROW ){
125264 zIndex = (char *)sqlite3_column_text(pStmt, 0);
125281 decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0);
125282 decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0);
125283 decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0);
125292 pSample->n = sqlite3_column_bytes(pStmt, 4);
125295 sqlite3_finalize(pStmt);
125299 memcpy(pSample->p, sqlite3_column_blob(pStmt, 4), pSample->n);
125303 rc = sqlite3_finalize(pStmt);
142095 sqlite3_stmt *pStmt = 0; /* The current SQL statement */
142108 pStmt = 0;
142109 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
142110 assert( rc==SQLITE_OK || pStmt==0 );
142114 if( !pStmt ){
142123 rc = sqlite3_step(pStmt);
142130 nCol = sqlite3_column_count(pStmt);
142136 azCols[i] = (char *)sqlite3_column_name(pStmt, i);
142146 azVals[i] = (char *)sqlite3_column_text(pStmt, i);
142147 if( !azVals[i] && sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
142159 sqlite3VdbeFinalize((Vdbe *)pStmt);
142160 pStmt = 0;
142167 rc = sqlite3VdbeFinalize((Vdbe *)pStmt);
142168 pStmt = 0;
142180 if( pStmt ) sqlite3VdbeFinalize((Vdbe *)pStmt);
142277 int (*column_count)(sqlite3_stmt*pStmt);
142311 int (*data_count)(sqlite3_stmt*pStmt);
142320 int (*finalize)(sqlite3_stmt*pStmt);
142340 int (*reset)(sqlite3_stmt*pStmt);
147793 sqlite3_stmt *pStmt;
147807 pStmt = 0;
147808 TESTONLY(rcp = ) sqlite3Prepare(db, argv[4], -1, 0, 0, &pStmt, 0);
147826 sqlite3_finalize(pStmt);
161221 sqlite3_stmt *pStmt;
161225 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
161227 while( SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){
161228 const char *zSubSql = (const char*)sqlite3_column_text(pStmt,0);
161247 (void)sqlite3_finalize(pStmt);
193575 u8 isRequireSeek; /* True if must seek pStmt to %_content row */
193576 u8 bSeekStmt; /* True if pStmt is a seek */
193577 sqlite3_stmt *pStmt; /* Prepared statement in use by the cursor */
194378 sqlite3_stmt *pStmt; /* Compiled "PRAGMA %Q.page_size" statement */
194384 rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
194386 sqlite3_step(pStmt);
194387 p->nPgsz = sqlite3_column_int(pStmt, 0);
194388 rc = sqlite3_finalize(pStmt);
194729 sqlite3_stmt *pStmt = 0; /* Compiled version of zSql */
194735 rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
194751 nCol = sqlite3_column_count(pStmt);
194753 const char *zCol = sqlite3_column_name(pStmt, i);
194764 const char *zCol = sqlite3_column_name(pStmt, i);
194771 sqlite3_finalize(pStmt);
195379 ** Finalize the statement handle at pCsr->pStmt.
195389 p->pSeekStmt = pCsr->pStmt;
195390 sqlite3_reset(pCsr->pStmt);
195391 pCsr->pStmt = 0;
195395 sqlite3_finalize(pCsr->pStmt);
195425 ** If pCsr->pStmt has not been prepared (i.e. if pCsr->pStmt==0), then
195430 ** (or the equivalent for a content=xxx table) and set pCsr->pStmt to
195435 if( pCsr->pStmt==0 ){
195439 pCsr->pStmt = p->pSeekStmt;
195445 rc = sqlite3Fts3PrepareStmt(p, zSql, 1, 1, &pCsr->pStmt);
195455 ** Position the pCsr->pStmt statement so that it is on the row
195466 sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iPrevId);
195468 if( SQLITE_ROW==sqlite3_step(pCsr->pStmt) ){
195473 rc = sqlite3_reset(pCsr->pStmt);
196602 sqlite3_stmt *pStmt
196621 rc = sqlite3Fts3AllSegdirs(p, iLangid, iIndex, iLevel, &pStmt);
196624 while( rc==SQLITE_OK && SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){
196628 sqlite3_int64 iStartBlock = sqlite3_column_int64(pStmt, 1);
196629 sqlite3_int64 iLeavesEndBlock = sqlite3_column_int64(pStmt, 2);
196630 sqlite3_int64 iEndBlock = sqlite3_column_int64(pStmt, 3);
196631 int nRoot = sqlite3_column_bytes(pStmt, 4);
196632 char const *zRoot = sqlite3_column_blob(pStmt, 4);
196654 rc2 = sqlite3_reset(pStmt);
196876 if( SQLITE_ROW!=sqlite3_step(pCsr->pStmt) ){
196878 rc = sqlite3_reset(pCsr->pStmt);
196880 pCsr->iPrevId = sqlite3_column_int64(pCsr->pStmt, 0);
197020 rc = sqlite3Fts3PrepareStmt(p, zSql, 1, 1, &pCsr->pStmt);
197029 rc = sqlite3_bind_value(pCsr->pStmt, 1, pCons);
197112 if( rc==SQLITE_OK && sqlite3_data_count(pCsr->pStmt)-1>iCol ){
197113 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
198629 sqlite3_stmt *pStmt;
198635 rc = sqlite3Fts3SelectDoctotal(p, &pStmt);
198637 a = sqlite3_column_blob(pStmt, 0);
198640 pEnd = &a[sqlite3_column_bytes(pStmt, 0)];
198647 sqlite3_reset(pStmt);
198654 rc = sqlite3_reset(pStmt);
199340 sqlite3_reset(pCsr->pStmt);
199342 assert( sqlite3_data_count(pCsr->pStmt)==0 );
199526 if( pCsr->isRequireSeek==0 ) sqlite3_reset(pCsr->pStmt);
199527 assert( sqlite3_data_count(pCsr->pStmt)==0 );
203117 sqlite3_stmt *pStmt;
203120 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
203125 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
203126 sqlite3_bind_blob(pStmt, 2, &p, sizeof(p), SQLITE_STATIC);
203127 sqlite3_step(pStmt);
203129 return sqlite3_finalize(pStmt);
203140 sqlite3_stmt *pStmt;
203144 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
203149 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
203150 if( SQLITE_ROW==sqlite3_step(pStmt) ){
203151 if( sqlite3_column_type(pStmt, 0)==SQLITE_BLOB
203152 && sqlite3_column_bytes(pStmt, 0)==sizeof(*pp)
203154 memcpy((void *)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
203158 return sqlite3_finalize(pStmt);
204392 sqlite3_stmt *pStmt;
204397 pStmt = p->aStmt[eStmt];
204398 if( !pStmt ){
204412 rc = sqlite3Fts3PrepareStmt(p, zSql, 1, bAllowVtab, &pStmt);
204414 assert( rc==SQLITE_OK || pStmt==0 );
204415 p->aStmt[eStmt] = pStmt;
204420 int nParam = sqlite3_bind_parameter_count(pStmt);
204422 rc = sqlite3_bind_value(pStmt, i+1, apVal[i]);
204425 *pp = pStmt;
204435 sqlite3_stmt *pStmt = 0; /* Statement requested from fts3SqlStmt() */
204438 rc = fts3SqlStmt(pTab, SQL_SELECT_DOCSIZE, &pStmt, 0);
204440 sqlite3_bind_int64(pStmt, 1, iDocid);
204441 rc = sqlite3_step(pStmt);
204442 if( rc!=SQLITE_ROW || sqlite3_column_type(pStmt, 0)!=SQLITE_BLOB ){
204443 rc = sqlite3_reset(pStmt);
204445 pStmt = 0;
204451 *ppStmt = pStmt;
204459 sqlite3_stmt *pStmt = 0;
204461 rc = fts3SqlStmt(pTab, SQL_SELECT_STAT, &pStmt, 0);
204463 sqlite3_bind_int(pStmt, 1, FTS_STAT_DOCTOTAL);
204464 if( sqlite3_step(pStmt)!=SQLITE_ROW
204465 || sqlite3_column_type(pStmt, 0)!=SQLITE_BLOB
204467 rc = sqlite3_reset(pStmt);
204469 pStmt = 0;
204472 *ppStmt = pStmt;
204498 sqlite3_stmt *pStmt;
204501 rc = fts3SqlStmt(p, eStmt, &pStmt, apVal);
204503 sqlite3_step(pStmt);
204504 rc = sqlite3_reset(pStmt);
204528 sqlite3_stmt *pStmt;
204529 rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_LEVEL, &pStmt, 0);
204531 sqlite3_bind_null(pStmt, 1);
204532 sqlite3_step(pStmt);
204533 rc = sqlite3_reset(pStmt);
204603 sqlite3_stmt *pStmt = 0;
204611 rc = fts3SqlStmt(p, SQL_SELECT_LEVEL_RANGE, &pStmt, 0);
204613 sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex, 0));
204614 sqlite3_bind_int64(pStmt, 2,
204620 rc = fts3SqlStmt(p, SQL_SELECT_LEVEL, &pStmt, 0);
204622 sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex,iLevel));
204625 *ppStmt = pStmt;
205932 sqlite3_stmt *pStmt;
205933 int rc = fts3SqlStmt(p, SQL_INSERT_SEGMENTS, &pStmt, 0);
205935 sqlite3_bind_int64(pStmt, 1, iBlock);
205936 sqlite3_bind_blob(pStmt, 2, z, n, SQLITE_STATIC);
205937 sqlite3_step(pStmt);
205938 rc = sqlite3_reset(pStmt);
205939 sqlite3_bind_null(pStmt, 2);
205952 sqlite3_stmt *pStmt = 0;
205954 rc = fts3SqlStmt(p, SQL_SELECT_MXLEVEL, &pStmt, 0);
205956 if( SQLITE_ROW==sqlite3_step(pStmt) ){
205957 mxLevel = sqlite3_column_int(pStmt, 0);
205959 rc = sqlite3_reset(pStmt);
205979 sqlite3_stmt *pStmt;
205980 int rc = fts3SqlStmt(p, SQL_INSERT_SEGDIR, &pStmt, 0);
205982 sqlite3_bind_int64(pStmt, 1, iLevel);
205983 sqlite3_bind_int(pStmt, 2, iIdx);
205984 sqlite3_bind_int64(pStmt, 3, iStartBlock);
205985 sqlite3_bind_int64(pStmt, 4, iLeafEndBlock);
205987 sqlite3_bind_int64(pStmt, 5, iEndBlock);
205991 sqlite3_bind_text(pStmt, 5, zEnd, -1, sqlite3_free);
205993 sqlite3_bind_blob(pStmt, 6, zRoot, nRoot, SQLITE_STATIC);
205994 sqlite3_step(pStmt);
205995 rc = sqlite3_reset(pStmt);
205996 sqlite3_bind_null(pStmt, 6);
206253 sqlite3_stmt *pStmt;
206267 rc = fts3SqlStmt(p, SQL_NEXT_SEGMENTS_ID, &pStmt, 0);
206269 if( SQLITE_ROW==sqlite3_step(pStmt) ){
206270 pWriter->iFree = sqlite3_column_int64(pStmt, 0);
206273 rc = sqlite3_reset(pStmt);
206443 sqlite3_stmt *pStmt;
206450 rc = fts3SqlStmt(p, SQL_IS_EMPTY, &pStmt, &pRowid);
206452 if( SQLITE_ROW==sqlite3_step(pStmt) ){
206453 *pisEmpty = sqlite3_column_int(pStmt, 0);
206455 rc = sqlite3_reset(pStmt);
206475 sqlite3_stmt *pStmt;
206479 /* Set pStmt to the compiled version of:
206485 rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR_MAX_LEVEL, &pStmt, 0);
206487 sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex, 0));
206488 sqlite3_bind_int64(pStmt, 2,
206491 if( SQLITE_ROW==sqlite3_step(pStmt) ){
206492 *pnMax = sqlite3_column_int64(pStmt, 0);
206494 return sqlite3_reset(pStmt);
206507 /* Set pStmt to the compiled version of:
206513 sqlite3_stmt *pStmt;
206514 int rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR_MAX_LEVEL, &pStmt, 0);
206516 sqlite3_bind_int64(pStmt, 1, iAbsLevel+1);
206517 sqlite3_bind_int64(pStmt, 2,
206522 if( SQLITE_ROW==sqlite3_step(pStmt) ){
206523 *pbMax = sqlite3_column_type(pStmt, 0)==SQLITE_NULL;
206525 return sqlite3_reset(pStmt);
207089 sqlite3_stmt *pStmt,
207094 const unsigned char *zText = sqlite3_column_text(pStmt, iCol);
207337 sqlite3_stmt *pStmt = 0;
207338 rc = fts3SqlStmt(p, SQL_SELECT_STAT, &pStmt, 0);
207340 sqlite3_bind_int(pStmt, 1, FTS_STAT_AUTOINCRMERGE);
207341 rc = sqlite3_step(pStmt);
207343 p->nAutoincrmerge = sqlite3_column_int(pStmt, 0);
207348 rc = sqlite3_reset(pStmt);
207407 sqlite3_stmt *pStmt; /* Statement used to insert the encoding */
207417 rc = fts3SqlStmt(p, SQL_REPLACE_DOCSIZE, &pStmt, 0);
207423 sqlite3_bind_int64(pStmt, 1, p->iPrevDocid);
207424 sqlite3_bind_blob(pStmt, 2, pBlob, nBlob, sqlite3_free);
207425 sqlite3_step(pStmt);
207426 *pRC = sqlite3_reset(pStmt);
207454 sqlite3_stmt *pStmt; /* Statement for reading and writing */
207467 rc = fts3SqlStmt(p, SQL_SELECT_STAT, &pStmt, 0);
207473 sqlite3_bind_int(pStmt, 1, FTS_STAT_DOCTOTAL);
207474 if( sqlite3_step(pStmt)==SQLITE_ROW ){
207476 sqlite3_column_blob(pStmt, 0),
207477 sqlite3_column_bytes(pStmt, 0));
207481 rc = sqlite3_reset(pStmt);
207502 rc = fts3SqlStmt(p, SQL_REPLACE_STAT, &pStmt, 0);
207508 sqlite3_bind_int(pStmt, 1, FTS_STAT_DOCTOTAL);
207509 sqlite3_bind_blob(pStmt, 2, pBlob, nBlob, SQLITE_STATIC);
207510 sqlite3_step(pStmt);
207511 *pRC = sqlite3_reset(pStmt);
207512 sqlite3_bind_null(pStmt, 2);
207571 sqlite3_stmt *pStmt = 0;
207579 rc = sqlite3Fts3PrepareStmt(p, zSql, 0, 1, &pStmt);
207595 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
207597 int iLangid = langidFromSelect(p, pStmt);
207598 rc = fts3PendingTermsDocid(p, 0, iLangid, sqlite3_column_int64(pStmt, 0));
207602 const char *z = (const char *) sqlite3_column_text(pStmt, iCol+1);
207604 aSz[p->nColumn] += sqlite3_column_bytes(pStmt, iCol+1);
207611 sqlite3_finalize(pStmt);
207612 pStmt = 0;
207625 if( pStmt ){
207626 int rc2 = sqlite3_finalize(pStmt);
207650 sqlite3_stmt *pStmt = 0; /* Statement used to read %_segdir entry */
207662 rc = fts3SqlStmt(p, SQL_SELECT_LEVEL, &pStmt, 0);
207667 sqlite3_bind_int64(pStmt, 1, iAbsLevel);
207669 for(i=0; rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW && i<nSeg; i++){
207671 sqlite3_column_int64(pStmt, 1), /* segdir.start_block */
207672 sqlite3_column_int64(pStmt, 2), /* segdir.leaves_end_block */
207673 sqlite3_column_int64(pStmt, 3), /* segdir.end_block */
207674 sqlite3_column_blob(pStmt, 4), /* segdir.root */
207675 sqlite3_column_bytes(pStmt, 4), /* segdir.root */
207680 rc2 = sqlite3_reset(pStmt);
209168 sqlite3_stmt *pStmt = 0;
209178 rc = fts3SqlStmt(p, SQL_REPLACE_STAT, &pStmt, 0);
209180 sqlite3_bind_int(pStmt, 1, FTS_STAT_AUTOINCRMERGE);
209181 sqlite3_bind_int(pStmt, 2, p->nAutoincrmerge);
209182 sqlite3_step(pStmt);
209183 rc = sqlite3_reset(pStmt);
209325 sqlite3_stmt *pStmt = 0;
209332 rc = sqlite3Fts3PrepareStmt(p, zSql, 0, 1, &pStmt);
209336 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
209337 i64 iDocid = sqlite3_column_int64(pStmt, 0);
209338 int iLang = langidFromSelect(p, pStmt);
209343 const char *zText = (const char *)sqlite3_column_text(pStmt, iCol+1);
209374 sqlite3_finalize(pStmt);
209527 iDocid = sqlite3_column_int64(pCsr->pStmt, 0);
209531 const char *zText = (const char *)sqlite3_column_text(pCsr->pStmt, i+1);
210584 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol);
210586 if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){
210591 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol);
210888 sqlite3_stmt *pStmt;
210899 pStmt = *ppStmt;
210900 assert( sqlite3_data_count(pStmt)==1 );
210902 n = sqlite3_column_bytes(pStmt, 0);
210903 a = sqlite3_column_blob(pStmt, 0);
211515 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1);
211516 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
211518 if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){
219217 sqlite3_stmt *pStmt;
219232 pStmt = pCsr->pReadAux;
219235 pCsr->pReadAux = pStmt;
219242 sqlite3_reset(pStmt);
221155 sqlite3_stmt *pStmt = 0;
221162 rc = sqlite3_prepare_v2(pRtree->db, zSql, -1, &pStmt, 0);
221170 const char *zCol = sqlite3_column_name(pStmt, 0);
221175 const char *zCol1 = sqlite3_column_name(pStmt, iCol);
221176 const char *zCol2 = sqlite3_column_name(pStmt, iCol+1);
221183 sqlite3_finalize(pStmt);
221623 sqlite3_stmt *pStmt = 0;
221624 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
221626 if( SQLITE_ROW==sqlite3_step(pStmt) ){
221627 *piVal = sqlite3_column_int(pStmt, 0);
221629 rc = sqlite3_finalize(pStmt);
221941 ** Reset SQL statement pStmt. If the sqlite3_reset() call returns an error,
221944 static void rtreeCheckReset(RtreeCheck *pCheck, sqlite3_stmt *pStmt){
221945 int rc = sqlite3_reset(pStmt);
222071 sqlite3_stmt *pStmt;
222085 pStmt = pCheck->aCheckMapping[bLeaf];
222086 sqlite3_bind_int64(pStmt, 1, iKey);
222087 rc = sqlite3_step(pStmt);
222093 i64 ii = sqlite3_column_int64(pStmt, 0);
222101 rtreeCheckReset(pCheck, pStmt);
222256 sqlite3_stmt *pStmt = 0; /* Used to find column count of rtree table */
222266 pStmt = rtreeCheckPrepare(&check, "SELECT * FROM %Q.'%q_rowid'", zDb, zTab);
222267 if( pStmt ){
222268 nAux = sqlite3_column_count(pStmt) - 2;
222269 sqlite3_finalize(pStmt);
222276 pStmt = rtreeCheckPrepare(&check, "SELECT * FROM %Q.%Q", zDb, zTab);
222277 if( pStmt ){
222279 check.nDim = (sqlite3_column_count(pStmt) - 1 - nAux) / 2;
222282 }else if( SQLITE_ROW==sqlite3_step(pStmt) ){
222283 check.bInt = (sqlite3_column_type(pStmt, 1)==SQLITE_INTEGER);
222285 rc = sqlite3_finalize(pStmt);
226688 static int resetAndCollectError(sqlite3_stmt *pStmt, char **pzErrmsg){
226689 int rc = sqlite3_reset(pStmt);
226691 *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(sqlite3_db_handle(pStmt)));
227075 static void rbuFinalize(sqlite3rbu *p, sqlite3_stmt *pStmt){
227076 sqlite3 *db = sqlite3_db_handle(pStmt);
227077 int rc = sqlite3_finalize(pStmt);
227265 sqlite3_stmt *pStmt = 0;
227290 p->rc = prepareFreeAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
227294 nCol = sqlite3_column_count(pStmt);
227298 const char *zName = (const char*)sqlite3_column_name(pStmt, i);
227308 sqlite3_finalize(pStmt);
227309 pStmt = 0;
227326 p->rc = prepareFreeAndCollectError(p->dbMain, &pStmt, &p->zErrmsg,
227330 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
227331 const char *zName = (const char*)sqlite3_column_text(pStmt, 1);
227342 int iPk = sqlite3_column_int(pStmt, 5);
227343 int bNotNull = sqlite3_column_int(pStmt, 3);
227344 const char *zType = (const char*)sqlite3_column_text(pStmt, 2);
227359 rbuFinalize(p, pStmt);
228157 sqlite3_stmt *pStmt = 0;
228164 rc = prepareAndCollectError(p->dbMain, &pStmt, &p->zErrmsg,
228170 rc = sqlite3_bind_text(pStmt, 1, pIter->zIdx, -1, SQLITE_STATIC);
228171 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
228172 char *zSql = (char*)sqlite3_column_text(pStmt, 0);
228243 rc2 = sqlite3_finalize(pStmt);
228632 sqlite3_stmt *pStmt = 0;
228639 rc = prepareFreeAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
228642 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
228643 switch( sqlite3_column_int(pStmt, 0) ){
228645 pRet->eStage = sqlite3_column_int(pStmt, 1);
228655 pRet->zTbl = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc);
228659 pRet->zIdx = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc);
228663 pRet->nRow = sqlite3_column_int(pStmt, 1);
228667 pRet->nProgress = sqlite3_column_int64(pStmt, 1);
228671 pRet->iWalCksum = sqlite3_column_int64(pStmt, 1);
228675 pRet->iCookie = (u32)sqlite3_column_int64(pStmt, 1);
228679 pRet->iOalSz = sqlite3_column_int64(pStmt, 1);
228683 pRet->nPhaseOneStep = sqlite3_column_int64(pStmt, 1);
228687 pRet->zDataTbl = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc);
228695 rc2 = sqlite3_finalize(pStmt);
229281 ** Assert that column iCol of statement pStmt is named zName.
229283 static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
229284 const char *zCol = sqlite3_column_name(pStmt, iCol);
229448 sqlite3_stmt *pStmt;
229450 p->rc = prepareAndCollectError(dbread, &pStmt, &p->zErrmsg,
229459 if( SQLITE_ROW==sqlite3_step(pStmt) ){
229460 iCookie = sqlite3_column_int(pStmt, 0);
229462 rbuFinalize(p, pStmt);
229841 sqlite3_stmt *pStmt = 0;
229849 rc = prepareFreeAndCollectError(db, &pStmt, &zErrmsg,
229857 if( SQLITE_ROW==sqlite3_step(pStmt) ){
229858 nIndex = sqlite3_column_int(pStmt, 0);
229860 rc = sqlite3_finalize(pStmt);
229888 sqlite3_stmt *pStmt = 0;
229900 p->rc = prepareAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
229905 if( SQLITE_ROW==sqlite3_step(pStmt) ){
229908 p->rc = sqlite3_finalize(pStmt);
229912 p->rc = prepareAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
229917 if( SQLITE_ROW==sqlite3_step(pStmt) ){
229918 p->nPhaseOneStep = sqlite3_column_int64(pStmt, 0);
229920 p->rc = sqlite3_finalize(pStmt);
231484 sqlite3_stmt *pStmt; /* Iterates through set of root pages */
231485 u8 isEof; /* After pStmt has returned SQLITE_DONE */
231702 sqlite3_reset(pCsr->pStmt);
231725 sqlite3_finalize(pCsr->pStmt);
231950 rc = sqlite3_step(pCsr->pStmt);
231953 u32 iRoot = (u32)sqlite3_column_int64(pCsr->pStmt, 1);
231957 return sqlite3_reset(pCsr->pStmt);
231970 return sqlite3_reset(pCsr->pStmt);
231995 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
232047 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
232115 sqlite3_finalize(pCsr->pStmt);
232116 pCsr->pStmt = 0;
232157 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pStmt, 0);
232804 ** int i = sqlite3_bind_parameter_index(pStmt, "$ptr");
232805 ** sqlite3_bind_pointer(pStmt, i, aX, "carray", 0);
233202 ** pStmt The prepared statement to which to bind
233203 ** idx The index of the parameter of pStmt to which to bind
233214 sqlite3_stmt *pStmt,
233303 return sqlite3_bind_pointer(pStmt, idx, pNew, "carray-bind", carrayBindDel);
233319 sqlite3_stmt *pStmt,
233326 return sqlite3_carray_bind_v2(pStmt,idx,aData,nData,mFlags,xDestroy,aData);
234413 sqlite3_stmt *pStmt;
234458 rc = sqlite3_prepare_v2(db, zPragma, -1, &pStmt, 0);
234466 while( SQLITE_ROW==sqlite3_step(pStmt) ){
234467 nByte += sqlite3_column_bytes(pStmt, 1); /* name */
234468 nByte += sqlite3_column_bytes(pStmt, 4); /* dflt_value */
234469 if( sqlite3_column_int(pStmt, 6)==0 ){ /* !hidden */
234472 if( sqlite3_column_int(pStmt, 5) ) bRowid = 0; /* pk */
234477 rc = sqlite3_reset(pStmt);
234510 while( SQLITE_ROW==sqlite3_step(pStmt) ){
234511 if( sqlite3_column_int(pStmt, 6)==0 ){ /* !hidden */
234512 int nName = sqlite3_column_bytes(pStmt, 1);
234513 int nDflt = sqlite3_column_bytes(pStmt, 4);
234514 const unsigned char *zName = sqlite3_column_text(pStmt, 1);
234515 const unsigned char *zDflt = sqlite3_column_text(pStmt, 4);
234528 abPK[i] = sqlite3_column_int(pStmt, 5);
234529 aiIdx[i] = sqlite3_column_int(pStmt, 0);
234534 rc = sqlite3_reset(pStmt);
234550 sqlite3_finalize(pStmt);
234892 sqlite3_stmt *pStmt = 0;
234895 rc = sessionPrepareDfltStmt(pSession->db, pTab, &pStmt);
234896 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
234902 sessionUpdateOneChange(pSession, &rc, pp, pTab->nCol, pStmt);
234909 rc = sqlite3_finalize(pStmt);
235348 sqlite3_stmt *pStmt;
235358 *ppVal = sqlite3_column_value(p->pStmt, iVal+p->nOldOff+p->bRowid);
235363 *ppVal = sqlite3_column_value(p->pStmt, iVal+p->bRowid);
235368 return (p->nOldOff ? p->nOldOff : sqlite3_column_count(p->pStmt)) - p->bRowid;
235477 sqlite3_stmt *pStmt;
235478 rc = sqlite3_prepare(pSession->db, zStmt, -1, &pStmt, 0);
235481 pDiffCtx->pStmt = pStmt;
235484 while( SQLITE_ROW==sqlite3_step(pStmt) ){
235485 i64 iRowid = (pTab->bRowid ? sqlite3_column_int64(pStmt, 0) : 0);
235488 rc = sqlite3_finalize(pStmt);
235540 sqlite3_stmt *pStmt;
235541 rc = sqlite3_prepare(pSession->db, zStmt, -1, &pStmt, 0);
235545 pDiffCtx->pStmt = pStmt;
235547 while( SQLITE_ROW==sqlite3_step(pStmt) ){
235548 i64 iRowid = (pTab->bRowid ? sqlite3_column_int64(pStmt, 0) : 0);
235551 rc = sqlite3_finalize(pStmt);
235966 ** in column iCol of the row that SQL statement pStmt currently points
235971 sqlite3_stmt *pStmt, /* Handle pointing to row containing value */
235976 int eType = sqlite3_column_type(pStmt, iCol);
235981 sqlite3_int64 i = sqlite3_column_int64(pStmt, iCol);
235984 double r = sqlite3_column_double(pStmt, iCol);
235993 z = (u8 *)sqlite3_column_blob(pStmt, iCol);
235995 z = (u8 *)sqlite3_column_text(pStmt, iCol);
235997 nByte = sqlite3_column_bytes(pStmt, iCol);
236033 sqlite3_stmt *pStmt, /* Statement handle pointing at new row */
236047 for(i=0; i<sqlite3_column_count(pStmt); i++){
236054 if( sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
236062 if( eType==sqlite3_column_type(pStmt, i) ){
236065 if( iVal==sqlite3_column_int64(pStmt, i) ) break;
236069 if( dVal==sqlite3_column_double(pStmt, i) ) break;
236081 if( eType==sqlite3_column_type(pStmt, i)
236082 && n==sqlite3_column_bytes(pStmt, i)
236083 && (n==0 || 0==memcmp(&pCsr[nHdr], sqlite3_column_blob(pStmt, i), n))
236107 sessionAppendCol(&buf2, pStmt, i, &rc);
237664 sqlite3_stmt *pStmt;
237751 sqlite3_finalize((*pp)->pStmt);
237813 rc = sqlite3_prepare_v2(p->db, zSql, buf.nBuf, &pUp->pStmt, 0);
237830 *ppStmt = pUp->pStmt;
237845 sqlite3_finalize(pUp->pStmt);
238015 sqlite3_stmt *pStmt, /* Statement to bind value to */
238030 return sqlite3_bind_value(pStmt, i, pVal);
238036 ** pStmt. The table being inserted into has nCol columns.
238039 ** statement pStmt. If parameter abPK is NULL, all values from 0 to (nCol-1)
238052 sqlite3_stmt *pStmt /* Bind values to this statement */
238072 rc = sessionBindValue(pStmt, i+1, pVal);
255626 sqlite3_stmt *pStmt = 0;
255627 fts5IndexPrepareStmt(p, &pStmt, sqlite3_mprintf(
255633 sqlite3_step(pStmt);
255634 rc = sqlite3_finalize(pStmt);
258547 sqlite3_stmt *pStmt = 0;
258554 fts5IndexPrepareStmt(p, &pStmt, sqlite3_mprintf(
258561 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
258565 const char *zIdxTerm = (const char*)sqlite3_column_blob(pStmt, 1);
258566 int nIdxTerm = sqlite3_column_bytes(pStmt, 1);
258567 int iIdxLeaf = sqlite3_column_int(pStmt, 2);
258568 int bIdxDlidx = sqlite3_column_int(pStmt, 3);
258680 rc2 = sqlite3_finalize(pStmt);
259784 ** pStmt:
259793 sqlite3_stmt *pStmt;
259833 sqlite3_stmt *pStmt; /* Statement used to read %_content */
260462 if( pCsr->pStmt ){
260464 sqlite3Fts5StorageStmtRelease(pTab->pStorage, eStmt, pCsr->pStmt);
260468 sqlite3_finalize(pSorter->pStmt);
260519 rc = sqlite3_step(pSorter->pStmt);
260531 pSorter->iRowid = sqlite3_column_int64(pSorter->pStmt, 0);
260532 nBlob = sqlite3_column_bytes(pSorter->pStmt, 1);
260533 aBlob = a = sqlite3_column_blob(pSorter->pStmt, 1);
260656 rc = sqlite3_step(pCsr->pStmt);
260660 rc = sqlite3_reset(pCsr->pStmt);
260735 rc = fts5PrepareStatement(&pSorter->pStmt, pConfig,
260752 sqlite3_finalize(pSorter->pStmt);
260837 sqlite3_stmt *pStmt = 0;
260839 SQLITE_PREPARE_PERSISTENT, &pStmt, 0);
260843 if( SQLITE_ROW==sqlite3_step(pStmt) ){
260845 pCsr->nRankArg = sqlite3_column_count(pStmt);
260851 pCsr->apRankArg[i] = sqlite3_column_value(pStmt, i);
260854 pCsr->pRankArgStmt = pStmt;
260856 rc = sqlite3_finalize(pStmt);
261104 assert( pCsr->pStmt==0 );
261255 pTab->pStorage, fts5StmtType(pCsr), &pCsr->pStmt, &pTab->p.base.zErrMsg
261260 sqlite3_bind_value(pCsr->pStmt, 1, pRowidEq);
261262 sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iFirstRowid);
261263 sqlite3_bind_int64(pCsr->pStmt, 2, pCsr->iLastRowid);
261298 return sqlite3_column_int64(pCsr->pStmt, 0);
261336 if( pCsr->pStmt==0 ){
261340 pTab->pStorage, eStmt, &pCsr->pStmt, (bErrormsg?&pTab->p.base.zErrMsg:0)
261349 sqlite3_reset(pCsr->pStmt);
261350 sqlite3_bind_int64(pCsr->pStmt, 1, fts5CursorRowid(pCsr));
261352 rc = sqlite3_step(pCsr->pStmt);
261358 rc = sqlite3_reset(pCsr->pStmt);
261861 ** Argument pStmt is an SQL statement of the type used by Fts5Cursor. This
261876 sqlite3_stmt *pStmt,
261881 sqlite3_value *pVal = sqlite3_column_value(pStmt, iCol+1);
261895 pLoc = (const char*)sqlite3_column_text(pStmt, iCol+1+pConfig->nCol);
261896 nLoc = sqlite3_column_bytes(pStmt, iCol+1+pConfig->nCol);
261922 rc = fts5TextFromStmt(pTab->pConfig, pCsr->pStmt, iCol, pz, pn);
261967 rc = fts5TextFromStmt(pConfig, pCsr->pStmt, i, &z, &n);
262160 rc = fts5TextFromStmt(pConfig, pCsr->pStmt, i, &z, &n);
262440 rc = fts5TextFromStmt(pConfig, pCsr->pStmt, iCol, &zDummy, &nDummy);
262712 sqlite3_value *pVal = sqlite3_column_value(pCsr->pStmt, iCol+1);
262719 rc = fts5TextFromStmt(pConfig, pCsr->pStmt, iCol, &z, &n);
264908 sqlite3_stmt *pStmt
264915 sqlite3_reset(pStmt);
264916 p->aStmt[eStmt] = pStmt;
264918 sqlite3_finalize(pStmt);
267731 sqlite3_stmt *pStmt; /* Statement holding lock on pIndex */
268012 sqlite3_stmt *pStmt = 0;
268026 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pStmt, 0);
268029 assert( rc==SQLITE_OK || pStmt==0 );
268033 if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
268034 i64 iId = sqlite3_column_int64(pStmt, 0);
268041 rc = sqlite3_finalize(pStmt);
268042 pStmt = 0;
268061 pCsr->pStmt = pStmt;
268065 sqlite3_finalize(pStmt);
268103 sqlite3_finalize(pCsr->pStmt);
Indexes created Tue Jun 23 00:25:03 UTC 2026