/// <summary> /// Gets the values. /// </summary> /// <param name="tempReader">The temporary reader.</param> /// <returns>The resulting values</returns> private List <dynamic> GetValues(DbDataReader tempReader) { if (tempReader is null) { return(new List <dynamic>()); } var ReturnValue = new List <dynamic>(); var FieldNames = ArrayPool <string> .Shared.Rent(tempReader.FieldCount); for (var x = 0; x < tempReader.FieldCount; ++x) { var FieldName = tempReader.GetName(x); FieldNames[x] = !string.IsNullOrWhiteSpace(FieldName) ? FieldName : $"(No column name #{x})"; } while (tempReader.Read()) { var Value = DynamoFactory.Create(false); for (var x = 0; x < tempReader.FieldCount; ++x) { Value.Add(FieldNames[x], tempReader[x]); } ReturnValue.Add(Value); } ArrayPool <string> .Shared.Return(FieldNames); return(ReturnValue); }
/// <summary> /// Initializes a new instance of the <see cref="SQLHelper"/> class. /// </summary> /// <param name="stringBuilderPool">The string builder pool.</param> /// <param name="dynamoFactory">The dynamo factory.</param> /// <param name="configuration">The configuration.</param> public SQLHelper(ObjectPool <StringBuilder> stringBuilderPool, DynamoFactory dynamoFactory, IConfiguration configuration) { StringBuilderPool = stringBuilderPool; DynamoFactory = dynamoFactory; Configuration = configuration; SetConnection(new Connection(configuration, SqlClientFactory.Instance, "Default")); }
/// <summary> /// Gets the results asynchronous. /// </summary> /// <param name="ReturnValue">The return value.</param> /// <param name="ExecutableCommand">The executable command.</param> /// <param name="FinalParameters">The final parameters.</param> /// <param name="Finalizable">if set to <c>true</c> [finalizable].</param> /// <param name="FinalSQLCommand">The final SQL command.</param> /// <returns>The async task.</returns> private async Task GetResultsAsync(List <List <dynamic> > ReturnValue, DbCommand ExecutableCommand, List <IParameter> FinalParameters, bool Finalizable, string FinalSQLCommand) { if (string.IsNullOrEmpty(FinalSQLCommand)) { return; } ExecutableCommand.CommandText = FinalSQLCommand; for (int x = 0, FinalParametersCount = FinalParameters.Count; x < FinalParametersCount; ++x) { FinalParameters[x].AddParameter(ExecutableCommand); } if (Finalizable) { using var TempReader = await ExecutableCommand.ExecuteReaderAsync().ConfigureAwait(false); do { ReturnValue.Add(GetValues(TempReader)); }while (TempReader.NextResult()); } else { ReturnValue.Add(new List <dynamic> { DynamoFactory.Create(await ExecutableCommand.ExecuteNonQueryAsync().ConfigureAwait(false), false) }); } }
/// <summary> /// Constructor /// </summary> /// <param name="source">Source info</param> /// <param name="stringBuilderPool">The string builder pool.</param> /// <param name="dynamoFactory">The dynamo factory.</param> public Batch(IConnection source, ObjectPool <StringBuilder> stringBuilderPool, DynamoFactory dynamoFactory) { Commands = new List <ICommand>(); Headers = new List <ICommand>(); Source = source; StringBuilderPool = stringBuilderPool; DynamoFactory = dynamoFactory; }
/// <summary> /// Creates the batch and gets the list of objects seen. /// </summary> /// <param name="source">The source.</param> /// <param name="dynamoFactory">The dynamo factory.</param> /// <param name="Batch">The batch.</param> /// <param name="ObjectsSeen">The objects seen.</param> private void CreateBatch(IMappingSource source, DynamoFactory dynamoFactory, out SQLHelper Batch, out List <object> ObjectsSeen) { Batch = QueryProviderManager.CreateBatch(source.Source, dynamoFactory); ObjectsSeen = new List <object>(); for (int x = 0, ObjectsLength = Objects.Length; x < ObjectsLength; ++x) { Delete(Objects[x], source, Batch, ObjectsSeen); } }
/// <summary> /// Initializes a new instance of the <see cref="Session"/> class. /// </summary> /// <param name="mappingManager">The mapping manager.</param> /// <param name="schemaManager">The schema manager.</param> /// <param name="queryProviderManager">The query provider manager.</param> /// <param name="logger">The logger.</param> /// <param name="cacheManager">The cache manager.</param> /// <param name="dynamoFactory">The dynamo factory.</param> /// <exception cref="ArgumentNullException"> /// cacheManager or aopManager or mappingManager or schemaManager or queryProviderManager /// </exception> public Session(MappingManager mappingManager, SchemaManager schemaManager, QueryProviderManager queryProviderManager, ILogger logger, BigBook.Caching.Manager cacheManager, DynamoFactory dynamoFactory) { MappingManager = mappingManager ?? throw new ArgumentNullException(nameof(mappingManager)); QueryProviderManager = queryProviderManager ?? throw new ArgumentNullException(nameof(queryProviderManager)); Commands = new List <Commands.Interfaces.ICommand>(); Logger = logger ?? throw new ArgumentNullException(nameof(logger)); Cache = cacheManager?.Cache(); DynamoFactory = dynamoFactory; }
/// <summary> /// Executes this instance. /// </summary> /// <param name="source">Mapping source.</param> /// <param name="dynamoFactory">The dynamo factory.</param> /// <returns>The number of rows that are modified.</returns> public override Task <int> ExecuteAsync(IMappingSource source, DynamoFactory dynamoFactory) { if (Objects.Length == 0) { return(Task.FromResult(0)); } CreateBatch(source, dynamoFactory, out var Batch, out var ObjectsSeen); if (ObjectsSeen.Count == 0) { return(Task.FromResult(0)); } return(Batch.RemoveDuplicateCommands().ExecuteScalarAsync <int>()); }
/// <summary> /// Executes this instance. /// </summary> /// <param name="source">The source.</param> /// <returns>The number of rows that are modified.</returns> public override int Execute(IMappingSource source, DynamoFactory dynamoFactory) { if (Objects.Length == 0) { return(0); } CreateBatch(source, dynamoFactory, out var Batch, out var ObjectsSeen); if (ObjectsSeen.Count == 0) { return(0); } return(Task.Run(async() => await Batch.RemoveDuplicateCommands().ExecuteScalarAsync <int>().ConfigureAwait(false)).GetAwaiter().GetResult()); }
/// <summary> /// Creates a batch. /// </summary> /// <param name="source">The source.</param> /// <param name="dynamoFactory">The dynamo factory.</param> /// <returns>Creates a batch</returns> /// <exception cref="ArgumentNullException">source</exception> /// <exception cref="ArgumentException">Provider not found</exception> public SQLHelper CreateBatch(IDatabase source, DynamoFactory dynamoFactory) { if (source is null) { throw new ArgumentNullException(nameof(source)); } if (!Providers.TryGetValue(source.Provider, out var QueryProvider)) { throw new ArgumentException("Provider not found: " + source.Provider); } if (IsDebug) { Logger.Debug("Creating batch for data source {SourceName:l}", source.Name); } return(QueryProvider.Batch(source, dynamoFactory)); }
public void GenerateQuery() { var Mappings = new MappingSource(new IMapping[] { new BaseClass1Mapping(), new ConcreteClass1Mapping(), new ConcreteClass2Mapping(), new ConcreteClass3Mapping(), new IInterface1Mapping(), new IInterface2Mapping() }, new MockDatabaseMapping(), new QueryProviderManager(new[] { new SQLServerQueryProvider(Configuration, ObjectPool) }, Logger), Canister.Builder.Bootstrapper.Resolve <ILogger>(), ObjectPool); var TestObject = new DataLoadQuery <ConcreteClass1>(Mappings, ObjectPool); var Result = TestObject.GenerateQueries(new Dynamo[] { DynamoFactory.Create(new { ID = 1 }) })[0]; Assert.Equal(CommandType.Text, Result.DatabaseCommandType); Assert.Single(Result.Parameters); Assert.Equal(1, Result.Parameters[0].InternalValue); Assert.Equal("SELECT [dbo].[IInterface1_].[ID_] AS [ID],[dbo].[BaseClass1_].[BaseClassValue1_] AS [BaseClassValue1],[dbo].[ConcreteClass1_].[Value1_] AS [Value1]\r\nFROM [dbo].[ConcreteClass1_]\r\nINNER JOIN [dbo].[BaseClass1_] ON [dbo].[ConcreteClass1_].[BaseClass1_ID_]=[dbo].[BaseClass1_].[ID_]\r\nINNER JOIN [dbo].[IInterface1_] ON [dbo].[BaseClass1_].[IInterface1_ID_]=[dbo].[IInterface1_].[ID_]\r\nWHERE ([dbo].[IInterface1_].[ID_]=@ID0);", Result.QueryString); Assert.Equal(QueryType.LoadData, Result.QueryType); }
/// <summary> /// Creates a batch for running commands /// </summary> /// <param name="source">The source.</param> /// <param name="dynamoFactory">The dynamo factory.</param> /// <returns>A batch object</returns> public SQLHelper Batch(IDatabase source, DynamoFactory dynamoFactory) => new SQLHelper(StringBuilderPool !, dynamoFactory, Configuration).CreateBatch(Provider, source?.Name ?? string.Empty);
/// <summary> /// Executes this instance. /// </summary> /// <param name="source">The source.</param> /// <param name="dynamoFactory">The dynamo factory.</param> /// <returns>The number of rows that are modified.</returns> public abstract int Execute(IMappingSource source, DynamoFactory dynamoFactory);
/// <summary> /// Executes this instance. /// </summary> /// <param name="source">The source.</param> /// <param name="dynamoFactory">The dynamo factory.</param> /// <returns>The number of rows that are modified.</returns> public abstract Task <int> ExecuteAsync(IMappingSource source, DynamoFactory dynamoFactory);