You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1116 lines
36 KiB
1116 lines
36 KiB
/* This file is part of the KDE project
|
|
Copyright (C) 2006-2007 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 "alter.h"
|
|
#include "utils.h"
|
|
#include <kexiutils/utils.h>
|
|
|
|
#include <tqmap.h>
|
|
|
|
#include <kstaticdeleter.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
namespace KexiDB {
|
|
class AlterTableHandler::Private
|
|
{
|
|
public:
|
|
Private()
|
|
{}
|
|
~Private()
|
|
{}
|
|
ActionList actions;
|
|
TQGuardedPtr<Connection> conn;
|
|
};
|
|
}
|
|
|
|
using namespace KexiDB;
|
|
|
|
//! a global instance used to when returning null is needed
|
|
AlterTableHandler::ChangeFieldPropertyAction nullChangeFieldPropertyAction(true);
|
|
AlterTableHandler::RemoveFieldAction nullRemoveFieldAction(true);
|
|
AlterTableHandler::InsertFieldAction nullInsertFieldAction(true);
|
|
AlterTableHandler::MoveFieldPositionAction nullMoveFieldPositionAction(true);
|
|
|
|
//--------------------------------------------------------
|
|
|
|
AlterTableHandler::ActionBase::ActionBase(bool null)
|
|
: m_alteringRequirements(0)
|
|
, m_order(-1)
|
|
, m_null(null)
|
|
{
|
|
}
|
|
|
|
AlterTableHandler::ActionBase::~ActionBase()
|
|
{
|
|
}
|
|
|
|
AlterTableHandler::ChangeFieldPropertyAction& AlterTableHandler::ActionBase::toChangeFieldPropertyAction()
|
|
{
|
|
if (dynamic_cast<ChangeFieldPropertyAction*>(this))
|
|
return *dynamic_cast<ChangeFieldPropertyAction*>(this);
|
|
return nullChangeFieldPropertyAction;
|
|
}
|
|
|
|
AlterTableHandler::RemoveFieldAction& AlterTableHandler::ActionBase::toRemoveFieldAction()
|
|
{
|
|
if (dynamic_cast<RemoveFieldAction*>(this))
|
|
return *dynamic_cast<RemoveFieldAction*>(this);
|
|
return nullRemoveFieldAction;
|
|
}
|
|
|
|
AlterTableHandler::InsertFieldAction& AlterTableHandler::ActionBase::toInsertFieldAction()
|
|
{
|
|
if (dynamic_cast<InsertFieldAction*>(this))
|
|
return *dynamic_cast<InsertFieldAction*>(this);
|
|
return nullInsertFieldAction;
|
|
}
|
|
|
|
AlterTableHandler::MoveFieldPositionAction& AlterTableHandler::ActionBase::toMoveFieldPositionAction()
|
|
{
|
|
if (dynamic_cast<MoveFieldPositionAction*>(this))
|
|
return *dynamic_cast<MoveFieldPositionAction*>(this);
|
|
return nullMoveFieldPositionAction;
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
|
|
AlterTableHandler::FieldActionBase::FieldActionBase(const TQString& fieldName, int uid)
|
|
: ActionBase()
|
|
, m_fieldUID(uid)
|
|
, m_fieldName(fieldName)
|
|
{
|
|
}
|
|
|
|
AlterTableHandler::FieldActionBase::FieldActionBase(bool)
|
|
: ActionBase(true)
|
|
, m_fieldUID(-1)
|
|
{
|
|
}
|
|
|
|
AlterTableHandler::FieldActionBase::~FieldActionBase()
|
|
{
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
|
|
static KStaticDeleter< TQMap<TQCString,int> > KexiDB_alteringTypeForProperty_deleter;
|
|
TQMap<TQCString,int> *KexiDB_alteringTypeForProperty = 0;
|
|
|
|
int AlterTableHandler::alteringTypeForProperty(const TQCString& propertyName)
|
|
{
|
|
if (!KexiDB_alteringTypeForProperty) {
|
|
KexiDB_alteringTypeForProperty_deleter.setObject( KexiDB_alteringTypeForProperty,
|
|
new TQMap<TQCString,int>() );
|
|
#define I(name, type) \
|
|
KexiDB_alteringTypeForProperty->insert(TQCString(name).lower(), (int)AlterTableHandler::type)
|
|
#define I2(name, type1, type2) \
|
|
flag = (int)AlterTableHandler::type1|(int)AlterTableHandler::type2; \
|
|
if (flag & AlterTableHandler::PhysicalAlteringRequired) \
|
|
flag |= AlterTableHandler::MainSchemaAlteringRequired; \
|
|
KexiDB_alteringTypeForProperty->insert(TQCString(name).lower(), flag)
|
|
|
|
/* useful links:
|
|
http://dev.mysql.com/doc/refman/5.0/en/create-table.html
|
|
*/
|
|
// ExtendedSchemaAlteringRequired is here because when the field is renamed,
|
|
// we need to do the same rename in extended table schema: <field name="...">
|
|
int flag;
|
|
I2("name", PhysicalAlteringRequired, MainSchemaAlteringRequired);
|
|
I2("type", PhysicalAlteringRequired, DataConversionRequired);
|
|
I("caption", MainSchemaAlteringRequired);
|
|
I("description", MainSchemaAlteringRequired);
|
|
I2("unsigned", PhysicalAlteringRequired, DataConversionRequired); // always?
|
|
I2("length", PhysicalAlteringRequired, DataConversionRequired); // always?
|
|
I2("precision", PhysicalAlteringRequired, DataConversionRequired); // always?
|
|
I("width", MainSchemaAlteringRequired);
|
|
// defaultValue: depends on backend, for mysql it can only by a constant or now()...
|
|
// -- should we look at Driver here?
|
|
#ifdef KEXI_NO_UNFINISHED
|
|
//! @todo reenable
|
|
I("defaultValue", MainSchemaAlteringRequired);
|
|
#else
|
|
I2("defaultValue", PhysicalAlteringRequired, MainSchemaAlteringRequired);
|
|
#endif
|
|
I2("primaryKey", PhysicalAlteringRequired, DataConversionRequired);
|
|
I2("unique", PhysicalAlteringRequired, DataConversionRequired); // we may want to add an Index here
|
|
I2("notNull", PhysicalAlteringRequired, DataConversionRequired); // we may want to add an Index here
|
|
// allowEmpty: only support it just at kexi level? maybe there is a backend that supports this?
|
|
I2("allowEmpty", PhysicalAlteringRequired, MainSchemaAlteringRequired);
|
|
I2("autoIncrement", PhysicalAlteringRequired, DataConversionRequired); // data conversion may be hard here
|
|
I2("indexed", PhysicalAlteringRequired, DataConversionRequired); // we may want to add an Index here
|
|
|
|
// easier cases follow...
|
|
I("visibleDecimalPlaces", ExtendedSchemaAlteringRequired);
|
|
|
|
// lookup-field-related properties...
|
|
/*moved to KexiDB::isExtendedTableFieldProperty()
|
|
I("boundColumn", ExtendedSchemaAlteringRequired);
|
|
I("rowSource", ExtendedSchemaAlteringRequired);
|
|
I("rowSourceType", ExtendedSchemaAlteringRequired);
|
|
I("rowSourceValues", ExtendedSchemaAlteringRequired);
|
|
I("visibleColumn", ExtendedSchemaAlteringRequired);
|
|
I("columnWidths", ExtendedSchemaAlteringRequired);
|
|
I("showColumnHeaders", ExtendedSchemaAlteringRequired);
|
|
I("listRows", ExtendedSchemaAlteringRequired);
|
|
I("limitToList", ExtendedSchemaAlteringRequired);
|
|
I("displayWidget", ExtendedSchemaAlteringRequired);*/
|
|
|
|
//more to come...
|
|
#undef I
|
|
#undef I2
|
|
}
|
|
const int res = (*KexiDB_alteringTypeForProperty)[propertyName.lower()];
|
|
if (res == 0) {
|
|
if (KexiDB::isExtendedTableFieldProperty(propertyName))
|
|
return (int)ExtendedSchemaAlteringRequired;
|
|
KexiDBWarn << TQString("AlterTableHandler::alteringTypeForProperty(): property \"%1\" not found!")
|
|
.tqarg(propertyName.data()) << endl;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
//---
|
|
|
|
AlterTableHandler::ChangeFieldPropertyAction::ChangeFieldPropertyAction(
|
|
const TQString& fieldName, const TQString& propertyName, const TQVariant& newValue, int uid)
|
|
: FieldActionBase(fieldName, uid)
|
|
, m_propertyName(propertyName)
|
|
, m_newValue(newValue)
|
|
{
|
|
}
|
|
|
|
AlterTableHandler::ChangeFieldPropertyAction::ChangeFieldPropertyAction(bool)
|
|
: FieldActionBase(true)
|
|
{
|
|
}
|
|
|
|
AlterTableHandler::ChangeFieldPropertyAction::~ChangeFieldPropertyAction()
|
|
{
|
|
}
|
|
|
|
void AlterTableHandler::ChangeFieldPropertyAction::updateAlteringRequirements()
|
|
{
|
|
// m_alteringRequirements = ???;
|
|
setAlteringRequirements( alteringTypeForProperty( m_propertyName.latin1() ) );
|
|
}
|
|
|
|
TQString AlterTableHandler::ChangeFieldPropertyAction::debugString(const DebugOptions& debugOptions)
|
|
{
|
|
TQString s = TQString("Set \"%1\" property for table field \"%2\" to \"%3\"")
|
|
.tqarg(m_propertyName).tqarg(fieldName()).tqarg(m_newValue.toString());
|
|
if (debugOptions.showUID)
|
|
s.append(TQString(" (UID=%1)").tqarg(m_fieldUID));
|
|
return s;
|
|
}
|
|
|
|
static AlterTableHandler::ActionDict* createActionDict(
|
|
AlterTableHandler::ActionDictDict &fieldActions, int forFieldUID )
|
|
{
|
|
AlterTableHandler::ActionDict* dict = new AlterTableHandler::ActionDict(101, false);
|
|
dict->setAutoDelete(true);
|
|
fieldActions.insert( forFieldUID, dict );
|
|
return dict;
|
|
}
|
|
|
|
static void debugAction(AlterTableHandler::ActionBase *action, int nestingLevel,
|
|
bool simulate, const TQString& prependString = TQString(), TQString* debugTarget = 0)
|
|
{
|
|
TQString debugString;
|
|
if (!debugTarget)
|
|
debugString = prependString;
|
|
if (action) {
|
|
AlterTableHandler::ActionBase::DebugOptions debugOptions;
|
|
debugOptions.showUID = debugTarget==0;
|
|
debugOptions.showFieldDebug = debugTarget!=0;
|
|
debugString += action->debugString( debugOptions );
|
|
}
|
|
else {
|
|
if (!debugTarget)
|
|
debugString += "[No action]"; //hmm
|
|
}
|
|
if (debugTarget) {
|
|
if (!debugString.isEmpty())
|
|
*debugTarget += debugString + '\n';
|
|
}
|
|
else {
|
|
KexiDBDbg << debugString << endl;
|
|
#ifdef KEXI_DEBUG_GUI
|
|
if (simulate)
|
|
KexiUtils::addAlterTableActionDebug(debugString, nestingLevel);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static void debugActionDict(AlterTableHandler::ActionDict *dict, int fieldUID, bool simulate)
|
|
{
|
|
TQString fieldName;
|
|
AlterTableHandler::ActionDictIterator it(*dict);
|
|
if (dynamic_cast<AlterTableHandler::FieldActionBase*>(it.current())) //retrieve field name from the 1st related action
|
|
fieldName = dynamic_cast<AlterTableHandler::FieldActionBase*>(it.current())->fieldName();
|
|
else
|
|
fieldName = "??";
|
|
TQString dbg = TQString("Action dict for field \"%1\" (%2, UID=%3):")
|
|
.tqarg(fieldName).tqarg(dict->count()).tqarg(fieldUID);
|
|
KexiDBDbg << dbg << endl;
|
|
#ifdef KEXI_DEBUG_GUI
|
|
if (simulate)
|
|
KexiUtils::addAlterTableActionDebug(dbg, 1);
|
|
#endif
|
|
for (;it.current(); ++it) {
|
|
debugAction(it.current(), 2, simulate);
|
|
}
|
|
}
|
|
|
|
static void debugFieldActions(const AlterTableHandler::ActionDictDict &fieldActions, bool simulate)
|
|
{
|
|
#ifdef KEXI_DEBUG_GUI
|
|
if (simulate)
|
|
KexiUtils::addAlterTableActionDebug("** Simplified Field Actions:");
|
|
#endif
|
|
for (AlterTableHandler::ActionDictDictIterator it(fieldActions); it.current(); ++it) {
|
|
debugActionDict(it.current(), it.currentKey(), simulate);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Legend: A,B==fields, P==property, [....]==action, (..,..,..) group of actions, <...> internal operation.
|
|
Case 1. (special)
|
|
when new action=[rename A to B]
|
|
and exists=[rename B to C]
|
|
=>
|
|
remove [rename B to C]
|
|
and set result to new [rename A to C]
|
|
and go to 1b.
|
|
Case 1b. when new action=[rename A to B]
|
|
and actions exist like [set property P to C in field B]
|
|
or like [delete field B]
|
|
or like [move field B]
|
|
=>
|
|
change B to A for all these actions
|
|
Case 2. when new action=[change property in field A] (property != name)
|
|
and exists=[remove A] or exists=[change property in field A]
|
|
=>
|
|
do not add [change property in field A] because it will be removed anyway or the property will change
|
|
*/
|
|
void AlterTableHandler::ChangeFieldPropertyAction::simplifyActions(ActionDictDict &fieldActions)
|
|
{
|
|
ActionDict *actionsLikeThis = fieldActions[ uid() ];
|
|
if (m_propertyName=="name") {
|
|
// Case 1. special: name1 -> name2, i.e. rename action
|
|
TQString newName( newValue().toString() );
|
|
// try to find rename(newName, otherName) action
|
|
ActionBase *renameActionLikeThis = actionsLikeThis ? actionsLikeThis->find( "name" ) : 0;
|
|
if (dynamic_cast<ChangeFieldPropertyAction*>(renameActionLikeThis)) {
|
|
// 1. instead of having rename(fieldName(), newValue()) action,
|
|
// let's have rename(fieldName(), otherName) action
|
|
dynamic_cast<ChangeFieldPropertyAction*>(renameActionLikeThis)->m_newValue
|
|
= dynamic_cast<ChangeFieldPropertyAction*>(renameActionLikeThis)->m_newValue;
|
|
/* AlterTableHandler::ChangeFieldPropertyAction* newRenameAction
|
|
= new AlterTableHandler::ChangeFieldPropertyAction( *this );
|
|
newRenameAction->m_newValue = dynamic_cast<ChangeFieldPropertyAction*>(renameActionLikeThis)->m_newValue;
|
|
// (m_order is the same as in newAction)
|
|
// replace prev. rename action (if any)
|
|
actionsLikeThis->remove( "name" );
|
|
ActionDict *adict = fieldActions[ fieldName().latin1() ];
|
|
if (!adict)
|
|
adict = createActionDict( fieldActions, fieldName() );
|
|
adict->insert(m_propertyName.latin1(), newRenameAction);*/
|
|
}
|
|
else {
|
|
ActionBase *removeActionForThisField = actionsLikeThis ? actionsLikeThis->find( ":remove:" ) : 0;
|
|
if (removeActionForThisField) {
|
|
//if this field is going to be removed, jsut change the action's field name
|
|
// and do not add a new action
|
|
}
|
|
else {
|
|
//just insert a copy of the rename action
|
|
if (!actionsLikeThis)
|
|
actionsLikeThis = createActionDict( fieldActions, uid() ); //fieldName() );
|
|
AlterTableHandler::ChangeFieldPropertyAction* newRenameAction
|
|
= new AlterTableHandler::ChangeFieldPropertyAction( *this );
|
|
KexiDBDbg << "ChangeFieldPropertyAction::simplifyActions(): insert into '"
|
|
<< fieldName() << "' dict:" << newRenameAction->debugString() << endl;
|
|
actionsLikeThis->insert( m_propertyName.latin1(), newRenameAction );
|
|
return;
|
|
}
|
|
}
|
|
if (actionsLikeThis) {
|
|
// Case 1b. change "field name" information to fieldName() in any action that
|
|
// is related to newName
|
|
// e.g. if there is setCaption("B", "captionA") action after rename("A","B"),
|
|
// replace setCaption action with setCaption("A", "captionA")
|
|
foreach_dict (ActionDictIterator, it, *actionsLikeThis) {
|
|
dynamic_cast<FieldActionBase*>(it.current())->setFieldName( fieldName() );
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
ActionBase *removeActionForThisField = actionsLikeThis ? actionsLikeThis->find( ":remove:" ) : 0;
|
|
if (removeActionForThisField) {
|
|
//if this field is going to be removed, do not add a new action
|
|
return;
|
|
}
|
|
// Case 2. other cases: just give up with adding this "intermediate" action
|
|
// so, e.g. [ setCaption(A, "captionA"), setCaption(A, "captionB") ]
|
|
// becomes: [ setCaption(A, "captionB") ]
|
|
// because adding this action does nothing
|
|
ActionDict *nextActionsLikeThis = fieldActions[ uid() ]; //fieldName().latin1() ];
|
|
if (!nextActionsLikeThis || !nextActionsLikeThis->find( m_propertyName.latin1() )) {
|
|
//no such action, add this
|
|
AlterTableHandler::ChangeFieldPropertyAction* newAction
|
|
= new AlterTableHandler::ChangeFieldPropertyAction( *this );
|
|
if (!nextActionsLikeThis)
|
|
nextActionsLikeThis = createActionDict( fieldActions, uid() );//fieldName() );
|
|
nextActionsLikeThis->insert( m_propertyName.latin1(), newAction );
|
|
}
|
|
}
|
|
|
|
bool AlterTableHandler::ChangeFieldPropertyAction::shouldBeRemoved(ActionDictDict &fieldActions)
|
|
{
|
|
Q_UNUSED(fieldActions);
|
|
return fieldName().lower() == m_newValue.toString().lower();
|
|
}
|
|
|
|
tristate AlterTableHandler::ChangeFieldPropertyAction::updateTableSchema(TableSchema &table, Field* field,
|
|
TQMap<TQString, TQString>& fieldMap)
|
|
{
|
|
//1. Simpler cases first: changes that do not affect table schema at all
|
|
// "caption", "description", "width", "visibleDecimalPlaces"
|
|
if (SchemaAlteringRequired & alteringTypeForProperty(m_propertyName.latin1())) {
|
|
bool result = KexiDB::setFieldProperty(*field, m_propertyName.latin1(), newValue());
|
|
return result;
|
|
}
|
|
|
|
if (m_propertyName=="name") {
|
|
if (fieldMap[ field->name() ] == field->name())
|
|
fieldMap.remove( field->name() );
|
|
fieldMap.insert( newValue().toString(), field->name() );
|
|
table.renameField(field, newValue().toString());
|
|
return true;
|
|
}
|
|
return cancelled;
|
|
}
|
|
|
|
/*! Many of the properties must be applied using a separate algorithm.
|
|
*/
|
|
tristate AlterTableHandler::ChangeFieldPropertyAction::execute(Connection &conn, TableSchema &table)
|
|
{
|
|
Q_UNUSED(conn);
|
|
Field *field = table.field( fieldName() );
|
|
if (!field) {
|
|
//! @todo errmsg
|
|
return false;
|
|
}
|
|
bool result;
|
|
//1. Simpler cases first: changes that do not affect table schema at all
|
|
// "caption", "description", "width", "visibleDecimalPlaces"
|
|
if (SchemaAlteringRequired & alteringTypeForProperty(m_propertyName.latin1())) {
|
|
result = KexiDB::setFieldProperty(*field, m_propertyName.latin1(), newValue());
|
|
return result;
|
|
}
|
|
|
|
//todo
|
|
return true;
|
|
|
|
//2. Harder cases, that often require special care
|
|
if (m_propertyName=="name") {
|
|
/*mysql:
|
|
A. Get real field type (it's safer):
|
|
let <TYPE> be the 2nd "Type" column from result of "DESCRIBE tablename oldfieldname"
|
|
( http://dev.mysql.com/doc/refman/5.0/en/describe.html )
|
|
B. Run "ALTER TABLE tablename CHANGE oldfieldname newfieldname <TYPE>";
|
|
( http://dev.mysql.com/doc/refman/5.0/en/alter-table.html )
|
|
*/
|
|
}
|
|
if (m_propertyName=="type") {
|
|
/*mysql:
|
|
A. Like A. for "name" property above
|
|
B. Construct <TYPE> string, eg. "varchar(50)" using the driver
|
|
C. Like B. for "name" property above
|
|
(mysql then truncate the values for changes like varchar -> integer,
|
|
and properly convert the values for changes like integer -> varchar)
|
|
|
|
TODO: more cases to check
|
|
*/
|
|
}
|
|
if (m_propertyName=="length") {
|
|
//use "select max( length(o_name) ) from kexi__Objects"
|
|
|
|
}
|
|
if (m_propertyName=="primaryKey") {
|
|
//! @todo
|
|
}
|
|
|
|
/*
|
|
"name", "unsigned", "precision",
|
|
"defaultValue", "primaryKey", "unique", "notNull", "allowEmpty",
|
|
"autoIncrement", "indexed",
|
|
|
|
|
|
bool result = KexiDB::setFieldProperty(*field, m_propertyName.latin1(), newValue());
|
|
*/
|
|
return result;
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
|
|
AlterTableHandler::RemoveFieldAction::RemoveFieldAction(const TQString& fieldName, int uid)
|
|
: FieldActionBase(fieldName, uid)
|
|
{
|
|
}
|
|
|
|
AlterTableHandler::RemoveFieldAction::RemoveFieldAction(bool)
|
|
: FieldActionBase(true)
|
|
{
|
|
}
|
|
|
|
AlterTableHandler::RemoveFieldAction::~RemoveFieldAction()
|
|
{
|
|
}
|
|
|
|
void AlterTableHandler::RemoveFieldAction::updateAlteringRequirements()
|
|
{
|
|
//! @todo sometimes add DataConversionRequired (e.g. when relationships require removing orphaned records) ?
|
|
|
|
setAlteringRequirements( PhysicalAlteringRequired );
|
|
//! @todo
|
|
}
|
|
|
|
TQString AlterTableHandler::RemoveFieldAction::debugString(const DebugOptions& debugOptions)
|
|
{
|
|
TQString s = TQString("Remove table field \"%1\"").tqarg(fieldName());
|
|
if (debugOptions.showUID)
|
|
s.append(TQString(" (UID=%1)").tqarg(uid()));
|
|
return s;
|
|
}
|
|
|
|
/*!
|
|
Legend: A,B==objects, P==property, [....]==action, (..,..,..) group of actions, <...> internal operation.
|
|
Preconditions: we assume there cannot be such case encountered: ([remove A], [do something related on A])
|
|
(except for [remove A], [insert A])
|
|
General Case: it's safe to always insert a [remove A] action.
|
|
*/
|
|
void AlterTableHandler::RemoveFieldAction::simplifyActions(ActionDictDict &fieldActions)
|
|
{
|
|
//! @todo not checked
|
|
AlterTableHandler::RemoveFieldAction* newAction
|
|
= new AlterTableHandler::RemoveFieldAction( *this );
|
|
ActionDict *actionsLikeThis = fieldActions[ uid() ]; //fieldName().latin1() ];
|
|
if (!actionsLikeThis)
|
|
actionsLikeThis = createActionDict( fieldActions, uid() ); //fieldName() );
|
|
actionsLikeThis->insert( ":remove:", newAction ); //special
|
|
}
|
|
|
|
tristate AlterTableHandler::RemoveFieldAction::updateTableSchema(TableSchema &table, Field* field,
|
|
TQMap<TQString, TQString>& fieldMap)
|
|
{
|
|
fieldMap.remove( field->name() );
|
|
table.removeField(field);
|
|
return true;
|
|
}
|
|
|
|
tristate AlterTableHandler::RemoveFieldAction::execute(Connection& conn, TableSchema& table)
|
|
{
|
|
Q_UNUSED(conn);
|
|
Q_UNUSED(table);
|
|
//! @todo
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
|
|
AlterTableHandler::InsertFieldAction::InsertFieldAction(int fieldIndex, KexiDB::Field *field, int uid)
|
|
: FieldActionBase(field->name(), uid)
|
|
, m_index(fieldIndex)
|
|
, m_field(0)
|
|
{
|
|
Q_ASSERT(field);
|
|
setField(field);
|
|
}
|
|
|
|
AlterTableHandler::InsertFieldAction::InsertFieldAction(const InsertFieldAction& action)
|
|
: FieldActionBase(action) //action.fieldName(), action.uid())
|
|
, m_index(action.index())
|
|
{
|
|
m_field = new KexiDB::Field( action.field() );
|
|
}
|
|
|
|
AlterTableHandler::InsertFieldAction::InsertFieldAction(bool)
|
|
: FieldActionBase(true)
|
|
, m_index(0)
|
|
, m_field(0)
|
|
{
|
|
}
|
|
|
|
AlterTableHandler::InsertFieldAction::~InsertFieldAction()
|
|
{
|
|
delete m_field;
|
|
}
|
|
|
|
void AlterTableHandler::InsertFieldAction::setField(KexiDB::Field* field)
|
|
{
|
|
if (m_field)
|
|
delete m_field;
|
|
m_field = field;
|
|
setFieldName(m_field ? m_field->name() : TQString());
|
|
}
|
|
|
|
void AlterTableHandler::InsertFieldAction::updateAlteringRequirements()
|
|
{
|
|
//! @todo sometimes add DataConversionRequired (e.g. when relationships require removing orphaned records) ?
|
|
|
|
setAlteringRequirements( PhysicalAlteringRequired );
|
|
//! @todo
|
|
}
|
|
|
|
TQString AlterTableHandler::InsertFieldAction::debugString(const DebugOptions& debugOptions)
|
|
{
|
|
TQString s = TQString("Insert table field \"%1\" at position %2")
|
|
.tqarg(m_field->name()).tqarg(m_index);
|
|
if (debugOptions.showUID)
|
|
s.append(TQString(" (UID=%1)").tqarg(m_fieldUID));
|
|
if (debugOptions.showFieldDebug)
|
|
s.append(TQString(" (%1)").tqarg(m_field->debugString()));
|
|
return s;
|
|
}
|
|
|
|
/*!
|
|
Legend: A,B==fields, P==property, [....]==action, (..,..,..) group of actions, <...> internal operation.
|
|
|
|
|
|
Case 1: there are "change property" actions after the Insert action.
|
|
-> change the properties in the Insert action itself and remove the "change property" actions.
|
|
Examples:
|
|
[Insert A] && [rename A to B] => [Insert B]
|
|
[Insert A] && [change property P in field A] => [Insert A with P altered]
|
|
Comment: we need to do this reduction because otherwise we'd need to do psyhical altering
|
|
right after [Insert A] if [rename A to B] follows.
|
|
*/
|
|
void AlterTableHandler::InsertFieldAction::simplifyActions(ActionDictDict &fieldActions)
|
|
{
|
|
// Try to find actions related to this action
|
|
ActionDict *actionsForThisField = fieldActions[ uid() ]; //m_field->name().latin1() ];
|
|
|
|
ActionBase *removeActionForThisField = actionsForThisField ? actionsForThisField->find( ":remove:" ) : 0;
|
|
if (removeActionForThisField) {
|
|
//if this field is going to be removed, do not add a new action
|
|
//and remove the "Remove" action
|
|
actionsForThisField->remove(":remove:");
|
|
return;
|
|
}
|
|
if (actionsForThisField) {
|
|
//collect property values that have to be changed in this field
|
|
TQMap<TQCString, TQVariant> values;
|
|
for (ActionDictIterator it(*actionsForThisField); it.current();) {
|
|
ChangeFieldPropertyAction* changePropertyAction = dynamic_cast<ChangeFieldPropertyAction*>(it.current());
|
|
if (changePropertyAction) {
|
|
//if this field is going to be renamed, also update fieldName()
|
|
if (changePropertyAction->propertyName()=="name") {
|
|
setFieldName(changePropertyAction->newValue().toString());
|
|
}
|
|
values.insert( changePropertyAction->propertyName().latin1(), changePropertyAction->newValue() );
|
|
//the subsequent "change property" action is no longer needed
|
|
actionsForThisField->remove(changePropertyAction->propertyName().latin1());
|
|
}
|
|
else {
|
|
++it;
|
|
}
|
|
}
|
|
if (!values.isEmpty()) {
|
|
//update field, so it will be created as one step
|
|
KexiDB::Field *f = new KexiDB::Field( field() );
|
|
if (KexiDB::setFieldProperties( *f, values )) {
|
|
//field() = f;
|
|
setField( f );
|
|
field().debug();
|
|
#ifdef KEXI_DEBUG_GUI
|
|
KexiUtils::addAlterTableActionDebug(
|
|
TQString("** Property-set actions moved to field definition itself:\n")+field().debugString(), 0);
|
|
#endif
|
|
}
|
|
else {
|
|
#ifdef KEXI_DEBUG_GUI
|
|
KexiUtils::addAlterTableActionDebug(
|
|
TQString("** Failed to set properties for field ")+field().debugString(), 0);
|
|
#endif
|
|
KexiDBWarn << "AlterTableHandler::InsertFieldAction::simplifyActions(): KexiDB::setFieldProperties() failed!" << endl;
|
|
delete f;
|
|
}
|
|
}
|
|
}
|
|
//ok, insert this action
|
|
//! @todo not checked
|
|
AlterTableHandler::InsertFieldAction* newAction
|
|
= new AlterTableHandler::InsertFieldAction( *this );
|
|
if (!actionsForThisField)
|
|
actionsForThisField = createActionDict( fieldActions, uid() );
|
|
actionsForThisField->insert( ":insert:", newAction ); //special
|
|
}
|
|
|
|
tristate AlterTableHandler::InsertFieldAction::updateTableSchema(TableSchema &table, Field* field,
|
|
TQMap<TQString, TQString>& fieldMap)
|
|
{
|
|
//in most cases we won't add the field to fieldMap
|
|
Q_UNUSED(field);
|
|
//! @todo add it only when there should be fixed value (e.g. default) set for this new field...
|
|
fieldMap.remove( this->field().name() );
|
|
table.insertField(index(), new Field(this->field()));
|
|
return true;
|
|
}
|
|
|
|
tristate AlterTableHandler::InsertFieldAction::execute(Connection& conn, TableSchema& table)
|
|
{
|
|
Q_UNUSED(conn);
|
|
Q_UNUSED(table);
|
|
//! @todo
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
|
|
AlterTableHandler::MoveFieldPositionAction::MoveFieldPositionAction(
|
|
int fieldIndex, const TQString& fieldName, int uid)
|
|
: FieldActionBase(fieldName, uid)
|
|
, m_index(fieldIndex)
|
|
{
|
|
}
|
|
|
|
AlterTableHandler::MoveFieldPositionAction::MoveFieldPositionAction(bool)
|
|
: FieldActionBase(true)
|
|
{
|
|
}
|
|
|
|
AlterTableHandler::MoveFieldPositionAction::~MoveFieldPositionAction()
|
|
{
|
|
}
|
|
|
|
void AlterTableHandler::MoveFieldPositionAction::updateAlteringRequirements()
|
|
{
|
|
setAlteringRequirements( MainSchemaAlteringRequired );
|
|
//! @todo
|
|
}
|
|
|
|
TQString AlterTableHandler::MoveFieldPositionAction::debugString(const DebugOptions& debugOptions)
|
|
{
|
|
TQString s = TQString("Move table field \"%1\" to position %2")
|
|
.tqarg(fieldName()).tqarg(m_index);
|
|
if (debugOptions.showUID)
|
|
s.append(TQString(" (UID=%1)").tqarg(uid()));
|
|
return s;
|
|
}
|
|
|
|
void AlterTableHandler::MoveFieldPositionAction::simplifyActions(ActionDictDict &fieldActions)
|
|
{
|
|
Q_UNUSED(fieldActions);
|
|
//! @todo
|
|
}
|
|
|
|
tristate AlterTableHandler::MoveFieldPositionAction::execute(Connection& conn, TableSchema& table)
|
|
{
|
|
Q_UNUSED(conn);
|
|
Q_UNUSED(table);
|
|
//! @todo
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
|
|
AlterTableHandler::AlterTableHandler(Connection &conn)
|
|
: Object()
|
|
, d( new Private() )
|
|
{
|
|
d->conn = &conn;
|
|
}
|
|
|
|
AlterTableHandler::~AlterTableHandler()
|
|
{
|
|
delete d;
|
|
}
|
|
|
|
void AlterTableHandler::addAction(ActionBase* action)
|
|
{
|
|
d->actions.append(action);
|
|
}
|
|
|
|
AlterTableHandler& AlterTableHandler::operator<< ( ActionBase* action )
|
|
{
|
|
d->actions.append(action);
|
|
return *this;
|
|
}
|
|
|
|
const AlterTableHandler::ActionList& AlterTableHandler::actions() const
|
|
{
|
|
return d->actions;
|
|
}
|
|
|
|
void AlterTableHandler::removeAction(int index)
|
|
{
|
|
d->actions.remove( d->actions.at(index) );
|
|
}
|
|
|
|
void AlterTableHandler::clear()
|
|
{
|
|
d->actions.clear();
|
|
}
|
|
|
|
void AlterTableHandler::setActions(const ActionList& actions)
|
|
{
|
|
d->actions = actions;
|
|
}
|
|
|
|
void AlterTableHandler::debug()
|
|
{
|
|
KexiDBDbg << "AlterTableHandler's actions:" << endl;
|
|
foreach_list (ActionListIterator, it, d->actions)
|
|
it.current()->debug();
|
|
}
|
|
|
|
TableSchema* AlterTableHandler::execute(const TQString& tableName, ExecutionArguments& args)
|
|
{
|
|
args.result = false;
|
|
if (!d->conn) {
|
|
//! @todo err msg?
|
|
return 0;
|
|
}
|
|
if (d->conn->isReadOnly()) {
|
|
//! @todo err msg?
|
|
return 0;
|
|
}
|
|
if (!d->conn->isDatabaseUsed()) {
|
|
//! @todo err msg?
|
|
return 0;
|
|
}
|
|
TableSchema *oldTable = d->conn->tableSchema(tableName);
|
|
if (!oldTable) {
|
|
//! @todo err msg?
|
|
return 0;
|
|
}
|
|
|
|
if (!args.debugString)
|
|
debug();
|
|
|
|
// Find a sum of requirements...
|
|
int allActionsCount = 0;
|
|
for(ActionListIterator it(d->actions); it.current(); ++it, allActionsCount++) {
|
|
it.current()->updateAlteringRequirements();
|
|
it.current()->m_order = allActionsCount;
|
|
}
|
|
|
|
/* Simplify actions list if possible and check for errors
|
|
|
|
How to do it?
|
|
- track property changes/deletions in reversed order
|
|
- reduce intermediate actions
|
|
|
|
Trivial example 1:
|
|
*action1: "rename field a to b"
|
|
*action2: "rename field b to c"
|
|
*action3: "rename field c to d"
|
|
|
|
After reduction:
|
|
*action1: "rename field a to d"
|
|
Summing up: we have tracked what happens to field curently named "d"
|
|
and eventually discovered that it was originally named "a".
|
|
|
|
Trivial example 2:
|
|
*action1: "rename field a to b"
|
|
*action2: "rename field b to c"
|
|
*action3: "remove field b"
|
|
After reduction:
|
|
*action3: "remove field b"
|
|
Summing up: we have noticed that field "b" has beed eventually removed
|
|
so we needed to find all actions related to this field and remove them.
|
|
This is good optimization, as some of the eventually removed actions would
|
|
be difficult to perform and/or costly, what would be a waste of resources
|
|
and a source of unwanted questions sent to the user.
|
|
*/
|
|
|
|
ActionListIterator it(d->actions);
|
|
|
|
// Fields-related actions.
|
|
ActionDictDict fieldActions(3001);
|
|
fieldActions.setAutoDelete(true);
|
|
ActionBase* action;
|
|
for(it.toLast(); (action = it.current()); --it) {
|
|
action->simplifyActions( fieldActions );
|
|
}
|
|
|
|
if (!args.debugString)
|
|
debugFieldActions(fieldActions, args.simulate);
|
|
|
|
// Prepare actions for execution ----
|
|
// - Sort actions by order
|
|
ActionVector actionsVector(allActionsCount);
|
|
int currentActionsCount = 0; //some actions may be removed
|
|
args.requirements = 0;
|
|
TQDict<char> fieldsWithChangedMainSchema(997); // Used to collect fields with changed main schema.
|
|
// This will be used when recreateTable is false to update kexi__fields
|
|
for (ActionDictDictIterator it(fieldActions); it.current(); ++it) {
|
|
for (AlterTableHandler::ActionDictIterator it2(*it.current());it2.current(); ++it2, currentActionsCount++) {
|
|
if (it2.current()->shouldBeRemoved(fieldActions))
|
|
continue;
|
|
actionsVector.insert( it2.current()->m_order, it2.current() );
|
|
// a sum of requirements...
|
|
const int r = it2.current()->alteringRequirements();
|
|
args.requirements |= r;
|
|
if (r & MainSchemaAlteringRequired && dynamic_cast<ChangeFieldPropertyAction*>(it2.current())) {
|
|
// Remember, this will be used when recreateTable is false to update kexi__fields, below.
|
|
fieldsWithChangedMainSchema.insert(
|
|
dynamic_cast<ChangeFieldPropertyAction*>(it2.current())->fieldName(), (char*)1 );
|
|
}
|
|
}
|
|
}
|
|
// - Debug
|
|
TQString dbg = TQString("** Overall altering requirements: %1").tqarg(args.requirements);
|
|
KexiDBDbg << dbg << endl;
|
|
|
|
if (args.onlyComputeRequirements) {
|
|
args.result = true;
|
|
return 0;
|
|
}
|
|
|
|
const bool recreateTable = (args.requirements & PhysicalAlteringRequired);
|
|
|
|
#ifdef KEXI_DEBUG_GUI
|
|
if (args.simulate)
|
|
KexiUtils::addAlterTableActionDebug(dbg, 0);
|
|
#endif
|
|
dbg = TQString("** Ordered, simplified actions (%1, was %2):").tqarg(currentActionsCount).tqarg(allActionsCount);
|
|
KexiDBDbg << dbg << endl;
|
|
#ifdef KEXI_DEBUG_GUI
|
|
if (args.simulate)
|
|
KexiUtils::addAlterTableActionDebug(dbg, 0);
|
|
#endif
|
|
for (int i=0; i<allActionsCount; i++) {
|
|
debugAction(actionsVector[i], 1, args.simulate, TQString("%1: ").tqarg(i+1), args.debugString);
|
|
}
|
|
|
|
if (args.requirements == 0) {//nothing to do
|
|
args.result = true;
|
|
return oldTable;
|
|
}
|
|
if (args.simulate) {//do not execute
|
|
args.result = true;
|
|
return oldTable;
|
|
}
|
|
// @todo transaction!
|
|
|
|
// Create new TableSchema
|
|
TableSchema *newTable = recreateTable ? new TableSchema(*oldTable, false/*!copy id*/) : oldTable;
|
|
// find nonexisting temp name for new table schema
|
|
if (recreateTable) {
|
|
TQString tempDestTableName;
|
|
while (true) {
|
|
tempDestTableName = TQString("%1_temp%2%3").tqarg(newTable->name()).tqarg(TQString::number(rand(), 16)).tqarg(TQString::number(rand(), 16));
|
|
if (!d->conn->tableSchema(tempDestTableName))
|
|
break;
|
|
}
|
|
newTable->setName( tempDestTableName );
|
|
}
|
|
oldTable->debug();
|
|
if (recreateTable && !args.debugString)
|
|
newTable->debug();
|
|
|
|
// Update table schema in memory ----
|
|
int lastUID = -1;
|
|
Field *currentField = 0;
|
|
TQMap<TQString, TQString> fieldMap; // a map from new value to old value
|
|
foreach_list( Field::ListIterator, it, newTable->fieldsIterator() ) {
|
|
fieldMap.insert( it.current()->name(), it.current()->name() );
|
|
}
|
|
for (int i=0; i<allActionsCount; i++) {
|
|
action = actionsVector[i];
|
|
if (!action)
|
|
continue;
|
|
//remember the current Field object because soon we may be unable to find it by name:
|
|
FieldActionBase *fieldAction = dynamic_cast<FieldActionBase*>(action);
|
|
if (!fieldAction) {
|
|
currentField = 0;
|
|
}
|
|
else {
|
|
if (lastUID != fieldAction->uid()) {
|
|
currentField = newTable->field( fieldAction->fieldName() );
|
|
lastUID = currentField ? fieldAction->uid() : -1;
|
|
}
|
|
InsertFieldAction *insertFieldAction = dynamic_cast<InsertFieldAction*>(action);
|
|
if (insertFieldAction && insertFieldAction->index()>(int)newTable->fieldCount()) {
|
|
//update index: there can be empty rows
|
|
insertFieldAction->setIndex(newTable->fieldCount());
|
|
}
|
|
}
|
|
//if (!currentField)
|
|
// continue;
|
|
args.result = action->updateTableSchema(*newTable, currentField, fieldMap);
|
|
if (args.result!=true) {
|
|
if (recreateTable)
|
|
delete newTable;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (recreateTable) {
|
|
// Create the destination table with temporary name
|
|
if (!d->conn->createTable( newTable, false )) {
|
|
setError(d->conn);
|
|
delete newTable;
|
|
args.result = false;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
#if 0//todo
|
|
// Execute actions ----
|
|
for (int i=0; i<allActionsCount; i++) {
|
|
action = actionsVector[i];
|
|
if (!action)
|
|
continue;
|
|
args.result = action->execute(*d->conn, *newTable);
|
|
if (!args.result || ~args.result) {
|
|
//! @todo delete newTable...
|
|
args.result = false;
|
|
return 0;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// update extended table schema after executing the actions
|
|
if (!d->conn->storeExtendedTableSchemaData(*newTable)) {
|
|
//! @todo better errmsg?
|
|
setError(d->conn);
|
|
//! @todo delete newTable...
|
|
args.result = false;
|
|
return 0;
|
|
}
|
|
|
|
if (recreateTable) {
|
|
// Copy the data:
|
|
// Build "INSERT INTO ... SELECT FROM ..." SQL statement
|
|
// The order is based on the order of the source table fields.
|
|
// Notes:
|
|
// -Some source fields can be skipped in case when there are deleted fields.
|
|
// -Some destination fields can be skipped in case when there
|
|
// are new empty fields without fixed/default value.
|
|
TQString sql = TQString("INSERT INTO %1 (").tqarg(d->conn->escapeIdentifier(newTable->name()));
|
|
//insert list of dest. fields
|
|
bool first = true;
|
|
TQString sourceFields;
|
|
foreach_list( Field::ListIterator, it, newTable->fieldsIterator() ) {
|
|
Field * const f = it.current();
|
|
TQString renamedFieldName( fieldMap[ f->name() ] );
|
|
TQString sourceSQLString;
|
|
if (!renamedFieldName.isEmpty()) {
|
|
//this field should be renamed
|
|
sourceSQLString = d->conn->escapeIdentifier(renamedFieldName);
|
|
}
|
|
else if (!f->defaultValue().isNull()) {
|
|
//this field has a default value defined
|
|
//! @todo support expressions (eg. TODAY()) as a default value
|
|
//! @todo this field can be notNull or notEmpty - check whether the default is ok
|
|
//! (or do this checking also in the Table Designer?)
|
|
sourceSQLString = d->conn->driver()->valueToSQL( f->type(), f->defaultValue() );
|
|
}
|
|
else if (f->isNotNull()) {
|
|
//this field cannot be null
|
|
sourceSQLString = d->conn->driver()->valueToSQL(
|
|
f->type(), KexiDB::emptyValueForType( f->type() ) );
|
|
}
|
|
else if (f->isNotEmpty()) {
|
|
//this field cannot be empty - use any nonempty value..., e.g. " " for text or 0 for number
|
|
sourceSQLString = d->conn->driver()->valueToSQL(
|
|
f->type(), KexiDB::notEmptyValueForType( f->type() ) );
|
|
}
|
|
//! @todo support unique, validatationRule, unsigned flags...
|
|
//! @todo check for foreignKey values...
|
|
|
|
if (!sourceSQLString.isEmpty()) {
|
|
if (first) {
|
|
first = false;
|
|
}
|
|
else {
|
|
sql.append( ", " );
|
|
sourceFields.append( ", " );
|
|
}
|
|
sql.append( d->conn->escapeIdentifier( f->name() ) );
|
|
sourceFields.append( sourceSQLString );
|
|
}
|
|
}
|
|
sql.append(TQString(") SELECT ") + sourceFields + " FROM " + oldTable->name());
|
|
KexiDBDbg << " ** " << sql << endl;
|
|
if (!d->conn->executeSQL( sql )) {
|
|
setError(d->conn);
|
|
//! @todo delete newTable...
|
|
args.result = false;
|
|
return 0;
|
|
}
|
|
|
|
const TQString oldTableName = oldTable->name();
|
|
/* args.result = d->conn->dropTable( oldTable );
|
|
if (!args.result || ~args.result) {
|
|
setError(d->conn);
|
|
//! @todo delete newTable...
|
|
return 0;
|
|
}
|
|
oldTable = 0;*/
|
|
|
|
// Replace the old table with the new one (oldTable will be destroyed)
|
|
if (!d->conn->alterTableName(*newTable, oldTableName, true /*replace*/)) {
|
|
setError(d->conn);
|
|
//! @todo delete newTable...
|
|
args.result = false;
|
|
return 0;
|
|
}
|
|
oldTable = 0;
|
|
}
|
|
|
|
if (!recreateTable) {
|
|
if ((MainSchemaAlteringRequired & args.requirements) && !fieldsWithChangedMainSchema.isEmpty()) {
|
|
//update main schema (kexi__fields) for changed fields
|
|
foreach_list(TQDictIterator<char>, it, fieldsWithChangedMainSchema) {
|
|
Field *f = newTable->field( it.currentKey() );
|
|
if (f) {
|
|
if (!d->conn->storeMainFieldSchema(f)) {
|
|
setError(d->conn);
|
|
//! @todo delete newTable...
|
|
args.result = false;
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
args.result = true;
|
|
return newTable;
|
|
}
|
|
|
|
/*TableSchema* AlterTableHandler::execute(const TQString& tableName, tristate &result, bool simulate)
|
|
{
|
|
return executeInternal( tableName, result, simulate, 0 );
|
|
}
|
|
|
|
tristate AlterTableHandler::simulateExecution(const TQString& tableName, TQString& debugString)
|
|
{
|
|
tristate result;
|
|
(void)executeInternal( tableName, result, true//simulate
|
|
, &debugString );
|
|
return result;
|
|
}
|
|
*/
|