removed List class wrapper and use simply std::vector throughout
This commit is contained in:
Pedro
parent
b5aba646d8
commit
71f9252019
|
|
@ -1,46 +0,0 @@
|
|||
#ifndef __LIST_H__
|
||||
#define __LIST_H__
|
||||
|
||||
#include <vector>
|
||||
#include <stdlib.h>
|
||||
|
||||
namespace hsql {
|
||||
|
||||
// TODO: try to replace the List wrapper by directly using std::vector
|
||||
|
||||
/**
|
||||
* @class List
|
||||
* @brief Classed interface to std::vector (may be replaced with std::vector)
|
||||
*/
|
||||
template <typename _T>
|
||||
class List {
|
||||
public:
|
||||
List() {}
|
||||
|
||||
List(_T first_value) {
|
||||
_vector.push_back(first_value);
|
||||
}
|
||||
|
||||
virtual ~List() {
|
||||
for (_T e : _vector) delete e;
|
||||
}
|
||||
|
||||
inline size_t size() { return _vector.size(); };
|
||||
|
||||
inline _T at(int i) { return _vector[i]; }
|
||||
inline _T &operator[](int i) { return _vector[i]; }
|
||||
|
||||
inline void push_back(_T value) { _vector.push_back(value); }
|
||||
|
||||
inline std::vector<_T> vector() { return _vector; };
|
||||
|
||||
|
||||
private:
|
||||
std::vector<_T> _vector;
|
||||
|
||||
};
|
||||
|
||||
|
||||
} // namespace hsql
|
||||
|
||||
#endif
|
||||
|
|
@ -1,9 +1,9 @@
|
|||
#ifndef __TABLEREF_H__
|
||||
#define __TABLEREF_H__
|
||||
|
||||
#include "List.h"
|
||||
#include "Expr.h"
|
||||
#include <stdio.h>
|
||||
#include <vector>
|
||||
|
||||
namespace hsql {
|
||||
|
||||
|
|
@ -47,7 +47,7 @@ struct TableRef {
|
|||
char* alias;
|
||||
|
||||
SelectStatement* select;
|
||||
List<TableRef*>* list;
|
||||
std::vector<TableRef*>* list;
|
||||
JoinDefinition* join;
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ void printTableRefInfo(TableRef* table, uint num_indent) {
|
|||
printExpression(table->join->condition, num_indent+2);
|
||||
break;
|
||||
case kTableCrossProduct:
|
||||
for (TableRef* tbl : table->list->vector()) printTableRefInfo(tbl, num_indent);
|
||||
for (TableRef* tbl : *table->list) printTableRefInfo(tbl, num_indent);
|
||||
break;
|
||||
}
|
||||
if (table->alias != NULL) {
|
||||
|
|
@ -76,7 +76,7 @@ void printExpression(Expr* expr, uint num_indent) {
|
|||
void printSelectStatementInfo(SelectStatement* stmt, uint num_indent) {
|
||||
inprint("SelectStatement", num_indent);
|
||||
inprint("Fields:", num_indent+1);
|
||||
for (Expr* expr : stmt->select_list->vector()) printExpression(expr, num_indent+2);
|
||||
for (Expr* expr : *stmt->select_list) printExpression(expr, num_indent+2);
|
||||
|
||||
inprint("Sources:", num_indent+1);
|
||||
printTableRefInfo(stmt->from_table, num_indent+2);
|
||||
|
|
@ -124,14 +124,14 @@ void printInsertStatementInfo(InsertStatement* stmt, uint num_indent) {
|
|||
inprint(stmt->table_name, num_indent+1);
|
||||
if (stmt->columns != NULL) {
|
||||
inprint("Columns", num_indent+1);
|
||||
for (char* col_name : stmt->columns->vector()) {
|
||||
for (char* col_name : *stmt->columns) {
|
||||
inprint(col_name, num_indent+2);
|
||||
}
|
||||
}
|
||||
switch (stmt->type) {
|
||||
case InsertStatement::kInsertValues:
|
||||
inprint("Values", num_indent+1);
|
||||
for (Expr* expr : stmt->values->vector()) {
|
||||
for (Expr* expr : *stmt->values) {
|
||||
printExpression(expr, num_indent+2);
|
||||
}
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ struct CreateStatement : SQLStatement {
|
|||
CreateType type;
|
||||
bool if_not_exists;
|
||||
|
||||
List<ColumnDefinition*>* columns;
|
||||
std::vector<ColumnDefinition*>* columns;
|
||||
|
||||
const char* file_path;
|
||||
const char* table_name;
|
||||
|
|
|
|||
|
|
@ -13,8 +13,7 @@ namespace hsql {
|
|||
struct ExecuteStatement : SQLStatement {
|
||||
ExecuteStatement() :
|
||||
SQLStatement(kStmtExecute),
|
||||
name(NULL),
|
||||
parameters(NULL) {}
|
||||
name(NULL) {}
|
||||
|
||||
virtual ~ExecuteStatement() {
|
||||
delete name;
|
||||
|
|
@ -22,7 +21,7 @@ struct ExecuteStatement : SQLStatement {
|
|||
}
|
||||
|
||||
const char* name;
|
||||
List<Expr*>* parameters;
|
||||
std::vector<Expr*>* parameters;
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -34,8 +34,8 @@ struct InsertStatement : SQLStatement {
|
|||
|
||||
InsertType type;
|
||||
const char* table_name;
|
||||
List<char*>* columns;
|
||||
List<Expr*>* values;
|
||||
std::vector<char*>* columns;
|
||||
std::vector<Expr*>* values;
|
||||
SelectStatement* select;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,6 @@
|
|||
#ifndef __STATEMENT_H__
|
||||
#define __STATEMENT_H__
|
||||
|
||||
#include "List.h"
|
||||
#include "Expr.h"
|
||||
#include <vector>
|
||||
|
||||
|
|
@ -50,22 +49,27 @@ private:
|
|||
* @struct SQLStatementList
|
||||
* @brief Represents the result of the SQLParser. If parsing was successful it is a list of SQLStatement.
|
||||
*/
|
||||
class SQLStatementList : public List<SQLStatement*> {
|
||||
struct SQLStatementList {
|
||||
public:
|
||||
SQLStatementList() :
|
||||
List<SQLStatement*>(),
|
||||
isValid(true),
|
||||
parser_msg(NULL) {};
|
||||
|
||||
SQLStatementList(SQLStatement* stmt) :
|
||||
List<SQLStatement*>(stmt),
|
||||
isValid(true),
|
||||
parser_msg(NULL) {};
|
||||
parser_msg(NULL) {
|
||||
addStatement(stmt);
|
||||
};
|
||||
|
||||
virtual ~SQLStatementList() {
|
||||
delete parser_msg;
|
||||
}
|
||||
|
||||
void addStatement(SQLStatement* stmt) { statements.push_back(stmt); }
|
||||
SQLStatement* getStatement(int id) { return statements[id]; }
|
||||
size_t numStatements() { return statements.size(); }
|
||||
|
||||
std::vector<SQLStatement*> statements;
|
||||
bool isValid;
|
||||
const char* parser_msg;
|
||||
int error_line;
|
||||
|
|
|
|||
|
|
@ -3,7 +3,6 @@
|
|||
|
||||
#include "SQLStatement.h"
|
||||
#include "Expr.h"
|
||||
#include "List.h"
|
||||
#include "Table.h"
|
||||
|
||||
namespace hsql {
|
||||
|
|
@ -62,7 +61,7 @@ struct GroupByDescription {
|
|||
delete having;
|
||||
}
|
||||
|
||||
List<Expr*>* columns;
|
||||
std::vector<Expr*>* columns;
|
||||
Expr* having;
|
||||
};
|
||||
|
||||
|
|
@ -94,7 +93,7 @@ struct SelectStatement : SQLStatement {
|
|||
|
||||
TableRef* from_table;
|
||||
bool select_distinct;
|
||||
List<Expr*>* select_list;
|
||||
std::vector<Expr*>* select_list;
|
||||
Expr* where_clause;
|
||||
GroupByDescription* group_by;
|
||||
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ struct UpdateStatement : SQLStatement {
|
|||
|
||||
// TODO: switch to char* instead of TableRef
|
||||
TableRef* table;
|
||||
List<UpdateClause*>* updates;
|
||||
std::vector<UpdateClause*>* updates;
|
||||
Expr* where;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -124,11 +124,12 @@ int yyerror(YYLTYPE* llocp, SQLStatementList** result, yyscan_t scanner, const c
|
|||
hsql::UpdateClause* update_t;
|
||||
|
||||
hsql::SQLStatementList* stmt_list;
|
||||
hsql::List<char*>* slist;
|
||||
hsql::List<hsql::Expr*>* expr_list;
|
||||
hsql::List<hsql::TableRef*>* table_list;
|
||||
hsql::List<hsql::ColumnDefinition*>* column_list_t;
|
||||
hsql::List<hsql::UpdateClause*>* update_list_t;
|
||||
|
||||
std::vector<char*>* str_vec;
|
||||
std::vector<hsql::TableRef*>* table_vec;
|
||||
std::vector<hsql::ColumnDefinition*>* column_vec;
|
||||
std::vector<hsql::UpdateClause*>* update_vec;
|
||||
std::vector<hsql::Expr*>* expr_vec;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -180,18 +181,19 @@ int yyerror(YYLTYPE* llocp, SQLStatementList** result, yyscan_t scanner, const c
|
|||
%type <expr> expr scalar_expr unary_expr binary_expr function_expr star_expr expr_alias placeholder_expr
|
||||
%type <expr> column_name literal int_literal num_literal string_literal
|
||||
%type <expr> comp_expr opt_where join_condition opt_having
|
||||
%type <expr_list> expr_list select_list literal_list
|
||||
%type <table_list> table_ref_commalist
|
||||
%type <order> opt_order
|
||||
%type <limit> opt_limit
|
||||
%type <order_type> opt_order_type
|
||||
%type <slist> ident_commalist opt_column_list
|
||||
%type <column_t> column_def
|
||||
%type <column_list_t> column_def_commalist
|
||||
%type <update_t> update_clause
|
||||
%type <update_list_t> update_clause_commalist
|
||||
%type <group_t> opt_group
|
||||
|
||||
%type <str_vec> ident_commalist opt_column_list
|
||||
%type <expr_vec> expr_list select_list literal_list
|
||||
%type <table_vec> table_ref_commalist
|
||||
%type <update_vec> update_clause_commalist
|
||||
%type <column_vec> column_def_commalist
|
||||
|
||||
/******************************
|
||||
** Token Precedence and Associativity
|
||||
** Precedence: lowest to highest
|
||||
|
|
@ -234,7 +236,7 @@ input:
|
|||
|
||||
statement_list:
|
||||
statement { $$ = new SQLStatementList($1); }
|
||||
| statement_list ';' statement { $1->push_back($3); $$ = $1; }
|
||||
| statement_list ';' statement { $1->addStatement($3); $$ = $1; }
|
||||
;
|
||||
|
||||
statement:
|
||||
|
|
@ -270,7 +272,6 @@ execute_statement:
|
|||
EXECUTE IDENTIFIER {
|
||||
$$ = new ExecuteStatement();
|
||||
$$->name = $2;
|
||||
$$->parameters = NULL;
|
||||
}
|
||||
| EXECUTE IDENTIFIER '(' literal_list ')' {
|
||||
$$ = new ExecuteStatement();
|
||||
|
|
@ -326,7 +327,7 @@ opt_not_exists:
|
|||
;
|
||||
|
||||
column_def_commalist:
|
||||
column_def { $$ = new List<ColumnDefinition*>($1); }
|
||||
column_def { $$ = new std::vector<ColumnDefinition*>(); $$->push_back($1); }
|
||||
| column_def_commalist ',' column_def { $1->push_back($3); $$ = $1; }
|
||||
;
|
||||
|
||||
|
|
@ -417,7 +418,7 @@ update_statement:
|
|||
;
|
||||
|
||||
update_clause_commalist:
|
||||
update_clause { $$ = new List<UpdateClause*>($1); }
|
||||
update_clause { $$ = new std::vector<UpdateClause*>(); $$->push_back($1); }
|
||||
| update_clause_commalist ',' update_clause { $1->push_back($3); $$ = $1; }
|
||||
;
|
||||
|
||||
|
|
@ -533,12 +534,12 @@ opt_limit:
|
|||
* Expressions
|
||||
******************************/
|
||||
expr_list:
|
||||
expr_alias { $$ = new List<Expr*>($1); }
|
||||
expr_alias { $$ = new std::vector<Expr*>(); $$->push_back($1); }
|
||||
| expr_list ',' expr_alias { $1->push_back($3); $$ = $1; }
|
||||
;
|
||||
|
||||
literal_list:
|
||||
literal { $$ = new List<Expr*>($1); }
|
||||
literal { $$ = new std::vector<Expr*>(); $$->push_back($1); }
|
||||
| literal_list ',' literal { $1->push_back($3); $$ = $1; }
|
||||
;
|
||||
|
||||
|
|
@ -661,7 +662,7 @@ table_ref_atomic:
|
|||
|
||||
|
||||
table_ref_commalist:
|
||||
table_ref_atomic { $$ = new List<TableRef*>($1); }
|
||||
table_ref_atomic { $$ = new std::vector<TableRef*>(); $$->push_back($1); }
|
||||
| table_ref_commalist ',' table_ref_atomic { $1->push_back($3); $$ = $1; }
|
||||
;
|
||||
|
||||
|
|
@ -752,7 +753,7 @@ opt_semicolon:
|
|||
|
||||
|
||||
ident_commalist:
|
||||
IDENTIFIER { $$ = new List<char*>($1); }
|
||||
IDENTIFIER { $$ = new std::vector<char*>(); $$->push_back($1); }
|
||||
| ident_commalist ',' IDENTIFIER { $1->push_back($3); $$ = $1; }
|
||||
;
|
||||
|
||||
|
|
|
|||
|
|
@ -13,10 +13,10 @@ using namespace hsql;
|
|||
TEST(DeleteStatementTest) {
|
||||
SQLStatementList* stmt_list = SQLParser::parseSQLString("DELETE FROM students WHERE grade > 2.0;");
|
||||
ASSERT(stmt_list->isValid);
|
||||
ASSERT_EQ(stmt_list->size(), 1);
|
||||
ASSERT(stmt_list->at(0)->type() == kStmtDelete);
|
||||
ASSERT_EQ(stmt_list->numStatements(), 1);
|
||||
ASSERT(stmt_list->getStatement(0)->type() == kStmtDelete);
|
||||
|
||||
DeleteStatement* stmt = (DeleteStatement*) stmt_list->at(0);
|
||||
DeleteStatement* stmt = (DeleteStatement*) stmt_list->getStatement(0);
|
||||
ASSERT_STREQ(stmt->table_name, "students");
|
||||
ASSERT_NOTNULL(stmt->expr);
|
||||
ASSERT(stmt->expr->isType(kExprOperator));
|
||||
|
|
@ -27,10 +27,10 @@ TEST(DeleteStatementTest) {
|
|||
TEST(CreateStatementTest) {
|
||||
SQLStatementList* stmt_list = SQLParser::parseSQLString("CREATE TABLE students (name TEXT, student_number INT, city INTEGER, grade DOUBLE)");
|
||||
ASSERT(stmt_list->isValid);
|
||||
ASSERT_EQ(stmt_list->size(), 1);
|
||||
ASSERT_EQ(stmt_list->at(0)->type(), kStmtCreate);
|
||||
ASSERT_EQ(stmt_list->numStatements(), 1);
|
||||
ASSERT_EQ(stmt_list->getStatement(0)->type(), kStmtCreate);
|
||||
|
||||
CreateStatement* stmt = (CreateStatement*) stmt_list->at(0);
|
||||
CreateStatement* stmt = (CreateStatement*) stmt_list->getStatement(0);
|
||||
ASSERT_EQ(stmt->type, CreateStatement::kTable);
|
||||
ASSERT_STREQ(stmt->table_name, "students");
|
||||
ASSERT_NOTNULL(stmt->columns);
|
||||
|
|
@ -49,10 +49,10 @@ TEST(CreateStatementTest) {
|
|||
TEST(UpdateStatementTest) {
|
||||
SQLStatementList* stmt_list = SQLParser::parseSQLString("UPDATE students SET grade = 5.0, name = 'test' WHERE name = 'Max Mustermann';");
|
||||
ASSERT(stmt_list->isValid);
|
||||
ASSERT_EQ(stmt_list->size(), 1);
|
||||
ASSERT_EQ(stmt_list->at(0)->type(), kStmtUpdate);
|
||||
ASSERT_EQ(stmt_list->numStatements(), 1);
|
||||
ASSERT_EQ(stmt_list->getStatement(0)->type(), kStmtUpdate);
|
||||
|
||||
UpdateStatement* stmt = (UpdateStatement*) stmt_list->at(0);
|
||||
UpdateStatement* stmt = (UpdateStatement*) stmt_list->getStatement(0);
|
||||
ASSERT_NOTNULL(stmt->table);
|
||||
ASSERT_STREQ(stmt->table->name, "students");
|
||||
|
||||
|
|
@ -77,8 +77,8 @@ TEST(UpdateStatementTest) {
|
|||
TEST(InsertStatementTest) {
|
||||
SQLStatementList* stmt_list = SQLParser::parseSQLString("INSERT INTO students VALUES ('Max Mustermann', 12345, 'Musterhausen', 2.0)");
|
||||
ASSERT(stmt_list->isValid);
|
||||
ASSERT_EQ(stmt_list->size(), 1);
|
||||
ASSERT_EQ(stmt_list->at(0)->type(), kStmtInsert);
|
||||
ASSERT_EQ(stmt_list->numStatements(), 1);
|
||||
ASSERT_EQ(stmt_list->getStatement(0)->type(), kStmtInsert);
|
||||
|
||||
// TODO
|
||||
}
|
||||
|
|
@ -87,10 +87,10 @@ TEST(InsertStatementTest) {
|
|||
TEST(DropTableStatementTest) {
|
||||
SQLStatementList* stmt_list = SQLParser::parseSQLString("DROP TABLE students");
|
||||
ASSERT(stmt_list->isValid);
|
||||
ASSERT_EQ(stmt_list->size(), 1);
|
||||
ASSERT_EQ(stmt_list->at(0)->type(), kStmtDrop);
|
||||
ASSERT_EQ(stmt_list->numStatements(), 1);
|
||||
ASSERT_EQ(stmt_list->getStatement(0)->type(), kStmtDrop);
|
||||
|
||||
DropStatement* stmt = (DropStatement*) stmt_list->at(0);
|
||||
DropStatement* stmt = (DropStatement*) stmt_list->getStatement(0);
|
||||
ASSERT_EQ(stmt->type, DropStatement::kTable);
|
||||
ASSERT_NOTNULL(stmt->name);
|
||||
ASSERT_STREQ(stmt->name, "students");
|
||||
|
|
@ -107,13 +107,13 @@ TEST(PrepareStatementTest) {
|
|||
ASSERT_EQ(prep_stmt->placeholders.size(), 3);
|
||||
|
||||
|
||||
ASSERT_EQ(prep_stmt->query->size(), 2);
|
||||
ASSERT_EQ(prep_stmt->query->at(0)->type(), kStmtInsert);
|
||||
ASSERT_EQ(prep_stmt->query->at(1)->type(), kStmtSelect);
|
||||
ASSERT_EQ(prep_stmt->query->numStatements(), 2);
|
||||
ASSERT_EQ(prep_stmt->query->getStatement(0)->type(), kStmtInsert);
|
||||
ASSERT_EQ(prep_stmt->query->getStatement(1)->type(), kStmtSelect);
|
||||
|
||||
|
||||
InsertStatement* insert = (InsertStatement*) prep_stmt->query->at(0);
|
||||
SelectStatement* select = (SelectStatement*) prep_stmt->query->at(1);
|
||||
InsertStatement* insert = (InsertStatement*) prep_stmt->query->getStatement(0);
|
||||
SelectStatement* select = (SelectStatement*) prep_stmt->query->getStatement(1);
|
||||
|
||||
ASSERT(insert->values->at(0)->isType(kExprPlaceholder));
|
||||
ASSERT(select->select_list->at(0)->isType(kExprPlaceholder));
|
||||
|
|
|
|||
|
|
@ -6,9 +6,9 @@
|
|||
#define TEST_PARSE_SINGLE_SQL(query, stmt_type, stmt_class, output_var) \
|
||||
SQLStatementList* stmt_list = SQLParser::parseSQLString(query); \
|
||||
ASSERT(stmt_list->isValid); \
|
||||
ASSERT_EQ(stmt_list->size(), 1); \
|
||||
ASSERT_EQ(stmt_list->at(0)->type(), stmt_type); \
|
||||
stmt_class* output_var = (stmt_class*) stmt_list->at(0);
|
||||
ASSERT_EQ(stmt_list->numStatements(), 1); \
|
||||
ASSERT_EQ(stmt_list->getStatement(0)->type(), stmt_type); \
|
||||
stmt_class* output_var = (stmt_class*) stmt_list->getStatement(0);
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue