Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Add os_test.c. Not activated yet. (CVS 1655) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
d16b863849d1aa887fe403e25153b1e9 |
User & Date: | danielk1977 2004-06-22 11:29:02.000 |
Context
2004-06-22
| ||
12:13 | Patch around compilers that do not support "long long int". (CVS 1656) (check-in: d98b1502e2 user: drh tags: trunk) | |
11:29 | Add os_test.c. Not activated yet. (CVS 1655) (check-in: d16b863849 user: danielk1977 tags: trunk) | |
2004-06-21
| ||
21:49 | configure fixes for cygwin (line endings in configure.ac) ticket #772 (CVS 1654) (check-in: 819a5973d1 user: dougcurrie tags: trunk) | |
Changes
Changes to main.mk.
︙ | ︙ | |||
52 53 54 55 56 57 58 | # TCCX = $(TCC) $(OPTS) $(THREADSAFE) $(USLEEP) -I. -I$(TOP)/src # Object files for the SQLite library. # LIBOBJ = attach.o auth.o btree.o build.o date.o delete.o \ expr.o func.o hash.o insert.o \ | | | 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 | # TCCX = $(TCC) $(OPTS) $(THREADSAFE) $(USLEEP) -I. -I$(TOP)/src # Object files for the SQLite library. # LIBOBJ = attach.o auth.o btree.o build.o date.o delete.o \ expr.o func.o hash.o insert.o \ main.o opcodes.o os_mac.o os_unix.o os_win.o os_test.o \ pager.o parse.o pragma.o printf.o random.o \ select.o table.o tclsqlite.o tokenize.o trigger.o \ update.o util.o vacuum.o \ vdbe.o vdbeapi.o vdbeaux.o vdbemem.o \ where.o utf.o legacy.o # All of the source code files. |
︙ | ︙ | |||
268 269 270 271 272 273 274 275 276 277 278 279 280 281 | echo '/* Automatically generated file. Do not edit */' >opcodes.h grep '^case OP_' $(TOP)/src/vdbe.c | \ sed -e 's/://' | \ awk '{printf "#define %-30s %3d\n", $$2, ++cnt}' >>opcodes.h os_mac.o: $(TOP)/src/os_mac.c $(HDR) $(TCCX) -c $(TOP)/src/os_mac.c os_unix.o: $(TOP)/src/os_unix.c $(HDR) $(TCCX) -c $(TOP)/src/os_unix.c os_win.o: $(TOP)/src/os_win.c $(HDR) $(TCCX) -c $(TOP)/src/os_win.c | > > > | 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 | echo '/* Automatically generated file. Do not edit */' >opcodes.h grep '^case OP_' $(TOP)/src/vdbe.c | \ sed -e 's/://' | \ awk '{printf "#define %-30s %3d\n", $$2, ++cnt}' >>opcodes.h os_mac.o: $(TOP)/src/os_mac.c $(HDR) $(TCCX) -c $(TOP)/src/os_mac.c os_test.o: $(TOP)/src/os_test.c $(HDR) $(TCCX) -c $(TOP)/src/os_test.c os_unix.o: $(TOP)/src/os_unix.c $(HDR) $(TCCX) -c $(TOP)/src/os_unix.c os_win.o: $(TOP)/src/os_win.c $(HDR) $(TCCX) -c $(TOP)/src/os_win.c |
︙ | ︙ | |||
350 351 352 353 354 355 356 357 358 359 360 361 362 363 | $(TCCX) $(TCL_FLAGS) -DTCLSH=1 -o tclsqlite3 \ $(TOP)/src/tclsqlite.c libsqlite3.a $(LIBTCL) testfixture$(EXE): $(TOP)/src/tclsqlite.c libsqlite3.a $(TESTSRC) $(TCCX) $(TCL_FLAGS) -DTCLSH=1 -DSQLITE_TEST=1 -o testfixture$(EXE) \ $(TESTSRC) $(TOP)/src/tclsqlite.c \ libsqlite3.a $(LIBTCL) $(THREADLIB) fulltest: testfixture$(EXE) sqlite3$(EXE) ./testfixture$(EXE) $(TOP)/test/all.test test: testfixture$(EXE) sqlite3$(EXE) ./testfixture$(EXE) $(TOP)/test/quick.test | > > > > > | 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 | $(TCCX) $(TCL_FLAGS) -DTCLSH=1 -o tclsqlite3 \ $(TOP)/src/tclsqlite.c libsqlite3.a $(LIBTCL) testfixture$(EXE): $(TOP)/src/tclsqlite.c libsqlite3.a $(TESTSRC) $(TCCX) $(TCL_FLAGS) -DTCLSH=1 -DSQLITE_TEST=1 -o testfixture$(EXE) \ $(TESTSRC) $(TOP)/src/tclsqlite.c \ libsqlite3.a $(LIBTCL) $(THREADLIB) testfixturex: $(TOP)/src/tclsqlite.c libsqlite3.a $(TESTSRC) $(TCCX) $(TCL_FLAGS) -DOS_TEST=1 -DTCLSH=1 -DSQLITE_TEST=1 -o testfixture$(EXE) \ $(TESTSRC) $(TOP)/src/tclsqlite.c \ libsqlite3.a $(LIBTCL) $(THREADLIB) fulltest: testfixture$(EXE) sqlite3$(EXE) ./testfixture$(EXE) $(TOP)/test/all.test test: testfixture$(EXE) sqlite3$(EXE) ./testfixture$(EXE) $(TOP)/test/quick.test |
︙ | ︙ |
Changes to src/os.h.
︙ | ︙ | |||
19 20 21 22 23 24 25 | /* ** Figure out if we are dealing with Unix, Windows or MacOS. ** ** N.B. MacOS means Mac Classic (or Carbon). Treat Darwin (OS X) as Unix. ** The MacOS build is designed to use CodeWarrior (tested with v8) */ | | | 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | /* ** Figure out if we are dealing with Unix, Windows or MacOS. ** ** N.B. MacOS means Mac Classic (or Carbon). Treat Darwin (OS X) as Unix. ** The MacOS build is designed to use CodeWarrior (tested with v8) */ #if !defined(OS_UNIX) && !defined(OS_TEST) # ifndef OS_WIN # ifndef OS_MAC # if defined(__MACOS__) # define OS_MAC 1 # define OS_WIN 0 # define OS_UNIX 0 # elif defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__) |
︙ | ︙ | |||
53 54 55 56 57 58 59 60 61 62 63 64 65 66 | # define OS_WIN 0 # endif #endif /* ** Invoke the appropriate operating-system specific header file. */ #if OS_UNIX # include "os_unix.h" #endif #if OS_WIN # include "os_win.h" #endif #if OS_MAC | > > > | 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | # define OS_WIN 0 # endif #endif /* ** Invoke the appropriate operating-system specific header file. */ #if OS_TEST # include "os_test.h" #endif #if OS_UNIX # include "os_unix.h" #endif #if OS_WIN # include "os_win.h" #endif #if OS_MAC |
︙ | ︙ | |||
150 151 152 153 154 155 156 | #define RESERVED_BYTE (PENDING_BYTE+1) #define SHARED_FIRST (PENDING_BYTE+2) #define SHARED_SIZE 510 int sqlite3OsDelete(const char*); int sqlite3OsFileExists(const char*); | < | 153 154 155 156 157 158 159 160 161 162 163 164 165 166 | #define RESERVED_BYTE (PENDING_BYTE+1) #define SHARED_FIRST (PENDING_BYTE+2) #define SHARED_SIZE 510 int sqlite3OsDelete(const char*); int sqlite3OsFileExists(const char*); int sqlite3OsOpenReadWrite(const char*, OsFile*, int*); int sqlite3OsOpenExclusive(const char*, OsFile*, int); int sqlite3OsOpenReadOnly(const char*, OsFile*); int sqlite3OsOpenDirectory(const char*, OsFile*); int sqlite3OsSyncDirectory(const char*); int sqlite3OsTempFileName(char*); int sqlite3OsClose(OsFile*); |
︙ | ︙ |
Added src/os_test.c.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 | /* ** 2004 May 22 ** ** 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 code that is specific to Unix systems. It is used ** for testing SQLite only. */ #include "os.h" /* Must be first to enable large file support */ #if OS_TEST /* This file is used for the test backend only */ #include "sqliteInt.h" #define sqlite3OsOpenReadWrite sqlite3RealOpenReadWrite #define sqlite3OsOpenExclusive sqlite3RealOpenExclusive #define sqlite3OsOpenReadOnly sqlite3RealOpenReadOnly #define sqlite3OsOpenDirectory sqlite3RealOpenDirectory #define sqlite3OsClose sqlite3RealClose #define sqlite3OsRead sqlite3RealRead #define sqlite3OsWrite sqlite3RealWrite #define sqlite3OsSeek sqlite3RealSeek #define sqlite3OsSync sqlite3RealSync #define sqlite3OsTruncate sqlite3RealTruncate #define sqlite3OsFileSize sqlite3RealFileSize #define sqlite3OsFileModTime sqlite3RealFileModTime #define sqlite3OsLock sqlite3RealLock #define sqlite3OsUnlock sqlite3RealUnlock #define sqlite3OsCheckReservedLock sqlite3RealCheckReservedLock #define OsFile OsRealFile #define OS_UNIX 1 #include "os_unix.c" #undef OS_UNIX #undef OsFile #undef sqlite3OsOpenReadWrite #undef sqlite3OsOpenExclusive #undef sqlite3OsOpenReadOnly #undef sqlite3OsOpenDirectory #undef sqlite3OsClose #undef sqlite3OsRead #undef sqlite3OsWrite #undef sqlite3OsSeek #undef sqlite3OsSync #undef sqlite3OsTruncate #undef sqlite3OsFileSize #undef sqlite3OsFileModTime #undef sqlite3OsLock #undef sqlite3OsUnlock #undef sqlite3OsCheckReservedLock #define BLOCKSIZE 512 #define BLOCK_OFFSET(x) ((x) * BLOCKSIZE) /* ** The crash-seed. Accessed via functions crashseed() and ** sqlite3SetCrashseed(). */ static int crashseed_var = 0; /* ** This function is used to set the value of the 'crash-seed' integer. ** ** If the crash-seed is 0, the default value, then whenever sqlite3OsSync() ** or sqlite3OsClose() is called, the write cache is written to disk before ** the os_unix.c Sync() or Close() function is called. ** ** If the crash-seed is non-zero, then it is used to determine a subset of ** the write-cache to actually write to disk before calling Sync() or ** Close() in os_unix.c. The actual subset of writes selected is not ** significant, except that it is constant for a given value of the ** crash-seed and cache contents. Before returning, exit(-1) is invoked. */ void sqlite3SetCrashseed(int seed){ sqlite3OsEnterMutex(); crashseed_var = seed; sqlite3OsLeaveMutex(); } /* ** Retrieve the current value of the crash-seed. */ static int crashseed(){ int i; sqlite3OsEnterMutex(); i = crashseed_var; sqlite3OsLeaveMutex(); return i; } /* ** Initialise the os_test.c specific fields of pFile. */ static void initFile(OsFile *pFile){ pFile->nMaxWrite = 0; pFile->nBlk = 0; pFile->apBlk = 0; } /* ** Return the current seek offset from the start of the file. This ** is unix-only code. */ static off_t osTell(OsFile *pFile){ return lseek(pFile->fd.h, 0, SEEK_CUR); } /* ** Load block 'blk' into the cache of pFile. */ static int cacheBlock(OsFile *pFile, int blk){ if( blk>=pFile->nBlk ){ int n = ((pFile->nBlk * 2) + 100 + blk); pFile->apBlk = (u8 **)sqliteRealloc(pFile->apBlk, n * sizeof(u8*)); if( !pFile->apBlk ) return SQLITE_NOMEM; pFile->nBlk = n; } if( !pFile->apBlk[blk] ){ off_t filesize; int rc; u8 *p = sqliteMalloc(BLOCKSIZE); if( !p ) return SQLITE_NOMEM; pFile->apBlk[blk] = p; rc = sqlite3RealFileSize(&pFile->fd, &filesize); if( rc!=SQLITE_OK ) return rc; if( BLOCK_OFFSET(blk)<filesize ){ int len = BLOCKSIZE; rc = sqlite3RealSeek(&pFile->fd, blk*BLOCKSIZE); if( BLOCK_OFFSET(blk+1)>filesize ){ len = filesize - BLOCK_OFFSET(blk); } if( rc!=SQLITE_OK ) return rc; rc = sqlite3RealRead(&pFile->fd, p, len); if( rc!=SQLITE_OK ) return rc; } } return SQLITE_OK; } /* ** Write the cache of pFile to disk. If crash is non-zero, randomly ** skip blocks when writing. The cache is deleted before returning. */ static int writeCache2(OsFile *pFile, int crash){ int i; int nMax = pFile->nMaxWrite; off_t offset; int rc = SQLITE_OK; offset = osTell(pFile); for(i=0; i<pFile->nBlk; i++){ u8 *p = pFile->apBlk[i]; if( p ){ int skip = 0; if( crash ){ char random; sqlite3Randomness(1, &random); if( random & 0x01 ) skip = 1; } if( rc==SQLITE_OK ){ rc = sqlite3RealSeek(&pFile->fd, BLOCK_OFFSET(i)); } if( rc==SQLITE_OK && !skip ){ int len = BLOCKSIZE; if( BLOCK_OFFSET(i+1)>nMax ){ len = nMax-BLOCK_OFFSET(i); } rc = sqlite3RealWrite(&pFile->fd, p, len); } sqliteFree(p); } } sqliteFree(pFile->apBlk); pFile->nBlk = 0; pFile->apBlk = 0; pFile->nMaxWrite = 0; if( rc==SQLITE_OK ){ rc = sqlite3RealSeek(&pFile->fd, offset); } return rc; } /* ** Write the cache to disk. */ static int writeCache(OsFile *pFile){ if( crashseed() ){ /* FIX ME: writeCache2() should be called on all open files ** here. */ writeCache2(pFile, 1); exit(-1); }else{ return writeCache2(pFile, 0); } } /* ** Close the file. */ int sqlite3OsClose(OsFile *id){ if( !id->fd.isOpen ) return SQLITE_OK; writeCache(id); sqlite3RealClose(&id->fd); return SQLITE_OK; } int sqlite3OsRead(OsFile *id, void *pBuf, int amt){ off_t offset; /* The current offset from the start of the file */ off_t end; /* The byte just past the last byte read */ int blk; /* Block number the read starts on */ int i; u8 *zCsr; int rc = SQLITE_OK; offset = osTell(id); end = offset+amt; blk = (offset/BLOCKSIZE); zCsr = (u8 *)pBuf; for(i=blk; i*BLOCKSIZE<end; i++){ int off = 0; int len = 0; if( BLOCK_OFFSET(i) < offset ){ off = offset-BLOCK_OFFSET(i); } len = BLOCKSIZE - off; if( BLOCK_OFFSET(i+1) > end ){ len = len - (BLOCK_OFFSET(i+1)-end); } if( i<id->nBlk && id->apBlk[i]){ u8 *pBlk = id->apBlk[i]; memcpy(zCsr, &pBlk[off], len); }else{ rc = sqlite3RealSeek(&id->fd, BLOCK_OFFSET(i) + off); if( rc!=SQLITE_OK ) return rc; rc = sqlite3RealRead(&id->fd, zCsr, len); if( rc!=SQLITE_OK ) return rc; } zCsr += len; } assert( zCsr==&((u8 *)pBuf)[amt] ); rc = sqlite3RealSeek(&id->fd, end); return rc; } int sqlite3OsWrite(OsFile *id, const void *pBuf, int amt){ off_t offset; /* The current offset from the start of the file */ off_t end; /* The byte just past the last byte written */ int blk; /* Block number the write starts on */ int i; const u8 *zCsr; int rc = SQLITE_OK; offset = osTell(id); end = offset+amt; blk = (offset/BLOCKSIZE); zCsr = (u8 *)pBuf; for(i=blk; i*BLOCKSIZE<end; i++){ u8 *pBlk; int off = 0; int len = 0; /* Make sure the block is in the cache */ rc = cacheBlock(id, i); if( rc!=SQLITE_OK ) return rc; /* Write into the cache */ pBlk = id->apBlk[i]; assert( pBlk ); if( BLOCK_OFFSET(i) < offset ){ off = offset-BLOCK_OFFSET(i); } len = BLOCKSIZE - off; if( BLOCK_OFFSET(i+1) > end ){ len = len - (BLOCK_OFFSET(i+1)-end); } memcpy(&pBlk[off], zCsr, len); zCsr += len; } if( id->nMaxWrite<end ){ id->nMaxWrite = end; } assert( zCsr==&((u8 *)pBuf)[amt] ); rc = sqlite3RealSeek(&id->fd, end); return rc; } /* ** Sync the file. First flush the write-cache to disk, then call the ** real sync() function. */ int sqlite3OsSync(OsFile *id){ int rc = writeCache(id); if( rc!=SQLITE_OK ) return rc; rc = sqlite3RealSync(&id->fd); return rc; } /* ** Truncate the file. Set the internal OsFile.nMaxWrite variable to the new ** file size to ensure that nothing in the write-cache past this point ** is written to disk. */ int sqlite3OsTruncate(OsFile *id, off_t nByte){ id->nMaxWrite = nByte; return sqlite3RealTruncate(&id->fd, nByte); } /* ** Return the size of the file. If the cache contains a write that extended ** the file, then return this size instead of the on-disk size. */ int sqlite3OsFileSize(OsFile *id, off_t *pSize){ int rc = sqlite3RealFileSize(&id->fd, pSize); if( rc==SQLITE_OK && pSize && *pSize<id->nMaxWrite ){ *pSize = id->nMaxWrite; } return rc; } /* ** The three functions used to open files. All that is required is to ** initialise the os_test.c specific fields and then call the corresponding ** os_unix.c function to really open the file. */ int sqlite3OsOpenReadWrite(const char *zFilename, OsFile *id, int *pReadonly){ initFile(id); return sqlite3RealOpenReadWrite(zFilename, &id->fd, pReadonly); } int sqlite3OsOpenExclusive(const char *zFilename, OsFile *id, int delFlag){ initFile(id); return sqlite3RealOpenExclusive(zFilename, &id->fd, delFlag); } int sqlite3OsOpenReadOnly(const char *zFilename, OsFile *id){ initFile(id); return sqlite3RealOpenReadOnly(zFilename, &id->fd); } /* ** These six function calls are passed straight through to the os_unix.c ** backend. */ int sqlite3OsSeek(OsFile *id, off_t offset){ return sqlite3RealSeek(&id->fd, offset); } int sqlite3OsCheckReservedLock(OsFile *id){ return sqlite3RealCheckReservedLock(&id->fd); } int sqlite3OsLock(OsFile *id, int locktype){ return sqlite3RealLock(&id->fd, locktype); } int sqlite3OsUnlock(OsFile *id, int locktype){ return sqlite3RealUnlock(&id->fd, locktype); } int sqlite3OsFileModTime(OsFile *id, double *prNow){ return sqlite3RealFileModTime(&id->fd, prNow); } int sqlite3OsOpenDirectory(const char *zDirname, OsFile *id){ return sqlite3RealOpenDirectory(zDirname, &id->fd); } #endif /* OS_TEST */ |
Added src/os_test.h.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | /* ** 2004 May 22 ** ** 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. ** ****************************************************************************** ** */ #ifndef _SQLITE_OS_TEST_H_ #define _SQLITE_OS_TEST_H_ #define OsFile OsRealFile #define OS_UNIX 1 #include "os_unix.h" #undef OS_UNIX #undef OsFile /* Include sqliteInt.h now to get the type u8. */ #include "sqliteInt.h" typedef struct OsFile OsFile; struct OsFile { u8 **apBlk; /* Array of blocks that have been written to. */ int nBlk; /* Size of apBlock. */ int nMaxWrite; /* Largest offset written to. */ OsRealFile fd; }; void sqlite3SetCrashseed(int seed); #endif /* _SQLITE_OS_UNIX_H_ */ |
Changes to src/os_unix.c.
︙ | ︙ | |||
508 509 510 511 512 513 514 | zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; } zBuf[j] = 0; }while( access(zBuf,0)==0 ); return SQLITE_OK; } | < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < | 508 509 510 511 512 513 514 515 516 517 518 519 520 521 | zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; } zBuf[j] = 0; }while( access(zBuf,0)==0 ); return SQLITE_OK; } /* ** Read data from a file into a buffer. Return SQLITE_OK if all ** bytes were read successfully and SQLITE_IOERR if anything goes ** wrong. */ int sqlite3OsRead(OsFile *id, void *pBuf, int amt){ int got; |
︙ | ︙ | |||
938 939 940 941 942 943 944 945 946 947 948 949 950 951 | pOpen->aPending = 0; } } sqlite3OsLeaveMutex(); id->locktype = locktype; return SQLITE_OK; } /* ** Get information to seed the random number generator. The seed ** is written into the buffer zBuf[256]. The calling function must ** supply a sufficiently large buffer. */ int sqlite3OsRandomSeed(char *zBuf){ | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 | pOpen->aPending = 0; } } sqlite3OsLeaveMutex(); id->locktype = locktype; return SQLITE_OK; } /* ** Close a file. */ int sqlite3OsClose(OsFile *id){ if( !id->isOpen ) return SQLITE_OK; sqlite3OsUnlock(id, NO_LOCK); if( id->dirfd>=0 ) close(id->dirfd); id->dirfd = -1; sqlite3OsEnterMutex(); if( id->pOpen->nLock ){ /* If there are outstanding locks, do not actually close the file just ** yet because that would clear those locks. Instead, add the file ** descriptor to pOpen->aPending. It will be automatically closed when ** the last lock is cleared. */ int *aNew; struct openCnt *pOpen = id->pOpen; pOpen->nPending++; aNew = sqliteRealloc( pOpen->aPending, pOpen->nPending*sizeof(int) ); if( aNew==0 ){ /* If a malloc fails, just leak the file descriptor */ }else{ pOpen->aPending = aNew; pOpen->aPending[pOpen->nPending-1] = id->h; } }else{ /* There are no outstanding locks so we can close the file immediately */ close(id->h); } releaseLockInfo(id->pLock); releaseOpenCnt(id->pOpen); sqlite3OsLeaveMutex(); id->isOpen = 0; TRACE2("CLOSE %-3d\n", id->h); OpenCounter(-1); return SQLITE_OK; } /* ** Get information to seed the random number generator. The seed ** is written into the buffer zBuf[256]. The calling function must ** supply a sufficiently large buffer. */ int sqlite3OsRandomSeed(char *zBuf){ |
︙ | ︙ |
Changes to src/pager.c.
︙ | ︙ | |||
14 15 16 17 18 19 20 | ** The pager is used to access a database disk file. It implements ** atomic commit and rollback through the use of a journal file that ** is separate from the database file. The pager also implements file ** locking to prevent two processes from writing the same database ** file simultaneously, or one process from reading the database while ** another is writing. ** | | | 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | ** The pager is used to access a database disk file. It implements ** atomic commit and rollback through the use of a journal file that ** is separate from the database file. The pager also implements file ** locking to prevent two processes from writing the same database ** file simultaneously, or one process from reading the database while ** another is writing. ** ** @(#) $Id: pager.c,v 1.134 2004/06/22 11:29:02 danielk1977 Exp $ */ #include "os.h" /* Must be first to enable large file support */ #include "sqliteInt.h" #include "pager.h" #include <assert.h> #include <string.h> |
︙ | ︙ | |||
2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 | #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) /* ** Return the current state of the file lock for the given pager. ** The return value is one of NO_LOCK, SHARED_LOCK, RESERVED_LOCK, ** PENDING_LOCK, or EXCLUSIVE_LOCK. */ int sqlite3pager_lockstate(Pager *pPager){ return pPager->fd.locktype; } #endif #ifdef SQLITE_TEST /* ** Print a listing of all referenced pages and their ref count. */ | > > > > | 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 | #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) /* ** Return the current state of the file lock for the given pager. ** The return value is one of NO_LOCK, SHARED_LOCK, RESERVED_LOCK, ** PENDING_LOCK, or EXCLUSIVE_LOCK. */ int sqlite3pager_lockstate(Pager *pPager){ #ifdef OS_TEST return pPager->fd.fd.locktype; #else return pPager->fd.locktype; #endif } #endif #ifdef SQLITE_TEST /* ** Print a listing of all referenced pages and their ref count. */ |
︙ | ︙ |
Changes to src/sqliteInt.h.
1 2 3 4 5 6 7 8 9 10 11 12 13 | /* ** 2001 September 15 ** ** 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. ** ************************************************************************* ** Internal interface definitions for SQLite. ** | | > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | /* ** 2001 September 15 ** ** 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. ** ************************************************************************* ** Internal interface definitions for SQLite. ** ** @(#) $Id: sqliteInt.h,v 1.298 2004/06/22 11:29:02 danielk1977 Exp $ */ #ifndef _SQLITEINT_H_ #define _SQLITEINT_H_ #include "config.h" #include "sqlite3.h" #include "hash.h" #include "parse.h" #include <stdio.h> #include <stdlib.h> #include <string.h> |
︙ | ︙ | |||
1393 1394 1395 1396 1397 1398 1399 | const void *sqlite3ValueText(sqlite3_value*, u8); int sqlite3ValueBytes(sqlite3_value*, u8); void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8, void(*)(void*)); void sqlite3ValueFree(sqlite3_value*); sqlite3_value *sqlite3ValueNew(); sqlite3_value *sqlite3GetTransientValue(sqlite *db); | > > | 1396 1397 1398 1399 1400 1401 1402 1403 1404 | const void *sqlite3ValueText(sqlite3_value*, u8); int sqlite3ValueBytes(sqlite3_value*, u8); void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8, void(*)(void*)); void sqlite3ValueFree(sqlite3_value*); sqlite3_value *sqlite3ValueNew(); sqlite3_value *sqlite3GetTransientValue(sqlite *db); #endif |
Changes to src/vdbeaux.c.
︙ | ︙ | |||
671 672 673 674 675 676 677 | } } /* ** Free all resources allociated with AggElem pElem, an element of ** aggregate pAgg. */ | | | 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 | } } /* ** Free all resources allociated with AggElem pElem, an element of ** aggregate pAgg. */ void freeAggElem(AggElem *pElem, Agg *pAgg){ int i; for(i=0; i<pAgg->nMem; i++){ Mem *pMem = &pElem->aMem[i]; if( pAgg->apFunc[i] && (pMem->flags & MEM_AggCtx)!=0 ){ sqlite3_context ctx; ctx.pFunc = pAgg->apFunc[i]; ctx.s.flags = MEM_Null; |
︙ | ︙ | |||
715 716 717 718 719 720 721 | ** ** If db is not NULL, then this is being called from with an OP_AggReset ** opcode. Open the temp-table, if it has not already been opened and ** delete the contents of the table used for aggregate information, ready ** for the next round of aggregate processing. */ int sqlite3VdbeAggReset(sqlite *db, Agg *pAgg, KeyInfo *pKeyInfo){ | < | 715 716 717 718 719 720 721 722 723 724 725 726 727 728 | ** ** If db is not NULL, then this is being called from with an OP_AggReset ** opcode. Open the temp-table, if it has not already been opened and ** delete the contents of the table used for aggregate information, ready ** for the next round of aggregate processing. */ int sqlite3VdbeAggReset(sqlite *db, Agg *pAgg, KeyInfo *pKeyInfo){ int rc = 0; BtCursor *pCsr = pAgg->pCsr; assert( (pCsr && pAgg->nTab>0) || (!pCsr && pAgg->nTab==0) || sqlite3_malloc_failed ); /* If pCsr is not NULL, then the table used for aggregate information |
︙ | ︙ |