public void Add(IQuerySource querySource)
{
if (_map.ContainsKey(querySource))
return;
_map.Add(querySource, CreateUniqueName(querySource.ItemName));
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual ExpressionVisitor Create(
EntityQueryModelVisitor queryModelVisitor, IQuerySource querySource)
=> new InMemoryEntityQueryableExpressionVisitor(
_model,
_materializerFactory,
Check.NotNull(queryModelVisitor, nameof(queryModelVisitor)),
querySource);
public QuerySourceReferenceExpression (IQuerySource querySource)
{
ArgumentUtility.CheckNotNull ("querySource", querySource);
_type = querySource.ItemType;
ReferencedQuerySource = querySource;
}
public LambdaExpression Visit(Expression clause, System.Type resultType, IQuerySource querySource)
{
_inputParameter = Expression.Parameter(resultType, "inputParameter");
_querySource = querySource;
return Expression.Lambda(VisitExpression(clause), _inputParameter);
}
public IncludeExpressionVisitor(
[NotNull] ISelectExpressionFactory selectExpressionFactory,
[NotNull] IMaterializerFactory materializerFactory,
[NotNull] ICommandBuilderFactory commandBuilderFactory,
[NotNull] IRelationalAnnotationProvider relationalAnnotationProvider,
[NotNull] ISqlQueryGeneratorFactory sqlQueryGeneratorFactory,
[NotNull] IQuerySource querySource,
[NotNull] IReadOnlyList<INavigation> navigationPath,
[NotNull] RelationalQueryCompilationContext queryCompilationContext,
[NotNull] IReadOnlyList<int> queryIndexes,
bool querySourceRequiresTracking)
{
Check.NotNull(selectExpressionFactory, nameof(selectExpressionFactory));
Check.NotNull(materializerFactory, nameof(materializerFactory));
Check.NotNull(commandBuilderFactory, nameof(commandBuilderFactory));
Check.NotNull(relationalAnnotationProvider, nameof(relationalAnnotationProvider));
Check.NotNull(sqlQueryGeneratorFactory, nameof(sqlQueryGeneratorFactory));
Check.NotNull(querySource, nameof(querySource));
Check.NotNull(navigationPath, nameof(navigationPath));
Check.NotNull(queryCompilationContext, nameof(queryCompilationContext));
Check.NotNull(queryIndexes, nameof(queryIndexes));
_selectExpressionFactory = selectExpressionFactory;
_materializerFactory = materializerFactory;
_commandBuilderFactory = commandBuilderFactory;
_relationalAnnotationProvider = relationalAnnotationProvider;
_sqlQueryGeneratorFactory = sqlQueryGeneratorFactory;
_querySource = querySource;
_navigationPath = navigationPath;
_queryCompilationContext = queryCompilationContext;
_queryIndexes = queryIndexes;
_querySourceRequiresTracking = querySourceRequiresTracking;
}
public virtual ExpressionVisitor Create(
EntityQueryModelVisitor queryModelVisitor, IQuerySource querySource)
=> new RelationalProjectionExpressionVisitor(
_sqlTranslatingExpressionVisitorFactory,
_entityMaterializerSource,
(RelationalQueryModelVisitor)Check.NotNull(queryModelVisitor, nameof(queryModelVisitor)),
Check.NotNull(querySource, nameof(querySource)));
public bool AddSelectPart(IQuerySource qs, string sql, string name, Type type, Func<ResultObjectMapping, BufferedTextReader, IDataReader, object> instancer)
{
if (Selects.Any(kv => kv.Name == name))
return false;
Selects.Add(new SelectSource { QuerySource = qs, Sql = sql, Name = name, ItemType = type, Instancer = instancer });
CurrentSelectIndex++;
return true;
}
public ContactListViewModel(IQuerySource querySource)
{
_querySource = querySource;
_treeLayout = new TreeContactLayout();
_plotLayout = new PlotContactLayout(querySource);
AttemptToSetLayout();
}
public RelationalEntityQueryableExpressionTreeVisitor(
[NotNull] RelationalQueryModelVisitor queryModelVisitor,
[NotNull] IQuerySource querySource)
: base(Check.NotNull(queryModelVisitor, nameof(queryModelVisitor)))
{
Check.NotNull(querySource, nameof(querySource));
_querySource = querySource;
}
public RelationalProjectionExpressionTreeVisitor(
[NotNull] RelationalQueryModelVisitor queryModelVisitor,
[NotNull] IQuerySource querySource)
: base(Check.NotNull(queryModelVisitor, nameof(queryModelVisitor)))
{
_querySource = querySource;
_sqlTranslatingExpressionTreeVisitor
= new SqlTranslatingExpressionTreeVisitor(queryModelVisitor);
}
/// <summary>
/// Creates a new ExpressionVisitor.
/// </summary>
/// <param name="queryModelVisitor"> The query model visitor. </param>
/// <param name="querySource"> The query source. </param>
/// <returns>
/// An ExpressionVisitor.
/// </returns>
public virtual ExpressionVisitor Create(
EntityQueryModelVisitor queryModelVisitor, IQuerySource querySource)
=> new RelationalEntityQueryableExpressionVisitor(
_model,
_selectExpressionFactory,
_materializerFactory,
_shaperCommandContextFactory,
_relationalAnnotationProvider,
(RelationalQueryModelVisitor)Check.NotNull(queryModelVisitor, nameof(queryModelVisitor)),
querySource);
public RelationalProjectionExpressionVisitor(
[NotNull] RelationalQueryModelVisitor queryModelVisitor,
[NotNull] IQuerySource querySource)
: base(Check.NotNull(queryModelVisitor, nameof(queryModelVisitor)))
{
Check.NotNull(querySource, nameof(querySource));
_queryModelVisitor = queryModelVisitor;
_querySource = querySource;
}
public Expression GetExpression (IQuerySource querySource)
{
ArgumentUtility.CheckNotNull ("querySource", querySource);
Expression expression;
if (!_lookup.TryGetValue (querySource, out expression))
throw new KeyNotFoundException (string.Format ("Query source ({0}) has not been associated with an expression.", querySource));
return expression;
}
public virtual QueryFlattener Create(
IQuerySource querySource,
RelationalQueryCompilationContext relationalQueryCompilationContext,
MethodInfo operatorToFlatten,
int readerOffset)
=> new QueryFlattener(
querySource,
relationalQueryCompilationContext,
operatorToFlatten,
readerOffset);
public void ReplaceMapping (IQuerySource querySource, Expression expression)
{
ArgumentUtility.CheckNotNull ("querySource", querySource);
ArgumentUtility.CheckNotNull ("expression", expression);
if (!ContainsMapping (querySource))
throw new InvalidOperationException ("Query source has not been associated with an expression, cannot replace its mapping.");
_lookup[querySource] = expression;
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
if (_type == fromClause.ItemType)
{
_querySource = fromClause;
}
else
{
base.VisitMainFromClause(fromClause, queryModel);
}
}
public override ExpressionVisitor Create(EntityQueryModelVisitor queryModelVisitor, IQuerySource querySource)
{
return new MaterializingRelationalEntityQueryableExpressionVisitor(
_model,
_selectExpressionFactory,
_materializerFactory,
_shaperCommandContextFactory,
_relationalAnnotationProvider,
(RelationalQueryModelVisitor)queryModelVisitor,
querySource); ;
}
public string GetName(IQuerySource querySource)
{
if (!_map.ContainsKey(querySource))
throw new HibernateException(
String.Format("Query Source could not be identified: ItemName = {0}, ItemType = {1}, Expression = {2}",
querySource.ItemName,
querySource.ItemType,
querySource));
return _map[querySource];
}
private void AddQuerySource(IQuerySource querySource)
{
if (!_querySources.ContainsKey(querySource))
{
_querySources.Add(querySource, 0);
}
if (_model.FindEntityType(querySource.ItemType) != null)
{
_querySources[querySource]++;
}
}
public Expression GetExpression (IQuerySource querySource)
{
ArgumentUtility.CheckNotNull ("querySource", querySource);
try
{
return _lookup[querySource];
}
catch (KeyNotFoundException)
{
throw new KeyNotFoundException ("Query source has not been associated with an expression.");
}
}
public QuerySourceReferenceExpression (IQuerySource querySource)
#if NET_3_5
: base(ExpressionType, querySource.ItemType)
#endif
{
ArgumentUtility.CheckNotNull ("querySource", querySource);
#if !NET_3_5
_type = querySource.ItemType;
#endif
ReferencedQuerySource = querySource;
}
public override void VisitAdditionalFromClause(AdditionalFromClause fromClause, QueryModel queryModel, int index)
{
if (_type.IsAssignableFrom(fromClause.ItemType))
{
if (_querySource == null)
{
_querySource = fromClause;
return;
}
}
base.VisitAdditionalFromClause(fromClause, queryModel, index);
}
/// <summary>
/// Change the extent name of a query source to a newly generated name, replacing any previously generated name.
/// </summary>
/// <param name="querySource">IQuerySource for which to get a new extent name</param>
/// <returns>The escaped extent name for the N1QL query</returns>
public string GenerateNewExtentName(IQuerySource querySource)
{
if (querySource == null)
{
throw new ArgumentNullException("querySource");
}
// Remove the extent name, if already generated
_extentDictionary.Remove(querySource);
// Generate and return a new extent name
return GetExtentName(querySource);
}
public InMemoryEntityQueryableExpressionVisitor(
[NotNull] IModel model,
[NotNull] IMaterializerFactory materializerFactory,
[NotNull] EntityQueryModelVisitor entityQueryModelVisitor,
[CanBeNull] IQuerySource querySource)
: base(Check.NotNull(entityQueryModelVisitor, nameof(entityQueryModelVisitor)))
{
Check.NotNull(model, nameof(model));
Check.NotNull(materializerFactory, nameof(materializerFactory));
_model = model;
_materializerFactory = materializerFactory;
_querySource = querySource;
}
public void AddMapping (IQuerySource querySource, Expression expression)
{
ArgumentUtility.CheckNotNull ("querySource", querySource);
ArgumentUtility.CheckNotNull ("expression", expression);
try
{
_lookup.Add (querySource, expression);
}
catch (ArgumentException)
{
throw new InvalidOperationException ("Query source has already been associated with an expression.");
}
}
public string GetName(IQuerySource querySource)
{
string result;
if (!_map.TryGetValue(querySource, out result))
{
throw new HibernateException(
String.Format("Query Source could not be identified: ItemName = {0}, ItemType = {1}, Expression = {2}",
querySource.ItemName,
querySource.ItemType,
querySource));
}
return result;
}
/// <summary>
/// Given array info, code a loop over it.
/// </summary>
/// <param name="query">The query this loop is associated with</param>
/// <param name="arrayRef">The reference to the array</param>
/// <remarks>Will add the query to the code context to forward to the variable that is being dealt with here.</remarks>
public static IVariableScopeHolder CodeLoopOverArrayInfo(this IArrayInfo arrayRef, IQuerySource query, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container)
{
var indexVar = arrayRef.AddLoop(gc, cc, container);
if (indexVar == null)
return null;
///
/// Next, make sure the index variable can be used for later references!
///
var result = cc.Add(query, indexVar.Item1);
cc.SetLoopVariable(indexVar.Item1, indexVar.Item2);
return result;
}
public virtual QuerySourceReferenceExpression FindResultQuerySourceReferenceExpression(
[NotNull] Expression expression,
[NotNull] IQuerySource targetQuerySource)
{
Check.NotNull(expression, nameof(expression));
Check.NotNull(targetQuerySource, nameof(targetQuerySource));
_targetQuerySource = targetQuerySource;
_originQuerySourceReferenceExpression = null;
_reachable = false;
VisitExpression(expression);
return _reachable ? _originQuerySourceReferenceExpression : null;
}
/// <summary>
/// Initializes a new instance of the <see cref="c:SelectQueryData"/> class.
/// </summary>
/// <param name="commandBuilder">
/// The object responsible for SELECT statement generation.
/// </param>
/// <param name="fromData">
/// The data passed to the from clause.
/// </param>
public SelectQueryData(SqlCommandBuilder commandBuilder, IQuerySource fromData, Type modelType = null)
{
Check.NotNull(commandBuilder, "commandBuilder");
Check.NotNull(fromData, "fromData");
WhereClauses = new List<LambdaExpression>();
HavingClauses = new List<LambdaExpression>();
Distinct = false;
TakeRows = 0;
SkipRows = 0;
OrderByProperties = new List<Tuple<LambdaExpression, bool>>();
Joins = new List<JoinSpec>();
FromData = fromData;
ModelType = modelType ?? fromData.ModelType;
this.commandBuilder = commandBuilder;
}
public void SetUp ()
{
_querySource = ExpressionHelper.CreateMainFromClause_Int ();
_sourceExpression = new QuerySourceReferenceExpression (_querySource);
var originalFunc = ExpressionHelper.CreateLambdaExpression<int, int, int> ((total, i) => total + i);
_func = Expression.Lambda (
ReplacingExpressionTreeVisitor.Replace (originalFunc.Parameters[1], _sourceExpression, originalFunc.Body),
originalFunc.Parameters[0]);
_resultSelector = ExpressionHelper.CreateLambdaExpression<int, string> (total => total.ToString ());
_seed = Expression.Constant (12);
_resultOperatorWithoutResultSelector = new AggregateFromSeedResultOperator (_seed, _func, null);
_resultOperatorWithResultSelector = new AggregateFromSeedResultOperator (_seed, _func, _resultSelector);
}
private void MarkForMaterialization(IQuerySource querySource)
{
RequiresMaterializationExpressionVisitor.HandleUnderlyingQuerySources(querySource, MarkForMaterialization);
QuerySources.Add(querySource);
}
public RedisQueryingExpressionTreeVisitor(RedisQueryModelVisitor parentVisitor, IQuerySource querySource)
: base(parentVisitor)
{
_parentVisitor = parentVisitor;
_querySource = querySource;
}
public ResultObjectMapping(IQuerySource querySource, object resultObject)
{
Add(querySource, resultObject);
}
public void Add(IQuerySource querySource, object resultObject)
{
_resultObjectsBySource.Add(querySource, resultObject);
}
public ReferenceFindingExpressionVisitor(IQuerySource querySource)
{
_querySource = querySource;
}
public override bool IsShaperForQuerySource(IQuerySource querySource) => _shaper.IsShaperForQuerySource(querySource);
private TResult GetResult <TResult>(IQuerySource querySource)
{
return(_querySource == querySource
? ((QuerySourceScope <TResult>) this).Result
: _parentScope.GetResult <TResult>(querySource));
}
public virtual object GetResult([NotNull] IQuerySource querySource)
{
return(_querySource == querySource
? UntypedResult
: _parentScope.GetResult(querySource));
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public ValueBufferShaper([NotNull] IQuerySource querySource)
: base(querySource)
{
}
public QuerySourceUsageLocator(IQuerySource querySource)
{
_querySource = querySource;
}
public virtual Expression CreateMaterializer(
[NotNull] IEntityType entityType,
[NotNull] SelectExpression selectExpression,
[NotNull] Func <IProperty, SelectExpression, int> projectionAdder,
[CanBeNull] IQuerySource querySource)
{
Check.NotNull(entityType, nameof(entityType));
Check.NotNull(selectExpression, nameof(selectExpression));
Check.NotNull(projectionAdder, nameof(projectionAdder));
var valueBufferParameter
= Expression.Parameter(typeof(ValueBuffer));
var concreteEntityTypes
= entityType.GetConcreteTypesInHierarchy().ToArray();
var indexMap = new int[concreteEntityTypes[0].GetProperties().Count()];
var propertyIndex = 0;
foreach (var property in concreteEntityTypes[0].GetProperties())
{
indexMap[propertyIndex++]
= projectionAdder(property, selectExpression);
}
var materializer
= _entityMaterializerSource
.CreateMaterializeExpression(
concreteEntityTypes[0], valueBufferParameter, indexMap);
if (concreteEntityTypes.Length == 1 &&
concreteEntityTypes[0].RootType() == concreteEntityTypes[0])
{
return(Expression.Lambda <Func <ValueBuffer, object> >(materializer, valueBufferParameter));
}
var discriminatorProperty
= concreteEntityTypes[0].Relational().DiscriminatorProperty;
var discriminatorColumn
= selectExpression.Projection
.OfType <AliasExpression>()
.Single(c => c.TryGetColumnExpression()?.Property == discriminatorProperty);
var firstDiscriminatorValue
= Expression.Constant(
concreteEntityTypes[0].Relational().DiscriminatorValue);
var discriminatorPredicate
= Expression.Equal(discriminatorColumn, firstDiscriminatorValue);
if (concreteEntityTypes.Length == 1)
{
selectExpression.Predicate
= new DiscriminatorPredicateExpression(discriminatorPredicate, querySource);
return(Expression.Lambda <Func <ValueBuffer, object> >(materializer, valueBufferParameter));
}
var discriminatorValueVariable
= Expression.Variable(discriminatorProperty.ClrType);
var returnLabelTarget = Expression.Label(typeof(object));
var blockExpressions
= new Expression[]
{
Expression.Assign(
discriminatorValueVariable,
_entityMaterializerSource
.CreateReadValueExpression(
valueBufferParameter,
discriminatorProperty.ClrType,
discriminatorProperty.Index)),
Expression.IfThenElse(
Expression.Equal(discriminatorValueVariable, firstDiscriminatorValue),
Expression.Return(returnLabelTarget, materializer),
Expression.Throw(
Expression.Call(
_createUnableToDiscriminateException,
Expression.Constant(concreteEntityTypes[0])))),
Expression.Label(
returnLabelTarget,
Expression.Default(returnLabelTarget.Type))
};
foreach (var concreteEntityType in concreteEntityTypes.Skip(1))
{
indexMap = new int[concreteEntityType.GetProperties().Count()];
propertyIndex = 0;
foreach (var property in concreteEntityType.GetProperties())
{
indexMap[propertyIndex++]
= projectionAdder(property, selectExpression);
}
var discriminatorValue
= Expression.Constant(
concreteEntityType.Relational().DiscriminatorValue);
materializer
= _entityMaterializerSource
.CreateMaterializeExpression(concreteEntityType, valueBufferParameter, indexMap);
blockExpressions[1]
= Expression.IfThenElse(
Expression.Equal(discriminatorValueVariable, discriminatorValue),
Expression.Return(returnLabelTarget, materializer),
blockExpressions[1]);
discriminatorPredicate
= Expression.OrElse(
Expression.Equal(discriminatorColumn, discriminatorValue),
discriminatorPredicate);
}
selectExpression.Predicate
= new DiscriminatorPredicateExpression(discriminatorPredicate, querySource);
return(Expression.Lambda <Func <ValueBuffer, object> >(
Expression.Block(new[] { discriminatorValueVariable }, blockExpressions),
valueBufferParameter));
}
private static string GetEntityName(IQuerySource querySource)
{
return(querySource.ItemType.FullName);
}
public override Expression GetAccessorExpression(IQuerySource querySource) => _shaper.GetAccessorExpression(querySource);
/// <summary>
/// Gets all trackable includes for a given query source.
/// </summary>
/// <param name="querySource"> The query source. </param>
/// <returns>
/// The trackable includes.
/// </returns>
public virtual IReadOnlyList <IReadOnlyList <INavigation> > GetTrackableIncludes([NotNull] IQuerySource querySource)
{
Check.NotNull(querySource, nameof(querySource));
return(_trackableIncludes == null ? null : _trackableIncludes.TryGetValue(querySource, out var includes) ? includes : null);
}
public QueryWordBlock(IQuerySource source, string searchValue)
: base(source)
{
name = string.Empty;
value = searchValue;
}
private static QuerySourceScope <TResult> Create <TResult>(
IQuerySource querySource, TResult result, QuerySourceScope parentScope)
{
return(new QuerySourceScope <TResult>(querySource, result, parentScope));
}
public QueryAndOrBlock(IQuerySource source, string combine)
: base(source, combine)
{
}
protected QuerySourceScope(IQuerySource querySource, QuerySourceScope parentScope)
{
_querySource = querySource;
_parentScope = parentScope;
}
public T GetObject <T>(IQuerySource source)
{
return((T)_resultObjectsBySource[source]);
}
public void AddFromPart(IQuerySource querySource)
{
FromParts.Add($"{GetEntityName(querySource)} {querySource.ItemName}");
}
public DiscriminatorReplacingExpressionVisitor(
Expression discriminatorPredicate, IQuerySource querySource)
{
_discriminatorPredicate = discriminatorPredicate;
_querySource = querySource;
}
public void AddQuerySourceMapping(IQuerySource querySource, Expression mappedExpression)
{
_querySourceMapping.AddMapping(querySource, mappedExpression);
}
public override void UpdateQuerySource(IQuerySource querySource) => _shaper.UpdateQuerySource(querySource);
public QueryBlock(IQuerySource source)
{
this.source = source;
}
protected override ExpressionTreeVisitor CreateQueryingExpressionTreeVisitor(IQuerySource querySource)
{
Check.NotNull(querySource, "querySource");
return(new RelationalEntityQueryableExpressionTreeVisitor(this, querySource));
}
/// <summary> /// Gets the entity type mapped to the given query source /// </summary> public virtual void AddOrUpdateMapping([NotNull] IQuerySource querySource, [NotNull] IEntityType entityType) => _querySourceEntityTypeMapping[Check.NotNull(querySource, nameof(querySource))] = entityType;
protected override ExpressionTreeVisitor CreateQueryingExpressionTreeVisitor(IQuerySource querySource)
{
return(new InMemoryQueryingExpressionTreeVisitor(this, querySource));
}
public virtual bool QuerySourceRequiresMaterialization([NotNull] IQuerySource querySource)
{
Check.NotNull(querySource, nameof(querySource));
return(_querySourcesRequiringMaterialization.Contains(querySource));
}
public InMemoryQueryingExpressionTreeVisitor(
InMemoryQueryModelVisitor entityQueryModelVisitor, IQuerySource querySource)
: base(entityQueryModelVisitor)
{
_querySource = querySource;
}
public Expression GetAccessorExpression(IQuerySource querySource) => null;
