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