AnyDataService

OperationQueue instance to be used by this data service. By default the number of queued operations is maximized in 10.

OperationQueue to be used for completion handlers.

Execute operation on a serial background queue.

Async version of pingServer.

Async version of loadMetadata.

Async version of unloadMetadata.

Async version of executeMethod.

Async version of executeQuery.

Async version of loadProperty.

Async version of ‘loadEntity’.

Async version of saveEntity.

Async version of createEntity.

Async version of createRelatedEntity.

Async version of updateEntity.

Async version of deleteEntity.

Async version of deleteByQuery.

Async version of createLink.

Async version of updateLink.

Async version of deleteLink.

Async version of createMedia.

Async version of uploadMedia.

Async version of uploadStream.

Async version of deleteStream.

Async version of downloadMedia.

Async version of downloadStream.

Async version of applyChanges.

Async version of processBatch.

Construct a new data service using a specified provider.

Apply the changes from a change set to the target system.

Example using proxy classes

open func applyChangesExample() throws -> Void {
    let service = self.service
    let suppliers = try service.fetchSuppliers(matching: DataQuery().top(2))
    let products = try service.fetchProducts(matching: DataQuery().top(3))
    let product1 = products[0].copy()
    let product2 = products[1].copy()
    let product3 = products[2].copy()
    product1.productName = "Blueberry Muffins"
    product2.productName = "Strawberry Yoghurt"
    product3.productName = "Raspberry Pie"
    let entityCreates = ChangeSet()
    entityCreates.createEntity(product1)
    entityCreates.createEntity(product2)
    entityCreates.createEntity(product3)
    try service.applyChanges(entityCreates)
    let entityChanges = ChangeSet()
    product2.productName = "Blackberry Yoghurt"
    entityChanges.updateEntity(product2)
    entityChanges.deleteEntity(product3)
    try service.applyChanges(entityChanges)
    let linkChanges = ChangeSet()
    let supplier1 = suppliers[0]
    let supplier2 = suppliers[1]
    linkChanges.createLink(from: product1, property: Product.supplier,
        to: supplier1)
    linkChanges.updateLink(from: product1, property: Product.supplier,
        to: supplier2)
    linkChanges.deleteLink(from: product1, property: Product.supplier)
    try service.applyChanges(linkChanges)
}

Example using dynamic API

open func applyChangesExample() throws -> Void {
    let service = self.service
    let suppliersEntitySet = service.entitySet(withName: "Suppliers")
    let productsEntitySet = service.entitySet(withName: "Products")
    let productEntityType = productsEntitySet.entityType
    let productNameProperty = productEntityType.property(withName: "ProductName")
    let supplierProperty = productEntityType.property(withName: "Supplier")
    let suppliers = try service.executeQuery(DataQuery().from(suppliersEntitySet)
        .top(2))
        .entityList()
    let products = try service.executeQuery(DataQuery().from(productsEntitySet)
        .top(3))
        .entityList()
    let product1 = products.item(at: 0).copyEntity()
    let product2 = products.item(at: 1).copyEntity()
    let product3 = products.item(at: 1).copyEntity()
    productNameProperty.setStringValue(in: product1, to: "Blueberry Yoghurt")
    productNameProperty.setStringValue(in: product2, to: "Strawberry Yoghurt")
    productNameProperty.setStringValue(in: product3, to: "Raspberry Pie")
    let entityCreates = ChangeSet()
    entityCreates.createEntity(product1)
    entityCreates.createEntity(product2)
    entityCreates.createEntity(product3)
    try service.applyChanges(entityCreates)
    let entityChanges = ChangeSet()
    productNameProperty.setStringValue(in: product2, to: "Blackberry Yoghurt")
    entityChanges.updateEntity(product2)
    entityChanges.deleteEntity(product3)
    try service.applyChanges(entityChanges)
    let linkChanges = ChangeSet()
    let supplier1 = suppliers.item(at: 0)
    let supplier2 = suppliers.item(at: 1)
    linkChanges.createLink(from: product1, property: supplierProperty,
        to: supplier1)
    linkChanges.updateLink(from: product1, property: supplierProperty,
        to: supplier2)
    linkChanges.deleteLink(from: product1, property: supplierProperty)
    try service.applyChanges(linkChanges)
}

Create an entity in the target system. Automatically calls CsdlDocument.resolveEntity to ensure that EntityValue.entitySet is available.

Example using proxy classes

open func createEntityExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindProxyClient.createEntityExample")
    }
    do {
        DebugConsole.traceIn("example.NorthwindProxyClient.createEntityExample")
        do {
            let service = self.service
            let customer = Customer()
            customer.companyName = "Enterprise Inc."
            customer.contactName = "Jean-Luc Picard"
            try service.createEntity(customer)
        }
    }
}

Example using proxy classes

open func createEntityInSetExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindProxyClient.createEntityInSetExample")
    }
    do {
        DebugConsole.traceIn("example.NorthwindProxyClient.createEntityInSetExample")
        do {
            let service = self.service
            let customer = Customer()
            customer.companyName = "Voyager Inc."
            customer.contactName = "Kathryn Janeway"
            try service.createEntity(customer.inSet(NorthwindServiceMetadata.EntitySets.customers))
        }
    }
}

Example using dynamic API

open func createEntityExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindClient.createEntityExample")
    }
    do {
        DebugConsole.traceIn("example.NorthwindClient.createEntityExample")
        do {
            let service = self.service
            let customersEntitySet = service.entitySet(withName: "Customers")
            let customerEntityType = customersEntitySet.entityType
            let companyNameProperty = customerEntityType.property(withName: "CompanyName")
            let contactNameProperty = customerEntityType.property(withName: "ContactName")
            let customer = EntityValue.ofType(customerEntityType)
            companyNameProperty.setStringValue(in: customer, to: "Enterprise Inc.")
            contactNameProperty.setStringValue(in: customer, to: "Jean-Luc Picard")
            try service.createEntity(customer)
        }
    }
}

Example using dynamic API

open func createEntityInSetExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindClient.createEntityInSetExample")
    }
    do {
        DebugConsole.traceIn("example.NorthwindClient.createEntityInSetExample")
        do {
            let service = self.service
            let customersEntitySet = service.entitySet(withName: "Customers")
            let customerEntityType = customersEntitySet.entityType
            let companyNameProperty = customerEntityType.property(withName: "CompanyName")
            let contactNameProperty = customerEntityType.property(withName: "ContactName")
            let customer = EntityValue.ofType(customerEntityType)
            companyNameProperty.setStringValue(in: customer, to: "Voyager Inc.")
            contactNameProperty.setStringValue(in: customer, to: "Kathryn Janeway")
            try service.createEntity(customer.inSet(customersEntitySet))
        }
    }
}

Create a link from a source entity to a target entity in the target system.

Example using proxy classes

open func createLinkExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindProxyClient.createLinkExample")
    }
    do {
        DebugConsole.traceIn("example.NorthwindProxyClient.createLinkExample")
        do {
            let service = self.service
            let category = try service.fetchCategory(matching: DataQuery()
                .skip(1).top(1))
            let product = try service.fetchProduct(matching: DataQuery().top(1))
            try service.createLink(from: category, property: Category.products,
                to: product)
        }
    }
}

Example using dynamic API

open func createLinkExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindClient.createLinkExample")
    }
    do {
        DebugConsole.traceIn("example.NorthwindClient.createLinkExample")
        do {
            let service = self.service
            let categoriesEntitySet = service.entitySet(withName: "Categories")
            let productsEntitySet = service.entitySet(withName: "Products")
            let categoryEntityType = categoriesEntitySet.entityType
            let productsProperty = categoryEntityType.property(withName: "Products")
            let category = try service.executeQuery(DataQuery()
                .from(categoriesEntitySet).skip(1).top(1))
                .requiredEntity()
            let product = try service.executeQuery(DataQuery()
                .from(productsEntitySet).top(1))
                .requiredEntity()
            try service.createLink(from: category, property: productsProperty,
                to: product)
        }
    }
}

Create a media entity with the specified content. If the entity has non-stream structural properties in addition to the key properties and media content, such as label in the examples below, then this function will send two requests to the server: a first request to upload (POST) the media stream, and a second request (PATCH/PUT) to update the non-stream properties. It is not currently supported to make these two calls atomic. Caution: Having too many threads simultaneously creating streams may result in out-of-memory conditions on memory-constrained devices.

Example using proxy classes

open func createMediaExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.MediaProxyClient.createMediaExample")
    }
    do {
        DebugConsole.traceIn("example.MediaProxyClient.createMediaExample")
        do {
            let service = self.service
            let image = Image()
            image.label = "Smiley"
            let content = ByteStream.fromBinary(data: Base16Binary.convert("3A2D29"))
            content.mediaType = "text/plain"
            try service.createMedia(entity: image, content: content)
        }
    }
}

Example using dynamic API

open func createMediaExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.MediaClient.createMediaExample")
    }
    do {
        DebugConsole.traceIn("example.MediaClient.createMediaExample")
        do {
            let service = self.service
            let imagesEntitySet = service.entitySet(withName: "Images")
            let imageEntityType = imagesEntitySet.entityType
            let labelProperty = imageEntityType.property(withName: "label")
            let image = EntityValue.ofType(imageEntityType)
            labelProperty.setStringValue(in: image, to: "Smiley")
            let content = ByteStream.fromBinary(data: Base16Binary.convert("3A2D29"))
            content.mediaType = "text/plain"
            try service.createMedia(entity: image, content: content)
        }
    }
}

Create an entity in the target system, related to a parent entity via a parent navigation property.

Example using proxy classes

open func createRelatedEntityExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindProxyClient.createRelatedEntityExample")
    }
    do {
        DebugConsole.traceIn("example.NorthwindProxyClient.createRelatedEntityExample")
        do {
            let service = self.service
            let customer = try service.fetchCustomer(matching: DataQuery().top(1)
                .filter(Customer.customerID.equal("ALFKI")))
            let orders = try service.fetchOrders(matching: DataQuery().top(1))
            let newOrder = orders.first!.copy()
            try service.createRelatedEntity(newOrder, in: customer,
                property: Customer.orders)
        }
    }
}

Example using dynamic API

open func createRelatedEntityExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindClient.createRelatedEntityExample")
    }
    do {
        DebugConsole.traceIn("example.NorthwindClient.createRelatedEntityExample")
        do {
            let service = self.service
            let customersEntitySet = service.entitySet(withName: "Customers")
            let ordersEntitySet = service.entitySet(withName: "Orders")
            let customerEntityType = customersEntitySet.entityType
            let customerIDProperty = customerEntityType.property(withName: "CustomerID")
            let ordersProperty = customerEntityType.property(withName: "Orders")
            let customers = try service.executeQuery(DataQuery()
                .from(customersEntitySet).filter(customerIDProperty.equal("ALFKI")))
                .entityList()
            let orders = try service.executeQuery(DataQuery()
                .from(ordersEntitySet).top(1))
                .entityList()
            let customer = customers.first()
            let newOrder = orders.first().copyEntity()
            try service.createRelatedEntity(newOrder, in: customer,
                property: ordersProperty)
        }
    }
}

Create an media entity in the target system, related to a parent entity via a parent navigation property.

Example using proxy classes

open func createRelatedMediaExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.MediaProxyClient.createRelatedMediaExample")
    }
    do {
        DebugConsole.traceIn("example.MediaProxyClient.createRelatedMediaExample")
        do {
            let service = self.service
            let artist = Artist()
            artist.firstName = "Salvador"
            artist.lastName = "Dali"
            artist.dateOfBirth = LocalDate.of(year: 1904, month: 5, day: 11)
            artist.placeOfBirth = GeographyPoint.with(latitude: 42.266667,
                longitude: 2.965)
            try service.createEntity(artist)
            let image = Image()
            image.label = "Dream"
            let content = ByteStream.fromBinary(data: Base16Binary.convert("447265616D204361757365642062792074686520466C69676874206F662061204265652061726F756E64206120506F6D656772616E6174652061205365636F6E64204265666F7265204177616B656E696E67"))
            content.mediaType = "text/plain"
            try service.createRelatedMedia(entity: image, in: content,
                property: artist, headers: Artist.images)
        }
    }
}

Example using dynamic API

open func createRelatedMediaExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.MediaClient.createRelatedMediaExample")
    }
    do {
        DebugConsole.traceIn("example.MediaClient.createRelatedMediaExample")
        do {
            let service = self.service
            let artistsEntitySet = service.entitySet(withName: "Artists")
            let artistEntityType = artistsEntitySet.entityType
            let firstNameProperty = artistEntityType.property(withName: "firstName")
            let lastNameProperty = artistEntityType.property(withName: "lastName")
            let dateOfBirthProperty = artistEntityType.property(withName: "dateOfBirth")
            let placeOfBirthProperty = artistEntityType.property(withName: "placeOfBirth")
            let imagesProperty = artistEntityType.property(withName: "images")
            let imagesEntitySet = service.entitySet(withName: "Images")
            let imageEntityType = imagesEntitySet.entityType
            let labelProperty = imageEntityType.property(withName: "label")
            let artist = EntityValue.ofType(artistEntityType)
            firstNameProperty.setStringValue(in: artist, to: "Maurits")
            lastNameProperty.setStringValue(in: artist, to: "Escher")
            dateOfBirthProperty.setDataValue(in: artist,
                to: LocalDate.of(year: 1898, month: 6, day: 17))
            placeOfBirthProperty.setDataValue(in: artist,
                to: GeographyPoint.with(latitude: 53.2, longitude: 5.783333))
            try service.createEntity(artist)
            let image = EntityValue.ofType(imageEntityType)
            labelProperty.setStringValue(in: image, to: "Hands")
            let content = ByteStream.fromBinary(data: Base16Binary.convert("44726177696E672048616E6473"))
            content.mediaType = "text/plain"
            try service.createRelatedMedia(entity: image, in: content,
                property: artist, headers: imagesProperty)
        }
    }
}

Lookup a data method by qualified name (for function/action definitions) or by unqualified name (for function/action imports). If the data method does not exist it indicates a fundamental implementation problem, therefore a non-catchable FatalException will be thrown, and the app intentionally crashes. The reason behind this drastic behaviour is to avoid mismatch between server and client. It is still possible to avoid the FatalException by looking up data methods before calling this function like in the following code snippet:

Example checking if a data method exists

open func checkDataMethodExistsExample() throws -> Void {
    let service = self.service
    let csdlDocument = service.metadata
    if csdlDocument.dataMethods.containsValue(forKey: "Microsoft.OData.Service.Sample.TrippinInMemory.Models.Person.UpdatePersonLastName") {
        _ = service.dataMethod(withName: "Microsoft.OData.Service.Sample.TrippinInMemory.Models.Person.UpdatePersonLastName")
    } else {
    }
}

Execute query to delete data from the target system.

Delete an entity from the target system.

Example using proxy classes

open func deleteEntityExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindProxyClient.deleteEntityExample")
    }
    do {
        DebugConsole.traceIn("example.NorthwindProxyClient.deleteEntityExample")
        do {
            let service = self.service
            let query = DataQuery().top(1).selectKey()
                .filter(Customer.contactName.equal("William Riker"))
            let customer = try service.fetchCustomer(matching: query)
            try service.deleteEntity(customer)
        }
    }
}

Example using dynamic API

open func deleteEntityExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindClient.deleteEntityExample")
    }
    do {
        DebugConsole.traceIn("example.NorthwindClient.deleteEntityExample")
        do {
            let service = self.service
            let customersEntitySet = service.entitySet(withName: "Customers")
            let customerEntityType = customersEntitySet.entityType
            let contactNameProperty = customerEntityType.property(withName: "ContactName")
            let query = DataQuery().top(1).selectKey().from(customersEntitySet)
                .filter(contactNameProperty.equal("William Riker"))
            let customer = try service.executeQuery(query).requiredEntity()
            try service.deleteEntity(customer)
        }
    }
}

Delete a link from a source entity to a target entity.

Example using proxy classes

open func deleteLinkExample1() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindProxyClient.deleteLinkExample1")
    }
    do {
        DebugConsole.traceIn("example.NorthwindProxyClient.deleteLinkExample1")
        do {
            let service = self.service
            let product = try service.fetchProduct(matching: DataQuery().top(1))
            try service.deleteLink(from: product, property: Product.supplier)
        }
    }
}

Example using proxy classes

open func deleteLinkExample2() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindProxyClient.deleteLinkExample2")
    }
    do {
        DebugConsole.traceIn("example.NorthwindProxyClient.deleteLinkExample2")
        do {
            let service = self.service
            let category = try service.fetchCategory(matching: DataQuery()
                .skip(1).top(1))
            let product = try service.fetchProduct(matching: DataQuery().top(1))
            try service.deleteLink(from: category, property: Category.products,
                to: product)
        }
    }
}

Example using dynamic API

open func deleteLinkExample1() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindClient.deleteLinkExample1")
    }
    do {
        DebugConsole.traceIn("example.NorthwindClient.deleteLinkExample1")
        do {
            let service = self.service
            let productsEntitySet = service.entitySet(withName: "Products")
            let productEntityType = productsEntitySet.entityType
            let supplierProperty = productEntityType.property(withName: "Supplier")
            let product = try service.executeQuery(DataQuery()
                .from(productsEntitySet).top(1))
                .requiredEntity()
            try service.deleteLink(from: product, property: supplierProperty)
        }
    }
}

Example using dynamic API

open func deleteLinkExample2() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindClient.deleteLinkExample2")
    }
    do {
        DebugConsole.traceIn("example.NorthwindClient.deleteLinkExample2")
        do {
            let service = self.service
            let categoriesEntitySet = service.entitySet(withName: "Categories")
            let productsEntitySet = service.entitySet(withName: "Products")
            let categoryEntityType = categoriesEntitySet.entityType
            let productsProperty = categoryEntityType.property(withName: "Products")
            let category = try service.executeQuery(DataQuery()
                .from(categoriesEntitySet).skip(1).top(1))
                .requiredEntity()
            let product = try service.executeQuery(DataQuery()
                .from(productsEntitySet).top(1))
                .requiredEntity()
            try service.deleteLink(from: category, property: productsProperty,
                to: product)
        }
    }
}

Delete the content of a stream property from the target system.

Obtain a stream for downloading the content of a media entity from the target system. Caution: streams are often used for large content that may not fit (all at once) in available application memory. Having too many threads simultaneously downloading streams, or using ByteStream.readAndClose, may result in out-of-memory conditions on memory-constrained devices.

Example using proxy classes

open func downloadMediaExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.MediaProxyClient.downloadMediaExample")
    }
    do {
        DebugConsole.traceIn("example.MediaProxyClient.downloadMediaExample")
        do {
            let service = self.service
            let query = DataQuery().filter(Image.label.equal("Smiley")).top(1)
            let image = try service.fetchImage(matching: query)
            let stream = try service.downloadMedia(entity: image)
            let data = try stream.readAndClose()
            assert(BinaryOperator.equal(data, Base16Binary.convert("3B2D29")))
            assert(OptionalString.hasValue(stream.mediaType, "text/plain"))
        }
    }
}

Example using dynamic API

open func downloadMediaExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.MediaClient.downloadMediaExample")
    }
    do {
        DebugConsole.traceIn("example.MediaClient.downloadMediaExample")
        do {
            let service = self.service
            let imagesEntitySet = service.entitySet(withName: "Images")
            let imageEntityType = imagesEntitySet.entityType
            let labelProperty = imageEntityType.property(withName: "label")
            let query = DataQuery().from(imagesEntitySet)
                .filter(labelProperty.equal("Smiley")).top(1)
            let image = try service.executeQuery(query).requiredEntity()
            let stream = try service.downloadMedia(entity: image)
            let data = try stream.readAndClose()
            assert(BinaryOperator.equal(data, Base16Binary.convert("3B2D29")))
            assert(OptionalString.hasValue(stream.mediaType, "text/plain"))
        }
    }
}

Obtain a stream for downloading the content of a stream property from the target system. Caution: streams are often used for large content that may not fit (all at once) in available application memory. Having too many threads simultaneously downloading streams, or using ByteStream.readAndClose, may result in out-of-memory conditions on memory-constrained devices.

Example using proxy classes

open func downloadStreamExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.MediaProxyClient.downloadStreamExample")
    }
    do {
        DebugConsole.traceIn("example.MediaProxyClient.downloadStreamExample")
        do {
            let service = self.service
            let query = DataQuery().filter(Video.label.equal("Happier")).top(1)
            let video = try service.fetchVideo(matching: query)
            let stream = try service.downloadStream(entity: video,
                link: video.content)
            let data = try stream.readAndClose()
            assert(BinaryOperator.equal(data, Base16Binary.convert("2E2E2E")))
            assert(OptionalString.hasValue(stream.mediaType, "text/plain"))
        }
    }
}

Example using dynamic API

open func downloadStreamExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.MediaClient.downloadStreamExample")
    }
    do {
        DebugConsole.traceIn("example.MediaClient.downloadStreamExample")
        do {
            let service = self.service
            let videosEntitySet = service.entitySet(withName: "Videos")
            let videoEntityType = videosEntitySet.entityType
            let labelProperty = videoEntityType.property(withName: "label")
            let contentProperty = videoEntityType.property(withName: "content")
            let query = DataQuery().from(videosEntitySet)
                .filter(labelProperty.equal("Happier")).top(1)
            let video = try service.executeQuery(query).requiredEntity()
            let link = contentProperty.streamLink(from: video)
            let stream = try service.downloadStream(entity: video, link: link)
            let data = try stream.readAndClose()
            assert(BinaryOperator.equal(data, Base16Binary.convert("2E2E2E")))
            assert(OptionalString.hasValue(stream.mediaType, "text/plain"))
        }
    }
}

Lookup an entity set (or singleton entity) by name. If the entity set does not exist it indicates a fundamental implementation problem, therefore a non-catchable FatalException will be thrown, and the app intentionally crashes. The reason behind this drastic behaviour is to avoid mismatch between server and client. It is still possible to avoid the FatalException by looking up entity sets before calling this method like in the following code snippet: Note that OData singleton entities are represented by entity sets where EntitySet.isSingleton is true.

Example checking if an entity set exists

open func checkEntitySetExistsExample() throws -> Void {
    let service = self.service
    if service.metadata.entitySets.containsValue(forKey: "Categories") {
        _ = service.entitySet(withName: "Categories")
    } else {
    }
}

Execute a data method (action or function) in the target system. Actions may have backend side-effects. Functions should not have backend side-effects.

Execute a data query to get data from the target system.

Has service metadata been loaded.

Reload an existing entity from the target system.

Example using proxy classes

open func loadEntityExample() throws -> Void {
    let service = self.service
    let customer = Customer()
    customer.customerID = "ALFKI"
    try service.loadEntity(customer)
    self.showCustomer(customer)
}

Example using dynamic API

open func loadEntityExample() throws -> Void {
    let service = self.service
    let customersEntitySet = service.entitySet(withName: "Customers")
    let customerEntityType = customersEntitySet.entityType
    let customerIDProperty = customerEntityType.property(withName: "CustomerID")
    let customer = EntityValue.ofType(customerEntityType)
    customerIDProperty.setStringValue(in: customer, to: "ALFKI")
    try service.loadEntity(customer)
    self.showCustomer(customer)
}

Load service metadata (if not already loaded).

Load the value of a property into an existing entity. This can be applied to both structural and navigation properties.

Example using proxy classes

open func loadPropertyExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindProxyClient.loadPropertyExample")
    }
    do {
        DebugConsole.traceIn("example.NorthwindProxyClient.loadPropertyExample")
        do {
            let service = self.service
            let query = DataQuery()
                .select(Customer.customerID, Customer.companyName,
                    Customer.contactName)
                .filter(Customer.customerID.equal("ALFKI")
                    .or(Customer.customerID.equal("ANATR")))
            let customers = try service.fetchCustomers(matching: query)
            var countOrders = 0
            for customer in customers {
                self.showCustomer(customer)
                try service.loadProperty(Customer.orders, into: 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 proxy classes (in request batch)

open func loadPropertyInBatchExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindProxyClient.loadPropertyInBatchExample")
    }
    do {
        DebugConsole.traceIn("example.NorthwindProxyClient.loadPropertyInBatchExample")
        do {
            let service = self.service
            let query = DataQuery()
                .select(Customer.customerID, Customer.companyName,
                    Customer.contactName)
                .filter(Customer.customerID.equal("ALFKI")
                    .or(Customer.customerID.equal("ANATR")))
            let customers = try service.fetchCustomers(matching: query)
            let customer1 = customers[0]
            let customer2 = customers[1]
            let query1 = DataQuery().load(customer1, Customer.orders)
            let query2 = DataQuery().load(customer2, Customer.orders)
            let batch = RequestBatch()
            batch.addQuery(query1)
            batch.addQuery(query2)
            try service.processBatch(batch)
            let result1 = batch.queryResult(for: query1)
            let result2 = batch.queryResult(for: query2)
            let orders1 = try Order.array(from: result1.entityList())
            let orders2 = try Order.array(from: result2.entityList())
            assert(orders1.count != 0)
            assert(orders2.count != 0)
            customer1.orders = orders1
            customer2.orders = orders2
        }
    }
}

Example using dynamic API

open func loadPropertyExample() 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)
        .filter(customerIDProperty.equal("ALFKI").or(customerIDProperty.equal("ANATR")))
    let customers = try service.executeQuery(query).entityList()
    var countOrders = 0
    for customer in customers {
        self.showCustomer(customer)
        try service.loadProperty(ordersProperty, into: 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)
}

Example using dynamic API (in request batch)

open func loadPropertyInBatchExample() throws -> Void {
    defer {
        DebugConsole.traceOut("example.NorthwindClient.loadPropertyInBatchExample")
    }
    do {
        DebugConsole.traceIn("example.NorthwindClient.loadPropertyInBatchExample")
        do {
            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 query = DataQuery()
                .select(customerIDProperty, companyNameProperty,
                    contactNameProperty)
                .from(customersEntitySet)
                .filter(customerIDProperty.equal("ALFKI")
                    .or(customerIDProperty.equal("ANATR")))
            let customers = try service.executeQuery(query).entityList()
            let customer1 = customers.item(at: 0)
            let customer2 = customers.item(at: 1)
            let query1 = DataQuery().load(customer1, ordersProperty)
            let query2 = DataQuery().load(customer2, ordersProperty)
            let batch = RequestBatch()
            batch.addQuery(query1)
            batch.addQuery(query2)
            try service.processBatch(batch)
            let result1 = batch.queryResult(for: query1)
            let result2 = batch.queryResult(for: query2)
            let orders1 = try result1.entityList()
            let orders2 = try result2.entityList()
            assert(orders1.length != 0)
            assert(orders2.length != 0)
            ordersProperty.setEntityList(in: customer1, to: orders1)
            ordersProperty.setEntityList(in: customer2, to: orders2)
        }
    }
}

Service metadata.

Service name.