database/mariadb-columnstore-engine
1
0
Fork 0
mirror of https://github.com/mariadb-corporation/mariadb-columnstore-engine.git synced 2025-11-03 17:13:17 +03:00
Code Activity
Files
d00b849279f77ade6d874d440bf8f99f59a284be
mariadb-columnstore-engine/dbcon/ddlpackage/tdriver.cpp
Leonid Fedorov 04752ec546 clang format apply
2022-01-21 16:43:49 +00:00

925 lines
22 KiB
C++
Raw Blame History

/* Copyright (C) 2014 InfiniDB, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; version 2 of
the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
/***************************************************************************
* dhill@srvengcm1.calpont.com
*
* Purpose: dll package tester
*
***************************************************************************/
#include <string>
#include <algorithm>
#include <functional>
#include <sstream>
#include <exception>
#include <iostream>
#include <fstream>
#include <unistd.h>
#include <vector>
#include <memory>
#include <cppunit/extensions/HelperMacros.h>
#include "sqlparser.h"
#include "messagequeue.h"
using namespace std;
using namespace ddlpackage;
using namespace messageqcpp;
std::string itoa(const int i);
bool parse_file(char* fileName)
{
SqlFileParser parser;
parser.Parse(fileName);
return parser.Good();
}
class ParserTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE(ParserTest);
CPPUNIT_TEST(atac01);
CPPUNIT_TEST(atac05);
CPPUNIT_TEST(atac09);
CPPUNIT_TEST(atmcdd01);
CPPUNIT_TEST(atrt01);
CPPUNIT_TEST(ct02);
CPPUNIT_TEST(ct06);
CPPUNIT_TEST(ct10);
CPPUNIT_TEST(dt02);
CPPUNIT_TEST(atac02);
CPPUNIT_TEST(atac06);
CPPUNIT_TEST(atatc01);
CPPUNIT_TEST(atmcsd01);
CPPUNIT_TEST(ci01);
CPPUNIT_TEST(ct03);
CPPUNIT_TEST(ct07);
CPPUNIT_TEST(ct11);
CPPUNIT_TEST(empty_stmt);
CPPUNIT_TEST(atac03);
CPPUNIT_TEST(atac07);
CPPUNIT_TEST(atdc01);
CPPUNIT_TEST(atdc02);
CPPUNIT_TEST(atdc03);
CPPUNIT_TEST(atmct01);
CPPUNIT_TEST(atmct02);
CPPUNIT_TEST(comment);
CPPUNIT_TEST(ct04);
CPPUNIT_TEST(ct08);
CPPUNIT_TEST(di01);
CPPUNIT_TEST(atac04);
CPPUNIT_TEST(atac08);
CPPUNIT_TEST(atdtc01);
CPPUNIT_TEST(atdtc02);
CPPUNIT_TEST(atrc01);
CPPUNIT_TEST(ct01);
CPPUNIT_TEST(ct05);
CPPUNIT_TEST(ct09);
CPPUNIT_TEST(dt01);
CPPUNIT_TEST(foo);
CPPUNIT_TEST_SUITE_END();
private:
public:
void setUp()
{
}
void tearDown()
{
}
void foo()
{
SqlParser p;
p.Parse("drop table foo");
cout << p.GetParseTree();
}
void atac01()
{
CPPUNIT_ASSERT(parse_file("sql/atac01.sql"));
}
void atac05()
{
CPPUNIT_ASSERT(parse_file("sql/atac05.sql"));
}
void atac09()
{
CPPUNIT_ASSERT(parse_file("sql/atac09.sql"));
}
void atmcdd01()
{
CPPUNIT_ASSERT(parse_file("sql/atmcdd01.sql"));
}
void atrt01()
{
CPPUNIT_ASSERT(parse_file("sql/atrt01.sql"));
}
void ct02()
{
CPPUNIT_ASSERT(parse_file("sql/ct02.sql"));
}
void ct06()
{
CPPUNIT_ASSERT(parse_file("sql/ct06.sql"));
}
void ct10()
{
CPPUNIT_ASSERT(parse_file("sql/ct10.sql"));
}
void dt02()
{
CPPUNIT_ASSERT(parse_file("sql/dt02.sql"));
}
void atac02()
{
CPPUNIT_ASSERT(parse_file("sql/atac02.sql"));
}
void atac06()
{
CPPUNIT_ASSERT(parse_file("sql/atac06.sql"));
}
void atatc01()
{
CPPUNIT_ASSERT(parse_file("sql/atatc01.sql"));
}
void atmcsd01()
{
CPPUNIT_ASSERT(parse_file("sql/atmcsd01.sql"));
}
void ci01()
{
CPPUNIT_ASSERT(parse_file("sql/ci01.sql"));
}
void ct03()
{
CPPUNIT_ASSERT(parse_file("sql/ct03.sql"));
}
void ct07()
{
CPPUNIT_ASSERT(parse_file("sql/ct07.sql"));
}
void ct11()
{
CPPUNIT_ASSERT(parse_file("sql/ct11.sql"));
}
void empty_stmt()
{
CPPUNIT_ASSERT(parse_file("sql/empty-stmt.sql"));
}
void atac03()
{
CPPUNIT_ASSERT(parse_file("sql/atac03.sql"));
}
void atac07()
{
CPPUNIT_ASSERT(parse_file("sql/atac07.sql"));
}
void atdc01()
{
CPPUNIT_ASSERT(parse_file("sql/atdc01.sql"));
}
void atdc02()
{
CPPUNIT_ASSERT(parse_file("sql/atdc02.sql"));
}
void atdc03()
{
CPPUNIT_ASSERT(parse_file("sql/atdc03.sql"));
}
void atmct01()
{
CPPUNIT_ASSERT(parse_file("sql/atmct01.sql"));
}
void atmct02()
{
CPPUNIT_ASSERT(parse_file("sql/atmct02.sql"));
}
void comment()
{
CPPUNIT_ASSERT(parse_file("sql/comment.sql"));
}
void ct04()
{
CPPUNIT_ASSERT(parse_file("sql/ct04.sql"));
}
void ct08()
{
CPPUNIT_ASSERT(parse_file("sql/ct08.sql"));
}
void di01()
{
CPPUNIT_ASSERT(parse_file("sql/di01.sql"));
}
void atac04()
{
CPPUNIT_ASSERT(parse_file("sql/atac04.sql"));
}
void atac08()
{
CPPUNIT_ASSERT(parse_file("sql/atac08.sql"));
}
void atdtc01()
{
CPPUNIT_ASSERT(parse_file("sql/atdtc01.sql"));
}
void atdtc02()
{
CPPUNIT_ASSERT(parse_file("sql/atdtc02.sql"));
}
void atrc01()
{
CPPUNIT_ASSERT(parse_file("sql/atrc01.sql"));
}
void ct01()
{
CPPUNIT_ASSERT(parse_file("sql/ct01.sql"));
}
void ct05()
{
CPPUNIT_ASSERT(parse_file("sql/ct05.sql"));
}
void ct09()
{
CPPUNIT_ASSERT(parse_file("sql/ct09.sql"));
}
void dt01()
{
CPPUNIT_ASSERT(parse_file("sql/dt01.sql"));
}
};
template <class T>
void u_sertest(T* x)
{
ByteStream bs;
stringstream s1, s2;
auto_ptr<T> y(new T);
x->serialize(bs);
y->unserialize(bs);
s1 << *x;
s2 << *y;
cout << "String Compare" << endl;
cout << "------------------" << endl;
cout << s1.str() << endl << s2.str() << endl;
cout << "------------------" << endl;
CPPUNIT_ASSERT(s1.str() == s2.str());
}
/** @brief Just like u_sertest except that a typecode is pulled off
the ByteStream before the unserialize. */
template <class T>
void t_sertest(T* x)
{
ByteStream bs;
stringstream s1, s2;
auto_ptr<T> y(new T);
x->serialize(bs);
quadbyte type;
bs >> type;
y->unserialize(bs);
s1 << *x;
s2 << *y;
cout << "String Compare" << endl;
cout << "------------------" << endl;
cout << s1.str() << endl << s2.str() << endl;
cout << "------------------" << endl;
CPPUNIT_ASSERT(s1.str() == s2.str());
}
class SerializeTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE(SerializeTest);
CPPUNIT_TEST(qname);
CPPUNIT_TEST(columntype);
CPPUNIT_TEST(columndefaultvalue);
CPPUNIT_TEST(columnconstraintdef);
CPPUNIT_TEST(columndef_01);
CPPUNIT_TEST(referentialaction);
CPPUNIT_TEST(tablecheckconstraint);
CPPUNIT_TEST(tableuniqueconstraint);
CPPUNIT_TEST(tableprimarykeyconstraint);
CPPUNIT_TEST(tablereferencesconstraint);
CPPUNIT_TEST(tabledef);
CPPUNIT_TEST(createtable);
CPPUNIT_TEST(droptable);
CPPUNIT_TEST(createindex);
CPPUNIT_TEST(dropindex);
CPPUNIT_TEST(altertableaddcolumn);
CPPUNIT_TEST(altertableaddcolumns);
CPPUNIT_TEST(altertabledropcolumns);
CPPUNIT_TEST(altertableaddtableconstraint);
CPPUNIT_TEST(altertabledropcolumn);
CPPUNIT_TEST(altertablesetcolumndefault);
CPPUNIT_TEST(altertabledropcolumndefault);
CPPUNIT_TEST(altertabledroptableconstraint);
CPPUNIT_TEST(altertablerenametable);
CPPUNIT_TEST(altertablemodifycolumntype);
CPPUNIT_TEST(altertablerenamecolumn);
CPPUNIT_TEST_SUITE_END();
private:
public:
void setUp()
{
}
void tearDown()
{
}
void altertablerenamecolumn()
{
SqlFileParser p;
p.Parse("sql/atrc01.sql");
if (p.Good())
{
const ParseTree& stmts = p.GetParseTree();
AlterTableStatement* stmt = dynamic_cast<AlterTableStatement*>(stmts[0]);
CPPUNIT_ASSERT(stmt);
t_sertest<AlterTableStatement>(stmt);
}
}
void altertablemodifycolumntype()
{
SqlFileParser p;
p.Parse("sql/atmct01.sql");
if (p.Good())
{
const ParseTree& stmts = p.GetParseTree();
AlterTableStatement* stmt = dynamic_cast<AlterTableStatement*>(stmts[0]);
CPPUNIT_ASSERT(stmt);
t_sertest<AlterTableStatement>(stmt);
}
}
void altertablerenametable()
{
SqlFileParser p;
p.Parse("sql/atrt01.sql");
if (p.Good())
{
const ParseTree& stmts = p.GetParseTree();
AlterTableStatement* stmt = dynamic_cast<AlterTableStatement*>(stmts[0]);
CPPUNIT_ASSERT(stmt);
t_sertest<AlterTableStatement>(stmt);
}
}
void altertabledroptableconstraint()
{
SqlFileParser p;
p.Parse("sql/atdtc01.sql");
if (p.Good())
{
const ParseTree& stmts = p.GetParseTree();
AlterTableStatement* stmt = dynamic_cast<AlterTableStatement*>(stmts[0]);
CPPUNIT_ASSERT(stmt);
t_sertest<AlterTableStatement>(stmt);
}
}
void altertabledropcolumndefault()
{
SqlFileParser p;
p.Parse("sql/atmcdd01.sql");
if (p.Good())
{
const ParseTree& stmts = p.GetParseTree();
AlterTableStatement* stmt = dynamic_cast<AlterTableStatement*>(stmts[0]);
CPPUNIT_ASSERT(stmt);
t_sertest<AlterTableStatement>(stmt);
}
}
void altertablesetcolumndefault()
{
SqlFileParser p;
p.Parse("sql/atmcsd01.sql");
if (p.Good())
{
const ParseTree& stmts = p.GetParseTree();
AlterTableStatement* stmt = dynamic_cast<AlterTableStatement*>(stmts[0]);
CPPUNIT_ASSERT(stmt);
t_sertest<AlterTableStatement>(stmt);
}
}
void altertabledropcolumn()
{
SqlFileParser p;
p.Parse("sql/atdc01.sql");
if (p.Good())
{
const ParseTree& stmts = p.GetParseTree();
AlterTableStatement* stmt = dynamic_cast<AlterTableStatement*>(stmts[0]);
CPPUNIT_ASSERT(stmt);
t_sertest<AlterTableStatement>(stmt);
}
}
void altertableaddtableconstraint()
{
SqlFileParser p;
p.Parse("sql/atatc01.sql");
if (p.Good())
{
const ParseTree& stmts = p.GetParseTree();
AlterTableStatement* stmt = dynamic_cast<AlterTableStatement*>(stmts[0]);
CPPUNIT_ASSERT(stmt);
t_sertest<AlterTableStatement>(stmt);
}
}
void altertableaddcolumn()
{
cout << "Serialize test: AtaAddColumn" << endl;
auto_ptr<AtaAddColumn> ata(new AtaAddColumn);
vector<string> files;
files.push_back("sql/ct01.sql");
files.push_back("sql/ct02.sql");
files.push_back("sql/ct03.sql");
files.push_back("sql/ct04.sql");
files.push_back("sql/ct05.sql");
files.push_back("sql/ct06.sql");
files.push_back("sql/ct07.sql");
files.push_back("sql/ct08.sql");
files.push_back("sql/ct09.sql");
files.push_back("sql/ct10.sql");
files.push_back("sql/ct11.sql");
vector<string>::const_iterator itr;
for (itr = files.begin(); itr != files.end(); ++itr)
{
SqlFileParser p;
p.Parse(*itr);
if (p.Good())
{
const ParseTree& stmts = p.GetParseTree();
CreateTableStatement* ct = dynamic_cast<CreateTableStatement*>(stmts[0]);
CPPUNIT_ASSERT(ct);
ColumnDefList* columns = &(ct->fTableDef->fColumns);
ColumnDefList::const_iterator itr;
for (itr = columns->begin(); itr != columns->end(); ++itr)
{
ata->fColumnDef = *itr;
t_sertest<AtaAddColumn>(ata.get());
// We borrowed the column def from the parse
// tree. Null it to avoid double free.
ata->fColumnDef = 0;
}
}
}
}
void altertableaddcolumns()
{
cout << "Serialize test: AtaAddColumnS" << endl;
auto_ptr<AtaAddColumns> ata(new AtaAddColumns);
vector<string> files;
files.push_back("sql/ct01.sql");
files.push_back("sql/ct02.sql");
files.push_back("sql/ct03.sql");
files.push_back("sql/ct04.sql");
files.push_back("sql/ct05.sql");
files.push_back("sql/ct06.sql");
files.push_back("sql/ct07.sql");
files.push_back("sql/ct08.sql");
files.push_back("sql/ct09.sql");
files.push_back("sql/ct10.sql");
files.push_back("sql/ct11.sql");
vector<string>::const_iterator itr;
for (itr = files.begin(); itr != files.end(); ++itr)
{
SqlFileParser p;
p.Parse(*itr);
if (p.Good())
{
const ParseTree& stmts = p.GetParseTree();
CreateTableStatement* ct = dynamic_cast<CreateTableStatement*>(stmts[0]);
CPPUNIT_ASSERT(ct);
ata->fColumns = ct->fTableDef->fColumns;
t_sertest<AtaAddColumns>(ata.get());
// We borrowed the column defs from the parse
// tree. Null it to avoid double free.
ata->fColumns.clear();
}
}
}
void altertabledropcolumns()
{
ColumnNameList* names = new ColumnNameList;
names->push_back("c1");
names->push_back("c2");
auto_ptr<AtaDropColumns> stmt(new AtaDropColumns(names));
t_sertest<AtaDropColumns>(stmt.get());
}
void qname()
{
cout << "Serialize test: QualifiedName" << endl;
auto_ptr<QualifiedName> name(new QualifiedName("one", "two", "three"));
u_sertest<QualifiedName>(name.get());
}
void columntype()
{
cout << "Serialize test: ColumnType" << endl;
auto_ptr<ColumnType> type(new ColumnType);
type->fType = 1;
type->fLength = 2;
type->fPrecision = 3;
type->fScale = 4;
type->fWithTimezone = true;
u_sertest<ColumnType>(type.get());
}
void columndefaultvalue()
{
cout << "Serialize test: ColumnDefaultValue" << endl;
auto_ptr<ColumnDefaultValue> dval(new ColumnDefaultValue);
dval->fNull = false;
dval->fValue = "1.234";
u_sertest<ColumnDefaultValue>(dval.get());
}
void columnconstraintdef()
{
cout << "Serialize test: ColumnConstraintDef" << endl;
auto_ptr<ColumnConstraintDef> con(new ColumnConstraintDef);
con->fDeferrable = true;
con->fCheckTime = DDL_INITIALLY_DEFERRED;
con->fConstraintType = DDL_CHECK;
con->fCheck = "thecheck";
u_sertest<ColumnConstraintDef>(con.get());
}
/** @brief Can we serialize ColumDefs?
*
* Here we leverage the parser and the ostream operators for
* parser objects to test serialization for ColumnDefs. We use
* the parser to build parse trees for some create table
* statements. Then we push the ColumnDefs through a ByteStream
* and compare the results as strings. In other words, if C is a
* ColumnDef in the parser constructed tree, we write C to the
* ByteStream and then unserialize it back out making a new ColumnDef,
* C'. We then format C and C' to respective stringstreams and
* then compare the strings. If they are equal, chances are good
* the serialization is OK.
*/
void columndef_01()
{
cout << "columndef_01" << endl;
vector<string> files;
files.push_back("sql/ct01.sql");
files.push_back("sql/ct02.sql");
files.push_back("sql/ct03.sql");
files.push_back("sql/ct04.sql");
files.push_back("sql/ct05.sql");
files.push_back("sql/ct06.sql");
files.push_back("sql/ct07.sql");
files.push_back("sql/ct08.sql");
files.push_back("sql/ct09.sql");
files.push_back("sql/ct10.sql");
files.push_back("sql/ct11.sql");
vector<string>::const_iterator itr;
for (itr = files.begin(); itr != files.end(); ++itr)
{
cout << "* * * Checking columndef serialization for " << *itr << endl;
SqlFileParser p;
p.Parse(*itr);
if (p.Good())
{
const ParseTree& stmts = p.GetParseTree();
CreateTableStatement* ct = dynamic_cast<CreateTableStatement*>(stmts[0]);
CPPUNIT_ASSERT(ct);
cout << "Parsed CreateTable:" << endl;
cout << *ct << endl;
ColumnDefList* columns = &(ct->fTableDef->fColumns);
ColumnDefList::const_iterator itr;
for (itr = columns->begin(); itr != columns->end(); ++itr)
{
u_sertest<ColumnDef>(*itr);
}
}
}
}
void referentialaction()
{
cout << "Serialize test: ReferentialAction" << endl;
auto_ptr<ReferentialAction> ref(new ReferentialAction);
ref->fOnUpdate = DDL_CASCADE;
ref->fOnDelete = DDL_SET_NULL;
u_sertest<ReferentialAction>(ref.get());
}
void tablecheckconstraint()
{
cout << "Serialize test: TableCheckConstraintDef" << endl;
auto_ptr<TableCheckConstraintDef> tc(new TableCheckConstraintDef);
tc->fName = "fooby";
tc->fCheck = "check constraint text";
u_sertest<TableCheckConstraintDef>(tc.get());
}
void tableuniqueconstraint()
{
cout << "Serialize test: TableUniqueConstraintDef" << endl;
auto_ptr<TableUniqueConstraintDef> tc(new TableUniqueConstraintDef);
tc->fName = "fooby";
tc->fColumnNameList.push_back("C1");
tc->fColumnNameList.push_back("C2");
tc->fColumnNameList.push_back("C3");
u_sertest<TableUniqueConstraintDef>(tc.get());
}
void tableprimarykeyconstraint()
{
cout << "Serialize test: TablePrimaryKeyConstraintDef" << endl;
auto_ptr<TablePrimaryKeyConstraintDef> tc(new TablePrimaryKeyConstraintDef);
tc->fName = "fooby";
tc->fColumnNameList.push_back("C1");
tc->fColumnNameList.push_back("C2");
tc->fColumnNameList.push_back("C3");
u_sertest<TablePrimaryKeyConstraintDef>(tc.get());
}
void tablereferencesconstraint()
{
cout << "Serialize test: TableReferencesConstraintDef" << endl;
auto_ptr<TableReferencesConstraintDef> tc(new TableReferencesConstraintDef);
tc->fName = "fooby";
tc->fColumns.push_back("C1");
tc->fColumns.push_back("C2");
tc->fColumns.push_back("C3");
QualifiedName* qname = new QualifiedName;
qname->fCatalog = "";
qname->fSchema = "calpont";
qname->fName = "table_fooby";
tc->fTableName = qname;
tc->fForeignColumns.push_back("F1");
tc->fForeignColumns.push_back("F2");
tc->fForeignColumns.push_back("F3");
tc->fMatchType = DDL_FULL;
ReferentialAction* ref = new ReferentialAction;
ref->fOnUpdate = DDL_CASCADE;
ref->fOnDelete = DDL_NO_ACTION;
tc->fRefAction = ref;
u_sertest<TableReferencesConstraintDef>(tc.get());
}
void tabledef()
{
cout << "tabledef" << endl;
vector<string> files;
files.push_back("sql/ct01.sql");
files.push_back("sql/ct02.sql");
files.push_back("sql/ct03.sql");
files.push_back("sql/ct04.sql");
files.push_back("sql/ct05.sql");
files.push_back("sql/ct06.sql");
files.push_back("sql/ct07.sql");
files.push_back("sql/ct08.sql");
files.push_back("sql/ct09.sql");
files.push_back("sql/ct10.sql");
files.push_back("sql/ct11.sql");
vector<string>::const_iterator itr;
for (itr = files.begin(); itr != files.end(); ++itr)
{
cout << "* * * Checking tabledef serialization for " << *itr << endl;
SqlFileParser p;
p.Parse(*itr);
if (p.Good())
{
const ParseTree& stmts = p.GetParseTree();
CreateTableStatement* ct = dynamic_cast<CreateTableStatement*>(stmts[0]);
CPPUNIT_ASSERT(ct);
cout << "Parsed CreateTable:" << endl;
cout << *ct << endl;
u_sertest<TableDef>(ct->fTableDef);
}
}
}
void createtable()
{
vector<string> files;
files.push_back("sql/ct01.sql");
files.push_back("sql/ct02.sql");
files.push_back("sql/ct03.sql");
files.push_back("sql/ct04.sql");
files.push_back("sql/ct05.sql");
files.push_back("sql/ct06.sql");
files.push_back("sql/ct07.sql");
files.push_back("sql/ct08.sql");
files.push_back("sql/ct09.sql");
files.push_back("sql/ct10.sql");
files.push_back("sql/ct11.sql");
vector<string>::const_iterator itr;
for (itr = files.begin(); itr != files.end(); ++itr)
{
cout << "* * * Checking CreateTableStatement serialization for " << *itr << endl;
SqlFileParser p;
p.setDefaultSchema("tpch");
p.Parse(*itr);
if (p.Good())
{
const ParseTree& stmts = p.GetParseTree();
CreateTableStatement* ct = dynamic_cast<CreateTableStatement*>(stmts[0]);
CPPUNIT_ASSERT(ct);
cout << "Parsed CreateTable:" << endl;
cout << *ct << endl;
t_sertest<CreateTableStatement>(ct);
}
}
}
void droptable()
{
vector<string> files;
files.push_back("sql/dt01.sql");
files.push_back("sql/dt02.sql");
vector<string>::const_iterator itr;
for (itr = files.begin(); itr != files.end(); ++itr)
{
cout << "* * * Checking DropTableStatement serialization for " << *itr << endl;
SqlFileParser p;
p.Parse(*itr);
if (p.Good())
{
const ParseTree& stmts = p.GetParseTree();
DropTableStatement* stmt = dynamic_cast<DropTableStatement*>(stmts[0]);
CPPUNIT_ASSERT(stmt);
cout << "Parsed DropTable:" << endl;
cout << *stmt << endl;
t_sertest<DropTableStatement>(stmt);
}
}
}
void createindex()
{
vector<string> files;
files.push_back("sql/ci01.sql");
files.push_back("sql/ci02.sql");
vector<string>::const_iterator itr;
for (itr = files.begin(); itr != files.end(); ++itr)
{
cout << "* * * Checking Create Index serialization for " << *itr << endl;
SqlFileParser p;
p.Parse(*itr);
if (p.Good())
{
const ParseTree& stmts = p.GetParseTree();
CreateIndexStatement* stmt = dynamic_cast<CreateIndexStatement*>(stmts[0]);
CPPUNIT_ASSERT(stmt);
cout << "Parsed:" << endl;
cout << *stmt << endl;
t_sertest<CreateIndexStatement>(stmt);
}
}
}
void dropindex()
{
vector<string> files;
files.push_back("sql/di01.sql");
vector<string>::const_iterator itr;
for (itr = files.begin(); itr != files.end(); ++itr)
{
cout << "* * * Checking Drop Index serialization for " << *itr << endl;
SqlFileParser p;
p.Parse(*itr);
if (p.Good())
{
const ParseTree& stmts = p.GetParseTree();
DropIndexStatement* stmt = dynamic_cast<DropIndexStatement*>(stmts[0]);
CPPUNIT_ASSERT(stmt);
cout << "Parsed:" << endl;
cout << *stmt << endl;
t_sertest<DropIndexStatement>(stmt);
}
}
}
};
CPPUNIT_TEST_SUITE_REGISTRATION(SerializeTest);
CPPUNIT_TEST_SUITE_REGISTRATION(ParserTest);
#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/ui/text/TestRunner.h>
int main(int argc, char* argv[])
{
CppUnit::TextUi::TestRunner runner;
CppUnit::TestFactoryRegistry& registry = CppUnit::TestFactoryRegistry::getRegistry();
runner.addTest(registry.makeTest());
bool wasSuccessful = runner.run("", false);
return (wasSuccessful ? 0 : 1);
}
string itoa(const int i)
{
stringstream ss;
ss << i;
return ss.str();
}
View Git Blame Copy Permalink