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