Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Fixed large file support under Linux. I'm unable to test under Windows. Ticket #191. (CVS 790) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
9864a1265b5a37c12b0dd8446d81b84c |
User & Date: | drh 2002-12-01 02:00:58.000 |
Context
2002-12-02
| ||
04:25 | Change to the pager to avoid opening journal files unnecessarily. This can sometimes results in a significant speed improvement. (CVS 791) (check-in: fa5c042585 user: drh tags: trunk) | |
2002-12-01
| ||
02:00 | Fixed large file support under Linux. I'm unable to test under Windows. Ticket #191. (CVS 790) (check-in: 9864a1265b user: drh tags: trunk) | |
2002-11-24
| ||
14:52 | Add the "space_used.tcl" script to the tools directory. This script is used to measure how much disk space is used by each table and index of a database. (CVS 789) (check-in: 83b2c27a56 user: drh tags: trunk) | |
Changes
Changes to src/os.c.
︙ | ︙ | |||
35 36 37 38 39 40 41 | #if OS_WIN # include <winbase.h> #endif /* ** Macros for performance tracing. Normally turned off */ | | | | | > > | 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 | #if OS_WIN # include <winbase.h> #endif /* ** Macros for performance tracing. Normally turned off */ #if 1 static int last_page = 0; #define SEEK(X) last_page=(X) #define TRACE1(X) fprintf(stderr,X) #define TRACE2(X,Y) fprintf(stderr,X,Y) #define TRACE3(X,Y,Z) fprintf(stderr,X,Y,Z) #else #define SEEK(X) #define TRACE1(X) #define TRACE2(X,Y) #define TRACE3(X,Y,Z) #endif #if OS_UNIX /* ** Here is the dirt on POSIX advisory locks: ANSI STD 1003.1 (1996) ** section 6.5.2.2 lines 483 through 490 specify that when a process |
︙ | ︙ | |||
229 230 231 232 233 234 235 | ** ** On success, a handle for the open file is written to *id ** and *pReadonly is set to 0 if the file was opened for reading and ** writing or 1 if the file was opened read-only. The function returns ** SQLITE_OK. ** ** On failure, the function returns SQLITE_CANTOPEN and leaves | | | 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 | ** ** On success, a handle for the open file is written to *id ** and *pReadonly is set to 0 if the file was opened for reading and ** writing or 1 if the file was opened read-only. The function returns ** SQLITE_OK. ** ** On failure, the function returns SQLITE_CANTOPEN and leaves ** *id and *pReadonly unchanged. */ int sqliteOsOpenReadWrite( const char *zFilename, OsFile *id, int *pReadonly ){ #if OS_UNIX |
︙ | ︙ | |||
491 492 493 494 495 496 497 498 499 500 501 502 503 504 | }else{ return SQLITE_IOERR; } #endif #if OS_WIN DWORD got; SimulateIOError(SQLITE_IOERR); if( !ReadFile(id->h, pBuf, amt, &got, 0) ){ got = 0; } if( got==(DWORD)amt ){ return SQLITE_OK; }else{ return SQLITE_IOERR; | > | 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 | }else{ return SQLITE_IOERR; } #endif #if OS_WIN DWORD got; SimulateIOError(SQLITE_IOERR); TRACE2("READ %d\n", last_page); if( !ReadFile(id->h, pBuf, amt, &got, 0) ){ got = 0; } if( got==(DWORD)amt ){ return SQLITE_OK; }else{ return SQLITE_IOERR; |
︙ | ︙ | |||
524 525 526 527 528 529 530 531 532 533 534 535 536 537 | } return SQLITE_OK; #endif #if OS_WIN int rc; DWORD wrote; SimulateIOError(SQLITE_IOERR); while( amt>0 && (rc = WriteFile(id->h, pBuf, amt, &wrote, 0))!=0 && wrote>0 ){ amt -= wrote; pBuf = &((char*)pBuf)[wrote]; } if( !rc || amt>(int)wrote ){ return SQLITE_FULL; } | > | 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 | } return SQLITE_OK; #endif #if OS_WIN int rc; DWORD wrote; SimulateIOError(SQLITE_IOERR); TRACE2("WRITE %d\n", last_page); while( amt>0 && (rc = WriteFile(id->h, pBuf, amt, &wrote, 0))!=0 && wrote>0 ){ amt -= wrote; pBuf = &((char*)pBuf)[wrote]; } if( !rc || amt>(int)wrote ){ return SQLITE_FULL; } |
︙ | ︙ | |||
547 548 549 550 551 552 553 | #if OS_UNIX lseek(id->fd, offset, SEEK_SET); return SQLITE_OK; #endif #if OS_WIN { LONG upperBits = offset>>32; | > > | > | 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 | #if OS_UNIX lseek(id->fd, offset, SEEK_SET); return SQLITE_OK; #endif #if OS_WIN { LONG upperBits = offset>>32; LONG lowerBits = offset & 0xffffffff; DWORD rc; rc = SetFilePointer(id->h, lowerBits, &upperBits, FILE_BEGIN); TRACE3("SEEK rc=0x%x upper=0x%x\n", rc, upperBits); } return SQLITE_OK; #endif } /* ** Make sure all writes to a particular file are committed to disk. |
︙ | ︙ |
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.59 2002/12/01 02:00:58 drh Exp $ */ #include "os.h" /* Must be first to enable large file support */ #include "sqliteInt.h" #include "pager.h" #include <assert.h> #include <string.h> |
︙ | ︙ | |||
391 392 393 394 395 396 397 | ** at the same time, if there is one. */ pPg = pager_lookup(pPager, pgRec.pgno); if( pPg ){ memcpy(PGHDR_TO_DATA(pPg), pgRec.aData, SQLITE_PAGE_SIZE); memset(PGHDR_TO_EXTRA(pPg), 0, pPager->nExtra); } | | | 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 | ** at the same time, if there is one. */ pPg = pager_lookup(pPager, pgRec.pgno); if( pPg ){ memcpy(PGHDR_TO_DATA(pPg), pgRec.aData, SQLITE_PAGE_SIZE); memset(PGHDR_TO_EXTRA(pPg), 0, pPager->nExtra); } rc = sqliteOsSeek(&pPager->fd, (pgRec.pgno-1)*(off_t)SQLITE_PAGE_SIZE); if( rc==SQLITE_OK ){ rc = sqliteOsWrite(&pPager->fd, pgRec.aData, SQLITE_PAGE_SIZE); } return rc; } /* |
︙ | ︙ | |||
830 831 832 833 834 835 836 | ** appear on the disk. We have experimented with sorting the pages ** by page numbers so that they are written in order, but that does ** not appear to improve performance. */ for(pPg=pPager->pFirst; pPg; pPg=pPg->pNextFree){ if( pPg->dirty ){ if( lastPgno==0 || pPg->pgno!=lastPgno+1 ){ | | | 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 | ** appear on the disk. We have experimented with sorting the pages ** by page numbers so that they are written in order, but that does ** not appear to improve performance. */ for(pPg=pPager->pFirst; pPg; pPg=pPg->pNextFree){ if( pPg->dirty ){ if( lastPgno==0 || pPg->pgno!=lastPgno+1 ){ sqliteOsSeek(&pPager->fd, (pPg->pgno-1)*(off_t)SQLITE_PAGE_SIZE); } rc = sqliteOsWrite(&pPager->fd, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE); if( rc!=SQLITE_OK ) break; pPg->dirty = 0; lastPgno = pPg->pgno; } } |
︙ | ︙ | |||
1057 1058 1059 1060 1061 1062 1063 | pPg->pNextHash->pPrevHash = pPg; } if( pPager->dbSize<0 ) sqlitepager_pagecount(pPager); if( pPager->dbSize<(int)pgno ){ memset(PGHDR_TO_DATA(pPg), 0, SQLITE_PAGE_SIZE); }else{ int rc; | | | 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 | pPg->pNextHash->pPrevHash = pPg; } if( pPager->dbSize<0 ) sqlitepager_pagecount(pPager); if( pPager->dbSize<(int)pgno ){ memset(PGHDR_TO_DATA(pPg), 0, SQLITE_PAGE_SIZE); }else{ int rc; sqliteOsSeek(&pPager->fd, (pgno-1)*(off_t)SQLITE_PAGE_SIZE); rc = sqliteOsRead(&pPager->fd, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE); if( rc!=SQLITE_OK ){ off_t fileSize; if( sqliteOsFileSize(&pPager->fd,&fileSize)!=SQLITE_OK || fileSize>=pgno*SQLITE_PAGE_SIZE ){ return rc; }else{ |
︙ | ︙ | |||
1453 1454 1455 1456 1457 1458 1459 | return rc; } if( pPager->needSync && sqliteOsSync(&pPager->jfd)!=SQLITE_OK ){ goto commit_abort; } for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ if( pPg->dirty==0 ) continue; | | | 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 | return rc; } if( pPager->needSync && sqliteOsSync(&pPager->jfd)!=SQLITE_OK ){ goto commit_abort; } for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ if( pPg->dirty==0 ) continue; rc = sqliteOsSeek(&pPager->fd, (pPg->pgno-1)*(off_t)SQLITE_PAGE_SIZE); if( rc!=SQLITE_OK ) goto commit_abort; rc = sqliteOsWrite(&pPager->fd, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE); if( rc!=SQLITE_OK ) goto commit_abort; } if( !pPager->noSync && sqliteOsSync(&pPager->fd)!=SQLITE_OK ){ goto commit_abort; } |
︙ | ︙ |
Changes to src/test2.c.
︙ | ︙ | |||
9 10 11 12 13 14 15 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** Code for testing the pager.c module in SQLite. This code ** is not included in the SQLite library. It is used for automated ** testing of the SQLite library. ** | | > | 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** Code for testing the pager.c module in SQLite. This code ** is not included in the SQLite library. It is used for automated ** testing of the SQLite library. ** ** $Id: test2.c,v 1.12 2002/12/01 02:00:58 drh Exp $ */ #include "os.h" #include "sqliteInt.h" #include "pager.h" #include "tcl.h" #include <stdlib.h> #include <string.h> /* |
︙ | ︙ | |||
467 468 469 470 471 472 473 474 475 476 477 478 479 480 | Tcl_AppendResult(interp, errorName(rc), 0); return TCL_ERROR; } strncpy((char*)pPage, argv[2], SQLITE_PAGE_SIZE-1); ((char*)pPage)[SQLITE_PAGE_SIZE-1] = 0; return TCL_OK; } /* ** Register commands with the TCL interpreter. */ int Sqlitetest2_Init(Tcl_Interp *interp){ extern int sqlite_io_error_pending; static struct { | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 | Tcl_AppendResult(interp, errorName(rc), 0); return TCL_ERROR; } strncpy((char*)pPage, argv[2], SQLITE_PAGE_SIZE-1); ((char*)pPage)[SQLITE_PAGE_SIZE-1] = 0; return TCL_OK; } /* ** Usage: fake_big_file N FILENAME ** ** Write a few bytes at the N megabyte point of FILENAME. This will ** create a large file. If the file was a valid SQLite database, then ** the next time the database is opened, SQLite will begin allocating ** new pages after N. If N is 2096 or bigger, this will test the ** ability of SQLite to write to large files. */ static int fake_big_file( void *NotUsed, Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ int argc, /* Number of arguments */ const char **argv /* Text of each argument */ ){ int rc; int n; off_t offset; OsFile fd; int readOnly = 0; if( argc!=3 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " N-MEGABYTES FILE\"", 0); return TCL_ERROR; } if( Tcl_GetInt(interp, argv[1], &n) ) return TCL_ERROR; rc = sqliteOsOpenReadWrite(argv[2], &fd, &readOnly); if( rc ){ Tcl_AppendResult(interp, "open failed: ", errorName(rc), 0); return TCL_ERROR; } offset = n; offset *= 1024*1024; rc = sqliteOsSeek(&fd, offset); if( rc ){ Tcl_AppendResult(interp, "seek failed: ", errorName(rc), 0); return TCL_ERROR; } rc = sqliteOsWrite(&fd, "Hello, World!", 14); if( rc ){ Tcl_AppendResult(interp, "write failed: ", errorName(rc), 0); return TCL_ERROR; } sqliteOsClose(&fd); return TCL_OK; } /* ** Register commands with the TCL interpreter. */ int Sqlitetest2_Init(Tcl_Interp *interp){ extern int sqlite_io_error_pending; static struct { |
︙ | ︙ | |||
492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 | { "pager_pagecount", (Tcl_CmdProc*)pager_pagecount }, { "page_get", (Tcl_CmdProc*)page_get }, { "page_lookup", (Tcl_CmdProc*)page_lookup }, { "page_unref", (Tcl_CmdProc*)page_unref }, { "page_read", (Tcl_CmdProc*)page_read }, { "page_write", (Tcl_CmdProc*)page_write }, { "page_number", (Tcl_CmdProc*)page_number }, }; int i; for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){ Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0); } Tcl_LinkVar(interp, "sqlite_io_error_pending", (char*)&sqlite_io_error_pending, TCL_LINK_INT); #ifdef SQLITE_TEST Tcl_LinkVar(interp, "pager_old_format", (char*)&pager_old_format, TCL_LINK_INT); #endif return TCL_OK; } | > | 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 | { "pager_pagecount", (Tcl_CmdProc*)pager_pagecount }, { "page_get", (Tcl_CmdProc*)page_get }, { "page_lookup", (Tcl_CmdProc*)page_lookup }, { "page_unref", (Tcl_CmdProc*)page_unref }, { "page_read", (Tcl_CmdProc*)page_read }, { "page_write", (Tcl_CmdProc*)page_write }, { "page_number", (Tcl_CmdProc*)page_number }, { "fake_big_file", (Tcl_CmdProc*)fake_big_file }, }; int i; for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){ Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0); } Tcl_LinkVar(interp, "sqlite_io_error_pending", (char*)&sqlite_io_error_pending, TCL_LINK_INT); #ifdef SQLITE_TEST Tcl_LinkVar(interp, "pager_old_format", (char*)&pager_old_format, TCL_LINK_INT); #endif return TCL_OK; } |
Added test/bigfile.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 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 | # 2002 November 30 # # 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 implements regression tests for SQLite library. The # focus of this script testing the ability of SQLite to handle database # files larger than 4GB. # # $Id: bigfile.test,v 1.1 2002/12/01 02:00:58 drh Exp $ # set testdir [file dirname $argv0] source $testdir/tester.tcl # This is the md5 checksum of all the data in table t1 as created # by the first test. We will use this number to make sure that data # never changes. # set MAGIC_SUM {593f1efcfdbe698c28b4b1b693f7e4cf} do_test bigfile-1.1 { execsql { BEGIN; CREATE TABLE t1(x); INSERT INTO t1 VALUES('abcdefghijklmnopqrstuvwxyz'); INSERT INTO t1 SELECT rowid || ' ' || x FROM t1; INSERT INTO t1 SELECT rowid || ' ' || x FROM t1; INSERT INTO t1 SELECT rowid || ' ' || x FROM t1; INSERT INTO t1 SELECT rowid || ' ' || x FROM t1; INSERT INTO t1 SELECT rowid || ' ' || x FROM t1; INSERT INTO t1 SELECT rowid || ' ' || x FROM t1; INSERT INTO t1 SELECT rowid || ' ' || x FROM t1; COMMIT; } execsql { SELECT md5sum(x) FROM t1; } } $::MAGIC_SUM do_test bigfile-1.2 { db close fake_big_file 4096 test.db sqlite db test.db execsql { SELECT md5sum(x) FROM t1; } } $::MAGIC_SUM # The previous test may fail on some systems because they are unable # to handle large files. If that is so, then skip all of the following # tests. We will know the above test failed because the "db" command # does not exist. # if {[llength [info command db]]>0} { do_test bigfile-1.3 { execsql { CREATE TABLE t2 AS SELECT * FROM t1; SELECT md5sum(x) FROM t2; } } $::MAGIC_SUM do_test bigfile-1.4 { db close sqlite db test.db execsql { SELECT md5sum(x) FROM t1; } } $::MAGIC_SUM do_test bigfile-1.5 { execsql { SELECT md5sum(x) FROM t2; } } $::MAGIC_SUM do_test bigfile-1.6 { db close fake_big_file 8192 test.db sqlite db test.db execsql { SELECT md5sum(x) FROM t1; } } $::MAGIC_SUM do_test bigfile-1.7 { execsql { CREATE TABLE t3 AS SELECT * FROM t1; SELECT md5sum(x) FROM t3; } } $::MAGIC_SUM do_test bigfile-1.8 { db close sqlite db test.db execsql { SELECT md5sum(x) FROM t1; } } $::MAGIC_SUM do_test bigfile-1.9 { execsql { SELECT md5sum(x) FROM t2; } } $::MAGIC_SUM do_test bigfile-1.10 { execsql { SELECT md5sum(x) FROM t3; } } $::MAGIC_SUM do_test bigfile-1.11 { db close fake_big_file 16384 test.db sqlite db test.db execsql { SELECT md5sum(x) FROM t1; } } $::MAGIC_SUM do_test bigfile-1.12 { execsql { CREATE TABLE t4 AS SELECT * FROM t1; SELECT md5sum(x) FROM t4; } } $::MAGIC_SUM do_test bigfile-1.13 { db close sqlite db test.db execsql { SELECT md5sum(x) FROM t1; } } $::MAGIC_SUM do_test bigfile-1.14 { execsql { SELECT md5sum(x) FROM t2; } } $::MAGIC_SUM do_test bigfile-1.15 { execsql { SELECT md5sum(x) FROM t3; } } $::MAGIC_SUM do_test bigfile-1.16 { execsql { SELECT md5sum(x) FROM t3; } } $::MAGIC_SUM } ;# End of the "if( db command exists )" finish_test |