sqliteLimit.h
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:5k
源码类别:

数据库系统

开发平台:

C/C++

  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. ** @(#) $Id: sqliteLimit.h,v 1.8 2008/03/26 15:56:22 drh Exp $
  16. */
  17. /*
  18. ** The maximum length of a TEXT or BLOB in bytes.   This also
  19. ** limits the size of a row in a table or index.
  20. **
  21. ** The hard limit is the ability of a 32-bit signed integer
  22. ** to count the size: 2^31-1 or 2147483647.
  23. */
  24. #ifndef SQLITE_MAX_LENGTH
  25. # define SQLITE_MAX_LENGTH 1000000000
  26. #endif
  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. ** The maximum length of a single SQL statement in bytes.
  49. **
  50. ** It used to be the case that setting this value to zero would
  51. ** turn the limit off.  That is no longer true.  It is not possible
  52. ** to turn this limit off.
  53. */
  54. #ifndef SQLITE_MAX_SQL_LENGTH
  55. # define SQLITE_MAX_SQL_LENGTH 1000000000
  56. #endif
  57. /*
  58. ** The maximum depth of an expression tree. This is limited to 
  59. ** some extent by SQLITE_MAX_SQL_LENGTH. But sometime you might 
  60. ** want to place more severe limits on the complexity of an 
  61. ** expression.
  62. **
  63. ** A value of 0 used to mean that the limit was not enforced.
  64. ** But that is no longer true.  The limit is now strictly enforced
  65. ** at all times.
  66. */
  67. #ifndef SQLITE_MAX_EXPR_DEPTH
  68. # define SQLITE_MAX_EXPR_DEPTH 1000
  69. #endif
  70. /*
  71. ** The maximum number of terms in a compound SELECT statement.
  72. ** The code generator for compound SELECT statements does one
  73. ** level of recursion for each term.  A stack overflow can result
  74. ** if the number of terms is too large.  In practice, most SQL
  75. ** never has more than 3 or 4 terms.  Use a value of 0 to disable
  76. ** any limit on the number of terms in a compount SELECT.
  77. */
  78. #ifndef SQLITE_MAX_COMPOUND_SELECT
  79. # define SQLITE_MAX_COMPOUND_SELECT 500
  80. #endif
  81. /*
  82. ** The maximum number of opcodes in a VDBE program.
  83. ** Not currently enforced.
  84. */
  85. #ifndef SQLITE_MAX_VDBE_OP
  86. # define SQLITE_MAX_VDBE_OP 25000
  87. #endif
  88. /*
  89. ** The maximum number of arguments to an SQL function.
  90. */
  91. #ifndef SQLITE_MAX_FUNCTION_ARG
  92. # define SQLITE_MAX_FUNCTION_ARG 100
  93. #endif
  94. /*
  95. ** The maximum number of in-memory pages to use for the main database
  96. ** table and for temporary tables.  The SQLITE_DEFAULT_CACHE_SIZE
  97. */
  98. #ifndef SQLITE_DEFAULT_CACHE_SIZE
  99. # define SQLITE_DEFAULT_CACHE_SIZE  2000
  100. #endif
  101. #ifndef SQLITE_DEFAULT_TEMP_CACHE_SIZE
  102. # define SQLITE_DEFAULT_TEMP_CACHE_SIZE  500
  103. #endif
  104. /*
  105. ** The maximum number of attached databases.  This must be between 0
  106. ** and 30.  The upper bound on 30 is because a 32-bit integer bitmap
  107. ** is used internally to track attached databases.
  108. */
  109. #ifndef SQLITE_MAX_ATTACHED
  110. # define SQLITE_MAX_ATTACHED 10
  111. #endif
  112. /*
  113. ** The maximum value of a ?nnn wildcard that the parser will accept.
  114. */
  115. #ifndef SQLITE_MAX_VARIABLE_NUMBER
  116. # define SQLITE_MAX_VARIABLE_NUMBER 999
  117. #endif
  118. /* Maximum page size.  The upper bound on this value is 32768.  This a limit
  119. ** imposed by the necessity of storing the value in a 2-byte unsigned integer
  120. ** and the fact that the page size must be a power of 2.
  121. */
  122. #ifndef SQLITE_MAX_PAGE_SIZE
  123. # define SQLITE_MAX_PAGE_SIZE 32768
  124. #endif
  125. /*
  126. ** The default size of a database page.
  127. */
  128. #ifndef SQLITE_DEFAULT_PAGE_SIZE
  129. # define SQLITE_DEFAULT_PAGE_SIZE 1024
  130. #endif
  131. #if SQLITE_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE
  132. # undef SQLITE_DEFAULT_PAGE_SIZE
  133. # define SQLITE_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE
  134. #endif
  135. /*
  136. ** Ordinarily, if no value is explicitly provided, SQLite creates databases
  137. ** with page size SQLITE_DEFAULT_PAGE_SIZE. However, based on certain
  138. ** device characteristics (sector-size and atomic write() support),
  139. ** SQLite may choose a larger value. This constant is the maximum value
  140. ** SQLite will choose on its own.
  141. */
  142. #ifndef SQLITE_MAX_DEFAULT_PAGE_SIZE
  143. # define SQLITE_MAX_DEFAULT_PAGE_SIZE 8192
  144. #endif
  145. #if SQLITE_MAX_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE
  146. # undef SQLITE_MAX_DEFAULT_PAGE_SIZE
  147. # define SQLITE_MAX_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE
  148. #endif
  149. /*
  150. ** Maximum number of pages in one database file.
  151. **
  152. ** This is really just the default value for the max_page_count pragma.
  153. ** This value can be lowered (or raised) at run-time using that the
  154. ** max_page_count macro.
  155. */
  156. #ifndef SQLITE_MAX_PAGE_COUNT
  157. # define SQLITE_MAX_PAGE_COUNT 1073741823
  158. #endif
  159. /*
  160. ** Maximum length (in bytes) of the pattern in a LIKE or GLOB
  161. ** operator.
  162. */
  163. #ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH
  164. # define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000
  165. #endif