Performing a calculation on a group of database objects may be a complex task. For example, to calculate the sum of all orders for a customer would require retrieving all customer’s orders, iterating over them to calculate the mathematical sum of all amounts. This was yesterday! As of Backendless 4.4.0, you can use aggregate functions to calculate the average, sum, maximum and minimum values for a collection of objects without retrieving them from the server. Additionally, the system supports calculating object count for all records in the database or a record subset.
To use an aggregate function, simply request a property in a data retrieval request in the following format (the example below is for calculating the sum for the orderAmount column):
|
1 |
GET https://api.backendless.com/<app id>/<REST API key>/data/Orders?props=Sum(orderAmount) |
The returned object includes the sum property with the calculated value:
|
1 2 3 4 5 6 |
[ { "sum": 14507795640, "___class": "Orders" } ] |
The name of the property can be modified by assigning an alias (using %20 to replace the spaces in the URL):
|
1 |
GET https://api.backendless.com/<app id>/<REST API key>/data/Orders?props=Sum(orderAmount)%20as%20totalAmount |
The result contains a value for the property named after the alias:
|
1 2 3 4 5 6 |
[ { "totalAmount": 14507795640, "___class": "Orders" } ] |
Grouping Results
Results can be grouped by a column. The column could be either in the same table or a related one. For example, the following request retrieves the sum of all orders grouped by related country:
|
1 2 |
GET https://api.backendless.com/<app id>/<REST API key>/data/Orders? props=Sum(orderAmount)&groupBy=relatedCountry.countryName |
Unlike the response above, the result for this query includes a collection of objects, each containing the sum for a related country:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
[ { "sum": 1324231, "countryName": "Italy", "___class": "Orders" }, { "sum": 5675675, "countryName": "France", "___class": "Orders" }, { "sum": 2342234, "countryName": "Ireland", "___class": "Orders" } ] |
It is also possible to apply a filter on the grouped values. This can be done using the having clause. For example, the request below retrieves only the groups of countries where the total order amount is greater than 10000:
|
1 2 3 4 |
GET https://api.backendless.com/<app id>/<REST API key>/data/Orders? props=Sum(orderAmount)& groupBy=relatedCountry.countryName& having=Sum(orderAmount)>10000 |
For more information about aggregate functions see the Backendless API documentation:
- Android: https://backendless.com/docs/android/doc.html#data_aggregating_functions
- iOS: https://backendless.com/docs/ios/doc.html#data_aggregating_functions
- JS: https://backendless.com/docs/js/doc.html#data_aggregating_functions
- REST: https://backendless.com/docs/rest/doc.html#data_aggregating_functions
Backendless supports two approaches for saving data objects in the database: class-based approach and map/dictionary approach. With the class approach, you declare a class, instances of which represent individual objects stored in the database. With the introduction of Swift 4, it is important to add a new attribute to your Swift 4 classes. For example:
|
1 2 3 4 5 6 7 8 |
@objcMembers class Contact : NSObject { var objectId : String? var age : Int = 0 var title : String? var name : String? var phone : String? } |
Notice the @objcMembers attribute declaration in the class. The attribute allows Backendless SDK (which is written in Objective-C) to access object’s property values. If you do not add the attribute, objects retrieved from the server will not have properties initialized with the values.
It is also possible to set a project-wide configuration property. When you do that, you do not need to add @objcMembers attribute, however, you will see warnings when the project is built. To set the project property, open “Build Settings” for the project target, locate “Swift 3 @objc inference” and set it to “On”.
For additional information on the @objcMembers attribute, see the “inheriting from Objective-C Classes” section in the Swift 4 programming guide.
We supported Google Sign in for a while, however, the feature was not properly documented. Not anymore )) The documentation has been updated for Android and iOS SDKs. Using the “Login with Google” function, an app can provide a way for the users to login using their Google credentials. Once a user is authenticated, Backendless creates an internal account and starts a logged-in session.
See Backendless documentation for details:
The recording of the “Push Notifications” webinar which we conducted earlier this month is now available in our YouTube channel. You watch the webinar below or on the Webinars page on our website. In the webinar we reviewed the process of setting up an Android and an iOS apps as well as the backend to be able to register device and receive push notifications.
We conducted a webinar titled “Backendless Core Concepts” for ex-Parses last week. A recording of the webinar is now available. The video should be helpful not only if you’re coming from Parse, but for anyone who is starting their journey with Backendless. The webinar reviewed the concepts of Backendless User and Data services. Specifically, we focused on:
- user properties
- setting up user relations
- registering a user
- registering a user with custom properties
- configuring a data model
- code-driven schema creation
- data relations
- a brief overview of Cloud Code
Video broadcasting and streaming is one of the coolest features of Backendless. Our Media Service API enables client-server functionality for working with live and on-demand audio and video content. A mobile application which uses the Media Service API can broadcast audio and video from the device’s cameras and microphone. Backendless automatically handles streaming of the received media content to other clients or recording of the content on the server. The API can also support the capability to stream a pre-recorded (on-demand) content managed by the Media Service. More details about these features are available in the Media Service documentation.
This post describes how to build an iOS application using the Swift language. The app will record a video on the server and then subsequently play it back.
We just pushed a new release to our production servers. The release includes multiple new features and a ton of improvements. Below is a summary of what went into the release. There will be a blog post with a video providing an in-depth review of each new feature:
CocoaPods manages library dependencies for your Xcode projects.
The dependencies for your projects are specified in a single text file called “Podfile”. CocoaPods resolves dependencies between libraries, fetches necessary code and links it together in an Xcode workspace to build your project.
Establishing relations between user objects and other entities in an application is a very common use case. This post describes various scenarios and shows sample code using Backendless SDK for Java/Android and Backendless SDK for iOS. Make sure the version of the client libraries are at least 1.5 for Backendless Java/Android and 1.11 for iOS.
One of the coolest features included into our November release is support for mobile audio/video conferencing, screen and gesture sharing. This functionality is made possible through our partnership with ShowKit – a mobile SDK for iOS and other environments. Integration with Backendless makes it trivially easy to enable the users of your mobile app to conference with each other and share app screens. Complete documentation describing the integration is available in the Backendless Media Service API doc as well as ShowKit’s website.
