Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Change the record format to include an extra varint at the beginning to record the number of bytes in the header. (CVS 1478) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
0c4d138807f367d75b3fb5b2dadf206d |
User & Date: | drh 2004-05-27 19:59:32.000 |
Context
2004-05-27
| ||
23:56 | Add API functions sqlite3_open_varargs(), sqlite3_open16_varargs() and sqlite3_complete16(). (CVS 1479) (check-in: 203af2b2e3 user: danielk1977 tags: trunk) | |
19:59 | Change the record format to include an extra varint at the beginning to record the number of bytes in the header. (CVS 1478) (check-in: 0c4d138807 user: drh tags: trunk) | |
17:22 | Remove the COPY command. (CVS 1477) (check-in: 287f86731c user: drh tags: trunk) | |
Changes
Changes to src/vdbe.c.
︙ | ︙ | |||
39 40 41 42 43 44 45 | ** ** Various scripts scan this source file in order to generate HTML ** documentation, headers files, or other derived files. The formatting ** of the code in this file is, therefore, important. See other comments ** in this file for details. If in doubt, do not deviate from existing ** commenting and indentation practices when changing or adding code. ** | | | 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 | ** ** Various scripts scan this source file in order to generate HTML ** documentation, headers files, or other derived files. The formatting ** of the code in this file is, therefore, important. See other comments ** in this file for details. If in doubt, do not deviate from existing ** commenting and indentation practices when changing or adding code. ** ** $Id: vdbe.c,v 1.341 2004/05/27 19:59:32 drh Exp $ */ #include "sqliteInt.h" #include "os.h" #include <ctype.h> #include "vdbeInt.h" /* |
︙ | ︙ | |||
237 238 239 240 241 242 243 | pTail->pNext = pLeft; }else if( pRight ){ pTail->pNext = pRight; } return sHead.pNext; } | < < < < < < < < < < < < < < < < < < < < < < < < < < | 237 238 239 240 241 242 243 244 245 246 247 248 249 250 | pTail->pNext = pLeft; }else if( pRight ){ pTail->pNext = pRight; } return sHead.pNext; } /* ** Make sure there is space in the Vdbe structure to hold at least ** mxCursor cursors. If there is not currently enough space, then ** allocate more. ** ** If a memory allocation error occurs, return 1. Return 0 if ** everything works. |
︙ | ︙ | |||
1842 1843 1844 1845 1846 1847 1848 | ** next on the stack is used. And so forth. The value pushed is always ** just a pointer into the record which is stored further down on the ** stack. The column value is not copied. The number of columns in the ** record is stored on the stack just above the record itself. */ case OP_Column: { int payloadSize; /* Number of bytes in the record */ | | | | | > > | | | | | < > | < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < > > > > > > > > > > > > > > > | > > < < < < < | < | < | > > | > | | | | | < < < < < < < < < < < | > > > > | > > > > | > | | > > > | > | < | < > | | | | | < > | | > > > > > | > > > > | > > | | > > > | | | | > | > > > < < < < | 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 | ** next on the stack is used. And so forth. The value pushed is always ** just a pointer into the record which is stored further down on the ** stack. The column value is not copied. The number of columns in the ** record is stored on the stack just above the record itself. */ case OP_Column: { int payloadSize; /* Number of bytes in the record */ int p1 = pOp->p1; /* P1 value of the opcode */ int p2 = pOp->p2; /* column number to retrieve */ Cursor *pC = 0; /* The VDBE cursor */ char *zRec; /* Pointer to record-data from stack or pseudo-table. */ BtCursor *pCrsr; /* The BTree cursor */ u32 *aType; /* aType[i] holds the numeric type of the i-th column */ u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */ u64 nField; /* number of fields in the record */ u32 szHdr; /* Number of bytes in the record header */ int len; /* The length of the serialized data for the column */ int offset = 0; /* Offset into the data */ int idx; /* Index into the header */ int i; /* Loop counter */ char *zData; /* Part of the record being decoded */ Mem sMem; /* For storing the record being decoded */ sMem.flags = 0; assert( p1<p->nCursor ); pTos++; /* This block sets the variable payloadSize, and if the data is coming ** from the stack or from a pseudo-table zRec. If the data is coming ** from a real cursor, then zRec is left as NULL. ** ** We also compute the number of columns in the record. For cursors, ** the number of columns is stored in the Cursor.nField element. For ** records on the stack, the next entry down on the stack is an integer ** which is the number of records. */ if( p1<0 ){ Mem *pRec = &pTos[p1]; Mem *pCnt = &pRec[-1]; assert( pRec>=p->aStack ); assert( pRec->flags & MEM_Blob ); payloadSize = pRec->n; zRec = pRec->z; assert( pCnt>=p->aStack ); assert( pCnt->flags & MEM_Int ); nField = pCnt->i; }else if( (pC = p->apCsr[p1])->pCursor!=0 ){ sqlite3VdbeCursorMoveto(pC); zRec = 0; pCrsr = pC->pCursor; if( pC->nullRow ){ payloadSize = 0; }else if( pC->cacheValid ){ payloadSize = pC->payloadSize; }else if( pC->keyAsData ){ i64 payloadSize64; sqlite3BtreeKeySize(pCrsr, &payloadSize64); payloadSize = payloadSize64; }else{ sqlite3BtreeDataSize(pCrsr, &payloadSize); } nField = pC->nField; }else if( pC->pseudoTable ){ payloadSize = pC->nData; zRec = pC->pData; pC->cacheValid = 0; assert( payloadSize==0 || zRec!=0 ); nField = pC->nField; }else{ payloadSize = 0; } /* If payloadSize is 0, then just push a NULL onto the stack. */ if( payloadSize==0 ){ pTos->flags = MEM_Null; break; } assert( p2<nField ); /* Read and parse the table header. Store the results of the parse ** into the record header cache fields of the cursor. */ if( pC && pC->cacheValid ){ aType = pC->aType; aOffset = pC->aOffset; }else{ aType = sqliteMallocRaw( 2*nField*sizeof(aType) ); aOffset = &aType[nField]; if( aType==0 ){ goto no_mem; } /* Figure out how many bytes are in the header */ if( zRec ){ zData = zRec; }else{ int sz = payloadSize<5 ? payloadSize : 5; if( pC->keyAsData ){ zData = (char*)sqlite3BtreeKeyFetch(pCrsr, sz); }else{ zData = (char*)sqlite3BtreeDataFetch(pCrsr, sz); } } idx = sqlite3GetVarint32(zData, &szHdr); /* Get the complete header text */ if( !zRec ){ rc = getBtreeMem(pCrsr, 0, szHdr, pC->keyAsData, &sMem); if( rc!=SQLITE_OK ){ goto abort_due_to_error; } zData = sMem.z; } /* Scan the header and use it to fill in the aType[] and aOffset[] ** arrays. aType[i] will contain the type integer for the i-th ** column and aOffset[i] will contain the offset from the beginning ** of the record to the start of the data for the i-th column */ offset = szHdr; i = 0; while( idx<szHdr && i<nField && offset<=payloadSize ){ aOffset[i] = offset; idx += sqlite3GetVarint32(&zData[idx], &aType[i]); offset += sqlite3VdbeSerialTypeLen(aType[i]); i++; } Release(&sMem); sMem.flags = MEM_Null; /* The header should end at the start of data and the data should ** end at last byte of the record. If this is not the case then ** we are dealing with a malformed record. */ if( idx!=szHdr || offset!=payloadSize ){ sqliteFree(aType); if( pC ) pC->aType = 0; rc = SQLITE_CORRUPT; break; } /* Remember all aType and aColumn information if we have a cursor ** to remember it in. */ if( pC ){ pC->payloadSize = payloadSize; pC->aType = aType; pC->aOffset = aOffset; pC->cacheValid = 1; } } /* Get the column information. */ if( zRec ){ zData = &zRec[aOffset[p2]]; }else{ len = sqlite3VdbeSerialTypeLen(aType[p2]); getBtreeMem(pCrsr, aOffset[p2], len, pC->keyAsData, &sMem); zData = sMem.z; } sqlite3VdbeSerialGet(zData, aType[p2], pTos, p->db->enc); if( rc!=SQLITE_OK ){ goto abort_due_to_error; } Release(&sMem); /* Release the aType[] memory if we are not dealing with cursor */ if( !pC ){ sqliteFree(aType); } break; } /* Opcode MakeRecord P1 * P3 ** ** Convert the top P1 entries of the stack into a single entry ** suitable for use as a data record in a database table. The ** details of the format are irrelavant as long as the OP_Column ** opcode can decode the record later. Refer to source code ** comments for the details of the record format. ** ** P3 may be a string that is P1 characters long. The nth character of the |
︙ | ︙ | |||
2052 2053 2054 2055 2056 2057 2058 | ** If P3 is NULL then all index fields have the affinity NONE. */ case OP_MakeRecord: { /* Assuming the record contains N fields, the record format looks ** like this: ** ** -------------------------------------------------------------------------- | | > > | | | > > | | > | | | | 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 | ** If P3 is NULL then all index fields have the affinity NONE. */ case OP_MakeRecord: { /* Assuming the record contains N fields, the record format looks ** like this: ** ** -------------------------------------------------------------------------- ** | header-siz | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 | ** -------------------------------------------------------------------------- ** ** Data(0) is taken from the lowest element of the stack and data(N-1) is ** the top of the stack. ** ** Each type field is a varint representing the serial type of the ** corresponding data element (see sqlite3VdbeSerialType()). The ** num-fields field is also a varint storing N. ** ** TODO: Even when the record is short enough for Mem::zShort, this opcode ** allocates it dynamically. */ int nField = pOp->p1; unsigned char *zNewRecord; unsigned char *zCsr; char *zAffinity; Mem *pRec; int nData = 0; /* Number of bytes of data space */ int nHdr = 0; /* Number of bytes of header space */ int nByte = 0; /* Space required for this record */ Mem *pData0 = &pTos[1-nField]; assert( pData0>=p->aStack ); zAffinity = pOp->p3; /* Loop through the elements that will make up the record to figure ** out how much space is required for the new record. */ for(pRec=pData0; pRec<=pTos; pRec++){ u64 serial_type; if( zAffinity ){ applyAffinity(pRec, zAffinity[pRec-pData0], db->enc); } serial_type = sqlite3VdbeSerialType(pRec); nData += sqlite3VdbeSerialTypeLen(serial_type); nHdr += sqlite3VarintLen(serial_type); } nHdr += sqlite3VarintLen(nHdr); nByte = nHdr+nData; if( nByte>MAX_BYTES_PER_ROW ){ rc = SQLITE_TOOBIG; goto abort_due_to_error; } /* Allocate space for the new record. */ zNewRecord = sqliteMallocRaw(nByte); if( !zNewRecord ){ goto no_mem; } /* Write the record */ zCsr = zNewRecord; zCsr += sqlite3PutVarint(zCsr, nHdr); for(pRec=pData0; pRec<=pTos; pRec++){ u64 serial_type = sqlite3VdbeSerialType(pRec); zCsr += sqlite3PutVarint(zCsr, serial_type); /* serial type */ } for(pRec=pData0; pRec<=pTos; pRec++){ zCsr += sqlite3VdbeSerialPut(zCsr, pRec); /* serial data */ } /* If zCsr has not been advanced exactly nByte bytes, then one ** of the sqlite3PutVarint() or sqlite3VdbeSerialPut() calls above ** failed. This indicates a corrupted memory cell or code bug. */ if( zCsr!=(zNewRecord+nByte) ){ rc = SQLITE_INTERNAL; goto abort_due_to_error; } /* Pop nField entries from the stack and push the new entry on */ popStack(&pTos, nField); pTos++; pTos->n = nByte; pTos->z = zNewRecord; pTos->flags = MEM_Blob | MEM_Dyn; break; } /* Opcode: MakeKey P1 P2 P3 |
︙ | ︙ |
Changes to src/vdbeInt.h.
︙ | ︙ | |||
76 77 78 79 80 81 82 83 84 85 86 | i64 movetoTarget; /* Argument to the deferred sqlite3BtreeMoveto() */ Btree *pBt; /* Separate file holding temporary table */ int nData; /* Number of bytes in pData */ char *pData; /* Data for a NEW or OLD pseudo-table */ i64 iKey; /* Key for the NEW or OLD pseudo-table row */ u8 *pIncrKey; /* Pointer to pKeyInfo->incrKey */ KeyInfo *pKeyInfo; /* Info about index keys needed by index cursors */ /* Cached information about the header for the data record that the ** cursor is currently pointing to */ Bool cacheValid; /* True if the cache is valid */ | > < < | > | 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 | i64 movetoTarget; /* Argument to the deferred sqlite3BtreeMoveto() */ Btree *pBt; /* Separate file holding temporary table */ int nData; /* Number of bytes in pData */ char *pData; /* Data for a NEW or OLD pseudo-table */ i64 iKey; /* Key for the NEW or OLD pseudo-table row */ u8 *pIncrKey; /* Pointer to pKeyInfo->incrKey */ KeyInfo *pKeyInfo; /* Info about index keys needed by index cursors */ int nField; /* Number of fields in the header */ /* Cached information about the header for the data record that the ** cursor is currently pointing to */ Bool cacheValid; /* True if the cache is valid */ int payloadSize; /* Total number of bytes in the record */ u32 *aType; /* Type values for all entries in the record */ u32 *aOffset; /* Cached offsets to the start of each columns data */ }; typedef struct Cursor Cursor; /* ** A sorter builds a list of elements to be sorted. Each element of ** the list is an instance of the following structure. */ |
︙ | ︙ | |||
363 364 365 366 367 368 369 | int sqlite3VdbeMemDynamicify(Mem*); int sqlite3VdbeMemStringify(Mem*, int); int sqlite3VdbeMemIntegerify(Mem*); int sqlite3VdbeMemRealify(Mem*); #ifndef NDEBUG void sqlite3VdbeMemSanity(Mem*, u8); #endif | < | 363 364 365 366 367 368 369 | int sqlite3VdbeMemDynamicify(Mem*); int sqlite3VdbeMemStringify(Mem*, int); int sqlite3VdbeMemIntegerify(Mem*); int sqlite3VdbeMemRealify(Mem*); #ifndef NDEBUG void sqlite3VdbeMemSanity(Mem*, u8); #endif |
Changes to src/vdbeaux.c.
︙ | ︙ | |||
1427 1428 1429 1430 1431 1432 1433 | */ int sqlite3VdbeRowCompare( void *userData, int nKey1, const void *pKey1, int nKey2, const void *pKey2 ){ KeyInfo *pKeyInfo = (KeyInfo*)userData; | | | | | | | | | < | < < | < < | | > | | < | | < < | | > > > > | > > > > > > > > > > > > > > > > | | 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 | */ int sqlite3VdbeRowCompare( void *userData, int nKey1, const void *pKey1, int nKey2, const void *pKey2 ){ KeyInfo *pKeyInfo = (KeyInfo*)userData; u32 d1, d2; /* Offset into aKey[] of next data element */ u32 idx1, idx2; /* Offset into aKey[] of next header element */ u32 szHdr1, szHdr2; /* Number of bytes in header */ int i = 0; int nField; int rc = 0; const unsigned char *aKey1 = (const unsigned char *)pKey1; const unsigned char *aKey2 = (const unsigned char *)pKey2; idx1 = sqlite3GetVarint32(pKey1, &szHdr1); d1 = szHdr1; idx2 = sqlite3GetVarint32(pKey2, &szHdr2); d2 = szHdr2; nField = pKeyInfo->nField; while( idx1<szHdr1 && idx2<szHdr2 && d1<nKey1 && d2<nKey2 && i<nField ){ Mem mem1; Mem mem2; u32 serial_type1; u32 serial_type2; /* Read the serial types for the next element in each key. */ idx1 += sqlite3GetVarint32(&aKey1[idx1], &serial_type1); idx2 += sqlite3GetVarint32(&aKey2[idx2], &serial_type2); /* Assert that there is enough space left in each key for the blob of ** data to go with the serial type just read. This assert may fail if ** the file is corrupted. Then read the value from each key into mem1 ** and mem2 respectively. */ d1 += sqlite3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1, 0); d2 += sqlite3VdbeSerialGet(&aKey2[d2], serial_type2, &mem2, 0); rc = sqlite3MemCompare(&mem1, &mem2, pKeyInfo->aColl[i]); if( mem1.flags&MEM_Dyn ){ sqliteFree(mem1.z); } if( mem2.flags&MEM_Dyn ){ sqliteFree(mem2.z); } if( rc!=0 ){ break; } i++; } /* One of the keys ran out of fields, but all the fields up to that point ** were equal. If the incrKey flag is true, then the second key is ** treated as larger. */ if( rc==0 ){ if( pKeyInfo->incrKey ){ assert( d2==nKey2 ); rc = -1; }else if( d1<nKey1 ){ rc = 1; }else if( d2<nKey2 ){ rc = -1; } } if( pKeyInfo->aSortOrder && i<pKeyInfo->nField && pKeyInfo->aSortOrder[i] ){ rc = -rc; } return rc; } /* ** pCur points at an index entry. Read the rowid (varint occuring at ** the end of the entry and store it in *rowid. Return SQLITE_OK if ** everything works, or an error code otherwise. |
︙ | ︙ |
Changes to test/types.test.
︙ | ︙ | |||
8 9 10 11 12 13 14 | # May you share freely, never taking more than you give. # #*********************************************************************** # This file implements regression tests for SQLite library. Specfically # it tests that the different storage classes (integer, real, text etc.) # all work correctly. # | | | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | # May you share freely, never taking more than you give. # #*********************************************************************** # This file implements regression tests for SQLite library. Specfically # it tests that the different storage classes (integer, real, text etc.) # all work correctly. # # $Id: types.test,v 1.7 2004/05/27 19:59:33 drh Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl # Tests in this file are organized roughly as follows: # # types-1.*.*: Test that values are stored using the expected storage |
︙ | ︙ | |||
195 196 197 198 199 200 201 | } [list 0 120 -120 30000 -30000 2100000000 -2100000000 \ 9000000000000000000 -9000000000000000000] # Check that all the record sizes are as we expected. do_test types-2.1.9 { set root [db eval {select rootpage from sqlite_master where name = 't1'}] record_sizes $root | | | | | 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 | } [list 0 120 -120 30000 -30000 2100000000 -2100000000 \ 9000000000000000000 -9000000000000000000] # Check that all the record sizes are as we expected. do_test types-2.1.9 { set root [db eval {select rootpage from sqlite_master where name = 't1'}] record_sizes $root } {3 3 3 4 4 6 6 10 10} # Insert some reals. These should be 10 byte records. do_test types-2.2.1 { execsql { CREATE TABLE t2(a float); INSERT INTO t2 VALUES(0.0); INSERT INTO t2 VALUES(12345.678); INSERT INTO t2 VALUES(-12345.678); } } {} do_test types-2.2.2 { execsql { SELECT a FROM t2; } } {0 12345.678 -12345.678} # Check that all the record sizes are as we expected. do_test types-2.2.3 { set root [db eval {select rootpage from sqlite_master where name = 't2'}] record_sizes $root } {10 10 10} # Insert a NULL. This should be a two byte record. do_test types-2.3.1 { execsql { CREATE TABLE t3(a nullvalue); INSERT INTO t3 VALUES(NULL); } } {} do_test types-2.3.2 { execsql { SELECT a ISNULL FROM t3; } } {1} # Check that all the record sizes are as we expected. do_test types-2.3.3 { set root [db eval {select rootpage from sqlite_master where name = 't3'}] record_sizes $root } {2} # Insert a couple of strings. do_test types-2.4.1 { set string10 abcdefghij set string500 [string repeat $string10 50] set string500000 [string repeat $string10 50000] |
︙ | ︙ | |||
260 261 262 263 264 265 266 | } } [list $string10 $string500 $string500000] # Check that all the record sizes are as we expected. do_test types-2.4.3 { set root [db eval {select rootpage from sqlite_master where name = 't4'}] record_sizes $root | | | 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 | } } [list $string10 $string500 $string500000] # Check that all the record sizes are as we expected. do_test types-2.4.3 { set root [db eval {select rootpage from sqlite_master where name = 't4'}] record_sizes $root } {12 503 500004} do_test types-2.5.1 { execsql { DROP TABLE t1; DROP TABLE t2; DROP TABLE t3; DROP TABLE t4; |
︙ | ︙ |