/// <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);
