Lines Matching defs:busy

1347 ** to the connection's busy-handler callback. The argument is of type (void**)
1350 ** busy-handler, this function should be invoked with the second (void *) in
3031 ** KEYWORDS: {busy-handler callback} {busy handler}
3042 ** ^If the busy callback is NULL, then [SQLITE_BUSY]
3043 ** is returned immediately upon encountering the lock. ^If the busy callback
3046 ** ^The first argument to the busy handler is a copy of the void* pointer which
3048 ** the busy handler callback is the number of times that the busy handler has
3050 ** busy callback returns 0, then no additional attempts are made to
3056 ** The presence of a busy handler does not guarantee that it will be invoked
3057 ** when there is lock contention. ^If SQLite determines that invoking the busy
3060 ** busy handler.
3067 ** invoke the busy handlers, neither will make any progress. Therefore,
3072 ** ^The default busy callback is NULL.
3074 ** ^(There can only be a single busy handler defined for each
3075 ** [database connection]. Setting a new busy handler clears any
3078 ** busy handler and thus clear any previously set busy handler.
3080 ** The busy callback should not take any actions which modify the
3081 ** database connection that invoked the busy handler. In other words,
3082 ** the busy handler is not reentrant. Any such actions
3085 ** A busy handler must not close the database connection
3086 ** or [prepared statement] that invoked the busy handler.
3094 ** ^This routine sets a [sqlite3_busy_handler | busy handler] that sleeps
3102 ** turns off all busy handlers.
3104 ** ^(There can only be a single busy handler for a particular
3105 ** [database connection] at any given moment. If another busy handler
3107 ** this routine, that other busy handler is cleared.)^
9309 ** the [sqlite3_busy_handler | busy-handler function]
9311 ** busy-handler returns non-zero before the lock is available, then
9724 ** in the log were checkpointed. ^The [busy-handler callback]
9731 ** [sqlite3_busy_handler|busy-handler callback]) until there is no
9740 ** [busy-handler callback])
9765 ** busy-handler configured, it will not be invoked in this case.
9769 ** obtained immediately, and a busy-handler is configured, it is invoked and
9770 ** the writer lock retried until either the busy-handler returns 0 or the lock
9771 ** is successfully obtained. ^The busy-handler is also invoked while waiting for
9772 ** database readers as described above. ^If the busy-handler returns 0 before
10378 ** immediately and there is a busy-handler callback configured, it is invoked
14630 ** An instance of the following structure is used to store the busy-handler
14633 ** The sqlite.busyHandler member of the sqlite struct contains the busy
14635 ** handle is passed a pointer to sqlite.busyHandler. The busy-handler
14640 int (*xBusyHandler)(void *,int); /* The busy callback */
14641 void *pBusyArg; /* First arg to busy callback */
14642 int nBusy; /* Incremented with each busy call */
17050 u8 busy; /* TRUE if currently initializing */
39343 /* didn't get, must be busy */
44200 /* If the lock failed (busy):
55450 int (*xBusy)(void*), /* Function to call when busy */
56184 int (*xBusyHandler)(void*); /* Function to call when busy */
59202 ** Set the busy handler function.
59204 ** The pager invokes the busy-handler if sqlite3OsLock() returns
59207 ** lock. It does *not* invoke the busy handler when upgrading from
59218 ** If the busy-handler callback returns non-zero, the lock is
59224 int (*xBusyHandler)(void *), /* Pointer to busy-handler function */
59437 ** the busy callback if the lock is currently not available. Repeat
59438 ** until the busy callback returns false or until the attempt to
59449 ** already held), or one of the transitions that the busy-handler
61453 ** The busy-handler is not invoked if another connection already
61460 ** busy-handler callback can be used when upgrading to the EXCLUSIVE
65219 ** with a busy-timeout. Return 1 if blocking locks are successfully enabled,
65301 ** busy-handler function. Invoke it and retry the lock until either the
65302 ** lock is successfully obtained or the busy-handler returns 0.
65306 int (*xBusy)(void*), /* Function to call when busy */
65402 int (*xBusy)(void*), /* Function to call when busy */
65423 /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked
67222 ** If parameter xBusy is not NULL, it is a pointer to a busy-handler
67229 int (*xBusy)(void*), /* Function to call when busy */
67245 /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked
67253 ** enabled, set xBusy2=0 so that the busy-handler is never invoked. */
67262 ** EVIDENCE-OF: R-53820-33897 Even if there is a busy-handler configured,
67276 ** immediately, and a busy-handler is configured, it is invoked and the
67277 ** writer lock retried until either the busy-handler returns 0 or the
68128 #define BTCF_Pinned 0x40 /* Cursor is busy and cannot be moved */
71037 ** Invoke the busy handler for a btree.
72114 ** and the database was previously unlocked, then invoke the busy handler
72116 ** invoke the busy handler - just return SQLITE_BUSY. SQLITE_BUSY is
72123 ** no progress. By returning SQLITE_BUSY and not invoking the busy callback
84419 ** that the correct busy-handler callback is invoked if required.
85928 assert( v->db->init.busy==0 );
87928 assert( db->init.busy==0 );
88545 && !db->init.busy && p->zSql ){
89349 "bind on a busy prepared statement: [%s]", p->zSql);
97207 assert( db->init.busy==0 );
97208 db->init.busy = 1;
97221 db->init.busy = 0;
101491 ** skip it. If the first (pSorter->nTask-1) sub-tasks are all still busy,
103818 if( db->init.busy ) return 1; /* Always support for legacy schemas */
104797 else if( no_such_func && pParse->db->init.busy==0
117025 if( pFix->pParse->db->init.busy ){
117300 if( db->init.busy ) return SQLITE_OK;
117397 if( db->xAuth==0 || db->init.busy || IN_SPECIAL_PARSE ){
117617 if( db->init.busy ){
117650 if( pParse->nTableLock>0 && db->init.busy==0 ){
117682 if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, 1);
117913 if( (pParse->prepFlags & SQLITE_PREPARE_NO_VTAB)==0 && db->init.busy==0 ){
118471 if( db->init.busy ) {
118482 assert( db->init.iDb==0 || db->init.busy || IN_SPECIAL_PARSE
118529 if( db->init.busy ){
118700 if( db->init.busy && db->init.newTnum==1 ){
118766 assert( !db->init.busy || CORRUPT_DB );
118805 if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
119215 int isInit = db->init.busy && db->init.iDb!=1;
119898 assert( db->init.busy==0 );
120077 ** this is a temporary table or db->init.busy==1. When db->init.busy==1
120110 /* If the db->init.busy is 1 it means we are reading the SQL off the
120119 if( db->init.busy ){
120246 if( !db->init.busy ){
120389 if( db->init.busy ){
121437 if( !db->init.busy ){
121472 && db->init.busy==0
121515 if( !db->init.busy ){
121525 assert( !db->init.busy );
121701 if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
121823 if( db->init.busy ){
121919 if( db->init.busy || pTblName==0 ){
123413 u8 initbusy = db->init.busy;
133688 /* 50 */ "busy", /* Used by: wal_checkpoint */
136644 ** if one is set. If no busy handler or a different busy handler is set
137261 ** But because db->init.busy is set to 1, no VDBE code is generated
137275 assert( db->init.busy );
137361 db->init.busy = 1;
137503 assert( db->init.busy );
137567 db->init.busy = 0;
137586 assert( db->init.busy==0 );
137616 if( !db->init.busy ){
137923 if( db->init.busy==0 ){
137931 if( sParse.checkSchema && db->init.busy==0 ){
146516 if( db->init.busy && iDb!=1 ){
146527 if( db->init.busy==0 && pName2->n==0 && pTab
146565 assert( !db->init.busy );
146703 assert( !db->init.busy );
146712 if( !db->init.busy ){
146750 if( db->init.busy ){
150400 if( !db->init.busy ){
150769 ** schema. Nevertheless, defend against that (turn off db->init.busy)
150771 assert( db->init.busy==0 );
150772 initBusy = db->init.busy;
150773 db->init.busy = 0;
150822 db->init.busy = initBusy;
166446 && pParse->db->init.busy==0
169882 {yymsp[0].minor.yy394 = pParse->db->init.busy==0;}
174870 schemaChange = (db->mDbFlags & DBFLAG_SchemaChange)!=0 && db->init.busy==0;
175079 ** This routine implements a busy callback that sleeps and tries
175089 int count /* Number of times table has been busy */
175131 ** Invoke the given busy handler.
175152 ** This routine sets the busy callback for an Sqlite database to the
175206 ** This routine installs a default busy handler that waits for the
176153 ** sequence. If so, and there are active VMs, return busy. If there
177819 db->init.busy = db->init.imposterTable = va_arg(ap,int);
177821 if( db->init.busy==0 && db->init.newTnum>0 ){
178499 ** (call it pOther) in the same process was busy using the same shared
243517 unsigned bBusy; /* True if busy */
244352 #define STMT_COLUMN_BUSY 3 /* True if currently busy */
244363 "CREATE TABLE x(sql,ncol,ro,busy,nscan,nsort,naidx,nstep,"