// Constructors protected SqlTemporaryDataProvider( HandlerAccessor handlers, QueryRequest request, TemporaryTableDescriptor tableDescriptor, CompilableProvider origin, ExecutableProvider[] sources) : base(handlers, request, origin, sources) { this.tableDescriptor = tableDescriptor; }
// Constructors /// <summary> /// Initializes a new instance of this class. /// </summary> /// <param name="handlers">The handlers.</param> /// <param name="request">The request.</param> /// <param name="descriptor">The descriptor.</param> /// <param name="origin">The origin.</param> /// <param name="source">The source.</param> public SqlStoreProvider( HandlerAccessor handlers, QueryRequest request, TemporaryTableDescriptor descriptor, StoreProvider origin, ExecutableProvider source) : base(handlers, request, descriptor, origin, new[] { source }) { Initialize(); }
/// <summary> /// Acquires the lock on the specified temporary table. /// </summary> /// <param name="context">The <see cref="EnumerationContext"/>.</param> /// <param name="descriptor">The descriptor of temporary table.</param> /// <returns> /// A <see cref="IDisposable"/> implementor that should be used to free acquired lock. /// </returns> public IDisposable Acquire(EnumerationContext context, TemporaryTableDescriptor descriptor) { var name = descriptor.Name; var session = context.Session; var registry = GetRegistry(session); bool isLocked; if (!registry.States.TryGetValue(name, out isLocked)) { backEnd.InitializeTable(context, descriptor); } else if (isLocked) { return(null); } registry.States[name] = true; backEnd.AcquireTable(context, descriptor); return(new Disposable(disposing => { backEnd.ReleaseTable(context, descriptor); registry.States[name] = false; })); }
// Constructors /// <summary> /// Initializes a new instance of this class. /// </summary> /// <param name="handlers">The handlers.</param> /// <param name="request">The request.</param> /// <param name="tableDescriptor">The table descriptor.</param> /// <param name="filterDataSource">The filter data source.</param> /// <param name="origin">The origin.</param> /// <param name="source">The source.</param> public SqlIncludeProvider( HandlerAccessor handlers, QueryRequest request, TemporaryTableDescriptor tableDescriptor, Func <IEnumerable <Tuple> > filterDataSource, IncludeProvider origin, ExecutableProvider source) : base(handlers, request, tableDescriptor, origin, new [] { source }) { this.filterDataSource = filterDataSource; Initialize(); }
/// <summary> /// Builds the descriptor of a temporary table. /// </summary> /// <param name="modelMapping">Model mapping.</param> /// <param name="name">The name of the temporary table.</param> /// <param name="source">The source.</param> /// <param name="fieldNames">The names of field in temporary table.</param> /// <returns>Built descriptor.</returns> public TemporaryTableDescriptor BuildDescriptor(ModelMapping modelMapping, string name, TupleDescriptor source, string[] fieldNames) { EnsureTemporaryTablesSupported(); var hasColumns = source.Count > 0; // TODO: split this method to a set of various simple virtual methods var driver = Handlers.StorageDriver; var catalog = new Catalog(modelMapping.TemporaryTableDatabase); var schema = catalog.CreateSchema(modelMapping.TemporaryTableSchema); var collation = modelMapping.TemporaryTableCollation != null ? new Collation(schema, modelMapping.TemporaryTableCollation) : null; if (fieldNames == null) { fieldNames = BuildFieldNames(source); } var typeMappings = source .Select(driver.GetTypeMapping) .ToArray(); // table var table = CreateTemporaryTable(schema, name, source, typeMappings, fieldNames, collation); var tableRef = SqlDml.TableRef(table); // select statement var queryStatement = MakeUpSelectQuery(tableRef, hasColumns); // insert statement var storeRequestBindings = new List <PersistParameterBinding>(); var insertStatement = MakeUpInsertQuery(tableRef, typeMappings, storeRequestBindings, hasColumns); var result = new TemporaryTableDescriptor(name) { TupleDescriptor = source, QueryStatement = queryStatement, CreateStatement = driver.Compile(SqlDdl.Create(table)).GetCommandText(), DropStatement = driver.Compile(SqlDdl.Drop(table)).GetCommandText(), StoreRequest = new PersistRequest(Handlers.StorageDriver, insertStatement, storeRequestBindings), ClearRequest = new PersistRequest(Handlers.StorageDriver, SqlDml.Delete(tableRef), null) }; result.StoreRequest.Prepare(); result.ClearRequest.Prepare(); return(result); }
protected SqlExpression CreateIncludeViaTemporaryTableExpression( IncludeProvider provider, IList <SqlExpression> sourceColumns, out TemporaryTableDescriptor tableDescriptor) { var filterTupleDescriptor = provider.FilteredColumnsExtractionTransform.Descriptor; var filteredColumns = provider.FilteredColumns.Select(index => sourceColumns[index]).ToList(); tableDescriptor = DomainHandler.TemporaryTableManager .BuildDescriptor(Mapping, Guid.NewGuid().ToString(), filterTupleDescriptor); var filterQuery = tableDescriptor.QueryStatement.ShallowClone(); var tableRef = filterQuery.From; for (int i = 0; i < filterTupleDescriptor.Count; i++) { filterQuery.Where &= filteredColumns[i] == tableRef[i]; } var resultExpression = SqlDml.Exists(filterQuery); return(resultExpression); }
public RowFilterParameter(TemporaryTableDescriptor temporaryTableDescriptor) : base("RowFilterData") { this.temporaryTableDescriptor = temporaryTableDescriptor; }
/// <inheritdoc/> protected override SqlProvider VisitInclude(IncludeProvider provider) { var source = Compile(provider.Source); var resultQuery = ExtractSqlSelect(provider, source); var sourceColumns = ExtractColumnExpressions(resultQuery); var bindings = source.Request.ParameterBindings; var filterDataSource = provider.FilterDataSource.CachingCompile(); var requestOptions = QueryRequestOptions.Empty; SqlExpression resultExpression; TemporaryTableDescriptor tableDescriptor = null; QueryParameterBinding extraBinding = null; var algorithm = provider.Algorithm; if (!temporaryTablesSupported) { algorithm = IncludeAlgorithm.ComplexCondition; } switch (algorithm) { case IncludeAlgorithm.Auto: var complexConditionExpression = CreateIncludeViaComplexConditionExpression( provider, BuildRowFilterParameterAccessor(filterDataSource, true), sourceColumns, out extraBinding); var temporaryTableExpression = CreateIncludeViaTemporaryTableExpression( provider, sourceColumns, out tableDescriptor); resultExpression = SqlDml.Variant(extraBinding, complexConditionExpression, temporaryTableExpression); anyTemporaryTablesRequired = true; break; case IncludeAlgorithm.ComplexCondition: resultExpression = CreateIncludeViaComplexConditionExpression( provider, BuildRowFilterParameterAccessor(filterDataSource, false), sourceColumns, out extraBinding); if (!anyTemporaryTablesRequired) { requestOptions |= QueryRequestOptions.AllowOptimization; } break; case IncludeAlgorithm.TemporaryTable: resultExpression = CreateIncludeViaTemporaryTableExpression( provider, sourceColumns, out tableDescriptor); anyTemporaryTablesRequired = true; break; default: throw new ArgumentOutOfRangeException("provider.Algorithm"); } resultExpression = GetBooleanColumnExpression(resultExpression); var calculatedColumn = provider.Header.Columns[provider.Header.Length - 1]; AddInlinableColumn(provider, calculatedColumn, resultQuery, resultExpression); if (extraBinding != null) { bindings = bindings.Concat(EnumerableUtils.One(extraBinding)); } var request = CreateQueryRequest(Driver, resultQuery, bindings, provider.Header.TupleDescriptor, requestOptions); return(new SqlIncludeProvider(Handlers, request, tableDescriptor, filterDataSource, provider, source)); }
private static Func <ParameterContext, object> BuildAutoRowFilterParameterAccessor( TemporaryTableDescriptor tableDescriptor) => context => context.TryGetValue(SqlIncludeProvider.CreateFilterParameter(tableDescriptor), out var filterData) ? filterData : null;
/// <summary> /// Releases the lock on a temporary table. /// </summary> public abstract void ReleaseTable(EnumerationContext context, TemporaryTableDescriptor descriptor);
/// <summary> /// Initializes the table. This is called once per session on a first acquire request. /// </summary> public abstract void InitializeTable(EnumerationContext context, TemporaryTableDescriptor descriptor);
public override void ReleaseTable(EnumerationContext context, TemporaryTableDescriptor descriptor) { }
public override void InitializeTable(EnumerationContext context, TemporaryTableDescriptor descriptor) { ExecuteNonQuery(context, descriptor.CreateStatement); }
public override void ReleaseTable(EnumerationContext context, TemporaryTableDescriptor descriptor) { ExecuteNonQuery(context, descriptor.DropStatement); }
public override void InitializeTable(EnumerationContext context, TemporaryTableDescriptor descriptor) { }