Import SQLite 3.10.2.

third_party/sqlite/src/test/sqllimits1.test

 # 2007 May 8
 #
 # The author disclaims copyright to this source code.  In place of
 # a legal notice, here is a blessing:
 #
 #    May you do good and not evil.
 #    May you find forgiveness for yourself and forgive others.
 #    May you share freely, never taking more than you give.
 #
 #***********************************************************************
@@ skipping 232 matching lines @@
 } $SQLITE_MAX_LIKE_PATTERN_LENGTH
 do_test sqllimits1-4.10.1 {
   sqlite3_limit db SQLITE_LIMIT_VARIABLE_NUMBER 0x7fffffff
   sqlite3_limit db SQLITE_LIMIT_VARIABLE_NUMBER -1
 } $SQLITE_MAX_VARIABLE_NUMBER
 
 #--------------------------------------------------------------------
 # Test cases sqllimits1-5.* test that the SQLITE_MAX_LENGTH limit
 # is enforced.
 #
+# EVIDENCE-OF: R-61987-00541 SQLITE_LIMIT_LENGTH The maximum size of any
+# string or BLOB or table row, in bytes.
+#
 db close
 sqlite3 db test.db
 set LARGESIZE 99999
 set SQLITE_LIMIT_LENGTH 100000
 sqlite3_limit db SQLITE_LIMIT_LENGTH $SQLITE_LIMIT_LENGTH
 
 do_test sqllimits1-5.1.1 {
   catchsql { SELECT randomblob(2147483647) }
 } {1 {string or blob too big}}
 do_test sqllimits1-5.1.2 {
@@ skipping 136 matching lines @@
   do_test sqllimits1-5.21 {
     catchsql {SELECT strftime('%Y-%m-%d ' || $::strvalue, '2008-01-02')}
   } {1 {string or blob too big}}
 }
 unset strvalue
 
 #--------------------------------------------------------------------
 # Test cases sqllimits1-6.* test that the SQLITE_MAX_SQL_LENGTH limit
 # is enforced.
 #
+# EVIDENCE-OF: R-09808-17554 SQLITE_LIMIT_SQL_LENGTH The maximum length
+# of an SQL statement, in bytes.
+#
 do_test sqllimits1-6.1 {
   sqlite3_limit db SQLITE_LIMIT_SQL_LENGTH 50000
   set sql "SELECT 1 WHERE 1==1"
   set tail " /* A comment to take up space in order to make the string\
                 longer without increasing the expression depth */\
                 AND   1  ==  1"
   set N [expr {(50000 / [string length $tail])+1}]
   append sql [string repeat $tail $N]
   catchsql $sql
 } {1 {string or blob too big}}
@@ skipping 141 matching lines @@
 } $fsize
 do_test sqllimits1-7.7.4 {
   execsql {
     DROP TABLE abc;
   }
 } {}
 
 #--------------------------------------------------------------------
 # Test cases sqllimits1-8.* test the SQLITE_MAX_COLUMN limit.
 #
+# EVIDENCE-OF: R-43996-29471 SQLITE_LIMIT_COLUMN The maximum number of
+# columns in a table definition or in the result set of a SELECT or the
+# maximum number of columns in an index or in an ORDER BY or GROUP BY
+# clause.
+#
 set SQLITE_LIMIT_COLUMN 200
 sqlite3_limit db SQLITE_LIMIT_COLUMN $SQLITE_LIMIT_COLUMN
 do_test sqllimits1-8.1 {
   # Columns in a table.
   set cols [list]
   for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} {
     lappend cols "c$i"
   }
   catchsql "CREATE TABLE t([join $cols ,])" 
 } {1 {too many columns on t}}
@@ skipping 45 matching lines @@
   }
   catchsql "UPDATE t1 SET [join $cols ,];"
 } {1 {too many columns in set list}}
 
 do_test sqllimits1-8.8 {
   # Columns in a view definition:
   set cols [list]
   for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} {
     lappend cols "c$i"
   }
-  catchsql "CREATE VIEW v1 AS SELECT [join $cols ,] FROM t1;"
+  execsql "CREATE VIEW v1 AS SELECT [join $cols ,] FROM t1;"
+  catchsql {SELECT * FROM v1}
 } {1 {too many columns in result set}}
 
 do_test sqllimits1-8.9 {
   # Columns in a view definition (testing * expansion):
   set cols [list]
   for {set i 0} {$i < $SQLITE_LIMIT_COLUMN} {incr i} {
     lappend cols "c$i"
   }
+  execsql {DROP VIEW IF EXISTS v1}
   catchsql "CREATE TABLE t2([join $cols ,])"
   catchsql "CREATE VIEW v1 AS SELECT *, c1 AS o FROM t2;"
+  catchsql "SELECT * FROM v1"
 } {1 {too many columns in result set}}
+
 do_test sqllimits1-8.10 {
   # ORDER BY columns
   set cols [list]
   for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} {
     lappend cols c
   }
   set sql "SELECT c FROM t1 ORDER BY [join $cols ,]"
   catchsql $sql
 } {1 {too many terms in ORDER BY clause}}
 do_test sqllimits1-8.11 {
   # ORDER BY columns
   set cols [list]
   for {set i 0} {$i <= $SQLITE_LIMIT_COLUMN} {incr i} {
     lappend cols [expr {$i%3 + 1}]
   }
   set sql "SELECT c, c+1, c+2 FROM t1 UNION SELECT c-1, c-2, c-3 FROM t1"
   append sql " ORDER BY [join $cols ,]"
   catchsql $sql
 } {1 {too many terms in ORDER BY clause}}
 
 
 #--------------------------------------------------------------------
 # These tests - sqllimits1-9.* - test that the SQLITE_LIMIT_EXPR_DEPTH
 # limit is enforced. The limit refers to the number of terms in 
 # the expression.
 #
+# EVIDENCE-OF: R-12723-08526 SQLITE_LIMIT_EXPR_DEPTH The maximum depth
+# of the parse tree on any expression.
+#
 if {$SQLITE_MAX_EXPR_DEPTH==0} {
   puts -nonewline stderr "WARNING: Compile with -DSQLITE_MAX_EXPR_DEPTH to run "
   puts stderr "tests sqllimits1-9.X"
 } else {
   do_test sqllimits1-9.1 {
     set max $::SQLITE_MAX_EXPR_DEPTH
     set expr "(1 [string repeat {AND 1 } $max])"
     catchsql [subst {
       SELECT $expr
     }]
@@ skipping 39 matching lines @@
 # Test cases sqllimits1-10.* test that the SQLITE_MAX_VDBE_OP
 # limit works as expected. The limit refers to the number of opcodes
 # in a single VDBE program.
 #
 # TODO
 
 #--------------------------------------------------------------------
 # Test the SQLITE_LIMIT_FUNCTION_ARG limit works. Test case names
 # match the pattern "sqllimits1-11.*".
 #
+# EVIDENCE-OF: R-59001-45278 SQLITE_LIMIT_FUNCTION_ARG The maximum
+# number of arguments on a function.
+#
 for {set max 5} {$max<=$SQLITE_MAX_FUNCTION_ARG} {incr max} {
   do_test sqllimits1-11.$max.1 {
     set vals [list]
     sqlite3_limit db SQLITE_LIMIT_FUNCTION_ARG $::max
     for {set i 0} {$i < $::max} {incr i} {
       lappend vals $i
     }
     catchsql "SELECT max([join $vals ,])"
   } "0 [expr {$::max - 1}]"
   do_test sqllimits1-11.$max.2 {
@@ skipping 13 matching lines @@
     for {set i 0} {$i <= $::max} {incr i} {
       lappend vals $i
     }
     catchsql "SELECT myfunc([join $vals ,])"
   } {1 {too many arguments on function myfunc}}
 }
 
 #--------------------------------------------------------------------
 # Test cases sqllimits1-12.*: Test the SQLITE_MAX_ATTACHED limit.
 #
+# EVIDENCE-OF: R-41778-26203 SQLITE_LIMIT_ATTACHED The maximum number of
+# attached databases.
+#
 ifcapable attach {
   do_test sqllimits1-12.1 {
     set max $::SQLITE_MAX_ATTACHED
     for {set i 0} {$i < ($max)} {incr i} {
       forcedelete test${i}.db test${i}.db-journal
     }
     for {set i 0} {$i < ($max)} {incr i} {
       execsql "ATTACH 'test${i}.db' AS aux${i}"
     }
     catchsql "ATTACH 'test${i}.db' AS aux${i}"
   } "1 {too many attached databases - max $::SQLITE_MAX_ATTACHED}"
   do_test sqllimits1-12.2 {
     set max $::SQLITE_MAX_ATTACHED
     for {set i 0} {$i < ($max)} {incr i} {
       execsql "DETACH aux${i}"
     }
   } {}
 }
 
 #--------------------------------------------------------------------
 # Test cases sqllimits1-13.*: Check that the SQLITE_MAX_VARIABLE_NUMBER 
 # limit works.
 #
+# EVIDENCE-OF: R-42363-29104 SQLITE_LIMIT_VARIABLE_NUMBER The maximum
+# index number of any parameter in an SQL statement.
+#
 do_test sqllimits1-13.1 {
   set max $::SQLITE_MAX_VARIABLE_NUMBER
   catchsql "SELECT ?[expr {$max+1}] FROM t1"
 } "1 {variable number must be between ?1 and ?$::SQLITE_MAX_VARIABLE_NUMBER}"
 do_test sqllimits1-13.2 {
   set max $::SQLITE_MAX_VARIABLE_NUMBER
   set vals [list]
   for {set i 0} {$i < ($max+3)} {incr i} {
     lappend vals ?
   }
   catchsql "SELECT [join $vals ,] FROM t1"
 } "1 {too many SQL variables}"
 
 
 #--------------------------------------------------------------------
 # Test cases sqllimits1-15.* verify that the 
 # SQLITE_MAX_LIKE_PATTERN_LENGTH limit is enforced. This limit only
 # applies to the built-in LIKE operator, supplying an external 
 # implementation by overriding the like() scalar function bypasses
 # this limitation.
 #
+# EVIDENCE-OF: R-12940-37052 SQLITE_LIMIT_LIKE_PATTERN_LENGTH The
+# maximum length of the pattern argument to the LIKE or GLOB operators.
+#
 # These tests check that the limit is not incorrectly applied to
 # the left-hand-side of the LIKE operator (the string being tested
 # against the pattern).
 #
 set SQLITE_LIMIT_LIKE_PATTERN 1000
 sqlite3_limit db SQLITE_LIMIT_LIKE_PATTERN_LENGTH $SQLITE_LIMIT_LIKE_PATTERN
 do_test sqllimits1-15.1 {
   set max $::SQLITE_LIMIT_LIKE_PATTERN
   set ::pattern [string repeat "A%" [expr $max/2]]
   set ::string  [string repeat "A" [expr {$max*2}]]
@@ skipping 18 matching lines @@
   set ::N [expr int(([expr pow(2,32)]/50) + 1)]
   expr (($::N*50) & 0xffffffff)<55
 } {1}
 do_test sqllimits1-16.2 {
   set ::format "[string repeat A 60][string repeat "%J" $::N]"
   catchsql {
     SELECT strftime($::format, 1);
   }
 } {1 {string or blob too big}}
 
+do_catchsql_test sqllimits1.17.0 {
+  SELECT *,*,*,*,*,*,*,* FROM (
+  SELECT *,*,*,*,*,*,*,* FROM (
+  SELECT *,*,*,*,*,*,*,* FROM (
+  SELECT *,*,*,*,*,*,*,* FROM (
+  SELECT *,*,*,*,*,*,*,* FROM (
+    SELECT 1,2,3,4,5,6,7,8,9,10
+  )
+  ))))
+} "1 {too many columns in result set}"
+
 
 foreach {key value} [array get saved] {
   catch {set $key $value}
 }
 finish_test