public RowMapperResultSetExtractor(IRowMapper rowMapper, int rowsExpected, IDataReaderWrapper dataReaderWrapper) { //TODO use datareaderwrapper if (rowMapper == null) { throw new ArgumentNullException("rowMapper"); } this.rowMapper = rowMapper; this.rowsExpected = rowsExpected; }
/// <summary> /// Executes a stored procedure and returns the result as an enumerable of <typeparamref name="TResult"/>. /// </summary> /// <typeparam name="TResult">The element type that will be returned when executing.</typeparam> /// <param name="procedureName">The name of the stored procedure that will be executed.</param> /// <param name="parameterMapper">The <see cref="IParameterMapper"/> that will be used to interpret the parameters passed to the Execute method.</param> /// <param name="rowMapper">The <see cref="IRowMapper<TResult>"/> that will be used to convert the returned data to clr type <typeparamref name="TResult"/>.</param> /// <param name="parameterValues">Parameter values passsed to the stored procedure.</param> /// <returns>An enumerable of <typeparamref name="TResult"/>.</returns> public IEnumerable <TResult> ExecuteOracleSprocAccessor <TResult>(string procedureName, IParameterMapper parameterMapper, IRowMapper <TResult> rowMapper, params object[] parameterValues) where TResult : new() { return(CreateOracleSprocAccessor(procedureName, parameterMapper, rowMapper).Execute(parameterValues)); }
// -- Async stuff here!!! protected async Task <IList <T> > ReadAsync <T>(IRowMapper <T> mapper, string commandText, CommandType commandType, DbParameter[] parameters) { return(await Database.ReadAsync(mapper, commandText, commandType, parameters)); }
protected IList <T> Read <T>(IRowMapper <T> mapper, string commandText, CommandType commandType, DbParameter[] parameters) { return(Database.Read(mapper, commandText, commandType, parameters)); }
/// <summary> /// Executes the rowmapper with a single input parameter. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="dbHelper">Database helper</param> /// <param name="commandText">Store procedure name. E.g. "Posts_GetPostsByUser</param> /// <param name="commandType">StoredProcedure</param> /// <param name="rowMapper">The mapper that maps a record to an object.</param> /// <returns></returns> public static IList <T> QueryNoParams <T>(this IDBHelper dbHelper, string commandText, CommandType commandType, IRowMapper <IDataReader, T> rowMapper) { return(Query <T>(dbHelper, commandText, commandType, null, rowMapper)); }
public RowMapperResultSetExtractor(IRowMapper rowMapper, int rowsExpected) : this(rowMapper, rowsExpected, null) { }
public void AddRowMapper(string name, IRowMapper rowMapper) { if (Compiled) { throw new InvalidDataAccessApiUsageException("Cannot add RowMappers once operation is compiled"); } resultProcessors.Add(new NamedResultSetProcessor(name,rowMapper)); }
public virtual IList QueryWithRowMapper(CommandType cmdType, string cmdText, IRowMapper rowMapper, string name, Enum dbType, int size, object parameterValue) { return (IList)QueryWithResultSetExtractor(cmdType, cmdText, new RowMapperResultSetExtractor(rowMapper), name, dbType, size, parameterValue); }
/// <summary> /// Execute reader and create instance of provided type using IRowMapper interface. /// </summary> /// <typeparam name="T">Type of object to create.</typeparam> /// <param name="args">Sql Parameters.</param> /// <param name="query">Sql Query.</param> /// <param name="rowMapper">IRowMapper used to map object instance from reader.</param> /// <returns>Instance of object type.</returns> public T SelectValue <T>(string query, IEnumerable <QueryParameter> args = null, IRowMapper <T> rowMapper = null) { object obj = null; using (SqlConnection connection = new SqlConnection(ConnectionString)) { connection.Open(); obj = SelectValueInternal(query, args, rowMapper, connection); } if (obj == null) { return(default(T)); } return((T)obj); }
/// <summary> /// Execute reader and create list of provided type using IRowMapper interface within existing transaction. /// </summary> /// <typeparam name="T">Type of object to create.</typeparam> /// <param name="query">Sql Query.</param> /// <param name="args">Sql Parameters.</param> /// <param name="rowMapper">IRowMapper used to map object instance from reader.</param> /// <param name="transaction">Existing <see cref="SqlTransaction"/> to use with this command.</param> /// <returns>List of provided object type.</returns> public IEnumerable <T> Select <T>(string query, IEnumerable <QueryParameter> args, IRowMapper <T> rowMapper, SqlTransaction transaction) { return(SelectInternal(query, args, rowMapper, transaction.Connection, transaction)); }
/// <summary> /// Execute reader and create list of provided type using IRowMapper interface. /// </summary> /// <typeparam name="T">Type of object to create.</typeparam> /// <param name="query">Sql Query.</param> /// <param name="args">Sql Parameters.</param> /// <param name="rowMapper">IRowMapper used to map object instance from reader.</param> /// <returns>List of provided object type.</returns> public IEnumerable <T> Select <T>(string query, IEnumerable <QueryParameter> args = null, IRowMapper <T> rowMapper = null) { using (SqlConnection connection = new SqlConnection(ConnectionString)) { connection.Open(); foreach (T item in SelectInternal(query, args, rowMapper, connection)) { yield return(item); } } }
/// <summary> /// Execute reader and create list of provided type using IRowMapper interface. /// </summary> /// <typeparam name="T">Type of object to create.</typeparam> /// <param name="query">Sql Query.</param> /// <param name="rowMapper">IRowMapper used to map object instance from reader.</param> /// <returns>List of provided object type.</returns> public IEnumerable <T> Select <T>(string query, IRowMapper <T> rowMapper) { return(Select <T>(query, null, rowMapper)); }
private IEnumerable <T> SelectInternal <T>(string query, IEnumerable <QueryParameter> args, IRowMapper <T> rowMapper, SqlConnection connection, SqlTransaction transaction = null) { using (SqlCommand command = connection.CreateCommand()) { command.CommandText = query; if (transaction != null) { command.Transaction = transaction; } PrepareCommandParameters(command, args); using (SqlDataReader reader = command.ExecuteReader()) { var isNullable = Nullable.GetUnderlyingType(typeof(T)) != null; while (reader.Read()) { if (rowMapper != null) { yield return(rowMapper.Map(reader)); } else { // Check for null values and return default instance of T (should be nullable) // If not checked for NULL values, conversion will fail, resulting in InvalidCastException being thrown if (isNullable && reader[0] == Convert.DBNull) { yield return(default(T)); } else { yield return((T)reader[0]); } } } reader.Close(); } } }
private object SelectValueInternal <T>(string query, IEnumerable <QueryParameter> args, IRowMapper <T> rowMapper, SqlConnection connection, SqlTransaction transaction = null) { object obj = null; using (SqlCommand command = connection.CreateCommand()) { command.CommandText = query; if (transaction != null) { command.Transaction = transaction; } PrepareCommandParameters(command, args); using (SqlDataReader reader = command.ExecuteReader(CommandBehavior.SingleResult)) { reader.Read(); if (reader.HasRows) { if (rowMapper != null) { obj = rowMapper.Map(reader); } else { // Used for primitive types obj = reader[0]; } } reader.Close(); } } return(obj); }
private static IEnumerable <T> GetListWithRowMapper <T>(string query, IEnumerable <QueryParameter> args, IRowMapper <T> rowMapper) { using (var connector = new Connector()) { return(connector.Select(query, args, rowMapper)); } }
public virtual IList QueryWithCommandCreator(IDbCommandCreator cc, IRowMapper rowMapper) { return QueryWithCommandCreator(cc, rowMapper, null); }
public AdoRowMapperQueryCommandCallback(AdoTemplate adoTemplate, IRowMapper rowMapper, IDictionary returnedParameters) { this.adoTemplate = adoTemplate; this.rowMapper = rowMapper; //this.declaredParameters = declaredParameters; this.returnedParameters = returnedParameters; }
/// <summary> /// Protected constructor to give subclass the flexibility of how row /// mapper is set. It also sets the <see cref="_rowMapper"/> to itself /// if subclass also implements <see cref="IRowMapper{T}"/>. /// </summary> protected ExtendedRowMapperResultSetExtractor() { _rowMapper = this as IRowMapper <T>; }
/// <summary> /// Execute a query with the specified command text and parameters, mapping a single result row /// to an object via a RowMapper. /// </summary> /// <param name="cmdType">The command type.</param> /// <param name="cmdText">The command text to execute.</param> /// <param name="rowMapper">object that will map one object per row</param> /// <param name="parameters">The parameter collection to use in the query.</param> /// <returns>The single mapped object.</returns> /// <exception cref="Spring.Dao.IncorrectResultSizeDataAccessException"> /// If the query does not return exactly one row. /// </exception> /// <exception cref="Spring.Dao.DataAccessException"> /// If there is any problem executing the query. /// </exception> public virtual object QueryForObject(CommandType cmdType, string cmdText, IRowMapper rowMapper, IDbParameters parameters) { IList results = QueryWithRowMapper(cmdType, cmdText, rowMapper, parameters); return DataAccessUtils.RequiredUniqueResultSet(results); }
/// <summary> /// Creates a <see cref="SprocAccessor<TResult>"/> for the given stored procedure. /// </summary> /// <typeparam name="TResult">The type the <see cref="SprocAccessor<TResult>"/> should return when executing.</typeparam> /// <param name="rowMapper">The <see cref="IRowMapper<TResult>"/> that will be used to convert the returned data to clr type <typeparamref name="TResult"/>.</param> /// <param name="database">The <see cref="Database"/> that contains the stored procedure.</param> /// <param name="procedureName">The name of the stored procedure that should be executed by the <see cref="SprocAccessor<TResult>"/>. </param> /// <param name="parameterMapper">The <see cref="IParameterMapper"/> that will be used to interpret the parameters passed to the Execute method.</param> /// <returns>A new instance of <see cref="SprocAccessor<TResult>"/>.</returns> public static DataAccessor <TResult> CreateSprocAccessor <TResult>(this Database database, string procedureName, IParameterMapper parameterMapper, IRowMapper <TResult> rowMapper) { if (string.IsNullOrEmpty(procedureName)) { throw new ArgumentException(Resources.ExceptionNullOrEmptyString); } return(new SprocAccessor <TResult>(database, procedureName, parameterMapper, rowMapper)); }
/// <summary> /// Initializes a new instance of the <see cref="NamedResultSetProcessor"/> class with a /// IRowMapper instance /// </summary> /// <param name="name">The name of the associated row mapper.</param> /// <param name="rowMapper">A IRowMapper instance.</param> public NamedResultSetProcessor(string name, IRowMapper rowMapper) { this.name = name; resultSetProcessor = rowMapper; }
/// <summary> /// Executes a Transact-SQL query and returns the result as an enumerable of <typeparamref name="TResult"/>. /// The conversion from <see cref="IDataRecord"/> to <typeparamref name="TResult"/> will be done for each property based on matching property name to column name. /// </summary> /// <typeparam name="TResult">The element type that will be returned when executing.</typeparam> /// <param name="database">The <see cref="Database"/> that contains the stored procedure.</param> /// <param name="sqlString">The Transact-SQL query that will be executed.</param> /// <param name="rowMapper">The <see cref="IRowMapper<TResult>"/> that will be used to convert the returned data to clr type <typeparamref name="TResult"/>.</param> /// <returns>An enumerable of <typeparamref name="TResult"/>.</returns> public static IEnumerable <TResult> ExecuteSqlStringAccessor <TResult>(this Database database, string sqlString, IRowMapper <TResult> rowMapper) { return(CreateSqlStringAccessor(database, sqlString, rowMapper).Execute()); }
public MappingFactory(PocoData pocoData, DbDataReader dataReader) { _pocoData = pocoData; _rowMapper = RowMappers.Select(mapper => mapper()).First(x => x.ShouldMap(pocoData)); _rowMapper.Init(dataReader, pocoData); }
/// <summary> /// Creates a <see cref="SqlStringAccessor<TResult>"/> for the given Transact-SQL query. /// </summary> /// <typeparam name="TResult">The type the <see cref="SprocAccessor<TResult>"/> should return when executing.</typeparam> /// <param name="database">The <see cref="Database"/> that contains the stored procedure.</param> /// <param name="sqlString">The Transact-SQL query that will be executed by the <see cref="SqlStringAccessor<TResult>"/>.</param> /// <param name="parameterMapper">The <see cref="IParameterMapper"/> that will be used to interpret the parameters passed to the Execute method.</param> /// <param name="rowMapper">The <see cref="IRowMapper<TResult>"/> that will be used to convert the returned data to clr type <typeparamref name="TResult"/>.</param> /// <returns>A new instance of <see cref="SprocAccessor<TResult>"/>.</returns> public static DataAccessor <TResult> CreateSqlStringAccessor <TResult>(this Database database, string sqlString, IParameterMapper parameterMapper, IRowMapper <TResult> rowMapper) { return(new SqlStringAccessor <TResult>(database, sqlString, parameterMapper, rowMapper)); }
/// <summary> /// Executes the rowmappers /// </summary> /// <typeparam name="T"></typeparam> /// <param name="dbHelper">Database helper</param> /// <param name="commandText">Store procedure name. E.g. "Posts_GetPostsByUser</param> /// <param name="commandType">StoredProcedure</param> /// <param name="rowMapper">The mapper that maps a record to an object.</param> /// <param name="dbParameters">Array of parameters for the query.</param> /// <returns></returns> public static IList <T> Query <T>(IDBHelper dbHelper, string commandText, CommandType commandType, DbParameter[] dbParameters, IRowMapper <IDataReader, T> rowMapper) { DbCommand command = dbHelper.BuildCommand(commandText, commandType, dbParameters); IList <T> items = null; using (command.Connection) { command.Connection.Open(); IDataReader reader = command.ExecuteReader(); // Map the workshops. items = rowMapper.MapRows(reader); reader.Close(); command.Dispose(); } return(items); }
/// <summary> /// Executes a stored procedure and returns the result as an enumerable of <typeparamref name="TResult"/>. /// </summary> /// <typeparam name="TResult">The element type that will be returned when executing.</typeparam> /// <param name="database">The <see cref="Database"/> that contains the stored procedure.</param> /// <param name="procedureName">The name of the stored procedure that will be executed.</param> /// <param name="parameterMapper">The <see cref="IParameterMapper"/> that will be used to interpret the parameters passed to the Execute method.</param> /// <param name="rowMapper">The <see cref="IRowMapper<TResult>"/> that will be used to convert the returned data to clr type <typeparamref name="TResult"/>.</param> /// <param name="parameterValues">Parameter values passed to the stored procedure.</param> /// <returns>An enumerable of <typeparamref name="TResult"/>.</returns> public static IEnumerable <TResult> ExecuteSprocAccessor <TResult>(this Database database, string procedureName, IParameterMapper parameterMapper, IRowMapper <TResult> rowMapper, params object[] parameterValues) where TResult : new() { return(CreateSprocAccessor(database, procedureName, parameterMapper, rowMapper).Execute(parameterValues)); }
protected IList <T> Read <T>(DbConnection connection, IRowMapper <T> mapper, string commandText, CommandType commandType, DbParameter[] parameters, DbTransaction transaction = null) { return(Database.Read(connection, mapper, commandText, commandType, parameters, transaction)); }
public SequentialDataTransform(IHost host, SequentialTransformerBase <TInput, TOutput, TState> parent, IDataView input, IRowMapper mapper) : base(parent.Host, input) { _parent = parent; _transform = CreateLambdaTransform(_parent.Host, input, _parent.InputColumnName, _parent.OutputColumnName, InitFunction, _parent.WindowSize > 0, _parent.OutputColumnType); _mapper = mapper; _bindings = new ColumnBindings(Schema.Create(input.Schema), _mapper.GetOutputColumns()); }
protected async Task <IList <T> > ReadAsync <T>(DbConnection connection, IRowMapper <T> mapper, string commandText, CommandType commandType, DbParameter[] parameters, DbTransaction transaction = null) { return(await Database.ReadAsync(connection, mapper, commandText, commandType, parameters, transaction)); }
protected override void Arrange() { base.Arrange(); mapper = builder.Build(); }
/// <summary> /// Creates a <see cref="SprocAccessor<TResult>"/> for the given stored procedure. /// </summary> /// <typeparam name="TResult">The type the <see cref="SprocAccessor<TResult>"/> should return when executing.</typeparam> /// <param name="rowMapper">The <see cref="IRowMapper<TResult>"/> that will be used to convert the returned data to clr type <typeparamref name="TResult"/>.</param> /// <param name="procedureName">The name of the stored procedure that should be executed by the <see cref="SprocAccessor<TResult>"/>. </param> /// <param name="parameterMapper">The <see cref="IParameterMapper"/> that will be used to interpret the parameters passed to the Execute method.</param> /// <returns>A new instance of <see cref="SprocAccessor<TResult>"/>.</returns> public DataAccessor <TResult> CreateOracleSprocAccessor <TResult>(string procedureName, IParameterMapper parameterMapper, IRowMapper <TResult> rowMapper) { if (string.IsNullOrEmpty(procedureName)) { throw new ArgumentException(); } return(new OracleSprocAccessor <TResult>(this, procedureName, parameterMapper, rowMapper)); }
public virtual IList QueryWithCommandCreator(IDbCommandCreator cc, IRowMapper rowMapper, IDictionary returnedParameters) { if (rowMapper == null) { throw new ArgumentNullException("rowMapper must not be null"); } return (IList)Execute(cc, new AdoRowMapperQueryCommandCallback(this, rowMapper, returnedParameters)); }
public CustomSprocAccessor(Database database, DbCommand command, IRowMapper <TResult> rowMapper) : base(database, command.CommandText, rowMapper) { Command = command; RowMapper = rowMapper; }
public virtual IList QueryWithRowMapper(CommandType cmdType, string cmdText, IRowMapper rowMapper, ICommandSetter commandSetter) { return (IList)QueryWithResultSetExtractor(cmdType, cmdText, new RowMapperResultSetExtractor(rowMapper), commandSetter); }
/// <summary> /// Creates a new instance of <see cref="SqlStringAccessor<TResult>"/> that works for a specific <paramref name="database"/> /// and uses <paramref name="rowMapper"/> to convert the returned rows to clr type <typeparamref name="TResult"/>. /// </summary> /// <param name="database">The <see cref="Database"/> used to execute the SQL.</param> /// <param name="sqlString">The SQL that will be executed.</param> /// <param name="rowMapper">The <see cref="IRowMapper<TResult>"/> that will be used to convert the returned data to clr type <typeparamref name="TResult"/>.</param> public SqlStringAccessor(Database database, string sqlString, IRowMapper <TResult> rowMapper) : this(database, sqlString, new DefaultSqlStringParameterMapper(), rowMapper) { }
public virtual IList QueryWithRowMapper(CommandType cmdType, string cmdText, IRowMapper rowMapper, IDbParameters parameters) { return (IList)QueryWithResultSetExtractor(cmdType, cmdText, new RowMapperResultSetExtractor(rowMapper), parameters); }
/// <summary> /// Creates a new instance of <see cref="SqlStringAccessor<TResult>"/> that works for a specific <paramref name="database"/> /// and uses <paramref name="rowMapper"/> to convert the returned rows to clr type <typeparamref name="TResult"/>. /// The <paramref name="parameterMapper"/> will be used to interpret the parameters passed to the Execute method. /// </summary> /// <param name="database">The <see cref="Database"/> used to execute the SQL.</param> /// <param name="sqlString">The SQL that will be executed.</param> /// <param name="parameterMapper">The <see cref="IParameterMapper"/> that will be used to interpret the parameters passed to the Execute method.</param> /// <param name="rowMapper">The <see cref="IRowMapper<TResult>"/> that will be used to convert the returned data to clr type <typeparamref name="TResult"/>.</param> public SqlStringAccessor(Database database, string sqlString, IParameterMapper parameterMapper, IRowMapper <TResult> rowMapper) : base(database, rowMapper) { if (string.IsNullOrEmpty(sqlString)) { throw new ArgumentException(Resources.ExceptionNullOrEmptyString); } if (parameterMapper == null) { throw new ArgumentNullException("parameterMapper"); } this.parameterMapper = parameterMapper; this.sqlString = sqlString; }
/// <summary> /// Execute a query with the specified command text and parameter, mapping a single result row /// to an object via a RowMapper. /// </summary> /// <param name="cmdType">The command type.</param> /// <param name="cmdText">The command text to execute.</param> /// <param name="rowMapper">object that will map one object per row</param> /// <param name="parameterName">The name of the parameter to map.</param> /// <param name="dbType">One of the database parameter type enumerations.</param> /// <param name="size">The length of the parameter. 0 if not applicable to parameter type.</param> /// <param name="parameterValue">The parameter value.</param> /// <returns>The single mapped object.</returns> /// <exception cref="Spring.Dao.IncorrectResultSizeDataAccessException"> /// If the query does not return exactly one row. /// </exception> /// <exception cref="Spring.Dao.DataAccessException"> /// If there is any problem executing the query. /// </exception> public virtual object QueryForObject(CommandType cmdType, string cmdText, IRowMapper rowMapper, string parameterName, Enum dbType, int size, object parameterValue) { IList results = QueryWithRowMapper(cmdType, cmdText, rowMapper, parameterName, dbType, size, parameterValue); return DataAccessUtils.RequiredUniqueResultSet(results); }
/// <summary> /// Initializes a new instance of the class with a /// IRowMapper instance /// </summary> /// <param name="name">The name of the associated row mapper.</param> /// <param name="rowMapper">A IRowMapper instance.</param> public NamedResultSetProcessor(string name, IRowMapper <T> rowMapper) { this.name = name; this.rowMapper = rowMapper; }
protected List<Model> queryBySql(String sql, IRowMapper mapper) { //经测试没有问题 SqlConnection conn = null;//数据库连接 // SqlDataReader dr = null; DataSet ds = null;//数据集 SqlCommand cmd = null;// List<Model> retList = new List<Model>(); try { conn = dbConn.getConnection(); cmd = new SqlCommand(); cmd.Connection = conn; cmd.CommandText = sql; SqlDataAdapter adp = new SqlDataAdapter(cmd); ds = new DataSet(); adp.Fill(ds); foreach (System.Data.DataRow row in ds.Tables[0].Rows) { Model obj = (Model)mapper.mappingRow(row); retList.Add(obj); } } catch (Exception) { } finally { dbConn.closeConnection(conn); } return retList; }
/// <summary> /// Initializes a new instance of the <see cref="Spring.Data.Core.RowMapperResultSetExtractor"/> class. /// </summary> public RowMapperResultSetExtractor(IRowMapper <T> rowMapper) : this(rowMapper, 0, null) { }
/// <summary> /// Initializes a new instance of the <see cref="RowMapperResultSetExtractor"/> class. /// </summary> public RowMapperResultSetExtractor(IRowMapper rowMapper) : this(rowMapper,0, null) { }
/// <summary> /// Initializes a new instance of the <see cref="RowMapperResultSetExtractor<T>"/> class. /// </summary> /// <param name="rowMapper">The row mapper.</param> /// <param name="rowsExpected">The rows expected.</param> public RowMapperResultSetExtractor(IRowMapper <T> rowMapper, int rowsExpected) : this(rowMapper, rowsExpected, null) { }
/// <summary> /// Executes the rowmapper with a single input parameter. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="commandText">Store procedure name. E.g. "Posts_GetPostsByUser</param> /// <param name="commandType">StoredProcedure</param> /// <param name="rowMapper">The mapper that maps a record to an object.</param> /// <param name="paramName">E.g. "userName"</param> /// <param name="paramType">string</param> /// <param name="paramValue">user001</param> /// <returns></returns> public static IList <T> Query <T>(this IDBHelper dbHelper, string commandText, CommandType commandType, string paramName, DbType paramType, object paramValue, IRowMapper <IDataReader, T> rowMapper) { DbParameter parameter = dbHelper.BuildInParam(paramName, paramType, paramValue); return(Query <T>(dbHelper, commandText, commandType, new DbParameter[1] { parameter }, rowMapper)); }
static CustomerRepository() { _rowMapper = MapBuilder<Customer> .MapAllProperties() .Build(); }