Apply edits (online)

After you have edited your ServiceFeatureTable in the online feature service editing process, you can apply local edits to the feature service through a call to ServiceFeatureTable.applyEditsAsync(). However, this method is only meant to be used for single table workflows or tables without geodatabase behavior. More commonly, geodatabases are more than single tables used to capture spatial data, they can provide functionality that realistically models the behavior of real world features. While performing editing operations, the geodatabase takes an active role to ensure the integrity of your data, often augmenting edits made directly to the data with automated changes or validation. Such changes are referred to as geodatabase behavior.

Examples of geodatabase behavior:

• Composite relationships: Causes a feature in the destination table to be deleted when a related feature is deleted in the origin table.

• Feature-linked annotation: Text in feature-linked annotation reflects the value of a field or fields from a feature in another feature class to which it is linked.

• Utility network association deletion semantics: Values in the UtilityAssociationDeletionSemantics enum describe how deleting a feature of a specific asset type affects associated features.

• Attribute rules: User-defined rules that can automatically populate attributes, restrict invalid edits during edit operations, and perform quality assurance checks.

These capabilities are honored by the ServiceGeodatabase class because it is a container for all the feature tables connected with a given feature service. As a consequence, the service geodatabase is able to respect and apply the defined behaviors of the underlying geodatabase. If edits are applied directly to a single service feature table without a service geodatabase, it may lead to data inconsistency. This is because your service feature table could be linked to other service feature tables in the service through one or more of the above mentioned geodatabase behaviors. Using a service geodatabase is recommended in such a scenario as it will apply any dependent edits that the geodatabase behavior may require.

The service geodatabase allows you to manage edits for all tables it contains, such as checking if the service geodatabase has local edits, applying all edits to the service, or undoing all local edits. Such operations affect all service feature tables in a service geodatabase. Additionally, when the service geodatabase supports branch versioning, you can get the available versions for the geodatabase, switch the current version, or create a new version. See the Use branch versioned data topic for more information.

Get the service geodatabase

If your application loads an existing ArcGISMap or ArcGISScene (from a web map, web scene, mobile map package, mobile scene package, and so on), a ServiceGeodatabase is created for every feature service that is referenced. You can use ServiceFeatureTable.getServiceGeodatabase() to begin working with the available service geodatabases.

If you need to load individual tables from a feature service, you can create a ServiceGeodatabase object first, and then use ServiceGeodatabase.getTable() to get the table. This is the recommended approach, rather than creating a new ServiceFeatureTable using its constructor.

Apply edits to the service geodatabase

After making edits to data within a feature table, the edits need to be packaged and sent to the feature service. Use the ServiceGeodatabase.applyEditsAsync() method to send all changes in all tables to the service as a single transaction. This ensures that geodatabase behavior is appropriately leveraged.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
// If the feature table is a service feature table, send these edits
// to the online service by applying them to its service geodatabase.
if (featureTable instanceof ServiceFeatureTable serviceFeatureTable) {
    try {
        ServiceGeodatabase serviceGeodatabase = serviceFeatureTable.getServiceGeodatabase();

        // Check if the service feature table has a service geodatabase.
        if (serviceGeodatabase != null) {
            // Apply edits to the service geodatabase.
            ListenableFuture<List<FeatureTableEditResult>> featureTableEditResultFuture =
                    serviceGeodatabase.applyEditsAsync();

            featureTableEditResultFuture.addDoneListener(() -> {
                try {
                    // Examine the edits that you just attempted to push to the service.
                    List<FeatureTableEditResult> featureTableEditResultList =
                            featureTableEditResultFuture.get();

                    // Each feature table edit result contains the feature edits for one feature table.
                    // Examine the feature edits for each feature table.

                    // ...
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }
            });
        }
    } catch (Exception e) {
        new Alert(Alert.AlertType.ERROR, "Error while applying edits.");
        e.printStackTrace();
    }
}

The advantage of calling ServiceGeodatabase.applyEditsAsync() on the service geodatabase, rather than on each individual table, is that it ensures that all of the edit operations take place in a single transaction. Either all of the edits are applied or none of them. If you apply edits to each table individually, it is possible that only some edits will be applied (for example, if you lose network connectivity in the middle of the operation).

Apply edits in a branch version

The edits made to service feature tables from a branch version can be applied by calling ServiceGeodatabase.applyEditsAsync() as described previously to ensure all the edits in the local tables are applied correctly to the feature service. These edits, now applied to the service, are contained to the branch version. In order to merge these changes from a branch version into the default branch version, a back-office operation is required. Using ArcGIS Pro, a GIS professional can reconcile and post the branch version into the default version so that viewers of the default branch can see the edits. See Branch version scenarios for more information on this multiuser editing workflow.