Menu
▾
▴
[Nhibernate-commit] SF.net SVN: nhibernate:[5383] trunk/nhibernate
|
From: <pa...@us...> - 2011-02-18 06:26:26
|
Revision: 5383
http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5383&view=rev
Author: patearl
Date: 2011-02-18 06:26:18 +0000 (Fri, 18 Feb 2011)
Log Message:
-----------
Reverted ReLinq upgrade until I can figure out what happened to test TearDowns.
Modified Paths:
--------------
trunk/nhibernate/lib/net/3.5/Remotion.Data.Linq.dll
trunk/nhibernate/lib/net/3.5/Remotion.Data.Linq.pdb
trunk/nhibernate/src/NHibernate/Linq/NhRelinqQueryParser.cs
trunk/nhibernate/src/NHibernate/Linq/Visitors/ExpressionKeyVisitor.cs
trunk/nhibernate/src/NHibernate/Linq/Visitors/QueryModelVisitor.cs
trunk/nhibernate/src/NHibernate/Linq/Visitors/ResultOperatorProcessors/ProcessAggregate.cs
trunk/nhibernate/src/NHibernate/NHibernate.csproj
Added Paths:
-----------
trunk/nhibernate/lib/net/3.5/Remotion.Data.Linq.xml
trunk/nhibernate/src/NHibernate/Linq/Expressions/AggregateExpressionNode.cs
trunk/nhibernate/src/NHibernate/Linq/ResultOperators/AggregateResultOperator.cs
Removed Paths:
-------------
trunk/nhibernate/src/NHibernate/Linq/Visitors/ResultOperatorProcessors/ProcessAggregateFromSeed.cs
Modified: trunk/nhibernate/lib/net/3.5/Remotion.Data.Linq.dll
===================================================================
(Binary files differ)
Modified: trunk/nhibernate/lib/net/3.5/Remotion.Data.Linq.pdb
===================================================================
(Binary files differ)
Copied: trunk/nhibernate/lib/net/3.5/Remotion.Data.Linq.xml (from rev 5381, trunk/nhibernate/lib/net/3.5/Remotion.Data.Linq.xml)
===================================================================
--- trunk/nhibernate/lib/net/3.5/Remotion.Data.Linq.xml (rev 0)
+++ trunk/nhibernate/lib/net/3.5/Remotion.Data.Linq.xml 2011-02-18 06:26:18 UTC (rev 5383)
@@ -0,0 +1,1253 @@
+<?xml version="1.0" encoding="utf-8"?><doc><assembly>
+ <name>Remotion.Data.Linq</name>
+ </assembly><members><member name="T:Remotion.Data.Linq.DefaultQueryProvider"><summary>
+ Represents a default implementation of <see cref="T:Remotion.Data.Linq.QueryProviderBase" /> that is automatically used by <see cref="T:Remotion.Data.Linq.QueryableBase`1" />
+ unless a custom <see cref="T:System.Linq.IQueryProvider" /> is specified. The <see cref="T:Remotion.Data.Linq.DefaultQueryProvider" /> executes queries by parsing them into
+ an instance of type <see cref="T:Remotion.Data.Linq.QueryModel" />, which is then passed to an implementation of <see cref="T:Remotion.Data.Linq.IQueryExecutor" /> to obtain the
+ result set.
+ </summary></member><member name="T:Remotion.Data.Linq.QueryProviderBase"><summary>
+ Provides a default implementation of <see cref="T:System.Linq.IQueryProvider" /> that executes queries (subclasses of <see cref="T:Remotion.Data.Linq.QueryableBase`1" />) by
+ first parsing them into a <see cref="T:Remotion.Data.Linq.QueryModel" /> and then passing that to a given implementation of <see cref="T:Remotion.Data.Linq.IQueryExecutor" />.
+ Usually, <see cref="T:Remotion.Data.Linq.DefaultQueryProvider" /> should be used unless <see cref="M:Remotion.Data.Linq.QueryProviderBase.CreateQuery``1(System.Linq.Expressions.Expression)" /> must be manually implemented.
+ </summary></member><member name="M:Remotion.Data.Linq.QueryProviderBase.#ctor(Remotion.Data.Linq.IQueryExecutor)"><summary>
+ Initializes a new instance of <see cref="T:Remotion.Data.Linq.QueryProviderBase" /> using the default <see cref="T:Remotion.Data.Linq.Parsing.Structure.MethodCallExpressionNodeTypeRegistry" />.
+ </summary><param name="executor">The <see cref="T:Remotion.Data.Linq.IQueryExecutor" /> used to execute queries against a specific query backend.</param></member><member name="M:Remotion.Data.Linq.QueryProviderBase.#ctor(Remotion.Data.Linq.IQueryExecutor,Remotion.Data.Linq.Parsing.Structure.MethodCallExpressionNodeTypeRegistry)"><summary>
+ Initializes a new instance of <see cref="T:Remotion.Data.Linq.QueryProviderBase" /> using a custom <see cref="T:Remotion.Data.Linq.Parsing.Structure.MethodCallExpressionNodeTypeRegistry" />. Use this
+ constructor to specify a specific set of parsers to use when analyzing the query.
+ </summary><param name="executor">The <see cref="T:Remotion.Data.Linq.IQueryExecutor" /> used to execute queries against a specific query backend.</param><param name="nodeTypeRegistry">The <see cref="T:Remotion.Data.Linq.Parsing.Structure.MethodCallExpressionNodeTypeRegistry" /> containing the <see cref="T:System.Linq.Expressions.MethodCallExpression" />
+ parsers that should be used when parsing queries.</param></member><member name="M:Remotion.Data.Linq.QueryProviderBase.CreateQuery(System.Linq.Expressions.Expression)"><summary>
+ Constructs an <see cref="T:System.Linq.IQueryable" /> object that can evaluate the query represented by a specified expression tree. This
+ method delegates to <see cref="M:Remotion.Data.Linq.QueryProviderBase.CreateQuery``1(System.Linq.Expressions.Expression)" />.
+ </summary><param name="expression">An expression tree that represents a LINQ query.</param></member><member name="M:Remotion.Data.Linq.QueryProviderBase.CreateQuery``1(System.Linq.Expressions.Expression)"><summary>
+ Constructs an <see cref="T:System.Linq.IQueryable`1" /> object that can evaluate the query represented by a specified expression tree. This method is
+ called by the standard query operators defined by the <see cref="T:System.Linq.Queryable" /> class.
+ </summary><param name="expression">An expression tree that represents a LINQ query.</param></member><member name="M:Remotion.Data.Linq.QueryProviderBase.Execute``1(System.Linq.Expressions.Expression)"><summary>
+ Executes the query defined by the specified expression by parsing it with a
+ <see cref="T:Remotion.Data.Linq.Parsing.Structure.QueryParser" /> and then running it through the <see cref="P:Remotion.Data.Linq.QueryProviderBase.Executor" />.
+ This method is invoked through the <see cref="T:System.Linq.IQueryProvider" /> interface by methods such as
+ <see cref="M:System.Linq.Queryable.First``1(System.Linq.IQueryable{``0})" /> and
+ <see cref="M:System.Linq.Queryable.Count``1(System.Linq.IQueryable{``0})" />, and it's also invoked by <see cref="T:Remotion.Data.Linq.QueryableBase`1" />
+ when the <see cref="T:System.Linq.IQueryable`1" /> is enumerated.
+ </summary></member><member name="M:Remotion.Data.Linq.QueryProviderBase.GenerateQueryModel(System.Linq.Expressions.Expression)"><summary>
+ The method generates a <see cref="T:Remotion.Data.Linq.QueryModel" />.
+ </summary><param name="expression">The query as expression chain.</param></member><member name="P:Remotion.Data.Linq.QueryProviderBase.Executor"><summary>
+ Gets or sets the implementation of <see cref="T:Remotion.Data.Linq.IQueryExecutor" /> used to execute queries created via <see cref="M:Remotion.Data.Linq.QueryProviderBase.CreateQuery``1(System.Linq.Expressions.Expression)" />.
+ </summary></member><member name="P:Remotion.Data.Linq.QueryProviderBase.ExpressionTreeParser"><summary>
+ Gets the <see cref="P:Remotion.Data.Linq.QueryProviderBase.ExpressionTreeParser" /> used by this <see cref="T:Remotion.Data.Linq.QueryProviderBase" /> to parse LINQ <see cref="T:System.Linq.Expressions.Expression" />
+ trees.
+ </summary></member><member name="M:Remotion.Data.Linq.DefaultQueryProvider.CreateQuery``1(System.Linq.Expressions.Expression)"><summary>
+ Creates a new <see cref="T:System.Linq.IQueryable" /> (of type <see cref="P:Remotion.Data.Linq.DefaultQueryProvider.QueryableType" /> with <typeparamref name="T" /> as its generic argument) that
+ represents the query defined by <paramref name="expression" /> and is able to enumerate its results.
+ </summary><param name="expression">An expression representing the query for which a <see cref="T:System.Linq.IQueryable`1" /> should be created.</param></member><member name="P:Remotion.Data.Linq.DefaultQueryProvider.QueryableType"><summary>
+ Gets the type of queryable created by this provider. This is the generic type definition of an implementation of <see cref="T:System.Linq.IQueryable`1" />
+ (usually a subclass of <see cref="T:Remotion.Data.Linq.QueryableBase`1" />) with exactly one type argument.
+ </summary></member><member name="T:Remotion.Data.Linq.IQueryExecutor"><summary>
+ Constitutes the bridge between re-linq and a concrete query provider implementation. Concrete providers implement this interface
+ and <see cref="T:Remotion.Data.Linq.QueryProviderBase" /> calls the respective method of the interface implementation when a query is to be executed.
+ </summary></member><member name="M:Remotion.Data.Linq.IQueryExecutor.ExecuteScalar``1(Remotion.Data.Linq.QueryModel)"><summary>
+ Executes the given <paramref name="queryModel" /> as a scalar query, i.e. as a query returning a scalar value of type <typeparamref name="T" />.
+ The query ends with a scalar result operator, for example a <see cref="T:Remotion.Data.Linq.Clauses.ResultOperators.CountResultOperator" /> or a <see cref="T:Remotion.Data.Linq.Clauses.ResultOperators.SumResultOperator" />.
+ </summary><param name="queryModel">The <see cref="T:Remotion.Data.Linq.QueryModel" /> representing the query to be executed. Analyze this via an
+ <see cref="T:Remotion.Data.Linq.IQueryModelVisitor" />.</param></member><member name="M:Remotion.Data.Linq.IQueryExecutor.ExecuteSingle``1(Remotion.Data.Linq.QueryModel,System.Boolean)"><summary>
+ Executes the given <paramref name="queryModel" /> as a single object query, i.e. as a query returning a single object of type
+ <typeparamref name="T" />.
+ The query ends with a single result operator, for example a <see cref="T:Remotion.Data.Linq.Clauses.ResultOperators.FirstResultOperator" /> or a <see cref="T:Remotion.Data.Linq.Clauses.ResultOperators.SingleResultOperator" />.
+ </summary><param name="queryModel">The <see cref="T:Remotion.Data.Linq.QueryModel" /> representing the query to be executed. Analyze this via an
+ <see cref="T:Remotion.Data.Linq.IQueryModelVisitor" />.</param><param name="returnDefaultWhenEmpty">If <see langword="true" />, the executor must return a default value when its result set is empty;
+ if <see langword="false" />, it should throw an <see cref="T:System.InvalidOperationException" /> when its result set is empty.</param></member><member name="M:Remotion.Data.Linq.IQueryExecutor.ExecuteCollection``1(Remotion.Data.Linq.QueryModel)"><summary>
+ Executes the given <paramref name="queryModel" /> as a collection query, i.e. as a query returning objects of type <typeparamref name="T" />.
+ The query does not end with a scalar result operator, but it can end with a single result operator, for example
+ <see cref="T:Remotion.Data.Linq.Clauses.ResultOperators.SingleResultOperator" /> or <see cref="T:Remotion.Data.Linq.Clauses.ResultOperators.FirstResultOperator" />. In such a case, the returned enumerable must yield exactly
+ one object (or none if the last result operator allows empty result sets).
+ </summary><param name="queryModel">The <see cref="T:Remotion.Data.Linq.QueryModel" /> representing the query to be executed. Analyze this via an
+ <see cref="T:Remotion.Data.Linq.IQueryModelVisitor" />.</param></member><member name="T:Remotion.Data.Linq.IQueryModelVisitor"><summary>
+ Defines an interface for visiting the clauses of a <see cref="T:Remotion.Data.Linq.QueryModel" />.
+ </summary></member><member name="T:Remotion.Data.Linq.QueryableBase`1"><summary>
+ Acts as a common base class for <see cref="T:System.Linq.IQueryable`1" /> implementations based on re-linq. In a specific LINQ provider, a custom queryable
+ class should be derived from <see cref="T:Remotion.Data.Linq.QueryableBase`1" /> which supplies an implementation of <see cref="T:Remotion.Data.Linq.IQueryExecutor" /> that is used to
+ execute the query. This is then used as an entry point (the main data source) of a LINQ query.
+ </summary></member><member name="M:Remotion.Data.Linq.QueryableBase`1.#ctor(Remotion.Data.Linq.IQueryExecutor)"><summary>
+ Initializes a new instance of the <see cref="T:Remotion.Data.Linq.QueryableBase`1" /> class with a <see cref="T:Remotion.Data.Linq.DefaultQueryProvider" /> and the given
+ <paramref name="executor" />. This constructor should be used by subclasses to begin a new query. The <see cref="P:Remotion.Data.Linq.QueryableBase`1.Expression" /> generated by
+ this constructor is a <see cref="T:System.Linq.Expressions.ConstantExpression" /> pointing back to this <see cref="T:Remotion.Data.Linq.QueryableBase`1" />.
+ </summary><param name="executor">The <see cref="T:Remotion.Data.Linq.IQueryExecutor" /> used to execute the query represented by this <see cref="T:Remotion.Data.Linq.QueryableBase`1" />.</param></member><member name="M:Remotion.Data.Linq.QueryableBase`1.#ctor(System.Linq.IQueryProvider)"><summary>
+ Initializes a new instance of the <see cref="T:Remotion.Data.Linq.QueryableBase`1" /> class with a specific <see cref="T:System.Linq.IQueryProvider" />. This constructor
+ should only be used to begin a query when <see cref="T:Remotion.Data.Linq.DefaultQueryProvider" /> does not fit the requirements.
+ </summary><param name="provider">The provider used to execute the query represented by this <see cref="T:Remotion.Data.Linq.QueryableBase`1" /> and to construct
+ queries around this <see cref="T:Remotion.Data.Linq.QueryableBase`1" />.</param></member><member name="M:Remotion.Data.Linq.QueryableBase`1.#ctor(System.Linq.IQueryProvider,System.Linq.Expressions.Expression)"><summary>
+ Initializes a new instance of the <see cref="T:Remotion.Data.Linq.QueryableBase`1" /> class with a given <paramref name="provider" /> and
+ <paramref name="expression" />. A constructor with a matching signature must be exposed on subclasses because it is used by
+ <see cref="T:Remotion.Data.Linq.DefaultQueryProvider" /> to construct queries around this <see cref="T:Remotion.Data.Linq.QueryableBase`1" /> when a query method (e.g. of the
+ <see cref="T:System.Linq.Queryable" /> class) is called.
+ </summary><param name="provider">The provider used to execute the query represented by this <see cref="T:Remotion.Data.Linq.QueryableBase`1" /> and to construct
+ queries around this <see cref="T:Remotion.Data.Linq.QueryableBase`1" />.</param><param name="expression">The expression representing the query.</param></member><member name="M:Remotion.Data.Linq.QueryableBase`1.GetEnumerator"><summary>
+ Executes the query via the <see cref="P:Remotion.Data.Linq.QueryableBase`1.Provider" /> and returns an enumerator that iterates through the items returned by the query.
+ </summary></member><member name="P:Remotion.Data.Linq.QueryableBase`1.Expression"><summary>
+ Gets the expression tree that is associated with the instance of <see cref="T:System.Linq.IQueryable" />. This expression describes the
+ query represented by this <see cref="T:Remotion.Data.Linq.QueryableBase`1" />.
+ </summary></member><member name="P:Remotion.Data.Linq.QueryableBase`1.Provider"><summary>
+ Gets the query provider that is associated with this data source. The provider is used to execute the query. By default, a
+ <see cref="T:Remotion.Data.Linq.DefaultQueryProvider" /> is used that parses the query and passes it on to an implementation of <see cref="T:Remotion.Data.Linq.IQueryExecutor" />.
+ </summary></member><member name="P:Remotion.Data.Linq.QueryableBase`1.ElementType"><summary>
+ Gets the type of the element(s) that are returned when the expression tree associated with this instance of <see cref="T:System.Linq.IQueryable" /> is executed.
+ </summary></member><member name="T:Remotion.Data.Linq.QueryModel"><summary>
+ Provides an abstraction of an expression tree created for a LINQ query. <see cref="T:Remotion.Data.Linq.QueryModel" /> instances are passed to LINQ providers based
+ on re-linq via <see cref="T:Remotion.Data.Linq.IQueryExecutor" />, but you can also use <see cref="T:Remotion.Data.Linq.Parsing.Structure.QueryParser" /> to parse an expression tree by hand or construct
+ a <see cref="T:Remotion.Data.Linq.QueryModel" /> manually via its constructor.
+ </summary></member><member name="M:Remotion.Data.Linq.QueryModel.#ctor(Remotion.Data.Linq.Clauses.MainFromClause,Remotion.Data.Linq.Clauses.SelectClause)"><summary>
+ Initializes a new instance of <see cref="T:Remotion.Data.Linq.QueryModel" />
+ </summary><param name="mainFromClause">The <see cref="T:Remotion.Data.Linq.Clauses.MainFromClause" /> of the query. This is the starting point of the query, generating items
+ that are filtered and projected by the query.</param><param name="selectClause">The <see cref="P:Remotion.Data.Linq.QueryModel.SelectClause" /> of the query. This is the end point of
+ the query, it defines what is actually returned for each of the items coming from the <see cref="P:Remotion.Data.Linq.QueryModel.MainFromClause" /> and passing the
+ <see cref="P:Remotion.Data.Linq.QueryModel.BodyClauses" />. After it, only the <see cref="P:Remotion.Data.Linq.QueryModel.ResultOperators" /> modify the result of the query.</param></member><member name="M:Remotion.Data.Linq.QueryModel.GetOutputDataInfo"><summary>
+ Gets an <see cref="T:Remotion.Data.Linq.Clauses.StreamedData.IStreamedDataInfo" /> object describing the data streaming out of this <see cref="T:Remotion.Data.Linq.QueryModel" />. If a query ends with
+ the <see cref="P:Remotion.Data.Linq.QueryModel.SelectClause" />, this corresponds to <see cref="M:Remotion.Data.Linq.Clauses.SelectClause.GetOutputDataInfo" />. If a query has
+ <see cref="P:Remotion.Data.Linq.QueryModel.ResultOperators" />, the data is further modified by those operators.
+ </summary></member><member name="M:Remotion.Data.Linq.QueryModel.GetUniqueIdentfierGenerator"><summary>
+ Gets the <see cref="T:Remotion.Data.Linq.UniqueIdentifierGenerator" /> which is used by the <see cref="T:Remotion.Data.Linq.QueryModel" />.
+ </summary></member><member name="M:Remotion.Data.Linq.QueryModel.Accept(Remotion.Data.Linq.IQueryModelVisitor)"><summary>
+ Accepts an implementation of <see cref="T:Remotion.Data.Linq.IQueryModelVisitor" /> or <see cref="T:Remotion.Data.Linq.QueryModelVisitorBase" />, as defined by the Visitor pattern.
+ </summary></member><member name="M:Remotion.Data.Linq.QueryModel.ToString"><summary>
+ Returns a <see cref="T:System.String" /> representation of this <see cref="T:Remotion.Data.Linq.QueryModel" />.
+ </summary></member><member name="M:Remotion.Data.Linq.QueryModel.Clone"><summary>
+ Clones this <see cref="T:Remotion.Data.Linq.QueryModel" />, returning a new <see cref="T:Remotion.Data.Linq.QueryModel" /> equivalent to this instance, but with its clauses being
+ clones of this instance's clauses. Any <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> in the cloned clauses that points back to another clause
+ in this <see cref="T:Remotion.Data.Linq.QueryModel" /> (including its subqueries) is adjusted to point to the respective clones in the cloned
+ <see cref="T:Remotion.Data.Linq.QueryModel" />. Any subquery nested in the <see cref="T:Remotion.Data.Linq.QueryModel" /> is also cloned.
+ </summary></member><member name="M:Remotion.Data.Linq.QueryModel.Clone(Remotion.Data.Linq.Clauses.QuerySourceMapping)"><summary>
+ Clones this <see cref="T:Remotion.Data.Linq.QueryModel" />, returning a new <see cref="T:Remotion.Data.Linq.QueryModel" /> equivalent to this instance, but with its clauses being
+ clones of this instance's clauses. Any <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> in the cloned clauses that points back to another clause
+ in this <see cref="T:Remotion.Data.Linq.QueryModel" /> (including its subqueries) is adjusted to point to the respective clones in the cloned
+ <see cref="T:Remotion.Data.Linq.QueryModel" />. Any subquery nested in the <see cref="T:Remotion.Data.Linq.QueryModel" /> is also cloned.
+ </summary><param name="querySourceMapping">The <see cref="T:Remotion.Data.Linq.Clauses.QuerySourceMapping" /> defining how to adjust instances of
+ <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> in the cloned <see cref="T:Remotion.Data.Linq.QueryModel" />. If there is a <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" />
+ that points out of the <see cref="T:Remotion.Data.Linq.QueryModel" /> being cloned, specify its replacement via this parameter. At the end of the cloning process,
+ this object maps all the clauses in this original <see cref="T:Remotion.Data.Linq.QueryModel" /> to the clones created in the process.
+ </param></member><member name="M:Remotion.Data.Linq.QueryModel.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})"><summary>
+ Transforms all the expressions in this <see cref="T:Remotion.Data.Linq.QueryModel" />'s clauses via the given <paramref name="transformation" /> delegate.
+ </summary><param name="transformation">The transformation object. This delegate is called for each <see cref="T:System.Linq.Expressions.Expression" /> within this
+ <see cref="T:Remotion.Data.Linq.QueryModel" />, and those expressions will be replaced with what the delegate returns.</param></member><member name="M:Remotion.Data.Linq.QueryModel.GetNewName(System.String)"><summary>
+ Returns a new name with the given prefix. The name is different from that of any <see cref="T:Remotion.Data.Linq.Clauses.FromClauseBase" /> added
+ in the <see cref="T:Remotion.Data.Linq.QueryModel" />. Note that clause names that are changed after the clause is added as well as names of other clauses
+ than from clauses are not considered when determining "unique" names. Use names only for readability and debugging, not
+ for uniquely identifying clauses.
+ </summary></member><member name="M:Remotion.Data.Linq.QueryModel.Execute(Remotion.Data.Linq.IQueryExecutor)"><summary>
+ Executes this <see cref="T:Remotion.Data.Linq.QueryModel" /> via the given <see cref="T:Remotion.Data.Linq.IQueryExecutor" />. By default, this indirectly calls
+ <see cref="M:Remotion.Data.Linq.IQueryExecutor.ExecuteCollection``1(Remotion.Data.Linq.QueryModel)" />, but this can be modified by the <see cref="P:Remotion.Data.Linq.QueryModel.ResultOperators" />.
+ </summary><param name="executor">The <see cref="T:Remotion.Data.Linq.IQueryExecutor" /> to use for executing this query.</param></member><member name="M:Remotion.Data.Linq.QueryModel.IsIdentityQuery"><summary>
+ Determines whether this <see cref="T:Remotion.Data.Linq.QueryModel" /> represents an identity query. An identity query is a query without any body clauses
+ whose <see cref="P:Remotion.Data.Linq.QueryModel.SelectClause" /> selects exactly the items produced by its <see cref="P:Remotion.Data.Linq.QueryModel.MainFromClause" />. An identity query can have
+ <see cref="P:Remotion.Data.Linq.QueryModel.ResultOperators" />.
+ </summary></member><member name="P:Remotion.Data.Linq.QueryModel.MainFromClause"><summary>
+ Gets or sets the query's <see cref="T:Remotion.Data.Linq.Clauses.MainFromClause" />. This is the starting point of the query, generating items that are processed by
+ the <see cref="P:Remotion.Data.Linq.QueryModel.BodyClauses" /> and projected or grouped by the <see cref="P:Remotion.Data.Linq.QueryModel.SelectClause" />.
+ </summary></member><member name="P:Remotion.Data.Linq.QueryModel.SelectClause"><summary>
+ Gets or sets the query's select clause. This is the end point of the query, it defines what is actually returned for each of the
+ items coming from the <see cref="P:Remotion.Data.Linq.QueryModel.MainFromClause" /> and passing the <see cref="P:Remotion.Data.Linq.QueryModel.BodyClauses" />. After it, only the <see cref="P:Remotion.Data.Linq.QueryModel.ResultOperators" />
+ modify the result of the query.
+ </summary></member><member name="P:Remotion.Data.Linq.QueryModel.BodyClauses"><summary>
+ Gets a collection representing the query's body clauses. Body clauses take the items generated by the <see cref="P:Remotion.Data.Linq.QueryModel.MainFromClause" />,
+ filtering (<see cref="T:Remotion.Data.Linq.Clauses.WhereClause" />), ordering (<see cref="T:Remotion.Data.Linq.Clauses.OrderByClause" />), augmenting (<see cref="T:Remotion.Data.Linq.Clauses.AdditionalFromClause" />), or otherwise
+ processing them before they are passed to the <see cref="P:Remotion.Data.Linq.QueryModel.SelectClause" />.
+ </summary></member><member name="P:Remotion.Data.Linq.QueryModel.ResultOperators"><summary>
+ Gets the result operators attached to this <see cref="P:Remotion.Data.Linq.QueryModel.SelectClause" />. Result operators modify the query's result set, aggregating,
+ filtering, or otherwise processing the result before it is returned.
+ </summary></member><member name="T:Remotion.Data.Linq.QueryModelBuilder"><summary>
+ Collects clauses and creates a <see cref="T:Remotion.Data.Linq.QueryModel" /> from them. This provides a simple way to first add all the clauses and then
+ create the <see cref="T:Remotion.Data.Linq.QueryModel" /> rather than the two-step approach (first <see cref="P:Remotion.Data.Linq.QueryModelBuilder.SelectClause" /> and <see cref="P:Remotion.Data.Linq.QueryModelBuilder.MainFromClause" />,
+ then the <see cref="T:Remotion.Data.Linq.Clauses.IBodyClause" />s) required by <see cref="T:Remotion.Data.Linq.QueryModel" />'s constructor.
+ </summary></member><member name="T:Remotion.Data.Linq.QueryModelVisitorBase"><summary>
+ Provides a default implementation of <see cref="T:Remotion.Data.Linq.IQueryModelVisitor" /> which automatically visits child items. That is, the default
+ implementation of <see cref="M:Remotion.Data.Linq.QueryModelVisitorBase.VisitQueryModel(Remotion.Data.Linq.QueryModel)" /> automatically calls <c>Accept</c> on all clauses in the <see cref="T:Remotion.Data.Linq.QueryModel" />
+ and the default implementation of <see cref="M:Remotion.Data.Linq.QueryModelVisitorBase.VisitOrderByClause(Remotion.Data.Linq.Clauses.OrderByClause,Remotion.Data.Linq.QueryModel,System.Int32)" /> automatically calls <see cref="M:Remotion.Data.Linq.Clauses.Ordering.Accept(Remotion.Data.Linq.IQueryModelVisitor,Remotion.Data.Linq.QueryModel,Remotion.Data.Linq.Clauses.OrderByClause,System.Int32)" /> on the
+ <see cref="T:Remotion.Data.Linq.Clauses.Ordering" /> instances in its <see cref="P:Remotion.Data.Linq.Clauses.OrderByClause.Orderings" /> collection, and so on.
+ </summary></member><member name="T:Remotion.Data.Linq.UniqueIdentifierGenerator"><summary>
+ Generates unique identifiers based on a set of known identifiers.
+ An identifier is generated by appending a number to a given prefix. The identifier is considered unique when no known identifier
+ exists which equals the prefix/number combination.
+ </summary></member><member name="M:Remotion.Data.Linq.UniqueIdentifierGenerator.AddKnownIdentifier(System.String)"><summary>
+ Adds the given <paramref name="identifier" /> to the set of known identifiers.
+ </summary><param name="identifier">The identifier to add.</param></member><member name="M:Remotion.Data.Linq.UniqueIdentifierGenerator.GetUniqueIdentifier(System.String)"><summary>
+ Gets a unique identifier starting with the given <paramref name="prefix" />. The identifier is generating by appending a number to the
+ prefix so that the resulting string does not match a known identifier.
+ </summary><param name="prefix">The prefix to use for the identifier.</param></member><member name="T:Remotion.Data.Linq.UnmappedItemException"><summary>
+ TODO: add summary
+ </summary></member><member name="T:Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression"><summary>
+ Acts as a base class for custom extension expressions, providing advanced visitor support. Also allows extension expressions to be reduced to
+ a tree of standard expressions with equivalent semantics.
+ </summary></member><member name="F:Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression.ExtensionExpressionNodeType"><summary>
+ Defines a standard <see cref="T:System.Linq.Expressions.ExpressionType" /> value that is used by all <see cref="T:Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression" /> subclasses.
+ </summary></member><member name="M:Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression.#ctor(System.Type)"><summary>
+ Initializes a new instance of the <see cref="T:Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression" /> class.
+ </summary><param name="type">The type of the value represented by the <see cref="T:Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression" />.</param></member><member name="M:Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression.Reduce"><summary>
+ Reduces this instance to a tree of standard expressions. If this instance cannot be reduced, the same <see cref="T:Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression" />
+ is returned.
+ </summary></member><member name="M:Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression.ReduceAndCheck"><summary>
+ Calls the <see cref="M:Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression.Reduce" /> method and checks certain invariants before returning the result. This method can only be called when
+ <see cref="P:Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression.CanReduce" /> returns <see langword="true" />.
+ </summary></member><member name="M:Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression.Accept(Remotion.Data.Linq.Parsing.ExpressionTreeVisitor)"><summary>
+ Accepts the specified visitor, by default dispatching to <see cref="M:Remotion.Data.Linq.Parsing.ExpressionTreeVisitor.VisitExtensionExpression(Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression)" />.
+ Inheritors of the <see cref="T:Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression" /> class can override this method in order to dispatch to a specific Visit method.
+ </summary><param name="visitor">The visitor whose Visit method should be invoked.</param></member><member name="M:Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression.VisitChildren(Remotion.Data.Linq.Parsing.ExpressionTreeVisitor)"><summary>
+ Must be overridden by <see cref="T:Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression" /> subclasses by calling <see cref="M:Remotion.Data.Linq.Parsing.ExpressionTreeVisitor.VisitExpression(System.Linq.Expressions.Expression)" /> on all
+ children of this extension node.
+ </summary><param name="visitor">The visitor to visit the child nodes with.</param></member><member name="P:Remotion.Data.Linq.Clauses.Expressions.ExtensionExpression.CanReduce"><summary>
+ Gets a value indicating whether this instance can be reduced to a tree of standard expressions.
+ </summary></member><member name="T:Remotion.Data.Linq.Clauses.Expressions.IVBSpecificExpressionVisitor"><summary>
+ This interface should be implemented by visitors that handle VB-specific expressions.
+ </summary></member><member name="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression"><summary>
+ Represents an expression tree node that points to a query source represented by a <see cref="T:Remotion.Data.Linq.Clauses.FromClauseBase" />. These expressions should always
+ point back, to a clause defined prior to the clause holding a <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" />. Otherwise, exceptions might be
+ thrown at runtime.
+ </summary></member><member name="M:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression.Equals(System.Object)"><summary>
+ Determines whether the specified <see cref="T:System.Object" /> is equal to the current <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> by
+ comparing the <see cref="P:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression.ReferencedQuerySource" /> properties for reference equality.
+ </summary><param name="obj">The <see cref="T:System.Object" /> to compare with the current <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" />.</param></member><member name="P:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression.ReferencedQuerySource"><summary>
+ Gets the query source referenced by this expression.
+ </summary></member><member name="T:Remotion.Data.Linq.Clauses.Expressions.SubQueryExpression"><summary>
+ Represents an <see cref="T:System.Linq.Expressions.Expression" /> that holds a subquery. The subquery is held by <see cref="P:Remotion.Data.Linq.Clauses.Expressions.SubQueryExpression.QueryModel" /> in its parsed form.
+ </summary></member><member name="T:Remotion.Data.Linq.Clauses.Expressions.VBStringComparisonExpression"><summary>
+ Represents a VB-specific comparison expression. To explicitly support this expression type, implement <see cref="T:Remotion.Data.Linq.Clauses.Expressions.IVBSpecificExpressionVisitor" />.
+ To treat this expression as if it were an ordinary <see cref="T:System.Linq.Expressions.BinaryExpression" />, call its <see cref="M:Remotion.Data.Linq.Clauses.Expressions.VBStringComparisonExpression.Reduce" /> method and visit the result.
+ </summary></member><member name="T:Remotion.Data.Linq.Clauses.ExpressionTreeVisitors.AccessorFindingExpressionTreeVisitor"><summary>
+ Constructs a <see cref="T:System.Linq.Expressions.LambdaExpression" /> that is able to extract a specific simple expression from a complex <see cref="T:System.Linq.Expressions.NewExpression" />
+ or <see cref="T:System.Linq.Expressions.MemberInitExpression" />.
+ </summary></member><member name="T:Remotion.Data.Linq.Parsing.ExpressionTreeVisitor"><summary>
+ Provides a base class that can be used for visiting and optionally transforming each node of an <see cref="T:System.Linq.Expressions.Expression" /> tree in a
+ strongly typed fashion.
+ This is the base class of many transformation classes.
+ </summary></member><member name="M:Remotion.Data.Linq.Clauses.ExpressionTreeVisitors.AccessorFindingExpressionTreeVisitor.FindAccessorLambda(System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.ParameterExpression)"><summary>
+ Constructs a <see cref="T:System.Linq.Expressions.LambdaExpression" /> that is able to extract a specific simple <paramref name="searchedExpression" /> from a
+ complex <paramref name="fullExpression" />.
+ </summary><param name="searchedExpression">The expression an accessor to which should be created.</param><param name="fullExpression">The full expression containing the <paramref name="searchedExpression" />.</param><param name="inputParameter">The input parameter to be used by the resulting lambda. Its type must match the type of <paramref name="fullExpression" />.</param></member><member name="T:Remotion.Data.Linq.Clauses.ExpressionTreeVisitors.CloningExpressionTreeVisitor"><summary>
+ Visits an <see cref="T:System.Linq.Expressions.Expression" /> tree, replacing all <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> instances with references to cloned clauses,
+ as defined by a <see cref="T:Remotion.Data.Linq.Clauses.QuerySourceMapping" />. In addition, all <see cref="T:Remotion.Data.Linq.QueryModel" /> instances in
+ <see cref="T:Remotion.Data.Linq.Clauses.Expressions.SubQueryExpression">SubQueryExpressions</see> are cloned, and their references also replaces. All referenced clauses must be mapped
+ to cloned clauses in the given <see cref="T:Remotion.Data.Linq.Clauses.QuerySourceMapping" />, otherwise an expression is thrown. This is used by <see cref="M:Remotion.Data.Linq.QueryModel.Clone" />
+ to adjust references to the old <see cref="T:Remotion.Data.Linq.QueryModel" /> with references to the new <see cref="T:Remotion.Data.Linq.QueryModel" />.
+ </summary></member><member name="T:Remotion.Data.Linq.Clauses.ExpressionTreeVisitors.ReferenceReplacingExpressionTreeVisitor"><summary>
+ Takes an expression and replaces all <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> instances, as defined by a given <see cref="P:Remotion.Data.Linq.Clauses.ExpressionTreeVisitors.ReferenceReplacingExpressionTreeVisitor.QuerySourceMapping" />.
+ This is used whenever references to query sources should be replaced by a transformation.
+ </summary></member><member name="M:Remotion.Data.Linq.Clauses.ExpressionTreeVisitors.ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(System.Linq.Expressions.Expression,Remotion.Data.Linq.Clauses.QuerySourceMapping,System.Boolean)"><summary>
+ Takes an expression and replaces all <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> instances, as defined by a given
+ <paramref name="querySourceMapping" />.
+ </summary><param name="expression">The expression to be scanned for references.</param><param name="querySourceMapping">The clause mapping to be used for replacing <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> instances.</param><param name="throwOnUnmappedReferences">If <see langword="true" />, the visitor will throw an exception when
+ <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> not mapped in the <paramref name="querySourceMapping" /> is encountered. If <see langword="false" />,
+ the visitor will ignore such expressions.</param></member><member name="M:Remotion.Data.Linq.Clauses.ExpressionTreeVisitors.CloningExpressionTreeVisitor.AdjustExpressionAfterCloning(System.Linq.Expressions.Expression,Remotion.Data.Linq.Clauses.QuerySourceMapping)"><summary>
+ Adjusts the given expression for cloning, that is replaces <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> and <see cref="T:Remotion.Data.Linq.Clauses.Expressions.SubQueryExpression" />
+ instances. All referenced clauses must be mapped to clones in the given <paramref name="querySourceMapping" />, otherwise an exception is thrown.
+ </summary><param name="expression">The expression to be adjusted.</param><param name="querySourceMapping">The clause mapping to be used for replacing <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> instances.</param></member><member name="T:Remotion.Data.Linq.Clauses.ExpressionTreeVisitors.FormattingExpressionTreeVisitor"><summary>
+ Transforms an expression tree into a human-readable string, taking all the custom expression nodes into account.
+ It does so by replacing all instances of custom expression nodes by parameters that have the desired string as their names. This is done
+ to circumvent a limitation in the <see cref="T:System.Linq.Expressions.Expression" /> class, where overriding <see cref="M:System.Linq.Expressions.Expression.ToString" /> in custom expressions
+ will not work.
+ </summary></member><member name="T:Remotion.Data.Linq.Clauses.ExpressionTreeVisitors.ReverseResolvingExpressionTreeVisitor"><summary>
+ Performs a reverse <see cref="M:Remotion.Data.Linq.Parsing.Structure.IntermediateModel.IExpressionNode.Resolve(System.Linq.Expressions.ParameterExpression,System.Linq.Expressions.Expression,Remotion.Data.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)" /> operation, i.e. creates a <see cref="T:System.Linq.Expressions.LambdaExpression" /> from a given resolved expression,
+ substituting all <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> objects by getting the referenced objects from the lambda's input parameter.
+ </summary></member><member name="M:Remotion.Data.Linq.Clauses.ExpressionTreeVisitors.ReverseResolvingExpressionTreeVisitor.ReverseResolve(System.Linq.Expressions.Expression,System.Linq.Expressions.Expression)"><summary>
+ Performs a reverse <see cref="M:Remotion.Data.Linq.Parsing.Structure.IntermediateModel.IExpressionNode.Resolve(System.Linq.Expressions.ParameterExpression,System.Linq.Expressions.Expression,Remotion.Data.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)" /> operation, i.e. creates a <see cref="T:System.Linq.Expressions.LambdaExpression" /> from a given resolved expression,
+ substituting all <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> objects by getting the referenced objects from the lambda's input parameter.
+ </summary><param name="itemExpression">The item expression representing the items passed to the generated <see cref="T:System.Linq.Expressions.LambdaExpression" /> via its input
+ parameter.</param><param name="resolvedExpression">The resolved expression for which to generate a reverse resolved <see cref="T:System.Linq.Expressions.LambdaExpression" />.</param></member><member name="M:Remotion.Data.Linq.Clauses.ExpressionTreeVisitors.ReverseResolvingExpressionTreeVisitor.ReverseResolveLambda(System.Linq.Expressions.Expression,System.Linq.Expressions.LambdaExpression,System.Int32)"><summary>
+ Performs a reverse <see cref="M:Remotion.Data.Linq.Parsing.Structure.IntermediateModel.IExpressionNode.Resolve(System.Linq.Expressions.ParameterExpression,System.Linq.Expressions.Expression,Remotion.Data.Linq.Parsing.Structure.IntermediateModel.ClauseGenerationContext)" /> operation on a <see cref="T:System.Linq.Expressions.LambdaExpression" />, i.e. creates a new
+ <see cref="T:System.Linq.Expressions.LambdaExpression" /> with an additional parameter from a given resolved <see cref="T:System.Linq.Expressions.LambdaExpression" />,
+ substituting all <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> objects by getting the referenced objects from the new input parameter.
+ </summary><param name="itemExpression">The item expression representing the items passed to the generated <see cref="T:System.Linq.Expressions.LambdaExpression" /> via its new
+ input parameter.</param><param name="resolvedExpression">The resolved <see cref="T:System.Linq.Expressions.LambdaExpression" /> for which to generate a reverse resolved <see cref="T:System.Linq.Expressions.LambdaExpression" />.</param><param name="parameterInsertionPosition">The position at which to insert the new parameter.</param></member><member name="T:Remotion.Data.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator"><summary>
+ Represents aggregating the items returned by a query into a single value with an initial seeding value.
+ This is a result operator, operating on the whole result set of a query.
+ </summary></member><member name="T:Remotion.Data.Linq.Clauses.ResultOperators.ValueFromSequenceResultOperatorBase"><summary>
+ Represents a <see cref="T:Remotion.Data.Linq.Clauses.ResultOperatorBase" /> that is executed on a sequence, returning a scalar value or single item as its result.
+ </summary></member><member name="T:Remotion.Data.Linq.Clauses.ResultOperatorBase"><summary>
+ Represents an operation that is executed on the result set of the query, aggregating, filtering, or restricting the number of result items
+ before the query result is returned.
+ </summary></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperatorBase.ExecuteInMemory(Remotion.Data.Linq.Clauses.StreamedData.IStreamedData)"><summary>
+ Executes this result operator in memory, on a given input. Executing result operators in memory should only be
+ performed if the target query system does not support the operator.
+ </summary><param name="input">The input for the result operator. This must match the type of <see cref="T:Remotion.Data.Linq.Clauses.StreamedData.IStreamedData" /> expected by the operator.</param></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperatorBase.GetOutputDataInfo(Remotion.Data.Linq.Clauses.StreamedData.IStreamedDataInfo)"><summary>
+ Gets information about the data streamed out of this <see cref="T:Remotion.Data.Linq.Clauses.ResultOperatorBase" />. This contains the result type a query would have if
+ it ended with this <see cref="T:Remotion.Data.Linq.Clauses.ResultOperatorBase" />, and it optionally includes an <see cref="P:Remotion.Data.Linq.Clauses.StreamedData.StreamedSequenceInfo.ItemExpression" /> describing
+ the streamed sequence's items.
+ </summary><param name="inputInfo">Information about the data produced by the preceding <see cref="T:Remotion.Data.Linq.Clauses.ResultOperatorBase" />, or the <see cref="T:Remotion.Data.Linq.Clauses.SelectClause" />
+ of the query if no previous <see cref="T:Remotion.Data.Linq.Clauses.ResultOperatorBase" /> exists.</param></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperatorBase.Clone(Remotion.Data.Linq.Clauses.CloneContext)"><summary>
+ Clones this item, registering its clone with the <paramref name="cloneContext" /> if it is a query source clause.
+ </summary><param name="cloneContext">The clones of all query source clauses are registered with this <see cref="T:Remotion.Data.Linq.Clauses.CloneContext" />.</param></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperatorBase.Accept(Remotion.Data.Linq.IQueryModelVisitor,Remotion.Data.Linq.QueryModel,System.Int32)"><summary>
+ Accepts the specified visitor by calling its <see cref="M:Remotion.Data.Linq.IQueryModelVisitor.VisitResultOperator(Remotion.Data.Linq.Clauses.ResultOperatorBase,Remotion.Data.Linq.QueryModel,System.Int32)" /> method.
+ </summary><param name="visitor">The visitor to accept.</param><param name="queryModel">The query model in whose context this clause is visited.</param><param name="index">The index of this item in the <paramref name="queryModel" />'s <see cref="P:Remotion.Data.Linq.QueryModel.ResultOperators" /> collection.</param></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperatorBase.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})"><summary>
+ Transforms all the expressions in this item via the given <paramref name="transformation" /> delegate. Subclasses must apply the
+ <paramref name="transformation" /> to any expressions they hold. If a subclass does not hold any expressions, it shouldn't do anything
+ in the implementation of this method.
+ </summary><param name="transformation">The transformation object. This delegate is called for each <see cref="T:System.Linq.Expressions.Expression" /> within this
+ item, and those expressions will be replaced with what the delegate returns.</param></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperatorBase.InvokeGenericExecuteMethod``2(Remotion.Data.Linq.Clauses.StreamedData.IStreamedData,System.Func{``0,``1})"><summary>
+ Invokes a given generic method on an <see cref="T:Remotion.Data.Linq.Clauses.StreamedData.IStreamedData" /> input via Reflection. Use this to implement
+ <see cref="M:Remotion.Data.Linq.Clauses.ResultOperatorBase.ExecuteInMemory(Remotion.Data.Linq.Clauses.StreamedData.IStreamedData)" /> by defining a strongly typed, generic variant
+ of <see cref="M:Remotion.Data.Linq.Clauses.ResultOperatorBase.ExecuteInMemory(Remotion.Data.Linq.Clauses.StreamedData.IStreamedData)" />; then invoke that strongly typed
+ variant via <see cref="M:Remotion.Data.Linq.Clauses.ResultOperatorBase.InvokeGenericExecuteMethod``2(Remotion.Data.Linq.Clauses.StreamedData.IStreamedData,System.Func{``0,``1})" />.
+ </summary><param name="input">The input <see cref="T:Remotion.Data.Linq.Clauses.StreamedData.IStreamedData" /> object to invoke the method on..</param><param name="genericExecuteCaller">A delegate holding exactly one public generic method with exactly one generic argument. This method is
+ called via Reflection on the given <paramref name="input" /> argument.</param></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperatorBase.InvokeExecuteMethod(System.Reflection.MethodInfo,System.Object)"><summary>
+ Invokes the given <paramref name="method" /> via reflection on the given <paramref name="input" />.
+ </summary><param name="input">The input to invoke the method with.</param><param name="method">The method to be invoked.</param></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperatorBase.CheckSequenceItemType(Remotion.Data.Linq.Clauses.StreamedData.StreamedSequenceInfo,System.Type)"><summary>
+ Checks the type of the items retrieved by the sequence, throwing an <see cref="T:Remotion.Data.Linq.Utilities.ArgumentTypeException" /> if the items don't match the
+ expected type.
+ </summary><param name="sequenceInfo">The <see cref="T:Remotion.Data.Linq.Clauses.StreamedData.StreamedSequenceInfo" /> object describing the sequence.</param><param name="expectedItemType">The expected item type.</param></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperatorBase.GetConstantValueFromExpression``1(System.String,System.Linq.Expressions.Expression)"><summary>
+ Gets the constant value of the given expression, assuming it is a <see cref="T:System.Linq.Expressions.ConstantExpression" />. If it is
+ not, an <see cref="T:System.InvalidOperationException" /> is thrown.
+ </summary><param name="expressionName">A string describing the value; this will be included in the exception message if an exception is thrown.</param><param name="expression">The expression whose value to get.</param></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.#ctor(System.Linq.Expressions.Expression,System.Linq.Expressions.LambdaExpression,System.Linq.Expressions.LambdaExpression)"><summary>
+ Initializes a new instance of the <see cref="T:Remotion.Data.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator" /> class.
+ </summary><param name="seed">The seed expression.</param><param name="func">The aggregating function. This is a <see cref="T:System.Linq.Expressions.LambdaExpression" /> taking a parameter that represents the value accumulated so
+ far and returns a new accumulated value. This is a resolved expression, i.e. items streaming in from prior clauses and result operators
+ are represented as expressions containing <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> nodes.</param><param name="optionalResultSelector">The result selector, can be <see langword="null" />.</param></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.GetConstantSeed``1"><summary>
+ Gets the constant value of the <see cref="P:Remotion.Data.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.Seed" /> property, assuming it is a <see cref="T:System.Linq.Expressions.ConstantExpression" />. If it is
+ not, an <see cref="T:System.InvalidOperationException" /> is thrown.
+ </summary></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.ExecuteInMemory``1(Remotion.Data.Linq.Clauses.StreamedData.StreamedSequence)"></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.ExecuteAggregateInMemory``3(Remotion.Data.Linq.Clauses.StreamedData.StreamedSequence)"><summary>
+ Executes the aggregating operation in memory.
+ </summary><param name="input">The input sequence.</param></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.Clone(Remotion.Data.Linq.Clauses.CloneContext)"></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.GetOutputDataInfo(Remotion.Data.Linq.Clauses.StreamedData.IStreamedDataInfo)"></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.ToString"></member><member name="P:Remotion.Data.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.Func"><summary>
+ Gets or sets the aggregating function. This is a <see cref="T:System.Linq.Expressions.LambdaExpression" /> taking a parameter that represents the value accumulated so
+ far and returns a new accumulated value. This is a resolved expression, i.e. items streaming in from prior clauses and result operators
+ are represented as expressions containing <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> nodes.
+ </summary></member><member name="P:Remotion.Data.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.Seed"><summary>
+ Gets or sets the seed of the accumulation. This is an <see cref="T:System.Linq.Expressions.Expression" /> denoting the starting value of the aggregation.
+ </summary></member><member name="P:Remotion.Data.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator.OptionalResultSelector"><summary>
+ Gets or sets the result selector. This is a <see cref="T:System.Linq.Expressions.LambdaExpression" /> applied after the aggregation to select the final value.
+ Can be <see langword="null" />.
+ </summary></member><member name="T:Remotion.Data.Linq.Clauses.ResultOperators.AggregateResultOperator"><summary>
+ Represents aggregating the items returned by a query into a single value. The first item is used as the seeding value for the aggregating
+ function.
+ This is a result operator, operating on the whole result set of a query.
+ </summary></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AggregateResultOperator.#ctor(System.Linq.Expressions.LambdaExpression)"><summary>
+ Initializes a new instance of the <see cref="T:Remotion.Data.Linq.Clauses.ResultOperators.AggregateResultOperator" /> class.
+ </summary><param name="func">The aggregating function. This is a <see cref="T:System.Linq.Expressions.LambdaExpression" /> taking a parameter that represents the value accumulated so
+ far and returns a new accumulated value. This is a resolved expression, i.e. items streaming in from prior clauses and result operators
+ are represented as expressions containing <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> nodes.</param></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AggregateResultOperator.ExecuteInMemory``1(Remotion.Data.Linq.Clauses.StreamedData.StreamedSequence)"></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AggregateResultOperator.Clone(Remotion.Data.Linq.Clauses.CloneContext)"></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AggregateResultOperator.GetOutputDataInfo(Remotion.Data.Linq.Clauses.StreamedData.IStreamedDataInfo)"></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AggregateResultOperator.ToString"></member><member name="P:Remotion.Data.Linq.Clauses.ResultOperators.AggregateResultOperator.Func"><summary>
+ Gets or sets the aggregating function. This is a <see cref="T:System.Linq.Expressions.LambdaExpression" /> taking a parameter that represents the value accumulated so
+ far and returns a new accumulated value. This is a resolved expression, i.e. items streaming in from prior clauses and result operators
+ are represented as expressions containing <see cref="T:Remotion.Data.Linq.Clauses.Expressions.QuerySourceReferenceExpression" /> nodes.
+ </summary></member><member name="T:Remotion.Data.Linq.Clauses.ResultOperators.AllResultOperator"><summary>
+ Represents a check whether all items returned by a query satisfy a predicate.
+ This is a result operator, operating on the whole result set of a query.
+ </summary></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AllResultOperator.#ctor(System.Linq.Expressions.Expression)"><summary>
+ Initializes a new instance of the <see cref="T:Remotion.Data.Linq.Clauses.ResultOperators.AllResultOperator" /> class.
+ </summary><param name="predicate">The predicate to evaluate. This is a resolved version of the body of the <see cref="T:System.Linq.Expressions.LambdaExpression" /> that would be
+ passed to <see cref="M:System.Linq.Queryable.All``1(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})" />.</param></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AllResultOperator.ExecuteInMemory``1(Remotion.Data.Linq.Clauses.StreamedData.StreamedSequence)"></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AllResultOperator.Clone(Remotion.Data.Linq.Clauses.CloneContext)"></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AllResultOperator.TransformExpressions(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})"></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AllResultOperator.GetOutputDataInfo(Remotion.Data.Linq.Clauses.StreamedData.IStreamedDataInfo)"></member><member name="M:Remotion.Data.Linq.Clauses.ResultOperators.AllResultOperator.ToString"></member><member name="P:Remotion.Data.Linq.Clauses.ResultOperators.AllResultOperator.Predicate"><summary>
+ Gets or sets the predicate to evaluate on all items in the sequence.
+ This is a resolved version of the body of the <see cref="T:System.Linq.Expressions.LambdaExpression" /> that would be
+ passed to <see cref="M:System.Linq.Queryable.All``1(System.Linq.IQueryable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})" />.
+ </summary></...
[truncated message content] |
