Return to sqliteLimit.h CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src

sqlite3

    1: /*
    2: ** 2007 May 7
    3: **
    4: ** The author disclaims copyright to this source code.  In place of
    5: ** a legal notice, here is a blessing:
    6: **
    7: **    May you do good and not evil.
    8: **    May you find forgiveness for yourself and forgive others.
    9: **    May you share freely, never taking more than you give.
   10: **
   11: *************************************************************************
   12: ** 
   13: ** This file defines various limits of what SQLite can process.
   14: */
   15: 
   16: /*
   17: ** The maximum length of a TEXT or BLOB in bytes.   This also
   18: ** limits the size of a row in a table or index.
   19: **
   20: ** The hard limit is the ability of a 32-bit signed integer
   21: ** to count the size: 2^31-1 or 2147483647.
   22: */
   23: #ifndef SQLITE_MAX_LENGTH
   24: # define SQLITE_MAX_LENGTH 1000000000
   25: #endif
   26: 
   27: /*
   28: ** This is the maximum number of
   29: **
   30: **    * Columns in a table
   31: **    * Columns in an index
   32: **    * Columns in a view
   33: **    * Terms in the SET clause of an UPDATE statement
   34: **    * Terms in the result set of a SELECT statement
   35: **    * Terms in the GROUP BY or ORDER BY clauses of a SELECT statement.
   36: **    * Terms in the VALUES clause of an INSERT statement
   37: **
   38: ** The hard upper limit here is 32676.  Most database people will
   39: ** tell you that in a well-normalized database, you usually should
   40: ** not have more than a dozen or so columns in any table.  And if
   41: ** that is the case, there is no point in having more than a few
   42: ** dozen values in any of the other situations described above.
   43: */
   44: #ifndef SQLITE_MAX_COLUMN
   45: # define SQLITE_MAX_COLUMN 2000
   46: #endif
   47: 
   48: /*
   49: ** The maximum length of a single SQL statement in bytes.
   50: **
   51: ** It used to be the case that setting this value to zero would
   52: ** turn the limit off.  That is no longer true.  It is not possible
   53: ** to turn this limit off.
   54: */
   55: #ifndef SQLITE_MAX_SQL_LENGTH
   56: # define SQLITE_MAX_SQL_LENGTH 1000000000
   57: #endif
   58: 
   59: /*
   60: ** The maximum depth of an expression tree. This is limited to 
   61: ** some extent by SQLITE_MAX_SQL_LENGTH. But sometime you might 
   62: ** want to place more severe limits on the complexity of an 
   63: ** expression.
   64: **
   65: ** A value of 0 used to mean that the limit was not enforced.
   66: ** But that is no longer true.  The limit is now strictly enforced
   67: ** at all times.
   68: */
   69: #ifndef SQLITE_MAX_EXPR_DEPTH
   70: # define SQLITE_MAX_EXPR_DEPTH 1000
   71: #endif
   72: 
   73: /*
   74: ** The maximum number of terms in a compound SELECT statement.
   75: ** The code generator for compound SELECT statements does one
   76: ** level of recursion for each term.  A stack overflow can result
   77: ** if the number of terms is too large.  In practice, most SQL
   78: ** never has more than 3 or 4 terms.  Use a value of 0 to disable
   79: ** any limit on the number of terms in a compount SELECT.
   80: */
   81: #ifndef SQLITE_MAX_COMPOUND_SELECT
   82: # define SQLITE_MAX_COMPOUND_SELECT 500
   83: #endif
   84: 
   85: /*
   86: ** The maximum number of opcodes in a VDBE program.
   87: ** Not currently enforced.
   88: */
   89: #ifndef SQLITE_MAX_VDBE_OP
   90: # define SQLITE_MAX_VDBE_OP 25000
   91: #endif
   92: 
   93: /*
   94: ** The maximum number of arguments to an SQL function.
   95: */
   96: #ifndef SQLITE_MAX_FUNCTION_ARG
   97: # define SQLITE_MAX_FUNCTION_ARG 127
   98: #endif
   99: 
  100: /*
  101: ** The maximum number of in-memory pages to use for the main database
  102: ** table and for temporary tables.  The SQLITE_DEFAULT_CACHE_SIZE
  103: */
  104: #ifndef SQLITE_DEFAULT_CACHE_SIZE
  105: # define SQLITE_DEFAULT_CACHE_SIZE  2000
  106: #endif
  107: #ifndef SQLITE_DEFAULT_TEMP_CACHE_SIZE
  108: # define SQLITE_DEFAULT_TEMP_CACHE_SIZE  500
  109: #endif
  110: 
  111: /*
  112: ** The default number of frames to accumulate in the log file before
  113: ** checkpointing the database in WAL mode.
  114: */
  115: #ifndef SQLITE_DEFAULT_WAL_AUTOCHECKPOINT
  116: # define SQLITE_DEFAULT_WAL_AUTOCHECKPOINT  1000
  117: #endif
  118: 
  119: /*
  120: ** The maximum number of attached databases.  This must be between 0
  121: ** and 62.  The upper bound on 62 is because a 64-bit integer bitmap
  122: ** is used internally to track attached databases.
  123: */
  124: #ifndef SQLITE_MAX_ATTACHED
  125: # define SQLITE_MAX_ATTACHED 10
  126: #endif
  127: 
  128: 
  129: /*
  130: ** The maximum value of a ?nnn wildcard that the parser will accept.
  131: */
  132: #ifndef SQLITE_MAX_VARIABLE_NUMBER
  133: # define SQLITE_MAX_VARIABLE_NUMBER 999
  134: #endif
  135: 
  136: /* Maximum page size.  The upper bound on this value is 65536.  This a limit
  137: ** imposed by the use of 16-bit offsets within each page.
  138: **
  139: ** Earlier versions of SQLite allowed the user to change this value at
  140: ** compile time. This is no longer permitted, on the grounds that it creates
  141: ** a library that is technically incompatible with an SQLite library 
  142: ** compiled with a different limit. If a process operating on a database 
  143: ** with a page-size of 65536 bytes crashes, then an instance of SQLite 
  144: ** compiled with the default page-size limit will not be able to rollback 
  145: ** the aborted transaction. This could lead to database corruption.
  146: */
  147: #ifdef SQLITE_MAX_PAGE_SIZE
  148: # undef SQLITE_MAX_PAGE_SIZE
  149: #endif
  150: #define SQLITE_MAX_PAGE_SIZE 65536
  151: 
  152: 
  153: /*
  154: ** The default size of a database page.
  155: */
  156: #ifndef SQLITE_DEFAULT_PAGE_SIZE
  157: # define SQLITE_DEFAULT_PAGE_SIZE 1024
  158: #endif
  159: #if SQLITE_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE
  160: # undef SQLITE_DEFAULT_PAGE_SIZE
  161: # define SQLITE_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE
  162: #endif
  163: 
  164: /*
  165: ** Ordinarily, if no value is explicitly provided, SQLite creates databases
  166: ** with page size SQLITE_DEFAULT_PAGE_SIZE. However, based on certain
  167: ** device characteristics (sector-size and atomic write() support),
  168: ** SQLite may choose a larger value. This constant is the maximum value
  169: ** SQLite will choose on its own.
  170: */
  171: #ifndef SQLITE_MAX_DEFAULT_PAGE_SIZE
  172: # define SQLITE_MAX_DEFAULT_PAGE_SIZE 8192
  173: #endif
  174: #if SQLITE_MAX_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE
  175: # undef SQLITE_MAX_DEFAULT_PAGE_SIZE
  176: # define SQLITE_MAX_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE
  177: #endif
  178: 
  179: 
  180: /*
  181: ** Maximum number of pages in one database file.
  182: **
  183: ** This is really just the default value for the max_page_count pragma.
  184: ** This value can be lowered (or raised) at run-time using that the
  185: ** max_page_count macro.
  186: */
  187: #ifndef SQLITE_MAX_PAGE_COUNT
  188: # define SQLITE_MAX_PAGE_COUNT 1073741823
  189: #endif
  190: 
  191: /*
  192: ** Maximum length (in bytes) of the pattern in a LIKE or GLOB
  193: ** operator.
  194: */
  195: #ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH
  196: # define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000
  197: #endif
  198: 
  199: /*
  200: ** Maximum depth of recursion for triggers.
  201: **
  202: ** A value of 1 means that a trigger program will not be able to itself
  203: ** fire any triggers. A value of 0 means that no trigger programs at all 
  204: ** may be executed.
  205: */
  206: #ifndef SQLITE_MAX_TRIGGER_DEPTH
  207: # define SQLITE_MAX_TRIGGER_DEPTH 1000
  208: #endif