public async Task ExecuteAsync(IEnumerable <CommandData> commands, CancellationToken cancellationToken = default)
{
FieldMap fieldMap = new FieldMap();
await using AsyncSession session = new AsyncSession(this.Options);
foreach (CommandData commandData in commands.NotNull())
{
Command command = new Command(commandData, fieldMap);
if (string.IsNullOrWhiteSpace(commandData.CommandText))
{
continue;
}
await foreach (DbDataReader dataReader in session.ExecuteAsync(command, cancellationToken).ConfigureAwait(false))
{
TableIdentity tableInfo = TableIdentity.FromRecord(dataReader);
FieldData[] fields = command.GetHeading(tableInfo);
MetadataIdentity[] attributes = fields.Select(f => f?.Attribute).ToArray();
var binder = FuncCache.GetFieldDataBinder(attributes, tableInfo);
if (await dataReader.ReadAsync().ConfigureAwait(false))
{
binder(dataReader, fields);
}
}
}
foreach (FieldData fieldData in fieldMap)
{
fieldData.Bind();
}
}
public void Execute(IEnumerable <CommandData> commands)
{
FieldMap fieldMap = new FieldMap();
using SyncSession session = new SyncSession(this.Options);
foreach (CommandData commandData in commands.NotNull())
{
Command command = new Command(commandData, fieldMap);
if (string.IsNullOrWhiteSpace(commandData.CommandText))
{
continue;
}
foreach (IDataReader reader in session.Execute(command))
{
TableIdentity tableInfo = TableIdentity.FromRecord(reader);
FieldData[] fields = command.GetHeading(tableInfo);
MetadataIdentity[] metadata = fields.Select(f => f?.Attribute).ToArray();
var binder = FuncCache.GetFieldDataBinder(metadata, tableInfo);
if (reader.Read())
{
binder(reader, fields);
}
}
}
foreach (FieldData fieldData in fieldMap)
{
fieldData.Bind();
}
}
public static ResultState <TItem> GetResultState(ISchemaStore schemas, TableIdentity heading)
{
return((ResultState <TItem>)factoryMap.GetOrAdd(heading, _ =>
{
TypeState state = GetTypeState(schemas);
return new ResultCompiler(state).Compile <TItem>(heading);
}));
}
public IEnumerable <TItem> Read <TItem>()
{
TableIdentity heading = TableIdentity.FromRecord(this.syncReader);
ResultState <TItem> state = ResultCache <TItem> .GetResultState(this.schemas, heading);
while (this.syncReader.Read())
{
yield return(state.Item(this.syncReader));
}
}
private Func <IDataReader, TItem> CompileForEnumerate <TItem>(TableIdentity heading)
{
this.variables = new VariableStore();
ItemBuilder builder = new ItemBuilder(this.State.Schema, heading);
EnumerateNode enumerateNode = builder.Build();
MetadataNode resultNode = enumerateNode.Items.FirstOrDefault(n => n.HasFlag(NodeFlags.Result));
if (resultNode == null)
{
return(r => default);
public FuncTableKey(MetadataIdentity[] metadata, TableIdentity heading)
{
if (metadata == null)
{
throw new ArgumentNullException(nameof(metadata));
}
if (heading == null)
{
throw new ArgumentNullException(nameof(heading));
}
this.Columns = metadata.Zip(heading.Columns).Select(t => new FuncColumnKey(t.l, t.r)).ToArray();
}
static async Task consumer(AdoHelper helper, DbDataReader reader)
{
TableIdentity tableInfo = TableIdentity.FromRecord(reader);
FieldData[] fields = helper.GetHeading(tableInfo);
MetadataIdentity[] attributes = fields.Select(f => f.Attribute).ToArray();
var fun = FuncCache.GetFieldDataBinder(attributes, tableInfo);
if (await reader.ReadAsync())
{
fun(reader, fields);
}
}
public async IAsyncEnumerable <TItem> ReadAsync <TItem>([EnumeratorCancellation] CancellationToken cancellationToken = default)
{
if (this.asyncReader == null)
{
throw new QueryException("Async not available. To use async operations, please supply a connection factory returning a DbConnection instance.");
}
TableIdentity heading = TableIdentity.FromRecord(this.asyncReader);
ResultState <TItem> state = ResultCache <TItem> .GetResultState(this.schemas, heading);
while (await this.asyncReader.ReadAsync(cancellationToken).ConfigureAwait(false))
{
yield return(state.Item(this.asyncReader));
}
}
public ResultState <TItem> Compile <TItem>(TableIdentity heading)
{
ResultBuilder builder = new ResultBuilder(this.State, heading);
ResultNode result = builder.Build();
ContractValidator.Validate(result);
ResultState <TItem> factory = new ResultState <TItem>()
{
Aggregate = this.State.Aggregate,
Item = this.CompileForEnumerate <TItem>(heading),
Initializer = this.CompileForInitializer(result),
List = this.CompileForList(result),
ListItem = this.CompileForListItem(result),
};
return(factory);
}
public static void SetTableIdentityEntities(List <string> contextEntitiesNames)
{
using (TransactionScope scope = new TransactionScope())
{
TableIdentity table = null;
MerkFinanceEntities context = null;
try
{
context = new MerkFinanceEntities();
context.Configuration.AutoDetectChangesEnabled = false;
int count = 0;
foreach (string entityToInsert in contextEntitiesNames)
{
++count;
table = new TableIdentity();
table.ID = count;
table.TableName = entityToInsert;
table.CommonEnityTypeID = null;
table.NextAvailableID = null;
context = SaveBulkChanges(context, table, count, 100, true);
}
//context.SaveChanges();
}
finally
{
if (context != null)
{
context.Dispose();
}
}
scope.Complete();
}
}
public ItemBuilder(ISchema schema, TableIdentity tableInfo)
{
this.schema = schema ?? throw new ArgumentNullException(nameof(schema));
this.tableInfo = tableInfo ?? throw new ArgumentNullException(nameof(tableInfo));
}
public FieldData[] GetHeading(TableIdentity tableInfo) => tableInfo.Columns.Select(ci => this.headingMap.TryGetValue(ci.Name)).ToArray();
private void SetState(IDataReader dataReader)
{
TableIdentity heading = TableIdentity.FromRecord(dataReader);
this.state = ResultCache <TItem> .GetResultState(this.Schemas, heading);
}
public static Action <IDataReader, FieldData[]> GetFieldDataBinder(MetadataIdentity[] metadata, TableIdentity tableInfo)
{
FuncTableKey key = new FuncTableKey(metadata, tableInfo);
return(tableMap.GetOrAdd(key, _ =>
{
FuncCompiler compiler = new FuncCompiler(tableInfo, metadata);
return compiler.Compile();
}));
}
public FuncCompiler(TableIdentity heading, MetadataIdentity[] attributes)
{
this.columns = heading.Columns.ToArray();
this.attributes = attributes;
}
public ResultBuilder(TypeState state, TableIdentity table)
{
this.State = state ?? throw new ArgumentNullException(nameof(state));
this.Table = table ?? throw new ArgumentNullException(nameof(table));
}
