protected SqlProvider CreateProvider(SqlSelect statement, IEnumerable <QueryParameterBinding> extraBindings,
CompilableProvider origin, params ExecutableProvider[] sources)
{
var sqlSources = sources.OfType <SqlProvider>();
var parameterBindings = sqlSources.SelectMany(p => p.Request.ParameterBindings);
if (extraBindings != null)
{
parameterBindings = parameterBindings.Concat(extraBindings);
}
bool allowBatching = sqlSources
.Aggregate(true, (current, provider) =>
current && provider.Request.CheckOptions(QueryRequestOptions.AllowOptimization));
var tupleDescriptor = origin.Header.TupleDescriptor;
var options = QueryRequestOptions.Empty;
if (allowBatching)
{
options |= QueryRequestOptions.AllowOptimization;
}
if (statement.Columns.Count < origin.Header.TupleDescriptor.Count)
{
tupleDescriptor = origin.Header.TupleDescriptor.Head(statement.Columns.Count);
}
var request = CreateQueryRequest(Driver, statement, parameterBindings, tupleDescriptor, options);
return(new SqlProvider(Handlers, request, origin, sources));
}
private CompilableProvider InsertCalculateFilter(CompilableProvider source,
CalculateProvider calculateProvider)
{
var result = source;
if (State.CalculateFilters.ContainsKey(calculateProvider))
{
Expression <Func <Tuple, bool> > concatenatedPredicate = null;
foreach (var filterPair in State.CalculateFilters[calculateProvider])
{
var currentPredicate = (Expression <Func <Tuple, bool> >)calculateExpressionRewriter
.Rewrite(filterPair.First, filterPair.First.Parameters[0],
filterPair.Second, result.Header.Columns);
if (concatenatedPredicate == null)
{
concatenatedPredicate = currentPredicate;
}
else
{
concatenatedPredicate = collectorHelper
.CreatePredicatesConjunction(currentPredicate, concatenatedPredicate);
}
}
result = new FilterProvider(result, concatenatedPredicate);
State.CalculateFilters.Remove(calculateProvider);
}
return(result);
}
protected SqlProvider CreateProvider(SqlSelect statement,
CompilableProvider origin, params ExecutableProvider[] sources)
{
var extraBindings = (IEnumerable <QueryParameterBinding>)null;
return(CreateProvider(statement, extraBindings, origin, sources));
}
protected SqlProvider CreateProvider(SqlSelect statement, QueryParameterBinding extraBinding,
CompilableProvider origin, params ExecutableProvider[] sources)
{
var extraBindings = extraBinding != null?EnumerableUtils.One(extraBinding) : null;
return(CreateProvider(statement, extraBindings, origin, sources));
}
public ItemProjectorExpression Remap(CompilableProvider dataSource, int[] columnMap)
{
var item = GenericExpressionVisitor <IMappedExpression>
.Process(Item, mapped => mapped.Remap(columnMap, new Dictionary <Expression, Expression>()));
return(new ItemProjectorExpression(item, dataSource, Context));
}
public static CompilableProvider Rewrite(CompilableProvider provider, Parameter <Tuple> parameterOfTuple, ApplyParameter applyParameter)
{
var expressionRewriter = new ApplyParameterToTupleParameterRewriter(parameterOfTuple, applyParameter);
var providerRewriter = new CompilableProviderVisitor(expressionRewriter.RewriteExpression);
return(providerRewriter.VisitCompilable(provider));
}
// Constructors
protected SqlTemporaryDataProvider(
HandlerAccessor handlers, QueryRequest request, TemporaryTableDescriptor tableDescriptor,
CompilableProvider origin, ExecutableProvider[] sources)
: base(handlers, request, origin, sources)
{
this.tableDescriptor = tableDescriptor;
}
protected SqlProvider CreateProvider(SqlSelect statement, IEnumerable <QueryParameterBinding> extraBindings,
CompilableProvider origin, params ExecutableProvider[] sources)
{
var allowBatching = true;
var parameterBindings = extraBindings ?? Enumerable.Empty <QueryParameterBinding>();
foreach (var provider in sources.OfType <SqlProvider>())
{
var queryRequest = provider.Request;
allowBatching &= queryRequest.CheckOptions(QueryRequestOptions.AllowOptimization);
parameterBindings = parameterBindings.Concat(queryRequest.ParameterBindings);
}
var tupleDescriptor = origin.Header.TupleDescriptor;
var options = QueryRequestOptions.Empty;
if (allowBatching)
{
options |= QueryRequestOptions.AllowOptimization;
}
if (statement.Columns.Count < origin.Header.TupleDescriptor.Count)
{
tupleDescriptor = origin.Header.TupleDescriptor.Head(statement.Columns.Count);
}
var request = CreateQueryRequest(Driver, statement, parameterBindings, tupleDescriptor, options);
return(new SqlProvider(Handlers, request, origin, sources));
}
// Constructors
public SkipTakeRewriter(CompilableProvider origin, bool takeSupported, bool skipSupported)
{
State = new SkipTakeRewriterState(this);
this.origin = origin;
this.takeSupported = takeSupported;
this.skipSupported = skipSupported;
}
public static CompilableProvider Rewrite(CompilableProvider provider, ApplyParameter oldParameter, ApplyParameter newParameter)
{
var expressionRewriter = new ApplyParameterRewriter(oldParameter, newParameter);
var providerRewriter = new CompilableProviderVisitor(expressionRewriter.RewriteExpression);
return(providerRewriter.VisitCompilable(provider));
}
public ExecutableProvider Compile(CompilableProvider provider, CompilerConfiguration configuration)
{
ArgumentValidator.EnsureArgumentNotNull(provider, "provider");
ArgumentValidator.EnsureArgumentNotNull(configuration, "configuration");
var preCompiler = preCompilerProvider.Invoke(configuration);
var compiler = compilerProvider.Invoke(configuration);
var postCompiler = postCompilerProvider.Invoke(configuration, compiler);
if (compiler == null)
{
throw new InvalidOperationException(Strings.ExCanNotCompileNoCompiler);
}
var preprocessed = preCompiler.Process(provider);
var compiled = compiler.Compile(preprocessed);
compiled = postCompiler.Process(compiled);
if (compiled == null)
{
throw new InvalidOperationException(string.Format(Strings.ExCantCompileProviderX, provider));
}
return(compiled);
}
public void MainTest()
{
Key key;
using (var session = Domain.OpenSession()) {
using (var t = session.OpenTransaction()) {
Book book = new Book {
Title = "Title", Text = "Text"
};
key = book.Key;
Session.Current.SaveChanges();
t.Complete();
}
}
using (var session = Domain.OpenSession()) {
using (session.OpenTransaction()) {
EntityState state = Session.Current.EntityStateCache[key, true];
Assert.IsNull(state);
IndexInfo ii = Domain.Model.Types[typeof(Book)].Indexes.PrimaryIndex;
var parameterContext = new ParameterContext();
// Select *
CompilableProvider rsMain = ii.GetQuery();
UpdateCache(session, rsMain.GetRecordSetReader(session, parameterContext));
state = Session.Current.EntityStateCache[key, true];
Assert.IsNotNull(state);
Assert.IsTrue(state.Tuple.GetFieldState(2).IsAvailable());
Assert.IsTrue(state.Tuple.GetFieldState(3).IsAvailable());
ResetState(state);
// Select Id, TypeId, Title
CompilableProvider rsTitle = rsMain.Select(0, 1, 2);
UpdateCache(session, rsTitle.GetRecordSetReader(session, parameterContext));
state = Session.Current.EntityStateCache[key, true];
Assert.IsNotNull(state);
Assert.IsTrue(state.Tuple.GetFieldState(2).IsAvailable());
Assert.IsFalse(state.Tuple.GetFieldState(3).IsAvailable());
ResetState(state);
// Select Id, TypeId, Text
CompilableProvider rsText = rsMain.Select(0, 1, 3);
UpdateCache(session, rsText.GetRecordSetReader(session, parameterContext));
state = Session.Current.EntityStateCache[key, true];
Assert.IsNotNull(state);
Assert.IsFalse(state.Tuple.GetFieldState(2).IsAvailable());
Assert.IsTrue(state.Tuple.GetFieldState(3).IsAvailable());
ResetState(state);
// Select a.Id, a.TypeId, a.Title, b.Id, b.TypeId, b.Text
CompilableProvider rsJoin = rsTitle.Alias("a").Join(rsText.Alias("b"), new Pair <int>(0, 0), new Pair <int>(1, 1));
UpdateCache(session, rsJoin.GetRecordSetReader(session, parameterContext));
state = Session.Current.EntityStateCache[key, true];
Assert.IsNotNull(state);
Assert.IsTrue(state.Tuple.GetFieldState(2).IsAvailable());
Assert.IsTrue(state.Tuple.GetFieldState(3).IsAvailable());
ResetState(state);
}
}
}
private static CalculateProvider RecreateCalculate(CalculateProvider provider,
CompilableProvider source)
{
var ccd = provider.CalculatedColumns.Select(
column => new CalculatedColumnDescriptor(column.Name, column.Type, column.Expression));
return(new CalculateProvider(source, ccd.ToArray()));
}
/// <summary>
/// Calculates count of elements of provided <paramref name="provider"/>.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="session">The session.</param>
public static long Count(this CompilableProvider provider, Session session)
{
return(provider
.Aggregate(null, new AggregateColumnDescriptor("$Count", 0, AggregateType.Count))
.GetRecordSet(session)
.First()
.GetValue <long>(0));
}
/// <summary>
/// Compiles specified <paramref name="provider"/>
/// and returns new <see cref="RecordSet"/> bound to specified <paramref name="session"/>.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="session">The session.</param>
/// <returns>New <see cref="RecordSet"/> bound to specified <paramref name="session"/>.</returns>
public static RecordSet GetRecordSet(this CompilableProvider provider, Session session)
{
ArgumentValidator.EnsureArgumentNotNull(provider, "provider");
ArgumentValidator.EnsureArgumentNotNull(session, "session");
var compiled = session.Compile(provider);
return(new RecordSet(session.CreateEnumerationContext(), compiled));
}
private static AggregateProvider RecreateAggregate(AggregateProvider provider,
CompilableProvider source)
{
var acd = provider.AggregateColumns.Select(
ac => new AggregateColumnDescriptor(ac.Name, ac.SourceIndex, ac.AggregateType));
return(new AggregateProvider(source, provider.GroupColumnIndexes, acd.ToArray()));
}
private void VisitBinaryProvider(BinaryProvider provider, out CompilableProvider left,
out CompilableProvider right)
{
using (new CorrectorState(this))
left = VisitCompilable(provider.Left);
using (new CorrectorState(this))
right = VisitCompilable(provider.Right);
}
protected override Provider VisitApply(ApplyProvider provider)
{
// split
List <int> leftMapping;
List <int> rightMapping;
SplitMappings(provider, out leftMapping, out rightMapping);
ApplyParameter applyParameter = provider.ApplyParameter;
var currentOuterUsages = new List <int>();
outerColumnUsages.Add(applyParameter, currentOuterUsages);
outerColumnUsageVisitor.VisitCompilable(provider.Right);
outerColumnUsages.Remove(applyParameter);
leftMapping = Merge(leftMapping, currentOuterUsages);
if (leftMapping.Count == 0)
{
leftMapping.Add(0);
}
// visit
var oldMappings = ReplaceMappings(provider.Left, leftMapping);
CompilableProvider newLeftProvider = VisitCompilable(provider.Left);
leftMapping = mappings[provider.Left];
ReplaceMappings(provider.Right, rightMapping);
outerColumnUsages.Add(applyParameter, leftMapping);
CompilableProvider newRightProvider = VisitCompilable(provider.Right);
outerColumnUsages.Remove(applyParameter);
var pair = OverrideRightApplySource(provider, newRightProvider, rightMapping);
if (pair.First == null)
{
rightMapping = mappings[provider.Right];
}
else
{
newRightProvider = pair.First;
rightMapping = pair.Second;
}
RestoreMappings(oldMappings);
mappings[provider] = Merge(leftMapping, rightMapping.Select(map => map + provider.Left.Header.Length));
if (newLeftProvider == provider.Left && newRightProvider == provider.Right)
{
return(provider);
}
return(new ApplyProvider(applyParameter, newLeftProvider, newRightProvider, provider.IsInlined, provider.SequenceType, provider.ApplyType));
}
/// <summary>
/// Compiles specified <paramref name="provider"/>
/// and returns new <see cref="RecordSetReader"/> bound to specified <paramref name="session"/>.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="session">The session.</param>
/// <param name="parameterContext"><see cref="ParameterContext"/> instance with
/// the values of query parameters.</param>
/// <returns>New <see cref="RecordSetReader"/> bound to specified <paramref name="session"/>.</returns>
public static RecordSetReader GetRecordSetReader(
this CompilableProvider provider, Session session, ParameterContext parameterContext)
{
ArgumentValidator.EnsureArgumentNotNull(provider, nameof(provider));
ArgumentValidator.EnsureArgumentNotNull(session, nameof(session));
var executableProvider = session.Compile(provider);
return(executableProvider.GetRecordSetReader(session, parameterContext));
}
public void RebindApplyParameter(CompilableProvider old, CompilableProvider @new)
{
ApplyParameter parameter;
if (applyParameters.TryGetValue(old, out parameter))
{
applyParameters[@new] = parameter;
}
}
public ItemProjectorExpression Remap(CompilableProvider dataSource, int offset)
{
if (offset == 0)
{
return(new ItemProjectorExpression(Item, dataSource, Context));
}
var item = GenericExpressionVisitor <IMappedExpression> .Process(Item, mapped => mapped.Remap(offset, new Dictionary <Expression, Expression>()));
return(new ItemProjectorExpression(item, dataSource, Context));
}
public CompilableProvider Process(CompilableProvider rootProvider)
{
var provider = rootProvider;
foreach (var item in Items)
{
provider = item.Process(provider);
}
return(provider);
}
protected override Provider Visit(CompilableProvider cp)
{
var isPagingProvider = cp.Type.In(ProviderType.Take, ProviderType.Skip, ProviderType.Paging);
if (isPagingProvider && !State.IsSkipTakeChain)
{
var visitedProvider = (CompilableProvider)base.Visit(cp);
var requiresRowNumber = (State.Take != null && !takeSupported) || (State.Skip != null && !skipSupported);
// add rownumber column (if needed)
if (requiresRowNumber)
{
// Arrray to avoid access to modified closure
string[] columnName = { String.Format(Strings.RowNumberX, rowNumberCount++) };
while (visitedProvider.Header.Columns.Any(column => column.Name == columnName[0]))
{
columnName[0] = String.Format(Strings.RowNumberX, rowNumberCount++);
}
visitedProvider = new RowNumberProvider(visitedProvider, columnName[0]);
}
if (State.Take != null && State.Skip != null)
{
visitedProvider = new PagingProvider(visitedProvider, State.Skip, State.Take);
}
else if (State.Take != null)
{
visitedProvider = new TakeProvider(visitedProvider, State.Take);
}
else
{
visitedProvider = new SkipProvider(visitedProvider, State.Skip);
}
// add select removing RowNumber column
if (requiresRowNumber)
{
visitedProvider = new SelectProvider(
visitedProvider,
Enumerable.Range(0, visitedProvider.Header.Length - 1).ToArray());
}
return(visitedProvider);
}
if (!isPagingProvider && State.IsSkipTakeChain)
{
using (State.CreateScope())
return(base.Visit(cp));
}
return(base.Visit(cp));
}
// Constructors
/// <summary>
/// Initializes a new instance of this class.
/// </summary>
/// <param name="request">A <see cref="QueryRequest"/> instance associated with
/// the newly created <see cref="SqlProvider"/>.
/// </param>
/// <param name="origin">The origin.</param>
/// <param name="handlers">The handlers.</param>
/// <param name="sources">The sources.</param>
public SqlProvider(HandlerAccessor handlers, QueryRequest request,
CompilableProvider origin, ExecutableProvider[] sources)
: base(origin, sources)
{
this.handlers = handlers;
Request = request;
if (typeof(SqlProvider) == GetType())
{
Initialize();
}
}
/// <summary>
/// Calculates count of elements of provided <paramref name="provider"/>.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="session">The session.</param>
public static long Count(this CompilableProvider provider, Session session)
{
ArgumentValidator.EnsureArgumentNotNull(provider, nameof(provider));
ArgumentValidator.EnsureArgumentNotNull(session, nameof(session));
using var recordSetReader = provider
.Aggregate(null, new AggregateColumnDescriptor("$Count", 0, AggregateType.Count))
.GetRecordSetReader(session, new ParameterContext());
return(recordSetReader.MoveNext() && recordSetReader.Current != null
? recordSetReader.Current.GetValue <long>(0)
: throw new InvalidOperationException("Sequence contains no elements."));
}
private static CompilableProvider BuildSetOperationSource(CompilableProvider provider, IEnumerable <int> expectedColumns, IList <int> returningColumns)
{
if (provider.Type == ProviderType.Select)
{
return(provider);
}
var columns = expectedColumns
.Select(originalIndex => new { OriginalIndex = originalIndex, NewIndex = returningColumns.IndexOf(originalIndex) })
.Select(x => x.NewIndex < 0 ? x.OriginalIndex : x.NewIndex).ToArray();
return(new SelectProvider(provider, columns));
}
// Constructors
public ItemProjectorExpression(Expression expression, CompilableProvider dataSource, TranslatorContext context)
: base(ExtendedExpressionType.ItemProjector, expression.Type)
{
DataSource = dataSource;
Context = context;
var newApplyParameter = Context.GetApplyParameter(dataSource);
var applyParameterReplacer = new ExtendedExpressionReplacer(ex =>
ex is SubQueryExpression
? ((SubQueryExpression)ex).ReplaceApplyParameter(newApplyParameter)
: null);
Item = applyParameterReplacer.Replace(expression);
}
protected static SqlSelect ExtractSqlSelect(CompilableProvider origin, SqlProvider compiledSource)
{
var sourceSelect = compiledSource.Request.Statement;
if (ShouldUseQueryReference(origin, compiledSource))
{
var queryRef = compiledSource.PermanentReference;
var query = SqlDml.Select(queryRef);
query.Columns.AddRange(queryRef.Columns);
return(query);
}
return(sourceSelect.ShallowClone());
}
private Provider ProcesSelfConvertibleApply(ApplyProvider provider, CompilableProvider left,
CompilableProvider right)
{
if (State.Predicates.ContainsKey(provider.ApplyParameter))
{
State.Predicates.Remove(provider.ApplyParameter);
}
if (left != provider.Left || right != provider.Right)
{
return(new ApplyProvider(provider.ApplyParameter, left, right, provider.IsInlined, provider.SequenceType, provider.ApplyType));
}
return(provider);
}
private CalculateProvider RewriteCalculateColumnExpressions(
Pair <CalculateProvider, ColumnCollection> providerPair, CompilableProvider source)
{
var ccd = providerPair.First.CalculatedColumns.Select(
column => {
var newColumnExpression = (Expression <Func <Tuple, object> >)calculateExpressionRewriter
.Rewrite(column.Expression, column.Expression.Parameters[0], providerPair.Second,
source.Header.Columns);
var currentName = providerPair.Second.Single(c => c.Index == column.Index).Name;
return(new CalculatedColumnDescriptor(currentName, column.Type, newColumnExpression));
});
return(new CalculateProvider(source, ccd.ToArray()));
}
