1 files changed, 576 insertions, 0 deletions

diff --git a/libraries/sqlite/unix/sqlite-3.5.1/test/sqllimits1.test b/libraries/sqlite/unix/sqlite-3.5.1/test/sqllimits1.test
new file mode 100644
index 0000000..6641e08
--- /dev/null
+++ b/libraries/sqlite/unix/sqlite-3.5.1/test/sqllimits1.test
@@ -0,0 +1,576 @@
+# 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.
+#
+#***********************************************************************
+#
+# This file contains tests to verify that the limits defined in
+# sqlite source file limits.h are enforced.
+#
+# $Id: sqllimits1.test,v 1.18 2007/09/06 23:39:37 drh Exp $
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# Test organization:
+#
+#     sqllimits-1.*:  SQLITE_MAX_LENGTH
+#     sqllimits-2.*:  SQLITE_MAX_SQL_LENGTH
+#     sqllimits-3.*:  SQLITE_MAX_PAGE_COUNT (and the max_page_count pragma)
+#     sqllimits-4.*:  SQLITE_MAX_COLUMN
+#
+#
+#     sqllimits-7.*:   SQLITE_MAX_FUNCTION_ARG  
+#     sqllimits-8.*:   SQLITE_MAX_ATTACHED
+#     sqllimits-9.*:   SQLITE_MAX_VARIABLE_NUMBER
+#     sqllimits-10.*:  SQLITE_MAX_PAGE_SIZE
+#     sqllimits-11.*:  SQLITE_MAX_LIKE_PATTERN_LENGTH
+#
+# Todo:
+#
+#     sqllimits-5.*:   SQLITE_MAX_EXPR_DEPTH            (sqlite todo)
+#     sqllimits-6.*:   SQLITE_MAX_VDBE_OP               (sqlite todo)
+#     sqllimits-12.*:  SQLITE_MAX_PAGE_COUNT            (sqlite todo)
+#
+
+unset -nocomplain saved
+foreach var [info vars SQLITE_MAX_*] {
+  set saved($var) [set $var]
+}
+
+set SQLITE_MAX_LENGTH                 100000
+set SQLITE_MAX_COLUMN
+set SQLITE_MAX_SQL_LENGTH              50000
+set SQLITE_MAX_EXPR_DEPTH               1000
+set SQLITE_MAX_COMPOUND_SELECT             5
+set SQLITE_MAX_VDBE_OP
+set SQLITE_MAX_FUNCTION_ARG
+set SQLITE_MAX_VARIABLE_NUMBER
+set SQLITE_MAX_PAGE_SIZE
+set SQLITE_MAX_PAGE_COUNT
+set SQLITE_MAX_LIKE_PATTERN_LENGTH      1000
+
+#--------------------------------------------------------------------
+# Test cases sqllimits-1.* test that the SQLITE_MAX_LENGTH limit
+# is enforced.
+#
+do_test sqllimits-1.1.1 {
+  catchsql { SELECT randomblob(2147483647) }
+} {1 {string or blob too big}}
+do_test sqllimits-1.1.2 {
+  catchsql { SELECT zeroblob(2147483647) }
+} {1 {string or blob too big}}
+
+# Large, but allowable, blob-size.
+#
+set ::LARGESIZE [expr $SQLITE_MAX_LENGTH - 1] 
+
+do_test sqllimits-1.2 {
+  catchsql { SELECT LENGTH(randomblob($::LARGESIZE)) }
+} "0 $::LARGESIZE"
+
+do_test sqllimits-1.3 {
+  catchsql { SELECT quote(randomblob($::LARGESIZE)) }
+} {1 {string or blob too big}}
+
+do_test sqllimits-1.4 {
+  catchsql { SELECT LENGTH(zeroblob($::LARGESIZE)) }
+} "0 $::LARGESIZE"
+
+do_test sqllimits-1.5 {
+  catchsql { SELECT quote(zeroblob($::LARGESIZE)) }
+} {1 {string or blob too big}}
+
+do_test sqllimits-1.6 {
+  catchsql { SELECT zeroblob(-1) }
+} {0 {{}}}
+
+do_test sqllimits-1.9 {
+  set ::str [string repeat A 65537]
+  set ::rep [string repeat B 65537]
+  catchsql { SELECT replace($::str, 'A', $::rep) }
+} {1 {string or blob too big}}
+
+do_test sqllimits-1.10 {
+  set ::str [string repeat %J 2100]
+  catchsql { SELECT strftime($::str, '2003-10-31') }
+} {1 {string or blob too big}}
+
+do_test sqllimits-1.11 {
+  set ::str1 [string repeat A [expr {$SQLITE_MAX_LENGTH - 10}]]
+  set ::str2 [string repeat B [expr {$SQLITE_MAX_LENGTH - 10}]]
+  catchsql { SELECT $::str1 || $::str2 }
+} {1 {string or blob too big}}
+
+do_test sqllimits-1.12 {
+  set ::str1 [string repeat ' [expr {$SQLITE_MAX_LENGTH - 10}]]
+  catchsql { SELECT quote($::str1) }
+} {1 {string or blob too big}}
+
+do_test sqllimits-1.13 {
+  set ::str1 [string repeat ' [expr {$SQLITE_MAX_LENGTH - 10}]]
+  catchsql { SELECT hex($::str1) }
+} {1 {string or blob too big}}
+
+do_test sqllimits-1.14.1 {
+  set ::STMT [sqlite3_prepare $::DB "SELECT ?" -1 TAIL]
+  sqlite3_bind_zeroblob $::STMT 1 [expr {$SQLITE_MAX_LENGTH + 1}]
+} {}
+do_test sqllimits-1.14.2 {
+  sqlite3_step $::STMT 
+} {SQLITE_ERROR}
+do_test sqllimits-1.14.3 {
+  sqlite3_finalize $::STMT 
+} {SQLITE_TOOBIG}
+
+#--------------------------------------------------------------------
+# Test cases sqllimits-2.* test that the SQLITE_MAX_SQL_LENGTH limit
+# is enforced.
+#
+do_test sqllimits-2.1 {
+  set    sql "SELECT 1 WHERE 1==1"
+  set N [expr {$::SQLITE_MAX_SQL_LENGTH / [string length " AND 1==1"]}]
+  append sql [string repeat " AND 1==1" $N]
+  catchsql $sql
+} {1 {String or BLOB exceeded size limit}}
+
+#--------------------------------------------------------------------
+# Test cases sqllimits-3.* test that the limit set using the
+# max_page_count pragma.
+#
+do_test sqllimits-3.1 {
+  execsql {
+    PRAGMA max_page_count = 1000;
+  }
+} {1000}
+do_test sqllimits-3.2 {
+  execsql { CREATE TABLE trig (a INTEGER, b INTEGER); }
+
+  # Set up a tree of triggers to fire when a row is inserted
+  # into table "trig".
+  #
+  # INSERT -> insert_b -> update_b -> insert_a -> update_a      (chain 1)
+  #                    -> update_a -> insert_a -> update_b      (chain 2)
+  #        -> insert_a -> update_b -> insert_b -> update_a      (chain 3)
+  #                    -> update_a -> insert_b -> update_b      (chain 4)
+  #
+  # Table starts with N rows.
+  #
+  #   Chain 1: insert_b (update N rows)
+  #              -> update_b (insert 1 rows)
+  #                -> insert_a (update N rows)
+  #                  -> update_a (insert 1 rows)
+  #
+  # chains 2, 3 and 4 are similar. Each inserts more than N^2 rows, where
+  # N is the number of rows at the conclusion of the previous chain.
+  #
+  # Therefore, a single insert adds (N^16 plus some) rows to the database.
+  # A really long loop...
+  #     
+  execsql {
+    CREATE TRIGGER update_b BEFORE UPDATE ON trig
+      FOR EACH ROW BEGIN
+        INSERT INTO trig VALUES (65, 'update_b');
+      END;
+
+    CREATE TRIGGER update_a AFTER UPDATE ON trig
+      FOR EACH ROW BEGIN
+        INSERT INTO trig VALUES (65, 'update_a');
+      END;
+
+    CREATE TRIGGER insert_b BEFORE INSERT ON trig
+      FOR EACH ROW BEGIN
+        UPDATE trig SET a = 1;
+      END;
+
+    CREATE TRIGGER insert_a AFTER INSERT ON trig
+      FOR EACH ROW BEGIN
+        UPDATE trig SET a = 1;
+      END;
+  }
+} {}
+
+do_test sqllimits1-3.3 {
+  execsql {
+    INSERT INTO trig VALUES (1,1); 
+  }
+} {}
+
+do_test sqllimits1-3.4 {
+  execsql {
+    SELECT COUNT(*) FROM trig;
+  }
+} {7}
+
+# This tries to insert so many rows it fills up the database (limited
+# to 1MB, so not that noteworthy an achievement).
+#
+do_test sqllimits1-3.5 {
+  catchsql {
+    INSERT INTO trig VALUES (1,10);
+  }
+} {1 {database or disk is full}}
+
+do_test sqllimits1-3.6 {
+  catchsql {
+    SELECT COUNT(*) FROM trig;
+  }
+} {0 7}
+
+# Now check the response of the library to opening a file larger than
+# the current max_page_count value. The response is to change the
+# internal max_page_count value to match the actual size of the file.
+do_test sqllimits1-3.7.1 {
+  execsql {
+    PRAGMA max_page_count = 1000000;
+    CREATE TABLE abc(a, b, c);
+    INSERT INTO abc VALUES(1, 2, 3);
+    INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc;
+    INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc;
+    INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc;
+    INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc;
+    INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc;
+    INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc;
+    INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc;
+    INSERT INTO abc SELECT a||b||c, b||c||a, c||a||b FROM abc;
+    INSERT INTO abc SELECT a, b, c FROM abc;
+    INSERT INTO abc SELECT b, a, c FROM abc;
+    INSERT INTO abc SELECT c, b, a FROM abc;
+  }
+  expr [file size test.db] / 1024
+} {1691}
+do_test sqllimits1-3.7.2 {
+  db close
+  sqlite3 db test.db
+  execsql {
+    PRAGMA max_page_count = 1000;
+  }
+  execsql {
+    SELECT count(*) FROM sqlite_master;
+  }
+} {6}
+do_test sqllimits1-3.7.3 {
+  execsql {
+    PRAGMA max_page_count;
+  }
+} {1691}
+do_test sqllimits1-3.7.4 {
+  execsql {
+    DROP TABLE abc;
+  }
+} {}
+
+#--------------------------------------------------------------------
+# Test cases sqllimits1-4.* test the SQLITE_MAX_COLUMN limit.
+#
+do_test sqllimits-1.4.1 {
+  # Columns in a table.
+  set cols [list]
+  for {set i 0} {$i <= $SQLITE_MAX_COLUMN} {incr i} {
+    lappend cols "c$i"
+  }
+  catchsql "CREATE TABLE t([join $cols ,])" 
+} {1 {too many columns on t}}
+
+do_test sqllimits-1.4.2 {
+  # Columns in the result-set of a SELECT.
+  set cols [list]
+  for {set i 0} {$i <= $SQLITE_MAX_COLUMN} {incr i} {
+    lappend cols "sql AS sql$i"
+  }
+  catchsql "SELECT [join $cols ,] FROM sqlite_master"
+} {1 {too many columns in result set}}
+
+do_test sqllimits-1.4.3 {
+  # Columns in the result-set of a sub-SELECT.
+  set cols [list]
+  for {set i 0} {$i <= $SQLITE_MAX_COLUMN} {incr i} {
+    lappend cols "sql AS sql$i"
+  }
+  catchsql "SELECT sql4 FROM (SELECT [join $cols ,] FROM sqlite_master)"
+} {1 {too many columns in result set}}
+
+do_test sqllimits-1.4.4 {
+  # Columns in an index.
+  set cols [list]
+  for {set i 0} {$i <= $SQLITE_MAX_COLUMN} {incr i} {
+    lappend cols c
+  }
+  set sql1 "CREATE TABLE t1(c);"
+  set sql2 "CREATE INDEX i1 ON t1([join $cols ,]);"
+  catchsql "$sql1 ; $sql2"
+} {1 {too many columns in index}}
+
+do_test sqllimits-1.4.5 {
+  # Columns in a GROUP BY clause.
+  catchsql "SELECT * FROM t1 GROUP BY [join $cols ,]"
+} {1 {too many terms in GROUP BY clause}}
+
+do_test sqllimits-1.4.6 {
+  # Columns in an ORDER BY clause.
+  catchsql "SELECT * FROM t1 ORDER BY [join $cols ,]"
+} {1 {too many terms in ORDER BY clause}}
+
+do_test sqllimits-1.4.7 {
+  # Assignments in an UPDATE statement.
+  set cols [list]
+  for {set i 0} {$i <= $SQLITE_MAX_COLUMN} {incr i} {
+    lappend cols "c = 1"
+  }
+  catchsql "UPDATE t1 SET [join $cols ,];"
+} {1 {too many columns in set list}}
+
+do_test sqllimits-1.4.8 {
+  # Columns in a view definition:
+  set cols [list]
+  for {set i 0} {$i <= $SQLITE_MAX_COLUMN} {incr i} {
+    lappend cols "c$i"
+  }
+  catchsql "CREATE VIEW v1 AS SELECT [join $cols ,] FROM t1;"
+} {1 {too many columns in result set}}
+
+do_test sqllimits-1.4.9 {
+  # Columns in a view definition (testing * expansion):
+  set cols [list]
+  for {set i 0} {$i < $SQLITE_MAX_COLUMN} {incr i} {
+    lappend cols "c$i"
+  }
+  catchsql "CREATE TABLE t2([join $cols ,])"
+  catchsql "CREATE VIEW v1 AS SELECT *, c1 AS o FROM t2;"
+} {1 {too many columns in result set}}
+
+#--------------------------------------------------------------------
+# These tests - sqllimits-5.* - test that the SQLITE_MAX_EXPR_DEPTH
+# limit is enforced. The limit refers to the number of terms in 
+# the expression.
+#
+if {$::SQLITE_MAX_EXPR_DEPTH != 1000} {
+  puts -nonewline stderr "WARNING: Compile with -DSQLITE_MAX_EXPR_DEPTH to run "
+  puts stderr "tests sqllimits-1.5.X"
+} else {
+  do_test sqllimits-1.5.1 {
+    set max $::SQLITE_MAX_EXPR_DEPTH
+    set expr "(1 [string repeat {AND 1 } $max])"
+    catchsql [subst {
+      SELECT $expr
+    }]
+  } "1 {Expression tree is too large (maximum depth $::SQLITE_MAX_EXPR_DEPTH)}"
+  
+  # Attempting to beat the expression depth limit using nested SELECT
+  # queries causes a parser stack overflow. 
+  do_test sqllimits-1.5.2 {
+    set max $::SQLITE_MAX_EXPR_DEPTH
+    set expr "SELECT 1"
+    for {set i 0} {$i <= $max} {incr i} {
+      set expr "SELECT ($expr)"
+    }
+    catchsql [subst { $expr }]
+  } "1 {parser stack overflow}"
+  
+  
+  do_test sqllimits-1.5.3 {
+    execsql {
+      PRAGMA max_page_count = 1000000;  -- 1 GB
+      CREATE TABLE v0(a);
+      INSERT INTO v0 VALUES(1);
+    }
+    db transaction {
+      for {set i 1} {$i < 200} {incr i} {
+        set expr "(a [string repeat {AND 1 } 50]) AS a"
+        execsql [subst {
+          CREATE VIEW v${i} AS SELECT $expr FROM v[expr {$i-1}]
+        }]
+      }
+    }
+  } {}
+  
+  do_test sqllimits-1.5.4 {
+    catchsql {
+      SELECT a FROM v199
+    }
+  } "1 {Expression tree is too large (maximum depth $::SQLITE_MAX_EXPR_DEPTH)}"
+}
+
+#--------------------------------------------------------------------
+# Test cases sqllimits-6.* 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_MAX_FUNCTION_ARG limit works. Test case names
+# match the pattern "sqllimits-7.*".
+#
+do_test sqllimits-1.7.1 {
+  set max $::SQLITE_MAX_FUNCTION_ARG
+  set vals [list]
+  for {set i 0} {$i < $SQLITE_MAX_FUNCTION_ARG} {incr i} {
+    lappend vals $i
+  }
+  catchsql "SELECT max([join $vals ,])"
+} "0 [expr {$::SQLITE_MAX_FUNCTION_ARG - 1}]"
+do_test sqllimits-1.7.2 {
+  set max $::SQLITE_MAX_FUNCTION_ARG
+  set vals [list]
+  for {set i 0} {$i <= $SQLITE_MAX_FUNCTION_ARG} {incr i} {
+    lappend vals $i
+  }
+  catchsql "SELECT max([join $vals ,])"
+} {1 {too many arguments on function max}}
+
+# Test that it is SQLite, and not the implementation of the
+# user function that is throwing the error.
+proc myfunc {args} {error "I don't like to be called!"}
+do_test sqllimits-1.7.2 {
+  db function myfunc myfunc
+  set max $::SQLITE_MAX_FUNCTION_ARG
+  set vals [list]
+  for {set i 0} {$i <= $SQLITE_MAX_FUNCTION_ARG} {incr i} {
+    lappend vals $i
+  }
+  catchsql "SELECT myfunc([join $vals ,])"
+} {1 {too many arguments on function myfunc}}
+
+#--------------------------------------------------------------------
+# Test cases sqllimits-8.*: Test the SQLITE_MAX_ATTACHED limit.
+#
+# TODO
+do_test sqllimits-1.8.1 {
+  set max $::SQLITE_MAX_ATTACHED
+  for {set i 0} {$i < ($max)} {incr i} {
+    file delete -force 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 sqllimits-1.8.2 {
+  set max $::SQLITE_MAX_ATTACHED
+  for {set i 0} {$i < ($max)} {incr i} {
+    execsql "DETACH aux${i}"
+  }
+} {}
+
+#--------------------------------------------------------------------
+# Test cases sqllimits-9.*: Check that the SQLITE_MAX_VARIABLE_NUMBER 
+# limit works.
+#
+do_test sqllimits-1.9.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 sqllimits-1.9.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}"
+
+
+#--------------------------------------------------------------------
+# sqllimits-10.*:  Test the SQLITE_MAX_PAGE_SIZE define is enforced. 
+# This is probably tested elsewhere too (pagerX.test). Attempts
+# to raise the page size above this limit are silently ignored.
+#
+do_test sqllimits-1.10.1 {
+  db close
+  file delete -force test.db test.db-journal
+  sqlite3 db test.db
+  set max $::SQLITE_MAX_PAGE_SIZE
+  catchsql "PRAGMA page_size = [expr {$max*2}]"
+} {0 {}}
+do_test sqllimits-1.10.2 {
+  catchsql "PRAGMA page_size"
+} {0 1024}
+do_test sqllimits-1.10.3 {
+  set max $::SQLITE_MAX_PAGE_SIZE
+  catchsql "PRAGMA page_size = $max"
+} {0 {}}
+do_test sqllimits-1.10.4 {
+  execsql "pragma page_size"
+} $::SQLITE_MAX_PAGE_SIZE
+do_test sqllimits-1.10.5 {
+  set max $::SQLITE_MAX_PAGE_SIZE
+  execsql "pragma page_size = [expr {$max - 5}]"
+  execsql "pragma page_size"
+} $::SQLITE_MAX_PAGE_SIZE
+
+# Opening a database where the page size is too large should generate
+# an error.
+#
+do_test sqllimits-1.10.5 {
+  db close
+  file delete -force test.db
+  set ::SQLITE_MAX_PAGE_SIZE 32768
+  sqlite3 db test.db
+  db eval {PRAGMA page_size=32768}
+  db eval {CREATE TABLE t1(x);}
+  db eval {PRAGMA page_size}
+} {32768}
+do_test sqllimits-1.10.6 {
+  db close
+  set ::SQLITE_MAX_PAGE_SIZE 8192
+  sqlite3 db test.db
+  catchsql {SELECT name FROM sqlite_master}
+} {1 {file is encrypted or is not a database}}
+db close
+file delete -force test.db
+sqlite3 db test.db
+
+#--------------------------------------------------------------------
+# Test cases sqllimits-11.* 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.
+#
+# 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).
+#
+do_test sqllimits-1.11.1 {
+  set max $::SQLITE_MAX_LIKE_PATTERN_LENGTH
+  set ::pattern [string repeat "A%" [expr $max/2]]
+  set ::string  [string repeat "A" [expr {$max*2}]]
+  execsql {
+    SELECT $::string LIKE $::pattern;
+  }
+} {1}
+do_test sqllimits-1.11.2 {
+  set max $::SQLITE_MAX_LIKE_PATTERN_LENGTH
+  set ::pattern [string repeat "A%" [expr {($max/2) + 1}]]
+  set ::string  [string repeat "A" [expr {$max*2}]]
+  catchsql {
+    SELECT $::string LIKE $::pattern;
+  }
+} {1 {LIKE or GLOB pattern too complex}}
+
+#--------------------------------------------------------------------
+# This test case doesn't really belong with the other limits tests.
+# It is in this file because it is taxing to run, like the limits tests.
+#
+do_test sqllimits-1.12.1 {
+  set ::N [expr int(([expr pow(2,32)]/50) + 1)]
+  expr (($::N*50) & 0xffffffff)<55
+} {1}
+do_test sqllimits-1.12.2 {
+  set ::format "[string repeat A 60][string repeat "%J" $::N]"
+  catchsql {
+    SELECT strftime($::format, 1);
+  }
+} {1 {string or blob too big}}
+
+
+foreach {key value} [array get saved] {
+  catch {set $key $value}
+}
+finish_test