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