Skip to content

Commit 5f5eb18

Browse files
poyrazKpoyrazK
committed
tests: harden cloudSQL execution and visibility tests
1 parent 17447c9 commit 5f5eb18

1 file changed

Lines changed: 40 additions & 55 deletions

File tree

‎tests/cloudSQL_tests.cpp‎

Lines changed: 40 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -783,9 +783,7 @@ TEST(CatalogTests, Stats) {
783783
TEST(ParserAdvanced, JoinAndComplexSelect) {
784784
/* 1. Left Join and multiple joins */
785785
{
786-
auto lexer = std::make_unique<Lexer>(
787-
"SELECT a.id, b.val FROM t1 LEFT JOIN t2 ON a.id = b.id JOIN t3 ON b.x = t3.x WHERE "
788-
"a.id > 10");
786+
auto lexer = std::make_unique<Lexer>("SELECT a.id, b.val FROM t1 LEFT JOIN t2 ON a.id = b.id JOIN t3 ON b.x = t3.x WHERE a.id > 10");
789787
Parser parser(std::move(lexer));
790788
auto stmt = parser.parse_statement();
791789
ASSERT_NE(stmt, nullptr);
@@ -798,9 +796,7 @@ TEST(ParserAdvanced, JoinAndComplexSelect) {
798796

799797
/* 2. Group By and Having */
800798
{
801-
auto lexer = std::make_unique<Lexer>(
802-
"SELECT cat, SUM(val) FROM items GROUP BY cat HAVING SUM(val) > 1000 ORDER BY cat "
803-
"DESC");
799+
auto lexer = std::make_unique<Lexer>("SELECT cat, SUM(val) FROM items GROUP BY cat HAVING SUM(val) > 1000 ORDER BY cat DESC");
804800
Parser parser(std::move(lexer));
805801
auto stmt = parser.parse_statement();
806802
ASSERT_NE(stmt, nullptr);
@@ -818,13 +814,13 @@ TEST(ParserAdvanced, JoinAndComplexSelect) {
818814
auto s1 = parser.parse_statement();
819815
ASSERT_NE(s1, nullptr);
820816
EXPECT_EQ(s1->type(), StmtType::TransactionBegin);
821-
817+
822818
auto lexer2 = std::make_unique<Lexer>("COMMIT");
823819
Parser parser2(std::move(lexer2));
824820
auto s2 = parser2.parse_statement();
825821
ASSERT_NE(s2, nullptr);
826822
EXPECT_EQ(s2->type(), StmtType::TransactionCommit);
827-
823+
828824
auto lexer3 = std::make_unique<Lexer>("ROLLBACK");
829825
Parser parser3(std::move(lexer3));
830826
auto s3 = parser3.parse_statement();
@@ -836,19 +832,19 @@ TEST(ParserAdvanced, JoinAndComplexSelect) {
836832
TEST(ParserAdvanced, ParserErrorPaths) {
837833
/* Invalid CREATE syntax */
838834
{
839-
auto lexer = std::make_unique<Lexer>("CREATE TABLE (id INT)"); // Missing table name
835+
auto lexer = std::make_unique<Lexer>("CREATE TABLE (id INT)"); // Missing table name
840836
Parser parser(std::move(lexer));
841837
EXPECT_EQ(parser.parse_statement(), nullptr);
842838
}
843839
/* Invalid JOIN syntax */
844840
{
845-
auto lexer = std::make_unique<Lexer>("SELECT * FROM t1 LEFT t2"); // Missing JOIN keyword
841+
auto lexer = std::make_unique<Lexer>("SELECT * FROM t1 LEFT t2"); // Missing JOIN keyword
846842
Parser parser(std::move(lexer));
847843
EXPECT_EQ(parser.parse_statement(), nullptr);
848844
}
849845
/* Invalid GROUP BY syntax */
850846
{
851-
auto lexer = std::make_unique<Lexer>("SELECT * FROM t1 GROUP cat"); // Missing BY keyword
847+
auto lexer = std::make_unique<Lexer>("SELECT * FROM t1 GROUP cat"); // Missing BY keyword
852848
Parser parser(std::move(lexer));
853849
EXPECT_EQ(parser.parse_statement(), nullptr);
854850
}
@@ -859,50 +855,37 @@ TEST(ParserAdvanced, ParserErrorPaths) {
859855
TEST(ExecutionTests, AggregationHaving) {
860856
static_cast<void>(std::remove("./test_data/having_test.heap"));
861857
StorageManager disk_manager("./test_data");
862-
BufferPoolManager sm(128, disk_manager);
858+
BufferPoolManager sm(config::Config::DEFAULT_BUFFER_POOL_SIZE, disk_manager);
863859
auto catalog = Catalog::create();
864860
LockManager lm;
865-
TransactionManager tm(lm, *catalog, sm, nullptr);
861+
TransactionManager tm(lm, *catalog, sm, sm.get_log_manager());
866862
QueryExecutor exec(*catalog, sm, lm, tm);
867863

868-
static_cast<void>(
869-
exec.execute(*Parser(std::make_unique<Lexer>("CREATE TABLE having_test (grp INT, val INT)"))
870-
.parse_statement()));
871-
static_cast<void>(exec.execute(
872-
*Parser(std::make_unique<Lexer>("INSERT INTO having_test VALUES (1, 10), (1, 20), (2, 5)"))
873-
.parse_statement()));
864+
static_cast<void>(exec.execute(*Parser(std::make_unique<Lexer>("CREATE TABLE having_test (grp INT, val INT)")).parse_statement()));
865+
static_cast<void>(exec.execute(*Parser(std::make_unique<Lexer>("INSERT INTO having_test VALUES (1, 10), (1, 20), (2, 5)")).parse_statement()));
874866

875867
// SELECT grp, SUM(val) FROM having_test GROUP BY grp HAVING SUM(val) > 10
876-
auto res = exec.execute(
877-
*Parser(std::make_unique<Lexer>(
878-
"SELECT grp, SUM(val) FROM having_test GROUP BY grp HAVING SUM(val) > 10"))
879-
.parse_statement());
880-
868+
auto res = exec.execute(*Parser(std::make_unique<Lexer>("SELECT grp, SUM(val) FROM having_test GROUP BY grp HAVING SUM(val) > 10")).parse_statement());
869+
881870
EXPECT_TRUE(res.success());
882-
ASSERT_EQ(res.row_count(), 1U); // Only group 1 should pass (sum=30)
871+
ASSERT_EQ(res.row_count(), 1U); // Only group 1 should pass (sum=30)
883872
EXPECT_STREQ(res.rows()[0].get(0).to_string().c_str(), "1");
884873
static_cast<void>(std::remove("./test_data/having_test.heap"));
885874
}
886875

887876
TEST(OperatorTests, AggregateTypes) {
888877
static_cast<void>(std::remove("./test_data/agg_types.heap"));
889878
StorageManager disk_manager("./test_data");
890-
BufferPoolManager sm(128, disk_manager);
879+
BufferPoolManager sm(config::Config::DEFAULT_BUFFER_POOL_SIZE, disk_manager);
891880
auto catalog = Catalog::create();
892881
LockManager lm;
893-
TransactionManager tm(lm, *catalog, sm, nullptr);
882+
TransactionManager tm(lm, *catalog, sm, sm.get_log_manager());
894883
QueryExecutor exec(*catalog, sm, lm, tm);
895884

896-
static_cast<void>(exec.execute(
897-
*Parser(std::make_unique<Lexer>("CREATE TABLE agg_types (val DOUBLE)")).parse_statement()));
898-
static_cast<void>(exec.execute(
899-
*Parser(std::make_unique<Lexer>("INSERT INTO agg_types VALUES (10.0), (20.0), (30.0)"))
900-
.parse_statement()));
885+
static_cast<void>(exec.execute(*Parser(std::make_unique<Lexer>("CREATE TABLE agg_types (val DOUBLE)")).parse_statement()));
886+
static_cast<void>(exec.execute(*Parser(std::make_unique<Lexer>("INSERT INTO agg_types VALUES (10.0), (20.0), (30.0)")).parse_statement()));
901887

902-
auto res = exec.execute(
903-
*Parser(std::make_unique<Lexer>(
904-
"SELECT MIN(val), MAX(val), AVG(val), SUM(val), COUNT(val) FROM agg_types"))
905-
.parse_statement());
888+
auto res = exec.execute(*Parser(std::make_unique<Lexer>("SELECT MIN(val), MAX(val), AVG(val), SUM(val), COUNT(val) FROM agg_types")).parse_statement());
906889
EXPECT_TRUE(res.success());
907890
ASSERT_EQ(res.row_count(), 1U);
908891
EXPECT_DOUBLE_EQ(res.rows()[0].get(0).to_float64(), 10.0);
@@ -916,21 +899,16 @@ TEST(OperatorTests, AggregateTypes) {
916899
TEST(OperatorTests, LimitOffset) {
917900
static_cast<void>(std::remove("./test_data/lim_off.heap"));
918901
StorageManager disk_manager("./test_data");
919-
BufferPoolManager sm(128, disk_manager);
902+
BufferPoolManager sm(config::Config::DEFAULT_BUFFER_POOL_SIZE, disk_manager);
920903
auto catalog = Catalog::create();
921904
LockManager lm;
922-
TransactionManager tm(lm, *catalog, sm, nullptr);
905+
TransactionManager tm(lm, *catalog, sm, sm.get_log_manager());
923906
QueryExecutor exec(*catalog, sm, lm, tm);
924907

925-
static_cast<void>(exec.execute(
926-
*Parser(std::make_unique<Lexer>("CREATE TABLE lim_off (val INT)")).parse_statement()));
927-
static_cast<void>(exec.execute(
928-
*Parser(std::make_unique<Lexer>("INSERT INTO lim_off VALUES (1), (2), (3), (4), (5)"))
929-
.parse_statement()));
908+
static_cast<void>(exec.execute(*Parser(std::make_unique<Lexer>("CREATE TABLE lim_off (val INT)")).parse_statement()));
909+
static_cast<void>(exec.execute(*Parser(std::make_unique<Lexer>("INSERT INTO lim_off VALUES (1), (2), (3), (4), (5)")).parse_statement()));
930910

931-
auto res = exec.execute(
932-
*Parser(std::make_unique<Lexer>("SELECT val FROM lim_off ORDER BY val LIMIT 2 OFFSET 2"))
933-
.parse_statement());
911+
auto res = exec.execute(*Parser(std::make_unique<Lexer>("SELECT val FROM lim_off ORDER BY val LIMIT 2 OFFSET 2")).parse_statement());
934912
EXPECT_TRUE(res.success());
935913
ASSERT_EQ(res.row_count(), 2U);
936914
EXPECT_EQ(res.rows()[0].get(0).to_int64(), 3);
@@ -939,17 +917,18 @@ TEST(OperatorTests, LimitOffset) {
939917
}
940918

941919
TEST(OperatorTests, SeqScanVisibility) {
920+
static_cast<void>(std::remove("./test_data/vis_test.heap"));
942921
StorageManager storage("./test_data");
943-
BufferPoolManager sm(128, storage);
922+
BufferPoolManager sm(config::Config::DEFAULT_BUFFER_POOL_SIZE, storage);
944923
auto catalog = Catalog::create();
945924
LockManager lm;
946-
TransactionManager tm(lm, *catalog, sm, nullptr);
925+
TransactionManager tm(lm, *catalog, sm, sm.get_log_manager());
947926
Schema schema;
948927
schema.add_column("v", ValueType::TYPE_INT64);
949-
928+
950929
HeapTable table("vis_test", sm, schema);
951930
table.create();
952-
931+
953932
// Use a transaction to insert, ensuring xmin > 0
954933
auto* txn_setup = tm.begin();
955934
table.insert(Tuple({Value::make_int64(1)}), txn_setup->get_id());
@@ -959,25 +938,31 @@ TEST(OperatorTests, SeqScanVisibility) {
959938
SeqScanOperator scan(std::make_unique<HeapTable>("vis_test", sm, schema), txn, nullptr);
960939
scan.init();
961940
scan.open();
962-
941+
963942
Tuple t;
964943
int count = 0;
965944
while (scan.next(t)) {
966945
count++;
967946
}
968-
EXPECT_GE(count, 1);
969-
947+
ASSERT_EQ(count, 1);
948+
970949
static_cast<void>(std::remove("./test_data/vis_test.heap"));
971950
}
972951

973952
TEST(ParserTests, CreateIndexAndAlter) {
974953
{
975954
auto lexer = std::make_unique<Lexer>("CREATE INDEX idx_name ON users (col1)");
976955
Parser parser(std::move(lexer));
956+
auto stmt = parser.parse_statement();
957+
ASSERT_NE(stmt, nullptr);
958+
EXPECT_EQ(stmt->type(), StmtType::CreateIndex);
959+
const auto* const create_idx = dynamic_cast<const CreateIndexStatement*>(stmt.get());
960+
ASSERT_NE(create_idx, nullptr);
961+
EXPECT_STREQ(create_idx->index_name().c_str(), "idx_name");
962+
EXPECT_STREQ(create_idx->table_name().c_str(), "users");
977963
}
978964
{
979-
auto lexer =
980-
std::make_unique<Lexer>("SELECT * FROM t WHERE col IS NOT NULL AND id IN (1, 2, 3)");
965+
auto lexer = std::make_unique<Lexer>("SELECT * FROM t WHERE col IS NOT NULL AND id IN (1, 2, 3)");
981966
Parser parser(std::move(lexer));
982967
auto stmt = parser.parse_statement();
983968
ASSERT_NE(stmt, nullptr);

0 commit comments

Comments
 (0)