protected override void ApplyTypeRestrictions(BedValueHolder holder, DbTypeBase type, ILogger logger) { base.ApplyTypeRestrictions(holder, type, logger); var dtype = type as DbTypeDatetime; var htype = holder.GetFieldType(); if (dtype != null && htype != TypeStorage.DateTime) { var val = holder.GetDateTimeValue(); if (dtype.GetSpecificAttribute("mssql", "subtype") == "datetime2" && m_dialect.Version.Is_2008()) { val.MakeRestriction(m_mindatetime2, m_maxdatetime2); } else if (dtype.GetSpecificAttribute("mssql", "subtype") == "smalldatetime") { val.MakeRestriction(m_minsmalldatetime, m_maxsmalldatetime); } else if (dtype.SubType == DbDatetimeSubType.Time && m_dialect.Version.Is_2008()) { holder.SetString(val.TimePart.ToStringNormalized()); return; } else { val.MakeRestriction(m_mindatetime, m_maxdatetime); } holder.SetDateTime(val.AsDateTime); } }
public static FilterParserType GetExpressionType(DbTypeBase type) { if (type != null) { switch (type.Code) { case DbTypeCode.Int: case DbTypeCode.Numeric: case DbTypeCode.Float: return(FilterParserType.Number); case DbTypeCode.Text: case DbTypeCode.String: case DbTypeCode.Guid: case DbTypeCode.Generic: return(FilterParserType.String); case DbTypeCode.Datetime: return(FilterParserType.DateTime); case DbTypeCode.Logical: return(FilterParserType.Logical); } } return(FilterParserType.None); }
//public override object AdaptValueToType(object value, DbTypeBase type) //{ // DateTime mintimestamp = new DateTime(1970, 1, 1, 0, 0, 1); // DateTime maxtimestamp = new DateTime(2038, 1, 9, 3, 14, 7); // if (type is DbTypeDatetime && type.GetSpecificAttribute("mysql", "subtype") == "timestamp" && value is DateTime) // { // DateTime dt = (DateTime)value; // if (dt < mintimestamp) dt = mintimestamp; // if (dt > maxtimestamp) dt = maxtimestamp; // } // return base.AdaptValueToType(value, type); //} public override string GetSpecificExpression(SqlSpecialConstant specConst, DbTypeBase type, IProgressInfo progress) { if (type is DbTypeDatetime && type.GetSpecificAttribute("mysql", "subtype") == "timestamp") { switch (specConst) { case SqlSpecialConstant.Current_Timestamp: case SqlSpecialConstant.Utc_Timestamp: return("CURRENT_TIMESTAMP"); } } if (type is DbTypeDatetime && type.GetSpecificAttribute("mysql", "subtype") == "datetime") { switch (specConst) { case SqlSpecialConstant.Current_Timestamp: case SqlSpecialConstant.Current_Time: case SqlSpecialConstant.Current_Date: case SqlSpecialConstant.Utc_Timestamp: return("CURRENT_DATETIME"); //case SqlSpecialConstant.Current_Time: return "CURRENT_TIME"; //case SqlSpecialConstant.Current_Date: return "CURRENT_DATE"; //case SqlSpecialConstant.Utc_Timestamp: return "UTC_TIMESTAMP"; } } return(null); }
public override ISpecificType GenericTypeToSpecific(DbTypeBase type, IMigrationProfile profile, IProgressInfo progress) { switch (type.Code) { case DbTypeCode.Int: return(GetAccessTypeInt((DbTypeInt)type)); case DbTypeCode.String: return(GetAccessTypeString((DbTypeString)type)); case DbTypeCode.Logical: return(new AccessTypeBit()); case DbTypeCode.Datetime: return(new AccessTypeDatetime()); case DbTypeCode.Numeric: { AccessTypeDecimal res = new AccessTypeDecimal(); res.Precision = ((DbTypeNumeric)type).Precision; res.Scale = ((DbTypeNumeric)type).Scale; res.IsAutoIncrement = ((DbTypeNumeric)type).Autoincrement; return(res); } case DbTypeCode.Blob: return(new AccessTypeImage()); case DbTypeCode.Text: case DbTypeCode.Array: return(new AccessTypeText()); case DbTypeCode.Float: { DbTypeFloat tp = (DbTypeFloat)type; if (tp.IsMoney) { return(new AccessTypeMoney()); } if (tp.Bytes == 4) { return(new AccessTypeReal()); } else { return(new AccessTypeFloat()); } } case DbTypeCode.Xml: return(new AccessTypeText()); case DbTypeCode.Generic: return(new AccessTypeGeneric { Sql = ((DbTypeGeneric)type).Sql }); } throw new InternalError("DAE-00058 unknown type"); }
public override string GetHashableString(string expr, DbTypeBase type) { if (type is DbTypeDatetime) { return(String.Format("concat(year({0}), '-',month({0}), '-',day({0}), '-',hour({0}), '-',minute({0}), '-',second({0}))", expr)); } return(base.GetHashableString(expr, type)); }
private string GetLinqType(DbTypeBase type) { if (type is DbTypeXml) { return("System.Xml.Linq.XElement"); } return(type.DotNetType.FullName); }
public override DbTypeBase MigrateDataType(IColumnStructure owningColumn, DbTypeBase type, IMigrationProfile profile, IProgressInfo progress) { if (type is DbTypeString && ((DbTypeString)type).Length <= 0) { // convert to BLOB variant, MySQL doesn't support varchar(max) notation return(((DbTypeString)type).ConvertToBlobVariant()); } return(base.MigrateDataType(owningColumn, type, profile, progress)); }
protected override void ApplyTypeRestrictions(BedValueHolder holder, DbTypeBase type, ILogger logger) { var htype = holder.GetFieldType(); if (htype == TypeStorage.String) { return; // skip string restrictions } base.ApplyTypeRestrictions(holder, type, logger); }
public void LoadFromXml(XmlElement xml) { this.LoadPropertiesCore(xml); var typeElem = xml.FindElement("Type"); if (typeElem != null) { CommonType = DbTypeBase.Load(typeElem); } }
public ColumnInfo AddColumn(string columnName, string dataType, DbTypeBase commonType) { var newColumn = new ColumnInfo(this) { Name = columnName, DataType = dataType, CommonType = commonType, OwnerTable = this, }; Columns.Add(newColumn); return(newColumn); }
public override string GetHashableString(string expr, DbTypeBase type) { if (type is DbTypeDatetime) { return(String.Format("(extract(year from {0}) || '-' || " + "extract(month from {0}) || '-' || " + "extract(day from {0}) || '-' || " + "extract(hour from {0}) || '-' || " + "extract(minute from {0}) || '-' || " + "extract(second from {0}))", expr)); } return(String.Format("({0} || '')", expr)); }
public override string GetHashableString(string expr, DbTypeBase type) { if (type is DbTypeDatetime) { return(String.Format("((strftime('%Y',{0})+0) || '-' || " + "(strftime('%m',{0})+0) || '-' || " + "(strftime('%d',{0})+0) || '-' || " + "(strftime('%H',{0})+0) || '-' || " + "(strftime('%M',{0})+0) || '-' || " + "(strftime('%S',{0})+0))", expr)); } return(base.GetHashableString(expr, type)); }
public void AdaptValue(ICdlValueReader reader, DbTypeBase type, ICdlValueWriter writer, ICdlValueConvertor converter) { if (reader.GetFieldType() == TypeStorage.Null) { m_holder.SetNull(); } else { ConvertNotNullValue(reader, type, m_holder, converter); ApplyTypeRestrictions(m_holder, type); } writer.ReadFrom(m_holder); }
public override string GetSpecificExpression(SqlSpecialConstant specConst, DbTypeBase type, IProgressInfo progress) { switch (specConst) { case SqlSpecialConstant.Current_Timestamp: case SqlSpecialConstant.Current_Date: case SqlSpecialConstant.Current_Time: return("GETDATE()"); case SqlSpecialConstant.Utc_Timestamp: return("GETUTCDATE()"); } return(null); }
public override bool CreateTablePrimaryKey(ITableStructure table, IPrimaryKey pk) { DbTypeBase type = null; if (pk.Columns.Count == 1) { type = table.Columns[pk.Columns[0].ColumnName].DataType; } if (type != null && type is DbTypeInt && ((DbTypeInt)type).Autoincrement) { return(false); } return(true); }
protected override void ApplyTypeRestrictions(BedValueHolder holder, DbTypeBase type, ILogger logger) { var htype = holder.GetFieldType(); var dtype = type as DbTypeDatetime; if (dtype != null && type.GetSpecificAttribute("mysql", "subtype") == "timestamp" && htype.IsDateRelated()) { var val = holder.GetDateTimeValue(); val.MakeRestriction(m_mintimestamp, m_maxtimestamp); val.MakeValidDate(); holder.SetDateTimeEx(val); } base.ApplyTypeRestrictions(holder, type, logger); }
public DbTypeBase ToGenericType() { DbTypeBase res = ToGenericTypeNoArray(); if (IsArray) { var ar = new DbTypeArray(); ar.ElementType = res; return(ar); } else { return(res); } }
public override string GetHashableString(string expr, DbTypeBase type) { if (type is DbTypeDatetime) { return(String.Format("convert(varchar,datepart(year, {0})) + '-' + " + "convert(varchar,datepart(month, {0})) + '-' +" + "convert(varchar,datepart(day, {0})) + '-' +" + "convert(varchar,datepart(hour, {0})) + '-' +" + "convert(varchar,datepart(minute, {0})) + '-' +" + "convert(varchar,datepart(second, {0}))", expr)); } if (type is DbTypeText) { if (((DbTypeText)type).IsUnicode) { return(String.Format("convert(nvarchar,{0})", expr)); } else { return(String.Format("convert(varchar,{0})", expr)); } } if (type is DbTypeNumber || type is DbTypeLogical) { return(String.Format("convert(varchar,{0})", expr)); } if (type is DbTypeBlob) { return(String.Format("convert(varchar(8000),convert(varbinary(8000), {0}))", expr)); } if (type is DbTypeXml) { return(String.Format("convert(varchar(8000),convert(nvarchar(max),{0}))", expr)); } var stype = type as DbTypeString; if (stype != null) { if (stype.IsUnicode) { return(String.Format("convert(nvarchar(4000),{0})", expr)); } return(String.Format("convert(varchar(8000),{0})", expr)); } return(base.GetHashableString(expr, type)); }
public override ISpecificType GenericTypeToSpecific(DbTypeBase type, IMigrationProfile profile, IProgressInfo progress) { switch (type.Code) { case DbTypeCode.Int: return(GetPostgreSqlTypeInt((DbTypeInt)type)); case DbTypeCode.String: return(GetPostgreSqlTypeString((DbTypeString)type)); case DbTypeCode.Logical: return(new PostgreSqlTypeBoolean()); case DbTypeCode.Datetime: return(GetPostgreSqlTypeDatetime((DbTypeDatetime)type)); case DbTypeCode.Numeric: { PostgreSqlTypeNumeric res = new PostgreSqlTypeNumeric(); res.Precision = ((DbTypeNumeric)type).Precision; res.Scale = ((DbTypeNumeric)type).Scale; return(res); } case DbTypeCode.Blob: return(new PostgreSqlTypeBytea()); case DbTypeCode.Xml: return(new PostgreSqlTypeText()); case DbTypeCode.Text: return(GetPostgreSqlTypeText((DbTypeText)type)); case DbTypeCode.Array: return(GetPostgreSqlTypeArray((DbTypeArray)type, profile, progress)); case DbTypeCode.Float: return(GetPostgreSqlTypeFloat((DbTypeFloat)type)); case DbTypeCode.Generic: return(new PostgreSqlTypeGeneric { Sql = ((DbTypeGeneric)type).Sql }); } throw new Exception("DAE-00346 unknown type"); }
public override DbTypeBase MigrateDataType(IColumnStructure owningColumn, DbTypeBase type, IMigrationProfile profile, IProgressInfo progress) { var stype = type as DbTypeString; if (stype != null) { if (stype.Length > 255) { string msg = Texts.Get("s_reduced_column_length$column$oldlen$newlen", "column", owningColumn.Table.ToString() + "." + owningColumn.ColumnName, "oldlen", stype.Length, "newlen", 255); progress.LogMessage("TABLE", LogLevel.Warning, msg); Logging.Info(msg); stype.Length = 255; return(stype); } } return(base.MigrateDataType(owningColumn, type, profile, progress)); }
public virtual void GetNativeDataType(DbTypeBase commonType, ColumnInfo columnInfo) { switch (commonType.Code) { case DbTypeCode.Blob: columnInfo.DataType = "blob"; return; case DbTypeCode.Datetime: columnInfo.DataType = "datetime"; return; case DbTypeCode.String: var str = (DbTypeString)commonType; columnInfo.DataType = $"{str.GetStandardSqlName()}({str.Length})"; return; case DbTypeCode.Guid: columnInfo.DataType = "varchar(50)"; return; case DbTypeCode.Float: columnInfo.DataType = "float"; return; case DbTypeCode.Numeric: columnInfo.DataType = $"numeric({commonType.GetLength()},{commonType.GetScale()})"; return; case DbTypeCode.Text: case DbTypeCode.Xml: columnInfo.DataType = "nvarchar(max)"; return; case DbTypeCode.Logical: columnInfo.DataType = "int"; return; } columnInfo.DataType = "varchar(50)"; }
public override ISpecificType GenericTypeToSpecific(DbTypeBase type, IMigrationProfile profile, IProgressInfo progress) { switch (type.Code) { case DbTypeCode.Int: return(new SqliteTypeInt { IsAutoIncrement = ((DbTypeInt)type).Autoincrement }); case DbTypeCode.Logical: return(new SqliteTypeLogical()); case DbTypeCode.Float: return(new SqliteTypeReal()); case DbTypeCode.Blob: return(new SqliteTypeBlob()); case DbTypeCode.String: case DbTypeCode.Xml: case DbTypeCode.Array: return(new SqliteTypeText()); case DbTypeCode.Datetime: return(new SqliteTypeDateTime()); case DbTypeCode.Numeric: return(new SqliteTypeNumeric()); case DbTypeCode.Text: { string subtype = type.GetSpecificAttribute("sqlite", "subtype"); return(new SqliteTypeText { SpecificCode = subtype }); } break; } return(new SqliteTypeText()); }
protected virtual void ApplyTypeRestrictions(CdlValueHolder holder, DbTypeBase type) { 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(); if (dt.MakeValidDate()) { m_holder.SetDateTimeEx(dt); } } }
protected override void ApplyTypeRestrictions(CdlValueHolder holder, DbTypeBase type) { base.ApplyTypeRestrictions(holder, type); var dtt = type as DbTypeDatetime; if (dtt != null) { if (!dtt.ExtendedPrecision) { var htype = holder.GetFieldType(); if (htype.IsDateRelated()) { var dt = holder.GetDateTimeValue(); dt.Nanosecond = dt.Nanosecond / 1000000 * 1000000; switch (htype) { case TypeStorage.DateEx: holder.SetDateEx(dt.DatePart); break; case TypeStorage.TimeEx: holder.SetTimeEx(dt.TimePart); break; case TypeStorage.DateTimeEx: holder.SetDateTimeEx(dt); break; case TypeStorage.DateTime: holder.SetDateTime(dt.AsDateTime); break; } } } } }
public string GetSqlLiteral(object value, DbTypeBase type) { m_holder.ReadFrom(value); return GetSqlLiteral(m_holder, type); }
public string GetSqlLiteral(ICdlValueReader reader, DbTypeBase type) { //m_literalFormatter.TargetType = type; m_literalFormatter.ReadFrom(reader); return m_literalFormatter.GetText(); }
protected virtual void ConvertNotNullValue(ICdlValueReader reader, DbTypeBase type, CdlValueHolder valueHolder, ICdlValueConvertor converter) { converter.ConvertValue(reader, type.DefaultStorage, valueHolder); }
public override ISpecificType GenericTypeToSpecific(DbTypeBase type, IMigrationProfile profile, IProgressInfo progress) { switch (type.Code) { case DbTypeCode.Int: return(GetEfzTypeInt((DbTypeInt)type)); case DbTypeCode.String: return(GetEfzTypeString((DbTypeString)type)); case DbTypeCode.Logical: return(new EfzTypeBoolean()); case DbTypeCode.Datetime: { string attr = type.GetSpecificAttribute("effiproz", "subtype"); var dtype = type as DbTypeDatetime; if (attr == "timestamp") { var res = new EfzTypeTimestamp(); res.Precision = Int32.Parse(type.GetSpecificAttribute("effiproz", "precision")); return(res); } if (attr == "yeartomonth") { var res = new EfzTypeIntervalYearToMonth(); //res.Precision = Int32.Parse(type.GetSpecificAttribute("effiproz", "precision")); return(res); } if (attr == "daytosecond") { var res = new EfzTypeIntervalDayToSecond(); //res.Precision = Int32.Parse(type.GetSpecificAttribute("effiproz", "precision")); return(res); } if (attr == "date") { var res = new EfzTypeDate(); return(res); } switch (dtype.SubType) { case DbDatetimeSubType.Date: return(new EfzTypeDate()); case DbDatetimeSubType.Datetime: if (dtype.HasTimeZone) { return(new EfzTypeTimestampTz()); } else { return(new EfzTypeTimestamp()); } case DbDatetimeSubType.Interval: return(new EfzTypeIntervalDayToSecond()); case DbDatetimeSubType.Time: return(new EfzTypeTimestamp()); case DbDatetimeSubType.Year: return(new EfzTypeDate()); } return(new EfzTypeTimestamp()); } case DbTypeCode.Numeric: { var res = new EfzTypeNumber(); res.Precision = ((DbTypeNumeric)type).Precision; res.Scale = ((DbTypeNumeric)type).Scale; res.IsIdentity = ((DbTypeNumeric)type).Autoincrement; int increment; if (Int32.TryParse(type.GetSpecificAttribute("effiproz", "identity_increment"), out increment)) { res.IdentityIncrement = increment; res.IdentitySeed = Int32.Parse(type.GetSpecificAttribute("effiproz", "identity_seed")); } return(res); } case DbTypeCode.Blob: { var res = new EfzTypeBlob(); string size = type.GetSpecificAttribute("effiproz", "maxbytes"); if (size != null) { res.MaxBytes = Int32.Parse(size); } return(res); } case DbTypeCode.Text: { var res = new EfzTypeClob(); string size = type.GetSpecificAttribute("effiproz", "maxbytes"); if (size != null) { res.MaxBytes = Int32.Parse(size); } return(res); } case DbTypeCode.Array: return(new EfzTypeClob()); case DbTypeCode.Float: return(new EfzTypeDouble()); case DbTypeCode.Xml: return(new EfzTypeClob()); case DbTypeCode.Generic: return(new EfzTypeGeneric { Sql = ((DbTypeGeneric)type).Sql }); } throw new Exception("DAE-00323 unknown type"); }
protected override void ConvertNotNullValue(Common.CommonDataLayer.ICdlValueReader reader, DbTypeBase type, Common.CommonDataLayer.CdlValueHolder valueHolder, Common.CommonDataLayer.ICdlValueConvertor converter) { if (type is DbTypeDatetime) { converter.ConvertValue(reader, TypeStorage.DateTime, valueHolder); } else { base.ConvertNotNullValue(reader, type, valueHolder, converter); } }
//public override bool IsSystemTable(string schema, string table) //{ // return table.Contains("$") || table == "HELP"; //} public override ISpecificType GenericTypeToSpecific(DbTypeBase type, IMigrationProfile profile, IProgressInfo progress) { switch (type.Code) { case DbTypeCode.Array: return(new OracleTypeClob()); case DbTypeCode.Blob: if (type.GetSpecificAttribute("oracle", "subtype") == "longraw") { return(new OracleTypeLongRaw()); } return(new OracleTypeBlob()); case DbTypeCode.Datetime: { var dtype = (DbTypeDatetime)type; string subtype = type.GetSpecificAttribute("oracle", "subtype"); if (subtype == "timestamp") { var res = new OracleTypeTimestamp(); try { res.TimeZone = (TimeZoneType)Enum.Parse(typeof(TimeZoneType), type.GetSpecificAttribute("oracle", "timezone"), true); } catch { res.TimeZone = TimeZoneType.None; } string fprec = type.GetSpecificAttribute("oracle", "fractionalprecision"); if (fprec != null) { res.FractionalPrecision = Int32.Parse(fprec); } return(res); } if (subtype == "yeartomonth") { var res = new OracleTypeIntervalYearToMonth(); string yprec = type.GetSpecificAttribute("oracle", "yearprecision"); if (yprec != null) { res.YearPrecision = Int32.Parse(yprec); } return(res); } if (subtype == "daytosecond") { var res = new OracleTypeIntervalDayToSecond(); string dprec = type.GetSpecificAttribute("oracle", "dayprecision"); string fprec = type.GetSpecificAttribute("oracle", "fractionalprecision"); if (dprec != null) { res.DayPrecision = Int32.Parse(dprec); } if (fprec != null) { res.FractionalPrecision = Int32.Parse(fprec); } return(res); } if (dtype.SubType == DbDatetimeSubType.Interval) { return(new OracleTypeIntervalDayToSecond()); } return(new OracleTypeDate()); } case DbTypeCode.Float: if (type.GetSpecificAttribute("oracle", "subtype") == "number") { return(new OracleTypeNumber()); } if (((DbTypeFloat)type).Bytes == 4) { return(new OracleTypeBinaryFloat()); } return(new OracleTypeBinaryDouble()); case DbTypeCode.Generic: return(new OracleTypeGeneric { Sql = ((DbTypeGeneric)type).Sql }); case DbTypeCode.Int: { string ilen = type.GetSpecificAttribute("oracle", "length"); if (ilen != null) { return new OracleTypeNumber { Precision = Int32.Parse(ilen) } } ; } return(new OracleTypeInteger()); case DbTypeCode.Logical: return(new OracleTypeInteger()); case DbTypeCode.Numeric: { var ntype = (DbTypeNumeric)type; if (type.GetSpecificAttribute("oracle", "noprec") == "1") { return new OracleTypeNumber { Scale = ntype.Scale } } ; return(new OracleTypeNumber { Precision = ntype.Precision, Scale = ntype.Scale }); } case DbTypeCode.String: { string subtype = type.GetSpecificAttribute("oracle", "subtype"); if (subtype != null) { switch (subtype) { case "rowid": return(new OracleTypeRowId()); case "urowid": return(new OracleTypeURowId()); case "mlslabel": return(new OracleTypeMlsLabel()); case "bfile": return(new OracleTypeBFile()); } } var stype = (DbTypeString)type; if (stype.IsBinary) { return new OracleTypeRaw { Length = stype.Length } } ; if (stype.IsVarLength) { if (stype.IsUnicode) { return new OracleTypeNVarChar2 { Length = stype.Length } } ; else { return new OracleTypeVarChar2 { Length = stype.Length } }; } else { if (stype.IsUnicode) { return new OracleTypeNChar { Length = stype.Length } } ; else { return new OracleTypeChar { Length = stype.Length } }; } } case DbTypeCode.Text: if (type.GetSpecificAttribute("oracle", "subtype") == "long") { return(new OracleTypeLong()); } if (((DbTypeText)type).IsUnicode) { return(new OracleTypeNClob()); } else { return(new OracleTypeClob()); } case DbTypeCode.Xml: return(new OracleTypeXml()); } throw new Exception("DAE-00342 unknown type"); }