mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
331 lines
10 KiB
C#
331 lines
10 KiB
C#
//---------------------------------------------------------------------
|
|
// <copyright file="ObjectQuery.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//
|
|
// @owner [....]
|
|
// @backupowner [....]
|
|
//---------------------------------------------------------------------
|
|
|
|
namespace System.Data.Objects
|
|
{
|
|
using System;
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Data.Common;
|
|
using System.Data.Metadata.Edm;
|
|
using System.Data.Objects.Internal;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
|
|
/// <summary>
|
|
/// This class implements untyped queries at the object-layer.
|
|
/// </summary>
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix")]
|
|
public abstract class ObjectQuery : IEnumerable, IQueryable, IOrderedQueryable, IListSource
|
|
{
|
|
#region Private Instance Members
|
|
|
|
// -----------------
|
|
// Instance Fields
|
|
// -----------------
|
|
|
|
/// <summary>
|
|
/// The underlying implementation of this ObjectQuery as provided by a concrete subclass
|
|
/// of ObjectQueryImplementation. Implementations currently exist for Entity-SQL- and Linq-to-Entities-based ObjectQueries.
|
|
/// </summary>
|
|
private ObjectQueryState _state;
|
|
|
|
/// <summary>
|
|
/// The result type of the query - 'TResultType' expressed as an O-Space type usage. Cached here and
|
|
/// only instantiated if the <see cref="GetResultType"/> method is called.
|
|
/// </summary>
|
|
private TypeUsage _resultType;
|
|
|
|
/// <summary>
|
|
/// Every instance of ObjectQuery get a unique instance of the provider. This helps propagate state information
|
|
/// using the provider through LINQ operators.
|
|
/// </summary>
|
|
private IQueryProvider _provider;
|
|
|
|
#endregion
|
|
|
|
#region Internal Constructors
|
|
|
|
// --------------------
|
|
// Internal Constructors
|
|
// --------------------
|
|
|
|
/// <summary>
|
|
/// The common constructor.
|
|
/// </summary>
|
|
/// <param name="queryState">
|
|
/// The underlying implementation of this ObjectQuery
|
|
/// </param>
|
|
/// <returns>
|
|
/// A new ObjectQuery instance.
|
|
/// </returns>
|
|
internal ObjectQuery(ObjectQueryState queryState)
|
|
{
|
|
Debug.Assert(queryState != null, "ObjectQuery state cannot be null");
|
|
|
|
// Set the query state.
|
|
this._state = queryState;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Internal Properties
|
|
|
|
/// <summary>
|
|
/// Gets an untyped instantiation of the underlying ObjectQueryState that implements this ObjectQuery.
|
|
/// </summary>
|
|
internal ObjectQueryState QueryState { get { return this._state; } }
|
|
|
|
#endregion
|
|
|
|
#region IQueryable implementation
|
|
|
|
/// <summary>
|
|
/// Gets the result element type for this query instance.
|
|
/// </summary>
|
|
Type IQueryable.ElementType
|
|
{
|
|
get { return this._state.ElementType; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the expression describing this query. For queries built using
|
|
/// LINQ builder patterns, returns a full LINQ expression tree; otherwise,
|
|
/// returns a constant expression wrapping this query. Note that the
|
|
/// default expression is not cached. This allows us to differentiate
|
|
/// between LINQ and Entity-SQL queries.
|
|
/// </summary>
|
|
System.Linq.Expressions.Expression IQueryable.Expression
|
|
{
|
|
get
|
|
{
|
|
return this.GetExpression();
|
|
}
|
|
}
|
|
|
|
internal abstract System.Linq.Expressions.Expression GetExpression();
|
|
|
|
/// <summary>
|
|
/// Gets the IQueryProvider associated with this query instance.
|
|
/// </summary>
|
|
IQueryProvider IQueryable.Provider
|
|
{
|
|
get
|
|
{
|
|
if (_provider == null)
|
|
{
|
|
_provider = new System.Data.Objects.ELinq.ObjectQueryProvider(this);
|
|
}
|
|
return _provider;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public Properties
|
|
|
|
// ----------
|
|
// Properties
|
|
// ----------
|
|
|
|
// ----------------------
|
|
// IListSource Properties
|
|
// ----------------------
|
|
/// <summary>
|
|
/// IListSource.ContainsListCollection implementation. Always returns true.
|
|
/// </summary>
|
|
bool IListSource.ContainsListCollection
|
|
{
|
|
get
|
|
{
|
|
return false; // this means that the IList we return is the one which contains our actual data, it is not a collection
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the Command Text (if any) for this ObjectQuery.
|
|
/// </summary>
|
|
public string CommandText
|
|
{
|
|
get
|
|
{
|
|
string commandText;
|
|
if (!_state.TryGetCommandText(out commandText))
|
|
{
|
|
return String.Empty;
|
|
}
|
|
|
|
Debug.Assert(commandText != null && commandText.Length != 0, "Invalid Command Text returned");
|
|
return commandText;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The context for the query, which includes the connection, cache and
|
|
/// metadata. Note that only the connection property is mutable and must be
|
|
/// set before a query can be executed.
|
|
/// </summary>
|
|
public ObjectContext Context
|
|
{
|
|
get
|
|
{
|
|
return this._state.ObjectContext;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Allows optional control over how queried results interact with the object state manager.
|
|
/// </summary>
|
|
public MergeOption MergeOption
|
|
{
|
|
get
|
|
{
|
|
return this._state.EffectiveMergeOption;
|
|
}
|
|
|
|
set
|
|
{
|
|
EntityUtil.CheckArgumentMergeOption(value);
|
|
this._state.UserSpecifiedMergeOption = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The parameter collection for this query.
|
|
/// </summary>
|
|
public ObjectParameterCollection Parameters
|
|
{
|
|
get
|
|
{
|
|
return this._state.EnsureParameters();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines if the query plan should be cached.
|
|
/// </summary>
|
|
public bool EnablePlanCaching
|
|
{
|
|
get
|
|
{
|
|
return this._state.PlanCachingEnabled;
|
|
}
|
|
|
|
set
|
|
{
|
|
this._state.PlanCachingEnabled = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public Methods
|
|
|
|
// --------------
|
|
// Public Methods
|
|
// --------------
|
|
|
|
// ----------------------
|
|
// IListSource method
|
|
// ----------------------
|
|
/// <summary>
|
|
/// IListSource.GetList implementation
|
|
/// </summary>
|
|
/// <returns>
|
|
/// IList interface over the data to bind
|
|
/// </returns>
|
|
IList IListSource.GetList()
|
|
{
|
|
return this.GetIListSourceListInternal();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the provider-specific command text used to execute this query
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[Browsable(false)]
|
|
public string ToTraceString()
|
|
{
|
|
return this._state.GetExecutionPlan(null).ToTraceString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method returns information about the result type of the ObjectQuery.
|
|
/// </summary>
|
|
/// <returns>
|
|
/// The TypeMetadata that describes the shape of the query results.
|
|
/// </returns>
|
|
public TypeUsage GetResultType ()
|
|
{
|
|
Context.EnsureMetadata();
|
|
if (null == this._resultType)
|
|
{
|
|
// Retrieve the result type from the implementation, in terms of C-Space.
|
|
TypeUsage cSpaceQueryResultType = this._state.ResultType;
|
|
|
|
// Determine the 'TResultType' equivalent type usage based on the mapped O-Space type.
|
|
// If the result type of the query is a collection[something], then
|
|
// extract out the 'something' (element type) and use that. This
|
|
// is the equivalent of saying the result type is T, rather than
|
|
// IEnumerable<T>, which aligns with users' expectations.
|
|
TypeUsage tResultType;
|
|
if (!TypeHelpers.TryGetCollectionElementType(cSpaceQueryResultType, out tResultType))
|
|
{
|
|
tResultType = cSpaceQueryResultType;
|
|
}
|
|
|
|
// Map the C-space result type to O-space.
|
|
tResultType = this._state.ObjectContext.Perspective.MetadataWorkspace.GetOSpaceTypeUsage(tResultType);
|
|
if (null == tResultType)
|
|
{
|
|
throw EntityUtil.InvalidOperation(System.Data.Entity.Strings.ObjectQuery_UnableToMapResultType);
|
|
}
|
|
|
|
this._resultType = tResultType;
|
|
}
|
|
|
|
return this._resultType;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method allows explicit query evaluation with a specified merge
|
|
/// option which will override the merge option property.
|
|
/// </summary>
|
|
/// <param name="mergeOption">
|
|
/// The MergeOption to use when executing the query.
|
|
/// </param>
|
|
/// <returns>
|
|
/// An enumerable for the ObjectQuery results.
|
|
/// </returns>
|
|
public ObjectResult Execute(MergeOption mergeOption)
|
|
{
|
|
EntityUtil.CheckArgumentMergeOption(mergeOption);
|
|
return this.ExecuteInternal(mergeOption);
|
|
}
|
|
|
|
#region IEnumerable implementation
|
|
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return this.GetEnumeratorInternal();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Internal Methods
|
|
internal abstract IEnumerator GetEnumeratorInternal();
|
|
internal abstract IList GetIListSourceListInternal();
|
|
internal abstract ObjectResult ExecuteInternal(MergeOption mergeOption);
|
|
#endregion
|
|
}
|
|
}
|