000001 /* 000002 ** 2007 May 7 000003 ** 000004 ** The author disclaims copyright to this source code. In place of 000005 ** a legal notice, here is a blessing: 000006 ** 000007 ** May you do good and not evil. 000008 ** May you find forgiveness for yourself and forgive others. 000009 ** May you share freely, never taking more than you give. 000010 ** 000011 ************************************************************************* 000012 ** 000013 ** This file defines various limits of what SQLite can process. 000014 */ 000015 000016 /* 000017 ** The maximum length of a TEXT or BLOB in bytes. This also 000018 ** limits the size of a row in a table or index. 000019 ** 000020 ** The hard limit is the ability of a 32-bit signed integer 000021 ** to count the size: 2^31-1 or 2147483647. 000022 */ 000023 #ifndef SQLITE_MAX_LENGTH 000024 # define SQLITE_MAX_LENGTH 1000000000 000025 #endif 000026 #define SQLITE_MIN_LENGTH 30 /* Minimum value for the length limit */ 000027 000028 /* 000029 ** This is the maximum number of 000030 ** 000031 ** * Columns in a table 000032 ** * Columns in an index 000033 ** * Columns in a view 000034 ** * Terms in the SET clause of an UPDATE statement 000035 ** * Terms in the result set of a SELECT statement 000036 ** * Terms in the GROUP BY or ORDER BY clauses of a SELECT statement. 000037 ** * Terms in the VALUES clause of an INSERT statement 000038 ** 000039 ** The hard upper limit here is 32676. Most database people will 000040 ** tell you that in a well-normalized database, you usually should 000041 ** not have more than a dozen or so columns in any table. And if 000042 ** that is the case, there is no point in having more than a few 000043 ** dozen values in any of the other situations described above. 000044 */ 000045 #ifndef SQLITE_MAX_COLUMN 000046 # define SQLITE_MAX_COLUMN 2000 000047 #endif 000048 000049 /* 000050 ** The maximum length of a single SQL statement in bytes. 000051 ** 000052 ** It used to be the case that setting this value to zero would 000053 ** turn the limit off. That is no longer true. It is not possible 000054 ** to turn this limit off. 000055 */ 000056 #ifndef SQLITE_MAX_SQL_LENGTH 000057 # define SQLITE_MAX_SQL_LENGTH 1000000000 000058 #endif 000059 000060 /* 000061 ** The maximum depth of an expression tree. This is limited to 000062 ** some extent by SQLITE_MAX_SQL_LENGTH. But sometime you might 000063 ** want to place more severe limits on the complexity of an 000064 ** expression. A value of 0 means that there is no limit. 000065 */ 000066 #ifndef SQLITE_MAX_EXPR_DEPTH 000067 # define SQLITE_MAX_EXPR_DEPTH 1000 000068 #endif 000069 000070 /* 000071 ** The maximum number of terms in a compound SELECT statement. 000072 ** The code generator for compound SELECT statements does one 000073 ** level of recursion for each term. A stack overflow can result 000074 ** if the number of terms is too large. In practice, most SQL 000075 ** never has more than 3 or 4 terms. Use a value of 0 to disable 000076 ** any limit on the number of terms in a compound SELECT. 000077 */ 000078 #ifndef SQLITE_MAX_COMPOUND_SELECT 000079 # define SQLITE_MAX_COMPOUND_SELECT 500 000080 #endif 000081 000082 /* 000083 ** The maximum number of opcodes in a VDBE program. 000084 ** Not currently enforced. 000085 */ 000086 #ifndef SQLITE_MAX_VDBE_OP 000087 # define SQLITE_MAX_VDBE_OP 250000000 000088 #endif 000089 000090 /* 000091 ** The maximum number of arguments to an SQL function. 000092 ** 000093 ** This value has a hard upper limit of 32767 due to storage 000094 ** constraints (it needs to fit inside a i16). We keep it 000095 ** lower than that to prevent abuse. 000096 */ 000097 #ifndef SQLITE_MAX_FUNCTION_ARG 000098 # define SQLITE_MAX_FUNCTION_ARG 1000 000099 #endif 000100 000101 /* 000102 ** The suggested maximum number of in-memory pages to use for 000103 ** the main database table and for temporary tables. 000104 ** 000105 ** IMPLEMENTATION-OF: R-30185-15359 The default suggested cache size is -2000, 000106 ** which means the cache size is limited to 2048000 bytes of memory. 000107 ** IMPLEMENTATION-OF: R-48205-43578 The default suggested cache size can be 000108 ** altered using the SQLITE_DEFAULT_CACHE_SIZE compile-time options. 000109 */ 000110 #ifndef SQLITE_DEFAULT_CACHE_SIZE 000111 # define SQLITE_DEFAULT_CACHE_SIZE -2000 000112 #endif 000113 000114 /* 000115 ** The default number of frames to accumulate in the log file before 000116 ** checkpointing the database in WAL mode. 000117 */ 000118 #ifndef SQLITE_DEFAULT_WAL_AUTOCHECKPOINT 000119 # define SQLITE_DEFAULT_WAL_AUTOCHECKPOINT 1000 000120 #endif 000121 000122 /* 000123 ** The maximum number of attached databases. This must be between 0 000124 ** and 125. The upper bound of 125 is because the attached databases are 000125 ** counted using a signed 8-bit integer which has a maximum value of 127 000126 ** and we have to allow 2 extra counts for the "main" and "temp" databases. 000127 */ 000128 #ifndef SQLITE_MAX_ATTACHED 000129 # define SQLITE_MAX_ATTACHED 10 000130 #endif 000131 000132 000133 /* 000134 ** The maximum value of a ?nnn wildcard that the parser will accept. 000135 ** If the value exceeds 32767 then extra space is required for the Expr 000136 ** structure. But otherwise, we believe that the number can be as large 000137 ** as a signed 32-bit integer can hold. 000138 */ 000139 #ifndef SQLITE_MAX_VARIABLE_NUMBER 000140 # define SQLITE_MAX_VARIABLE_NUMBER 32766 000141 #endif 000142 000143 /* Maximum page size. The upper bound on this value is 65536. This a limit 000144 ** imposed by the use of 16-bit offsets within each page. 000145 ** 000146 ** Earlier versions of SQLite allowed the user to change this value at 000147 ** compile time. This is no longer permitted, on the grounds that it creates 000148 ** a library that is technically incompatible with an SQLite library 000149 ** compiled with a different limit. If a process operating on a database 000150 ** with a page-size of 65536 bytes crashes, then an instance of SQLite 000151 ** compiled with the default page-size limit will not be able to rollback 000152 ** the aborted transaction. This could lead to database corruption. 000153 */ 000154 #ifdef SQLITE_MAX_PAGE_SIZE 000155 # undef SQLITE_MAX_PAGE_SIZE 000156 #endif 000157 #define SQLITE_MAX_PAGE_SIZE 65536 000158 000159 000160 /* 000161 ** The default size of a database page. 000162 */ 000163 #ifndef SQLITE_DEFAULT_PAGE_SIZE 000164 # define SQLITE_DEFAULT_PAGE_SIZE 4096 000165 #endif 000166 #if SQLITE_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE 000167 # undef SQLITE_DEFAULT_PAGE_SIZE 000168 # define SQLITE_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE 000169 #endif 000170 000171 /* 000172 ** Ordinarily, if no value is explicitly provided, SQLite creates databases 000173 ** with page size SQLITE_DEFAULT_PAGE_SIZE. However, based on certain 000174 ** device characteristics (sector-size and atomic write() support), 000175 ** SQLite may choose a larger value. This constant is the maximum value 000176 ** SQLite will choose on its own. 000177 */ 000178 #ifndef SQLITE_MAX_DEFAULT_PAGE_SIZE 000179 # define SQLITE_MAX_DEFAULT_PAGE_SIZE 8192 000180 #endif 000181 #if SQLITE_MAX_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE 000182 # undef SQLITE_MAX_DEFAULT_PAGE_SIZE 000183 # define SQLITE_MAX_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE 000184 #endif 000185 000186 000187 /* 000188 ** Maximum number of pages in one database file. 000189 ** 000190 ** This is really just the default value for the max_page_count pragma. 000191 ** This value can be lowered (or raised) at run-time using that the 000192 ** max_page_count macro. 000193 */ 000194 #ifndef SQLITE_MAX_PAGE_COUNT 000195 # define SQLITE_MAX_PAGE_COUNT 0xfffffffe /* 4294967294 */ 000196 #endif 000197 000198 /* 000199 ** Maximum length (in bytes) of the pattern in a LIKE or GLOB 000200 ** operator. 000201 */ 000202 #ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH 000203 # define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000 000204 #endif 000205 000206 /* 000207 ** Maximum depth of recursion for triggers. 000208 ** 000209 ** A value of 1 means that a trigger program will not be able to itself 000210 ** fire any triggers. A value of 0 means that no trigger programs at all 000211 ** may be executed. 000212 */ 000213 #ifndef SQLITE_MAX_TRIGGER_DEPTH 000214 # define SQLITE_MAX_TRIGGER_DEPTH 1000 000215 #endif