public DbSchema GetSchema()
{
var schema = new DbSchema();
var map = _configuration.BuildMapping();
var mappings = _configuration.ClassMappings;
foreach(var class_map in mappings)
{
var table = class_map.Table;
var table_schema = new TableSchema() {TableName = table.Name, SchemaName = table.Schema};
foreach (var column in table.ColumnIterator)
{
var type_code = column.GetSqlTypeCode(map);
var columnSchema = new ColumnSchema()
{
TableName = table_schema.TableName,
ColumnName = column.Name,
IsNullable = column.IsNullable,
DatabaseType = type_code.DbType,
Size = column.Length,
Scale = column.Scale,
Precision = column.Precision,
IsPrimaryKey = table.PrimaryKey.Columns.Contains(column)
};
// columnSchema.DatabaseType = property.GetSqlTypeCode(map).DbType;
table_schema.AddColumn(columnSchema);
}
schema.AddTable(table_schema);
}
return schema;
}
public override string BuildAlterColumnCommand(ColumnSchema schema)
{
string sql = String.Format(
@"ALTER TABLE {0} ALTER COLUMN {1}",
Api.CommandBuilder.QuoteIdentifier(schema.TableName),
ColumnSqlCommand(schema)
);
return sql;
}
public string GetColumnSize(ColumnSchema column)
{
string columnSize = column.Size.ToString();
if (column.NativeType == "numeric" && column.Precision != 0)
{
columnSize += "(" + column.Precision.ToString() + "," + column.Scale + ")";
}
return columnSize;
}
public string GetPropertyName(ColumnSchema column)
{
string propertyName = column.Name;
if (propertyName == column.Table.Name + "Name") return "Name";
if (propertyName == column.Table.Name + "Description") return "Description";
if (propertyName.EndsWith("TypeCode")) propertyName = propertyName.Substring(0, propertyName.Length - 4);
return propertyName;
}
/// <summary>
/// Helper for class generation from tables, converts a column name into a Property Name
/// </summary>
/// <param name="column"> Column to be converted</param>
/// <param name="prefix">Add characters to column</param>
/// <param name="strip">remove characters from column</param>
/// <returns>string</returns>
public static string GetPropertyNameFromColumn(ColumnSchema column, string prefix, string strip)
{
if (strip != string.Empty)
{
return prefix + column.Name.Replace(strip, "").ToCSharpIdentifier().ToPascalCase();
}
else
{
return prefix + column.Name.ToCSharpIdentifier().ToPascalCase();
}
}
public string GetReaderMethod(ColumnSchema column)
{
switch (column.DataType)
{
case DbType.Byte:
{
return "GetByte";
}
case DbType.Int16:
{
return "GetInt16";
}
case DbType.Int32:
{
return "GetInt32";
}
case DbType.Int64:
{
return "GetInt64";
}
case DbType.AnsiStringFixedLength:
case DbType.AnsiString:
case DbType.String:
case DbType.StringFixedLength:
{
return "GetString";
}
case DbType.Boolean:
{
return "GetBoolean";
}
case DbType.Guid:
{
return "GetGuid";
}
case DbType.Currency:
case DbType.Decimal:
{
return "GetDecimal";
}
case DbType.DateTime:
case DbType.Date:
{
return "GetDateTime";
}
default:
{
return "__SQL__" + column.DataType;
}
}
}
/// <summary>
/// Builds the column.
/// </summary>
/// <param name="dr">The dr.</param>
/// <returns></returns>
private ColumnSchema BuildColumn(DataRowView dr)
{
ColumnSchema ci = new ColumnSchema();
ci.Ordinal = (int)dr["column_id"];
ci.Alias = (string)dr["column_name"];
ci.Name = (string)dr["column_name"];
ci.DataTypeId = (int)dr["user_type_id"];
ci.DataType = ((string)dr["type_name"]).ToLower();
Type netType = convertor.DataBaseTypeToNetType(ci.DataType);
ci.NetType = netType.FullName;
ci.DbDataType = convertor.NetTypeToDbType(netType);
ci.Length = (short)dr["max_length"];
ci.Precision = (byte)dr["precision"];
ci.Scale = (byte)dr["scale"];
if (ci.DataType.StartsWith("n"))
{
ci.Length = ci.Length / 2;
ci.DataTypeFull = string.Format("[{0}]({1})",
ci.DataType,
ci.Length);
}
else if (ci.DataType == "decimal" || ci.DataType == "numeric")
{
ci.DataTypeFull = string.Format("[{0}]({1},{2})",
ci.DataType,
ci.Precision,
ci.Scale);
}
else
{
ci.DataTypeFull = string.Format("[{0}]", ci.DataType);
}
ci.AllowNulls = (bool)dr["is_nullable"];
ci.IsAutoIncrement = (bool)dr["is_identity"];
ci.IsReadOnly = (bool)dr["is_computed"];
ci.IsForeignKey = false;
ci.IsPrimaryKey = false;
ci.IsUnique = false;
return(ci);
}
public static string GetCType(ColumnSchema column)
{
if (column.Description.Trim().StartsWith("enum", System.StringComparison.OrdinalIgnoreCase) && column.Description.Trim().Length > 6)
{
if (column.AllowDBNull)
{
return(string.Format("{0}", column.Description.Trim().Substring(5)));
}
else
{
return(string.Format("{0}", column.Description.Trim().Substring(5)));
}
}
return(GetCType(column.DataType, column.AllowDBNull));
}
private HashMappedList <string, ColumnSchema> GetUnionColumns()
{
if (this._unionCorresponding || (this._leftQueryExpression == null))
{
HashMappedList <string, ColumnSchema> columnList = ((TableDerived)this.ResultTable).ColumnList;
HashMappedList <string, ColumnSchema> list3 = new HashMappedList <string, ColumnSchema>();
for (int i = 0; i < this.UnionColumnMap.Length; i++)
{
ColumnSchema schema = columnList.Get(i);
list3.Add(schema.GetName().Name, schema);
}
return(list3);
}
return(this._leftQueryExpression.GetUnionColumns());
}
public EntityBase GetEntityBaseFromColumn(ColumnSchema column)
{
if (MemberMap.ContainsKey(column))
{
return(MemberMap[column]);
}
else if (AssociationMap.ContainsKey(column))
{
return(AssociationMap[column]);
}
else
{
return(null);
}
}
/// <summary>
/// Returns the name of the public property for a given column.
/// </summary>
/// <param name="column"></param>
/// <returns></returns>
public string GetPropertyName(ColumnSchema column)
{
string propertyName = column.Name;
if (propertyName == String.Format("{0}Name", column.Table.Name))
{
return("Name");
}
if (propertyName == String.Format("{0}Description", column.Table.Name))
{
return("Description");
}
return(propertyName);
}
protected virtual string CreateColumnString(string objectName, ColumnSchema schema)
{
if (schema.SqlType == null)
{
throw new ArgumentNullException($"SqlType of column {schema.Name} cannot be null");
}
return(string.Join(" ", new[]
{
CreateNameString(schema),
CreateTypeString(schema) + CreateSizeAppendString(schema),
CreateNullableString(schema),
CreateDefaultValueString(objectName, schema),
}));
}
/// <summary>
/// Creates a method that sets a nullable column to null.
/// </summary>
/// <param name="tableSchema">A description of the table.</param>
/// <param name="columnSchema">A description of the column.</param>
public SetNullMethod(TableSchema tableSchema, ColumnSchema columnSchema)
{
// /// <summary>
// /// Sets the Null property of the RaceCode column.
// /// </summary>
// public void SetRaceCodeNull() {
// this[this.tableEmployee.RaceCodeColumn] = global::System.DBNull.Value;
// }
this.Comments.Add(new CodeCommentStatement("<summary>", true));
this.Comments.Add(new CodeCommentStatement(String.Format("Sets the Null property of the {0} column.", columnSchema.Name), true));
this.Comments.Add(new CodeCommentStatement("</summary>", true));
this.Attributes = MemberAttributes.Public | MemberAttributes.Final;
this.Name = String.Format("Set{0}Null", columnSchema.Name);
this.Statements.Add(new CodeAssignStatement(new CodeIndexerExpression(new CodeThisReferenceExpression(), new CodePropertyReferenceExpression(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), String.Format("table{0}", tableSchema.Name)), String.Format("{0}Column", columnSchema.Name))), new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(DBNull)), "Value")));
}
public string GetReaderAssignmentStatement(ColumnSchema column, int index)
{
string statement = "if (!reader.IsDBNull(" + index.ToString() + ")) ";
statement += this.GetMemberVariableName(column) + " = ";
if (column.Name.EndsWith("TypeCode"))
{
statement += "(" + column.Name + ")";
}
statement += "reader." + this.GetReaderMethod(column) + "(" + index.ToString() + ");";
return(statement);
}
public bool PrecisionMatters(ColumnSchema column)
{
switch (column.DataType)
{
case DbType.Decimal:
{
return(true);
}
default:
{
return(false);
}
}
}
public static bool IsChildFKColumn(ColumnSchema column, TableSchema table)
{
foreach (ReferenceSchema inReference in table.InReferences)
{
foreach (ReferenceJoin join in inReference.Joins)
{
//Found the child Column...
if (join.ChildColumn.ObjectID == column.ObjectID)
{
return true;
}
}
}
return false;
}
/// <summary>
/// Builds the column.
/// </summary>
/// <param name="dr">The dr.</param>
/// <param name="rs">The rs.</param>
/// <returns></returns>
private ColumnSchema BuildColumn(DataRowView dr, DataRow rs)
{
var ci = new ColumnSchema();
ci.Ordinal = (int)rs["ColumnOrdinal"];
ci.Name = ci.Alias = (string)rs["ColumnName"];
ci.DataTypeId = (int)rs["ProviderType"];
ci.DataType = ((string)rs["DataTypeName"]).ToLower();
var netType = (Type)rs["DataType"];
ci.NetType = netType.FullName;
ci.DbDataType = _convertor.NetTypeToDbType(netType);
ci.Length = (int)rs["ColumnSize"];
ci.Precision = (byte)GetShort(rs["NumericPrecision"]);
ci.Scale = (byte)GetShort(rs["NumericScale"]);
if (ci.DataType.StartsWith("n"))
{
ci.Length = ci.Length / 2;
ci.DataTypeFull = string.Format("[{0}]({1})",
ci.DataType,
ci.Length);
}
else if (ci.DataType == "decimal" || ci.DataType == "numeric")
{
ci.DataTypeFull = string.Format("[{0}]({1},{2})",
ci.DataType,
ci.Precision,
ci.Scale);
}
else
{
ci.DataTypeFull = string.Format("[{0}]", ci.DataType);
}
ci.AllowNulls = (bool)rs["AllowDBNull"];
ci.IsAutoIncrement = (bool)rs["IsAutoIncrement"];
ci.IsReadOnly = (bool)rs["IsReadOnly"];
ci.IsForeignKey = false;
ci.IsPrimaryKey = (bool)rs["IsKey"];
ci.IsUnique = (bool)rs["IsUnique"];
return(ci);
}
public string GetPopulateType(ColumnSchema column)
{
string ret = string.Empty;
if (column.Description.Trim().StartsWith("enum", System.StringComparison.OrdinalIgnoreCase) && column.Description.Trim().Length > 6)
{
ret = string.Format("{0}", column.Description.Trim().Substring(5));
ret = string.Format("({0})({1})", ret, GetCType(column.DataType, false));
}
else
{
ret = string.Format("({0})", GetCType(column.DataType, column.AllowDBNull));
}
return(ret);
}
/// <summary>
/// Creates a method that checks whether a given nullable column has a null value.
/// </summary>
/// <param name="tableSchema">A description of the table.</param>
/// <param name="columnSchema">A description of the column.</param>
public IsNullMethod(TableSchema tableSchema, ColumnSchema columnSchema)
{
// /// <summary>
// /// Gets the Null property of the RaceCode column.
// /// </summary>
// public bool IsRaceCodeNull() {
// return (this[this.tableEmployee.RaceCodeColumn] == global::System.DBNull.Value);
// }
this.Comments.Add(new CodeCommentStatement("<summary>", true));
this.Comments.Add(new CodeCommentStatement(String.Format("Gets the Null property of the {0} column.", columnSchema.Name), true));
this.Comments.Add(new CodeCommentStatement("</summary>", true));
this.Attributes = MemberAttributes.Public | MemberAttributes.Final;
this.ReturnType = new CodeGlobalTypeReference(typeof(bool));
this.Name = String.Format("Is{0}Null", columnSchema.Name);
this.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(new CodeIndexerExpression(new CodeThisReferenceExpression(), new CodePropertyReferenceExpression(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), String.Format("table{0}", tableSchema.Name)), String.Format("{0}Column", columnSchema.Name))), CodeBinaryOperatorType.IdentityEquality, new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(DBNull)), "Value"))));
}
public void ConvertArgsToSql(Session session, object[] callArguments, object[] data)
{
int num = this.CSharpMethodWithConnection ? 1 : 0;
SqlType[] parameterTypes = this.GetParameterTypes();
for (int i = 0; i < callArguments.Length; i++)
{
object a = data[i + num];
ColumnSchema parameter = this.GetParameter(i);
if (((parameter.ParameterMode != 1) && (parameter.ParameterMode != 4)) && (parameter.ParameterMode != 2))
{
a = ((Array)a).GetValue(0);
}
callArguments[i] = parameterTypes[i].ConvertCSharpToSQL(session, a);
}
}
/// <summary>
/// Add a range partition split. The split row must fall in a range partition,
/// and causes the range partition to split into two contiguous range partitions.
/// </summary>
/// <param name="configure">A delegate to configure the split row.</param>
public TableBuilder AddSplitRow(Action <PartialRowOperation> configure)
{
// TODO: Rework this
var columns = _createTableRequest.Schema.Columns
.Select(c => ColumnSchema.FromProtobuf(c))
.ToList();
var schema = new KuduSchema(columns);
var splitRow = new PartialRowOperation(schema, RowOperation.SplitRow);
configure(splitRow);
_splitRowsRangeBounds.Add(splitRow);
return(this);
}
private bool AllowDBNull(ColumnSchema col)
{
if (!col.AllowDBNull)
{
return(false);
}
var type = col.SystemType;
if (type.IsValueType && !type.Name.EndsWith("String"))
{
return(true);
}
return(false);
}
public bool IsCompatible(UtlDataReader reader)
{
if (reader.FieldCount != this._dataTypes.Length)
{
return(false);
}
for (int i = 0; i < reader.FieldCount; i++)
{
ColumnSchema column = this._table.GetColumn(i);
if ((reader.GetDataTypeName(i).ToUpper() != column.DataType.GetNameString()) || (reader.GetName(i).ToUpper() != column.ColumnName.Name))
{
return(false);
}
}
return(true);
}
public Table MakeTable(Database database, DataTable dataTable)
{
QNameManager.QName name = database.NameManager.NewQName(dataTable.TableName.ToUpper(), false, 3);
Table table = new Table(database, name, 11);
foreach (DataColumn column in dataTable.Columns)
{
QNameManager.QName name1 = database.NameManager.NewQName(column.ColumnName.ToUpper(), false, 9);
name1.schema = SqlInvariants.ModuleQname;
name1.Parent = name;
ColumnSchema schema = new ColumnSchema(name1, Types.GetParameterSqlType(column.DataType), column.AllowDBNull, false, null);
table.AddColumn(schema);
}
table.CreatePrimaryKey();
return(table);
}
public string ToDefaultValue(ColumnSchema column)
{
var result = string.Empty;
switch (column.DataType)
{
case DbType.Guid:
result = Guid.Empty.ToString();
break;
case DbType.AnsiString:
case DbType.AnsiStringFixedLength:
case DbType.String:
case DbType.StringFixedLength:
result = "string.Empty";
break;
case DbType.Boolean:
result = "false";
break;
case DbType.Date:
case DbType.DateTime:
result = "DateTime.MaxValue";
break;
case DbType.Currency:
case DbType.Decimal:
case DbType.Double:
result = "0";
break;
case DbType.Int16:
case DbType.Int32:
case DbType.Int64:
case DbType.Single:
result = "0";
break;
default:
result = "string.Empty";
break;
}
return(result);
}
ExplorerItem GetColumnItem(ColumnSchema column)
{
var memberType = UseProviderSpecificTypes ? (column.ProviderSpecificType ?? column.MemberType) : column.MemberType;
var sqlName = (string)_sqlBuilder.Convert(column.ColumnName, ConvertType.NameToQueryField);
return(new ExplorerItem(
column.MemberName,
ExplorerItemKind.Property,
column.IsPrimaryKey ? ExplorerIcon.Key : ExplorerIcon.Column)
{
Text = $"{column.MemberName} : {memberType}",
ToolTipText = $"{sqlName} {column.ColumnType} {(column.IsNullable ? "NULL" : "NOT NULL")}{(column.IsIdentity ? " IDENTITY" : "")}",
DragText = column.MemberName,
SqlName = sqlName,
SqlTypeDeclaration = $"{column.ColumnType} {(column.IsNullable ? "NULL" : "NOT NULL")}{(column.IsIdentity ? " IDENTITY" : "")}",
});
}
public bool IsCompatible(DataTable dataTable)
{
if (dataTable.Columns.Count != this._dataTypes.Length)
{
return(false);
}
for (int i = 0; i < dataTable.Columns.Count; i++)
{
DataColumn column = dataTable.Columns[i];
ColumnSchema schema = this._table.GetColumn(i);
if ((Types.GetParameterSqlType(column.DataType).TypeCode != schema.DataType.TypeCode) || (column.ColumnName.ToUpper() != schema.ColumnName.Name))
{
return(false);
}
}
return(true);
}
public override void Generate(StringBuilder builder)
{
var viewModelName = this.Model.Name.EndsWith("Info", StringComparison.OrdinalIgnoreCase)
? this.Model.Name : (this.Model.Name + "Info");
viewModelName = viewModelName.StartsWith("vw_", StringComparison.OrdinalIgnoreCase) ?
viewModelName.Substring(3) : viewModelName;
var dtoModeName = this.Model.Name + "Dto";
if (DBGlobalService.UseAutoMapper)
{
builder.AppendFormat("Mapper.CreateMap<{0}, {1}>();", dtoModeName, viewModelName);
}
else
{
//var entityName = Helper.GetClassName(dtoModeName);
var varDtoName = "dto";// Helper.GetVarName(dtoModeName);
ColumnSchema keyColumn = null;
foreach (var f in this.ColumnSetNode.Columns)
{
if (f.IsPK)
{
keyColumn = f;
break;//一般只有一个pk，其他情况暂不处理
}
}
builder.AppendLine(" public static " + viewModelName + " ConvertTo" + viewModelName + "(" +
dtoModeName + " " + varDtoName + " )");
builder.AppendLine(" {");
builder.AppendLine(" return new " + viewModelName + "()" + "{");
foreach (FieldType field in this.Model.Fields.OrderBy(x => x.Name).ToList())
{
//if (field.Name.Value == keyColumn.Name)
// continue;
builder.AppendLine(string.Format(" {0} = dto.{0},", field.Name, varDtoName));
}
builder.AppendLine(" };");
builder.Append(" }");
}
base.Generate(builder);
}
public string GetMemberVariableDeclarationStatement(string protectionLevel, ColumnSchema column)
{
string statement = protectionLevel + " ";
statement += this.GetCSharpVariableType(column) + " " + this.GetMemberVariableName(column);
string defaultValue = this.GetMemberVariableDefaultValue(column);
if (defaultValue != "")
{
statement += " = " + defaultValue;
}
statement += ";";
return(statement);
}
/// <summary>
/// Builds the primary keys.
/// </summary>
private void BuildPrimaryKeys()
{
// Get the primary key information
DataTable pkeys = GetOleDbSchema(OleDbSchemaGuid.Primary_Keys, "", _schemaFilter, "", "");
foreach (DataRow dr in pkeys.Rows)
{
TableSchema tableSchema;
if (result.Tables.TryGetValue(dr["TABLE_NAME"].ToString(), out tableSchema))
{
ColumnSchema columnSchema = tableSchema[dr["COLUMN_NAME"].ToString()];
columnSchema.IsPrimaryKey = true;
//tableSchema.AddColumn(columnSchema);
}
}
}
public async Task TestUpdateSchemaIsUpdatedIntoCache()
{
await this.CachedManager.CreateObject(this.Connection, this.BaselineSchema);
SchemaAssertions.AssertObjectSchemasEqual(this.BaselineSchema, this.SchemaCache.Get(this.BaselineSchema.Name));
var newCol = new ColumnSchema()
{
Name = "NewCol",
SqlType = SqlDbType.Bit
};
this.BaselineSchema.Columns["NewCol"] = newCol;
await this.CachedManager.CreateColumn(this.Connection, this.BaselineSchema.Name, newCol);
SchemaAssertions.AssertObjectSchemasEqual(this.BaselineSchema, this.SchemaCache.Get(this.BaselineSchema.Name));
}
public string Refine(SchemaRefineOption option)
{
string SQL = $"SELECT * FROM [{tname.Name}]";
var dt = FillDataTable(SQL);
StringBuilder builder = new StringBuilder();
foreach (IColumn column in schema.Columns)
{
ColumnSchema cs = (ColumnSchema)column;
bool isDirty = false;
if (option.ChangeNotNull && column.Nullable && !HasNull(dt, column))
{
cs.Nullable = false;
isDirty = true;
}
if (option.ConvertInteger && CanConvertToInt32(dt, column))
{
cs.DataType = "int";
isDirty = true;
}
if (option.ConvertBoolean && CanConvertBoolean(dt, column))
{
cs.DataType = "bit";
isDirty = true;
}
if (option.ShrinkString && ShrinkString(dt, column, out short length))
{
cs.Length = length;
isDirty = true;
}
if (isDirty)
{
string field = cs.GetSQLField();
SQL = $"ALTER TABLE [{tname.Name}] ALTER COLUMN {field}";
builder.AppendLine(SQL);
}
}
return(builder.ToString());
}
public Table MakeTable(Database database, UtlDataReader reader)
{
QNameManager.QName name = database.NameManager.NewQName("PARAMETER___TABLE", false, 3);
Table table = new Table(database, name, 11);
for (int i = 0; i < reader.FieldCount; i++)
{
QNameManager.QName name1 = database.NameManager.NewQName(reader.GetName(i).ToUpper(), false, 9);
name1.schema = SqlInvariants.ModuleQname;
name1.Parent = name;
DataTable schemaTable = reader.GetSchemaTable();
ColumnSchema column = new ColumnSchema(name1, Types.GetParameterSqlType((Type)schemaTable.Rows[i][SchemaTableColumn.DataType]), (bool)schemaTable.Rows[i][SchemaTableColumn.AllowDBNull], false, null);
table.AddColumn(column);
}
table.CreatePrimaryKey();
return(table);
}
private static void CheckColumnSchema(
ColumnSchema column, SqlDbType sqlDbType, object defaultValue, bool allowNull, int?size)
{
SqlServerColumnSchema msAccessColumn = (SqlServerColumnSchema)column;
string columnName = msAccessColumn.Name;
msAccessColumn.SqlDbType.Should().Be(sqlDbType, $"{columnName} should have correct SqlDbType.");
msAccessColumn.AllowNull.Should().Be(allowNull, $"{columnName} should allow NULL.");
if (defaultValue != null)
{
msAccessColumn.DefaultValue.Should().Be(defaultValue, $"{columnName} should have correct default value.");
}
if (size.HasValue)
{
msAccessColumn.Size.Should().Be(size, $"{columnName} should have correct size.");
}
}
public int AddTableColumns(List <Expression> expList, int position, UtlHashSet <string> exclude)
{
Table table = this.GetTable();
int columnCount = table.GetColumnCount();
for (int i = 0; i < columnCount; i++)
{
ColumnSchema column = table.GetColumn(i);
string key = (this._columnAliases == null) ? column.GetName().Name : this._columnAliases.Get(i);
if ((exclude == null) || !exclude.Contains(key))
{
Expression item = new ExpressionColumn(this, i);
expList.Insert(position++, item);
}
}
return(position);
}
public void SetOrAddSessionVariable(ColumnSchema variable, object value)
{
int index = this.SessionVariables.Size();
if (this.SessionVariables.ContainsKey(variable.GetName().Name))
{
index = this.SessionVariables.GetIndex(variable.GetName().Name);
}
else
{
this.SessionVariables.Add(variable.GetName().Name, variable);
object[] destinationArray = new object[this.SessionVariables.Size()];
Array.Copy(this.SessionVariableValues, destinationArray, this.SessionVariableValues.Length);
this.SessionVariableValues = destinationArray;
}
this.SessionVariableValues[index] = value;
}
public static TableSchema GetPrimaryTable(this ColumnSchema column)
{
if (!column.Table.ForeignKeyColumns.Contains(column))
{
return(null);
}
foreach (var tableKeySchema in column.Table.ForeignKeys)
{
if (tableKeySchema.ForeignKeyMemberColumns.Contains(column))
{
return(tableKeySchema.PrimaryKeyTable);
}
}
return(null);
}
public string GetCSharpTypeFromDBFieldType(ColumnSchema column)
{
if (column.Name.EndsWith("TypeCode")) return column.Name;
string type;
switch (column.DataType)
{
case DbType.AnsiString: type= "string";break;
case DbType.AnsiStringFixedLength: type= "string";break;
case DbType.Binary: type= "byte[]";break;
case DbType.Boolean: type= "bool";break;
case DbType.Byte: type= "byte";break;
case DbType.Currency: type= "decimal";break;
case DbType.Date: type= "DateTime";break;
case DbType.DateTime: type= "DateTime";break;
case DbType.Decimal: type= "decimal";break;
case DbType.Double: type= "double";break;
case DbType.Guid: type= "Guid";break;
case DbType.Int16: type= "short";break;
case DbType.Int32: type= "int";break;
case DbType.Int64: type= "long";break;
case DbType.Object: type= "object";break;
case DbType.SByte: type= "sbyte";break;
case DbType.Single: type= "float";break;
case DbType.String: type= "string";break;
case DbType.StringFixedLength: type= "string";break;
case DbType.Time: type= "TimeSpan";break;
case DbType.UInt16: type= "ushort";break;
case DbType.UInt32: type= "uint";break;
case DbType.UInt64: type= "ulong";break;
case DbType.VarNumeric: type= "decimal";break;
default:
{
type= "__UNKNOWN__" + column.NativeType;
break;
}
}
if(column.AllowDBNull&&
column.SystemType.IsValueType)
{
type=type+"?";
}
return type;
}
public static string GetConvertToNETType(ColumnSchema column, string strExpression)
{
switch (column.NetDataType)
{
case "System.Int32":
return "Convert.ToInt32(" + strExpression + ")";
case "System.Byte":
return "Convert.ToByte(" + strExpression + ")";
case "System.Boolean":
return "Convert.ToBoolean(" + strExpression + ")";
case "System.Char":
return "Convert.ToChar(" + strExpression + ")";
case "System.DateTime":
return "Convert.ToDateTime(" + strExpression + ")";
case "System.Decimal":
return "Convert.ToDecimal(" + strExpression + ")";
case "System.Double":
return "Convert.ToDouble(" + strExpression + ")";
case "System.Int16":
return "Convert.ToInt16(" + strExpression + ")";
case "System.Int64":
return "Convert.ToInt64(" + strExpression + ")";
case "System.SByte":
return "Convert.ToSByte(" + strExpression + ")";
case "System.Single":
return "Convert.ToSingle(" + strExpression + ")";
case "System.TimeSpan":
return "Convert.ToDateTime(" + strExpression + ")";
case "System.UInt16":
return "Convert.ToUInt16(" + strExpression + ")";
case "System.UInt32":
return "Convert.ToUInt32(" + strExpression + ")";
case "System.UInt64":
return "Convert.ToUInt64 (" + strExpression + ")";
case "System.Guid":
return "Convert.ToString(" + strExpression + ")";
case "System.Byte[]":
return "(Byte[])(" + strExpression + ")";
default:
return "Convert.ToString(" + strExpression + ")";
}
}
private string ExtractType(ColumnSchema schema)
{
var rez = schema.DataType;
if (!string.IsNullOrEmpty(schema.CharacterMaximumLength))
{
rez = rez + "(" + (schema.CharacterMaximumLength == "-1"
? "max"
: schema.CharacterMaximumLength) + ")";
return rez;
}
if (!string.IsNullOrEmpty(schema.NumericPrecision))
{
rez = rez + "(" + schema.NumericPrecision;
if (!string.IsNullOrEmpty(schema.NumericScale))
{
rez = rez + "," + schema.NumericScale;
}
return rez + ")";
}
return rez;
}
public string GetMemberVariableDefaultValue(ColumnSchema column)
{
switch (column.DataType)
{
case DbType.Guid:
{
return "Guid.Empty";
}
case DbType.AnsiString:
case DbType.AnsiStringFixedLength:
case DbType.String:
case DbType.StringFixedLength:
{
return "String.Empty";
}
default:
{
return "";
}
}
}
public override IList<ColumnSchema> GetColumns(System.Data.Common.DbConnectionStringBuilder connectionstr, string tablename)
{
IList<ColumnSchema> list = null;
using (MySqlConnection connection = new MySqlConnection(connectionstr.ConnectionString))
{
connection.Open();
DataTable columns = connection.GetSchema(SqlClientMetaDataCollectionNames.Columns, new string[] { null, null, tablename, null });
if (columns != null && columns.Rows.Count > 0)
{
list = new List<ColumnSchema>();
DataView dv = columns.DefaultView;
dv.Sort = "ORDINAL_POSITION asc";
foreach (DataRowView table in dv)
{
string name = string.Format("{0}({1})", table["COLUMN_NAME"], table["DATA_TYPE"]);
ColumnSchema column = new ColumnSchema(name);
list.Add(column);
}
}
}
return list;
}
public string GetConvert(ColumnSchema column)
{
if (column.Name.EndsWith("TypeCode")) return column.Name;
switch (column.DataType)
{
case DbType.AnsiString: return "Convert.ToString";
case DbType.AnsiStringFixedLength: return "Convert.ToString";
case DbType.Binary: return "Convert.ToByte";
case DbType.Boolean: return "Convert.ToBoolean";
case DbType.Byte: return "Convert.ToInt32";
case DbType.Currency: return "Convert.ToDecimal";
case DbType.Date: return "Convert.ToDateTime";
case DbType.DateTime: return "Convert.ToDateTime";
case DbType.Decimal: return "Convert.ToDecimal";
case DbType.Double: return "Convert.ToDouble";
case DbType.Guid: return "Convert.ToString";
case DbType.Int16: return "Convert.ToInt16";
case DbType.Int32: return "Convert.ToInt32";
case DbType.Int64: return "Convert.ToInt64";
case DbType.Object: return "Convert.ToString";
case DbType.SByte: return "Convert.ToByte";
case DbType.Single: return "Convert.ToInt32";
case DbType.String: return "Convert.ToString";
case DbType.StringFixedLength: return "Convert.ToString";
case DbType.Time: return "Convert.DateTime";
case DbType.UInt16: return "Convert.ToUInt16";
case DbType.UInt32: return "Convert.ToUInt32";
case DbType.UInt64: return "Convert.ToUInt64";
case DbType.VarNumeric: return "Convert.ToDecimal";
default:
{
return "__UNKNOWN__" + column.NativeType;
}
}
}
public static string GetCSharpConvert(ColumnSchema column, string placeholder)
{
if (column.Name.EndsWith("TypeCode")) return column.Name;
switch (column.DataType)
{
case DbType.AnsiString: return placeholder;
case DbType.AnsiStringFixedLength: return placeholder;
//case DbType.Binary: return "byte []";
case DbType.Boolean: return "Convert.ToBoolean(" + placeholder + ");";
case DbType.Byte: return "Convert.ToByte(" + placeholder + ")";
case DbType.Currency: return "Convert.ToDecimal(" + placeholder + ")";
case DbType.Date: return placeholder;
case DbType.DateTime: return placeholder;
case DbType.Decimal: return "Convert.ToDecimal(" + placeholder + ")";
case DbType.Double: return "Convert.ToDouble(" + placeholder + ")";
case DbType.Guid: return placeholder;
case DbType.Int16: return "Convert.ToInt16(" + placeholder + ")";
case DbType.Int32: return "Convert.ToInt32(" + placeholder + ")";
case DbType.Int64: return "Convert.ToInt64(" + placeholder + ")";
case DbType.Object: return placeholder;
case DbType.SByte: return "Convert.ToSByte(" + placeholder + ")";
case DbType.Single: return "Convert.ToFloat(" + placeholder + ")";
case DbType.String: return placeholder;
case DbType.StringFixedLength: return placeholder;
case DbType.Time: return "TimeSpan";
case DbType.UInt16: return "Convert.ToUInt16(" + placeholder + ")";
case DbType.UInt32: return "Convert.ToUInt32(" + placeholder + ")";
case DbType.UInt64: return "Convert.ToUInt64(" + placeholder + ")";
case DbType.VarNumeric: return "Convert.ToDecimal(" + placeholder + ")";
default:
{
return "__UNKNOWN__" + column.NativeType;
}
}
}
public static string GetCSharpVariableType(ColumnSchema column)
{
if (column.Name.EndsWith("TypeCode")) return column.Name;
switch (column.DataType)
{
case DbType.AnsiString: return "string";
case DbType.AnsiStringFixedLength: return "string";
case DbType.Binary: return "byte []";
case DbType.Boolean: return "bool";
case DbType.Byte: return "byte";
case DbType.Currency: return "decimal";
case DbType.Date: return "DateTime";
case DbType.DateTime: return "DateTime";
case DbType.Decimal: return "decimal";
case DbType.Double: return "double";
case DbType.Guid: return "Guid";
case DbType.Int16: return "short";
case DbType.Int32: return "int";
case DbType.Int64: return "long";
case DbType.Object: return "object";
case DbType.SByte: return "sbyte";
case DbType.Single: return "float";
case DbType.String: return "string";
case DbType.StringFixedLength: return "string";
case DbType.Time: return "TimeSpan";
case DbType.UInt16: return "ushort";
case DbType.UInt32: return "uint";
case DbType.UInt64: return "ulong";
case DbType.VarNumeric: return "decimal";
default:
{
return "__UNKNOWN__" + column.NativeType;
}
}
}
public bool IsIdentity(ColumnSchema column)
{
if((bool)column.ExtendedProperties["CS_IsIdentity"].Value)
{
return true;
}
else
{
return false;
}
}
public string GetDefaultValue(ColumnSchema column)
{
if (column.Name.EndsWith("TypeCode")) return column.Name;
switch (column.DataType)
{
case DbType.AnsiString: return "\"\"";
case DbType.AnsiStringFixedLength: return "\"\"";
case DbType.Binary: return "null";
case DbType.Boolean: return "false";
case DbType.Byte: return "0";
case DbType.Currency: return "0";
case DbType.Date: return "DateTime.Parse(\"1900-1-1\")";
case DbType.DateTime: return "DateTime.Parse(\"1900-1-1\")";
case DbType.Decimal: return "0";
case DbType.Double: return "0";
case DbType.Guid: return "Guid.NewGuid().ToString()";
case DbType.Int16: return "0";
case DbType.Int32: return "0";
case DbType.Int64: return "0";
case DbType.Object: return "\"\"";
case DbType.SByte: return "0";
case DbType.Single: return "0";
case DbType.String: return "\"\"";
case DbType.StringFixedLength: return "";
case DbType.Time: return "DateTime.Parse(\"1900-1-1\")";
case DbType.UInt16: return "0";
case DbType.UInt32: return "0";
case DbType.UInt64: return "0";
case DbType.VarNumeric: return "0";
default:
{
return "__UNKNOWN__" + column.NativeType;
}
}
}
public ColumnSchema[] GetTableColumns(string connectionString, TableSchema table)
{
if (_cachedConnectionString != connectionString)
{
_cachedConnectionString = connectionString;
_doc.Load(connectionString);
}
XmlNodeList columns = _doc.SelectNodes("dcl:schema/dcl:table[@name='" + table.Name + "']/dcl:column", _manager);
int columnCount = columns.Count;
ColumnSchema[] ret = new ColumnSchema[columnCount];
for (int i = 0; i < columnCount; ++i)
{
byte precision = 0;
int size = -1, scale = 0;
string nativeDataType = "", columnName = "";
DbType dbType = 0;
bool isNullable = false;
XmlNode currentColumn = columns[i];
XmlAttribute columnNameNode = currentColumn.Attributes["name"];
if (columnNameNode != null)
{
columnName = columnNameNode.Value.Trim('\"').Replace("\"\"", "\"");
}
XmlAttribute isNullableNode = currentColumn.Attributes["isNullable"];
if (isNullableNode != null)
{
isNullable = bool.Parse(isNullableNode.Value);
}
XmlNode predefinedDataTypeNode = currentColumn.SelectSingleNode("dcl:predefinedDataType", _manager);
if (predefinedDataTypeNode == null)
{
XmlNode refNameNode = currentColumn.SelectSingleNode("dcl:domainRef/@name", _manager);
if (refNameNode != null)
{
string refName = refNameNode.Value;
predefinedDataTypeNode = currentColumn.SelectSingleNode("dcl:schema/dcl:domain[@name='" + refName +"']/dcl:predefinedDataType", _manager);
}
}
if (predefinedDataTypeNode != null)
{
XmlAttribute nativeDataTypeNode = predefinedDataTypeNode.Attributes["name"];
if (nativeDataTypeNode != null)
{
nativeDataType = nativeDataTypeNode.Value.ToLower();
}
switch (nativeDataType.ToUpper())
{
case "CHARACTER LARGE OBJECT":
case "BINARY LARGE OBJECT":
dbType = DbType.Binary;
size = 16;
break;
case "CHARACTER":
dbType = DbType.StringFixedLength;
size = 100;
break;
case "CHARACTER VARYING":
dbType = DbType.String;
size = 100;
break;
case "NUMERIC":
case "DECIMAL":
dbType = DbType.Decimal;
size = 32;
break;
case "SMALLINT":
dbType = DbType.Int16;
size = 2;
break;
case "INTEGER":
dbType = DbType.Int32;
size = 4;
break;
case "BIGINT":
dbType = DbType.Int64;
size = 8;
precision = 19;
break;
case "DOUBLE PRECISION":
case "FLOAT":
dbType = DbType.Double;
size = 8;
break;
case "REAL":
dbType = DbType.Single;
size = 4;
break;
case "BOOLEAN":
dbType = DbType.Boolean;
size = 1;
break;
case "DATE":
dbType = DbType.Date;
size = 4;
break;
case "TIME":
dbType = DbType.Time;
size = 3;
break;
case "TIMESTAMP":
case "INTERVAL":
dbType = DbType.DateTime;
size = 10;
break;
default:
dbType = 0;
size = -1;
break;
}
XmlAttribute precisionNode = currentColumn.Attributes["precision"];
if (precisionNode != null)
{
precision = Byte.Parse(precisionNode.Value);
}
XmlAttribute lengthNode = currentColumn.Attributes["length"];
if (lengthNode != null)
{
size = int.Parse(lengthNode.Value);
}
XmlAttribute scaleNode = currentColumn.Attributes["scale"];
if (scaleNode != null)
{
scale = int.Parse(scaleNode.Value);
}
}
ret[i] = new ColumnSchema(table, columnName, dbType, nativeDataType, size, precision, scale, isNullable);
}
return ret;
}
public string GetNameFromDBFieldName(ColumnSchema column)
{
return column.Name;
}
public string GetPropertyName(ColumnSchema column)
{
return MakePascal(GetNameFromDBFieldName(column));
}
private static String GetPropName(ColumnSchema column, MemberOption option) {
String result = column.Name;
if (CSHelper.IsNotBlank(option.PrefixToTrim)) {
result = CSHelper.StripPrefix(result, option.PrefixToTrim);
}
if (option.TrimTablePrefix) {
string prefix = column.Table.Name;
if (CSHelper.IsNotBlank(option.TablePrePrefix)) {
prefix = CSHelper.StripPrefix(prefix, option.TablePrePrefix);
}
result = CSHelper.StripPrefix(result, prefix);
}
if (CSHelper.IsNotBlank(option.SuffixToTrim)) {
result = CSHelper.StripSuffix(result, column.Table.Name);
}
if (option.TrimTableSuffix) {
string suffix = column.Table.Name;
if (CSHelper.IsNotBlank(option.TablePostSuffix)) {
suffix = CSHelper.StripSuffix(suffix, option.TablePostSuffix.Trim());
}
result = CSHelper.StripPrefix(result, suffix);
}
if (option.PropInPascalCase) {
result = CSHelper.GetPascalCase(result);
}
result = CSHelper.GetCSharpIdentifier(result);
return result;
}
public string GetPropertyType(ColumnSchema column)
{
return GetCSharpTypeFromDBFieldType(column);
}
public static bool IsNullableType(ColumnSchema column)
{
return !column.IsRequired && column.NetDataType != "System.String";
}
public ColumnInfo(ColumnSchema column, MemberOption memberOption, SqlOption sqlOption, IDbVendor dbVendor) {
if (column == null) throw new ArgumentNullException("column");
if (memberOption == null) throw new ArgumentNullException("memberOption");
if (dbVendor == null) throw new ArgumentNullException("dbVendor");
//Assign parameters to member variables.
m_Column = column;
m_MemberOption = memberOption;
m_SqlOption = sqlOption;
m_DbVendor = dbVendor;
m_ClrType = DbVendor.GetClrType(column, MemberOption.UseNullable);
m_ClrPrimitiveType = Nullable.GetUnderlyingType(m_ClrType);
m_ClrPrimitiveType = (m_ClrPrimitiveType != null) ? m_ClrPrimitiveType : m_ClrType;
m_IsClrNullable = Nullable.GetUnderlyingType(m_ClrType) != null;
//m_ClrTypeDecl = GetClrTypeDecl(m_ClrType);
m_ClrTypeDecl = CSHelper.CSharpType(m_Column);
m_IsLob = DbVendor.IsLob(Column);
m_PropName = GetPropName(Column, MemberOption);
m_VarName = GetVarName(PropName, MemberOption);
m_ClrParamName = CSHelper.GetCamelCase(PropName);
m_ClrParamDecl = ClrTypeDecl + " " + ClrParamName;
m_InitialValueDecl = m_IsClrNullable ? " = null" : String.Empty;
m_PropAccessDecl = CSHelper.GetMemberAccessName(MemberOption.PropAccess);
m_VarAccessDecl = CSHelper.GetMemberAccessName(MemberOption.VarAccess);
m_ProviderDbType = DbVendor.GetProviderDbType(Column);
m_ProviderDbTypeName = DbVendor.GetProviderDbTypeName(m_ProviderDbType);
m_IsExpilicit = DbVendor.IsExplicit(Column);
m_ResultColumnName = Column.Name;
m_SqlColumnName = DbVendor.QuotedStr(Column.Name);
m_SqlQualifiedColumnName = DbVendor.QuotedStr(column.Table.Name) + "." + m_SqlColumnName;
m_SqlInlineParameterMap = GetSqlInlineParameterMap(PropName, ClrTypeDecl, ProviderDbTypeName, IsExpilicit, SqlOption);
m_SqlParameterClass = m_ClrPrimitiveType.Name;
}
public override ConstraintSchemaCollection GetColumnConstraints (TableSchema table, ColumnSchema column)
{
ConstraintSchemaCollection constraints = new ConstraintSchemaCollection ();
using (IPooledDbConnection conn = connectionPool.Request ()) {
using (IDbCommand command = conn.CreateCommand (String.Format ("DESCRIBE {0}", table.Name))) {
try {
using (IDataReader r = command.ExecuteReader()) {
while (r.Read ()) {
if (r.IsDBNull (3) || String.Compare (r.GetString (0), column.Name, true) != 0)
continue;
string key = r.GetString (3).ToUpper ();
ConstraintSchema constraint = null;
if (key.Contains ("PRI"))
constraint = CreatePrimaryKeyConstraintSchema ("pk_" + column.Name);
else if (key.Contains ("UNI"))
constraint = CreateUniqueConstraintSchema ("uni_" + column.Name);
else
continue;
constraint.IsColumnConstraint = true;
constraint.OwnerName = r.GetString (0);
constraints.Add (constraint);
}
r.Close ();
}
} catch (Exception e) {
QueryService.RaiseException (e);
} finally {
conn.Release ();
}
}
}
return constraints;
}
public override ColumnSchemaCollection GetViewColumns (ViewSchema view)
{
ColumnSchemaCollection columns = new ColumnSchemaCollection ();
using (IPooledDbConnection conn = connectionPool.Request ()) {
using (IDbCommand command = conn.CreateCommand (String.Format ("DESCRIBE {0}", view.Name))) {
try {
using (IDataReader r = command.ExecuteReader()) {
while (r.Read ()) {
ColumnSchema column = new ColumnSchema (this, view);
column.Name = r.GetString (0);
column.DataTypeName = r.GetString (1);
column.IsNullable = r.IsDBNull (2);
column.DefaultValue = r.GetString (4);
column.Comment = r.GetString (5);
column.OwnerName = view.Name;
columns.Add (column);
}
r.Close ();
}
} catch (Exception e) {
QueryService.RaiseException (e);
} finally {
conn.Release ();
}
}
}
return columns;
}
public override ColumnSchemaCollection GetTableColumns (TableSchema table)
{
ColumnSchemaCollection columns = new ColumnSchemaCollection ();
using (IPooledDbConnection conn = connectionPool.Request ()) {
using (IDbCommand command = conn.CreateCommand (String.Format ("DESCRIBE {0}", table.Name))) {
try {
using (IDataReader r = command.ExecuteReader()) {
while (r.Read ()) {
ColumnSchema column = new ColumnSchema (this, table);
column.Name = r.GetString (0);
column.DataTypeName = r.GetString (1);
column.IsNullable = String.Compare (r.GetString (2), "YES", true) == 0;
column.DefaultValue = r.IsDBNull (4) ? null : r.GetString (4);
//TODO: if r.GetString (5) constains "auto_increment" ?
column.OwnerName = table.Name;
columns.Add (column);
}
r.Close ();
}
} catch (Exception e) {
// Don't raise error, if the table doesn't exists return an empty collection
} finally {
conn.Release ();
}
}
}
return columns;
}
public string GetSqlDbType(ColumnSchema column)
{
switch (column.NativeType.ToLower())
{
case "bigint": return "SqlDbType.BigInt";
case "binary": return "SqlDbType.Binary";
case "bit": return "SqlDbType.Bit";
case "char": return "SqlDbType.Char";
case "datetime": return "SqlDbType.DateTime";
case "decimal": return "SqlDbType.Decimal";
case "float": return "SqlDbType.Float";
case "image": return "SqlDbType.Image";
case "int": return "SqlDbType.Int";
case "money": return "SqlDbType.Money";
case "nchar": return "SqlDbType.NChar";
case "ntext": return "SqlDbType.NText";
case "numeric": return "SqlDbType.Decimal";
case "nvarchar": return "SqlDbType.NVarChar";
case "real": return "SqlDbType.Real";
case "smalldatetime": return "SqlDbType.SmallDateTime";
case "smallint": return "SqlDbType.SmallInt";
case "smallmoney": return "SqlDbType.SmallMoney";
case "sql_variant": return "SqlDbType.Variant";
case "sysname": return "SqlDbType.NChar";
case "text": return "SqlDbType.Text";
case "timestamp": return "SqlDbType.Timestamp";
case "tinyint": return "SqlDbType.TinyInt";
case "uniqueidentifier": return "SqlDbType.UniqueIdentifier";
case "varbinary": return "SqlDbType.VarBinary";
case "varchar": return "SqlDbType.VarChar";
default: return "__UNKNOWN__" + column.NativeType;
}
}
public ColumnSchema[] GetTableColumns(string connectionString, TableSchema table)
{
DataTable dt = GetSchemaData(connectionString,
Columns,
null /*restrictions[0] - catalog*/,
null /*restrictions[1] - unused*/,
table.Name /*restrictions[2] - table*/,
null /*restrictions[3] - column*/);
ColumnSchema[] columns = new ColumnSchema[dt.Rows.Count];
int colIdx = 0;
foreach (DataRow dr in dt.Rows)
{
ColumnSchema col = new ColumnSchema(table,
(String)dr[ColumnsNameColumn],
DbTypeFromType((String)dr[ColumnsTypeColumn]),
NativeTypeFromType((String)dr[ColumnsTypeColumn]),
0,
0,
0,
(bool)dr[ColumnsNullableColumn]
);
columns[colIdx++] = col;
}
return columns;
}
public static string iBatisNetType(ColumnSchema column)
{
if (column.Name.EndsWith("TypeCode")) return column.Name;
switch (column.DataType)
{
case DbType.AnsiString: return "String";
case DbType.AnsiStringFixedLength: return "String";
case DbType.Binary: return "Byte[]";
case DbType.Boolean: return "Boolean";
case DbType.Byte: return "Byte";
case DbType.Currency: return "Decimal";
case DbType.Date: return "DateTime";
case DbType.DateTime: return "DateTime";
case DbType.Decimal: return "Decimal";
case DbType.Double: return "Double";
case DbType.Guid: return "Guid";
case DbType.Int16: return "Int16";
case DbType.Int32: return "Int32";
case DbType.Int64: return "Int64";
case DbType.Object: return "BinaryBlob";
case DbType.SByte: return "Byte";
case DbType.Single: return "Single";
case DbType.String: return "String";
case DbType.StringFixedLength: return "String";
case DbType.Time: return "DateTime";
case DbType.UInt16: return "Int16";
case DbType.UInt32: return "Int32";
case DbType.UInt64: return "Int64";
case DbType.VarNumeric: return "Decimal";
default:
{
return "__UNKNOWN__" + column.NativeType;
}
}
}
