mirror of
https://github.com/mariadb-corporation/mariadb-columnstore-engine.git
synced 2025-04-18 21:44:02 +03:00
1568 lines
40 KiB
C++
1568 lines
40 KiB
C++
/* 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. */
|
|
|
|
/***********************************************************************
|
|
* $Id: ddlpkg.h 9210 2013-01-21 14:10:42Z rdempsey $
|
|
*
|
|
*
|
|
***********************************************************************/
|
|
/** @file
|
|
*
|
|
* Class definitions for ddl parser objects. These are the things
|
|
* manufactured by the bison SQL parser. SqlStatementList is the
|
|
* toplevel parser result.
|
|
*
|
|
* Parser objects are described as structs. These objects never
|
|
* change state following construction. An accessor/mutator
|
|
* discipline would amount to clutter.
|
|
*
|
|
* The constructor forms here are directly driven by the structure of
|
|
* the grammar in ddl.y.
|
|
*
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <vector>
|
|
#include <string>
|
|
#include <map>
|
|
#include <set>
|
|
#include <utility>
|
|
#include <iostream>
|
|
#include "bytestream.h"
|
|
#include "logicalpartition.h"
|
|
|
|
#define EXPORT
|
|
|
|
namespace ddlpackage
|
|
{
|
|
typedef messageqcpp::ByteStream::byte byte;
|
|
typedef messageqcpp::ByteStream::doublebyte doublebyte;
|
|
typedef messageqcpp::ByteStream::quadbyte quadbyte;
|
|
|
|
class AlterTable;
|
|
struct AlterTableAction;
|
|
struct ColumnDef;
|
|
struct ColumnDefaultValue;
|
|
struct ColumnType;
|
|
struct QualifiedName;
|
|
struct CreateTableStatement;
|
|
struct SqlStatementList;
|
|
struct SqlStatement;
|
|
struct ColumnConstraintDef;
|
|
struct TableConstraintDef;
|
|
struct SchemaObject;
|
|
struct ReferentialAction;
|
|
struct TableDef;
|
|
|
|
typedef SqlStatement DDLPkg;
|
|
|
|
typedef std::vector<ColumnConstraintDef*> ColumnConstraintList;
|
|
typedef std::vector<SchemaObject*> SchemaObjectList;
|
|
typedef std::vector<std::string> ColumnNameList;
|
|
typedef std::vector<AlterTableAction*> AlterTableActionList;
|
|
typedef std::vector<ColumnDef*> ColumnDefList;
|
|
typedef std::map<std::string, std::string> TableOptionMap;
|
|
typedef std::vector<SchemaObject*> TableElementList;
|
|
typedef std::vector<TableConstraintDef*> TableConstraintDefList;
|
|
|
|
std::ostream& operator<<(std::ostream& os, const ColumnType& columnType);
|
|
std::ostream& operator<<(std::ostream& os, const QualifiedName& constraint);
|
|
std::ostream& operator<<(std::ostream& os, const TableConstraintDef& constraint);
|
|
std::ostream& operator<<(std::ostream& os, const ColumnConstraintDef& con);
|
|
std::ostream& operator<<(std::ostream& os, const ColumnDef& column);
|
|
EXPORT std::ostream& operator<<(std::ostream& os, const SqlStatementList& ct);
|
|
EXPORT std::ostream& operator<<(std::ostream& os, const SqlStatement& stmt);
|
|
std::ostream& operator<<(std::ostream& os, const ColumnDefList& columnList);
|
|
std::ostream& operator<<(std::ostream& os, const AlterTableAction& columnList);
|
|
std::ostream& operator<<(std::ostream& os, const ColumnDefaultValue& defaultValue);
|
|
std::ostream& operator<<(std::ostream& os, const ColumnNameList& columnNames);
|
|
std::ostream& operator<<(std::ostream& os, const ReferentialAction& ref);
|
|
std::ostream& operator<<(std::ostream& os, const TableDef& tableDef);
|
|
|
|
/** @brief Verb List
|
|
* Make sure to keep the enum and string list in-sync
|
|
*/
|
|
enum DDL_VERBS
|
|
{
|
|
DDL_CREATE,
|
|
DDL_ALTER,
|
|
DDL_DROP,
|
|
DDL_INVALID_VERB
|
|
};
|
|
/** @brief Subject List
|
|
* Make sure to keep the enum and string list in-sync
|
|
*/
|
|
enum DDL_SUBJECTS
|
|
{
|
|
DDL_TABLE,
|
|
DDL_INDEX,
|
|
DDL_INVALID_SUBJECT
|
|
};
|
|
|
|
enum DDL_CONSTRAINT_ATTRIBUTES
|
|
{
|
|
DDL_DEFERRABLE,
|
|
DDL_NON_DEFERRABLE,
|
|
DDL_INITIALLY_IMMEDIATE,
|
|
DDL_INITIALLY_DEFERRED,
|
|
DDL_INVALID_ATTRIBUTE
|
|
};
|
|
|
|
const std::string ConstraintAttrStrings[] = {"deferrable", "non-deferrable", "initially-immediate",
|
|
"initially-deferred", "invalid"};
|
|
|
|
enum DDL_REFERENTIAL_ACTION
|
|
{
|
|
DDL_CASCADE,
|
|
DDL_SET_NULL,
|
|
DDL_SET_DEFAULT,
|
|
DDL_NO_ACTION,
|
|
DDL_RESTRICT,
|
|
DDL_INVALID_REFERENTIAL_ACTION
|
|
};
|
|
|
|
const std::string ReferentialActionStrings[] = {"cascade", "set_null", "set_default", "no_action",
|
|
"invalid_action"};
|
|
|
|
enum DDL_MATCH_TYPE
|
|
{
|
|
DDL_FULL,
|
|
DDL_PARTIAL,
|
|
DDL_INVALID_MATCH_TYPE
|
|
};
|
|
|
|
const std::string MatchTypeStrings[] = {"full", "partial", "invalid_match_type"};
|
|
|
|
/** @brief Constraint List
|
|
* Make sure to keep the enum and string list in-sync
|
|
*/
|
|
enum DDL_CONSTRAINTS
|
|
{
|
|
DDL_PRIMARY_KEY,
|
|
DDL_FOREIGN_KEY,
|
|
DDL_CHECK,
|
|
DDL_UNIQUE,
|
|
DDL_REFERENCES,
|
|
DDL_NOT_NULL,
|
|
DDL_AUTO_INCREMENT,
|
|
DDL_INVALID_CONSTRAINT
|
|
};
|
|
/** @brief
|
|
*/
|
|
const std::string ConstraintString[] = {"primary",
|
|
"foreign",
|
|
"check",
|
|
"unique",
|
|
"references",
|
|
"not_null",
|
|
"auto_increment"
|
|
""};
|
|
|
|
/** @brief Datatype List
|
|
* Make sure to keep the enum, string, and length list in-sync
|
|
*/
|
|
enum DDL_DATATYPES
|
|
{
|
|
DDL_BIT,
|
|
DDL_TINYINT,
|
|
DDL_CHAR,
|
|
DDL_SMALLINT,
|
|
DDL_DECIMAL,
|
|
DDL_MEDINT,
|
|
DDL_INT,
|
|
DDL_FLOAT,
|
|
DDL_DATE,
|
|
DDL_BIGINT,
|
|
DDL_DOUBLE,
|
|
DDL_DATETIME,
|
|
DDL_VARCHAR,
|
|
DDL_VARBINARY,
|
|
DDL_CLOB,
|
|
DDL_BLOB,
|
|
DDL_REAL,
|
|
DDL_NUMERIC,
|
|
DDL_NUMBER,
|
|
DDL_INTEGER,
|
|
DDL_UNSIGNED_TINYINT,
|
|
DDL_UNSIGNED_SMALLINT,
|
|
DDL_UNSIGNED_MEDINT,
|
|
DDL_UNSIGNED_INT,
|
|
DDL_UNSIGNED_BIGINT,
|
|
DDL_UNSIGNED_DECIMAL,
|
|
DDL_UNSIGNED_FLOAT,
|
|
DDL_UNSIGNED_DOUBLE,
|
|
DDL_UNSIGNED_NUMERIC,
|
|
DDL_TEXT,
|
|
DDL_TIME,
|
|
DDL_TIMESTAMP,
|
|
DDL_INVALID_DATATYPE
|
|
};
|
|
|
|
/** @brief Datatype string list
|
|
*/
|
|
const std::string DDLDatatypeString[] = {"bit",
|
|
"tinyint",
|
|
"char",
|
|
"smallint",
|
|
"decimal",
|
|
"medint",
|
|
"integer",
|
|
"float",
|
|
"date",
|
|
"bigint",
|
|
"double",
|
|
"datetime",
|
|
"varchar",
|
|
"varbinary",
|
|
"clob",
|
|
"blob",
|
|
"real",
|
|
"numeric",
|
|
"number",
|
|
"integer",
|
|
"unsigned-tinyint",
|
|
"unsigned-smallint",
|
|
"unsigned-medint",
|
|
"unsigned-int",
|
|
"unsigned-bigint",
|
|
"unsigned-decimal",
|
|
"unsigned-float",
|
|
"unsigned-double",
|
|
"unsigned-numeric",
|
|
"text",
|
|
"time",
|
|
"timestamp",
|
|
""};
|
|
|
|
/** @brief Alter table action string list
|
|
*/
|
|
const std::string AlterActionString[] = {
|
|
"AtaAddColumn", "AtaAddColumns", "AtaDropColumn", "AtaDropColumns",
|
|
"AtaAddTableConstraint", "AtaSetColumnDefault", "AtaDropColumnDefault", "AtaDropTableConstraint",
|
|
"AtaRenameTable", "AtaModifyColumnType", "AtaRenameColumn", "AtaTableComment"};
|
|
/** @brief Datatype Length list
|
|
*
|
|
*/
|
|
const int DDLDatatypeLength[] = {
|
|
1, // BIT
|
|
1, // TINYINT
|
|
1, // CHAR
|
|
2, // SMALLINT
|
|
2, // DECIMAL
|
|
4, // MEDINT
|
|
4, // INT
|
|
4, // FLOAT
|
|
4, // DATE
|
|
8, // BIGINT
|
|
8, // DOUBLE
|
|
8, // DATETIME
|
|
8, // VARCHAR
|
|
8, // VARBINAR
|
|
8, // CLOB
|
|
8, // BLOB
|
|
4, // REAL
|
|
2, // NUMERIC
|
|
4, // NUMBER
|
|
4, // INTEGER
|
|
1, // UNSIGNED_TINYINT,
|
|
2, // UNSIGNED_SMALLINT,
|
|
4, // UNSIGNED_MEDINT,
|
|
4, // UNSIGNED_INT,
|
|
8, // UNSIGNED_BIGINT,
|
|
2, // UNSIGNED_DECIMAL,
|
|
4, // UNSIGNED_FLOAT,
|
|
8, // UNSIGNED_DOUBLE,
|
|
2, // UNSIGNED_NUMERIC,
|
|
8, // TEXT
|
|
8, // TIME
|
|
8, // TIMESTAMP
|
|
-1 // INVALID LENGTH
|
|
};
|
|
|
|
enum DDL_SERIAL_TYPE
|
|
{
|
|
DDL_TABLE_DEF,
|
|
DDL_COLUMN_DEF,
|
|
DDL_COLUMN_CONSTRAINT_DEF,
|
|
DDL_TABLE_CONSTRAINT_DEF,
|
|
DDL_SQL_STATEMENT_LIST,
|
|
DDL_CREATE_TABLE_STATEMENT,
|
|
DDL_CREATE_INDEX,
|
|
DDL_ALTER_TABLE_STATEMENT,
|
|
DDL_ATA_ADD_COLUMN,
|
|
DDL_ATA_ADD_COLUMNS,
|
|
DDL_ATA_DROP_COLUMN,
|
|
DDL_ATA_ADD_TABLE_CONSTRAINT,
|
|
DDL_ATA_SET_COLUMN_DEFAULT,
|
|
DDL_ATA_DROP_COLUMN_DEFAULT,
|
|
DDL_ATA_DROP_TABLE_CONSTRAINT,
|
|
DDL_ATA_RENAME_TABLE,
|
|
DDL_ATA_RENAME_COLUMN,
|
|
DDL_ATA_MODIFY_COLUMN_TYPE,
|
|
DDL_ATA_TABLE_COMMENT,
|
|
DDL_COLUMN_TYPE,
|
|
DDL_COLUMN_DEFAULT_VALUE,
|
|
DDL_TABLE_UNIQUE_CONSTRAINT_DEF,
|
|
DDL_TABLE_PRIMARY_CONSTRAINT_DEF,
|
|
DDL_REF_ACTION,
|
|
DDL_TABLE_REFERENCES_CONSTRAINT_DEF,
|
|
DDL_TABLE_CHECK_CONSTRAINT_DEF,
|
|
DDL_QUALIFIED_NAME,
|
|
DDL_CONSTRAINT_ATTRIBUTES_DEF,
|
|
DDL_DROP_INDEX_STATEMENT,
|
|
DDL_DROP_TABLE_STATEMENT,
|
|
DDL_ATA_DROP_COLUMNS,
|
|
DDL_NULL,
|
|
DDL_INVALID_SERIAL_TYPE,
|
|
DDL_TRUNC_TABLE_STATEMENT,
|
|
DDL_MARK_PARTITION_STATEMENT,
|
|
DDL_RESTORE_PARTITION_STATEMENT,
|
|
DDL_DROP_PARTITION_STATEMENT
|
|
};
|
|
|
|
/** @brief An abstract base for TableDef, ColumnDef, ...
|
|
*
|
|
* The primary purpose of this class is to provide a unified type
|
|
* for things that can appear together in syntactic elements. For
|
|
* example, column definitions and table constraints can appear
|
|
* together in the table_element_list of a create table statement.
|
|
* We need a base class so that we can return different concrete
|
|
* types as the semantic value of bison rules, while having a
|
|
* single, more abstract type to report to bison as the type of
|
|
* the semantic value.
|
|
*/
|
|
struct SchemaObject
|
|
{
|
|
virtual ~SchemaObject()
|
|
{
|
|
}
|
|
|
|
SchemaObject(std::string name) : fName(name)
|
|
{
|
|
}
|
|
|
|
SchemaObject() : fName("unnamed")
|
|
{
|
|
}
|
|
|
|
std::string fName;
|
|
};
|
|
|
|
/** @brief SqlStatement represents a toplevel
|
|
* syntactic element such as a create table or alter table SQL
|
|
* statement.
|
|
*
|
|
* SqlStatements are containers for the various structures
|
|
* manufactured by the parsing process for a single SQL
|
|
* statement.
|
|
*/
|
|
struct SqlStatement
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs) = 0;
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs) = 0;
|
|
|
|
/** @brief Dump to stdout. */
|
|
virtual std::ostream& put(std::ostream& os) const = 0;
|
|
|
|
EXPORT SqlStatement();
|
|
|
|
EXPORT virtual ~SqlStatement();
|
|
|
|
/** @brief The session ID assigned to this stmt by the front end (in theory)
|
|
*
|
|
* XXXPAT: need to fix this. It should be type execplan::SessionManager::SID, but
|
|
* that causes a circular dependency in the header files. Should unravel that at
|
|
* some point.
|
|
*
|
|
* Right now this var is initialized from a counter. At some point we need
|
|
* to serialize/unserialize it from a byte stream.
|
|
*/
|
|
uint32_t fSessionID;
|
|
|
|
/** @brief The original sql string
|
|
*/
|
|
std::string fSql;
|
|
|
|
/** @brief the default schema (owner that will be used when not specified)
|
|
*/
|
|
std::string fOwner;
|
|
|
|
uint32_t fTableWithAutoi; // has autoincrement column?
|
|
};
|
|
|
|
/** @brief Collects SqlStatements so that we can support the
|
|
* parsing of sqltext containing multiple statements.
|
|
*
|
|
* The SqlParser also accepts empty statements (a mixture of
|
|
* whitespace and semicolons) in which case the result can be a
|
|
* SqlStatementList of zero items.
|
|
*/
|
|
struct SqlStatementList
|
|
{
|
|
SqlStatementList()
|
|
{
|
|
}
|
|
|
|
SqlStatement* operator[](int i) const
|
|
{
|
|
return fList[i];
|
|
}
|
|
|
|
virtual ~SqlStatementList();
|
|
|
|
/** @brief Add a statement to the underlying container. */
|
|
void push_back(SqlStatement* v);
|
|
|
|
std::vector<SqlStatement*> fList;
|
|
std::string fSqlText;
|
|
|
|
private:
|
|
SqlStatementList(const SqlStatementList& x);
|
|
};
|
|
|
|
/** @brief Stores catalog, schema, object names.
|
|
*
|
|
* ddl.y does not yet support catalog. So, expect catalog
|
|
* qualified names to fail parsing for the moment.
|
|
*/
|
|
struct QualifiedName
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
EXPORT virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
EXPORT virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
QualifiedName()
|
|
{
|
|
}
|
|
|
|
EXPORT QualifiedName(const char* name);
|
|
EXPORT QualifiedName(const char* name, const char* schema);
|
|
EXPORT QualifiedName(const char* name, const char* schema, const char* catalog);
|
|
|
|
virtual ~QualifiedName()
|
|
{
|
|
}
|
|
|
|
std::string fCatalog;
|
|
std::string fName;
|
|
std::string fSchema;
|
|
};
|
|
|
|
/** TableDef represents a table definition.
|
|
*/
|
|
struct TableDef : public SchemaObject
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
EXPORT virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
EXPORT virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
TableDef() : fQualifiedName(0)
|
|
{
|
|
}
|
|
|
|
EXPORT TableDef(QualifiedName* name, TableElementList* elements, TableOptionMap* options);
|
|
|
|
/** @brief TableDef ctor.
|
|
* ctor
|
|
*/
|
|
TableDef(QualifiedName* name, ColumnDefList columns, TableConstraintDefList constraints,
|
|
int tableWithAutoinc)
|
|
: fQualifiedName(name), fColumns(columns), fConstraints(constraints)
|
|
|
|
{
|
|
}
|
|
|
|
EXPORT virtual ~TableDef();
|
|
|
|
QualifiedName* fQualifiedName;
|
|
|
|
ColumnDefList fColumns;
|
|
TableConstraintDefList fConstraints;
|
|
|
|
TableOptionMap fOptions;
|
|
};
|
|
|
|
/** @brief Represents the create table statement
|
|
*
|
|
* @note It takes possession of the TableDef given to it.
|
|
*/
|
|
struct CreateTableStatement : public SqlStatement
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
EXPORT virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
EXPORT virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Ctor for deserialization */
|
|
EXPORT CreateTableStatement();
|
|
|
|
/** @brief You can't have a CreateTableStatement without a
|
|
table defintion */
|
|
EXPORT CreateTableStatement(TableDef* tableDef);
|
|
|
|
EXPORT virtual ~CreateTableStatement();
|
|
|
|
/** @brief Dump to stdout. */
|
|
EXPORT virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
std::string schemaName() const
|
|
{
|
|
if (!fTableDef || !fTableDef->fQualifiedName)
|
|
return "UNKNOWN";
|
|
|
|
return fTableDef->fQualifiedName->fSchema;
|
|
}
|
|
|
|
TableDef* fTableDef; ///< The table defintion.
|
|
};
|
|
|
|
/**
|
|
* @brief The subforms of alter table are represented as
|
|
* subclasses of AlterTableAction
|
|
*
|
|
* SQL-92 specifies that an alter_table_statement has exactly one
|
|
* alter_table_action. But many vendors support aggregating
|
|
* alter_table_actions under one alter_table_statement. We
|
|
* support that. The subforms of alter table are represented as
|
|
* subclasses of AlterTableAction, all of which are named
|
|
* according to the convention AtaFoo, where Ata stands for
|
|
* AlterTableAction.
|
|
*/
|
|
struct AlterTableAction
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
EXPORT virtual int unserialize(messageqcpp::ByteStream& bs) = 0;
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
EXPORT virtual int serialize(messageqcpp::ByteStream& bs) = 0;
|
|
|
|
/** @brief Ctor for deserialization */
|
|
AlterTableAction()
|
|
{
|
|
}
|
|
|
|
virtual ~AlterTableAction()
|
|
{
|
|
}
|
|
|
|
/** @brief QualifiedName of the focal table for this
|
|
statement. */
|
|
// QualifiedName *fTableName;
|
|
|
|
/** @brief Dump to stdout. */
|
|
EXPORT virtual std::ostream& put(std::ostream& os) const;
|
|
};
|
|
|
|
/** @brief Represents alter table add column forms.
|
|
*/
|
|
struct AtaAddColumn : public AlterTableAction
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Ctor for deserialization */
|
|
AtaAddColumn() : fColumnDef(0)
|
|
{
|
|
}
|
|
|
|
/** @brief You can't add a column without specifying a column
|
|
definition. */
|
|
AtaAddColumn(ColumnDef* columnDef);
|
|
|
|
virtual ~AtaAddColumn();
|
|
|
|
/** @brief Dump to stdout. */
|
|
virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
/** @brief The focal column definition. */
|
|
ColumnDef* fColumnDef;
|
|
};
|
|
|
|
/** @brief Represents the table_element_list style of add column
|
|
which is not part of SQL-92.
|
|
*/
|
|
struct AtaAddColumns : public AlterTableAction
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Ctor for deserialization */
|
|
AtaAddColumns()
|
|
{
|
|
}
|
|
|
|
AtaAddColumns(TableElementList* tableElements);
|
|
|
|
virtual ~AtaAddColumns();
|
|
|
|
/** @brief Dump to stdout. */
|
|
virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
ColumnDefList fColumns;
|
|
};
|
|
|
|
/** @brief Represents the table_element_list style of drop column
|
|
which is not part of SQL-92.
|
|
*/
|
|
struct AtaDropColumns : public AlterTableAction
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
EXPORT virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
EXPORT virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Ctor for deserialization */
|
|
AtaDropColumns()
|
|
{
|
|
}
|
|
|
|
EXPORT AtaDropColumns(ColumnNameList* tableElements);
|
|
|
|
EXPORT virtual ~AtaDropColumns();
|
|
|
|
/** @brief Dump to stdout. */
|
|
EXPORT virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
ColumnNameList fColumns;
|
|
};
|
|
|
|
/** AtaAddTableConstraint
|
|
*/
|
|
struct AtaAddTableConstraint : public AlterTableAction
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Ctor for deserialization */
|
|
AtaAddTableConstraint() : fTableConstraint(0)
|
|
{
|
|
}
|
|
|
|
AtaAddTableConstraint(TableConstraintDef* tableConstraint);
|
|
|
|
virtual ~AtaAddTableConstraint();
|
|
|
|
/** @brief Dump to stdout. */
|
|
virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
TableConstraintDef* fTableConstraint;
|
|
};
|
|
|
|
/** @brief alter table drop column.
|
|
*/
|
|
struct AtaDropColumn : public AlterTableAction
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
EXPORT virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
EXPORT virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Ctor for deserialization */
|
|
AtaDropColumn()
|
|
{
|
|
}
|
|
|
|
/** @brief Ctor for parser construction */
|
|
EXPORT AtaDropColumn(std::string columnName, DDL_REFERENTIAL_ACTION dropBehavior);
|
|
|
|
/** @brief Dump to stdout. */
|
|
EXPORT virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~AtaDropColumn()
|
|
{
|
|
}
|
|
std::string fColumnName;
|
|
DDL_REFERENTIAL_ACTION fDropBehavior;
|
|
};
|
|
|
|
/** @brief alter table set column default */
|
|
|
|
struct AtaSetColumnDefault : AlterTableAction
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
AtaSetColumnDefault() : fDefaultValue(0)
|
|
{
|
|
}
|
|
|
|
/** @brief Dump to stdout. */
|
|
virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~AtaSetColumnDefault();
|
|
|
|
AtaSetColumnDefault(const char* colName, ColumnDefaultValue* defaultValue);
|
|
|
|
std::string fColumnName;
|
|
ColumnDefaultValue* fDefaultValue;
|
|
};
|
|
|
|
/** @brief alter table drop column default. */
|
|
struct AtaDropColumnDefault : AlterTableAction
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Ctor for deserialization */
|
|
AtaDropColumnDefault()
|
|
{
|
|
}
|
|
|
|
/** @brief Dump to stdout. */
|
|
virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~AtaDropColumnDefault()
|
|
{
|
|
}
|
|
|
|
/** @brief Ctor for parser construction */
|
|
AtaDropColumnDefault(const char* colName);
|
|
|
|
std::string fColumnName;
|
|
};
|
|
|
|
/** @brief alter table drop table constraint. */
|
|
struct AtaDropTableConstraint : AlterTableAction
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Ctor for deserialization */
|
|
AtaDropTableConstraint()
|
|
{
|
|
}
|
|
|
|
/** @brief Dump to stdout. */
|
|
virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~AtaDropTableConstraint()
|
|
{
|
|
}
|
|
|
|
AtaDropTableConstraint(const char* constraintName, DDL_REFERENTIAL_ACTION dropBehavior);
|
|
|
|
std::string fConstraintName;
|
|
DDL_REFERENTIAL_ACTION fDropBehavior;
|
|
};
|
|
|
|
/** alter table rename */
|
|
struct AtaRenameTable : public AlterTableAction
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Ctor for deserialization */
|
|
AtaRenameTable() : fQualifiedName(0)
|
|
{
|
|
}
|
|
AtaRenameTable(QualifiedName* qualifiedName);
|
|
|
|
/** @brief Dump to stdout. */
|
|
std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~AtaRenameTable();
|
|
|
|
QualifiedName* fQualifiedName;
|
|
};
|
|
|
|
/** alter table comment */
|
|
struct AtaTableComment : public AlterTableAction
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Ctor for deserialization */
|
|
AtaTableComment() : fTableComment("")
|
|
{
|
|
}
|
|
AtaTableComment(const char* tableComment);
|
|
|
|
/** @brief Dump to stdout. */
|
|
std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~AtaTableComment();
|
|
|
|
std::string fTableComment;
|
|
};
|
|
|
|
/** @brief alter table modify column */
|
|
struct AtaModifyColumnType : public AlterTableAction
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Ctor for deserialization */
|
|
AtaModifyColumnType() : fColumnType(0)
|
|
{
|
|
}
|
|
|
|
/** @brief Ctor for parser construction */
|
|
AtaModifyColumnType(const char* name, ColumnType* columnType) : fColumnType(columnType), fName(name)
|
|
{
|
|
}
|
|
|
|
AtaModifyColumnType(QualifiedName* qualifiedName);
|
|
|
|
/** @brief Dump to stdout. */
|
|
std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~AtaModifyColumnType();
|
|
|
|
ColumnType* fColumnType;
|
|
|
|
std::string fName;
|
|
};
|
|
|
|
/** @brief alter table rename column */
|
|
struct AtaRenameColumn : public AlterTableAction
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Ctor for deserialization */
|
|
AtaRenameColumn() : fNewType(0), fDefaultValue(0)
|
|
{
|
|
}
|
|
|
|
AtaRenameColumn(const char* name, const char* newName, ColumnType* newType, const char* comment = NULL)
|
|
: fName(name), fNewName(newName), fNewType(newType)
|
|
{
|
|
if (comment)
|
|
fComment = comment;
|
|
|
|
fDefaultValue = 0;
|
|
}
|
|
|
|
AtaRenameColumn(const char* name, const char* newName, ColumnType* newType,
|
|
ColumnConstraintList* constraint_list, ColumnDefaultValue* defaultValue,
|
|
const char* comment = NULL)
|
|
: fName(name), fNewName(newName), fNewType(newType), fDefaultValue(defaultValue)
|
|
{
|
|
if (constraint_list)
|
|
fConstraints = *constraint_list;
|
|
|
|
// if (defaultValue)
|
|
//{
|
|
// fDefaultValue = defaultValue;
|
|
//}
|
|
|
|
if (comment)
|
|
fComment = comment;
|
|
}
|
|
|
|
AtaRenameColumn(QualifiedName* qualifiedName);
|
|
|
|
/** @brief Dump to stdout. */
|
|
std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~AtaRenameColumn();
|
|
|
|
std::string fName; ///< current column name
|
|
std::string fNewName; ///< new column name
|
|
ColumnType* fNewType;
|
|
/** @brief Zero or more constraints. */
|
|
ColumnConstraintList fConstraints;
|
|
|
|
/** @brief NULL if there was no DEFAULT clause */
|
|
ColumnDefaultValue* fDefaultValue;
|
|
std::string fComment;
|
|
};
|
|
|
|
/** @brief Stores the type information for a column. */
|
|
|
|
struct ColumnType
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
EXPORT virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
EXPORT virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief For deserialization. */
|
|
ColumnType() : fCharset(NULL), fExplicitLength(false)
|
|
{
|
|
}
|
|
|
|
friend std::ostream& operator<<(std::ostream& os, const ColumnType& ac);
|
|
|
|
/** @brief This constructor is used by the parser to construct the
|
|
ColumnType when a precision/scale clause is encountered. */
|
|
|
|
EXPORT ColumnType(int prec, int scale);
|
|
|
|
/** @brief Used in cases where we don't need to create an
|
|
object until we have seen all it's parts. */
|
|
|
|
EXPORT ColumnType(int type);
|
|
|
|
virtual ~ColumnType()
|
|
{
|
|
}
|
|
|
|
/** @brief Type code from DDL_DATATYPES */
|
|
int fType;
|
|
|
|
/** @brief Length of datatype in bytes */
|
|
long fLength;
|
|
|
|
/** @brief SQL precision. This is the number of digits in the representation. */
|
|
int fPrecision;
|
|
|
|
/** @brief SQL scale. This is is the number of digits to the
|
|
right of the decimal point. */
|
|
int fScale;
|
|
|
|
/** @brief SQL "with timezone" specifier */
|
|
bool fWithTimezone;
|
|
|
|
int fCompressiontype;
|
|
|
|
std::string fAutoincrement;
|
|
|
|
uint64_t fNextvalue;
|
|
|
|
/** @brief Column charset (CHAR, VARCHAR and TEXT only) */
|
|
const char* fCharset;
|
|
|
|
/** @brief Is the TEXT column has explicit defined length, ie TEXT(1717) */
|
|
bool fExplicitLength;
|
|
};
|
|
|
|
/** @brief A column constraint definition.
|
|
*
|
|
* Since we aren't supporting references constraint specifications
|
|
* for columns, it seemed simpler to use a single column
|
|
* constraint class instead of articulating the varieties among
|
|
* several classes like we do with table constraints.
|
|
*/
|
|
struct ColumnConstraintDef : public SchemaObject
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
EXPORT virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
EXPORT virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
ColumnConstraintDef()
|
|
{
|
|
}
|
|
|
|
/** @brief Constructs as check constraint. */
|
|
EXPORT ColumnConstraintDef(const char* check);
|
|
|
|
/** @brief Constructs as other constraint. */
|
|
EXPORT ColumnConstraintDef(DDL_CONSTRAINTS type);
|
|
|
|
virtual ~ColumnConstraintDef()
|
|
{
|
|
}
|
|
|
|
/** @brief Whether deferrable. */
|
|
bool fDeferrable;
|
|
|
|
/** @brief Immediate or defferred */
|
|
DDL_CONSTRAINT_ATTRIBUTES fCheckTime;
|
|
|
|
/** @brief Distinguish kinds of constraints */
|
|
DDL_CONSTRAINTS fConstraintType;
|
|
|
|
/** @brief Stores foo from check(foo) */
|
|
std::string fCheck;
|
|
};
|
|
|
|
/** @brief Represents a columns default value. */
|
|
struct ColumnDefaultValue
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
ColumnDefaultValue()
|
|
{
|
|
}
|
|
|
|
ColumnDefaultValue(const char* value);
|
|
|
|
virtual ~ColumnDefaultValue()
|
|
{
|
|
}
|
|
|
|
/** @brief Is NULL the default value? */
|
|
bool fNull;
|
|
|
|
/** @brief Specified default value as a string. */
|
|
std::string fValue;
|
|
};
|
|
|
|
/** @brief Represents a column definition. */
|
|
|
|
struct ColumnDef : public SchemaObject
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
EXPORT virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
EXPORT virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief For deserialization. */
|
|
ColumnDef() : fType(0)
|
|
{
|
|
}
|
|
|
|
EXPORT virtual ~ColumnDef();
|
|
|
|
/** @brief Parser ctor. */
|
|
EXPORT ColumnDef(const char* name, ColumnType* type, ColumnConstraintList* constraint_list,
|
|
ColumnDefaultValue* defaultValue, const char* comment = NULL);
|
|
|
|
/** @brief ColumnDef ctor.
|
|
* ctor */
|
|
ColumnDef(const char* name, ColumnType* type, ColumnConstraintList constraints,
|
|
ColumnDefaultValue* defaultValue = NULL, const char* comment = NULL)
|
|
: SchemaObject(name), fType(type), fConstraints(constraints), fDefaultValue(defaultValue)
|
|
{
|
|
}
|
|
|
|
void convertDecimal();
|
|
|
|
/** @brief Never NULL since all Columns must have a type. */
|
|
ColumnType* fType;
|
|
|
|
/** @brief Zero or more constraints. */
|
|
ColumnConstraintList fConstraints;
|
|
|
|
/** @brief NULL if there was no DEFAULT clause */
|
|
ColumnDefaultValue* fDefaultValue;
|
|
|
|
std::string fComment;
|
|
};
|
|
|
|
/** @brief Abstract base for table constraint definitions. */
|
|
|
|
struct TableConstraintDef : public SchemaObject
|
|
{
|
|
/** @brief Return DDL_SERIAL code */
|
|
virtual DDL_SERIAL_TYPE getSerialType() = 0;
|
|
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs) = 0;
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs) = 0;
|
|
|
|
TableConstraintDef();
|
|
|
|
TableConstraintDef(DDL_CONSTRAINTS cType);
|
|
|
|
/** @brief Dump to stdout. */
|
|
virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~TableConstraintDef()
|
|
{
|
|
}
|
|
// std::string fName;
|
|
DDL_CONSTRAINTS fConstraintType;
|
|
};
|
|
|
|
/** @brief Unique table constraint. */
|
|
|
|
struct TableUniqueConstraintDef : public TableConstraintDef
|
|
{
|
|
/** @brief Return DDL_SERIAL code */
|
|
virtual DDL_SERIAL_TYPE getSerialType()
|
|
{
|
|
return DDL_TABLE_UNIQUE_CONSTRAINT_DEF;
|
|
}
|
|
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
TableUniqueConstraintDef() : TableConstraintDef(DDL_UNIQUE)
|
|
{
|
|
}
|
|
|
|
TableUniqueConstraintDef(ColumnNameList* columns);
|
|
virtual ~TableUniqueConstraintDef()
|
|
{
|
|
}
|
|
|
|
/** @brief Dump to stdout. */
|
|
virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
ColumnNameList fColumnNameList;
|
|
};
|
|
|
|
/** @brief Primary key table constraint.
|
|
*/
|
|
struct TablePrimaryKeyConstraintDef : public TableConstraintDef
|
|
{
|
|
/** @brief Return DDL_SERIAL code */
|
|
virtual DDL_SERIAL_TYPE getSerialType()
|
|
{
|
|
return DDL_TABLE_PRIMARY_CONSTRAINT_DEF;
|
|
}
|
|
|
|
/** @brief Deserialize from ByteStream */
|
|
EXPORT virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
EXPORT virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
TablePrimaryKeyConstraintDef() : TableConstraintDef(DDL_PRIMARY_KEY)
|
|
{
|
|
}
|
|
|
|
EXPORT TablePrimaryKeyConstraintDef(ColumnNameList* columns);
|
|
|
|
virtual ~TablePrimaryKeyConstraintDef()
|
|
{
|
|
}
|
|
|
|
/** @brief Dump to stdout. */
|
|
EXPORT virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
ColumnNameList fColumnNameList;
|
|
};
|
|
|
|
/** @brief ReferentialAction specifies what to do about table
|
|
relationships when elements are updated and deleted.
|
|
*/
|
|
struct ReferentialAction
|
|
{
|
|
virtual ~ReferentialAction()
|
|
{
|
|
}
|
|
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
DDL_REFERENTIAL_ACTION fOnUpdate;
|
|
DDL_REFERENTIAL_ACTION fOnDelete;
|
|
};
|
|
|
|
/** @brief TableReferencesConstraintDef represents a foreign key constraint.
|
|
*/
|
|
struct TableReferencesConstraintDef : public TableConstraintDef
|
|
{
|
|
/** @brief Return DDL_SERIAL code */
|
|
virtual DDL_SERIAL_TYPE getSerialType()
|
|
{
|
|
return DDL_TABLE_REFERENCES_CONSTRAINT_DEF;
|
|
}
|
|
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
TableReferencesConstraintDef() : TableConstraintDef(DDL_REFERENCES), fTableName(0), fRefAction(0)
|
|
{
|
|
}
|
|
|
|
TableReferencesConstraintDef(ColumnNameList* columns, QualifiedName* fTableName,
|
|
ColumnNameList* foreignColumns, DDL_MATCH_TYPE matchType,
|
|
ReferentialAction* refAction);
|
|
|
|
virtual ~TableReferencesConstraintDef();
|
|
|
|
/** @brief Dump to stdout. */
|
|
virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
ColumnNameList fColumns;
|
|
QualifiedName* fTableName;
|
|
ColumnNameList fForeignColumns;
|
|
DDL_MATCH_TYPE fMatchType;
|
|
ReferentialAction* fRefAction;
|
|
};
|
|
|
|
/** @brief Table check constraint.
|
|
*/
|
|
struct TableCheckConstraintDef : public TableConstraintDef
|
|
{
|
|
/** @brief Return DDL_SERIAL code */
|
|
virtual DDL_SERIAL_TYPE getSerialType()
|
|
{
|
|
return DDL_TABLE_CHECK_CONSTRAINT_DEF;
|
|
}
|
|
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
TableCheckConstraintDef() : TableConstraintDef(DDL_CHECK)
|
|
{
|
|
}
|
|
|
|
TableCheckConstraintDef(const char* check);
|
|
|
|
/** @brief Dump to stdout. */
|
|
virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~TableCheckConstraintDef()
|
|
{
|
|
}
|
|
std::string fCheck;
|
|
};
|
|
|
|
/** @brief Represents the alter table command.
|
|
*
|
|
* All forms of alter_table_statements are represented as
|
|
* subclasses of this.
|
|
*/
|
|
|
|
struct AlterTableStatement : public SqlStatement
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
EXPORT virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
EXPORT virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
AlterTableStatement() : fTableName(0)
|
|
{
|
|
}
|
|
|
|
EXPORT AlterTableStatement(QualifiedName* qName, AlterTableActionList* ataList);
|
|
|
|
/** @brief Dump to stdout. */
|
|
EXPORT virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
/** @brief Delete members. */
|
|
EXPORT virtual ~AlterTableStatement();
|
|
|
|
std::string schemaName() const
|
|
{
|
|
if (!fTableName)
|
|
return "UNKNOWN";
|
|
|
|
return fTableName->fSchema;
|
|
}
|
|
|
|
long getTimeZone() const
|
|
{
|
|
return fTimeZone;
|
|
}
|
|
void setTimeZone(long timeZone)
|
|
{
|
|
fTimeZone = timeZone;
|
|
}
|
|
|
|
QualifiedName* fTableName;
|
|
AlterTableActionList fActions;
|
|
private:
|
|
long fTimeZone;
|
|
public:
|
|
};
|
|
|
|
/** @brief This is used during parsing when constraint attributes
|
|
are recognized. This is always before the parent column def
|
|
is recognized. That's why we need a separate structure during
|
|
parsing. When the column def is recognized, we'll just copy
|
|
these into the Column structure.
|
|
*/
|
|
struct ConstraintAttributes
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
ConstraintAttributes()
|
|
{
|
|
}
|
|
|
|
ConstraintAttributes(DDL_CONSTRAINT_ATTRIBUTES checkTime, bool deferrable)
|
|
: fCheckTime(checkTime), fDeferrable(deferrable)
|
|
{
|
|
}
|
|
|
|
virtual ~ConstraintAttributes()
|
|
{
|
|
}
|
|
|
|
DDL_CONSTRAINT_ATTRIBUTES fCheckTime;
|
|
bool fDeferrable;
|
|
};
|
|
|
|
/** @brief CreateIndex represents the CreateIndex operation.
|
|
*
|
|
* @note This currently takes ownership of the objects assigned to
|
|
* fIndexName & fTableName.
|
|
*/
|
|
struct CreateIndexStatement : public SqlStatement
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
CreateIndexStatement();
|
|
CreateIndexStatement(QualifiedName* qualifiedName1, QualifiedName* qualifiedName2,
|
|
ColumnNameList* columnNames, bool unique);
|
|
|
|
/** @brief Dump to stdout. */
|
|
std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~CreateIndexStatement();
|
|
|
|
QualifiedName* fIndexName;
|
|
QualifiedName* fTableName;
|
|
ColumnNameList fColumnNames;
|
|
bool fUnique;
|
|
};
|
|
|
|
/** @brief DropIndexStatement represents the drop index operation. */
|
|
|
|
struct DropIndexStatement : public SqlStatement
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
DropIndexStatement() : fIndexName(0)
|
|
{
|
|
}
|
|
DropIndexStatement(QualifiedName* qualifiedName);
|
|
|
|
/** @brief Dump to stdout. */
|
|
std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~DropIndexStatement();
|
|
|
|
QualifiedName* fIndexName;
|
|
};
|
|
|
|
/** @brief DropTableStatement represents the drop table operation
|
|
*/
|
|
struct DropTableStatement : public SqlStatement
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
EXPORT virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
EXPORT virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
DropTableStatement() : fTableName(0)
|
|
{
|
|
}
|
|
EXPORT DropTableStatement(QualifiedName* qualifiedName, bool cascade);
|
|
|
|
/** @brief Dump to stdout. */
|
|
EXPORT std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~DropTableStatement()
|
|
{
|
|
delete fTableName;
|
|
}
|
|
|
|
std::string schemaName() const
|
|
{
|
|
if (!fTableName)
|
|
return "UNKNOWN";
|
|
|
|
return fTableName->fSchema;
|
|
}
|
|
|
|
QualifiedName* fTableName;
|
|
bool fCascade;
|
|
};
|
|
|
|
/** @brief TruncTableStatement represents the drop table operation
|
|
*/
|
|
struct TruncTableStatement : public SqlStatement
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
EXPORT virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
EXPORT virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
TruncTableStatement() : fTableName(0)
|
|
{
|
|
}
|
|
EXPORT TruncTableStatement(QualifiedName* qualifiedName);
|
|
|
|
/** @brief Dump to stdout. */
|
|
EXPORT std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~TruncTableStatement()
|
|
{
|
|
delete fTableName;
|
|
}
|
|
|
|
std::string schemaName() const
|
|
{
|
|
if (!fTableName)
|
|
return "UNKNOWN";
|
|
|
|
return fTableName->fSchema;
|
|
}
|
|
|
|
QualifiedName* fTableName;
|
|
};
|
|
|
|
/** @brief Represents the mark partition out of service statement
|
|
*
|
|
*/
|
|
struct MarkPartitionStatement : public SqlStatement
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
EXPORT virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
EXPORT virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Ctor for deserialization */
|
|
MarkPartitionStatement() : fTableName(0)
|
|
{
|
|
}
|
|
|
|
/** @brief You can't have a CreateTableStatement without a table defintion */
|
|
EXPORT MarkPartitionStatement(QualifiedName* qualifiedName);
|
|
|
|
/** @brief Dump to stdout. */
|
|
EXPORT virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~MarkPartitionStatement()
|
|
{
|
|
delete fTableName;
|
|
}
|
|
|
|
QualifiedName* fTableName; ///< The table defintion
|
|
std::set<BRM::LogicalPartition> fPartitions; // partition numbers
|
|
};
|
|
|
|
/** @brief Represents the mark partition out of service statement
|
|
*
|
|
*/
|
|
struct RestorePartitionStatement : public SqlStatement
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
EXPORT virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
EXPORT virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Ctor for deserialization */
|
|
RestorePartitionStatement() : fTableName(0)
|
|
{
|
|
}
|
|
|
|
EXPORT RestorePartitionStatement(QualifiedName* qualifiedName);
|
|
|
|
/** @brief Dump to stdout. */
|
|
EXPORT virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~RestorePartitionStatement()
|
|
{
|
|
delete fTableName;
|
|
}
|
|
|
|
QualifiedName* fTableName; ///< The table name.
|
|
std::set<BRM::LogicalPartition> fPartitions; // partition numbers
|
|
};
|
|
|
|
/** @brief Represents the mark partition out of service statement
|
|
*
|
|
*/
|
|
struct DropPartitionStatement : public SqlStatement
|
|
{
|
|
/** @brief Deserialize from ByteStream */
|
|
EXPORT virtual int unserialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Serialize to ByteStream */
|
|
EXPORT virtual int serialize(messageqcpp::ByteStream& bs);
|
|
|
|
/** @brief Ctor for deserialization */
|
|
DropPartitionStatement() : fTableName(0)
|
|
{
|
|
}
|
|
|
|
EXPORT DropPartitionStatement(QualifiedName* qualifiedName);
|
|
|
|
/** @brief Dump to stdout. */
|
|
EXPORT virtual std::ostream& put(std::ostream& os) const;
|
|
|
|
virtual ~DropPartitionStatement()
|
|
{
|
|
delete fTableName;
|
|
}
|
|
|
|
QualifiedName* fTableName; ///< The table name.
|
|
std::set<BRM::LogicalPartition> fPartitions; // partition numbers
|
|
};
|
|
|
|
} // namespace ddlpackage
|
|
|
|
#undef EXPORT
|