Result:
found more than 757 distributions - search limited to the first 2001 files matching your query
( run in 0.982 )
DBD-SQLite-Amalgamation
view release on metacpan or search on metacpan
sqlite-amalgamation.c view on Meta::CPAN
/* beginning-of-error-codes */
#define SQLITE_ERROR 1 /* SQL error or missing database */
#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */
#define SQLITE_PERM 3 /* Access permission denied */
#define SQLITE_ABORT 4 /* Callback routine requested an abort */
#define SQLITE_BUSY 5 /* The database file is locked */
#define SQLITE_LOCKED 6 /* A table in the database is locked */
#define SQLITE_NOMEM 7 /* A malloc() failed */
#define SQLITE_READONLY 8 /* Attempt to write a readonly database */
#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/
#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */
#define SQLITE_CORRUPT 11 /* The database disk image is malformed */
sqlite-amalgamation.c view on Meta::CPAN
/*
** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors {H12310} <S40400>
**
** This routine sets a callback function that might be invoked whenever
** an attempt is made to open a database table that another thread
** or process has locked.
**
** If the busy callback is NULL, then [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED]
** is returned immediately upon encountering the lock. If the busy callback
** is not NULL, then the callback will be invoked with two arguments.
**
sqlite-amalgamation.c view on Meta::CPAN
** or [SQLITE_IOERR_BLOCKED] instead of invoking the busy handler.
** Consider a scenario where one process is holding a read lock that
** it is trying to promote to a reserved lock and
** a second process is holding a reserved lock that it is trying
** to promote to an exclusive lock. The first process cannot proceed
** because it is blocked by the second and the second process cannot
** proceed because it is blocked by the first. If both processes
** invoke the busy handlers, neither will make any progress. Therefore,
** SQLite returns [SQLITE_BUSY] for the first process, hoping that this
** will induce the first process to release its read lock and allow
** the second process to proceed.
**
sqlite-amalgamation.c view on Meta::CPAN
/*
** CAPI3REF: Set A Busy Timeout {H12340} <S40410>
**
** This routine sets a [sqlite3_busy_handler | busy handler] that sleeps
** for a specified amount of time when a table is locked. The handler
** will sleep multiple times until at least "ms" milliseconds of sleeping
** have accumulated. {H12343} After "ms" milliseconds of sleeping,
** the handler returns 0 which causes [sqlite3_step()] to return
** [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED].
**
sqlite-amalgamation.c view on Meta::CPAN
default: {
static sqlite3_mutex staticMutexes[6];
static int isInit = 0;
while( !isInit ){
static long lock = 0;
if( InterlockedIncrement(&lock)==1 ){
int i;
for(i=0; i<sizeof(staticMutexes)/sizeof(staticMutexes[0]); i++){
InitializeCriticalSection(&staticMutexes[i].mutex);
}
isInit = 1;
sqlite-amalgamation.c view on Meta::CPAN
** locks on the corresponding inode. There is one locking structure
** per inode, so if the same inode is opened twice, both unixFile structures
** point to the same locking structure. The locking structure keeps
** a reference count (so we will know when to delete it) and a "cnt"
** field that tells us its internal lock status. cnt==0 means the
** file is unlocked. cnt==-1 means the file has an exclusive lock.
** cnt>0 means there are cnt shared locks on the file.
**
** Any attempt to lock or unlock a file first checks the locking
** structure. The fcntl() system call is only invoked to set a
** POSIX lock if the internal lock structure transitions between
** a locked and an unlocked state.
**
** 2004-Jan-11:
** More recent discoveries about POSIX advisory locks. (The more
** I discover, the more I realize the a POSIX advisory locks are
** an abomination.)
sqlite-amalgamation.c view on Meta::CPAN
/*
** This structure holds information passed into individual test
** threads by the testThreadLockingBehavior() routine.
*/
struct threadTestData {
int fd; /* File to be locked */
struct flock lock; /* The locking operation */
int result; /* Result of the locking operation */
};
#ifdef SQLITE_LOCK_TRACE
sqlite-amalgamation.c view on Meta::CPAN
**
** A unixFile is only owned by a thread on systems where one thread is
** unable to override locks created by a different thread. RedHat9 is
** an example of such a system.
**
** Ownership transfer is only allowed if the unixFile is currently unlocked.
** If the unixFile is locked and an ownership is wrong, then return
** SQLITE_MISUSE. SQLITE_OK is returned if everything works.
*/
#if SQLITE_THREADSAFE
static int transferOwnership(unixFile *pFile){
int rc;
sqlite-amalgamation.c view on Meta::CPAN
}
/*
** This routine checks if there is a RESERVED lock held on the specified
** file by this or any other process. If such a lock is held, return
** non-zero. If the file is unlocked or holds only SHARED locks, then
** return zero.
*/
static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){
int r = 0;
unixFile *pFile = (unixFile*)id;
sqlite-amalgamation.c view on Meta::CPAN
** byte', each single bytes at well known offsets, and the 'shared byte
** range', a range of 510 bytes at a well known offset.
**
** To obtain a SHARED lock, a read-lock is obtained on the 'pending
** byte'. If this is successful, a random byte from the 'shared byte
** range' is read-locked and the lock on the 'pending byte' released.
**
** A process may only obtain a RESERVED lock after it has a SHARED lock.
** A RESERVED lock is implemented by grabbing a write-lock on the
** 'reserved byte'.
**
sqlite-amalgamation.c view on Meta::CPAN
struct ByteRangeLockPB2
{
unsigned long long offset; /* offset to first byte to lock */
unsigned long long length; /* nbr of bytes to lock */
unsigned long long retRangeStart; /* nbr of 1st byte locked if successful */
unsigned char unLockFlag; /* 1 = unlock, 0 = lock */
unsigned char startEndFlag; /* 1=rel to end of fork, 0=rel to start */
int fd; /* file desc to assoc this lock with */
};
sqlite-amalgamation.c view on Meta::CPAN
}
/*
** This routine checks if there is a RESERVED lock held on the specified
** file by this or any other process. If such a lock is held, return
** non-zero. If the file is unlocked or holds only SHARED locks, then
** return zero.
*/
static int afpCheckReservedLock(sqlite3_file *id, int *pResOut){
int r = 0;
unixFile *pFile = (unixFile*)id;
sqlite-amalgamation.c view on Meta::CPAN
rc2==SQLITE_IOERR ||
rc2==SQLITE_CORRUPT
){
pPager->errCode = rc;
if( pPager->state==PAGER_UNLOCK && pPager->nRef==0 ){
/* If the pager is already unlocked, call pager_unlock() now to
** clear the error state and ensure that the pager-cache is
** completely empty.
*/
pager_unlock(pPager);
}
sqlite-amalgamation.c view on Meta::CPAN
sqlite3BitvecDestroy(pPager->pInJournal);
pPager->pInJournal = 0;
}
/* If Pager.errCode is set, the contents of the pager cache cannot be
** trusted. Now that the pager file is unlocked, the contents of the
** cache can be discarded and the error code safely cleared.
*/
if( pPager->errCode ){
if( rc==SQLITE_OK ) pPager->errCode = SQLITE_OK;
pager_reset(pPager);
sqlite-amalgamation.c view on Meta::CPAN
** for certain that original page contents are synced into the main rollback
** journal. Otherwise, a power loss might leave modified data in the
** database file without an entry in the rollback journal that can
** restore the database to its original form. Two conditions must be
** met before writing to the database files. (1) the database must be
** locked. (2) we know that the original page content is fully synced
** in the main journal either because the page is not in cache or else
** the page is marked as needSync==0.
**
** 2008-04-14: When attempting to vacuum a corrupt database file, it
** is possible to fail a statement on a database that does not yet exist.
sqlite-amalgamation.c view on Meta::CPAN
return rc;
}
/*
** Create a new page cache and put a pointer to the page cache in *ppPager.
** The file to be cached need not exist. The file is not locked until
** the first call to sqlite3PagerGet() and is only held open until the
** last page is released using sqlite3PagerUnref().
**
** If zFilename is NULL then a randomly-named temporary file is created
** and used as the file to be cached. The file will be deleted
sqlite-amalgamation.c view on Meta::CPAN
/* The OS lock values must be the same as the Pager lock values */
assert( PAGER_SHARED==SHARED_LOCK );
assert( PAGER_RESERVED==RESERVED_LOCK );
assert( PAGER_EXCLUSIVE==EXCLUSIVE_LOCK );
/* If the file is currently unlocked then the size must be unknown */
assert( pPager->state>=PAGER_SHARED || pPager->dbSize<0 || MEMDB );
if( pPager->state>=locktype ){
rc = SQLITE_OK;
}else{
sqlite-amalgamation.c view on Meta::CPAN
sqlite3_vfs *pVfs = pPager->pVfs;
int rc = SQLITE_OK;
*pExists = 0;
if( pPager->useJournal && pPager->fd->pMethods ){
int exists;
int locked;
rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);
if( rc==SQLITE_OK && exists ){
rc = sqlite3OsCheckReservedLock(pPager->fd, &locked);
}
if( rc==SQLITE_OK && exists && !locked ){
int nPage;
rc = sqlite3PagerPagecount(pPager, &nPage);
if( rc==SQLITE_OK ){
if( nPage==0 ){
sqlite3OsDelete(pVfs, pPager->zJournal, 0);
sqlite-amalgamation.c view on Meta::CPAN
struct Btree {
sqlite3 *db; /* The database connection holding this btree */
BtShared *pBt; /* Sharable content of this btree */
u8 inTrans; /* TRANS_NONE, TRANS_READ or TRANS_WRITE */
u8 sharable; /* True if we can share pBt with another db */
u8 locked; /* True if db currently has pBt locked */
int wantToLock; /* Number of nested calls to sqlite3BtreeEnter() */
Btree *pNext; /* List of other sharable Btrees from the same db */
Btree *pPrev; /* Back pointer of the same list */
};
sqlite-amalgamation.c view on Meta::CPAN
** If the object is not sharable, then no mutex is ever required
** and this routine is a no-op. The underlying mutex is non-recursive.
** But we keep a reference count in Btree.wantToLock so the behavior
** of this interface is recursive.
**
** To avoid deadlocks, multiple Btrees are locked in the same order
** by all database connections. The p->pNext is a list of other
** Btrees belonging to the same database connection as the p Btree
** which need to be locked after p. If we cannot get a lock on
** p, then first unlock all of the others on p->pNext, then wait
** for the lock to become available on p, then relock all of the
** subsequent Btrees that desire a lock.
*/
SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){
sqlite-amalgamation.c view on Meta::CPAN
assert( p->pNext==0 || p->pNext->db==p->db );
assert( p->pPrev==0 || p->pPrev->db==p->db );
assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
/* Check for locking consistency */
assert( !p->locked || p->wantToLock>0 );
assert( p->sharable || p->wantToLock==0 );
/* We should already hold a lock on the database connection */
assert( sqlite3_mutex_held(p->db->mutex) );
if( !p->sharable ) return;
p->wantToLock++;
if( p->locked ) return;
#ifndef SQLITE_MUTEX_NOOP
/* In most cases, we should be able to acquire the lock we
** want without having to go throught the ascending lock
** procedure that follows. Just be sure not to block.
*/
if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
p->locked = 1;
return;
}
/* To avoid deadlock, first release all locks with a larger
** BtShared address. Then acquire our lock. Then reacquire
sqlite-amalgamation.c view on Meta::CPAN
** order.
*/
for(pLater=p->pNext; pLater; pLater=pLater->pNext){
assert( pLater->sharable );
assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
assert( !pLater->locked || pLater->wantToLock>0 );
if( pLater->locked ){
sqlite3_mutex_leave(pLater->pBt->mutex);
pLater->locked = 0;
}
}
sqlite3_mutex_enter(p->pBt->mutex);
p->locked = 1;
for(pLater=p->pNext; pLater; pLater=pLater->pNext){
if( pLater->wantToLock ){
sqlite3_mutex_enter(pLater->pBt->mutex);
pLater->locked = 1;
}
}
#endif /* SQLITE_MUTEX_NOOP */
}
sqlite-amalgamation.c view on Meta::CPAN
SQLITE_PRIVATE void sqlite3BtreeLeave(Btree *p){
if( p->sharable ){
assert( p->wantToLock>0 );
p->wantToLock--;
if( p->wantToLock==0 ){
assert( p->locked );
sqlite3_mutex_leave(p->pBt->mutex);
p->locked = 0;
}
}
}
#ifndef NDEBUG
sqlite-amalgamation.c view on Meta::CPAN
**
** This routine is used only from within assert() statements.
*/
SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree *p){
return (p->sharable==0 ||
(p->locked && p->wantToLock && sqlite3_mutex_held(p->pBt->mutex)));
}
#endif
#ifndef SQLITE_OMIT_INCRBLOB
sqlite-amalgamation.c view on Meta::CPAN
assert( sqlite3_mutex_held(db->mutex) );
for(i=0; i<db->nDb; i++){
p = db->aDb[i].pBt;
if( p && p->sharable ){
p->wantToLock++;
if( !p->locked ){
assert( p->wantToLock==1 );
while( p->pPrev ) p = p->pPrev;
while( p->locked && p->pNext ) p = p->pNext;
for(pLater = p->pNext; pLater; pLater=pLater->pNext){
if( pLater->locked ){
sqlite3_mutex_leave(pLater->pBt->mutex);
pLater->locked = 0;
}
}
while( p ){
sqlite3_mutex_enter(p->pBt->mutex);
p->locked++;
p = p->pNext;
}
}
}
}
sqlite-amalgamation.c view on Meta::CPAN
p = db->aDb[i].pBt;
if( p && p->sharable ){
assert( p->wantToLock>0 );
p->wantToLock--;
if( p->wantToLock==0 ){
assert( p->locked );
sqlite3_mutex_leave(p->pBt->mutex);
p->locked = 0;
}
}
}
}
sqlite-amalgamation.c view on Meta::CPAN
int i;
for(i=0; i<pArray->nMutex; i++){
Btree *p = pArray->aBtree[i];
/* Some basic sanity checking */
assert( i==0 || pArray->aBtree[i-1]->pBt<p->pBt );
assert( !p->locked || p->wantToLock>0 );
/* We should already hold a lock on the database connection */
assert( sqlite3_mutex_held(p->db->mutex) );
p->wantToLock++;
if( !p->locked && p->sharable ){
sqlite3_mutex_enter(p->pBt->mutex);
p->locked = 1;
}
}
}
/*
sqlite-amalgamation.c view on Meta::CPAN
int i;
for(i=0; i<pArray->nMutex; i++){
Btree *p = pArray->aBtree[i];
/* Some basic sanity checking */
assert( i==0 || pArray->aBtree[i-1]->pBt<p->pBt );
assert( p->locked || !p->sharable );
assert( p->wantToLock>0 );
/* We should already hold a lock on the database connection */
assert( sqlite3_mutex_held(p->db->mutex) );
p->wantToLock--;
if( p->wantToLock==0 && p->locked ){
sqlite3_mutex_leave(p->pBt->mutex);
p->locked = 0;
}
}
}
sqlite-amalgamation.c view on Meta::CPAN
/* If there are still other outstanding references to the shared-btree
** structure, return now. The remainder of this procedure cleans
** up the shared-btree.
*/
assert( p->wantToLock==0 && p->locked==0 );
if( !p->sharable || removeFromSharingList(pBt) ){
/* The pBt is no longer on the sharing list, so we can access
** it without having to hold the mutex.
**
** Clean out and delete the BtShared object.
sqlite-amalgamation.c view on Meta::CPAN
sqlite3_free(pBt);
}
#ifndef SQLITE_OMIT_SHARED_CACHE
assert( p->wantToLock==0 );
assert( p->locked==0 );
if( p->pPrev ) p->pPrev->pNext = p->pNext;
if( p->pNext ) p->pNext->pPrev = p->pPrev;
#endif
sqlite3_free(p);
sqlite-amalgamation.c view on Meta::CPAN
** Get a reference to pPage1 of the database file. This will
** also acquire a readlock on that file.
**
** SQLITE_OK is returned on success. If the file is not a
** well-formed database file, then SQLITE_CORRUPT is returned.
** SQLITE_BUSY is returned if the database is locked. SQLITE_NOMEM
** is returned if we run out of memory.
*/
static int lockBtree(BtShared *pBt){
int rc;
MemPage *pPage1;
sqlite-amalgamation.c view on Meta::CPAN
** sqlite3BtreeInsert()
** sqlite3BtreeDelete()
** sqlite3BtreeUpdateMeta()
**
** If an initial attempt to acquire the lock fails because of lock contention
** and the database was previously unlocked, then invoke the busy handler
** if there is one. But if there was previously a read-lock, do not
** invoke the busy handler - just return SQLITE_BUSY. SQLITE_BUSY is
** returned when there is already a read-lock in order to avoid a deadlock.
**
** Suppose there are two processes A and B. A has a read lock and B has
** a reserved lock. B tries to promote to exclusive but is blocked because
** of A's read lock. A tries to promote to reserved but is blocked by B.
** One or the other of the two processes must give way or there can be
** no progress. By returning SQLITE_BUSY and not invoking the busy callback
** when A already has a read lock, we encourage A to give up and let B
** proceed.
*/
sqlite-amalgamation.c view on Meta::CPAN
**
** Whenever a row or result data is available, this routine will either
** invoke the result callback (if there is one) or return with
** SQLITE_ROW.
**
** If an attempt is made to open a locked database, then this routine
** will either invoke the busy callback (if there is one) or it will
** return SQLITE_BUSY.
**
** If an error occurs, an error message is written to memory obtained
** from sqlite3_malloc() and p->zErrMsg is made to point to that memory.
sqlite-amalgamation.c view on Meta::CPAN
**
** If P5!=0 then use the content of register P2 as the root page, not
** the value of P2 itself.
**
** There will be a read lock on the database whenever there is an
** open cursor. If the database was unlocked prior to this instruction
** then a read lock is acquired as part of this instruction. A read
** lock allows other processes to read the database but prohibits
** any other process from modifying the database. The read lock is
** released when all cursors are closed. If this instruction attempts
** to get a read lock but fails, the script terminates with an
sqlite-amalgamation.c view on Meta::CPAN
** on which the lock is acquired. A readlock is obtained if P3==0 or
** a write lock if P3==1.
**
** P2 contains the root-page of the table to lock.
**
** P4 contains a pointer to the name of the table being locked. This is only
** used to generate an error message if the lock cannot be obtained.
*/
case OP_TableLock: {
int p1 = pOp->p1;
u8 isWriteLock = pOp->p3;
sqlite-amalgamation.c view on Meta::CPAN
assert( (p->btreeMask & (1<<p1))!=0 );
assert( isWriteLock==0 || isWriteLock==1 );
rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
if( rc==SQLITE_LOCKED ){
const char *z = pOp->p4.z;
sqlite3SetString(&p->zErrMsg, db, "database table is locked: %s", z);
}
break;
}
#endif /* SQLITE_OMIT_SHARED_CACHE */
sqlite-amalgamation.c view on Meta::CPAN
sqlite3_snprintf(sizeof(zErr), zErr,
"cannot DETACH database within transaction");
goto detach_error;
}
if( sqlite3BtreeIsInReadTrans(pDb->pBt) ){
sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
goto detach_error;
}
sqlite3BtreeClose(pDb->pBt);
pDb->pBt = 0;
sqlite-amalgamation.c view on Meta::CPAN
/*
** The TableLock structure is only used by the sqlite3TableLock() and
** codeTableLocks() functions.
*/
struct TableLock {
int iDb; /* The database containing the table to be locked */
int iTab; /* The root page of the table to be locked */
u8 isWriteLock; /* True for write lock. False for a read lock */
const char *zName; /* Name of the table */
};
/*
** Record the fact that we want to lock a table at run-time.
**
** The table to be locked has root page iTab and is found in database iDb.
** A read or a write lock can be taken depending on isWritelock.
**
** This routine just records the fact that the lock is desired. The
** code to make the lock occur is generated by a later call to
** codeTableLocks() which occurs during sqlite3FinishCoding().
*/
SQLITE_PRIVATE void sqlite3TableLock(
Parse *pParse, /* Parsing context */
int iDb, /* Index of the database containing the table to lock */
int iTab, /* Root page number of the table to be locked */
u8 isWriteLock, /* True for a write lock */
const char *zName /* Name of the table to be locked */
){
int i;
int nBytes;
TableLock *p;
sqlite-amalgamation.c view on Meta::CPAN
pParse->db->mallocFailed = 1;
}
}
/*
** Code an OP_TableLock instruction for each table locked by the
** statement (configured by calls to sqlite3TableLock()).
*/
static void codeTableLocks(Parse *pParse){
int i;
Vdbe *pVdbe;
sqlite-amalgamation.c view on Meta::CPAN
/*
** Report the current state of file logs for all databases
*/
if( sqlite3StrICmp(zLeft, "lock_status")==0 ){
static const char *const azLockName[] = {
"unlocked", "shared", "reserved", "pending", "exclusive"
};
int i;
Vdbe *v = sqlite3GetVdbe(pParse);
sqlite3VdbeSetNumCols(v, 2);
pParse->nMem = 2;
sqlite-amalgamation.c view on Meta::CPAN
return SQLITE_MISUSE;
}
assert( !db->mallocFailed );
assert( sqlite3_mutex_held(db->mutex) );
/* If any attached database schemas are locked, do not proceed with
** compilation. Instead return SQLITE_LOCKED immediately.
*/
for(i=0; i<db->nDb; i++) {
Btree *pBt = db->aDb[i].pBt;
if( pBt ){
int rc;
rc = sqlite3BtreeSchemaLocked(pBt);
if( rc ){
const char *zDb = db->aDb[i].zName;
sqlite3Error(db, SQLITE_LOCKED, "database schema is locked: %s", zDb);
(void)sqlite3SafetyOff(db);
return sqlite3ApiExit(db, SQLITE_LOCKED);
}
}
}
sqlite-amalgamation.c view on Meta::CPAN
/*
** Lock the virtual table so that it cannot be disconnected.
** Locks nest. Every lock should have a corresponding unlock.
** If an unlock is omitted, resources leaks will occur.
**
** If a disconnect is attempted while a virtual table is locked,
** the disconnect is deferred until all locks have been removed.
*/
SQLITE_PRIVATE void sqlite3VtabLock(sqlite3_vtab *pVtab){
pVtab->nRef++;
}
sqlite-amalgamation.c view on Meta::CPAN
case SQLITE_DONE:
case SQLITE_OK: z = "not an error"; break;
case SQLITE_ERROR: z = "SQL logic error or missing database"; break;
case SQLITE_PERM: z = "access permission denied"; break;
case SQLITE_ABORT: z = "callback requested query abort"; break;
case SQLITE_BUSY: z = "database is locked"; break;
case SQLITE_LOCKED: z = "database table is locked"; break;
case SQLITE_NOMEM: z = "out of memory"; break;
case SQLITE_READONLY: z = "attempt to write a readonly database"; break;
case SQLITE_INTERRUPT: z = "interrupted"; break;
case SQLITE_IOERR: z = "disk I/O error"; break;
case SQLITE_CORRUPT: z = "database disk image is malformed"; break;
sqlite-amalgamation.c view on Meta::CPAN
values[i] = string_dup((char*)sqlite3_column_text(s, i));
}
}
/* We expect only one row. We must execute another sqlite3_step()
* to complete the iteration; otherwise the table will remain locked. */
rc = sqlite3_step(s);
if( rc==SQLITE_DONE ){
*pValues = values;
return SQLITE_OK;
}
sqlite-amalgamation.c view on Meta::CPAN
rc = sqlite3_step(s);
if( rc!=SQLITE_ROW ) return rc;
/* We expect only one row. We must execute another sqlite3_step()
* to complete the iteration; otherwise the table will remain locked. */
rc = sqlite3_step(s);
if( rc==SQLITE_DONE ) return SQLITE_ROW;
if( rc==SQLITE_ROW ) return SQLITE_ERROR;
return rc;
}
sqlite-amalgamation.c view on Meta::CPAN
}
*pidx = sqlite3_column_int(s, 0);
/* We expect only one row. We must execute another sqlite3_step()
* to complete the iteration; otherwise the table will remain locked. */
rc = sqlite3_step(s);
if( rc==SQLITE_ROW ) return SQLITE_ERROR;
if( rc!=SQLITE_DONE ) return rc;
return SQLITE_ROW;
}
sqlite-amalgamation.c view on Meta::CPAN
if( rc!=SQLITE_ROW ) return rc;
/* This happens if all segments at this level are entirely inline. */
if( SQLITE_NULL==sqlite3_column_type(s, 0) ){
/* We expect only one row. We must execute another sqlite3_step()
* to complete the iteration; otherwise the table will remain locked. */
int rc2 = sqlite3_step(s);
if( rc2==SQLITE_ROW ) return SQLITE_ERROR;
return rc2;
}
*piStartBlockid = sqlite3_column_int64(s, 0);
*piEndBlockid = sqlite3_column_int64(s, 1);
/* We expect only one row. We must execute another sqlite3_step()
* to complete the iteration; otherwise the table will remain locked. */
rc = sqlite3_step(s);
if( rc==SQLITE_ROW ) return SQLITE_ERROR;
if( rc!=SQLITE_DONE ) return rc;
return SQLITE_ROW;
}
sqlite-amalgamation.c view on Meta::CPAN
*pnSegments = sqlite3_column_int(s, 0);
*piMaxLevel = sqlite3_column_int(s, 1);
/* We expect only one row. We must execute another sqlite3_step()
* to complete the iteration; otherwise the table will remain locked. */
rc = sqlite3_step(s);
if( rc==SQLITE_DONE ) return SQLITE_OK;
if( rc==SQLITE_ROW ) return SQLITE_ERROR;
return rc;
}
sqlite-amalgamation.c view on Meta::CPAN
getChildrenContaining(sqlite3_column_blob(s, 0), sqlite3_column_bytes(s, 0),
pTerm, nTerm, isPrefix, piStartChild, piEndChild);
/* We expect only one row. We must execute another sqlite3_step()
* to complete the iteration; otherwise the table will remain
* locked. */
rc = sqlite3_step(s);
if( rc==SQLITE_ROW ) return SQLITE_ERROR;
if( rc!=SQLITE_DONE ) return rc;
return SQLITE_OK;
DBD-SQLite
view release on metacpan or search on metacpan
lib/DBD/SQLite.pm view on Meta::CPAN
When you use L<File::Temp> to create a temporary file/directory for
SQLite databases, you need to remember:
=over 4
=item tempfile may be locked exclusively
You may want to use C<tempfile()> to create a temporary database
filename for DBD::SQLite, but as noted in L<File::Temp>'s POD,
this file may have an exclusive lock under some operating systems
(notably Mac OSX), and result in a "database is locked" error.
To avoid this, set EXLOCK option to false when you call tempfile().
($fh, $filename) = tempfile($template, EXLOCK => 0);
=item CLEANUP may not work unless a database is disconnected
DBD-SQLite2
view release on metacpan or search on metacpan
** Get a reference to page1 of the database file. This will
** also acquire a readlock on that file.
**
** SQLITE_OK is returned on success. If the file is not a
** well-formed database file, then SQLITE_CORRUPT is returned.
** SQLITE_BUSY is returned if the database is locked. SQLITE_NOMEM
** is returned if we run out of memory. SQLITE_PROTOCOL is returned
** if there is a locking protocol violation.
*/
static int lockBtree(Btree *pBt){
int rc;
DBD-Unify
view release on metacpan or search on metacpan
get_av|5.006000|5.003007|p
getc|5.003007||Viu
get_c_backtrace|5.021001||Vi
get_c_backtrace_dump|5.021001||V
get_context|5.006000|5.006000|nu
getc_unlocked|5.003007||Viu
get_cv|5.006000|5.003007|p
get_cvn_flags|5.009005|5.003007|p
get_cvs|5.011000|5.003007|p
getcwd_sv|5.007002|5.007002|
get_db_sub|||iu
PERL_MALLOC_WRAP|5.009002|5.009002|Vn
PerlMem_calloc|5.006000||Viu
PerlMem_free|5.005000||Viu
PerlMem_free_lock|5.006000||Viu
PerlMem_get_lock|5.006000||Viu
PerlMem_is_locked|5.006000||Viu
PerlMem_malloc|5.005000||Viu
PERL_MEMORY_DEBUG_HEADER_SIZE|5.019009||Viu
PerlMemParse_calloc|5.006000||Viu
PerlMemParse_free|5.006000||Viu
PerlMemParse_free_lock|5.006000||Viu
PerlMemParse_get_lock|5.006000||Viu
PerlMemParse_is_locked|5.006000||Viu
PerlMemParse_malloc|5.006000||Viu
PerlMemParse_realloc|5.006000||Viu
PerlMem_realloc|5.005000||Viu
PerlMemShared_calloc|5.006000||Viu
PerlMemShared_free|5.006000||Viu
PerlMemShared_free_lock|5.006000||Viu
PerlMemShared_get_lock|5.006000||Viu
PerlMemShared_is_locked|5.006000||Viu
PerlMemShared_malloc|5.006000||Viu
PerlMemShared_realloc|5.006000||Viu
PERL_MG_UFUNC|5.007001||Viu
Perl_modf|5.006000|5.006000|n
PERL_MULTICONCAT_HEADER_SIZE|5.027006||Viu
putc|5.003007||Viu
put_charclass_bitmap_innards|5.021004||Viu
put_charclass_bitmap_innards_common|5.023008||Viu
put_charclass_bitmap_innards_invlist|5.023008||Viu
put_code_point|5.021004||Viu
putc_unlocked|5.003007||Viu
putenv|5.005000||Viu
put_range|5.019009||Viu
putw|5.003007||Viu
pv_display|5.006000|5.003007|p
pv_escape|5.009004|5.003007|p
DBD-cubrid
view release on metacpan or search on metacpan
cci-src/config/ltmain.sh view on Meta::CPAN
EOF
fi
$run $mv "${libobj}T" "${libobj}"
# Unlock the critical section if it was locked
if test "$need_locks" != no; then
$run $rm "$lockfile"
fi
exit $EXIT_SUCCESS
DBD_SQLFLEX
view release on metacpan or search on metacpan
"Illegal argument", /* 102 */
"Bad key descriptor", /* 103 */
"Too many files", /* 104 */
"Corrupted isam file", /* 105 */
"Need exclusive access", /* 106 */
"Record or file locked", /* 107 */
"Index already exists", /* 108 */
"Illegal primary key operation", /* 109 */
"End of file", /* 110 */
"Record not found", /* 111 */
"No current record", /* 112 */
DBI
view release on metacpan or search on metacpan
drivers may attempt to implement this method by executing
"C<select max($field) from $table>". Drivers using any approach
like this should issue a warning if C<AutoCommit> is true because
it is generally unsafe - another process may have modified the table
between your insert and the select. For situations where you know
it is safe, such as when you have locked the table, you can silence
the warning by passing C<Warn> => 0 in \%attr.
B<*> If no insert has been performed yet, or the last insert failed,
then the value is implementation defined.
DBIx-Admin-DSNManager
view release on metacpan or search on metacpan
lib/DBIx/Admin/DSNManager.pm view on Meta::CPAN
For cases like SQLite, testing code can either look in dsn.ini, or manufacture a temporary directory and file name
for testing.
This leads to a new question: If the testing code finds a DSN in dsn.ini which is marked use_for_testing = 0,
should that code still generate another DSN for testing? My suggestions is: Yes, since the one in dsn.ini does
not indicate that all possible DSNs should be blocked from testing.
=back
=head1 The Format of dsn.ini
DBIx-Class-EasyFixture
view release on metacpan or search on metacpan
lib/DBIx/Class/EasyFixture/Tutorial.pm view on Meta::CPAN
=head1 CREATING YOUR FIXTURE CLASS
To use C<DBIx::Class::EasyFixture>, you must first create a subclass of it.
It's required to define two methods: C<get_fixture> and C<all_fixture_names>.
You may implement those any way you wish and you're not locked into a
particular format. Here's one way to do it, using a big hash (there are plenty
of other ways to do this, but this is easy for a tutorial.
package My::Fixtures;
use Moo; # (Moose is also fine)
DBIx-Class-MoreHelpers
view release on metacpan or search on metacpan
lib/DBIx/Class/Helper/ResultSet/Shortcut/Search/Is.pm view on Meta::CPAN
version 1.0001
=head2 is(@columns || \@columns)
$rs->is('active');
$rs->is(['active', 'blocked']);
=head1 AUTHOR
D Ruth Holloway <ruth@hiruthie.me>
DBIx-Class-Schema-Loader
view release on metacpan or search on metacpan
maint/travis-ci_scripts/10_before_install.bash view on Meta::CPAN
if [[ "$(free -m | grep 'buffers/cache:' | perl -p -e '$_ = (split /\s+/, $_)[3]')" -lt "$CI_VM_MIN_FREE_MB" ]]; then
export SHORT_CIRCUIT_SMOKE=1
echo_err "
=============================================================================
CI virtual machine stuck in a state with a lot of memory locked for no reason.
Under Travis this state usually results in a failed build.
Short-circuiting buildjob to avoid false negatives, please restart it manually.
============================================================================="
fi
DBIx-Class
view release on metacpan or search on metacpan
lib/DBIx/Class/ResultSet.pm view on Meta::CPAN
carp_unique("Fast-path populate() of non-uniquely identifiable rows with related data is not possible - falling back to regular create()");
return my $throwaway = $self->populate(@_);
}
}
### inherit the data locked in the conditions of the resultset
my ($rs_data) = $self->_merge_with_rscond({});
delete @{$rs_data}{@$colnames}; # passed-in stuff takes precedence
# if anything left - decompose rs_data
my $rs_data_vals;
lib/DBIx/Class/ResultSet.pm view on Meta::CPAN
my $fresh_rs = (ref $self)->new (
$self->result_source,
{},
);
# these pieces will be locked in the subquery
delete $fresh_rs->{cond};
delete @{$fresh_rs->{attrs}}{qw/where bind/};
return $fresh_rs->search( {}, {
from => [{
DBIx-Counter
view release on metacpan or search on metacpan
lib/DBIx/Counter.pm view on Meta::CPAN
return $v;
}
sub lock { 0 }
sub unlock { 0 }
sub locked { 0 }
1;
__END__
lib/DBIx/Counter.pm view on Meta::CPAN
=item unlock
Noop. Only provided for API compatibility with File::CounterFile.
=item locked
Noop. Only provided for API compatibility with File::CounterFile.
=back
DBIx-JCL
view release on metacpan or search on metacpan
lib/DBIx/JCL.pm view on Meta::CPAN
## log file rotation if generations > 0
if ( -e $log_filefull && $log_gdg > 0 ) {
_log_rotate();
}
## create new locked log file
## if the file is already locked, will wait until the file is unlocked
my $fh = new IO::LockedFile(">$log_filefull")
or sys_die( 'Failed opening log file', 0 );
## close and unlock the file
$fh->close();
lib/DBIx/JCL.pm view on Meta::CPAN
my $preamble = time2str( '%Y/%m/%d %T', time );
if ( $level eq 'FATAL' ) { $preamble .= ' FATAL'; }
if ( $level eq 'ERROR' ) { $preamble .= ' ERROR'; }
if ( $level eq 'WARN' ) { $preamble .= ' WARNING'; }
## open locked log file for appending
## if the file is already locked, will wait until the file is unlocked
my $fh = new IO::LockedFile(">>$log_filefull")
or sys_die( 'Failed opening log file', 0 );
print {$fh} "$preamble $message\n";
## close and unlock the file
$fh->close();
DBIx-Lite
view release on metacpan or search on metacpan
lib/DBIx/Lite/ResultSet.pm view on Meta::CPAN
=head2 for_update
This method accepts no argument. It enables the addition of the SQL C<FOR UPDATE>
clause at the end of the query, which allows to fetch data and lock it for updating.
It returns a L<DBIx::Lite::ResultSet> object to allow for further method chaining.
Note that no records are actually locked until the query is executed with L<single()>,
L<all()> or L<next()>.
$dbix->txn(sub {
my $author = $dbix->table('authors')->find($id)->for_update->single
or die "Author not found";
DBIx-Locker
view release on metacpan or search on metacpan
lib/DBIx/Locker.pm view on Meta::CPAN
#pod database connection failure, silently losing the connection-based lock.
#pod DBIx::Locker locks by creating a persistent row in a "locks" table.
#pod
#pod Because DBIx::Locker locks are stored in a table, they won't go away. They
#pod have to be purged regularly. (A program for doing this, F<dbix_locker_purge>,
#pod is included.) The locked resource is just a string. All records in the lock
#pod (or semaphore) table are unique on the lock string.
#pod
#pod This is the I<entire> mechanism. This is quick and dirty and quite effective,
#pod but it's not highly efficient. If you need high speed locks with multiple
#pod levels of resolution, or anything other than a quick and brutal solution,
lib/DBIx/Locker.pm view on Meta::CPAN
#pod
#pod =item * C<created> datetime
#pod
#pod =item * C<expires> datetime
#pod
#pod =item * C<locked_by> text
#pod
#pod =back
#pod
#pod See the C<sql> directory included in this dist for DDL for your database.
#pod
lib/DBIx/Locker.pm view on Meta::CPAN
Carp::confess("expires must be a positive integer")
unless $expires > 0 and $expires == int $expires;
$expires = time + $expires;
my $locked_by = {
host => Sys::Hostname::hostname(),
guid => Data::GUID->new->as_string,
pid => $$,
};
lib/DBIx/Locker.pm view on Meta::CPAN
local $dbh->{RaiseError} = 0;
local $dbh->{PrintError} = 0;
my $rows = $dbh->do(
"INSERT INTO $table (lockstring, created, expires, locked_by)
VALUES (?, ?, ?, ?)",
undef,
$lockstring,
$self->_time_to_string,
$self->_time_to_string([ localtime($expires) ]),
$JSON->encode($locked_by),
);
die(
"could not lock resource <$lockstring>" . (
$dbh->err && $dbh->errstr
lib/DBIx/Locker.pm view on Meta::CPAN
my $lock = DBIx::Locker::Lock->new({
locker => $self,
lock_id => $self->last_insert_id,
expires => $expires,
locked_by => $locked_by,
lockstring => $lockstring,
});
return $lock;
}
lib/DBIx/Locker.pm view on Meta::CPAN
database connection failure, silently losing the connection-based lock.
DBIx::Locker locks by creating a persistent row in a "locks" table.
Because DBIx::Locker locks are stored in a table, they won't go away. They
have to be purged regularly. (A program for doing this, F<dbix_locker_purge>,
is included.) The locked resource is just a string. All records in the lock
(or semaphore) table are unique on the lock string.
This is the I<entire> mechanism. This is quick and dirty and quite effective,
but it's not highly efficient. If you need high speed locks with multiple
levels of resolution, or anything other than a quick and brutal solution,
lib/DBIx/Locker.pm view on Meta::CPAN
=item * C<created> datetime
=item * C<expires> datetime
=item * C<locked_by> text
=back
See the C<sql> directory included in this dist for DDL for your database.
DBIx-Mint
view release on metacpan or search on metacpan
lib/DBIx/Mint.pm view on Meta::CPAN
$team->name('Los Invencibles');
$team->update;
Bloodbowl::Coach->update(
{ status => 'suspended' },
{ password => 'blocked' });
Declaring the schema allows you to modify the data. To define a schema and to learn about data modification methods, look into L<DBIx::Mint::Schema> and L<DBIx::Mint::Table>.
If you only need to query the database, no schema is needed. L<DBIx::Mint::ResultSet> objects build database queries and fetch the resulting records:
DBIx-MyParse
view release on metacpan or search on metacpan
lib/DBIx/MyParse/Query.pm view on Meta::CPAN
=back
=head2 C<"SQLCOM_LOCK_TABLES"> and C<"SQLCOM_UNLOCK_TABLES">
You can use C<getTables()> to get a list of the tables being locked. Calling C<getOptions()> returns a list of lock
types so that the first lock type in the list corresponds to the first table and so on in a one-to-one relationship.
=head2 C<"SQLCOM_DROP_TABLE">, C<"SQLCOM_TRUNCATE"> and C<"SQLCOM_RENAME_TABLE">
For C<"SQLCOM_DROP_TABLE"> and C<"SQLOM_TRUNCATE">, use C<getTables()> to obtain a reference to an array of
DBIx-NinjaORM
view release on metacpan or search on metacpan
lib/DBIx/NinjaORM.pm view on Meta::CPAN
skip_cache => 1,
) // die 'Book with ISBN 9781449303587 does not exist';
=item * lock (default: 0)
By default, the underlying row is not locked when retrieving an object via
C<new()>. Setting C<lock> to 1 forces the ORM to bypass the cache if any, and
to lock the rows in the database as it retrieves them.
my $object = My::Model::Book->new(
{ isbn => '9781449303587' },
lib/DBIx/NinjaORM.pm view on Meta::CPAN
if defined( $args{'query_extensions'}->{'joined_fields'} );
# We need to make an exception for lock=1 when using SQLite, since
# SQLite doesn't support FOR UPDATE.
# Per http://sqlite.org/cvstrac/wiki?p=UnsupportedSql, the entire
# database is locked when updating any bit of it, so we can simply
# ignore the locking request here.
my $lock = '';
if ( $args{'lock'} )
{
my $database_type = $dbh->{'Driver'}->{'Name'} || '';
lib/DBIx/NinjaORM.pm view on Meta::CPAN
"Performing pre-locking query:\n%s\nValues:\n%s",
$query,
\@query_values,
) if $args{'show_queries'};
my $locked_ids;
try
{
local $dbh->{'RaiseError'} = 1;
$locked_ids = $dbh->selectall_arrayref(
$query,
{
Columns => [ 1 ],
},
@query_values
lib/DBIx/NinjaORM.pm view on Meta::CPAN
\@query_values,
);
croak "Failed select: $_";
};
if ( !defined( $locked_ids ) || ( scalar( @$locked_ids ) == 0 ) )
{
return [];
}
$where = sprintf(
'WHERE %s.%s IN ( %s )',
$quoted_table_name,
$quoted_primary_key_name,
join( ', ', ( ('?') x scalar( @$locked_ids ) ) ),
);
$where_values = [ [ map { $_->[0] } @$locked_ids ] ];
$lock = '';
}
# Prepare the query elements.
my $query = sprintf(
DBIx-OnlineDDL
view release on metacpan or search on metacpan
lib/DBIx/OnlineDDL/Helper/SQLite.pm view on Meta::CPAN
# Disable /x flag to allow for whitespace within string, but turn it on for newlines
# and comments.
return $error =~ m<
# Locks
(?-x:database( table)? is locked)|
# Connections
(?-x:attempt to [\w\s]+ on inactive database handle)|
# Queries
DBIx-ParseError-MySQL
view release on metacpan or search on metacpan
lib/DBIx/ParseError/MySQL.pm view on Meta::CPAN
(?-x:Query execution was interrupted(?!, maximum statement execution time exceeded))|
# Initial connection failure
(?-x:Bad handshake)|
(?-x:Too many connections)|
(?-x:Host '\S+' is blocked because of many connection errors)|
(?-x:Can't get hostname for your address)|
(?-x:Can't connect to (?:local )?MySQL server)|
# Packet corruption
(?-x:Got a read error from the connection pipe)|
DBIx-Path
view release on metacpan or search on metacpan
lib/DBIx/Path.pm view on Meta::CPAN
no strict 'refs';
*{$field}=sub { $_[0]->{$field} }
}
{
my $locked=0;
sub _lock {
my($me, $type)=@_;
$locked++;
if($locked == 1 and $me->{hooks}{lock}) {
$me->{hooks}{lock}->($me->{dbh}, $type);
}
}
sub _unlock {
my($me, $type)=@_;
if($locked == 1) {
$me->{hooks}{unlock}->($me->{dbh}, $type) if $me->{hooks}{unlock};
}
elsif($locked == 0) {
croak "DBIx::Path: PANIC: Key won't fit in lock";
}
$locked--;
}
END {
if($locked) {
warn "DBIx::Path: WARNING: Program may have exited with lock(s) still held";
}
}
}
DBIx-QueryByName
view release on metacpan or search on metacpan
lib/DBIx/QueryByName/SthPool.pm view on Meta::CPAN
while (1) {
# Normally, if traffic between the client and the database
# server is interupted (cable cut, whatever), the client will
# timeout after 1min (observed on osx). But it has been
# observed on some setups (client on linux, server blocked by
# drop rule in firewall) that the client hang forever in
# execute(). The following code is a workaround:
#
# my $did_timeout = 0;
# eval {
DBIx-QuickORM
view release on metacpan or search on metacpan
lib/DBIx/QuickORM.pm view on Meta::CPAN
The rows are also smart enough to check if your inflated forms have been
mutated and consider the row dirty (in need of saving or discarding) after the
mutation. This is done by deflating the values to compare to the stored form
when checking for dirtyness.
If your inflated values are readonly, locked restricted hashes, or objects that
implement the 'qorm_immutible' method (and it returns true). Then the row is
smart enough to skip checking them for mutations as they cannot be mutated.
Oh, also of note, inflated forms do not need to be blessed, nor do they even
need to be references. You could write a conflator that inflates string to have
DBIx-Schema-Changelog
view release on metacpan or search on metacpan
examples/changelog/changelog-002-tables.yml view on Meta::CPAN
type: uuid
- name: msg_user
type: uuid
- default: 0
length: 1
name: locked
type: bit
- default: now()
name: last_read
type: timestamp
name: msg_session_members
DBIx-Simple-Class
view release on metacpan or search on metacpan
t/01-dbix-simple-class-schema-mysql.t view on Meta::CPAN
$dbix->query('DROP TABLE IF EXISTS `groups`');
$dbix->query(<<'TAB');
CREATE TABLE IF NOT EXISTS groups(
id INTEGER PRIMARY KEY AUTO_INCREMENT,
group_name VARCHAR(12),
`is blocked` INT,
data TEXT
) DEFAULT CHARSET=utf8 COLLATE=utf8_bin
TAB
DBIx-Struct
view release on metacpan or search on metacpan
NoUser->throw("User is not logged in or does not exist") unless defined $session;
# get client's row
my $client = $session->Client;
# strip microseconds part
$client->filter_timestamp;
# throw exception if client is blocked
BlkUser->throw if $client->state eq 'blocked';
# set expire date
$session->expire(\"now() + interval '2 day'");
# update session
$session->update;
# get usd client's balance from client_balance
DBIx-TextIndex
view release on metacpan or search on metacpan
lib/DBIx/TextIndex.pm view on Meta::CPAN
_log("field$fno ", scalar keys %{$self->{TERM_DOCS_VINT}->[$fno]},
" distinct terms\n") if $PA;
my $s_sth;
# SQLite chokes with "database table is locked" unless s_sth
# is finished before i_sth->execute
unless ($self->{DBD_TYPE} eq 'SQLite') {
$s_sth = $self->{INDEX_DBH}->prepare(
$self->{DB}->inverted_select(
$self->{INVERTED_TABLES}->[$fno] ) );
DBIx-TryAgain
view release on metacpan or search on metacpan
lib/DBIx/TryAgain.pm view on Meta::CPAN
my $dbh = DBI->connect(... dbi params.. { RootClass => "DBIx::TryAgain" } ) or die $DBI::errstr;
$dbh->try_again_algorithm('fibonacci');
$dbh->try_again_max_retries(5);
$dbh->try_again_on_messages([ qr/database is locked/i ]);
$dbh->try_again_on_prepare(1);
=head1 DESCRIPTION
This is a subclass of DBI which simply tries to execute a query
again whenever the error string matches a given set of patterns.
By default the only pattern is qr[database is locked], which is
what is returned by SQLite when the database is locked.
There is a delay between retries. Setting try_again_algorithm
to 'constant', 'linear', 'fibonacci', or 'exponential' causes
the corresponding algorithm to be used. The first five
values for these algorithsm are :
( run in 0.982 second using v1.01-cache-2.11-cpan-49f99fa48dc )