public void Setup() { if (String.IsNullOrEmpty(ConfigPath)) { ConfigPath = Consts.DEFAULT_SMARTSQL_CONFIG_PATH; } if (String.IsNullOrEmpty(Alias)) { Alias = ConfigPath; } if (LoggerFactory == null) { LoggerFactory = NoneLoggerFactory.Instance; } if (ConfigLoader == null) { ConfigLoader = new LocalFileConfigLoader(ConfigPath, LoggerFactory); } var sqlMapConfig = ConfigLoader.Load(); SmartSqlContext = new SmartSqlContext(LoggerFactory.CreateLogger <SmartSqlContext>(), sqlMapConfig); if (DbSessionStore == null) { DbSessionStore = new DbConnectionSessionStore(LoggerFactory, SmartSqlContext.DbProvider.Factory); } if (DataSourceFilter == null) { DataSourceFilter = new DataSourceFilter(LoggerFactory.CreateLogger <DataSourceFilter>(), DbSessionStore, SmartSqlContext); } if (SqlBuilder == null) { SqlBuilder = new SqlBuilder(LoggerFactory.CreateLogger <SqlBuilder>()); } if (PreparedCommand == null) { PreparedCommand = new PreparedCommand(LoggerFactory.CreateLogger <PreparedCommand>(), SmartSqlContext); } if (CommandExecuter == null) { CommandExecuter = new CommandExecuter(LoggerFactory.CreateLogger <CommandExecuter>(), PreparedCommand); } if (DataReaderDeserializerFactory == null) { DataReaderDeserializerFactory = new EmitDataReaderDeserializerFactory(); } if (CacheManager == null) { if (SmartSqlContext.IsCacheEnabled) { CacheManager = new CacheManager(LoggerFactory.CreateLogger <CacheManager>(), SmartSqlContext, DbSessionStore); } else { CacheManager = new NoneCacheManager(); } } ConfigLoader.OnChanged += ConfigLoader_OnChanged; }
public CommandExecutor(DbCommand command, PreparedCommand prepared, RetryPolicy retryPolicy, TimedSection timedSection, ITransactionDiagnostic transaction, bool allowSynchronousOperations) { this.command = command; this.prepared = prepared; this.retryPolicy = retryPolicy; this.timedSection = timedSection; this.transaction = transaction; this.allowSynchronousOperations = allowSynchronousOperations; }
public void Execute() { Writer.Flush(); Stream.Position = 0; Stream.SetLength(Stream.Length - 2); IDbCommand com; if (UsePrepared) { var name = ActionName.ToString(); PreparedCommand preparedCommand; if (!PreparedStatements.TryGetValue(name, out preparedCommand)) { var preparedName = "LR-" + PreparedCount++; var rdr = Stream.GetReader(); preparedCommand = new PreparedCommand(preparedName, rdr.ReadToEnd(), string.Join(",", Types)); PreparedStatements[name] = preparedCommand; } Stream.Reset(); Writer.Write("EXECUTE \""); Writer.Write(preparedCommand.Name); Writer.Write('"'); if (preparedCommand.Types.Length > 0) { Writer.Write(" ("); if (WriteValues.Count > 0) { WriteValues[0](Writer); } for (int i = 1; i < WriteValues.Count; i++) { Writer.Write(','); WriteValues[i](Writer); } Writer.Write(")"); } Writer.Flush(); Stream.Position = 0; com = PostgresCommandFactory.PreparedCommand(Stream, preparedCommand.Name, preparedCommand.Query, preparedCommand.Types); } else { com = PostgresCommandFactory.NewCommand(Stream); } Results = new object[ResultActions.Count]; Query.Execute( com, dr => { for (int i = 0; i < ResultActions.Count; i++) { Results[i] = ResultActions[i](dr, i); } }); }
/// <summary> /// Attempts to execute the given prepared command. /// </summary> /// <param name="preparedCommand">The prepared command.</param> /// <param name="services">The services available to the invocation.</param> /// <param name="ct">The cancellation token for this operation.</param> /// <returns>An execution result which may or may not have succeeded.</returns> public async Task <Result <IResult> > TryExecuteAsync ( PreparedCommand preparedCommand, IServiceProvider services, CancellationToken ct = default ) { var(boundCommandNode, parameters) = preparedCommand; var groupType = boundCommandNode.Node.GroupType; var groupInstance = (CommandGroup)services.GetRequiredService(groupType); groupInstance.SetCancellationToken(ct); var method = boundCommandNode.Node.CommandMethod; try { IResult result; if (method.ReturnType.GetGenericTypeDefinition() == typeof(ValueTask <>)) { var genericUnwrapMethod = GetType() .GetMethod(nameof(UnwrapCommandValueTask), BindingFlags.NonPublic | BindingFlags.Static) ?? throw new InvalidOperationException(); var unwrapMethod = genericUnwrapMethod .MakeGenericMethod(method.ReturnType.GetGenericArguments().Single()); var invocationResult = method.Invoke(groupInstance, parameters); var unwrapTask = (Task <IResult>)(unwrapMethod.Invoke ( null, new[] { invocationResult } ) ?? throw new InvalidOperationException()); result = await unwrapTask; } else { var invocationResult = (Task)(method.Invoke(groupInstance, parameters) ?? throw new InvalidOperationException()); await invocationResult; result = (IResult)(invocationResult.GetType().GetProperty(nameof(Task <object> .Result)) ?.GetValue(invocationResult) ?? throw new InvalidOperationException()); } return(Result <IResult> .FromSuccess(result)); } catch (Exception ex) { return(ex); } }
public DapperDataReaderDeserializerFactory_Test() { _deserializerFactory = new DapperDataReaderDeserializerFactory(); _sessionStore = new DbConnectionSessionStore(LoggerFactory, DbProviderFactory); var _configLoader = new LocalFileConfigLoader(SqlMapConfigFilePath, LoggerFactory); var config = _configLoader.Load(); _smartSqlContext = new SmartSqlContext(LoggerFactory.CreateLogger <SmartSqlContext>(), config); _sqlBuilder = new SqlBuilder(LoggerFactory.CreateLogger <SqlBuilder>(), _smartSqlContext, _configLoader); var _preparedCommand = new PreparedCommand(LoggerFactory.CreateLogger <PreparedCommand>(), _smartSqlContext); _commandExecuter = new CommandExecuter(LoggerFactory.CreateLogger <CommandExecuter>(), _preparedCommand); }
public async Task PrepareCommand_NoArg() { var preparedCommand = new PreparedCommand(postgres, "SELECT value FROM enumerate_table WHERE value = @value;"); var command = preparedCommand.Clone(); var values = new HashSet <int>(); using (var reader = await command.ExecuteReaderAsync()) { await foreach (var row in reader.ToAsyncEnumerable()) { values.Add(row.GetInt32(0)); } } for (int i = 0; i < 10; i++) { Assert.Contains(i, values); } }
public void ShouldCreateDocumentsWithPreparedCommandByPossition() { var createQuery = new PreparedCommand("insert into Profile set name = ? , surname = ?"); var values = new[] { new { Name = "Pura", Surname = "Shields" }, new { Name = "Deedra", Surname = "Bonura" }, new { Name = "Foster", Surname = "Coppin" }, new { Name = "Bradly", Surname = "Sanzone" } }; foreach (var item in values) { var createdDoc = _database.Command(createQuery) .Run(item.Name, item.Surname).ToSingle(); Assert.That(createdDoc.ORID, Is.Not.Null); Assert.That(createdDoc.GetField <string>("name"), Is.EqualTo(item.Name)); Assert.That(createdDoc.GetField <string>("surname"), Is.EqualTo(item.Surname)); } }
public async Task PrepareCommand_Arg() { var singleParameters = new Dictionary <string, NpgsqlDbType>() { { "Value", NpgsqlDbType.Integer } }; var preparedCommand = new PreparedCommand(postgres, "SELECT value FROM enumerate_table WHERE value = @value;", singleParameters); var command = preparedCommand.Clone(); var values = new HashSet <int>(); command.Parameters["value"].Value = 5; using (var reader = await command.ExecuteReaderAsync()) { await foreach (var row in reader.ToAsyncEnumerable()) { values.Add(row.GetInt32(0)); } } Assert.Single(values); Assert.Contains(values, v => v == 5); }
public PreparedCommand Command(PreparedCommand command) { command.SetConnection(GetConnection()); return(command); }