mirror of
https://github.com/VCMP-SqMod/SqMod.git
synced 2026-11-21 19:27:09 +01:00
Update libraries and make it build on windows.
Still gets some warnings because compilers have changed. But should work.
This commit is contained in:
1 parent
520a5eacc5
commit
f2b7499f85
3038 files changed
+251668
-273857
No files matched your search
@@ -0,0 +1,97 @@
|
||||
#include <stdio.h>
|
||||
#include <chrono>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "SQLParser.h"
|
||||
#include "thirdparty/microtest/microtest.h"
|
||||
|
||||
// Read all lines from the given file path. Skips comment lines.
|
||||
std::vector<std::string> readlines(std::string path);
|
||||
|
||||
// Read the queries from all files that were supplied to the test
|
||||
// through the -f argument. For all queries it is checked whether they
|
||||
// can be parsed successfully.
|
||||
TEST(AutoQueryFileTest) {
|
||||
const std::vector<std::string>& args = mt::Runtime::args();
|
||||
|
||||
std::vector<std::string> query_files;
|
||||
|
||||
// Parse command line arguments to retrieve query files.
|
||||
uint i = 1;
|
||||
for (; i < args.size(); ++i) {
|
||||
if (args[i] == "-f") {
|
||||
query_files.push_back(args[++i]);
|
||||
}
|
||||
}
|
||||
|
||||
// Read list of queries from all input files.
|
||||
std::vector<std::string> lines;
|
||||
for (std::string path : query_files) {
|
||||
std::vector<std::string> tmp = readlines(path);
|
||||
lines.insert(lines.end(), tmp.begin(), tmp.end());
|
||||
}
|
||||
|
||||
// Execute queries.
|
||||
size_t num_executed = 0;
|
||||
size_t num_failed = 0;
|
||||
for (std::string line : lines) {
|
||||
bool expected_result = true;
|
||||
std::string query = line;
|
||||
|
||||
// If a line starts with '!' parsing is expected to fail.
|
||||
if (query.at(0) == '!') {
|
||||
expected_result = false;
|
||||
query = query.substr(1);
|
||||
}
|
||||
|
||||
// Measuring the parsing time.
|
||||
std::chrono::time_point<std::chrono::system_clock> start, end;
|
||||
start = std::chrono::system_clock::now();
|
||||
|
||||
// Parse the query.
|
||||
hsql::SQLParserResult result;
|
||||
hsql::SQLParser::parse(query, &result);
|
||||
|
||||
end = std::chrono::system_clock::now();
|
||||
std::chrono::duration<double> elapsed_seconds = end - start;
|
||||
double us = elapsed_seconds.count() * 1000 * 1000;
|
||||
|
||||
if (expected_result == result.isValid()) {
|
||||
printf("\033[0;32m{ ok} (%.1fus)\033[0m %s\n", us, line.c_str());
|
||||
} else {
|
||||
printf("\033[0;31m{ failed}\033[0m\n");
|
||||
printf("\t\033[0;31m%s (L%d:%d)\n\033[0m", result.errorMsg(), result.errorLine(), result.errorColumn());
|
||||
printf("\t%s\n", line.c_str());
|
||||
++num_failed;
|
||||
}
|
||||
++num_executed;
|
||||
}
|
||||
|
||||
if (num_failed == 0) {
|
||||
printf("\033[0;32m{ ok} \033[0mAll %lu grammar tests completed successfully!\n", num_executed);
|
||||
} else {
|
||||
fprintf(stderr, "\033[0;31m{ failed} \033[0mSome grammar tests failed! %lu out of %lu tests failed!\n", num_failed,
|
||||
num_executed);
|
||||
}
|
||||
ASSERT_EQ(num_failed, 0);
|
||||
}
|
||||
|
||||
std::vector<std::string> readlines(std::string path) {
|
||||
std::ifstream infile(path);
|
||||
std::vector<std::string> lines;
|
||||
std::string line;
|
||||
while (std::getline(infile, line)) {
|
||||
std::istringstream iss(line);
|
||||
|
||||
// Skip comments.
|
||||
if (line[0] == '#' || (line[0] == '-' && line[1] == '-')) {
|
||||
continue;
|
||||
}
|
||||
|
||||
lines.push_back(line);
|
||||
}
|
||||
return lines;
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
|
||||
#include "SQLParser.h"
|
||||
#include "sql_asserts.h"
|
||||
#include "thirdparty/microtest/microtest.h"
|
||||
|
||||
using hsql::kExprLiteralInt;
|
||||
using hsql::kExprParameter;
|
||||
|
||||
using hsql::kStmtDrop;
|
||||
using hsql::kStmtExecute;
|
||||
using hsql::kStmtInsert;
|
||||
using hsql::kStmtPrepare;
|
||||
using hsql::kStmtSelect;
|
||||
|
||||
using hsql::kDropPreparedStatement;
|
||||
|
||||
using hsql::DropStatement;
|
||||
using hsql::ExecuteStatement;
|
||||
using hsql::InsertStatement;
|
||||
using hsql::PrepareStatement;
|
||||
using hsql::SelectStatement;
|
||||
|
||||
TEST(PrepareSingleStatementTest) {
|
||||
TEST_PARSE_SINGLE_SQL("PREPARE test FROM 'SELECT * FROM students WHERE grade = ?';", kStmtPrepare, PrepareStatement,
|
||||
result, prepare);
|
||||
|
||||
ASSERT_STREQ(prepare->name, "test");
|
||||
ASSERT_STREQ(prepare->query, "SELECT * FROM students WHERE grade = ?");
|
||||
|
||||
TEST_PARSE_SINGLE_SQL(prepare->query, kStmtSelect, SelectStatement, result2, select);
|
||||
|
||||
ASSERT_EQ(result2.parameters().size(), 1);
|
||||
ASSERT(select->whereClause->expr2->isType(kExprParameter))
|
||||
ASSERT_EQ(select->whereClause->expr2->ival, 0)
|
||||
}
|
||||
|
||||
TEST(DeallocatePrepareStatementTest) {
|
||||
TEST_PARSE_SINGLE_SQL("DEALLOCATE PREPARE test;", kStmtDrop, DropStatement, result, drop);
|
||||
|
||||
ASSERT_EQ(drop->type, kDropPreparedStatement);
|
||||
ASSERT_STREQ(drop->name, "test");
|
||||
}
|
||||
|
||||
TEST(StatementWithParameters) {
|
||||
TEST_PARSE_SINGLE_SQL("SELECT * FROM test WHERE a = ? AND b = ?", kStmtSelect, SelectStatement, result, stmt);
|
||||
|
||||
const hsql::Expr* eq1 = stmt->whereClause->expr;
|
||||
const hsql::Expr* eq2 = stmt->whereClause->expr2;
|
||||
|
||||
ASSERT_EQ(result.parameters().size(), 2);
|
||||
|
||||
ASSERT_EQ(eq1->opType, hsql::kOpEquals)
|
||||
ASSERT(eq1->expr->isType(hsql::kExprColumnRef))
|
||||
ASSERT(eq1->expr2->isType(kExprParameter))
|
||||
ASSERT_EQ(eq1->expr2->ival, 0)
|
||||
ASSERT_EQ(result.parameters()[0], eq1->expr2);
|
||||
|
||||
ASSERT_EQ(eq2->opType, hsql::kOpEquals)
|
||||
ASSERT(eq2->expr->isType(hsql::kExprColumnRef))
|
||||
ASSERT(eq2->expr2->isType(kExprParameter))
|
||||
ASSERT_EQ(eq2->expr2->ival, 1)
|
||||
ASSERT_EQ(result.parameters()[1], eq2->expr2);
|
||||
}
|
||||
|
||||
TEST(ExecuteStatementTest) {
|
||||
TEST_PARSE_SINGLE_SQL("EXECUTE test(1, 2);", kStmtExecute, ExecuteStatement, result, stmt);
|
||||
|
||||
ASSERT_STREQ(stmt->name, "test");
|
||||
ASSERT_EQ(stmt->parameters->size(), 2);
|
||||
}
|
||||
|
||||
TEST(ExecuteStatementTestNoParam) {
|
||||
TEST_PARSE_SINGLE_SQL("EXECUTE test();", kStmtExecute, ExecuteStatement, result, stmt);
|
||||
|
||||
ASSERT_STREQ(stmt->name, "test");
|
||||
ASSERT_EQ(stmt->parameters, 0);
|
||||
}
|
||||
|
||||
TEST(ExecuteStatementTestNoParamList) {
|
||||
TEST_PARSE_SINGLE_SQL("EXECUTE test;", kStmtExecute, ExecuteStatement, result, stmt);
|
||||
|
||||
ASSERT_STREQ(stmt->name, "test");
|
||||
ASSERT_EQ(stmt->parameters, 0);
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
# This file contains a list of strings that are NOT valid SQL queries.
|
||||
# Each line contains a single SQL query.
|
||||
# Each line starts with a '!' char to indicate that parsing should fail.
|
||||
!
|
||||
!1
|
||||
!gibberish;
|
||||
!CREATE TABLE "table" FROM TBL FILE 'students.tbl';gibberish
|
||||
!CREATE TABLE "table" FROM TBL FILE 'students.tbl';1
|
||||
!INSERT INTO test_table VALUESd (1, 2, 'test');
|
||||
!SELECT * FROM t WHERE a = ? AND b = ?;gibberish;
|
||||
!SHOW COLUMNS;
|
||||
!DESCRIBE;
|
||||
!COPY;
|
||||
!COPY students;
|
||||
!COPY students FROM 'students_file' WITH FORMAT XYZ;
|
||||
!COPY students TO 'students_file' WITH FORMAT XYZ;
|
||||
!select a + 2 as b(spam, eggs) from B;
|
||||
!WITH a AS SELECT 1 SELECT 1;
|
||||
!WITH a AS (SELECT ) SELECT 1;
|
||||
!WITH a AS (WITH b AS (SELECT 1) SELECT 1) SELECT 1; # We do not support nested WITH clauses
|
||||
!WITH a AS (SELECT ) b AS (SELECT ) SELECT 1; # Missing comma between WITH descriptions
|
||||
!BEGIN TRANSACTION transName; # Transaction naming is currently not supported
|
||||
!SELECT -9223372036854775809; # Out of int64_t range
|
||||
!SELECT 9223372036854775808; # Out of int64_t range
|
||||
!SELECT * FROM t WHERE a = DATE 'anystring';
|
||||
!SELECT * FROM t WHERE a = DATE '1996-12-310';
|
||||
!SELECT * FROM t WHERE a = DATE '1996-120-31';
|
||||
!SELECT * FROM t WHERE a = DATE '19960-12-31';
|
||||
!SELECT * FROM t WHERE a = DATE 'asdf-gh-jkl';
|
||||
!SELECT * FROM t WHERE a = DATE '2000-01-01' + INTERVAL 30;
|
||||
!SELECT * FROM t WHERE a = DATE '2000-01-01' + INTERVAL 30 DAYS;
|
||||
!SELECT * FROM t WHERE a = DATE '2000-01-01' + INTERVAL 30 'DAYS';
|
||||
!SELECT * FROM t WHERE a = DATE '2000-01-01' + INTERVAL 'DAYS';
|
||||
!SELECT * FROM t WHERE a = DATE '2000-01-01' + INTERVAL '1' ANYTHING;
|
||||
!SELECT * FROM t WHERE a = DATE '2000-01-01' + INTERVAL '1 DAY' DAY;
|
||||
!SELECT * FROM t WHERE a = DATE '2000-01-01' + INTERVAL '30 ANYTHING';
|
||||
!SELECT * FROM t WHERE a = DATE '2000-01-01' + INTERVAL '30' DAYS;
|
||||
!SELECT * FROM t WHERE a = DATE '2000-01-01' + x DAYS;
|
||||
!SELECT * FROM t WHERE a = DATE '2000-01-01' + INTERVAL 'x' DAY;
|
||||
!SELECT * FROM t WHERE a = DATE '2000-01-01' + INTERVAL '3.3 DAYS';
|
||||
# ON is not supported by postgres. We follow postgres here since the sql-92 standard does not specify index
|
||||
# implementation details.
|
||||
!DROP INDEX myindex ON mytable;
|
||||
!SELECT * FROM test WHERE val = 2 FOR KEY UPDATE;
|
||||
!SELECT * FROM test WHERE val = 2 FOR SHARE test1;
|
||||
!SELECT * FROM test WHERE val = 2 FOR NO KEY SHARE;
|
||||
!SELECT * FROM test WHERE val = 2 NOWAIT FOR UPDATE;
|
||||
!CREATE TABLE a_table (a_column INT PRIMARY KEY NULL);
|
||||
!CREATE TABLE a_table (a_column INT NULL PRIMARY KEY);
|
||||
!CREATE TABLE a_table (a_column INT NOT NULL NULL);
|
||||
!CREATE TABLE a_table (a_column INT NULL NOT NULL);
|
||||
# WINDOW EXPRESSIONS
|
||||
!SELECT test1, sum(sum(test2)) OVER (PARTITION BY test3 ORDER BY test4 ROWS BETWEEN UNBOUNDED AND CURRENT ROW) FROM test;
|
||||
!SELECT test1, sum(sum(test2)) OVER (PARTITION BY test3 ORDER BY test4 ROWS BETWEEN -1 PRECEDING AND CURRENT ROW) FROM test;
|
||||
!SELECT test1, rank() OVER (INVALID UNBOUNDED PRECEDING) FROM test;
|
||||
!SELECT rank() OVER (INVALID) FROM test;
|
||||
!SELECT rank OVER () FROM test;
|
||||
!SELECT a = 1 OVER () FROM test;
|
||||
!SELECT rank() OVER (ROWS UNBOUNDEDD PRECEDING) FROM test;
|
||||
!SELECT rank() OVER (ROWS UNBOUNDED PRECEDINGG) FROM test;
|
||||
!SELECT test1, rank() OVER (ROWS -1 PRECEDING) FROM test;
|
||||
!SELECT test1, rank() OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND -1 FOLLOWING) FROM test;
|
||||
@@ -0,0 +1,110 @@
|
||||
# This file contains a list of strings that are NOT valid SQL queries.
|
||||
# Each line contains a single SQL query.
|
||||
# SELECT statement
|
||||
SELECT * FROM orders;
|
||||
SELECT a FROM foo WHERE a > 12 OR b > 3 AND NOT c LIMIT 10
|
||||
SELECT a FROM some_schema.foo WHERE a > 12 OR b > 3 AND NOT c LIMIT 10
|
||||
SELECT col1 AS myname, col2, 'test' FROM "table", foo AS t WHERE age > 12 AND zipcode = 12345 GROUP BY col1;
|
||||
SELECT * from "table" JOIN table2 ON a = b WHERE (b OR NOT a) AND a = 12.5
|
||||
(SELECT a FROM foo WHERE a > 12 OR b > 3 AND c NOT LIKE 's%' LIMIT 10);
|
||||
SELECT * FROM "table" LIMIT 10 OFFSET 10; SELECT * FROM another;
|
||||
SELECT * FROM t1 UNION SELECT * FROM t2 ORDER BY col1;
|
||||
SELECT * FROM (SELECT * FROM t1);
|
||||
SELECT * FROM t1 UNION (SELECT * FROM t2 UNION SELECT * FROM t3) ORDER BY col1;
|
||||
SELECT TOP 10 * FROM t1 ORDER BY col1, col2;
|
||||
SELECT a, MAX(b), MAX(c, d), CUSTOM(q, UP(r)) AS f FROM t1;
|
||||
SELECT * FROM t WHERE a BETWEEN 1 and c;
|
||||
SELECT * FROM t WHERE a = ? AND b = ?;
|
||||
SELECT City.name, Product.category, SUM(price) FROM fact INNER JOIN City ON fact.city_id = City.id INNER JOIN Product ON fact.product_id = Product.id GROUP BY City.name, Product.category;
|
||||
SELECT SUBSTR(a, 3, 5) FROM t;
|
||||
SELECT * FROM t WHERE a = DATE '1996-12-31';
|
||||
# JOIN
|
||||
SELECT t1.a, t1.b, t2.c FROM "table" AS t1 JOIN (SELECT * FROM foo JOIN bar ON foo.id = bar.id) t2 ON t1.a = t2.b WHERE (t1.b OR NOT t1.a) AND t2.c = 12.5
|
||||
SELECT * FROM t1 JOIN t2 ON c1 = c2;
|
||||
SELECT a, SUM(b) FROM t2 GROUP BY a HAVING SUM(b) > 100;
|
||||
# CREATE statement
|
||||
CREATE TABLE "table" FROM TBL FILE 'students.tbl'
|
||||
CREATE TABLE IF NOT EXISTS "table" FROM TBL FILE 'students.tbl'
|
||||
CREATE TABLE students (name TEXT, student_number INTEGER, city TEXT, grade DOUBLE, credits BIGINT)
|
||||
CREATE TABLE students (name TEXT, student_number INTEGER NOT NULL, city TEXT, grade DOUBLE PRIMARY KEY UNIQUE)
|
||||
CREATE TABLE teachers (name VARCHAR(30), student_number LONG, city CHAR(10), grade FLOAT)
|
||||
CREATE TABLE teachers (name VARCHAR(30), student_number LONG, PRIMARY KEY (name, student_number), city CHAR(10), grade FLOAT)
|
||||
CREATE TABLE teachers (name CHARACTER VARYING(30));
|
||||
CREATE TABLE students_2 AS SELECT * FROM students
|
||||
CREATE TABLE students_3 AS SELECT city, grade FROM students WHERE grade > 3.0
|
||||
CREATE TABLE students (date_of_birth DATE, matriculation_date DATETIME, graduation_date TIMESTAMP, graduated BOOLEAN);
|
||||
# Multiple statements
|
||||
CREATE TABLE "table" FROM TBL FILE 'students.tbl'; SELECT * FROM "table";
|
||||
# INSERT
|
||||
INSERT INTO test_table VALUES (1, 2, 'test');
|
||||
INSERT INTO test_table (id, value, name) VALUES (1, 2, 'test');
|
||||
INSERT INTO test_table SELECT * FROM students;
|
||||
INSERT INTO some_schema.test_table SELECT * FROM another_schema.students;
|
||||
# DELETE
|
||||
DELETE FROM students WHERE grade > 3.0
|
||||
DELETE FROM students
|
||||
TRUNCATE students
|
||||
# UPDATE
|
||||
UPDATE students SET grade = 1.3 WHERE name = 'Max Mustermann';
|
||||
UPDATE students SET grade = 1.3, name='Felix Fürstenberg' WHERE name = 'Max Mustermann';
|
||||
UPDATE students SET grade = 1.0;
|
||||
UPDATE some_schema.students SET grade = 1.0;
|
||||
# ALTER
|
||||
ALTER TABLE mytable DROP COLUMN IF EXISTS mycolumn;
|
||||
ALTER TABLE IF EXISTS mytable DROP COLUMN IF EXISTS mycolumn;
|
||||
# DROP
|
||||
DROP TABLE students;
|
||||
DROP TABLE IF EXISTS students;
|
||||
DROP VIEW IF EXISTS students;
|
||||
DROP INDEX myindex;
|
||||
DROP INDEX IF EXISTS myindex;
|
||||
# PREPARE
|
||||
PREPARE prep_inst FROM 'INSERT INTO test VALUES (?, ?, ?)';
|
||||
PREPARE prep2 FROM 'INSERT INTO test VALUES (?, 0, 0); INSERT INTO test VALUES (0, ?, 0); INSERT INTO test VALUES (0, 0, ?);';
|
||||
EXECUTE prep_inst(1, 2, 3);
|
||||
EXECUTE prep;
|
||||
DEALLOCATE PREPARE prep;
|
||||
# COPY
|
||||
COPY students FROM 'student.tbl';
|
||||
COPY students FROM 'file_path' WITH FORMAT TBL;
|
||||
COPY students FROM 'file_path' WITH FORMAT CSV;
|
||||
COPY students FROM 'file_path' WITH FORMAT BIN;
|
||||
COPY students FROM 'file_path' WITH FORMAT BINARY;
|
||||
COPY good_students FROM 'file_path' WHERE grade > (SELECT AVG(grade) from alumni);
|
||||
COPY students TO 'student.tbl';
|
||||
COPY students TO 'file_path' WITH FORMAT TBL;
|
||||
COPY students TO 'file_path' WITH FORMAT CSV;
|
||||
COPY students TO 'file_path' WITH FORMAT BIN;
|
||||
COPY students TO 'file_path' WITH FORMAT BINARY;
|
||||
COPY (SELECT firstname, COUNT(*) FROM students GROUP BY firstname) TO 'student_names.csv';
|
||||
# HINTS
|
||||
SELECT * FROM test WITH HINT(NO_CACHE);
|
||||
SELECT * FROM test WITH HINT(NO_CACHE, NO_SAMPLING);
|
||||
SELECT * FROM test WITH HINT(NO_CACHE, SAMPLE_RATE(0.1), OMW(1.0, 'test'));
|
||||
SHOW TABLES;
|
||||
SHOW COLUMNS students;
|
||||
DESCRIBE students;
|
||||
SELECT * FROM t WHERE a = DATE '2000-01-01' + INTERVAL '30 DAYS';
|
||||
SELECT * FROM t WHERE a = DATE '2000-01-01' + INTERVAL '10' DAY;
|
||||
SELECT * FROM t WHERE a BETWEEN '2000-01-01' AND DATE '2000-01-01' - 1 MONTH;
|
||||
SELECT (CAST('2002-5-01' as DATE) + INTERVAL '60 days');
|
||||
SELECT CAST(student.student_number as BIGINT) FROM student;
|
||||
SELECT student.name AS character FROM student;
|
||||
# ROW LOCKING
|
||||
SELECT * FROM test WHERE id = 1 FOR UPDATE;
|
||||
SELECT * FROM test WHERE id = 1 FOR SHARE;
|
||||
SELECT * FROM test WHERE id = 1 FOR NO KEY UPDATE;
|
||||
SELECT * FROM test WHERE id = 1 FOR KEY SHARE;
|
||||
SELECT * FROM test WHERE id = 1 FOR UPDATE SKIP LOCKED;
|
||||
SELECT * FROM test WHERE id = 1 FOR UPDATE NOWAIT;
|
||||
SELECT * FROM test1, test2 WHERE test1.id = 10 FOR UPDATE OF test1;
|
||||
SELECT * FROM test1, test2 WHERE test2.val = 2 FOR SHARE OF test1, test2;
|
||||
SELECT * FROM test1, test2 WHERE test2.val = 2 FOR UPDATE OF test1 FOR SHARE OF test2;
|
||||
# WINDOW EXPRESSIONS
|
||||
SELECT test1, sum(sum(test2)) OVER (PARTITION BY test3 ORDER BY test4 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) an_alias FROM test;
|
||||
SELECT sum(test2)/sum(sum(test2)) OVER (PARTITION BY test1) FROM test GROUP BY test3;
|
||||
SELECT test1, sum(sum(test2)) OVER (PARTITION BY test3, test4 ORDER BY test5, test6 ROWS BETWEEN 1 PRECEDING AND 2 FOLLOWING) FROM test;
|
||||
SELECT test1, rank() OVER (ORDER BY test2 DESC, test3 ASC) rnk FROM test;
|
||||
SELECT rank() OVER () FROM test;
|
||||
SELECT rank() OVER (PARTITION BY test1) FROM test;
|
||||
SELECT rank() OVER (PARTITION BY test1 ORDER BY test2) FROM test;
|
||||
@@ -0,0 +1,9 @@
|
||||
-- http://www.sqlserver-dba.com/2011/09/this-is-a-followup-on-my-earlier-post-of-sql-server-test-data-generation-testing-tools-i-had-some-requests-for-my-set-up-pr.html
|
||||
SELECT L_RETURNFLAG, L_LINESTATUS, SUM(L_QUANTITY) AS SUM_QTY,
|
||||
SUM(L_EXTENDEDPRICE) AS SUM_BASE_PRICE, SUM(L_EXTENDEDPRICE*(1-L_DISCOUNT)) AS SUM_DISC_PRICE,
|
||||
SUM(L_EXTENDEDPRICE*(1-L_DISCOUNT)*(1+L_TAX)) AS SUM_CHARGE, AVG(L_QUANTITY) AS AVG_QTY,
|
||||
AVG(L_EXTENDEDPRICE) AS AVG_PRICE, AVG(L_DISCOUNT) AS AVG_DISC, COUNT(*) AS COUNT_ORDER
|
||||
FROM LINEITEM
|
||||
WHERE L_SHIPDATE <= dateadd(dd, -90, cast('1998-12-01' as datetime))
|
||||
GROUP BY L_RETURNFLAG, L_LINESTATUS
|
||||
ORDER BY L_RETURNFLAG,L_LINESTATUS
|
||||
@@ -0,0 +1,10 @@
|
||||
-- http://www.sqlserver-dba.com/2011/09/this-is-a-followup-on-my-earlier-post-of-sql-server-test-data-generation-testing-tools-i-had-some-requests-for-my-set-up-pr.html
|
||||
SELECT TOP 100 S_ACCTBAL, S_NAME, N_NAME, P_PARTKEY, P_MFGR, S_ADDRESS, S_PHONE, S_COMMENT
|
||||
FROM PART, SUPPLIER, PARTSUPP, NATION, REGION
|
||||
WHERE P_PARTKEY = PS_PARTKEY AND S_SUPPKEY = PS_SUPPKEY AND P_SIZE = 15 AND
|
||||
P_TYPE LIKE '%%BRASS' AND S_NATIONKEY = N_NATIONKEY AND N_REGIONKEY = R_REGIONKEY AND
|
||||
R_NAME = 'EUROPE' AND
|
||||
PS_SUPPLYCOST = (SELECT MIN(PS_SUPPLYCOST) FROM PARTSUPP, SUPPLIER, NATION, REGION
|
||||
WHERE P_PARTKEY = PS_PARTKEY AND S_SUPPKEY = PS_SUPPKEY
|
||||
AND S_NATIONKEY = N_NATIONKEY AND N_REGIONKEY = R_REGIONKEY AND R_NAME = 'EUROPE')
|
||||
ORDER BY S_ACCTBAL DESC, N_NAME, S_NAME, P_PARTKEY
|
||||
@@ -0,0 +1,7 @@
|
||||
-- http://www.sqlserver-dba.com/2011/09/this-is-a-followup-on-my-earlier-post-of-sql-server-test-data-generation-testing-tools-i-had-some-requests-for-my-set-up-pr.html
|
||||
SELECT TOP 10 L_ORDERKEY, SUM(L_EXTENDEDPRICE*(1-L_DISCOUNT)) AS REVENUE, O_ORDERDATE, O_SHIPPRIORITY
|
||||
FROM CUSTOMER, ORDERS, LINEITEM
|
||||
WHERE C_MKTSEGMENT = 'BUILDING' AND C_CUSTKEY = O_CUSTKEY AND L_ORDERKEY = O_ORDERKEY AND
|
||||
O_ORDERDATE < '1995-03-15' AND L_SHIPDATE > '1995-03-15'
|
||||
GROUP BY L_ORDERKEY, O_ORDERDATE, O_SHIPPRIORITY
|
||||
ORDER BY REVENUE DESC, O_ORDERDATE;
|
||||
@@ -0,0 +1,6 @@
|
||||
-- http://www.sqlserver-dba.com/2011/09/this-is-a-followup-on-my-earlier-post-of-sql-server-test-data-generation-testing-tools-i-had-some-requests-for-my-set-up-pr.html
|
||||
SELECT O_ORDERPRIORITY, COUNT(*) AS ORDER_COUNT FROM ORDERS
|
||||
WHERE O_ORDERDATE >= '1993-07-01' AND O_ORDERDATE < dateadd(mm,3, cast('1993-07-01' as datetime))
|
||||
AND EXISTS (SELECT * FROM LINEITEM WHERE L_ORDERKEY = O_ORDERKEY AND L_COMMITDATE < L_RECEIPTDATE)
|
||||
GROUP BY O_ORDERPRIORITY
|
||||
ORDER BY O_ORDERPRIORITY
|
||||
@@ -0,0 +1,9 @@
|
||||
-- http://www.sqlserver-dba.com/2011/09/this-is-a-followup-on-my-earlier-post-of-sql-server-test-data-generation-testing-tools-i-had-some-requests-for-my-set-up-pr.html
|
||||
SELECT N_NAME, SUM(L_EXTENDEDPRICE*(1-L_DISCOUNT)) AS REVENUE
|
||||
FROM CUSTOMER, ORDERS, LINEITEM, SUPPLIER, NATION, REGION
|
||||
WHERE C_CUSTKEY = O_CUSTKEY AND L_ORDERKEY = O_ORDERKEY AND L_SUPPKEY = S_SUPPKEY
|
||||
AND C_NATIONKEY = S_NATIONKEY AND S_NATIONKEY = N_NATIONKEY AND N_REGIONKEY = R_REGIONKEY
|
||||
AND R_NAME = 'ASIA' AND O_ORDERDATE >= '1994-01-01'
|
||||
AND O_ORDERDATE < DATEADD(YY, 1, cast('1994-01-01' as datetime))
|
||||
GROUP BY N_NAME
|
||||
ORDER BY REVENUE DESC
|
||||
@@ -0,0 +1,5 @@
|
||||
-- http://www.sqlserver-dba.com/2011/09/this-is-a-followup-on-my-earlier-post-of-sql-server-test-data-generation-testing-tools-i-had-some-requests-for-my-set-up-pr.html
|
||||
SELECT SUM(L_EXTENDEDPRICE*L_DISCOUNT) AS REVENUE
|
||||
FROM LINEITEM
|
||||
WHERE L_SHIPDATE >= '1994-01-01' AND L_SHIPDATE < dateadd(yy, 1, cast('1994-01-01' as datetime))
|
||||
AND L_DISCOUNT BETWEEN .06 - 0.01 AND .06 + 0.01 AND L_QUANTITY < 24
|
||||
@@ -0,0 +1,11 @@
|
||||
-- http://www.sqlserver-dba.com/2011/09/this-is-a-followup-on-my-earlier-post-of-sql-server-test-data-generation-testing-tools-i-had-some-requests-for-my-set-up-pr.html
|
||||
SELECT SUPP_NATION, CUST_NATION, L_YEAR, SUM(VOLUME) AS REVENUE
|
||||
FROM ( SELECT N1.N_NAME AS SUPP_NATION, N2.N_NAME AS CUST_NATION, datepart(yy, L_SHIPDATE) AS L_YEAR,
|
||||
L_EXTENDEDPRICE*(1-L_DISCOUNT) AS VOLUME
|
||||
FROM SUPPLIER, LINEITEM, ORDERS, CUSTOMER, NATION N1, NATION N2
|
||||
WHERE S_SUPPKEY = L_SUPPKEY AND O_ORDERKEY = L_ORDERKEY AND C_CUSTKEY = O_CUSTKEY
|
||||
AND S_NATIONKEY = N1.N_NATIONKEY AND C_NATIONKEY = N2.N_NATIONKEY AND ((N1.N_NAME = 'FRANCE' AND N2.N_NAME = 'GERMANY') OR
|
||||
(N1.N_NAME = 'GERMANY' AND N2.N_NAME = 'FRANCE')) AND
|
||||
L_SHIPDATE BETWEEN '1995-01-01' AND '1996-12-31' ) AS SHIPPING
|
||||
GROUP BY SUPP_NATION, CUST_NATION, L_YEAR
|
||||
ORDER BY SUPP_NATION, CUST_NATION, L_YEAR
|
||||
@@ -0,0 +1,10 @@
|
||||
-- http://www.sqlserver-dba.com/2011/09/this-is-a-followup-on-my-earlier-post-of-sql-server-test-data-generation-testing-tools-i-had-some-requests-for-my-set-up-pr.html
|
||||
SELECT O_YEAR, SUM(CASE WHEN NATION = 'BRAZIL' THEN VOLUME ELSE 0 END)/SUM(VOLUME) AS MKT_SHARE
|
||||
FROM (SELECT datepart(yy,O_ORDERDATE) AS O_YEAR, L_EXTENDEDPRICE*(1-L_DISCOUNT) AS VOLUME, N2.N_NAME AS NATION
|
||||
FROM "PART", SUPPLIER, LINEITEM, ORDERS, CUSTOMER, NATION N1, NATION N2, REGION
|
||||
WHERE P_PARTKEY = L_PARTKEY AND S_SUPPKEY = L_SUPPKEY AND L_ORDERKEY = O_ORDERKEY
|
||||
AND O_CUSTKEY = C_CUSTKEY AND C_NATIONKEY = N1.N_NATIONKEY AND
|
||||
N1.N_REGIONKEY = R_REGIONKEY AND R_NAME = 'AMERICA' AND S_NATIONKEY = N2.N_NATIONKEY
|
||||
AND O_ORDERDATE BETWEEN '1995-01-01' AND '1996-12-31' AND P_TYPE= 'ECONOMY ANODIZED STEEL') AS ALL_NATIONS
|
||||
GROUP BY O_YEAR
|
||||
ORDER BY O_YEAR
|
||||
@@ -0,0 +1,10 @@
|
||||
-- http://www.sqlserver-dba.com/2011/09/this-is-a-followup-on-my-earlier-post-of-sql-server-test-data-generation-testing-tools-i-had-some-requests-for-my-set-up-pr.html
|
||||
SELECT NATION, O_YEAR, SUM(AMOUNT) AS SUM_PROFIT
|
||||
FROM (SELECT N_NAME AS NATION, datepart(yy, O_ORDERDATE) AS O_YEAR,
|
||||
L_EXTENDEDPRICE*(1-L_DISCOUNT)-PS_SUPPLYCOST*L_QUANTITY AS AMOUNT
|
||||
FROM "PART", SUPPLIER, LINEITEM, PARTSUPP, ORDERS, NATION
|
||||
WHERE S_SUPPKEY = L_SUPPKEY AND PS_SUPPKEY= L_SUPPKEY AND PS_PARTKEY = L_PARTKEY AND
|
||||
P_PARTKEY= L_PARTKEY AND O_ORDERKEY = L_ORDERKEY AND S_NATIONKEY = N_NATIONKEY AND
|
||||
P_NAME LIKE '%%green%%') AS PROFIT
|
||||
GROUP BY NATION, O_YEAR
|
||||
ORDER BY NATION, O_YEAR DESC
|
||||
@@ -0,0 +1,9 @@
|
||||
-- http://www.sqlserver-dba.com/2011/09/this-is-a-followup-on-my-earlier-post-of-sql-server-test-data-generation-testing-tools-i-had-some-requests-for-my-set-up-pr.html
|
||||
SELECT TOP 20 C_CUSTKEY, C_NAME, SUM(L_EXTENDEDPRICE*(1-L_DISCOUNT)) AS REVENUE, C_ACCTBAL,
|
||||
N_NAME, C_ADDRESS, C_PHONE, C_COMMENT
|
||||
FROM CUSTOMER, ORDERS, LINEITEM, NATION
|
||||
WHERE C_CUSTKEY = O_CUSTKEY AND L_ORDERKEY = O_ORDERKEY AND O_ORDERDATE>= '1993-10-01' AND
|
||||
O_ORDERDATE < dateadd(mm, 3, cast('1993-10-01' as datetime)) AND
|
||||
L_RETURNFLAG = 'R' AND C_NATIONKEY = N_NATIONKEY
|
||||
GROUP BY C_CUSTKEY, C_NAME, C_ACCTBAL, C_PHONE, N_NAME, C_ADDRESS, C_COMMENT
|
||||
ORDER BY REVENUE DESC
|
||||
@@ -0,0 +1,10 @@
|
||||
-- http://www.sqlserver-dba.com/2011/09/this-is-a-followup-on-my-earlier-post-of-sql-server-test-data-generation-testing-tools-i-had-some-requests-for-my-set-up-pr.html
|
||||
-- TPC_H Query 11 - Important Stock Identification
|
||||
SELECT PS_PARTKEY, SUM(PS_SUPPLYCOST*PS_AVAILQTY) AS VALUE
|
||||
FROM PARTSUPP, SUPPLIER, NATION
|
||||
WHERE PS_SUPPKEY = S_SUPPKEY AND S_NATIONKEY = N_NATIONKEY AND N_NAME = 'GERMANY'
|
||||
GROUP BY PS_PARTKEY
|
||||
HAVING SUM(PS_SUPPLYCOST*PS_AVAILQTY) > (SELECT SUM(PS_SUPPLYCOST*PS_AVAILQTY) * 0.0001000000
|
||||
FROM PARTSUPP, SUPPLIER, NATION
|
||||
WHERE PS_SUPPKEY = S_SUPPKEY AND S_NATIONKEY = N_NATIONKEY AND N_NAME = 'GERMANY')
|
||||
ORDER BY VALUE DESC;
|
||||
@@ -0,0 +1,10 @@
|
||||
-- TPC_H Query 12 - Shipping Modes and Order Priority
|
||||
SELECT L_SHIPMODE,
|
||||
SUM(CASE WHEN O_ORDERPRIORITY = '1-URGENT' OR O_ORDERPRIORITY = '2-HIGH' THEN 1 ELSE 0 END) AS HIGH_LINE_COUNT,
|
||||
SUM(CASE WHEN O_ORDERPRIORITY <> '1-URGENT' AND O_ORDERPRIORITY <> '2-HIGH' THEN 1 ELSE 0 END ) AS LOW_LINE_COUNT
|
||||
FROM ORDERS, LINEITEM
|
||||
WHERE O_ORDERKEY = L_ORDERKEY AND L_SHIPMODE IN ('MAIL','SHIP')
|
||||
AND L_COMMITDATE < L_RECEIPTDATE AND L_SHIPDATE < L_COMMITDATE AND L_RECEIPTDATE >= '1994-01-01'
|
||||
AND L_RECEIPTDATE < dateadd(mm, 1, cast('1995-09-01' as datetime))
|
||||
GROUP BY L_SHIPMODE
|
||||
ORDER BY L_SHIPMODE;
|
||||
@@ -0,0 +1,8 @@
|
||||
-- TPC_H Query 13 - Customer Distribution
|
||||
SELECT C_COUNT, COUNT(*) AS CUSTDIST
|
||||
FROM (SELECT C_CUSTKEY, COUNT(O_ORDERKEY)
|
||||
FROM CUSTOMER left outer join ORDERS on C_CUSTKEY = O_CUSTKEY
|
||||
AND O_COMMENT not like '%%special%%requests%%'
|
||||
GROUP BY C_CUSTKEY) AS C_ORDERS (C_CUSTKEY, C_COUNT)
|
||||
GROUP BY C_COUNT
|
||||
ORDER BY CUSTDIST DESC, C_COUNT DESC;
|
||||
@@ -0,0 +1,5 @@
|
||||
-- TPC_H Query 14 - Promotion Effect
|
||||
SELECT 100.00* SUM(CASE WHEN P_TYPE LIKE 'PROMO%%' THEN L_EXTENDEDPRICE*(1-L_DISCOUNT)
|
||||
ELSE 0 END) / SUM(L_EXTENDEDPRICE*(1-L_DISCOUNT)) AS PROMO_REVENUE
|
||||
FROM LINEITEM, PART
|
||||
WHERE L_PARTKEY = P_PARTKEY AND L_SHIPDATE >= '1995-09-01' AND L_SHIPDATE < dateadd(mm, 1, '1995-09-01');
|
||||
@@ -0,0 +1,15 @@
|
||||
-- TPC_H Query 15.1 - Create View for Top Supplier Query
|
||||
CREATE VIEW REVENUE0 (SUPPLIER_NO, TOTAL_REVENUE) AS
|
||||
SELECT L_SUPPKEY, SUM(L_EXTENDEDPRICE*(1-L_DISCOUNT)) FROM LINEITEM
|
||||
WHERE L_SHIPDATE >= '1996-01-01' AND L_SHIPDATE < dateadd(mm, 3, cast('1996-01-01' as datetime))
|
||||
GROUP BY L_SUPPKEY;
|
||||
|
||||
|
||||
-- TPC_H Query 15.2 - Top Supplier
|
||||
SELECT S_SUPPKEY, S_NAME, S_ADDRESS, S_PHONE, TOTAL_REVENUE
|
||||
FROM SUPPLIER, REVENUE0
|
||||
WHERE S_SUPPKEY = SUPPLIER_NO AND TOTAL_REVENUE = (SELECT MAX(TOTAL_REVENUE) FROM REVENUE0)
|
||||
ORDER BY S_SUPPKEY;
|
||||
|
||||
-- TPC_H Query 15.3 - Drop View
|
||||
DROP VIEW REVENUE0;
|
||||
@@ -0,0 +1,9 @@
|
||||
-- http://www.sqlserver-dba.com/2011/09/this-is-a-followup-on-my-earlier-post-of-sql-server-test-data-generation-testing-tools-i-had-some-requests-for-my-set-up-pr.html
|
||||
-- TPC_H Query 16 - Parts/Supplier Relationship
|
||||
SELECT P_BRAND, P_TYPE, P_SIZE, COUNT(DISTINCT PS_SUPPKEY) AS SUPPLIER_CNT
|
||||
FROM PARTSUPP, "PART"
|
||||
WHERE P_PARTKEY = PS_PARTKEY AND P_BRAND <> 'Brand#45' AND P_TYPE NOT LIKE 'MEDIUM POLISHED%%'
|
||||
AND P_SIZE IN (49, 14, 23, 45, 19, 3, 36, 9) AND PS_SUPPKEY NOT IN (SELECT S_SUPPKEY FROM SUPPLIER
|
||||
WHERE S_COMMENT LIKE '%%Customer%%Complaints%%')
|
||||
GROUP BY P_BRAND, P_TYPE, P_SIZE
|
||||
ORDER BY SUPPLIER_CNT DESC, P_BRAND, P_TYPE, P_SIZE;
|
||||
@@ -0,0 +1,4 @@
|
||||
-- TPC_H Query 17 - Small-Quantity-Order Revenue
|
||||
SELECT SUM(L_EXTENDEDPRICE)/7.0 AS AVG_YEARLY FROM LINEITEM, "PART"
|
||||
WHERE P_PARTKEY = L_PARTKEY AND P_BRAND = 'Brand#23' AND P_CONTAINER = 'MED BOX'
|
||||
AND L_QUANTITY < (SELECT 0.2*AVG(L_QUANTITY) FROM LINEITEM WHERE L_PARTKEY = P_PARTKEY);
|
||||
@@ -0,0 +1,7 @@
|
||||
-- TPC_H Query 18 - Large Volume Customer
|
||||
SELECT TOP 100 C_NAME, C_CUSTKEY, O_ORDERKEY, O_ORDERDATE, O_TOTALPRICE, SUM(L_QUANTITY)
|
||||
FROM CUSTOMER, ORDERS, LINEITEM
|
||||
WHERE O_ORDERKEY IN (SELECT L_ORDERKEY FROM LINEITEM GROUP BY L_ORDERKEY HAVING
|
||||
SUM(L_QUANTITY) > 300) AND C_CUSTKEY = O_CUSTKEY AND O_ORDERKEY = L_ORDERKEY
|
||||
GROUP BY C_NAME, C_CUSTKEY, O_ORDERKEY, O_ORDERDATE, O_TOTALPRICE
|
||||
ORDER BY O_TOTALPRICE DESC, O_ORDERDATE;
|
||||
@@ -0,0 +1,9 @@
|
||||
-- TPC_H Query 19 - Discounted Revenue
|
||||
SELECT SUM(L_EXTENDEDPRICE* (1 - L_DISCOUNT)) AS REVENUE
|
||||
FROM LINEITEM, "PART"
|
||||
WHERE (P_PARTKEY = L_PARTKEY AND P_BRAND = 'Brand#12' AND P_CONTAINER IN ('SM CASE', 'SM BOX', 'SM PACK', 'SM PKG') AND L_QUANTITY >= 1 AND L_QUANTITY <= 1 + 10 AND P_SIZE BETWEEN 1 AND 5
|
||||
AND L_SHIPMODE IN ('AIR', 'AIR REG') AND L_SHIPINSTRUCT = 'DELIVER IN PERSON')
|
||||
OR (P_PARTKEY = L_PARTKEY AND P_BRAND ='Brand#23' AND P_CONTAINER IN ('MED BAG', 'MED BOX', 'MED PKG', 'MED PACK') AND L_QUANTITY >=10 AND L_QUANTITY <=10 + 10 AND P_SIZE BETWEEN 1 AND 10
|
||||
AND L_SHIPMODE IN ('AIR', 'AIR REG') AND L_SHIPINSTRUCT = 'DELIVER IN PERSON')
|
||||
OR (P_PARTKEY = L_PARTKEY AND P_BRAND = 'Brand#34' AND P_CONTAINER IN ( 'LG CASE', 'LG BOX', 'LG PACK', 'LG PKG') AND L_QUANTITY >=20 AND L_QUANTITY <= 20 + 10 AND P_SIZE BETWEEN 1 AND 15
|
||||
AND L_SHIPMODE IN ('AIR', 'AIR REG') AND L_SHIPINSTRUCT = 'DELIVER IN PERSON');
|
||||
@@ -0,0 +1,8 @@
|
||||
-- TPC_H Query 20 - Potential Part Promotion
|
||||
SELECT S_NAME, S_ADDRESS FROM SUPPLIER, NATION
|
||||
WHERE S_SUPPKEY IN (SELECT PS_SUPPKEY FROM PARTSUPP
|
||||
WHERE PS_PARTKEY in (SELECT P_PARTKEY FROM "PART" WHERE P_NAME like 'forest%%') AND
|
||||
PS_AVAILQTY > (SELECT 0.5*sum(L_QUANTITY) FROM LINEITEM WHERE L_PARTKEY = PS_PARTKEY AND
|
||||
L_SUPPKEY = PS_SUPPKEY AND L_SHIPDATE >= '1994-01-01' AND
|
||||
L_SHIPDATE < dateadd(yy,1,'1994-01-01'))) AND S_NATIONKEY = N_NATIONKEY AND N_NAME = 'CANADA'
|
||||
ORDER BY S_NAME;
|
||||
@@ -0,0 +1,11 @@
|
||||
-- TPC_H Query 21 - Suppliers Who Kept Orders Waiting
|
||||
SELECT TOP 100 S_NAME, COUNT(*) AS NUMWAIT
|
||||
FROM SUPPLIER, LINEITEM L1, ORDERS, NATION WHERE S_SUPPKEY = L1.L_SUPPKEY AND
|
||||
O_ORDERKEY = L1.L_ORDERKEY AND O_ORDERSTATUS = 'F' AND L1.L_RECEIPTDATE> L1.L_COMMITDATE
|
||||
AND EXISTS (SELECT * FROM LINEITEM L2 WHERE L2.L_ORDERKEY = L1.L_ORDERKEY
|
||||
AND L2.L_SUPPKEY <> L1.L_SUPPKEY) AND
|
||||
NOT EXISTS (SELECT * FROM LINEITEM L3 WHERE L3.L_ORDERKEY = L1.L_ORDERKEY AND
|
||||
L3.L_SUPPKEY <> L1.L_SUPPKEY AND L3.L_RECEIPTDATE > L3.L_COMMITDATE) AND
|
||||
S_NATIONKEY = N_NATIONKEY AND N_NAME = 'SAUDI ARABIA'
|
||||
GROUP BY S_NAME
|
||||
ORDER BY NUMWAIT DESC, S_NAME;
|
||||
@@ -0,0 +1,9 @@
|
||||
-- TPC_H Query 22 - Global Sales Opportunity */
|
||||
SELECT CNTRYCODE, COUNT(*) AS NUMCUST, SUM(C_ACCTBAL) AS TOTACCTBAL
|
||||
FROM (SELECT SUBSTRING(C_PHONE,1,2) AS CNTRYCODE, C_ACCTBAL
|
||||
FROM CUSTOMER WHERE SUBSTRING(C_PHONE,1,2) IN ('13', '31', '23', '29', '30', '18', '17') AND
|
||||
C_ACCTBAL > (SELECT AVG(C_ACCTBAL) FROM CUSTOMER WHERE C_ACCTBAL > 0.00 AND
|
||||
SUBSTRING(C_PHONE,1,2) IN ('13', '31', '23', '29', '30', '18', '17')) AND
|
||||
NOT EXISTS ( SELECT * FROM ORDERS WHERE O_CUSTKEY = C_CUSTKEY)) AS CUSTSALE
|
||||
GROUP BY CNTRYCODE
|
||||
ORDER BY CNTRYCODE;
|
||||
+1138
File diff suppressed because it is too large.
Load diff
+19
@@ -0,0 +1,19 @@
|
||||
#ifndef __HELPER_H__
|
||||
#define __HELPER_H__
|
||||
|
||||
#define TEST_PARSE_SQL_QUERY(query, result, numStatements) \
|
||||
hsql::SQLParserResult result; \
|
||||
hsql::SQLParser::parse(query, &result); \
|
||||
ASSERT(result.isValid()); \
|
||||
ASSERT_EQ(result.size(), numStatements);
|
||||
|
||||
#define TEST_PARSE_SINGLE_SQL(query, stmtType, stmtClass, result, outputVar) \
|
||||
TEST_PARSE_SQL_QUERY(query, result, 1); \
|
||||
ASSERT_EQ(result.getStatement(0)->type(), stmtType); \
|
||||
const stmtClass* outputVar = (const stmtClass*)result.getStatement(0);
|
||||
|
||||
#define TEST_CAST_STMT(result, stmt_index, stmtType, stmtClass, outputVar) \
|
||||
ASSERT_EQ(result.getStatement(stmt_index)->type(), stmtType); \
|
||||
const stmtClass* outputVar = (const stmtClass*)result.getStatement(stmt_index);
|
||||
|
||||
#endif
|
||||
+44
@@ -0,0 +1,44 @@
|
||||
#include "thirdparty/microtest/microtest.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <map>
|
||||
#include <string>
|
||||
|
||||
#include "SQLParser.h"
|
||||
#include "parser/bison_parser.h"
|
||||
#include "sql_asserts.h"
|
||||
|
||||
using namespace hsql;
|
||||
|
||||
void test_tokens(const std::string& query, const std::vector<int16_t>& expected_tokens) {
|
||||
std::vector<int16_t> tokens;
|
||||
ASSERT(SQLParser::tokenize(query, &tokens));
|
||||
|
||||
ASSERT_EQ(expected_tokens.size(), tokens.size());
|
||||
|
||||
for (unsigned i = 0; i < expected_tokens.size(); ++i) {
|
||||
ASSERT_EQ(expected_tokens[i], tokens[i]);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(SQLParserTokenizeTest) {
|
||||
test_tokens("SELECT * FROM test;", {SQL_SELECT, '*', SQL_FROM, SQL_IDENTIFIER, ';'});
|
||||
test_tokens("SELECT a, 'b' FROM test WITH HINT;",
|
||||
{SQL_SELECT, SQL_IDENTIFIER, ',', SQL_STRING, SQL_FROM, SQL_IDENTIFIER, SQL_WITH, SQL_HINT, ';'});
|
||||
}
|
||||
|
||||
TEST(SQLParserTokenizeStringifyTest) {
|
||||
const std::string query = "SELECT * FROM test;";
|
||||
std::vector<int16_t> tokens;
|
||||
ASSERT(SQLParser::tokenize(query, &tokens));
|
||||
|
||||
// Make u16string.
|
||||
std::u16string token_string(tokens.cbegin(), tokens.cend());
|
||||
|
||||
// Check if u16 string is cacheable.
|
||||
std::map<std::u16string, std::string> cache;
|
||||
cache[token_string] = query;
|
||||
|
||||
ASSERT(query == cache[token_string]);
|
||||
ASSERT(&query != &cache[token_string]);
|
||||
}
|
||||
+679
@@ -0,0 +1,679 @@
|
||||
/*
|
||||
* sql_tests.cpp
|
||||
*/
|
||||
|
||||
#include "thirdparty/microtest/microtest.h"
|
||||
|
||||
#include "SQLParser.h"
|
||||
#include "util/sqlhelper.h"
|
||||
|
||||
#include "sql_asserts.h"
|
||||
|
||||
using namespace hsql;
|
||||
|
||||
TEST(DeleteStatementTest) {
|
||||
SQLParserResult result;
|
||||
SQLParser::parse("DELETE FROM students WHERE grade > 2.0;", &result);
|
||||
|
||||
ASSERT(result.isValid());
|
||||
ASSERT_EQ(result.size(), 1);
|
||||
ASSERT(result.getStatement(0)->type() == kStmtDelete);
|
||||
|
||||
const DeleteStatement* stmt = (const DeleteStatement*)result.getStatement(0);
|
||||
ASSERT_STREQ(stmt->tableName, "students");
|
||||
ASSERT_NOTNULL(stmt->expr);
|
||||
ASSERT(stmt->expr->isType(kExprOperator));
|
||||
ASSERT_STREQ(stmt->expr->expr->name, "grade");
|
||||
ASSERT_EQ(stmt->expr->expr2->fval, 2.0);
|
||||
}
|
||||
|
||||
TEST(CreateStatementTest) {
|
||||
SQLParserResult result;
|
||||
SQLParser::parse(
|
||||
"CREATE TABLE dummy_table ("
|
||||
" c_bigint BIGINT, "
|
||||
" c_boolean BOOLEAN, "
|
||||
" c_char CHAR(42), "
|
||||
" c_date DATE, "
|
||||
" c_datetime DATETIME, "
|
||||
" c_decimal DECIMAL, "
|
||||
" c_decimal_precision DECIMAL(13), "
|
||||
" c_decimal_precision_scale DECIMAL(13,37), "
|
||||
" c_double_not_null DOUBLE NOT NULL, "
|
||||
" c_float FLOAT, "
|
||||
" c_int INT, "
|
||||
" PRIMARY KEY(c_char, c_int), "
|
||||
" c_integer_null INTEGER NULL, "
|
||||
" c_long LONG, "
|
||||
" c_real REAL, "
|
||||
" c_smallint SMALLINT, "
|
||||
" c_text TEXT UNIQUE PRIMARY KEY NOT NULL, "
|
||||
" c_time TIME, "
|
||||
" c_time_precision TIME(17), "
|
||||
" c_timestamp TIMESTAMP, "
|
||||
" c_varchar VARCHAR(50), "
|
||||
" c_char_varying CHARACTER VARYING(60)"
|
||||
")",
|
||||
&result);
|
||||
ASSERT(result.isValid());
|
||||
ASSERT_EQ(result.size(), 1);
|
||||
ASSERT_EQ(result.getStatement(0)->type(), kStmtCreate);
|
||||
|
||||
const CreateStatement* stmt = (const CreateStatement*)result.getStatement(0);
|
||||
ASSERT_EQ(stmt->type, kCreateTable);
|
||||
ASSERT_STREQ(stmt->tableName, "dummy_table");
|
||||
ASSERT_NOTNULL(stmt->columns);
|
||||
ASSERT_EQ(stmt->columns->size(), 21);
|
||||
// c_bigint BIGINT
|
||||
ASSERT_STREQ(stmt->columns->at(0)->name, "c_bigint");
|
||||
ASSERT_EQ(stmt->columns->at(0)->type, (ColumnType{DataType::BIGINT}));
|
||||
ASSERT_EQ(stmt->columns->at(0)->nullable, true);
|
||||
// c_boolean BOOLEAN
|
||||
ASSERT_STREQ(stmt->columns->at(1)->name, "c_boolean");
|
||||
ASSERT_EQ(stmt->columns->at(1)->type, (ColumnType{DataType::BOOLEAN}));
|
||||
ASSERT_EQ(stmt->columns->at(1)->nullable, true);
|
||||
// c_char CHAR(42)
|
||||
ASSERT_STREQ(stmt->columns->at(2)->name, "c_char");
|
||||
ASSERT_EQ(stmt->columns->at(2)->type, (ColumnType{DataType::CHAR, 42}));
|
||||
ASSERT_NEQ(stmt->columns->at(2)->type, (ColumnType{DataType::CHAR, 43}));
|
||||
ASSERT_EQ(stmt->columns->at(2)->nullable, true);
|
||||
// c_date DATE
|
||||
ASSERT_STREQ(stmt->columns->at(3)->name, "c_date");
|
||||
ASSERT_EQ(stmt->columns->at(3)->type, (ColumnType{DataType::DATE}));
|
||||
ASSERT_EQ(stmt->columns->at(3)->nullable, true);
|
||||
// c_datetime DATETIME
|
||||
ASSERT_STREQ(stmt->columns->at(4)->name, "c_datetime");
|
||||
ASSERT_EQ(stmt->columns->at(4)->type, (ColumnType{DataType::DATETIME}));
|
||||
ASSERT_EQ(stmt->columns->at(4)->nullable, true);
|
||||
// c_decimal DECIMAL
|
||||
ASSERT_STREQ(stmt->columns->at(5)->name, "c_decimal");
|
||||
ASSERT_EQ(stmt->columns->at(5)->type, (ColumnType{DataType::DECIMAL}));
|
||||
ASSERT_EQ(stmt->columns->at(5)->nullable, true);
|
||||
// c_decimal_precision DECIMAL(13)
|
||||
ASSERT_STREQ(stmt->columns->at(6)->name, "c_decimal_precision");
|
||||
ASSERT_EQ(stmt->columns->at(6)->type, (ColumnType{DataType::DECIMAL, 0, 13}));
|
||||
ASSERT_NEQ(stmt->columns->at(6)->type, (ColumnType{DataType::DECIMAL, 0, 14}));
|
||||
ASSERT_NEQ(stmt->columns->at(6)->type, (ColumnType{DataType::DECIMAL, 1, 13}));
|
||||
ASSERT_EQ(stmt->columns->at(6)->nullable, true);
|
||||
// c_decimal_precision_scale DECIMAL(13,37)
|
||||
ASSERT_STREQ(stmt->columns->at(7)->name, "c_decimal_precision_scale");
|
||||
ASSERT_EQ(stmt->columns->at(7)->type, (ColumnType{DataType::DECIMAL, 0, 13, 37}));
|
||||
ASSERT_NEQ(stmt->columns->at(7)->type, (ColumnType{DataType::DECIMAL, 0, 14, 37}));
|
||||
ASSERT_NEQ(stmt->columns->at(7)->type, (ColumnType{DataType::DECIMAL, 0, 13, 38}));
|
||||
ASSERT_NEQ(stmt->columns->at(7)->type, (ColumnType{DataType::DECIMAL, 1, 13, 37}));
|
||||
ASSERT_EQ(stmt->columns->at(7)->nullable, true);
|
||||
// c_double_not_null DOUBLE NOT NULL
|
||||
ASSERT_STREQ(stmt->columns->at(8)->name, "c_double_not_null");
|
||||
ASSERT_EQ(stmt->columns->at(8)->type, (ColumnType{DataType::DOUBLE}));
|
||||
ASSERT_EQ(stmt->columns->at(8)->nullable, false);
|
||||
ASSERT_EQ(stmt->columns->at(8)->column_constraints->size(), 1);
|
||||
ASSERT(stmt->columns->at(8)->column_constraints->count(ConstraintType::NotNull));
|
||||
// c_float FLOAT
|
||||
ASSERT_STREQ(stmt->columns->at(9)->name, "c_float");
|
||||
ASSERT_EQ(stmt->columns->at(9)->type, (ColumnType{DataType::FLOAT}));
|
||||
ASSERT_EQ(stmt->columns->at(9)->nullable, true);
|
||||
// c_int INT
|
||||
ASSERT_STREQ(stmt->columns->at(10)->name, "c_int");
|
||||
ASSERT_EQ(stmt->columns->at(10)->type, (ColumnType{DataType::INT}));
|
||||
ASSERT_EQ(stmt->columns->at(10)->nullable, true);
|
||||
// c_integer INTEGER NULL
|
||||
ASSERT_STREQ(stmt->columns->at(11)->name, "c_integer_null");
|
||||
ASSERT_EQ(stmt->columns->at(11)->type, (ColumnType{DataType::INT}));
|
||||
ASSERT_EQ(stmt->columns->at(11)->nullable, true);
|
||||
ASSERT_EQ(stmt->columns->at(11)->column_constraints->size(), 1);
|
||||
ASSERT(stmt->columns->at(11)->column_constraints->count(ConstraintType::Null));
|
||||
// c_long LONG
|
||||
ASSERT_STREQ(stmt->columns->at(12)->name, "c_long");
|
||||
ASSERT_EQ(stmt->columns->at(12)->type, (ColumnType{DataType::LONG}));
|
||||
ASSERT_EQ(stmt->columns->at(12)->nullable, true);
|
||||
// c_real REAL
|
||||
ASSERT_STREQ(stmt->columns->at(13)->name, "c_real");
|
||||
ASSERT_EQ(stmt->columns->at(13)->type, (ColumnType{DataType::REAL}));
|
||||
ASSERT_EQ(stmt->columns->at(13)->nullable, true);
|
||||
// c_smallint SMALLINT
|
||||
ASSERT_STREQ(stmt->columns->at(14)->name, "c_smallint");
|
||||
ASSERT_EQ(stmt->columns->at(14)->type, (ColumnType{DataType::SMALLINT}));
|
||||
ASSERT_EQ(stmt->columns->at(14)->nullable, true);
|
||||
// c_text TEXT UNIQUE PRIMARY KEY NOT NULL
|
||||
ASSERT_STREQ(stmt->columns->at(15)->name, "c_text");
|
||||
ASSERT_EQ(stmt->columns->at(15)->type, (ColumnType{DataType::TEXT}));
|
||||
ASSERT_EQ(stmt->columns->at(15)->nullable, false);
|
||||
// Expecting two elements in column_constraints since information about NULL constraints is separately stored in
|
||||
// ColumnDefinition::nullable
|
||||
ASSERT_EQ(stmt->columns->at(15)->column_constraints->size(), 3);
|
||||
ASSERT(stmt->columns->at(15)->column_constraints->count(ConstraintType::Unique));
|
||||
ASSERT(stmt->columns->at(15)->column_constraints->count(ConstraintType::PrimaryKey));
|
||||
ASSERT(stmt->columns->at(15)->column_constraints->count(ConstraintType::NotNull));
|
||||
// c_time TIME
|
||||
ASSERT_STREQ(stmt->columns->at(16)->name, "c_time");
|
||||
ASSERT_EQ(stmt->columns->at(16)->type, (ColumnType{DataType::TIME}));
|
||||
ASSERT_EQ(stmt->columns->at(16)->nullable, true);
|
||||
// c_time_precision TIME(17)
|
||||
ASSERT_STREQ(stmt->columns->at(17)->name, "c_time_precision");
|
||||
ASSERT_EQ(stmt->columns->at(17)->type, (ColumnType{DataType::TIME, 0, 17}));
|
||||
ASSERT_NEQ(stmt->columns->at(17)->type, (ColumnType{DataType::TIME, 0, 18}));
|
||||
ASSERT_NEQ(stmt->columns->at(17)->type, (ColumnType{DataType::TIME, 1, 17}));
|
||||
ASSERT_EQ(stmt->columns->at(17)->nullable, true);
|
||||
// c_timestamp TIMESTAMP
|
||||
ASSERT_STREQ(stmt->columns->at(18)->name, "c_timestamp");
|
||||
ASSERT_EQ(stmt->columns->at(18)->type, (ColumnType{DataType::DATETIME}));
|
||||
ASSERT_EQ(stmt->columns->at(18)->nullable, true);
|
||||
// c_varchar VARCHAR(50)
|
||||
ASSERT_STREQ(stmt->columns->at(19)->name, "c_varchar");
|
||||
ASSERT_EQ(stmt->columns->at(19)->type, (ColumnType{DataType::VARCHAR, 50}));
|
||||
ASSERT_NEQ(stmt->columns->at(19)->type, (ColumnType{DataType::VARCHAR, 51}));
|
||||
ASSERT_EQ(stmt->columns->at(19)->nullable, true);
|
||||
// c_char_varying CHARACTER VARYING(60)
|
||||
ASSERT_STREQ(stmt->columns->at(20)->name, "c_char_varying");
|
||||
ASSERT_EQ(stmt->columns->at(20)->type, (ColumnType{DataType::VARCHAR, 60}));
|
||||
ASSERT_NEQ(stmt->columns->at(20)->type, (ColumnType{DataType::VARCHAR, 61}));
|
||||
// Table constraints are identified and separated during the parsing of the SQL string
|
||||
// Table constraints:
|
||||
// - PRIMARY KEY(c_char, c_int)
|
||||
ASSERT_EQ(stmt->tableConstraints->size(), 1);
|
||||
ASSERT(stmt->tableConstraints->at(0)->type == ConstraintType::PrimaryKey);
|
||||
ASSERT_STREQ(stmt->tableConstraints->at(0)->columnNames->at(0), "c_char");
|
||||
ASSERT_STREQ(stmt->tableConstraints->at(0)->columnNames->at(1), "c_int");
|
||||
}
|
||||
|
||||
TEST(CreateAsSelectStatementTest) {
|
||||
SQLParserResult result;
|
||||
SQLParser::parse("CREATE TABLE students_2 AS SELECT student_number, grade FROM students", &result);
|
||||
|
||||
ASSERT(result.isValid());
|
||||
ASSERT_EQ(result.size(), 1);
|
||||
ASSERT_EQ(result.getStatement(0)->type(), kStmtCreate);
|
||||
|
||||
const CreateStatement* stmt = (const CreateStatement*)result.getStatement(0);
|
||||
ASSERT_EQ(stmt->type, kCreateTable);
|
||||
ASSERT_STREQ(stmt->tableName, "students_2");
|
||||
ASSERT_NULL(stmt->columns);
|
||||
ASSERT_NOTNULL(stmt->select);
|
||||
ASSERT(stmt->select->selectList->at(0)->isType(kExprColumnRef));
|
||||
ASSERT_STREQ(stmt->select->selectList->at(0)->getName(), "student_number");
|
||||
ASSERT(stmt->select->selectList->at(1)->isType(kExprColumnRef));
|
||||
ASSERT_STREQ(stmt->select->selectList->at(1)->getName(), "grade");
|
||||
}
|
||||
|
||||
TEST(UpdateStatementTest) {
|
||||
SQLParserResult result;
|
||||
SQLParser::parse("UPDATE students SET grade = 5.0, name = 'test' WHERE name = 'Max O''Mustermann';", &result);
|
||||
|
||||
ASSERT(result.isValid());
|
||||
ASSERT_EQ(result.size(), 1);
|
||||
ASSERT_EQ(result.getStatement(0)->type(), kStmtUpdate);
|
||||
|
||||
const UpdateStatement* stmt = (const UpdateStatement*)result.getStatement(0);
|
||||
ASSERT_NOTNULL(stmt->table);
|
||||
ASSERT_STREQ(stmt->table->name, "students");
|
||||
|
||||
ASSERT_NOTNULL(stmt->updates);
|
||||
ASSERT_EQ(stmt->updates->size(), 2);
|
||||
ASSERT_STREQ(stmt->updates->at(0)->column, "grade");
|
||||
ASSERT_STREQ(stmt->updates->at(1)->column, "name");
|
||||
ASSERT(stmt->updates->at(0)->value->isType(kExprLiteralFloat));
|
||||
ASSERT(stmt->updates->at(1)->value->isType(kExprLiteralString));
|
||||
ASSERT_EQ(stmt->updates->at(0)->value->fval, 5.0);
|
||||
ASSERT_STREQ(stmt->updates->at(1)->value->name, "test");
|
||||
|
||||
ASSERT_NOTNULL(stmt->where);
|
||||
ASSERT(stmt->where->isType(kExprOperator));
|
||||
ASSERT_EQ(stmt->where->opType, kOpEquals);
|
||||
ASSERT_STREQ(stmt->where->expr->name, "name");
|
||||
ASSERT_STREQ(stmt->where->expr2->name, "Max O'Mustermann");
|
||||
}
|
||||
|
||||
TEST(InsertStatementTest) {
|
||||
TEST_PARSE_SINGLE_SQL("INSERT INTO students VALUES ('Max Mustermann', 12345, 'Musterhausen', 2.0)", kStmtInsert,
|
||||
InsertStatement, result, stmt);
|
||||
|
||||
ASSERT_EQ(stmt->values->size(), 4);
|
||||
// TODO
|
||||
}
|
||||
|
||||
TEST(AlterStatementDropActionTest) {
|
||||
SQLParserResult result;
|
||||
SQLParser::parse("ALTER TABLE mytable DROP COLUMN IF EXISTS mycolumn", &result);
|
||||
|
||||
ASSERT(result.isValid());
|
||||
ASSERT_EQ(result.size(), 1);
|
||||
|
||||
const AlterStatement* stmt = (const AlterStatement*)result.getStatement(0);
|
||||
ASSERT_STREQ(stmt->name, "mytable");
|
||||
ASSERT_EQ(stmt->ifTableExists, false);
|
||||
|
||||
auto dropAction = (const DropColumnAction*)stmt->action;
|
||||
|
||||
ASSERT_EQ(dropAction->type, hsql::ActionType::DropColumn);
|
||||
ASSERT_STREQ(dropAction->columnName, "mycolumn");
|
||||
}
|
||||
|
||||
TEST(CreateIndexStatementTest) {
|
||||
SQLParserResult result;
|
||||
SQLParser::parse("CREATE INDEX myindex ON myTable (col1);", &result);
|
||||
|
||||
ASSERT(result.isValid());
|
||||
ASSERT_EQ(result.size(), 1);
|
||||
|
||||
const CreateStatement* stmt = (const CreateStatement*)result.getStatement(0);
|
||||
ASSERT_STREQ(stmt->indexName, "myindex");
|
||||
ASSERT_STREQ(stmt->tableName, "myTable");
|
||||
ASSERT_EQ(stmt->type, kCreateIndex);
|
||||
ASSERT_EQ(stmt->ifNotExists, false);
|
||||
ASSERT_EQ(stmt->indexColumns->size(), 1);
|
||||
}
|
||||
|
||||
TEST(CreateIndexStatementIfNotExistsTest) {
|
||||
SQLParserResult result;
|
||||
SQLParser::parse("CREATE INDEX IF NOT EXISTS myindex ON myTable (col1, col2);", &result);
|
||||
|
||||
ASSERT(result.isValid());
|
||||
ASSERT_EQ(result.size(), 1);
|
||||
|
||||
const CreateStatement* stmt = (const CreateStatement*)result.getStatement(0);
|
||||
ASSERT_STREQ(stmt->indexName, "myindex");
|
||||
ASSERT_STREQ(stmt->tableName, "myTable");
|
||||
ASSERT_EQ(stmt->type, kCreateIndex);
|
||||
ASSERT_EQ(stmt->ifNotExists, true);
|
||||
ASSERT_EQ(stmt->indexColumns->size(), 2);
|
||||
}
|
||||
|
||||
TEST(DropIndexTest) {
|
||||
SQLParserResult result;
|
||||
SQLParser::parse("DROP INDEX myindex", &result);
|
||||
|
||||
ASSERT(result.isValid());
|
||||
ASSERT_EQ(result.size(), 1);
|
||||
|
||||
const DropStatement* stmt = (const DropStatement*)result.getStatement(0);
|
||||
ASSERT_STREQ(stmt->indexName, "myindex");
|
||||
ASSERT_EQ(stmt->ifExists, false);
|
||||
}
|
||||
|
||||
TEST(DropIndexIfExistsTest) {
|
||||
SQLParserResult result;
|
||||
SQLParser::parse("DROP INDEX IF EXISTS myindex", &result);
|
||||
|
||||
ASSERT(result.isValid());
|
||||
ASSERT_EQ(result.size(), 1);
|
||||
|
||||
const DropStatement* stmt = (const DropStatement*)result.getStatement(0);
|
||||
ASSERT_STREQ(stmt->indexName, "myindex");
|
||||
ASSERT_EQ(stmt->ifExists, true);
|
||||
}
|
||||
|
||||
TEST(DropTableStatementTest) {
|
||||
TEST_PARSE_SINGLE_SQL("DROP TABLE students", kStmtDrop, DropStatement, result, stmt);
|
||||
|
||||
ASSERT_FALSE(stmt->ifExists);
|
||||
ASSERT_EQ(stmt->type, kDropTable);
|
||||
ASSERT_NOTNULL(stmt->name);
|
||||
ASSERT_STREQ(stmt->name, "students");
|
||||
}
|
||||
|
||||
TEST(DropTableIfExistsStatementTest) {
|
||||
TEST_PARSE_SINGLE_SQL("DROP TABLE IF EXISTS students", kStmtDrop, DropStatement, result, stmt);
|
||||
|
||||
ASSERT_TRUE(stmt->ifExists);
|
||||
ASSERT_EQ(stmt->type, kDropTable);
|
||||
ASSERT_NOTNULL(stmt->name);
|
||||
ASSERT_STREQ(stmt->name, "students");
|
||||
}
|
||||
|
||||
TEST(ReleaseStatementTest) {
|
||||
TEST_PARSE_SINGLE_SQL("SELECT * FROM students;", kStmtSelect, SelectStatement, result, stmt);
|
||||
|
||||
ASSERT_EQ(1, result.size());
|
||||
ASSERT_NULL(stmt->whereClause);
|
||||
|
||||
std::vector<SQLStatement*> statements = result.releaseStatements();
|
||||
|
||||
ASSERT_EQ(0, result.size());
|
||||
|
||||
for (SQLStatement* stmt : statements) {
|
||||
delete stmt;
|
||||
}
|
||||
}
|
||||
|
||||
TEST(ShowTableStatementTest) {
|
||||
TEST_PARSE_SINGLE_SQL("SHOW TABLES;", kStmtShow, ShowStatement, result, stmt);
|
||||
|
||||
ASSERT_EQ(stmt->type, kShowTables);
|
||||
ASSERT_NULL(stmt->name);
|
||||
}
|
||||
|
||||
TEST(ShowColumnsStatementTest) {
|
||||
TEST_PARSE_SINGLE_SQL("SHOW COLUMNS students;", kStmtShow, ShowStatement, result, stmt);
|
||||
|
||||
ASSERT_EQ(stmt->type, kShowColumns);
|
||||
ASSERT_NOTNULL(stmt->name);
|
||||
ASSERT_STREQ(stmt->name, "students");
|
||||
}
|
||||
|
||||
TEST(DescribeStatementTest) {
|
||||
TEST_PARSE_SINGLE_SQL("DESCRIBE students;", kStmtShow, ShowStatement, result, stmt);
|
||||
|
||||
ASSERT_EQ(stmt->type, kShowColumns);
|
||||
ASSERT_NOTNULL(stmt->name);
|
||||
ASSERT_STREQ(stmt->name, "students");
|
||||
}
|
||||
|
||||
TEST(ImportStatementTest) {
|
||||
TEST_PARSE_SINGLE_SQL("IMPORT FROM TBL FILE 'students_file' INTO students;", kStmtImport, ImportStatement, result,
|
||||
stmt);
|
||||
|
||||
ASSERT_EQ(stmt->type, kImportTbl);
|
||||
ASSERT_NOTNULL(stmt->tableName);
|
||||
ASSERT_STREQ(stmt->tableName, "students");
|
||||
ASSERT_STREQ(stmt->filePath, "students_file");
|
||||
}
|
||||
|
||||
TEST(CopyStatementTest) {
|
||||
TEST_PARSE_SINGLE_SQL("COPY students FROM 'students_file' WITH FORMAT BINARY;", kStmtImport, ImportStatement,
|
||||
import_result, import_stmt);
|
||||
|
||||
ASSERT_EQ(import_stmt->type, kImportBinary);
|
||||
ASSERT_NOTNULL(import_stmt->tableName);
|
||||
ASSERT_STREQ(import_stmt->tableName, "students");
|
||||
ASSERT_NOTNULL(import_stmt->filePath);
|
||||
ASSERT_STREQ(import_stmt->filePath, "students_file");
|
||||
ASSERT_NULL(import_stmt->whereClause);
|
||||
|
||||
TEST_PARSE_SINGLE_SQL("COPY students FROM 'students_file' WHERE lastname = 'Potter';", kStmtImport, ImportStatement,
|
||||
import_filter_result, import_filter_stmt);
|
||||
|
||||
ASSERT_EQ(import_filter_stmt->type, kImportAuto);
|
||||
ASSERT_NOTNULL(import_filter_stmt->tableName);
|
||||
ASSERT_STREQ(import_filter_stmt->tableName, "students");
|
||||
ASSERT_NOTNULL(import_filter_stmt->filePath);
|
||||
ASSERT_STREQ(import_filter_stmt->filePath, "students_file");
|
||||
ASSERT_NOTNULL(import_filter_stmt->whereClause);
|
||||
ASSERT_EQ(import_filter_stmt->whereClause->opType, kOpEquals);
|
||||
ASSERT_EQ(import_filter_stmt->whereClause->expr->type, kExprColumnRef);
|
||||
ASSERT_STREQ(import_filter_stmt->whereClause->expr->name, "lastname");
|
||||
ASSERT_EQ(import_filter_stmt->whereClause->expr2->type, kExprLiteralString);
|
||||
ASSERT_STREQ(import_filter_stmt->whereClause->expr2->name, "Potter");
|
||||
|
||||
TEST_PARSE_SINGLE_SQL("COPY students TO 'students_file' WITH FORMAT CSV;", kStmtExport, ExportStatement,
|
||||
export_table_result, export_table_stmt);
|
||||
|
||||
ASSERT_EQ(export_table_stmt->type, kImportCSV);
|
||||
ASSERT_NOTNULL(export_table_stmt->tableName);
|
||||
ASSERT_STREQ(export_table_stmt->tableName, "students");
|
||||
ASSERT_NOTNULL(export_table_stmt->filePath);
|
||||
ASSERT_STREQ(export_table_stmt->filePath, "students_file");
|
||||
ASSERT_NULL(export_table_stmt->select);
|
||||
|
||||
TEST_PARSE_SINGLE_SQL("COPY (SELECT firstname, lastname FROM students) TO 'students_file';", kStmtExport,
|
||||
ExportStatement, export_select_result, export_select_stmt);
|
||||
|
||||
ASSERT_EQ(export_select_stmt->type, kImportAuto);
|
||||
ASSERT_NULL(export_select_stmt->tableName);
|
||||
ASSERT_NOTNULL(export_select_stmt->filePath);
|
||||
ASSERT_STREQ(export_select_stmt->filePath, "students_file");
|
||||
|
||||
ASSERT_NOTNULL(export_select_stmt->select);
|
||||
const auto& select_stmt = export_select_stmt->select;
|
||||
ASSERT_NULL(select_stmt->whereClause);
|
||||
ASSERT_NULL(select_stmt->groupBy);
|
||||
ASSERT_EQ(select_stmt->selectList->size(), 2);
|
||||
ASSERT(select_stmt->selectList->at(0)->isType(kExprColumnRef));
|
||||
ASSERT_STREQ(select_stmt->selectList->at(0)->getName(), "firstname");
|
||||
ASSERT(select_stmt->selectList->at(1)->isType(kExprColumnRef));
|
||||
ASSERT_STREQ(select_stmt->selectList->at(1)->getName(), "lastname");
|
||||
ASSERT_NOTNULL(select_stmt->fromTable);
|
||||
ASSERT_STREQ(select_stmt->fromTable->name, "students");
|
||||
}
|
||||
|
||||
SQLParserResult parse_and_move(std::string query) {
|
||||
hsql::SQLParserResult result;
|
||||
hsql::SQLParser::parse(query, &result);
|
||||
// Moves on return.
|
||||
return result;
|
||||
}
|
||||
|
||||
SQLParserResult move_in_and_back(SQLParserResult res) {
|
||||
// Moves on return.
|
||||
return res;
|
||||
}
|
||||
|
||||
TEST(MoveSQLResultTest) {
|
||||
SQLParserResult res = parse_and_move("SELECT * FROM test;");
|
||||
ASSERT(res.isValid());
|
||||
ASSERT_EQ(1, res.size());
|
||||
|
||||
// Moved around.
|
||||
SQLParserResult new_res = move_in_and_back(std::move(res));
|
||||
|
||||
// Original object should be invalid.
|
||||
ASSERT_FALSE(res.isValid());
|
||||
ASSERT_EQ(0, res.size());
|
||||
|
||||
ASSERT(new_res.isValid());
|
||||
ASSERT_EQ(1, new_res.size());
|
||||
}
|
||||
|
||||
TEST(HintTest) {
|
||||
TEST_PARSE_SINGLE_SQL("SELECT * FROM students WITH HINT(NO_CACHE, SAMPLE_RATE(10));", kStmtSelect, SelectStatement,
|
||||
result, stmt);
|
||||
|
||||
ASSERT_NOTNULL(stmt->hints);
|
||||
ASSERT_EQ(2, stmt->hints->size());
|
||||
ASSERT_STREQ("NO_CACHE", stmt->hints->at(0)->name);
|
||||
ASSERT_STREQ("SAMPLE_RATE", stmt->hints->at(1)->name);
|
||||
ASSERT_EQ(1, stmt->hints->at(1)->exprList->size());
|
||||
ASSERT_EQ(10, stmt->hints->at(1)->exprList->at(0)->ival);
|
||||
}
|
||||
|
||||
TEST(StringLengthTest) {
|
||||
TEST_PARSE_SQL_QUERY("SELECT * FROM bar; INSERT INTO foo VALUES (4);\t\n SELECT * FROM foo;", result, 3);
|
||||
|
||||
ASSERT_EQ(result.getStatement(0)->stringLength, 18);
|
||||
ASSERT_EQ(result.getStatement(1)->stringLength, 28);
|
||||
ASSERT_EQ(result.getStatement(2)->stringLength, 21);
|
||||
}
|
||||
|
||||
TEST(ExceptOperatorTest) {
|
||||
TEST_PARSE_SINGLE_SQL("SELECT * FROM students EXCEPT SELECT * FROM students_2;", kStmtSelect, SelectStatement, result,
|
||||
stmt);
|
||||
|
||||
ASSERT_STREQ(stmt->setOperations->back()->nestedSelectStatement->fromTable->name, "students_2");
|
||||
ASSERT_STREQ(stmt->fromTable->name, "students");
|
||||
ASSERT_EQ(stmt->setOperations->back()->setType, kSetExcept);
|
||||
}
|
||||
|
||||
TEST(IntersectOperatorTest) {
|
||||
TEST_PARSE_SINGLE_SQL("SELECT * FROM students INTERSECT SELECT * FROM students_2;", kStmtSelect, SelectStatement,
|
||||
result, stmt);
|
||||
|
||||
ASSERT_STREQ(stmt->setOperations->back()->nestedSelectStatement->fromTable->name, "students_2");
|
||||
ASSERT_STREQ(stmt->fromTable->name, "students");
|
||||
ASSERT_EQ(stmt->setOperations->back()->setType, kSetIntersect);
|
||||
}
|
||||
|
||||
TEST(UnionOperatorTest) {
|
||||
TEST_PARSE_SINGLE_SQL("SELECT * FROM students UNION SELECT * FROM students_2;", kStmtSelect, SelectStatement, result,
|
||||
stmt);
|
||||
|
||||
ASSERT_STREQ(stmt->setOperations->back()->nestedSelectStatement->fromTable->name, "students_2");
|
||||
ASSERT_STREQ(stmt->fromTable->name, "students");
|
||||
ASSERT_EQ(stmt->setOperations->back()->setType, kSetUnion);
|
||||
ASSERT_FALSE(stmt->setOperations->back()->isAll);
|
||||
}
|
||||
|
||||
TEST(UnionAllOperatorTest) {
|
||||
TEST_PARSE_SINGLE_SQL("SELECT * FROM students UNION ALL SELECT * FROM students_2;", kStmtSelect, SelectStatement,
|
||||
result, stmt);
|
||||
|
||||
ASSERT_STREQ(stmt->setOperations->back()->nestedSelectStatement->fromTable->name, "students_2");
|
||||
ASSERT_STREQ(stmt->fromTable->name, "students");
|
||||
ASSERT_TRUE(stmt->setOperations->back()->isAll);
|
||||
}
|
||||
|
||||
TEST(NestedSetOperationTest) {
|
||||
TEST_PARSE_SINGLE_SQL("SELECT * FROM students INTERSECT SELECT grade FROM students_2 UNION SELECT * FROM employees;",
|
||||
kStmtSelect, SelectStatement, result, stmt);
|
||||
|
||||
ASSERT_STREQ(
|
||||
stmt->setOperations->back()->nestedSelectStatement->setOperations->back()->nestedSelectStatement->fromTable->name,
|
||||
"employees");
|
||||
ASSERT_STREQ(stmt->setOperations->back()->nestedSelectStatement->fromTable->name, "students_2");
|
||||
ASSERT_STREQ(stmt->fromTable->name, "students");
|
||||
ASSERT_EQ(stmt->setOperations->back()->setType, kSetIntersect);
|
||||
ASSERT_EQ(stmt->setOperations->back()->nestedSelectStatement->setOperations->back()->setType, kSetUnion);
|
||||
ASSERT_FALSE(stmt->setOperations->back()->isAll);
|
||||
}
|
||||
|
||||
TEST(OrderByFullStatementTest) {
|
||||
TEST_PARSE_SINGLE_SQL(
|
||||
"SELECT * FROM students INTERSECT SELECT grade FROM students_2 UNION SELECT * FROM employees ORDER BY grade ASC;",
|
||||
kStmtSelect, SelectStatement, result, stmt);
|
||||
|
||||
ASSERT_EQ(stmt->setOperations->back()->resultOrder->at(0)->type, kOrderAsc);
|
||||
ASSERT_STREQ(stmt->setOperations->back()->resultOrder->at(0)->expr->name, "grade");
|
||||
ASSERT_FALSE(stmt->setOperations->back()->isAll);
|
||||
}
|
||||
|
||||
TEST(SetOperationSubQueryOrder) {
|
||||
TEST_PARSE_SINGLE_SQL(
|
||||
"(SELECT * FROM students ORDER BY name DESC) INTERSECT SELECT grade FROM students_2 UNION SELECT * FROM "
|
||||
"employees ORDER BY grade ASC;",
|
||||
kStmtSelect, SelectStatement, result, stmt);
|
||||
|
||||
ASSERT_EQ(stmt->order->at(0)->type, kOrderDesc);
|
||||
ASSERT_STREQ(stmt->order->at(0)->expr->name, "name");
|
||||
|
||||
ASSERT_EQ(stmt->setOperations->back()->resultOrder->at(0)->type, kOrderAsc);
|
||||
ASSERT_STREQ(stmt->setOperations->back()->resultOrder->at(0)->expr->name, "grade");
|
||||
ASSERT_FALSE(stmt->setOperations->back()->isAll);
|
||||
}
|
||||
|
||||
TEST(SetOperationLastSubQueryOrder) {
|
||||
TEST_PARSE_SINGLE_SQL(
|
||||
"SELECT * FROM students INTERSECT SELECT grade FROM students_2 UNION (SELECT * FROM employees ORDER BY name "
|
||||
"DESC) ORDER BY grade ASC;",
|
||||
kStmtSelect, SelectStatement, result, stmt);
|
||||
|
||||
ASSERT_EQ(stmt->setOperations->back()
|
||||
->nestedSelectStatement->setOperations->back()
|
||||
->nestedSelectStatement->order->at(0)
|
||||
->type,
|
||||
kOrderDesc);
|
||||
ASSERT_STREQ(stmt->setOperations->back()
|
||||
->nestedSelectStatement->setOperations->back()
|
||||
->nestedSelectStatement->order->at(0)
|
||||
->expr->name,
|
||||
"name");
|
||||
|
||||
ASSERT_EQ(stmt->setOperations->back()->resultOrder->at(0)->type, kOrderAsc);
|
||||
ASSERT_STREQ(stmt->setOperations->back()->resultOrder->at(0)->expr->name, "grade");
|
||||
ASSERT_FALSE(stmt->setOperations->back()->isAll);
|
||||
}
|
||||
|
||||
TEST(NestedDifferentSetOperationsWithWithClause) {
|
||||
TEST_PARSE_SINGLE_SQL(
|
||||
"WITH UNION_FIRST AS (SELECT * FROM A UNION SELECT * FROM B) SELECT * FROM UNION_FIRST EXCEPT SELECT * FROM C",
|
||||
kStmtSelect, SelectStatement, result, stmt);
|
||||
|
||||
ASSERT_STREQ(stmt->withDescriptions->back()->alias, "UNION_FIRST");
|
||||
ASSERT_EQ(stmt->withDescriptions->back()->select->setOperations->back()->setType, kSetUnion);
|
||||
ASSERT_STREQ(stmt->withDescriptions->back()->select->fromTable->name, "A");
|
||||
ASSERT_STREQ(stmt->withDescriptions->back()->select->setOperations->back()->nestedSelectStatement->fromTable->name,
|
||||
"B");
|
||||
|
||||
ASSERT_EQ(stmt->setOperations->back()->setType, kSetExcept);
|
||||
ASSERT_STREQ(stmt->fromTable->name, "UNION_FIRST");
|
||||
ASSERT_STREQ(stmt->setOperations->back()->nestedSelectStatement->fromTable->name, "C");
|
||||
}
|
||||
|
||||
TEST(NestedAllSetOperationsWithWithClause) {
|
||||
TEST_PARSE_SINGLE_SQL(
|
||||
"WITH UNION_FIRST AS (SELECT * FROM A UNION SELECT * FROM B) SELECT * FROM UNION_FIRST EXCEPT SELECT * FROM "
|
||||
"(SELECT * FROM C INTERSECT SELECT * FROM D)",
|
||||
kStmtSelect, SelectStatement, result, stmt);
|
||||
|
||||
ASSERT_STREQ(stmt->withDescriptions->back()->alias, "UNION_FIRST");
|
||||
ASSERT_EQ(stmt->withDescriptions->back()->select->setOperations->back()->setType, kSetUnion);
|
||||
ASSERT_STREQ(stmt->withDescriptions->back()->select->fromTable->name, "A");
|
||||
ASSERT_STREQ(stmt->withDescriptions->back()->select->setOperations->back()->nestedSelectStatement->fromTable->name,
|
||||
"B");
|
||||
|
||||
ASSERT_EQ(stmt->setOperations->back()->setType, kSetExcept);
|
||||
ASSERT_STREQ(stmt->fromTable->name, "UNION_FIRST");
|
||||
ASSERT_EQ(stmt->setOperations->back()->nestedSelectStatement->fromTable->select->setOperations->back()->setType,
|
||||
kSetIntersect);
|
||||
ASSERT_STREQ(stmt->setOperations->back()->nestedSelectStatement->fromTable->select->fromTable->name, "C");
|
||||
ASSERT_STREQ(stmt->setOperations->back()
|
||||
->nestedSelectStatement->fromTable->select->setOperations->back()
|
||||
->nestedSelectStatement->fromTable->name,
|
||||
"D");
|
||||
}
|
||||
|
||||
TEST(NestedSetOperationsWithMultipleWithClauses) {
|
||||
TEST_PARSE_SINGLE_SQL(
|
||||
"WITH UNION_FIRST AS (SELECT * FROM A UNION SELECT * FROM B),INTERSECT_SECOND AS (SELECT * FROM UNION_FIRST "
|
||||
"INTERSECT SELECT * FROM C) SELECT * FROM UNION_FIRST EXCEPT SELECT * FROM INTERSECT_SECOND",
|
||||
kStmtSelect, SelectStatement, result, stmt);
|
||||
|
||||
ASSERT_STREQ(stmt->withDescriptions->at(0)->alias, "UNION_FIRST");
|
||||
ASSERT_STREQ(stmt->withDescriptions->back()->alias, "INTERSECT_SECOND");
|
||||
|
||||
ASSERT_EQ(stmt->withDescriptions->at(0)->select->setOperations->back()->setType, kSetUnion);
|
||||
ASSERT_STREQ(stmt->withDescriptions->at(0)->select->fromTable->name, "A");
|
||||
ASSERT_STREQ(stmt->withDescriptions->at(0)->select->setOperations->back()->nestedSelectStatement->fromTable->name,
|
||||
"B");
|
||||
|
||||
ASSERT_EQ(stmt->withDescriptions->back()->select->setOperations->back()->setType, kSetIntersect);
|
||||
ASSERT_STREQ(stmt->withDescriptions->back()->select->fromTable->name, "UNION_FIRST");
|
||||
ASSERT_STREQ(stmt->withDescriptions->back()->select->setOperations->back()->nestedSelectStatement->fromTable->name,
|
||||
"C");
|
||||
|
||||
ASSERT_EQ(stmt->setOperations->back()->setType, kSetExcept);
|
||||
ASSERT_STREQ(stmt->fromTable->name, "UNION_FIRST");
|
||||
ASSERT_STREQ(stmt->setOperations->back()->nestedSelectStatement->fromTable->name, "INTERSECT_SECOND");
|
||||
}
|
||||
|
||||
TEST(WrongOrderByStatementTest) {
|
||||
SQLParserResult res = parse_and_move("SELECT * FROM students ORDER BY name INTERSECT SELECT grade FROM students_2;");
|
||||
ASSERT_FALSE(res.isValid());
|
||||
}
|
||||
|
||||
TEST(BeginTransactionTest) {
|
||||
{
|
||||
TEST_PARSE_SINGLE_SQL("BEGIN TRANSACTION;", kStmtTransaction, TransactionStatement, transaction_result,
|
||||
transaction_stmt);
|
||||
|
||||
ASSERT_EQ(transaction_stmt->command, kBeginTransaction);
|
||||
}
|
||||
|
||||
{
|
||||
TEST_PARSE_SINGLE_SQL("BEGIN;", kStmtTransaction, TransactionStatement, transaction_result, transaction_stmt);
|
||||
|
||||
ASSERT_EQ(transaction_stmt->command, kBeginTransaction);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(RollbackTransactionTest) {
|
||||
TEST_PARSE_SINGLE_SQL("ROLLBACK TRANSACTION;", kStmtTransaction, TransactionStatement, transaction_result,
|
||||
transaction_stmt);
|
||||
|
||||
ASSERT_EQ(transaction_stmt->command, kRollbackTransaction);
|
||||
}
|
||||
|
||||
TEST(CommitTransactionTest) {
|
||||
TEST_PARSE_SINGLE_SQL("COMMIT TRANSACTION;", kStmtTransaction, TransactionStatement, transaction_result,
|
||||
transaction_stmt);
|
||||
|
||||
ASSERT_EQ(transaction_stmt->command, kCommitTransaction);
|
||||
}
|
||||
|
||||
TEST(CastAsType) {
|
||||
TEST_PARSE_SINGLE_SQL("SELECT CAST(ID AS VARCHAR(8)) FROM TEST", kStmtSelect, SelectStatement, result, stmt);
|
||||
|
||||
ASSERT_TRUE(result.isValid());
|
||||
ASSERT_EQ(stmt->selectList->size(), 1);
|
||||
ASSERT_EQ(stmt->selectList->front()->columnType.data_type, DataType::VARCHAR);
|
||||
ASSERT_EQ(stmt->selectList->front()->columnType.length, 8);
|
||||
}
|
||||
|
||||
TEST_MAIN();
|
||||
+95
@@ -0,0 +1,95 @@
|
||||
#!/bin/bash
|
||||
# Has to be executed from the root of the repository.
|
||||
# Usually invoked by `make test`.
|
||||
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:./
|
||||
|
||||
# Colors
|
||||
RED='\033[1;31m'
|
||||
GREEN='\033[1;32m'
|
||||
YELLOW='\033[1;33m'
|
||||
NC='\033[0m'
|
||||
BOLD='\033[1;39m'
|
||||
|
||||
RET=0
|
||||
SQL_TEST_RET=0
|
||||
MEM_LEAK_EXECUTED=$?
|
||||
MEM_LEAK_RET=0
|
||||
CONFLICT_RET=0
|
||||
|
||||
#################################################
|
||||
# Running SQL parser tests.
|
||||
printf "\n${GREEN}Running SQL parser tests...${NC}\n"
|
||||
bin/tests -f "test/queries/queries-good.sql" -f "test/queries/queries-bad.sql"
|
||||
SQL_TEST_RET=$?
|
||||
|
||||
if [ $SQL_TEST_RET -eq 0 ]; then
|
||||
printf "${GREEN}SQL parser tests succeeded!${NC}\n"
|
||||
else
|
||||
RET=1
|
||||
printf "${RED}SQL parser tests failed!${NC}\n"
|
||||
fi
|
||||
|
||||
#################################################
|
||||
# Running memory leak checks (only on Linux).
|
||||
unamestr=$(uname)
|
||||
if [[ "$unamestr" == 'Linux' ]]; then
|
||||
printf "\n${GREEN}Running memory leak checks...${NC}\n"
|
||||
valgrind --leak-check=full --error-exitcode=200 --log-fd=3 \
|
||||
bin/tests -f "test/queries/queries-good.sql" -f "test/queries/queries-bad.sql" \
|
||||
3>&1>/dev/null;
|
||||
|
||||
MEM_LEAK_EXECUTED=true
|
||||
MEM_LEAK_RET=$?
|
||||
RET=1
|
||||
|
||||
if [ $MEM_LEAK_RET -eq 0 ]; then
|
||||
printf "${GREEN}Memory leak check succeeded!${NC}\n"
|
||||
MEM_LEAK_RET=0
|
||||
RET=0
|
||||
elif [ $MEM_LEAK_RET -eq 200 ]; then
|
||||
printf "${RED}Memory leak check failed!${NC}\n"
|
||||
elif [ $MEM_LEAK_RET -eq 127 ]; then
|
||||
printf "${RED}Memory leak check failed: command 'valgrind' not found!${NC}\n"
|
||||
else
|
||||
printf "${RED}Memory leak check failed: error code ${MEM_LEAK_RET}!${NC}\n"
|
||||
fi
|
||||
else
|
||||
printf "\n${YELLOW}Skipping memory leak checks (can only be executed on Linux)!${NC}\n"
|
||||
MEM_LEAK_EXECUTED=false
|
||||
fi
|
||||
|
||||
#################################################
|
||||
# Checking if the grammar is conflict free.
|
||||
printf "\n${GREEN}Checking for conflicts in the grammar...${NC}\n"
|
||||
printf "${RED}"
|
||||
make -C src/parser/ test >>/dev/null
|
||||
CONFLICT_RET=$?
|
||||
|
||||
if [ $CONFLICT_RET -eq 0 ]; then
|
||||
printf "${GREEN}Conflict check succeeded!${NC}\n"
|
||||
else
|
||||
RET=1
|
||||
printf "${RED}Conflict check failed!${NC}\n"
|
||||
fi
|
||||
|
||||
# Print a summary of the test results.
|
||||
printf "
|
||||
----------------------------------
|
||||
${BOLD}Summary:\n"
|
||||
if [ $SQL_TEST_RET -eq 0 ]; then printf "SQL Tests: ${GREEN}Success${BOLD}\n";
|
||||
else printf "SQL Tests: ${RED}Failure${BOLD}\n"; fi
|
||||
if [ "$MEM_LEAK_EXECUTED" = true ]; then
|
||||
if [ $MEM_LEAK_RET -eq 0 ]; then printf "Memory Leak Check: ${GREEN}Success${BOLD}\n";
|
||||
else printf "Memory Leak Check: ${RED}Failure${BOLD}\n"; fi
|
||||
else printf "Memory Leak Check: ${YELLOW}Skipped${BOLD}\n"
|
||||
fi
|
||||
if [ $CONFLICT_RET -eq 0 ]; then printf "Grammar Conflict Check: ${GREEN}Success${BOLD}\n";
|
||||
else printf "Grammar Conflict Check: ${RED}Failure${BOLD}\n"; fi
|
||||
|
||||
if [ $RET -ne 0 ]; then printf "${RED}Some tests failed!${NC}\n"
|
||||
elif [ "$MEM_LEAK_EXECUTED" = false ]; then printf "${YELLOW}Some tests were skipped!${NC}\n"
|
||||
else printf "${GREEN}All tests passed!${NC}\n"
|
||||
fi
|
||||
printf "${NC}----------------------------------\n"
|
||||
|
||||
exit $RET
|
||||
@@ -0,0 +1,199 @@
|
||||
//
|
||||
// microtest.h
|
||||
//
|
||||
// URL: https://github.com/torpedro/microtest.h
|
||||
// Author: Pedro Flemming (http://torpedro.com/)
|
||||
// License: MIT License (https://github.com/torpedro/microtest.h/blob/master/LICENSE)
|
||||
// Copyright (c) 2017 Pedro Flemming
|
||||
//
|
||||
// This is a small header-only C++ unit testing framework.
|
||||
// It allows to define small unit tests with set of assertions available.
|
||||
//
|
||||
#ifndef __MICROTEST_H__
|
||||
#define __MICROTEST_H__
|
||||
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
////////////////
|
||||
// Assertions //
|
||||
////////////////
|
||||
|
||||
#define ASSERT(cond) ASSERT_TRUE(cond);
|
||||
|
||||
#define ASSERT_TRUE(cond) \
|
||||
if (!(cond)) throw mt::AssertFailedException(#cond, __FILE__, __LINE__);
|
||||
|
||||
#define ASSERT_FALSE(cond) \
|
||||
if (cond) throw mt::AssertFailedException(#cond, __FILE__, __LINE__);
|
||||
|
||||
#define ASSERT_NULL(value) ASSERT_TRUE(value == NULL);
|
||||
|
||||
#define ASSERT_NOTNULL(value) ASSERT_TRUE(value != NULL);
|
||||
|
||||
#define ASSERT_STREQ(a, b) \
|
||||
if (std::string(a).compare(std::string(b)) != 0) { \
|
||||
printf("%s{ info} %s", mt::yellow(), mt::def()); \
|
||||
std::cout << "Actual values: " << a << " != " << b << std::endl; \
|
||||
throw mt::AssertFailedException(#a " == " #b, __FILE__, __LINE__); \
|
||||
}
|
||||
|
||||
#define ASSERT_STRNEQ(a, b) \
|
||||
if (std::string(a).compare(std::string(b)) != = 0) { \
|
||||
printf("%s{ info} %s", mt::yellow(), mt::def()); \
|
||||
std::cout << "Actual values: " << a << " == " << b << std::endl; \
|
||||
throw mt::AssertFailedException(#a " != " #b, __FILE__, __LINE__); \
|
||||
}
|
||||
|
||||
#define ASSERT_EQ(a, b) \
|
||||
if (a != b) { \
|
||||
printf("%s{ info} %s", mt::yellow(), mt::def()); \
|
||||
std::cout << "Actual values: " << a << " != " << b << std::endl; \
|
||||
} \
|
||||
ASSERT(a == b);
|
||||
|
||||
#define ASSERT_NEQ(a, b) \
|
||||
if (a == b) { \
|
||||
printf("%s{ info} %s", mt::yellow(), mt::def()); \
|
||||
std::cout << "Actual values: " << a << " == " << b << std::endl; \
|
||||
} \
|
||||
ASSERT(a != b);
|
||||
|
||||
////////////////
|
||||
// Unit Tests //
|
||||
////////////////
|
||||
|
||||
#define TEST(name) \
|
||||
void name(); \
|
||||
namespace { \
|
||||
bool __##name = mt::TestsManager::AddTest(name, #name); \
|
||||
} \
|
||||
void name()
|
||||
|
||||
///////////////
|
||||
// Framework //
|
||||
///////////////
|
||||
|
||||
namespace mt {
|
||||
|
||||
inline const char* red() { return "\033[1;31m"; }
|
||||
|
||||
inline const char* green() { return "\033[0;32m"; }
|
||||
|
||||
inline const char* yellow() { return "\033[0;33m"; }
|
||||
|
||||
inline const char* def() { return "\033[0m"; }
|
||||
|
||||
inline void printRunning(const char* message, FILE* file = stdout) {
|
||||
fprintf(file, "%s{ running}%s %s\n", green(), def(), message);
|
||||
}
|
||||
|
||||
inline void printOk(const char* message, FILE* file = stdout) {
|
||||
fprintf(file, "%s{ ok}%s %s\n", green(), def(), message);
|
||||
}
|
||||
|
||||
inline void printFailed(const char* message, FILE* file = stdout) {
|
||||
fprintf(file, "%s{ failed} %s%s\n", red(), message, def());
|
||||
}
|
||||
|
||||
// Exception that is thrown when an assertion fails.
|
||||
class AssertFailedException : public std::exception {
|
||||
public:
|
||||
AssertFailedException(std::string description, std::string filepath, int line)
|
||||
: std::exception(), description_(description), filepath_(filepath), line_(line){};
|
||||
|
||||
virtual const char* what() const throw() { return description_.c_str(); }
|
||||
|
||||
inline const char* getFilepath() { return filepath_.c_str(); }
|
||||
|
||||
inline int getLine() { return line_; }
|
||||
|
||||
protected:
|
||||
std::string description_;
|
||||
std::string filepath_;
|
||||
int line_;
|
||||
};
|
||||
|
||||
class TestsManager {
|
||||
// Note: static initialization fiasco
|
||||
// http://www.parashift.com/c++-faq-lite/static-init-order.html
|
||||
// http://www.parashift.com/c++-faq-lite/static-init-order-on-first-use.html
|
||||
public:
|
||||
struct Test {
|
||||
const char* name;
|
||||
void (*fn)(void);
|
||||
};
|
||||
|
||||
static std::vector<Test>& tests() {
|
||||
static std::vector<Test> tests_;
|
||||
return tests_;
|
||||
}
|
||||
|
||||
// Adds a new test to the current set of tests.
|
||||
// Returns false if a test with the same name already exists.
|
||||
inline static bool AddTest(void (*fn)(void), const char* name) {
|
||||
tests().push_back({name, fn});
|
||||
return true;
|
||||
}
|
||||
|
||||
// Run all tests that are registered.
|
||||
// Returns the number of tests that failed.
|
||||
inline static size_t RunAllTests(FILE* file = stdout) {
|
||||
size_t num_failed = 0;
|
||||
|
||||
for (const Test& test : tests()) {
|
||||
// Run the test.
|
||||
// If an AsserFailedException is thrown, the test has failed.
|
||||
try {
|
||||
printRunning(test.name, file);
|
||||
|
||||
(*test.fn)();
|
||||
|
||||
printOk(test.name, file);
|
||||
|
||||
} catch (AssertFailedException& e) {
|
||||
printFailed(test.name, file);
|
||||
fprintf(file, " %sAssertion failed: %s%s\n", red(), e.what(), def());
|
||||
fprintf(file, " %s%s:%d%s\n", red(), e.getFilepath(), e.getLine(), def());
|
||||
++num_failed;
|
||||
}
|
||||
}
|
||||
|
||||
int return_code = (num_failed > 0) ? 1 : 0;
|
||||
return return_code;
|
||||
}
|
||||
};
|
||||
|
||||
// Class that will capture the arguments passed to the program.
|
||||
class Runtime {
|
||||
public:
|
||||
static const std::vector<std::string>& args(int argc = -1, char** argv = NULL) {
|
||||
static std::vector<std::string> args_;
|
||||
if (argc >= 0) {
|
||||
for (int i = 0; i < argc; ++i) {
|
||||
args_.push_back(argv[i]);
|
||||
}
|
||||
}
|
||||
return args_;
|
||||
}
|
||||
};
|
||||
} // namespace mt
|
||||
|
||||
#define TEST_MAIN() \
|
||||
int main(int argc, char* argv[]) { \
|
||||
mt::Runtime::args(argc, argv); \
|
||||
\
|
||||
size_t num_failed = mt::TestsManager::RunAllTests(stdout); \
|
||||
if (num_failed == 0) { \
|
||||
fprintf(stdout, "%s{ summary} All tests succeeded!%s\n", mt::green(), mt::def()); \
|
||||
return 0; \
|
||||
} else { \
|
||||
double percentage = 100.0 * num_failed / mt::TestsManager::tests().size(); \
|
||||
fprintf(stderr, "%s{ summary} %lu tests failed (%.2f%%)%s\n", mt::red(), num_failed, percentage, mt::def()); \
|
||||
return -1; \
|
||||
} \
|
||||
}
|
||||
|
||||
#endif // __MICROTEST_H__
|
||||
+111
@@ -0,0 +1,111 @@
|
||||
#include "thirdparty/microtest/microtest.h"
|
||||
|
||||
#include "SQLParser.h"
|
||||
#include "util/sqlhelper.h"
|
||||
|
||||
#include "sql_asserts.h"
|
||||
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <streambuf>
|
||||
#include <string>
|
||||
|
||||
using namespace hsql;
|
||||
|
||||
std::string readFileContents(std::string file_path) {
|
||||
std::ifstream t(file_path.c_str());
|
||||
std::string text((std::istreambuf_iterator<char>(t)), std::istreambuf_iterator<char>());
|
||||
return text;
|
||||
}
|
||||
|
||||
TEST(TPCHQueryGrammarTests) {
|
||||
std::vector<std::string> files = {
|
||||
"test/queries/tpc-h-01.sql", "test/queries/tpc-h-02.sql", "test/queries/tpc-h-03.sql",
|
||||
"test/queries/tpc-h-04.sql", "test/queries/tpc-h-05.sql", "test/queries/tpc-h-06.sql",
|
||||
"test/queries/tpc-h-07.sql", "test/queries/tpc-h-08.sql", "test/queries/tpc-h-09.sql",
|
||||
"test/queries/tpc-h-10.sql", "test/queries/tpc-h-11.sql", "test/queries/tpc-h-12.sql",
|
||||
"test/queries/tpc-h-13.sql", "test/queries/tpc-h-14.sql", "test/queries/tpc-h-15.sql",
|
||||
"test/queries/tpc-h-16.sql", "test/queries/tpc-h-17.sql", "test/queries/tpc-h-18.sql",
|
||||
"test/queries/tpc-h-19.sql", "test/queries/tpc-h-20.sql", "test/queries/tpc-h-21.sql",
|
||||
"test/queries/tpc-h-22.sql",
|
||||
};
|
||||
|
||||
int testsFailed = 0;
|
||||
std::string concatenated = "";
|
||||
for (const std::string& file_path : files) {
|
||||
std::string query = readFileContents(file_path);
|
||||
|
||||
concatenated += query;
|
||||
if (concatenated.back() != ';') concatenated += ';';
|
||||
|
||||
SQLParserResult result;
|
||||
SQLParser::parse(query.c_str(), &result);
|
||||
if (!result.isValid()) {
|
||||
mt::printFailed(file_path.c_str());
|
||||
printf("%s %s (L%d:%d)%s\n", mt::red(), result.errorMsg(), result.errorLine(), result.errorColumn(),
|
||||
mt::def());
|
||||
++testsFailed;
|
||||
} else {
|
||||
mt::printOk(file_path.c_str());
|
||||
}
|
||||
}
|
||||
|
||||
SQLParserResult result;
|
||||
SQLParser::parse(concatenated.c_str(), &result);
|
||||
if (!result.isValid()) {
|
||||
mt::printFailed("TPCHAllConcatenated");
|
||||
printf("%s %s (L%d:%d)%s\n", mt::red(), result.errorMsg(), result.errorLine(), result.errorColumn(),
|
||||
mt::def());
|
||||
++testsFailed;
|
||||
} else {
|
||||
mt::printOk("TPCHAllConcatenated");
|
||||
}
|
||||
|
||||
ASSERT_EQ(testsFailed, 0);
|
||||
}
|
||||
|
||||
TEST(TPCHQueryDetailTest) {
|
||||
std::string query = readFileContents("test/queries/tpc-h-20.sql");
|
||||
|
||||
SQLParserResult result;
|
||||
SQLParser::parse(query.c_str(), &result);
|
||||
ASSERT(result.isValid());
|
||||
ASSERT_EQ(result.size(), 1);
|
||||
|
||||
const SQLStatement* stmt20 = result.getStatement(0);
|
||||
ASSERT_EQ(stmt20->type(), kStmtSelect);
|
||||
|
||||
const SelectStatement* select20 = (const SelectStatement*)stmt20;
|
||||
ASSERT_EQ(select20->selectList->size(), 2);
|
||||
ASSERT_STREQ(select20->selectList->at(0)->getName(), "S_NAME");
|
||||
ASSERT_STREQ(select20->selectList->at(1)->getName(), "S_ADDRESS");
|
||||
|
||||
// Test WHERE Clause.
|
||||
Expr* where = select20->whereClause;
|
||||
ASSERT_NOTNULL(where);
|
||||
ASSERT(where->isType(kExprOperator));
|
||||
ASSERT_EQ(where->opType, kOpAnd);
|
||||
|
||||
Expr* andExpr2 = where->expr;
|
||||
ASSERT_NOTNULL(andExpr2);
|
||||
ASSERT(andExpr2->isType(kExprOperator));
|
||||
ASSERT_EQ(andExpr2->opType, kOpAnd);
|
||||
|
||||
// Test IN expression.
|
||||
Expr* inExpr = andExpr2->expr;
|
||||
ASSERT_NOTNULL(inExpr);
|
||||
ASSERT(inExpr->isType(kExprOperator));
|
||||
ASSERT_EQ(inExpr->opType, kOpIn);
|
||||
|
||||
ASSERT_STREQ(inExpr->expr->getName(), "S_SUPPKEY");
|
||||
ASSERT_NOTNULL(inExpr->select);
|
||||
ASSERT_EQ(inExpr->select->selectList->size(), 1);
|
||||
ASSERT(inExpr->select->selectList->at(0)->isType(kExprColumnRef));
|
||||
ASSERT_STREQ(inExpr->select->selectList->at(0)->getName(), "PS_SUPPKEY");
|
||||
|
||||
// Test ORDER BY clause.
|
||||
ASSERT_NOTNULL(select20->order);
|
||||
ASSERT_EQ(select20->order->size(), 1);
|
||||
ASSERT(select20->order->at(0)->expr->isType(kExprColumnRef));
|
||||
ASSERT_STREQ(select20->order->at(0)->expr->getName(), "S_NAME");
|
||||
}
|
||||
Reference in new issue
Block a user