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