public override void GenerateSql(ISqlDumper dmp, DbTypeBase targetType) { FunctionName.GenerateSql(dmp); dmp.Put("%:s", LeftBracket, "("); Arguments.GenerateSql(dmp); dmp.Put("%:s", RightBracket, ")"); }
public override void GenerateSql(ISqlDumper dmp, DbTypeBase targetType) { foreach (var qal in Qualificators) { qal.GenerateSql(dmp); } Name.GenerateSql(dmp); }
public static DbTypeBase Load(XmlElement xml) { DbTypeCode code = (DbTypeCode)Enum.Parse(typeof(DbTypeCode), xml.GetAttribute("datatype"), true); DbTypeBase res = DbTypeBase.CreateType(code); res.LoadFromXml(xml); return(res); }
public override void GenerateSql(ISqlDumper dmp, DbTypeBase targetType) { for (int i = 0; i < UnaryMarks.Length; i++) { dmp.Put("&s%:k", UnaryMarks[i], Operator.Tokens[i]); } Inner.GenerateSql(dmp, targetType); }
public override void GenerateSql(ISqlDumper dmp, DbTypeBase targetType) { Value.GenerateSql(dmp); dmp.Put("&s%:k", BetweenPos, "between"); LowerBound.GenerateSql(dmp); dmp.Put("&s%:k", AndPos, "and"); UpperBound.GenerateSql(dmp); }
//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); }
public virtual DbTypeBase MigrateDataType(IColumnStructure owningColumn, DbTypeBase type, IMigrationProfile profile, IProgressInfo progress) { ISpecificType spectype = GenericTypeToSpecific(type, profile, progress); //if (!DialectCaps.Arrays && type.ArraySpec.IsArray) //{ // return new DbTypeText(); // migrate arrays as text blob //} return(spectype.ToGenericType()); }
// GenerateSql can return NULL, if SQL cannot be generated for given dialect public string GenerateSql(ISqlDialect dialect, DbTypeBase targetType, IProgressInfo progress) { try { return(dialect.GenerateScript(dmp => { dmp.ProgressInfo = progress; GenerateSql(dmp, targetType); })); } catch (SyntaxNotSupportedError) { return(null); } }
public override void GenerateSql(ISqlDumper dmp, DbTypeBase targetType) { if (targetType is DbTypeLogical) { dmp.Put("%:s", Original, dmp.Dialect.GetSqlLiteral(m_value != 0)); } else { dmp.Put("&s%:s", Original, m_value.ToString(CultureInfo.InvariantCulture)); } }
private void LoadInternal(XmlElement xml) { m_dataType = DbTypeBase.Load(xml); XmlTool.LoadSpecificAttributes(SpecificData, "colspec.", xml); var defval = xml.FindElement("Default"); if (defval != null) { m_defaultValue = SqlExpression.Load(defval); } Domain = NameWithSchema.LoadFromXml(xml, "domain."); }
public override void GenerateSql(ISqlDumper dmp, DbTypeBase targetType) { if (m_dialect == null) { dmp.Put("%:s", Original, m_expr); return; } if (dmp.Dialect.DialectName != m_dialect) { throw new SyntaxNotSupportedError("DAE-00250 Specific expression has other target dialect"); } dmp.Put("%:s", Original, m_expr); }
public void AdaptValue(IBedValueReader reader, DbTypeBase type, IBedValueWriter writer, IBedValueConvertor converter, ILogger logger) { if (reader.GetFieldType() == TypeStorage.Null) { m_holder.SetNull(); } else { converter.ConvertValue(reader, type.DefaultStorage, m_holder); ApplyTypeRestrictions(m_holder, type, logger); } writer.ReadFrom(m_holder); }
public override void GenerateSql(ISqlDumper dmp, DbTypeBase targetType) { string expr = dmp.Dialect.GetSpecificExpression(m_specConst, targetType, dmp.ProgressInfo); if (expr != null) { dmp.Put("%:s", Original, expr); } else { throw new SyntaxNotSupportedError("DAE-00249 Specific constant not supported"); } }
public DomainStructure(XmlElement xml) : base(xml) { //this.LoadProperties(xml); SpecificData = XmlTool.LoadParameters(xml); FullName = NameWithSchema.LoadFromXml(xml); DataType = DbTypeBase.Load(xml); var defval = xml.FindElement("Default"); if (defval != null) { DefaultValue = SqlExpression.Load(defval); } }
public ColumnStructure(IColumnStructure src) : base(src) { m_columnName = src.ColumnName; m_dataType = src.DataType.Clone(); m_isNullable = src.IsNullable; m_defaultValue = src.DefaultValue; m_characterSet = src.CharacterSet; m_collation = src.Collation; SpecificData.AddAll(src.SpecificData); //TableName = src.Table; //Table = src.Table; Domain = src.Domain; }
public override void GenerateSql(ISqlDumper dmp, DbTypeBase targetType) { dmp.Put("&s%:k", CasePos, "case"); CaseVal.GenerateSql(dmp); foreach (var when in Whens) { when.GenerateSql(dmp); } if (ElseVal != null) { dmp.Put("&s%:k", ElsePos, "else"); ElseVal.GenerateSql(dmp); } dmp.Put("&s%:k", EndPos, "end"); }
public static bool EqualTypes(DbTypeBase t1, DbTypeBase t2, DbDiffOptions opts) { if (!opts.IgnoreSpecificData && !t1.SpecificData.EqualsDictionary(t2.SpecificData, opts.IgnoreDataTypeProperties)) { opts.DiffLogger.Trace("Types {0}, {1}: different specific data: {2}; {3}", t1, t2, t1.SpecificData.Format(), t2.SpecificData.Format()); return(false); } if (t1.Code != t2.Code) { opts.DiffLogger.Trace("Types {0}, {1}: different type code: {2}; {3}", t1, t2, t1.Code, t2.Code); return(false); } if (!XmlTool.PropertiesEquals(t1, t2, opts.DiffLogger)) { return(false); } return(true); }
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)); } } } }
public override void GenerateSql(ISqlDumper dmp, DbTypeBase targetType) { if (dmp.Dialect.PossibleKeywords.Contains(Identifier.ToUpper())) { // we cannot change quoting if (IsQuoted) { dmp.Put("&s%:s", Original, dmp.Dialect.QuoteIdentBegin + Identifier + dmp.Dialect.QuoteIdentEnd); } else { dmp.Put("&s%:s", Original, Identifier); } } else { dmp.Put("&s%:i", Original, Identifier); } }
public override void GenerateSql(ISqlDumper dmp, DbTypeBase targetType) { switch (Token) { case TokenType.StringSingle: dmp.Put("%:v", Original, Data); break; case TokenType.QuotedIdent: var old = dmp.FormatProperties.IdentifierQuoteMode; dmp.FormatProperties.IdentifierQuoteMode = SqlIdentifierQuoteMode.Quoted; dmp.Put("%:v", Original, Data); dmp.FormatProperties.IdentifierQuoteMode = old; break; case TokenType.StringDouble: dmp.Put("%:s", Original, '"' + Data + '"'); break; } }
protected virtual void ApplyTypeRestrictions(BedValueHolder holder, DbTypeBase type, ILogger logger) { var stype = type as DbTypeString; var htype = holder.GetFieldType(); if (stype != null && htype == TypeStorage.String) { string sval = holder.GetString(); if (stype.Length > 0 && sval.Length > stype.Length) { sval = sval.Substring(0, stype.Length); holder.SetString(sval); } } if (htype.IsDateRelated() && !m_allowZeroInDate) { var dt = holder.GetDateTimeValue(); dt.MakeValidDate(); m_holder.SetDateTimeEx(dt); } }
public static ISpecificType GenericTypeToSpecific(this ISqlDialect dialect, DbTypeBase type) { return(dialect.GenericTypeToSpecific(type, null, null)); }
public override void GenerateSql(ISqlDumper dmp, DbTypeBase targetType) { dmp.Put("&s%:s", Original, "*"); }
//public virtual string Symbols { get { return "()=+-<>*/"; } } public virtual string GetSpecificExpression(SqlSpecialConstant specConst, DbTypeBase type, IProgressInfo progress) { return(null); }
public virtual ISpecificType CreateSpecificTypeInstance(object enumValue) { return(DbTypeBase.CreateType((DbTypeCode)enumValue)); }
public abstract void GenerateSql(ISqlDumper dmp, DbTypeBase targetType);
public virtual bool SupportsColumnCollation(DbTypeBase coltype) { return(false); }
public override void GenerateSql(ISqlDumper dmp, DbTypeBase targetType) { dmp.Put("%:s", LeftBracket, "("); Inner.GenerateSql(dmp); dmp.Put("%:s", RightBracket, ")"); }
public override void GenerateSql(ISqlDumper dmp, DbTypeBase targetType) { dmp.Put("%:v", Original, m_value); }
public override void GenerateSql(ISqlDumper dmp, DbTypeBase targetType) { dmp.Put("^:null", Original); }