/// <summary>
/// This query-builder method creates a new query whose results are the
/// first 'count' results of this query.
/// </summary>
/// <param name="count">
/// Specifies the number of results to return. This must be either a constant or
/// a parameter reference.
/// </param>
/// <param name="parameters">
/// An optional set of query parameters that should be in scope when parsing.
/// </param>
/// <returns>
/// a new ObjectQuery instance.
/// </returns>
/// <exception cref="ArgumentNullException">
/// If the top count command text is null.
/// </exception>
/// <exception cref="ArgumentException">
/// If the top count command text is empty.
/// </exception>
public ObjectQuery <T> Top(string count, params ObjectParameter[] parameters)
{
EntityUtil.CheckArgumentNull(count, "count");
if (StringUtil.IsNullOrEmptyOrWhiteSpace(count))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.ObjectQuery_QueryBuilder_InvalidTopCount, "count");
}
return(new ObjectQuery <T>(EntitySqlQueryBuilder.Top(this.QueryState, this.Name, count, parameters)));
}
/// <summary>
/// This query-builder method creates a new query whose results are all of
/// the results of this query, plus all of the results of the other query,
/// without duplicates (i.e., results are unique).
/// </summary>
/// <param name="query"> A query representing the results to add. </param>
/// <returns> a new ObjectQuery instance. </returns>
/// <exception cref="ArgumentNullException">If the query parameter is null.</exception>
public ObjectQuery <T> Union(ObjectQuery <T> query)
{
Check.NotNull(query, "query");
if (IsLinqQuery(this) ||
IsLinqQuery(query))
{
return((ObjectQuery <T>)Queryable.Union(this, query));
}
return(new ObjectQuery <T>(EntitySqlQueryBuilder.Union(QueryState, query.QueryState)));
}
/// <summary>Limits the query results to only the property specified in the projection.</summary>
/// <returns>
/// A new <see cref="T:System.Data.Entity.Core.Objects.ObjectQuery`1" /> instance of a type compatible with the specific projection. The returned
/// <see
/// cref="T:System.Data.Entity.Core.Objects.ObjectQuery`1" />
/// is equivalent to the original instance with SELECT VALUE applied.
/// </returns>
/// <param name="projection">The projection list.</param>
/// <param name="parameters">An optional set of query parameters that should be in scope when parsing.</param>
/// <typeparam name="TResultType">
/// The type of the <see cref="T:System.Data.Entity.Core.Objects.ObjectQuery`1" /> returned by the
/// <see
/// cref="M:System.Data.Entity.Core.Objects.ObjectQuery`1.SelectValue``1(System.String,System.Data.Entity.Core.Objects.ObjectParameter[])" />
/// method.
/// </typeparam>
/// <exception cref="T:System.ArgumentNullException"> projection is null or parameters is null.</exception>
/// <exception cref="T:System.ArgumentException">The projection is an empty string.</exception>
public ObjectQuery <TResultType> SelectValue <TResultType>(string projection, params ObjectParameter[] parameters)
{
Check.NotEmpty(projection, "projection");
Check.NotNull(parameters, "parameters");
// SQLPUDT 484974: Make sure TResultType is loaded.
QueryState.ObjectContext.MetadataWorkspace.ImplicitLoadAssemblyForType(typeof(TResultType), Assembly.GetCallingAssembly());
return
(new ObjectQuery <TResultType>(
EntitySqlQueryBuilder.SelectValue(QueryState, Name, projection, parameters, typeof(TResultType))));
}
/// <summary>
/// This query-builder method creates a new query whose results are the
/// results of this query filtered by some criteria.
/// </summary>
/// <param name="predicate">
/// The filter predicate.
/// </param>
/// <param name="parameters">
/// An optional set of query parameters that should be in scope when parsing.
/// </param>
/// <returns>
/// a new ObjectQuery instance.
/// </returns>
/// <exception cref="ArgumentNullException">
/// If either argument is null.
/// </exception>
/// <exception cref="ArgumentException">
/// If the filter predicate command text is empty.
/// </exception>
public ObjectQuery <T> Where(string predicate, params ObjectParameter[] parameters)
{
EntityUtil.CheckArgumentNull(predicate, "predicate");
EntityUtil.CheckArgumentNull(parameters, "parameters");
if (StringUtil.IsNullOrEmptyOrWhiteSpace(predicate))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.ObjectQuery_QueryBuilder_InvalidFilterPredicate, "predicate");
}
return(new ObjectQuery <T>(EntitySqlQueryBuilder.Where(this.QueryState, this.Name, predicate, parameters)));
}
/// <summary>
/// This query-builder method creates a new query whose results are data
/// records containing selected fields of the results of this query.
/// </summary>
/// <param name="projection">
/// The projection list.
/// </param>
/// <param name="parameters">
/// An optional set of query parameters that should be in scope when parsing.
/// </param>
/// <returns>
/// a new ObjectQuery instance.
/// </returns>
/// <exception cref="ArgumentNullException">
/// If either argument is null.
/// </exception>
/// <exception cref="ArgumentException">
/// If the projection list command text is empty.
/// </exception>
public ObjectQuery <DbDataRecord> Select(string projection, params ObjectParameter[] parameters)
{
EntityUtil.CheckArgumentNull(projection, "projection");
EntityUtil.CheckArgumentNull(parameters, "parameters");
if (StringUtil.IsNullOrEmptyOrWhiteSpace(projection))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.ObjectQuery_QueryBuilder_InvalidProjectionList, "projection");
}
return(new ObjectQuery <DbDataRecord>(EntitySqlQueryBuilder.Select(this.QueryState, this.Name, projection, parameters)));
}
/// <summary>
/// This query-builder method creates a new query whose results are the
/// results of this query, ordered by some criteria. Note that any relational
/// operations performed after an OrderBy have the potential to "undo" the
/// ordering, so OrderBy should be considered a terminal query-building
/// operation.
/// </summary>
/// <param name="keys">
/// The sort keys.
/// </param>
/// <param name="parameters">
/// An optional set of query parameters that should be in scope when parsing.
/// </param>
/// <returns>
/// a new ObjectQuery instance.
/// </returns>
/// <exception cref="ArgumentNullException">
/// If either argument is null.
/// </exception>
/// <exception cref="ArgumentException">
/// If the sort key command text is empty.
/// </exception>
public ObjectQuery <T> OrderBy(string keys, params ObjectParameter[] parameters)
{
EntityUtil.CheckArgumentNull(keys, "keys");
EntityUtil.CheckArgumentNull(parameters, "parameters");
if (StringUtil.IsNullOrEmptyOrWhiteSpace(keys))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.ObjectQuery_QueryBuilder_InvalidSortKeyList, "keys");
}
return(new ObjectQuery <T>(EntitySqlQueryBuilder.OrderBy(this.QueryState, this.Name, keys, parameters)));
}
/// <summary>
/// This query-builder method creates a new query whose results are a sequence
/// of values projected from the results of this query.
/// </summary>
/// <param name="projection">
/// The projection list.
/// </param>
/// <param name="parameters">
/// An optional set of query parameters that should be in scope when parsing.
/// </param>
/// <returns>
/// a new ObjectQuery instance.
/// </returns>
/// <exception cref="ArgumentNullException">
/// If either argument is null.
/// </exception>
/// <exception cref="ArgumentException">
/// If the projection list command text is empty.
/// </exception>
public ObjectQuery <TResultType> SelectValue <TResultType> (string projection, params ObjectParameter[] parameters)
{
EntityUtil.CheckArgumentNull(projection, "projection");
EntityUtil.CheckArgumentNull(parameters, "parameters");
if (StringUtil.IsNullOrEmptyOrWhiteSpace(projection))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.ObjectQuery_QueryBuilder_InvalidProjectionList, "projection");
}
// SQLPUDT 484974: Make sure TResultType is loaded.
this.QueryState.ObjectContext.MetadataWorkspace.ImplicitLoadAssemblyForType(typeof(TResultType), System.Reflection.Assembly.GetCallingAssembly());
return(new ObjectQuery <TResultType>(EntitySqlQueryBuilder.SelectValue(this.QueryState, this.Name, projection, parameters, typeof(TResultType))));
}
/// <summary>Limits the query to only results of a specific type.</summary>
/// <returns>
/// A new <see cref="T:System.Data.Entity.Core.Objects.ObjectQuery`1" /> instance that is equivalent to the original instance with OFTYPE applied.
/// </returns>
/// <typeparam name="TResultType">
/// The type of the <see cref="T:System.Data.Entity.Core.Objects.ObjectResult`1" /> returned when the query is executed with the applied filter.
/// </typeparam>
/// <exception cref="T:System.Data.Entity.Core.EntitySqlException">The type specified is not valid.</exception>
public ObjectQuery <TResultType> OfType <TResultType>()
{
if (ObjectQuery <T> .IsLinqQuery((ObjectQuery)this))
{
return((ObjectQuery <TResultType>)Queryable.OfType <TResultType>(this));
}
this.QueryState.ObjectContext.MetadataWorkspace.ImplicitLoadAssemblyForType(typeof(TResultType), Assembly.GetCallingAssembly());
Type type1 = typeof(TResultType);
EdmType type2;
if (!this.QueryState.ObjectContext.MetadataWorkspace.GetItemCollection(DataSpace.OSpace).TryGetType(type1.Name, type1.NestingNamespace() ?? string.Empty, out type2) || !Helper.IsEntityType(type2) && !Helper.IsComplexType(type2))
{
throw new EntitySqlException(Strings.ObjectQuery_QueryBuilder_InvalidResultType((object)typeof(TResultType).FullName));
}
return(new ObjectQuery <TResultType>(EntitySqlQueryBuilder.OfType(this.QueryState, type2, type1)));
}
/// <summary>
/// This query-builder method creates a new query whose results are all of
/// the results of this query, plus all of the results of the other query,
/// including any duplicates (i.e., results are not necessarily unique).
/// </summary>
/// <param name="query"> A query representing the results to add. </param>
/// <returns> a new ObjectQuery instance. </returns>
/// <exception cref="ArgumentNullException">If the query parameter is null.</exception>
public ObjectQuery <T> UnionAll(ObjectQuery <T> query)
{
Check.NotNull(query, "query");
return(new ObjectQuery <T>(EntitySqlQueryBuilder.UnionAll(QueryState, query.QueryState)));
}
/// <summary>Limits the query results to a specified number of items.</summary>
/// <returns>
/// A new <see cref="T:System.Data.Entity.Core.Objects.ObjectQuery`1" /> instance that is equivalent to the original instance with TOP applied.
/// </returns>
/// <param name="count">The number of items in the results as a string. </param>
/// <param name="parameters">An optional set of query parameters that should be in scope when parsing.</param>
/// <exception cref="T:System.ArgumentNullException"> count is null.</exception>
/// <exception cref="T:System.ArgumentException"> count is an empty string.</exception>
public ObjectQuery <T> Top(string count, params ObjectParameter[] parameters)
{
Check.NotEmpty(count, "count");
return(new ObjectQuery <T>(EntitySqlQueryBuilder.Top(QueryState, Name, count, parameters)));
}
/// <summary>Limits the query to results that match specified filtering criteria.</summary>
/// <returns>
/// A new <see cref="T:System.Data.Entity.Core.Objects.ObjectQuery`1" /> instance that is equivalent to the original instance with WHERE applied.
/// </returns>
/// <param name="predicate">The filter predicate.</param>
/// <param name="parameters">Zero or more parameters that are used in this method.</param>
/// <exception cref="T:System.ArgumentNullException"> predicate is null or parameters is null.</exception>
/// <exception cref="T:System.ArgumentException">The predicate is an empty string.</exception>
public ObjectQuery <T> Where(string predicate, params ObjectParameter[] parameters)
{
Check.NotEmpty(predicate, nameof(predicate));
Check.NotNull <ObjectParameter[]>(parameters, nameof(parameters));
return(new ObjectQuery <T>(EntitySqlQueryBuilder.Where(this.QueryState, this.Name, predicate, parameters)));
}
/// <summary>
/// This query-builder method creates a new query whose results are all of
/// the results of this query, plus all of the results of the other query,
/// including any duplicates (i.e., results are not necessarily unique).
/// </summary>
/// <param name="query"> A query representing the results to add. </param>
/// <returns> a new ObjectQuery instance. </returns>
/// <exception cref="T:System.ArgumentNullException">If the query parameter is null.</exception>
public ObjectQuery <T> UnionAll(ObjectQuery <T> query)
{
Check.NotNull <ObjectQuery <T> >(query, nameof(query));
return(new ObjectQuery <T>(EntitySqlQueryBuilder.UnionAll(this.QueryState, query.QueryState)));
}
/// <summary>Orders the query results by the specified criteria.</summary>
/// <returns>
/// A new <see cref="T:System.Data.Entity.Core.Objects.ObjectQuery`1" /> instance that is equivalent to the original instance with ORDER BY applied.
/// </returns>
/// <param name="keys">The key columns by which to order the results.</param>
/// <param name="parameters">Zero or more parameters that are used in this method.</param>
/// <exception cref="T:System.ArgumentNullException">The keys or parameters parameter is null.</exception>
/// <exception cref="T:System.ArgumentException">The key is an empty string.</exception>
public ObjectQuery <T> OrderBy(string keys, params ObjectParameter[] parameters)
{
Check.NotEmpty(keys, nameof(keys));
Check.NotNull <ObjectParameter[]>(parameters, nameof(parameters));
return(new ObjectQuery <T>(EntitySqlQueryBuilder.OrderBy(this.QueryState, this.Name, keys, parameters)));
}
/// <summary>
/// This query-builder method creates a new query whose results are all of
/// the results of this query, plus all of the results of the other query,
/// including any duplicates (i.e., results are not necessarily unique).
/// </summary>
/// <param name="query">
/// A query representing the results to add.
/// </param>
/// <returns>
/// a new ObjectQuery instance.
/// </returns>
/// <exception cref="ArgumentNullException">
/// If the query parameter is null.
/// </exception>
public ObjectQuery <T> UnionAll(ObjectQuery <T> query)
{
EntityUtil.CheckArgumentNull(query, "query");
return(new ObjectQuery <T>(EntitySqlQueryBuilder.UnionAll(this.QueryState, query.QueryState)));
}
