// 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)
{
}
