public CommandServiceTests()
{
// Create Alter Query
_alterQuery = new AlterTableStatement <TestClass>("testtableName", AlterTableStatement <TestClass> .AlterType.Create);
// Create Delete Query
_deleteQuery = new DeleteStatement <TestClass>(m => m.Id > 10);
// Create Update Query
Expression <Func <TestClass> > newExpression = () => new TestClass()
{
Id = 3
};
MemberInitExpression memberInit = newExpression.Body as MemberInitExpression;
_updateQuery = new UpdateStatement <TestClass>(
memberInit.Bindings.Cast <MemberAssignment>(),
null
);
// Create Merge Query
Expression <Func <TestClass, int> > expression = t => t.Id;
MemberExpression memberExpression = expression.Body as MemberExpression;
var mergeKeys = new List <MemberExpression>()
{
memberExpression
};
_mergeQuery = new MergeStatement <TestClass>(mergeKeys, "temporarytable", MergeStatement <TestClass> .MergeType.InsertOnly);
}
public int Alter(AlterTableStatement <TEntity> alterQuery)
{
Check.NotNull(alterQuery, nameof(alterQuery));
(string query, IEnumerable <object> parameters) = _queryTranslator.TranslateQuery(alterQuery);
return(_queryProcessor.ExecuteCommand(
query: query,
parameters: parameters
));
}
public virtual bool Action(AlterTableStatement node)
{
AddTablesContext(node);
FixIdentifiers(node.TableSource.DbObject, ObjectType.TABLE, node.TableSource.DbObject.Identifiers);
dynamic dynAction = node.Action;
Action(dynAction);
return(false);
}
public void AlterTable_AddColumn()
{
var addColumn = new AddColumnAction(new SqlTableColumn("a", PrimitiveTypes.BigInt()));
var statement = new AlterTableStatement(ObjectName.Parse("APP.test_table1"), addColumn);
SerializeAndAssert(statement, (serialized, deserialized) => {
Assert.IsNotNull(deserialized);
Assert.IsNotNull(statement.TableName);
Assert.IsNotNull(statement.Action);
Assert.IsInstanceOf <AddColumnAction>(statement.Action);
});
}
public override Statement EmitStatement(EmitMode mode)
{
AlterTableStatement statement = new AlterTableStatement();
statement.TableVarName = Schema.Object.EnsureRooted(_tableVarColumn.TableVar.Name);
AlterColumnDefinition definition = new AlterColumnDefinition();
definition.ColumnName = _tableVarColumn.Name;
definition.Default = EmitDefinition(mode);
statement.AlterColumns.Add(definition);
return(statement);
}
public void ConstructorShouldAssignValues()
{
// Arrange
var tableName = "This is the tableName";
var actionType = AlterTableStatement <object> .AlterType.Drop;
// Act
var statment = new AlterTableStatement <object>(
tableName: tableName,
type: actionType
);
// Assert
Assert.Same(tableName, statment.TableName);
Assert.Equal(actionType, statment.Type);
}
public (string, IEnumerable <object>) TranslateQuery(AlterTableStatement <TEntity> query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
switch (query.Type)
{
case AlterTableStatement <TEntity> .AlterType.Create: return(GenerateCreateQuery(query.TableName).Build());
case AlterTableStatement <TEntity> .AlterType.Drop: return(GenerateDropQuery(query.TableName).Build());
default:
throw new InvalidOperationException($"The alter operation\"{query.Type}\" is not supported.");
}
}
internal void AddField(string fieldname, Type type)
{
fieldname = Qoute(fieldname);
if (_currentTableStatment != null)
{
_currentAddFieldStatment = _currentTableStatment.AddFieldStatement(fieldname, type);
}
else if (_currentTableInfo != null)
{
AlterTableStatement alterTableStatement = new AlterTableStatement(_currentTableInfo.TableName, fieldname, type, _currentTableInfo);
_currentAddFieldStatment = alterTableStatement.FieldStatement;
_tableStatments.Add(alterTableStatement);
}
else
throw new InvalidOperationException("No Table selected");
}
public override Statement EmitDropStatement(EmitMode mode)
{
if (_tableVarColumn.TableVar is BaseTableVar)
{
AlterTableStatement statement = new AlterTableStatement();
statement.TableVarName = Schema.Object.EnsureRooted(_tableVarColumn.TableVar.Name);
AlterColumnDefinition definition = new D4.AlterColumnDefinition();
definition.ColumnName = _tableVarColumn.Name;
definition.Default = new DropDefaultDefinition();
statement.AlterColumns.Add(definition);
return(statement);
}
else
{
return(new Block());
}
}
protected override void EmitAlterTableStatement(AlterTableStatement statement)
{
Indent();
AppendFormat("{0} {1} ", Keywords.Alter, Keywords.Table);
EmitIdentifier(statement.TableName);
for (int index = 0; index < statement.AddColumns.Count; index++)
{
AppendFormat(" {0} {1}", Keywords.Add, Keywords.BeginGroup);
EmitColumnDefinition(statement.AddColumns[index]);
Append(Keywords.EndGroup);
}
for (int index = 0; index < statement.DropColumns.Count; index++)
{
AppendFormat(" {0} {1}", Keywords.Drop, Keywords.BeginGroup);
EmitIdentifier(statement.DropColumns[index].ColumnName);
Append(Keywords.EndGroup);
}
}
public override void Visit(AlterTableStatement node)
{
DDLStatementFound = true;
}
public void DropCreateTemporaryTable(AlterTableStatement <TRecord> .AlterType alterType)
{
_commandService.Alter(
new AlterTableStatement <TRecord>(TEMP_TABLE, alterType)
);
}
public override void ExplicitVisit(AlterTableStatement node)
{
this.AlterTableStatements.Add(node);
}
public override void Visit(AlterTableStatement node)
{
Traverse(node);
}
public virtual bool PostAction(AlterTableStatement node)
{
RemoveTablesContext(node);
return(false);
}
private IList <DbObjectTableSource> GetAvailTables(GrammarNode node)
{
IList <DbObjectTableSource> ret = new List <DbObjectTableSource>();
if (node is UpdateStatement)
{
UpdateStatement upd = (UpdateStatement)node;
dynamic ts = upd.TableSource;
AddAvailTable(ts, ret);
AddAvailTables(upd.FromClause, ret);
}
if (node is DeleteStatement)
{
dynamic ts = ((DeleteStatement)node).Table;
AddAvailTable(ts, ret);
}
if (node is InsertStatement)
{
InsertStatement insert = (InsertStatement)node;
if (insert.InsertTarget is DbObjectInsertTarget)
{
AddAvailTable(((DbObjectInsertTarget)insert.InsertTarget).TableSource, ret);
}
}
if (node is CreateIndexStatement)
{
CreateIndexStatement stmt = (CreateIndexStatement)node;
if (stmt.IndexTarget is DbObjectIndexTarget)
{
AddAvailTable(stmt.IndexTarget.TableSource, ret);
}
}
if (node is DropIndexStatement)
{
DropIndexStatement stmt = (DropIndexStatement)node;
foreach (DropIndexAction action in stmt.Actions)
{
if (action.TableSource != null)
{
AddAvailTable(action.TableSource, ret);
}
}
}
if (node is AlterIndexStatement)
{
AlterIndexStatement stmt = (AlterIndexStatement)node;
if (stmt.TableSource != null)
{
// It will be removed in Modifier, so probably useless code
AddAvailTable(stmt.TableSource, ret);
}
}
if (node is AlterTableStatement)
{
AlterTableStatement stmt = (AlterTableStatement)node;
if (stmt.TableSource != null)
{
AddAvailTable(stmt.TableSource, ret);
}
}
if (node is DropTableStatement)
{
DropTableStatement stmt = (DropTableStatement)node;
foreach (DbObjectTableSource tableSource in stmt.TableSources)
{
if (tableSource != null)
{
AddAvailTable(tableSource, ret);
}
}
}
TrimTables(ref ret);
return((ret.Count == 0) ? null : ret);
}
public override void ExplicitVisit(AlterTableStatement fragment)
{
_fragments.Add(fragment);
}
public override void ExplicitVisit(AlterTableStatement node) { this.action(node); }
