public virtual TableStructure ReadCreateTable() { SkipKeyword("create"); SkipTokenIf("temporary"); SkipTokenIf("temp"); SkipKeyword("table"); TableStructure res = new TableStructure(); res.FullName = ReadFullName(); SkipSymbol("("); bool was = false; while (!IsSymbol(")")) { if (was) { SkipKeyword(","); } Constraint cnt = ReadConstraint(); if (cnt != null) { res._Constraints.Add(cnt); } else { ColumnStructure col = new ColumnStructure(); res._Columns.Add(col); ReadColumn(col); } was = true; } SkipSymbol(")"); return(res); }
public EditorColumnStructure(TableEditFrame frame, ColumnStructure src, ISqlDialect dialect) { m_frame = frame; if (src.Domain != null) { Domain = m_frame.Domains[src.Domain]; } ColumnName = src.ColumnName; IsNullable = src.IsNullable; CharacterSet = src.CharacterSet; Collation = src.Collation; if (src.DefaultValue != null) { DefaultValue = src.DefaultValue.GenerateSql(dialect, src.DataType, null); } m_originalGroupId = src.GroupId; if (dialect == null) { DataType = src.DataType; } else { DataType = dialect.GenericTypeToSpecific(src.DataType); } Source = src; }
private ColumnStructure GetColumnWithDummyTable() { var c = new ColumnStructure(Column); c.SetDummyTable(DbObjectName); return(c); }
public void CreateColumn(ITableStructure table, ColumnStructure newcol) { TableStructure tbl = Structure.FindOrCreateTable(table.FullName); AddOperation(new AlterOperation_CreateColumn { ParentTable = tbl, NewObject = new ColumnStructure(newcol) }); }
public void ChangeColumn(IColumnStructure column, IColumnStructure newcolumn) { ColumnStructure col = Structure.FindOrCreateColumn(column); AddOperation(new AlterOperation_ChangeColumn { OldObject = col, ParentTable = (TableStructure)col.Table, NewObject = new ColumnStructure(newcolumn) }); }
public void RenameColumn(IColumnStructure column, string name) { ColumnStructure col = Structure.FindOrCreateColumn(column); AddOperation(new AlterOperation_RenameColumn { OldObject = col, ParentTable = (TableStructure)col.Table, NewName = new NameWithSchema(name) }); }
public void DropColumn(IColumnStructure column) { ColumnStructure col = Structure.FindOrCreateColumn(column); AddOperation(new AlterOperation_DropColumn { ParentTable = (TableStructure)col.Table, OldObject = col }); }
//public NameWithSchema FullName //{ // get { return new NameWithSchema(SchemaName, Name); } // set { SchemaName = value.Schema; Name = value.Name; } //} //#region ITableStructure Members //IColumnCollection ITableStructure.Columns //{ // get { return Columns; } //} //IList<IConstraint> ITableStructure.Constraints //{ // get { return Constraints.ToTypedList<IConstraint>(); } //} //IList<IForeignKey> ITableStructure.ReferencedFrom //{ // get { return ReferencedFrom.ToTypedList<IForeignKey>(); } //} ////TableStructureMembers ITableStructure.FilledMembers ////{ //// get { return FilledMembers; } ////} //#endregion public ColumnStructure AddColumn(string name, DbTypeBase datatype) { ColumnStructure col = new ColumnStructure(); col.ColumnName = name; col.DataType = datatype; _Columns.Add(col); return(col); }
protected virtual void ProcessTableColumnsTable(TableStructure table, DataTable columns) { foreach (DataRow row in columns.Rows.SortedByKey <DataRow, int>(row => Int32.Parse(row["ORDINAL_POSITION"].ToString()))) { //NameWithSchema table = NewNameWithSchema(row["TABLE_SCHEMA"].SafeToString(), row["TABLE_NAME"].ToString()); ColumnStructure col = table.AddColumn(row["COLUMN_NAME"].ToString(), AnalyseType(new DataRowAdapter(row), m_conn, false)); LoadTableColumn(col, row); } //table.FilledMembers |= TableStructureMembers.ColumnNames | TableStructureMembers.ColumnTypes; }
protected void CopyFromTable(ITableStructure src, bool hardAssign) { if (hardAssign || ShouldCopy(src, TableStructureMembers.SpecificDetails)) { base.AssignFrom(src); } if (hardAssign || ShouldCopy(src, TableStructureMembers.ColumnNames)) { var oldcols = new List <ColumnStructure>(); foreach (ColumnStructure c in _Columns) { oldcols.Add(c); } _Columns.Clear(); foreach (var col in src.Columns) { ColumnStructure scol = (from c in oldcols where c.ColumnName == col.ColumnName select c).FirstOrDefault(); if (scol != null) { scol.AssignFrom(col); } else { scol = new ColumnStructure(col); } _Columns.Add(scol); } } if (hardAssign || ShouldCopy(src, TableStructureMembers.ColumnTypes)) { foreach (var col in src.Columns) { ColumnStructure scol = this.FindColumn(col.ColumnName) as ColumnStructure; if (scol != null) { scol.AssignFrom(col); } } } if (hardAssign || ShouldCopy(src, TableStructureMembers.Constraints)) { foreach (var cnt in src.Constraints) { Constraint scnt = this.FindConstraint(cnt) as Constraint; if (scnt != null) { scnt.AssignFrom(scnt); } else { _Constraints.Add(Constraint.CreateCopy(cnt)); } } } }
public ColumnStructure AddColumn(IColumnStructure source, bool reuseGrouId) { ColumnStructure col = new ColumnStructure(source); if (!reuseGrouId) { col.GroupId = Guid.NewGuid().ToString(); } _Columns.Add(col); return(col); }
private TableStructure CreateStructure() { TableStructure ts = new TableStructure(); foreach (string colname in m_columnNames) { ColumnStructure col = new ColumnStructure(); col.ColumnName = colname; col.DataType = new DbTypeString(); ts._Columns.Add(col); } return(ts); }
protected virtual void LoadTableColumn(ColumnStructure col, DataRow row) { col.IsNullable = IsColumnNullable(new DataRowAdapter(row)); string def = row.ColumnDefault(); col.DefaultValue = SqlExpression.ParseDefaultValue(GetDefaultValueExpression(def), m_dialect); col.Collation = row.SafeString("COLLATION_NAME"); col.CharacterSet = row.SafeString("CHARACTER_SET_NAME"); string dschema = row.SafeString("DOMAIN_SCHEMA"), dname = row.SafeString("DOMAIN_NAME"); if (dname != null && dname.Trim() != "") { col.Domain = NewNameWithSchema(dschema, dname); } }
public void DropColumn(IColumnStructure column) { ColumnStructure colcopy = new ColumnStructure(column); colcopy.SetDummyTable(column.Table.FullName); // we must send copy of column, because when dropping column, column.Table will be null foreach (AbstractObjectStructure obj in this.GetAllObjects()) { obj.NotifyDropColumn(colcopy); } foreach (TableStructure tbl in Tables) { tbl.DropEmptyConstraints(); } }
public static TableStructure SchemaTableToStructure(DataTable schemaTable, ISqlDialect dialect) { TableStructure res = new TableStructure(); PrimaryKey pk = new PrimaryKey(); foreach (DataRow row in schemaTable.Rows.SortedByKey <DataRow, int>(row => Int32.Parse(row["ColumnOrdinal"].ToString()))) { if (row.SafeBool("IsHidden", false)) { continue; } var col = new ColumnStructure(); col.ColumnName = row.SafeString("ColumnName"); col.IsNullable = (bool)row["AllowDBNull"]; if (dialect != null) { col.DataType = dialect.ReaderDataType(row); } else { col.DataType = ReaderDataType(row); } string schema = row.SafeString("BaseSchemaName"); string table = row.SafeString("BaseTableName"); if (table != null && res.FullName == null) { res.FullName = new NameWithSchema(schema, table); } if (row.SafeBool("IsAutoIncrement", false)) { col.DataType.SetAutoincrement(true); } if (row.SafeBool("IsKey", false)) { pk.Columns.Add(new ColumnReference(col.ColumnName)); } res._Columns.Add(col); } if (pk.Columns.Count > 0) { res._Constraints.Add(pk); } return(res); }
private ITableStructure CreateTargetStructure() { TableStructure table = new TableStructure(); foreach (DataGridViewRow row in lbtarget.Rows) { var type = GetExprType(row); if (type == null) { continue; } if (type is GenericTransform.ColumnColExprType) { string oldcol = row.Cells[2].Value.ToString(); if (m_srcformat.Columns.GetIndex(oldcol) < 0) { throw new IncorrectObjectReferenceError("DAE-00185", "s_column", oldcol); } var coldef = new ColumnStructure(m_srcformat.Columns[oldcol]); coldef.ColumnName = row.Cells[0].Value.ToString(); table.AddColumn(coldef, true); } else if (type is GenericTransform.RowNumberColExprType) { var col = new ColumnStructure(); col.ColumnName = row.Cells[0].Value.ToString(); col.DataType = new DbTypeInt(); table._Columns.Add(col); if (table.FindConstraint <IPrimaryKey>() == null && table.FindAutoIncrementColumn() == null) { var pk = new PrimaryKey(); pk.Columns.Add(new ColumnReference(col.ColumnName)); table._Constraints.Add(pk); } } else { var col = new ColumnStructure(); col.ColumnName = row.Cells[0].Value.ToString(); col.DataType = new DbTypeString(250); table._Columns.Add(col); } } return(table); }
public override void AddLogicalDependencies(AlterProcessorCaps caps, DbDiffOptions opts, List <AlterOperation> before, List <AlterOperation> after, AlterPlan plan, IDatabaseSource targetDb) { ParentTable.LoadStructure(TableStructureMembers.ReferencedFrom, targetDb); var oldcol = OldObject as ColumnStructure; var newcol = NewObject as ColumnStructure; List <IForeignKey> recreateFks = new List <IForeignKey>(); var changeCols = new List <Tuple <IColumnStructure, IColumnStructure> >(); foreach (ForeignKey fk in ParentTable.GetReferencedFrom()) { for (int i = 0; i < fk.PrimaryKeyColumns.Count; i++) { if (fk.PrimaryKeyColumns[i].ColumnName == oldcol.ColumnName) { //plan.RecreateObject(fk, null); TableStructure table = (TableStructure)fk.Table; table.LoadStructure(TableStructureMembers.Columns, targetDb); ColumnStructure othercol = table.Columns[fk.Columns[i].ColumnName] as ColumnStructure; // compare types with ignoring autoincrement flag // HACK: ignore specific attributes var opts2 = opts.Clone(); opts2.IgnoreSpecificData = true; DbTypeBase dt1 = othercol.DataType.Clone(), dt2 = newcol.DataType.Clone(); dt1.SetAutoincrement(false); dt2.SetAutoincrement(false); if (!DbDiffTool.EqualTypes(dt1, dt2, opts2)) { after.Add(new AlterOperation_ChangeColumn { ParentTable = table, OldObject = othercol, NewObject = new ColumnStructure(othercol) { DataType = dt2 } }); } opts.AlterLogger.Warning(Texts.Get("s_changed_referenced_column$table$column", "table", fk.Table.FullName, "column", othercol.ColumnName)); } } } }
protected virtual void ReadColumn(ColumnStructure col) { col.ColumnName = ReadName(); col.DataType = ReadDataType(); col.IsNullable = true; if (SkipMultiIf("not", "null")) { col.IsNullable = false; } if (SkipMultiIf("null")) { col.IsNullable = true; } if (SkipMultiIf("default")) { col.DefaultValue = ParseExpression(); } ReadColumnSpecific(col); }
protected virtual void ReadCharSetCollate(ColumnStructure col) { bool any = true; while (any) { any = false; if (SkipTokenIf("collate")) { col.Collation = SkipToken(); any = true; } if (SkipMultiIf("character", "set")) { col.CharacterSet = SkipToken(); any = true; } } }
public ColumnStructure FindOrCreateColumn(IColumnStructure col) { var t = FindTable(col.Table.FullName); if (t == null) { t = AddTable(new TableStructure { FullName = col.Table.FullName }, false); } ColumnStructure res = t.FindColumn(col.ColumnName) as ColumnStructure; if (res == null) { res = new ColumnStructure(col); res.GroupId = Guid.NewGuid().ToString(); t._Columns.Add(res); } return(res); }
public override void LoadFromXml(XmlElement xml, ITableStructure source, ITableStructure target) { m_source = source; m_target = target; if (m_target == null) { var t = new TableStructure(); foreach (XmlElement e in xml.SelectNodes("Column")) { int colindex = m_source.Columns.GetIndex(e.GetAttribute("src")); m_dstIndexes.Add(colindex); var newcol = new ColumnStructure(m_source.Columns[colindex]); newcol.ColumnName = e.GetAttribute("dst"); t.AddColumn(newcol, true); } m_target = t; } else { var t = new TableStructure(); foreach (XmlElement e in xml.SelectNodes("Column")) { string colname = e.GetAttribute("src"); string dstcolname = e.GetAttribute("dst"); int pos = m_source.Columns.GetIndex(colname); if (pos < 0) { throw new InternalError(String.Format("DAE-00025 Error transforming column {0}, column not found in source table", colname)); } IColumnStructure dstcol = m_target.Columns.FirstOrDefault(col => col.ColumnName == dstcolname); if (dstcol == null) { throw new InternalError(String.Format("DAE-00026 Error transforming column {0}, column not found in destination table", dstcolname)); } m_dstIndexes.Add(pos); t.AddColumn(dstcol, true); } m_target = t; } }
public static void AlterTable(AlterPlan plan, ITableStructure oldTable, ITableStructure newTable, DbDiffOptions opts, DbObjectPairing pairing) { //plan.BeginFixedOrder(); if (oldTable == null) { throw new ArgumentNullException("oldTable", "DAE-00240 oldTable is null"); } if (newTable == null) { throw new ArgumentNullException("newTable", "DAE-00241 newTable is null"); } //bool processed; //proc.AlterTable(oldTable, newTable, out processed); //if (processed) return; InMemoryTableOperation dataOps = null; if (oldTable.FixedData != null) { dataOps = new InMemoryTableOperation(oldTable.FixedData.Structure); } NameWithSchema newTableName = GenerateNewName(oldTable.FullName, newTable.FullName, opts); bool permuteColumns = false; bool insertColumns = false; //bool renameColumns = false; List <int> columnMap = new List <int>(); List <int> constraintMap = new List <int>(); foreach (var col in newTable.Columns) { columnMap.Add(oldTable.Columns.IndexOfIf(c => c.GroupId == col.GroupId)); } foreach (var cnt in newTable.Constraints) { int cindex = oldTable.Constraints.IndexOfIf(c => c.GroupId == cnt.GroupId); if (cindex < 0 && cnt is IPrimaryKey) { // primary keys for one table are equal cindex = oldTable.Constraints.IndexOfIf(c => c is IPrimaryKey); } constraintMap.Add(cindex); } if (!opts.IgnoreColumnOrder) { // count alter requests int lastcol = -1; foreach (int col in columnMap) { if (col < 0) { continue; } if (col < lastcol) { permuteColumns = true; } lastcol = col; } bool wasins = false; foreach (int col in columnMap) { if (col < 0) { wasins = true; } if (col >= 0 && wasins) { insertColumns = true; } } } int index; // drop constraints index = 0; foreach (IConstraint cnt in oldTable.Constraints) { if (constraintMap.IndexOf(index) < 0) { plan.DropConstraint(cnt); } index++; } // drop columns index = 0; foreach (IColumnStructure col in oldTable.Columns) { if (columnMap.IndexOf(index) < 0) { plan.DropColumn(col); if (dataOps != null) { dataOps.DropColumn(col.ColumnName); } } index++; } if (!DbDiffTool.EqualFullNames(oldTable.FullName, newTable.FullName, opts)) { plan.RenameTable(oldTable, newTable.FullName); } // create columns index = 0; foreach (IColumnStructure col in newTable.Columns) { if (columnMap[index] < 0) { ColumnStructure newcol = new ColumnStructure(col); plan.CreateColumn(oldTable, newcol); if (dataOps != null) { dataOps.CreateColumn(newcol); } } index++; } // change columns index = 0; foreach (IColumnStructure col in newTable.Columns) { if (columnMap[index] >= 0) { IColumnStructure src = oldTable.Columns[columnMap[index]]; if (!DbDiffTool.EqualsColumns(src, col, true, opts, pairing)) { using (var ctx = new DbDiffChangeLoggerContext(opts, NopLogger.Instance, DbDiffOptsLogger.DiffLogger)) { if (DbDiffTool.EqualsColumns(src, col, false, opts, pairing)) { plan.RenameColumn(src, col.ColumnName); } else { plan.ChangeColumn(src, col); } if (dataOps != null && src.ColumnName != col.ColumnName) { dataOps.RenameColumn(src.ColumnName, col.ColumnName); } } } } index++; } // create fixed data script var script = AlterFixedData(oldTable.FixedData, newTable.FixedData, dataOps, opts); if (script != null) { plan.UpdateData(oldTable.FullName, script); } // change constraints index = 0; foreach (IConstraint cnt in newTable.Constraints) { if (constraintMap[index] >= 0) { IConstraint src = oldTable.Constraints[constraintMap[index]]; if (DbDiffTool.EqualsConstraints(src, cnt, opts, false, pairing) && src.Name != cnt.Name) { if (cnt is IPrimaryKey && (pairing.Source.Dialect.DialectCaps.AnonymousPrimaryKey || pairing.Target.Dialect.DialectCaps.AnonymousPrimaryKey)) { // do nothing } else { plan.RenameConstraint(src, cnt.Name); } } else { if (!DbDiffTool.EqualsConstraints(src, cnt, opts, true, pairing)) { plan.ChangeConstraint(src, cnt); } } } index++; } // create constraints index = 0; foreach (IConstraint cnt in newTable.Constraints) { if (constraintMap[index] < 0) { plan.CreateConstraint(oldTable, cnt); } index++;; } if (permuteColumns || insertColumns) { plan.ReorderColumns(oldTable, new List <string>((from c in newTable.Columns select c.ColumnName))); } var alteredOptions = GetTableAlteredOptions(oldTable, newTable, opts); if (alteredOptions.Count > 0) { plan.ChangeTableOptions(oldTable, alteredOptions); } //plan.EndFixedOrder(); }
public static void LoadQueue(Stream fr, IDataQueue queue) { try { BinaryReader br = new BinaryReader(fr); int sgn = br.ReadInt32(); if (sgn != SIGNATURE) { throw new InternalError("DAE-00021 Bad BED file"); } int ver = br.ReadInt32(); if (ver != 1 && ver != 2) { throw new InternalError("DAE-00022 Bad BED file"); } int colcnt = br.Read7BitEncodedInt(); TableStructure ts = new TableStructure(); PrimaryKey pk = new PrimaryKey(); for (int i = 0; i < colcnt; i++) { ColumnStructure col = new ColumnStructure(); col.ColumnName = br.ReadString(); if (ver >= 2) { var type = (TypeStorage)br.ReadByte(); col.DataType = type.GetDatAdminType(); var flags = (ColFlags)br.ReadByte(); if ((flags & ColFlags.ISPK) != 0) { pk.Columns.Add(new ColumnReference(col.ColumnName)); } } ts._Columns.Add(col); } if (pk.Columns.Count > 0) { ts._Constraints.Add(pk); } for (; ;) { int len = br.Read7BitEncodedInt(); if (len < 0) { break; } var rec = LoadRecord(br, ts); queue.PutRecord(rec); } queue.PutEof(); } catch (Exception e) { Errors.Report(e); queue.PutError(e); } finally { queue.CloseWriting(); } }
protected virtual void ReadColumnSpecific(ColumnStructure col) { SkipToOneOf(",", ")"); }