DataQuery

The request path for this query. Intended for use by servers. Clients should use API calls (e.g. from) to create request paths.

The query string for this query. Intended for use by servers. Clients should use API calls (e.g. select, expand, filter, orderBy) to create query strings.

The data format for this query’s result.

The entity type expected for the result of this query. Can be used for inference of entitySet, if only one entity set in the data model uses this type.

Derived type for limiting query results.

The method call for this query. To execute a query, either this must be non-nil, or entitySet must be non-nil.

Resource path indicating the target resource for this query.

Property path for accessing individual properties of an entity.

Set to the expected query result data type. This may be required if url has been explicitly set.

Set to true if a single result is expected. This may be required if url has been explicitly set.

The properties to select from target entities.

Whether to select only distinct items.

true if all properties are selected (using “*”).

true if all key properties should be selected.

The properties to expand from target entities.

The filter criteria for the target entities.

The search criteria for the target entities.

The search text to locate in target entities. Preferably, the searchExpression will be used when formatting queries. Using searchExpression also ensures correct encoding of query URLs.

The sort criteria for the target entities.

The OData transformation items as described in OData Data Aggregation.

A group transformation item set by groupBy.

If true, the service should return only the number of available results matching the query.

If true, the service should return the total number of available results as an inline count in the result list.

If true, the query result entities will use sparse array storage of properties, to conserve memory. This is only applicable to queries whose result entities will not be updated.

If true, the client should use streamed parsing of the response.

If true, the client should use delta parsing of the response.

The delta time (deltaToken as UTC date/time).

The delta token for use in change tracking.

Does the client want the server to track changes?

The skip token for use in server-driven paging.

The number of initial results to skip.

The maximum number of results per page. Note that this is just a hint to the service. The service is permitted to ignore the client-requested page size. Use skipCount and topCount for predictable paging.

The number of initial results to return.

Parameter alias values.

Custom query options.

Elapsed time metric (unit: “MICROSECOND”) to be used for execution of this query.

Result count metric to be used for execution of this query.

Default initializer.

This function is an alias for filter.

Adds aggregate items (to transformValues) for transforming the result of a query sent to an entity set. This method is only for adding aggregate transformation items (in contrast to ‘transform’ method) for readability purposes.

Example for aggregations

open func aggregationExample() throws -> Void {
    let service = self.service
    let orderDetailsEntitySet = service.entitySet(withName: "Order_Detail")
    let orderDetailEntityType = orderDetailsEntitySet.entityType
    let orderDetailQuantity = orderDetailEntityType.property(withName: "Quantity")
    let query = DataQuery().from(orderDetailsEntitySet)
    let aggregateTransform = orderDetailQuantity.sum(as: "SumQuantity")
    _ = query.aggregate(aggregateTransform)
    try self.testApplyQueryResult(query: query, expectedDynamicPropertyName: "SumQuantity")
    let queryCount = DataQuery().from(orderDetailsEntitySet)
    let countAggregate = AggregateValue.count(as: "AllOrderDetails")
    _ = queryCount.aggregate(countAggregate)
    try self.testApplyQueryResult(query: queryCount,
        expectedDynamicPropertyName: "AllOrderDetails")
}

Example for aggregations

open func aggregationExample() throws -> Void {
    let query = DataQuery()
        .from(NorthwindServiceMetadata.EntitySets.orderDetails)
    let aggregateTransform = OrderDetail.quantity.sum(as: "SumQuantity")
    _ = query.aggregate(aggregateTransform)
    try self.testApplyQueryResult(query: query, expectedDynamicPropertyName: "SumQuantity")
    let queryCount = DataQuery()
        .from(NorthwindServiceMetadata.EntitySets.orderDetails)
    let countAggregate = AggregateValue.count(as: "AllOrderDetails")
    _ = queryCount.aggregate(countAggregate)
    try self.testApplyQueryResult(query: queryCount,
        expectedDynamicPropertyName: "AllOrderDetails")
}

Bind a resource as the binding parameter of a bound action/function. If resource is a DataPath, then sets resourcePath.ResourcePath.dataPath. If resource is an EntitySet, then calls from to set resourcePath.ResourcePath.entitySet. If resource is an EntityValue, then calls load to set resourcePath.ResourcePath.entitySet and resourcePath.ResourcePath.entityKey.

Check if this query is properly configured from the client’s perspective. Note: This does not guarantee that the server will be able to execute it.

Set countOnly to true to request only the number of matching query results.

Example using proxy classes

open func navigationCountExample() throws -> Void {
    let service = self.service
    let customer = try service.fetchCustomer(matching: DataQuery()
        .expand(Customer.orders).top(1))
    let orders = customer.orders
    let query = DataQuery().load(customer, Customer.orders).count()
    let count = try service.executeQuery(query).count()
    assert(count == Int64(orders.count))
}

Example using proxy classes

open func collectionCountExample() throws -> Void {
    let service = self.service
    let customers = try service.fetchCustomers()
    let query = DataQuery().from(NorthwindServiceMetadata.EntitySets.customers)
        .count()
    let count = try service.executeQuery(query).count()
    assert(count == Int64(customers.count))
}

Example using dynamic API

open func collectionCountExample() throws -> Void {
    let service = self.service
    let customersEntitySet = service.entitySet(withName: "Customers")
    let customers = try service.executeQuery(DataQuery().from(customersEntitySet))
        .entityList()
    let query = DataQuery().from(customersEntitySet).count()
    let count = try service.executeQuery(query).count()
    assert(count == Int64(customers.length))
}

Example using dynamic API

open func navigationCountExample() throws -> Void {
    let service = self.service
    let customersEntitySet = service.entitySet(withName: "Customers")
    let customerEntityType = customersEntitySet.entityType
    let ordersProperty = customerEntityType.property(withName: "Orders")
    let customer = try service.executeQuery(DataQuery().from(customersEntitySet)
        .expand(ordersProperty).top(1))
        .entityList().first()
    let orders = ordersProperty.entityList(from: customer)
    let query = DataQuery().load(customer, ordersProperty).count()
    let count = try service.executeQuery(query).count()
    assert(count == Int64(orders.length))
}

Alter this query to include all current entities (non-pending, or with pending create/update requests) as well as deleted entities (pending deletion). This is relevant in offline scenarios.

Add a custom option to customOptions.

Alter this query to defer its execution. This is particular useful when using actions/functions with proxy classes. It allows the use of deferred proxy method calls together with request batches.

Example using proxy classes

open func invokeActionsInBatch() throws -> Void {
    let service = self.service
    let batch = RequestBatch()
    let action1 = DataQuery()
    let action2 = DataQuery()
    try service.deleteVideosInCategory("Romance", query: action1.deferExecution())
    try service.deleteVideosInCategory("Suspense", query: action2.deferExecution())
    batch.addAction(call: action1)
    batch.addAction(call: action2)
    try service.processBatch(batch)
    batch.checkActionResult(for: action1)
    batch.checkActionResult(for: action2)
}

Example using proxy classes

open func invokeFunctionsInBatch() throws -> Void {
    let service = self.service
    let batch = RequestBatch()
    let query1 = DataQuery()
    let query2 = DataQuery()
    _ = try service.videosInCategory("Romance", query: query1.deferExecution())
    _ = try service.videosInCategory("Suspense", query: query2.deferExecution())
    batch.addFunction(call: query1)
    batch.addFunction(call: query2)
    try service.processBatch(batch)
    let videos1 = try Video.array(from: batch.functionResult(for: query1)
        .entityList())
    let videos2 = try Video.array(from: batch.functionResult(for: query2)
        .entityList())
    self.showVideos(videos1)
    self.showVideos(videos2)
}

Deprecated. Use search(SearchExpression) or set the searchText property.

The entity key for this query. If specified, then entitySet should also be specified.

The entity set expected for the result of this query. To execute a query, either this must be non-nil, or methodCall must be non-nil.

Add properties (to expandItems) for expanding from the target entity.

Example using proxy classes

open func expandExample() throws -> Void {
    let service = self.service
    let query = DataQuery()
        .select(Customer.customerID, Customer.companyName, Customer.contactName)
        .filter(Customer.customerID.equal("ALFKI").or(Customer.customerID.equal("ANATR")))
        .expand(Customer.orders).orderBy(Customer.companyName)
    let customers = try service.fetchCustomers(matching: query)
    var countOrders = 0
    for customer in customers {
        self.showCustomer(customer)
        let orders = customer.orders
        for order in orders {
            let orderID = order.orderID
            try Example.show("  Order ", Example.formatInt(orderID))
            countOrders = countOrders + 1
        }
    }
    assert(countOrders > 0)
}

Example using dynamic API

open func expandExample() throws -> Void {
    let service = self.service
    let customersEntitySet = service.entitySet(withName: "Customers")
    let customerEntityType = customersEntitySet.entityType
    let customerIDProperty = customerEntityType.property(withName: "CustomerID")
    let companyNameProperty = customerEntityType.property(withName: "CompanyName")
    let contactNameProperty = customerEntityType.property(withName: "ContactName")
    let ordersProperty = customerEntityType.property(withName: "Orders")
    let orderIDProperty = ordersProperty.itemEntityType.property(withName: "OrderID")
    let query = DataQuery()
        .select(customerIDProperty, companyNameProperty, contactNameProperty)
        .from(customersEntitySet).expand(ordersProperty)
        .filter(customerIDProperty.equal("ALFKI").or(customerIDProperty.equal("ANATR")))
        .orderBy(companyNameProperty)
    let customers = try service.executeQuery(query).entityList()
    var countOrders = 0
    for customer in customers {
        self.showCustomer(customer)
        let orders = ordersProperty.entityList(from: customer)
        for order in orders {
            let orderID = orderIDProperty.intValue(from: order)
            try Example.show("  Order ", Example.formatInt(orderID))
            countOrders = countOrders + 1
        }
    }
    assert(countOrders > 0)
}

Add a property with a nested query to expandItems. See the expandWithQueryExample2 below for an abbreviated syntax that implicitly creates the nested query.

Example using proxy classes

open func expandWithQueryExample1() throws -> Void {
    let service = self.service
    let query = DataQuery()
        .select(Customer.customerID, Customer.companyName, Customer.contactName)
        .filter(Customer.customerID.equal("ALFKI").or(Customer.customerID.equal("ANATR")))
        .expand(Customer.orders, withQuery: DataQuery().select(Order.orderID)
            .expand(Order.orderDetails,
                withQuery: DataQuery().select(OrderDetail.quantity, OrderDetail.unitPrice)))
        .orderBy(Customer.companyName)
    let customers = try service.fetchCustomers(matching: query)
    var countDetails = 0
    for customer in customers {
        self.showCustomer(customer)
        let orders = customer.orders
        for order in orders {
            let orderID = order.orderID
            var totalPrice = BigDecimal(0)
            for orderDetail in order.orderDetails {
                totalPrice = totalPrice.add(DecimalFunction.fromShort(orderDetail.quantity)
                    .multiply(orderDetail.unitPrice))
                countDetails = countDetails + 1
            }
            try Example.show("Order ", Example.formatInt(orderID), ": total price ",
                Example.formatDecimal(totalPrice))
        }
    }
    assert(countDetails > 0)
}

Example using proxy classes

open func expandWithQueryExample2() throws -> Void {
    let service = self.service
    let query = DataQuery()
        .select(Customer.customerID, Customer.companyName, Customer.contactName)
        .filter(Customer.customerID.equal("ALFKI").or(Customer.customerID.equal("ANATR")))
        .expand(Customer.orders.select(Order.orderID)
            .expand(Order.orderDetails.select(OrderDetail.quantity,
                OrderDetail.unitPrice)))
        .orderBy(Customer.companyName)
    let customers = try service.fetchCustomers(matching: query)
    var countDetails = 0
    for customer in customers {
        self.showCustomer(customer)
        let orders = customer.orders
        for order in orders {
            let orderID = order.orderID
            var totalPrice = BigDecimal(0)
            for orderDetail in order.orderDetails {
                totalPrice = totalPrice.add(DecimalFunction.fromShort(orderDetail.quantity)
                    .multiply(orderDetail.unitPrice))
                countDetails = countDetails + 1
            }
            try Example.show("Order ", Example.formatInt(orderID), ": total price ",
                Example.formatDecimal(totalPrice))
        }
    }
    assert(countDetails > 0)
}

Example using dynamic API

open func expandWithQueryExample() throws -> Void {
    let service = self.service
    let customersEntitySet = service.entitySet(withName: "Customers")
    let customerEntityType = customersEntitySet.entityType
    let customerIDProperty = customerEntityType.property(withName: "CustomerID")
    let companyNameProperty = customerEntityType.property(withName: "CompanyName")
    let contactNameProperty = customerEntityType.property(withName: "ContactName")
    let ordersProperty = customerEntityType.property(withName: "Orders")
    let orderIDProperty = ordersProperty.itemEntityType.property(withName: "OrderID")
    let orderDetailsProperty = ordersProperty.itemEntityType.property(withName: "Order_Details")
    let quantityProperty = orderDetailsProperty.itemEntityType.property(withName: "Quantity")
    let unitPriceProperty = orderDetailsProperty.itemEntityType.property(withName: "UnitPrice")
    let query = DataQuery()
        .select(customerIDProperty, companyNameProperty, contactNameProperty)
        .from(customersEntitySet)
        .filter(customerIDProperty.equal("ALFKI").or(customerIDProperty.equal("ANATR")))
        .expand(ordersProperty, withQuery: DataQuery().select(orderIDProperty)
            .expand(orderDetailsProperty,
                withQuery: DataQuery().select(quantityProperty, unitPriceProperty)))
        .orderBy(companyNameProperty)
    let customers = try service.executeQuery(query).entityList()
    for customer in customers {
        self.showCustomer(customer)
        let orders = ordersProperty.entityList(from: customer)
        for order in orders {
            let orderID = orderIDProperty.intValue(from: order)
            var totalPrice = BigDecimal(0)
            for orderDetail in orderDetailsProperty.entityList(from: order) {
                let quantity = quantityProperty.shortValue(from: orderDetail)
                let unitPrice = unitPriceProperty.decimalValue(from: orderDetail)
                totalPrice = totalPrice.add(DecimalFunction.fromShort(quantity)
                    .multiply(unitPrice))
            }
            try Example.show("Order ", Example.formatInt(orderID), ": total price ",
                Example.formatDecimal(totalPrice))
        }
    }
}

Set expectedType and expectSingle, depending on the type parameter.

Modify queryFilter to be and'ed with test (or set to test if queryFilter was nil).

Example using proxy classes

open func queryWithFilterExample() throws -> Void {
    let service = self.service
    let query = DataQuery()
        .select(Customer.customerID, Customer.companyName, Customer.contactName)
        .filter(Customer.country.equal("Germany")
            .and(Customer.contactName.greaterEqual("N")))
    // Alternate syntax using convenience operators:
    // let query = DataQuery()
    //     .select(Customer.customerID, Customer.companyName, Customer.contactName)
    //     .filter(Customer.country == "Germany" && Customer.contactName >= "N")
    let customers = try service.fetchCustomers(matching: query)
    self.showCustomers(customers)
}

Example using proxy classes

open func filterByDateExample() throws -> Void {
    let service = self.service
    let oneWeekAgo = GlobalDateTime.now().plusDays(-7)
    let query = DataQuery().filter(Order.orderDate.greaterThan(oneWeekAgo))
    // Alternate syntax using convenience operators:
    // let query = DataQuery().filter(Order.orderDate >= oneWeekAgo)
    let orders = try service.fetchOrders(matching: query)
    self.showOrders(orders)
}

Example using proxy classes

open func filterByEnumExample() throws -> Void {
    let service = self.service
    let query = DataQuery()
        .filter(TrippinPerson.gender.equal(TrippinServiceMetadata.EnumValues.TrippinPersonGender.female))
    // Alternate syntax using convenience operators:
    // let query = DataQuery().filter(TrippinPerson.gender == TrippinPersonGender.female.enumValue)
    let people = try service.fetchPeople(matching: query)
    try self.showPeople(people)
}

Example using dynamic API

open func queryWithFilterExample() throws -> Void {
    let service = self.service
    let customersEntitySet = service.entitySet(withName: "Customers")
    let customerEntityType = customersEntitySet.entityType
    let customerIDProperty = customerEntityType.property(withName: "CustomerID")
    let companyNameProperty = customerEntityType.property(withName: "CompanyName")
    let contactNameProperty = customerEntityType.property(withName: "ContactName")
    let countryProperty = customerEntityType.property(withName: "Country")
    let query = DataQuery()
        .select(customerIDProperty, companyNameProperty, contactNameProperty)
        .from(customersEntitySet)
        .filter(countryProperty.equal("Germany")
            .and(contactNameProperty.greaterEqual("N")))
    // Alternate syntax using convenience operators:
    // let query = DataQuery()
    //     .select(customerIDProperty, companyNameProperty, contactNameProperty)
    //     .from(customersEntitySet)
    //     .filter(countryProperty == "Germany" && contactNameProperty >= "N")
    let customers = try service.executeQuery(query).entityList()
    self.showCustomers(customers)
}

Example using dynamic API

open func filterByDateExample() throws -> Void {
    let service = self.service
    let ordersEntitySet = service.entitySet(withName: "Orders")
    let orderEntityType = ordersEntitySet.entityType
    let orderDateProperty = orderEntityType.property(withName: "OrderDate")
    let oneWeekAgo = GlobalDateTime.now().plusDays(-7)
    let query = DataQuery().from(ordersEntitySet)
        .filter(orderDateProperty.greaterThan(oneWeekAgo))
    // Alternate syntax using convenience operators:
    // let query = DataQuery().filter(orderDateProperty >= oneWeekAgo)
    let orders = try service.executeQuery(query).entityList()
    self.showOrders(orders)
}

Example using dynamic API

open func filterByEnumExample() throws -> Void {
    let service = self.service
    let peopleEntitySet = service.entitySet(withName: "People")
    let personEntityType = peopleEntitySet.entityType
    let genderProperty = personEntityType.property(withName: "Gender")
    let genderEnumType = service.metadata.enumType(withName: "Microsoft.OData.Service.Sample.TrippinInMemory.Models.PersonGender")
    let female = genderEnumType.member(name: "Female")
    let query = DataQuery().from(peopleEntitySet)
        .filter(genderProperty.equal(female))
    // Alternate syntax using convenience operators:
    // let query = DataQuery().filter(genderProperty == genderFemale)
    let people = try service.executeQuery(query).entityList()
    try self.showPeople(people)
}

Set the entitySet property to identify this query’s target entity set.

Example using proxy classes

open func fromExample() throws -> Void {
    let service = self.service
    let customers = try service.fetchCustomers()
    for customer in customers {
        self.showCustomer(customer)
    }
}

Example using dynamic API

open func fromExample() throws -> Void {
    let service = self.service
    let customersEntitySet = service.entitySet(withName: "Customers")
    let query = DataQuery().from(customersEntitySet)
    let customers = try service.executeQuery(query).entityList()
    for customer in customers {
        self.showCustomer(customer)
    }
}

Set the entitySet property to identify this query’s target entity set, but only if the entitySet property wasn’t previously set. This function is intended for use by generated proxy classes.

Adds a group transformation item to the DataQuery with the property paths given in the parameter list. Note: If this method is called then all the transformation and aggregation items added to the query will be applied to the group transformation in the query.

Example for transformations

open func transformationExample() throws -> Void {
    let service = self.service
    let employeeEntitySet = service.entitySet(withName: "Employees")
    let employeeEntityType = employeeEntitySet.entityType
    let employeeReportsToProperty = employeeEntityType.property(withName: "ReportsTo")
    let ordersProperty = employeeEntityType.property(withName: "Orders")
    let orderID = ordersProperty.itemEntityType.property(withName: "OrderID")
    let countryProperty = employeeEntityType.property(withName: "Country")
    let queryGroup = DataQuery().from(employeeEntitySet)
    let filterGroupTransform = FilterTransform.of(QueryOperator.equal(countryProperty,
        StringValue.of("Budapest")))
    let groupTransform = GroupTransform.groupBy(employeeReportsToProperty)
        .aggregate(ordersProperty.path(orderID).countDistinct(as: "TotalOrders"))
    _ = queryGroup.transform(groupTransform)
    try self.testApplyQueryResult(query: queryGroup,
        expectedDynamicPropertyName: "TotalOrders")
    let groupTransformForQuery = DataQuery().from(employeeEntitySet)
        .groupBy(employeeReportsToProperty)
        .aggregate(ordersProperty.path(orderID).countDistinct(as: "TotalOrders"))
        .transform(filterGroupTransform)
    try self.testApplyQueryResult(query: groupTransformForQuery,
        expectedDynamicPropertyName: "TotalOrders")
    let queryTopPercent = DataQuery().from(employeeEntitySet)
    let topPercentTransform = TopTransform.percent(amount: Double(50),
        value: employeeReportsToProperty)
    _ = queryTopPercent.transform(topPercentTransform)
    try self.testApplyQueryResult(query: queryTopPercent,
        expectedDynamicPropertyName: nil)
    let queryExpand = DataQuery().from(employeeEntitySet)
    let expandTransform = ExpandTransform.withFilter(ordersProperty,
        filter: FilterTransform.of(QueryOperator.equal(employeeReportsToProperty,
            IntValue.of(1000))))
    _ = queryExpand.transform(expandTransform)
    try self.testApplyQueryResult(query: queryExpand,
        expectedDynamicPropertyName: nil)
    let employee1Property = employeeEntityType.property(withName: "Employee1")
    let expandWithExpandTransform = ExpandTransform.withExpand(employee1Property,
        expand: expandTransform)
    let queryExpand1 = DataQuery().from(employeeEntitySet)
    _ = queryExpand1.transform(expandWithExpandTransform)
    try self.testApplyQueryResult(query: queryExpand1,
        expectedDynamicPropertyName: nil)
    let queryOrderBy = DataQuery().from(employeeEntitySet)
    let orderTransform = OrderTransform.orderBy(SortItem.of(countryProperty,
        SortOrder.descending))
    let skipTransform = SkipTransform.skip(5)
    let topTransform = TopTransform.top(10)
    _ = queryOrderBy.transform(orderTransform.chain(skipTransform)
        .chain(topTransform))
    try self.testApplyQueryResult(query: queryOrderBy,
        expectedDynamicPropertyName: nil)
    let orderDetailsEntitySet = service.entitySet(withName: "Order_Details")
    let ordersQuantityProperty = orderDetailsEntitySet.entityType.property(withName: "Quantity")
    let queryConcat = DataQuery().from(orderDetailsEntitySet)
    let concatTransform = ConcatTransform.create(IdentityTransform.create(),
        ordersQuantityProperty.sum(as: "SumQuantity"))
    _ = queryConcat.transform(concatTransform)
    try self.testApplyQueryResult(query: queryConcat,
        expectedDynamicPropertyName: "SumQuantity")
    let var_employeeEntitySet = service.entitySet(withName: "Employees")
    let var_employeeEntityType = var_employeeEntitySet.entityType
    let employeeIDProperty = var_employeeEntityType.property(withName: "EmployeeID")
    let firstNameProperty = var_employeeEntityType.property(withName: "FirstName")
    let lastNameProperty = var_employeeEntityType.property(withName: "LastName")
    let var_ordersProperty = var_employeeEntityType.property(withName: "Orders")
    let ordersEntitySet = service.entitySet(withName: "Orders")
    let orderEntityType = ordersEntitySet.entityType
    let orderIDProperty = orderEntityType.property(withName: "OrderID")
    let queryJoin = DataQuery().from(var_employeeEntitySet)
    let joinTransform = JoinTransform.join(var_ordersProperty, alias: "Order")
    _ = joinTransform.transform(GroupTransform.groupBy(employeeIDProperty,
        firstNameProperty, lastNameProperty)
        .aggregate(DataPath.ofDynamic("Order").path(orderIDProperty).countDistinct(as: "TotalOrders")))
    _ = queryJoin.transform(joinTransform)
    try self.testApplyQueryResult(query: queryJoin,
        expectedDynamicPropertyName: "Order")
}

Example for transformations

open func transformationExample() throws -> Void {
    let queryGroup = DataQuery()
        .from(NorthwindServiceMetadata.EntitySets.employees)
    let groupTransform = GroupTransform.groupBy(Employee.reportsTo)
        .aggregate(Employee.orders.path(Order.orderID).countDistinct(as: "TotalOrders"))
    _ = queryGroup.transform(groupTransform)
    try self.testApplyQueryResult(query: queryGroup,
        expectedDynamicPropertyName: "TotalOrders")
    let filterGroupTransform = FilterTransform.of(QueryOperator.equal(Employee.country,
        StringValue.of("Budapest")))
    let groupTransformForQuery = DataQuery()
        .from(NorthwindServiceMetadata.EntitySets.employees)
        .groupBy(Employee.reportsTo)
        .aggregate(Employee.orders.path(Order.orderID).countDistinct(as: "TotalOrders"))
        .transform(filterGroupTransform)
    try self.testApplyQueryResult(query: groupTransformForQuery,
        expectedDynamicPropertyName: "TotalOrders")
    let queryTopPercent = DataQuery()
        .from(NorthwindServiceMetadata.EntitySets.employees)
    let topPercentTransform = TopTransform.percent(amount: Double(50),
        value: Employee.reportsTo)
    _ = queryTopPercent.transform(topPercentTransform)
    try self.testApplyQueryResult(query: queryTopPercent,
        expectedDynamicPropertyName: nil)
    let queryExpand = DataQuery()
        .from(NorthwindServiceMetadata.EntitySets.employees)
    let expandTransform = ExpandTransform.withFilter(Employee.orders,
        filter: FilterTransform.of(QueryOperator.equal(Employee.reportsTo,
            IntValue.of(1000))))
    _ = queryExpand.transform(expandTransform)
    try self.testApplyQueryResult(query: queryExpand,
        expectedDynamicPropertyName: nil)
    let expandWithExpandTransform = ExpandTransform.withExpand(Employee.employee1,
        expand: expandTransform)
    let queryExpand1 = DataQuery()
        .from(NorthwindServiceMetadata.EntitySets.employees)
    _ = queryExpand1.transform(expandWithExpandTransform)
    try self.testApplyQueryResult(query: queryExpand1,
        expectedDynamicPropertyName: nil)
    let queryOrderBy = DataQuery()
        .from(NorthwindServiceMetadata.EntitySets.employees)
    let orderTransform = OrderTransform.orderBy(SortItem.of(Customer.country,
        SortOrder.descending))
    let skipTransform = SkipTransform.skip(5)
    let topTransform = TopTransform.top(10)
    _ = queryOrderBy.transform(orderTransform.chain(skipTransform)
        .chain(topTransform))
    try self.testApplyQueryResult(query: queryOrderBy,
        expectedDynamicPropertyName: nil)
    let queryConcat = DataQuery()
        .from(NorthwindServiceMetadata.EntitySets.orderDetails)
    let concatTransform = ConcatTransform.create(IdentityTransform.create(),
        OrderDetail.quantity.sum(as: "SumQuantity"))
    _ = queryConcat.transform(concatTransform)
    try self.testApplyQueryResult(query: queryConcat,
        expectedDynamicPropertyName: "SumQuantity")
    let queryJoin = DataQuery()
        .from(NorthwindServiceMetadata.EntitySets.employees)
    let joinTransform = JoinTransform.join(Employee.orders, alias: "Order")
    _ = joinTransform.transform(GroupTransform.groupBy(Employee.employeeID,
        Employee.firstName, Employee.lastName)
        .aggregate(DataPath.ofDynamic("Order").path(Order.orderID).countDistinct(as: "TotalOrders")))
    _ = queryJoin.transform(joinTransform)
    try self.testApplyQueryResult(query: queryJoin,
        expectedDynamicPropertyName: "Order")
}

Alter this query to apply to all entities with pending changes.

Alter this query to apply to all entities with original state.

Set countInline to true to request an inline count in the server’s response.

Example using proxy classes

open func inlineCountExample() throws -> Void {
    let service = self.service
    let query = DataQuery().from(NorthwindServiceMetadata.EntitySets.customers)
        .skip(20).top(10).inlineCount()
    let result = try service.executeQuery(query)
    let customers = try Customer.array(from: result.entityList())
    let count = try result.inlineCount()
    assert(customers.count == 10)
    assert(count > Int64(10))
}

Example using dynamic API

open func inlineCountExample() throws -> Void {
    let service = self.service
    let customersEntitySet = service.entitySet(withName: "Customers")
    let query = DataQuery().from(customersEntitySet).skip(20).top(10)
        .inlineCount()
    let result = try service.executeQuery(query)
    let customers = try result.entityList()
    let count = try result.inlineCount()
    assert(customers.length == 10)
    assert(count > Int64(10))
}

Set methodCall to associate this query with an action/function invocation.

Example using proxy classes

open func invokeExample() throws -> Void {
    let service = self.service
    let person = try service.personWithMostFriends()
    try self.showPerson(person)
}

Example using dynamic API

open func invokeExample() throws -> Void {
    let service = self.service
    let functionImport = service.dataMethod(withName: "GetPersonWithMostFriends")
    let query = DataQuery().invoke(functionImport)
    let person = try service.executeQuery(query).requiredEntity()
    try self.showPerson(person)
}

Set the resourcePath property to identify this query’s entity sets for a cross join.

Example using proxy classes

open func joinExample() throws -> Void {
    let service = self.service
    let c = NorthwindService.customers
    let o = NorthwindService.orders
    let query = DataQuery().join(c, o).expand(c.select(Customer.companyName))
        .expand(o.select(Order.orderDate))
        .filter(c.path(Customer.customerID).equal(o.path(Order.customerID)))
    let resultList = try service.executeQuery(query).complexList()
    for resultItem in resultList {
        let customer = (resultItem.dynamicValue(name: c.localName) as! Customer)
        let order = (resultItem.dynamicValue(name: o.localName) as! Order)
        self.showCustomer(customer)
        self.showOrder(order)
    }
}

Example using dynamic API

open func joinExample() throws -> Void {
    let service = self.service
    let customersEntitySet = service.entitySet(withName: "Customers")
    let customerEntityType = customersEntitySet.entityType
    let customerIDProperty = customerEntityType.property(withName: "CustomerID")
    let companyNameProperty = customerEntityType.property(withName: "CompanyName")
    let ordersEntitySet = service.entitySet(withName: "Orders")
    let orderEntityType = ordersEntitySet.entityType
    let orderCustomerID = orderEntityType.property(withName: "CustomerID")
    let orderDateProperty = customerEntityType.property(withName: "OrderDate")
    let query = DataQuery().join(customersEntitySet, ordersEntitySet)
        .expand(customersEntitySet.select(companyNameProperty))
        .expand(ordersEntitySet.select(orderDateProperty))
        .filter(customersEntitySet.path(customerIDProperty)
            .equal(ordersEntitySet.path(orderCustomerID)))
    let resultList = try service.executeQuery(query).complexList()
    for resultItem in resultList {
        let customer = (resultItem.dynamicValue(name: customersEntitySet.localName) as! EntityValue)
        let order = (resultItem.dynamicValue(name: ordersEntitySet.localName) as! EntityValue)
        self.showCustomer(customer)
        self.showOrder(order)
    }
}

Set entitySet and entityKey to configure this query to load an existing entity. Equivalent to calling from(entity.entitySet).withKey(entity.entityKey).

Construct a new DataQuery if the query parameter is nil.

Add to sortItems a value for result ordering.

Example using proxy classes

open func orderByExample() throws -> Void {
    // Find the 3 artists born nearest to Avila, Spain.
    let service = self.service
    let avila = GeographyPoint.with(latitude: 40.6567, longitude: -4.6812)
    let query = DataQuery().top(3).orderBy(Artist.placeOfBirth.geoDistance(avila))
    let artists = try service.fetchArtists(matching: query)
    self.showArtists(artists)
}

Example using dynamic API

open func orderByExample() throws -> Void {
    // Find the 3 artists born nearest to Avila, Spain.
    let service = self.service
    let artistsEntitySet = service.entitySet(withName: "Artists")
    let artistEntityType = artistsEntitySet.entityType
    let placeOfBirthProperty = artistEntityType.property(withName: "placeOfBirth")
    let avila = GeographyPoint.with(latitude: 40.6567, longitude: -4.6812)
    let query = DataQuery().top(3).from(artistsEntitySet)
        .orderBy(placeOfBirthProperty.geoDistance(avila))
    let artists = try service.executeQuery(query).entityList()
    self.showArtists(artists)
}

Set pageSize to specify the page-size for server-driven paging of results. Note: the server is not required to respect this setting. But if this setting is used, the client should expect to have to follow next-links.

Example using proxy classes

open func queryWithPageExample() throws -> Void {
    let service = self.service
    let expected = try service.executeQuery(DataQuery()
        .from(NorthwindServiceMetadata.EntitySets.customers).count())
        .count()
    var found = 0
    var query = DataQuery().from(NorthwindServiceMetadata.EntitySets.customers)
        .page(5)
    repeat {
        let result = try service.executeQuery(query)
        let customers = try Customer.array(from: result.entityList())
        self.showCustomers(customers)
        found = found &+ customers.count
        query = try result.nextQuery()
    }
    while query.url != nil
    assert(Int64(found) == expected)
}

Example using dynamic API

open func queryWithPageExample() throws -> Void {
    let service = self.service
    let customersEntitySet = service.entitySet(withName: "Customers")
    var query = DataQuery().from(customersEntitySet).page(5)
    repeat {
        let result = try service.executeQuery(query)
        let customers = try result.entityList()
        self.showCustomers(customers)
        query = try result.nextQuery()
    }
    while query.url != nil
}

Set propertyPath to identify this query’s target path.

Set propertyPath to identify this query’s target property.

Set resourcePath to identify this query’s target resource.

Set searchExpression for free-text searching.

Example using proxy classes

open func searchExample() throws -> Void {
    let service = self.service
    let query = DataQuery().search(SearchTerm.word("Juice"))
    let products = try service.fetchProducts(matching: query)
    self.showProducts(products)
}

Example using dynamic API

open func searchExample() throws -> Void {
    let service = self.service
    let productsEntitySet = service.entitySet(withName: "Products")
    let query = DataQuery().from(productsEntitySet).search(SearchTerm.word("Juice"))
    let products = try service.executeQuery(query).entityList()
    self.showProducts(products)
}

Add properties (to selectItems) for selecting from the target entity.

Example using proxy classes

open func selectExample() throws -> Void {
    let service = self.service
    let query = DataQuery()
        .select(Customer.customerID, Customer.companyName, Customer.contactName)
    let customers = try service.fetchCustomers(matching: query)
    for customer in customers {
        self.showCustomer(customer)
    }
}

Example using dynamic API

open func selectExample() throws -> Void {
    let service = self.service
    let customersEntitySet = service.entitySet(withName: "Customers")
    let customerEntityType = customersEntitySet.entityType
    let customerIDProperty = customerEntityType.property(withName: "CustomerID")
    let companyNameProperty = customerEntityType.property(withName: "CompanyName")
    let contactNameProperty = customerEntityType.property(withName: "ContactName")
    let query = DataQuery()
        .select(customerIDProperty, companyNameProperty, contactNameProperty)
        .from(customersEntitySet)
    let customers = try service.executeQuery(query).entityList()
    for customer in customers {
        self.showCustomer(customer)
    }
}