From: drh Date: Wed, 15 Jan 2020 12:49:49 +0000 (+0000) Subject: Merge all recent enhancements and fixes from trunk into the apple-osx branch. X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=2f263a1fce755c5fc713a5794a897d18db367007;p=thirdparty%2Fsqlite.git Merge all recent enhancements and fixes from trunk into the apple-osx branch. FossilOrigin-Name: dadedf41c7cced0cea5c69584ff11405c2fc53518c7ddbea2e4e51cc44b4cd0a --- 2f263a1fce755c5fc713a5794a897d18db367007 diff --cc ext/fts5/test/fts5misc.test index 8d3742417a,9abc92b23f..8ffb1bfe97 --- a/ext/fts5/test/fts5misc.test +++ b/ext/fts5/test/fts5misc.test @@@ -106,6 -106,222 +106,221 @@@ do_execsql_test 2.2.5 INSERT INTO vt0(vt0) VALUES('integrity-check'); } + #------------------------------------------------------------------------- + reset_db + do_execsql_test 3.0 { + CREATE VIRTUAL TABLE vt0 USING fts5(a); + PRAGMA reverse_unordered_selects = true; + INSERT INTO vt0 VALUES('365062398'), (0), (0); + INSERT INTO vt0(vt0, rank) VALUES('pgsz', '38'); + } + do_execsql_test 3.1 { + UPDATE vt0 SET a = 399905135; -- unexpected: database disk image is malformed + } + do_execsql_test 3.2 { + INSERT INTO vt0(vt0) VALUES('integrity-check'); + } - finish_test + #------------------------------------------------------------------------- + reset_db + do_execsql_test 4.0 { + CREATE VIRTUAL TABLE vt0 USING fts5(c0); + INSERT INTO vt0(c0) VALUES ('xyz'); + } + + do_execsql_test 4.1 { + BEGIN; + INSERT INTO vt0(c0) VALUES ('abc'); + INSERT INTO vt0(vt0) VALUES('rebuild'); + COMMIT; + } + + do_execsql_test 4.2 { + INSERT INTO vt0(vt0) VALUES('integrity-check'); + } + + do_execsql_test 4.3 { + BEGIN; + INSERT INTO vt0(vt0) VALUES('rebuild'); + INSERT INTO vt0(vt0) VALUES('rebuild'); + COMMIT; + } + + do_execsql_test 4.4 { + INSERT INTO vt0(vt0) VALUES('integrity-check'); + } + + #------------------------------------------------------------------------- + # Ticket [81a7f7b9]. + # + reset_db + do_execsql_test 5.0 { + CREATE VIRTUAL TABLE vt0 USING fts5(c0, c1); + INSERT INTO vt0(vt0, rank) VALUES('pgsz', '65536'); + WITH s(i) AS ( + SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<1236 + ) + INSERT INTO vt0(c0) SELECT '0' FROM s; + } {} + + do_execsql_test 5.1 { + UPDATE vt0 SET c1 = 'T,D&p^y/7#3*vxOpen(pVfs, zPath, pFile, flags & 0x1087f7f, pFlagsOut); +#if SQLITE_ENABLE_DATA_PROTECTION - openFlags = flags & (0x87f7f | SQLITE_OPEN_FILEPROTECTION_MASK); ++ openFlags = flags & (0x1087f7f | SQLITE_OPEN_FILEPROTECTION_MASK); +#else - openFlags = flags & 0x87f7f; ++ openFlags = flags & 0x1087f7f; +#endif + rc = pVfs->xOpen(pVfs, zPath, pFile, openFlags, pFlagsOut); assert( rc==SQLITE_OK || pFile->pMethods==0 ); return rc; } diff --cc src/os_unix.c index a29b9988dc,07ae4bc03a..206ea5cfe0 --- a/src/os_unix.c +++ b/src/os_unix.c @@@ -5317,18 -4575,13 +5317,20 @@@ static int unixOpenSharedMemory(unixFil } if( pInode->bProcessLock==0 ){ +#ifdef __APPLE__ + /* On MacOS and iOS, avoid even trying to open a read-only SHM file + ** for writing, because doing so generates scary log messages */ + if( osAccess(zShm, R_OK|W_OK)!=0 && (errno==EPERM || errno==EACCES) ){ + pShmNode->hShm = -1; + }else +#endif if( 0==sqlite3_uri_boolean(pDbFd->zPath, "readonly_shm", 0) ){ - pShmNode->hShm = robust_open(zShm, O_RDWR|O_CREAT,(sStat.st_mode&0777)); + pShmNode->hShm = robust_open(zShm, O_RDWR|O_CREAT|O_NOFOLLOW, + (sStat.st_mode&0777)); } if( pShmNode->hShm<0 ){ - pShmNode->hShm = robust_open(zShm, O_RDONLY, (sStat.st_mode&0777)); + pShmNode->hShm = robust_open(zShm, O_RDONLY|O_NOFOLLOW, + (sStat.st_mode&0777)); if( pShmNode->hShm<0 ){ rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zShm); goto shm_open_err; @@@ -7092,11 -5931,7 +7094,11 @@@ static int unixOpen unixFile *p = (unixFile *)pFile; int fd = -1; /* File descriptor returned by open() */ int openFlags = 0; /* Flags to pass to open() */ - int eType = flags&0x0FFF00; /* Type of file to open */ +#if SQLITE_ENABLE_DATA_PROTECTION - int eType = flags&0xFF0FFF00; /* Type of file to open */ ++ int eType = flags&0xFE0FFF00; /* Type of file to open */ +#else - int eType = flags&0xFFFFFF00; /* Type of file to open */ ++ int eType = flags&0xFEFFFF00; /* Type of file to open */ +#endif int noLock; /* True to omit locking primitives */ int rc = SQLITE_OK; /* Function Return Code */ int ctrlFlags = 0; /* UNIXFILE_* flags */ @@@ -7206,12 -6041,8 +7208,12 @@@ if( isReadWrite ) openFlags |= O_RDWR; if( isCreate ) openFlags |= O_CREAT; if( isExclusive ) openFlags |= (O_EXCL|O_NOFOLLOW); - openFlags |= (O_LARGEFILE|O_BINARY); + openFlags |= (O_LARGEFILE|O_BINARY|O_NOFOLLOW); +#if SQLITE_ENABLE_DATA_PROTECTION + p->protFlags = (flags & SQLITE_OPEN_FILEPROTECTION_MASK); +#endif + if( fd<0 ){ mode_t openMode; /* Permissions to create file with */ uid_t uid; /* Userid for the file */ diff --cc src/pager.h index 4f02ec4c40,904278944c..5b5b323e6b --- a/src/pager.h +++ b/src/pager.h @@@ -203,10 -203,9 +203,10 @@@ u32 sqlite3PagerDataVersion(Pager*) int sqlite3PagerRefcount(Pager*); #endif int sqlite3PagerMemUsed(Pager*); - const char *sqlite3PagerFilename(Pager*, int); + const char *sqlite3PagerFilename(const Pager*, int); sqlite3_vfs *sqlite3PagerVfs(Pager*); sqlite3_file *sqlite3PagerFile(Pager*); +sqlite3_file *sqlite3PagerWalFile(Pager *pPager); sqlite3_file *sqlite3PagerJrnlFile(Pager*); const char *sqlite3PagerJournalname(Pager*); void *sqlite3PagerTempSpace(Pager*); diff --cc src/sqlite.h.in index 9c683af66c,c61c0e8b31..66d9cf4615 --- a/src/sqlite.h.in +++ b/src/sqlite.h.in @@@ -568,8 -571,8 +571,9 @@@ int sqlite3_exec #define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */ #define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */ #define SQLITE_OPEN_WAL 0x00080000 /* VFS only */ - #define SQLITE_OPEN_FILEPROTECTION_MASK 0x00700000 - ++#define SQLITE_OPEN_FILEPROTECTION_MASK \ ++ 0x00700000 + #define SQLITE_OPEN_NOFOLLOW 0x01000000 /* Ok for sqlite3_open_v2() */ - /* Reserved: 0x00F00000 */ /* diff --cc test/altertab.test index 79b54272a0,7dcf8a5e0d..70b3e72afd --- a/test/altertab.test +++ b/test/altertab.test @@@ -547,13 -547,29 +547,33 @@@ ifcapable fts3 } {1 {table y1_segments may not be modified}} do_catchsql_test 16.20 { + DROP TABLE y1_segments; + } {1 {table y1_segments may not be dropped}} + - do_catchsql_test 16.20 { ++ do_catchsql_test 16.21 { ALTER TABLE y1_segments RENAME TO abc; } {1 {table y1_segments may not be altered}} + sqlite3_db_config db DEFENSIVE 0 + do_catchsql_test 16.22 { + ALTER TABLE y1_segments RENAME TO abc; + } {0 {}} + sqlite3_db_config db DEFENSIVE 1 + do_catchsql_test 16.23 { + CREATE TABLE y1_segments AS SELECT * FROM abc; + } {1 {object name reserved for internal use: y1_segments}} + do_catchsql_test 16.24 { + CREATE VIEW y1_segments AS SELECT * FROM abc; + } {1 {object name reserved for internal use: y1_segments}} + sqlite3_db_config db DEFENSIVE 0 + do_catchsql_test 16.25 { + ALTER TABLE abc RENAME TO y1_segments; + } {0 {}} + sqlite3_db_config db DEFENSIVE 1 + do_catchsql_test 16.21 { + DROP TABLE y1_segments; + } {1 {table y1_segments may not be dropped}} + do_execsql_test 16.30 { ALTER TABLE y1 RENAME TO z1; } diff --cc test/filter1.test index 9309b744b1,ee17099d99..2eb101572e --- a/test/filter1.test +++ b/test/filter1.test @@@ -184,5 -184,24 +184,44 @@@ do_execsql_test 5.3 SELECT count(*) FILTER (WHERE b>2) OVER (ORDER BY b) FROM (SELECT * FROM t1) } {0 1} - finish_test ++#------------------------------------------------------------------------- ++reset_db ++do_execsql_test 5.0 { ++ CREATE TABLE t1(a, b); ++ INSERT INTO t1 VALUES(1, 2); ++ INSERT INTO t1 VALUES(1, 3); ++} + ++do_execsql_test 5.1 { ++ SELECT count(*) FILTER (WHERE b>2) FROM (SELECT * FROM t1) ++} {1} ++ ++do_execsql_test 5.2 { ++ SELECT count(*) FILTER (WHERE b>2) OVER () FROM (SELECT * FROM t1) ++} {1 1} ++ ++do_execsql_test 5.3 { ++ SELECT count(*) FILTER (WHERE b>2) OVER (ORDER BY b) FROM (SELECT * FROM t1) ++} {0 1} ++ + #------------------------------------------------------------------------- + reset_db + do_execsql_test 6.0 { + CREATE TABLE t1(a,b); + INSERT INTO t1 VALUES(1,1); + INSERT INTO t1 VALUES(2,2); + CREATE TABLE t2(x,y); + INSERT INTO t2 VALUES(1,1); + } + + do_execsql_test 6.1 { + SELECT (SELECT COUNT(a) FILTER(WHERE x) FROM t2) FROM t1; + } {1 1} + do_execsql_test 6.2 { + SELECT (SELECT COUNT(a+x) FROM t2) FROM t1; + } {1 1} + do_execsql_test 6.3 { + SELECT (SELECT COUNT(a) FROM t2) FROM t1; + } {2} + + finish_test diff --cc test/join.test index 682186200b,391e0681ce..6d93848df4 --- a/test/join.test +++ b/test/join.test @@@ -905,5 -905,123 +905,144 @@@ do_execsql_test join-18.4 SELECT NOT(v0.a IS FALSE) FROM v0 } {1} ++#------------------------------------------------------------------------- ++reset_db ++do_execsql_test join-18.1 { ++ CREATE TABLE t0(a); ++ CREATE TABLE t1(b); ++ CREATE VIEW v0 AS SELECT a FROM t1 LEFT JOIN t0; ++ INSERT INTO t1 VALUES (1); ++} {} ++ ++do_execsql_test join-18.2 { ++ SELECT * FROM v0 WHERE NOT(v0.a IS FALSE); ++} {{}} ++ ++do_execsql_test join-18.3 { ++ SELECT * FROM t1 LEFT JOIN t0 WHERE NOT(a IS FALSE); ++} {1 {}} ++ ++do_execsql_test join-18.4 { ++ SELECT NOT(v0.a IS FALSE) FROM v0 ++} {1} ++ + #------------------------------------------------------------------------- + reset_db + do_execsql_test join-19.0 { + CREATE TABLE t1(a); + CREATE TABLE t2(b); + INSERT INTO t1(a) VALUES(0); + CREATE VIEW v0(c) AS SELECT t2.b FROM t1 LEFT JOIN t2; + } + + do_execsql_test join-19.1 { + SELECT * FROM v0 WHERE v0.c NOTNULL NOTNULL; + } {{}} + + do_execsql_test join-19.2 { + SELECT * FROM t1 LEFT JOIN t2 + } {0 {}} + + do_execsql_test join-19.3 { + SELECT * FROM t1 LEFT JOIN t2 WHERE (b IS NOT NULL) IS NOT NULL; + } {0 {}} + + do_execsql_test join-19.4 { + SELECT (b IS NOT NULL) IS NOT NULL FROM t1 LEFT JOIN t2 + } {1} + + do_execsql_test join-19.5 { + SELECT * FROM t1 LEFT JOIN t2 WHERE + (b IS NOT NULL AND b IS NOT NULL) IS NOT NULL; + } {0 {}} + + # 2019-11-02 ticket 623eff57e76d45f6 + # The optimization of exclusing the WHERE expression of a partial index + # from the WHERE clause of the query if the index is used does not work + # of the table of the index is the right-hand table of a LEFT JOIN. + # + db close + sqlite3 db :memory: + do_execsql_test join-20.1 { + CREATE TABLE t1(c1); + CREATE TABLE t0(c0); + INSERT INTO t0(c0) VALUES (0); + SELECT * FROM t0 LEFT JOIN t1 WHERE NULL IN (c1); + } {} + do_execsql_test join-20.2 { + CREATE INDEX t1x ON t1(0) WHERE NULL IN (c1); + SELECT * FROM t0 LEFT JOIN t1 WHERE NULL IN (c1); + } {} + + # 2019-11-30 ticket 7f39060a24b47353 + # Do not allow a WHERE clause term to qualify a partial index on the + # right table of a LEFT JOIN. + # + do_execsql_test join-21.10 { + DROP TABLE t0; + DROP TABLE t1; + CREATE TABLE t0(aa); + CREATE TABLE t1(bb); + INSERT INTO t0(aa) VALUES (1); + INSERT INTO t1(bb) VALUES (1); + SELECT 11, * FROM t1 LEFT JOIN t0 WHERE aa ISNULL; + SELECT 12, * FROM t1 LEFT JOIN t0 WHERE +aa ISNULL; + SELECT 13, * FROM t1 LEFT JOIN t0 ON aa ISNULL; + SELECT 14, * FROM t1 LEFT JOIN t0 ON +aa ISNULL; + CREATE INDEX i0 ON t0(aa) WHERE aa ISNULL; + SELECT 21, * FROM t1 LEFT JOIN t0 WHERE aa ISNULL; + SELECT 22, * FROM t1 LEFT JOIN t0 WHERE +aa ISNULL; + SELECT 23, * FROM t1 LEFT JOIN t0 ON aa ISNULL; + SELECT 24, * FROM t1 LEFT JOIN t0 ON +aa ISNULL; + } {13 1 {} 14 1 {} 23 1 {} 24 1 {}} + + # 2019-12-18 problem with a LEFT JOIN where the RHS is a view. + # Detected by Yongheng and Rui. + # Follows from the optimization attempt of check-in 41c27bc0ff1d3135 + # on 2017-04-18 + # + reset_db + do_execsql_test join-22.10 { + CREATE TABLE t0(a, b); + CREATE INDEX t0a ON t0(a); + INSERT INTO t0 VALUES(10,10),(10,11),(10,12); + SELECT DISTINCT c FROM t0 LEFT JOIN (SELECT a+1 AS c FROM t0) ORDER BY c ; + } {11} + + # 2019-12-22 ticket 7929c1efb2d67e98 + # + reset_db + do_execsql_test join-23.10 { + CREATE TABLE t0(c0); + INSERT INTO t0(c0) VALUES(123); + CREATE VIEW v0(c0) AS SELECT 0 GROUP BY 1; + SELECT t0.c0, v0.c0, vt0.name + FROM v0, t0 LEFT JOIN pragma_table_info('t0') AS vt0 + ON vt0.name LIKE 'c0' + WHERE v0.c0 == 0; + } {123 0 c0} + + #------------------------------------------------------------------------- + reset_db + do_execsql_test join-24.1 { + CREATE TABLE t1(a PRIMARY KEY, x); + CREATE TABLE t2(b INT); + CREATE INDEX t1aa ON t1(a, a); + + INSERT INTO t1 VALUES('abc', 'def'); + INSERT INTO t2 VALUES(1); + } + + do_execsql_test join-24.2 { + SELECT * FROM t2 JOIN t1 WHERE a='abc' AND x='def'; + } {1 abc def} + do_execsql_test join-24.3 { + SELECT * FROM t2 JOIN t1 WHERE a='abc' AND x='abc'; + } {} + + do_execsql_test join-24.2 { + SELECT * FROM t2 LEFT JOIN t1 ON a=0 WHERE (x='x' OR x IS NULL); + } {1 {} {}} + finish_test diff --cc test/tester.tcl index 9498735cdc,05c52343f0..c6207de33c --- a/test/tester.tcl +++ b/test/tester.tcl @@@ -586,25 -592,9 +592,26 @@@ if {[info exists cmdlinearg]==0} # way if an individual test file changes the soft-heap-limit, it # will be reset at the start of the next test file. # - sqlite3_soft_heap_limit $cmdlinearg(soft-heap-limit) + sqlite3_soft_heap_limit64 $cmdlinearg(soft-heap-limit) + sqlite3_hard_heap_limit64 $cmdlinearg(hard-heap-limit) +proc forced_proxy_locking {} { + if $::sqlite_options(lock_proxy_pragmas)&&$::sqlite_options(prefer_proxy_locking) { + set force_proxy_value 0 + set force_key "SQLITE_FORCE_PROXY_LOCKING=" + foreach {env_pair} [exec env] { + if { [string first $force_key $env_pair] == 0} { + set force_proxy_value [string range $env_pair [string length $force_key] end] + } + } + if { "$force_proxy_value " == "1 " } { + return 1 + } + } + return 0 +} + + # Create a test database # proc reset_db {} { diff --cc test/window1.test index 7a41e7268d,833e211fbd..a7473d9a85 --- a/test/window1.test +++ b/test/window1.test @@@ -1234,4 -1234,364 +1234,363 @@@ do_catchsql_test 31.3 ); } {1 {frame ending offset must be a non-negative integer}} + # 2019-11-16 chromium issue 1025467 + db close + sqlite3 db :memory: + do_catchsql_test 32.10 { + CREATE VIEW a AS SELECT NULL INTERSECT SELECT NULL ORDER BY s() OVER R; + CREATE TABLE a0 AS SELECT 0; + ALTER TABLE a0 RENAME TO S; + } {1 {error in view a: 1st ORDER BY term does not match any column in the result set}} + + reset_db + do_execsql_test 33.1 { + CREATE TABLE t1(aa, bb); + INSERT INTO t1 VALUES(1, 2); + INSERT INTO t1 VALUES(5, 6); + CREATE TABLE t2(x); + INSERT INTO t2 VALUES(1); + } + do_execsql_test 33.2 { + SELECT (SELECT DISTINCT sum(aa) OVER() FROM t1 ORDER BY 1), x FROM t2 + ORDER BY 1; + } {6 1} + + reset_db + do_execsql_test 34.1 { + CREATE TABLE t1(a,b,c); + } + do_execsql_test 34.2 { + SELECT avg(a) OVER ( + ORDER BY (SELECT sum(b) OVER () + FROM t1 ORDER BY ( + SELECT total(d) OVER (ORDER BY c) + FROM (SELECT 1 AS d) ORDER BY 1 + ) + ) + ) + FROM t1; + } + + #------------------------------------------------------------------------- + reset_db + do_catchsql_test 35.0 { + SELECT * WINDOW f AS () ORDER BY name COLLATE nocase; + } {1 {no tables specified}} + + do_catchsql_test 35.1 { + VALUES(1) INTERSECT SELECT * WINDOW f AS () ORDER BY x COLLATE nocase; + } {1 {no tables specified}} + + do_execsql_test 35.2 { + CREATE TABLE t1(x); + INSERT INTO t1 VALUES(1), (2), (3); + VALUES(1) INTERSECT + SELECT sum(x) OVER f FROM t1 WINDOW f AS (ORDER BY x) ORDER BY 1; + } {1} + + do_execsql_test 35.3 { + VALUES(8) EXCEPT + SELECT sum(x) OVER f FROM t1 WINDOW f AS (ORDER BY x) ORDER BY 1; + } {8} + + do_execsql_test 35.4 { + VALUES(1) UNION + SELECT sum(x) OVER f FROM t1 WINDOW f AS (ORDER BY x) ORDER BY 1; + } {1 3 6} + + # 2019-12-07 gramfuzz find + # + do_execsql_test 36.10 { + VALUES(count(*)OVER()); + } {1} + do_execsql_test 36.20 { + VALUES(count(*)OVER()),(2); + } {1 2} + do_execsql_test 36.30 { + VALUES(2),(count(*)OVER()); + } {2 1} + do_execsql_test 36.40 { + VALUES(2),(3),(count(*)OVER()),(4),(5); + } {2 3 1 4 5} + + # 2019-12-17 crash test case found by Yongheng and Rui + # See check-in 1ca0bd982ab1183b + # + reset_db + do_execsql_test 37.10 { + CREATE TABLE t0(a UNIQUE, b PRIMARY KEY); + CREATE VIEW v0(c) AS SELECT max((SELECT count(a)OVER(ORDER BY 1))) FROM t0; + SELECT c FROM v0 WHERE c BETWEEN 10 AND 20; + } {} + do_execsql_test 37.20 { + DROP VIEW v0; + CREATE VIEW v0(c) AS SELECT max((SELECT count(a)OVER(ORDER BY 1234))) FROM t0; + SELECT c FROM v0 WHERE c BETWEEN -10 AND 20; + } {} + + # 2019-12-20 mrigger reported problem with a FILTER clause on an aggregate + # in a join. + # + reset_db + do_catchsql_test 38.10 { + CREATE TABLE t0(c0); + CREATE TABLE t1(c0, c1 UNIQUE); + INSERT INTO t0(c0) VALUES(1); + INSERT INTO t1(c0,c1) VALUES(2,3); + SELECT COUNT(*) FROM t0, t1 WHERE (SELECT AVG(0) FILTER(WHERE t1.c1)); + } {1 {misuse of aggregate: AVG()}} + do_execsql_test 38.20 { + SELECT COUNT(*), AVG(1) FILTER(WHERE t1.c1) FROM t0, t1; + } {1 1.0} + do_catchsql_test 38.30 { + SELECT COUNT(*) FROM t0, t1 WHERE (SELECT AVG(1) FILTER(WHERE t1.c1)); + } {1 {misuse of aggregate: AVG()}} + + reset_db + do_execsql_test 39.1 { + CREATE TABLE t0(c0 UNIQUE); + } + do_execsql_test 39.2 { + SELECT FIRST_VALUE(0) OVER(); + } {0} + do_execsql_test 39.3 { + SELECT * FROM t0 WHERE(c0, 0) IN(SELECT FIRST_VALUE(0) OVER(), 0); + } + do_execsql_test 39.4 { + SELECT * FROM t0 WHERE (t0.c0, 1) IN(SELECT NTILE(1) OVER(), 0 FROM t0); + } + + ifcapable rtree { + # 2019-12-25 ticket d87336c81c7d0873 + # + reset_db + do_catchsql_test 40.1 { + CREATE VIRTUAL TABLE t0 USING rtree(c0, c1, c2); + SELECT * FROM t0 + WHERE ((0,0) IN (SELECT COUNT(*),LAG(5)OVER(PARTITION BY 0) FROM t0),0)<=(c1,0); + } {0 {}} + } + + #------------------------------------------------------------------------- + reset_db + do_execsql_test 41.1 { + CREATE TABLE t1(a, b, c); + INSERT INTO t1 VALUES(NULL,'bb',355); + INSERT INTO t1 VALUES('CC','aa',158); + INSERT INTO t1 VALUES('GG','bb',929); + INSERT INTO t1 VALUES('FF','Rb',574); + } + + do_execsql_test 41.2 { + SELECT min(c) OVER ( + ORDER BY a RANGE BETWEEN 5.2 PRECEDING AND 0.1 PRECEDING + ) FROM t1 + } {355 158 574 929} + + do_execsql_test 41.2 { + SELECT min(c) OVER ( + ORDER BY a RANGE BETWEEN 5.2 PRECEDING AND 0.1 PRECEDING + ) << 100 FROM t1 + } {0 0 0 0} + + do_execsql_test 41.3 { + SELECT + min(c) OVER win3 << first_value(c) OVER win3, + min(c) OVER win3 << first_value(c) OVER win3 + FROM t1 + WINDOW win3 AS ( + PARTITION BY 6 ORDER BY a RANGE BETWEEN 5.2 PRECEDING AND 0.1 PRECEDING + ); + } {0 0 0 0 0 0 0 0} + + #------------------------------------------------------------------------- + reset_db + do_execsql_test 42.1 { + CREATE TABLE t1(a, b, c); + INSERT INTO t1 VALUES(1, 1, 1); + INSERT INTO t1 VALUES(2, 2, 2); + } + do_execsql_test 42.2 { + SELECT * FROM t1 WHERE (0, 0) IN ( SELECT count(*), 0 FROM t1 ) + } {} + do_execsql_test 42.3 { + SELECT * FROM t1 WHERE (2, 0) IN ( SELECT count(*), 0 FROM t1 ) + } {1 1 1 2 2 2} + + do_execsql_test 42.3 { + SELECT count(*), max(a) OVER () FROM t1 GROUP BY c; + } {1 2 1 2} + + do_execsql_test 42.4 { + SELECT sum(a), max(b) OVER () FROM t1; + } {3 1} + + do_execsql_test 42.5 { + CREATE TABLE t2(a, b); + INSERT INTO t2 VALUES('a', 1); + INSERT INTO t2 VALUES('a', 2); + INSERT INTO t2 VALUES('a', 3); + INSERT INTO t2 VALUES('b', 4); + INSERT INTO t2 VALUES('b', 5); + INSERT INTO t2 VALUES('b', 6); + } + + do_execsql_test 42.6 { + SELECT a, sum(b), sum( sum(b) ) OVER (ORDER BY a) FROM t2 GROUP BY a; + } {a 6 6 b 15 21} + + do_execsql_test 42.7 { + SELECT sum(b), sum( sum(b) ) OVER (ORDER BY a) FROM t2; + } {21 21} + + #------------------------------------------------------------------------- + reset_db + do_execsql_test 43.1.1 { + CREATE TABLE t1(x INTEGER PRIMARY KEY); + INSERT INTO t1 VALUES (10); + } + do_catchsql_test 43.1.2 { + SELECT count() OVER() AS m FROM t1 ORDER BY (SELECT m); + } {1 {misuse of aliased window function m}} + + reset_db + do_execsql_test 43.2.1 { + CREATE TABLE t1(a INTEGER PRIMARY KEY, b INTEGER); + INSERT INTO t1(a, b) VALUES(1, 10); -- 10 + INSERT INTO t1(a, b) VALUES(2, 15); -- 25 + INSERT INTO t1(a, b) VALUES(3, -5); -- 20 + INSERT INTO t1(a, b) VALUES(4, -5); -- 15 + INSERT INTO t1(a, b) VALUES(5, 20); -- 35 + INSERT INTO t1(a, b) VALUES(6, -11); -- 24 + } + + do_execsql_test 43.2.2 { + SELECT a, sum(b) OVER (ORDER BY a) AS abc FROM t1 ORDER BY 2 + } { + 1 10 4 15 3 20 6 24 2 25 5 35 + } + + do_execsql_test 43.2.3 { + SELECT a, sum(b) OVER (ORDER BY a) AS abc FROM t1 ORDER BY abc + } { + 1 10 4 15 3 20 6 24 2 25 5 35 + } + + do_execsql_test 43.2.4 { + SELECT a, sum(b) OVER (ORDER BY a) AS abc FROM t1 ORDER BY abc+5 + } { + 1 10 4 15 3 20 6 24 2 25 5 35 + } + + do_catchsql_test 43.2.5 { + SELECT a, sum(b) OVER (ORDER BY a) AS abc FROM t1 ORDER BY (SELECT abc) + } {1 {misuse of aliased window function abc}} + + do_catchsql_test 43.2.6 { + SELECT a, 1+sum(b) OVER (ORDER BY a) AS abc FROM t1 ORDER BY (SELECT abc) + } {1 {misuse of aliased window function abc}} + + #------------------------------------------------------------------------- + reset_db + do_execsql_test 44.1 { + CREATE TABLE t0(c0); + } + + do_catchsql_test 44.2.1 { + SELECT ntile(0) OVER (); + } {1 {argument of ntile must be a positive integer}} + do_catchsql_test 44.2.2 { + SELECT (0, 0) IN(SELECT MIN(c0), NTILE(0) OVER()) FROM t0; + } {1 {argument of ntile must be a positive integer}} + + do_execsql_test 44.3.1 { + SELECT ntile(1) OVER (); + } {1} + do_execsql_test 44.3.2 { + SELECT (0, 0) IN(SELECT MIN(c0), NTILE(1) OVER()) FROM t0; + } {0} + + do_execsql_test 44.4.2 { + INSERT INTO t0 VALUES(2), (1), (0); + SELECT (0, 1) IN(SELECT MIN(c0), NTILE(1) OVER()) FROM t0; + } {1} + + #------------------------------------------------------------------------- + reset_db + do_execsql_test 45.1 { + CREATE TABLE t0(x); + CREATE TABLE t1(a); + INSERT INTO t1 VALUES(1000); + INSERT INTO t1 VALUES(1000); + INSERT INTO t0 VALUES(10000); + } + do_execsql_test 45.2 { + SELECT * FROM ( + SELECT sum (a) OVER() FROM t1 UNION ALL SELECT x FROM t0 + ); + } {2000 2000 10000} + + #------------------------------------------------------------------------- + reset_db + do_execsql_test 46.1 { + CREATE TABLE t1 (a); + CREATE INDEX i1 ON t1(a); + + INSERT INTO t1 VALUES (10); + } + + do_execsql_test 46.2 { + SELECT (SELECT sum(a) OVER(ORDER BY a)) FROM t1 + } 10 + + do_execsql_test 46.3 { + SELECT * FROM t1 WHERE (SELECT sum(a) OVER(ORDER BY a)); + } 10 + + do_execsql_test 46.4 { + SELECT * FROM t1 NATURAL JOIN t1 + WHERE a=1 + OR ((SELECT sum(a)OVER(ORDER BY a)) AND a<=10) + } 10 + + #------------------------------------------------------------------------- + reset_db + do_execsql_test 47.0 { + CREATE TABLE t1( + a, + e, + f, + g UNIQUE, + h UNIQUE + ); + } + + do_execsql_test 47.1 { + CREATE VIEW t2(k) AS + SELECT e FROM t1 WHERE g = 'abc' OR h BETWEEN 10 AND f; + } + + do_catchsql_test 47.2 { + SELECT 234 FROM t2 + WHERE k=1 + OR (SELECT k FROM t2 WHERE (SELECT sum(a) OVER() FROM t1 GROUP BY 1)); + } {1 {misuse of window function sum()}} + + #------------------------------------------------------------------------- + reset_db + do_execsql_test 48.0 { + CREATE TABLE t1(a); + INSERT INTO t1 VALUES(1); + INSERT INTO t1 VALUES(2); + INSERT INTO t1 VALUES(3); + SELECT (SELECT max(x)OVER(ORDER BY x) + min(x)OVER(ORDER BY x)) + FROM (SELECT (SELECT sum(a) FROM t1) AS x FROM t1); + } {12 12 12} + + do_execsql_test 48.1 { + SELECT (SELECT max(x)OVER(ORDER BY x) + min(x)OVER(ORDER BY x)) + FROM (SELECT (SELECT sum(a) FROM t1 GROUP BY a) AS x FROM t1); + } {2 2 2} + - finish_test