Deveel.Data.Sql.Statements.AlterTableStatement Class Reference

Inheritance diagram for Deveel.Data.Sql.Statements.AlterTableStatement:

Public Member Functions
	AlterTableStatement (ObjectName tableName, IAlterTableAction action)
Public Member Functions inherited from Deveel.Data.Sql.Statements.SqlStatement
ITable	Execute (IRequest context)
	Prepares and evaluates this statement into a tabular result. More...

Protected Member Functions
override void	GetData (SerializeData data)
override void	ExecuteStatement (ExecutionContext context)
Protected Member Functions inherited from Deveel.Data.Sql.Statements.SqlStatement
	SqlStatement ()
	SqlStatement (ObjectData data)

Properties
ObjectName	TableName [get, private set]
IAlterTableAction	Action [get, private set]
Properties inherited from Deveel.Data.Sql.Statements.SqlStatement
SqlQuery	SourceQuery [get, set]
	Gets the SqlQuery that is the origin of this statement. More...
bool	IsFromQuery [get, private set]
	Gets a boolean value indicating if this object was formed from the parsing of a SqlQuery or if it was manually created. More...
Properties inherited from Deveel.Data.Sql.Statements.IStatement
SqlQuery	SourceQuery [get]

Private Member Functions
	AlterTableStatement (ObjectData data)
IStatement IPreparableStatement.	Prepare (IRequest context)
object IPreparable.	Prepare (IExpressionPreparer preparer)
	Converts the underlying value of this instance into an object that can be evaluated by an expression. More...
bool	CheckColumnNamesMatch (IRequest context, String col1, String col2)

Static Private Member Functions
static void	CheckColumnConstraint (string columnName, string[] columns, ObjectName table, string constraintName)

Additional Inherited Members
Static Public Member Functions inherited from Deveel.Data.Sql.Statements.SqlStatement
static IEnumerable< SqlStatement >	Parse (string sqlSource)
	Parses a given string into one of more statements. More...
static IEnumerable< SqlStatement >	Parse (IContext context, string sqlSource)
	Parses a given string into one of more statements. More...
static IEnumerable< SqlStatement >	Parse (IContext context, SqlQuery query)
Package Functions inherited from Deveel.Data.Sql.Statements.SqlStatement
void	SetSource (SqlQuery query)

Detailed Description

Definition at line 28 of file AlterTableStatement.cs.

Constructor & Destructor Documentation

Deveel.Data.Sql.Statements.AlterTableStatement.AlterTableStatement ( ObjectName  tableName, IAlterTableAction  action  )

inline

Definition at line 29 of file AlterTableStatement.cs.

                                                                                   {
            if (tableName == null)
                throw new ArgumentNullException("tableName");
            if (action == null)
                throw new ArgumentNullException("action");

            TableName = tableName;
            Action = action;
        }

Deveel.Data.Sql.Statements.AlterTableStatement.AlterTableStatement ( ObjectData  data )

inlineprivate

Definition at line 39 of file AlterTableStatement.cs.

                                                     {
            TableName = data.GetValue<ObjectName>("TableName");
            Action = data.GetValue<IAlterTableAction>("Action");
        }

Member Function Documentation

static void Deveel.Data.Sql.Statements.AlterTableStatement.CheckColumnConstraint ( string  columnName, string[]  columns, ObjectName  table, string  constraintName  )

inlinestaticprivate

Definition at line 61 of file AlterTableStatement.cs.

                                                                                                                                {
            foreach (string column in columns) {
                if (columnName.Equals(column)) {
                    throw new ConstraintViolationException(SqlModelErrorCodes.DropColumnViolation,
                              "Constraint violation (" + constraintName +
                              ") dropping column " + columnName + " because of " +
                              "referential constraint in " + table);
                }
            }

        }

bool Deveel.Data.Sql.Statements.AlterTableStatement.CheckColumnNamesMatch ( IRequest  context, String  col1, String  col2  )

inlineprivate

Definition at line 73 of file AlterTableStatement.cs.

                                                                                       {
            var comparison = context.Query.IgnoreIdentifiersCase() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
            return col1.Equals(col2, comparison);
        }

override void Deveel.Data.Sql.Statements.AlterTableStatement.ExecuteStatement ( ExecutionContext  context )

inlineprotectedvirtual

Reimplemented from Deveel.Data.Sql.Statements.SqlStatement.

Definition at line 83 of file AlterTableStatement.cs.

                                                                           {
            if (!context.Request.Query.UserCanAlterTable(TableName))
                throw new InvalidAccessException(context.Request.Query.UserName(), TableName);

            var table = context.Request.Query.GetTable(TableName);
            if (table == null)
                throw new ObjectNotFoundException(TableName);

            var tableInfo = table.TableInfo;
            var newTableInfo = new TableInfo(tableInfo.TableName);

            var checker = ColumnChecker.Default(context.Request, TableName);

            bool tableAltered = false;
            bool markDropped = false;

            for (int n = 0; n < tableInfo.ColumnCount; ++n) {
                var column = tableInfo[n];

                string columnName = column.ColumnName;
                var columnType = column.ColumnType;
                var defaultExpression = column.DefaultExpression;

                if (Action.ActionType == AlterTableActionType.SetDefault &&
                    CheckColumnNamesMatch(context.Request, ((SetDefaultAction)Action).ColumnName, columnName)) {
                    var exp = ((SetDefaultAction)Action).DefaultExpression;
                    exp = checker.CheckExpression(exp);
                    defaultExpression = exp;
                    tableAltered = true;
                } else if (Action.ActionType == AlterTableActionType.DropDefault &&
                           CheckColumnNamesMatch(context.Request, ((DropDefaultAction)Action).ColumnName, columnName)) {
                    defaultExpression = null;
                    tableAltered = true;
                } else if (Action.ActionType == AlterTableActionType.DropColumn &&
                           CheckColumnNamesMatch(context.Request, ((DropColumnAction)Action).ColumnName, columnName)) {
                    // Check there are no referential links to this column
                    var refs = context.Request.Query.GetTableImportedForeignKeys(TableName);
                    foreach (var reference in refs) {
                        CheckColumnConstraint(columnName, reference.ForeignColumnNames, reference.ForeignTable, reference.ConstraintName);
                    }

                    // Or from it
                    refs = context.Request.Query.GetTableForeignKeys(TableName);
                    foreach (var reference in refs) {
                        CheckColumnConstraint(columnName, reference.ColumnNames, reference.TableName, reference.ConstraintName);
                    }

                    // Or that it's part of a primary key
                    var primaryKey = context.Request.Query.GetTablePrimaryKey(TableName);
                    if (primaryKey != null)
                        CheckColumnConstraint(columnName, primaryKey.ColumnNames, TableName, primaryKey.ConstraintName);

                    // Or that it's part of a unique set
                    var uniques = context.Request.Query.GetTableUniqueKeys(TableName);
                    foreach (var unique in uniques) {
                        CheckColumnConstraint(columnName, unique.ColumnNames, TableName, unique.ConstraintName);
                    }

                    markDropped = true;
                    tableAltered = true;
                }

                var newColumn = new ColumnInfo(columnName, columnType);
                if (defaultExpression != null)
                    newColumn.DefaultExpression = defaultExpression;

                newColumn.IndexType = column.IndexType;
                newColumn.IsNotNull = column.IsNotNull;

                // If not dropped then add to the new table definition.
                if (!markDropped) {
                    newTableInfo.AddColumn(newColumn);
                }
            }

            if (Action.ActionType == AlterTableActionType.AddColumn) {
                var col = ((AddColumnAction)Action).Column;

                checker.CheckExpression(col.DefaultExpression);
                var columnName = col.ColumnName;
                var columnType = col.ColumnType;

                // If column name starts with [table_name]. then strip it off
                columnName = checker.StripTableName(TableName.Name, columnName);
                if (tableInfo.IndexOfColumn(col.ColumnName) != -1)
                    throw new InvalidOperationException("The column '" + col.ColumnName + "' is already in the table '" + tableInfo.TableName + "'.");

                var newColumn = new ColumnInfo(columnName, columnType) {
                    IsNotNull = col.IsNotNull,
                    DefaultExpression = col.DefaultExpression
                };

                newTableInfo.AddColumn(newColumn);
                tableAltered = true;
            }

            if (Action.ActionType == AlterTableActionType.DropConstraint) {
                string constraintName = ((DropConstraintAction)Action).ConstraintName;
                int dropCount = context.Request.Query.DropConstraint(TableName, constraintName);
                if (dropCount == 0)
                    throw new InvalidOperationException("Named constraint to drop on table " + TableName + " was not found: " + constraintName);
            } else if (Action.ActionType == AlterTableActionType.DropPrimaryKey) {
                string constraintName = ((DropConstraintAction)Action).ConstraintName;
                if (!context.Request.Query.DropPrimaryKey(TableName, constraintName))
                    throw new InvalidOperationException("No primary key to delete on table " + TableName);
            }

            if (Action.ActionType == AlterTableActionType.AddConstraint) {
                var constraint = ((AddConstraintAction)Action).Constraint;
                bool foreignConstraint = (constraint.ConstraintType == ConstraintType.ForeignKey);

                ObjectName refTname = null;
                if (foreignConstraint) {
                    refTname = context.Request.Query.ResolveTableName(constraint.ReferenceTable);
                }

                var columnNames = checker.StripColumnList(TableName.FullName, constraint.Columns);
                columnNames = checker.StripColumnList(constraint.ReferenceTable, columnNames);
                var expression = checker.CheckExpression(constraint.CheckExpression);
                columnNames = checker.CheckColumns(columnNames);

                IEnumerable<string> refCols = null;
                if (foreignConstraint && constraint.ReferenceColumns != null) {
                    var referencedChecker = ColumnChecker.Default(context.Request, refTname);
                    refCols = referencedChecker.CheckColumns(constraint.ReferenceColumns);
                }

                var newConstraint = new ConstraintInfo(constraint.ConstraintType, TableName, columnNames.ToArray());
                if (foreignConstraint) {
                    newConstraint.ForeignTable = refTname;
                    newConstraint.ForeignColumnNames = refCols.ToArray();
                }

                if (constraint.ConstraintType == ConstraintType.Check)
                    newConstraint.CheckExpression = expression;

                context.Request.Query.AddConstraint(TableName, newConstraint);
            }

            // Alter the existing table to the new format...
            if (tableAltered) {
                if (newTableInfo.ColumnCount == 0)
                    throw new InvalidOperationException("Can not ALTER table to have 0 columns.");

                context.Request.Query.AlterTable(newTableInfo);
            } else {
                // If the table wasn't physically altered, check the constraints.
                // Calling this method will also make the transaction check all
                // deferred constraints during the next commit.
                context.Request.Query.CheckConstraints(TableName);
            }
        }

override void Deveel.Data.Sql.Statements.AlterTableStatement.GetData ( SerializeData  data )

inlineprotectedvirtual

Reimplemented from Deveel.Data.Sql.Statements.SqlStatement.

Definition at line 78 of file AlterTableStatement.cs.

                                                            {
            data.SetValue("TableName", TableName);
            data.SetValue("Action", Action);
        }

IStatement IPreparableStatement. Deveel.Data.Sql.Statements.AlterTableStatement.Prepare ( IRequest  context )

inlineprivate

Implements Deveel.Data.Sql.Statements.IPreparableStatement.

Definition at line 48 of file AlterTableStatement.cs.

                                                                  {
            var tableName = context.Query.ResolveTableName(TableName);
            return new AlterTableStatement(tableName, Action);
        }

object IPreparable. Deveel.Data.Sql.Statements.AlterTableStatement.Prepare ( IExpressionPreparer  preparer )

inlineprivate

Converts the underlying value of this instance into an object that can be evaluated by an expression.

Parameters

preparer

The context used to prepare this object.

Returns

Returns an object that can be evaluated by an expression.

Implements Deveel.Data.Sql.Expressions.IPreparable.

Definition at line 53 of file AlterTableStatement.cs.

                                                                 {
            var action = Action;
            if (action is IPreparable)
                action = (IAlterTableAction)(action as IPreparable).Prepare(preparer);

            return new AlterTableStatement(TableName, action);
        }

Property Documentation

IAlterTableAction Deveel.Data.Sql.Statements.AlterTableStatement.Action

getprivate set

Definition at line 46 of file AlterTableStatement.cs.

ObjectName Deveel.Data.Sql.Statements.AlterTableStatement.TableName

getprivate set

Definition at line 44 of file AlterTableStatement.cs.

---

The documentation for this class was generated from the following file:

• /var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb/Deveel.Data.Sql.Statements/AlterTableStatement.cs