test: cover inSubqueryUsableInDeleteWhereClause

src/test/kotlin/kestrel/SubqueryTest.kt

@@ -162,3 +162,74 @@ class SubqueryTest {
         assertEquals(listOf(listOf(int(2)), listOf(int(2)), listOf(int(0))), result.rows)
     }
 
+    @Test
+    fun inSubqueryUsableInDeleteWhereClause() {
+        seed()
+        run("INSERT INTO employees VALUES (5, 'temp', 3, 10)")
+        run("DELETE FROM employees WHERE department_id IN (SELECT id FROM departments WHERE budget = 0)")
+        val result = select("SELECT name FROM employees ORDER BY name ASC")
+        assertEquals(
+            listOf(listOf(text("ada")), listOf(text("grace")), listOf(text("guido")), listOf(text("linus"))),
+            result.rows
+        )
+    }
+
+    @Test
+    fun scalarSubqueryUsableAsInsertValue() {
+        seed()
+        run("CREATE TABLE summary (id INTEGER PRIMARY KEY, employee_count INTEGER)")
+        run("INSERT INTO summary VALUES (1, (SELECT COUNT(*) FROM employees))")
+        val result = select("SELECT employee_count FROM summary")
+        assertEquals(listOf(listOf(int(4))), result.rows)
+    }
+
+    @Test
+    fun correlatedScalarSubqueryInUpdateSetRoundTripsThroughSqlWriter() {
+        seed()
+        run("CREATE TABLE dept_stats (id INTEGER PRIMARY KEY, headcount INTEGER)")
+        run("INSERT INTO dept_stats VALUES (1, 0), (2, 0), (3, 0)")
+        val statement = Parser(
+            Lexer(
+                "UPDATE dept_stats SET headcount = " +
+                    "(SELECT COUNT(*) FROM employees WHERE employees.department_id = dept_stats.id)"
+            ).tokenize()
+        ).parseProgram().single()
+        val rendered = kestrel.persistence.SqlWriter.write(statement)
+        val reparsed = Parser(Lexer(rendered).tokenize()).parseProgram().single()
+        executor.execute(reparsed)
+        val result = select("SELECT headcount FROM dept_stats ORDER BY id ASC")
+        assertEquals(listOf(listOf(int(2)), listOf(int(2)), listOf(int(0))), result.rows)
+    }
+
+    @Test
+    fun inSubqueryInDeleteWhereRoundTripsThroughSqlWriter() {
+        seed()
+        run("INSERT INTO employees VALUES (5, 'temp', 3, 10)")
+        val statement = Parser(
+            Lexer("DELETE FROM employees WHERE department_id IN (SELECT id FROM departments WHERE budget = 0)").tokenize()
+        ).parseProgram().single()
+        val rendered = kestrel.persistence.SqlWriter.write(statement)
+        val reparsed = Parser(Lexer(rendered).tokenize()).parseProgram().single()
+        executor.execute(reparsed)
+        val result = select("SELECT name FROM employees ORDER BY name ASC")
+        assertEquals(
+            listOf(listOf(text("ada")), listOf(text("grace")), listOf(text("guido")), listOf(text("linus"))),
+            result.rows
+        )
+    }
+
+    @Test
+    fun aggregateOverUncorrelatedScalarSubqueryEvaluatesItPerRow() {
+        seed()
+        val result = select("SELECT SUM((SELECT budget FROM departments WHERE id = 1)) FROM employees")
+        assertEquals(listOf(listOf(int(1000 * 4))), result.rows)
+    }
+
+    @Test
+    fun existsResultCannotBeUsedAsAnArithmeticOperand() {
+        seed()
+        assertFailsWith<KestrelException> {
+            select("SELECT 1 + EXISTS (SELECT 1 FROM employees) FROM departments WHERE id = 1")
+        }
+    }
+}