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);
		}

 /// <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 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 void Add(IQuerySource querySource)
		{
			if (_map.ContainsKey(querySource))
				return;

			_map.Add(querySource, CreateUniqueName(querySource.ItemName));
		}

		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 RelationalEntityQueryableExpressionTreeVisitor(
            [NotNull] RelationalQueryModelVisitor queryModelVisitor,
            [NotNull] IQuerySource querySource)
            : base(Check.NotNull(queryModelVisitor, nameof(queryModelVisitor)))
        {
            Check.NotNull(querySource, nameof(querySource));

            _querySource = querySource;
        }

        public ContactListViewModel(IQuerySource querySource)
        {
            _querySource = querySource;

            _treeLayout = new TreeContactLayout();
            _plotLayout = new PlotContactLayout(querySource);

            AttemptToSetLayout();
        }

    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 virtual QueryFlattener Create(
     IQuerySource querySource,
     RelationalQueryCompilationContext relationalQueryCompilationContext,
     MethodInfo operatorToFlatten,
     int readerOffset)
     => new QueryFlattener(
         querySource,
         relationalQueryCompilationContext,
         operatorToFlatten,
         readerOffset);

 /// <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 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 RelationalProjectionExpressionTreeVisitor(
            [NotNull] RelationalQueryModelVisitor queryModelVisitor,
            [NotNull] IQuerySource querySource)
            : base(Check.NotNull(queryModelVisitor, nameof(queryModelVisitor)))
        {
            _querySource = querySource;

            _sqlTranslatingExpressionTreeVisitor
                = new SqlTranslatingExpressionTreeVisitor(queryModelVisitor);
        }

        public RelationalProjectionExpressionVisitor(
            [NotNull] RelationalQueryModelVisitor queryModelVisitor,
            [NotNull] IQuerySource querySource)
            : base(Check.NotNull(queryModelVisitor, nameof(queryModelVisitor)))
        {
            Check.NotNull(querySource, nameof(querySource));

            _queryModelVisitor = queryModelVisitor;
            _querySource = querySource;
        }

 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 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 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.");
   }
 }