adjust names of members

src/SQLParser.cpp

@@ -37,6 +37,7 @@ namespace hsql {
 		return result;
 	}
 
+
 	SQLParserResult* SQLParser::parseSQLString(const std::string& text) {
 		return parseSQLString(text.c_str());
 	}

src/SQLParser.h

@@ -1,7 +1,6 @@
 #ifndef __SQLPARSER_H_
 #define __SQLPARSER_H_
 
-#include "sqltypes.h"
 #include "SQLParserResult.h"
 #include "sql/statements.h"
 

src/SQLParserResult.cpp

@@ -1,2 +1,41 @@
 
 #include "SQLParserResult.h"
+
+namespace hsql {
+
+	SQLParserResult::SQLParserResult() :
+		isValid(true),
+		errorMsg(NULL) {};
+
+
+	SQLParserResult::SQLParserResult(SQLStatement* stmt) :
+		isValid(true),
+		errorMsg(NULL) {
+		addStatement(stmt); 
+	};
+
+
+	SQLParserResult::~SQLParserResult() {
+		for (std::vector<SQLStatement*>::iterator it = statements.begin(); it != statements.end(); ++it) {
+			delete *it;
+		}
+
+		delete errorMsg;
+	}
+
+
+	void SQLParserResult::addStatement(SQLStatement* stmt) {
+		statements.push_back(stmt);
+	}
+
+
+	SQLStatement* SQLParserResult::getStatement(int id) {
+		return statements[id];
+	}
+
+
+	size_t SQLParserResult::size() {
+		return statements.size();
+	}
+	
+} // namespace hsql

src/SQLParserResult.h

@@ -8,36 +8,28 @@ namespace hsql {
 	 * Represents the result of the SQLParser.
 	 * If parsing was successful it contains a list of SQLStatement.
 	 */
-	struct SQLParserResult {
+	class SQLParserResult {
 	public:
-		SQLParserResult() :
-			isValid(true),
-			parser_msg(NULL) {};
 
-		SQLParserResult(SQLStatement* stmt) :
+		SQLParserResult();
-			isValid(true),
+		SQLParserResult(SQLStatement* stmt);
-			parser_msg(NULL) {
+		virtual ~SQLParserResult();
-			addStatement(stmt); 
-		};
 
-		virtual ~SQLParserResult() {
+		void addStatement(SQLStatement* stmt);
-			for (std::vector<SQLStatement*>::iterator it = statements.begin(); it != statements.end(); ++it) {
-				delete *it;
-			}
-			delete parser_msg;
-		}
 
-		void addStatement(SQLStatement* stmt) { statements.push_back(stmt); }
+		SQLStatement* getStatement(int id);
-		SQLStatement* getStatement(int id) { return statements[id]; }
-		size_t numStatements() { return statements.size(); }
 
+		size_t size();
+		
+		// public properties
 		std::vector<SQLStatement*> statements;
 		bool isValid;
-		const char* parser_msg;
+
-		int error_line;
+		const char* errorMsg;
-		int error_col;
+		int errorLine;
+		int errorColumn;
 	};
 
-}
+} // namespace hsql
 
 #endif // __SQLPARSERRESULT__

src/parser/bison_parser.cpp

@@ -95,9 +95,9 @@ int yyerror(YYLTYPE* llocp, SQLParserResult** result, yyscan_t scanner, const ch
 
 	SQLParserResult* list = new SQLParserResult();
 	list->isValid = false;
-	list->parser_msg = strdup(msg);
+	list->errorMsg = strdup(msg);
-	list->error_line = llocp->first_line;
+	list->errorLine = llocp->first_line;
-	list->error_col = llocp->first_column;
+	list->errorColumn = llocp->first_column;
 
 	*result = list;
 	return 0;

src/parser/bison_parser.y

@@ -22,9 +22,9 @@ int yyerror(YYLTYPE* llocp, SQLParserResult** result, yyscan_t scanner, const ch
 
 	SQLParserResult* list = new SQLParserResult();
 	list->isValid = false;
-	list->parser_msg = strdup(msg);
+	list->errorMsg = strdup(msg);
-	list->error_line = llocp->first_line;
+	list->errorLine = llocp->first_line;
-	list->error_col = llocp->first_column;
+	list->errorColumn = llocp->first_column;
 
 	*result = list;
 	return 0;

src/sql/Expr.h

@@ -26,8 +26,7 @@ typedef enum {
 typedef struct Expr Expr;
 
 /** 
- * @class Expr
+ * Represents SQL expressions (i.e. literals, operators, column_refs)
- * @brief Represents SQL expressions (i.e. literals, operators, column_refs)
  *
  * TODO: When destructing a placeholder expression, we might need to alter the placeholder_list
  */

src/sqlhelper.cpp

@@ -8,12 +8,12 @@ namespace hsql {
 void printOperatorExpression(Expr* expr, uint num_indent);
 
 std::string indent(uint num_indent) { return std::string(num_indent, '\t'); }
-void inprint(int64_t val, uint num_indent) { printf("%s%lld  \n", indent(num_indent).c_str(), val); }
+void inprint(int64_t val, uint num_indent) { printf("%s%ld  \n", indent(num_indent).c_str(), val); }
 void inprint(float val, uint num_indent) { printf("%s%f\n", indent(num_indent).c_str(), val); }
 void inprint(const char* val, uint num_indent) { printf("%s%s\n", indent(num_indent).c_str(), val); }
 void inprint(const char* val, const char* val2, uint num_indent) { printf("%s%s->%s\n", indent(num_indent).c_str(), val, val2); }
 void inprintC(char val, uint num_indent) { printf("%s%c\n", indent(num_indent).c_str(), val); }
-void inprintU(uint64_t val, uint num_indent) { printf("%s%llu\n", indent(num_indent).c_str(), val); }
+void inprintU(uint64_t val, uint num_indent) { printf("%s%lu\n", indent(num_indent).c_str(), val); }
 
 void printTableRefInfo(TableRef* table, uint num_indent) {
 	switch (table->type) {

src/sqlhelper.h

@@ -1,19 +1,16 @@
-
 #ifndef __SQLHELPER_H__
 #define __SQLHELPER_H__
 
-
-#include "sqltypes.h"
 #include "sql/statements.h"
 
 namespace hsql {
 
-void printStatementInfo(SQLStatement* stmt);
+	void printStatementInfo(SQLStatement* stmt);
-void printSelectStatementInfo(SelectStatement* stmt, uint num_indent);
+	void printSelectStatementInfo(SelectStatement* stmt, uint num_indent);
-void printImportStatementInfo(ImportStatement* stmt, uint num_indent);
+	void printImportStatementInfo(ImportStatement* stmt, uint num_indent);
-void printInsertStatementInfo(InsertStatement* stmt, uint num_indent);
+	void printInsertStatementInfo(InsertStatement* stmt, uint num_indent);
-void printCreateStatementInfo(CreateStatement* stmt, uint num_indent);
+	void printCreateStatementInfo(CreateStatement* stmt, uint num_indent);
-void printExpression(Expr* expr, uint num_indent);
+	void printExpression(Expr* expr, uint num_indent);
 
 } // namespace hsql
 

src/sqltypes.h

@@ -1,6 +0,0 @@
-#ifndef __SQLLIB_H__
-#define __SQLLIB_H__
-
-typedef unsigned int uint;
-
-#endif

test/lib/helper.h

@@ -5,7 +5,7 @@
 #define TEST_PARSE_SQL_QUERY(query, output_var, num_statements) \
 	SQLParserResult* output_var = SQLParser::parseSQLString(query); \
 	ASSERT(output_var->isValid); \
-	ASSERT_EQ(output_var->numStatements(), num_statements);
+	ASSERT_EQ(output_var->size(), num_statements);
 
 
 #define TEST_PARSE_SINGLE_SQL(query, stmt_type, stmt_class, output_var) \

test/sql_grammar_test.cpp

@@ -75,7 +75,7 @@ int main(int argc, char *argv[]) {
 
         if (expect_false == stmt_list->isValid) {
             printf("\033[0;31m{  failed}\033[0m\n");
-            printf("\t\033[0;31m%s (L%d:%d)\n\033[0m", stmt_list->parser_msg, stmt_list->error_line, stmt_list->error_col);
+            printf("\t\033[0;31m%s (L%d:%d)\n\033[0m", stmt_list->errorMsg, stmt_list->errorLine, stmt_list->errorColumn);
             printf("\t%s\n", sql.c_str());
             num_failed++;
         } else {

test/sql_tests.cpp

@@ -11,12 +11,12 @@ using namespace hsql;
 
 
 TEST(DeleteStatementTest) {
-	SQLParserResult* stmt_list = SQLParser::parseSQLString("DELETE FROM students WHERE grade > 2.0;");
+	SQLParserResult* result = SQLParser::parseSQLString("DELETE FROM students WHERE grade > 2.0;");
-	ASSERT(stmt_list->isValid);
+	ASSERT(result->isValid);
-	ASSERT_EQ(stmt_list->numStatements(), 1);
+	ASSERT_EQ(result->size(), 1);
-	ASSERT(stmt_list->getStatement(0)->type() == kStmtDelete);
+	ASSERT(result->getStatement(0)->type() == kStmtDelete);
 
-	DeleteStatement* stmt = (DeleteStatement*) stmt_list->getStatement(0);
+	DeleteStatement* stmt = (DeleteStatement*) result->getStatement(0);
 	ASSERT_STREQ(stmt->table_name, "students");
 	ASSERT_NOTNULL(stmt->expr);
 	ASSERT(stmt->expr->isType(kExprOperator));
@@ -25,12 +25,12 @@ TEST(DeleteStatementTest) {
 }
 
 TEST(CreateStatementTest) {
-	SQLParserResult* stmt_list = SQLParser::parseSQLString("CREATE TABLE students (name TEXT, student_number INT, city INTEGER, grade DOUBLE)");
+	SQLParserResult* result = SQLParser::parseSQLString("CREATE TABLE students (name TEXT, student_number INT, city INTEGER, grade DOUBLE)");
-	ASSERT(stmt_list->isValid);
+	ASSERT(result->isValid);
-	ASSERT_EQ(stmt_list->numStatements(), 1);
+	ASSERT_EQ(result->size(), 1);
-	ASSERT_EQ(stmt_list->getStatement(0)->type(), kStmtCreate);
+	ASSERT_EQ(result->getStatement(0)->type(), kStmtCreate);
 
-	CreateStatement* stmt = (CreateStatement*) stmt_list->getStatement(0);
+	CreateStatement* stmt = (CreateStatement*) result->getStatement(0);
 	ASSERT_EQ(stmt->type, CreateStatement::kTable);
 	ASSERT_STREQ(stmt->table_name, "students");
 	ASSERT_NOTNULL(stmt->columns);
@@ -47,12 +47,12 @@ TEST(CreateStatementTest) {
 
 
 TEST(UpdateStatementTest) {
-	SQLParserResult* stmt_list = SQLParser::parseSQLString("UPDATE students SET grade = 5.0, name = 'test' WHERE name = 'Max Mustermann';");
+	SQLParserResult* result = SQLParser::parseSQLString("UPDATE students SET grade = 5.0, name = 'test' WHERE name = 'Max Mustermann';");
-	ASSERT(stmt_list->isValid);
+	ASSERT(result->isValid);
-	ASSERT_EQ(stmt_list->numStatements(), 1);
+	ASSERT_EQ(result->size(), 1);
-	ASSERT_EQ(stmt_list->getStatement(0)->type(), kStmtUpdate);
+	ASSERT_EQ(result->getStatement(0)->type(), kStmtUpdate);
 
-	UpdateStatement* stmt = (UpdateStatement*) stmt_list->getStatement(0);
+	UpdateStatement* stmt = (UpdateStatement*) result->getStatement(0);
 	ASSERT_NOTNULL(stmt->table);
 	ASSERT_STREQ(stmt->table->name, "students");
 	
@@ -99,16 +99,16 @@ TEST(PrepareStatementTest) {
 		"PREPARE stmt: SELECT * FROM data WHERE c1 = ?;"
 		"DEALLOCATE PREPARE stmt;";
 
-	TEST_PARSE_SQL_QUERY(query, stmt_list, 3);
+	TEST_PARSE_SQL_QUERY(query, result, 3);
 
-	TEST_CAST_STMT(stmt_list, 0, kStmtPrepare, PrepareStatement, prep1);
+	TEST_CAST_STMT(result, 0, kStmtPrepare, PrepareStatement, prep1);
-	TEST_CAST_STMT(stmt_list, 1, kStmtPrepare, PrepareStatement, prep2);
+	TEST_CAST_STMT(result, 1, kStmtPrepare, PrepareStatement, prep2);
-	TEST_CAST_STMT(stmt_list, 2, kStmtDrop, DropStatement, drop);
+	TEST_CAST_STMT(result, 2, kStmtDrop, DropStatement, drop);
 
 	// Prepare Statement #1
 	ASSERT_STREQ(prep1->name, "test");
 	ASSERT_EQ(prep1->placeholders.size(), 3);
-	ASSERT_EQ(prep1->query->numStatements(), 2);
+	ASSERT_EQ(prep1->query->size(), 2);
 	
 	TEST_CAST_STMT(prep1->query, 0, kStmtInsert, InsertStatement, insert);
 	TEST_CAST_STMT(prep1->query, 1, kStmtSelect, SelectStatement, select);