Data Storage Guide for Java

With the Data Storage service, you can have your app persist data on the cloud and query them at any time. The code below shows how you can create an object and store it into the cloud:

// Create an object
LCObject todo = new LCObject("Todo");

// Set values of fields
todo.put("title",   "R&D Weekly Meeting");
todo.put("content", "All team members, Tue 2pm");

// Save the object to the cloud
todo.saveInBackground().subscribe(new Observer<LCObject>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(LCObject todo) {
        // Execute any logic that should take place after the object is saved
        System.out.println("Object saved. objectId: " + todo.getObjectId());
    }
    public void onError(Throwable throwable) {
        // Execute any logic that should take place if the save fails
    }
    public void onComplete() {}
});

The SDK designed for each language interacts with the same REST API via HTTPS, offering fully functional interfaces for you to manipulate the data in the cloud.

Installing SDK

See Installing Java SDK.

Objects

`LCObject`

The objects on the cloud are built around LCObject. Each LCObject contains key-value pairs of JSON-compatible data. This data is schema-free, which means that you don't need to specify ahead of time what keys exist on each LCObject. Simply set whatever key-value pairs you want, and our backend will store them.

For example, the LCObject storing a simple todo item may contain the following data:

title:      "Email Linda to Confirm Appointment",
isComplete: false,
priority:   2,
tags:       ["work", "sales"]

Data Types

LCObject supports a wide range of data types to be used for each field, including common ones like String, Number, Boolean, Object, Array, and Date. You can nest objects in JSON format to store more structured data within a single Object or Array field.

Special data types supported by LCObject include Pointer and File, which are used to store a reference to another LCObject and binary data respectively.

LCObject also supports GeoPoint, a special data type you can use to store location-based data. See GeoPoints for more details.

Some examples:

// Basic types
boolean bool = true;
int number = 2018;
String string = number + " Top Hits";
Date date = new Date();
byte[] data = "Hello world!".getBytes();
ArrayList<Object> arrayList = new ArrayList<>();
arrayList.add(number);
arrayList.add(string);
HashMap<Object, Object> hashMap = new HashMap<>();
hashMap.put("number", number);
hashMap.put("string", string);

// Create an object
LCObject testObject = new LCObject("TestObject");
testObject.put("testBoolean",   bool);
testObject.put("testInteger",   number);
testObject.put("testDate",      date);
testObject.put("testData",      data);
testObject.put("testArrayList", arrayList);
testObject.put("testHashMap",   hashMap);
testObject.save();

We do not recommend storing large pieces of binary data like images or documents with LCObject using byte[]. The size of each LCObject should not exceed 128 KB. We recommend using LCFile for storing images, documents, and other types of files. To do so, create LCFile objects and assign them to fields of LCObject. See Files for details.

Keep in mind that our backend stores dates in UTC format and the SDK will convert them to local times upon retrieval.

The date values displayed on Dashboard > Data Storage > Data are also converted to match your operating system's time zone. The only exception is that when you retrieve these date values through our REST API, they will remain in UTC format. You can manually convert them using appropriate time zones when necessary.

To learn about how you can protect the data stored on the cloud, see Data Security.

Creating Objects

The code below creates a new instance of LCObject with class Todo:

LCObject todo = new LCObject("Todo");

The constructor takes a class name as a parameter so that the cloud knows the class you are using to create the object. A class is comparable to a table in a relational database. A class name starts with a letter and can only contain numbers, letters, and underscores.

Saving Objects

The following code saves a new object with class Todo to the cloud:

// Create an object
LCObject todo = new LCObject("Todo");

// Set values of fields
todo.put("title", "Sign up for Marathon");
todo.put("priority", 2);

// Save the object to the cloud
todo.saveInBackground().subscribe(new Observer<LCObject>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(LCObject todo) {
        // Execute any logic that should take place after the object is saved
        System.out.println("Object saved. objectId: " + todo.getObjectId());
    }
    public void onError(Throwable throwable) {
        // Execute any logic that should take place if the save fails
    }
    public void onComplete() {}
});

To make sure the object is successfully saved, take a look at Dashboard > Data Storage > Data > Todo in your app. You should see a new entry of data with something like this when you click on its objectId:

{
  "title": "Sign up for Marathon",
  "priority": 2,
  "ACL": {
    "*": {
      "read": true,
      "write": true
    }
  },
  "objectId": "582570f38ac247004f39c24b",
  "createdAt": "2017-11-11T07:19:15.549Z",
  "updatedAt": "2017-11-11T07:19:15.549Z"
}

You don't have to create or set up a new class called Todo in Dashboard > Data Storage > Data before running the code above. If the class doesn't exist, it will be automatically created.

Several built-in fields are provided by default which you don't need to specify in your code:

Built-in Field	Type	Description
`objectId`	`String`	A unique identifier for each saved object.
`ACL`	`LCACL`	Access Control List, a special object defining the read and write permissions of other people.
`createdAt`	`Date`	The time the object was created.
`updatedAt`	`Date`	The time the object was last modified.

Each of these fields is filled in by the cloud automatically and doesn't exist on the local LCObject until a save operation has been completed.

Field names, or keys, can only contain letters, numbers, and underscores. A custom key can neither start with double underscores __, nor be identical to any system reserved words or built-in field names (ACL, className, createdAt, objectId, and updatedAt) regardless of letter cases.

Values can be strings, numbers, booleans, or even arrays and dictionaries — anything that can be JSON-encoded. See Data Types for more information.

We recommend that you adopt CamelCase naming convention to NameYourClassesLikeThis and nameYourKeysLikeThis, which keeps your code more readable.

Retrieving Objects

If an LCObject is already in the cloud, you can retrieve it using its objectId with the following code:

LCQuery<LCObject> query = new LCQuery<>("Todo");
query.getInBackground("582570f38ac247004f39c24b").subscribe(new Observer<LCObject>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(LCObject todo) {
        // todo is the instance of the Todo object with objectId 582570f38ac247004f39c24b
        String title    = todo.getString("title");
        int priority    = todo.getInt("priority");

        // Get special properties
        String objectId = todo.getObjectId();
        Date updatedAt  = todo.getUpdatedAt();
        Date createdAt  = todo.getCreatedAt();
    }
    public void onError(Throwable throwable) {}
    public void onComplete() {}
});

If you try to access a field or property that doesn't exist, the SDK will not raise an error. Instead, it will return null.

Refreshing Objects

If you need to refresh a local object with the latest version of it in the cloud, call the fetchInBackground method on it:

LCObject todo = LCObject.createWithoutData("Todo", "582570f38ac247004f39c24b");
todo.fetchInBackground().subscribe(new Observer<LCObject>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(LCObject todo) {
        // todo is refreshed
    }
    public void onError(Throwable throwable) {}
    public void onComplete() {}
});

Keep in mind that any unsaved changes made to the object prior to calling fetchInBackground will be discarded. To avoid this, you have the option to provide a list of keys when calling the method so that only the fields being specified are retrieved and refreshed (including special built-in fields such as objectId, createdAt, and updatedAt). Changes made to other fields will remain intact.

LCObject todo = LCObject.createWithoutData("Todo", "582570f38ac247004f39c24b");
String keys = "priority, location";
todo.fetchInBackground(keys).subscribe(new Observer<LCObject>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(LCObject todo) {
        // Only priority and location will be retrieved and refreshed
    }
    public void onError(Throwable throwable) {}
    public void onComplete() {}
});

Updating Objects

To update an existing object, assign the new data to each field and call the saveInBackground method. For example:

LCObject todo = LCObject.createWithoutData("Todo", "582570f38ac247004f39c24b");
todo.put("content", "Weekly meeting has been rescheduled to Wed 3pm for this week.");
todo.saveInBackground().subscribe(new Observer<LCObject>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(LCObject savedTodo) {
        System.out.println("Saved.");
    }
    public void onError(Throwable throwable) {
        System.out.println("Failed to save.");
    }
    public void onComplete() {}
});;

The cloud automatically figures out which data has changed and only the fields with changes will be sent to the cloud. The fields you didn't update will remain intact.

Updating Data Conditionally

By passing in a query option when saving, you can specify conditions on the save operation so that the object can be updated atomically only when those conditions are met. If no object matches the conditions, the cloud will return error 305 to indicate that there was no update taking place.

For example, in the class Account there is a field called balance, and there are multiple incoming requests that want to modify this field. Since an account cannot have a negative balance, we can only allow a request to update the balance when the amount requested is lower than or equal to the balance:

LCObject account = LCObject.createWithoutData("Account", "5745557f71cfe40068c6abe0");
// Atomically decrease balance by 100
final int amount = -100;
account.increment("balance", amount);
// Add the condition
LCSaveOption option = new LCSaveOption();
option.query(new LCQuery<>("Account").whereGreaterThanOrEqualTo("balance", -amount));
// Return the latest data in the cloud upon completion.
// All the fields will be returned if the object is new,
// otherwise only fields with changes will be returned.
option.setFetchWhenSave(true);
account.saveInBackground(option).subscribe(new Observer<LCObject>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(LCObject account) {
        System.out.println("Balance: " + account.get("balance"));
    }
    public void onError(Throwable throwable) {
        System.out.println("Insufficient balance. Operation failed!");
    }
    public void onComplete() {}
});

The query option only works for existing objects. In other words, it does not affect objects that haven't been saved to the cloud yet.

The benefit of using the query option instead of combining LCQuery and LCObject shows up when you have multiple clients trying to update the same field at the same time. The latter way is more cumbersome and may lead to potential inconsistencies.

Updating Counters

Take Twitter as an example, we need to keep track of how many Likes and Retweets a tweet has gained so far. Since a Like or Retweet action can be triggered simultaneously by multiple clients, saving objects with updated values directly can lead to inaccurate results. To make sure that the total number is stored correctly, you can atomically increase (or decrease) the value of a number field:

post.increment("likes", 1);

You can specify the amount of increment (or decrement) by providing an additional argument. If the argument is not provided, 1 is used by default.

Updating Arrays

There are several operations that can be used to atomically update an array associated with a given key:

add() appends the given object to the end of an array.
addUnique() adds the given object into an array only if it is not in it. The object will be inserted at a random position.
removeAll() removes all instances of the given object from an array.

For example, Todo has a field named alarms for keeping track of the times at which a user wants to be alerted. The following code adds the times to the alarms field:

Date getDateWithDateString(String dateString) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date date = dateFormat.parse(dateString);
    return date;
}

Date alarm1 = getDateWithDateString("2018-04-30 07:10:00");
Date alarm2 = getDateWithDateString("2018-04-30 07:20:00");
Date alarm3 = getDateWithDateString("2018-04-30 07:30:00");

LCObject todo = new LCObject("Todo");
todo.addAllUnique("alarms", Arrays.asList(alarm1, alarm2, alarm3));
todo.save();

Deleting Objects

The following code deletes a Todo object from the cloud:

LCObject todo = LCObject.createWithoutData("Todo", "582570f38ac247004f39c24b");
todo.deleteInBackground().subscribe(new Observer<LCNull>() {
    @Override
    public void onSubscribe(@NonNull Disposable d) {}

    @Override
    public void onNext(LCNull response) {
        // succeed to delete a todo.
    }

    @Override
    public void onError(@NonNull Throwable e) {
        System.out.println("failed to delete a todo: " + e.getMessage());
    }

    @Override
    public void onComplete() {}
});

Removing data from the cloud should always be dealt with great caution as it may lead to non-recoverable data loss. We strongly advise that you read ACL Guide to understand the risks thoroughly. You should also consider implementing class-level, object-level, and field-level permissions for your classes in the cloud to guard against unauthorized data operations.

Batch Processing

// Batch create and update
saveAll()
saveAllInBackground()

// Batch delete
deleteAll()
deleteAllInBackground()

// Batch fetch
fetchAll()
fetchAllInBackground()

The following code sets isComplete of all Todo objects to be true:

LCQuery<LCObject> query = new LCQuery<>("Todo");
query.findInBackground().subscribe(new Observer<List<LCObject>>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(List<LCObject> todos) {
        // Get a collection of todos to work on
        for (LCObject todo : todos) {
            // Update value
            todo.put("isComplete", true);
        }
        // Save all at once
        LCObject.saveAll(todos);
    }
    public void onError(Throwable throwable) {}
    public void onComplete() {}
});

Although each function call sends multiple operations in one single network request, saving operations and fetching operations are billed as separate API calls for each object in the collection, while deleting operations are billed as a single API call.

Running in the Background

You may have noticed from the examples above that we have been accessing the cloud asynchronously in our code. The methods with names like xxxxInBackground are provided for you to implement asynchronous calls so that your main thread will not be blocked.

Storing Data Locally

Most of the operations for saving objects can be executed immediately and the program will be notified once the operation is done. However, if the program does not need to know when the operation is done, you can use saveEventually instead.

The benefit of this function is that if the device is offline, saveEventually will cache the data locally and send them to the server once the device gets online again. If the app is closed before the device gets online, the SDK will try to send the data to the server when the app is opened again.

It is safe to call saveEventually (or deleteEventually) multiple times since all the operations will be performed in the order they are initiated.

Data Models

Objects may have relationships with other objects. For example, in a blogging application, a Post object may have relationships with many Comment objects. The Data Storage service supports three kinds of relationships, including one-to-one, one-to-many, and many-to-many.

One-to-One and One-to-Many Relationships

One-to-one and one-to-many relationships are modeled by saving LCObject as a value in the other object. For example, each Comment in a blogging app might correspond to one Post.

The following code creates a new Post with a single Comment:

// Create a post
LCObject post = new LCObject("Post");
post.put("title", "I am starving!");
post.put("content", "Hmmm, where should I go for lunch?");

// Create a comment
LCObject comment = new LCObject("Comment");
comment.put("content", "How about KFC?");

// Add the post as a property of the comment
comment.put("parent", post);

// This will save both post and comment
comment.save();

Internally, the backend will store the referred-to object with the Pointer type in just one place in order to maintain consistency. You can also link objects using their objectIds like this:

LCObject post = LCObject.createWithoutData("Post", "57328ca079bc44005c2472d0");
comment.put("post", post);

See Relational Queries for instructions on how to query relational data.

Many-to-Many Relationships

The easiest way to model many-to-many relationships is to use arrays. In most cases, using arrays helps you reduce the number of queries you need to make and leads to better performance. However, if additional properties need to be attached to the relationships between two classes, using join tables would be a better choice. Keep in mind that the additional properties are used to describe the relationships between classes rather than any single class.

We recommend you to use join tables if the total number of objects of any class exceeds 100.

Serialization and Deserialization

If you need to pass an LCObject to a method as an argument, you may want to first serialize the object to avoid certain problems. You can use the following ways to serialize and deserialize LCObjects.

Serialization:

LCObject todo = new LCObject("Todo"); // Create object
todo.put("title", "Sign up for Marathon"); // Set title
todo.put("priority", 2); // Set priority
todo.put("owner", LCUser.getCurrentUser()); // A Pointer pointing to the current user
String serializedString = todo.toString();

Deserialization:

LCObject deserializedObject = LCObject.parseLCObject(serializedString);
deserializedObject.save(); // Save to the cloud

Queries

We've already seen how you can retrieve a single object from the cloud with LCObject, but it doesn't seem to be powerful enough when you need to retrieve multiple objects that match certain conditions at once. In such a situation, LCQuery would be a more efficient tool you can use.

Basic Queries

The general steps of performing a basic query include:

Creating LCQuery.
Putting conditions on it.
Retrieving an array of objects matching the conditions.

The code below retrieves all Student objects whose lastName is Smith:

LCQuery<LCObject> query = new LCQuery<>("Student");
query.whereEqualTo("lastName", "Smith");
query.findInBackground().subscribe(new Observer<List<LCObject>>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(List<LCObject> students) {
        // students is an array of Student objects satisfying conditions
    }
    public void onError(Throwable throwable) {}
    public void onComplete() {}
});

Query Constraints

There are several ways to put constraints on the objects found by LCObject.

The code below filters out objects with Jack as firstName:

query.whereNotEqualTo("firstName", "Jack");

For sortable types like numbers and strings, you can use comparisons in queries:

// Restricts to age < 18
query.whereLessThan("age", 18);

// Restricts to age <= 18
query.whereLessThanOrEqualTo("age", 18);

// Restricts to age > 18
query.whereGreaterThan("age", 18);

// Restricts to age >= 18
query.whereGreaterThanOrEqualTo("age", 18);

You can apply multiple constraints to a single query, and objects will only be in the results if they match all of the constraints. In other words, it's like concatenating constraints with AND:

query.whereEqualTo("firstName", "Jack");
query.whereGreaterThan("age", 18);

You can limit the number of results by setting limit (defaults to 100):

// Get at most 10 results
query.limit(10);

For performance reasons, the maximum value allowed for limit is 1000, meaning that the cloud would only return 1,000 results even if it is set to be greater than 1000.

If you need exactly one result, you may use getFirstInBackground for convenience:

LCQuery<LCObject> query = new LCQuery<>("Todo");
query.whereEqualTo("priority", 2);
query.getFirstInBackground().subscribe(new Observer<LCObject>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(LCObject todo) {
        // todo is the first Todo object satisfying conditions
    }
    public void onError(Throwable throwable) {}
    public void onComplete() {}
});

You can skip a certain number of results by setting skip:

// Skip the first 20 results
query.skip(20);

You can implement pagination in your app by using skip together with limit:

LCQuery<LCObject> query = new LCQuery<>("Todo");
query.whereEqualTo("priority", 2);
query.limit(10);
query.skip(20);

Keep in mind that the higher the skip goes, the slower the query will run. You may consider using createdAt or updatedAt (which are indexed) to set range boundaries for large datasets to make queries more efficient. You may also use the last value returned from an auto-increment field along with limit for pagination.

For sortable types, you can control the order in which results are returned:

// Sorts the results in ascending order by the createdAt property
query.orderByAscending("createdAt");

// Sorts the results in descending order by the createdAt property
query.orderByDescending("createdAt");

You can even attach multiple sorting rules to a single query:

query.addAscendingOrder("priority");
query.addDescendingOrder("createdAt");

To retrieve objects that have or do not have particular fields:

// Finds objects that have the "images" field
query.whereExists("images");

// Finds objects that don't have the 'images' field
query.whereDoesNotExist("images");

You can restrict the fields returned by providing a list of keys with selectKeys. The code below retrieves todos with only the title and content fields (and also special built-in fields including objectId, createdAt, and updatedAt):

LCQuery<LCObject> query = new LCQuery<>("Todo");
query.selectKeys(Arrays.asList("title", "content"));
query.getFirstInBackground().subscribe(new Observer<LCObject>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(LCObject todo) {
        String title = todo.getString("title"); // √
        String content = todo.getString("content"); // √
        String notes = todo.getString("notes"); // An error will occur
    }
    public void onError(Throwable throwable) {}
    public void onComplete() {}
});

You can add a minus prefix to the attribute name for inverted selection. For example, if you do not care about the post author, use -author. The inverted selection also applies to preserved attributes and can be used with dot notations, e.g., -pubUser.createdAt.

The unselected fields can be fetched later with fetchInBackground. See Refreshing Objects.

Queries on String Values

Use whereStartsWith to restrict to string values that start with a particular string. Similar to a LIKE operator in SQL, it is indexed so it is efficient for large datasets:

LCQuery<LCObject> query = new LCQuery<>("Todo");
// SQL equivalent: title LIKE 'lunch%'
query.whereStartsWith("title", "lunch");

Use whereContains to restrict to string values that contain a particular string:

LCQuery<LCObject> query = new LCQuery<>("Todo");
// SQL equivalent: title LIKE '%lunch%'
query.whereContains("title", "lunch");

Unlike whereStartsWith, whereContains can't take advantage of indexes, so it is not encouraged to be used for large datasets.

Please note that both whereStartsWith and whereContains perform case-sensitive matching, so the examples above will not look for string values containing Lunch, LUNCH, etc.

If you are looking for string values that do not contain a particular string, use whereMatches with regular expressions:

LCQuery<LCObject> query = new LCQuery<>("Todo");
// "title" without "ticket" (case-insensitive)
query.whereMatches("title", "^((?!ticket).)*$", "i");

However, performing queries with regular expressions as constraints can be very expensive, especially for classes with over 100,000 records. The reason behind this is that queries like this can't take advantage of indexes and will lead to exhaustive scanning of the whole dataset to find the matching objects. We recommend that you take a look at our In-App Searching feature, a full-text search solution we provide to improve your app's searching ability and user experience.

If you are facing performance issues with queries, please refer to Optimizing Performance for possible workarounds and best practices.

Queries on Array Values

The code below looks for all the objects with work as an element of its array field tags:

query.whereEqualTo("tags", "work");

To look for objects whose array field tags contains three elements:

query.whereSizeEqual("tags", 3);

You can also look for objects whose array field tags contains work, sales, and appointment:

query.whereContainsAll("tags", Arrays.asList("work", "sales", "appointment"));

To retrieve objects whose field matches any one of the values in a given list, you can use whereContainedIn instead of performing multiple queries. The code below constructs a query that retrieves todo items with priority to be 1 or 2:

// Single query
LCQuery<LCObject> priorityOneOrTwo = new LCQuery<>("Todo");
priorityOneOrTwo.whereContainedIn("priority", Arrays.asList(1, 2));
// Mission completed :)

// ---------------
//       vs.
// ---------------

// Multiple queries
final LCQuery<LCObject> priorityOne = new LCQuery<>("Todo");
priorityOne.whereEqualTo("priority", 1);

final LCQuery<LCObject> priorityTwo = new LCQuery<>("Todo");
priorityTwo.whereEqualTo("priority", 2);

LCQuery<LCObject> priorityOneOrTwo = LCQuery.or(Arrays.asList(priorityOne, priorityTwo));
// Kind of verbose :(

Conversely, you can use whereNotContainedIn if you want to retrieve objects that do not match any of the values in a list.

Relational Queries

There are several ways to perform queries for relational data. To retrieve objects whose given field matches a particular LCObject, you can use whereEqualTo just like how you use it for other data types. For example, if each Comment has a Post object in its post field, you can fetch all the comments for a particular Post with the following code:

LCObject post = LCObject.createWithoutData("Post", "57328ca079bc44005c2472d0");
LCQuery<LCObject> query = new LCQuery<>("Comment");
query.whereEqualTo("post", post);
query.findInBackground().subscribe(new Observer<List<LCObject>>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(List<LCObject> comments) {
        // comments contains the comments for the post
    }
    public void onError(Throwable throwable) {}
    public void onComplete() {}
});

To retrieve objects whose given field contains an LCObject that matches a different query, you can use whereMatchesQuery. The code below constructs a query that looks for all the comments for posts with images:

LCQuery<LCObject> innerQuery = new LCQuery<>("Post");
innerQuery.whereExists("image");

LCQuery<LCObject> query = new LCQuery<>("Comment");
query.whereMatchesQuery("post", innerQuery);

To retrieve objects whose given field does not contain an LCObject that matches a different query, use whereDoesNotMatchQuery instead.

Sometimes you may need to look for related objects from different classes without extra queries. In such situations, you can use include on the same query. The following code retrieves the last 10 comments together with the posts related to them:

LCQuery<LCObject> query = new LCQuery<>("Comment");

// Retrieve the most recent ones
query.orderByDescending("createdAt");

// Only retrieve the last 10
query.limit(10);

// Include the related post together with each comment
query.include("post");

query.findInBackground().subscribe(new Observer<List<LCObject>>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(List<LCObject> comments) {
        // comments contains the last 10 comments including the post associated with each
        for (LCObject comment : comments) {
            // This does not require a network access
            LCObject post = comment.getLCObject("post");
        }
    }
    public void onError(Throwable throwable) {}
    public void onComplete() {}
});

Caveats about Inner Queries

The Data Storage service is not built on relational databases, which makes it impossible to join tables while querying. For the relational queries mentioned above, what we would do is to perform an inner query first (with 100 as the default limit and 1000 as the maximum) and then insert the result from this query into the outer query. If the number of records matching the inner query exceeds the limit and the outer query contains other constraints, the amount of the records returned in the end could be zero or less than your expectation since only the records within the limit would be inserted into the outer query.

The following actions can be taken to solve the problem:

Make sure the number of records in the result of the inner query is no more than 100. If it is between 100 and 1,000, set 1000 as the limit of the inner query.
Create redundancy for the fields being queried by the inner query on the table for the outer query.
Repeat the same query with different skip values until all the records are gone through (performance issue could occur if the value of skip gets too big).

Counting Objects

If you just need to count how many objects match a query but do not need to retrieve the actual objects, use countInBackground instead of findInBackground. For example, to count how many todos have been completed:

LCQuery<LCObject> query = new LCQuery<>("Todo");
query.whereEqualTo("isComplete", true);
query.countInBackground().subscribe(new Observer<Integer>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(Integer count) {
        System.out.println(count + " todos completed.");
    }
    public void onError(Throwable throwable) {}
    public void onComplete() {}
});

Compound Queries

Compound queries can be used if complex query conditions need to be specified. A compound query is a logical combination (OR or AND) of subqueries.

Note that we do not support GeoPoint or non-filtering constraints (e.g. near, withinGeoBox, limit, skip, ascending, descending, include) in the subqueries of a compound query.

OR-ed Query Constraints

An object will be returned as long as it fulfills any one of the subqueries. The code below constructs a query that looks for all the todos that either have priorities higher than or equal to 3, or are already completed:

final LCQuery<LCObject> priorityQuery = new LCQuery<>("Todo");
priorityQuery.whereGreaterThanOrEqualTo("priority", 3);

final LCQuery<LCObject> isCompleteQuery = new LCQuery<>("Todo");
isCompleteQuery.whereEqualTo("isComplete", true);

LCQuery<LCObject> query = LCQuery.or(Arrays.asList(priorityQuery, isCompleteQuery));

Queries regarding GeoPoint cannot be present among OR-ed queries.

AND-ed Query Constraints

The effect of using AND-ed query is the same as adding constraints to LCQuery. The code below constructs a query that looks for all the todos that are created between 2016-11-13 and 2016-12-02:

Date getDateWithDateString(String dateString) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
    Date date = dateFormat.parse(dateString);
    return date;
}

final LCQuery<LCObject> startDateQuery = new LCQuery<>("Todo");
startDateQuery.whereGreaterThanOrEqualTo("createdAt", getDateWithDateString("2016-11-13"));

final LCQuery<LCObject> endDateQuery = new LCQuery<>("Todo");
endDateQuery.whereLessThan("createdAt", getDateWithDateString("2016-12-03"));

LCQuery<LCObject> query = LCQuery.and(Arrays.asList(startDateQuery, endDateQuery));

While using an AND-ed query by itself doesn't bring anything new compared to a basic query, to combine two or more OR-ed queries, you have to use AND-ed queries:

Date getDateWithDateString(String dateString) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
    Date date = dateFormat.parse(dateString);
    return date;
}

final LCQuery<LCObject> createdAtQuery = new LCQuery<>("Todo");
createdAtQuery.whereGreaterThanOrEqualTo("createdAt", getDateWithDateString("2018-04-30"));
createdAtQuery.whereLessThan("createdAt", getDateWithDateString("2018-05-01"));

final LCQuery<LCObject> locationQuery = new LCQuery<>("Todo");
locationQuery.whereDoesNotExist("location");

final LCQuery<LCObject> priority2Query = new LCQuery<>("Todo");
priority2Query.whereEqualTo("priority", 2);

final LCQuery<LCObject> priority3Query = new LCQuery<>("Todo");
priority3Query.whereEqualTo("priority", 3);

LCQuery<LCObject> priorityQuery = LCQuery.or(Arrays.asList(priority2Query, priority3Query));
LCQuery<LCObject> timeLocationQuery = LCQuery.or(Arrays.asList(locationQuery, createdAtQuery));
LCQuery<LCObject> query = LCQuery.and(Arrays.asList(priorityQuery, timeLocationQuery));

Optimizing Performance

There are several factors that could lead to potential performance issues when you conduct a query, especially when more than 100,000 records are returned at a time. We are listing some common ones here so you can design your apps accordingly to avoid them:

Querying with "not equal to" or "not include" (index will not work)
Querying on strings with a wildcard at the beginning of the pattern (index will not work)
Using count with conditions (all the entries will be gone through)
Using skip for a large number of entries (all the entries that need to be skipped will be gone through)
Sorting without an index (querying and sorting cannot share a composite index unless the conditions used on them are both covered by the same one)
Querying without an index (the conditions used on the query cannot share a composite index unless all of them are covered by the same one; additional time will be consumed if excessive data falls under the uncovered conditions)

LiveQuery

LiveQuery is, as its name implies, derived from LCQuery but has enhanced capability. It allows you to automatically synchronize data changes from one client to other clients without writing complex code, making it suitable for apps that need real-time data.

Suppose you are building an app that allows multiple users to edit the same file at the same time. LCQuery would not be an ideal tool since it is based on a pull model and you cannot know when to query from the cloud to get the updates.

To solve this problem, we introduced LiveQuery. This tool allows you to subscribe to the LCQuerys you are interested in. Once subscribed, the cloud will notify clients by generating event messages whenever LCObjects that match the LCQuery are created or updated, in real-time.

Behind the scenes, we use WebSocket connections to have clients and the cloud communicate with each other and maintain the subscription status of clients. In most cases, it isn't necessary to deal with the WebSocket connections directly, so we developed a simple API to help you focus on your business logic rather than technical implementations.

Initializing LiveQuery

To use LiveQuery in your app, go to Dashboard > Data Storage > Settings and check the Enable LiveQuery option under the Security section. Make sure the module for instant messaging is added to AndroidManifest.xml:

<service android:name="cn.leancloud.push.PushService"/>
<receiver android:name="cn.leancloud.push.LCBroadcastReceiver">
  <intent-filter>
    <action android:name="android.intent.action.BOOT_COMPLETED"/>
    <action android:name="android.intent.action.USER_PRESENT"/>
    <action android:name="android.net.conn.CONNECTIVITY_CHANGE" />
  </intent-filter>
</receiver>

See Installing SDK for more details.

Demo

We’ve made a demo app called “LeanTodo” which shows the functionality of LiveQuery. If you’d like to try it:

Go to https://leancloud.github.io/leantodo-vue/, enter a username and a password, and then hit “Signup”.
Open the same URL on a different device, enter the same credentials, and hit “Login”.
Create, edit, or delete some items on one device and watch what happens on the other one.

Creating a Subscription

To make a query live, create an LCQuery object, put conditions on it if there are any, and then subscribe to events:

LCQuery<LCObject> query = new LCQuery<>("Todo");
query.whereEqualTo("isComplete", true);
LCLiveQuery liveQuery = LCLiveQuery.initWithQuery(query);
liveQuery.subscribeInBackground(new LCLiveQuerySubscribeCallback() {
    @Override
    public void done(LCException e) {
        if (e == null) {
            // Subscribed
        }
    }
});

You can't use subqueries or restrict fields being returned when using LiveQuery.

Now you will be able to receive updates related to LCObject. If a Todo object is created by another client with Update Portfolio as title, the following code can get the new Todo for you:

LCQuery<LCObject> query = new LCQuery<>("Todo");
query.whereEqualTo("isComplete", true);
LCLiveQuery liveQuery = LCLiveQuery.initWithQuery(query);
liveQuery.setEventHandler(new LCLiveQueryEventHandler() {
    @Override
    public void onObjectCreated(LCObject newTodo) {
        System.out.println(newTodo.getString("title")); // Update Portfolio
    }
});
liveQuery.subscribeInBackground(new LCLiveQuerySubscribeCallback() {
    @Override
    public void done(LCException e) {
        if (e == null) {
            // Subscribed
        }
    }
});

If someone updates this Todo by changing its content to Add my recent paintings, the following code can get the updated version for you:

liveQuery.setEventHandler(new LCLiveQueryEventHandler() {
    @Override
    public void onObjectUpdated(LCObject updatedTodo, List<String> updatedKeys) {
        System.out.println(updatedTodo.getString("content")); // Add my recent paintings
    }
});

Event Handling

The following types of data changes can be monitored once a subscription is set up:

create
update
enter
leave
delete

`create` Event

A create event will be triggered when a new LCObject is created and fulfills the LCQuery you subscribed to. The object is the new LCObject being created:

liveQuery.setEventHandler(new LCLiveQueryEventHandler() {
    @Override
    public void onObjectCreated(LCObject object) {
        System.out.println("Object created.");
    }
});

`update` Event

An update event will be triggered when an existing LCObject fulfilling the LCQuery you subscribed to is updated. The object is the LCObject being updated:

liveQuery.setEventHandler(new LCLiveQueryEventHandler() {
    @Override
    public void onObjectUpdated(LCObject object, List<String> updatedKeys) {
        System.out.println("Object updated.");
    }
});

`enter` Event

An enter event will be triggered when an existing LCObject's old value does not fulfill the LCQuery you subscribed to but its new value does. The object is the LCObject entering the LCQuery and its content is the latest value of it:

liveQuery.setEventHandler(new LCLiveQueryEventHandler() {
    @Override
    public void onObjectEnter(LCObject object, List<String> updatedKeys) {
        System.out.println("Object entered.");
    }
});

There is a difference between a create event and an enter event. If an object already exists and later matches the query's conditions, an enter event will be triggered. If an object didn't exist already and is later created, a create event will be triggered.

`leave` Event

A leave event will be triggered when an existing LCObject's old value fulfills the LCQuery you subscribed to but its new value does not. The object is the LCObject leaving the LCQuery and its content is the latest value of it:

liveQuery.setEventHandler(new LCLiveQueryEventHandler() {
    @Override
    public void onObjectLeave(LCObject object, List<String> updatedKeys) {
        System.out.println("Object left.");
    }
});

`delete` Event

A delete event will be triggered when an existing LCObject fulfilling the LCQuery you subscribed to is deleted. The object is the objectId of the LCObject being deleted:

liveQuery.setEventHandler(new LCLiveQueryEventHandler() {
    @Override
    public void onObjectDeleted(String object) {
        System.out.println("Object deleted.");
    }
});

Unsubscribing

You can cancel a subscription to stop receiving events regarding LCQuery. After that, you won't get any events from the subscription.

liveQuery.unsubscribeInBackground(new LCLiveQuerySubscribeCallback() {
    @Override
    public void done(LCException e) {
        if (e == null) {
            // Successfully unsubscribed
        }
    }
});

Losing Connections

There are different scenarios regarding losing connections:

The connection to the Internet is lost unexpectedly.
The user performs certain operations outside of the app, like switching the app to the background, turning off the phone, or turning on the flight mode.

For the scenarios above, you don't need to do any extra work. As long as the user switches back to the app, the SDK will automatically re-establish the connection.

There is another scenario when the user completely kills the app or closes the web page. In this case, the SDK cannot automatically re-establish the connection. You will have to create subscriptions again by yourself.

Monitoring Network Status Changes

Your app can get notified when a LiveQuery connection is established, closed, or getting an error with the setConnectionHandler method:

LCLiveQuery.setConnectionHandler(new LCLiveQueryConnectionHandler() {
    @Override
    public void onConnectionOpen() {
        System.out.println("============ LiveQuery Connection opened ============");
    }

    @Override
    public void onConnectionClose() {
        System.out.println("============ LiveQuery Connection closed ============");
    }

    @Override
    public void onConnectionError(int code, String reason) {
        System.out.println("============ LiveQuery Connection error. code:" + code
            + ", reason:" + reason + " ============");
    }
});

Caveats about LiveQuery

Given the real-time feature of LiveQuery, developers may find it tempting to use it for instant messaging. As LiveQuery is neither designed nor optimized for completing such tasks, we discourage such use of this tool, let alone there will be an additional cost for saving message history and rising challenges of code maintenance. We recommend using our Instant Messaging service for this scenario.

Applications that use LiveQuery without using Instant Messaging and other push services can invoke the static method startIfRequired of PushService to create WebSocket connections when initializing the SDK:

PushService.startIfRequired(android.content.Context context);

Files

LCFile allows you to store application files in the cloud that would otherwise be too large or cumbersome to fit into a regular LCObject. The most common use case is storing images, but you can also use it for documents, videos, music, and any other binary data.

Creating Files

You can create a file from a string:

// resume.txt is the file name
LCFile file = new LCFile("resume.txt", "LeanCloud".getBytes());

You can also create a file from a URL:

LCFile file = new LCFile(
    "logo.png",
    "https://leancloud.cn/assets/imgs/press/Logo%20-%20Blue%20Padding.a60eb2fa.png",
    new HashMap<String, Object>()
);

When creating files from URLs, the SDK will not upload the actual files into the cloud but will store the addresses of the files as strings. This will not lead to actual traffic for uploading files, as opposed to creating files in other ways by doing which the files will be actually stored into the cloud.

The cloud will auto-detect the type of the file you are uploading based on the file extension, but you can also specify the Content-Type (commonly referred to as MIME type):

Map<String, Object> meta = new HashMap<String, Object>();
meta.put("mime_type", "application/json");
LCFile file = new LCFile("resume.txt", "LeanCloud".getBytes(), meta);

But the most common method for creating files is to upload them from local paths:

LCFile file = LCFile.withAbsoluteLocalPath("avatar.jpg", "/tmp/avatar.jpg");

The file we uploaded here is named avatar.jpg. There are a couple of things to note here:

Each file uploaded will get its unique objectId, so it is allowed for multiple files to share the same name.
A correct extension needs to be assigned to each file which the cloud will use to infer the type of a file. For example, if you are storing a PNG image with LCFile, use .png as its extension.
If the file doesn't have an extension and the content type is not specified, the file will get the default type application/octet-stream.

Saving Files

By saving a file, you store it into the cloud and get a permanent URL pointing to it:

file.saveInBackground().subscribe(new Observer<LCFile>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(LCFile file) {
        System.out.println("File saved. URL: " + file.getUrl());
    }
    public void onError(Throwable throwable) {
        // The file either could not be read or could not be saved to the cloud
    }
    public void onComplete() {}
});

A file successfully uploaded can be found in Dashboard > Data Storage > Files and cannot be modified later. If you need to change the file, you have to upload the modified file again and a new objectId and URL will be generated.

You can associate a file with LCObject after it has been saved:

LCObject todo = new LCObject("Todo");
todo.put("title", "Buy Cakes");
// The type of attachments is Array
todo.add("attachments", file);
todo.save();

You can also construct an LCQuery to query files:

LCQuery<LCObject> query = new LCQuery<>("_File");

Note that the url field of internal files (files uploaded to the file service) is dynamically generated by the cloud, which will switch custom domain names automatically. Therefore, querying files by the url field is only applicable to external files (files created by saving the external URL directly to the _File table). Query internal files by the key field (path in URL) instead.

On a related note, if the files are referenced in an array field of LCObject and you want to get them within the same query for LCObject, you need to use the include method with LCQuery. For example, if you are retrieving all the todos with the same title Buy Cakes and you want to retrieve their related attachments at the same time:

// Get all todos with the same title and contain attachments
LCQuery<LCObject> query = new LCQuery<>("Todo");
query.whereEqualTo("title", "Buy Cakes");
query.whereExists("attachments");

// Include attachments with each todo
query.include("attachments");

query.findInBackground().subscribe(new Observer<List<LCObject>>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(List<LCObject> todos) {
        for (LCObject todo : todos) {
            // Get the attachments array for each todo
        }
    }
    public void onError(Throwable throwable) {}
    public void onComplete() {}
});

Upload Progress

You can monitor the upload progress and display that to the user:

file.saveInBackground(new ProgressCallback() {
    @Override
    public void done(Integer percent) {
        System.out.println("Progress: " + percent + "%");
    }
});

File Metadata

When uploading a file, you can attach additional properties to it with metaData. A file's metaData cannot be updated once the file is stored to the cloud.

// Set metadata
file.addMetaData("author", "LeanCloud");
file.saveInBackground().subscribe(new Observer<LCFile>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(LCFile file) {
        // Get author
        String author = (String) file.getMetaData("author");
        // Get file name
        String fileName = file.getName();
        // Get size (not available for files created from base64-encoded strings or URLs)
        int size = file.getSize();
    }
    public void onError(Throwable throwable) {}
    public void onComplete() {}
});

Image Thumbnails

After saving an image, you can get the URL of a thumbnail of the image beside that of the image itself. You can even specify the width and height of the thumbnail:

LCFile file = new LCFile("test.jpg", "file-url", new HashMap<String, Object>());
file.getThumbnailUrl(true, 100, 100);

You can only get thumbnails for images smaller than 20 MB.

Downloading Files

Call getDataInBackground or getDataStreamInBackground on an LCFile to download the file:

file.getDataInBackground().subscribe(new Observer<byte[]>() {
    @Override
    public void onSubscribe(Disposable d) {}

    @Override
    public void onNext(byte[] bytes) {
        Log.d("LCFile", "file data length: " + bytes.length);
    }

    @Override
    public void onError(Throwable e) {
        Log.d("LCFile", "failed to get data. cause: " + e.getMessage());
    }

    @Override
    public void onComplete() {}
});

file.getDataStreamInBackground().subscribe(new Observer<InputStream>() {
    @Override
    public void onSubscribe(Disposable d) {}

    @Override
    public void onNext(InputStream inputStream) {
        try {
            byte[] buffer = new byte[102400];
            int read = inputStream.read(buffer);
            Log.d("LCFile", "file data length: " + read);
            inputStream.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    @Override
    public void onError(Throwable e) {
        Log.d("LCFile", "failed to get data. cause: " + e.getMessage());
    }

    @Override
    public void onComplete() {}
});

You can also get the url of the LCFile and use the standard library or a third-party library to download the file.

Deleting Files

The code below deletes a file from the cloud:

LCObject file = LCObject.createWithoutData("_File", "552e0a27e4b0643b709e891e");
file.deleteInBackground().subscribe(new Observer<LCNull>() {
    @Override
    public void onSubscribe(@NonNull Disposable d) {}

    @Override
    public void onNext(LCNull response) {
        // succeed to delete the file
    }

    @Override
    public void onError(@NonNull Throwable e) {
        System.out.println("failed to delete the file: " + e.getMessage());
    }

    @Override
    public void onComplete() {}
});

By default, a file is not allowed to be deleted. We recommend you delete files by accessing our REST API with the Master Key. You can also allow certain users and roles to delete files by going to Dashboard > Data Storage > Files > Permission.

File Censorship

The censorship feature allows you to censor image files stored on the cloud.

You can Enable automatic content censor for subsequent uploaded pictures by going to Data Storage > Files > Censorship. You can also batch-censor all the images uploaded during a specific time scope. You can view the results of the censorship under the Files tab.

You can manually Pass or Block images even if they have gone through automatic censorship.

GeoPoints

You can associate real-world latitude and longitude coordinates with an object by adding an LCGeoPoint to the LCObject. By doing so, queries on the proximity of an object to a given point can be performed, allowing you to implement functions like looking for users or places nearby easily.

To associate a point with an object, you need to create the point first. The code below creates an LCGeoPoint with 39.9 as latitude and 116.4 as longitude:

LCGeoPoint point = new LCGeoPoint(39.9, 116.4);

Now you can store the point into an object as a regular field:

todo.put("location", point);

Geo Queries

With a number of existing objects with spatial coordinates, you can find out which of them are closest to a given point, or are contained within a particular area. This can be done by adding another restriction to LCQuery using whereNear. The code below returns a list of Todo objects with location closest to a given point:

LCQuery<LCObject> query = new LCQuery<>("Todo");
LCGeoPoint point = new LCGeoPoint(39.9, 116.4);
query.whereNear("location", point);

// Limit to 10 results
query.limit(10);
query.findInBackground().subscribe(new Observer<List<LCObject>>() {
    public void onSubscribe(Disposable disposable) {}
    public void onNext(List<LCObject> todos) {
        // todos is an array of Todo objects satisfying conditions
    }
    public void onError(Throwable throwable) {}
    public void onComplete() {}
});

Additional sorting conditions like orderByAscending and orderByDescending will gain higher priorities than the default order by distance.

To have the results limited within a certain distance, check out whereWithinKilometers, whereWithinMiles, and whereWithinRadians in our API docs.

You can also query for the set of objects that are contained within a rectangular bounding box with whereWithinGeoBox:

withinGeoBox

LCQuery<LCObject> query = new LCQuery<>("Todo");
LCGeoPoint southwest = new LCGeoPoint(30, 115);
LCGeoPoint northeast = new LCGeoPoint(40, 118);
query.whereWithinGeoBox("location", southwest, northeast);

Caveats about GeoPoints

Points should not exceed the extreme ends of the ranges. Latitude should be between -90.0 and 90.0. Longitude should be between -180.0 and 180.0. Attempting to set latitude or longitude out of bounds will cause an error. Also, each LCObject can only have one field for LCGeoPoint.

Users

See TDS Authentication Guide.

Roles

As your app grows in scope and user base, you may find yourself needing more coarse-grained control over access to pieces of your data than user-linked ACLs can provide. To address this requirement, we support a form of role-based access control. Check the detailed ACL Guide to learn how to set it up for your objects.

Full-Text Search

Full-Text Search offers a better way to search through the information contained within your app. It's built with search engine capabilities that you can easily tap into your app. Effective and useful searching functionality in your app is crucial for helping users find what they need. For more details, see Full-Text Search Guide.

Installing SDK​

Objects​

LCObject​

Data Types​

Creating Objects​

Saving Objects​

Retrieving Objects​

Refreshing Objects​

Updating Objects​

Updating Data Conditionally​

Updating Counters​

Updating Arrays​

Deleting Objects​

Batch Processing​

Running in the Background​

Storing Data Locally​

Data Models​

One-to-One and One-to-Many Relationships​

Many-to-Many Relationships​

Serialization and Deserialization​

Queries​

Basic Queries​

Query Constraints​

Queries on String Values​

Queries on Array Values​

Relational Queries​

Caveats about Inner Queries​

Counting Objects​

Compound Queries​

OR-ed Query Constraints​

AND-ed Query Constraints​

Optimizing Performance​

LiveQuery​

Initializing LiveQuery​

Demo​

Creating a Subscription​

Event Handling​

create Event​

update Event​

enter Event​

leave Event​

delete Event​

Unsubscribing​

Losing Connections​

Monitoring Network Status Changes​

Caveats about LiveQuery​

Files​

Creating Files​

Saving Files​

Upload Progress​

File Metadata​

Image Thumbnails​

Downloading Files​

Deleting Files​

File Censorship​

GeoPoints​

Geo Queries​

Caveats about GeoPoints​

Users​

Roles​

Full-Text Search​