Lines Matching refs:pStmt
4593 SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);
4594 SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt);
4596 SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt);
4646 SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
4658 SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt);
4986 SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt);
5206 SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
5490 SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt);
5517 SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
6806 ** pStmt associated with the [database connection] pDb. ^If pStmt is NULL
6815 SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
10319 ** performance for pStmt. Advanced applications can use this
10346 sqlite3_stmt *pStmt, /* Prepared statement for which info desired */
52032 sqlite3_stmt *pStmt = 0;
52065 rc = zSql ? sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0) : SQLITE_NOMEM;
52068 rc = sqlite3_step(pStmt);
52072 sz = sqlite3_column_int64(pStmt, 0)*szPage;
52079 int nPage = sqlite3_column_int(pStmt, 0);
52096 sqlite3_finalize(pStmt);
52112 sqlite3_stmt *pStmt = 0;
52136 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
52142 rc = sqlite3_step(pStmt);
52166 sqlite3_finalize(pStmt);
87890 SQLITE_API int sqlite3_expired(sqlite3_stmt *pStmt){
87891 Vdbe *p = (Vdbe*)pStmt;
87961 SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt){
87963 if( pStmt==0 ){
87968 Vdbe *v = (Vdbe*)pStmt;
87990 SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt){
87992 if( pStmt==0 ){
87995 Vdbe *v = (Vdbe*)pStmt;
88011 SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
88014 Vdbe *p = (Vdbe*)pStmt;
88016 sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
88500 ** Execute the statement pStmt, either until a row of data is ready, the
88659 SQLITE_API int sqlite3_step(sqlite3_stmt *pStmt){
88661 Vdbe *v = (Vdbe*)pStmt; /* the prepared statement */
88710 sqlite3_reset(pStmt);
89004 ** Return the number of columns in the result set for the statement pStmt.
89006 SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt){
89007 Vdbe *pVm = (Vdbe *)pStmt;
89013 ** currently executing statement pStmt.
89015 SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt){
89016 Vdbe *pVm = (Vdbe *)pStmt;
89064 static Mem *columnMem(sqlite3_stmt *pStmt, int i){
89068 pVm = (Vdbe *)pStmt;
89086 ** code of statement pStmt set to SQLITE_NOMEM.
89099 static void columnMallocFailure(sqlite3_stmt *pStmt)
89106 Vdbe *p = (Vdbe *)pStmt;
89119 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
89121 val = sqlite3_value_blob( columnMem(pStmt,i) );
89126 columnMallocFailure(pStmt);
89129 SQLITE_API int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
89130 int val = sqlite3_value_bytes( columnMem(pStmt,i) );
89131 columnMallocFailure(pStmt);
89134 SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
89135 int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
89136 columnMallocFailure(pStmt);
89139 SQLITE_API double sqlite3_column_double(sqlite3_stmt *pStmt, int i){
89140 double val = sqlite3_value_double( columnMem(pStmt,i) );
89141 columnMallocFailure(pStmt);
89144 SQLITE_API int sqlite3_column_int(sqlite3_stmt *pStmt, int i){
89145 int val = sqlite3_value_int( columnMem(pStmt,i) );
89146 columnMallocFailure(pStmt);
89149 SQLITE_API sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){
89150 sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
89151 columnMallocFailure(pStmt);
89154 SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){
89155 const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
89156 columnMallocFailure(pStmt);
89159 SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
89160 Mem *pOut = columnMem(pStmt, i);
89165 columnMallocFailure(pStmt);
89169 SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
89170 const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
89171 columnMallocFailure(pStmt);
89175 SQLITE_API int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
89176 int iType = sqlite3_value_type( columnMem(pStmt,i) );
89177 columnMallocFailure(pStmt);
89182 ** Convert the N-th element of pStmt->pColName[] into a string using
89198 sqlite3_stmt *pStmt, /* The statement */
89208 if( pStmt==0 ){
89214 p = (Vdbe *)pStmt;
89217 n = sqlite3_column_count(pStmt);
89244 ** statement pStmt.
89246 SQLITE_API const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
89247 return columnName(pStmt, N, 0, COLNAME_NAME);
89250 SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
89251 return columnName(pStmt, N, 1, COLNAME_NAME);
89267 ** of the result set of SQL statement pStmt.
89269 SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
89270 return columnName(pStmt, N, 0, COLNAME_DECLTYPE);
89273 SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
89274 return columnName(pStmt, N, 1, COLNAME_DECLTYPE);
89285 SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){
89286 return columnName(pStmt, N, 0, COLNAME_DATABASE);
89289 SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
89290 return columnName(pStmt, N, 1, COLNAME_DATABASE);
89299 SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){
89300 return columnName(pStmt, N, 0, COLNAME_TABLE);
89303 SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
89304 return columnName(pStmt, N, 1, COLNAME_TABLE);
89313 SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){
89314 return columnName(pStmt, N, 0, COLNAME_COLUMN);
89317 SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
89318 return columnName(pStmt, N, 1, COLNAME_COLUMN);
89382 sqlite3_stmt *pStmt, /* The statement to bind against */
89389 Vdbe *p = (Vdbe *)pStmt;
89418 sqlite3_stmt *pStmt,
89427 return bindText(pStmt, i, zData, nData, xDel, 0);
89430 sqlite3_stmt *pStmt,
89437 return bindText(pStmt, i, zData, nData, xDel, 0);
89439 SQLITE_API int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
89441 Vdbe *p = (Vdbe *)pStmt;
89452 SQLITE_API int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
89454 Vdbe *p = (Vdbe *)pStmt;
89462 SQLITE_API int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
89464 Vdbe *p = (Vdbe*)pStmt;
89472 sqlite3_stmt *pStmt,
89479 Vdbe *p = (Vdbe*)pStmt;
89490 sqlite3_stmt *pStmt,
89496 return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
89499 sqlite3_stmt *pStmt,
89508 return bindText(pStmt, i, zData, nData, xDel, enc);
89512 sqlite3_stmt *pStmt,
89518 return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
89521 SQLITE_API int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
89525 rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
89530 rc = sqlite3_bind_double(pStmt, i,
89537 rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
89539 rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT);
89544 rc = bindText(pStmt,i, pValue->z, pValue->n, SQLITE_TRANSIENT,
89549 rc = sqlite3_bind_null(pStmt, i);
89555 SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
89557 Vdbe *p = (Vdbe *)pStmt;
89569 SQLITE_API int sqlite3_bind_zeroblob64(sqlite3_stmt *pStmt, int i, sqlite3_uint64 n){
89571 Vdbe *p = (Vdbe *)pStmt;
89577 rc = sqlite3_bind_zeroblob(pStmt, i, n);
89588 SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){
89589 Vdbe *p = (Vdbe*)pStmt;
89599 SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){
89600 Vdbe *p = (Vdbe*)pStmt;
89614 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
89615 return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
89672 SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){
89673 return pStmt ? ((Vdbe*)pStmt)->db : 0;
89680 SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt){
89681 return pStmt ? ((Vdbe*)pStmt)->readOnly : 1;
89688 SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt){
89689 return pStmt ? ((Vdbe*)pStmt)->explain : 0;
89695 SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt *pStmt){
89696 Vdbe *v = (Vdbe*)pStmt;
89701 ** Return a pointer to the next prepared statement after pStmt associated
89702 ** with database connection pDb. If pStmt is NULL, return the first
89706 SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){
89715 if( pStmt==0 ){
89718 pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pVNext;
89727 SQLITE_API int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
89728 Vdbe *pVdbe = (Vdbe*)pStmt;
89731 if( !pStmt
89759 SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt){
89760 Vdbe *p = (Vdbe *)pStmt;
89773 SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt){
89778 const char *zSql = sqlite3_sql(pStmt);
89780 Vdbe *p = (Vdbe *)pStmt;
89793 SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt){
89794 Vdbe *p = (Vdbe *)pStmt;
90007 ** Return status data for a single loop within query pStmt.
90010 sqlite3_stmt *pStmt, /* Prepared statement being queried */
90015 Vdbe *p = (Vdbe*)pStmt;
90068 SQLITE_API void sqlite3_stmt_scanstatus_reset(sqlite3_stmt *pStmt){
90069 Vdbe *p = (Vdbe*)pStmt;
99287 sqlite3_stmt *pStmt; /* Statement holding cursor open */
99314 Vdbe *v = (Vdbe *)p->pStmt;
99331 rc = sqlite3_step(p->pStmt);
99346 sqlite3_finalize(p->pStmt);
99347 p->pStmt = 0;
99358 }else if( p->pStmt ){
99359 rc = sqlite3_finalize(p->pStmt);
99360 p->pStmt = 0;
99503 pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(&sParse);
99504 assert( pBlob->pStmt || db->mallocFailed );
99505 if( pBlob->pStmt ){
99532 Vdbe *v = (Vdbe *)pBlob->pStmt;
99599 if( pBlob && pBlob->pStmt ) sqlite3VdbeFinalize((Vdbe *)pBlob->pStmt);
99620 sqlite3_stmt *pStmt = p->pStmt;
99625 rc = sqlite3_finalize(pStmt);
99650 v = (Vdbe*)p->pStmt;
99696 p->pStmt = 0;
99729 return (p && p->pStmt) ? p->nByte : 0;
99751 if( p->pStmt==0 ){
99758 ((Vdbe*)p->pStmt)->rc = SQLITE_OK;
99768 assert( rc==SQLITE_OK || p->pStmt==0 );
102579 sqlite3_stmt *pStmt; /* The statement whose bytecode is displayed */
102582 int needFinalize; /* Cursors owns pStmt and must finalize it */
102675 sqlite3_finalize(pCur->pStmt);
102677 pCur->pStmt = 0;
102712 (Vdbe*)pCur->pStmt,
102877 rc = sqlite3_prepare_v2(pVTab->db, zSql, -1, &pCur->pStmt, 0);
102881 pCur->pStmt = (sqlite3_stmt*)sqlite3_value_pointer(argv[0],"stmt-pointer");
102883 if( pCur->pStmt==0 ){
116321 sqlite3_stmt *pStmt = 0; /* An SQL statement being run */
116331 rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
116335 while( sqlite3_step(pStmt)==SQLITE_ROW ){
116345 zIndex = (char *)sqlite3_column_text(pStmt, 0);
116347 nSample = sqlite3_column_int(pStmt, 1);
116364 sqlite3_finalize(pStmt);
116377 rc = sqlite3_finalize(pStmt);
116384 rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
116388 while( sqlite3_step(pStmt)==SQLITE_ROW ){
116393 zIndex = (char *)sqlite3_column_text(pStmt, 0);
116405 decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0);
116406 decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0);
116407 decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0);
116415 pSample->n = sqlite3_column_bytes(pStmt, 4);
116418 sqlite3_finalize(pStmt);
116422 memcpy(pSample->p, sqlite3_column_blob(pStmt, 4), pSample->n);
116426 rc = sqlite3_finalize(pStmt);
131802 sqlite3_stmt *pStmt = 0; /* The current SQL statement */
131815 pStmt = 0;
131816 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
131817 assert( rc==SQLITE_OK || pStmt==0 );
131821 if( !pStmt ){
131830 rc = sqlite3_step(pStmt);
131837 nCol = sqlite3_column_count(pStmt);
131843 azCols[i] = (char *)sqlite3_column_name(pStmt, i);
131853 azVals[i] = (char *)sqlite3_column_text(pStmt, i);
131854 if( !azVals[i] && sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
131866 sqlite3VdbeFinalize((Vdbe *)pStmt);
131867 pStmt = 0;
131874 rc = sqlite3VdbeFinalize((Vdbe *)pStmt);
131875 pStmt = 0;
131887 if( pStmt ) sqlite3VdbeFinalize((Vdbe *)pStmt);
131984 int (*column_count)(sqlite3_stmt*pStmt);
132018 int (*data_count)(sqlite3_stmt*pStmt);
132027 int (*finalize)(sqlite3_stmt*pStmt);
132047 int (*reset)(sqlite3_stmt*pStmt);
137272 sqlite3_stmt *pStmt;
137286 pStmt = 0;
137287 TESTONLY(rcp = ) sqlite3Prepare(db, argv[4], -1, 0, 0, &pStmt, 0);
137305 sqlite3_finalize(pStmt);
149543 sqlite3_stmt *pStmt;
149547 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
149549 while( SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){
149550 const char *zSubSql = (const char*)sqlite3_column_text(pStmt,0);
149569 (void)sqlite3_finalize(pStmt);
179608 u8 isRequireSeek; /* True if must seek pStmt to %_content row */
179609 u8 bSeekStmt; /* True if pStmt is a seek */
179610 sqlite3_stmt *pStmt; /* Prepared statement in use by the cursor */
180398 sqlite3_stmt *pStmt; /* Compiled "PRAGMA %Q.page_size" statement */
180404 rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
180406 sqlite3_step(pStmt);
180407 p->nPgsz = sqlite3_column_int(pStmt, 0);
180408 rc = sqlite3_finalize(pStmt);
180749 sqlite3_stmt *pStmt = 0; /* Compiled version of zSql */
180755 rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
180771 nCol = sqlite3_column_count(pStmt);
180773 const char *zCol = sqlite3_column_name(pStmt, i);
180784 const char *zCol = sqlite3_column_name(pStmt, i);
180791 sqlite3_finalize(pStmt);
181399 ** Finalize the statement handle at pCsr->pStmt.
181409 p->pSeekStmt = pCsr->pStmt;
181410 sqlite3_reset(pCsr->pStmt);
181411 pCsr->pStmt = 0;
181415 sqlite3_finalize(pCsr->pStmt);
181445 ** If pCsr->pStmt has not been prepared (i.e. if pCsr->pStmt==0), then
181450 ** (or the equivalent for a content=xxx table) and set pCsr->pStmt to
181455 if( pCsr->pStmt==0 ){
181459 pCsr->pStmt = p->pSeekStmt;
181466 p->db, zSql,-1,SQLITE_PREPARE_PERSISTENT,&pCsr->pStmt,0
181477 ** Position the pCsr->pStmt statement so that it is on the row
181488 sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iPrevId);
181490 if( SQLITE_ROW==sqlite3_step(pCsr->pStmt) ){
181495 rc = sqlite3_reset(pCsr->pStmt);
182619 sqlite3_stmt *pStmt = 0; /* Statement to iterate through segments */
182638 rc = sqlite3Fts3AllSegdirs(p, iLangid, iIndex, iLevel, &pStmt);
182641 while( rc==SQLITE_OK && SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){
182645 sqlite3_int64 iStartBlock = sqlite3_column_int64(pStmt, 1);
182646 sqlite3_int64 iLeavesEndBlock = sqlite3_column_int64(pStmt, 2);
182647 sqlite3_int64 iEndBlock = sqlite3_column_int64(pStmt, 3);
182648 int nRoot = sqlite3_column_bytes(pStmt, 4);
182649 char const *zRoot = sqlite3_column_blob(pStmt, 4);
182671 rc2 = sqlite3_reset(pStmt);
182893 if( SQLITE_ROW!=sqlite3_step(pCsr->pStmt) ){
182895 rc = sqlite3_reset(pCsr->pStmt);
182897 pCsr->iPrevId = sqlite3_column_int64(pCsr->pStmt, 0);
183038 p->db,zSql,-1,SQLITE_PREPARE_PERSISTENT,&pCsr->pStmt,0
183048 rc = sqlite3_bind_value(pCsr->pStmt, 1, pCons);
183131 if( rc==SQLITE_OK && sqlite3_data_count(pCsr->pStmt)-1>iCol ){
183132 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
184591 sqlite3_stmt *pStmt;
184597 rc = sqlite3Fts3SelectDoctotal(p, &pStmt);
184599 a = sqlite3_column_blob(pStmt, 0);
184602 pEnd = &a[sqlite3_column_bytes(pStmt, 0)];
184609 sqlite3_reset(pStmt);
184616 rc = sqlite3_reset(pStmt);
185303 sqlite3_reset(pCsr->pStmt);
185305 assert( sqlite3_data_count(pCsr->pStmt)==0 );
185460 if( pCsr->isRequireSeek==0 ) sqlite3_reset(pCsr->pStmt);
185461 assert( sqlite3_data_count(pCsr->pStmt)==0 );
189025 sqlite3_stmt *pStmt;
189028 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
189033 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
189034 sqlite3_bind_blob(pStmt, 2, &p, sizeof(p), SQLITE_STATIC);
189035 sqlite3_step(pStmt);
189037 return sqlite3_finalize(pStmt);
189048 sqlite3_stmt *pStmt;
189052 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
189057 sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
189058 if( SQLITE_ROW==sqlite3_step(pStmt) ){
189059 if( sqlite3_column_type(pStmt, 0)==SQLITE_BLOB
189060 && sqlite3_column_bytes(pStmt, 0)==sizeof(*pp)
189062 memcpy((void *)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
189066 return sqlite3_finalize(pStmt);
190281 sqlite3_stmt *pStmt;
190286 pStmt = p->aStmt[eStmt];
190287 if( !pStmt ){
190301 rc = sqlite3_prepare_v3(p->db, zSql, -1, f, &pStmt, NULL);
190303 assert( rc==SQLITE_OK || pStmt==0 );
190304 p->aStmt[eStmt] = pStmt;
190309 int nParam = sqlite3_bind_parameter_count(pStmt);
190311 rc = sqlite3_bind_value(pStmt, i+1, apVal[i]);
190314 *pp = pStmt;
190324 sqlite3_stmt *pStmt = 0; /* Statement requested from fts3SqlStmt() */
190327 rc = fts3SqlStmt(pTab, SQL_SELECT_DOCSIZE, &pStmt, 0);
190329 sqlite3_bind_int64(pStmt, 1, iDocid);
190330 rc = sqlite3_step(pStmt);
190331 if( rc!=SQLITE_ROW || sqlite3_column_type(pStmt, 0)!=SQLITE_BLOB ){
190332 rc = sqlite3_reset(pStmt);
190334 pStmt = 0;
190340 *ppStmt = pStmt;
190348 sqlite3_stmt *pStmt = 0;
190350 rc = fts3SqlStmt(pTab, SQL_SELECT_STAT, &pStmt, 0);
190352 sqlite3_bind_int(pStmt, 1, FTS_STAT_DOCTOTAL);
190353 if( sqlite3_step(pStmt)!=SQLITE_ROW
190354 || sqlite3_column_type(pStmt, 0)!=SQLITE_BLOB
190356 rc = sqlite3_reset(pStmt);
190358 pStmt = 0;
190361 *ppStmt = pStmt;
190387 sqlite3_stmt *pStmt;
190390 rc = fts3SqlStmt(p, eStmt, &pStmt, apVal);
190392 sqlite3_step(pStmt);
190393 rc = sqlite3_reset(pStmt);
190417 sqlite3_stmt *pStmt;
190418 rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_LEVEL, &pStmt, 0);
190420 sqlite3_bind_null(pStmt, 1);
190421 sqlite3_step(pStmt);
190422 rc = sqlite3_reset(pStmt);
190492 sqlite3_stmt *pStmt = 0;
190500 rc = fts3SqlStmt(p, SQL_SELECT_LEVEL_RANGE, &pStmt, 0);
190502 sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex, 0));
190503 sqlite3_bind_int64(pStmt, 2,
190509 rc = fts3SqlStmt(p, SQL_SELECT_LEVEL, &pStmt, 0);
190511 sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex,iLevel));
190514 *ppStmt = pStmt;
191817 sqlite3_stmt *pStmt;
191818 int rc = fts3SqlStmt(p, SQL_INSERT_SEGMENTS, &pStmt, 0);
191820 sqlite3_bind_int64(pStmt, 1, iBlock);
191821 sqlite3_bind_blob(pStmt, 2, z, n, SQLITE_STATIC);
191822 sqlite3_step(pStmt);
191823 rc = sqlite3_reset(pStmt);
191824 sqlite3_bind_null(pStmt, 2);
191837 sqlite3_stmt *pStmt = 0;
191839 rc = fts3SqlStmt(p, SQL_SELECT_MXLEVEL, &pStmt, 0);
191841 if( SQLITE_ROW==sqlite3_step(pStmt) ){
191842 mxLevel = sqlite3_column_int(pStmt, 0);
191844 rc = sqlite3_reset(pStmt);
191864 sqlite3_stmt *pStmt;
191865 int rc = fts3SqlStmt(p, SQL_INSERT_SEGDIR, &pStmt, 0);
191867 sqlite3_bind_int64(pStmt, 1, iLevel);
191868 sqlite3_bind_int(pStmt, 2, iIdx);
191869 sqlite3_bind_int64(pStmt, 3, iStartBlock);
191870 sqlite3_bind_int64(pStmt, 4, iLeafEndBlock);
191872 sqlite3_bind_int64(pStmt, 5, iEndBlock);
191876 sqlite3_bind_text(pStmt, 5, zEnd, -1, sqlite3_free);
191878 sqlite3_bind_blob(pStmt, 6, zRoot, nRoot, SQLITE_STATIC);
191879 sqlite3_step(pStmt);
191880 rc = sqlite3_reset(pStmt);
191881 sqlite3_bind_null(pStmt, 6);
192138 sqlite3_stmt *pStmt;
192152 rc = fts3SqlStmt(p, SQL_NEXT_SEGMENTS_ID, &pStmt, 0);
192154 if( SQLITE_ROW==sqlite3_step(pStmt) ){
192155 pWriter->iFree = sqlite3_column_int64(pStmt, 0);
192158 rc = sqlite3_reset(pStmt);
192328 sqlite3_stmt *pStmt;
192335 rc = fts3SqlStmt(p, SQL_IS_EMPTY, &pStmt, &pRowid);
192337 if( SQLITE_ROW==sqlite3_step(pStmt) ){
192338 *pisEmpty = sqlite3_column_int(pStmt, 0);
192340 rc = sqlite3_reset(pStmt);
192360 sqlite3_stmt *pStmt;
192364 /* Set pStmt to the compiled version of:
192370 rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR_MAX_LEVEL, &pStmt, 0);
192372 sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex, 0));
192373 sqlite3_bind_int64(pStmt, 2,
192376 if( SQLITE_ROW==sqlite3_step(pStmt) ){
192377 *pnMax = sqlite3_column_int64(pStmt, 0);
192379 return sqlite3_reset(pStmt);
192392 /* Set pStmt to the compiled version of:
192398 sqlite3_stmt *pStmt;
192399 int rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR_MAX_LEVEL, &pStmt, 0);
192401 sqlite3_bind_int64(pStmt, 1, iAbsLevel+1);
192402 sqlite3_bind_int64(pStmt, 2,
192407 if( SQLITE_ROW==sqlite3_step(pStmt) ){
192408 *pbMax = sqlite3_column_type(pStmt, 0)==SQLITE_NULL;
192410 return sqlite3_reset(pStmt);
192972 sqlite3_stmt *pStmt,
192977 const unsigned char *zText = sqlite3_column_text(pStmt, iCol);
193221 sqlite3_stmt *pStmt = 0;
193222 rc = fts3SqlStmt(p, SQL_SELECT_STAT, &pStmt, 0);
193224 sqlite3_bind_int(pStmt, 1, FTS_STAT_AUTOINCRMERGE);
193225 rc = sqlite3_step(pStmt);
193227 p->nAutoincrmerge = sqlite3_column_int(pStmt, 0);
193232 rc = sqlite3_reset(pStmt);
193287 sqlite3_stmt *pStmt; /* Statement used to insert the encoding */
193297 rc = fts3SqlStmt(p, SQL_REPLACE_DOCSIZE, &pStmt, 0);
193303 sqlite3_bind_int64(pStmt, 1, p->iPrevDocid);
193304 sqlite3_bind_blob(pStmt, 2, pBlob, nBlob, sqlite3_free);
193305 sqlite3_step(pStmt);
193306 *pRC = sqlite3_reset(pStmt);
193334 sqlite3_stmt *pStmt; /* Statement for reading and writing */
193347 rc = fts3SqlStmt(p, SQL_SELECT_STAT, &pStmt, 0);
193353 sqlite3_bind_int(pStmt, 1, FTS_STAT_DOCTOTAL);
193354 if( sqlite3_step(pStmt)==SQLITE_ROW ){
193356 sqlite3_column_blob(pStmt, 0),
193357 sqlite3_column_bytes(pStmt, 0));
193361 rc = sqlite3_reset(pStmt);
193382 rc = fts3SqlStmt(p, SQL_REPLACE_STAT, &pStmt, 0);
193388 sqlite3_bind_int(pStmt, 1, FTS_STAT_DOCTOTAL);
193389 sqlite3_bind_blob(pStmt, 2, pBlob, nBlob, SQLITE_STATIC);
193390 sqlite3_step(pStmt);
193391 *pRC = sqlite3_reset(pStmt);
193392 sqlite3_bind_null(pStmt, 2);
193451 sqlite3_stmt *pStmt = 0;
193459 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
193475 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
193477 int iLangid = langidFromSelect(p, pStmt);
193478 rc = fts3PendingTermsDocid(p, 0, iLangid, sqlite3_column_int64(pStmt, 0));
193482 const char *z = (const char *) sqlite3_column_text(pStmt, iCol+1);
193484 aSz[p->nColumn] += sqlite3_column_bytes(pStmt, iCol+1);
193491 sqlite3_finalize(pStmt);
193492 pStmt = 0;
193505 if( pStmt ){
193506 int rc2 = sqlite3_finalize(pStmt);
193530 sqlite3_stmt *pStmt = 0; /* Statement used to read %_segdir entry */
193542 rc = fts3SqlStmt(p, SQL_SELECT_LEVEL, &pStmt, 0);
193547 sqlite3_bind_int64(pStmt, 1, iAbsLevel);
193549 for(i=0; rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW && i<nSeg; i++){
193551 sqlite3_column_int64(pStmt, 1), /* segdir.start_block */
193552 sqlite3_column_int64(pStmt, 2), /* segdir.leaves_end_block */
193553 sqlite3_column_int64(pStmt, 3), /* segdir.end_block */
193554 sqlite3_column_blob(pStmt, 4), /* segdir.root */
193555 sqlite3_column_bytes(pStmt, 4), /* segdir.root */
193560 rc2 = sqlite3_reset(pStmt);
195041 sqlite3_stmt *pStmt = 0;
195051 rc = fts3SqlStmt(p, SQL_REPLACE_STAT, &pStmt, 0);
195053 sqlite3_bind_int(pStmt, 1, FTS_STAT_AUTOINCRMERGE);
195054 sqlite3_bind_int(pStmt, 2, p->nAutoincrmerge);
195055 sqlite3_step(pStmt);
195056 rc = sqlite3_reset(pStmt);
195198 sqlite3_stmt *pStmt = 0;
195205 rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
195209 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
195210 i64 iDocid = sqlite3_column_int64(pStmt, 0);
195211 int iLang = langidFromSelect(p, pStmt);
195216 const char *zText = (const char *)sqlite3_column_text(pStmt, iCol+1);
195247 sqlite3_finalize(pStmt);
195392 iDocid = sqlite3_column_int64(pCsr->pStmt, 0);
195396 const char *zText = (const char *)sqlite3_column_text(pCsr->pStmt, i+1);
196446 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol);
196448 if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){
196453 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol);
196750 sqlite3_stmt *pStmt;
196761 pStmt = *ppStmt;
196762 assert( sqlite3_data_count(pStmt)==1 );
196764 n = sqlite3_column_bytes(pStmt, 0);
196765 a = sqlite3_column_blob(pStmt, 0);
197353 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1);
197354 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
197356 if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){
202042 sqlite3_stmt *pStmt;
202057 pStmt = pCsr->pReadAux;
202060 pCsr->pReadAux = pStmt;
204127 sqlite3_stmt *pStmt = 0;
204134 rc = sqlite3_prepare_v2(pRtree->db, zSql, -1, &pStmt, 0);
204142 const char *zCol = sqlite3_column_name(pStmt, 0);
204147 const char *zCol1 = sqlite3_column_name(pStmt, iCol);
204148 const char *zCol2 = sqlite3_column_name(pStmt, iCol+1);
204155 sqlite3_finalize(pStmt);
204589 sqlite3_stmt *pStmt = 0;
204590 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
204592 if( SQLITE_ROW==sqlite3_step(pStmt) ){
204593 *piVal = sqlite3_column_int(pStmt, 0);
204595 rc = sqlite3_finalize(pStmt);
204902 ** Reset SQL statement pStmt. If the sqlite3_reset() call returns an error,
204905 static void rtreeCheckReset(RtreeCheck *pCheck, sqlite3_stmt *pStmt){
204906 int rc = sqlite3_reset(pStmt);
205032 sqlite3_stmt *pStmt;
205046 pStmt = pCheck->aCheckMapping[bLeaf];
205047 sqlite3_bind_int64(pStmt, 1, iKey);
205048 rc = sqlite3_step(pStmt);
205054 i64 ii = sqlite3_column_int64(pStmt, 0);
205062 rtreeCheckReset(pCheck, pStmt);
205217 sqlite3_stmt *pStmt = 0; /* Used to find column count of rtree table */
205237 pStmt = rtreeCheckPrepare(&check, "SELECT * FROM %Q.'%q_rowid'", zDb, zTab);
205238 if( pStmt ){
205239 nAux = sqlite3_column_count(pStmt) - 2;
205240 sqlite3_finalize(pStmt);
205248 pStmt = rtreeCheckPrepare(&check, "SELECT * FROM %Q.%Q", zDb, zTab);
205249 if( pStmt ){
205251 check.nDim = (sqlite3_column_count(pStmt) - 1 - nAux) / 2;
205254 }else if( SQLITE_ROW==sqlite3_step(pStmt) ){
205255 check.bInt = (sqlite3_column_type(pStmt, 1)==SQLITE_INTEGER);
205257 rc = sqlite3_finalize(pStmt);
209560 static int resetAndCollectError(sqlite3_stmt *pStmt, char **pzErrmsg){
209561 int rc = sqlite3_reset(pStmt);
209563 *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(sqlite3_db_handle(pStmt)));
209946 static void rbuFinalize(sqlite3rbu *p, sqlite3_stmt *pStmt){
209947 sqlite3 *db = sqlite3_db_handle(pStmt);
209948 int rc = sqlite3_finalize(pStmt);
210136 sqlite3_stmt *pStmt = 0;
210161 p->rc = prepareFreeAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
210165 nCol = sqlite3_column_count(pStmt);
210169 const char *zName = (const char*)sqlite3_column_name(pStmt, i);
210179 sqlite3_finalize(pStmt);
210180 pStmt = 0;
210197 p->rc = prepareFreeAndCollectError(p->dbMain, &pStmt, &p->zErrmsg,
210201 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
210202 const char *zName = (const char*)sqlite3_column_text(pStmt, 1);
210213 int iPk = sqlite3_column_int(pStmt, 5);
210214 int bNotNull = sqlite3_column_int(pStmt, 3);
210215 const char *zType = (const char*)sqlite3_column_text(pStmt, 2);
210230 rbuFinalize(p, pStmt);
211028 sqlite3_stmt *pStmt = 0;
211035 rc = prepareAndCollectError(p->dbMain, &pStmt, &p->zErrmsg,
211041 rc = sqlite3_bind_text(pStmt, 1, pIter->zIdx, -1, SQLITE_STATIC);
211042 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
211043 char *zSql = (char*)sqlite3_column_text(pStmt, 0);
211114 rc2 = sqlite3_finalize(pStmt);
211503 sqlite3_stmt *pStmt = 0;
211510 rc = prepareFreeAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
211513 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
211514 switch( sqlite3_column_int(pStmt, 0) ){
211516 pRet->eStage = sqlite3_column_int(pStmt, 1);
211526 pRet->zTbl = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc);
211530 pRet->zIdx = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc);
211534 pRet->nRow = sqlite3_column_int(pStmt, 1);
211538 pRet->nProgress = sqlite3_column_int64(pStmt, 1);
211542 pRet->iWalCksum = sqlite3_column_int64(pStmt, 1);
211546 pRet->iCookie = (u32)sqlite3_column_int64(pStmt, 1);
211550 pRet->iOalSz = sqlite3_column_int64(pStmt, 1);
211554 pRet->nPhaseOneStep = sqlite3_column_int64(pStmt, 1);
211558 pRet->zDataTbl = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc);
211566 rc2 = sqlite3_finalize(pStmt);
212134 ** Assert that column iCol of statement pStmt is named zName.
212136 static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
212137 const char *zCol = sqlite3_column_name(pStmt, iCol);
212301 sqlite3_stmt *pStmt;
212303 p->rc = prepareAndCollectError(dbread, &pStmt, &p->zErrmsg,
212312 if( SQLITE_ROW==sqlite3_step(pStmt) ){
212313 iCookie = sqlite3_column_int(pStmt, 0);
212315 rbuFinalize(p, pStmt);
212693 sqlite3_stmt *pStmt = 0;
212700 rc = prepareFreeAndCollectError(db, &pStmt, &zErrmsg,
212708 if( SQLITE_ROW==sqlite3_step(pStmt) ){
212709 nIndex = sqlite3_column_int(pStmt, 0);
212711 rc = sqlite3_finalize(pStmt);
212739 sqlite3_stmt *pStmt = 0;
212751 p->rc = prepareAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
212756 if( SQLITE_ROW==sqlite3_step(pStmt) ){
212759 p->rc = sqlite3_finalize(pStmt);
212763 p->rc = prepareAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
212768 if( SQLITE_ROW==sqlite3_step(pStmt) ){
212769 p->nPhaseOneStep = sqlite3_column_int64(pStmt, 0);
212771 p->rc = sqlite3_finalize(pStmt);
214304 sqlite3_stmt *pStmt; /* Iterates through set of root pages */
214305 u8 isEof; /* After pStmt has returned SQLITE_DONE */
214519 sqlite3_reset(pCsr->pStmt);
214542 sqlite3_finalize(pCsr->pStmt);
214767 rc = sqlite3_step(pCsr->pStmt);
214770 u32 iRoot = (u32)sqlite3_column_int64(pCsr->pStmt, 1);
214774 return sqlite3_reset(pCsr->pStmt);
214787 return sqlite3_reset(pCsr->pStmt);
214812 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
214864 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
214930 sqlite3_finalize(pCsr->pStmt);
214931 pCsr->pStmt = 0;
214972 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pStmt, 0);
216518 sqlite3_stmt *pStmt;
216560 rc = sqlite3_prepare_v2(db, zPragma, -1, &pStmt, 0);
216571 while( SQLITE_ROW==sqlite3_step(pStmt) ){
216572 nByte += sqlite3_column_bytes(pStmt, 1);
216575 rc = sqlite3_reset(pStmt);
216596 while( SQLITE_ROW==sqlite3_step(pStmt) ){
216597 int nName = sqlite3_column_bytes(pStmt, 1);
216598 const unsigned char *zName = sqlite3_column_text(pStmt, 1);
216603 abPK[i] = sqlite3_column_int(pStmt, 5);
216606 rc = sqlite3_reset(pStmt);
216624 sqlite3_finalize(pStmt);
217071 sqlite3_stmt *pStmt;
217080 *ppVal = sqlite3_column_value(p->pStmt, iVal+p->nOldOff);
217085 *ppVal = sqlite3_column_value(p->pStmt, iVal);
217090 return p->nOldOff ? p->nOldOff : sqlite3_column_count(p->pStmt);
217195 sqlite3_stmt *pStmt;
217196 rc = sqlite3_prepare(pSession->db, zStmt, -1, &pStmt, 0);
217199 pDiffCtx->pStmt = pStmt;
217201 while( SQLITE_ROW==sqlite3_step(pStmt) ){
217204 rc = sqlite3_finalize(pStmt);
217233 sqlite3_stmt *pStmt;
217234 rc = sqlite3_prepare(pSession->db, zStmt, -1, &pStmt, 0);
217238 pDiffCtx->pStmt = pStmt;
217240 while( SQLITE_ROW==sqlite3_step(pStmt) ){
217243 rc = sqlite3_finalize(pStmt);
217684 ** in column iCol of the row that SQL statement pStmt currently points
217689 sqlite3_stmt *pStmt, /* Handle pointing to row containing value */
217694 int eType = sqlite3_column_type(pStmt, iCol);
217700 i = sqlite3_column_int64(pStmt, iCol);
217702 double r = sqlite3_column_double(pStmt, iCol);
217712 z = (u8 *)sqlite3_column_blob(pStmt, iCol);
217714 z = (u8 *)sqlite3_column_text(pStmt, iCol);
217716 nByte = sqlite3_column_bytes(pStmt, iCol);
217752 sqlite3_stmt *pStmt, /* Statement handle pointing at new row */
217766 for(i=0; i<sqlite3_column_count(pStmt); i++){
217773 if( sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
217781 if( eType==sqlite3_column_type(pStmt, i) ){
217784 if( iVal==sqlite3_column_int64(pStmt, i) ) break;
217788 if( dVal==sqlite3_column_double(pStmt, i) ) break;
217800 if( eType==sqlite3_column_type(pStmt, i)
217801 && n==sqlite3_column_bytes(pStmt, i)
217802 && (n==0 || 0==memcmp(&pCsr[nHdr], sqlite3_column_blob(pStmt, i), n))
217826 sessionAppendCol(&buf2, pStmt, i, &rc);
219279 sqlite3_stmt *pStmt;
219363 sqlite3_finalize((*pp)->pStmt);
219425 rc = sqlite3_prepare_v2(p->db, zSql, buf.nBuf, &pUp->pStmt, 0);
219442 *ppStmt = pUp->pStmt;
219457 sqlite3_finalize(pUp->pStmt);
219629 sqlite3_stmt *pStmt, /* Statement to bind value to */
219644 return sqlite3_bind_value(pStmt, i, pVal);
219650 ** pStmt. The table being inserted into has nCol columns.
219653 ** statement pStmt. If parameter abPK is NULL, all values from 0 to (nCol-1)
219666 sqlite3_stmt *pStmt /* Bind values to this statement */
219686 rc = sessionBindValue(pStmt, i+1, pVal);
236091 sqlite3_stmt *pStmt = 0;
236098 fts5IndexPrepareStmt(p, &pStmt, sqlite3_mprintf(
236105 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
236109 const char *zIdxTerm = (const char*)sqlite3_column_blob(pStmt, 1);
236110 int nIdxTerm = sqlite3_column_bytes(pStmt, 1);
236111 int iIdxLeaf = sqlite3_column_int(pStmt, 2);
236112 int bIdxDlidx = sqlite3_column_int(pStmt, 3);
236209 rc2 = sqlite3_finalize(pStmt);
236959 ** pStmt:
236968 sqlite3_stmt *pStmt;
237006 sqlite3_stmt *pStmt; /* Statement used to read %_content */
237575 if( pCsr->pStmt ){
237577 sqlite3Fts5StorageStmtRelease(pTab->pStorage, eStmt, pCsr->pStmt);
237581 sqlite3_finalize(pSorter->pStmt);
237632 rc = sqlite3_step(pSorter->pStmt);
237644 pSorter->iRowid = sqlite3_column_int64(pSorter->pStmt, 0);
237645 nBlob = sqlite3_column_bytes(pSorter->pStmt, 1);
237646 aBlob = a = sqlite3_column_blob(pSorter->pStmt, 1);
237757 rc = sqlite3_step(pCsr->pStmt);
237761 rc = sqlite3_reset(pCsr->pStmt);
237835 rc = fts5PrepareStatement(&pSorter->pStmt, pConfig,
237852 sqlite3_finalize(pSorter->pStmt);
237935 sqlite3_stmt *pStmt = 0;
237937 SQLITE_PREPARE_PERSISTENT, &pStmt, 0);
237941 if( SQLITE_ROW==sqlite3_step(pStmt) ){
237943 pCsr->nRankArg = sqlite3_column_count(pStmt);
237949 pCsr->apRankArg[i] = sqlite3_column_value(pStmt, i);
237952 pCsr->pRankArgStmt = pStmt;
237954 rc = sqlite3_finalize(pStmt);
238068 assert( pCsr->pStmt==0 );
238202 pTab->pStorage, fts5StmtType(pCsr), &pCsr->pStmt, &pTab->p.base.zErrMsg
238207 sqlite3_bind_value(pCsr->pStmt, 1, pRowidEq);
238209 sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iFirstRowid);
238210 sqlite3_bind_int64(pCsr->pStmt, 2, pCsr->iLastRowid);
238269 *pRowid = sqlite3_column_int64(pCsr->pStmt, 0);
238287 if( pCsr->pStmt==0 ){
238291 pTab->pStorage, eStmt, &pCsr->pStmt, (bErrormsg?&pTab->p.base.zErrMsg:0)
238300 sqlite3_reset(pCsr->pStmt);
238301 sqlite3_bind_int64(pCsr->pStmt, 1, fts5CursorRowid(pCsr));
238303 rc = sqlite3_step(pCsr->pStmt);
238309 rc = sqlite3_reset(pCsr->pStmt);
238680 *pz = (const char*)sqlite3_column_text(pCsr->pStmt, iCol+1);
238681 *pn = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
239340 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
240778 sqlite3_stmt *pStmt
240785 sqlite3_reset(pStmt);
240786 p->aStmt[eStmt] = pStmt;
240788 sqlite3_finalize(pStmt);
243522 sqlite3_stmt *pStmt; /* Statement holding lock on pIndex */
243798 sqlite3_stmt *pStmt = 0;
243812 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pStmt, 0);
243815 assert( rc==SQLITE_OK || pStmt==0 );
243819 if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
243820 i64 iId = sqlite3_column_int64(pStmt, 0);
243827 rc = sqlite3_finalize(pStmt);
243828 pStmt = 0;
243847 pCsr->pStmt = pStmt;
243851 sqlite3_finalize(pStmt);
243878 sqlite3_finalize(pCsr->pStmt);