pgLab/tests/pglabtests/tst_newParser.cpp

#include <gtest/gtest.h>
#include <gmock/gmock-matchers.h>
#include "PrintTo_Qt.h"
#include "sqlparser/Parser.h"

using namespace testing;
using namespace sqlast;

TEST(NewSqlLexer, Select)
{
    std::string source = "SELECT";
    antlr4::ANTLRInputStream input(source);
    PgsqlLexer lexer(&input);

    auto token = lexer.nextToken();
    ASSERT_EQ(PgsqlLexer::Select, token->getType());
}

TEST(NewSqlLexer, Ident)
{
    std::string source = "Abc";
    antlr4::ANTLRInputStream input(source);
    PgsqlLexer lexer(&input);

    auto token = lexer.nextToken();
    ASSERT_EQ(PgsqlLexer::Ident, token->getType());
    ASSERT_EQ("abc", token->getText());
}

TEST(NewSqlLexer, QuotedIdent)
{
    std::string source = "\"Abc\"";
    antlr4::ANTLRInputStream input(source);
    PgsqlLexer lexer(&input);

    auto token = lexer.nextToken();
    ASSERT_EQ(PgsqlLexer::Ident, token->getType());
    ASSERT_EQ("Abc", token->getText());
}

TEST(NewSqlLexer, AcceptNewLineInQuotedIdent)
{
    std::string source = "\"Ab\nc\"";
    antlr4::ANTLRInputStream input(source);
    PgsqlLexer lexer(&input);

    auto token = lexer.nextToken();
    ASSERT_EQ(PgsqlLexer::Ident, token->getType());
    ASSERT_EQ("Ab\nc", token->getText());
}


TEST(NewSqlParser, statementList)
{
    std::string input_string = "SEleCT 1; Select 2;";
    Parser parser(input_string);
    std::unique_ptr<sqlast::StatementList> program = parser.Parse();

    ASSERT_TRUE(program != nullptr);
    ASSERT_EQ(2, program->Count());
    ASSERT_EQ(0, parser.errorCount());
}

TEST(NewSqlParser, missingSemi)
{
    std::string input_string = "1";
    Parser parser(input_string);
    std::unique_ptr<sqlast::StatementList> program = parser.Parse();

    ASSERT_EQ(1, parser.errorCount());
}

TEST(NewSqlParser, selectList)
{
    std::string input_string = "SEleCT 1, 'Tekst'";
    Parser parser(input_string);
    std::unique_ptr<sqlast::StatementList> program = parser.Parse();

    ASSERT_TRUE(program != nullptr);
    ASSERT_EQ(1, program->Count());
    ASSERT_EQ(0, parser.errorCount());

    SelectStatement &s = dynamic_cast<SelectStatement&>(program->Get(0));
    SelectList* sl = s.GetSelectList();
    ASSERT_TRUE(sl != nullptr);
    ASSERT_EQ(2, sl->Count());

    SelectItem& si = sl->Get(1);
    StringLiteral& string_literal = dynamic_cast<StringLiteral&>(si.GetExpression());
    ASSERT_EQ("Tekst", string_literal.GetValue());
}

TEST(NewSqlParser, selectAliasWithoutAs)
{
    std::string input_string = "SELECT 1 a";
    Parser parser(input_string);
    std::unique_ptr<sqlast::StatementList> program = parser.Parse();

    ASSERT_TRUE(program != nullptr);
    ASSERT_EQ(1, program->Count());
    ASSERT_EQ(0, parser.errorCount());

    SelectStatement &s = dynamic_cast<SelectStatement&>(program->Get(0));
    SelectList* sl = s.GetSelectList();
    SelectItem& si = sl->Get(0);
    ASSERT_EQ("a", si.GetAlias());
}


TEST(NewSqlParser, selectAliasWithAs)
{
    std::string input_string = "SELECT 1 AS b";
    Parser parser(input_string);
    std::unique_ptr<sqlast::StatementList> program = parser.Parse();

    ASSERT_TRUE(program != nullptr);
    ASSERT_EQ(1, program->Count());
    ASSERT_EQ(0, parser.errorCount());

    SelectStatement &s = dynamic_cast<SelectStatement&>(program->Get(0));
    SelectList* sl = s.GetSelectList();
    SelectItem& si = sl->Get(0);
    ASSERT_EQ("b", si.GetAlias());
}

TEST(NewSqlParser, selectFrom)
{
    std::string input_string = "SELECT 1 FROM a";
    Parser parser(input_string);
    std::unique_ptr<sqlast::StatementList> program = parser.Parse();

    ASSERT_TRUE(program != nullptr);
    ASSERT_EQ(1, program->Count());
    ASSERT_EQ(0, parser.errorCount());
}