static DataSet BizTableMapping(SqlConnection connection)
{
using (connection)
{
// <Snippet2>
// Assumes that connection is a valid SqlConnection object.
DataSet custDataSet = new DataSet();
SqlDataAdapter custAdapter = new SqlDataAdapter(
"SELECT * FROM dbo.Customers", connection);
// The DataTableMapping is implemented ITableMapping.
ITableMapping mapping =
custAdapter.TableMappings.Add("Table", "BizTalkSchema");
mapping.ColumnMappings.Add("CustomerID", "ClientID");
mapping.ColumnMappings.Add("CompanyName", "ClientName");
mapping.ColumnMappings.Add("ContactName", "Contact");
mapping.ColumnMappings.Add("PostalCode", "ZIP");
custAdapter.Fill(custDataSet);
// </Snippet2>
return(custDataSet);
}
}
public static string ToDebugString(
[NotNull] this ITableMapping tableMapping,
MetadataDebugStringOptions options,
int indent = 0)
{
var builder = new StringBuilder();
var indentString = new string(' ', indent);
builder.Append(indentString);
var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0;
if (singleLine)
{
builder.Append("TableMapping: ");
}
builder.Append(tableMapping.EntityType.Name).Append(" - ");
builder.Append(tableMapping.Table.Name);
if (tableMapping.IncludesDerivedTypes)
{
builder.Append(" IncludesDerivedTypes");
}
if (!singleLine && (options & MetadataDebugStringOptions.IncludeAnnotations) != 0)
{
builder.Append(tableMapping.AnnotationsToDebugString(indent + 2));
}
return(builder.ToString());
}
/// <summary>
/// Returns the columnName or the Mapped Column Name
/// </summary>
/// <param name="dataTableName"></param>
/// <param name="columnName"></param>
/// <returns></returns>
private KeyValuePair <string, Type> GetMappingColumnName(string dataTableName, string columnName)
{
string cn = columnName;
if (this.HasTableMappings())
{
if (this.TableMappings.Contains(dataTableName))
{
ITableMapping mapping = this.TableMappings[dataTableName];
if (mapping.ColumnMappings.Contains(columnName))
{
DataColumnMapping dcm = (DataColumnMapping)mapping.ColumnMappings[columnName];
cn = dcm.DataSetColumn;
}
}
}
Type t;
if (!this.columnsType.TryGetValue(cn, out t))
{
t = STRING_TYPE;
}
return(new KeyValuePair <string, Type>(cn, t));
}
public IList <ExpressionParseResult> Parse(ITableMapping table, Expression <Func <TEntity, object> > expression)
{
Clear();
ParseExpression(expression.Body, ref table);
return(parseResult.Values.ToList());
}
protected DbSet(DbContext context)
{
Context = context;
// TODO: Take from cache
//Table = new TableMapping<>();
Table = TableMappingCache.Instance.GetTableMapping <TEntity>();
}
/***********************************************************************
*
* Data Table definitions
*
**********************************************************************/
protected void CreateDataSetMapping(IDataAdapter da, string tableName)
{
ITableMapping dbMapping = da.TableMappings.Add(tableName, tableName);
foreach (DataColumn col in ds.Tables[tableName].Columns)
{
dbMapping.ColumnMappings.Add(col.ColumnName, col.ColumnName);
}
}
public static void CreateTable(string NameTable, DataSet dataSet)
{
DataTable Table = new DataTable();
SqlDataAdapter Adapter = new SqlDataAdapter("SELECT * FROM " + NameTable, CreateConnection());
ITableMapping Map = Adapter.TableMappings.Add(NameTable, NameTable);
Map.ColumnMappings.Add("Id", "Код");
Adapter.MissingSchemaAction = MissingSchemaAction.AddWithKey;
Adapter.Fill(dataSet, NameTable);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public ColumnMapping(
[NotNull] IProperty property,
[NotNull] IColumn column,
[NotNull] RelationalTypeMapping typeMapping,
[NotNull] ITableMapping tableMapping)
{
Property = property;
Column = column;
TypeMapping = typeMapping;
TableMapping = tableMapping;
}
public void AddColumnMapping(string targetDataTableName, string sourceColumnName, string targetColumnName, Type columnType = null)
{
if (!this.HasTableMappings() && !this.TableMappings.Contains("Table"))
{
this.TableMappings.Add("Table", targetDataTableName);
}
ITableMapping mapping = this.TableMappings["Table"];
mapping.ColumnMappings.Add(sourceColumnName, targetColumnName);
columnsType.Add(targetColumnName, columnType ?? STRING_TYPE);
}
protected ColumnMapping <TEntity, TFieldType> Clone(ColumnMapping <TEntity, TFieldType> origin, ITableMapping table)
{
Name = origin.Name;
FieldName = origin.FieldName;
Table = table;
IsReadonly = origin.IsReadonly;
Getter = origin.Getter;
Setter = origin.Setter;
return(this);
}
/// <summary>
/// 获取映射关系类
/// </summary>
/// <param name="Class"></param>
/// <returns></returns>
public ITableMapping GetMapping(Type Class)
{
string ClassName = Class.FullName;
ITableMapping Mapping = MappingPool.Instance[ClassName] as ITableMapping;
if (Mapping == null)
{
Mapping = CreateMapping(Class);
MappingPool.Instance[ClassName] = Mapping;
}
return(Mapping);
}
private ITableMapping <TProperty> InitForeignTable()
{
if (ForeignTableImpl == null)
{
ForeignTableImpl = TableMappingCache.GetTableMapping <TProperty>();
JoinOnColumn = string.IsNullOrEmpty(JoinOnFieldName)
? ForeignTableImpl.PrimaryKey
: ForeignTableImpl.Columns.GetColumn(JoinOnFieldName);
}
return(ForeignTableImpl);
}
protected async Task <DbLazyLoad <T> > InitializeAsync(IDatabaseAsync db)
{
ITableMapping tableMapping = await db.GetTableMappingAsync <T>().ConfigureAwait(false);
PrimaryKeyPropName = tableMapping.GetPrimaryKeyProp();
PropertyInfoMap = new Dictionary <string, PropertyInfo>();
List <string> permanentPropertiesList = new List <string>();
List <string> lazyLoadedPropertiesList = new List <string>();
List <string> lazyUnloadedPropertiesList = new List <string>();
foreach (string propName in tableMapping.GetColumnMarkedProperties())
{
PropertyInfo propInfo = tableMapping.GetPropertyInfo(propName);
var lazyLoadedAttribute = propInfo.GetCustomAttribute <LazyLoadedAttribute>();
var lazyUnloadedAttribute = propInfo.GetCustomAttribute <LazyUnloadedAttribute>();
if (propName == PrimaryKeyPropName)
{
permanentPropertiesList.Add(propName);
lazyLoadedPropertiesList.Add(propName);
lazyUnloadedPropertiesList.Add(propName);
}
else if (lazyUnloadedAttribute != null && lazyLoadedAttribute != null)
{
lazyLoadedPropertiesList.Add(propName);
lazyUnloadedPropertiesList.Add(propName);
}
else if (lazyLoadedAttribute != null)
{
lazyLoadedPropertiesList.Add(propName);
}
else
{
permanentPropertiesList.Add(propName);
}
PropertyInfoMap.Add(propName, propInfo);
}
PermanentProperties = permanentPropertiesList.ToArray();
LazyLoadedProperties = lazyLoadedPropertiesList.ToArray();
LazyUnloadedProperties = lazyUnloadedPropertiesList.ToArray();
return(this);
}
/// <summary>
/// Read entity from SqlDataReader and return it
/// </summary>
/// <typeparam name="TEntity"> Entity type </typeparam>
/// <param name="reader"> Sql Data Reader </param>
/// <param name="table"> Table mapping from sql to entity </param>
/// <returns> Entity instance or null </returns>
public static TEntity ReadFirstOrDefault <TEntity>(this DbDataReader reader, ITableMapping <TEntity> table)
{
//using (reader)
//{
// var entity = default(TEntity);
// while (reader.Read())
// {
// entity = table.ReadFirstOrDefault(reader);
// break;
// }
// return entity;
//}
return(table.ReadFirstOrDefault(reader));
}
private void ParseExpression(System.Linq.Expressions.Expression exp, ref ITableMapping table)
{
switch (exp.NodeType)
{
case ExpressionType.Convert:
case ExpressionType.ConvertChecked:
ParseExpression((exp as UnaryExpression).Operand, ref table);
break;
case ExpressionType.MemberAccess:
var memberAccess = (exp as MemberExpression);
ITableMapping accessCurrTable = table;
ParseExpression(memberAccess.Expression, ref accessCurrTable);
var name = memberAccess.Member.Name;
var property = accessCurrTable.GetProperty(name);
if (property == null)
{
throw new ArgumentException($"There is no navigation property '{name}' for entity {typeof(TEntity).FullName}");
}
table = property.ForeignTable;
AddToResult($"{table.Alias}_{name}", property);
break;
case ExpressionType.Lambda:
ParseExpression((exp as LambdaExpression).Body, ref table);
break;
case ExpressionType.Call:
var args = (exp as MethodCallExpression).Arguments;
var callCurrTable = table;
ParseExpression(args[0], ref callCurrTable);
if (args.Count > 1)
{
ParseExpression(args[1], ref callCurrTable);
}
break;
default:
// Do nothing
break;
}
}
public InsertQueryBuilder(DbContext context, ITableMapping <TEntity> table)
: base(context, table)
{
switch (context.DbProvider.DbType)
{
case DbProviderType.SqlServer:
InsertExpr = $"INSERT INTO {Table.Reference}({Table.WriteColumns.Names}) OUTPUT inserted.[{Table.PrimaryKey.Name}] VALUES ({Table.WriteColumns.Params})";
break;
case DbProviderType.MySql:
InsertExpr = $"INSERT INTO {Table.Reference}({Table.WriteColumns.Names}) VALUES ({Table.WriteColumns.Params}); SELECT LAST_INSERT_ID();";
break;
default:
InsertExpr = $"INSERT INTO {Table.Reference}({Table.WriteColumns.Names}) VALUES ({Table.WriteColumns.Params})";
break;
}
}
public void ITableMappingCollectionIndexer()
{
ITableMappingCollection collection = new DataTableMappingCollection();
Assert.Throws <IndexOutOfRangeException>(() => { var x = collection["source"]; });
Assert.Throws <IndexOutOfRangeException>(() => { collection["source"] = new DataTableMapping(); });
ITableMapping mapping = collection.Add("source", "dataSet");
Assert.Same(mapping, collection["source"]);
Assert.Same(mapping, collection.GetByDataSetTable("dataSet"));
Assert.Throws <ArgumentNullException>(() => { collection["source"] = null; });
Assert.Throws <InvalidCastException>(() => { collection["source"] = "invalid"; });
ITableMapping mapping2 = new DataTableMapping("source2", "dataSet2");
collection["source"] = mapping2;
Assert.Single(collection);
Assert.Same(mapping2, collection["source2"]);
Assert.Throws <IndexOutOfRangeException>(() => collection.GetByDataSetTable("dataSet"));
}
private static IList <ExpressionParseResult> ParseExpressions(ITableMapping table, params Expression <Func <TEntity, object> >[] properties)
{
var parser = new ExpressionParser <TEntity>();
var parseResultsMap = new Dictionary <string, ExpressionParseResult>();
foreach (var expression in properties)
{
var expressionsResults = parser.Parse(table, expression);
foreach (var result in expressionsResults)
{
if (parseResultsMap.ContainsKey(result.UniqueKey))
{
continue;
}
parseResultsMap.Add(result.UniqueKey, result);
}
}
return(parseResultsMap.Values.ToList());
}
/// <summary>
/// Initialize column mapping
/// </summary>
protected ColumnMapping(ITableMapping table, PropertyInfo info, string name, string fieldName)
{
Name = name;
FieldName = fieldName;
Table = table;
IsReadonly = false;
FieldType = info.PropertyType;
// TODO: Choose between memory or spead
// As table name and alias are static, then init fields in constructor
/*
* SafeName = $"[{Name}]";
* Param = $"@{Name}";
* Alias = $"{Table.Alias}_{Name}";
* Reference = $"{Table}.[{Name}]";
* Declaration = $"{Reference} AS [{Alias}]";
*/
Getter = (Func <TEntity, TFieldType>)Delegate.CreateDelegate(typeof(Func <TEntity, TFieldType>), info.GetGetMethod());
Setter = (Action <TEntity, TFieldType>)Delegate.CreateDelegate(typeof(Action <TEntity, TFieldType>), info.GetSetMethod());
}
private System.Data.DataTable PrepareDataTable(DataSet dataSet, ref string dataTableName)
{
if (dataTableName == null)
{
dataTableName = "Table";
}
// MAPPING
if (this.HasTableMappings() && TableMappings.Contains(dataTableName))
{
ITableMapping mapping = this.TableMappings[dataTableName];
if (mapping != null)
{
dataTableName = mapping.DataSetTable;
}
}
else // Or No Mapping
{
dataTableName = dataSet.DataSetName;
}
System.Data.DataTable dt = new System.Data.DataTable(dataTableName);
dataSet.Tables.Add(dt);
// For The filling columns, add their columns name
foreach (KeyValuePair <string, Type> columnName in this.columnsFilling.Values)
{
dt.Columns.Add(columnName.Key, columnName.Value /*Type of Column*/);
}
foreach (string columnName in this.columnsFillingConstant.Keys)
{
dt.Columns.Add(columnName);
}
return(dt);
}
public UpdateQueryBuilder(DbContext context, ITableMapping <TEntity> table)
: base(context, table)
{
UpdateExpr = $"UPDATE {Table.Reference} SET {Table.WriteColumns.ReferenceParams}";
}
public virtual int DataTableFillWithParams(DataTable dataTable, CommandType commandType, string sql,
IDbParameters parameters,
ITableMapping tableMapping,
IDataAdapterSetter dataAdapterSetter)
{
ValidateFillWithParameterArguments(dataTable, sql, parameters, tableMapping);
ITableMappingCollection mappingCollection = new DataTableMappingCollection();
mappingCollection.Add((object)tableMapping);
return (int)Execute(new DataAdapterFillCallback(dataTable,
commandType, sql,
mappingCollection, dataAdapterSetter, null, parameters));
}
protected virtual void ValidateUpdateWithCommandBuilderArguments(DataTable dataTable, ITableMapping tableMapping, string selectSql)
{
if (dataTable == null)
{
throw new ArgumentNullException("dataTable", "DataTable can not be null for update operation");
}
if (tableMapping == null)
{
throw new ArgumentNullException("tableMapping", "TableMapping for DataSet Update operation can not be null");
}
if (selectSql == null)
{
throw new ArgumentNullException("selectSql", "SelectSql for DataSet Update operations can not be null");
}
}
public abstract IColumnMapping <TEntity> Clone(ITableMapping table);
public override IColumnMapping <TEntity> Clone(ITableMapping t) => new ColumnUIntNullMapping <TEntity>().Clone(this, t);
protected virtual void ValidateUpdateArguments(DataTable dataTable, ITableMapping tableMapping)
{
if (dataTable == null)
{
throw new ArgumentNullException("dataTable", "DataTable argument can not be null for DataTable update operation");
}
if (tableMapping == null)
{
throw new ArgumentNullException("tableMapping", "TableMapping for DataTable Update operation can not be null");
}
}
/// <summary>
/// Read list of entity from SqlDataReader and return it
/// </summary>
/// <typeparam name="TEntity"> Entity type </typeparam>
/// <param name="reader"> Sql Data Reader </param>
/// <param name="table"> Table mapping from sql to entity </param>
/// <returns> Entity instance or null </returns>
public static List <TEntity> ReadList <TEntity>(this DbDataReader reader, ITableMapping <TEntity> table)
{
return(table.ReadList(reader));
}
/// <summary>
/// Read list of entity from SqlDataReader and return it
/// </summary>
/// <typeparam name="TEntity"> Entity type </typeparam>
/// <param name="reader"> Sql Data Reader </param>
/// <param name="table"> Table mapping from sql to entity </param>
/// <param name="token"></param>
/// <returns> Entity instance or null </returns>
public static async Task <List <TEntity> > ReadListAsync <TEntity>(this Task <DbDataReader> reader, ITableMapping <TEntity> table, CancellationToken?token = null)
{
return(await ReadListAsync(await reader, table, token));
}
public ColumnStringMapping(ITableMapping table, PropertyInfo info, string name, string fieldName) : base(table, info, name, fieldName)
{
}
public DeleteQueryBuilder(DbContext context, ITableMapping <TEntity> table)
: base(context, table)
{
DeleteExpr = $"DELETE FROM {Table.Reference}";
}
public virtual int DataTableFill(DataTable dataTable, CommandType commandType, string sql,
ITableMapping tableMapping)
{
ValidateFillArguments(dataTable, sql, tableMapping);
ITableMappingCollection mappingCollection = new DataTableMappingCollection();
mappingCollection.Add((object)tableMapping);
return (int)Execute(new DataAdapterFillCallback(dataTable,
commandType, sql,
mappingCollection, null, null, null));
}
public virtual DataTable DataTableCreateWithParams(CommandType commandType, string sql,
IDbParameters parameters,
ITableMapping tableMapping,
IDataAdapterSetter dataAdapterSetter)
{
DataTable dataTable = CreateDataTable();
DataTableFillWithParams(dataTable, commandType, sql, parameters, tableMapping, dataAdapterSetter);
return dataTable;
}
public virtual DataTable DataTableCreate(CommandType commandType, string sql,
ITableMapping tableMapping)
{
DataTable dataTable = CreateDataTable();
DataTableFill(dataTable, commandType, sql, tableMapping);
return dataTable;
}
public override IColumnMapping <TEntity> Clone(ITableMapping table)
{
return(new ColumnStringMapping <TEntity>().Clone(this, table));
}
public virtual int DataTableUpdateWithCommandBuilder(DataTable dataTable,
CommandType commandType,
string selectSql,
IDbParameters parameters,
ITableMapping tableMapping,
IDataAdapterSetter dataAdapterSetter)
{
ValidateUpdateWithCommandBuilderArguments(dataTable, tableMapping, selectSql);
ITableMappingCollection mappingCollection = new DataTableMappingCollection();
mappingCollection.Add(tableMapping);
return (int)Execute(new DataAdapterUpdateWithCommandBuilderCallback(dataTable,
DbProvider.CreateCommandBuilder(),
mappingCollection,
commandType,
selectSql,
parameters,
dataAdapterSetter));
}
public virtual int DataTableUpdate(DataTable dataTable,
ITableMapping tableMapping,
CommandType insertCommandtype, string insertSql, IDbParameters insertParameters,
CommandType updateCommandtype, string updateSql, IDbParameters updateParameters,
CommandType deleteCommandtype, string deleteSql, IDbParameters deleteParameters,
IDataAdapterSetter dataAdapterSetter)
{
ValidateUpdateArguments(dataTable, tableMapping);
ITableMappingCollection mappingCollection = new DataTableMappingCollection();
mappingCollection.Add((object)tableMapping);
return DataTableUpdate(dataTable, mappingCollection,
insertCommandtype, insertSql, insertParameters,
updateCommandtype, updateSql, updateParameters,
deleteCommandtype, deleteSql, deleteParameters,
dataAdapterSetter);
}
protected virtual void ValidateFillArguments(DataTable dataTable, string sql,
ITableMapping tableMapping)
{
ValidateFillArguments(dataTable, sql);
if (tableMapping == null)
{
throw new ArgumentNullException("tableMapping", "ITableMapping for DataTable Fill operations can not be null");
}
}
/// <summary>
/// Read list of entity from SqlDataReader and return it
/// </summary>
/// <typeparam name="TEntity"> Entity type </typeparam>
/// <param name="reader"> Sql Data Reader </param>
/// <param name="table"> Table mapping from sql to entity </param>
/// <param name="token"></param>
/// <returns> Entity instance or null </returns>
public static Task <List <TEntity> > ReadListAsync <TEntity>(this DbDataReader reader, ITableMapping <TEntity> table, CancellationToken?token = null)
{
return(table.ReadListAsync(reader, token));
}
protected virtual void ValidateFillWithParameterArguments(DataTable dataTable, string sql, IDbParameters parameters, ITableMapping tableMapping)
{
ValidateFillWithParameterArguments(dataTable, sql, parameters);
if (tableMapping == null)
{
throw new ArgumentNullException("tableMapping", "ITableMappingCollection for DataTable Fill operations can not be null");
}
}
public virtual DataTable DataTableCreate(CommandType commandType, string sql,
ITableMapping tableMapping,
IDataAdapterSetter setter)
{
DataTable dataTable = CreateDataTable();
DataTableFill(dataTable, commandType, sql, tableMapping, setter);
return dataTable;
}
public override IColumnMapping <TEntity> Clone(ITableMapping table) => new ColumnLongNullMapping <TEntity>().Clone(this, table);
