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