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;