koffice/kexi/kexidb/parser/parser.cpp

/* This file is part of the KDE project
   Copyright (C) 2003 Lucijan Busch <lucijan@kde.org>
   Copyright (C) 2004 Jaroslaw Staniek <js@iidea.pl>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/

#include <connection.h>
#include <tableschema.h>
#include "parser.h"
#include "parser_p.h"
#include "sqlparser.h"

extern const char * reserved_keywords[];

using namespace KexiDB;

Parser::Parser(Connection *db)
 : d(new ParserPrivate)
{
	d->db = db;
}

Parser::~Parser()
{
	delete d;
}

Parser::OPCode Parser::operation() const { return (OPCode)d->operation; }

TQString
Parser::operationString() const
{
	switch((OPCode)d->operation) {
		case OP_Error:
			return "Error";
		case OP_CreateTable:
			return "CreateTable";
		case OP_AlterTable:
			return "AlterTable";
		case OP_Select:
			return "Select";
		case OP_Insert:
			return "Insert";
		case OP_Update:
			return "Update";
		case OP_Delete:
			return "Delete";
		default: //OP_None
			return "None";
	}
}

TableSchema *Parser::table() { TableSchema *t = d->table; d->table=0; return t; }

QuerySchema *Parser::query() { QuerySchema *s = d->select; d->select=0; return s; }

Connection *Parser::db() const { return d->db; }

ParserError Parser::error() const { return d->error; }

TQString Parser::statement() const { return d->statement; }

void Parser::setOperation(OPCode op) { d->operation = op; }

QuerySchema *Parser::select() const { return d->select; }

void Parser::setError(const ParserError &err) { d->error = err; }

void
Parser::createTable(const char *t)
{
	if (d->table)
		return;

	d->table = new KexiDB::TableSchema(t);
}

void
Parser::setQuerySchema(QuerySchema *query)
{
	if (d->select)
		delete d->select;

	d->select = query;
}

void Parser::init()
{
	if (d->initialized)
		return;
#define INS(p) d->reservedKeywords.insert(p, (char*)1, 0)
#include "tokens.cpp"
	d->initialized = true;
}

bool Parser::isReservedKeyword(const char *str)
{
	return d->reservedKeywords.find(str);
}

bool
Parser::parse(const TQString &statement)
{
	init();
	clear();
	d->statement = statement;

	KexiDB::Parser *oldParser = parser;
	KexiDB::Field *oldField = field;
	bool res = parseData(this, statement.utf8());
	parser = oldParser;
	field = oldField;
	return res;
}

void
Parser::clear()
{
	d->clear();
}

//-------------------------------------

ParserError::ParserError()
: m_at(-1)
{
//	m_isNull = true;
}

ParserError::ParserError(const TQString &type, const TQString &error, const TQString &hint, int at)
{
	m_type = type;
	m_error = error;
	m_hint = hint;
	m_at = at;
}

ParserError::~ParserError()
{
}