static global::System.Data.Common.DbCommand __dapper__CreateCommand(global::System.Data.Common.DbConnection connection) { var command = connection.CreateCommand(); if (command is global::Oracle.ManagedDataAccess.Client.OracleCommand typed0) { typed0.BindByName = true; typed0.InitialLONGFetchSize = -1; } command.CommandType = global::System.Data.CommandType.StoredProcedure; command.CommandText = @"sproc"; var args = command.Parameters; var p = command.CreateParameter(); p.ParameterName = @"id"; p.Direction = global::System.Data.ParameterDirection.Input; args.Add(p); p = command.CreateParameter(); p.ParameterName = @"name"; p.Direction = global::System.Data.ParameterDirection.Input; p.Size = -1; args.Add(p); return(command); }
internal IDbCommand SetupCommand(IDbConnection cnn, Action <IDbCommand, object> paramReader) { var cmd = cnn.CreateCommand(); var init = GetInit(cmd.GetType()); if (init != null) { init(cmd); } if (transaction != null) { cmd.Transaction = transaction; } cmd.CommandText = commandText; if (commandTimeout.HasValue) { cmd.CommandTimeout = commandTimeout.Value; } else if (SqlMapper.Settings.CommandTimeout.HasValue) { cmd.CommandTimeout = SqlMapper.Settings.CommandTimeout.Value; } if (commandType.HasValue) { cmd.CommandType = commandType.Value; } if (paramReader != null) { paramReader(cmd, parameters); } return(cmd); }
static global::System.Data.Common.DbCommand __dapper__CreateCommand(global::System.Data.Common.DbConnection connection) { var command = connection.CreateCommand(); if (command is global::Oracle.ManagedDataAccess.Client.OracleCommand typed0) { typed0.BindByName = true; typed0.InitialLONGFetchSize = -1; } command.CommandType = global::System.Data.CommandType.Text; command.CommandText = @"/* Test.ImplicitCommandText, Samples/Commands.input.cs #14 */ this is CommandText"; var args = command.Parameters; var p = command.CreateParameter(); p.ParameterName = @"id"; p.Direction = global::System.Data.ParameterDirection.Input; args.Add(p); p = command.CreateParameter(); p.ParameterName = @"name"; p.Direction = global::System.Data.ParameterDirection.Input; p.Size = -1; args.Add(p); return(command); }
private static async Task <int> ExecuteImplAsync(IDbConnection cnn, CommandDefinition command, object param) { var identity = new Identity(command.CommandText, command.CommandType, cnn, null, param == null ? null : param.GetType(), null); var info = GetCacheInfo(identity, param, command.AddToCache); bool wasClosed = cnn.State == ConnectionState.Closed; using (var cmd = (DbCommand)command.SetupCommand(cnn, info.ParamReader)) { try { if (wasClosed) { await((DbConnection)cnn).OpenAsync(command.CancellationToken).ConfigureAwait(false); } var result = await cmd.ExecuteNonQueryAsync(command.CancellationToken).ConfigureAwait(false); command.OnCompleted(); return(result); } finally { if (wasClosed) { cnn.Close(); } } } }
private static async Task <IEnumerable <TReturn> > MultiMapAsync <TReturn>(this IDbConnection cnn, CommandDefinition command, Type[] types, Func <object[], TReturn> map, string splitOn) { if (types.Length < 1) { throw new ArgumentException("you must provide at least one type to deserialize"); } object param = command.Parameters; var identity = new Identity(command.CommandText, command.CommandType, cnn, types[0], param == null ? null : param.GetType(), types); var info = GetCacheInfo(identity, param, command.AddToCache); bool wasClosed = cnn.State == ConnectionState.Closed; try { if (wasClosed) { await((DbConnection)cnn).OpenAsync().ConfigureAwait(false); } using (var cmd = (DbCommand)command.SetupCommand(cnn, info.ParamReader)) using (var reader = await cmd.ExecuteReaderAsync(command.CancellationToken).ConfigureAwait(false)) { var results = MultiMapImpl <TReturn>(null, default(CommandDefinition), types, map, splitOn, reader, identity, true); return(command.Buffered ? results.ToList() : results); } } finally { if (wasClosed) { cnn.Close(); } } }
/// <summary> /// Execute a query asynchronously using .NET 4.5 Task. /// </summary> public static Task <IEnumerable <object> > QueryAsync(this IDbConnection cnn, Type type, string sql, dynamic param = null, IDbTransaction transaction = null, int?commandTimeout = null, CommandType?commandType = null) { if (type == null) { throw new ArgumentNullException("type"); } return(QueryAsync <object>(cnn, type, new CommandDefinition(sql, (object)param, transaction, commandTimeout, commandType, CommandFlags.Buffered, default(CancellationToken)))); }
/// <summary> /// Gets the feature set based on the passed connection /// </summary> public static FeatureSupport Get(IDbConnection connection) { string name = connection == null ? null : connection.GetType().Name; if (string.Equals(name, "npgsqlconnection", StringComparison.OrdinalIgnoreCase)) { return(postgres); } return(@default); }
public async partial global::System.Threading.Tasks.Task TaskAsync(global::System.Data.Common.DbConnection connection, int id, string name) { // locals global::System.Data.Common.DbCommand?__dapper__command = null; bool __dapper__close = false; try { // prepare connection if (connection !.State == global::System.Data.ConnectionState.Closed) { await connection !.OpenAsync(global::System.Threading.CancellationToken.None).ConfigureAwait(false); __dapper__close = true; } // prepare command (excluding parameter values) if ((__dapper__command = global::System.Threading.Interlocked.Exchange(ref s___dapper__command_Samples_Async_NonQuery_input_cs_TaskAsync_8, null)) is null) { __dapper__command = __dapper__CreateCommand(connection !); } else { __dapper__command.Connection = connection; } // assign parameter values #pragma warning disable CS0618 __dapper__command.Parameters[0].Value = global::Dapper.Internal.InternalUtilities.AsValue(id); __dapper__command.Parameters[1].Value = global::Dapper.Internal.InternalUtilities.AsValue(name); #pragma warning restore CS0618 // execute non-query await __dapper__command.ExecuteNonQueryAsync(global::System.Threading.CancellationToken.None).ConfigureAwait(false); // TODO: post-process parameters } finally { // cleanup if (__dapper__command is not null) { __dapper__command.Connection = default; __dapper__command = global::System.Threading.Interlocked.Exchange(ref s___dapper__command_Samples_Async_NonQuery_input_cs_TaskAsync_8, __dapper__command); if (__dapper__command is not null) { await __dapper__command.DisposeAsync().ConfigureAwait(false); } } if (__dapper__close) { await(connection?.CloseAsync() ?? global::System.Threading.Tasks.Task.CompletedTask).ConfigureAwait(false); } }
public partial int ReturnViaReturn(global::System.Data.Common.DbConnection connection, int id, string inputOutput, global::System.DateTime output) { // locals global::System.Data.Common.DbCommand?__dapper__command = null; bool __dapper__close = false; try { // prepare connection if (connection !.State == global::System.Data.ConnectionState.Closed) { connection !.Open(); __dapper__close = true; } // prepare command (excluding parameter values) if ((__dapper__command = global::System.Threading.Interlocked.Exchange(ref s___dapper__command_Samples_Sync_Parameters_input_cs_ReturnViaReturn_9, null)) is null) { __dapper__command = __dapper__CreateCommand(connection !); } else { __dapper__command.Connection = connection; } // assign parameter values #pragma warning disable CS0618 __dapper__command.Parameters[0].Value = global::Dapper.Internal.InternalUtilities.AsValue(id); __dapper__command.Parameters[1].Value = global::Dapper.Internal.InternalUtilities.AsValue(inputOutput); __dapper__command.Parameters[2].Value = global::Dapper.Internal.InternalUtilities.AsValue(output); #pragma warning restore CS0618 // execute non-query __dapper__command.ExecuteNonQuery(); // TODO: post-process parameters } finally { // cleanup if (__dapper__command is not null) { __dapper__command.Connection = default; __dapper__command = global::System.Threading.Interlocked.Exchange(ref s___dapper__command_Samples_Sync_Parameters_input_cs_ReturnViaReturn_9, __dapper__command); __dapper__command?.Dispose(); } if (__dapper__close) { connection?.Close(); } }
/// <summary> /// Execute a command asynchronously using .NET 4.5 Task. /// </summary> public static Task <int> ExecuteAsync(this IDbConnection cnn, CommandDefinition command) { object param = command.Parameters; IEnumerable multiExec = GetMultiExec(param); if (multiExec != null) { return(ExecuteMultiImplAsync(cnn, command, multiExec)); } else { return(ExecuteImplAsync(cnn, command, param)); } }
private void LiteralReplacement(IDbConnection connection) { try { connection.ExecuteAsync("drop table literal1").Wait(); } catch { } connection.ExecuteAsync("create table literal1 (id int not null, foo int not null)").Wait(); connection.ExecuteAsync("insert literal1 (id,foo) values ({=id}, @foo)", new { id = 123, foo = 456 }).Wait(); var rows = new[] { new { id = 1, foo = 2 }, new { id = 3, foo = 4 } }; connection.ExecuteAsync("insert literal1 (id,foo) values ({=id}, @foo)", rows).Wait(); var count = connection.QueryAsync <int>("select count(1) from literal1 where id={=foo}", new { foo = 123 }).Result.Single(); count.IsEqualTo(1); int sum = connection.QueryAsync <int>("select sum(id) + sum(foo) from literal1").Result.Single(); sum.IsEqualTo(123 + 456 + 1 + 2 + 3 + 4); }
private void LiteralReplacementDynamic(IDbConnection connection) { var args = new DynamicParameters(); args.Add("id", 123); try { connection.ExecuteAsync("drop table literal2").Wait(); } catch { } connection.ExecuteAsync("create table literal2 (id int not null)").Wait(); connection.ExecuteAsync("insert literal2 (id) values ({=id})", args).Wait(); args = new DynamicParameters(); args.Add("foo", 123); var count = connection.QueryAsync <int>("select count(1) from literal2 where id={=foo}", args).Result.Single(); count.IsEqualTo(1); }
public async partial global::PooledAwait.PooledTask <global::SomeType> TaskAsync(global::System.Data.Common.DbConnection connection, int id, string name) { // locals global::System.Data.Common.DbCommand? __dapper__command = null; global::System.Data.Common.DbDataReader?__dapper__reader = null; bool __dapper__close = false; int[]? __dapper__tokenBuffer = null; try { // prepare connection if (connection !.State == global::System.Data.ConnectionState.Closed) { await connection !.OpenAsync(global::System.Threading.CancellationToken.None).ConfigureAwait(false); __dapper__close = true; } // prepare command (excluding parameter values) if ((__dapper__command = global::System.Threading.Interlocked.Exchange(ref s___dapper__command_Samples_Async_SinglePooled_input_cs_TaskAsync_8, null)) is null) { __dapper__command = __dapper__CreateCommand(connection !); } else { __dapper__command.Connection = connection; } // assign parameter values #pragma warning disable CS0618 __dapper__command.Parameters[0].Value = global::Dapper.Internal.InternalUtilities.AsValue(id); __dapper__command.Parameters[1].Value = global::Dapper.Internal.InternalUtilities.AsValue(name); #pragma warning restore CS0618 // execute reader const global::System.Data.CommandBehavior __dapper__behavior = global::System.Data.CommandBehavior.SequentialAccess | global::System.Data.CommandBehavior.SingleResult | global::System.Data.CommandBehavior.SingleRow; __dapper__reader = await __dapper__command.ExecuteReaderAsync(__dapper__close?(__dapper__behavior | global::System.Data.CommandBehavior.CloseConnection) : __dapper__behavior, global::System.Threading.CancellationToken.None).ConfigureAwait(false); __dapper__close = false; // performed via CommandBehavior // process single row global::SomeType __dapper__result; if (__dapper__reader.HasRows && await __dapper__reader.ReadAsync(global::System.Threading.CancellationToken.None).ConfigureAwait(false)) { __dapper__result = await global::Dapper.TypeReader.TryGetReader <global::SomeType>() !.ReadAsync(__dapper__reader, ref __dapper__tokenBuffer, global::System.Threading.CancellationToken.None).ConfigureAwait(false); } else { __dapper__result = default !;
public partial int?ShouldDetectThis(global::System.Data.Common.DbConnection connection, string region) { // locals global::System.Data.Common.DbCommand? __dapper__command = null; global::System.Data.Common.DbDataReader?__dapper__reader = null; bool __dapper__close = false; int[]? __dapper__tokenBuffer = null; try { // prepare connection if (connection !.State == global::System.Data.ConnectionState.Closed) { connection !.Open(); __dapper__close = true; } // prepare command (excluding parameter values) if ((__dapper__command = global::System.Threading.Interlocked.Exchange(ref s___dapper__command_Samples_Basic_input_cs_ShouldDetectThis_11, null)) is null) { __dapper__command = __dapper__CreateCommand(connection !); } else { __dapper__command.Connection = connection; } // assign parameter values #pragma warning disable CS0618 __dapper__command.Parameters[0].Value = global::Dapper.Internal.InternalUtilities.AsValue(region); #pragma warning restore CS0618 // execute reader const global::System.Data.CommandBehavior __dapper__behavior = global::System.Data.CommandBehavior.SequentialAccess | global::System.Data.CommandBehavior.SingleResult | global::System.Data.CommandBehavior.SingleRow; __dapper__reader = __dapper__command.ExecuteReader(__dapper__close ? (__dapper__behavior | global::System.Data.CommandBehavior.CloseConnection) : __dapper__behavior); __dapper__close = false; // performed via CommandBehavior // process single row int?__dapper__result; if (__dapper__reader.HasRows && __dapper__reader.Read()) { __dapper__result = global::Dapper.TypeReader.TryGetReader <int?>() !.Read(__dapper__reader, ref __dapper__tokenBuffer); } else { __dapper__result = default !;
public partial global::System.Collections.Generic.List <global::SomeType> List(global::System.Data.Common.DbConnection connection, int id, string name) { // locals global::System.Data.Common.DbCommand? __dapper__command = null; global::System.Data.Common.DbDataReader?__dapper__reader = null; bool __dapper__close = false; try { // prepare connection if (connection !.State == global::System.Data.ConnectionState.Closed) { connection !.Open(); __dapper__close = true; } // prepare command (excluding parameter values) if ((__dapper__command = global::System.Threading.Interlocked.Exchange(ref s___dapper__command_Samples_Sync_Multiple_input_cs_List_8, null)) is null) { __dapper__command = __dapper__CreateCommand(connection !); } else { __dapper__command.Connection = connection; } // assign parameter values #pragma warning disable CS0618 __dapper__command.Parameters[0].Value = global::Dapper.Internal.InternalUtilities.AsValue(id); __dapper__command.Parameters[1].Value = global::Dapper.Internal.InternalUtilities.AsValue(name); #pragma warning restore CS0618 // execute reader const global::System.Data.CommandBehavior __dapper__behavior = global::System.Data.CommandBehavior.SequentialAccess | global::System.Data.CommandBehavior.SingleResult | global::System.Data.CommandBehavior.SingleRow; __dapper__reader = __dapper__command.ExecuteReader(__dapper__close ? (__dapper__behavior | global::System.Data.CommandBehavior.CloseConnection) : __dapper__behavior); __dapper__close = false; // performed via CommandBehavior // process single row global::System.Collections.Generic.List <global::SomeType> __dapper__result; if (__dapper__reader.HasRows && __dapper__reader.Read()) { __dapper__result = global::Dapper.SqlMapper.GetRowParser <global::System.Collections.Generic.List <global::SomeType> >(__dapper__reader).Invoke(__dapper__reader); } else { __dapper__result = default !;
public partial void Abstract(global::System.Data.Common.DbConnection connection) { // locals global::System.Data.Common.DbCommand?__dapper__command = null; bool __dapper__close = false; try { // prepare connection if (connection !.State == global::System.Data.ConnectionState.Closed) { connection !.Open(); __dapper__close = true; } // prepare command (excluding parameter values) if ((__dapper__command = global::System.Threading.Interlocked.Exchange(ref s___dapper__command_Samples_Transactions_input_cs_Abstract_9, null)) is null) { __dapper__command = __dapper__CreateCommand(connection !); } else { __dapper__command.Connection = connection; } // execute non-query __dapper__command.ExecuteNonQuery(); // TODO: post-process parameters } finally { // cleanup if (__dapper__command is not null) { __dapper__command.Connection = default; __dapper__command = global::System.Threading.Interlocked.Exchange(ref s___dapper__command_Samples_Transactions_input_cs_Abstract_9, __dapper__command); __dapper__command?.Dispose(); } if (__dapper__close) { connection?.Close(); } }
/// <summary> /// Execute a query asynchronously using .NET 4.5 Task. /// </summary> /// <remarks>Note: each row can be accessed via "dynamic", or by casting to an IDictionary<string,object></remarks> public static async Task <IEnumerable <dynamic> > QueryAsync(this IDbConnection cnn, CommandDefinition command) { return(await QueryAsync <DapperRow>(cnn, typeof(DapperRow), command).ConfigureAwait(false)); }
/// <summary> /// Perform a multi mapping query with 7 input parameters /// </summary> public static Task <IEnumerable <TReturn> > QueryAsync <TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh, TReturn>(this IDbConnection cnn, string sql, Func <TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh, TReturn> map, dynamic param = null, IDbTransaction transaction = null, bool buffered = true, string splitOn = "Id", int?commandTimeout = null, CommandType?commandType = null) { return(MultiMapAsync <TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh, TReturn>(cnn, new CommandDefinition(sql, (object)param, transaction, commandTimeout, commandType, buffered ? CommandFlags.Buffered : CommandFlags.None, default(CancellationToken)), map, splitOn)); }
internal IDbCommand SetupCommand(IDbConnection cnn, Action<IDbCommand, object> paramReader) { var cmd = cnn.CreateCommand(); var init = GetInit(cmd.GetType()); if (init != null) init(cmd); if (transaction != null) cmd.Transaction = transaction; cmd.CommandText = commandText; if (commandTimeout.HasValue) { cmd.CommandTimeout = commandTimeout.Value; } else if (SqlMapper.Settings.CommandTimeout.HasValue) { cmd.CommandTimeout = SqlMapper.Settings.CommandTimeout.Value; } if (commandType.HasValue) cmd.CommandType = commandType.Value; if (paramReader != null) { paramReader(cmd, parameters); } return cmd; }
/// <summary> /// Perform a multi mapping query with 7 input parameters /// </summary> public static Task <IEnumerable <TReturn> > QueryAsync <TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh, TReturn>(this IDbConnection cnn, CommandDefinition command, Func <TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh, TReturn> map, string splitOn = "Id") { return(MultiMapAsync <TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh, TReturn>(cnn, command, map, splitOn)); }
private static async Task <IEnumerable <TReturn> > MultiMapAsync <TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh, TReturn>(this IDbConnection cnn, CommandDefinition command, Delegate map, string splitOn) { object param = command.Parameters; var identity = new Identity(command.CommandText, command.CommandType, cnn, typeof(TFirst), param == null ? null : param.GetType(), new[] { typeof(TFirst), typeof(TSecond), typeof(TThird), typeof(TFourth), typeof(TFifth), typeof(TSixth), typeof(TSeventh) }); var info = GetCacheInfo(identity, param, command.AddToCache); bool wasClosed = cnn.State == ConnectionState.Closed; try { if (wasClosed) { await((DbConnection)cnn).OpenAsync(command.CancellationToken).ConfigureAwait(false); } using (var cmd = (DbCommand)command.SetupCommand(cnn, info.ParamReader)) using (var reader = await cmd.ExecuteReaderAsync(wasClosed ? CommandBehavior.CloseConnection | CommandBehavior.SequentialAccess : CommandBehavior.SequentialAccess, command.CancellationToken).ConfigureAwait(false)) { if (!command.Buffered) { wasClosed = false; // handing back open reader; rely on command-behavior } var results = MultiMapImpl <TFirst, TSecond, TThird, TFourth, TFifth, TSixth, TSeventh, TReturn>(null, CommandDefinition.ForCallback(command.Parameters), map, splitOn, reader, identity, true); return(command.Buffered ? results.ToList() : results); } } finally { if (wasClosed) { cnn.Close(); } } }
/// <summary> /// Perform a multi mapping query with arbitrary input parameters /// </summary> /// <typeparam name="TReturn">The return type</typeparam> /// <param name="cnn"></param> /// <param name="sql"></param> /// <param name="types">array of types in the recordset</param> /// <param name="map"></param> /// <param name="param"></param> /// <param name="transaction"></param> /// <param name="buffered"></param> /// <param name="splitOn">The Field we should split and read the second object from (default: id)</param> /// <param name="commandTimeout">Number of seconds before command execution timeout</param> /// <param name="commandType">Is it a stored proc or a batch?</param> /// <returns></returns> public static Task <IEnumerable <TReturn> > QueryAsync <TReturn>(this IDbConnection cnn, string sql, Type[] types, Func <object[], TReturn> map, dynamic param = null, IDbTransaction transaction = null, bool buffered = true, string splitOn = "Id", int?commandTimeout = null, CommandType?commandType = null) { var command = new CommandDefinition(sql, (object)param, transaction, commandTimeout, commandType, buffered ? CommandFlags.Buffered : CommandFlags.None, default(CancellationToken)); return(MultiMapAsync <TReturn>(cnn, command, types, map, splitOn)); }
private void LiteralReplacementDynamic(IDbConnection connection) { var args = new DynamicParameters(); args.Add("id", 123); try { connection.ExecuteAsync("drop table literal2").Wait(); } catch { } connection.ExecuteAsync("create table literal2 (id int not null)").Wait(); connection.ExecuteAsync("insert literal2 (id) values ({=id})", args).Wait(); args = new DynamicParameters(); args.Add("foo", 123); var count = connection.QueryAsync<int>("select count(1) from literal2 where id={=foo}", args).Result.Single(); count.IsEqualTo(1); }
public partial global::System.Collections.Generic.IAsyncEnumerable <global::SomeType> SequenceAsync(global::System.Data.Common.DbConnection connection, int id, string name) { // use wrapper method to add support for enumerator cancellation return(__dapper__SequenceAsync(connection, id, name, global::System.Threading.CancellationToken.None));
/// <summary> /// Gets the feature set based on the passed connection /// </summary> public static FeatureSupport Get(IDbConnection connection) { string name = connection?.GetType().Name; if (string.Equals(name, "npgsqlconnection", StringComparison.OrdinalIgnoreCase)) return postgres; return @default; }
internal IDbCommand SetupCommand(IDbConnection cnn, Action<IDbCommand, object> paramReader) { var cmd = cnn.CreateCommand(); var init = GetInit(cmd.GetType()); init?.Invoke(cmd); if (Transaction != null) cmd.Transaction = Transaction; cmd.CommandText = CommandText; if (CommandTimeout.HasValue) { cmd.CommandTimeout = CommandTimeout.Value; } else if (SqlMapper.Settings.CommandTimeout.HasValue) { cmd.CommandTimeout = SqlMapper.Settings.CommandTimeout.Value; } if (CommandType.HasValue) cmd.CommandType = CommandType.Value; paramReader?.Invoke(cmd, Parameters); return cmd; }
public partial global::System.Collections.Generic.IEnumerable <global::SomeType> Sequence(global::System.Data.Common.DbConnection connection, int id, string name) { // locals global::System.Data.Common.DbCommand? __dapper__command = null; global::System.Data.Common.DbDataReader?__dapper__reader = null; bool __dapper__close = false; int[]? __dapper__tokenBuffer = null; try { // prepare connection if (connection !.State == global::System.Data.ConnectionState.Closed) { connection !.Open(); __dapper__close = true; } // prepare command (excluding parameter values) if ((__dapper__command = global::System.Threading.Interlocked.Exchange(ref s___dapper__command_Samples_Sync_Sequence_input_cs_Sequence_7, null)) is null) { __dapper__command = __dapper__CreateCommand(connection !); } else { __dapper__command.Connection = connection; } // assign parameter values #pragma warning disable CS0618 __dapper__command.Parameters[0].Value = global::Dapper.Internal.InternalUtilities.AsValue(id); __dapper__command.Parameters[1].Value = global::Dapper.Internal.InternalUtilities.AsValue(name); #pragma warning restore CS0618 // execute reader const global::System.Data.CommandBehavior __dapper__behavior = global::System.Data.CommandBehavior.SequentialAccess | global::System.Data.CommandBehavior.SingleResult | global::System.Data.CommandBehavior.SingleRow; __dapper__reader = __dapper__command.ExecuteReader(__dapper__close ? (__dapper__behavior | global::System.Data.CommandBehavior.CloseConnection) : __dapper__behavior); __dapper__close = false; // performed via CommandBehavior // process multiple rows if (__dapper__reader.HasRows) { var __dapper__parser = global::Dapper.TypeReader.TryGetReader <global::SomeType>() !; global::System.Span <int> __dapper__tokens = __dapper__reader.FieldCount <= global::Dapper.TypeReader.MaxStackTokens ? stackalloc int[__dapper__reader.FieldCount] : global::Dapper.TypeReader.RentSpan(ref __dapper__tokenBuffer, __dapper__reader.FieldCount); __dapper__parser.IdentifyFieldTokensFromSchema(__dapper__reader, __dapper__tokens); while (__dapper__reader.Read()) { yield return(__dapper__parser.Read(__dapper__reader, __dapper__tokens)); } } // consume additional results (ensures errors from the server are observed) while (__dapper__reader.NextResult()) { } // TODO: post-process parameters } finally { // cleanup global::Dapper.TypeReader.Return(ref __dapper__tokenBuffer); __dapper__reader?.Dispose(); if (__dapper__command is not null) { __dapper__command.Connection = default; __dapper__command = global::System.Threading.Interlocked.Exchange(ref s___dapper__command_Samples_Sync_Sequence_input_cs_Sequence_7, __dapper__command); __dapper__command?.Dispose(); } if (__dapper__close) { connection?.Close(); } }
/// <summary> /// Execute a query asynchronously using .NET 4.5 Task. /// </summary> public static Task <IEnumerable <T> > QueryAsync <T>(this IDbConnection cnn, CommandDefinition command) { return(QueryAsync <T>(cnn, typeof(T), command)); }
/// <summary> /// Execute a query asynchronously using .NET 4.5 Task. /// </summary> /// <remarks>Note: each row can be accessed via "dynamic", or by casting to an IDictionary<string,object></remarks> public static async Task <IEnumerable <dynamic> > QueryAsync(this IDbConnection cnn, string sql, dynamic param = null, IDbTransaction transaction = null, int?commandTimeout = null, CommandType?commandType = null) { return(await QueryAsync <DapperRow>(cnn, typeof(DapperRow), new CommandDefinition(sql, (object)param, transaction, commandTimeout, commandType, CommandFlags.Buffered, default(CancellationToken))).ConfigureAwait(false)); }
private void LiteralReplacement(IDbConnection connection) { try { connection.ExecuteAsync("drop table literal1").Wait(); } catch { } connection.ExecuteAsync("create table literal1 (id int not null, foo int not null)").Wait(); connection.ExecuteAsync("insert literal1 (id,foo) values ({=id}, @foo)", new { id = 123, foo = 456 }).Wait(); var rows = new[] { new { id = 1, foo = 2 }, new { id = 3, foo = 4 } }; connection.ExecuteAsync("insert literal1 (id,foo) values ({=id}, @foo)", rows).Wait(); var count = connection.QueryAsync<int>("select count(1) from literal1 where id={=foo}", new { foo = 123 }).Result.Single(); count.IsEqualTo(1); int sum = connection.QueryAsync<int>("select sum(id) + sum(foo) from literal1").Result.Single(); sum.IsEqualTo(123 + 456 + 1 + 2 + 3 + 4); }
static async global::System.Collections.Generic.IAsyncEnumerable <global::SomeType> __dapper__SequenceAsync(global::System.Data.Common.DbConnection connection, int id, string name, [global::System.Runtime.CompilerServices.EnumeratorCancellationAttribute] global::System.Threading.CancellationToken __dapper__cancellation) { // locals global::System.Data.Common.DbCommand? __dapper__command = null; global::System.Data.Common.DbDataReader?__dapper__reader = null; bool __dapper__close = false; int[]? __dapper__tokenBuffer = null; try { // prepare connection if (connection !.State == global::System.Data.ConnectionState.Closed) { await connection !.OpenAsync(__dapper__cancellation).ConfigureAwait(false); __dapper__close = true; } // prepare command (excluding parameter values) if ((__dapper__command = global::System.Threading.Interlocked.Exchange(ref s___dapper__command_Samples_Async_Sequence_input_cs_SequenceAsync_8, null)) is null) { __dapper__command = __dapper__CreateCommand(connection !); } else { __dapper__command.Connection = connection; } // assign parameter values #pragma warning disable CS0618 __dapper__command.Parameters[0].Value = global::Dapper.Internal.InternalUtilities.AsValue(id); __dapper__command.Parameters[1].Value = global::Dapper.Internal.InternalUtilities.AsValue(name); #pragma warning restore CS0618 // execute reader const global::System.Data.CommandBehavior __dapper__behavior = global::System.Data.CommandBehavior.SequentialAccess | global::System.Data.CommandBehavior.SingleResult | global::System.Data.CommandBehavior.SingleRow; __dapper__reader = await __dapper__command.ExecuteReaderAsync(__dapper__close?(__dapper__behavior | global::System.Data.CommandBehavior.CloseConnection) : __dapper__behavior, __dapper__cancellation).ConfigureAwait(false); __dapper__close = false; // performed via CommandBehavior // process multiple rows if (__dapper__reader.HasRows) { var __dapper__parser = global::Dapper.TypeReader.TryGetReader <global::SomeType>() !; var __dapper__tokens = global::Dapper.TypeReader.RentSegment(ref __dapper__tokenBuffer, __dapper__reader.FieldCount); __dapper__parser.IdentifyFieldTokensFromSchema(__dapper__reader, __dapper__tokens); while (await __dapper__reader.ReadAsync(__dapper__cancellation).ConfigureAwait(false)) { yield return(await __dapper__parser.ReadAsync(__dapper__reader, __dapper__tokens, __dapper__cancellation).ConfigureAwait(false)); } } // consume additional results (ensures errors from the server are observed) while (await __dapper__reader.NextResultAsync(__dapper__cancellation).ConfigureAwait(false)) { } // TODO: post-process parameters } finally { // cleanup global::Dapper.TypeReader.Return(ref __dapper__tokenBuffer); __dapper__reader?.Dispose(); if (__dapper__command is not null) { __dapper__command.Connection = default; __dapper__command = global::System.Threading.Interlocked.Exchange(ref s___dapper__command_Samples_Async_Sequence_input_cs_SequenceAsync_8, __dapper__command); __dapper__command?.Dispose(); } if (__dapper__close) { connection?.Close(); } } }
/// <summary> /// Execute a query asynchronously using .NET 4.5 Task. /// </summary> public static Task <IEnumerable <T> > QueryAsync <T>(this IDbConnection cnn, string sql, dynamic param = null, IDbTransaction transaction = null, int?commandTimeout = null, CommandType?commandType = null) { return(QueryAsync <T>(cnn, typeof(T), new CommandDefinition(sql, (object)param, transaction, commandTimeout, commandType, CommandFlags.Buffered, default(CancellationToken)))); }
/// <summary> /// Execute a command that returns multiple result sets, and access each in turn /// </summary> public static Task <GridReader> QueryMultipleAsync( #if CSHARP30 this IDbConnection cnn, string sql, object param, IDbTransaction transaction, int?commandTimeout, CommandType?commandType #else this IDbConnection cnn, string sql, dynamic param = null, IDbTransaction transaction = null, int?commandTimeout = null, CommandType?commandType = null
/// <summary> /// Execute a query asynchronously using .NET 4.5 Task. /// </summary> public static Task <IEnumerable <object> > QueryAsync(this IDbConnection cnn, Type type, CommandDefinition command) { return(QueryAsync <object>(cnn, type, command)); }
private static async Task <IEnumerable <T> > QueryAsync <T>(this IDbConnection cnn, Type effectiveType, CommandDefinition command) { object param = command.Parameters; var identity = new Identity(command.CommandText, command.CommandType, cnn, effectiveType, param == null ? null : param.GetType(), null); var info = GetCacheInfo(identity, param, command.AddToCache); bool wasClosed = cnn.State == ConnectionState.Closed; var cancel = command.CancellationToken; using (var cmd = (DbCommand)command.SetupCommand(cnn, info.ParamReader)) { DbDataReader reader = null; try { if (wasClosed) { await((DbConnection)cnn).OpenAsync(cancel).ConfigureAwait(false); } reader = await cmd.ExecuteReaderAsync(wasClosed?CommandBehavior.CloseConnection | CommandBehavior.SequentialAccess : CommandBehavior.SequentialAccess, cancel).ConfigureAwait(false); var tuple = info.Deserializer; int hash = GetColumnHash(reader); if (tuple.Func == null || tuple.Hash != hash) { tuple = info.Deserializer = new DeserializerState(hash, GetDeserializer(effectiveType, reader, 0, -1, false)); if (command.AddToCache) { SetQueryCache(identity, info); } } var func = tuple.Func; if (command.Buffered) { List <T> buffer = new List <T>(); while (await reader.ReadAsync(cancel).ConfigureAwait(false)) { buffer.Add((T)func(reader)); } while (await reader.NextResultAsync().ConfigureAwait(false)) { } command.OnCompleted(); return(buffer); } else { // can't use ReadAsync / cancellation; but this will have to do wasClosed = false; // don't close if handing back an open reader; rely on the command-behavior var deferred = ExecuteReaderSync <T>(reader, func, command.Parameters); reader = null; // to prevent it being disposed before the caller gets to see it return(deferred); } } finally { using (reader) { } // dispose if non-null if (wasClosed) { cnn.Close(); } } } }