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