1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
# 2001 September 15
#
# The author disclaims copyright to this source code. In place of
# a legal notice, here is a blessing:
#
# May you do good and not evil.
# May you find forgiveness for yourself and forgive others.
# May you share freely, never taking more than you give.
#
#***********************************************************************
# This file implements regression tests for SQLite library. The
# focus of this file is testing SELECT statements that are part of
# expressions.
#
# $Id: subselect.test,v 1.16 2008/08/04 03:51:24 danielk1977 Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
# Omit this whole file if the library is build without subquery support.
ifcapable !subquery {
finish_test
return
}
# Basic sanity checking. Try a simple subselect.
#
do_test subselect-1.1 {
execsql {
CREATE TABLE t1(a int, b int);
INSERT INTO t1 VALUES(1,2);
INSERT INTO t1 VALUES(3,4);
INSERT INTO t1 VALUES(5,6);
}
execsql {SELECT * FROM t1 WHERE a = (SELECT count(*) FROM t1)}
} {3 4}
# Try a select with more than one result column.
#
do_test subselect-1.2 {
set v [catch {execsql {SELECT * FROM t1 WHERE a = (SELECT * FROM t1)}} msg]
lappend v $msg
} {1 {row value misused}}
# A subselect without an aggregate.
#
do_test subselect-1.3a {
execsql {SELECT b from t1 where a = (SELECT a FROM t1 WHERE b=2)}
} {2}
do_test subselect-1.3b {
execsql {SELECT b from t1 where a = (SELECT a FROM t1 WHERE b=4)}
} {4}
do_test subselect-1.3c {
execsql {SELECT b from t1 where a = (SELECT a FROM t1 WHERE b=6)}
} {6}
do_test subselect-1.3d {
execsql {SELECT b from t1 where a = (SELECT a FROM t1 WHERE b=8)}
} {}
ifcapable compound {
do_test subselect-1.3e {
execsql {
SELECT b FROM t1
WHERE a = (SELECT a FROM t1 UNION SELECT b FROM t1 ORDER BY 1);
}
} {2}
}
# What if the subselect doesn't return any value. We should get
# NULL as the result. Check it out.
#
do_test subselect-1.4 {
execsql {SELECT b from t1 where a = coalesce((SELECT a FROM t1 WHERE b=5),1)}
} {2}
# Try multiple subselects within a single expression.
#
do_test subselect-1.5 {
execsql {
CREATE TABLE t2(x int, y int);
INSERT INTO t2 VALUES(1,2);
INSERT INTO t2 VALUES(2,4);
INSERT INTO t2 VALUES(3,8);
INSERT INTO t2 VALUES(4,16);
}
execsql {
SELECT y from t2
WHERE x = (SELECT sum(b) FROM t1 where a notnull) - (SELECT sum(a) FROM t1)
}
} {8}
# Try something useful. Delete every entry from t2 where the
# x value is less than half of the maximum.
#
do_test subselect-1.6 {
execsql {DELETE FROM t2 WHERE x < 0.5*(SELECT max(x) FROM t2)}
execsql {SELECT x FROM t2 ORDER BY x}
} {2 3 4}
# Make sure sorting works for SELECTs there used as a scalar expression.
#
do_test subselect-2.1 {
execsql {
SELECT (SELECT a FROM t1 ORDER BY a), (SELECT a FROM t1 ORDER BY a DESC)
}
} {1 5}
do_test subselect-2.2 {
execsql {
SELECT 1 IN (SELECT a FROM t1 ORDER BY a);
}
} {1}
do_test subselect-2.3 {
execsql {
SELECT 2 IN (SELECT a FROM t1 ORDER BY a DESC);
}
} {0}
# Verify that the ORDER BY clause is honored in a subquery.
#
ifcapable compound {
do_test subselect-3.1 {
execsql {
CREATE TABLE t3(x int);
INSERT INTO t3 SELECT a FROM t1 UNION ALL SELECT b FROM t1;
SELECT * FROM t3 ORDER BY x;
}
} {1 2 3 4 5 6}
} ;# ifcapable compound
ifcapable !compound {
do_test subselect-3.1 {
execsql {
CREATE TABLE t3(x int);
INSERT INTO t3 SELECT a FROM t1;
INSERT INTO t3 SELECT b FROM t1;
SELECT * FROM t3 ORDER BY x;
}
} {1 2 3 4 5 6}
} ;# ifcapable !compound
do_test subselect-3.2 {
execsql {
SELECT sum(x) FROM (SELECT x FROM t3 ORDER BY x LIMIT 2);
}
} {3}
do_test subselect-3.3 {
execsql {
SELECT sum(x) FROM (SELECT x FROM t3 ORDER BY x DESC LIMIT 2);
}
} {11}
do_test subselect-3.4 {
execsql {
SELECT (SELECT x FROM t3 ORDER BY x);
}
} {1}
do_test subselect-3.5 {
execsql {
SELECT (SELECT x FROM t3 ORDER BY x DESC);
}
} {6}
do_test subselect-3.6 {
execsql {
SELECT (SELECT x FROM t3 ORDER BY x LIMIT 1);
}
} {1}
do_test subselect-3.7 {
execsql {
SELECT (SELECT x FROM t3 ORDER BY x DESC LIMIT 1);
}
} {6}
do_test subselect-3.8 {
execsql {
SELECT (SELECT x FROM t3 ORDER BY x LIMIT 1 OFFSET 2);
}
} {3}
do_test subselect-3.9 {
execsql {
SELECT (SELECT x FROM t3 ORDER BY x DESC LIMIT 1 OFFSET 2);
}
} {4}
do_test subselect-3.10 {
execsql {
SELECT x FROM t3 WHERE x IN
(SELECT x FROM t3 ORDER BY x DESC LIMIT 1 OFFSET 2);
}
} {4}
# Ticket #2295.
# Make sure type affinities work correctly on subqueries with
# an ORDER BY clause.
#
do_test subselect-4.1 {
execsql {
CREATE TABLE t4(a TEXT, b TEXT);
INSERT INTO t4 VALUES('a','1');
INSERT INTO t4 VALUES('b','2');
INSERT INTO t4 VALUES('c','3');
SELECT a FROM t4 WHERE b IN (SELECT b FROM t4 ORDER BY b);
}
} {a b c}
do_test subselect-4.2 {
execsql {
SELECT a FROM t4 WHERE b IN (SELECT b FROM t4 ORDER BY b LIMIT 1);
}
} {a}
do_test subselect-4.3 {
execsql {
SELECT a FROM t4 WHERE b IN (SELECT b FROM t4 ORDER BY b DESC LIMIT 1);
}
} {c}
finish_test
|
