# xsql

sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE a= /* */b=C AND c=? AND d=E AND b=? AND c=? AND d=E AND b=? AND c=? AND d=E AND e OR?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE a= /* */b=C AND c=? AND d=e AND b=? AND c=? AND  /* */ ~~~ ~~~~~d=E AND e OR ~~~~~~~~~~~~~d=E AND e OR ~~~~~~~~~~~~~~~d=E AND e O;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE a= /* */b=C AND c=? AND d=e AND b=? AND c=? AND d= d=E AND~~~~~d=E AND E AND~~~~~d=E AND e OR ~~~~~~~~~~~~~~~d=E AND e OR@R?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE a= /* */b=C AND c=? AND d=e AND b=? AND c=? AND d=E || ~~~ ~~~~~d=E AND e OR ~~~~~~~~~~~~~d=E AND e OR  total_changes()=E AND e O;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE a= /* */b=C AND d=E AND b=? AND c=? AND d=E AND c=? AND d=E AND b=? AND c=? AND d=E AND e OR?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE a= /* */b=C AND ~~~~~~~~~~~~~~~d=E AND e OR c=? AND d=e AND b=? AND c=? AND d=E AND e =? AND c=? AND ~~~~~~~~~~~~~~~d=E AND e OROR?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE a=?  >= b=?  >= c=? AND d=? AND b=? AND c=?  AND d<? AND e >=?AND d<? AND e >=?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND b=? AND c=+ -12 days=? A e=?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND b=A AND c=? AND d=? AND e e=?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=?AND d<? AND e >=?AND d<? AND c=?  AND d<? AND e OR?AND d<? AND e >=?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=?AND d<? AND e OR?AND d<? AND a=?  AND d,?  e >


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=?AND d<? AND e OR?AND d<? AND c=?  AND d<? AND e >=?AND ? AND c=?  AND d<? AND e >=?AND d<? AND e >=?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=C AND c=? AND d=? AND b=? AND c=? AND d= -1? AN


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE a=C AND c=? AND d=e AND b=? AND c= /* */b=C AND c=? AND d=e AND b=? AND c=? AND d=E AND~~~~~d=E AND e OR ~~~~~~~~~~~~~~~d=E AND e ORO


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE a=D AND b=? AND c=? AND d=? AND b=? AND c=? AND d=? AND e e=?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE c= /* */b=C AND c=? AND d=E AND b=? AND c=? AND d=E AND e OR?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE d=? AND b=? AND a=? AND b=? AND c=? AND d= - -11? AND e OR?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE d=? AND b=? AND a=? AND b=? AND c=? AND d=33333333333? AND b*? AND c=? AND d=? AND e OR?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE d=? AND b=? AND a=? AND b=? AND c=? AND d=? AND b=?  AND c=? AND d=?AND c=? AND d=+2 days OR?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE d=? AND b=? AND a=? AND b=? AND c=? AND d=? AND b=? AND c=? AND e=? AND e e=?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE@a AND c=B AND d=E AND b== /* */b=C AND c=? AND d=E AND b=? AND c=? AND d=E AND e OR?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE~~~~~~~~~~~~~ a= /* */b=C AND c=? AND d=e
AND b=? AND c=? AND d=E || ~~~~~d=E AND e OR ~~~~~~~~~~~~~~~d=E AND e OROR?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT DISTINCT* FROM t0 WHERE glob(1,1)=? AND a=? AND  0  AND c=? AND d=? AND b=? AND c=? AND d=? AND e OR?AND b=? AND c=? ;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT DISTINCT* FROM t0 WHERE glob(1,1)=? AND a=? AND b=? AND c=? AND d=? AND b=? AND c=? AND d=? AND e OR?AND b= a=? AND b=? AND c=? AND d=? AND b=? AND c=? AND d=? AND? @ND c=? ;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT DISTINCT* FROM t0 WHERE glob(1,1)=? AND a=? AND b=? AND c=? AND d=?;
SELECT DISTINCT* FROM t0 WHERE glob(1,1)=? AND a=? AND b=? AND c=? AND d=? AND b=? AND c=? AND d=? AND e OR?AND b=? AND c=?  AND b=? AND c=? AND d=? AND e OR?AND b=? AND c=? ;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT DISTINCT* FROM t0 WHERE glob(1,1)=? AND a=?4AND b=? AND c=? AND d=? AND ? AND a=? AND b=? AND c=? AND d=? AND b=? AND b=? AND c=? AND d=? AND b=? AND c=? AND d=? AND e IS?AN


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT DISTINCT* FROM t0 WHERE glob(1,1)=? AND a=?4AND b=? AND c=? AND d=? AND ? AND a=? AND b=? AND c=? AND d=? AND b=? AND b=? AND c=? AND d=? AND b=? AND c=? AND d=? AND e OR?AN


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,e,b,c,d,e,c,e,c,c,d,e,b,c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(b, b);
VACUUM


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,c,e,b,c,e,e,c,e,b,c,d,e,b,c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(b, b);
VACUUM


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,b,e,d,e));
SELECT DISTINCT* FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e=?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,ba,b,ce));
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND!d=? AND e=?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,c,c,e,b,c,d,a,b,c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(b, b);
VACUUM


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,d,c,e,b,c,d,e,b,c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(b, b);
VACUUM


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e=?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(a,d,e));
SELECT DISTINCT* FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e=?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(b,c,a,e));
SELECT DISTINCT* FROM t0 WHERE a=? AND b=? AND c=?ND;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(b,c,d,b,a,d,e,e));
SELECT DISTINCT* FROM t0 WHERE a=? AND b=? AND c=?ND;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(b,c,d,b,c,c,e,e));
SELECT DISTINCT* FROM t0 WHERE d=? AND b=? AND c=?ND;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=D AND d=? AND b=? AND c=? AND e<? AND e >=?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c /* */,e));
SELECT DISTINCT* FROM t0 WHERE glob(1,1)=? AND a=? AND b=? AND c=? AND d=? AND e OR?AND c=? AND d=? AND b AND d=? AND e OR?AND c=? AND c=? AND d=? AND e OR?AND c=? AND d=? AND b AND d=?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0( "a","b",c,d,e);
000000


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(b,a,a, b,c,d,e);
VACUUM


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(b,c, [a],c,d,e);
VACUUM


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(b,c,a, a, b,c,d,e)b


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(b,c,a, b,c,d,e);
000000


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(b,c,a,a, b,c,d,e);
000000


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c,a,a,e,e));
SELECT * FROM t0 WHERE a=E AND b=? AND c=? AND d=A AND b=? AND c=?  AND d<? AND e ISNULL d<?


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c,b,a,d,e));
SELECT * FROM t0 WHERE a=E AND b=7 AND c=? AND d=A AND b=? AND c=?  AND d<? AND e ISNULL d<?


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c,b,a,e,e));
SELECT * FROM t0 WHERE a=E AND b=? AND c=? AND b=? AND b=? AND c=?  AND d<? AND e AND c=? AND b=? AND b=? AND c=?  AND d<? AND e ISNULL d<?


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c,b,a,e,e));
SELECT * FROM t0 WHERE a=E AND b=? AND c=? AND d=? AND b=? AND c=?  AND d<? AND e IS@d<? AND e IS@ULL d<?ULL d<?


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c,b,a,e,e));
SELECT * FROM t0 WHERE a=E AND b=? AND c=? AND d=A AND b=? AND c=?  AND d<? AND e ISNULL d<?


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c,b,a,e,e));
SELECT * FROM t0 WHERE a=E AND b=C AND c=? AND d=? AND b=? AND c=?  AND d<? AND e ISNULL d<?


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c,b,a,e,e));
SELECT * FROM t0 WHERE a=E AND b=E AND b=? AND c=? AND b=? AND b=? AND c=?? AND e ISNULL d<?


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c,b,a,e,e));
SELECT * FROM t0 WHERE a=E AND glob(1,1)=? AND d=? AND b=? AND c=?  AND d<? AND e ISNULL d<?


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c,b,c,a,b,c,d,a,b,c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0( [a],c,c,e);
VACUUM


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c,b,c,a,b,c,d,a,b,c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(c, c,c,c,e);
VACUUM


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c,b,c,d,b,c,d,c,e));
SELECT DISTINCT* FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e=?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(c,b,c,d,e));
SELECT DISTINCT* FROM t0 WHERE glob(1,1)=? AND a=? AND b=? AND c=? AND d=? AND b=? AND c=? AND d=? AND e OR?AND b=? AND c=? ;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,E,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e= strftime(1, randomblob(1));


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,E,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e= strftime(1,1, random(),1));


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,E,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e= strftime(1,1, time( 1=11));


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,E,c,e,a));
SELECT * FROM t0 WHERE a=? AND b=? AND c=7 AND d=? AND e= strftime(1 >=CURRENT_TIME);


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,E,c,e,a));
SELECT * FROM t0 WHERE a=? AND b=? AND c=7 AND d=? AND e= strftime(1<1, printf(1,1));


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,E,c,e,a));
SELECT * FROM t0 WHERE a=? AND b=? AND c=7 AND d=? AND e= strftime(1<1,CURRENT_DATE);


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,E,c,e,a));
SELECT * FROM t0 WHERE a=? AND b=? AND c=7 AND d=? AND e= strftime(1<1,CURRENT_TIME);


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,E,c,e,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=7 AND d=? AND e= strftime(1 >=CURRENT_TIME);


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,E,c,e,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=7 AND d=? AND e= strftime(1, substr(1,1,1));


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,E,c,e,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=7 AND d=? AND e= strftime(1,1,CURRENT_TIME);


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,E,c,e,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=7 AND d=? AND e= strftime(1<1,CURRENT_DATE);


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,E,c,e,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=7 AND d=? AND e= strftime(1<1,CURRENT_TIME);


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,E,c,e,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e= strftime(1,1, random(),1));


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,E,c,e,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e= strftime(1,1, time(1,1,1));


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,E,c,e,e));EXPLAIN
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e= strftime(1,1,CURRENT_TIME);


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,E,e,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e= strftime(1,1,CURRENT_TIME);


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,D,a,b,c,d,a,b,c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(c, c,c,c,e);
VACUUM


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,a,b,c,d,a,b,c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0( "a","b",e);
VACUUM


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,a,b,c,d,a,b,c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0( [a],c,c,e);
VACUUM


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,a,b,c,d,a,b,c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(b,b,a,a, b,c,d,e)000000


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,a,b,c,d,a,b,c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(b,b,c,a, b,c,d,e)00000


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,a,b,c,d,a,b,c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(b,b,c,c, b,c,b,c)000000


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,a,b,c,d,a,b,c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(c, b,c,d,e);
VACUUM


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,a,b,c,d,a,b,c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(c, c,c,c,e);
VACUUM


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE  -0 AND b=? AND c AND b=? AND c=? AND d=? AND e=? AND d=? AND e=B;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c AND b=? AND c=? AND d=? AND e= likely(1)AND e=B;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c AND b=? AND? AND c AND b=? AND c=? AND d=? AND e=? AND d=? AND e=B;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e= strftime(1,1,1,1,b,c,d,e= strftime(1,1,1,1,b,c,d,e));
e));


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e= strftime(1,1,A,1,b,c,d,e));


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e= strftime(1<1,1,1,b,c,d,e));


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND time(1,1,A,1,b,c,d,e));


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=?BETWEEN?AND b=?BETWEEN? AND d=?BETWEEN? AND e=A;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=?BETWEEN?AND c=?BETWEEN? AND d=? AND e=A;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=?BETWEEN?AND c=NOT?BETWEEN? AND d=? AND e=A;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE a=?BETWEEN? AND time(1,1,A,1,b,e));


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE a=?BETWEEN? AND time(1,1,A,1<b,c,d,e));


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE a=?BETWEEN? AND time(A,1,A,1,b,c,d,e));


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE a=?BETWEEN?BETWEEN?AND@b=?BETWEEN /* */d=? AND?BETWEEN /* */d=? AND d=? AND d=? AND e=A;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE a=?LIKE b=?BETWEEN?AND b=?BETWEEN? AND d=?BETWEEN? AND e=A;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE d=?BETWEEN?BETWEEN?AND b=?BETWEEN /* */oid AND d=? AND e=A;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE d=?BETWEEN?BETWEEN?AND@b=?BETWEEN /* */oid AND d=? AND e=A;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE?AND@b=?BETWEEN? AND c=?BETWEEN?BETWEEN?AND@b=?BETWEEN? AND d=? AND d=? AND e=A;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT * FROM t0 WHERE@a=? AND b=? AND c=? AND d=? AND e=?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e));
SELECT DISTINCT* FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e=?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,d,e,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=C AND c=? AND d=? AND e=B;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,b,c,e,b,c,d,e,c,e,b,c,d,e,b,c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(b, b);
VACUUM


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,c,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e= strftime(1,d,e,1,1,1)OR?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,c,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=E AND d=? AND e= strftime(0e+21,1)?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,c,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=E AND d=? AND e= strftime(1, random()MATCH -1,1)?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,c,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=E AND d=? AND e= strftime(10e02,1)?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,c,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=E AND d=? AND e= strftime(1e031,1)?;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,c,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=E AND d=? AND e= strftime(1e081,1);;


sqltext:
CREATE TABLE t0(a,b,c,d,e, PRIMARY KEY(e,c,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=E AND d=? AND e= strftime(1e084,1)?;


sqltext:
CREATE TABLE t0(a,b,c,dc int,d,e, PRIMARY KEY(a,b,d,e,c,d,b,e,c,d,b,c,d,e,c,d,d,b,c,d,e,c,d,e,e,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e=?;


sqltext:
CREATE TABLE t0(a,�b);
SELECT DISTINCT "a","b""""a","ba","b",oid,"b""a","ba","b", *FROM (SELECT DISTINCT"ba","b",oid,"b",oid,"b""a","ba","b", *FROM t0) WHERE a==0;


sqltext:
CREATE TABLE t0(a9 b);
SELECT total(1) "a","b""b""a","ba","b", *,"b""a","ba","b", *FROM (SELECT "b","b""""a","ba","b",oid,"b""a","a","a","ba","b",oid,"b""a","ba""b",oid,"b""a","ba","b",count(*)a FROM t0) W;


sqltext:
CREATE TABLE t0(aATE TABY KEY, b REFERENCE��������S t0);
CREATE TABLE t2(a PRIM RY KEY,  c REFEt0);VACUUM;
CREATE TABLE t3(a REFERE6CES t0, b REFERENCES t2, c REFERENCES t0);VACUUM


sqltext:
CREATE TABLE t0(ab""""a","ba","b",oid,"b""a","ba","b", |"a","a","a","ba","b",oiW,"b""a","ba""b",oid,"b""a","ba","b", b);
SELECT total(1) "a","b""""a","ba","b",oid, date(1,1,1)"b", *FROM (SELECT "b","b""""a","ba","b",tio || "a","a","a","ba","b",oid,"b""bJ, b);
S�LECT total(1) "a","b""""a","ba",DROPoid,"b""a","ba","b", *FROM (SELECT "b","P""""a","ba","b",oid || "a","a","a","ba","b",oid,"b""a","ba""b",oid,""a","a","ba","b",oid,"b""a","ba""b",oid,"b""a","wa","b",count(*)a FROg t0) WHERE a="a","ba""b",oid,""a","a","ba","b",oid,"b""a","ba""b",oid,"b""a","ba","b",count(*)a FROM t0) WHERE a==;


sqltext:
CREATE TABLE t0(a� b);
SELECT DISTINCT "a","b",oid b,"b",oid,"b""a","ba","b", *FROM (SELECT DISTINCT"ba","b",oid bloboid,"b""a","ba","b", *FROM t0) E a=


sqltext:
CREATE TABLE t0(a� b);
SELECT total(1) "a","b""""a","ba","b",oid,"b""a","ba","b", *FROM (SELECT "b","b""""a","ba","b",@id,"b""a","a","a","ba","b",oid,"b""a","ba""b",oid,"b""a","ba","b",count(*)a FROM t0) WHERE a==0;


sqltext:
CREATE TABLE t0(c INTEGER PRIMARY KEY, d TEXT COLLATE nocase);
INSERT INTO t0 VALUES(10, 'fuzz');
SELECT 1 FROM t0 WHERE'0000' IN (d);  
SELECT 2 FROM t0 WHERE '0000' IN (d);  --000000000
SELECT 4 FROM t0 WHERE@d IN ('FUZZ');  --000000


sqltext:
CREATE TABLE t0(c INTEGER PRIMARY KEY, d TEXT COLLATE nocase);
INSERT INTO t0 VALUES(10, 'fuzz');
SELECT 1 FROM t0 WHERE'0000' IN (d);  
SELECT 2 FROM t0 WHERE NOT'0000' IN (d);  --00000
SELECT 4 FROM t0 WHERE d IN ('FUZZ');  --000000


sqltext:
CREATE TABLE t0(c INTEGER PRIMARY KEY, d TEXT COLLATE nocase);
INSERT INTO t0 VALUES(10, 'fuzz');
SELECT 1 FROM t0 WHERE'0000' IN (d);  
SELECT 2 FROM t0 WHERE NOT-0000' IN (d);  --00000
SELECT 4 FROM t0 WHERE d IN (Z');00


sqltext:
CREATE TABLE t0(e00T);
SELECT DISTINCT "a", "a","b","ba", "a","b","ba","b","aa","b","a", "a","b","ba","b","a","b","ba"b


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES( 'a''b''0z');
INSERT INTO t0 VALUES( 'a''b''0y');
INSERT INTO t0 VALUES('c0');
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m;
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,?)  FROM t0 ORDER BY lower(m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES( (1));
INSERT INTO t0 VALUES('0y');
INSERT INTO t0 VALUES('c0');
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m;
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,M)  FROM t0 ORDER BY lower(m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES( trim(1,1));
INSERT INTO t0 VALUES('');
INSERT INTO t0 VALUES('c0');
SELECT '0', substr(m, -12) AS m FROM t0 ORDER BY m;
SELECT '0', substr(m, -12) AS m FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,2)  FROM t0 ORDER BY lower(m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES( trim(1,1));
INSERT INTO t0 VALUES('0y');
INSERT INTO t0 VALUES('c0');
SELECT '0', substr(m, -12) AS m FROM t0


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES( trim(1,1));
INSERT INTO t0 VALUES('0y');
INSERT INTO t0 VALUES('c0');
SELECT '0', substr(m, -12) AS m FROM t0 ORDER BY m;
SELECT '0', substr(m, -12) AS m FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,2)  FROM t0 ORDER BY lower(m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES( trim(1,1));
INSERT INTO t0 VALUES('0y');
INSERT INTO t0 VALUES('c0');
SELECT '0', substr(m, -12) AS m FROM t0 ORDER BY m;
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,2)  FROM t0 ORDER BY lower(m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES( trim(1,1));
INSERT INTO t0 VALUES('0y');
INSERT INTO t0 VALUES('c0');
SELECT '0',$substr(m,2) IS m FROM t0 ORDER BY m;
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,2)  FROM t0 ORDER BY lower(m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES( trim(1,1));
INSERT INTO t0 VALUES('0y');
INSERT INTO t0 VALUES('c0');
SELECT '0',$substr(m,2) IS m FROM t0 ORDER BY m;
SELECT '0', substr(m,2) IS m FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,2)  FROM t0 ORDER BY lower(m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES( trim(1,1));
INSERT INTO t0 VALUES('φ');
INSERT INTO t0 VALUES('c0');
SELECT '0', substr(m, -12) AS m FROM t0 ORDER BY m;
SELECT '0', substr(m, -12) AS m FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,2)  FR FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,2)  FROM t0 ORDER BY lower(m);OM t0 ORDER BY lower(m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES( trim(1,1));
INSERT INTO t0 VALUES('φ');
INSERT INTO t0 VALUES('��');
SELECT '0', substr(m, -12) AS m FROM t0 ORDER BY m;
SELECT '0', substr(m, -12) AS m FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,2)  FROM t0 ORDER BY lower(m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES( trim(1,1));
INSERT INTO t0 VALUES('φ����������������������������������������������������������������������������������������������������������������');
INSERT INTO t0 VALUES('c0');
SELECT '0', substr(m, -12) AS m FROM t0 ORDER BY m;
SELECT '0', substr(m, -12) AS m FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,2)  FROM t0 ORDER BY lower(m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES(' -100');
INSERT INTO t0 VALUES('b0' -1);
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,M) AS00 FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES(' -100');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,M) AS00 FROM t0 GROUP BY m


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES(' -100');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,M) AS00 FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES(' -100');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,M) AS00 FROM t0 GROUP BY m ORDER BY 2, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES(' -100');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2<M) AS00 FROM t0 GROUP BY m ORDER BY 2, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES(' -1�0');
INSERT INTO t0 VALUES(' -1b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,M) AS00 FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES(' -1�0');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,M) AS00 FROM t0 GROUP BY m ORDER BY 2, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES(' abs(1)��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT lower(M), substr(m,2,1) AS00 FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES(' b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY  "a","b",0e0,.2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES(' -');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY m OR round(1,M);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES(' -1b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,M) AS00 FROM t0 GROUP BY m


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES(' 0');
INSERT INTO t0 VALUES(' 0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY m OR round(1,M);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*)& substr(m,2,M) AS00 FROM t0 GROUP BY mOR


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*),  group_concat( ltrim(1,1)) FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*),  group_concat(DISTINCT?,1) FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), sqlite_source_id() FROM t0 GROUP BY m ORDER BY 2, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m, "a","b" -1) AS00 FROM t0 GROUP BY m OR round(1,1);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m, -1) AS00 FROM t0 GROUP BY-m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m, -12,1) AS00 FROM t0 GROUP BY-m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2, "a") AS00 FROM t0 GROUP BY CURRENT_TIME,oid


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2, -01) AS00 FROM t0 GROUP BY CURRENT_TIME,0e0


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2, -11) AS00 FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY m OR round(M, -11);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY m OR round(M, .18);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY m OR round(M, @18);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY m OR round(M,2001-01-011);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY m OR round(M,3);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY m OR round(M,4);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY m OR round(M,8);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY m OR round(M,9);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY m OR round(M-1);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY m ORDER BY sum(1)


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY@m OR round(1,1);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,?) AS00 FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2. -01) AS00 FROM t0 GROUP BY CURRENT_TIME,oid


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2.1) AS00 FROM t0 GROUP BY  zeroblob(1), 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2.1) AS00 FROM t0 GROUP BY m ORDER BY 1, substr(1,1,1) 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2.1) AS00 FROM t0 GROUP BY m ORDER BY 2, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2<M) AS00 FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*),REPLACE(m,2, -11) AS00 FROM t0 GROUP BY CURRENT_TIME,oid


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT total(1), substr(m,2,1) AS00 FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN');
SELECT count(*),REPLACE(m, "a","b" -1) AS00 FROM t0 GROUP BY m >= round(1,1);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0'ISNULL);
INSERT INTO t0 VALUES('c0');
SELECT count(*),  group_concat(?,1) FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('0z');
INSERT INTO t0 VALUES('0y');
INSERT INTO t0 VALUES('c0');
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m;
SELECT '0', substr(m,2) AS m FROM t0 GROUP BY m COLLATE binary;
SELECT '0', substr(m,2)  FROM t0 ORDER BY lower(m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('0z');
INSERT INTO t0 VALUES('0y');
INSERT INTO t0 VALUES('c0');
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m;
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,2)  FROM t0 ORDER BY lower( @1m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('0z');
INSERT INTO t0 VALUES('0y');
INSERT INTO t0 VALUES('c0');
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m;
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,M)  FROM t0 ORDER BY lower(m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('0z');
INSERT INTO t0 VALUES('0y'ISNULL);
INSERT INTO t0 VALUES('c0');
SELECT '0', substr(m,2)m FROM t0 ORDER BY m;
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,?)  FROM t0 ORDER BY lower(m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('80');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY m OR round(M,8);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('RENAME0z');
INSERT INTO t0 VALUES('RENAME0y');
INSERT INTO t0 VALUES('c0');
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m;
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,2)  FROM t0 ORDER BY lower(m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('υ');
INSERT INTO t0 VALUES('0y');
INSERT INTO t0 VALUES('c0');
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m;
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,2)  FROM t0 ORDER BY lower(m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('υ');
INSERT INTO t0 VALUES('φ');
INSERT INTO t0 VALUES('c0');
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m;
SELECT '0', substr(m,2) AS m FROM t0 ORDER BY m COLLATE binary;
SELECT '0', substr(m,2)  FROM t0 ORDER BY lower(m);


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m, -1) AS00 FROM t0 GROUP BY   "a","b""a","b","b",.2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m, -1) AS00 FROM t0 GROUP BY mOR


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m, -1) AS00 FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m, -1) AS00 FROM t0 GROUP BY m ORDER BY 2, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m, count(1) -1) AS00 FROM t0 GROUP BY m ORDER BY 2, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY  "a","b",0e0,.2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY m OR "a","b",$2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY m OR "a","m",.2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT lower( ltrim(1,1)), substr(m,2,1) AS00 FROM t0 GROUP BY m ORDER BY 1, 1;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT lower( ltrim(1<1)), substr(m,2,1) AS00 FROM t0 GROUP BY m ORDER BY 1, 1;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT lower( ltrim(M<1)), substr(m,2,1) AS00 FROM t0 GROUP BY m ORDER BY 1, 1;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT lower(2&01-01E0112001-01-01), substr(m,2,1) AS00 FROM t0 GROUP BY m ORDER BY 1, 1;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT lower(2001-0.E011), substr(m,2,1) AS00 FROM t0 GROUP BY m ORDER BY 1, 1;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT lower(2001-01.011), substr(m,2,1) AS00 FROM t0 GROUP BY m ORDER BY 1, 1;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT lower(2001-01.011), substr(m,2,1) AS00 FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT lower(2001-01E011), substr(m,2,1) AS00 FROM t0GRO1;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT lower(2001-01E011), substr(m,2,1) AS00 FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT lower(2001.01E011), substr(m,2,1) AS00 FROM t0 GROUP BY m ORDER BY 1, 1;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT lower(:001-01-011), substr(m,2,1) AS00 FROM t0 GROUP BY m ORDER BY 1, 1;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT lower(?), substr(m,2,1) AS00 FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT random(), substr(m,2,1) AS00 FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m CHAR(2));
INSERT INTO t0 VALUES('��');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT sqlite_source_id(), substr(m,2,1) AS00 FROM t0 GROUP BY m ORDER BY 1, 2;


sqltext:
CREATE TABLE t0(m �HAR(2));
INSERT INTO t0 VALUES('00');
INSERT INTO t0 VALUES('b0');
INSERT INTO t0 VALUES('c0');
SELECT count(*), substr(m,2,1) AS00 FROM t0 GROUP BY m OR round(M,1);


sqltext:
CREATE TABLE t0(x INT0000, y TEXT, z);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0.0,3);
INSERT INTO t0 VALUES(0.0,0.0,0);
SELECT DISTINCT "a","b" x, "a",oid y FROM t0 ORDER BY z;


sqltext:
CREATE TABLE t0(x INT0000, y TEXT, z);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0.0,3);
INSERT INTO t0 VALUES(0.0,0.0,0);
SELECT DISTINCT "a","b"OR@x, * FROM t0 ORDER BY z;


sqltext:
CREATE TABLE t0(x INT0000, y TEXT, z);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0.0,3);
INSERT INTO t0 VALUES(0.0,0.0,0);
SELECT DISTINCT "a"COLLATE y FROM t0 ORDER BY z;


sqltext:
CREATE TABLE t0(x INT0000, y TEXT, z);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0.0,3);
INSERT INTO t0 VALUES(0.0,0.0,0);
SELECT DISTINCT random() x, zeroblob(200
-01-011) y FROM t0 GROUP BY z;


sqltext:
CREATE TABLE t0(x INT0000, y TEXT, z);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0.0,3);
INSERT INTO t0 VALUES(0.0,0.0,0);
SELECT DISTINCT random() x, zeroblob(2001-01-011) z FROM t0 ORDER BY z;


sqltext:
CREATE TABLE t0(x INT0000, y TEXT, z);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0.0,3);
INSERT INTO t0 VALUES(0.0,0.0,0);
SELECT DISTINCT x, round(1,1) y FROM t0 ORDER BY z;


sqltext:
CREATE TABLE t0(x INT0000, y TEXT, z);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0.0,3);
INSERT INTO t0 VALUES(0.0,0.0,0);
SELECT DISTINCT x, zeroblob(2001 || 011) y FROM t0 GROUP BY z;


sqltext:
CREATE TABLE t0(x INT0000, y TEXT, z);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0.0,3);
INSERT INTO t0 VALUES(0.0,0.0,0);
SELECT DISTINCT x, zeroblob(2001.01-011) y FROM t0 GROUP BY z;


sqltext:
CREATE TABLE t0(x INT0000, y TEXT, z);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0.0,3);
INSERT INTO t0 VALUES(0.0,0.0,0);
SELECT DISTINCT x, zeroblob(2001.01-011) y FROM t0 ORDER BY z;


sqltext:
CREATE TABLE t0(x INT0000, y TEXT, z);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0.0,3);
INSERT INTO t0 VALUES(0.0,0.0,0);
SELECT DISTINCT zeroblob(1) x, zeroblob(1) y FROM t0 ORDER BY z;


sqltext:
CREATE TABLE t0(x INT0000, y TEXT, z);
INSERT INTO t0 VALUES(0,0,8);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0.0,3);
INSERT INTO t0 VALUES(0.0,0.0,0);
SELECT DISTINCT x, zeroblob(2001.01-011) y FROM t0 GROUP BY z;


sqltext:
CREATE TABLE t0(x INT0000, y TEXT, z);
INSERT INTO t0 VALUES(8,0,0);
INSERT INTO t0 VALUES(0,0,0);
INSERT INTO t0 VALUES(0,0.0,3);
INSERT INTO t0 VALUES(0.0,0.0,0);
SELECT DISTINCT x, zeroblob(2001-01-011) y FROM t0 ORDER BY z;


sqltext:
CREATE TABLE t0(x INTEGER PRIMARY KEY, y);
CREATE TABLE t3(a, b);
CREATE TRIGGER a0000000 AFTER INSERT ON t0 BEGIN
INSERT INTO t3 VALUES(new.x, new.y);
END;
INSERT INTO t0 VALUES(5000000000, 0);EXPLAIN
SELECT last_insert_rowid();


sqltext:
CREATE TABLE t0(x INTEGER PRIMARY KEY, y);
CREATE TABLE t3(a, b);
CREATE TRIGGER a0000000 AFTER INSERT ON t0 BEGIN
INSERT INTO t3 VALUES(new.x, new.y);
END;EXPLAIN
INSERT INTO t0 VALUES(5000000000, 0);
SELECT last_insert_rowid();


sqltext:
CREATE TABLE t0(x TEX5 UNIQPE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','0 0','0');
SELECT DISTINCT? FROM t0 WHERE (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR y='000' OR y='0000' OR y='000' OR y= y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT? FROM t0 WHERE (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR y='000' OR y='0000' OR y='000'�OR y= y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000' =R y='000') OR '0' ='000' =R y='000') OR '0' y='00O


sqltext:
CREATE TABLE t0(x TEX5 UNIQPE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT? FROM t0 WHERE (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR (y='00L' OR y AND x= datetime(1,1,1) OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR y='000' OR y='0000' OR y='000' OR y= y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000< OR') OR y AND x='00' OR y='000' OR y AND x='000' OR (y='00L' OR y AND x= datetime(1,1,1) OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR y='000' OR y='0000' OR y='000' OR y= y='000' O y='000') OR '0' y='00O


sqltext:
CREATE TABLE t0(x TEX5 UNIQPE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT? FROM t0 WHERE (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y ;
SELECT DISTINCT? FROM t0 WHERE (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR y='000' OR y='0000' OR y='000' OR y= y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000' OR y='000') AND x='00' OR y='000' OR y AND x='000' OR y='000' OR y='000' OR y='000' OR y= y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000' OR y='000') OR '0' y='00O


sqltext:
CREATE TABLE t0(x TEX5 UNIQPE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT? FROM t0 WHERE (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR (y='00L0');
SELECT DISTINCT? FROM t0 WHERE (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='' OR y AN='x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR y='000' OR y='0000' OR y='000' OR y= y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000' OR y='000') OR '0' y='00O


sqltext:
CREATE TABLE t0(x TEX5 UNIQPE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT? FROM t0 WHERE (y='00L' OR y AND x='000' OR y='000' OR y='00000') OR y AND x='00' OR y='000' OR y AND x='00' OR (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR y='000' OR y='0000' OR y='000' OR y= y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000' OR y='') OR y AND x='00' OR y='000' OR y AND x='00' OR (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR y='000' OR y='0000' OR y='000' OR y= y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000' OR y='000') OR '0' y='00O


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEWT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT? FROM t0 WHERE (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR y='000' OR y='0000' OR y='000' @ y='0' y='00O


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE ( date(1,1,1) AND x='000' OR y='000' OR y='000') AND(x='000' OR y='000')N


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (x='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000'OR)N


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (x='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR y='000' OR y='000'; OR;N


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (x='00L' OR y AND x='000�������������������������������������������������������������0');
SELECT DISTINCT* FROM t0 WHERE (x='00L' OR y AND x='000�����������������������������������������������겲�����������������' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y='000';N


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR y='000' OR y='0000' OR y='000' OR y='0' y='00O


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR y='000' OR y='000') OR;N


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (z='00L' IS y AND x=' julianday(1,1,1)000' OR y='000') AND(x='000' OR y='000')N


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (z='00L' IS y AND x='000' OR y<'000' OR y='000') AND(x='000' OR y='000')N


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (z='00L' IS y AND x='000'ISNULL MATCH'000' OR y='000') AND(x='000' OR y='000')N


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (z='00L' IS y AND x='000'ISNULL OR y='000' OR y='000') AND(x='000' OR y='000')N


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (z='00L' OR /* */ x='000' OR y='000' OR y='000') AND x='000' OR y='000')N


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (z='00L' OR y AND x='00dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd0' OR y='000' OR y='000') AND(x='0ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd0' OR y='0000' OR y='000')N


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT? FROM t0 WHERE (y<'00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR y='000' OR y='0000' OR y='000' OR y='0' y='00O


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT? FROM t0 WHERE (y='00L' OR y );
SELECT DISTINCT? FROM t0 WHERE (y='00L' OR y AND x='000' OR y='0��' OR y='000') OR y AND x='00' OR y='000000' OR y='0') O


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT? FROM t0 WHERE (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR y='000'  OR y AND x='00' OR y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR y='000' OR y='0' OR y AND x='000' OR y='000' OR y='000') OR OR y='0' OR y AND x='000' OR y=8000' OR y='000') OR yOR y AND x='00' OR y='000' OR000' OR y='000' OR y='0' y='00O


sqltext:
CREATE TABLE t0(x TEX5 UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT? FROM t0 WHERE (z='00L' OR y AND x='000' OR y='000' OR y='000') AND(x='000' OR y='000')N


sqltext:
CREATE TABLE t0(x TEX5�UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT? FROM t0 WHERE (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR (y='00L' OR y AND x='000' OR y='000' OR y='000') OR y AND x='00' OR y='000' OR y AND x='000' OR y='000' OR y='0000' OR y='000' OR y='0' yO


sqltext:
CREATE TABLE t0(x TEXCEPTIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('0&0','000','0');
SELECT DISTINCT* FROM t0 WHERE (z='00L' OR y='000' OR y='T000' OR y='000')N


sqltext:
CREATE TABLE t0(x TEXT UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT * FROM t0 WHERE (x='000' OR y='000') AND z <= NOT NULL;


sqltext:
CREATE TABLE t0(x TEXT UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (x='000' OR y='000' OR x='000')AND N


sqltext:
CREATE TABLE t0(x TEXT UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (x='000' OR y='000') AND x ISNULL N


sqltext:
CREATE TABLE t0(x TEXT UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (x='000' OR y='000') AND y ISNULL N


sqltext:
CREATE TABLE t0(x TEXT UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (x='000' OR y='000') AND z ISNULL N


sqltext:
CREATE TABLE t0(x TEXT UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (y='00L' OR y='000' OR y='000') AND x='000' OR y='000')N


sqltext:
CREATE TABLE t0(x TEXT UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (y='00L' OR y='000' OR y='000') AND(x='000' OR y='000')N


sqltext:
CREATE TABLE t0(x TEXT UNIQUE, y TEXT UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (z='000' OR y='000') AND z ISNULL N


sqltext:
CREATE TABLE t0(x TEXT UNIQUE, y TEXT�UNIQUE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (x='000' OR y='000') AND x ISNULL N


sqltext:
CREATE TABLE t0(x TEXT UNIQUT, y TEXT UNIQHHHHHHHHHHHHHHHHHHHHHHH�HHHHHH'000','000','0');
SELECT DISTINCT* FROM t0 WHERE (8='000' OR y='000') AND y ISNULL N


sqltext:
CREATE TABLE t0(x TEXT UNIQUT, y TEXT UNIQlE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (8='000' OR y='000') AND y ISNULL N


sqltext:
CREATE TABLE t0(x TEXT UNIQUT, y TEXT UNIQlE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (8='000' OR y='000') AND z ISNULL N


sqltext:
CREATE TABLE t0(x TEXT UNIQUT, y TEXT UNIQlE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (x='000' OR y='000') AND y ISNULL N


sqltext:
CREATE TABLE t0(x TEXT UNIQUT, y TEXT UNIQlE, z);
INSERT INTO t0 VALUES('000','000','0');
SELECT DISTINCT* FROM t0 WHERE (x='000' OR y='000') AND z ISNULL N


sqltext:
CREATE TABLE t0(x sqlite_compileoption_get(1));
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE x LIKE '%h%' ESCAPE'߀';


sqltext:
CREATE TABLE t0(x sqlite_compileoption_get(1));
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE x LIKE '%�%' ESCAPE '�';


sqltext:
CREATE TABLE t0(x sqlite_compileoption_get(1));
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h0';
SELECT 2, x FROM t0 WHERE x LIKE '%h%' ESCAPE'߀�������������������������������������������������������������������';


sqltext:
CREATE TABLE t0(x);
CREATE UNIQUE INDEX t00 ON t0(x);
BEGIN;
INSERT OR ROLLBACK INTO t0 VALUES(1);
INSERT OR ROLLBACK INTO t0 VALUES(1);


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES(' hex(1)0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE x LIKE '%h%' ESCAPE'��';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE x LIKE '%h%' ESCAPE '0';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('00');
SELECT 1, x FROM t0 WHERE x LIKE 'Hh%';
SELECT 2, x FROM t0 WHERE x LIKE 'Hh%' ESCAPE oid;


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('00');
SELECT 1, x FROM t0 WHERE x LIKE wid()NOT LIKE '%h%' ESCAPE rowid()NOT LIKE '%h%' ESCAPE trim(1,1) '0';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT  last_insert_rowid()NOT LIKE '%h%' ESCAPE trim(1,1)


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT  last_insert_rowid()NOT LIKE '%h%' ESCAPE trim(1,1)  -1;


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE 8 LIKE '%h%' ESCAPE'߀';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE 8 LIKE '%��' ESCAPE '�';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE 8 LIKE '���' ESCAPE '�';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE x LIKE '%0';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE x LIKE '%h%' ESCAPE  'a''0';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE x LIKE '%h%' ESCAPE ' @10';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE x LIKE '%h%' ESCAPE 'NOTNULL0';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE x LIKE '%h%' ESCAPE '�������������������0';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE x LIKE '%h%' ESCAPE'߀';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE x LIKE '%�%' ESCAPE'��';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE x LIKE '%��' ESCAPE '�������������';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE x LIKE '0h0' ESCAPE '0';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%h%';
SELECT 2, x FROM t0 WHERE x LIKE '0�%' ESCAPE '�';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('000000');
SELECT 1, x FROM t0 WHERE x LIKE '%��';
SELECT 2, x FROM t0 WHERE x LIKE '%��' ESCAPE '�';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('h');
INSERT INTO t0 VALUES('��0000');
SELECT 1, x FROM t0 WHERE x LIKE '%_%';
SELECT 2, x FROM t0 WHERE x LIKE '%h%' ESCAPE '0';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0');
INSERT INTO t0 VALUES('hHAVING');
INSERT INTO t0 VALUES('00');
SELECT 1, x FROM t0 WHERE x LIKE 'Hh%';
SELECT 2, x FROM t0 WHERE x LIKE 'Hh%' ESCAPE '0';


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0000t'),('0o00');
SELECT DISTINCT x
FROM (SELECT zeroblob(1) x FROM t0 GROUP BY x)
WHERE x='0'
ORDER BY x;


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES('0000t'),('0o00');
SELECT DISTINCT x
FROm (SELECT zeroblob(1) x FROM t0 GROUP BY x)
WHERE x=('0o00');
SELECT DISTINCT x
FROM (SELECT zeroblob(1) x FROM t0 GROUP BY x)
WHERE x='0'
ORD'0'
ORDER BY x;


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES(1);
INSERT INTO t0 VALUES(2);
INSERT INTO t0 VALUES(3);
INSERT INTO t0(rowid,x) SELECT nullif( "a","b" || 4), x+100 FROM t0;
SELECT rowid, x FROM t0;


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES(1);
INSERT INTO t0 VALUES(2);
INSERT INTO t0 VALUES(3);
INSERT INTO t0(rowid,x) SELECT nullif(x || 0,14), x+100 FROM t0;
SELECT rowid, x FROM t0;


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES(1);
INSERT INTO t0 VALUES(2);
INSERT INTO t0 VALUES(3);
INSERT INTO t0(rowid,x) SELECT nullif(x*2+1.,14), x+100 FROM t0;
S


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES(1);
INSERT INTO t0 VALUES(2);
INSERT INTO t0 VALUES(3);
INSERT INTO t0(rowid,x) SELECT nullif(x*2+10,.4), x+100 FROM t0;
SELECT rowid, x FROM t0;


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES(1);
INSERT INTO t0 VALUES(2);
INSERT INTO t0 VALUES(3);
INSERT INTO t0(rowid,x) SELECT nullif(x*2+10,14), x+100 FROM t0;
SELECT rowid,CURRENT_DATE x FROM t0;


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES(1);
INSERT INTO t0 VALUES(2);
INSERT INTO t0 VALUES(3);
INSERT INTO t0(rowid,x) SELECT nullif(x*2+10,14), x+100 FROM t0;
SELECT rowid,CURRENT_TIME x FROM t0;


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES(1);
INSERT INTO t0 VALUES(2);
INSERT INTO t0 VALUES(3);
INSERT INTO t0(rowid,x) SELECT nullif(x*2+10,14), x+100 FROM t0;
SELECT rowid,CURRENT_TIMESTAMP x FROM t0;


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES(1);
INSERT INTO t0 VALUES(2);
INSERT INTO t0 VALUES(3);
INSERT INTO t0(rowid,x) SELECT nullif(x*2/10,.4), avg(1)FROM t0;
SELECT rowid, x FROM t0;


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES(1);
INSERT INTO t0 VALUES(2);
INSERT INTO t0 VALUES(3);
INSERT INTO t0(rowid,x) SELECT nullif(x*22001-01-01+10,14), x+100 FROM t0;
SELECT rowid, x FROM t0;


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES(1);
INSERT INTO t0 VALUES(2);
INSERT INTO t0 VALUES(3);
INSERT INTO t0(rowid,x) SELECT nullif(x*2E16,14), x+100 FROM t0;
SELECT rowid, x FROM t0;


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES(1);
INSERT INTO t0 VALUES(2);
INSERT INTO t0 VALUES(?);
INSERT INTO t0(rowid,x) SELECT nullif(x+2E10,14), x+100 FROM t0;
SELECT rowid, x FROM t0;


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES(1);
INSERT INTO t0 VALUES(3);
INSERT INTO t0 VALUES(2);
INSERT INTO t0 VALUES(3);
INSERT INTO t0(rowid,x) SELECT nullif(x || 0,14), x+100 FROM t0;
SELECk rowid, x FROM t0;


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES(9);
INSERT INTO t0 VALUES(2);
INSERT INTO t0 VALUES(3);
INSERT INTO t0(rowid,x) SELECT nullif(x*2+1.,14), x+100 FROM t0;
S


sqltext:
CREATE TABLE t0(x);
INSERT INTO t0 VALUES(?);
INSERT INTO t0 VALUES(1);
INSERT INTO t0 VALUES(2);
INSERT INTO t0 VALUES(?);
INSERT INTO t0(rowid,x) SELECT nullif(x*2+10,.4), x+100 FROM t0;
SELECT rowid, x FROM t0;


sqltext:
CREATE TABLE t0(x, a, b);
CREATE INDEX t0a ON t0(x, a COLLATE nocase);
CREATE INDEX t0b ON t0(x' b);


sqltext:
CREATE TABLE t0(x, a, b);
CREATE INDEX t0a ON t0(x, a COLLATE nocase);
CREATE INDEX t0b ON t0(x, b);VACUUM


sqltext:
CREATE TABLE t0(x, a, b);
CREATE INDEX t0a ON t0(x, a COLLATE nocase);ANALYZE INDEX t0b ON t0(x, b);


sqltext:
CREATE TABLE t0(x, a, b);
CREATE INDEX t0a ON t0(x, a COLLATE nocase, a, b);
CREATE INDEX t0a ON t0(x, a COLLATE nocase);
CREATE INDE t0b ON k0(x, );
CREATE INDE t0b ON k0(x, b)�


sqltext:
CREATE TABLE t0(x, y randomblob(1)UNIQUE);
INSERT INTO t0 VALUES('0ne','000');
SELECT * FROM t0 WHERE x='0ne';
PRAGMA integrity_check;


sqltext:
CREATE TABLE t0(x, y);
CREATE INDEX i0 ON t0(x, y);
CREATE VIEW v0 AS SELECT /*   */ * FROM t0;
ANALYZE;


sqltext:
CREATE TABLE t0(x, y);
CREATE INDEX i0 ON t0(x, y);
CREATE VIEW v0 AS SELECT /*  ;*/ * FROM t0;
ANALYZE;


sqltext:
CREATE TABLE t0(x, y);
CREATE INDEX s0 ON t0(x, y);
CREATE VIEW v0 AS SELECT /*  ;*/ * FROM t0;
ANALYZE;SELECT /*  ;*/ * FROM t0;
AN


sqltext:
CREATE TABLE t0(x, y, UNIQUE(x, x));
INSERT INTO t0 VALUES('0ne','000');
SELECT * FROM t0 WHERE x='0ne';
PRAGMA integbity;
SELECT * FROM t0 WHERE x='0ne';_check;


sqltext:
CREATE TABLE t0(x, y, UNIQUE(x, x));
INSERT INTO t0 VALUES('0ne','000');
SELECT * FROM t0 WHERE x='0ne';
PRAGMA integrity_check;


sqltext:
CREATE TABLE t0(x,y DEF "a","b", z DEFAULT-x'0000');
INSERT INTO t0 DEFAULT VALUES;
SELECT * FROM t0;


sqltext:
CREATE TABLE t0(x,y DEFAULT 4.3, z DEFAULT x'0000');
INSERT INTO t0 DEFAULT VALUES;
SELECT * FROM t0;VACUUM


sqltext:
CREATE TABLE t0(x,y DEFAULT 4.3, z DEFAULT x'00A0');
INSERT INTO t0 DEFAULT VALUES;
SELECT * FROM t0;


sqltext:
CREATE TABLE t0(x,y DEFAULT 4.3, z DEFAULT x'00A0EEEEEEEEEE');
INSERT INTO t0 DEFAULT VALUES;
SELECT * FROM t0;


sqltext:
CREATE TABLE t0(x,y DEFAULT-4.3, z DEFAULT-x'000DEFAA');
INSERT INTO t0 DEFAULT VALUeS;
SELECT * FROM t0;


sqltext:
CREATE TABLE t0(x,y DEFAULT-4.3, z DEFAULT-x'0A00');
INSERT INTO t0 DEFAULT VALUES;
SELECT * FROM t0;


sqltext:
CREATE TABLE t0(�ӝ�c,d,e, PRIMARY KEY(a,b,c,a,b,c,d,a,b,c)) WITHOUT ROWID;
CREATE INDEX t0a ON t0(b, b);
000000


sqltext:
CREATE TABLE t0(�ӝ�c,d,e, PRIMARY KEY(a,b,c,d,e));
SELECT * FROM t0 WHERE a=? AND b=? AND c=? AND d=? AND e=?;


sqltext:
CREATE TABLE t000( ''CURRENT_TIMESTAMP a,c0);
CREATE TABLE t002(c000,I,J0000);
SELECT c000,* FROM t002 LAL JOIN t000 AS c00 NATURAL JOIN t000 AS c00 NATS  


sqltext:
CREATE TABLE t000( ''c0  UNIQUE,�,I, a,c0);
CREATE TABLE t002(c000,INT0000);
SELECT c000,* FROM t002 LEFT NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000( ''c0  UNIQUE,�,I, a,c0);
CREATE TABLE t002(c002,INT0000);
SELECT c000.* FROM t000 t000 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000( ''c0, UNUE,NUE,�,I, a,c0);
CREATE TABLE t002(c000,I,J0000);
SELECT c000,* FROM t002 LAL JOIN t000 AS c00 NATURAL JOIN t000 AS c00 NATS  


sqltext:
CREATE TABLE t000( 'a''b' "a","b"c0  UNIQUE,�,I, a,c0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000 t000 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000( 'a''b' a,bc0  UNIQUE,��I, a,c0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000,t000 NATURAL JOIN t000 AS c000 NATURAL JOIN t000 AS c00  NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000( 'a''b'c0  UNIQUE,c000 a,c0);
CREATE TABLE t002(c000, 'a''b');
SELECT c000.* FROM t002 LEFT00 NATURAL JOIN t000 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000( 'a''b'c0  UNIQUE,�,I, a,c0);
CREATE TABLE t002(c000,I,T0000);
SELECT c000.* FROM t002 LEFT NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c NATURAL JOIN t000 A00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000( 'a''b'c0  UNIQUE,�,I, a,c0);
CREATE TABLE t002(c000,I,T0000);
SELECT c000.* FROM t002 LEFT NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000( 'a''b'c0  UNIQUE,�,I, a,c0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000,t000 NATURAL JOIN t000 AS c000 NATURAL JOIN t000 AS c00  NATURAL JOIN t000 AURAL JOIN t000 TUR00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000( 'a''b'c0  UNIQUE,�,I, a,c0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t002 LEFT NATURAL JOIN t000 AS c00 NATURAL JOIN t002 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000( 'a''b'c0  UNIQUE,��I, a,c0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000,t000 NATURAL JOIN t000 AS c000 NATURAL JOIN t000 AS c00  NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000( 'a''b'c0  UNIQUE��,I, a,c0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000 t000 NATURAL JOIN t000 AS c000 NATURAL JOIN t000 AS c00  NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000( 'a''b'c0  UNIQU��O�I, a,c0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000,t000 NATURAL JOIN t000 AS c000 NATURAL JOIN t000 AS c00  NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000( 'a''b'c0 �UNIQUE,c000 a,c0);
CREATE TABLE t002(c0 �UNIQUEc000, 'a''b');
SELECT c0 `a` FROM t002 LEFT NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000( 'a''b'c0 �UNIQUE,c000 a,c0);
CREATE TABLE t002(c0 �UNIQUEc000, 'a''b');
SELECT c0 `a` FROM t002 LEFT NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c00 NATURAL JoIN t000 ASc00 NATURAL JOIN t000 AS c00 NA c000;


sqltext:
CREATE TABLE t000( 'a''b'c0, U,UE,�,I, a,c0);
CREATE TABLE t002(c000,I,T0000);
SELECT c000.* FROM t002 LATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000( 'a''b'c0, UNUE,�,I, a,c0);
CREATE TABLE t002(c000,I,T0000);
SELECT c000.* FROM t002 LATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000( 'a''b'c0, a,c0);
CREATE TABLE t002(c000,I,J0000);
SELECT c000,* FROM t002 LAT JOIN t000 AS c00 NATURAL JOIN t000 AS c00 N 


sqltext:
CREATE TABLE t000( /* */c000,INT0,ba,b,�,I, a,b0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000( a,ba INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002(x  "a","b"PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002 WHERE t002.z GLOB '0000';


sqltext:
CREATE TABLE t000( a,ba INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002(x INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002  t001, t002 WHWHERE t0;


sqltext:
CREATE TABLE t000( a,ba INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002(x�,N,EGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002  t001, t002 WHE t0;


sqltext:
CREATE TABLE t000( a,ba INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002(x�IN,EGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002  t001, t002 WHE t0;


sqltext:
CREATE TABLE t000( a,ba INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002(x�INTEGER PRIMARY KEY DESC/* */);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002  t001, t002 WHE t0;


sqltext:
CREATE TABLE t000( a,ba INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002(x�INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002  t001, t000 WHE t0;


sqltext:
CREATE TABLE t000( a,ba INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002(x�INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002  t001, t002 WHE t0;


sqltext:
CREATE TABLE t000(AUTOINCREMENTI, a,b0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000 AS c00 NATURAL JOIN t000 LEFT NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(D,F,RREDa,b000,INT0,ba,b,�,I, ab�������������������������0,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(D,FERREDa,b000,INT0,ba,b,�,I, ab�������������������������0,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(DEFERREDa,b000,INT0,ba,b,�,I, ab�������������������������0,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(TRANSACTION�,I, a,b0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(a  "a"GER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARW KEY, q, r);
CREATE TABLE t002(x INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002 WHERE t002.z GLOB '0000';


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001( a,bp INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002(x INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002  t001, t002 WHWHERE t0;


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INER PRIMARY KEY, q, r);
CREATE TABLE t002(x I);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002  t001, t002 WHWHERE t0;


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTC);
CREATE TABLE t002(x INTEGER PRIMARL KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002 WHERE t002.z GLOB '0000';


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTCURRENT_TIMESTAMP q, r);
CREATE TABLE t002(x INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002 WHERE t002.z GLOB '0000';


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARY KEY UNIQUE/* */);
CREATE TABLE t002(x INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002 WHERE t002.z GLOB '0000';


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002( a,bx INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002  t001, t002 WHWHERE t0;


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002(x INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT $$$$$$$$� t001, t002 WHERE t002.z GLOB '0000';


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002(x INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT * FROM t002, t001, t002 WHERE t002.z GLOB '0000';


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002(x INTEGER�PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000 t001, t002 WHERE t002.z GLOB '0000';


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002(x,INTEGER PRITEGER PRIMARY KEY, b,MARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002  t001, t002 WRE t0;


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002(x�INTEGER PRIMARY KEY /* */);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002  t001, t002 WHE t0;


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q6 r);
CREATE TABLE t002(x INTEGEV PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002 WHERE t002.z GLOB '0000';


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q� r);
CREATE TABLE t002(x INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002  t001, t002 WHWHERE t0;


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INTEGER Pq, r);
CREATE TABLE t002(x INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t001, t002 WHERE t002.z GLOB '0000';


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INY KEY, q, r);
CREATE TABLE t002(x INTdGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT 2%Y FROM  t000, t001,t000, t001, t000, t001, t002 WH�RE t2 W


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p�INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002(x INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002  t001, t002 WHWHERE t0;


sqltext:
CREATE TABLE t000(a INTEGER PRIMARY KEY, b� c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002(x�INTEGER PRIMARY KEY, y� z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002  t001, t002 WHE t0;


sqltext:
CREATE TABLE t000(a INTEGIR PRIMARY KEY, b c);
CREATE TABLE t001(p INTEGER PRIMARY KEY, q, r);
CREATE TABLE t002(x INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002 WHERE t002.z GLOB '0000';


sqltext:
CREATE TABLE t000(a INvEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INY KEY, q, r);
CREATE TABLE t002(x INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT 2 FROM t000, t000, t001, t001, t002 WH


sqltext:
CREATE TABLE t000(a INvEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INY KEY, q, r);
CREATE TABLE t002(x INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT avg(A%A)FROM t002, t001, t000, t002, t001, t002 IR, t001, t002 WR


sqltext:
CREATE TABLE t000(a INvEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INY KEY, q, r);
CREATE TABLE t002(x INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT avg(A) "a","b"FROM t002, t001, t000, t002, t001, t002R


sqltext:
CREATE TABLE t000(a INvEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INY KEY, q, r);
CREATE TABLE t002(x,INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT 2 FROM t000, t001, t000, t001, t002, t002 


sqltext:
CREATE TABLE t000(a INvEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INY KEY, q, r);
CREATE TABLE t002(x�INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT 2 FROM t000, t001, t000, t000, t001, t002 IR, t001, t002 WR


sqltext:
CREATE TABLE t000(a INvEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INY KEY���, r);
CREATE TABLE t002(x INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT avg(A)FROM t002, t001, t000, t001, t002  t0, t001, t002 IR, t001, t002 WR


sqltext:
CREATE TABLE t000(a I�TEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p INY KEY, q, r);
CREATE TABLE t002(x,INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT 2 FROM  t000, t001,t000, t001, t000, t001, t002 W, t000, t001, t002  W


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);
INSERT INTO t000 VALUES('s','s0'),( 2001-01- strftime(1<1,1,1),'m00');


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);
INSERT INTO t000 VALUES('s','s0'),( 2001-01-01,'000'),('0r000','m00');
SELECT a, b, '0' FROM t000 WHERE a= total(1)OR b='mr0' GROUP BY +a;


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);
INSERT INTO t000 VALUES('s','s0'),( group_concat(1,1)-hex(2<01-01-01-011),'000'),(-hex(1),'000'),(-hex(1),'m00');


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);
INSERT INTO t000 VALUES('s','s0'),( hex(2001-01-011),'000'),( hex(1),'m00');


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);
INSERT INTO t000 VALUES('s','s0'),( substr(1,1,1)-hex(2001-01-011),'000'),(-hex(1),'m00');


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);
INSERT INTO t000 VALUES('s','s0'),(-hex( likely(1)-011),'000'),(-hex(1),'000'),(-hex(1),'m00');


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);
INSERT INTO t000 VALUES('s','s0'),(-hex(2001-01-011),'000'),( hex(1),'m00');


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);
INSERT INTO t000 VALUES('s','s0'),(-hex(2401-01-01-011),'000'),(-hex(1),'000'),(-hex(1),'m00');


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);
INSERT INTO t000 VALUES('s','s0'),(-hex(2<01),'000'),(-hex(-01-011),'000'),(-hex(1),'m00');


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);
INSERT INTO t000 VALUES('s','s0'),(-hex(2<01-01-01-011),'000'),(-hex(1),'000'),(-hex(1),'m00');


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);
INSERT INTO t000 VALUES('stat0','s0'),( NOT( 1=11),'000'),('0r000','m0r00r0');
SELECT a, b, '0' FROM t000 WHERE a=='stat0' OR b='m0r00r0' ORDER BY +a;


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);
INSERT INTO t000 VALUES('stat0','s0'),( hex( 1=11),'000'),('0r000','m0r00r0');
SELECT a, b, '0' FROM t000 WHERE a=='stat0' OR b='m0r00r0' ORDER BY a,b


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);
INSERT INTO t000 VALUES('stat0','s0'),( hex(1),'000'),('0r000','m0r00r0');
SELECT a, b, '0' FROM t000 WHERE a=='stat0' OR b='m0r00r0' ORDER BY +a;


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);
INSERT INTO t000 VALUES('stat0','s0'),('00000','000'),('0r000','m0r00r0');
SELECT a, b, '0' FROM t000 WHERE a=='stat0' OR b='m0r00r0' ORDER BY +a;VACUUM


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);REINDEX INTO t000 VALUES('s','s0'),( hex(2001-01-011),'000'),( hex(1),'m00');


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);REPLACE INTO t000 VALUES('s','s0'),('0000','000'),('0r000','m0r00'),('00','000'),('0r000','m0r00'),('0r000','0rr0');
SELECT a, b, '0' FROM t000 W='m0


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(a);REPLACE INTO t000 VALUES('s','s0'),('00000','000'),('0r000','m0r00'),('0r000','0rr0');
SELECT a, b, '0' FROM t000 W='m0


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(b);
INSERT INTO t000 VALUES('s','s0'),('00000','000'),('0r000','m0r00r0');
SELECT a, b, '0' FROM t000 WHERE round(1,1) OR b='mr0' ORDER BY +a;


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(b);
INSERT INTO t000 VALUES('stat0','s0'),('00000','000'),('0r000', quote(1));
SELECT a, b, '0' FROM t000 WHERE a=='stat0' OR b='mr0' ORDER BY +a;


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(b);
INSERT INTO t000 VALUES('stat0','s0'),('00000','000'),('0r000','m0r00r0');
SELECT a, b, '0' FROM t000 WHERE a=='stat0' OR b='m0r00r0' ORDER BY +a;REINDEX


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;
CREATE INDEX t0000 ON t000(b);
INSERT INTO t000 VALUES('stat0','s0'),('00000','000'),('0r000','m0r00r0');
SELECT likely(1) FROM t000 WHERE a?='stat0' OR b='m0r00r0' ORDER BY +a;


sqltext:
CREATE TABLE t000(a PRIMARY KEY, b) WITHOUT rowid;EXPLAIN
CREATE INDEX t0000 ON t000(a);
INSERT INTO t000 VALUES('s','s0'),( hex(1),'000'),( hex(1),'m00');


sqltext:
CREATE TABLE t000(a YNTEGER PRIMARY KEY, b, c);
CREATE TABLE t001(p PRIMARY KEY, q, r);
CREATE TABLE t002(x INTEGER PRIMARY KEY, y, z);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM t000, t001, t002  t001, t002 WHWHERE t0;


sqltext:
CREATE TABLE t000(a0  a,ba,b,�,I, a,b0);
CREATE TABLE t002(c000,INT0000);
SELECT c000,* FROM t000 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c a,b0  a,ba,b,�,I, a blobte_compileoption_get(1)UNIQUE,INT0000);
SELECT c000.* FROM t000 AS c00 NATURAL JOIN t000 AS00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c a,b0 UNIQUE,b000,INT0,ba,b,�,I, a,b�,���������������0,INT0000);
SELECT c000,* FROM t000 NATURAL JOIN t000 AS c000 NATURAL JOIN t000 AS c000;;


sqltext:
CREATE TABLE t000(c a,b0 UNIQUE,b000,INT0,ba,b,�,I, a,b�,���������������0,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c000 NATURAL JOIN t000 AS c000;;


sqltext:
CREATE TABLE t000(c0  UNIQUE,�,I, a,b0);
CREATE TABLE t002(NATURINT0000);
SELECT c000.* FROM t000 AS c00 NATURAL JOIN t000 AS00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000 NATURAL JOIN t000 AS00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c0;


sqltext:
CREATE TABLE t000(c0  UNIQUE,�,I, a,b0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000 AS c00 NATURAL JOIN t000 RAL JOIN t000 AS00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS cAS00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000* FROM t000 AS c;


sqltext:
CREATE TABLE t000(c0  UNIQUE,��I, a,b0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a,ba,b�,I, a,b0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a,ba,b,�, 'a''b'I, a,��,���������������������������,I000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a,ba,b,�,I, a blobte_compileoption_get(1)UNIQUE,INT a,b0000);
SELECT c000.* FROM t000 AS c00 NATURAL JOIN t000 LEFT NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a,ba,b,�,I, a blobte_compileoption_get(1)UNIQUE,INT a,b0000);
SELECT c000.* FROM t000 AS c00 NATURAL JOIN t000 LEFT NATURAL NATURAL JOIN t000 LEFT NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a,ba,b,�,I, a blobte_compileoption_get(1)UNIQUE,INT a,b0000);
SELECT c000.* FROM t000 AS t000 LEFT NATURAL JOIN t000 AS c00 NATURAL JOIN t000 LEFT NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a,ba,b,�,I, a blobte_compileoption_get(1)UNIQUE,INT0000);
SELECT c000.* FROM t000 AS c00 NATURAL JOIN t000 LEFT NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a,ba,b,�,I, a,b0);
CREATE TABLE t002(c000,I,T0000);
SELECT c000,* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0  a,ba,b,�,I, a,b0);
CREATE TABLE t002(c000,INT0000);
SELECT c000,* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0  a,ba,b,�,I, a,b0);
CREATE TABLE t002(c000�INT0000);
SELECT c000,* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0  a,ba,b,�,I, a,� a,b����������������������,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c00c00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a,ba,b,�,I, a,��,���������������������������,I000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a,ba,b,�,I, a,�������������,���������������������������,��������������,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c00c00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a,ba,b,�,I, a,���������������������������,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a,ba,b,�,I, a,���������������������������,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c00c0c00 NATURAL JOIN t000 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a,c a,b000INT0,ba,b,�,I, a,b�������������������������0,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c00000 NATURAL JOIN t000 AS c000;;


sqltext:
CREATE TABLE t000(c0  a,c a,b000,INT0,ba,b�,I, a,b�������������������������0,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c00000 NATURAL JOIN t000 AS c000;;


sqltext:
CREATE TABLE t000(c0  a,c a,b000,INT0,ba,b,�,I, a,b0);
CREATE TABLE t002( a,bc000,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0  a,c a,b000,INT0,ba,b,�,I, a,b�,�����������������������0,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c0000000000 NATURAL JOIN t000 AS c000 NATURAL JOIN t000 AS c000;;


sqltext:
CREATE TABLE t000(c0  a,c a,b000,INT0,ba,b,�,I, a,b�����������������0,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c000 NATURAL JOIN t000 AS c000;;


sqltext:
CREATE TABLE t000(c0  a,c a,b000,INT0,ba,b,�,I, a,b�������������������������0,INT0000);
SELECT c000,* FROM t000 NATURAL JOIN t000 AS c00000 NATURAL JOIN t000 AS c000;;


sqltext:
CREATE TABLE t000(c0  a,c000,INT0,ba,b,�,I, a,b0);
CREATE TABLE t002(c a,b000,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0  a,c000,INT0,ba,b,�,I, a,b0);
CREATE TABLE t002(c000,INT a,b);
SELECT c000.* FROM t002 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a,c000,INT0,ba,b,�,I, a,b0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a,c000,INT0,ba,b,�,I, a,b0);
CREATE TABLE t002(c000�INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0  a,c000,INT00ba,b,�,I, a,b0);
CREATE TABLE t002( a,b,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0  a,c000,INT00ba,b,�,I, a,b0);
CREATE TABLE t002(c000,I,T0000);
SELECT c000.* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0  a,c000,INT00ba,b,�,I, a,b0);
CREATE TABLE t002(c0�0,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0  a,c000,�,INT0,ba,b,�,I, a,b0);
CREATE TABLE t002(c0 ifnull(1,1),I, a);
SELECT c000.* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0  a,c000,�,INT0,ba,b,�,I, a,b0);
CREATE TABLE t002(c0,�NT0,ba,b,�,I, a);
SELECT c000.* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0  a,c000,�,INT0,baEb,�,I, a,b0);
CREATE TABLE t002(c0,�NT0,ba,b,�,I, a);
SELECT c000.* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0  a,c000,�NT0	ba,b,�,I, a,b0);
CREATE TABLE t002(c0,�NT0,ba,b,�,I, a);
SELECT c000.* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0  a,c000,�NT0 "a","b"I, a,b0);
CREATE TABLE t002(c0,�NT0,ba,b,�,I, a);
SELECT c000.* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0  a,c000,�NT0,ba,b,�,I, a,b0);
CREATE TABLE t002(c000,INT0000a,b000,�NT0,ba,b,�,I, a);
SELECT c000.* FROM t000 NATURAL JOIN t002 AS c000;VACUUM


sqltext:
CREATE TABLE t000(c0  a�ba,b�,I, a,b0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000 AS c00 NATURAL JOIN t000 AS00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a�ba,b,�I, a,b0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000 AS c00 NATURAL JOIN t000 AS00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a�ba,b,�,I, a blobte_compileoption_ge a,bUNIQUE,INT a,b0000);
SELECT c000.* FROM t000 AS c00 NATURAL JOIN t000 LEFT NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a�ba,b,�,I, a blobte_compileoption_get(1)UNIQUE,INT0000);
SELECT c000.* FROM t000 AS c00 NATURAL JOIN t000 AS00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a�ba,b,�,I, a blobte_compileoption_get(1)UNIQUE,INT0000);
SELECT c000.* FROM t000 AS c00 NATURAL JOIN t000 LEFT NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0  a�ba,b,�,I, a,b0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000 AS c00 NATURAL JOIN t000 LEFT NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0 UNIQUE,b000,INT0,ba,b,�,I, a,b�,���������������0,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c000 NATURAL JOIN t000 AS c000000 NATURAL JOIN t000 AS c000;;


sqltext:
CREATE TABLE t000(c0 a,b,�,I, a,b0);
CREATE TABLE t002(c000,I,T0000);
SELECT c000,* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0 a,b,�,I, a,b0);
CREATE TABLE t002(c000,INT0000);
SELECT c000,* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0,�,I, a,b0);
CREATE TABLE t002(c000,INT a,b);
SELECT c000,* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c0,�,I,T0000);
CREATE TABLE t002(c000 INT0000);
SELECT c000,* FROM t000 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0,�,I,T0000);
CREATE TABLE t002(c000 INT0000);
SELECT c000,* FROM t000 NATURAL JOIN t002 AS c000;


sqltext:
CREATE TABLE t000(c000 INT0000);
CREATE TABLE t002(NT0000);
SELECT c000.* ,R0.* ,ROM t000 NATURAL JO


sqltext:
CREATE TABLE t000(c000 INT0000);
CREATE TABLE t002(c000 INT0000);
SELECT a,b a,b0.* ,ROM,t000 NATURAL JO


sqltext:
CREATE TABLE t000(c000 INT0000);
CREATE TABLE t002(c000 INT0000);
SELECT a,b0.* ,ROM t000 NATURAL JO


sqltext:
CREATE TABLE t000(c000 INT0000);
CREATE TABLE t002(c000 INT0000);
SELECT a,b0.* ,ROM,t000 NATURAL JO


sqltext:
CREATE TABLE t000(c0��000);
SELECT c000.* FROM t000 AS c00 NATURAL JOIN t000 AS00 NATURAL JOIN t000  c00 NATURAL JOIN t000 AS00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0��a,ba,b�,I, a sqlite_compileREALon_get(1),INT0000);
SELECT c000.* FROM t000 AS	c00 NATURAL JOIN t000 AS00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0��a�ba,b�,I, a sqlite_compileREALon_get(1)UNIQUE,INT0000);
SELECT c000.* FROM t000 AS	c�0�NATURAL JOIN t000 AS0 JOIN t000 AS00 NATURAL JOIN t000 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0��a�ba,b�,I, a sqlite�compileREALon_get(1),INT0000);
SELECT c000.* FROM t000 AS	c00 NATURAL JOIN t000 AS00 NATURAL JOIN t000 AS00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(c0��a�ba,b,�,I, a sqlite_compileoption_get(1),INT0000);
SELECT c000.* FROM t000 AS c00 NATURAL JOIN t000 AS000 NATURAL JOIN t000 AS00 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 A0 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t000(cD,b00cD,b000, 'a''b'a,b,�,I, a,b�,���� load_extension(1,1));
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c000 NATURAL JOIN t000 AS c000;;


sqltext:
CREATE TABLE t000(cE,b000, 'a''b'INT0,ba,b,�,I, a,b�,���� loadTextension(1,1));
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c0000 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;;


sqltext:
CREATE TABLE t000(cE,b000, 'a''b'INT0,ba,b,�,I, a,b�,���� load_extension(1,1));
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c000 NATURAL JOIN t000 AS c000;;


sqltext:
CREATE TABLE t000(cE,b000, 'a''b'INT0,ba,b,�,I, a,b�,���� load_extension(1,1));
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c0000 NATURAL JOIN t000 AS c00 NATURAL JOIN t000 AS c000;;


sqltext:
CREATE TABLE t000(cE,b000,INT0,ba,b�,I, a,b�,���� load_extension(1,1));
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c000 NATURAL JOIN t000 AS c000;;


sqltext:
CREATE TABLE t000(cE,b000,INT0,ba,b,�,I, a,b�,���� load_extension(1,1));
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c000 NATURAL JOIN t000 AS c000;;


sqltext:
CREATE TABLE t000(cE�b000,INT0, 'a''b'ba,b,�,I, a,b�,���� load_extension(1,1));
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c000 NATURAL JOIN t000 AS c000;;


sqltext:
CREATE TABLE t000(ction,c000,INT0,ba,b
�,I, a,b0);
CREATE TABLE t002(c000,INT0000);
SELECT c000.* FROM t000 NATURAL JOIN t000 AS c000;


sqltext:
CREATE TABLE t0000( a,ba INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000000');
INSERT INTO t0000(b) VALUES('00');
END;EXPLAIN
INSERT INTO t0000(b) VALUES('0000');
SELECT * FROM t0000 ORDER BY a;


sqltext:
CREATE TABLE t0000(Q blobGER
PIQUE,UFOINCRPRIMARY KUY U���������������NIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
SELECT('har(1)ACE I0000');
VALUES('NTO t0000(b) VALUES(000');
END;
CREATE TRIGGER t000000�AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');
VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INARY KEY ,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('00$000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER DEFAULT KEY UNIQUE,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER DEFAULT KEY UNIQUE,UTOINCRPRIMARY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');
INSERT INTO t0000(a) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PR,MARY KEY ,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('000');
INSERT INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) SELECT('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRCURRENT_TIMESTAMPUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000000');
INSERT INTO t0000(a) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY ,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) SELECT('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY ,UTOINCRRIMARY KEY ,UTOINCREMENT, EMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('000');
 VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('000');
INSERT INTO t0000(a) VALUES('000<);
END;
CRE000 AFTER INSERT ON t0000 BEGIN
INSERT I00');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('000');
INSERT INTO t0000(a) VALUES('000<);
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT I00');
INSERT INTO t0000(b) VALUES('00');
END;EXPLAIN
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('000');
INSERT INTO t0000(a) VALUES('000<);
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT I00');
INSERT INTO t0000(b) VALUES('00'); /* */INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('000');
INSERT INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000�AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(b) SELECT('000');
INSERT INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES(NOT'0000');
SELECT * FROM t0000 ORDER BY a;


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000');
INSERT INTO t0000(b) VALUES( random());
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');
SELECT * FROM t0000 ORDER BY b;


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000');
INSERT INTO t0000(b) VALUES('0000000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000000');
INSERT INTO t0000(b) VALUES('00');
END+
INSERT INTO t0000(b) VALUES('0000');
SELECT * FROM t0000 ORDER BY a;


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000');
INSERT INTO t0000(b) VALUES('0000000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) SELECT @1('0000');
SELECT * FROM t0000 ORDER BY@a;


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000');
INSERT INTO t0000(b) VALUES('0000000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) SELECT('0000');
SELECT * FROM t0000 ORDER BY a;VACUUM


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000');
INSERT INTO t0000(b) VALUES('0000000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');
SELECT * FROM t0000 ORDER BY 'a'


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000');
INSERT INTO t0000(b) VALUES('0000000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');
SELECT * FROM t0000 ORDER BY b;


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');
SELECT * FROM t0000 ORDER BY a;


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000�AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000000');
INSERT INTO t0000(b) VALUES('00');
END;EXPLAIN
INSERT INTO t0000(b) VALUES('0000');
SELECT * FROM t0000 ORDER BY a;


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000');REPLACE INTO t0000(b) VALUES('000GER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES(000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');
SELECT * FROM t0000 ORDER BY a;


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000');REPLACE INTO t0000(b) VALUES('000TRIGGER t000 AFTER INSERT ON t00 BEGIN
INSERT INTO t0000(b) VALUES(000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('00000000 BEGIN
INSERT INTO t0000(b) VALUES(000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('00');
SELECT * FROM t0000 ORDER BY a;


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000')�


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE UPDATE ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000');
INSERT INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) SELECT('000000');REPLACE INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) SELECT('0000');
SELECT * FROM t0000 ORDER BY a;


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE UPDATE ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000');
INSERT INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t0000000AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000000');
INSERT INTO t0090(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');
M


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE UPDATE ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000');
INSERT INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t0000000AFTER INSERT ON t0000 BEGIN
INSERT INTO w0000(b) VALUES('000000');
INSERT INTO t0090(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');
M


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE UPDATE ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000');
INSERT INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000�AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');
SELECT * FROM t0000 ORDER BY a;VACUUM


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY UNIQUE,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(a) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000000');
INSERT INTO t0000(a) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY UNIQUE,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(a) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000000');
INSERT INTO t0000(b) VALUES('00');
END;EXPLAIN
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY UNIQUE,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000000');
INSERT INTO t0000(a) VALUES('00');
END;EXPLAIN
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY UNIQUE,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000000');
INSERT INTO t0000(b) VALUES('00');
END;EXPLAIN
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY UNIQUE,UTOINCRPRIMAEY UNIQUE,UTOMNCREEMENT,RY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');
INSERT INTO t0000(a) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY UNIQUE,UTOINCRPRIMARY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000') "a","b";REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');REPLACE INTO t0000(a) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY UNIQUE,UTOINCRPRIMARY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');
INSERT INTO t0000(a) VALUES('00');
END;EXPLAIN
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY UNIQUE,UTOINCRPRIMARY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER UPDATE ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');
INSERT INTO t0000(a) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY UNIQUE,UTOINCRPRIMARY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT(SELECT'000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');REPLACE INTO t0000(a) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY UNIQUE,UTOINCRPRIMARY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(b) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');
INSERT INTO t0000(a) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a INTEGER PRIMARY KEY UNIQUE,UTOINCRPRIMARY KEY UNIQUE,UTOINCREEY KEY UNIQUE,UTOIEFOREER t��0001 BRY KEY UNIQUE,UTOIE INSERT 


sqltext:
CREATE TABLE t0000(a blobGER
PIQUE,UFOINCRPRIMARY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
SELECT('har(1)ACE INTO t0000(b) VALUES(000');
END;
CREATE TRIGGER t000000�AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');
VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a blobGER DEFAULT KEY UNIQUE,UTOINCRPRIMARY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');
INSERT INTO t0000(a) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a blobGER PIQUE,UFOINCRPRIMARY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
SELECT('har(1)ACE INTO t0000(b) VALUES(000');
END;
CREATE TRIGGER t000000�AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');
INSERT INTO t0000(a) VALUES('00');
END;EXPLAIN
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a blobGER PRIMARY KEY UNIQUE,UFOINCRPRIMARY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');
INSERT INTO t0000(a) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a blobGER PRIMARY KEY UNIQUE,UTOINCRPRIMARY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');
INSERT INTO t0000(a) VALUES('00');
END;REPLACE INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a blobGER PRRIMARY KEY UNIQUE,UTOIIMARY KEY UNIQUE,UTOINCRPRIMARY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t000001������������������������������������������������������������������������������������������������������������������������ BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');
INSERT INTO t0000(a) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a blobGER PRRIMARY KEY UNIQUE,UTOIIMARY KEY UNIQUE,UTOINCRPRIMARY KEY UNIQUE,UTOINCREEMEOINCRPRIMARY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');
INSERT INTO t0000(a) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');NT, b);
CREATE TRIGGER t0000-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------01 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');
INSERT INTO t0000(a) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a blobGER PRRIMARY KEY UNIQUE,UTOIIMARY KEY UNIQUE,UT���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������OINCRPRIMARY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');
INSERT INTO t0000(a) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a blobGER PRTE TRIGGER t00000d BEFORE INS���RIMARY KEY UNIQUE,UTOI UNIQUE,UTOIIMARY KEY UNIQUE,UTOINCRPRIMARIMARY KEY UNIQUE,UTOINCRPRIMARY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGE�������������������������������������������������������������������GER t00000d BEFORE IN���RIMARY KEY UNIQUE,UTOI UR t00000 erse(1,1)NS�����������������������������������������������������������������������������������������������������������������������������������������������������������������������GER t00000d BEFORE INS���RIMARY KEY UNIQUE,UTOI UNIQUE,UTOIIMARY KEY URIMARIMARY KEY UNIQUE,UTOINCRPRIMARY KEY UNIQUE,UTOINCREEMENT, b);
CREATE TRIGGER t00000 like(1,1)NS����������������������������������������������������������������������������������������������������������������������������ERT ON t0000 BEGI3
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000( date(1,111)00');
AND;
CREATE �RIGGER t 00 AFTER INSERT O��000 BEGIN
INSERT INTO t0000(a) SELECT('�00000');
>NSERT INTO t000000');


sqltext:
CREATE TABLE t0000(a �NTEGER PRIMARY KEY ,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) SELECT typeof(1);
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a �NTEGER PRIMARY KEY ,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000oAFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b��������������������������������������������������������������������������) SELECT('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a �NTEGER PRIMARY KEY ,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('000');
INSERT INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000�AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) SELECT('000000');
INSERT INTO t0000(b) VALUES('00');
END;EXPLAIN
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a �NTEGER PRIMARY KEY ,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) SELECT('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a �NTEGER PRIMARY KEY ,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) SELECT('000000');
INSERT INTO t0000(b) VALUES('00');
END;EXPLAIN
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a �NTEGER PRIMARY KEY ,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('00E');
INSERT INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('-00000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a �NTEGER�PRIMARY KEY ,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('-0E');
INSERT INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a,INARY KEY ,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(a) SELECT('00$000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(a,�NTEGER PRIMARY KEY ,UTOINCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(a) VALUES('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) SELECT('000000');
INSERT INTO t0000(b) VALUES('00');
END;
INSERT INTO t0000(b) VALUES('0000');


sqltext:
CREATE TABLE t0000(aCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000000');VALUES('00');
END;EXPLAIN
INSERT INTO t0000(b) VALUES('0000');
SELECT * FROM t0000 ORDER BY a;


sqltext:
CREATE TABLE t0000(aCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
VALUES('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(_) VALUES('000000');VALUES('00');
END;EXPLAIN
INSERT INTO t0000(b) VALUES('0000');
SELECT * FROM t0000 ORDER BY a;


sqltext:
CREATE TABLE t0000(aCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
VALUES('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER INSERT ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000000');VALUES('00');
END;EXPLAIN
INSERT INTO t0000(b) VALUES('0000');
SELECT * FROM t0000 ORDER BY a;


sqltext:
CREATE TABLE t0000(aCREMENT, b);
CREATE TRIGGER t000001 BEFORE INSERT ON t0000 BEGIN
VALUES('000');REPLACE INTO t0000(b) VALUES('000');
END;
CREATE TRIGGER t000000 AFTER UPDATE ON t0000 BEGIN
INSERT INTO t0000(b) VALUES('000000');VALUES('00');
END;EXPLAIN
INSERT INTO t0000(b) VALUES('0000');
SELECT * FROM t0000 ORDER BY a;


sqltext:
CREATE TABLE t00a(a,b);
INSERT INTO t00a VALUES(0,0);
CREATE TABLE t00b(n);
CREATE TRIGGER r00 AFTER INSERT ON t00b BEGIN
SELECT 0 >ROM t00a WHERE 0>n0000 UNION ALL
SELECT 0 FROa WHERE 0>n0000 UNION ALL
SELECT 0 FROM t0 a WHERE 0>new>x ORDER BY 0 LIMIT 0;
END;
INSERT INTO t00b VALUES(6);
M t0 a WHERE 0>new>x ORDER BY 0 LIMIT 0;
END;
INSERT INTO t00b VALUES(6);


sqltext:
CREATE TABLE t00a(a,b);
INSERT INTO t00a VALUES(0,0);
CREATE TABLE t00b(n);
CREATE TRIGGER r00 AFTER INSERT ON t00b BEGIN
SELECT 0 FROM t0,a, "a","b"n0000 UNION ALL
SELECT 0 FROM t0,a WHERE 0>new>x ORDER BY 0 LIMIT 0;
END;
INSERT INTO t00b VALUES(6);


sqltext:
CREATE TABLE t00a(a,b);
INSERT INTO t00a VALUES(0,0);
CREATE TABLE t00b(n);
CREATE TRIGGER r00 AFTER INSERT ON t00b BEGIN
SELECT 0 FROM t0,a, "a","b"n0000 UNION ALL
SELECT 0 FROM t00a WHERE 0>new>x ORDER BY 0 LIMIT 0;
END;
INSERT INTO t00b VALUES(6);


sqltext:
CREATE TABLE t00a(a,b);
INSERT INTO t00a VALUES(0,0);
CREATE TABLE t00b(n);
CREATE TRIGGER r00 AFTER INSERT ON t00b BEGIN
SELECT 0 FROM t00a  "a","b"n0000 UNION ALL
SELECT 0 FROM t0 a WHERE 0>new>x ORDER BY 0 LIMIT 0;
END;
INSERT INTO t00b VALUES(6);


sqltext:
CREATE TABLE t00a(a,b);
INSERT INTO t00a VALUES(0,0);
CREATE TABLE t00b(n);
CREATE TRIGGER r00 AFTER INSERT ON t00b BEGIN
SELECT 0 FROM t00a  "a","b"n0000 UNION ALL
SELECT 0 FROM t00 "a","b"a WHERE 0>new>x ORDER BY 0 LIMIT 0;
END;
INSERT INTO t00b VALUES(6);


sqltext:
CREATE TABLE t00a(a,b);
INSERT INTO t00a VALUES(0,0);
CREATE TABLE t00b(n);
CREATE TRIGGER r00 AFTER INSERT ON t00b BEGIN
SELECT 0 FROM t00a  "a","b"n0000 UNION ALL
SELECT 0 FROM t00a WHERE 0>new>x ORDER BY 0 LIMIT 0;
END;
INSERT INTO t00b VALUES(6);


sqltext:
CREATE TABLE t00a(a,b);
INSERT INTO t00a VALUES(0,0);
CREATE TABLE t00b(n);
CREATE TRIGGER r00 AFTER INSERT ON t00b BEGIN
SELECT 0 FROM t00a WHERE 0>n0000 UNION ALL
SELECT 0 FROM t00a WHERE 0>new>x ORDER BY 0 LIMIT 0,
END;
INSERT INTO t00b VALUES(6);


sqltext:
CREATE TABLE t00b AS SELECT "a","b"COLLALE�t00b ,"b"COLLALE AS SELECT "a","b"COLTE''LIKE'';
SELECT * FROM t00b;


sqltext:
CREATE TABLE t00b AS SELECT "a","b"COLLATE''LIKE''LIKE'  "a","b"COLLE''LIKE'',"b"COLLATE''LIKE''L;
S0',"b"COLLATE''LIKE''L;
 00b;


sqltext:
CREATE TABLE t00b AS SELECT "a","b"COLLATE''LIKE''LIKE'  "a","b"COLLE''LIKE'',"b"COLLATE''LIKE''L;
S0'<"b"COLLATE''LIKE''L;
 00b;


sqltext:
CREATE TABLE t00b AS SELECT "a","b"COLLATE''LIKE''LIKE'  "a","b"COLLE'COLLATE'LIKE'',"b"COLLATE''LIKE''L;
S0',"b"COLLATE''LIKE''L;
 00b;


sqltext:
CREATE TABLE t00b AS SELECT "a","b"COLLATE''LIKE''LIKE'  "a","b"COLLE�'LIKE'',"b"COLLATE''LIKE''L;
S0',"b"COLLATE''LIKE''L;
 00b;


sqltext:
CREATE TABLE t00b AS SELECT 4 AS '', 5 A__________________________R���������������������������������������������������_______________________R��������������������������������������������OM t00b;


sqltext:
CREATE TABLE t01(x, y);
CREATE TABLE t02(x, y);
CREATE VIEW v0 as
SELECT "a","b" x, * FROM t01
UNION ALL
SELECT x, y FROM t02;
CREATE INDEX t000 ON t01(x);
CREATE INDEX t00x ON t02(x);
EXPLAIN QUERY PLAN
SELECT * FROM v0 WHERE x='0' ORDER BY y;


sqltext:
CREATE TABLE t01(x, y);
CREATE TABLE t02(x, y);
CREATE VIEW v0 as
SELECT strftime(1,1,1,1) x, y FROM t01
UNION ALL
SELECT 1=1 x, y FROM t02;
CREATE INDEX t000 ON t01(x);
CREATE INDEX t00x ON t02(x);
EXPLAIN QUERY PLAN
SELECT * FROM v0 WHERE x='0' OR likely(1)


sqltext:
CREATE TABLE t01(x, y);
CREATE TABLE t02(x, y);
CREATE VIEW v0 as
SELECT time(1,1,1) x, y FROM t01
UNION ALL
SELECT x,NOT y FROM t02;
CREATE INDEX t000 ON t01(x);
CREATE INDEX t00x ON t02(x);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM v0 WCO ORDER BY y;


sqltext:
CREATE TABLE t01(x, y);
CREATE TABLE t02(x, y);
CREATE VIEW v0 as
SELECT x, y FROM t01
UNION ALL
SELECT min(1,1) x, y FROM t02;
CREATE INDEX t000 ON t01(x);
CREATE INDEX t00x ON t02(x);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM v0 WCO ORDER BY y;


sqltext:
CREATE TABLE t01(x, y);
CREATE TABLE t02(x, y);
CREATE VIEW v0 as
SELECT x, y FROM t01
UNION ALL
SELECT x, y FROM t01
UNION ALL
SELECT x, y F
UNION ALL
SELECT x, y FROM ROM t02;
CREATE INDEX t000 ON t01(x);
CREATE t02(x, y);
CREAT2(x);
EXPLAIN QUERYPLAN

SELECT * FROM v0 SELECT 


sqltext:
CREATE TABLE t01(x, y);
CREATE TABLE t02(x, y);
CREATE VIEW v0 as
SELECT x, y FROM t01
UNION ALL
SELECT x, y FROM t01
UNION ALL
SELECT x, y FROM t02;
CREATE INDEX t000 ON t01(x);
CREATE INDEX t00x ON t02(x);
EXPLAIN QUERY PLAN
SELECT * FROM v0 WHERE -1'0'I)


sqltext:
CREATE TABLE t01(x, y);
CREATE TABLE t02(x, y);
CREATE VIEW v0 as
SELECT x, y FROM t01
UNION ALL
SELECT x, y FROM t01
UNION ALL
SELECT x, y FROM t02;
CREATE INDEX t000 ON t01(x);
CREATE INDEX t00x ON t02(x);
EXPLAIN QUERY PLAN
SELECT * FROM v0 WHERE x<'0' -1


sqltext:
CREATE TABLE t01(x, y);
CREATE TABLE t02(x, y);
CREATE VIEW v0 as
SELECT x, y FROM t01
UNION ALL
SELECT x, y FROM t01
UNION ALL
SELECT x, y FROM t02;
CREATE INDEX t000 ON t01(x);
CREATE INDEX t00x ON t02(x);
EXPLAIN QUERY PLAN
SELECT * FROM v0 WHERE x>'0'I)


sqltext:
CREATE TABLE t01(x, y);
CREATE TABLE t02(x, y);
CREATE VIEW v0 as
SELECT x, y FROM t01
UNION ALL
SELECT x, y FROM t02;
CREATE INDEX t000 ON t01(x);
CREATE INDEX t00x ON t02(x);
EXPLAIN QUERY PLAN
SELECT * FROM v0 WHERE x='0' GROUP BY 2001-01-01"a"


sqltext:
CREATE TABLE t01(x, y);
CREATE TABLE t02(x, y);
CREATE VIEW v0 as
SELECT x, y FROM t01
UNION ALL
SELECT x, y FROM t02;
CREATE INDEX t000 ON t01(x);
CREATE INDEX t00x ON t02(x);
EXPLAIN QUERY PLAN
SELECT * FROM v0 WHERE x='0' ORDER BY 2,01
01-01"a"


sqltext:
CREATE TABLE t01(x, y);
CREATE TABLE t02(x, y);
CREATE VIEW v0 as
SELECT x, y FROM t01
UNION ALL
SELECT x, y FROM t02;
CREATE INDEX t000 ON t01(x);
CREATE INDEX t00x ON t02(x);
EXPLAIN QUERY PLAN
SELECT * FROM v0 WHERE x='0'ISNULL OR likely(1)


sqltext:
CREATE TABLE t01(x, y);
CREATE TABLE t02(x, y);
CREATE VIEW v0 as
SELECT x, y FROM t01
UNION ALL
SELECT x, y FROM t02;
CREATE INDEX t000 ON t01(x);
CREATE INDEX t00x ON t02(x);
EXPLAIN QUERY PLAN
SELECT * FROM v0 WHERE x>'0' ORDER BY y;


sqltext:
CREATE TABLE t01(x, y);
CREATE TABLE t02(x, y);
CREATE VIEW v0 as
SELECT x, y FROM t01
UNION ALL
SELECT x, y FROM t02;
CREATE INDEX t000 ON t01(x);
CREATE INDEX t00x ON t02(x);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM v0 WCO ORDER BY y;


sqltext:
CREATE TABLE t01(x, y);
CREATE TABLE t02(x, y);
CREATE VIEW v0 as
SELECT x, y FROM t02
UNION ALL
SELECT x,NOT y FROM t02;
CREATE INDEX t000 ON t01(x);
CREATE INDEX t00x ON t02(x);
EXPLAIN QUERY PLAN
SELECT DISTINCT* FROM v0 WCO GROUP BY y;


sqltext:
CREATE TABLE t010(a, CHECK( m000.t010.a>00));
CREATE TABLE t011(b, CHECK( x000y.t011.b BETWEEN 0 AND 10 ));


sqltext:
CREATE TABLE t010(a, CHECK( m000.t010.a>00));
CREATE TABLE t011(b, CHECK( x000y.t011.b BETWEEN 0 AND 10 ));VACUUM


sqltext:
CREATE TABLE t010(a, CHECK( m000.t010.a>00));
CREATE TABLE �011(b, CHECK( x000y.t011.b BETWEEN 0 AND 10 ));


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES ( "a");
INSERT INTO t03 VALUES('00c');
SELECT count( sqlite_source_id()),
NULLIF(n00e,NOT'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES ( round(1,1)-"a");
INSERT INTO t03 VALUES('00c');
SELECT count( unicode(1)),
NULLIF(n00e,NOT'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 SELECT count(),
 group_concat(1,1)A00
FROM t03
GROUP BY zeroblob(1);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00NSERT INTO t0TABLE t03(n00e);
IN3 VALUES (NULc
GROUP BY lowe');
SELECT count( sqlite_version())OR group_concat(1,1)A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00NSERT INTO t0TABLE t03(n00e);
IN3 VALUES (NULc');
SELECT count( typeof(1)),
 group_concat(1,1)A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( abs( -11)),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( abs( .11)),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( abs(?)),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( abs(?)),:NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( changes()),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( instr(1,1)),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( length(1)),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( length(?)),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( min(),1)),
N3
GROUP BY lower(n00


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( quote(1)),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( round( -1)),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( round(0,3)),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( round(1, -13)),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( round(1,2001-01-011)),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( round(1,9)),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( sqlite_compileoption_get(1)),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( sqlite_compileoption_used(1)),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( sqlite_version()),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count( total_changes()),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count(),
 group_concat(1,1)A00
FROM t03
GROUP BY zeroblob(1);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count(),
 group_concat(?,1)A00
FROM t03
GROUP BY zeroblob(1);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count(),
NULLIF( "a",'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count(),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(@00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');
SELECT count(DISTINCT),
NULLIF( (1),'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t03(n00e);
INSERT INTO t03 VALUES (NULL);
INSERT INTO t03 VALUES('00c');EXPLAIN
SELECT count(),
NULLIF(n00e,'00c')A00
FROM t03
GROUP BY lower(n00e);


sqltext:
CREATE TABLE t0a(a,b char(1));
CREATE TABLE t0b(x);
INSERT INTO t0a VALUES('on0', 1);
INSERT INTO t0a VALUES('on0', 2);
INSERT INTO t0a VALUES('t00', 3);
INSERT INTO t0a VALUES('00',  (1));
INSERT INTO t0b(rowid,x)VALUES(1,1);
INSERT INTO t0b(rowid,x)VALUES(2,200);
INSERT INTO t0b(rowid,x) VALUES(3,300);
SELECT a, count(b) FROM t0a, t0b WHERE b<t0b.rowid GROUP BY a OR "a","b";


sqltext:
CREATE TABLE t0a(a,b char(1));
CREATE TABLE t0b(x);
INSERT INTO t0a VALUES('on0', 1);
INSERT INTO t0a VALUES('on0', 2);
INSERT INTO t0a VALUES('t00', 3);
INSERT INTO t0a VALUES('00', NULL);
INSERT INTO t0b(rowid,x)VALUES(1,1);
INSERT INTO t0b(rowid,x)VALUES(2,200);
INSERT INTO t0b(rowid,x) VALUES(3,300);
SELECT a, count(b) FROM t0a, t0b WHERE b<t0b.rowid GROUP BY a ORDER BY a;


sqltext:
CREATE TABLE t0a(a,b char(1));
CREATE TABLE t0b(x);EXPLAIN
INSERT INTO t0a VALUES('on0', 1);
INSERT INTO t0a VALUES('on0', 2);
INSERT INTO t0a VALUES('t00', 3);
INSERT INTO t0a VALUES('00', NULL);
INSERT INTO t0b(rowid,x)VALUES(1,1);
INSERT INTO t0b(rowid,x)VALUES(2,200);
INSERT INTO t0b(rowid,x) VALUES(3,300);
SELECT a, count(b) FROM t0a, t0b WHERE b<t0b.rowid GROUP BY a ORDER BY a;


sqltext:
CREATE TABLE t0a(a,b);
CREATE TABLE t0b(x);
INSERT INTO t0a VALUES('on0', 1);
INSERT INTO t0a VALUES('on0', 2);
INSERT INTO t0a VALUES('t00', 3);
INSERT INTO t0a VALUES('00', NULL);
INSERT INTO t0b(rowid,x)VALUES(1,1);
INSERT INTO t0b(rowid,x)VALUES(2,200);
INSERT INTO t0b(rowid,x) VALUES(3,300);
SELECT a, count(b) FROM t0a, t0b WHERE b= lower(1) GROUP BY a ORDER BY a;


sqltext:
CREATE TABLE t0a(a,b);
CREATE TABLE t0b(x);
INSERT INTO t0a VALUES('on0', 1);
INSERT INTO t0a VALUES('on0', 2);
INSERT INTO t0a VALUES('t00', 3);
INSERT INTO t0a VALUES('00', NULL);
INSERT INTO t0b(rowid,x)VALUES(1,1);
INSERT INTO t0b(rowid,x)VALUES(2,200);
INSERT INTO t0b(rowid,x) VALUES(3,300);
SELECT a, count(b) FROM t0a, t0b WHERE b= total(1) GROUP BY a ORDER BY a;


sqltext:
CREATE TABLE t0a(a,b);
CREATE TABLE t0b(x);
INSERT INTO t0a VALUES('on0', 1);
INSERT INTO t0a VALUES('on0', 2);
INSERT INTO t0a VALUES('t00', 3);
INSERT INTO t0a VALUES('00', NULL);
INSERT INTO t0b(rowid,x)VALUES(1,1);
INSERT INTO t0b(rowid,x)VALUES(2,200);
INSERT INTO t0b(rowid,x) VALUES(3,300);
SELECT a, count(b) FROM t0a, t0b WHERE@b<t0b.rowid GROUP BY a ORDER BY a;


sqltext:
CREATE TABLE t0a(a,b);
CREATE TABLE t0b(x);
INSERT INTO t0a VALUES('on0', 1);
INSERT INTO t0a VALUES('on0', 2);
INSERT INTO t0a VALUES('t00', 3);
INSERT INTO t0a VALUES('00', NULL);
INSERT INTO t0b(rowid,x)VALUES(1,1);
INSERT INTO t0b(rowid,x)VALUES(2,200);
INSERT INTO t0b(rowid,x) VALUES(3,300);
SELECT a, count(b) FROM t0a, t0b WHERE@b=t0b.rowid GROUP BY "a","�" BY a;


sqltext:
CREATE TABLE t0a(a,b);
CREATE TABLE t0b(x);
INSERT INTO t0a VALUES('on0', 1);
INSERT INTO t0a VALUES('on0', 2);
INSERT INTO t0a VALUES('t00', 3);
INSERT INTO t0a VALUES('00', NULL);
INSERT INTO t0b(rowid,x)VALUES(1,1);
INSERT INTO t0b(rowid,x)VALUES(2,200);
INSERT INTO t0b(rowid,x) VALUES(3,300);
SELECT a, count(b) FROM t0a, t0b WHERE@b=t0b.rowid GROUP BY "�","b" BY a;


sqltext:
CREATE TABLE t0a(a,b);
CREATE TABLE t0b(x);
INSERT INTO t0a VALUES('on0', 1);
INSERT INTO t0a VALUES('on0', 2);
INSERT INTO t0a VALUES('t00', 3);
INSERT INTO t0a VALUES('00', NULL);
INSERT INTO t0b(rowid,x)VALUES(1,1);
INSERT INTO t0b(rowid,x)VALUES(2,200);
INSERT INTO t0b(rowid,x) VALUES(3,300);
SELECT a, count(b) FROM t0a, t0b WHERE@b=t0b.rowid GROUP BY random()"a" BY


sqltext:
CREATE TABLE t0a(a,b);
CREATE TABLE t0b(x);
INSERT INTO t0a VALUES('on0', 1);
INSERT INTO t0a VALUES('on0', 2);
INSERT INTO t0a VALUES('t00', 3);
INSERT INTO t0a VALUES('00', NULL);
INSERT INTO t0b(rowid,x)VALUES(1,1);
INSERT INTO t0b(rowid,x)VALUES(2,200);
INSERT INTO t0b(rowid,x) VALUES(3,300);
SELECT zeroblob(1) a, count(b) FROM t0a, t0b WHERE b=t0b.rowid GROUP BY a ORDER BY a;


sqltext:
CREATE TABLE t0a(a,b);
CREATE TABLE t0b(x);
INSERT INTO t0a VALUES('on0', 1);
INSERT INTO t0a VALUES('on0', 2);
INSERT INTO t0a VALUES('t00', 3);
INSERT INTO t0a VALUES('�0', NULL);
INSERT INTO t0b(rowid,x)VALUES(1,1);
INSERT INTO t0b(rowid,x)VALUES(2,200);
INSERT INTO t0b(rowid,x) VALUES(3,300);
SELECT a, count(b) FROM t0a, t0b WHERE a<t0b.rowid GROUP BY a ORDER BY a;


sqltext:
CREATE TABLE t0a(a,b);
CREATE TABLE t0b(x);EXPLAIN
INSERT INTO t0a VALUES('on0', 1);
INSERT INTO t0a VALUES('on0', 2);
INSERT INTO t0a VALUES('t00', 3);
INSERT INTO t0a VALUES('00', NULL);
INSERT INTO t0b(rowid,x)VALUES(1,1);
INSERT INTO t0b(rowid,x)VALUES(2,200);
INSERT INTO t0b(rowid,x) VALUES(3,300);
SELECT a, count(b) FROM t0a, t0b WHERE@b<t0b.rowid GROUP BY a ORDER BY a;


sqltext:
CREATE TABLE t0a(a,b);
CREATE TABLE t0b(x);EXPLAIN
INSERT INTO t0a VALUES('on0', 1);EXPLAIN
INSERT INTO t0a VALUES('on0', 2);
INSERT INTO t0a VALUES('t00', 3);
INSERT INTO t0a VALUES('00', NULL);
INSERT INTO t0b(rowid,x)VALUES(1,1);
INSERT INTO t0b(rowid,x)VALUES(2,200);
INSERT INTO t0b(rowid,x) VALUES(3,300);
SELECT a, count(b) FROM t0a, t0b WHERE@b<t0b.rowid GROUP BY a ORDER BY a;


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  "R";
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ON (x=99) ORDER BY x;ANALYZE


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  "R";
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ON (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  "_OR";
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ON (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  (1)NOTNULL;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ON 1=199) M


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  (1)NOTNULL;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ON?(x=M


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0X0;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ON (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0X0DD02001FOR-01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ON (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADD /* */OR
01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ONT JOIN t0b ON (x<99) OR (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADD02001FOR
01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ON (1)99


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADD02FOR-01=01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0A aub ON - 1=1) OR


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADDA2001-01-01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ONT JOIN t0b ON (x=99) OR (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADDA2001FOR-01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ONT JOIN t0b ON (x<99) OR (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADDA2001FOR-01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a WHERE  0XADDA2001F JOI


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADDA200NOTNULL;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0a ONT JOIN t0b ON -1 (M


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADDADD0NOTNULL;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ON (1)IN t0b ON UM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADDADD0NOTNULL;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ONT JOIN t0b ON (x<99) OR (x=9) OR (x=99) ORDER BY x;VA3UUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADDADD0NOTNULL;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ONT JOIN t0b ON (x<99) OR (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADDADDADD0;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ON (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADDIN
PRAGMA x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADDNOTNULL /* * /* */;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ONT JOIN t0b ON (x<99)AND (1)99) M


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADDNOTNULL /* */OR
01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0a ONT JOIN t0b ON?(M


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADDNOTNULL /* */OR
01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b Et0b ON (x<99)AND   0XADDNOTNULL(1)99LOB


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADDNOTNULL /* */OR
01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ONT JOIN t0b ON (x<99) OR (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADDNOTNULL /* */OR
01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ONT JOIN t0b ON (x<99)AND (1)99) M


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADDNOTNULL /* */OR
01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ONT JOIN t0b ON (x<99)AND (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0XADDNOTNULL /* */OR
01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ONT JOIN t0b ON (x=99) OR (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  0e0;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ON (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE  oid;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ON (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE x=992001-01-01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ON (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE x=99;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ON~~~~~~~~2001-01-01~


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE x=99;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a �EFT JOIN t0b ON (x=x);x;


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE+ 0XADD02001FOR-01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ON (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE- 0XADD02001FOR-01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0b ON (x=99) ORDER BY x;VACUUM


sqltext:
CREATE TABLE t0a(x);
CREATE TABLE t0b(y);
INSERT INTO t0a(x)VALUES(1);
CREATE INDEX t000 ON t0a(x) WHERE- 0XADDA2001FOR-01;
PRAGMA automatic_index=OFF;
SELECT * FROM t0a LEFT JOIN t0a ONT JOIN t0b ON -1 (M


sqltext:
CREATE TABLE t0b(x);
INSERT INTO t0b(rowid, x) VALUES( 1%11,10),(2, length(1)-10),(0, likely(1)-01-1);
�;


sqltext:
CREATE TABLE t0b(x);
INSERT INTO t0b(rowid, x) VALUES( 1511,10),(2, length(1)-10),(0, likely(1)-01-1);
ix=10;


sqltext:
CREATE TABLE t0b(x);
INSERT INTO t0b(rowid, x) VALUES( 1511,10),(2, likely(1)-10),(0, likely(1)-01-1);
ix=10;


sqltext:
CREATE TABLE t0b(x);
INSERT INTO t0b(rowid, x) VALUES( 1511,10),(2, likely(1)-10),(0, likely(1)-01=1);
ix=10;


sqltext:
CREATE TABLE t0b(x);
INSERT INTO t0b(rowid, x) VALUES( 1=01,10),(2,1 >>1);
UPDATE t0b SET rowid=rowid+1 WHERE x=10;


sqltext:
CREATE TABLE t0b(x);
INSERT INTO t0b(rowid, x) VALUES( 1=11,10),(2,1 >2001-01-01=1);
UPDATE t0b SET rowid=rowid;
UPDATE t0b SET rowid=rowid+1 WHERE x=10;


sqltext:
CREATE TABLE t0b(x);
INSERT INTO t0b(rowid, x) VALUES( 1=11,10),(2,1 >2001-01-01=1);
UPDATE t0b SET rowid=rowid;
UPDATE t0b SET rowid=rowid+1 WHERE x=10;
UPDATE t0b SET rowid=rowid;
UPDATE t0b SET rowid=rowid+1


sqltext:
CREATE TABLE t0b(x);
INSERT INTO t0b(rowid, x) VALUES( 1=11,10),(2,1 >=1);
UPDATE t0b SET rowid=rowid+1 WHERE x=10;


sqltext:
CREATE TABLE t0b(x);
INSERT INTO t0b(rowid, x) VALUES(1,10),(2,1 -11);
UPDATE t0b SET rowid=rowid+1 WHERE x=10;


sqltext:
CREATE TABLE t0b(x);
INSERT INTO t0b(rowid, x) VALUES(1,10),(2,1 >=1);
UPDATE t0b SET rowid=rowid+1 WHERE x=10;


sqltext:
CREATE TABLE t0b(x);
INSERT INTO t0b(rowid, x) VALUES(20000001012001-01-011,10),(2,11);
UPDATE t0b SET rowid=rowid&1 WHERE x=10;


sqltext:
CREATE TABLE t0e01(a INTEGER PRIMARY KEY, b) WITHOUT rowid;
CREATE UNIQUE INDEX i0000 ON t0e01(a,a);
INSERT INTO t0e01 VALUES(100,200);
CREATE TABLE t0e02(w, x, y, FOREIGN KEY(x,y) REFERENCES t0000(a,b));
INSERT INTO t0e02 VALUES(300,100,200);
UPDATE t0e01 set a = 200 where a ISNULL
2;


sqltext:
CREATE TABLE t0e01(a INTEGER PRIMARY KEY, b) WITHOUT rowid;
CREATE UNIQUE INDEX i0000 ON t0e01(a,a);
INSERT INTO t0e01 VALUES(100,200);
CREATE TABLE t0e02(w, x, y, FOREIGN KEY(x,y) REFERENCES t0000(a,b));
INSERT INTO t0e02 VALUES(300,100,200);
UPDATE t0e01 set b = 200 where a = 1.0;
SELECT* FROM t0e01, t0e02;


sqltext:
CREATE TABLE t0e01(a INTEGER PRIMARY KEY, b) WITHOUT rowid;
CREATE UNIQUE INDEX i0000 ON t0e01(a,a);REPLACE INTO t0e01 VALUES(100,200);
CREATE TABLE t0e02(w, x);REPLACE INTO t0e01 VALUES(100,200);
CREATE TABLE t0e02(w, x, y, FOREIG, y, FOREIGN KEY(x,y) REFERENCES t0000(a,b));
INSERT INTO t0e02 VALUES(300,100,200);
UPDATE t0e01 set a = oid where a = 10,;
2;


sqltext:
CREATE TABLE t0e01(a INTEGER PRIMARY KEY, b) WITHOUT rowid;
CREATE UNIQUE INDEX i0000 ON t0e01(a,a);REPLACE INTO t0e01 VALUES(100,200);
CREATE TABLE t0e02(w, x, y, FOREIGN KEY(x,y) REFERENCES t0000(a,b));
INSERT INTO t0e02 VALUES(300,100,200);
UPDATE t0e01 set a = 200 where a / 100;
SELECT* FROM t0e01, t0e02;


sqltext:
CREATE TABLE t0e01(a INTEGER PRIMARY KEY, b) WITHOUT rowid;
CREATE UNIQUE INDEX i0000 ON t0e01(a,a);REPLACE INTO t0e01 VALUES(100,200);
CREATE TABLE t0e02(w, x, y, FOREIGNTEGER PRIMARY KEY, b) WITHOUT rowid;
CREATE UNIQUE INDEX i0000 ON t0e01(a,a);2;


sqltext:
CREATE TABLE t0e01(a INTEGER PRIMARY KEY, b) WITHOUT rowid;
CREATE UNIQUE INDEX i0000 ON t0e01(a,a);REPLACE INTO t0e01 VALUES(100,200);
CREATE TABLE t0e02(w, x, y, FOREIGNTEGER PRIMARY KEY, b) WITHOUT rowid;ANALYZE UNIQUE IN2;


sqltext:
CREATE TABLE t0e01(a INTEGER PRIMARY KEY, b) WITHOUT rowid;
CREATE UNIQUE INDEX i0000 ON t0e01(a,b);
INSERT INTO t0e01 VALUES(100,200);
CREATE TABLE t0e02(w, x, y, FOREIGN KEY(x,y) REFERENCES t0000(a,b));
INSERT INTO t0e02 VALUES(300,100,200);
UPDATE t0e01 set b = 200 where a = 1.0;
SELECT* FROM t0e01, t0e02;


sqltext:
CREATE TABLE t0e01(a INTEGER PRIMARY KEY, b) WITHOUT rowid;
CREATE UNIQUE INDEX i0000 ON t0e01(a,b);
INSERT INTO t0e01 VALUES(100,200);
CREATE TABLE t0e02(w, x, y, FOREIGN KEY(x,y) REFERENCES t0000(a,b));
INSERT INTO t0e02 VALUES(300,100,200);
UPDATE t0e01 set b = 200 where a = 100;
SELECT* FROM t0e01, t0e02;VACUUM


sqltext:
CREATE TABLE t0e01(a INTEGER PRIMARY KEY, b) WITHOUT rowid;
CREATE UNIQUE INDEX i0000 ON t0e01(a,b);
INSERT INTO t0e01 VALUES(100,200);
CREATE TABLE t0e02(w, x, y, FOREIGN KEY(x,y) REFERENCES t0000(a,b));
INSERT INTO t0e02 VALUES(300,100,200);
UPDATE t0e01 set b = 200 where a!= 100;
SELECT* FROM t0e01, t0e02;


sqltext:
CREATE TABLE t0e01(a INTEGER PRIMARY KEY, b) WITHOUT rowid;
CREATE UNIQUE INDEX i0000 ON t0e01(a,b);
INSERT INTO t0e01 VALUES(100,200);
CREATE TABLE t0e02(w, x, y, FOREIGN KEY(x,y) REFERENCES t0000(a,b));
INSERT INTO t0e02 VALUES(300,100,200);REINDEX t0e01 b =2;


sqltext:
CREATE TABLE t0e01(a INTEGER PRIMARY KEY, b) WITHOUT rowid;
CREATE UNIQUE INDEX i0000 ON t0e01(b,b);
INSERT INTO t0e01 VALUES(100,200);
CREATE TABLE t0e02(w, x, y, FOREIGN KEY(x,y) REFERENCES t0000(a,b));
INSERT INTO t0e02 VALUES(300,100,200);
UPDATE t0e01 set b = 200 where a = 100;
SELECT* FROM t0e01, t0e02;


sqltext:
CREATE TABLE t0e01(a INTEGER PRIMARY KEY, b) WITHOUT rowid;
CREATE UNIQUE INDEX �0000 ON t0e01(a,a);REPLACE INTO t0e01 VALUES(100,200);
CREATE TABLE t0e02(w, x, y, FOREIGNTEGER PRIMARY KEY, b) WITHOUT rowid;
CREATE UNIQUE INDEX i0000 ON t0e01(a,a);2;


sqltext:
CREATE TABLE t0e01(a INTEGER PRIMARY KEY, b) WITHOUT rowid;EXPLAIN
CREATE UNIQUE INDEX i0000 ON t0e01(a,a);REPLACE INTO t0e01 VALUES(100,200);
CREATE TABLE t0e02(w, x, y, FOREIGNTEGER PRIMARY KEY, b) WITHOUT rowid;
CREATE UNIQUE INDEX i0000 ON t0e01(a,a);2;


sqltext:
CREATE TABLE t0e01(a gNTEGER PRIMARY KEY, b) WITHOUT rowid;
CREATE UNIQUE INDEX i0000 ON t0e01(a,a);REPLACE INTO t0e01 VALUES(100,200);
CREATE TABLE t0e02(w, x, yL FOREIGNTEGER PRIMARY KEY, b) WITHOUT rowid#ANALYZE UNIQUE IN2;


sqltext:
CREATE TABLE t0e03(a INTEGER PRIMARY KEY, b, UNIQUE(a,b)) WITHOUT rowid+0e03 set b = 200 where a = 100;
SELECT* FROM t0e03, t0e00;


sqltext:
CREATE TABLE t0e03(a INTEGER PRIMARY KEY, b, UNIQUE(a,b)) WITHOUT rowid;
INSERT INTO t0e03 VALUES(100,200);
CREATE TABLE t0e00(w, x, y, FOREIGN KEY(x,y) REFERENCES t0000(a,b));
INSERT INTO t0e00 VALUES(300,100,200);
UPDATE t0e03 set b = 200 where a = 100;
SELECT* FROM t0e03, t0e00;VACUUM


sqltext:
CREATE TABLE t0e03(a INTEGER PRIMARY KEY, b, UNIQUE(a,b)) WITHOUT rowid;REPLACE INTO t0e03 VALUES(100,200);
CREATE TABLE t0e00(w, x, y, FOREIGN KEY(x,y) REFERENCES t0000(a,b));
INSERT INTO t0e00 VALUES(300,100,200);
UPDATE t0e03 set b = 200 where a = 100;
SELECT* FROM t0e03, t0e00;


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES(#ab00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
INSERT INTO t0t0000 VALUES('ABX0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
SELECT DISTINCT a FROM t0t0000;


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
SELECT DISTINCT a FROM t0t0000;


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
INSERT INTO t0t0000 VALUES(000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000004);
SELECT DISTINCT a FROM t0t0000;


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
INSERT INTO t0t0000 VALUES(0E0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004);
SELECT DISTINCT a FROM t0t0000;


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('ab0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
INSERT INTO t0t0000 VALUES('AB0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000NOTNULL0000000000000000000000000000');
SELECT DISTINCT a FROM t0t0000;


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('ab00000000000000 quote(1)000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
INSERT INTO t0t0000 VALUES('AB00000000000�������������������0000000000000000000000000000000000000000000000000000000000000000000000000L0000000000000000000000000000000');
SELECT DISTINCT a FROM t0t0000;


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('ab00000000000000000000/00000000000000000000000000000000000000000000000000000000N00000000000000000000 00000000000000000000000000000000000000000000000000000000000000000');
INSERT INTO t0t0000 VALUES('AB00000e10000000000000000000000000000000000000000000000000000000070000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
SELECT DISTINC  a FROM t0t0000;


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('ab0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
INSERT INTO t0t0000 VALUES('ABX0000000000000000000000000000000000000000000000');
SELECT 0000000000000000000000000000600000000000000000000000000000000000000000000000
00
SEL


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('ab0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
INSERT INTO t0t0000 VALUES('ABX0000000000000000000000000000000000000000000000');
SELECT 0E000000000600000000000000000000000000000000000000000000000
00
SEL


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('ab0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');REPLACE INTO t0t0000 VALUES('ABX0000000000000000000000000000000000000000000000');
SELECT 00000000000E000000000000000000000000000000000000000
00
SEL


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('ab00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
INSERT INTO t0t0000 VALUES('AB000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000OF0000000000000000000000000000000');
SELECT DISTINCT a FROM t0t0000;


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('ab00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
INSERT INTO t0t0000 VALUES('AB000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000OF0000000000000000000000000000000');
SELECT DISTINCT+a FROM t0t0000;


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('ab00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');REPLACE INTO t0t0000 VALUES('AB000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000OF0000000000000000000000000000000');
SELECT DISTINCT+a FROM t0t0000;


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('ab000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000');
INSERT INTO t0t0000 VALUES('AB00000000000000000000000000000000000000000000�000000000000000000000000000000000000000000000000000000000000000000000000000000000');
SELECT DISTINCT a EROM t0t;


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('ab0000000000000000000000000000000000000000000000000000Y00000000000000000000000000000000000000000000000000000000000000000000000000');
INSERT INTO t0t0000 VALUES('ABX0000000000000000000000000000000000000000000000');
SELECT 00000000000E00000000000000000000000000000000000000000000000000000000000000000000000
00
SEL


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('ab0000�0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
INSERT INTO t0t0000 VALUES('AB000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000OF0000000000000000000000000000000');
SELECT DISTINCT a FROM t0t0000;


sqltext:
CREATE TABLE t0t0000(a COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000@VALUES('ab00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
INSERT INTO t0t0000 VALUES('ABX0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
SELECT DISTINCT a FROM t0t0000;


sqltext:
CREATE TABLE t0t0000(� COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('ab00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
INSERT INTO t0t0000 VALUES('AB000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000OF0000000000000000000000000000000');
SELECT DISTINCT a FROM t0t0000;


sqltext:
CREATE TABLE t0t0000(� COLLATE nocase PRIMARY KEY);
INSERT INTO t0t0000 VALUES('ab0000000000�000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
INSERT INTO t0t0000 VALUES('AB000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000OF0000000000000000000000000000000');
SELECT DISTINCT a FROM t0t0000;


sqltext:
CREATE TABLE t1( [a]a char(1),b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%p0%s',a,b,c) FROM t1 GROUP BY 00001;


sqltext:
CREATE TABLE t1( [a]a, b, c);
INSERT INTO t1 VALUES('a', 1, 1);
INSERT INTO t1 VALUES('0', 6, 6);
INSERT INTO t1 VALUES('c', 5, 5);
INSERT INTO t1 VALUES('0', 4, 4);
INSERT INTO t1 VALUES('0', 5, 5);
INSERT INTO t1 VALUES('b', 6, 6);
INSERT INTO t1 VALUES('b', 4, 4);
INSERT INTO t1 VALUES('c', 7, 7);
INSERT INTO t1 VALUES('0', 2, 2);
INSERT INTO t1 VALUES('0', 3, 3);
INSERT INTO t1 VALUES('a', 3, 3);
INSERT INTO t1 VALUES('b', 5, 5);
INSERT INTO t1 VALUES('c', 4, 4);
INSERT INTO t1 VALUES('c', 3, 3);
INSERT INTO t1 VALUES('a', 2, 2);
SELECT * FROM t1 GROUP BY@a, a,oid


sqltext:
CREATE TABLE t1( [a]a, b, c);
INSERT INTO t1 VALUES('a', 1, 1);
INSERT INTO t1 VALUES('0', 6, 6);
INSERT INTO t1 VALUES('c', 5, 5);
INSERT INTO t1 VALUES('0', 4, 4);
INSERT INTO t1 VALUES('0', 5, 5);
INSERT INTO t1 VALUES('b', 6, 6);
INSERT INTO t1 VALUES('b', 4, 4);
INSERT INTO t1 VALUES('c', 7, 7);
INSERT INTO t1 VALUES('0', 2, 2); VALUES('b', 5, 5);
INSERT INTO t1 VALUES('c', 4, 4);
INSERT INTO t1 VALUES('c', 3, 3);
INSERT INTO t1 VALUES('a', 2, 2);
SELECT * FROM t1 GROUP BY a, a,oid


sqltext:
CREATE TABLE t1( [a]a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0% -1200s',a,b,c) FROM t1 GROUP BY 00001;


sqltext:
CREATE TABLE t1( [a]a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%0ess',a,b,c) FROM t1 GROUP BY 00001;


sqltext:
CREATE TABLE t1( [a]a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%2.0s',a,b,c) FROM t1 GROUP BY 00001;


sqltext:
CREATE TABLE t1( [a]a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%200g',a,b,c) FROM t1 GROUP BY 00001;


sqltext:
CREATE TABLE t1( [a]a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%200s',oid,c) FROM t1 GROUP BY 00001;


sqltext:
CREATE TABLE t1( [a]a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%20Es',a,b,c) FROM t1 GROUP BY 00001;


sqltext:
CREATE TABLE t1( [a]a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%2G0s',a,b,c) FROM t1 GROUP BY 00001;


sqltext:
CREATE TABLE t1( [a]a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%f0%g',a,b,c) FROM t1 GROUP BY 00001;


sqltext:
CREATE TABLE t1( [a]a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%f0%s', -1,c) FROM t1 GROUP BY 00001;


sqltext:
CREATE TABLE t1( [a]a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%n0%w',a,b,c) FROM t1 GROUP BY 00001;


sqltext:
CREATE TABLE t1( [a]a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%s0% *s',?,b,c) FROM t1 GROUP BY 00001;


sqltext:
CREATE TABLE t1( [a]a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%s0%',a,b,c) FROM t1 GROUP BY 00001;


sqltext:
CREATE TABLE t1( [a]a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%s0%s' /* */) FROM t1 GROUP BY 00001;


sqltext:
CREATE TABLE t1( [a]a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1>5,2.05,3.005);
SELECT printf('0%p0%s',a,b,c) FROM t1 GROUP BY 00001;


sqltext:
CREATE TABLE t1( [a]a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(.1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%p0%s',a,b,c) FROM t1 GROUP BY 00001;


sqltext:
CREATE TABLE t1( a,ba,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(b);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','1߃| '),('t1','t1b','1߃| ');
ANALYZE sqlite_master;
SELECT*,'0'FROM t1 WHERE a BETWEEN 3 AND 8 ORDER BY a,b


sqltext:
CREATE TABLE t1( a,oa,x);
INSERT INTO t1(oid,a,x)VALUES(-9,1,'000000000f000000');
INSERT INTO t1(oid,a,x)VALUES(900,2,'000000000000000');
INSERT INTO t1(oid,a,x) VALUES(-6,29,'00000f0000000f0f');
INSERT INTO t1(oid,a,x) VALUES(205,30,'00000000000000f0');
INSERT INTO t1(oid,a,x) VALUES(4,31,'0000000000000004');
INSERT INTO t1(oid,a,x) VALUES(-68,32,'00000f0000008000');
INSERT INTO t1(oid,a,x) VALUES(-2,33,'00000f0000000ff0');
INSERT INTO t1(oid,a,x) VALUES(10000000000008,34,'0000800000000000');
INSERT INTO t1(oid,a,x) VALUES(50000000000,35,'0000008000000000');
INSERT INTO t1(oid,a,x) VALUES(4000000000,36,'0000000100000000');
INSERT INTO t1(oid,a,x) VALUES(-60,37,'00000f0000800000');
INSERT INTO t1(oid,a,x) VALUES(-1,38,'00000f0f');
INSERT INTO t1(oid,a,x) VALUES(3000000000,39,'00000000000f0ff0');
INSERT INTO t1(oid,a,x) VALUES(0400000,40,'0000000010000000');
INSERT INTO t1(oid,a,x) VALUES(2,41,'0000000000000002');
INSERT INTO t1(oid,a,x) VALUES(90000,42,'0000000000200000');
INSERT INTO t1(oid,a,x) VALUES(50000000,43,'000200000000');
INSERT00');
INSERT INTO t1(oid,a,x)VALUES(10000000000000,25,'00000f00000000ff');
INSERT INTO t1(oid,a,x)VALUES(20000000000000,26,'0001000000000000');
INSERT INTO t1(oid,a,x)VALUES(3000000000000000,27,'00000f0000000f00');
INSERT IN O t1(oid,a,x) VALUES(72057594037927936,28,'0100000000000000');
INSERT INTO t1(oid,a,x) VALUES(-6,29,'00000f0000000f0f');
INSERT INTO t1(oid,a,x) VALUES(205,30,'00000000000000f0');
INSERT INTO t1(oid,a,x) VALUES(4,31,'0000000000000004');
INSERT INTO t1(oid,a,x) VALUES(-68,32,'00000f0000008000');
INSERT INTO t1(oid,a,x) VALUES(-2,33,'00000f0000000ff0');
INSERT INTO t1(oid,a,x) VALUES(10000000000008,34,'0000800000000000');
INSERT INTO t1(oid,a,x) VALUES(50000000000,35,'0000008000000000');
INSERT INTO t1(oid,a,x) VALUES(4000000000,36,'0000000100000000');
INSERT INTO t1(oid,a,x) VALUES(-60,37,'00000f0000800000');
INSERT INTO t1(oid,a,x) VALUES(-1,38,'00000f0f');
INSERT INTO t1(oid,a,x) VALUES(3000000000,39,'00000000000f0ff0');
INSERT INTO t1(oid,a,x) VALUES(8400000,40,'0000000010000000');
INSERT INTO t1(oid,a,x) VALUES(2,41,'0000000000000002');
INSERT INTO t1(oid,a,x) VALUES(90000,42,'0000000000200000');
INSERT INTO t1(oid,a,x) VALUES(50000000,43,'000200000000');
INSERT INTO t1(oid,a,x) VALUES(-7,44,'000f800000000000');
INSERT INTO t1(oid,a,x) VALUES(060000000,45,'0080000000000000');
INSERT INTO t1(oid,a,x) VALUES(5000000000,46,'000000P000000fff');
INSERT INTO t1(oid,a,x) VALUES(-20,47,'00000f000000f000');
INSERT INTO t1(oid,a,x) VALUES(60000,48,'00000000000000ff');
INSERT INTO t1(oid,a,x) VALUES(128,49,'0000000000000080');
INSERT INTO t1(oid,a,x) VALUES(32768,50,'0000000000008000');
INSERT INTO t1(oid,a,x) VALUES(2147483648,51,'0000000080000000');
INSERT INTO t1(oid,a,x) VALUES(-3,52,'00000f00000000fd');
INSERT INTO t1(oid,a,x) VALUES(-28,53,'00000f0000000f80');
INSERT INTO t1(oid,a,x) VALUES(-29,5�'00000f0000000f70');
INSERT INTO t1(oid,a,x) VALUES(-9223372036854775808,55,'8000000000000000');
INSERT INTO t1(oid,a,x) VALUES(400000000000,56,'0000040000000000');
INSERT INTO t1(oid,a,x) VALUES(10000000000,57,'0000000000000ff0');
INSERT INTO t1(oid,a,x) VALUES(00800,58,'00000f000000f00f');
INSERT INTO t1(oid,a,x) VALUES(0,59,'0000000000000000');
INSERT INTO t1(oid,a,x) VALUES(1,60,'0000000000000001');
INSERT INTO t1(oid,a,x) VALUES(206,61,'0000000000000100');
INSERT INTO t1(oid,a,x) VALUES(60006,62,'0000000000010000');
INSERT INTO t1(oid,a,x) VALUES(-5000000000,63,'00000f8000000000');
INSERT INTO t1(oid,a,x) VALUES(8,64,'0f80000000000000');
�����������������������������������������������������ח����������������������������������������������������������CREATE INDEX t000 ON t1(a);
CREATE INDE


sqltext:
CREATE TABLE t1( a,oa,x);
INSERT INTO t1(oid,a,x)VALUES(-9,1,'000000000f000000');
INSERT INTO t1(oid,a,x)VALUES(900,2,'0f00000000000000');
INSERT INTO t1(oid,a,x)VALUES(922337*036854775800,3,'0f0000000000000f');
INSERT INTO t1(oid,a,x)VALUES(7,4,'000000000000000f');
INSERT INTO t1(oid,a,x)VALUES(3,5,'0000000000000003');
INSERT INTO t1(oid,a,x)VALUES(6,29,'00000f0000000f0f');
INSERT INTO t1(oid,a,x) VALUES(205,30,'00000000000000f0');
INSERT INTO t1(oid,a,x) VALUES(4,31,'0000000000000004');
INSERT INTO t1(oid,a,x) VALUES(-68,32,'00000f0000008000');
INSERT INTO t1(oid,a,x) VALUES(-2,33,'00000f0000000ff0');
INSERT INTO t1(oid,a,x) VALUES(10000000000008,34,'0000800000000000');
INSERT INTO t1(oid,a,x) VALUES(50000000000,35,'0000008000000000');
INSERT INTO t1(oid,a,x) VALUES(4000000000,36,'0000000100000000');
INSERT INTO t1(oid,a,x) VALUES(-60,37,'00000f0000800000');
INSERT INTO t1(oid,a,x) VALUES(-1,38,'00000f0f');
INSERT INTO t1(oid,a,x) VALUES(3000000000,39,'00000000000f0ff0');
INSERT INTO t1(oid,a,x) VALUES(8400000,40,'0000000010000000');
INSERT INTO t1(oid,a,x) VALUES(2,41,'0000000000000002');
INSERT INTO t1(oid,a,x) VALUES(90000,42,'0000000000200000');
INSERT INTO t1(oid,a,x) VALUES(50000000,43,'000200000000');
INSERT INTO t1(oid,a,x) VALUES(-7,44,'000f800000000000');
INSERT INTO t1(oid,a,x) VALUES(060000000,45,'0080000000000000');
INSERT INTO t1(oid,a,x) VALUES(5000000000,46,'0000000000000fff');
INSERT INTO t1(oid,a,x) VALUES(-20,47,'00000f000000f000');
INSERT INTO t1(oid,a,x) VALUES(60000,48,'00000000000000ff');
INSERT INTO t1(oid,a,x) VALUES(128,49,'0000000000000080');
INSERT INTO t1(oid,a,x) VALUES(32768,50,'0000000000008000');
INSERT INTO t1(oid,a,x) VALUES(2147483648,51,'0000000080000000');
INSERT INTO t1(oid,a,x) VALUES(-3,52,'00000f00000000fd');
INSERT INTO t1(oid,a,x) VALUES(-28,53,'00000f0000000f80');
INSERT INTO t1(oid,a,x) VALUES(-29,54,'00000f0000000f70');
INSERT INTO t1(oid,a,x) VALUES(-9223372036854775808,55,'8000000000000000');
INSERT INTO t1(oid,a,x) VALUES(400000000000,56,'0000040000000000');
INSERT INTO t1(oid,a,x) VALUES(10000000000,57,'0000000000000ff0');
INSERT INTO t1(oid,a,x) VALUES(00800,58,'00000f000000f00f');
INSERT INTO t1(oid,a,x) VALUES(0,59,'0000000000000000');
INSERT INTO t1(oid,a,x) VALUES(1,60,'0000000000000001');
INSERT INTO t1(oid,a,x) VALUES(206,61,'0000000000000100');
INSERT INTO t1(oid,a,x) VALUES(60006,62,'0000000000010000');
INSERT INTO t1(oid,a,x) VALUES(-5000000000,63,'00000f8000000000');
INSERT INTO t1(oid,a,x) VALUES(8,64,'0f80000000000000');
CREATE INDEX t000 ON t)(a);
CREATE INDE


sqltext:
CREATE TABLE t1( a,oa,x);
INSERT INTO t1(oid,a,x)VALUES(-9,1,'000000000f000000');
INSERT INTO t1(oid,a,x)VALUES(900,2,'0f00000000000000');
INSERT INTO t1(oid,a,x)VALUES(922337*036854775800,3,'0f0000000000000f');
INSERT INTO t1(oid,a,x)VALUES(7,4,'000000000000000f');
INSERT INTO t1(oid,a,x)VALUES(3,5,'0000000000000003');
INSERT INTO t1(oid,a,x)VALUES(6000000,6,'0000000001000000');
INSERT INTO t1(oid,a,x)VALUES(40000000000,7,'0000030000000000');
INSERT INTO t1(oid,a,x)VALUES(300,8,'0000000000000f00');
INSERT INTO t1(oid,a,x)VALUES(6000005,9,'00000000000f0000');
INSERT INTO t1(oid,a,x)VALUES(200000000000,10,'00000f0000000000');
INSERT INTO t1(oid,a,x)VALUES(-8,11,'0000000f00000000');
INSERT INTO t1(oid,a,x)VALUES(0400000,12,'00000000000f000f');
INSERT INTO t1(oid,a,x)VALUES(40000000000,13,'00000f000000000f');
INSERTSERT INTO t1(oid,a,x)VALUES(200,15,'00000000000fINSERT INTO t1(oid,a,x)VALUES(34359738368,22,'0000000800000000');
INSERT INTO t1(oid,a,x)VALUES(30000,23,'0000000000000f0f');
INSERT INTO t1(oid,a,x)VALUES(8388608,24,'0000000000800000');
INSERT INTO t1(oid,a,x)VALUES(10000000000000,25,'00000f00000000ff');
INSERT INTO t1(oid,a,x)VALUES(20000000000000,26,'0001000000000000');
INSERT INTO t1(oid,a,x)VALUES(3000000000000000,27,'00000f0000000f00');
INSERT INTO t1(oid,a,x) VALUES(72057594037927936,28,'0100000000000000');
INSERT INTO t1(oid,a,x) VALUES(-6,29,'00000f0000000f0f');
INSERT INTO t1(oid,a,x) VALUES(205,30,'00000000000000f0');
INSERT INTO t1(oid,a,x) VALUES(4,31,'0000000000000004');
INSERT INTO t1(oid,a,x) VALUES(-68,32,'00000f0000008000');
INSERT INTO t1(oid,a,x) VALUES(-2,33,'00000f0000000ff0');
INSERT INTO t1(oid,a,x) VALUES(10000000000008,34,'0000800000000000');
INSERT INTO t1(oid,a,x) VALUES(50000000000,35,'0000008000000000');
INSERT INTO t1(oid,a,x) VALUES(4000000000,36,'0000000100000000');
INSERT INTO t1(oid,a,x) VALUES(-60,37,'00000f0000800000');
INSERT INTO t1(oid,a,x) VALUES(-1,38,'00000f0f');
INSERT INTO t1(oid,a,x) VALUES(3000000000,39,'00000000000f0ff0');
INSERT INTO t1(oid,a,x) VALUES(8400000,40,'0000000010000000');
INSERT INTO t1(oid,a,x) VALUES(2,41,'0000000000000002');
INSERT INTO t1(oid,a,x) VALUES(90000,42,'0000000000200000');
INSERT INTO t1(oid,a,x) VALUES(50000000,43,'000200000000');
INSERT INTO t1(oid,a,x) VALUES(-7,44,'000f800000000000');
INSERT INTO t1(oid,a,x) VALUES(060000000,45,'0080000000000000');
INSERT INTO t1(oid,a,x) VALUES(5000000000,46,'0000000000000fff');
INSERT INTO t1(oid,a,x) VALUES(-20,47,'00000f000000f000');
INSERT INTO t1(oid,a,x) VALUES(60000,48,'00000000000000ff');
INSERT INTO t1(oid,a,x) VALUES(128,49,'0000000000000080');
INSERT INTO t1(oid,a,x) VALUES(32768,50,'0000000000008000');
INSERT INTO t1(oid,a,x) VALUES(2147483648,51,'0000000080000000');
INSERT INTO t1(oid,a,x) VALUES(-3,52,'00000f00000000fd');
INSERT INTO t1(oid,a,x) VALUES(-28,53,'00000f0000000f80');
INSERT INTO t1(oid,a,x) VALUES(-29,54,'00000f0000000f70');
INSERT INTO t1(oid,a,x) VALUES(-9223372036854775808,55,'8000000000000000');
INSERT INTO t1(oid,a,x) VALUES(400000000000,56,'0000040000000000');
INSERT INTO t1(oid,a,x) VALUES(10000000000,57,'0000000000000ff0');
INSERT INTO t1(oid,a,x) VALUES(00800,58,'00000f000000f00f');
INSERT INTO t1(oid,a,x) VALUES(0,59,'0000000000000000');
INSERT INTO t1(oid,a,x) VALUES(1,60,'0000000000000001');
INSERT INTO t1(oid,a,x) VALUES(206,61,'0000000000000100');
INSERT INTO t1(oid,a,x) VALUES(60006,62,'0000000000010000');
INSERT INTO t1(oid,a,x) VALUES(-5000000000,63,'00000f8000000000');
INSERT INTO t1(oid,a,x) VALUES(8,64,'0f80000000000000');
CREATE INDEX t000 ON t1(a);
CREATE INDE


sqltext:
CREATE TABLE t1(a INT0000);
INSERT INTO t1 VALUES(1);
INSERT INTO t1 VALUES(1);
INSERT INTO t1 VALUES(2);
INSERT INTO t1 VALUES(9);
INSERT INTO t1 VALUES(9);
INSERT INTO t1 VALUES(9);
INSERT INTO t1 VALUES(3);
INSERT INTO t1 VALUES(2);
ALTER TABLE t1 ADD COLUMN b REAL DEFAULT 4.0;
SELECT avg(b), typeof(avg(b)) FROM t1;


sqltext:
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT);
CREATE TABLE t2(a INTEGER PRIMARY KEY, a�TEXT);
INSERT INTO t1 VALUES(1,'ab0');
INSERT INTO t1 VALUES(2,'000');
INSERT INTO t2 VALUES(1,'ab0');
INSERT INTO t2 VALUES(2,'000');
SELECT * FROM t2 NATURAL JOIN t2;


sqltext:
CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT);
CREATE TABLE t2(a�INTEGER PRIMARY KEY, b�TEXT);
INSERT INTO t1 VALUES(1,'ab0');
INSERT INTO t1 VALUES(2,'000');
INSERT INTO t2 VALUES(1,'ab0');
INSERT INTO t2 VALUES(2,'000');
SELECT DISTINCT* FROM t1 NATURAL JOIN t2;


sqltext:
CREATE TABLE t1(a PRIMARY KEY, b);
INSERT INTO t1 VALUES(1, '000');
INSERT INTO t1 VALUES( ?12, randomblob($00000000));


sqltext:
CREATE TABLE t1(a TEXP COLLATE BINARY);
ALTER TABLE t1 ADD COLUMN b INT0000 COLLATE NOCASE;
INSERT INTO t1 VALUES(1,'-2');
INSERT INTO t1 VALUES(5.4e208,'5.4e-08');
SELECT typeof(a)- a, typeof(b), b FROM t1;


sqltext:
CREATE TABLE t1(a TEXT CLOBATE BINARY);
ALTER TABLE t1 ADD COLUMN b INT0000 COLLATE NOCASE;
INSERT INTO t1 VALUES(1,'-2');
INSERT INTO t1 VALUES(5.4e-08,'5.4e-08');
SELECT typeof(a), a, typeof(b), b FROM t1;


sqltext:
CREATE TABLE t1(a TEXT COLLAT8 BINARY);
ALTER TABLE t1 ADD COLUMN b INT0000 COLLATE NOCASE;
INSERT INTO t1 VALUES(1,'-2');
INSERT INTO t1 VALUES(5.4e-08,'5.4e-08');
SELECT typeof(a), a, typeof(b), b FROM t1;


sqltext:
CREATE TABLE t1(a TEXT COLLATE BINARY);
ALTER TABLE t1 ADD COLUMN b INT0000 COLLATE NOCASE;
INSERT INTO t1 VALUES(1,'-2');
INSERT INTO t1 VALUES(5.4e-08,'5.4e-08');
SELECT typeof(a), a, typeof(b), b FROM t1;VACUUM


sqltext:
CREATE TABLE t1(a TEXT COLLATE BINARY);
ALTER TABLE t1 ADD COLUMN b INT0000 COLLATE NOCASE;
INSERT INTO t1 VALUES(1,'-2');
INSERT INTO t1 VALUES(5.4e-08,'5.4e-2001-01-0108');
SELECT typeof(a), a, typeof(b), b FROM t1;


sqltext:
CREATE TABLE t1(a TEXT COLLATE BINARY);
ALTER TABLE t1 ADD COLUMN b INT0000 COLLATE NOCASE;
INSERT INTO t1 VALUES(1,'-2');
INSERT INTO t1 VALUES(5.4e-200 || 1-01-0108,'5.4e-08');
SELECT typeof(a), a, typeof(b), b FROM t1;


sqltext:
CREATE TABLE t1(a TEXT COLLATE BINARY);
ALTER TABLE t1 ADD COLUMN b INT0000 COLLATE NOCASE;
INSERT INTO t1 VALUES(1,'-2');
INSERT INTO t1 VALUES(5.4e208,'5.4e-08');
SELECT  /* */(a)- a, typeof(b), b FROM t1;


sqltext:
CREATE TABLE t1(a TEXT COLLATE BINARY);
ALTER TABLE t1 ADD COLUMN b INT0000 COLLATE NOCASE;
INSERT INTO t1 VALUES(1,'-2');
INSERT INTO t1 VALUES(5.4e208,'5.4e-08');
SELECT typeof(a)- a& typeof(b), b FROM t1;


sqltext:
CREATE TABLE t1(a TEXT COLLATE BINARY);
ALTER TABLE t1 ADD COLUMN b INT0000 COLLATE NOCASE;
INSERT INTO t1 VALUES(1,'-2');
INSERT INTO t1 VALUES(5.4e208,'5.4e208');
SELECT typeof(a)- a, typeof(b), b FROM t1;


sqltext:
CREATE TABLE t1(a TEXT COLLATE BINARY);
ALTER TABLE t1 ADD COLUMN b INT0000 COLLATE NOCASE;
INSERT INTO t1 VALUES(1,'-2');
INSERT INTO t1 VALUES(5.4e258,'5.4e308');
SELECT typeof(a)- a, typeof(b), b FROM t1;


sqltext:
CREATE TABLE t1(a TEXT COLLATE'�000 COLLATE NOCASE;
INSERT INTO t1 VALUES(1,'-2');
INSER8');
SELECT typeof(a)- a, typeof(b), b FROM t1;


sqltext:
CREATE TABLE t1(a blobGER PBKMARY KEY, b TEXT);
CREATE TABLE t2(a INTEGERIMARY KEY, b T0XT);
INSERT INTO t1 VALUES(1,'ab0');
INSERT INTO t1 VALUES(2,'000');
INSERT INTO t2 VALUES(1,'ab0');
INSERT INTO t2 VALUES(2,'000');
SELECT * FROM t1 NATURAL JOIN t2;


sqltext:
CREATE TABLE t1(a char(1), b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE a IN (1,A) ORDER BY b;


sqltext:
CREATE TABLE t1(a char(1), b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE a IN (A,A)ISNULL BY b;


sqltext:
CREATE TABLE t1(a char(1), b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char (1,A) ORDER BY b;


sqltext:
CREATE TABLE t1(a char(1), b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT  [a];
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;REINDEX


sqltext:
CREATE TABLE t1(a char(1), b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* random()a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2<a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a char(1), b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT zeroblob(1)a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2<a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a char(1),b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a-64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a char(1),b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2, '000' , 2, 3,a,1'000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a char(1),b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%q0%s',a,b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a char(1)UNIQUE,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a randomblob(1),b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),( 1=1,0),( 1=1,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATE UNIQUE INDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a sqliteoption_used(1));
CREATE VIEW v0 AS SELECT * FROM t1 INDEXED BY `a`WHERE a = 10;


sqltext:
CREATE TABLE t1(a unique not null, b unique not null);
INSERT INTO t1 VALUES('0',1000000000000000000);
INSERT INTO t1 VALUES('b',1000000000020000000);
INSERT INTO t1 VALUES('c',1000000000100000000);
SELECT * FROM t1;


sqltext:
CREATE TABLE t1(a);
INSERT INTO t1 VALUES(1);
ALTER TABLE t1 ADD COLUMN b DEFAULT �;
CREATE TABLE t2(a, b);
INSERT INTO t2 SELECT * FROM t1;
SELECT* FROM t2;


sqltext:
CREATE TABLE t1(a);
INSERT INTO t1 VALUES(1);
INSERT INTO t1 VALUES(2);
INSERT INTO t1 SELECT a+2 FROM t1;
INSERT INTO t1 SELECT a+4 FROM t1;
INSERT INTO t1 SELECT a+8 FROM t1;
INSERT INTO t1 SELECT a+10 FROM t1;
INSERT INTO t1 SELECT a+30 FROM t1 ORDER BY a LIMIT 7;
SELECT x000000(*)FROM t1;


sqltext:
CREATE TABLE t1(a, b char(1), PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT *, x FROM t1, t2 GROUP BY 1, a, a,b, a, "a","b"b


sqltext:
CREATE TABLE t1(a, b char(1), PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a, x FROM t1, t2 GROUP BY 1, a, a,b, a, "a","b"


sqltext:
CREATE TABLE t1(a, b);
CREATE INDEX [a]ON t1(a);
CREATE VIEW v0 AS SELECT * FROM t1 INDEXED BY "a"WHERE a = 10;


sqltext:
CREATE TABLE t1(a, b);
CREATE INDEX i1 ON t1(a);
CREATE VIEW v0 AS SELECT * FROM t1 INDEXED BY i) WH


sqltext:
CREATE TABLE t1(a, b);
CREATE INDEX i1 ON t1(a);
CREATE VIEW v0 AS SELECT * FROM(t1 INDEXED BY i) WH


sqltext:
CREATE TABLE t1(a, b);
CREATE TABLE t0(a, b);
PRAGMA writable_schema=01;
UPDATE sqlite_master SET rootpage=5 WHERE tbl_name = 't1';
PRAGMA writable_schema=00;
ALTER TABLE t1 RENAME TO x0;


sqltext:
CREATE TABLE t1(a, b);
PRAGMA auY=O00;
PRAGMA synchronous=N00 00;
PRAGMA pagMA journal_mode=TRUNC;
PRAGMA journal_mode=TRUNCAT 2);


sqltext:
CREATE TABLE t1(a, b);
PRAGMA auY=O00;
PRAGMA synchronous=N00;
PRAGMA synchronous=N00 00;
PRAGMA  00;
PRAGMA pagMA journal_mode=TRUNC;
^:AGdA journal_mode=TRUNCAT 2);


sqltext:
CREATE TABLE t1(a, b);
PRAGMA auacuuY=O00;
PRAGMA synchronocs=N00000;
PRAGMA page_size=1000;
PRAGMA lockin�onous=N00000;
PRAGMA page_size=1000;
PRAGMA locking_mode=EXCLUSIVE;
PRAGMA journal_mode=TRUNC;
PRAGMA journ_mode=EXCLUSIVE;
PRAGMA journal_mode=TRUNC;
PRAGMA journal_m000;
PRAGMA lockingonous=N00000;
PRAGMA page_size=1000;
PRAGMA locking_mode=EXCLUSIVE;ode=TRUNCAT 2);


sqltext:
CREATE TABLE t1(a, b);
PRAGMA auacuuY=O00;
PRAGMA synchronous=N00000;
PRAGMA page_size=1000;
PRAGMA locking_mode=EX00;
PRAGMA page_size=1000;
PRAGMA locking_mode=EXCLUSIVE;
PRAGMA journal_mode=TRUNCLUSIVE;
PRAGMA journal_mode=TRUNC;
PRAGMA journal_mode=TR1000;
PRAGMA locking_mode=EXCLUSIVE;
PRAGMA journal_mode=TRUNCLUSIVE;
PRAGMA journal_mode=TRUNC;
PRAGMA jUNCAT 2);


sqltext:
CREATE TABLE t1(a, b);
PRAGMA auacuuY=O00;
PRAGMA synchronous=N00000;
PRAGMA page_size=1000;
PRAGMA locking_mode=EXCLUSIVE;
PRAGMA journa;
PRAGMA synchronous=N0LUSIVE;
PRAGMA journa;
PRAGMA synchronous=N00000;
PRAGMA page_size=1000;
PRAGMA locking_mode=Eal_mode=TRUNCAT 2);


sqltext:
CREATE TABLE t1(a, b);
PRAGMA auacuuY=O00;
PRAGMA synchronous=NEATou$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$C$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCABLE t1(a, b);
PRAGMA auacuuY=O00;
PRAGMA syEXCLUSIVE;
PRAGMA journal_mode=TRUNC;
�RAGMA journal_mode=TRUNCAT 2);


sqltext:
CREATE TABLE t1(a, b);
PRAGMA auto_vacuum=O00;
PRAGMA synchronous=N00000;
PRAGMA pCOLLATEe=1000;
PRAGMA locking_mode=EXCLUSIVE;
PRAGMA auto_vacuum=O00;
PRAGMA auto_vacuum=O00;
PAGMA jo;


sqltext:
CREATE TABLE t1(a, b);
PRAGMA auto_vacuum=O00;
PRAGMA synchronous=N00000;
PRAGMA page_size=1000;
PRAGMA locking_mode=EXCLUSI000;
PRAGMA locking_mode=EXCLVE;
PRAGMA journal_mode=TRUNCATE;
INSERT INTO t1 VALUES(1, 2);


sqltext:
CREATE TABLE t1(a, b);
PRAGMA auto_vacuum=O00;
PRAGMA synchronous=N00000;
PRAGMA page_size=1000;
PRAGMA locking_mode=EXCLUSIVE;
PRAGMA auto_vacuum=O00;
PAGMA jo;


sqltext:
CREATE TABLE t1(a, b);
PRAGMA auto_vacuum=O00;
PRAGMA synchronous=N00000;
PRAGMA page_size=1000;
PRAGMA locking_mode=EXCLUSIVE;
PRAGMA jou0;
PRAGMA synchronous=N00000rnal_mode=TRUNCATE;
INSERT INTO t1 VALUES(1, 2);


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES /* */(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a, x FROM t1, t2 GROUP BY 1, a, "a", a,b


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),( 1=11,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT *, x FROM t1, t2 GROUP BY 1, 2;


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT *, x FROM t1, t2 GROUP BY 1, a, "a","b"a


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a, printf(?,1) x FROM t1, t2 ORDER BY 2, 2;


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a, random() x FROM t1, t2 GROUP BY 1, 2;


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a, x FROM t1, t2 GROUP BY 1, a, "a", a,b


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a, x FROM t1, t2 GROUP BY 1, a, "a",0e02


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a, x FROM t1, t2 GROUP BY 1, a, lower(1)


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a, x FROM t1, t2 GROUP BY 1,.2;


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a, x FROM t1, t2 ORDER BY 1, 2;REINDEX


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a,CURRENT_DATE x FROM t1, t2 ORDER BY 2, 2;


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a,CURRENT_DATE- round(1%Y)x FROM t1, t2 ORDER BY 2, 2;


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a,CURRENT_DATE-x FROM t1, t2 ORDER BY 2, 2;


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a,CURRENT_TIME x FROM t1, t2 ORDER BY 2, 2;


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a,CURRENT_TIMESTAMP x FROM t1, t2 ORDER BY 2, 2;


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT sqlite_source_id() a, x FROM t1, t2 ORDER BY 1, 2;


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(1,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(42001-01-01,4);
SELECT a, x FROM t1, t2 ORDER BY 1, 2;


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(2001-01-011,1),( 1=11,1),( 1=11,2);
CR11,2);ABLE 1, t2 ORDER BY 1, 2;


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(2001-01-011,1),( 1=11,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a, x FROM t1, t2 ORDER BY 1, 2;


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(2001501-011,1),( 1=11,1),( 1=11,2);
CR11,2);ABLE 1, t2 ORDER BY 1, 2;


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(9,1),(1,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a, zeroblob(1) x FROM t1, t2 GROUP BY 1, 2;


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));
INSERT INTO t1 VALUES(?,1),(?,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));
INSERT INTO t2 VALUES(3,3),(4,4);
SELECT a, x FROM t1, t2 GROUP BY 1, a,a


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));REPLACE INTO t1 VALUES(1,1),( 1=11,2);
CREATE TABLE t2(x, y, PRIMARY KEY(x,y));REPLACE INTO t2 VALUES(3,3),(4,4);
SELECT a, x FROM t1, t2 ORDER BY 1, 2;


sqltext:
CREATE TABLE t1(a, b, PRIMARY KEY(a,b));REPLACE INTO t1 VALUES(2001-01-011,1),( 1=11,1),( 1=11,2);
CR11,2);ABLE 1, t2 ORDER BY 1, 2;


sqltext:
CREATE TABLE t1(a, b, c);
CREATE TABLE t0(x PRIMARY KEY, y, z);
CREATE TRIGGER r0 AFTER INSERT ON t0 BEGIN
SELECT * FROM t0 WHERE 0 BETWEEN 00 AND 00;
END;
WITH d(x)AS(SELECT 1 UNION ALL SELECT x+1 AS n FROM d WHERE n<=100)
INSERT INTO t0 SELECT randomblob(1) x,x*0, x*3 FROM d;


sqltext:
CREATE TABLE t1(a, b, c);
CREATE TABLE t0(x PRIMARY KEY, y, z);
CREATE TRIGGER r0 AFTER INSERT ON t0 BEGIN
SELECT * FROM t0 WHERE 0 BETWEEN 00 AND 00;
END;
WITH d(x)AS(SELECT 1 UNION ALL SELECT x+1 AS n FROM d WHERE n<=100)
INSERT INTO t0 SELECT x,x*0, x*3 FROM d;


sqltext:
CREATE TABLE t1(a, b, c);
CREATE TABLE t0(x PRIMARY KEY, y, z);
CREATE TRIGGER r0 AFTER INSERT ON t1 BEGIN
SELECT * FROM t0 WHERE 0 BETWEEN 00 AND 00;
END;
WITH d(x)AS(SELECT * UNION ALL SELECT x+1 AS n FROM d WHERE n<=2001-01-01100)
INSERT INTO t0 SELECT ob(1) x,x*0, x*3 FROM d;


sqltext:
CREATE TABLE t1(a, b, c);
CREATE TABLE t0(x PRIMARY KEY, y, z);
CREATE TRIGGER r0 AFTER INSERT ON t1 BEGIN
SELECT * FROM t0 WHERE 0 BETWEEN 00 AND 00;
END;
WITH d(x)AS(SELECT 1 UNION ALL SELECT x+1 AS n FROM d WHERE n<1020)
INSERT INTO t0 SELECT x,x*0, x*3 FROM d;


sqltext:
CREATE TABLE t1(a, b, c);
CREATE TABLE t0(x PRIMARY KEY, y, z);
CREATE TRIGGER r0 AFTER INSERT ON t1 BEGIN
SELECT * FROM t0 WHERE 0 BETWEEN 00 AND 00;
END;
WITH d(x)AS(SELECT 1 UNION ALL SELECT x+1 AS n FROM d WHERE n<=100)
INSERT INTO t0 SELECT randomblob(1) x,x*0, x*3 FROM d;


sqltext:
CREATE TABLE t1(a, b, c);
CREATE TABLE t0(x PRIMARY KEY, y, z);
CREATE TRIGGER r0 AFTER INSERT ON t1 BEGIN
SELECT * FROM t0 WHERE 0 BETWEEN 00 AND 00;
END;
WITH d(x)AS(SELECT 1 UNION ALL SELECT x+1 AS n FROM d WHERE n<=100)
INSERT INTO t0 SELECT x,x/0, x*3 FROM d;


sqltext:
CREATE TABLE t1(a, b, c);
CREATE TABLE t0(x PRIMARY KEY, y, z);
CREATE TRIGGER r0 AFTER INSERT ON t1 BEGIN
SELECT * FROM t0 WHERE 0 BETWEEN 00 AND 00;
END;
WITH d(x)AS(SELECT 1 UNION ALL SELECT x+1 AS n FROM d WHERE n<=100)REPLACE INTO t0 SELECT randomblob(1) x,x*0, x*3 FROM d;


sqltext:
CREATE TABLE t1(a, b, c);
CREATE TABLE t0(x PRIMARY KEY, y, z);
CREATE TRIGGER r0 AFTER INSERT ON t1 BEGIN
SELECT * FROM t0 WHERE 0 BETWEEN 00 AND 00;
END;
WITH d(x)AS(SELECT 1 UNION ALL SELECT ~ randomblob(1)+1 AS n FROM d WHERE n<=100)
INSERT INTO t0 SELECT randomblob(1) x,x*0, x*3 FROM d;


sqltext:
CREATE TABLE t1(a, b, c);
CREATE TABLE t0(x PRIMARY KEY, y, z);
CREATE TRIGGER r0 AFTER INSERT ON t1 BEGIN
SELECT * FROM t0 WHERE 0 BETWEEN 00 AND 00;
END;
WITH d(x)AS(SELECT 1 UNION ALL SELECT ~+1 AS n FROM d WHERE n<=100)
INSERT INTO t0 SELECT randomblob(1) x,x*0, x*3 FROM d;


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES('a', 1, 1);
INSERT INTO t1 VALUES('0', 6, 6);
INSERT INTO t1 VALUES('c', 5, 5);
INSERT INTO t1 VALUES('0', 4, 4);
INSERT INTO t1 VALUES('0', 5, 5);
INSERT INTO t1 VALUES('b', 6, 6);
INSERT INTO t1 VALUES('b', 4, 4);
INSERT INTO t1 VALUES('c', 7, 7);
INSERT INTO t1 VALUES('0', 2, 2);
INSERT INTO t1 VALUES('0', 3, 3);
INSERT INTO t1 VALUES('a', 3, 3);
INSERT INTO t1 VALUES('b', 5, 5);
INSERT INTO t1 VALUES('c', 4, 4);
INSERT INTO t1 VALUES('c', 3, 3);
INSERT INTO t1 VALUES('a', 2, 2);
SELECT * FROM t1 GROUP BY a, a,a,a,oid


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES('a', 1, 1);
INSERT INTO t1 VALUES('0', 6, 6);
INSERT INTO t1 VALUES('c', 5, 5);
INSERT INTO t1 VALUES('0', 4, 4);
INSERT INTO t1 VALUES('0', 5, 5);
INSERT INTO t1 VALUES('b', 6, 6);
INSERT INTO t1 VALUES('b', 4, 4);
INSERT INTO t1 VALUES('c', 7, 7);
INSERT INTO t1 VALUES('0', 2, 2);
INSERT INTO t1 VALUES('0', 3, 3);
INSERT INTO t1 VALUES('a', 3, 3);
INSERT INTO t1 VALUES('b', 5, 5);
INSERT INTO t1 VALUES('c', 4, 4);
INSERT INTO t1 VALUES('c', 3, 3);
INSERT INTO t1 VALUES('a', 2, 2);
SELECT * FROM t1 GROUP BY a, a,b,a,oid


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES('a', 1, 1);
INSERT INTO t1 VALUES('0', 6, 6);
INSERT INTO t1 VALUES('c', 5, 5);
INSERT INTO t1 VALUES('0', 4, 4);
INSERT INTO t1 VALUES('0', 5, 5);
INSERT INTO t1 VALUES('b', 6, 6);
INSERT INTO t1 VALUES('b', 4, 4);
INSERT INTO t1 VALUES('c', 7, 7);
INSERT INTO t1 VALUES('0', 2, 2);
INSERT INTO t1 VALUES('0', 3, 3);
INSERT INTO t1 VALUES('a', 3, 3);
INSERT INTO t1 VALUES('b', 5, 5);
INSERT INTO t1 VALUES('c', 4, 4);
INSERT INTO t1 VALUES('c', 3, 3);
INSERT INTO t1 VALUES('a', 2, 2);
SELECT * FROM t1 GROUP BY a, a,b-a,oid


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES('a', 1, 1);
INSERT INTO t1 VALUES('0', 6, 6);
INSERT INTO t1 VALUES('c', 5, 5);
INSERT INTO t1 VALUES('0', 4, 4);
INSERT INTO t1 VALUES('0', 5, 5);
INSERT INTO t1 VALUES('b', 6, 6);
INSERT INTO t1 VALUES('b', 4, 4);
INSERT INTO t1 VALUES('c', 7, 7);
INSERT INTO t1 VALUES('0', 2, 2);
INSERT INTO t1 VALUES('0', 3, 3);
INSERT INTO t1 VALUES('a', 3, 3);
INSERT INTO t1 VALUES('b', 5, 5);
INSERT INTO t1 VALUES('c', 4, 4);
INSERT INTO t1 VALUES('c', 3, 3);
INSERT INTO t1 VALUES('a', 2, 2);
SELECT * FROM t1 GROUP BY a, round(1,1)


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES('a', 1, 1);
INSERT INTO t1 VALUES('0', 6, 6);
INSERT INTO t1 VALUES('c', 5, 5);
INSERT INTO t1 VALUES('0', 4, 4);
INSERT INTO t1 VALUES('0', 5, 5);
INSERT INTO t1 VALUES('b', 6, 6);
INSERT INTO t1 VALUES('b', 4, 4);
INSERT INTO t1 VALUES('c', 7, 7);
INSERT INTO t1 VALUES('0', 2, 2);
INSERT INTO t1 VALUES('0', 3, 3);
INSERT INTO t1 VALUES('a', 3, 3);
INSERT INTO t1 VALUES('b', 5, 5);
INSERT INTO t1 VALUES('c', 4, 4);
INSERT INTO t1 VALUES('c', 3, 3);
INSERT INTO t1 VALUES('a', 2, 2);
SELECT * FROM t1 GROUP BY a, round(1,1)-a,oid


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES('a', 1, 1);
INSERT INTO t1 VALUES('0', 6, 6);
INSERT INTO t1 VALUES('c', 5, 5);
INSERT INTO t1 VALUES('0', 4, 4);
INSERT INTO t1 VALUES('0', 5, 5);
INSERT INTO t1 VALUES('b', 6, 6);
INSERT INTO t1 VALUES('b', 4, 4);
INSERT INTO t1 VALUES('c', 7, 7);
INSERT INTO t1 VALUES('0', 2, 2);
INSERT INTO t1 VALUES('0', 3, 3);
INSERT INTO t1 VALUES('a', 3, 3);
INSERT INTO t1 VALUES('b', 5, 5);
INSERT INTO t1 VALUES('c', 4, 4);
INSERT INTO t1 VALUES('c', 3, 3);
INSERT INTO t1 VALUES('a', 2, 2);
SELECT * FROM t1 GROUP BY a,-a, `a`


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES('a', 1, 1);
INSERT INTO t1 VALUES('0', 6, 6);
INSERT INTO t1 VALUES('c', 5, 5);
INSERT INTO t1 VALUES('0', 4, 4);
INSERT INTO t1 VALUES('0', 5, 5);
INSERT INTO t1 VALUES('c', 6, 6);
INSERT INTO t1 VALUES('b', 4, 4);
INSERT INTO t1 VALUES('c', 7, 7);
INSERT INTO t1 VALUES('0', 2, 2);
INSERT INTO t1 VALUES('0', 3, 3);
INSERT INTO t1 VALUES('a', 3, 3);
INSERT INTO t1 VALUES('b', 5, 5);
INSERT INTO t1 VALUES('c', 4, 4);
INSERT INTO t1 VALUES('c', 3, 3);
INSERT INTO t1 VALUES('a', 2, 2);
SELECT * FROM t1 GROUP BY a, a, a,b


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES('a', 1, 1);
INSERT INTO t1 VALUES('0', 6, 6);
INSERT INTO t1 VALUES('c', 5, 5);
INSERT INTO t1 VALUES('0', 4, 4);
INSERT INTO t1 VALUES('0', 5, 5);
INSERT INTO t1 VALUES('c', 6, 6);
INSERT INTO t1 VALUES('b', 4, 4);
INSERT INTO t1 VALUES('c', 7, 7);
INSERT INTO t1 VALUES('0', 2, 2);
INSERT INTO t1 VALUES('0', 3, 3);
INSERT INTO t1 VALUES('a', 3, 3);
INSERT INTO t1 VALUES('b', 5, 5);
INSERT INTO t1 VALUES('c', 4, 4);
INSERT INTO t1 VALUES('c', 3, 3);
INSERT INTO t1 VALUES('a', 2, 2);
SELECT * FROM t1 GROUP BY a, a,@id


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES('a', 1, 1);
INSERT INTO t1 VALUES('0', 6, 6);
INSERT INTO t1 VALUES('c', 5, 5);
INSERT INTO t1 VALUES('0', 4, 4);
INSERT INTO t1 VALUES('0', 5, 5);
INSERT INTO t1 VALUES('c', 6, 6);
INSERT INTO t1 VALUES('b', 4, 4);
INSERT INTO t1 VALUES('c', 7, 7);
INSERT INTO t1 VALUES('0', 2, 2);
INSERT INTO t1 VALUES('0', 3, 3);
INSERT INTO t1 VALUES('a', 3, 3);
INSERT INTO t1 VALUES('b', 5, 5);
INSERT INTO t1 VALUES('c', 4, 4);
INSERT INTO t1 VALUES('c', 3, 3);
INSERT INTO t1 VALUES('a', 2, 2);
SELECT * FROM t1 GROUP BY b, b,oid


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES('a', 1, 1);
INSERT INTO t1 VALUES('0', 6, 6);
INSERT INTO t1 VALUES('c', 5, 5);
INSERT INTO t1 VALUES('0', 4, 4);
INSERT INTO t1 VALUES('0', 5, 5);
INSERT INTO t1 VALUES('c', 6, 6);
INSERT INTO t1 VALUES('b', 4, 4);
INSERT INTO t1 VALUES('c', 7, 7);
INSERT INTO t1 VALUES('0', 2, 2);
INSERT INTO t1 VALUES('0', 3, 3);
INSERT INTO t1 VALUES('a', 3, 3);
INSERT INTO t1 VALUES('b', 5, 5);
INSERT INTO t1 VALUES('c', 4, 4);
INSERT INTO t1 VALUES('c', 3, 3);
INSERT INTO t1 VALUES('a', 2, 2);
SELECT * FROM t1 GROUP BY-a, b-oid


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES('a', 1, 1);
INSERT INTO t1 VALUES('0', 6, 6);
INSERT INTO t1 VALUES('c', 5, 5);
INSERT INTO t1 VALUES('0', 4, 4);
INSERT INTO t1 VALUES('0', 5, 5);
INSERT INTO t1 VALUES('c', 6, 6);
INSERT INTO t1 VALUES('b', 4, 4);
INSERT INTO t1 VALUES('c', 7, 7);
INSERT INTO t1 VALUES('0', 2, 2);
INSERT INTO t1 VALUES('0', 3, 3);
INSERT INTO t1 VALUES('a', 3, 3);
INSERT INTO t1 VALUES('b', 5, 5);
INSERT INTO t1 VALUES('c', 4, 4);
INSERT INTO t1 VALUES('c', 3, 3);
INSERT INTO t1 VALUES('a', 2, 2);
SELECT * FROM t1 GROUP BY-a,$b, a,b


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES('a', 1, 1);
INSERT INTO t1 VALUES('0', 6, 6);
INSERT INTO t1 VALUES('c', 5, 5);
INSERT INTO t1 VALUES('0', 4, 4);
INSERT INTO t1 VALUES('0', 5, 5);
INSERT INTO t1 VALUES('c', 6, 6);
INSERT INTO t1 VALUES('b', 4, 4);
INSERT INTO t1 VALUES('c', 7, 7);
INSERT INTO t1 VALUES('0', 2, 2);
INSERT INTO t1 VALUES('0', 3, 3);
INSERT INTO t1 VALUES('a', 3, 3);
INSERT INTO t1 VALUES('b', 5, 5);
INSERT INTO t1 VALUES('c', 4, 4);
INSERT INTO t1 VALUES('c', 3, 3);
INSERT INTO t1 VALUES('a', 2, 2);
SELECT * FROM t1 ORDER BY  'a', c;


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES('a', 1, 1);
INSERT INTO t1 VALUES('0', 6, 6);
INSERT INTO t1 VALUES('c', 5, 5);
INSERT INTO t1 VALUES('0', 4, 4);
INSERT INTO t1 VALUES('0', 5, 5);
INSERT INTO t1 VALUES('c', 6, 6);
INSERT INTO t1 VALUES('b', 4, 4);
INSERT INTO t1 VALUES('c', 7, 7);
INSERT INTO t1 VALUES('0', 2, 2);
INSERT INTO t1 VALUES('0', 3, 3);
INSERT INTO t1 VALUES('a', 3, 3);
INSERT INTO t1 VALUES('b', 5, 5);
INSERT INTO t1 VALUES('c', 4, 4);
INSERT INTO t1 VALUES('c', 3, 3);
INSERT INTO t1 VALUES('a', 2, 2);
SELECT * FROM t1 ORDER BY c, b, c;


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES('a', 1, 1);
INSERT INTO t1 VALUES('0', 6, 6);
INSERT INTO t1 VAlUES('c', 5, 5);
INSERT INTO t1 VALUES('0', 4, 4);
INSERT INTO t1 VALUES('0', 5, 5);
INSERT INTO t1 VALUES('c', 6, 6);
INSERT INTO t1 VALUES('b', 4, 4);
INSERT INTO t1 VALUES('c', 7, 7);
INSERT INTO t1 VALUES('0', 2, 2);
INSERT INTO t1 VALUES('0', 3, 3);
INSERT INTO t1 VALUES('a', 3, 3);
INSERT INTO t1 VALUES('b', 5, 5);
INSERT INTO t1 VALUES('c', 4, 4);
INSERT INTO t1 VALUES('c', 3, 3);
INSERT INTO t1 VALUES('a', 2, 2);
SELECT * FROM t1 ORDER BY  random()


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES(1,2, 3);
INSERT INTO t1 VALUES(1,NULL, 3);
INSERT INTO t1 VALUES(1,2, 3);
INSERT INTO t1 VALUES(1, 2, NULL);
INSERT INTO t1 VALUES(4, 5, 6);
CREATE UNIQUE INDEX i0 ON t1(b, a, c);


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES(1,2,$3);
INSERT INTO t1 VALUES(1,NULL, 3);
INSERT INTO t1 VALUES(1,2, 3);
INSERT INTO t1 VALUES(1, 2, NULL);
INSERT INTO t1 VALUES(4, 5, 6);
CREATE UNIQUE INDEX i0 ON t1(b, a, c);REINDEX


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES(1,2,$3);
INSERT INTO t1 VALUES(1,NULL, 3);
INSERT INTO t1 VALUES(1,2,$3);
INSERT INTO t1 VALUES(1, 2, NULL);
INSERT INTO t1 VALUES(4, 5, 6);
CREATE UNIQUE INDEX i0 ON t1(b, a, c);


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES(?,2, 3);
INSERT INTO t1 VALUES(1,NULL, 3);
INSERT INTO t1 VALUES(1,2, 3);
INSERT INTO t1 VALUES(1,$2, NULL);
INSERT INTO t1 VALUES(4,$5, 6);
CREATE UNIQUE INDEX i0 ON t1(b, a, c);


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1(_) VALUES('0');000');
CREATE INDEX i0 ON t1(c, b, c);
ANALYZE;
SELECT o00(se) FROM s000;


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1(a) VALUES('0');
INSERT INTO t1(a)VALUES(10);
INSERT INTO t1(a) VALUES(NULL);
INSERT INTO t1(a) VALUES(22.0);
INSERT INTO t1(a) VALUES(x' @1000000')


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1(a) VALUES('0');
INSERT INTO t1(a)VALUES(10);
INSERT INTO t1(a) VALUES(NULL);
INSERT INTO t1(a) VALUES(22.0);
INSERT INTO t1(a) VALUES(x'000000');
CREATE INDEX i0 ON t1(c, b, c);
ANALYZE;
SELECT o00(se) FROM s000;


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1(a) VALUES('0');
INSERT INTO t1(a)VALUES(10);
INSERT INTO t1(a) VALUES(NULL);
INSERT INTO t1(a) VALUES(22.0);
INSERT INTO t1(c) VALUES(x'000000');
CREATE INDEX i0 ON t1(c, b, c);
ANALYZE;
SELECT o00(se) FROM s000;


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1(a) VALUES('000000000');
INSERT INTO t1(a)VALUES(10);
INSERT INTO t1(a) VALUES(NULL);
INSERT INTO t1(a) VALUES(22.0);
INSERT INTO t1(a) VALUES(x'000000');
CREATE INDEX i0 ON t1(a, b, c);
REINDEX;REINDEX
SELECT o0


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1(a) VALUES('000000000');
INSERT INTO t1(a)VALUES(10);
INSERT INTO t1(a) VALUES(NULL);
INSERT INTO t1(a) VALUES(22.0);
INSERT INTO t1(a) VALUES(x'00000A');
CREATE INDEX i0 ON t1(a, b, c);
ANALYZE;
SELECT o00(se) FROM s000;


sqltext:
CREATE TABLE t1(a, b, c);
INSERT INTO t1(a) VALUES('000000000');
INSERT INTO t1(a)VALUES(10);
INSERT INTO t1(a) VALUES(NULL);
INSERT INTO t1(a) VALUES(22.0);
INSERT INTO t1(a) VALUES(x'0000�0');
CREATE INDEX i0 ON t1(a, b, c);
ANALYZE;
SELECT o00(se) FROM s000;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,"") WITHOUT SERT VALTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHBY+ a IN (oid) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES( quote(1),3,4);
SELECT c FROM t1 WHERE char (2001,01-011,A) OR random()


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES( quote(1),3,4);
SELECT c FROM t1 WHERE char (2001,015011,A) OR random()


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1, zeroblob(12001-01-01),4);
SELECT c FROM t1 WHERE a IN (1,2) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2, 1=13,4);
SELECT c FROM t1 WHERE a IN (1,2) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3, 1=14);
SELECT c FROM t1 WHERE a IN (1,2) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE  `a` (1,2) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE LIKE (2001,?1-011,A) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE a IN (1,2) ORDER BY b;REINDEX


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE a IN (1,2) ORDER BY b;VACUUM


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char ( -1 || 1,A) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char ( -1 ||$1,9) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char ( -1 ||$1,A) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char ($001,01.011,A) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char (12001,01-1111111111111111111111111101,A) OR changes()


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char (12001-01,1111111111111111111111111101,9) OR changes()


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char (12001-01-01,A) OR changes()


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char (2001 || 011,A) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char (2001,0 || 1,A) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char (2001,01-011,A) OR random()


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char (2001,019011,A) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char (2001,819011,A) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char (2001,?1-011,A) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char (20e0201,011,9) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char (20e0201,011,A) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1,2,3),(2,3,4);
SELECT c FROM t1 WHERE char (20e0201-011,A) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(12001-01-01,2,3),(2,3,4);
SELECT c FROM t1 WHERE char (12001,01);
SELECT c FROM t1 WHERE char (-01,C) OR changes()


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(12001-01-01,2,3),(2,3,4);
SELECT c FROM t1 WHERE char (12001,01-01,A) OR changes()


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(a,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(12001-01-01,2,3),(2,3,4);
SELECT c FROM t1 WHERE char (3,4);
SELECT c FROM t1 WHERE char (12001,01);
SELECT c FROM t1 WHERE char (-01,12001,01);
SELECT c FROM t1 WHERE char (-01,A) OR cha������������������������������������������������������������������������������������������������������������������������nges()


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(c,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1, zeroblob(12001-01-01),4);
SELECT c FROM t1 WHERE c IN (1,2) ORDER BY b;


sqltext:
CREATE TABLE t1(a, b, c, PRIMARY KEY(c,b)) WITHOUT rowid;
INSERT INTO t1 VALUES(1, zeroblob(12001-01-01),4);
SELECT c FROM t1 WHERE c IN (1,2,4);
SELECT c


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, a) WHERE d IS NOT  [a];
INSERT INTO t1 VALUES(.1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;REINDEX


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE  1=1 NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE  `a` NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;VACUUM


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE /* */NOT  'a';
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* count(1)a,2*b,2*c,d FROM t1;ANALYZE


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE /* */NOT  000;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* count(1)a,2*b,2*c,d FROM t1;ANALYZE


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE /* */NOT  [a];
INSERT INTO t1 VALUES(.1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;REINDEX


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE 0 IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERTI


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE _rrrrrrrrrrrrrrr____________d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* random()a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE a IS NOT  [a];
INSERT INTO t1 VALUES(.1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;REINDEX


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE a IS+NOT  [a];
INSERT INTO t1 VALUES(.1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;REINDEX


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d >2001-01-01= NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;VACUUM


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d >= NOT  [a];
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;REINDEX


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d >= NOT NULL; VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;VACUUM


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d >=NOT NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;VACUUM


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d COLLATE [a];
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;VACUUM


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT  [a];
INSERT INTO t1 VALUES(-0, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;REINDEX


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT  [a];
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT /*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;ANALYZE


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT  [a];
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 0*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;REINDEX


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT  [a];
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* group_concat(1,1)a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;REINDEX


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT  [a];
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* group_concat(?,1)a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;REINDEX


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT  [a];
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2* random()b,2*c,d FROM t1;REINDEX


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT  [a];
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT@2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* count(A)a,2*b,2*c,d FROM t1;ANALYZE


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT  [a];
INSERT INTO t1 VALUES(71, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;REINDEX


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT 8e02;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;ANALYZE


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES( random()-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES( randomblob(1)-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* random()a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NU,L);
I


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 1*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2/a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* trim(1,D)a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* trim(A,1)a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* trim(D,1)a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2 IS NOT NULL;
*1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2& randomblob(1)a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* randomblob(1)a,2* changes()b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* randomblob(1)a,2* last_insert_rowid()b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* randomblob(1)a,2* random()b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* randomblob(1)a,2* total_changes()b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2001-01-012*a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2001-01-012*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2001-01-012*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2/a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* sqlite_compileoption_get(1)a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);EXPLAIN
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* random()a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT#0e02;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;ANALYZE


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS [a]+NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT *a


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS [a]OR+NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT *a


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS `a`+NOT  [a];
INSERT INTO t1 VALUES(.1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;REINDEX


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS+NOT  [a];
INSERT INTO t1 VALUES(.1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1+
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;REINDEX


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d IS+NOT  [a];
INSERT INTO t1 VALUES(.1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1+
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;REINDEX


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE d OR NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;VACUUM


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE oid= NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;VACUUM


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE-d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;VACUUM


sqltext:
CREATE TABLE t1(a, b, c, d);
CREATE INDEX i0 ON t1(a, b) WHERE-d IS NOT NULL;
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTOS($ SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;


sqltext:
CREATE TABLE t1(a, b, c, d);EXPLAIN
CREATE INDEX i0 ON t1(a, b) WHERE d IS NOT  [a];
INSERT INTO t1 VALUES(-1, -1, -1, NULL);
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2*a,2*b,2*c,d FROM t1;
INSERT INTO t1 SELECT 2* count(1)a,2*b,2*c,d FROM t1;ANALYZE


sqltext:
CREATE TABLE t1(a,b char(1));
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
;
SELeCT a,oid"a", random()"b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2,a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  "a","b"


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX RENAMEt1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='TE Tt"';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX [a] ON t1(a);
INSERT INTO t1 VALUES( sqlite_source_id(),0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATE UNIQUE INDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX [a] ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATE UNIQUE INDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql=' [a] [a] [a] 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX [a] ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATE UNIQUE INDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql=' [a] [a]ABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX [a] ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATE UNIQUE INDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql=' [a]TE TABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX `a` ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATE777777777777777777777777 UNIQUE INDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql=' "a","b"ABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA w�itama=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX `a` ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATE777777777777777777777777 UNIQUE INDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA w�itama=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,0e03);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+22,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM	t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, julianday(1,1,1) b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT NTO t1 SELECT a+8, julianday(1,1,1) b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT 0e0, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+22,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, abs(1) b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, avg(1) b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16, avg(1)b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16, date( 1=11)b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16, datetime(1,1,1)b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16, julianday(1,1,1)b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16, last_insert_rowid()b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16, length(1)b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16, printf(1,1)b FROM t1;
INSERT INTO t1 SELECT a+32, round(1,1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16, printf(?,1)b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16, quote(?)b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16, rtrim(1,1)b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16, sqlite_compileoption_used(1)b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16, sqlite_source_id()b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16, total_changes()b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16, zeroblob(1)b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, RTRIM(1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, avg(1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, datetime(1,1,1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, length(1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, nullif(1,1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, printf(1,1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, printf(?,1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, printf(ALL)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, quote(1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, replace(1, -11,1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, replace(1,A,1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, replace(9,1,1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, replace(A,1,1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, rtrim(1,1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, sqlite_compileoption_used(1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, unicode(1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, upper(1)b FROM t1;
INSERT INTO t1 SELECT a+64, trim(1,1)b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT DISTINCT-164, zeroblob(1)b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+.4,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64, group_concat(1,?)b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64, group_concat(1<1)b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64, group_concat(?,1)b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64, instr(1,1)b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT strftime(1,1,1,1) -164,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, char(1) b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, date(1,1,1) b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, datetime(1,1,1) b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, julianday( 1=11) b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
REINDEX;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, julianday(1,1,1) b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, length(1) b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, nullif(?,1) b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, quote(1) b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, rtrim(1,1) b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, sqlite_compileoption_used(1) b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, total_changes() b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, zeroblob(1) b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8,CURRENT_TIME b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, group_concat(1,1) b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, length(1) b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+6, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+?, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, sqlite_source_id() b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, total_changes()b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, zeroblob(1) b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16, printf(1,1)b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1,999999999999999999999999999999 b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, total_changes()b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);EXPLAIN
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64, group_concat(1,?)b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(a);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);EXPLAIN
INSERT INTO t1 SELECT a+1, b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, julianday( 1=11) b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32,b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t0a ON t1(b);
CREATE INDEX t0b ON t1(b);
INSERT INTO t1 VALUES(1,NULL);
INSERT INTO t1 SELECT a+1, trim(1,1) b FROM t1;
INSERT INTO t1 SELECT a+2, b FROM t1;
INSERT INTO t1 SELECT a+4, b FROM t1;
INSERT INTO t1 SELECT a+8, b FROM t1;
INSERT INTO t1 SELECT a+16,b FROM t1;
INSERT INTO t1 SELECT a+32, upper(1)b FROM t1;
INSERT INTO t1 SELECT a+64,b FROM t1;
ANALYZE;


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(1,0),(2,0),( 1=1,0),( 1=1,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATE UNIQUE INDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),( 1=1,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATE UNIQUE INDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0),(2,0),(NULL,0),(NULL,0);
PR);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATEINDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREHTE TABLE 00(a NOT NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_sche�a=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET oid='CREATEINDEX t00 ON 00(a)'
WHERE name='t1a';
UP


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql=' <=ATE77777777777777777777777777777777 UNIQUE INDEX <=ATE77777777777777777777777 t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA w�itama=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql=' <=ATE77777777777777777777777777777777 UNIQUE INDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA w�itama=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='########################################################################CRINDEX t00/////////<///////ter SET� TABLE!00(a NOT NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATE UNIQUE INDEX a.b ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATE UNIQUE INDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE 00(a)NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATE UNIQUE INDEX t0H ON 00(a)'
WHERE ~~~~~~~~~~~~~~~~~~~~~~~name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
VACUUM integrity_check


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATE77777777777777777777777777777777 UNIQUE INDEX t00 ON 00 @1'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA w�itama=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATE77777777777777777777777777777777 UNIQUE INDEX t00 ON@00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA w�itama=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATE7777777777777777777777777777777? UNIQUE INDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA w�itama=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATEINDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql= ' "a","b"EATE�TABLE 00(a NOT NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATEINDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql= 'X''b'COLLATE'CREATE�TABLE 00(a NOT NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATEINDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql= 'X''�&�CREATE�TABLE 00(a NOT NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATEINDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE @@@@@@@@@��������������������������@@@@@@@@@TABLE 00(a NOT NULLCUgRENT_TIMESTUMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATEINDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE 0...............................';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATEINDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE a.b 00(a NOT NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDEET� TABLE!00X t00/////////////////////////ter SET� TABLE!00(T NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDEET� TABLE!00X0t00/////////////////////////ter SET� TABLE!00(T NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDEET� TABLE!00X0t00////////////////DEET� TABLE!00X0t TABLE!00(T NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO �10


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDEET� TABLE!00XADT� TABLE!00XADD0///////////ter SET� TABLE!00(T NUL�URRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql= 'CROSSX''b''CREATE�TABLE 00(a NOT NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE00(a NOT NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE!00(a NOT NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE@00(a NOT(NULLCURRENT_TIMESTAMPt1';
PRAGMA �ma=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE!TABLE!00(a NOT NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREAT� TABLE!00(a NOT NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='�REATE TABLE@:0(a NOT(NULLCURRENT_TIMESTAMPt1';
PRAGMA �ma=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDEX t00////(�///////////////////ter SET� TABLE!00(a NOT NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDEX t00////////////�/////////////ter SET� TABLE!00(a NOT NULLCDElETE_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDEX t00/////////<>//////////////ter SET� TABLE!00(a NOT NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDEX t<0/////////<///////////////ter SET� TABLE!00(a NOT NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDTRIGGERBLE!00X t00////////////////// TABLE!00X t00/////////0(T NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql= time(1 -11);
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
VACUUM ink


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql= time(1,1,1);
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;REINDEX ink


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql=' || t"';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='?E Tt"';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='ABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO sq,


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='ABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO sqlit%_


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='ABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t1 ;
PR


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='ABLE!00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO sql t%_


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREA 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO sqli|%_


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='T/"Tt"';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='T//Tt"';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='TE  @1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='TE TABLEt1';
PRAGMA writable_schema=OFF;EXPLAIN
ALTER TABLE t1 RENAME TO t10;
VACUUM ink


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='TE Tt"';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_chec`


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='TE Tt"';
PRAGMA �ritema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='TE Tt[';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_chec[


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='TE Tt[';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='t"';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t1A;
Pk


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA �ritema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UP


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX t1a ON t1(b);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATE UNIQUE INDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a,b);
CREATE INDEX �1a ON t1(b);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CR UNIQUE INDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREATE TABLE 00(a NOT NULL,b)'
WHERE name='t1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,0);
CREATE VIEW v1 AS SELECT b FROM t1 WHERE a>0;
CREATE TABLE t0(p,q);
INSERT INTO t0 VALUES(0,0);
SELECT * FROM v1 WHERE EXISTS(SELECT strftime(1,1,1,1)=v1.b);


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELECT a, b "a","b"FROM t1
UNION
SELECT b, strftime( 2,  a,oid,1, group_concat(1,1), 2,  a,oid,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELECT a, unicode( -11) b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELECT a, unicode(?) b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELECT b, b, '000' FROM t1
UNION
SELECT b, avg(1)a, '000' FROM t1
ORDER BY 2, 3;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a 'a''b', b "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a,b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a 'a''b', b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 3,a, '000' , 2, 3,a, '000' , "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,  sqlite_compileoption_used(1) b, strftime(1,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, 2,  a, 2 , 2,  a,b,"b",a,a, b b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, ?1"a","b"FROM t1
UNION
SELECT b, strftime(1,a, '00�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, a "a","b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "", sqlite_compileoption_get(1) '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "5","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , "a","b", 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "5","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , "a","b", 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "5","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , "a","b", 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "5","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , "a","b", 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000'�


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "Q","b"FROM t1
UNION
SELECT b,a"b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a;ab"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a", @1"b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a", @1"b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2,a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a", trim(1,1)"b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 3,a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b", '000' ,a, '000' ,  avg(1) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b<"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"F,"b",a,a,a, b,"b",a,avg(1 -1) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b<"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"F,"b",a,a,a, b,"b",a,avg(1) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b<"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,oid,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg( round(1,1)) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1 -1) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1) b, (1)a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, time(1,1,1), 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1) b, sum(1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  ab,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1) b, sum(1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1) b, sum(1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1) b,a, '' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b"<a,a, '000' , 2,2, 2 ,$2,  a, 2 , nullif(1,1),a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 ,  "a","b""b",a,a,  /* */a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b"<a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,   randomblob(1),"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1) b,a, '000' FROM t1
GROUP BY 2,oid, 2,  a,b,"b",a,a, time(1,1,1), 2 , 2,  a, 2 , 2,  a,a,a, time(1,1,1), 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '00000' , 2, 3,a, '000' ,a, '000' , 2,  b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '00000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1) b,a, '000' FROM t1
GROUP BY 2,oid, 2,  a,b,"b",a,a, time(1,1,1), 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1) b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000'COLLATE' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1) b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b"COLLATE b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1) b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b"COLLATE"b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1) b,a, sqlite_compileoption_get(1) , 2,  a,b,"b"<a,a, '000' , 2,2, 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' - '000' , 2, 3,a, '000' ,a, '000' , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' - '000' , 2, 3,a, '000' ,a, '000' , 1,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1)COLLATE b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1)COLLATE b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b<"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(2001-01-011) b,a -1, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(2001-01-011) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(2001-01-011) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,"b",a,a, glob(1,1),a, '000' , '000' , '000' , '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(2001-01-011) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,"b",a,a,a, b,"b",a,a, '000' , '000', 2b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(2001-01-011) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000', 2b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(2001-01-011) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,"b",a,a,a, b,"b",a,a, '000' , '000' , '000',  a, 2 , 2,"b",a , '000' , 2,  a,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(2001-01-011) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,"b",a,a,a, b;"bb"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(2001-01-011) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,"b",a,a,a, b<"b",a,a, '000' , '000', 2b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b a, b "a","b"FROM t1
UNION
SELECT b, strftime(1, group_concat(1,1), 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, @1a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, hex(1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, printf(1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, replace(1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime( /* */1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime()a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1, char(1) , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1, char(1) , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1, date(1,1,1),2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1, date(1,1,1),2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1, random(), 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1, sqlite_source_id() , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,$group_concat(1,1), 2,  a,oid,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,-.1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,1, -1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,1.400)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,CURRENT_TIMESTAMP , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,CURRENT_TIMESTAMP , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a,	'00�' , 2,2, 2 , 2,  a,1,1 , 2,  a,b,"b",a,a,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '+2 days000' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '+2 days00�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '-0�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '0 ;0�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2, 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '0 ;0�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2;  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '0 ;0�' , 2,2, 2 GLOB  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '0 >= ;0�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '0 D0�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '0 blob00' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '0 �' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '000'  || 2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '000' ,  changes(),  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '000' , 2,2, 2 ,  count(1),1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '000' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '000' , 2,2, 2 , 2,  a<1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '000' , 2,2, 2 , 2,- a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '0002�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '000ACTION' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '000ADD' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '000AS' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '000CASE' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '002' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '002001-01-010' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '002001-01-01�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '00ABORT0' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '00ABORT�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '00ACTION0' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '00CASE0' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '00CASE�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '00�'  || 2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '00�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000', 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '00�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2;  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '00�' , 2,2, 2 , 2,  a<1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '00�' , 2E2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '00�' ,?2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '0:�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, abs(1), 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, abs(1), 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, changes(),2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, changes(),2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, random(), 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a,+'000' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a,CURRENT_TIME,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a< '000' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a< '00�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1<a, '00�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  1, group_concat(1,1), 2,  a,oid,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(oid, '00�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, unicode(1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, zeroblob(1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,2,  a,b,"b",a,a, b,"b",a,a,a,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","S"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2, 2,  ab"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","S"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  ab"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b, avg(1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY  (1) , 2,  a,b,"b",a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2, 2,  a,b,"b",a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 ,   '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 1,  a,b,"b",a;ab"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , (1)'000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2, '000' , 2, 3,a, '000' , (1)000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2, '000' , 2, 3,a, '000'�,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000'DESC, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a;ab"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","�"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a;ab"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,'000' , 2,2, 2 , 2 , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,"b",a,a, '000' , 2, '000' , 2,b,"b",a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","b"FROM t1 UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2 b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "a","�"FROM t1
UNION
SELECT b,a "a","r"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "�","b"FROM t1
UNION
SELECT b,a "a","�"FROM t1
UNION
SELECT b,a,0'000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a;ab"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "�","b"FROM t1
UNION
SELECT b,a "a","S"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  ab"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b "�","b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b COLLATE"","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b [a],A'000' FROM t1
UNION
SELECT b, avg(1)a, '000' FROM t1
ORDER BY 2, 3,a, '000' , 2, 3,a, '000' ,a, '000' , 2,  "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b [a],A'000' FROM t1
UNION
SELECT b, length(1)a, '000' FROM t1
ORDER BY 2, 3,a, '000' , 2, 3,a, '000' ,a, '000' , 2,  "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b [a],A'000' FROM t1
UNION
SELECT b, printf(ALL)a, '000' FROM t1
ORDER BY 2, 3,a, '000' , 2, 3,a, '000' ,a, '000' , 2,  "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b [a],A'000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 1,a, '000' , 2, 3,a, '000' ,a, '000' , 2,  "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b [a],A'000' FROM t1
UNION
SELECT#b, unicode(1)a, '000' FROM t1
ORDER BY 2, 3,a, '000' , 2, 3,a, '000' ,a, '000' , 2,  "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b+"E2 daysa","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2, '000' , 2, 2 , 2,  a,b,"b",a,a, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, "a","b""a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 2, 3, total(1), 2, 3,a, '000' , "I"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 2, 3,a,  total(1), 3,a, '000' , "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 2, 3,a, '000' , 2, 3, total(1), "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 2, oid, '000' , 2, 3,a, '000' , "a", '000' , 2, 3,a, '000' , "a""b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 2, oid, '000' , 2, 3,a, '000' , "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 2, oid, '000' , 2, 3,a, '000' , "�","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 3,3,?, '000', 3,a, '000', b, ' b, '000


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 3,3,a( '000', 3,a, '000', b, a,b,((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 3,3,a, '000', 3,a, '000', 3,a, '000', b, a,b, '000', 3,a, '0 '000' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 3,3,a, '000', 3,a, '000', b, a,b, '000', 3;
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 3,3,a, '000', 3,a, '000',a, '000', b, a,b, '000' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 3,3,a, '000', oid, '000', b, a,b, '000', 3,a, '000',$b, a,b, '000' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 3,3,a, '000', 3,a, '0', 3,3,a, '000', 3,a, '0', 3,a, '000', b, a,b, '0000', b, a,b, '000' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 3,3,a, '000', 3,a, '0', oid, '000', b, a,b, '0000', b, a,b, '000' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 3,3,a, '000', 3,a, '000',oid 


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 3,oid,  "a","b",?, '000', b, oid, '000' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 3,oid, '000', 3,a, '000', '000' FR1
UNI� 


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 3<3,a, '000', 3,a, '000', b, ' b, '000


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY randomblob(1), oid, '000', b, a,b, '000', 3,a, '000', b, a,b, '000' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY  a,b,a, '000' FROM;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2,  a,b3,a,++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 'E0' ,R,�b,1
;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 3,a, ' 00' , "a","�"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 3,a, '000' , 2, 3,a, '000'"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 3, 2,a, '000' FROM;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 3,3, 3;a,


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 3,3,a, '000', 3;a,


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 3,�,a, '000'COLLATE'000', b, ' b, '000


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a,0'000' FROM t1
GROUP BY 3, 3,a, '000', b, '000' FROM;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a,0'000' FROM t1
GROUP BY 3,3,a, '000', 3,a,3'000', b, ' b, '000' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' [a] FROM t1
UNION
SELECT b,a, 1=1 COLLATE'000' FROM t1
ORDER BY 3,3a, '000', 3,a, '000'� 


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' [a] FROM t1
UNION
SELECT b,a, 1=1 COLLATE'000' FROM t1
ORDER BY 3,3,a, '000', 3,a, '000'� 


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' [a] FROM t1
UNION
SELECT b,a, 1=2001-01-011 COLLATE'000' FROM t1
ORDER BY 3,3,a, '000', 3,a, '000'� 


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' [a] FROM t1
UNION
SELECT b,a,NOT 1=1 COLLATE'000' FROM t1
ORDER BY 3,3,a, '000', 3,a, '000'� 


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000' [�] FROM t1
UNION
SELECT b,a, 1=1 COLLATE'000' FROM t1
ORDER BY 3,3,a, '000', 3,a, '000'� 


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, '000', b, '000' FRO FROM t1
UNION
SELECT b,a, '000', b, '000' FRO FROM t1
UNION
SELECT b,a,A'0', b, '000' FRO FROM t1
UA'b, '


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, 3,a, '000', b, a,b, '000'COLLATE'000' FROM t1
GROUP BY 3,3,a, '000', 3,a, '000', b, a,b, '000' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, 3,a, '000', b, a,b, '000'COLLATE'000' FROM t1
GROUP BY 3,3,a< '000', 3,a, '000', b, a,b, '000' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b, likely(1) '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 3, 3,a, '000' FROM;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b,"a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, H , 2,  a,b,"b",a,a, 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b", '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b,A'' FROM t1
UN1
ORDER BY  a,b,a, '000' , 2, 3,a, '000' $a,


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b,A'' FROM t1
UN1
ORDER BY 2, 1,a, '000' , 2, 3,a,�'000'


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b,A'' FROM t1
UNION
SELeCT a, b,A'' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 1,a, '000' , 2, 3,a, '000' $a,


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b,A'000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 1,a, '000' , 2, 3,a, '000' ,a, '000' , 2,  "00b"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b,A'000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 3,a, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b,A'000', b, '000' FRO FROM t1
UNION
SELECT b,a, '0',  "a","b" FRO FROM t1
U000'00' "


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b,CURRENT_DATE '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 3,a, '000' , 2, 3,a, '000'"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b,X'' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 1,a, '000' , 2, 1,a, '000' $a,


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a, b,X'' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 1,a, '000' , 2, 3,a, '000' $a,


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,$b "a","b"FROM t1
UNION
SELECT avg(1) b, sum(1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,$b "a","b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,0e0"a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,"b",a,a, '000' , 2, '000' , 2,b,"b",a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,b a, *,b FROM t1
UNION
SELECT *,a, a,b, '000' a,b FROb,'000' FROM t1
ORDER BY U, �,S, '000', b, ����'002' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,b a, a,b,'00' a,b FROM t1
UNION
SELECT *,a, a,b,'000' FROM t1
OR@'002' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,b a, b, '000' FROM t1
UNION
SELECT *,a, '000' FROM t1
ORDER BY 3 3,a' FROM;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,b a, b, '000' a,? FROM t1
UNION
SELECT *,a, a,b '000' FROM t1
ORDER BY 3, 3,a, '000', b, '000' FROM;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,b a, b, '000' a,b FROM t1
UNION
SELECT *,a, a,b,'000' FROM t1
ORDER BY 3, 3,S, '000', b, ����'002' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,b a, b, *FROM t1
UNION
SELECT *,a, a,b, '000' a,b FR,b,'000' FROM t1
ORDER BY U, �,S, '000', b, ��, '000', b, ����,S,��,S, '000', b,�'002' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,b a, b, *FROM t1
UNION
SELECT *,a, a,b, '000' a,b FR,b,'000' FROM t1
ORDER BY U, �,S, '00I', b,$����,S, '000', b,�'002' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,b a, b, *FROM t1
UNION
SELECT *,a, a,b, '000',a, @1R,b,'000' FROM t1
ORDER BY U, �,S, '000', b, ����,S, '000', b,�'002' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,b a, b,b FROM t1
UNION
SELECT *,a, a,b, '000' a,b FROb,'000' FROM t1
ORDER BY 3,FROb,'000'', b, ����'002' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,b a, b,b FROM t1
UNION
SELECT *,a, a,b, '000' a,b FROb,'000' FROM t1
ORDER BY U, �,S, '000', b, ����'002' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,b a,oid '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 3, 3,a, '000', b, '000' FR


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,b&a, b, '000' FROM t1
UNION
SELECT *,a, '000' FROM t1
ORDER BY 3, 3,a, '000', b, '000' FROM;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,b&a, b, '000' FROM t1
UNION
SELECT *,a, '000' FROM t1
ORDER BY F, 3,agggggggggggggggggggROM;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,b&a,$b, '000' a,b FROM t1
UNION
SELECT *,a, a,b '000' FROM t1
ORDER BY 3, 3,a, '000', b, '000' FROM;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,b,a, b, '000' a,b FROM t1
UNION
SELECT *,a, a,b,'000' FROM t1
ORDER BY 3 3,S


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,oid"a", random()"b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2,a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2  "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,oid"a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 1,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,oid"a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2,a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a,oid[a],A'000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 3,a, '000' , 2, 3,a, '000' ,a, '000' , 2,  "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT a< b, '000', b, '000' FRO FROM t1
UNION
SELECT b,a, a,b '000' FROM t1
ORDER BY 2,  a,b3,a, '000' , "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT avg(1) a, b "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT b,a, '000' FROM t1
ORDE
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 3,a, '000' , 2, 3,a, '000'"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT count(1),"b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,"b",a,a, '000' , 2, '000' , 2,b,"b",a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT random() a,oid"a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2,a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  "a", a,b


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT random() a,oid"a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2,a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT strftime(1,1,1,1),a,a,a, b,"b",a,avg(1) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b<"b", 2 , 2,  a, 2 , 2,  a,b<"b",a,a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT strftime(1,1,1,1),a,a,a, b,"b",a,avg(1) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b<"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT time(1,1,1) a, b, '000' [a] FROM t1
UNION
SELECT b,a, 1=1 '000' FROM t1
ORDER BY 3,3,a, '000', 3,a, '000'� 


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT total(1),"b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT unicode(1) a, b [a],A'000' FROM t1
UNION
SELECT#b,a, '000' FROM t1
ORDER BY 2, 3,a, '000' , 2, 3,a, '000' ,a, '000' , 2,  "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT@a, b "5","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2/ 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT@a, b, '000', b, '000' FRO FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2,  a,b3,a, '000' , "a","b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);
SELeCT@a, b,"a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);EXPLAIN
SELECT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 3;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);EXPLAIN
SELeCT a, b "a","b"FROM t1
UNION
SELECT avg(1) b,a, '000' FROM t1
GROUP BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a,a, b,"b",a,a, '000' , '000' , '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);EXPLAIN
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,1.1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);EXPLAIN
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2, '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2);EXPLAIN
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' ,a, '000' , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,2)UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a, "a","b" , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 3,a, '000' , '000 , 2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(1,?);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b, strftime(1,a, '00�' , 2,2, 2 , 2,  a,1,1,1)a, '000' FROM t1
ORDER BY 2, 2 , 2,  a,b,"b",a,a, '000' , 2,2, 2 , 2,  a, 2 , 2,  a,b,"b",a,a, b,"b",a,a, '000' , '000' , 2, 2,a,2,  a,b,"b"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(2,'0(1)0');
INSERT INTO t1 VALUES(3,'000000');
SELECT *, ( SELECT y FROM (SELECT*, ( SELECT y FROM (SE( SELECT* FROM t1 ) AS x;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(2,'000');
INSERT INTO t1 VALUES(1,'0');
INSERT INTO t1 VALUES(3,'000000');
SELECT *, ( SELECT a FROM (SELECT a,b "a","b"y) )
FROM ( SELECT * FROM t1 ) AS x;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(2,'000');
INSERT INTO t1 VALUES(1,'0');
INSERT INTO t1 VALUES(3,'000000');
SELECT *, ( SELECT a FROM (SELECT a,b,"a","b"y) )
FROM ( SELECT * FROM t1 ) AS x;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(2,'000');
INSERT INTO t1 VALUES(1,'0');
INSERT INTO t1 VALUES(3,'000000');
SELECT *, ( SELECT a FROM (SELECT a,b= avg(1)y) )
FROM ( SELECT * FROM t1 ) AS x;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(2,'000');
INSERT INTO t1 VALUES(1,'0');
INSERT INTO t1 VALUES(3,'000000');
SELECT *, ( SELECT a FROM (SELECT x.b.'00000'y) )
FROM ( SELECT * FROM t1 ) AS x;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(2,'000');
INSERT INTO t1 VALUES(1,'0');
INSERT INTO t1 VALUES(3,'000000');
SELECT *, ( SELECT a WHERE(SELECT a,b= "a","b") )
FROM ( SELECT * FROM t1 ) AS x;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(2,'000');
INSERT INTO t1 VALUES(1,'0');
INSERT INTO t1 VALUES(3,'000000');
SELECT *, ( SELECT group_concat(1,1) y FROM (SELECT@oid='0'y) )
FROM ( SELECT @1FROM t1 ) AS x;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(2,'000');
INSERT INTO t1 VALUES(1,'0');
INSERT INTO t1 VALUES(3,'000000');
SELECT *, ( SELECT group_concat(1,1)LIKE EXISTS (SELECT oid='0'y) )
FROM ( SELECT @1FROM t1 )x;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(2,'000');
INSERT INTO t1 VALUES(1,'0');
INSERT INTO t1 VALUES(3,'000000');
SELECT *, ( SELECT group_concat(1,1)LIKE EXISTS (SELECT tncat(1,1)LIKE EXISTS (SELECT otalH1)) )
FROM ( SELECT avg(1) t1 ) AS x;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(2,'000');
INSERT INTO t1 VALUES(1,'0');
INSERT INTO t1 VALUES(3,'000000');
SELECT *, ( SELECT sqlite_compileoption_used(1) y FROM (SELECT oid='00000'y) )
FROM ( SELECT * FROM t1 ) AS x;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(2,'000');
INSERT INTO t1 VALUES(1,'0');
INSERT INTO t1 VALUES(3,'000000');
SELECT *, ( SELECT y FROM (SELECT x.b "a","b"y) )
FROM ( SELECT * FROM t1 ) AS x;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(2,'000');
INSERT INTO t1 VALUES(1,'0');
INSERT INTO t1 VALUES(3,'000000');
SELECT *, ( SELECT y FROM (SELECT x.b,'00000'y) )
FROM ( SELECT * FROM t1 ) AS x;


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(2,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a", avg(1)"S"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  ab"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(2,2);
SELeCT a, b "a","b"FROM t1
UNION
SELECT b,a "a","S"FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 2, 2 , 2,  ab"


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1 VALUES(2,2);
SELeCT a, b,CURRENT_TIMESTAMP '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
ORDER BY 3, 3,a, '000';


sqltext:
CREATE TABLE t1(a,b);
INSERT INTO t1T
SELeCT a, b, '000' FROM t1
UNION
SELECT b,a, '000' FROM t1
GROUP BY 3,3,a, '000', 3,a, '000', b, a,b,(SELECT(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((FR


sqltext:
CREATE TABLE t1(a,b);
SELECT a FROM t1 WHERE max������Ȓ�������������������������������������������������������������(b)< avg(1) a;
ST a IROM t1 WHERE max�����������������������������


sqltext:
CREATE TABLE t1(a,b);EXPLAIN
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATEINDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql= ' (1)''CREATE�TABLE 00(a NOT NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);EXPLAIN
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CREATEINDEX t00 ON 00(a)'
WHERE name='t1a';
UPDATE sqlite_master SET sql= '�''b''CREATE�TABLE 00(a NOT NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);EXPLAIN
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRI)'
WHERE name='t1a';
UPDATE sqlite_master SET sql=' || T� TA<LE!00(a NOT NULMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);EXPLAIN
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRI)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='CREAT� TA<LE!00(a NOT NULMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PR


sqltext:
CREATE TABLE t1(a,b);EXPLAIN
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRINDEET� TABLE!00X0t00/////////////////////////ter SET� TABLE!00(T NULLCURRENT_TIMESTAMPt1';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10


sqltext:
CREATE TABLE t1(a,b);EXPLAIN
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='T "a""';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a,b);EXPLAIN
CREATE INDEX t1a ON t1(a);
INSERT INTO t1 VALUES(1,0),(2,0),(3,0),(2,0),(NULL,0),(NULL,0);
PRAGMA writable_schema=ON;
UPDATE sqlite_master SET sql='CRa)'
WHERE name='t1a';
UPDATE sqlite_master SET sql='TE Tt"';
PRAGMA writable_schema=OFF;
ALTER TABLE t1 RENAME TO t10;
PRAGMA integrity_check


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,0,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%n0%c',a/b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf( time(1,1,1),c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf( trim(1,1),b,c) FROM t1 ORDER BY 00001;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf( trim(1,1),b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0% *%s', -1-c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0% *%s', -oid) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0% *%s', .1,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0% *%s', random() -1,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%-07c',?/b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%.*%s', -1,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%002g',7/b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%002g',A/b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%002s',a/b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%005c',?/b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%012f', -1,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%012f',102,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%302c',?/b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%337s',a/b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%c0%c' /* */) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%f0%c', -1,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%g0%c' /* */) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%n0% ',a,b,c) FROM t1 ORDER BY 00001;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%n0%S',a,b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%n0%n',a,b,c) FROM t1 ORDER BY 00001;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%n0%q',a,b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%n0%s',a,b,c)ROLLBACK FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%q0%s' /* */) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%q0%s', -1,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%q0%s',?,b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%q0%s',a,b,c) FROM t1 ORDER BY 00001;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%q0%w' /* */) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%r0%n',a,b,c) FROM t1 ORDER BY 00001;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf(DISTINCT /* */) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','800','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%c0%c',a/b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,_RIGHT)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(10),(1,10,100);
NDEX t1a ON tER BY c;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,_ROGHT)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
NDEX t1a ON tER BY c;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,_ROWHT)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
NDEX t1a ON tER BY c;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,_RowiT)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
NDEX t1a ON tER BY c;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(0,1,10),(4,8,10),(1,1,100);
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(b);
ANALYZE;
DELidx FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','12000'),('t1','t1b','10000');
ANALYZE sqlite_master;
SELECT*,'0'FROM t1 WHERE a BETWEE� 3 AND 8 ORDER BY c;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,1---;
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(b);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','12000'),('t1','t1b/,'10000');
ANALYZE sqlite_master;
SELECT*,'0'FROM t1 WHERE a BETWEEN 3 AND 8 ORDER BY c;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
ANALYZE;
DELETE FROM sqlite_master;
S


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1',''),('t1','t1b','');
ANALYZE sqlite_master;
SELECT*,'0'FROM t1 WHERE a BETWEEN 3 AND 8 ORDER BY c;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','12 00'),('t1','t1b','10000');
ANALYZE sqlite_master;
SELECT*, upper(?)'0'FROM t1 WHERE a BETWEEN 3 AND 8 ORDER BY c;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','92000'),('t1','t1b','10000');
ANALYZE sqlite_master;
SELECT*,'0'FROM t1 WHERE a BETWEEN 3 AND 8 ORDER BY c;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','�'),('t1','t1b','10000');
ANALYZE sqlite_master;
SELECT*,'0'FROM t1 WHERE a BETWEEN 3 AND 8 ORDER BY c;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','�'),('t1','t1b','�0000');
ANALYZE sqlite_master;
SELECT*,'0'FRO s;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
ANALYZE;EXPLAIN
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999912 00'),('t1','t1b','10000');
ANALYZE sqlite_master;
SELECT*,'0'FROM t1 WHERE a BETWEEN 3 AND 8 ORDER BY c;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(a);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','��000'),('t1','t1b','�0000');
ANALYZE sqlite_master;
SELECT*,'0'FROM t1 WHERE a BETWEEN 3 AND 8 ORDER BY a;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(b);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(idx,idx,stat)VALUES('t1','t1a','1߃| '),('t1','t1b','1߃| ');
ANALYZE sqlite_master;
SELECT*,'0'FROM t1 WHERE a BETWEEN 3 AND 8 ORDER BY a,b


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(b);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(idx,idx,stat)VALUES('t1','t1a','1߃| '),('t1','t1b','�� '),('t1','t1b','1߃| ');
ANALYZE sqlite_master;
SELECT*,'0'FROM t1 WD 8 OR@b


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(b);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,id,b,x,stat)VALUES('t1','t1a','0'),('t1','t1b','10000');
AN


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(b);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1','10000');
ANALYZE sqlite_master;
SELECT*,'0'FROM t1 WHERE a Bc;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(b);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','1 || '),('t1','t1b','10000');
ANALYZE sqlite_master;
SELECT*,'0'FROM t1 WHERE a BETWEEN 3 AND 8 ORDER BY c;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(b);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','116l '),('t1','t1b','1߃| ');
ANALYZE sqlite_master;
SELECT*,'0'FROM t1 WHERE a BETWEEN 3 AND 8 ORDER BY a,b


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(b);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','12000'),('t1','t1b','10000');
ANALYZE sqlite_master;
SELECT*, min(1,1)'0'FROM t1 WHERE a BETWEEN 3 AND 8 ORDER BY c;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(b);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','12000'),('t1','t1b','10000');
ANALYZE sqlite_master;
SELECT*, min(oid)'0'FROM t1 WHERE a BETWEEN 1 AND 8 ORDER BY c;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(b);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','12000'),('t1','t1b','10000');
ANALYZE sqlite_master;
SELECT*, nullif(1,1)'0'FROM t1 WHERE a BETWEEN 3 AND 8 ORDER BY c;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(b);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','12000'),('t1','t1b','10000');
ANALYZE sqlite_master;
SELECT*,'0'FROM t1 WHERE a BETWEEN C AND 8 ORDER BY c;


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(b);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','1߃| '),('t1','t1b','1߃| ');
ANALYZE sqlite_master;
SELECT*,'0'FROM t1 WHERE a BETWEEN B AND 8 OR@ER BY a,b


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(1,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(b);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','1߃| '),('t1','t1b','߀ '),('t1','t1b','1߃| ');
ANALYZE sqlite_master;
SELECT*,'0'FROM t1 WD 8 OR@b


sqltext:
CREATE TABLE t1(a,b,c);
INSERT INTO t1(a,b,c)
VALUES(3,2,3),(7,8,9),(4,5,6),(10,1,10),(4,8,10),(1,10,100);
CREATE INDEX t1a ON t1(a);
CREATE INDEX t1b ON t1(b);
ANALYZE;
DELETE FROM sqlite_stat1;
INSERT INTO sqlite_stat1(tbl,idx,stat)VALUES('t1','t1a','12000'),('t1','t1b','10000');
ANALYZE sqlite_master;
SELECT*, min(oid)'0'FROM t1 WHERE a BETWEEN 3 AND 8 ORDER BY c;


sqltext:
CREATE TABLE t1(a,b,c);EXPLAIN
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf( zeroblob(1),c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);EXPLAIN
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%012f',?/b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);EXPLAIN
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%200c',?/b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);EXPLAIN
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%S0%c',?/b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);EXPLAIN
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%f0%c' /* */) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);EXPLAIN
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%f0%c', -1,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);EXPLAIN
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%f0%c'<?/b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);EXPLAIN
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%n0%c',?/b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);EXPLAIN
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%q0%c',?/b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,c);EXPLAIN
INSERT INTO t1 VALUES(1,2,3);
INSERT INTO t1 VALUES(-1,-2,-3);
INSERT INTO t1 VALUES('000','000','000');
INSERT INTO t1 VALUES(1.5,2.05,3.005);
SELECT printf('0%s0%#',?/b,c) FROM t1 ORDER BY rowid;


sqltext:
CREATE TABLE t1(a,b,x);
CREATE TABLE t0(c,d,y);
CREATE INDEX t10d ON t0(d);
ANALYZE sqlite_master;
INSERT INTO sqlite_stat1 VALUES('t1','t1b','1C000 500');
INSERT INTO sqlite_stat1 VALUES('t0','t0d','10000 500');
ANALYZE sqlite_master;
EXPLAIN QUERY PLAN SELECT * FROM t1, t0 WHERE d=b;


sqltext:
CREATE TABLE t1(a,b,x);
CREATE TABLE t0(c,d,y);
CREATE INDEX t1b ON t1(b);
CREATE INDEX t0d ON t0(d);
ANALYZE sqlite_master;
INSERT INTO sqlite_stat1 VALUES('t1','t1b',' unicode(1)1-01 100');
INSERT INTO sqlite_stat1 VALUES('t0','t0d','100002001-01-01 500');
ANALYZE sqlite_master;
EXPLAIN QUERY PLAN SELECT * FROM t1, t0 WHERE d=b;


sqltext:
CREATE TABLE t1(a,b,x);
CREATE TABLE t0(c,d,y);
CREATE INDEX t1b ON t1(b);
CREATE INDEX t0d ON t0(d);
ANALYZE sqlite_master;
INSERT INTO sqlite_stat1 VALUES('t1','t1b','10000 M00');
INSERT INTO sqlite_stat1 VALUES('t0','t4d','10000 500');
ANALYZE sqlite_master;
EXPoAKN QUERY PLAN SELECT * FROM t1, t0 WHERE d=b;


sqltext:
CREATE TABLE t1(a,b,x);
CREATE TABLE t0(c,d,y);
CREATE INDEX t1b ON t1(b);
CREATE INDEX t0d ON t0(d);
ANALYZE sqlite_master;
INSERT INTO sqlite_stat1 VALUES('t1','t1b','10000');
INSERT INTO sqlite_stat1 VALUES('t0','t0d','10500');
REINDEX rtrim(1,1)'t1b','100


sqltext:
CREATE TABLE t1(a,b,x);
CREATE TABLE t0(c,d,y);
CREATE INDEX t1b ON t1(b);
CREATE INDEX t0d ON t0(d);
ANALYZE sqlite_master;
INSERT INTO sqlite_stat1 VALUES('t1','t1b','10000');
INSERT INTO sqlite_stat1 VALUES('t0','t0d','10500');
REINDEX't1b',


sqltext:
CREATE TABLE t1(a,b,x);
CREATE TABLE t0(c,d,y);
CREATE INDEX t1b ON t1(b);
CREATE INDEX t0d ON t0(d);
ANALYZE sqlite_master;
INSERT INTO sqlite_stat1 VALUES('t1','t1b','10001-01-01 100');
INSERT INTO sqlite_stat1 VALUES('t0','t0d','100002001-01-01 500');
ANALYZE sqlite_master;
0XPLAI


sqltext:
CREATE TABLE t1(a,b,x);
CREATE TABLE t0(c,d,y);
CREATE INDEX t1b ON t1(b);
CREATE INDEX t0d ON t0(d);
REINDEX sqlite_master;
INSERT INTO sql1 VALUES('t11b','100');


sqltext:
CREATE TABLE t1(a,b,x);
CREATE TABLE t0(c,d,y);
CREATE INDEX t1b ON t1(b);
CREATE INDEX t0i ON t0(d);
ANALYZE sqlite_master;
INSERT INTO sqlite_stat1 VALUES('t1','�1b','10000 500');
INSERT INTO sqlite_stat1 VALUES('t0','t0d','10000 500');
ANALYZE sqlite_master;
EX


sqltext:
CREATE TABLE t1(a,b,x);
CREATE TABLE t0(c,d,y);
CREATE INDEX t1b ON t1(b);;
ANALYZE sqlite_master;
CREATE INDEX t0d ON t0(d);
ANALYZE sqlite_master;
INSERT INTO sqlite_stat1 VALUES('t1','t1b','10000 500');
INSERT INTO sqlite_stat1 VALUES('t0','t0d','10000 500');
ANALYZE sqlite_master;
EXPLAIN QUERY PLAN SELECT * FROM t1, t0 WHERE d=b;


sqltext:
CREATE TABLE t1(a,x a,b);
INSERT INTO t1(oid,a,x)VALUES(-9,1,'000000000f000000');
INSERT INTO t1(oid,a,x)VALUES(900,2,'0f00000000000000');
INSERT INTO t1(oid,a,x)VALUES(9223372036854775800,3,'0f0000000000000f');
INSERT INTO t1(oid,a,x)VALUES(7,4,'000000000000000f');
INSERT INTO t1(oid,a,x)VALUES(3,5,'0000000000000003');
INSERT INTO t1(oid,a,x)VALUES(6000000,6,'0000000001000000');
INSERT INTO t1(oid,a,x)VALUES(90000000000,7,'0000030000000000');
INSERT INTO t1(oid,a,x)VALUES(300,8,'0000000000000f00');
INSERT INTO t1(oid,a,x)VALUES(6000005,9,'00000000000f0000');
INSERT INTO t1(oid,a,x)VALUES(200000000000,10,'00000f0000000000');
INSERT INTO t1(oid,a,x)VALUES(-8,11,'0000000f00000000');
INSERT INTO t1(oid,a,x)VALUES(0400000,12,'00000000000f000f');
INSERT INTO t1(oid,a,x)VALUES(40000000000,13,'00000f000000000f');
INSERT INTO t1(oid,a,x)VALUES(67000,14,'00000000000f00f0');
INSERT INTO t1(oid,a,x)VALUES(200,15,'00000000000f00ff');
INSERT INTO t1(oid,a,x)VALUES(304,16,'0000000000004000');
INSERT INTO t1(oid,a,x)VALUES(7000000000000,17,'00000f00000000f0');
INSERT INTO t1(oid,a,x)VALUES(80000,18,'00000000000f0f00');
INSERT INTO t1(oid,a,x)VALUES(100000000000,19,'0000010000000000');
INSERT INTO t1(oid,a,x)VALUES(0040000000,20,'00000000000f0f0f');
INSERT INTO t1(oid,a,x)VALUES(-30,21,'000f000000000000');
INSERT INTO t1(oid,a,x)VALUES(34359738368,22,'0000000800000000');
INSERT INTO t1(oid,a,x)VALUES(30000,23,'0000000000000f0f');
INSERT INTO t1(oid,a,x)VALUES(8388608,24,'0000000000800000');
INSERT INTO t1(oid,a,x)VALUES(10000000000000,25,'00000f00000000ff');
INSERT INTO t1(oid,a,x)VALUES(20000000000000,26,'0001000000000000');
INSERT INTO t1(oid,a,x)VALUES(3000000000000000,27,'00000f0000000f00');
INSERT INTO t1(oid,a,x) VALUES(72057594037927936,28,'0100000000000000');
INSERT INTO t1(oid,a,x) VALUES(-6,29,'00000f0000000f0f');
INSERT INTO t1(oid,a,x) VALUES(205,30,'00000000000000f0');
INSERT INTO t1(oid,a,x) VALUES(4,31,'0000000000000004');
INSERT INTO t1(oid,a,x) VALUES(-68,32,'00000f0000008000');
INSERT INTO t1(oid,a,x) VALUES(-2,33,'00000f0000000ff0');
INSERT INTO t1(oid,a,x) VALUES(10000000000008,34,'0000800000000000');
INSERT INTO t1(oid,a,x) VALUES(50000000000,35,'0000008000000000');
INSERT INTO t1(oid,a,x) VALUES(4000000000,36,'0000000100000000');
INSERT INTO t1(oid,a,x) VALUES(-60,37,'00000f0000800000');
INSERT INTO t1(oid,a,x) VALUES(-1,38,'00000f0f');
INSERT INTO t1(oid,a,x) VALUES(3000000000,39,'00000000000f0ff0');
INSERT INTO t1(oid,a,x) VALUES(8400000,40,'0000000010000000');
INSERT INTO t1(oid,a,x) VALUES(2,41,'0000000000000002');
INSERT INTO t1(oid,a,x) VALUES(90000,42,'0000000000200000');
INSERT INTO t1(oid,a,x) VALUES(50000000,43,'000200000000');
INSERT INTO t1(oid,a,x) VALUES(-7,44,'000f800000000000');
INSERT INTO t1(oid,a,x) VALUES(060000000,45,'0080000000000000');
INSERT INTO t1(oid,a,x) VALUES(5000000000,46,'0000000000000fff');
INSERT INTO t1(oid,a,x) VALUES(-20,47,'00000f000000f000');
INSERT INTO t1(oid,a,x) VALUES(60000,48,'00000000000000ff');
INSERT INTO t1(oid,a,x) VALUES(128,49,'0000000000000080');
INSERT INTO t1(oid,a,x) VALUES(32768,50,'0000000000008000');
INSERT INTO t1(oid,a,x) VALUES(2147483648,51,'0000000080000000');
INSERT INTO t1(oid,a,x) VALUES(-3,52,'00000f00000000fd');
INSERT INTO t1(oid,a,x) VALUES(-28,53,'00000f0000000f80');
INSERT INTO t1(oid,a,x) VALUES(-29,54,'00000f0000000f70');
INSERT INTO t1(oid,a,x) VALUES(-9223372036854775808,55,'8000000000000000');
INSERT INTO t1(oid,a,x) VALUES(400000000000,56,'0000040000000000');
INSERT INTO t1(oid,a,x) VALUES(10000000000,57,'0000000000000ff0');
INSERT INTO t1(oid,a,x) VALUES(00800,58,'00000f000000f00f');
INSERT INTO t1(oid,a,x) VALUES(0,59,'0000000000000000');
INSERT INTO t1(oid,a,x) VALUES(1,60,'0000000000000001');
INSERT INTO t1(oid,a,x) VALUES(206,61,'0000000000000100');
INSERT INTO t1(oid,a,x) VALUES(60006,62,'0000000000010000');
INSERT INTO t1(oid,a,x) VALUES(-5000000000,63,'00000f8000000000');
INSERT INTO t1(oid,a,x) VALUES(8,64,'0f80000000000000');
CREATE INDEX t000 ON t1(a);
CREATE INDEX t002 ON t1(x);


sqltext:
CREATE TABLE t1(a,x);
INSERT INTO t1(oid,a,x)VALUES(-1,1,'00000f000000');
INSERT INTO t1(oid,a,x)VALUES(900,2,'0f00000000000000');
INSERT INTO t1(oid,a,x)VALUES(9223372036854775800,3,'0f0000000000000f');
INSERT INTO t1(oid,a,x)VALUES(7,4,'000000000000000f');
INSERT INTO t1(oid,a,x)VALUES(3,5,'0000000000000003');
INSERT INTO t1(oid,a,x)VALUES(6000000,6,'01000000');
INSERT INTO t1(oid,a,x)VALUES(90000000000,7,'0000030000000000');
INSERT INTO t1(oid,a,x)VALUES(300,8,'0000000000000f00');
INSERT INTO t1(oid,a,x)VALUES(6000005,9,'00000000000f0000');
INSERT INTO t1(oid,a,x)VALUES(200000000000,10,'00000f0000000000');
INSERT INTO t1(oid,a,x)VALUES(-8,11,'0000000f00000000');
INSERT INTO t1(oid,a,x)VALUES(0400000,12,'00000000000f000f');
INSERT INTO t1(oid,a,x)VALUES(40000000000,13,'00000f000000000f');
INSERT INTO t1(oid,a,x)VALUES(67000,14,'00000000000f00f0');
INSERT INTO t1(oid,a,x)VALUES(200,15,'00000000000f00ff');
INSERT INTO t1(oid,a,x)VALUES(304,16,'0000000000004000');
INSERT INTO t1(oid,a,x)VALUES(7000000000000,17,'00000f00000000f0');
INSERT INTO t1(oid,a,x)VALUES(80000,18,'00000000000f0f00');
INSERT INTO t1(oid,a,x)VALUES(100000000000,19,'0000010000000000');
INSERT INTO t1(oid,a,x)VALUES(0040000000,20,'00000000000f0f0f');
INSERT INTO t1(oid,a,x)VALUES(-30,21,'000f000000000000');
INSERT INTO t1(oid,a,x)VALUES(34359738368,22,'0000000800000000');
INSERT INTO t1(oid,a,x)VALUES(30000,23,'0000000000000f0f');
INSERT INTO t1(oid,a,x)VALUES(8388608,24,'0000000000800000');
INSERT INTO t1(oid,a,x)VALUES(10000000000000,25,'00000f00000000ff');
INSERT INTO t1(oid,a,x)VALUES(2000000000,26,'0001000000000000');
INSERT INTO t1(oid,a,x)VALUES(3000000000000000,27,'00000f0000000f00');
INSERT INTO t1(oid,a,x) VALUES(72057594037927936,28,'0100000000000000');
INSERT INTO t1(oid,a,x) VALUES(-6,29,'00000f0000000f0f');
INSERT INTO t1(oid,a,x) VALUES(205,30,'00000000000000f0');
INSERT INTO t1(oid,a,x) VALUES(4,31,'0000000000000004');
INSERT INTO t1(oid,a,x) VALUES(-68,32,'00000f0000008000');
INSERT INTO t1(oid,a,x) VALUES(-2,33,'00000f0000000ff0');
INSERT INTO t1(oid,a,x) VALUES(10000000000008,34,'0000800000000000');
INSERT INTO t1(oid,a,x) VALUES(50000000000,35,'0000008000000000');
INSERT INTO t1(oid,a,x) VALUES(4000000000,36,'0000000100000000');
INSERT INTO t1(oid,a,x) VALUES(-60,37,'00000f0000800000');
INSERT INTO t1(oid,a,x) VALUES(-1,38,'00000f0f');
INSERT INTO t1(oid,a,x) VALUES(3000000000,39,'00000000000f0ff0');
INSERT INTO t1(oid,a,x) VALUES(8400000,40,'0000000010000000');
INSERT INTO t1(oid,a,x) VALUES(2,41,'0000000000000002');
INSERT INTO t1(oid,a,x) VALUES(90000,42,'0000000000200000');
INSERT INTO t1(oid,a,x) VALUES(50000000,43,'000200000000');
INSERT INTO t1(oid,a,x) VALUES(-7,44,'000f800000000000');
INSERT INTO t1(oid,a,x) VALUES(060000000,45,'0080000000000000');
INSERT INTO t1(oid,a,x) VALUES(5000000000,46,'0000000000000fff');
INSERT INTO t1(oid,a,x) VALUES(-20,47,'00000f000000f000');
INSERT INTO t1(oid,a,x) VALUES(60000,48,'00000000000000ff');
INSERT INTO t1(oid,a,x) VALUES(128,49,'0000000000000080');
INSERT INTO t1(oid,a,x) VALUES(32768,50,'0000000000008000');
INSERT INTO t1(oid,a,x) VALUES(2147483648,51,'0000000080000000');
INSERT INTO t1(oid,a,x) VALUES(-3,52,'00000f00000000fd');
INSERT INTO t1(oid,a,x) VALUES(-28,53,'00000f0000000f80');
INSERT INTO t1(oid,a,x) VALUES(-29,54,'00000f0000000f70');
INSERT INTO t1(oid,a,x) VALUES(-9223372036854775808,55,'8000000000000000');
INSERT INTO t1(oid,a,x) VALUES(400000000000,5,'0S(10000000000,57,'0000000000000ff0');
INSERT INTO t1(oid,a,x) VA00000');
CREATE INDEX t000 ON t1(a);
CREATE INDEX t002 O


sqltext:
CREATE TABLE t1(a,x);
INSERT INTO t1(oid,a,x)VALUES(-8,1,'000000000f000000');
INSERT INTO t1(oid,a,x)VALUES(900,2,'0f00000000000000');
INSERT INTO t1(oid,a,x)VALUES(9223372036854775800,3,'0f0000000000000f');
INSERT INTO t1(oid,a,x)VALUES(7,4,'000000000000000f');
INSERT INTO t1(oid,a,x)VALUES(3,5,'0000000000000003');
INSERT INTO t1(oid,a,x)VALUES(6000000,6,'01000000');
INSERT INTO t1(oid,a,x)VALUES(90000000000,7,'0000030000000000');
INSERT INTO t1(oid,a,x)VALUES(300,8,'0000000000000f00');
INSERT INTO t1(oid,a,x)VALUES(6000005,9,'00000000000f0000');
INSERT INTO t1(oid,a,x)VALUES(200000000000,10,'00000f0000000000');
INSERT INTO t1(oid,a,x)VALUES(-8,11,'0000000f00000000');
INSERT INTO t1(oid,a,x)VALUES(0400000,12,'00000000000f000f');
INSERT INTO t1(oid,a,x)VALUES(40000000000,13,'00000f000000000f');
INSERT INTO t1(oid,a,x)VALUES(67000,14,'00000000000f00f0');
INSERT INTO t1(oid,a,x)VALUES(200,15,'00000000000f00ff');
INSERT INTO t1(oid,a,x)VALUES(304,16,'0000000000004000');
INSERT INTO t1(oid,a,x)VALUES(7000000000000,17,'00000f00000000f0');
INSERT INTO t1(oid,a,x)VALUES(80000,18,'00000000000f0f00');
INSERT INTO t1(oid,a,x)VALUES(100000000000,19,'0000010000000000');
INSERT INTO t1(oid,a,x)VALUES(0040000000,20,'00000000000f0f0f');
INSERT INTO t1(oid,a,x)VALUES(-30,21,'000f000000000000');
INSERT INTO t1(oid,a,x)VALUES(34359738368,22,'0000000800000000');
INSERT INTO t1(oid,a,x)VALUES(30000,23,'0000000000000f0f');
INSERT INTO t1(oid,a,x)VALUES(8388608,24,'0000000000800000');
INSERT INTO t1(oid,a,x)VALUES(10000000000000,25,'00000f00000000ff');
INSERT INTO t1(oid,a,x)VALUES(2000000000,26,'0001000000000000');
INSERT INTO t1(oid,a,x)VALUES(3000000000000000,27,'00000f0000000f00');
INSERT INTO t1(oid,a,x) VALUES(72057594037927936,28,'0100000000000000');
INSERT INTO t1(oid,a,x) VALUES(-6,29,'00000f0000000f0f');
INSERT INTO t1(oid,a,x) VALUES(205,30,'00000000000000f0');
INSERT INTO t1(oid,a,x) VALUES(4,31,'0000000000000004');
INSERT INTO t1(oid,a,x) VALUES(-68,32,'00000f0000008000');
INSERT INTO t1(oid,a,x) VALUES(-2,33,'00000f0000000ff0');
INSERT INTO t1(oid,a,x) VALUES(10000000000008,34,'0000800000000000');
INSERT INTO t1(oid,a,x) VALUES(50000000000,35,'0000008000000000');
INSERT INTO t1(oid,a,x) VALUES(4000000000,36,'0000000100000000');
INSERT INTO t1(oid,a,x) VALUES(-60,37,'00000f0000800000');
INSERT INTO t1(oid,a,x) VALUES(-1,38,'00000f0f');
INSERT INTO t1(oid,a,x) VALUES(3000000000,39,'00000000000f0ff0');
INSERT INTO t1(oid,a,x) VALUES(8400000,40,'0000000010000000');
INSERT INTO t1(oid,a,x) VALUES(2,41,'0000000000000002');
INSERT INTO t1(oid,a,x) VALUES(90000,42,'0000000000200000');
INSERT INTO t1(oid,a,x) VALUES(50000000,43,'000200000000');
INSERT INTO t1(oid,a,x) VALUES(-7,44,'000f800000000000');
INSERT INTO t1(oid,a,x) VALUES(060000000,45,'0080000000000000');
INSERT INTO t1(oid,a,x) VALUES(5000000000,46,'0000000000000fff');
INSERT INTO t1(oid,a,x) VALUES(-20,47,'00000f000000f000');
INSERT INTO t1(oid,a,x) VALUES(60000,48,'00000000000000ff');
INSERT INTO t1(oid,a,x) VALUES(128,49,'0000000000000080');
INSERT INTO t1(oid,a,x) VALUES(32768,50,'0000000000008000');
INSERT INTO t1(oid,a,x) VALUES(2147483648,51,'0000000080000000');
INSERT INTO t1(oid,a,x) VALUES(-3,52,'00000f00000000fd');
INSERT INTO t1(oid,a,x) VALUES(-28,53,'00000f0000000f80');
INSERT INTO t1(oid,a,x) VALUES(-29,54,'00000f0000000f70');
INSERT INTO t1(oid,a,x) VALUES(-9223372036854775808,55,'8000000000000000');
INSERT INTO t1(oid,a,x) VALUES(400000000000,56,'0000040000000000');
INSERT INTO t1(oid,a,x) VALUES(10000000000,57,'0000000000000ff0');
INSERT INTO t1(oid,a,x) VALUES(00800,58,'00000f000000f00f');
INSERT INTO t1(oid,a,x) VALUES(0,59,'0000000000000000');
INSERT INTO t1(oid,a,x) VALUES(1,60,'0000000000000001');
INSERT INTO t1(oid,a,x) VALUES(206,61,'0000000000000100');
INSERT INTO t1(oid,a,x) VALUES(60006,62,'0000000000010000');
INSERT INTO t1(oid,a,x) VALUES(-5000000000,63,'00000f8000000000');
INSERT INTO t1(oid,a,x) VALUES(8,64,'0f80000000000000');
CREATE INDEX t000 ON t1(a);
CREATE INDEX t002 O


sqltext:
CREATE TABLE t1(a,x);
INSERT INTO t1(oid,a,x)VALUES(-9,1,'00000000');
INSERT INTO t1(oid,a,x)VALUES(900,2,'0f00000000000000');
INSERT INTO t1(oid,a,x)VALUES(9223372036854775808,3,'0f00INSERT INTO t1(o00f');
INSERT INTO t1(oid,a,x)VA0f00000000');
INSERT INTO t1(oid,a,x)VALUES(0400000,12,'00000000000f000f');
INSERT INTO t1(oid,a,x)VALUES(40000000000,13,'00000f000000000f');
INSERT INTO t1(oid,a,x)VALUES(67000,14,'00000000000f00f0');
INSERT INTO t1(oid,a,x)VALUES(200,15,'00000000000f00ff');
INSERT INTO t1(oid,a,x)VALUES(304,16,'0000000000004000');
INSERT INTO t1(oid,a,x)VALUES(7000000000000,17,'00000f00000000f0');
INSERT INTO t1(oid,a,x)VALUES(80000,18,'00000000000f0f00');
INSERT INTO t1(oid,a,x)VALUES(100000000000,19,'0000010000000000');
INSERT INTO t1(oid,a,x)VALUES(0040000000,20,'00000000000f0f0f');
INSERT INTO t1(oid,a,x)VALUES(-30,21,'000f000000000000');
INSERT INTO t1(oid,a,x)VALUES(34359738368,22,'0000000800000000');
INSERT INTO t1(oid,a,x)VALUES(30000,23,'0000000000000f0f');
INSERT INTO t1(oid,a,x)VALUES(8388608,24,'0000000000800000');
INSERT INTO t1(oid,a,x)VALUES(10000000000000,25,'00000f00000000ff');
INSERT INTO t1(oid,a,x)VALUES(20000000000000,26,'0001000000000000');
INSERT INTO t1(oid,a,x)VALUES(3000000000000000,27,'00000f0000000f00');
INSERT INTO t1(oid,a,x) VALUES(72057594037927936,28,'0100000000000000');
INSERT INTO t1(oid,a,x) VALUES(-6,29,'00000f0000000f0f');
INSERT INTO t1(oid,a,x) VALUES(205,30,'00000000000000f0');
INSERT INTO t1(oid,a,x) VALUES(4,31,'0000000000000004');
INSERT INTO t1(oid,a,x) VALUES(-68,32,'00000f0000008000');
INSERT INTO t1(oid,a,x) VALUES(-2,33,'00000f0000000ff0');
INSERT INTO t1(oid,a,x) VALUES(10000000000008,34,'0000800000000000');
INSERT INTO t1(oid,a,x) VALUES(50000000000,35,'0000008000000000');
INSERT INTO t1(oid,a,x) VALUES(4000000000,36,'0000000100000000');
INSERT INTO t1(oid,a,x) VALUES(-60,37,'00000f0000800000');
INSERT INTO t1(oid,a,x) VALUES(-1,38,'00000f0f');
INSERT INTO t1(oid,a,x) VALUES(3000000000,39,'00000000000f0ff0');
INSERT INTO t1(oid,a,x) VALUES(8400000,40,'0000000010000000');
INSERT INTO t1(oid,a,x) VALUES(2,41,'0000000000000002');
INSERT INTO t1(oid,a,x) VALUES(90000,42,'0000000000200000');
INSERT INTO t1(oid,a,x) VALUES(50000000,43,'000200000000');
INSERT INTO t1(oid,a,x) VALUES(-7,44,'000f800000000000');
INSERT INTO t1(oid,a,x) VALUES(060000000,45,'0080000000000000');
INSERT INTO t1(oid,a,x) VALUES(5000000000,46,'0000000000000fff');
INSERT INTO t1(oid,a,x) VALUES(-20,47,'00000f000000f000');
INSERT INTO t1(oid,a,x) VALUES(60000,48,'00000000000000ff');
INSERT INTO t1(oid,a,x) VALUES(128,49,'0000000000000080');
INSERT INTO t1(oid,a,x) VALUES(32768,50,'0000000000008000');
INSERT INTO t1(oid,a,x) VALUES(2147483648,51,'0000000080000000');
INSERT INTO t1(oid,a,x) VALUES(-3,52,'00000f00000000fd');
INSERT INTO t1(oid,a,x) VALUES(-28,53,'00000f0000000f80');
INSERT INTO t1(oid,a,x) VALUES(-29,54,'00000f0000000f70');
INSERT INTO t1(oid,a,x) VALUES(-9223372036854775808,55,'8000000000000000');
INSERT INTO t1(oid,a,x) VALUES(400000000000,56,'0000040000000000');
INSERT INTO t1(oid,a,x) VALUES(10000000000,57,'0000000000000ff0');
INSERT INTO t1(oid,a,x) VALUES(00800,58,'00000f000000f00f');
INSERT INTO t1(oid,a,x) VALUES(0,59,'0000000000000000');
INSERT INTO t1(oid,a,x) VALUES(1,60,'0000000000000001');
INSERT INTO t1(oid,a,x) VALUES(206,61,'0000000000000100');
INSERT INTO t1(oid,a,x) VALUES(60006,62,'0000000000010000');
INSERT INTO t1(oid,a,x) VALUES(-5000000000,63,'00000f8000000000');
INSERT INTO t1(oid,a,x) VALUES(8,64,'0f80000000000000');
CREATE INDEX t000 ON t1(a);
CREATE INDEX t0


sqltext:
CREATE TABLE t1(a,x);
INSERT INTO t1(oid,a,x)VALUES(-9,1,'000000000f000000');
INSERT INTO t1(oid,a,x)VALUES(900,2,'0f00000000000000');
INSERT INTO t1(oid,a,x)VALUES(922+372036854775800,3,'0f0000000000000f');
INSERT INTO t1(oid,a,x)VALUES(7,4,'000000000000000f');
INSERT INTO t1(oid,a,x)VALUES(3,5,'0000000000000003');
INSERT INTO t1(oid,a,x)VALUES(6000000,6,'0000000001000000');
INSERT INTO t1(oid,a,x)VALUES(90000000000,7,'0000030000000000');
INSERT INTO t1(oid,a,x)VALUES(300,8,'0000000000000f00');
INSERT INTO t1(oid,a,x)VALUES(6000005,9,'00000000000f0000');
INSERT INTO t1(oid,a,x)VALUES(200000000000,10,'00000f0000000000');
INSERT INTO t1(oid,a,x)VALUES(-8,11,'0000000f00000000');
INSERT INTO t1(oid,a,x)VALUES(0400000,12,'00000000000f000f');
INSERT INTO t1(oid,a,x)VALUES(40000000000,13,'00000f000000000f');
INSERT INTO t1(oid,a,x)VALUES(67000,14,'00000000000f00f0');
INSERT INTO t1(oid,a,x)VALUES(200,15,'00000000000f00ff');
INSERT INTO t1(oid,a,x)VALUES(304,16,'0000000000004000');
INSERT INTO t1(oid,a,x)VALUES(7000000000000,17,'00000f00000000f0');
INSERT INTO t1(oid,a,x)VALUES(80000,18,'00000000000f0f00');
INSERT INTO t1(oid,a,x)VALUES(100000000000,19,'0000010000000000');
INSERT INTO t1(oid,a,x)VALUES(0040000000,20,'00000000000f0f0f');
INSERT INTO t1(oid,a,x)VALUES(-30,21,'000f000000000000');
INSERT INTO t1(oid,a,x)VALUES(34359738368,22,'0000000800000000');
INSERT INTO t1(oid,a,x)VALUES(30000,23,'0000000000000f0f');
INSERT INTO t1(oid,a,x)VALUES(8388608,24,'0000000000800000');
INSERT INTO t1(oid,a,x)VALUES(10000000000000,25,'00000f00000000ff');
INSERT INTO t1(oid,a,x)VALUES(20000000000000,26,'0001000000000000');
INSERT INTO t1(oid,a,x)VALUES(3000000000000000,27,'00000f0000000f00');
INSERT INTO t1(oid,a,x) VALUES(72057594037927936,28,'0100000000000000');
INSERT INTO t1(oid,a,x) VALUES(-6,29,'00000f0000000f0f');
INSERT INTO t1(oid,a,x) VALUES(205,30,'00000000000000f0');
INSERT INTO t1(oid,a,x) VALUES(4,31,'0000000000000004');
INSERT INTO t1(oid,a,x) VALUES(-68,32,'00000f0000008000');
INSERT INTO t1(oid,a,x) VALUES(-2,33,'00000f0000000ff0');
INSERT INTO t1(oid,a,x) VALUES(10000000000008,34,'00008000');
INSERT INTO t1(oid,a,x) VALUES(50000000000,35,'0000008000000000');
INSERT INTO t1(oid,a,x) VALUES(4000000000,36,'0000000100000000');
INSERT INTO t1(oid,a,x) VALUES(-60,37,'00000f0000800000');
INSERT INTO t1(oid,a,x) VALUES(-1,38,'00000f0f');
INSERT INTO t1(oid,a,x) VALUES(3000000000,39,'00000000000f0ff0');
INSERT INTO t1(oid,a,x) VALUES(8400000,40,'0000000010000000');
INSERT INTO t1(oid,a,x) VALUES(2,41,'0000000000000002');
INSERT INTO t1(oid,a,x) VALUES(90000,42,'0000000000200000');
INSERT INTO t1(oid,a,x) VALUES(50000000,43,'000200000000');
INSERT INTO t1(oid,a,x) VALUES(-7,44,'000f800000000000');
INSERT INTO t1(oid,a,x) VALUES(060000000,45,'0080000000000000');
INSERT INTO t1(oid,a,x) VALUES(5000000000,46,'0000000000000fff');
INSERT INTO t1(oid,a,x) VALUES(-20,47,'00000f000000f000');
INSERT INTO t1(oid,a,x) VALUES(60000,48,'00000000000000ff');
INSERT INTO t1(oid,a,x) VALUES(128,49,'0000000000000080');
INSERT INTO t1(oid,a,x) VALUES(32768,50,'0000000000008000');
INSERT INTO t1(oid,a,x) VALUES(2147483648,51,'0000000080000000');
INSERT INTO t1(oid,a,x) VALUES(-3,52,'00000f00000000fd');
INSERT INTO t1(oid,a,x) VALUES(-28,53,'00000f0000000f80');
INSERT INTO t1(oid,a,x) VALUES(-29,54,'00000f0000000f70');
INSERT INTO t1(oid,a,x) VALUES(-9223372036854775808,55,'8000000000000000');
INSERT INTO t1(oid,a,x) VALUES(400000000000,56,'0000040000000000');
INSERT INTO t1(oid,a,x) VALUES(10000000000,57,'0000000000000ff0');
INSERT INTO t1(oid,a,x) VALUES(00800,58,'00000f000000f00f');
INSERT INTO t1(oid,a,x) VALUES(0,59,'0000000000000000');
INSERT INTO t1(oid,a,x) VALUES(1,60,'0000000000000001');
INSERT INTO t1(oid,a,x) VALUES(206,61,'0000000000000100');
INSERT INTO t1(oid,a,x) VALUES(60006,62,'0000000000010000');
INSERT INTO t1(oid,a,x) VALUES(-5000000000,63,'00000f8000000000');
INSERT INTO t1(oid,a,x) VALUES(8,64,'0f800000');
CREATE INDEX t000 ON t1(a);
CREATE INDEX t002 ON t1(x);


sqltext:
CREATE TABLE t1(a,x);
INSERT INTO t1(oid,a,x)VALUES(-9,1,'000000000f000000');
INSERT INTO t1(oid,a,x)VALUES(900,2,'0f00000000000000');
INSERT INTO t1(oid,a,x)VALUES(9223372036854775800,3,'0f0000000000000f');
INSERT INTO t1(oid,a,x)VALUES(7,4,'000000000000000f');
INSERT INTO t1(oid,a,x)VALUES(3,5,'0000000000000003');
INSERT INTO t1(oid,a,x)VALUES(6000000,6,'0000000001000000');
INSERT INTO t1(oid,a,x)VALUES(90000000000,7,'0000030000000000');
INSERT INTO t1(oid,a,x)VALUES(300,8,'0000000000000f00');
INSERT INTO t1(oid,a,x)VALUES(6000005,9,'00000000000f0000');
INSERT INTO t1(oid,a,x)VALUES(200000000000,10,'00000f0000000000');
INSERT INTO t1(oid,a,x)VALUES(-8,11,'0000000f00000000');
INSERT INTO t1(oid,a,x)VALUES(0400000,12,'00000000000f000f');
INSERT INTO t1(oid,a,x)VALUES(4000000000 ,13,'00000f000000000f');
INSERT INTO t1(oid,a,x)VALUES(67000,14,'00000000000f00f0');
INSERT INTO t1(oid,a,x)VALUES(200,15,'00000000000f00ff');
INSERT INTO t1(oid,a,x)VALUES(304,16,'0000000000004000');
INSERT INTO t1(oid,a,x)VALUES(7000000000000,17,'00000f00000000f0');
INSERT INTO t1(oid,a,x)VALUES(80000,18,'00000000000f0f00');
INSERT INTO t1(oid,a,x)VALUES(100000000000,19,'0000010000000000');
INSERT INTO t1(oid,a,x)VALUES(0040000000,20,'00000000000f0f0f');
INSERT INTO t1(oid,a,x)VALUES(-30,21,'000f000000000000');
INSERT INTO t1(oid,a,x)VALUES(34359738368,22,'0000000800000000');
INSERT INTO t1(oid,a,x)VALUES(30000,23,'0000000000000f0f');
INSERT INTO t1(oid,a,x)VALUES(8388608,24,'0000000000800000');
INSERT INTO t1(oid,a,x)VALUES(10000000000000,25,'00000f00000000ff');
INSERT INTO t1(oid,a,x)VALUES(20000000000000,26,'0001000000000000');
INSERT INTO t1(oid,a,x)VALUES(3000000000000000,27,'00000f0000000f00');
INSERT INTO t1(oid,a,x) VALUES(72057594037927936,28,'0100000000000000');
INSERT INTO t1(oid,a,x) VALUES(-6,29,'00000f0000000f0f');
INSERT INTO t1(oid,a,x) VALUES(205,30,'00000000000000f0');
INSERT INTO t1(oid,a,x) VALUES(4,31,'0000000000000004');
INSERT INTO t1(oid,a,x) VALUES(-68,32,'00000f0000008000');
INSERT INTO t1(oid,a,x) VALUES(-2,33,'00000f0000000ff0');
INSERT INTO t1(oid,a,x) VALUES(10000000000008,34,'0000800000000000');
INSERT INTO t1(oid,a,x) VALUES(50000000000,35,'0000008000000000');
INSERT INTO t1(oid,a,x) VALUES(4000000000,36,'0000000100000000');
INSERT INTO t1(oid,a,x) VALUES(-60,37,'00000f0000800000');
INSERT INTO t1(oid,a,x) VALUES(-1,38,'00000f0f');
INSERT INTO t1(oid,a,x) VALUES(3000000000,39,'00000000000f0ff0');
INSERT INTO t1(oid,a,x) VALUES(8400000,40,'0000000010000000');
INSERT INTO t1(oid,a,x) VALUES(2,41,'0000000000000002');
INSERT INTO t1(oid,a,x) VALUES(90000,42,'0000000000200000');
INSERT INTO t1(oid,a,x) VALUES(50000000,43,'000200000000');
INSERT INTO t1(oid,a,x) VALUES(-7,44,'000f800000000000');
INSERT INTO t1(oid,a,x) VALUES(060000000,45,'0080000000000000');
INSERT INTO t1(oid,a,x) VALUES(5000000000,46,'0000000000000fff');
INSERT INTO t1(oid,a,x) VALUES(-20,47,'00000f000000f000');
INSERT INTO t1(oid,a,x) VALUES(60000,48,'00000000000000ff');
INSERT INTO t1(oid,a,x) VALUES(128,49,'0000000000000080');
INSERT INTO t1(oid,a,x) VALUES(32768,50,'0000000000008000');
INSERT INTO t1(oid,a,x) VALUES(2147483648,51,'0000000080000000');
INSERT INTO t1(oid,a,x) VALUES(-3,52,'00000f00000000fd');
INSERT INTO t1(oid,a,x) VALUES(-28,53,'00000f0000000f80');
INSERT INTO t1(oid,a,x) VALUES(-29,54,'00000f0000000f70');
INSERT INTO t1(oid,a,x) VALUES(-9223372036854775808,55,'8000000000000000');
INSERT INTO t1(oid,a,x) VALUES(400000000000,56,'0000040000000000');
INSERT INTO t1(oid,a,x) VALUES(10000000000,57,'0000000000000ff0');
INSERT INTO t1(oid,a,x) VALUES(00800,58,'00000f000000f00f');
INSERT INTO t1(oid,a,x) VALUES(0,59,'0000000000000000');
INSERT INTO t1(oid,a,x) VALUES(1,60,'0000000000000001');
INSERT INTO t1(oid,a,x) VALUES(206,61,'0000000000000100');
INSERT INTO t1(oid,a,x) VALUES(60006,62,'0000000000010000');
INSERT INTO t1(oid,a,x) VALUES(-5000000000,63,'00000f8000000000');
INSERT INTO t1(oid,a,x) VALUES(8,64,'0f80000000000000');
CREATE INDEX t000 ON t1(a);
CREATE INDEX t002 ON t1(x);


sqltext:
CREATE TABLE t1(a,x);
INSERT INTO t1(oid,a,x)VALUES(-9,1,'000000000f000000');
INSERT INTO t1(oid,a,x)VALUES(900,2,'0f00000000000000');
INSERT INTO t1(oid,a,x)VALUES(9223372036854775800,3,'0f0000000000000f');
INSERT INTO t1(oid,a,x)VALUES(7,4,'000000000000000f');
INSERT INTO t1(oid,a,x)VALUES(3,5,'0000000000000003');
INSERT INTO t1(oid,a,x)VALUES(6000000,6,'0000000001000000');
INSERT INTO t1(oid,a,x)VALUES(90000000000,7,'0000030000000000');
INSERT INTO t1(oid,a,x)VALUES(300,8,'0000000000000f00');
INSERT INTO t1(oid,a,x)VALUES(6000005,9,'00000000000f0000');
INSERT INTO t1(oid,a,x)VALUES(200000000000,10,'00000f0000000000');
INSERT INTO t1(oid,a,x)VALUES(-8,11,'0000000f00000000');
INSERT INTO t1(oid,a,x)VALUES(0400000,12,'00000000000f000f');
INSERT INTO t1(oid,a,x)VALUES(40000000000,13,'00000f000000000f');
INSERT INTO t1(oid,a,x)VALUES(67000,14,'00000000000f00f0');
INSERT INTO t1(oid,a,x)VALUES(200,15,'00000000000f00ff');
INSERT INTO t1(oid,a,x)VALUES(304,16,'0000000000004000');
INSERT INTO t1(oid,a,x)VALUES(7000000000000,17,'00000f00000000f0');
INSERT INTO t1(oid,a,x)VALUES(80000,18,'00000000000f0f00');
INSERT INTO t1(oid,a,x)VALUES(100000000000,19,'0000010000000000');
INSERT INTO t1(oid,a,x)VALUES(0040000000,20,'00000000000f0f0f');
INSERT INTO t1(oid,a,x)VALUES(-20,21,'000f000000000000');
INSERT INTO t1(oid,a,x)VALUES(34359738368,22,'0000000800000000');
INSERT INTO t1(oid,a,x)VALUES(30000,23,'0000000000000f0f');
INSERT INTO t1(oid,a,x)VALUES(8388608,24,'0000000000800000');
INSERT INTO t1(oid,a,x)VALUES(10000000000000,25,'00000f00000000ff');
INSERT INTO t1(oid,a,x)VALUES(20000000000000,26,'0001000000000000');
INSERT INTO t1(oid,a,x)VALUES(3000000000000000,27,'00000f0000000f00');
INSERT INTO t1(oid,a,x) VALUES(72057594037927936,28,'0100000000000000');
INSERT INTO t1(oid,a,x) VALUES(-6,29,'00000f0000000f0f');
INSERT INTO t1(oid,a,x) VALUES(205,30,'00000000000000f0');
INSERT INTO t1(oid,a,x) VALUES(4,31,'0000000000000004');
INSERT INTO t1(oid,a,x) VALUES(-68,32,'00000f0000008000');
INSERT INTO t1(oid,a,x) VALUES(-2,33,'00000f0000000ff0');
INSERT INTO t1(oid,a,x) VALUES(10000000000008,34,'0000800000000000');
INSERT INTO t1(oid,a,x) VALUES(50000000000,35,'0000008000000000');
INSERT INTO t1(oid,a,x) VALUES(4000000000,36,'0000000100000000');
INSERT INTO t1(oid,a,x) VALUES(-60,37,'00000f0000800000');
INSERT INTO t1(oid,a,x) VALUES(-1,38,'00000f0f');
INSERT INTO t1(oid,a,x) VALUES(3000000000,39,'00000000000f0ff0');
INSERT INTO t1(oid,a,x) VALUES(8400000,40,'0000000010000000');
INSERT INTO t1(oid,a,x) VALUES(2,41,'0000000000000002');
INSERT INTO t1(oid,a,x) VALUES(90000,42,'0000000000200000');
INSERT INTO t1(oid,a,x) VALUES(50000000,43,'000200000000');
INSERT INTO t1(oid,a,x) VALUES(-7,44,'000f800000000000');
INSERT INTO t1(oid,a,x) VALUES(060000000,45,'0080000000000000');
INSERT INTO t1(oid,a,x) VALUES(5000000000,46,'0000000000000fff');
INSERT INTO t1(oid,a,x) VALUES(-20,47,'00000f000000f000');
INSERT INTO t1(oid,a,x) VALUES(60000,48,'00000000000000ff');
INSERT INTO t1(oid,a,x) VALUES(128,49,'0000000000000080');
INSERT INTO t1(oid,a,x) VALUES(32768,50,'0000000000008000');
INSERT INTO t1(oid,a,x) VALUES(2147483648,51,'0000000080000000');
INSERT INTO t1(oid,a,x) VALUES(-3,52,'00000f00000000fd');
INSERT INTO t1(oid,a,x) VALUES(-28,53,'00000f0000000f80');
INSERT INTO t1(oid,a,x) VALUES(-29,54,'00000f0000000f70');
INSERT INTO t1(oid,a,x) VALUES(-9223372036854775808,55,'8000000000000000');
INSERT INTO t1(oid,a,x) VALUES(400000000000,56,'0000040000000000');
INSERT INTO t1(oid,a,x) VALUES(10000000000,57,'0000000000000ff0');
INSERT INTO t1(oid,a,x) VALUES(00800,58,'00000f000000f00f');
INSERT INTO t1(oid,a,x) VALUES(0,59,'0000000000000000');
INSERT INTO t1(oid,a,x) VALUES(1,60,'0000000000000001');
INSERT INTO t1(oid,a,x) VALUES(206,61,'0000000000000100');
INSERT INTO t1(oid,a,x) VALUES(60006,62,'0000000000010000');
INSERT INTO t1(oid,a,x) VALUES(-5000000000,63,'00000f8000000000');
INSERT INTO t1(oid,a,x) VALUES(8,64,'0f80000000000000');
CREATE INDEX t000 ON t1(a);
CREATE INDEX t002 ON t1(x);


sqltext:
CREATE TABLE t1(a,x);
INSERT INTO t1(oid,a,x)VALUES(-9,1,'000000000f000000');
INSERT INTO t1(oid,a,x)VALUES(900,2,'0f00000000000000');
INSERT INTO t1(oid,a,x)VALUES(9223372036854775800,3,'0f0000000000000f');
INSERT INTO t1(oid,a,x)VALUES(7,4,'000000000000000f');
INSERT INTO t1(oid,a,x)VALUES(3,5,'0000000000000003');
INSERT INTO t1(oid,a,x)VALUES(6000000,6,'0000000001000000');
INSERT INTO t1(oid,a,x)VALUES(90000000000,7,'0000030000000000');
INSERT INTO t1(oid,a,x)VALUES(300,8,'0000000000000f00');
INSERT INTO t1(oid,a,x)VALUES(6000005,9,'00000000000f0000');
INSERT INTO t1(oid,a,x)VALUES(200000000000,10,'00000f0000000000');
INSERT INTO t1(oid,a,x)VALUES(-8,11,'0000000f00000000');
INSERT INTO t1(oid,a,x)VALUES(0400000,12,'00000000000f000f');
INSERT INTO t1(oid,a,x)VALUES(40000000000,13,'00000f000000000f');
INSERT INTO t1(oid,a,x)VALUES(67000,14,'00000000000f00f0');
INSERT INTO t1(oid,a,x)VALUES(200,15,'00000000000f00ff');
INSERT INTO t1(oid,a,x)VALUES(304,16,'0000000000004000');
INSERT INTO t1(oid,a,x)VALUES(7000000000000,17,'00000f00000000f0');
INSERT INTO t1(oid,a,x)VALUES(80000,18,'00000000000f0f00');
INSERT INTO t1(oid,a,x)VALUES(100000000000,19,'0000010000000000');
INSERT INTO t1(oid,a,x)VALUES(0040000000,20,'00000000000f0f0f');
INSERT INTO t1(oid,a,x)VALUES(-30,21,'000f000000000000');
INSERT INTO t1(oid,a,x)VALUES(34359738368,22,'0000000800000000');
INSERT INTO t1(oid,a,x)VALUES(30000,23,'0000000000000f0f');
INSERT INTO t1(oid,a,x)VALUES(8388608,24,'0000000000800000');
INSERT INTO t1(oid,a,x)VALUES(10000000000000,25,'00000f00000000ff');
INSERT INTO t1(oid,a,x)VALUES(20000000000000,26,'0001000000000000');
INSERT INTO t1(oid,a,x)VALUES(3000000000000000,27,'00000f0000000f00');
INSERT INTO t1(oid,a,x) VALUES(72057594037927936,28,'0100000000000000');
INSERT INTO t1(oid,a,x) VALUES(-6,29,'00000f0000000f0f');
INSERT INTO t1(oid,a,x) VALUES(205,30,'00000000000000f0');
INSERT INTO t1(oid,a,x) VALUES(4,31,'0000000000000004');
INSERT INTO t1(oid,a,x) VALUES(-68,32,'00000f0000008000');
INSERT INTO t1(oid,a,x) VALUES(-2,33,'00000f0000000ff0');
INSERT INTO t1(oid,a,x) VALUES(10000000000008,34,'0000800000000000');
INSERT INTO t1(oid,a,x) VALUES(50000000000,35,'0000008000000000');
INSERT INTO t1(oid,a,x) VALUES(4000000000,36,'0000000100000000');
INSERT INTO t1(oid,a,x) VALUES(-60,37,'00000f0000800000');
INSERT INTO t1(oid,a,x) VALUES(-1,38,'00000f0f');
INSERT INTO t1(oid,a,x) VALUES(3000000000,39,'00000000000f0ff0');
INSERT INTO t1(oid,a,x) VALUES(8400000,40,'0000000010000000');
INSERT INTO t1(oid,a,x) VALUES(2,41,'0000000000000002');
INSERT INTO t1(oid,a,x) VALUES(90000,42,'0000000000200000');
INSERT INTO t1(oid,a,x) VALUES(50000000,43,'000200000000');
INSERT INTO t1(oid,a,x) VALUES(-7,44,'000f800000000000');
INSERT INTO t1(oid,a,x) VALUES(060000000,45,'0080000000000000');
INSERT INTO t1(oid,a,x) VALUES(5000000000,46,'0000000000000fff');
INSERT INTO t1(oid,a,x) VALUES(-20,47,'00000f000000f000');
INSERT INTO t1(oid,a,x) VALUES(60000,48,'00000000000000ff');
INSERT INTO t1(oid,a,x) VALUES(128,49,'0000000000000080');
INSERT INTO t1(oid,a,x) VALUES(32768,50,'0000000000008000');
INSERT INTO t1(oid,a,x) VALUES(2147483648,51,'0000000080000000');
INSERT INTO t1(oid,a,x) VALUES(-3,52,'00000f00000000fd');
INSERT INTO t1(oid,a,x) VALUES(-28,53,'00000f0000000f80');
INSERT INTO t1(oid,a,x) VALUES(-29,54,'00000f0000000f70');
INSERT INTO t1(oid,a,x) VALUES(-9223372036854775800,55,'8000000000000000');
INSERT INTO t1(oid,a,x) VALUES(400000000000,56,'0000040000000000');
INSERT INTO t1(oid,a,x) VALUES(10000000000,57,'0000000000000ff0');
INSERT INTO t1(oid,a,x) VALUES(00800,58,'00000f000000f00f');
INSERT INTO t1(oid,a,x) VALUES(0,59,'0000000000000000');
INSERT INTO t1(oid,a,x) VALUES(1,60,'0000000000000001');
INSERT INTO t1(oid,a,x) VALUES(206,61,'0000000000000100');
INSERT INTO t1(oid,a,x) VALUES(60006,62,'0000000000010000');
INSERT INTO t1(oid,a,x) VALUES(-5000000000,63,'00000f8000000000');
INSERT INTO t1(oid,a,x) VALUES(8,64,'0f80000000000000');
CREATE INDEX t000 ON t1(a);
CREATE INDEX t002 ON t1(x);


sqltext:
CREATE TABLE t1(a,x);
INSERT INTO t1(oid,a,x)VALUES(-9,1,'000000000f000000');
INSERT INTO t1(oid,a,x)VALUES(900,2,'0f00000000000000');
INSERT INTO t1(oid,a,x)VALUES(9223372036854775800,3,'0f0000000000000f');
INSERT INTO t1(oid,a,x)VALUES(7,4,'000000000000000f');
INSERT INTO t1(oid,a,x)VALUES(3,5,'0000000000000003');
INSERT INTO t1(oid,a,x)VALUES(6000000,6,'0000000001000000');
INSERT INTO t1(oid,a,x)VALUES(90000000000,7,'0000030000000000');
INSERT INTO t1(oid,a,x)VALUES(300,8,'0000000000000f00');
INSERT INTO t1(oid,a,x)VALUES(6000005,9,'00000000000f0000');
INSERT INTO t1(oid,a,x)VALUES(200000000000,10,'00000f0000000000');
INSERT INTO t1(oid,a,x)VALUES(-8,11,'0000000f00000000');
INSERT INTO t1(oid,a,x)VALUES(0400000,12,'00000000000f000f');
INSERT INTO t1(oid,a,x)VALUES(40000000000,13,'00000f000000000f');
INSERT INTO t1(oid,a,x)VALUES(67000,14,'00000000000f00f0');
INSERT INTO t1(oid,a,x)VALUES(200,15,'00000000000f00ff');
INSERT INTO t1(oid,a,x)VALUES(304,16,'0000000000004000');
INSERT INTO t1(oid,a,x)VALUES(7000000000000,17,'00000f00000000f0');
INSERT INTO t1(oid,a,x)VALUES(80000,18,'00000000000f0f00');
INSERT INTO t1(oid,a,x)VALUES(100000000000,19,'0000010000000000');
INSERT INTO t1(oid,a,x)VALUES(0040000000,20,'00000000000f0f0f');
INSERT INTO t1(oid,a,x)VALUES(-30,21,'000f000000000000');
INSERT INTO t1(oid,a,x)VALUES(34359738368,22,'0000000800000000');
INSERT INTO t1(oid,a,x)VALUES(30000,23,'0000000000000f0f');
INSERT INTO t1(oid,a,x)VALUES(8388608,24,'0000000000800000');
INSERT INTO t1(oid,a,x)VALUES(10000000000000,25,'00000f00000000ff');
INSERT INTO t1(oid,a,x)VALUES(20000000000000,26,'0001000000000000');
INSERT INTO t1(oid,a,x)VALUES(3000000000000000,27,'00000f0000000f00');
INSERT INTO t1(oid,a,x) VALUES(72057594037927936,28,'0100000000000000');
INSERT INTO t1(oid,a,x) VALUES(-6,29,'00000f0000000f0f');
INSERT INTO t1(oid,a,x) VALUES(205,30,'00000000000000f0');
INSERT INTO t1(oid,a,x) VALUES(4,31,'0000000000000004');
INSERT INTO t1(oid,a,x) VALUES(-68,32,'00000f0000008000');
INSERT INTO t1(oid,a,x) VALUES(-2,33,'00000f0000000ff0');
INSERT INTO t1(oid,a,x) VALUES(10000000000008,34,'0000800000000000');
INSERT INTO t1(oid,a,x) VALUES(50000000000,35,'0000008000000000');
INSERT INTO t1(oid,a,x) VALUES(4000000000,36,'0000000100000000');
INSERT INTO t1(oid,a,x) VALUES(-60,37,'00000f0000800000');
INSERT INTO t1(oid,a,x) VALUES(-1,38,'00000f0f');
INSERT INTO t1(oid,a,x) VALUES(3000000000,39,'00000000000f0ff0');
INSERT INTO t1(oid,a,x) VALUES(8400000,40,'0000000010000000');
INSERT INTO t1(oid,a,x) VALUES(2,41,'0000000000000002');
INSERT INTO t1(oid,a,x) VALUES(90000,42,'0000000000200000');
INSERT INTO t1(oid,a,x) VALUES(50000000,43,'000200000000');
INSERT INTO t1(oid,a,x) VALUES(-7,44,'000f800000000000');
INSERT INTO t1(oid,a,x) VALUES(060000000,45,'0080000000000000');
INSERT INTO t1(oid,a,x) VALUES(5000000000,46,'0000000000000fff');
INSERT INTO t1(oid,a,x) VALUES(-20,47,'00000f000000f000');
INSERT INTO t1(oid,a,x) VALUES(60000,48,'00000000000000ff');
INSERT INTO t1(oid,a,x) VALUES(128,49,'0000000000000080');
INSERT INTO t1(oid,a,x) VALUES(32768,50,'0000000000008000');
INSERT INTO t1(oid,a,x) VALUES(2147483648,51,'0000000080000000');
INSERT INTO t1(oid,a,x) VALUES(-3,52,'00000f00000000fd');
INSERT INTO t1(oid,a,x) VALUES(-28,53,'00000f0000000f80');
INSERT INTO t1(oid,a,x) VALUES(-29,54,'00000f0000000f70');
INSERT INTO t1(oid,a,x) VALUES(-9223372036854775808,55,'8000000000000000');
INSERT INTO t1(oid,a,x) VALUES(400000000000,56,'0000040000000000');
INSERT INTO t1(oid,a,x) VALUES(10000000000,57,'0000000000000ff0');
INSERT INTO t1(oid,a,x) VALUES(00800,58,'00000f000000f00f');
INSERT INTO t1(oid,a,x) VALUES(0,59,'0000000000000000');
INSERT INTO t1(oid,a,x) VALUES(1,60,'0000000000000001');
INSERT INTO t1(oid,a,x) VALUES(206,61,'0000000000000100');
INSERT INTO t1(oid,a,x) VALUES(60006,62,'0000000000010000');
INSERT INTO t1(oid,a,x) VALUES(-5000000000,63,'00000f8000000000');
INSERT INTO t1(oid,a,x) VALUES(8,64,'0f80000000000000');
CREATE INDEX t000 ON t1(a);
CREATE INDEX t002 ON t1(x);VACUUM


