mariadb-columnstore-engine/dbcon/ddlpackage/tabledef.cpp

/* 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: tabledef.cpp 9210 2013-01-21 14:10:42Z rdempsey $
*
*
***********************************************************************/

#include <iostream>
#define DDLPKG_DLLEXPORT
#include "ddlpkg.h"
#undef DDLPKG_DLLEXPORT

namespace ddlpackage
{
using namespace std;


TableDef::~TableDef()
{
    {
        ColumnDefList::iterator itr;

        for (itr = fColumns.begin(); itr != fColumns.end(); itr++)
        {
            delete *itr;
        }
    }
    {
        TableConstraintDefList::iterator itr;

        for (itr = fConstraints.begin(); itr != fConstraints.end(); itr++)
        {
            delete *itr;
        }
    }

    delete fQualifiedName;
}


TableDef::TableDef(QualifiedName* name, TableElementList* elements, TableOptionMap* options) :
    fQualifiedName(name)
{
    if (options)
    {
        fOptions = *options;
        delete options;
    }

    ColumnDef* column;
    TableConstraintDef* constraint;

    /* When parsing, it is necessary to collect ColumnDefs and
       TableConstraintDefs as TableElements.  Here we separate
       them out into separately typed lists.
     */
    TableElementList::iterator itr;

    for (itr = elements->begin(); itr != elements->end(); ++itr)
    {
        column = dynamic_cast<ColumnDef*>(*itr);

        if (column)
        {
            fColumns.push_back(column);
        }
        else
        {
            constraint = dynamic_cast<TableConstraintDef*>(*itr);

            if (constraint)
            {
                fConstraints.push_back(constraint);
            }
        }
    }

    delete elements;
}


/** \brief Put to ostream. */
ostream& operator<<(ostream& os, const TableDef& tableDef)
{
    os << "CreateTable ";

    if (tableDef.fQualifiedName->fSchema != "")
        //cout << tableDef.fQualifiedName->fSchema << ".";
        os << tableDef.fQualifiedName->fName
           << " " << tableDef.fConstraints.size()
           << " table constraints"
           << endl;

    {
        ColumnDefList::const_iterator itr;

        for (itr = tableDef.fColumns.begin();
                itr != tableDef.fColumns.end(); ++itr)
        {
            ColumnDef* col = *itr;
            os << *col << endl;
        }
    }


    {
        TableConstraintDefList::const_iterator itr;

        for (itr = tableDef.fConstraints.begin();
                itr != tableDef.fConstraints.end();
                ++itr)
        {
            os << (**itr);
        }
    }

    pair<string, string> oval;
    TableOptionMap::const_iterator oitr;
    os << "Table Options" << endl;

    if (!tableDef.fOptions.empty())
    {
        TableOptionMap::const_iterator oitr;

        for (oitr = tableDef.fOptions.begin();
                oitr != tableDef.fOptions.end(); ++oitr)
        {
            oval = *oitr;
            os << "   " << oval.first << "=" << oval.second << endl;
        }
    }

    return os;
}




ostream& operator<<(ostream& os, const TableConstraintDef& constraint)
{
    return constraint.put(os);
}

std::ostream& TableConstraintDef::put(std::ostream& os) const
{
    os << "No!!!" << endl;

    return os;
}


TableConstraintDef::TableConstraintDef(DDL_CONSTRAINTS cType) :
    fConstraintType(cType)
{
}

TableConstraintDef::TableConstraintDef() :
    fConstraintType(DDL_INVALID_CONSTRAINT)
{
}

TableCheckConstraintDef::TableCheckConstraintDef(const char* check) :
    TableConstraintDef(DDL_CHECK),
    fCheck(check)
{
}
std::ostream& TableCheckConstraintDef::put(std::ostream& os) const
{
    os << "Constraint: "
       << ConstraintString[fConstraintType] << " ";
    os << "\"" << fCheck << "\"";
    os << endl;

    return os;
}


TableUniqueConstraintDef::TableUniqueConstraintDef(ColumnNameList* columns) :
    TableConstraintDef(DDL_UNIQUE),
    fColumnNameList(*columns)
{
    delete columns;
}
std::ostream& TableUniqueConstraintDef::put(std::ostream& os) const
{
    os << "Constraint: "
       << fName << " "
       << ConstraintString[fConstraintType] << " ";

    ColumnNameList::const_iterator itr;
    os << "(";

    for (itr = fColumnNameList.begin();
            itr != fColumnNameList.end();
            ++itr)
    {
        os << *itr << " ";
    }

    os << ")";
    return os;
}

TablePrimaryKeyConstraintDef::TablePrimaryKeyConstraintDef(ColumnNameList* columns) :
    TableConstraintDef(DDL_PRIMARY_KEY),
    fColumnNameList(*columns)
{
    delete columns;
}
std::ostream& TablePrimaryKeyConstraintDef::put(std::ostream& os) const
{
    os << "Constraint: "
       << fName << " "
       << ConstraintString[fConstraintType] << " ";

    ColumnNameList::const_iterator itr;
    os << "(";

    for (itr = fColumnNameList.begin();
            itr != fColumnNameList.end();
            ++itr)
    {
        os << *itr << " ";
    }

    os << ")";

    return os;
}

TableReferencesConstraintDef::TableReferencesConstraintDef
(ColumnNameList* columns,
 QualifiedName* tableName,
 ColumnNameList* foreignColumns,
 DDL_MATCH_TYPE matchType,
 ReferentialAction* refAction) :
    TableConstraintDef(DDL_REFERENCES),
    fColumns(*columns),
    fTableName(tableName),
    fForeignColumns(*foreignColumns),
    fMatchType(matchType),
    fRefAction(refAction)
{
    delete columns;
    delete foreignColumns;
}
std::ostream& TableReferencesConstraintDef::put(std::ostream& os) const
{
    os << "Constraint: "
       << fName << " "
       << ConstraintString[fConstraintType] << " ";

    ColumnNameList::const_iterator itr;
    os << "lcols (";

    for (itr = fColumns.begin();
            itr != fColumns.end();
            ++itr)
    {
        os << *itr << " ";
    }

    os << ")";

    os << " ftable=" << *fTableName;

    os << " ";

    os << "fcols (";

    for (itr = fForeignColumns.begin();
            itr != fForeignColumns.end();
            ++itr)
    {
        os << *itr << " ";
    }

    os << ")";

    return os;
}
std::ostream& operator<<(std::ostream& os, const ColumnNameList& columnNames)
{
    ColumnNameList::const_iterator itr;
    os << '(';

    for (itr = columnNames.begin();
            itr != columnNames.end();
            ++itr)
    {
        os << *itr << " ";
    }

    os << ')';
    return os;
}


TableReferencesConstraintDef::~TableReferencesConstraintDef()
{
    delete fTableName;
    delete fRefAction;
}

}