# xsql

sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a AND v= 1=1=1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a AND v=.1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a= lower(1)=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a AND v=.1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a<4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a AND v=2001-01-01=1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a AND v==1;
  UPDATE counts SET n=n-1 WHERE v<old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a AND v==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n= json_extract(1,1)=1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a AND v==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a= instr(1,1);
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a AND v==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND v==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a AND v>=1;
  UPDATE counts SET n=n-1 WHERE v<old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a AND v>=1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a AND v>=1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;VACUUM


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a AND v>=1;
  UPDATE �ounts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a AND v>>1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a glob(1,1)AND true AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n= json_object(1,1,1,1)OR true=N;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
  ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
D


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=520012001-01-01-01-01;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND sqlite_compileoption_get(1)=n glob(1,1)=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND v==N;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND v==V;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v>old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v>old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=2001-01-014;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v>old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v>old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v>old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;VACUUM


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v>old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v>old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v>old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v>old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE+v=old.a AND sqlite_compileoption_get(1)=n glob(1,1)=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n,INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a AND n==1;
  UPDATE counts SET v=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v �NTEGER PRIMARY KEY, n,INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND v==N;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v,INTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(INTERSECTv,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v,INTEGER PRIMARY KEY, n,INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(INTERSECTv,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);


sqltext:
CREATE TABLE t1(a INT);
CREATE TABLE counts(v,INTERSECTRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(INTERSECTv,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);


sqltext:
CREATE TABLE t1(a INT);EXPLAIN
CREATE TABLE counts(v INTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT);EXPLAIN
CREATE TABLE counts(v INTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;EXPLAIN
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=ol�.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;EXPLAIN
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4


sqltext:
CREATE TABLE t1(a INT);EXPLAIN QUERY PLAN
CREATE TABLE counts(v INTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a INT,b 	NTEGER, c TEXT, d BLOB, e AEXPLAIN QUERY PLANON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);ANALYZE TEMP;VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e AEXPLAIN QUERY PLANON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);ANALYZETEMP;VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e AEXPLAIN QUERY PLANON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);ANALYZE TEMP;VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT REPLACE
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);ANALYZE TEMP;VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT REPLACE
    PRIMARY KEY(e),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ROLLBACK    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,a) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET b=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(b) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX ANALYZEt1d ON t1(d);ANALYZE TEMP;VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX ASd ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET b=max(e,excluded.e);VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1ENDd ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(b);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);REPLACE INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d -1);
CREATE UNIQUE INDEX t1e ON t1( json_replace(1,1,1),b,c,d,e) VALUES(;


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d -1);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);REINDEX


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d -1);ANALYZE TEMP;VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE  /* */ INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET b=max(e,excluded.e);VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(   a,ba,ba,bn,ace(1,1,1),b,c,d,e) VALUES(;


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(  a,ba,bn,ace(1,1,1),b,c,d,e) VALUES(;


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1( a, /* */(1,1,1),b,c,d,e) VALUES(;


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1( json_rep,ace(1,1,1)COLLATE   a,ba,bne,b,c,d,e) VALUES(;


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1( json_rep,ace(1,1,1)COLLATE  a,bne,b,c,d,e) VALUES(;


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1( json_rep,ace(1,1,1)COLLATE ne,b,c,d,e) VALUES(;


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1( json_replace(),1,1),b,c,d,e) VALUES(;


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e -1);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);REINDEX


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3', -.3 || .5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3 OR .5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3 | random()| .5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3 | round(1,1)| .5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3 || .5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.%5)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.&5)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4./5)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e)OR true;


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET b=max(e, likely(1));VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET b=max(e,excluded.e);REINDEX


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e= json_extract(1,1)


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);REINDEX rtrim(1,1)


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.E9)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);EXPLAIN
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET b=max(e,excluded.e);VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);EXPLAIN QUERY PLAN
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(c) DO UPDATE SET b=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);REPLACE INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET b=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3E5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.E5)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc'ISNULL,'b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET b=max(e,excluded.e);VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e)�VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(b,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);REINDEX


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e); WITH c(x) AS (values(1)) 
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);EXPLAIN QUERY PLAN
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET b=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);EXPLAIN
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);REINDEX


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);REPLACE INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET b=max(e,excluded.e);VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);ANALYZE TEMP.VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);ANALYZE TEMP;ANALYZE


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);ANALYZE TEMP;END


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);ANALYZE TEMP;REINDEX


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);EXPLAIN
CREATE UNIQUE INDEX t1e ON t1( json_replace(1,1,1),b,c,d,e) VALUES(;


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;EXPLAIN
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3 || .5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;EXPLAIN
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET b=max(e,excluded.e);VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;EXPLAIN
CREATE INDEX t1d ON t1(d);ANALYZE TEMP;VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(c),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE  /* */ INDEX t1e ON t1( json_replace(1,1,1),b,c,d,e) VALUES(;


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(c),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(c),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);ANALYZE TEMP;VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(d),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(d);ANALYZE INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(d),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(d);REINDEX INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(d),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(d);REPLACE INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(d),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(d);REPLACE INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);REPLACE INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(d),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(d)�REPLACE INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(d),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);REPLACE INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);REPLACE INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a,'b3',3.5);
&5)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a,'b3'COLLATE nocase,3.5);
&5FLICT(b) DO UPDATE SET e=max(e,excluded.


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(b) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID+
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(b) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);ANALYZE


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(b) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(b) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(e);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(b) ON CONFLICT ignore,
    PRIMARY KEY(e),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(b) ON CONFLICT ignore,
    PRIMARY KEY(e),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(e);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(c) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) W;


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT REPLACE
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e GLOB-E);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d -1);
CREATE UNIQUE INDEX t1e ON t1(e -E);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1( 'a');
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1( 1=1);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1( json(1));
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e -1);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);REPLACE INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e -E);REPLACE INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e GLOB a,b-E);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e GLOB-E);ANALYZE INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e GLOB-E);REPLACE INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e IS-1);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e ISNULL-E);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e OR-1);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e || B-E);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e&-E);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,a) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);ANALYZE


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,e,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(~ -1);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(e);
CREATE UNIQUE INDEX t1e ON t1(e -1);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e CASEANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET b=max(e,excluded.e);VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID+
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
 WITH c(x) AS (values(1)) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4,25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);REPLACE INTO t1(c,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;REINDEX INDEX t1d ONDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOB,�e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d BLOC� e AEXPLAIN QUERY PLANON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);ANALYZE TEMP;VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d CLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET b=max(e,excluded.e);VACUUM


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d DEFAULT ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT, d PRIMARY KEY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
  (c) ON C,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c TEXT� d BLOB, e ANY,
    UNIQUE(b) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c �EXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c,TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;REINDEX INDEX t1d ONDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a INT,b INTEGER, c,TEXT, d,BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;REINDEX INDEX t1d ONDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a INT,b INTE���� c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b TEXTGER, c TEXT, d BLOB, e ANY,
    UNIQUE(e) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a INT,b _NTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET b=max(e,excluded.e);VACUUM


sqltext:
CREATE TABLE t1(a INTEGER PRIMARY KEY, b) -- WITHOUT ROWID
;
INSERT INTO t1(a,b) VALUES(1,2),(1,7),(1,3)
    ON CONFLICT(rowid) DO UPDATE set b=max(b,excluded.b);
INSERT INTO t1(a,b) VALUES(1,2),(1,7),(1,3)
    ON CONFLICT(A) DO UPDATE set b=max(b,excluded.b);


sqltext:
CREATE TABLE t1(a INTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1�AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(�,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);


sqltext:
CREATE TABLE t1(a INTEXCEPT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);EXPLAIN QUERY PLAN
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET b=max(e,excluded.e);


sqltext:
CREATE TABLE t1(a blob INT,b INTEGER, c TEXT, d BLOB, e AEXPLAIN QUERY PLANON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);ANALYZE TEMP;VACUUM


sqltext:
CREATE TABLE t1(a char(1),INT);
CREATE TABLE counts(v INTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1�AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a json_array_length(1,1));REINDEX rtrim(1,1)a,b,
INSERT INTO t1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,''''''''''''''''''''b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREAT� UNIQUE INDEX t1bc ON \1(c,c);
INSERT INTO t1( glo a=a+1000;
ANALYZE*,S(1,2,3,4),(5,6,7�n_group_object(1),63,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
ANALYZE*, '


sqltext:
CREATE TABLE t1(a,DOb,c,d,PRIMARY KEY(d,d));VACUUM
;ITH data(a,b,cINSERT INTO t1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,I T,b,INTEGER, c,TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,I,T);
CREATE TABLE counts(v INTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1�AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a,INT);
CREATE TABLE counts(v INTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1�AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.INDEXED==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a,INT);
CREATE TABLE counts(v INTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1�AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.INTERSECT1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4


sqltext:
CREATE TABLE t1(a,INT);
CREATE TABLE counts(v INTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1�AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2�AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;VACUUM


sqltext:
CREATE TABLE t1(a,INT);
CREATE TABLE counts(v blobGER PRIMARY KEY, n,INT)WITHOUT ROWID;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v<old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4;
DELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t1(a,INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT REPLACE
    PRIMARY KEY(d),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b INTEGER, c TEXT, d BLOB, e ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);ANALYZE TEMP;VACUUM


sqltext:
CREATE TABLE t1(a,INT,b INTEGER, c TEXT, d BLOB, e,AN a,bY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b INTEGER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT REPLACE
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b INTEGER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID+
CR;


sqltext:
CREATE TABLE t1(a,INT,b INTEGER, c TEXT, d BLOB, e,ANY,
    UNIQUICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT IN�� t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b INTEGER, c TEXT, d BLOB, e,AN�a,bY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);REPLACE INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b a,bEGER, c,TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c TEXT, d BLOB, e,ANY,
    UNI a,ba) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c TEXT, d BLOB, e,ANY,
    UNIFLICT ignore,
  CT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1( json_replace(1,1,1),b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UP


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c TEXT, d BLOB, e,ANY,
    UNIFLICT ignore,
  CT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);REINDEX INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UP


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c TEXT, d BLOB, e,ANY,
    UNIFLICT ignore,
  CT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);REPLACE INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UP


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c TEXT, d BLOB, e,ANY,
    UNIFLICT ignore,
  CT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(e);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UP


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID+
CR;


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);REINDEX UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c),
    UNIQUE(c)il
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,ex�d.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b,2,'abc','b3',3.5);
),
    UNIQUE(c) ON CONFLICT fail
) WITHOWT ROWID;
CREATE INDEX t1dON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
IN INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c TEXT, d BLOB,�e,ANY,
    UNIFLICT ignore,
  CT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UP


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c,TEXT, d BLOB, e,ANY,
    UNIFLICT ignore,
  CT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UP


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c,TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT REPLACE
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c,TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID+
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c,TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);REINDEX INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c,TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);REPLACE INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c,TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(e),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEGER, c,TEXT, d,BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEaER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
DELETE FROM t1WHERE a=7;

CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEaER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
DELETE FROM t1 WHERE a= sqlite_compileoption_used(1);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEaER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
DELETE FROM t1 WHERE a=7;

CREATE INDEX t.d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEaER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
DELETE FROM t1 WHERE a=B;

CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEaER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
DELETE FROM t1 WHERE a=C;

CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEaER, c TEXT, d BLOB, e,ANY,
    UNIQUE(a) ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
DELETE FROM t1 WHERE e=7;

CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,INTEaER, c TEXT, d BLOB, e,ANY,
    UNIQUEמ��ON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
DELETE FROM t1 WHERE a=7;

CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,d,e) VALUES(1,2,'abc','b3',3.5);
INSERT INTO t1 VALUES(2,2,'xyz',NULL,4.25)
ON CONFLICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INT,b,xyz',NU@L,4.25)
ON CONFLTe,ANY,
    UNIQUE(a) ON CONFGICT ignore,
    PRIMARY KEY(b),
    UNIQUE(]) ON CONFLICT fail
) WITHOUT ROWID;
DELETE FROM t1 WHERE a=7;
CREATE INDEX t1d ON t1(d);
CREATE UNIQUE INDEX t1e ON t1(e);
INSERT INTO t1(a,b,c,dabc','b3'VALUES(2,2,'xyz',NU@L,4.25)
ON CONFLTEXT, d BLOB, e,ICT(b) DO UPDATE SET e=max(e,excd.e);


sqltext:
CREATE TABLE t1(a,INTEMPT);
CREATE TABLE counts(v INTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1�AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.INTERSECT1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4


sqltext:
CREATE TABLE t1(a,INTERSECTINT);
CREATE TABLE counts(v INTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1�AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.INTERSECT1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1 SET a=5 WHERE a=4


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
 WITH c(x) AS (values(1)) SELECT(1,2),(3,4),(7,8)
  ON CONFLIERE (a,b)=(eded.a,exed.b


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
 WITH c(x) AS (values(1)) VALUES(1,2001-01-017,8)
  ON CONFLIERE (a,b)=(eded.a,exed.b


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
 WITH �ׇ� AS (values(1)) VALUES(1,2),(3,4),(7,8)
  ON CONFLIERE (a,b)=(eded.a,exed.b


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT a,b c)FR


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT avg( a%NOT INDEXEDY.b1) c)FR


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT avg( a.b2001-01-011) c)FR


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT avg( a2001-01-01%Y.b1) c)FR


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT avg(1)&c)FR


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c  a,b GROUP BY (a,b)= a,b(eded.a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c  a,b GROUP BY (a,b)=(eded.a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c  a,b GROUP BY �a, a,beded.a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c  a,b ORDER BY (a,b)= a,b(eded.a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c  a,b t2 LIMIT (a,b)=(eded.a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c  a,b t2 WHERE (a,b)=(eded.a glob(1,1),exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c "a", avg(1) a,bWHERE (a,b)=(eded.a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c "a","b" "a", avg(1)"b" WHERE (a,b)=(eded.a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c ABORTt2 WHERE (a, "a","b".a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM a,b t2 USING ( a,ba,b)=(e


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM a,b t2 USING (a,b)=(e


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM a,b t2 USING (a�b)=(e


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2  "a","b", "a","b".a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 GROUP BY a,bd.a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 GROUP BY(eded.a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 HAVING(a,b)=(eded.a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 LIMIT (a,b)=(e


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 ORDER BY a,bd,a,exed,b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 ORDER BY a,bd,a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 ORDER BY a,bd.a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 USING (a,b)=(e


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 WHER, (a, "a",(VA,a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 WHER, (a, a,b,"b",a,exed,b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 WHER, a.b "a","b".a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 WHER, �a, "a","b",a,exed,b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 WHER, �a, "a","b",a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 WWHER, (a,H)R, (a, "a","b",a,qxed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 WWHER, (a,H,R, (a, "a","b",a,qxed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 WWHER, (a,HER, (a, "a")"b",a,qxed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 WWHER, (a,HER, (a, "a","b")a,qxed.b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 WWHER, (a,HER, (a, "a","b",a,qxed)�));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2,WHER, (a, "a","b",a,exed,b));


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c NOT glob(1,1) (a,b


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c NOTNULL WHERE (?<b)OR true)(e


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c NOTNULL WHERE (a *-b)OR true)(e


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c NOTNULL WHERE (a,b)AND true)(e


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c NOTNULL WHERE (a,b)OR true)(e


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c NOTNULL WHERE (a-b)OR  `a`)(e


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c NOTNULL WHERE (a<b)IS true)(e


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c NOTNULL WHERE (a<b)OR  `a`)(e


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c NOTNULL WHERE+(a,b))(e


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c) glob(1,1) glob(A,1)FR


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c) glob(1,1)FR


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c)>glob(1,1)FR


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,b) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=EXISTS(SELECT c)FR


sqltext:
CREATE TABLE t1(a,b,c DEFAULT 0,PRIMARY KEY(a,b));
INSERT INTO t1 AS nx(a,r) VALUES(1,2),(3,4),(7,8)
  ON CONFLICT(a,b) DO
    UPDATE SET c=(SELECT c FROM t2 WHERE (a,b)=(eded.a,exed.b));


sqltext:
CREATE TABLE t1(a,b,c,d""""""REFERENCES"",eRY KEY(b,,10,11,12))
I=SERT INTO t1(a,b,c,d) SELECT * FROM d�ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d""""REFERENCES""REFERENCES""REFERENCES
I=SERT INTO t1(a,b,c,d) SELECT * FROM d�ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d""REFERENCES""REFERENCES""REFERENCES"",eRY KEY()
I=SERT INTO t1(a,b,c,d) SELECT * FROM d�ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,FOREIGN KEY( 'a'COLLATE nocase);11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY( 'a'COLLATE nocase);11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY( 'a'COLLATE nocase11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY( 'a'IS
2001-01-01,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY( 'a'IS
NULL,( WITH c(x) AS (values(1)) 1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY( @1b,@UES(1,2,3,4),@5, @1, @18),(9RTO t1(a(VA,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY( group_concat( avg(1)),b,c,d) AS INTO t1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(a,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT*, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b, (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a FROM data
ON CONFLICT(b,d) UPD`TE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b, (VALUES(1,2,3,4)UNION ALL),(9,10,11,12))
INSERT INTO t1(a FROM data
ON CONFLICT(b,d) UPD`TE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b, a,betime(1,1,1)COLLATE nocase,b,c, sqid(),b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b, datetime(1,1,1	,b,c, sqlite_source_id(),b,c,d))SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b, datetime(1,1,1)COLLATE nocase,b,CONFLICT9,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b, datetime(1,1,1)COLLATE nocase,b,c, sqid(),b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b, datetime(1,1,1)COLLATE nocase,b,c,d) AS(9,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b, datetime(1,1,1)COLLATE nocase�b,c,d) AS(9,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,@UES(1,2,3,4),@5(6,7,8)$(9RT INTO t1(a(VA,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,@UES(1,2,3,4),@5(6,7,8)$CONSTRAINTt1(a(VA,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,LA,b,c,UES(1,2,3,4)COLLATE nobase,@5,6,7,8),(9RT(ad) SELECT * FROM data
ON OONFLICT(b,d) UPDATE 


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,LUES(1,2,3,4)COLLATE nocase,@5,6,7,8),(9RT(a(VA,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE 


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,LUES(1,2,3,4)COLLATE nocase,@5,6,7,ES(1,2,3,4)COLLATE nocase,@5,6,8),(9RT(a(VA,b,c,d) SELECT * FROM dCONFLICT(b,d) UPDATE 


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH  `a`(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) WITH c(x) AS (values(1))  SELECT * FROM a,ba
ON CONFLICT(b,d) UPDATE


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,a,b,c,d,CURRENT_DATEa,b,c,d) SELECT *FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,a,b,c,d,PRI(1,2,3,4(a,b,c,d) SELECT *FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,b,c,d) SELECT * FROM datd) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12)
INSERT INTO t1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (SELECT(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data
�N CONFLICT


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,(VALUES(1,2,3,4),(5,6,7,8),(9,8),(9,10,11,12))
INSE(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(   a,ba,ba,ba,b,c,da,b,c,d) SELECT * FROM d;
WI


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(  a,ba,ba,b,c,da,b,c,d) SELECT * FROM d;
WI


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1( a,ba,b,c,da,b,c,d) SELECT * FROM d;
WI


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,E,c,d) SELECT * FROM (b,d) UPDATE


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM a,ba
ON LIC,(b,d)ON CONFLICT UPDATE


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM d (1)O, CONFLICT(b,d) UPDATE


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM d (1)ON CONFLICT(b,d(�UPDATE


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM d (1)ON CONFLICT(b,d) UPDATE


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data (1)CONFLICT) UP


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data ORDER BY instr(1,1)


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data ORDER BY(1)CONFLICT


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data ORDER BY.1)CONFLICT


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data,DATEON 


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM datf�ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM om()a
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM( (1)
ON CONFLICT(b,d) UPDATE


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM(data
ON CONFLICT(b,d) UPDATE


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) WITH DATABASEc(x) AS (values(1))  SELECT * FROM data,DATEON 


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) WITH a(x) AS (values(1))  SELECT * FROM a,ba
ON CONFLICT(b,d) UPDATE


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,88888888888888888888888.886,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data
�CT


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,8888888<8882001-01-01888886,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data
�CT


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,b,c,d) AS (VALUES(�,2,3,4),((VALUES(1,2,3,4),(52))
INSERT INTO t1(a,b,c,d11111111�111ROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a,c,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data
�N CONFLICT


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(a�b,c,d) AS (SELECT(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data
�N CONFLICT


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(c,c,c,c) AS (VALUES( soundex(1),6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data
�N CONFLICT


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(c,c,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data
�N CONFLICT


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));
WITH data(c,d,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data
�N CONFLICT


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));PRAGMA
WITH data(a,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));REINDEX
W.TH data(a,b,
INSERT INTO t1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));REINDEX
WITH data(a,b,
INSERT INTO t1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));REINDEX rtrim(1,1)a,b,
INSERT INTO t1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));VACUUM
TEMP data(a,b,cINSERT INTO t1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d));VACUUM
WITH data(a,b,cINSERT INTO t1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d))WITHOUT ROWID,b,c,d) AS (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d,(9,10,11,12)
@NSERT IBT (VALUES(1,2,3,4),(5,6,7,8),(9,10,11,12))
`d) SELE * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(b,d,c,d) AS (VALUES(1,2,3,4/,(5,6,7,8),(9,10,11,12))
INSERT INTO t1(a,b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,a))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b, json_replace(1,1,1),b,c,d) VALUES(1,2,RDER BY 


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,b))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT*, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,b))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(d,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT*, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX s�bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ONOT INDEXED BY sqlit+a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b -1,b);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,2001-01-012,3,10),(11,12,13,14)
ON CONFLICT(c,d) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b*b);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,2001-01-012,3,10),(11,12,13,14)
ON CONFLICT(c,d) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b, json_replace(1,1,1),b)c,d) VALUES(1,2,RDER BY 


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,a);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,b -1);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,2001-01-012,3,10),(11,12,13,14)
ON CONFLICT(c,d) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,b);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,2001-01-012,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,b);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,2001-01-012,3,10),(11,12,13,14)
ON CONFLICT(c,d) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,b);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,2001-01-012,3,10),(11,2001-01-0112,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,b);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,2001-01-012,3,10),(11,2001-01-0112,13,14)
ON CONFLICT(c,d) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,b);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6 -1,7,8),(9,2 -1,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,b);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6 -1,7,8),(9,2 -1,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a;1000;
a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,b);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6 -1,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,b);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6 -1,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a;1000;
a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,b);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;VACUUM


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,b);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY+2 daa;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,b);
INSERT INTO t1(a,b,c,d) VALUES(2001-01-015,6,7,8),(9, randomblob(1),13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,b);
INSERT INTO t1(a,b,c,d) VALUES(2001-01-015,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,b);ANALYZE INTO
SELECT *, 'x' FROM t1 ORDER BY 


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,2001-01-018),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY  sqlite_source_id();


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,2001-01-018),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY sqlite_version(),+a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SAVEPOINT 'x'F


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 GROUP BY sqlite_version()HAVING #a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 GROUP BY sqlite_version()HAVING +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 GROUP BY sqlite_version()HAVING 1=1 +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 GROUP BY sqlite_version()HAVING 2001-01-01+a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 GROUP BY sqlite_version()HAVING sqlite_version() +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 GROUP BY sqlite_version()HAVING++a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 GROUP BY sqlite_version()ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ONOT INDEXED BY sqlite_AUTOINCREMENTve+a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ONOT INDEXED BY sqli�e_ve+a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ONOT INDEXED BY sql�t+a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ONOT INDEXED BY sq�ite_ve+a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY  sqlite_source_id();


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY  sqlite_source_id()COLLATE nocase;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;ANALYZE


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;REINDEX


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY a,b


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY d;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY sqlite_version(),+ "a","b"a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY sqlite_version()COLLATE nocase,+a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY+2 daa;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY+3 days +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x'OR true FROM t1 ORDER BY sqlite_version(),+a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(a,c,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY  sqlite_source_id();


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b,c);
INSERT INTO t1(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY sqlite_version(),+a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(b<b);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,2001-01-012,3,10),(11,12,13,14)
ON CONFLICT(c,d) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t1 ORDER BY +a;


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMARY KEY(d,c))WITHOUT ROWID;
CREATE UNIQUE INDEX t1bc ON t1(c,c);
INSERT INTO t1(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
ANALYZE*, '


sqltext:
CREATE TABLE t1(a,b,c,d,PRIMAR`dONFLICT(b,d) UY KEY(b,d));
^.TH da prntf(1,1)d) AS 10(1�,1ELE�6,7,8),(9,10(WHEREALTER11,12))
I�SECT *����M`data
ON CO


sqltext:
CREATE TABLE t1(a,b�c,d,PRIMARY KEY(b, datetime(1,1,1),b,c, sqlite_source_id(),b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(a,�Ӝ�d,PRIMARY KEY(b, e,b,Cdatetime(1,1,1)COLLATE nocase,b,CONFLICT9,b,c,d) SELECT *%FROM data
OT(b,d) UPDdE SET


sqltext:
CREATE TABLE t1(aON CONFLICT INT,b INTEGER, c TEXT, d BLOB, e AEXPLAIN QUERY PLANON CONFLICT ignore,
    PRIMARY KEY(b),
    UNIQUE(c) ON CONFLICT fail
) WITHOUT ROWID;
CREATE INDEX t1d ON t1(d);ANALYZE TEMP;VACUUM


sqltext:
CREATE TABLE t1(b�b,c,d,PRIMARY KEY(b, datetime(1,1,1),b,c, sqlite_source_id(),b,c,d) SELECT * FROM data
ON CONFLICT(b,d) UPDATE SET


sqltext:
CREATE TABLE t1(� INT);
CREATE TABLE counts(v INTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) WITH c( a,bx) AS (values(1))  VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UPDATE t1t1 WHERE a=7;


sqltext:
CREATE TABLE t1(� INT);
CREATE TABLE counts(v INTEGER PRIMARY KEY, n INT)/*WUT ROWID*/;
CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN
  INSERT INTO counts(v,n) WITH �ׇ� AS (values(1))  VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r2 AFTER UPDATE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
  INSERT INTO counts(v,n) VALUES(new.a,1)
      ON CONFLICT(v) DO UPDATE SET n=n+1;
END;
CREATE TRIGGER r3 AFTER DELETE ON t1 BEGIN
  DELETE FROM counts WHERE v=old.a AND n==1;
  UPDATE counts SET n=n-1 WHERE v=old.a;
END;
INSERT INTO t1(a) VALUES(1),(2),(1),(3),(1),(3),(2),(4),(7);
UDELETE FROM t1 WHERE a=7;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,b�d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1, ltrim(1,1),7,8),(9, randomblob(1),13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(1)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *,d'x' FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9, randomblob(1),13,04)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
S;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 GROUP BY a,b +a;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY a,b


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, *,b 'x' FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, *,b 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, a,b 'x' FROM t2 GROUP BY #a;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, a,b 'x' FROM t2 ORDER BY a,b +a;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, a,b, a,b'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, a,b,'x' FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, a,b,'x' FROM t2 ORDER BY +a;END


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, a,~ 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, avg(1) 'x' FROM t2 ORDER BY sum(1) Ba;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, avg(B) 'x' FROM t2 ORDER BY Ba;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, c,b 'x' FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *,A'x' FROM t2 ORDER BY a,b +a;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+d0;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, a, *FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2( a,ba,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, a,b 'x' FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2(a char(1),b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, round(?,A) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c blob,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,2001-01-013,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c char(1),d,PRIMARY KEY(a))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT*, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d char(1),PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
S;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(a))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,a,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(a))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(b))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(72001-01-01)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(b))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);EXPLAIN
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY+2 DESC


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(b))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(c))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,2001-01-013,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
S;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(c))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,2001-01-013,10),(11,12,2001-01-0113,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
S;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(c))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
S;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID+
CR)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX  `a` ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDT INDEXED BY `a`


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2( -1);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(-1,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(5,6,7,8),(9,2,3,10),(11UNIQUE IALUES(1,THOUT ROWID;7,8),(9,2,3,10),(11,12,13,14)
OgggggggggN CONFLICT(c,b) DO UPDATE SET a=a+d0;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b, json_replace(1,1,1)COLLATE nocase,b,c,d) VALUES(


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b, json_replace(1,1,1)COLLATE nocase�b,c,d) VALUES(


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,b);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY+2 days


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,b,c,d)VALUES,6,������������� t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,a,d) VALUES( -11,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,a,d) VALUES(1,2,3,4),(5,6,7,8),(0,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,a,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,.2,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;REINDEX


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,a,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY 2001-01-01


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,a,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY sqlite_source_id() +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,a,d) VALUES(2001-01-011,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,a,d) VALUES(2001-01-015,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;REINDEX


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,a,d) VALUES(9,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;REINDEX


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES( rtrim(1,1),6,7, zeroblob(12001-01-01)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES( rtrim(1,1),6,7, zeroblob(12001-01-01)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;REINDEX


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES( rtrim(1,1),6,7, zeroblob(12001-01-01)COLLATE nocase)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES( rtrim(9,1),6,7, zeroblob(12001-01-01)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,2001-01- sqlite_compileoption_get(1))
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY+2 DESC


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,2001-01-018),(9,2, json_type(1,1),14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,2001-01-018),(9,2,3, total_changes())
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, group_concat(?,1) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,2001-01-018),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 GROUP BY zeroblob(1)


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,2001-01-018),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY round(1,1)LIMIT -1;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,2001-01-018),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY+2 DESC


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,',8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, 1=18),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(.2001-01-01)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(1)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 GROUP BY  'a'


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(1)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 GROUP BY + "a","b"a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(1)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 GROUP BY?+a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(1)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, *,b FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(1)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, a,b FROM t2 GROUP BY strftime(1,1,1,1) +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(1)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, b,b FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(1)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, group_concat(1,1) 'x' FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(1)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT A, 'x' FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(1)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT sum(1) FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(1)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;EXPLAIN
SELECT *, 'x' FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(12001-01-01)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(12001-01-01)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;VACUUM


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(16001-01-01)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(720.1-01-01)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(7200
-01-01)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(72001-01-01)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;REINDEX


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(72001-01-01)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;VACUUM


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(72001-01-01)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT �, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(72001E01-01)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3, total_changes())
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY 2001-01-01


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3, total_changes())
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY 20012001-01-01-01-01


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3, total_changes())
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY 2001501-01


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3, total_changes())
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, count(1) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3, total_changes())
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, group_concat( a,b1<1) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3, total_changes())
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, group_concat(1,1) 'x' FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3, total_changes())
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, group_concat(1,?) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3, total_changes())
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, group_concat(1<1) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3, total_changes())
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, group_concat(?,1) 'x' FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3, total_changes())
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, group_concat(C,1) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3, total_changes())
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT @1 'x' FROM t2 ORDER BY #a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3, total_changes())
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT @1 'x' FROM t2 ORDER BY d;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3, total_changes())
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT avg(?) FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3, total_changes())
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT+avg(1) FROM t2 ORDER BY + avg(1)a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,++++++++++++++++++++++++++++++++b) DO UPDTE SET a=a+1000;
SELECT DISTINCT*, 'x',a,b FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(-1,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=~+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(.1,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 GROUP BY random() +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(.1,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY a,b


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12, ?113,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;EXPLAIN QUERY PLAN
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+100.;
SELECT *, 'x' FROM t2 GROUP BY NOT+a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+100.;
SELECT *, round(1,A) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+10002001-01-01;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+10002001-01-01;
SELECT *, 'x' FROM t2 ORDER BY strftime(1,1,1,1) +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *,  random()/'x' FROM t2 ORDER BY randomblob(1) +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x'  ROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 GROUP BY -1;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 GROUP BY a,b -1;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 GROUP BY avg(1) +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 GROUP BY zeroblob(1)


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY 51;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY 52001-01-011;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY round(1,1)LIMIT 
1;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY round(1,1)LIMIT "a","b" -1;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY round(1,1)LIMIT -1;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY round(1,1)LIMIT 51;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY sqlite_source_id() -1;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY++a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY+2 COLLATE nocase~ays


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY+2 DESC


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY+3 days


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY+4 COLLATE nocasedays


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY+4 COLLATE nocase~ays


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDT INDEXED BY `a`


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x'ASC FROM t2 ORDER BY Aa;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, changes()/ last_insert_rowid()'x' FROM t2 ORDER BY randomblob(1) +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, changes()/ total_changes()'x' FROM t2 ORDER BY randomblob(1) +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, changes()/CURRENT_DATE'x' FROM t2 ORDER BY randomblob(1) +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, last_insert_rowid() 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, round( -11,A) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, round(1,1)&'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, round(1,1)OR '+2 daysx' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, round(1,A) 'x' FROM t2 ORDER BY +X;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, round(1,B) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, round(2001-01-011,D) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, round(?,A) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, round(?<A) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, total_changes() 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *,*'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *,-round(1,1) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINC,*, 'x',a,b FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT "a","b" "a","b"


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT "a","b","a","b"


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT "a","b"ORDER BY "a","b"


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT "a","b"ROM t2;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT "a"LIMIT"a","b"


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT @1 || 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT @1'x' FROM t2 ORDER BY #a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT @1'x' FROM t2 ORDER BY +a;VACUUM


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT*, 'x' a,b FROM t2 ORDER BY +a;VACUUM


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT*, 'x' a,b,a,b FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT*, 'x',a, *FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT*, 'x',a,b FROM t2 ORDER BY +a;VACUUM


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT?, 'x' a,b FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT?,A'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT?IS'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT NOT'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT affinity(1) t2 GROUP BY zeroblob(1)


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT sum(1) FROM t2 ORDER BY avg(1) + count(1)


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT sum(1) FROM t2 ORDER BY avg(1)%Y +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT sum(1) FROM t2 ORDER BY avg(�) + avg(1)a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT sum(?) FROM t2 ORDER BY avg(1) +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;EXPLAIN QUERY PLAN
SELECT DISTINCT*, 'x' FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+d0;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET c=a+1000;
SELECT *, round(?,A) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(112001-01-01,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(19,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, round(1,A) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(91,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, round(?,A) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,CURRENT_TIME),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,?,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(7,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, round(1,A) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,b,d,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
S;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,c,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(12001-01-01)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,c,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3, total_changes())
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;ANALYZE


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(a,c,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, round(?,A) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,a,d) VALUES(1,2,3,4),(5,6,3,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,a,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;REINDEX


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,a,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY round(1,1) +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),( round(1,1),2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 GROUP BY zeroblob(1)


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY NOT+a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY round(1,1)LIMIT -1;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY+2 DESC


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, *, *FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, a, *FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, a, *FROM t2 ORDER BY �a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, a, *FROM t2 WHERE BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, a, *FROM t2 �RDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, a,b FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, count(1) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, group_concat(1,1) 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, round(1,1)OR 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, sqlite_source_id() a,b FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT*, a, *FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT NOT'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);
INSERT INTO t2(c,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT avg(1) FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);EXPLAIN
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(1)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);EXPLAIN
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7, zeroblob(1)),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, a,b FROM t2 GROUP BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);EXPLAIN
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT DISTINCT @1'x' FROM t2 ORDER BY @1;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);EXPLAIN QUERY PLAN
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;EXPLAIN QUERY PLAN
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c);EXPLAIN QUERY PLAN
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;EXPLAIN QUERY PLAN
SELECT *, 'x' FROM t2 ORDER BY +a;EXPLAIN QUERY PLAN


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b,c)�
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(b<c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
S;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES( instr(1,?),6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES( instr(?,1),6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES( unicode(1),6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,-unicode(1),10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,-unicode(1),10),(11,12,2001-01-0113,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,2001-01-013,10),(11,12,2001-01-0113,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9, substr(1,1,1),13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+ 1=1;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET a=a+1<00;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(c,c);
INSERT INTO t2(a,b,c,d) VALUES(1,2,3,4),(5,6,7,8),(9,2,3,10),(11,12,13,14)
ON CONFLICT(c,b) DO UPDATE SET c=a+1000;
SELECT *, 'x' FROM t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(a,b,c,d,PRIMARY KEY(d))WITHOUT ROWID;
CREATE UNIQUE INDEX t2bc ON t2(d) VALUES(1N
SELECT *, 'c,d) VA t2 ORDER BY +a;


sqltext:
CREATE TABLE t2(x "a","b" PRIMARY KEY, "a","b"NIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),( ?16,7),(3,1),(8,9),(6,11),(1,1);VACUUM;


sqltext:
CREATE TABLE t2(x INTEGE)/*WIT RWID*,E TABtruAUTOINCREMENTCLE  IN y INT UN QUE)/*WIT RWID*�
CREATE 2(x,y) aEL,b);
ded.x);
INSERT INSERT INTO t3 VALUES(1, json_type(1,1)2),(3,4)((1,5),(6,7),(3,1),(�,9),(6,�1),(1,1);
INSERT INTO t2(x,y) SeLECT a,b json_array(1,1,1)true
  /N CONFLICT(x) DO UPDATE SET y=max(t2.y��luded.x);
INSERT INTO t2(x,y) SElECT a(b FROWID*/;
CRM t3 WHERE truo
  ON CONFLICT() E y<e��������������������;


sqltext:
CREATE TABLE t2(x INTEGER DEFAULT KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),( ?16,7),(3,1),(8,9),(6,11),(1,1);VACUUM;ANALYZE


sqltext:
CREATE TABLE t2(x INTEGER DESCARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(8,9),(6,11),(1,1);
INSERT INT(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(  "a","b""a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT U,IQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT 1=1 a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT U,IQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT@1=1 a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT 1=1 a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT 1=1>a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, likely(1)b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT randomblob(1) a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT round(1,1) a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT@1=1 a, @1b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT@1=1 a,b FROM t3WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT@1=1 a,b FROM t3 WHERE 2001-01-01


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT@1=1&a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,7),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT 1=- a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,7),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT 1=1 a,b FROM t3WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,7),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT 1=1 a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,7),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT 2001-01-011=1 a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,7),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,7),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT random() a,b FROM t3WHERE true



sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,7),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT random() a,b FROM t3 WHERE true



sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,7),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT randomblob(1) a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,7),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT round(1,1) a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,7),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT@1=1 a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,7),(1,7),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT 1=1 a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,4),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT�UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT 1=1 a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PR,MARY KEY, y INT�UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT@1=1 a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PRICARY KEY, y INT UNIQUE)/*WIT ROWI***********************b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5)*(6,7),(3,1),(8,9),(6,11),(1,1);
IUE)/*WIT ROWI****************NAERT INTO t2(y,y) SELECT randombbob(22001-01-01) a,b FROM t3 WHERE true
  ON CONFLICT(x)y=max(t2.y,uCOLLATE binaryded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY)y UNIECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY) y UNIECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, "a","b"NIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),( ?16,7),(3,1),(8,9),(6,11),(1,1);VACUUM;VACUUM


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, CURRENT_TIMESTAMPy INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),( ?16,7),(3,1),(8,9),(6,11),(1,1);VACUUM;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, quote UNIQUE)/*WIT R@ *********ID*
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6test1,11),(1,1(;
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
 ON CONFLICT(x) DO�PDATE SET y=max(t2.y,excluded.x);
INSERT INTO t2(x,y) SELECb FROM t3 WHERE true
  ON CONF0I�(xI 3,1),(8,9),(6,y=eextrded.y WHERE y<excluded.y


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y "a","b"QUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT U,IQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT 1=1 a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*W*T ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,(6,7),(3,1),(8,9),(6,11),(1,1,4),(1,5),(6,7),(3,1),(F,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(2001-01-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SEC y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT RWHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID**;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(R PRIMARY KEY, y Ia,b);REINDEX
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
IN;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b UNIQUE));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE round(1,B)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1) a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 SELECT(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES /* */(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT sqlite_source_id() a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES( /* */3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES( avg(1),4),( avg(1),7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y�uded.y);y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES( avg(1),4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES( hex(1),4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,? FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES( hex(1),4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES( sqlite_source_id(),7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES( sqlite_source_id(),7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(1001-01-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES( sqlite_source_id(),7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(22001-01-01) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(0,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, sqlite_source_id()b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(0,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,? FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(0,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 ORDER BY NOT"a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1, 'a''b'),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE round(1,B)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1, hex(1)),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE round(1,B)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1, hex(1)),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT sqlite_source_id() a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1, sqlite_source_id()),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, random() || b FROM t3 WHERE true



sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(2,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT total_changes()GLOB a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,  zeroblob(1001-01-011)),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,  zeroblob(12001-01-01)),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,  zeroblob(2001-01-011)),(3,1),(8,1),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,  zeroblob(2001-01-011)),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT -1 a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,  zeroblob(2001-01-011)),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, 'a'b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,  zeroblob(2001-01-011)),(3,1),(8,9),(6,11),(3,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,  zeroblob(202001-01-0101-01-011)),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,  zeroblob(22001-01-01001-01-011)),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,  zeroblob(6001-01-011)),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3, 'a''b'),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, 'a'b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,20.1-01-014),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1, sqlite_source_id()),(1,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, 'a'b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1, sqlite_source_id()),(6,.1),(1,1);
INSERT INTO t2(x,y) SELECT a, random()b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1, sqlite_source_id()),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, random() || b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1, sqlite_source_id()),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, random()b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;VACUUM


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1, sqlite_source_id()),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, random()b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROMD*/;
CREATE ue
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHdy<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1, sqlite_source_id()),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y= last_insert_rowid();
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1, sqlite_source_id()),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(  "a","b""a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1, sqlite_source_id()),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, trim(1,1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1, sqlite_source_id()),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, zeroblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1, sqlite_source_id()),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT sqlite_source_id() a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,1),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=mIN(  "y","b""a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,4),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE round(1,B)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,4),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE round(?,B)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),( ?16,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),( ?16,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),( ?16,7),(3,1),(8,9),(6,11),(1,1);VACUUM;DROP


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),( ?16,7),(3,1),(8,9),(6,11),(1,1);VACUUM;VACUUM


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),( ?=6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,2),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 ORDER BY "vera","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),( json_group_array( -11),1);
INSERT INTO t2(x,y) SELECT total_changes()GLOB a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),( json_group_array(1),1);
INSERT INTO t2(x,y) SELECT total_changes()GLOB json_array(1,1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),( json_group_array(1),1);
INSERT INTO t2(x,y) SELECT total_changes()GLOB@a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),( json_group_array(?),1);
INSERT INTO t2(x,y) SELECT total_changes()GLOB a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3, 'a''b'),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3, coalesce(1,1)),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3, json(1)),(1,1);
INSERT INTO t2(x,y) SELECT sqlite_source_id() a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3, randomblob(1)),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(  "a","b""a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3, randomblob(1)),(1,? -1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3, randomblob(1)),(1,?);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3, randomblob(1)),(1,NOT?);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3, randomblob(1001-01-011)),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3, randomblob(2031-01-011)),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),( randomblob(1),1);
INSERT INTO t2(x,y) SELECT zeroblob(1)GLOB randomblob(1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),( randomblob(1),1);
INSERT INTO t2(x,y) SELECT zeroblob(1)GLOB randomblob(12001-01-01) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),( randomblob(1),1);
INSERT INTO t2(x,y) SELECT zeroblob(1)GLOB randomblob(2) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),( randomblob(1),1);
INSERT INTO t2(x,y) SELECT zeroblob(1)GLOB randomblob(4) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),( randomblob(1),1);
INSERT INTO t2(x,y) SELECT zeroblob(A)GLOB a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),( randomblob(3),1);
INSERT INTO t2(x,y) SELECT zeroblob(1)GLOB randomblob(1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(6,9),(6,11),(1,1);REPLACE INTO t2(x,y) SELECT random() a,a FROM t3 WHERE true



sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,01),(1,1);
INSERT INTO t2(x,y) SELECT  unicode(1) || last_insert_rowid()  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2 /* */SELECT a. *FROM t3 LIMIT`a`REy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2 /* */SELECT a. *FROM t3 `a`REy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x'y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,x) SELECT a,? FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);ANALYZE


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT  a,ba. *,ROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT  a,ba. *,ROM,t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT  avg(1) a, abs(1)b FROM t2 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT  round(1,1)&a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT  unicode(1) | last_insert_rowid()| last_insert_rowid()  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT  unicode(1) | randomblob(1)| last_insert_rowid()  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT  unicode(1) ||  a, random() || b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
IN


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT  unicode(1) ||  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y= unlikely(1)luded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT  unicode(1) || last_insert_rowid()  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT  unicode(1) || last_insert_rowid()  a,b FROM t3 WHERE true
  ON CONFLICT(y) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT  unicode(1) || last_insert_rowid() ||   a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT  unicode(1) || round(1,1)  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT -1 a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT :eroblob(1) ||  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT DISTINCT(1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT DISTINCT(1) ||  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT T. *FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, datetime(1,1,1)FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y)AND true;
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, random() *b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);
IN


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, random() || trim(1,1) b FROM t3 WHERE true



sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, random() ||2001-01-01 b FROM t3 WHERE true



sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, random()b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(-"a",excluded.y);
IN


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, random()b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.x);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, random()b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y|excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(  "y","b""a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y) || true;
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y)AND true;
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(2)b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, sqlite_source_id() || b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, total_changes()b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,? FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(  "a","b""a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,?AND true FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);ANALYZE


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,NOT? FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 (1)REded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 GROUP BY(1);Ey;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 ORDER BY "�","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 ORDER BY 'a''b'


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 ORDER BY abs(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE  `a`
  IN  (9)LICT(y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE  `a`
  IN  (A)LICT(y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE  `a`
  IN  (A)OR true


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE _rue
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE likely(1) CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE round(0,B)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE round(1-B)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE round(1/B)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE round(1<B)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  IN  (A)LICT(y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  IS  (1)LICT(y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET x=max(t2.y,excluded.x);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=TEMPt2.y�uded.y);y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=j�x(t2.y,excluded.y);y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=mIN(  "y","b" -1,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=mIN(  "y","b""a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=maIFt2.y�uded.y);y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(  "y",  "a","b""a","b""b""a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(  "y", "y","b""b""a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(  "y", randomblob(1),excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(  "y","b""a", trim(1,1));
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(  "y","b""a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(  "y",NOT"a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "  -1",excluded.y)%Y;
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( " -1 ",excluded.y)%Y;
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "+2 daysa",excluded.y)%Y;
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( ".",excluded.y)%Y;
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( @1y,excluded.y) >= true;
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( @1y,excluded.y) glob(1,1)INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( @1y,excluded.y) || true;
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( @1y,excluded.y)AND round(1,1);


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y%Y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.r);y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.x);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.x WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y%Y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y) >=@true;
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHER, true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE  zeroblob(1);


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y)AND ltrim(1,1);


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y)AND@true;VACUUM


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excl�ded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max�t2.y�uded.y);y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
ISNULL  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
NOT  IN CONFLICT(x) DO;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
NOTNULL  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a. *,R.M t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT b, random() || b FROM t3 WHERE true



sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT changes() a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.x);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json( -11) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json(0) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json(1) a, random()b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json(1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y)%Y;
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json(1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE json(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json(1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT json(1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json(1)OR a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json(A) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json_array_length(1,1)
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json_group_array(1) a,b FROM t3 WHERE json_extract(1,1)T(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json_group_array(1) a,b FROM t3 WHERE@true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json_group_array(?) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT max(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT random() a, random() || b FROM t3 WHERE true



sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT random() a, random()b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT randomblob(1)= zeroblob(1)  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT round(1,1) a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT round(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT sqlite_source_id() a, abs(1)b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT sqlite_source_id() a,b FROM t3 ORDER BY "a","a"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT sqlite_source_id()COLLATE nocase a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT sqlite_version()GLOB a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
IN


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT total(1) a, avg(1)t3 WHERE@true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FR,M t3 WHERE t  ON CONFLICT(x) DO UPDATE SET y=excd.y WHERE y<uded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT total(1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT total(1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT total(1) a,b FROM t3 WHERE@true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y= strftime(1,1,1,1)<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT total(1) a,b glob(1,1) FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT total(?) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT total_changes()GLOB a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y= strftime(1,1,1,1)<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT total_changes()GLOB a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y MATCH y like(1,1)y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT total_changes()GLOB a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y MATCH y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT total_changes()GLOB json_array(1,1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT total_changes()GLOB round(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT total_changes()GLOB total_changes() a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob( -11) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob( random()*-11) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1) >= randomblob(1)a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1) >> zeroblob(1)  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1) a, random()b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1) a,b FROM t3 ORDER BY  "a","b""a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1) a,b FROM t3 ORDER BY "a","a"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1) a,b FROM t3 ORDER BY "a"<"b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1) | avg(1)|  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1) | randomblob(1)| zeroblob(1)  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1) || zeroblob(1)  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1)%a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1)& 'a'a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1)*a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1)-a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1)/a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1)AND zeroblob(1)  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1)GLOB randomblob(1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1)GLOB zeroblob(1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1)LIKE a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(A) a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(A)GLOB a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT-?,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT-sqlite_source_id() a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT?a,? FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT 1=1 a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT 1== a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT :eroblob(1)&a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT a,b FROM t3Wy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT a,b FROM t3 WHERE-true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT changes() a,b FROM t3Wy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT changes() a,b FROM t3 WHERE-true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT changes() a,b FROM t3 WHERE-true
AND true  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT coalesce(1,1)GLOB a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT random() a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob( avg(1)-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(1) a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(1)GLOB json_array(1,1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(1000011-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(1001-0 -111) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(1001-01-011) ||  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(1001-01-211) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(1001-01-311) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(1001-04-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(1001-51-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(1001-81-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(1003-01-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(2.01-01-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(20 || 01501-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(2001 || 011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(2001-01-011)  "a","b" t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(20015+1-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(2001501-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(22001- -101001-01-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(22001-01-01001-01-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(22001-01-01001-020001) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(22001-01-05001-01-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(22001-01E01001-01-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(22071-01-01001-01-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(2E01501-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(5001E01-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(5009-01-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(502001-01-0101-01-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(5041-01-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(62001-01-01) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(62001-01-01001-01-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(92001-01-01001-01-011) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(?) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT zeroblob(1) >= zeroblob(1)  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT zeroblob(1)&a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT-a,b FROM t3Wy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT-a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT@1=1 a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t3 /* */SELECT a,b FROM t3 ORDER BY @1REy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t3 /* */SELECT a,b FROM t3 ORDER BY(1) -1;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1); WITH c(x) AS (values(1)) 
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  IN CONFLICT(x) DO UPy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);EXPLAIN
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y)AND true;
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);EXPLAIN
INSERT INTO t2(x,y) SELECT total(1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);EXPLAIN
INSERT INTO t2(y,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);REPLACE INTO t2(x,y) SELECT  unicode(1) || last_insert_rowid()  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);REPLACE INTO t2(x,y) SELECT a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y)AND true;
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);REPLACE INTO t2(x,y) SELECT random() a,b FROM t3 WHERE true



sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);REPLACE INTO t2(y,y) SELECT 1=1 a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,9);
INSERT INTO t2(x,y) SELECT a,b FROM t3 ORDER BY "a"*"b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,9);
INSERT INTO t2(x,y) SELECT a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,~~~~~~~~~~~~~~~~~~~~~~9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT total(1) a, avg(1)t3 WHERE@true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,|) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,9),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT  unicode(1) || last_insert_rowid()  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,9),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT sqlite_source_id() a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,9),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1) a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,7),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1) >= zeroblob(1)  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,7),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1)&a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,42001-01-01),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json(1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,5),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1) >= zeroblob(1)  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,5),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1)&a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,5),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);REPLACE INTO t2(x,y) SELECT random() a,b FROM t3 WHERE true



sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,7),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,?),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,2001-01-01);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,?),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y= strftime(1,1,1,1)<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,?),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y NOTNULL<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,?),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y OR true<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,?),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< trim(1,1);


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,?),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT round(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(6,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,9);
INSERT INTO t2(x,y) SELECT a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(7,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT  unicode(1) ||  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(7,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( @1y,excluded.y)AND round(1,1);


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(7,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y)AND@true;
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2001-01-012),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT sqlite_source_id() a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,8),(3,4),(1,4),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE round(1,B)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(2001-01-011,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(2001-01-011,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,9);
INSERT INTO t2(x,y) SELECT a,b FROM t3 ORDER BY "a","b"


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(3,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT a,b FROM t3Wy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(6,2),(3,  zeroblob(2001-01-011)),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(6,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT-a,b FROM t3Wy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(9,2),(3,4),(1,5),(6,7),(3, randomblob(2001-01-011)),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(9,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT  unicode(1) ||  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(9,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( @1y,excluded.y)AND round(1,1);


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(9,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y)AND@true;
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(9,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);REPLACE INTO t2(x,y) SELECT random() a,a FROM t3 WHERE true



sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b); WITH c(x) AS (values(1)) 
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET r=max(t2.y,excluded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);EXPLAIN
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3, randomblob(1)),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);REPLACE INTO t2 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=@ax(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.yWHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);REPLACE INTO t2 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=@ax(t2.y,excluded.y);
SELECT @t2(x,y)y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);REPLACE INTO t2 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;ANALYZE


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);REPLACE INTO t2 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);REPLACE INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE �3(a,b);
INSERT INTO t3 VALUES(1,2),(~~~~~~~~~~~~~~~3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
@SERT INTO t2(x,y) SELECT json(1) a, abs(1)b FROM t2 WHERE true
 ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID/*WIT RWHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID/*WIT ROWID*/;
CREATE TABLE t3(R PRIMARY KEY, y Ia,b);ANALYZE INTO t3 VALUES;
IN;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),( ?16,7),(3,1),(8,9),(6,11),(1,1);VACUUM;ANALYZE


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES( sqlite_source_id(),7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(1,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),( sqlite_source_id(),11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6, char(1));
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT 1=1 a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT 1=1 a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, round(1,1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y= strftime(1,1,1,1)<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y%Y


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET x=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=@ax(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y) -1;
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.yWHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;REINDEX


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;VACUUM


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT random() a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT sqlite_source_id() a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(122001-01-01001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(18001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(22001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(42001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(52001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(62001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(82001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(92001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET x=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y, likely(1));
INSERT INTO t2(x,y) SELECT a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, randomblob(1) || b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.x WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;ANALYZE


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y|excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, randomblob(3)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, round(1,1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json_array(1,1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json(1) a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT randomblob(1) a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT sqlite_source_id() a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT trim(1,1) a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1) a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT-a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(8,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(?,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(?,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3, randomblob(2001-01-011)),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( "a",excluded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT�UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(  "a","b""a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT�UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(9,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(  "a","b""a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT�UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,x) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(   "a","b""a","b""a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT�UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT  unicode(1) || last_insert_rowid()  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT�UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,? FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(   "a","b""a","b""a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT�UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(    "a","b""a","b""a","b""a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT�UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(   "a","b""a","b""a"%Y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT�UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(   "a","b""a",NOT"a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT�UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max( " ",excluded.y)%Y;
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT�UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT randomblob(1)GLOB a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
I


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT�UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT zeroblob(1)& round(1,1)a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT�UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT zeroblob(1)&a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y INT�UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(9,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(   "a","b""a","b""a",excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y a,b INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y blobUNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b); WITH c(x) AS (values(1)) 
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a char(1),b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a char(1)ERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t2 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES( 1=11,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES( avg(1),4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT group_concat(1,1) true
  ON CONFLICT(x) DO UPDATE SET y=exed.y WHERE y<excd.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1, sqlite_source_id()),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a, zeroblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3 /* */,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(1,1) a, avg(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT group_concat(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3 /* */,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3 /* */,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT group_concat(1.1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3 /* */,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT last_insert_rowid() a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3, coalesce(1,1)),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a, zeroblob(0)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a, zeroblob(1) >=b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a, zeroblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,x) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a, zeroblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a, zeroblob(2001-01-011)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a, zeroblob(4)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a, zeroblob(6)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a, zeroblob(8)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a, zeroblob(9)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a, zeroblob(A)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a, zeroblob(B)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET x=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, zeroblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE@true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT group_concat(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2 /* */SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, trim(1,1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, zeroblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y%Y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE@true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<@xcluded�y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT count(1) a,b FROM t3 WHERE@true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;VACUUM


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT group_concat(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(1,?) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(9,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(9,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT last_insert_rowid() a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(9,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(y,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT random() a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT sum(1) a,b FROM t3 WHERE@true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,:1),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE@true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<@xcluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(?,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(9,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(5,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(9,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(8,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y< zeroblob(1)


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(9,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(9,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(x INTEGER PRIMARY KEY, yUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, r2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y FROM t3 WHE,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.���ERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y varchar(1)UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3 /* */,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT group_concat(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT group_concat(1,1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y,INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(y,y) SELECT 1=1 a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,uded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y,INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y,INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY, y,INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(7,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x INTEGER PRIMARY KEY,CURRENT_TIMESTAMP y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),( ?16,7),(3,1),(8,9),(6,11),(1,1);VACUUM;


sqltext:
CREATE TABLE t2(x INTEGER PR�MAreplRY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 ORDER BY "a,9),(6,11),(1,1);
INSERT INT",");
INSERT Ib"


sqltext:
CREATE TABLE t2(x INUEGER PRIMARY KEY, y INT UNIQUE)/*WIT  INTEGER PRIMARY KEY, y INT );
IuSERT INTO t3 VALUES(1,2),(3,4)G(1,5),(6,7),(3,1),(8ecor,9),(6,11),(***************** t2(x,y) SELECT a,b FROM;t3 WHERE true
� CONFLICT(x) D(V'O UPDATE SET y=max(tL.y,excludY KEY, y INT UNIQUE)/*WIy) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=e� y INT y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x TEXTGER PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a, randomblob(1)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x `a`EGER PRIMARY KEY, "a","b"NIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),( ?16,7),(3,1),(8,9),(6,11),(1,1);VACUUM;


sqltext:
CREATE TABLE t2(x blobGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT total(1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x char(1) PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x char(1) PRIMARY KEY, y INT UNIQUE)WITHOUT ROWID;
CREATE TABLE t3(a,b char(1));
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, randomblob(12001-01-01)b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x char(1) PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x �NTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, random() || b FROM t3 WHERE true



sqltext:
CREATE TABLE t2(x �NTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a, random()b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x �NTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x �NTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json(1) a, abs(1)b FROM t2 WHERE true
AND true  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
;


sqltext:
CREATE TABLE t2(x �NTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT json(1) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x �NTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob( random()*-11) a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
;


sqltext:
CREATE TABLE t2(x �NTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT zeroblob(1) ||  a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSy;


sqltext:
CREATE TABLE t2(x �NTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);REPLACE INTO t2(x,y) SELECT a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x �NTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);REPLACE INTO t2 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x �NTEGER PRIMARY KEY, y varchar(1))/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8, randomblob(1));
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x'�NTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t2(x'�NTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
  ON CONFLICT(x) DO UPDATE SET y=max(t2.y,excluded.y)AND true;
INSy;


sqltext:
CREATE TABLE t2(x,INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x,INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT@a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x,INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,7),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x,INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,5),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x,INTEGER PR,MARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,5),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT random() a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x,INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT-a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x,INTEGER PRIMARY KEY, y,INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a char(1),b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),(6,7),(3,1),(8,9),(6,11),(1,1);
INSERT INTO t2(x,y) SELECT a,b FROM t3 WHERE true
 y;


sqltext:
CREATE TABLE t2(x�INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(R PRIMARY KEY, y UNIQUE
INSERT INTO t3 VALUES;
IN;


sqltext:
CREATE TABLE t2BY(INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a,b);
INSERT INTO t3 VALUES(1,2),(3,4),(1,5),( ?16,7),(3,1),(8,9),(6,11),(1,1);VACUUM;ANALYZE


sqltext:
CREATE TABLE t3(x INTEGER PRIMARY KEY, y INT UNIQUE)/*WIT ROWID*/;
CREATE TABLE t3(a
INSERT PDATE SET y=excluded.y WHERE y<excluded.y;


sqltext:
CREATE TABLE t4(a , b INT);
CREATE UNIQUE INDEX tcht4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(1<1,1)=2000;
INSERT INTO t4(a,b) V�LUES(50,60) ON THING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE  /* */ INDEX t4a1 ON t4(a) WHERE b< `a`;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b>= `a`;REPLACE INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX ACTIONt4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_object(1,1,1,1)=2000;
INS;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON PRAG (1),1) b<1000;
CNTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON PRAGMA(1,1) b<1000;
CNTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON PRAGMAt4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b>=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON pr (1)intf(1,1) b<1000;
CNTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON printf(1,1) b<1000;
CNTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4 (1)WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a -1) WHERE b> json_remove(ALL)=2000;VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE -11.00;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b>=2000;
INSERT INTO t4(a,b) VALUES(50,60)�ON


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE -11000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b>=2000;REPLACE INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE .11000;
CNTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE .11000;
REINDEX(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE ?11000;
CNTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE NOT(1)IS true;
CNTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHI


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE NOT(1)IS true;
REINDEX(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHI


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE NOT(1)IS+true;
CNTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHI


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE NOT(1)ISNULL;
CNT(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE NOT(1)ISNULL;
REINDEX) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE NOT(1)OR true;
CNTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHI


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE NOT(1)OR true;
REINDEX(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHI


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE NOT/* */0;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b>=2000;REPLACE INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE NOT/* */0;REINDEX UNIQUE INDEX t4a2 ON t4(a) WHERE b>=:000;
ING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE NOT`a`OR true;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b>=2000;REPLACE INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE avg( sqlite_compileoption_used(1)) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE avg(1);
CNTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b >=00;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b>=2000;REPLACE INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b/1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1/0)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b< `a`AND true;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b>=2000;REPLACE INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b< `a`NOTNULL;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> 1=1=2000;REPLACE INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b< json_array_length(1E1)=2001000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array_length(1E1)=2000
I


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<-`a`OR true;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b>=2000;REPLACE INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<.000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b>.2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1. -1E0;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b>.2000;
INSERT INTO t4(a,b) VALUES(50,60)�ON


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1.%0;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b>=200.;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1.%0;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b>=2000;
INSERT INTO t4(a,b) VALUES(5.,60)�ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1.%0;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b>=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1.80;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b>.2000;
INSERT INTO t4(a,b) VALUES(50,60)�ON


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1.E0;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b>.2000;
INSERT INTO t4(a,b) VALUES(50,60)�ON


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<100 ;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL)=2000;VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<10002001-01-01;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> lower(12001501-01)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE  /* */ INDEX t4a2 ON t4(a) WHERE  [a]in(1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(?) WHERE b>=:000;
ING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  ' 'in(1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  '+2 daysa'in(1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  'a'in(1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  (1)in(),HING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  [a]in( -11,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  [a]in( -11,1)=2000;REPLACE INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  [a]in( /* */)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  [a]in(+-11,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  [a]in(1,  "a","b""a","b",1))


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  [a]in(1, "a","b",1))


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  [a]in(1,1 glob 1,1))


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  [a]in(1,1 glob a,b))=2000;
I


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  [a]in(1,1 glob(1,1))=2000;
I


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  [a]in(1,1)AND true=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  [a]in(1,1,glob(1,1))=2000;
I


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  [a]in(1<1)=2000;REPLACE INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  [a]in(B,1)=2 00;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  [a]in(B,1)=2000;REINDEX /* */t4(;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  [a]in(B,1)=2000;REPLACE INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE  [a]in(B,A)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b/ strftime( 'a%fb')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b< json_remove(ALL)=2000;VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b<=2000;REPLACE INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> datetime( 1=11)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> datetime( 1=11)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> instr( ' total_changes()a',1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> instr( 'ANALYZEa',1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> instr( 'AND truea',1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> instr( 'a',1)=2000;�INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> instr( -11,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> instr( -9.,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> instr( -91,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> instr(1, -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> instr(1, -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> instr(1, json(1))=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> instr(1,NULL -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> instr(A,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> instr(NULL,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json /* */(  ' "a"a')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(   'a "a","b"''a')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(   'a''')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(   'a''\')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(   'a''a')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(   'a�a')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  '')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  '')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  '	')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  ' 
a"a')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  ' "a" sqlite_compileoption_used(1)a')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  ' "a","b"a')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  ' "a"a')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  ' changes()a')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  ' datetime(1,1,1)a')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  '"')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  'ACTIONa')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  '\')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  '\')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  'a 
a"')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  'a "\"')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  'a "a"')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  ALL)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(  json(1))=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array( ' "a","b"�a')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array( '�')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array( '�\')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array( '�a')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array(1<1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array_length( -11E20&1-01-011)=2000;
I


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array_length( -11E2001-01-011)=2000;
I


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array_length(1<1)=2000;DETACH
I


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array_length(1E200 || 1-01-011)=2000;
I


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array_length(1E207 || 1-01-011)=2000;
I


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_array_length(1E300 || 1-01-011)=2000;
I


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_extract(1<1)=2000;
ING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_object(1<1,1,1)=2000;
INS;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_object(ALL)=2000;
INS;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_object(ALL)=2000;VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_patch(1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL `a`)=2000;VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL abs(1))=2000;VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL json(1))=2000;VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL json_array(  'a'))=2000;
I


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL json_array( NULL))=2000;
I


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL json_array(1,1,1))=2000;
I


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL json_array(1,1,1))=2000;VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL json_array(1<1,1))=2000;
I


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL likely(1))=2000;VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL strftime(1,1,1,1))=2000;VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL)= json_array(1,1,1);VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL)=2000;SAVEPOINT
INS;ANALYZE


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL)=2000;SAVEPOINT
INS;BEGIN


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL)=2000;SAVEPOINT
INS;END


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL)=2000;SAVEPOINT
INS;ROLLBACK


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL)=2000;SAVEPOINT
INS;VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_remove(ALL)OR false=2000;VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_replace( 1=11)=2000;VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_set( 1E11)=2000;VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_set( 1E91)-2000;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_set( 1E91)=2000;VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_set(1,1,1)COLLATE n2001-01-01;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_set(1,1,1)COLLATE nocase glob(1,1)=2000;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_set(1,A,1)=2000;VACUUM


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_set(1<1,1)=2000;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_test1(1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)G;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_test1(1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_valid(1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> json_valid(1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> length(1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> likely(1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> lower( -.1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> lower( -01)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> lower( -01)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> lower( -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> lower( ltrim(),1))=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> lower( ltrim(1,1))=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> lower( ltrim(1,1))=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> lower( ltrim(9,1))=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> lower(1.001501-01)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> lower(12001501-01)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> lower(1202001-01-01012001-01-01-01-01)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> max(A,1)=2=00;REPLACE INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> min(),HING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> nullif(1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> quote( ltrim(9,1))=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> quote(1 -1.1)-2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> quote(1 -1.1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> quote(1 || .1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> quote(1 || 1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> quote(1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> quote(1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> quote(1.1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> quote(1.1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> replace( ' bm25(1)a',1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> replace( ' total_changes()a',1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> replace( 'a',1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> replace( -91,1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> replace( 111,1, -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> replace( 111,1, -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> replace( round(1,1) -11,1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> replace(1, -11,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> replace(1,1, 'a')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> replace(1,1, 'a')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> replace(1,1, -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> replace(1,1, -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> replace(1111,1, -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> replace(2001-01-011,1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> replace(9,1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round( ltrim(1,1),1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round( ltrim(1,1),1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round( round(1,1),1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(0,2001-01-011)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(0,2001-01-011)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(0,4)=2000;
INSERT INTO t4(a,b) VALUES(50,60);ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(0,7)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(0,8)-~~~~~~~~~~~2000;
INSERT INTO t4G;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(0,8)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(0,8)=~~~~~~a~~~~2000;
INSERT INTO t4G;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(0,8)=~~~~~~~B~~~2000;
INSERT INTO t4G;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(0,8)=~~~~~~~a~~~2000;
INSERT INTO t4G;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(0,8)=~~~~~~~~~~~NULL;
INSERT INTO t4G;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(0,9)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1 COLLATE nocase| hex(1)| .1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1 | hex(1)|NOT .1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1 || .1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1, 'a')=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1, hex(1) -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1,1)&2.00;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1,200 || -011)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1,200 || zeroblob(1) -011)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1,200/-01-011)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1,2001-01-011) || 0;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1,2001.01-011)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1,8)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1,9)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1/0)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1/0)=2000;
INSERT INTO t4(a/


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(12001-01-01,2001-01-011)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1E20 || 1-011)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1E20&1-01-011)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1E20-01-011)=2000;
INSERT T INTO t4(a,b) VALUES(5060)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1E20/1-01-011)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1E200 || -011)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1E200 || 1-01-011)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1E200/-01-011)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1E2001-01,011)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1E2001-01-011)=2000;�INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1E2002-01-011)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(1E2006-01-011)=2000;
INSERT INTO t4(a,b) VALUES(50,60)


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> round(2001-01-011,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> rtrim(1, -1.)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> rtrim(1, -1.)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> rtrim(1, -1.2001-01-01)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> rtrim(1, -2001-01-011.)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime(  /* */)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime(  /* */)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( ' coalesce(1,1)a''b')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'ACTIONa''b')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%%YIb')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%Hb')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%Hb')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%Ib')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%Ib')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%Jb')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%Jb')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%Mb')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%Mb')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%Sb')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%Sb')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%Wb')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%Wb')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%Yb')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%Yb')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%db')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%fb')=2000;
INSERT INTO t4(a,b) VALUES(50,60);ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%jb')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%jb')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%mb')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%mb')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%sb')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%sb')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%wb')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%wb')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a%�b')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a&�b')=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a'COLLATE'b' glob(1,1))=2000;;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a'COLLATE'b' glob(1,1))=2=00;;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( 'a'COLLATE'b')=2= 1=1


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( date(1,1,1)/* */)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( hex(1))=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( json(1)  /* */)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( trim(1,1)  /* */)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> strftime( trim(1,1)  /* */)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr( -1, -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr( -11, -1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)G;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr( -11,1,1)-2000;
INSERT INTO t4(a,b) VALUES(50,60)G;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr( -11,1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr( -11.1,1)-2000;
INSERT INTO t4(a,b) VALUES(50,60)G;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr( -12001-01-011, -1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)G;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1 || .1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1 || .1,9)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1 |~ .1,4)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1, -11,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1,0, -1 || 1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1,0,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1,1, 'a')=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1,1, 'a'COLLATE nocase)=2=00;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1,1, 'a'COLLATE nocase)�2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1,1, 'a'COLLATE �ocase)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1,1, -1 || 1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)G;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1,1, .11)=2000;
INSERT INTO t4(a,b) VALUES(50,60)G;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1,1, .11)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1,1,NULL)=2000;
INSERT INTO t4(a,b) VALUES(50,60)G;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1,1,NULL)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1,1.1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1,1.1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1,2,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1,2001-01-011, -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60)G;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1,2001-01-011, -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1.1, -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1/0,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1/0,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(12001-01-01, -1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)G;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(1E1, -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> substr(2001-01-011,2001-01-011, -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60)G;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time( '2001-01-01a''b',1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time( 'NOTb',1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time( -.1 || .1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time( -11 || .1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time( -11 || .1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time( 1E11)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time( 1E11)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time( hex(1),1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time(-.1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time(-.1,1)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time(0 AND- ?111)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time(0 AND?11)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time(1 -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time(1 -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time(1 AND-11)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time(1 ||  -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60)ON CONFLICT(a) DO NOTHING;


sqltext:
CREATE TABLE t4(a INT, b INT);
CREATE UNIQUE INDEX t4a1 ON t4(a) WHERE b<1000;
CREATE UNIQUE INDEX t4a2 ON t4(a) WHERE b> time(1 ||  -11)=2000;
INSERT INTO t4(a,b) VALUES(50,60) ON CONFLICT(a) DO NOTHING;


