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;
	}
	
}