Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Update comments. No changes to code. (CVS 841) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
f6a8706872c43cee3003b48bb427c7b7 |
User & Date: | drh 2003-01-19 03:59:46.000 |
Context
2003-01-21
| ||
02:39 | In the pager, cache a pointer to the first page on the freelist that does not need to be synced. This makes a fetch of a page that is not in cache go a lot faster when the cache is full. This check-in also adds some performance instrumentation to the OS layer. (CVS 842) (check-in: 00f08fc0b5 user: drh tags: trunk) | |
2003-01-19
| ||
03:59 | Update comments. No changes to code. (CVS 841) (check-in: f6a8706872 user: drh tags: trunk) | |
2003-01-18
| ||
22:01 | Update the speed comparison page. (CVS 840) (check-in: 424cb2edb0 user: drh tags: trunk) | |
Changes
Changes to src/encode.c.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains helper routines used to translate binary data into ** a null-terminated string (suitable for use in SQLite) and back again. ** These are convenience routines for use by people who want to store binary | | | | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains helper routines used to translate binary data into ** a null-terminated string (suitable for use in SQLite) and back again. ** These are convenience routines for use by people who want to store binary ** data in an SQLite database. The code in this file is not used by any other ** part of the SQLite library. ** ** $Id: encode.c,v 1.5 2003/01/19 03:59:46 drh Exp $ */ #include <string.h> /* ** Encode a binary buffer "in" of size n bytes so that it contains ** no instances of characters '\'' or '\000'. The output is ** null-terminated and can be used as a string value in an INSERT |
︙ | ︙ |
Changes to src/main.c.
︙ | ︙ | |||
10 11 12 13 14 15 16 | ** ************************************************************************* ** Main file for the SQLite library. The routines in this file ** implement the programmer interface to the library. Routines in ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** | | | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** ************************************************************************* ** Main file for the SQLite library. The routines in this file ** implement the programmer interface to the library. Routines in ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** ** $Id: main.c,v 1.109 2003/01/19 03:59:47 drh Exp $ */ #include "sqliteInt.h" #include "os.h" #include <ctype.h> /* ** A pointer to this structure is used to communicate information |
︙ | ︙ | |||
35 36 37 38 39 40 41 | ** database. See sqliteInit() below for additional information. ** ** Each callback contains the following information: ** ** argv[0] = "file-format" or "schema-cookie" or "table" or "index" ** argv[1] = table or index name or meta statement type. ** argv[2] = root page number for table or index. NULL for meta. | | | 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 | ** database. See sqliteInit() below for additional information. ** ** Each callback contains the following information: ** ** argv[0] = "file-format" or "schema-cookie" or "table" or "index" ** argv[1] = table or index name or meta statement type. ** argv[2] = root page number for table or index. NULL for meta. ** argv[3] = SQL text for a CREATE TABLE or CREATE INDEX statement. ** argv[4] = "1" for temporary files, "0" for main database ** */ static int sqliteInitCallback(void *pInit, int argc, char **argv, char **azColName){ InitData *pData = (InitData*)pInit; Parse sParse; |
︙ | ︙ | |||
387 388 389 390 391 392 393 | sqliteFree(*pzErrMsg); *pzErrMsg = 0; } /* If the database is in formats 1 or 2, then upgrade it to ** version 3. This will reconstruct all indices. If the ** upgrade fails for any reason (ex: out of disk space, database | | | 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 | sqliteFree(*pzErrMsg); *pzErrMsg = 0; } /* If the database is in formats 1 or 2, then upgrade it to ** version 3. This will reconstruct all indices. If the ** upgrade fails for any reason (ex: out of disk space, database ** is read only, interrupt received, etc.) then refuse to open. */ if( rc==SQLITE_OK && db->file_format<3 ){ char *zErr = 0; InitData initData; int meta[SQLITE_N_BTREE_META]; initData.db = db; |
︙ | ︙ | |||
782 783 784 785 786 787 788 | ** string that is exported from SQLite should have already passed through ** sqliteStrRealloc(). */ void sqlite_freemem(void *p){ free(p); } /* ** Windows systems need functions to call to return the sqlite_version | | > | 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 | ** string that is exported from SQLite should have already passed through ** sqliteStrRealloc(). */ void sqlite_freemem(void *p){ free(p); } /* ** Windows systems need functions to call to return the sqlite_version ** and sqlite_encoding strings since they are unable to access constants ** within DLLs. */ const char *sqlite_libversion(void){ return sqlite_version; } const char *sqlite_libencoding(void){ return sqlite_encoding; } /* ** Create new user-defined functions. The sqlite_create_function() ** routine creates a regular function and sqlite_create_aggregate() |
︙ | ︙ |
Changes to src/printf.c.
1 2 3 4 5 | /* ** The "printf" code that follows dates from the 1980's. It is in ** the public domain. The original comments are included here for ** completeness. They are slightly out-of-date. ** | | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | /* ** The "printf" code that follows dates from the 1980's. It is in ** the public domain. The original comments are included here for ** completeness. They are slightly out-of-date. ** ** The following modules is an enhanced replacement for the "printf" subroutines ** found in the standard C library. The following enhancements are ** supported: ** ** + Additional functions. The standard set of "printf" functions ** includes printf, fprintf, sprintf, vprintf, vfprintf, and ** vsprintf. This module adds the following: ** ** * snprintf -- Works like sprintf, but has an extra argument |
︙ | ︙ |
Changes to src/select.c.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains C code routines that are called by the parser ** to handle SELECT statements in SQLite. ** | | | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains C code routines that are called by the parser ** to handle SELECT statements in SQLite. ** ** $Id: select.c,v 1.123 2003/01/19 03:59:47 drh Exp $ */ #include "sqliteInt.h" /* ** Allocate a new Select structure and return a pointer to that ** structure. |
︙ | ︙ | |||
176 177 178 179 180 181 182 | *ppExpr = pE; } } /* ** Set the EP_FromJoin property on all terms of the given expression. ** | | | 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 | *ppExpr = pE; } } /* ** Set the EP_FromJoin property on all terms of the given expression. ** ** The EP_FromJoin property is used on terms of an expression to tell ** the LEFT OUTER JOIN processing logic that this term is part of the ** join restriction specified in the ON or USING clause and not a part ** of the more general WHERE clause. These terms are moved over to the ** WHERE clause during join processing but we need to remember that they ** originated in the ON or USING clause. */ static void setJoinExpr(Expr *p){ |
︙ | ︙ | |||
673 674 675 676 677 678 679 680 681 682 683 684 685 686 | sqliteVdbeResolveLabel(v, end); sqliteVdbeAddOp(v, OP_SortReset, 0, 0); } /* ** Generate code that will tell the VDBE the datatypes of ** columns in the result set. */ static void generateColumnTypes( Parse *pParse, /* Parser context */ int base, /* VDBE cursor corresponding to first entry in pTabList */ SrcList *pTabList, /* List of tables */ ExprList *pEList /* Expressions defining the result set */ ){ | > > > > > > > > > > > | 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 | sqliteVdbeResolveLabel(v, end); sqliteVdbeAddOp(v, OP_SortReset, 0, 0); } /* ** Generate code that will tell the VDBE the datatypes of ** columns in the result set. ** ** This routine only generates code if the "PRAGMA show_datatypes=on" ** has been executed. The datatypes are reported out in the azCol ** parameter to the callback function. The first N azCol[] entries ** are the names of the columns, and the second N entries are the ** datatypes for the columns. ** ** The "datatype" for a result that is a column of a type is the ** datatype definition extracted from the CREATE TABLE statement. ** The datatype for an expression is either TEXT or NUMERIC. The ** datatype for a ROWID field is INTEGER. */ static void generateColumnTypes( Parse *pParse, /* Parser context */ int base, /* VDBE cursor corresponding to first entry in pTabList */ SrcList *pTabList, /* List of tables */ ExprList *pEList /* Expressions defining the result set */ ){ |
︙ | ︙ | |||
1183 1184 1185 1186 1187 1188 1189 | ** if the corresponding column in p and every SELECT to the left of ** p has a datatype of SQLITE_SO_TEXT. If the cooressponding column ** in p or any of the left SELECTs is SQLITE_SO_NUM, then the datatype ** of the order-by expression is set to SQLITE_SO_NUM. ** ** Examples: ** | > > > > > > > > > > > > | | 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 | ** if the corresponding column in p and every SELECT to the left of ** p has a datatype of SQLITE_SO_TEXT. If the cooressponding column ** in p or any of the left SELECTs is SQLITE_SO_NUM, then the datatype ** of the order-by expression is set to SQLITE_SO_NUM. ** ** Examples: ** ** CREATE TABLE one(a INTEGER, b TEXT); ** CREATE TABLE two(c VARCHAR(5), d FLOAT); ** ** SELECT b, b FROM one UNION SELECT d, c FROM two ORDER BY 1, 2; ** ** The primary sort key will use SQLITE_SO_NUM because the "d" in ** the second SELECT is numeric. The 1st column of the first SELECT ** is text but that does not matter because a numeric always overrides ** a text. ** ** The secondary key will use the SQLITE_SO_TEXT sort order because ** both the (second) "b" in the first SELECT and the "c" in the second ** SELECT have a datatype of text. */ static void multiSelectSortOrder(Select *p, ExprList *pOrderBy){ int i; ExprList *pEList; if( pOrderBy==0 ) return; if( p==0 ){ for(i=0; i<pOrderBy->nExpr; i++){ |
︙ | ︙ | |||
1211 1212 1213 1214 1215 1216 1217 | } } /* ** This routine is called to process a query that is really the union ** or intersection of two or more separate queries. ** | | > > > > | > > > > > > > > > > > > > > > > > > > | 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 | } } /* ** This routine is called to process a query that is really the union ** or intersection of two or more separate queries. ** ** "p" points to the right-most of the two queries. the query on the ** left is p->pPrior. The left query could also be a compound query ** in which case this routine will be called recursively. ** ** The results of the total query are to be written into a destination ** of type eDest with parameter iParm. ** ** Example 1: Consider a three-way compound SQL statement. ** ** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3 ** ** This statement is parsed up as follows: ** ** SELECT c FROM t3 ** | ** `-----> SELECT b FROM t2 ** | ** `------> SELECT c FROM t1 ** ** The arrows in the diagram above represent the Select.pPrior pointer. ** So if this routine is called with p equal to the t3 query, then ** pPrior will be the t2 query. p->op will be TK_UNION in this case. ** ** Notice that because of the way SQLite parses compound SELECTs, the ** individual selects always group from left to right. */ static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ int rc; /* Success code from a subroutine */ Select *pPrior; /* Another SELECT immediately to our left */ Vdbe *v; /* Generate code to this VDBE */ /* Make sure there is no ORDER BY clause on prior SELECTs. Only the |
︙ | ︙ | |||
1691 1692 1693 1694 1695 1696 1697 | return 1; } /* ** Analyze the SELECT statement passed in as an argument to see if it ** is a simple min() or max() query. If it is and this query can be ** satisfied using a single seek to the beginning or end of an index, | | | 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 | return 1; } /* ** Analyze the SELECT statement passed in as an argument to see if it ** is a simple min() or max() query. If it is and this query can be ** satisfied using a single seek to the beginning or end of an index, ** then generate the code for this SELECT and return 1. If this is not a ** simple min() or max() query, then return 0; ** ** A simply min() or max() query looks like this: ** ** SELECT min(a) FROM table; ** SELECT max(a) FROM table; ** |
︙ | ︙ | |||
1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 | ** ** SRT_Union Store results as a key in a temporary table iParm ** ** SRT_Except Remove results form the temporary table iParm. ** ** SRT_Table Store results in temporary table iParm ** ** This routine returns the number of errors. If any errors are ** encountered, then an appropriate error message is left in ** pParse->zErrMsg. ** ** This routine does NOT free the Select structure passed in. The ** calling function needs to do that. ** ** The pParent, parentTab, and *pParentAgg fields are filled in if this ** SELECT is a subquery. This routine may try to combine this SELECT ** with its parent to form a single flat query. In so doing, it might ** change the parent query from a non-aggregate to an aggregate query. ** For that reason, the pParentAgg flag is passed as a pointer, so it ** can be changed. */ int sqliteSelect( Parse *pParse, /* The parser context */ Select *p, /* The SELECT statement being coded. */ | > > > > > > > > > > > > > > > > > > | | | 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 | ** ** SRT_Union Store results as a key in a temporary table iParm ** ** SRT_Except Remove results form the temporary table iParm. ** ** SRT_Table Store results in temporary table iParm ** ** The table above is incomplete. Additional eDist value have be added ** since this comment was written. See the selectInnerLoop() function for ** a complete listing of the allowed values of eDest and their meanings. ** ** This routine returns the number of errors. If any errors are ** encountered, then an appropriate error message is left in ** pParse->zErrMsg. ** ** This routine does NOT free the Select structure passed in. The ** calling function needs to do that. ** ** The pParent, parentTab, and *pParentAgg fields are filled in if this ** SELECT is a subquery. This routine may try to combine this SELECT ** with its parent to form a single flat query. In so doing, it might ** change the parent query from a non-aggregate to an aggregate query. ** For that reason, the pParentAgg flag is passed as a pointer, so it ** can be changed. ** ** Example 1: The meaning of the pParent parameter. ** ** SELECT * FROM t1 JOIN (SELECT x, count(*) FROM t2) JOIN t3; ** \ \_______ subquery _______/ / ** \ / ** \____________________ outer query ___________________/ ** ** This routine is called for the outer query first. For that call, ** pParent will be NULL. During the processing of the outer query, this ** routine is called recursively to handle the subquery. For the recursive ** call, pParent will point to the outer query. Because the subquery is ** the second element in a three-way join, the parentTab parameter will ** be 1 (the 2nd value of a 0-indexed array.) */ int sqliteSelect( Parse *pParse, /* The parser context */ Select *p, /* The SELECT statement being coded. */ int eDest, /* How to dispose of the results */ int iParm, /* A parameter used by the eDest disposal method */ Select *pParent, /* Another SELECT for which this is a sub-query */ int parentTab, /* Index in pParent->pSrc of this query */ int *pParentAgg /* True if pParent uses aggregate functions */ ){ int i; WhereInfo *pWInfo; Vdbe *v; |
︙ | ︙ | |||
1891 1892 1893 1894 1895 1896 1897 | /* ** Do not even attempt to generate any code if we have already seen ** errors before this routine starts. */ if( pParse->nErr>0 ) goto select_end; | | < | > | 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 | /* ** Do not even attempt to generate any code if we have already seen ** errors before this routine starts. */ if( pParse->nErr>0 ) goto select_end; /* Expand any "*" terms in the result set. (For example the "*" in ** "SELECT * FROM t1") The fillInColumnlist() routine also does some ** other housekeeping - see the header comment for details. */ if( fillInColumnList(pParse, p) ){ goto select_end; } pWhere = p->pWhere; pEList = p->pEList; if( pEList==0 ) goto select_end; |
︙ | ︙ | |||
2020 2021 2022 2023 2024 2025 2026 | } /* Begin generating code. */ v = sqliteGetVdbe(pParse); if( v==0 ) goto select_end; | | | | 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 | } /* Begin generating code. */ v = sqliteGetVdbe(pParse); if( v==0 ) goto select_end; /* Identify column names if we will be using them in a callback. This ** step is skipped if the output is going to some other destination. */ if( eDest==SRT_Callback ){ generateColumnNames(pParse, p->base, pTabList, pEList); } /* Set the limiter */ |
︙ | ︙ | |||
2072 2073 2074 2075 2076 2077 2078 | */ if( pParent && pParentAgg && flattenSubquery(pParse, pParent, parentTab, *pParentAgg, isAgg) ){ if( isAgg ) *pParentAgg = 1; return rc; } | | | > | 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 | */ if( pParent && pParentAgg && flattenSubquery(pParse, pParent, parentTab, *pParentAgg, isAgg) ){ if( isAgg ) *pParentAgg = 1; return rc; } /* Identify column types if we will be using a callback. This ** step is skipped if the output is going to a destination other ** than a callback. */ if( eDest==SRT_Callback ){ generateColumnTypes(pParse, p->base, pTabList, pEList); } /* If the output is destined for a temporary table, open that table. */ |
︙ | ︙ | |||
2250 2251 2252 2253 2254 2255 2256 | */ rc = 0; /* Control jumps to here if an error is encountered above, or upon ** successful coding of the SELECT. */ select_end: | < | 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 | */ rc = 0; /* Control jumps to here if an error is encountered above, or upon ** successful coding of the SELECT. */ select_end: sqliteAggregateInfoReset(pParse); return rc; } |
Changes to src/vdbe.c.
︙ | ︙ | |||
32 33 34 35 36 37 38 | ** ** 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. ** | | | 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 | ** ** 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.199 2003/01/19 03:59:47 drh Exp $ */ #include "sqliteInt.h" #include <ctype.h> /* ** The makefile scans this source file and creates the following ** array of string constants which are the names of all VDBE opcodes. |
︙ | ︙ | |||
1755 1756 1757 1758 1759 1760 1761 | break; } /* Opcode: NullCallback P1 * * ** ** Invoke the callback function once with the 2nd argument (the ** number of columns) equal to P1 and with the 4th argument (the | | | | 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 | break; } /* Opcode: NullCallback P1 * * ** ** Invoke the callback function once with the 2nd argument (the ** number of columns) equal to P1 and with the 4th argument (the ** names of the columns) set according to prior OP_ColumnName ** instructions. This is all like the regular ** OP_Callback or OP_SortCallback opcodes. But the 3rd argument ** which normally contains a pointer to an array of pointers to ** data is NULL. ** ** The callback is only invoked if there have been no prior calls ** to OP_Callback or OP_SortCallback. ** |
︙ | ︙ |