Add file test_quota.c, demonstrating how file-system quotas may be implemented as a VFS wrapper.
FossilOrigin-Name: 383eb87bbf560b20682dd5be0e18ddadf762f415
This commit is contained in:
parent
bd2aaf9ab1
commit
8cf35eb449
1
main.mk
1
main.mk
@ -245,6 +245,7 @@ TESTSRC = \
|
||||
$(TOP)/src/test_onefile.c \
|
||||
$(TOP)/src/test_osinst.c \
|
||||
$(TOP)/src/test_pcache.c \
|
||||
$(TOP)/src/test_quota.c \
|
||||
$(TOP)/src/test_rtree.c \
|
||||
$(TOP)/src/test_schema.c \
|
||||
$(TOP)/src/test_server.c \
|
||||
|
21
manifest
21
manifest
@ -1,5 +1,5 @@
|
||||
C Fix\ssome\scompiler\swarnings\sunder\sMSVC.
|
||||
D 2010-09-01T02:38:22
|
||||
C Add\sfile\stest_quota.c,\sdemonstrating\show\sfile-system\squotas\smay\sbe\simplemented\sas\sa\sVFS\swrapper.
|
||||
D 2010-09-01T11:40:05
|
||||
F Makefile.arm-wince-mingw32ce-gcc d6df77f1f48d690bd73162294bbba7f59507c72f
|
||||
F Makefile.in c599a15d268b1db2aeadea19df2adc3bf2eb6bee
|
||||
F Makefile.linux-gcc 91d710bdc4998cb015f39edf3cb314ec4f4d7e23
|
||||
@ -96,7 +96,7 @@ F ext/rtree/tkt3363.test 142ab96eded44a3615ec79fba98c7bde7d0f96de
|
||||
F ext/rtree/viewrtree.tcl eea6224b3553599ae665b239bd827e182b466024
|
||||
F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895 x
|
||||
F ltmain.sh 3ff0879076df340d2e23ae905484d8c15d5fdea8
|
||||
F main.mk e5a8d2441a4949abfc73bb3fe752c65fb2f8a62c
|
||||
F main.mk 1c6b2152dab78cc0c9f74958968c87fea232254c
|
||||
F mkdll.sh 7d09b23c05d56532e9d44a50868eb4b12ff4f74a
|
||||
F mkextu.sh 416f9b7089d80e5590a29692c9d9280a10dbad9f
|
||||
F mkextw.sh 4123480947681d9b434a5e7b1ee08135abe409ac
|
||||
@ -179,7 +179,7 @@ F src/sqliteInt.h 4e31d3b58720d6251e08ba394641b9a63725eb8a
|
||||
F src/sqliteLimit.h a17dcd3fb775d63b64a43a55c54cb282f9726f44
|
||||
F src/status.c 496913d4e8441195f6f2a75b1c95993a45b9b30b
|
||||
F src/table.c 2cd62736f845d82200acfa1287e33feb3c15d62e
|
||||
F src/tclsqlite.c 3a6687806193a2610eb7c4c2d282493ff5c8d96c
|
||||
F src/tclsqlite.c e91019fb6787166abca23a81b16c07fecc2ed751
|
||||
F src/test1.c c1b74b15b55051e7004ede9233e4b2b323e8ba65
|
||||
F src/test2.c 80d323d11e909cf0eb1b6fbb4ac22276483bcf31
|
||||
F src/test3.c 056093cfef69ff4227a6bdb9108564dc7f45e4bc
|
||||
@ -208,6 +208,7 @@ F src/test_mutex.c ce06b59aca168cd8c520b77159a24352a7469bd3
|
||||
F src/test_onefile.c 40cf9e212a377a6511469384a64b01e6e34b2eec
|
||||
F src/test_osinst.c f408c6a181f2fb04c56273afd5c3e1e82f60392c
|
||||
F src/test_pcache.c 7bf828972ac0d2403f5cfa4cd14da41f8ebe73d8
|
||||
F src/test_quota.c 43b7e1b2bec8fa259bc3717f67b9f5c8026724ed
|
||||
F src/test_rtree.c e957a603a98871dcf005c1e96ae791cfe74eb7f6
|
||||
F src/test_schema.c 8c06ef9ddb240c7a0fcd31bc221a6a2aade58bf0
|
||||
F src/test_server.c bbba05c144b5fc4b52ff650a4328027b3fa5fcc6
|
||||
@ -561,6 +562,7 @@ F test/printf.test 05970cde31b1a9f54bd75af60597be75a5c54fea
|
||||
F test/progress.test 5b075c3c790c7b2a61419bc199db87aaf48b8301
|
||||
F test/ptrchng.test ef1aa72d6cf35a2bbd0869a649b744e9d84977fc
|
||||
F test/quick.test 1681febc928d686362d50057c642f77a02c62e57
|
||||
F test/quota.test 0026c53f3ad78094f478c5e7048fb63602d59ee7
|
||||
F test/quote.test 215897dbe8de1a6f701265836d6601cc6ed103e6
|
||||
F test/randexpr1.tcl 40dec52119ed3a2b8b2a773bce24b63a3a746459
|
||||
F test/randexpr1.test 1084050991e9ba22c1c10edd8d84673b501cc25a
|
||||
@ -851,7 +853,10 @@ F tool/speedtest2.tcl ee2149167303ba8e95af97873c575c3e0fab58ff
|
||||
F tool/speedtest8.c 2902c46588c40b55661e471d7a86e4dd71a18224
|
||||
F tool/speedtest8inst1.c 293327bc76823f473684d589a8160bde1f52c14e
|
||||
F tool/vdbe-compress.tcl d70ea6d8a19e3571d7ab8c9b75cba86d1173ff0f
|
||||
P 631423677bd7043e99987edc633005443125181c
|
||||
R 05e5b03d9444a84913fc1df09eed54da
|
||||
U shaneh
|
||||
Z d536f60f29570cdd4e12c9463729e891
|
||||
P afdc82a99eba260aed8ae2cca4bcec629f384098
|
||||
R f576cc3079f8c23a4490d6ed337ce008
|
||||
T *branch * experimental
|
||||
T *sym-experimental *
|
||||
T -sym-trunk *
|
||||
U dan
|
||||
Z da8e3747f889e65babc56beff4831221
|
||||
|
@ -1 +1 @@
|
||||
afdc82a99eba260aed8ae2cca4bcec629f384098
|
||||
383eb87bbf560b20682dd5be0e18ddadf762f415
|
@ -3577,6 +3577,7 @@ static void init_all(Tcl_Interp *interp){
|
||||
extern int Sqlitetestvfs_Init(Tcl_Interp *);
|
||||
extern int SqlitetestStat_Init(Tcl_Interp*);
|
||||
extern int Sqlitetestrtree_Init(Tcl_Interp*);
|
||||
extern int Sqlitequota_Init(Tcl_Interp*);
|
||||
|
||||
Sqliteconfig_Init(interp);
|
||||
Sqlitetest1_Init(interp);
|
||||
@ -3606,6 +3607,7 @@ static void init_all(Tcl_Interp *interp){
|
||||
Sqlitetestvfs_Init(interp);
|
||||
SqlitetestStat_Init(interp);
|
||||
Sqlitetestrtree_Init(interp);
|
||||
Sqlitequota_Init(interp);
|
||||
|
||||
Tcl_CreateObjCommand(interp,"load_testfixture_extensions",init_all_cmd,0,0);
|
||||
|
||||
|
819
src/test_quota.c
Normal file
819
src/test_quota.c
Normal file
@ -0,0 +1,819 @@
|
||||
/*
|
||||
** 2010 September 31
|
||||
**
|
||||
** The author disclaims copyright to this source code. In place of
|
||||
** a legal notice, here is a blessing:
|
||||
**
|
||||
** May you do good and not evil.
|
||||
** May you find forgiveness for yourself and forgive others.
|
||||
** May you share freely, never taking more than you give.
|
||||
**
|
||||
*************************************************************************
|
||||
**
|
||||
** This file contains a VFS "shim" - a layer that sits in between the
|
||||
** pager and the real VFS.
|
||||
**
|
||||
** This particular shim enforces a quota system on files. One or more
|
||||
** database files are in a "quota group" that is defined by a GLOB
|
||||
** pattern. A quota is set for the combined size of all files in the
|
||||
** the group. A quota of zero means "no limit". If the total size
|
||||
** of all files in the quota group is met or exceeded, then new
|
||||
** write requests that attempt to enlarge a file fail with SQLITE_FULL.
|
||||
**
|
||||
** However, before returning SQLITE_FULL, the write requests invoke
|
||||
** a callback function that is configurable for each quota group.
|
||||
** This callback has the opportunity to enlarge the quota. If the
|
||||
** callback does enlarge the quota such that the total size of all
|
||||
** files within the group is less than the new quota, then the write
|
||||
** continues as if nothing had happened.
|
||||
*/
|
||||
#include "sqlite3.h"
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
/************************ Object Definitions ******************************/
|
||||
|
||||
/*
|
||||
** This module contains a table of filename patterns that have size
|
||||
** quotas. The quota applies to the sum of the sizes of all open
|
||||
** database files whose names match the GLOB pattern.
|
||||
**
|
||||
** Each quota is an instance of the following object. Quotas must
|
||||
** be established (using sqlite3_quota_set()) prior to opening any
|
||||
** of the database connections that access files governed by the
|
||||
** quota.
|
||||
**
|
||||
** Each entry in the quota table is an instance of the following object.
|
||||
*/
|
||||
typedef struct quotaGroup quotaGroup;
|
||||
struct quotaGroup {
|
||||
const char *zPattern; /* Filename pattern to be quotaed */
|
||||
sqlite3_int64 iLimit; /* Upper bound on total file size */
|
||||
sqlite3_int64 iSize; /* Current size of all files */
|
||||
void (*xCallback)( /* Callback invoked when going over quota */
|
||||
const char *zFilename, /* Name of file whose size increases */
|
||||
sqlite3_int64 *piLimit, /* IN/OUT: The current limit */
|
||||
sqlite3_int64 iSize, /* Total size of all files in the group */
|
||||
void *pArg /* Client data */
|
||||
);
|
||||
void *pArg; /* Third argument to the xCallback() */
|
||||
int nRef; /* Number of files in the group references. */
|
||||
quotaGroup *pNext, **ppPrev; /* Doubly linked list of all quota objects */
|
||||
};
|
||||
|
||||
/*
|
||||
** An instance of the following object represents each file that
|
||||
** participates in quota tracking. The sqlite3_file object for the
|
||||
** underlying VFS is appended to this structure.
|
||||
*/
|
||||
typedef struct quotaFile quotaFile;
|
||||
struct quotaFile {
|
||||
sqlite3_file base; /* Base class - must be first */
|
||||
const char *zFilename; /* Name of this file */
|
||||
quotaGroup *pGroup; /* Upper bound on file size */
|
||||
sqlite3_int64 iSize; /* Current size of this file */
|
||||
/* The underlying VFS sqlite3_file is appended to this object */
|
||||
};
|
||||
|
||||
/************************* Global Variables **********************************/
|
||||
/*
|
||||
** All global variables used by this file are containing within the following
|
||||
** gQuota structure.
|
||||
*/
|
||||
static struct {
|
||||
/* The pOrigVfs is a pointer to the real underlying VFS implementation.
|
||||
** Most operations pass-through to the real VFS. This value is read-only
|
||||
** during operation. It is only modified at start-time and thus does not
|
||||
** require a mutex.
|
||||
*/
|
||||
sqlite3_vfs *pOrigVfs;
|
||||
|
||||
/* The sThisVfs is the VFS structure used by this shim. It is initialized
|
||||
** at start-time and thus does not require a mutex
|
||||
*/
|
||||
sqlite3_vfs sThisVfs;
|
||||
|
||||
/* The sIoMethods defines the methods used by sqlite3_file objects
|
||||
** associated with this shim. It is initialized at start-time and does
|
||||
** not require a mutex.
|
||||
**
|
||||
** When the underlying VFS is called to open a file, it might return
|
||||
** either a version 1 or a version 2 sqlite3_file object. This shim
|
||||
** has to create a wrapper sqlite3_file of the same version. Hence
|
||||
** there are two I/O method structures, one for version 1 and the other
|
||||
** for version 2.
|
||||
*/
|
||||
sqlite3_io_methods sIoMethodsV1;
|
||||
sqlite3_io_methods sIoMethodsV2;
|
||||
|
||||
/* True when this shim as been initialized.
|
||||
*/
|
||||
int isInitialized;
|
||||
|
||||
/* For run-time access any of the other global data structures in this
|
||||
** shim, the following mutex must be held.
|
||||
*/
|
||||
sqlite3_mutex *pMutex;
|
||||
|
||||
/* List of quotaGroup objects.
|
||||
*/
|
||||
quotaGroup *pGroup;
|
||||
|
||||
} gQuota;
|
||||
|
||||
/************************* Utility Routines *********************************/
|
||||
/*
|
||||
** Acquire and release the mutex used to serialize access to the
|
||||
** list of quotaGroups.
|
||||
*/
|
||||
static void quotaEnter(void){ sqlite3_mutex_enter(gQuota.pMutex); }
|
||||
static void quotaLeave(void){ sqlite3_mutex_leave(gQuota.pMutex); }
|
||||
|
||||
|
||||
/* If the reference count and threshold for a quotaGroup are both
|
||||
** zero, then destroy the quotaGroup.
|
||||
*/
|
||||
static void quotaGroupDeref(quotaGroup *p){
|
||||
if( p->nRef==0 && p->iLimit==0 ){
|
||||
if( p->pNext ) p->pNext->ppPrev = p->ppPrev;
|
||||
if( p->ppPrev ) *p->ppPrev = p->pNext;
|
||||
sqlite3_free(p);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
** Return TRUE if string z matches glob pattern zGlob.
|
||||
**
|
||||
** Globbing rules:
|
||||
**
|
||||
** '*' Matches any sequence of zero or more characters.
|
||||
**
|
||||
** '?' Matches exactly one character.
|
||||
**
|
||||
** [...] Matches one character from the enclosed list of
|
||||
** characters.
|
||||
**
|
||||
** [^...] Matches one character not in the enclosed list.
|
||||
**
|
||||
*/
|
||||
static int strglob(const char *zGlob, const char *z){
|
||||
int c, c2;
|
||||
int invert;
|
||||
int seen;
|
||||
|
||||
while( (c = (*(zGlob++)))!=0 ){
|
||||
if( c=='*' ){
|
||||
while( (c=(*(zGlob++))) == '*' || c=='?' ){
|
||||
if( c=='?' && (*(z++))==0 ) return 0;
|
||||
}
|
||||
if( c==0 ){
|
||||
return 1;
|
||||
}else if( c=='[' ){
|
||||
while( *z && strglob(zGlob-1,z)==0 ){
|
||||
z++;
|
||||
}
|
||||
return (*z)!=0;
|
||||
}
|
||||
while( (c2 = (*(z++)))!=0 ){
|
||||
while( c2!=c ){
|
||||
c2 = *(z++);
|
||||
if( c2==0 ) return 0;
|
||||
}
|
||||
if( strglob(zGlob,z) ) return 1;
|
||||
}
|
||||
return 0;
|
||||
}else if( c=='?' ){
|
||||
if( (*(z++))==0 ) return 0;
|
||||
}else if( c=='[' ){
|
||||
int prior_c = 0;
|
||||
seen = 0;
|
||||
invert = 0;
|
||||
c = *(z++);
|
||||
if( c==0 ) return 0;
|
||||
c2 = *(zGlob++);
|
||||
if( c2=='^' ){
|
||||
invert = 1;
|
||||
c2 = *(zGlob++);
|
||||
}
|
||||
if( c2==']' ){
|
||||
if( c==']' ) seen = 1;
|
||||
c2 = *(zGlob++);
|
||||
}
|
||||
while( c2 && c2!=']' ){
|
||||
if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){
|
||||
c2 = *(zGlob++);
|
||||
if( c>=prior_c && c<=c2 ) seen = 1;
|
||||
prior_c = 0;
|
||||
}else{
|
||||
if( c==c2 ){
|
||||
seen = 1;
|
||||
}
|
||||
prior_c = c2;
|
||||
}
|
||||
c2 = *(zGlob++);
|
||||
}
|
||||
if( c2==0 || (seen ^ invert)==0 ) return 0;
|
||||
}else{
|
||||
if( c!=(*(z++)) ) return 0;
|
||||
}
|
||||
}
|
||||
return *z==0;
|
||||
}
|
||||
|
||||
|
||||
/* Find a quotaGroup given the filename.
|
||||
**
|
||||
** Return a pointer to the quotaFile object. Return NULL if not found.
|
||||
*/
|
||||
static quotaGroup *quotaGroupFind(const char *zFilename){
|
||||
quotaGroup *p;
|
||||
for(p=gQuota.pGroup; p && strglob(p->zPattern, zFilename)==0; p=p->pNext){}
|
||||
return p;
|
||||
}
|
||||
|
||||
/* Translate an sqlite3_file* that is really a quotaFile* into
|
||||
** an sqlite3_file* for the underlying original VFS.
|
||||
*/
|
||||
static sqlite3_file *quotaSubFile(sqlite3_file *pFile){
|
||||
quotaFile *p = (quotaFile*)pFile;
|
||||
return (sqlite3_file*)&p[1];
|
||||
}
|
||||
|
||||
/************************* VFS Method Wrappers *****************************/
|
||||
/*
|
||||
** This is the xOpen method used for the "quota" VFS.
|
||||
**
|
||||
** Most of the work is done by the underlying original VFS. This method
|
||||
** simply links the new file into the quota group if it is a file that
|
||||
** needs to be tracked.
|
||||
*/
|
||||
static int quotaOpen(
|
||||
sqlite3_vfs *pVfs,
|
||||
const char *zName,
|
||||
sqlite3_file *pFile,
|
||||
int flags,
|
||||
int *pOutFlags
|
||||
){
|
||||
int rc;
|
||||
quotaFile *pQuotaFile;
|
||||
quotaGroup *pGroup;
|
||||
sqlite3_file *pSubFile;
|
||||
sqlite3_vfs *pOrigVfs = gQuota.pOrigVfs;
|
||||
|
||||
/* If the file is not a main database file or a WAL, then use the
|
||||
** normal xOpen method.
|
||||
*/
|
||||
if( (flags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_WAL))==0 ){
|
||||
return pOrigVfs->xOpen(pOrigVfs, zName, pFile, flags, pOutFlags);
|
||||
}
|
||||
|
||||
/* If the name of the file does not match any quota group, then
|
||||
** use the normal xOpen method.
|
||||
*/
|
||||
quotaEnter();
|
||||
pGroup = quotaGroupFind(zName);
|
||||
if( pGroup==0 ){
|
||||
rc = pOrigVfs->xOpen(pOrigVfs, zName, pFile, flags, pOutFlags);
|
||||
}else{
|
||||
/* If we get to this point, it means the file needs to be quota tracked.
|
||||
*/
|
||||
pQuotaFile = (quotaFile*)pFile;
|
||||
pSubFile = quotaSubFile(pFile);
|
||||
rc = pOrigVfs->xOpen(pOrigVfs, zName, pSubFile, flags, pOutFlags);
|
||||
if( rc==SQLITE_OK ){
|
||||
pQuotaFile->iSize = 0;
|
||||
pQuotaFile->pGroup = pGroup;
|
||||
pGroup->nRef++;
|
||||
pQuotaFile->zFilename = zName;
|
||||
if( pSubFile->pMethods->iVersion==1 ){
|
||||
pQuotaFile->base.pMethods = &gQuota.sIoMethodsV1;
|
||||
}else{
|
||||
pQuotaFile->base.pMethods = &gQuota.sIoMethodsV2;
|
||||
}
|
||||
}
|
||||
}
|
||||
quotaLeave();
|
||||
return rc;
|
||||
}
|
||||
|
||||
/************************ I/O Method Wrappers *******************************/
|
||||
|
||||
/* xClose requests get passed through to the original VFS. But we
|
||||
** also have to unlink the quotaFile from the quotaGroup.
|
||||
*/
|
||||
static int quotaClose(sqlite3_file *pFile){
|
||||
quotaFile *p = (quotaFile*)pFile;
|
||||
quotaGroup *pGroup = p->pGroup;
|
||||
sqlite3_file *pSubFile = quotaSubFile(pFile);
|
||||
int rc;
|
||||
rc = pSubFile->pMethods->xClose(pSubFile);
|
||||
quotaEnter();
|
||||
pGroup->nRef--;
|
||||
pGroup->iSize -= p->iSize;
|
||||
quotaGroupDeref(pGroup);
|
||||
quotaLeave();
|
||||
return rc;
|
||||
}
|
||||
|
||||
/* Pass xRead requests directory thru to the original VFS without
|
||||
** further processing.
|
||||
*/
|
||||
static int quotaRead(
|
||||
sqlite3_file *pFile,
|
||||
void *pBuf,
|
||||
int iAmt,
|
||||
sqlite3_int64 iOfst
|
||||
){
|
||||
sqlite3_file *pSubFile = quotaSubFile(pFile);
|
||||
return pSubFile->pMethods->xRead(pSubFile, pBuf, iAmt, iOfst);
|
||||
}
|
||||
|
||||
/* Check xWrite requests to see if they expand the file. If they do,
|
||||
** the perform a quota check before passing them through to the
|
||||
** original VFS.
|
||||
*/
|
||||
static int quotaWrite(
|
||||
sqlite3_file *pFile,
|
||||
const void *pBuf,
|
||||
int iAmt,
|
||||
sqlite3_int64 iOfst
|
||||
){
|
||||
quotaFile *p = (quotaFile*)pFile;
|
||||
sqlite3_file *pSubFile = quotaSubFile(pFile);
|
||||
sqlite3_int64 iEnd = iOfst+iAmt;
|
||||
quotaGroup *pGroup;
|
||||
sqlite3_int64 szNew;
|
||||
|
||||
if( p->iSize<iEnd ){
|
||||
pGroup = p->pGroup;
|
||||
quotaEnter();
|
||||
szNew = pGroup->iSize - p->iSize + iEnd;
|
||||
if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){
|
||||
if( pGroup->xCallback ){
|
||||
pGroup->xCallback(p->zFilename, &pGroup->iLimit, szNew,
|
||||
pGroup->pArg);
|
||||
}
|
||||
if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){
|
||||
quotaLeave();
|
||||
return SQLITE_FULL;
|
||||
}
|
||||
}
|
||||
pGroup->iSize = szNew;
|
||||
p->iSize = iEnd;
|
||||
quotaLeave();
|
||||
}
|
||||
return pSubFile->pMethods->xWrite(pSubFile, pBuf, iAmt, iOfst);
|
||||
}
|
||||
|
||||
/* Pass xTruncate requests thru to the original VFS. If the
|
||||
** success, update the file size.
|
||||
*/
|
||||
static int quotaTruncate(sqlite3_file *pFile, sqlite3_int64 size){
|
||||
quotaFile *p = (quotaFile*)pFile;
|
||||
sqlite3_file *pSubFile = quotaSubFile(pFile);
|
||||
int rc = pSubFile->pMethods->xTruncate(pSubFile, size);
|
||||
quotaGroup *pGroup = p->pGroup;
|
||||
if( rc==SQLITE_OK ){
|
||||
quotaEnter();
|
||||
pGroup->iSize -= p->iSize;
|
||||
p->iSize = size;
|
||||
pGroup->iSize += size;
|
||||
quotaLeave();
|
||||
}
|
||||
return rc;
|
||||
}
|
||||
|
||||
/* Pass xSync requests through to the original VFS without change
|
||||
*/
|
||||
static int quotaSync(sqlite3_file *pFile, int flags){
|
||||
sqlite3_file *pSubFile = quotaSubFile(pFile);
|
||||
return pSubFile->pMethods->xSync(pSubFile, flags);
|
||||
}
|
||||
|
||||
/* Pass xFileSize requests through to the original VFS but then
|
||||
** update the quotaGroup with the new size before returning.
|
||||
*/
|
||||
static int quotaFileSize(sqlite3_file *pFile, sqlite3_int64 *pSize){
|
||||
quotaFile *p = (quotaFile*)pFile;
|
||||
sqlite3_file *pSubFile = quotaSubFile(pFile);
|
||||
quotaGroup *pGroup;
|
||||
sqlite3_int64 sz;
|
||||
int rc;
|
||||
|
||||
rc = pSubFile->pMethods->xFileSize(pSubFile, &sz);
|
||||
if( rc==SQLITE_OK ){
|
||||
pGroup = p->pGroup;
|
||||
quotaEnter();
|
||||
pGroup->iSize -= p->iSize;
|
||||
p->iSize = sz;
|
||||
pGroup->iSize += sz;
|
||||
quotaLeave();
|
||||
*pSize = sz;
|
||||
}
|
||||
return rc;
|
||||
}
|
||||
|
||||
/* Pass xLock requests through to the original VFS unchanged.
|
||||
*/
|
||||
static int quotaLock(sqlite3_file *pFile, int lock){
|
||||
sqlite3_file *pSubFile = quotaSubFile(pFile);
|
||||
return pSubFile->pMethods->xLock(pSubFile, lock);
|
||||
}
|
||||
|
||||
/* Pass xUnlock requests through to the original VFS unchanged.
|
||||
*/
|
||||
static int quotaUnlock(sqlite3_file *pFile, int lock){
|
||||
sqlite3_file *pSubFile = quotaSubFile(pFile);
|
||||
return pSubFile->pMethods->xUnlock(pSubFile, lock);
|
||||
}
|
||||
|
||||
/* Pass xCheckReservedLock requests through to the original VFS unchanged.
|
||||
*/
|
||||
static int quotaCheckReservedLock(sqlite3_file *pFile, int *pResOut){
|
||||
sqlite3_file *pSubFile = quotaSubFile(pFile);
|
||||
return pSubFile->pMethods->xCheckReservedLock(pSubFile, pResOut);
|
||||
}
|
||||
|
||||
/* Pass xFileControl requests through to the original VFS unchanged.
|
||||
*/
|
||||
static int quotaFileControl(sqlite3_file *pFile, int op, void *pArg){
|
||||
sqlite3_file *pSubFile = quotaSubFile(pFile);
|
||||
return pSubFile->pMethods->xFileControl(pSubFile, op, pArg);
|
||||
}
|
||||
|
||||
/* Pass xSectorSize requests through to the original VFS unchanged.
|
||||
*/
|
||||
static int quotaSectorSize(sqlite3_file *pFile){
|
||||
sqlite3_file *pSubFile = quotaSubFile(pFile);
|
||||
return pSubFile->pMethods->xSectorSize(pSubFile);
|
||||
}
|
||||
|
||||
/* Pass xDeviceCharacteristics requests through to the original VFS unchanged.
|
||||
*/
|
||||
static int quotaDeviceCharacteristics(sqlite3_file *pFile){
|
||||
sqlite3_file *pSubFile = quotaSubFile(pFile);
|
||||
return pSubFile->pMethods->xDeviceCharacteristics(pSubFile);
|
||||
}
|
||||
|
||||
/* Pass xShmMap requests through to the original VFS unchanged.
|
||||
*/
|
||||
static int quotaShmMap(
|
||||
sqlite3_file *pFile, /* Handle open on database file */
|
||||
int iRegion, /* Region to retrieve */
|
||||
int szRegion, /* Size of regions */
|
||||
int bExtend, /* True to extend file if necessary */
|
||||
void volatile **pp /* OUT: Mapped memory */
|
||||
){
|
||||
sqlite3_file *pSubFile = quotaSubFile(pFile);
|
||||
return pSubFile->pMethods->xShmMap(pSubFile, iRegion, szRegion, bExtend, pp);
|
||||
}
|
||||
|
||||
/* Pass xShmLock requests through to the original VFS unchanged.
|
||||
*/
|
||||
static int quotaShmLock(
|
||||
sqlite3_file *pFile, /* Database file holding the shared memory */
|
||||
int ofst, /* First lock to acquire or release */
|
||||
int n, /* Number of locks to acquire or release */
|
||||
int flags /* What to do with the lock */
|
||||
){
|
||||
sqlite3_file *pSubFile = quotaSubFile(pFile);
|
||||
return pSubFile->pMethods->xShmLock(pSubFile, ofst, n, flags);
|
||||
}
|
||||
|
||||
/* Pass xShmBarrier requests through to the original VFS unchanged.
|
||||
*/
|
||||
static void quotaShmBarrier(sqlite3_file *pFile){
|
||||
sqlite3_file *pSubFile = quotaSubFile(pFile);
|
||||
pSubFile->pMethods->xShmBarrier(pSubFile);
|
||||
}
|
||||
|
||||
/* Pass xShmUnmap requests through to the original VFS unchanged.
|
||||
*/
|
||||
static int quotaShmUnmap(sqlite3_file *pFile, int deleteFlag){
|
||||
sqlite3_file *pSubFile = quotaSubFile(pFile);
|
||||
return pSubFile->pMethods->xShmUnmap(pSubFile, deleteFlag);
|
||||
}
|
||||
|
||||
/************************** Public Interfaces *****************************/
|
||||
/*
|
||||
** Initialize the quota VFS shim. Use the VFS named zOrigVfsName
|
||||
** as the VFS that does the actual work. Use the default if
|
||||
** zOrigVfsName==NULL.
|
||||
**
|
||||
** The quota VFS shim is named "quota". It will become the default
|
||||
** VFS if makeDefault is non-zero.
|
||||
**
|
||||
** THIS ROUTINE IS NOT THREADSAFE. Call this routine exactly once
|
||||
** during start-up.
|
||||
*/
|
||||
int sqlite3_quota_initialize(const char *zOrigVfsName, int makeDefault){
|
||||
sqlite3_vfs *pOrigVfs;
|
||||
if( gQuota.isInitialized ) return SQLITE_MISUSE;
|
||||
pOrigVfs = sqlite3_vfs_find(zOrigVfsName);
|
||||
if( pOrigVfs==0 ) return SQLITE_ERROR;
|
||||
assert( pOrigVfs!=&gQuota.sThisVfs );
|
||||
gQuota.pMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
|
||||
if( !gQuota.pMutex ){
|
||||
return SQLITE_NOMEM;
|
||||
}
|
||||
gQuota.isInitialized = 1;
|
||||
gQuota.pOrigVfs = pOrigVfs;
|
||||
gQuota.sThisVfs = *pOrigVfs;
|
||||
gQuota.sThisVfs.xOpen = quotaOpen;
|
||||
gQuota.sThisVfs.szOsFile += sizeof(quotaFile);
|
||||
gQuota.sThisVfs.zName = "quota";
|
||||
gQuota.sIoMethodsV1.iVersion = 1;
|
||||
gQuota.sIoMethodsV1.xClose = quotaClose;
|
||||
gQuota.sIoMethodsV1.xRead = quotaRead;
|
||||
gQuota.sIoMethodsV1.xWrite = quotaWrite;
|
||||
gQuota.sIoMethodsV1.xTruncate = quotaTruncate;
|
||||
gQuota.sIoMethodsV1.xSync = quotaSync;
|
||||
gQuota.sIoMethodsV1.xFileSize = quotaFileSize;
|
||||
gQuota.sIoMethodsV1.xLock = quotaLock;
|
||||
gQuota.sIoMethodsV1.xUnlock = quotaUnlock;
|
||||
gQuota.sIoMethodsV1.xCheckReservedLock = quotaCheckReservedLock;
|
||||
gQuota.sIoMethodsV1.xFileControl = quotaFileControl;
|
||||
gQuota.sIoMethodsV1.xSectorSize = quotaSectorSize;
|
||||
gQuota.sIoMethodsV1.xDeviceCharacteristics = quotaDeviceCharacteristics;
|
||||
gQuota.sIoMethodsV2 = gQuota.sIoMethodsV1;
|
||||
gQuota.sIoMethodsV2.iVersion = 2;
|
||||
gQuota.sIoMethodsV2.xShmMap = quotaShmMap;
|
||||
gQuota.sIoMethodsV2.xShmLock = quotaShmLock;
|
||||
gQuota.sIoMethodsV2.xShmBarrier = quotaShmBarrier;
|
||||
gQuota.sIoMethodsV2.xShmUnmap = quotaShmUnmap;
|
||||
sqlite3_vfs_register(&gQuota.sThisVfs, makeDefault);
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
** Shutdown the quota system.
|
||||
**
|
||||
** All SQLite database connections must be closed before calling this
|
||||
** routine.
|
||||
**
|
||||
** THIS ROUTINE IS NOT THREADSAFE. Call this routine exactly one while
|
||||
** shutting down in order to free all remaining quota groups.
|
||||
*/
|
||||
int sqlite3_quota_shutdown(void){
|
||||
quotaGroup *p;
|
||||
if( gQuota.isInitialized==0 ) return SQLITE_MISUSE;
|
||||
for(p=gQuota.pGroup; p; p=p->pNext){
|
||||
if( p->nRef ) return SQLITE_MISUSE;
|
||||
}
|
||||
while( gQuota.pGroup ){
|
||||
quotaGroup *p = gQuota.pGroup;
|
||||
gQuota.pGroup = p->pNext;
|
||||
sqlite3_free(p);
|
||||
}
|
||||
gQuota.isInitialized = 0;
|
||||
sqlite3_mutex_free(gQuota.pMutex);
|
||||
sqlite3_vfs_unregister(&gQuota.sThisVfs);
|
||||
memset(&gQuota, 0, sizeof(gQuota));
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
** Create or destroy a quota group.
|
||||
**
|
||||
** The quota group is defined by the zPattern. When calling this routine
|
||||
** with a zPattern for a quota group that already exists, this routine
|
||||
** merely updates the iLimit, xCallback, and pArg values for that quota
|
||||
** group. If zPattern is new, then a new quota group is created.
|
||||
**
|
||||
** If the iLimit for a quota group is set to zero, then the quota group
|
||||
** is disabled and will be deleted when the last database connection using
|
||||
** the quota group is closed.
|
||||
**
|
||||
** Calling this routine on a zPattern that does not exist and with a
|
||||
** zero iLimit is a no-op.
|
||||
**
|
||||
** A quota group must exist with a non-zero iLimit prior to opening
|
||||
** database connections if those connections are to participate in the
|
||||
** quota group. Creating a quota group does not affect database connections
|
||||
** that are already open.
|
||||
*/
|
||||
int sqlite3_quota_set(
|
||||
const char *zPattern, /* The filename pattern */
|
||||
sqlite3_int64 iLimit, /* New quota to set for this quota group */
|
||||
void (*xCallback)( /* Callback invoked when going over quota */
|
||||
const char *zFilename, /* Name of file whose size increases */
|
||||
sqlite3_int64 *piLimit, /* IN/OUT: The current limit */
|
||||
sqlite3_int64 iSize, /* Total size of all files in the group */
|
||||
void *pArg /* Client data */
|
||||
),
|
||||
void *pArg /* client data passed thru to callback */
|
||||
){
|
||||
quotaGroup *pGroup;
|
||||
quotaEnter();
|
||||
pGroup = gQuota.pGroup;
|
||||
while( pGroup && strcmp(pGroup->zPattern, zPattern)!=0 ){
|
||||
pGroup = pGroup->pNext;
|
||||
}
|
||||
if( pGroup==0 && iLimit>0 ){
|
||||
int nPattern = strlen(zPattern);
|
||||
pGroup = sqlite3_malloc( sizeof(*pGroup) + nPattern + 1 );
|
||||
if( pGroup==0 ){
|
||||
quotaLeave();
|
||||
return SQLITE_NOMEM;
|
||||
}
|
||||
memset(pGroup, 0, sizeof(*pGroup));
|
||||
pGroup->zPattern = (char*)&pGroup[1];
|
||||
memcpy((char *)pGroup->zPattern, zPattern, nPattern+1);
|
||||
if( gQuota.pGroup ) gQuota.pGroup->ppPrev = &pGroup->pNext;
|
||||
pGroup->pNext = gQuota.pGroup;
|
||||
pGroup->ppPrev = &gQuota.pGroup;
|
||||
gQuota.pGroup = pGroup;
|
||||
}
|
||||
pGroup->iLimit = iLimit;
|
||||
pGroup->xCallback = xCallback;
|
||||
pGroup->pArg = pArg;
|
||||
quotaGroupDeref(pGroup);
|
||||
quotaLeave();
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
|
||||
/***************************** Test Code ***********************************/
|
||||
#ifdef SQLITE_TEST
|
||||
#include <tcl.h>
|
||||
|
||||
typedef struct TclQuotaCallback TclQuotaCallback;
|
||||
struct TclQuotaCallback {
|
||||
Tcl_Interp *interp;
|
||||
Tcl_Obj *pScript;
|
||||
TclQuotaCallback *pNext;
|
||||
};
|
||||
static TclQuotaCallback *pQuotaCallbackList = 0;
|
||||
|
||||
extern const char *sqlite3TestErrorName(int);
|
||||
|
||||
static void tclQuotaCallback(
|
||||
const char *zFilename, /* Name of file whose size increases */
|
||||
sqlite3_int64 *piLimit, /* IN/OUT: The current limit */
|
||||
sqlite3_int64 iSize, /* Total size of all files in the group */
|
||||
void *pArg /* Client data */
|
||||
){
|
||||
TclQuotaCallback *p; /* Callback script object */
|
||||
Tcl_Obj *pEval; /* Script to evaluate */
|
||||
Tcl_Obj *pVarname; /* Name of variable to pass as 2nd arg */
|
||||
unsigned int rnd; /* Random part of pVarname */
|
||||
int rc; /* Tcl error code */
|
||||
|
||||
p = (TclQuotaCallback *)pArg;
|
||||
|
||||
pVarname = Tcl_NewStringObj("::piLimit_", -1);
|
||||
Tcl_IncrRefCount(pVarname);
|
||||
sqlite3_randomness(sizeof(rnd), (void *)&rnd);
|
||||
Tcl_AppendObjToObj(pVarname, Tcl_NewIntObj((int)(rnd&0x7FFFFFFF)));
|
||||
Tcl_ObjSetVar2(p->interp, pVarname, 0, Tcl_NewWideIntObj(*piLimit), 0);
|
||||
|
||||
pEval = Tcl_DuplicateObj(p->pScript);
|
||||
Tcl_IncrRefCount(pEval);
|
||||
Tcl_ListObjAppendElement(0, pEval, Tcl_NewStringObj(zFilename, -1));
|
||||
Tcl_ListObjAppendElement(0, pEval, pVarname);
|
||||
Tcl_ListObjAppendElement(0, pEval, Tcl_NewWideIntObj(iSize));
|
||||
rc = Tcl_EvalObjEx(p->interp, pEval, TCL_EVAL_GLOBAL);
|
||||
|
||||
if( rc==TCL_OK ){
|
||||
Tcl_Obj *pLimit = Tcl_ObjGetVar2(p->interp, pVarname, 0, 0);
|
||||
rc = Tcl_GetWideIntFromObj(p->interp, pLimit, piLimit);
|
||||
Tcl_UnsetVar(p->interp, Tcl_GetString(pVarname), 0);
|
||||
}
|
||||
|
||||
Tcl_DecrRefCount(pEval);
|
||||
Tcl_DecrRefCount(pVarname);
|
||||
if( rc!=TCL_OK ) Tcl_BackgroundError(p->interp);
|
||||
}
|
||||
|
||||
/*
|
||||
** tclcmd: sqlite3_quota_initialize NAME MAKEDEFAULT
|
||||
*/
|
||||
static int test_quota_initialize(
|
||||
void * clientData,
|
||||
Tcl_Interp *interp,
|
||||
int objc,
|
||||
Tcl_Obj *CONST objv[]
|
||||
){
|
||||
const char *zName; /* Name of new quota VFS */
|
||||
int makeDefault; /* True to make the new VFS the default */
|
||||
int rc; /* Value returned by quota_initialize() */
|
||||
|
||||
/* Process arguments */
|
||||
if( objc!=3 ){
|
||||
Tcl_WrongNumArgs(interp, 1, objv, "NAME MAKEDEFAULT");
|
||||
return TCL_ERROR;
|
||||
}
|
||||
zName = Tcl_GetString(objv[1]);
|
||||
if( Tcl_GetBooleanFromObj(interp, objv[2], &makeDefault) ) return TCL_ERROR;
|
||||
if( zName[0]=='\0' ) zName = 0;
|
||||
|
||||
/* Call sqlite3_quota_initialize() */
|
||||
rc = sqlite3_quota_initialize(zName, makeDefault);
|
||||
Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
|
||||
|
||||
return TCL_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
** tclcmd: sqlite3_quota_shutdown
|
||||
*/
|
||||
static int test_quota_shutdown(
|
||||
void * clientData,
|
||||
Tcl_Interp *interp,
|
||||
int objc,
|
||||
Tcl_Obj *CONST objv[]
|
||||
){
|
||||
int rc; /* Value returned by quota_shutdown() */
|
||||
|
||||
if( objc!=1 ){
|
||||
Tcl_WrongNumArgs(interp, 1, objv, "");
|
||||
return TCL_ERROR;
|
||||
}
|
||||
|
||||
/* Call sqlite3_quota_shutdown() */
|
||||
rc = sqlite3_quota_shutdown();
|
||||
Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
|
||||
|
||||
/* If the quota system was successfully shut down, delete all the quota
|
||||
** callback script objects in the global linked list.
|
||||
*/
|
||||
if( rc==SQLITE_OK ){
|
||||
TclQuotaCallback *p, *pNext;
|
||||
for(p=pQuotaCallbackList; p; p=pNext){
|
||||
pNext = p->pNext;
|
||||
Tcl_DecrRefCount(p->pScript);
|
||||
ckfree((char *)p);
|
||||
}
|
||||
pQuotaCallbackList = 0;
|
||||
}
|
||||
|
||||
return TCL_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
** tclcmd: sqlite3_quota_set PATTERN LIMIT SCRIPT
|
||||
*/
|
||||
static int test_quota_set(
|
||||
void * clientData,
|
||||
Tcl_Interp *interp,
|
||||
int objc,
|
||||
Tcl_Obj *CONST objv[]
|
||||
){
|
||||
const char *zPattern; /* File pattern to configure */
|
||||
sqlite3_int64 iLimit; /* Initial quota in bytes */
|
||||
Tcl_Obj *pScript; /* Tcl script to invoke to increase quota */
|
||||
int rc; /* Value returned by quota_set() */
|
||||
TclQuotaCallback *p; /* Callback object */
|
||||
|
||||
/* Process arguments */
|
||||
if( objc!=4 ){
|
||||
Tcl_WrongNumArgs(interp, 1, objv, "PATTERN LIMIT SCRIPT");
|
||||
return TCL_ERROR;
|
||||
}
|
||||
zPattern = Tcl_GetString(objv[1]);
|
||||
if( Tcl_GetWideIntFromObj(interp, objv[2], &iLimit) ) return TCL_ERROR;
|
||||
pScript = objv[3];
|
||||
|
||||
/* Allocate a TclQuotaCallback object */
|
||||
p = (TclQuotaCallback *)ckalloc(sizeof(TclQuotaCallback));
|
||||
memset(p, 0, sizeof(TclQuotaCallback));
|
||||
|
||||
/* Invoke sqlite3_quota_set() */
|
||||
rc = sqlite3_quota_set(zPattern, iLimit, tclQuotaCallback, (void *)p);
|
||||
if( rc!=SQLITE_OK ){
|
||||
ckfree((char *)p);
|
||||
}else{
|
||||
Tcl_IncrRefCount(pScript);
|
||||
p->interp = interp;
|
||||
p->pScript = pScript;
|
||||
p->pNext = pQuotaCallbackList;
|
||||
pQuotaCallbackList = p;
|
||||
}
|
||||
|
||||
Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
|
||||
return TCL_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
** This routine registers the custom TCL commands defined in this
|
||||
** module. This should be the only procedure visible from outside
|
||||
** of this module.
|
||||
*/
|
||||
int Sqlitequota_Init(Tcl_Interp *interp){
|
||||
static struct {
|
||||
char *zName;
|
||||
Tcl_ObjCmdProc *xProc;
|
||||
} aCmd[] = {
|
||||
{ "sqlite3_quota_initialize", test_quota_initialize },
|
||||
{ "sqlite3_quota_shutdown", test_quota_shutdown },
|
||||
{ "sqlite3_quota_set", test_quota_set },
|
||||
};
|
||||
int i;
|
||||
|
||||
for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
|
||||
Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
|
||||
}
|
||||
|
||||
return TCL_OK;
|
||||
}
|
||||
#endif
|
150
test/quota.test
Normal file
150
test/quota.test
Normal file
@ -0,0 +1,150 @@
|
||||
# 2010 September 1
|
||||
#
|
||||
# The author disclaims copyright to this source code. In place of
|
||||
# a legal notice, here is a blessing:
|
||||
#
|
||||
# May you do good and not evil.
|
||||
# May you find forgiveness for yourself and forgive others.
|
||||
# May you share freely, never taking more than you give.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
|
||||
db close
|
||||
|
||||
do_test quota-1.1 { sqlite3_quota_initialize nosuchvfs 1 } {SQLITE_ERROR}
|
||||
do_test quota-1.2 { sqlite3_quota_initialize "" 1 } {SQLITE_OK}
|
||||
do_test quota-1.3 { sqlite3_quota_initialize "" 1 } {SQLITE_MISUSE}
|
||||
do_test quota-1.4 { sqlite3_quota_shutdown } {SQLITE_OK}
|
||||
|
||||
do_test quota-1.5 { sqlite3_quota_initialize "" 0 } {SQLITE_OK}
|
||||
do_test quota-1.6 { sqlite3_quota_shutdown } {SQLITE_OK}
|
||||
do_test quota-1.7 { sqlite3_quota_initialize "" 1 } {SQLITE_OK}
|
||||
do_test quota-1.8 { sqlite3_quota_shutdown } {SQLITE_OK}
|
||||
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Some simple warm-body tests with a single database file in rollback
|
||||
# mode:
|
||||
#
|
||||
# quota-2.1.*: Test that SQLITE_FULL is returned if the database would
|
||||
# exceed the configured quota.
|
||||
#
|
||||
# quota-2.2.*: Test that SQLITE_FULL is not returned and the database
|
||||
# grows if the callback extends the quota when the database
|
||||
# attempts to grow beyond the configured quota.
|
||||
#
|
||||
# quota-2.3.*: Open and close a db that is not part of any quota group. At
|
||||
# one point this was causing mutex refs to be leaked.
|
||||
#
|
||||
# quota-2.4.*: Try to shutdown the quota system before closing the db
|
||||
# file. Check that this fails and the quota system still works
|
||||
# afterwards. Then close the database and successfully shut
|
||||
# down the quota system.
|
||||
#
|
||||
sqlite3_quota_initialize "" 1
|
||||
|
||||
proc quota_check {filename limitvar size} {
|
||||
upvar $limitvar limit
|
||||
|
||||
lappend ::quota [set limit] $size
|
||||
if {[info exists ::quota_request_ok]} { set limit $size }
|
||||
}
|
||||
|
||||
do_test quota-2.1.1 {
|
||||
sqlite3_quota_set *test.db 4096 quota_check
|
||||
} {SQLITE_OK}
|
||||
do_test quota-2.1.2 {
|
||||
sqlite3 db test.db
|
||||
execsql {
|
||||
PRAGMA page_size=1024;
|
||||
PRAGMA auto_vacuum=OFF;
|
||||
PRAGMA journal_mode=DELETE;
|
||||
}
|
||||
set ::quota [list]
|
||||
execsql {
|
||||
CREATE TABLE t1(a, b);
|
||||
INSERT INTO t1 VALUES(1, randomblob(1100));
|
||||
INSERT INTO t1 VALUES(2, randomblob(1100));
|
||||
}
|
||||
set ::quota
|
||||
} {}
|
||||
do_test quota-2.1.3 { file size test.db } {4096}
|
||||
do_test quota-2.1.4 {
|
||||
catchsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
|
||||
} {1 {database or disk is full}}
|
||||
do_test quota-2.1.5 { set ::quota } {4096 5120}
|
||||
|
||||
set ::quota_request_ok 1
|
||||
set ::quota [list]
|
||||
do_test quota-2.2.1 {
|
||||
execsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
|
||||
} {}
|
||||
do_test quota-2.2.2 { set ::quota } {4096 5120}
|
||||
do_test quota-2.2.3 { file size test.db } {5120}
|
||||
unset ::quota_request_ok
|
||||
|
||||
do_test quota-2.3.1 {
|
||||
sqlite3 db2 bak.db
|
||||
db2 close
|
||||
} {}
|
||||
|
||||
do_test quota-2.4.1 {
|
||||
sqlite3_quota_shutdown
|
||||
} {SQLITE_MISUSE}
|
||||
set ::quota [list]
|
||||
do_test quota-2.4.2 {
|
||||
catchsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
|
||||
} {1 {database or disk is full}}
|
||||
do_test quota-2.4.3 { set ::quota } {5120 6144}
|
||||
do_test quota-2.4.4 { file size test.db } {5120}
|
||||
do_test quota-2.4.5 {
|
||||
db close
|
||||
sqlite3_quota_shutdown
|
||||
} {SQLITE_OK}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Try some tests with more than one connection to a database file. Still
|
||||
# in rollback mode.
|
||||
#
|
||||
proc quota_check {filename limitvar size} {
|
||||
upvar $limitvar limit
|
||||
lappend ::quota [set limit] $size
|
||||
if {[info exists ::quota_request_ok]} { set limit $size }
|
||||
}
|
||||
|
||||
do_test quota-3.1.1 {
|
||||
file delete -force test.db
|
||||
sqlite3_quota_initialize "" 1
|
||||
sqlite3_quota_set *test.db 4096 quota_check
|
||||
} {SQLITE_OK}
|
||||
|
||||
do_test quota-3.1.2 {
|
||||
sqlite3 db test.db
|
||||
execsql {
|
||||
PRAGMA page_size = 1024;
|
||||
PRAGMA journal_mode = delete;
|
||||
PRAGMA auto_vacuum = off;
|
||||
CREATE TABLE t1(a PRIMARY KEY, b);
|
||||
INSERT INTO t1 VALUES(1, 'one');
|
||||
}
|
||||
file size test.db
|
||||
} {3072}
|
||||
do_test quota-3.1.3 {
|
||||
sqlite3 db2 test.db
|
||||
set ::quota [list]
|
||||
execsql { CREATE TABLE t2(a, b) } db2
|
||||
set ::quota
|
||||
} {}
|
||||
|
||||
do_test quota-3.X {
|
||||
catch { db close }
|
||||
catch { db2 close }
|
||||
sqlite3_quota_shutdown
|
||||
} {SQLITE_OK}
|
||||
finish_test
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user