/// <summary> /// Instantiates an entity and loads its mapped fields with the data from the reader. /// </summary> /// <param name="entityType">The entity being created and loaded.</param> /// <param name="mappings">The field mappings for the passed in entity.</param> /// <param name="reader">The open data reader.</param> /// <param name="useAltNames">Determines if the column AltName should be used.</param> /// <returns>Returns an entity loaded with data.</returns> public object CreateAndLoadEntity(Type entityType, ColumnMapCollection mappings, DbDataReader reader, bool useAltName) { // Create new entity object ent = _repos.ReflectionStrategy.CreateInstance(entityType); return(LoadExistingEntity(mappings, reader, ent, useAltName)); }
/// <summary> /// Provides a fluent way to manually add column mappings for the current entity.. /// </summary> /// <param name="overwriteExistingMappings"> /// Overwrites existing mappings if true, or appends if false. /// Default is true. /// </param> /// <returns></returns> public ColumnMapBuilder <TEntity> MapProperties(bool overwriteExistingMappings = true) { var repos = MapRepository.Instance; ColumnMapCollection columns = null; if (overwriteExistingMappings) { columns = new ColumnMapCollection(); repos.Columns[_entityType] = columns; } else { if (repos.Columns.ContainsKey(_entityType)) { columns = repos.Columns[_entityType]; } else { columns = new ColumnMapCollection(); repos.Columns[_entityType] = columns; } } return(new ColumnMapBuilder <TEntity>(_fluentEntity, columns)); }
public object LoadExistingEntity(ColumnMapCollection mappings, DbDataReader reader, object ent, bool useAltName) { // Populate entity fields from data reader foreach (ColumnMap dataMap in mappings) { try { string colName = dataMap.ColumnInfo.GetColumName(useAltName); int ordinal = reader.GetOrdinal(colName); object dbValue = reader.GetValue(ordinal); // Handle conversions if (dataMap.Converter != null) { dbValue = dataMap.Converter.FromDB(dataMap, dbValue); } if (dbValue != DBNull.Value && dbValue != null) { dataMap.Setter(ent, dbValue); } } catch (Exception ex) { string msg = string.Format("The DataMapper was unable to load the following field: '{0}'. {1}", dataMap.ColumnInfo.Name, ex.Message); throw new DataMappingException(msg, ex); } } PrepareLazyLoadedProperties(ent); return(ent); }
/// <summary> /// Parses and orders the parameters from the query text. /// Filters the list of mapped columns to match the parameters found in the sql query. /// All parameters starting with the '@' or ':' symbol are matched and returned. /// </summary> /// <param name="command">The command and parameters that are being parsed.</param> /// <returns>A list of mapped columns that are present in the sql statement as parameters.</returns> public ColumnMapCollection OrderParameters(DbCommand command) { if (command.CommandType == CommandType.Text && this.Count > 0) { string commandTypeString = command.GetType().ToString(); if (commandTypeString.Contains("Oracle") || commandTypeString.Contains("OleDb")) { ColumnMapCollection columns = new ColumnMapCollection(); // Find all @Parameters contained in the sql statement string paramPrefix = commandTypeString.Contains("Oracle") ? ":" : "@"; string regexString = string.Format(@"{0}[\w-]+", paramPrefix); Regex regex = new Regex(regexString); foreach (Match m in regex.Matches(command.CommandText)) { ColumnMap matchingColumn = this.Find(c => string.Concat(paramPrefix, c.ColumnInfo.Name.ToLower()) == m.Value.ToLower()); if (matchingColumn != null) { columns.Add(matchingColumn); } } return(columns); } } return(this); }
/// <summary> /// Creates a ColumnMapBuilder that starts out with no pre-populated columns. /// All columns must be added manually using the builder. /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> public ColumnMapBuilder <TEntity> MapProperties() { Type entityType = typeof(TEntity); ColumnMapCollection columns = new ColumnMapCollection(); MapRepository.Instance.Columns[entityType] = columns; return(new ColumnMapBuilder <TEntity>(_fluentEntity, columns)); }
/// <summary> /// Creates a ColumnMapBuilder that starts out with no pre-populated columns. /// All columns must be added manually using the builder. /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> public ColumnMapBuilder <T> Columns <T>() { Type entityType = typeof(T); ColumnMapCollection columns = new ColumnMapCollection(); MapRepository.Instance.Columns[entityType] = columns; return(new ColumnMapBuilder <T>(null, columns)); }
/// <summary> /// Creates column mappings for the given type if they match the predicate. /// </summary> /// <typeparam name="T">The type that is being built.</typeparam> /// <param name="predicate">Determines whether a mapping should be created based on the member info.</param> /// <returns><see cref="ColumnMapConfigurator"/></returns> public ColumnMapBuilder <TEntity> AutoMapPropertiesWhere(Func <MemberInfo, bool> predicate) { ConventionMapStrategy strategy = new ConventionMapStrategy(_publicOnly); strategy.ColumnPredicate = predicate; ColumnMapCollection columns = strategy.MapColumns(_entityType); MapRepository.Instance.Columns[_entityType] = columns; return(new ColumnMapBuilder <TEntity>(_fluentEntity, columns)); }
/// <summary> /// Creates column mappings for the given type if they match the predicate. /// </summary> /// <typeparam name="T">The type that is being built.</typeparam> /// <param name="predicate">Determines whether a mapping should be created based on the member info.</param> /// <returns><see cref="ColumnMapConfigurator"/></returns> public ColumnMapBuilder <T> BuildColumns <T>(Func <MemberInfo, bool> predicate) { Type entityType = typeof(T); ConventionMapStrategy strategy = new ConventionMapStrategy(_publicOnly); strategy.ColumnPredicate = predicate; ColumnMapCollection columns = strategy.MapColumns(entityType); MapRepository.Instance.Columns[entityType] = columns; return(new ColumnMapBuilder <T>(null, columns)); }
/// <summary> /// Creates all parameters for a SP based on the mappings of the entity, /// and assigns them values based on the field values of the entity. /// </summary> public void CreateParameters <T>(T entity, ColumnMapCollection columnMapCollection, bool isAutoQuery) { ColumnMapCollection mappings = columnMapCollection; if (!isAutoQuery) { // Order columns (applies to Oracle and OleDb only) mappings = columnMapCollection.OrderParameters(_db.Command); } foreach (ColumnMap columnMap in mappings) { if (columnMap.ColumnInfo.IsAutoIncrement || !columnMap.CanRead) { continue; } var param = _db.Command.CreateParameter(); param.ParameterName = columnMap.ColumnInfo.Name; param.Size = columnMap.ColumnInfo.Size; param.Direction = columnMap.ColumnInfo.ParamDirection; object val = columnMap.Getter(entity); param.Value = val ?? DBNull.Value; // Convert nulls to DBNulls // Handle data type conversions if (columnMap.Converter != null) { param.Value = columnMap.Converter.ToDB(param.Value); } // Handle column conversions (specified during fluent mapping) if (columnMap.ToDB != null) { param.Value = columnMap.ToDB(param.Value); } // Set the appropriate DbType property depending on the parameter type // Note: the columnMap.DBType property was set when the ColumnMap was created MapRepository.Instance.DbTypeBuilder.SetDbType(param, columnMap.DBType); _db.Command.Parameters.Add(param); } }
/// <summary> /// Instantiates an entity and loads its mapped fields with the data from the reader. /// </summary> public object CreateAndLoadEntity <T>(ColumnMapCollection mappings, DbDataReader reader, bool useAltName) { return(CreateAndLoadEntity(typeof(T), mappings, reader, useAltName)); }
public ColumnMapBuilder(FluentMappings.MappingsFluentEntity <TEntity> fluentEntity, ColumnMapCollection mappedColumns) { _fluentEntity = fluentEntity; MappedColumns = mappedColumns; }