Query a feature layer (SQL) | ArcGIS Maps SDK for Swift

Learn how to execute a SQL query to return features A feature is a single record, also known as a row, that represents a real-world entity. It typically contains a geometry (point, multipoint, polyline, or polygon) and attributes but it can also contain just attributes. Learn more from a feature layer A feature layer (server-side) is a spatially-enabled table in a feature service. All features in a feature layer share the same geometry type and set of fields. Learn more based on spatial and attribute Attributes are fields and values for a single feature or non-spatial record. They are typically stored in a database or service such as a feature service. Learn more criteria.

Figure : Overview of how to execute an SQL query to return features from a feature layer.

A feature layer A feature layer (server-side) is a spatially-enabled table in a feature service. All features in a feature layer share the same geometry type and set of fields. Learn more can contain a large number of features A feature is a single record, also known as a row, that represents a real-world entity. It typically contains a geometry (point, multipoint, polyline, or polygon) and attributes but it can also contain just attributes. Learn more stored in ArcGIS. You can query a layer to access a subset of its features using any combination of spatial and attribute Attributes are fields and values for a single feature or non-spatial record. They are typically stored in a database or service such as a feature service. Learn more criteria. You can control whether or not each feature’s geometry A geometry is a geometric shape, such as a point, polyline, or polygon, that contains one or more coordinates and a spatial reference. Learn more is returned, as well as which attributes are included in the results. Queries allow you to return a well-defined subset of your hosted data for analysis or display in your app.

In this tutorial, you’ll write code to perform SQL queries that return a subset of features A feature is a single record, also known as a row, that represents a real-world entity. It typically contains a geometry (point, multipoint, polyline, or polygon) and attributes but it can also contain just attributes. Learn more in the LA County Parcel feature layer A feature layer (server-side) is a spatially-enabled table in a feature service. All features in a feature layer share the same geometry type and set of fields. Learn more (containing over 2.4 million features). Features that meet the query criteria are selected in the map.

Prerequisites

Before starting this tutorial:

You need an ArcGIS Location Platform or ArcGIS Online account.
Your system meets the system requirements.

Develop or Download

You have two options for completing this tutorial:

Option 1: Develop the code or
Option 2: Download the completed solution

Option 1: Develop the code

To start the tutorial, complete the Display a map tutorial. This creates a map to display the Santa Monica Mountains in California using the topographic basemap from the ArcGIS Basemap Styles service The ArcGIS Basemap Styles service, also referred to as the Basemap Styles service, is a location service that provides basemap styles and data for the world. It returns styles as Mapbox styles and web maps, and data as vector tiles and/or map tiles. It supports all of the styles in the ArcGIS Basemap style and Open Basemap style family. An ArcGIS Location Platform or ArcGIS Online account is required to use the service. Learn more .

Open an Xcode project

Open the .xcodeproj project you created by completing the Display a map tutorial.
Continue with the following instructions to execute a SQL query to return features from a feature layer based on spatial and attribute criteria.

Update the map

In Xcode, in the Project Navigator, click ContentView.swift.

In the editor, modify the map variable’s initial viewpoint.

ContentView.swift

1
        let map: Map = {
2
            let map = Map(basemapStyle: .arcGISTopographic)
3

4
            map.initialViewpoint = Viewpoint(latitude: 34.03000, longitude: -118.80500, scale: 6e4)
5

6
            return map
7
        }()

Create a private extension named Model with a class of type ObservableObject. Move the map variable there.

ContentView.swift

1
private extension ContentView {
2

3
    class Model: ObservableObject {
4

5
        let map: Map = {
6
            let map = Map(basemapStyle: .arcGISTopographic)
7

8
            map.initialViewpoint = Viewpoint(latitude: 34.03000, longitude: -118.80500, scale: 6e4)
9

10
            return map
11
        }()
12

13

14
    }
15

16
}

Create a ServiceFeatureTable from the parcels service URL, then use it to make a FeatureLayer. Then, add the parcels feature layer to the map as an operational layer.

ContentView.swift

1
    class Model: ObservableObject {
2

3
        let map: Map = {
4
            let map = Map(basemapStyle: .arcGISTopographic)
5

6
            map.initialViewpoint = Viewpoint(latitude: 34.03000, longitude: -118.80500, scale: 6e4)
7

8
            let parcelsURL = URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0")!
9
            let featureTable = ServiceFeatureTable(url: parcelsURL)
10
            let featureLayer = FeatureLayer(featureTable: featureTable)
11
            map.addOperationalLayer(featureLayer)
12

13
            return map
14
        }()
15

16

17
    }

To access the model’s map in the ContentView struct, create a private variable of type Model with a @StateObject property wrapper and modify the MapView to display the model’s map.

ContentView.swift

1
struct ContentView: View {
2

3
    @StateObject private var model = Model()
4

5
    @State private var geoViewExtent: Envelope?
6

7
    var body: some View {
8

9
        MapView(map: model.map)
10

11
            .onVisibleAreaChanged { newVisibleArea in
12
                geoViewExtent = newVisibleArea.extent
13
            }
14

15
    }
16

17
}

Make an enumeration for predefined where clauses

To allow the user to query the parcels feature layer, create an enum that contains a set of predefined where clauses.

In the ContentView extension, make an enum type called WhereClause that is CaseIterable and Equatable. Add a switch statement and a case option for each where clause.

ContentView.swift

1
private extension ContentView {
2

3
    enum WhereClause: CaseIterable, Equatable {
4
        case government, residential, farm, taxRate10853, taxRate10860, landValueGreaterThan, landValueLessThan
5

6
        var expression: String {
7
            switch self {
8
            case .government: return "UseType = 'Government'"
9
            case .residential: return "UseType = 'Residential'"
10
            case .farm: return "UseType = 'Irrigated Farm'"
11
            case .taxRate10853: return "TaxRateArea = 10853"
12
            case .taxRate10860: return "TaxRateArea = 10860"
13
            case .landValueGreaterThan: return "Roll_LandValue > 1000000"
14
            case .landValueLessThan: return "Roll_LandValue < 1000000"
15
            }
16
        }
17
    }
18

19
    class Model: ObservableObject {
20

21
        let map: Map = {
22
            let map = Map(basemapStyle: .arcGISTopographic)
23

24
            map.initialViewpoint = Viewpoint(latitude: 34.03000, longitude: -118.80500, scale: 6e4)
25

26
            let parcelsURL = URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0")!
27
            let featureTable = ServiceFeatureTable(url: parcelsURL)
28
            let featureLayer = FeatureLayer(featureTable: featureTable)
29
            map.addOperationalLayer(featureLayer)
30

31
            return map
32
        }()
33

34

35
    }
36

37
}

Create a function to query the parcels layer and select the result

Create a new function that queries the parcels FeatureTable with the chosen where clause and current extent. Clear any currently selected features and create a new QueryParameters object. Set the selectedWhereClause property to the option selected by the user and geoViewExtent to the current visible area. Asynchronously, query the feature table using the QueryParameters and select the features returned in the FeatureQueryResult.

Create a private variable of type Envelope with the @State property wrapper named geoViewExtent. This variable keeps track of the current, visible extent.

ContentView.swift


18 collapsed lines
1
// Copyright 2024 Esri
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//   https://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
import SwiftUI
16
import ArcGIS
17

18

19
struct ContentView: View {
20

21
    @StateObject private var model = Model()
22

23
    @State private var geoViewExtent: Envelope?
24

25
    var body: some View {
26

27
        MapView(map: model.map)
28

29
    }
30

31
}
58 collapsed lines
32

33
private extension ContentView {
34

35
    enum WhereClause: CaseIterable, Equatable {
36
        case government, residential, farm, taxRate10853, taxRate10860, landValueGreaterThan, landValueLessThan
37

38
        var expression: String {
39
            switch self {
40
            case .government: return "UseType = 'Government'"
41
            case .residential: return "UseType = 'Residential'"
42
            case .farm: return "UseType = 'Irrigated Farm'"
43
            case .taxRate10853: return "TaxRateArea = 10853"
44
            case .taxRate10860: return "TaxRateArea = 10860"
45
            case .landValueGreaterThan: return "Roll_LandValue > 1000000"
46
            case .landValueLessThan: return "Roll_LandValue < 1000000"
47
            }
48
        }
49
    }
50

51
    class Model: ObservableObject {
52

53
        let map: Map = {
54
            let map = Map(basemapStyle: .arcGISTopographic)
55

56
            map.initialViewpoint = Viewpoint(latitude: 34.03000, longitude: -118.80500, scale: 6e4)
57

58
            let parcelsURL = URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0")!
59
            let featureTable = ServiceFeatureTable(url: parcelsURL)
60
            let featureLayer = FeatureLayer(featureTable: featureTable)
61
            map.addOperationalLayer(featureLayer)
62

63
            return map
64
        }()
65

66

67
        func queryFeatureLayer(with selectedWhereClause: WhereClause, in extent: Envelope) async {
68
            guard
69
                let parcelsFeatureLayer = map.operationalLayers.first as? FeatureLayer,
70
                let featureTable = parcelsFeatureLayer.featureTable
71
            else { return }
72
            parcelsFeatureLayer.clearSelection()
73

74
            let parameters = QueryParameters()
75
            parameters.whereClause = selectedWhereClause.expression
76
            parameters.geometry = extent
77

78
            do {
79
                let result = try await featureTable.queryFeatures(using: parameters)
80
                let features = result.features()
81
                parcelsFeatureLayer.selectFeatures(features)
82
            } catch {
83
                print(error)
84
            }
85
        }
86

87
    }
88

89
}

To update the geoViewExtent variable when the visible area is changed, add the onVisibleAreaChanged(perform:) task modifer to the map view. When the visible area has changed, update geoViewExtent to the new area’s extent.

ContentView.swift


18 collapsed lines
1
// Copyright 2024 Esri
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//   https://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
import SwiftUI
16
import ArcGIS
17

18

19
struct ContentView: View {
20

21
    @StateObject private var model = Model()
22

23
    @State private var geoViewExtent: Envelope?
24

25
    var body: some View {
26

27
        MapView(map: model.map)
28

29
            .onVisibleAreaChanged { newVisibleArea in
30
                geoViewExtent = newVisibleArea.extent
31
            }
32

33
    }
34

35
}
58 collapsed lines
36

37
private extension ContentView {
38

39
    enum WhereClause: CaseIterable, Equatable {
40
        case government, residential, farm, taxRate10853, taxRate10860, landValueGreaterThan, landValueLessThan
41

42
        var expression: String {
43
            switch self {
44
            case .government: return "UseType = 'Government'"
45
            case .residential: return "UseType = 'Residential'"
46
            case .farm: return "UseType = 'Irrigated Farm'"
47
            case .taxRate10853: return "TaxRateArea = 10853"
48
            case .taxRate10860: return "TaxRateArea = 10860"
49
            case .landValueGreaterThan: return "Roll_LandValue > 1000000"
50
            case .landValueLessThan: return "Roll_LandValue < 1000000"
51
            }
52
        }
53
    }
54

55
    class Model: ObservableObject {
56

57
        let map: Map = {
58
            let map = Map(basemapStyle: .arcGISTopographic)
59

60
            map.initialViewpoint = Viewpoint(latitude: 34.03000, longitude: -118.80500, scale: 6e4)
61

62
            let parcelsURL = URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0")!
63
            let featureTable = ServiceFeatureTable(url: parcelsURL)
64
            let featureLayer = FeatureLayer(featureTable: featureTable)
65
            map.addOperationalLayer(featureLayer)
66

67
            return map
68
        }()
69

70

71
        func queryFeatureLayer(with selectedWhereClause: WhereClause, in extent: Envelope) async {
72
            guard
73
                let parcelsFeatureLayer = map.operationalLayers.first as? FeatureLayer,
74
                let featureTable = parcelsFeatureLayer.featureTable
75
            else { return }
76
            parcelsFeatureLayer.clearSelection()
77

78
            let parameters = QueryParameters()
79
            parameters.whereClause = selectedWhereClause.expression
80
            parameters.geometry = extent
81

82
            do {
83
                let result = try await featureTable.queryFeatures(using: parameters)
84
                let features = result.features()
85
                parcelsFeatureLayer.selectFeatures(features)
86
            } catch {
87
                print(error)
88
            }
89
        }
90

91
    }
92

93
}

Create a new method called queryFeatureLayer(selectedWhereClause:extent:) in the Model. Specify that it accepts parameters of type WhereClause and Envelope.

ContentView.swift


54 collapsed lines
1
// Copyright 2024 Esri
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//   https://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
import SwiftUI
16
import ArcGIS
17

18

19
struct ContentView: View {
20

21
    @StateObject private var model = Model()
22

23
    @State private var geoViewExtent: Envelope?
24

25
    var body: some View {
26

27
        MapView(map: model.map)
28

29
            .onVisibleAreaChanged { newVisibleArea in
30
                geoViewExtent = newVisibleArea.extent
31
            }
32

33
    }
34

35
}
36

37
private extension ContentView {
38

39
    enum WhereClause: CaseIterable, Equatable {
40
        case government, residential, farm, taxRate10853, taxRate10860, landValueGreaterThan, landValueLessThan
41

42
        var expression: String {
43
            switch self {
44
            case .government: return "UseType = 'Government'"
45
            case .residential: return "UseType = 'Residential'"
46
            case .farm: return "UseType = 'Irrigated Farm'"
47
            case .taxRate10853: return "TaxRateArea = 10853"
48
            case .taxRate10860: return "TaxRateArea = 10860"
49
            case .landValueGreaterThan: return "Roll_LandValue > 1000000"
50
            case .landValueLessThan: return "Roll_LandValue < 1000000"
51
            }
52
        }
53
    }
54

55
    class Model: ObservableObject {
56

57
        let map: Map = {
58
            let map = Map(basemapStyle: .arcGISTopographic)
59

60
            map.initialViewpoint = Viewpoint(latitude: 34.03000, longitude: -118.80500, scale: 6e4)
61

62
            let parcelsURL = URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0")!
63
            let featureTable = ServiceFeatureTable(url: parcelsURL)
64
            let featureLayer = FeatureLayer(featureTable: featureTable)
65
            map.addOperationalLayer(featureLayer)
66

67
            return map
68
        }()
69

70

71
        func queryFeatureLayer(with selectedWhereClause: WhereClause, in extent: Envelope) async {
72
            guard
73
                let parcelsFeatureLayer = map.operationalLayers.first as? FeatureLayer,
74
                let featureTable = parcelsFeatureLayer.featureTable
75
            else { return }
76
            parcelsFeatureLayer.clearSelection()
77

78
            let parameters = QueryParameters()
79
            parameters.whereClause = selectedWhereClause.expression
80
            parameters.geometry = extent
81

82
            do {
83
                let result = try await featureTable.queryFeatures(using: parameters)
84
                let features = result.features()
85
                parcelsFeatureLayer.selectFeatures(features)
86
            } catch {
87
                print(error)
88
            }
89
        }
90

91
    }
2 collapsed lines
92

93
}

Add UI for selecting a predefined where clause

To allow the user to choose a where clause that queries the parcels dataset, add a Picker that presents the list of predefined where clauses.

In the ContentView, create a @State variable named selectedWhereClause of type WhereClause. Assign .government as the default enum. The @State variable selectedWhereClause allows the model’s queryFeatureLayer(selectedWhereClause:extent:) method to track which where clause the user has selected.

ContentView.swift


18 collapsed lines
1
// Copyright 2024 Esri
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//   https://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
import SwiftUI
16
import ArcGIS
17

18

19
struct ContentView: View {
20

21
    @StateObject private var model = Model()
22

23
    @State private var geoViewExtent: Envelope?
24

25
    @State private var selectedWhereClause: WhereClause = .government
26

27
    var body: some View {
28

29
        MapView(map: model.map)
30

31
            .onVisibleAreaChanged { newVisibleArea in
32
                geoViewExtent = newVisibleArea.extent
33
            }
34

35
    }
36

37
}
58 collapsed lines
38

39
private extension ContentView {
40

41
    enum WhereClause: CaseIterable, Equatable {
42
        case government, residential, farm, taxRate10853, taxRate10860, landValueGreaterThan, landValueLessThan
43

44
        var expression: String {
45
            switch self {
46
            case .government: return "UseType = 'Government'"
47
            case .residential: return "UseType = 'Residential'"
48
            case .farm: return "UseType = 'Irrigated Farm'"
49
            case .taxRate10853: return "TaxRateArea = 10853"
50
            case .taxRate10860: return "TaxRateArea = 10860"
51
            case .landValueGreaterThan: return "Roll_LandValue > 1000000"
52
            case .landValueLessThan: return "Roll_LandValue < 1000000"
53
            }
54
        }
55
    }
56

57
    class Model: ObservableObject {
58

59
        let map: Map = {
60
            let map = Map(basemapStyle: .arcGISTopographic)
61

62
            map.initialViewpoint = Viewpoint(latitude: 34.03000, longitude: -118.80500, scale: 6e4)
63

64
            let parcelsURL = URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0")!
65
            let featureTable = ServiceFeatureTable(url: parcelsURL)
66
            let featureLayer = FeatureLayer(featureTable: featureTable)
67
            map.addOperationalLayer(featureLayer)
68

69
            return map
70
        }()
71

72

73
        func queryFeatureLayer(with selectedWhereClause: WhereClause, in extent: Envelope) async {
74
            guard
75
                let parcelsFeatureLayer = map.operationalLayers.first as? FeatureLayer,
76
                let featureTable = parcelsFeatureLayer.featureTable
77
            else { return }
78
            parcelsFeatureLayer.clearSelection()
79

80
            let parameters = QueryParameters()
81
            parameters.whereClause = selectedWhereClause.expression
82
            parameters.geometry = extent
83

84
            do {
85
                let result = try await featureTable.queryFeatures(using: parameters)
86
                let features = result.features()
87
                parcelsFeatureLayer.selectFeatures(features)
88
            } catch {
89
                print(error)
90
            }
91
        }
92

93
    }
94

95
}

In the body, add a Toolbar and a ToolbarItemGroup with .bottomBar placement to the MapView.

ContentView.swift


26 collapsed lines
1
// Copyright 2024 Esri
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//   https://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
import SwiftUI
16
import ArcGIS
17

18

19
struct ContentView: View {
20

21
    @StateObject private var model = Model()
22

23
    @State private var geoViewExtent: Envelope?
24

25
    @State private var selectedWhereClause: WhereClause = .government
26

27
    var body: some View {
28

29
        MapView(map: model.map)
30

31
            .onVisibleAreaChanged { newVisibleArea in
32
                geoViewExtent = newVisibleArea.extent
33
            }
34

35
            .toolbar {
36
                ToolbarItemGroup(placement: .bottomBar) {
37

38
                }
39
            }
40

41
    }
60 collapsed lines
42

43
}
44

45
private extension ContentView {
46

47
    enum WhereClause: CaseIterable, Equatable {
48
        case government, residential, farm, taxRate10853, taxRate10860, landValueGreaterThan, landValueLessThan
49

50
        var expression: String {
51
            switch self {
52
            case .government: return "UseType = 'Government'"
53
            case .residential: return "UseType = 'Residential'"
54
            case .farm: return "UseType = 'Irrigated Farm'"
55
            case .taxRate10853: return "TaxRateArea = 10853"
56
            case .taxRate10860: return "TaxRateArea = 10860"
57
            case .landValueGreaterThan: return "Roll_LandValue > 1000000"
58
            case .landValueLessThan: return "Roll_LandValue < 1000000"
59
            }
60
        }
61
    }
62

63
    class Model: ObservableObject {
64

65
        let map: Map = {
66
            let map = Map(basemapStyle: .arcGISTopographic)
67

68
            map.initialViewpoint = Viewpoint(latitude: 34.03000, longitude: -118.80500, scale: 6e4)
69

70
            let parcelsURL = URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0")!
71
            let featureTable = ServiceFeatureTable(url: parcelsURL)
72
            let featureLayer = FeatureLayer(featureTable: featureTable)
73
            map.addOperationalLayer(featureLayer)
74

75
            return map
76
        }()
77

78

79
        func queryFeatureLayer(with selectedWhereClause: WhereClause, in extent: Envelope) async {
80
            guard
81
                let parcelsFeatureLayer = map.operationalLayers.first as? FeatureLayer,
82
                let featureTable = parcelsFeatureLayer.featureTable
83
            else { return }
84
            parcelsFeatureLayer.clearSelection()
85

86
            let parameters = QueryParameters()
87
            parameters.whereClause = selectedWhereClause.expression
88
            parameters.geometry = extent
89

90
            do {
91
                let result = try await featureTable.queryFeatures(using: parameters)
92
                let features = result.features()
93
                parcelsFeatureLayer.selectFeatures(features)
94
            } catch {
95
                print(error)
96
            }
97
        }
98

99
    }
100

101
}

Add a Picker to the toolbar item group and label it, “Choose an SQL where clause”. Set the selection to $selectedWhereClause. Iterating through .allCases of the WhereClause to populate the Picker with all the WhereClause enums.

ContentView.swift


26 collapsed lines
1
// Copyright 2024 Esri
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//   https://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
import SwiftUI
16
import ArcGIS
17

18

19
struct ContentView: View {
20

21
    @StateObject private var model = Model()
22

23
    @State private var geoViewExtent: Envelope?
24

25
    @State private var selectedWhereClause: WhereClause = .government
26

27
    var body: some View {
28

29
        MapView(map: model.map)
30

31
            .onVisibleAreaChanged { newVisibleArea in
32
                geoViewExtent = newVisibleArea.extent
33
            }
34

35
            .toolbar {
36
                ToolbarItemGroup(placement: .bottomBar) {
37

38
                    Spacer()
39
                    Picker("Choose an SQL `where` clause", selection: $selectedWhereClause) {
40
                        ForEach(WhereClause.allCases, id: \.self) { clause in
41
                            Text(clause.expression)
42
                        }
43

44
                    }
45
                    Spacer()
46

47
                }
48
            }
49

50
    }
60 collapsed lines
51

52
}
53

54
private extension ContentView {
55

56
    enum WhereClause: CaseIterable, Equatable {
57
        case government, residential, farm, taxRate10853, taxRate10860, landValueGreaterThan, landValueLessThan
58

59
        var expression: String {
60
            switch self {
61
            case .government: return "UseType = 'Government'"
62
            case .residential: return "UseType = 'Residential'"
63
            case .farm: return "UseType = 'Irrigated Farm'"
64
            case .taxRate10853: return "TaxRateArea = 10853"
65
            case .taxRate10860: return "TaxRateArea = 10860"
66
            case .landValueGreaterThan: return "Roll_LandValue > 1000000"
67
            case .landValueLessThan: return "Roll_LandValue < 1000000"
68
            }
69
        }
70
    }
71

72
    class Model: ObservableObject {
73

74
        let map: Map = {
75
            let map = Map(basemapStyle: .arcGISTopographic)
76

77
            map.initialViewpoint = Viewpoint(latitude: 34.03000, longitude: -118.80500, scale: 6e4)
78

79
            let parcelsURL = URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0")!
80
            let featureTable = ServiceFeatureTable(url: parcelsURL)
81
            let featureLayer = FeatureLayer(featureTable: featureTable)
82
            map.addOperationalLayer(featureLayer)
83

84
            return map
85
        }()
86

87

88
        func queryFeatureLayer(with selectedWhereClause: WhereClause, in extent: Envelope) async {
89
            guard
90
                let parcelsFeatureLayer = map.operationalLayers.first as? FeatureLayer,
91
                let featureTable = parcelsFeatureLayer.featureTable
92
            else { return }
93
            parcelsFeatureLayer.clearSelection()
94

95
            let parameters = QueryParameters()
96
            parameters.whereClause = selectedWhereClause.expression
97
            parameters.geometry = extent
98

99
            do {
100
                let result = try await featureTable.queryFeatures(using: parameters)
101
                let features = result.features()
102
                parcelsFeatureLayer.selectFeatures(features)
103
            } catch {
104
                print(error)
105
            }
106
        }
107

108
    }
109

110
}

Lastly, add a .task modifier that calls the model’s queryFeatureLayer(selectedWhereClause:extent:) function using the selectedWhereClause property.

ContentView.swift


26 collapsed lines
1
// Copyright 2024 Esri
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//   https://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
import SwiftUI
16
import ArcGIS
17

18

19
struct ContentView: View {
20

21
    @StateObject private var model = Model()
22

23
    @State private var geoViewExtent: Envelope?
24

25
    @State private var selectedWhereClause: WhereClause = .government
26

27
    var body: some View {
28

29
        MapView(map: model.map)
30

31
            .onVisibleAreaChanged { newVisibleArea in
32
                geoViewExtent = newVisibleArea.extent
33
            }
34

35
            .toolbar {
36
                ToolbarItemGroup(placement: .bottomBar) {
37

38
                    Spacer()
39
                    Picker("Choose an SQL `where` clause", selection: $selectedWhereClause) {
40
                        ForEach(WhereClause.allCases, id: \.self) { clause in
41
                            Text(clause.expression)
42
                        }
43

44
                        .task(id: selectedWhereClause) {
45
                            guard let geoViewExtent = geoViewExtent else { return }
46
                            await model.queryFeatureLayer(with: selectedWhereClause, in: geoViewExtent)
47
                        }
48

49
                    }
50
                    Spacer()
51

52
                }
53
            }
54

55
    }
60 collapsed lines
56

57
}
58

59
private extension ContentView {
60

61
    enum WhereClause: CaseIterable, Equatable {
62
        case government, residential, farm, taxRate10853, taxRate10860, landValueGreaterThan, landValueLessThan
63

64
        var expression: String {
65
            switch self {
66
            case .government: return "UseType = 'Government'"
67
            case .residential: return "UseType = 'Residential'"
68
            case .farm: return "UseType = 'Irrigated Farm'"
69
            case .taxRate10853: return "TaxRateArea = 10853"
70
            case .taxRate10860: return "TaxRateArea = 10860"
71
            case .landValueGreaterThan: return "Roll_LandValue > 1000000"
72
            case .landValueLessThan: return "Roll_LandValue < 1000000"
73
            }
74
        }
75
    }
76

77
    class Model: ObservableObject {
78

79
        let map: Map = {
80
            let map = Map(basemapStyle: .arcGISTopographic)
81

82
            map.initialViewpoint = Viewpoint(latitude: 34.03000, longitude: -118.80500, scale: 6e4)
83

84
            let parcelsURL = URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0")!
85
            let featureTable = ServiceFeatureTable(url: parcelsURL)
86
            let featureLayer = FeatureLayer(featureTable: featureTable)
87
            map.addOperationalLayer(featureLayer)
88

89
            return map
90
        }()
91

92

93
        func queryFeatureLayer(with selectedWhereClause: WhereClause, in extent: Envelope) async {
94
            guard
95
                let parcelsFeatureLayer = map.operationalLayers.first as? FeatureLayer,
96
                let featureTable = parcelsFeatureLayer.featureTable
97
            else { return }
98
            parcelsFeatureLayer.clearSelection()
99

100
            let parameters = QueryParameters()
101
            parameters.whereClause = selectedWhereClause.expression
102
            parameters.geometry = extent
103

104
            do {
105
                let result = try await featureTable.queryFeatures(using: parameters)
106
                let features = result.features()
107
                parcelsFeatureLayer.selectFeatures(features)
108
            } catch {
109
                print(error)
110
            }
111
        }
112

113
    }
114

115
}

Run the solution

Press Command + R to run the app.

If you are using the Xcode simulator your system must meet these minimum requirements: macOS 14 (Sonoma), Xcode 16, iOS 18. If you are using a physical device, then refer to the system requirements.

The app loads with the map centered on the Santa Monica Mountains in California with the parcels feature layer displayed. Choose an attribute expression and to display parcels that meet the selected criteria.

Alternatively, you can download the tutorial solution, as follows.

Option 2: Download the solution

Click the Download solution link under Solution and unzip the file to a location on your machine.
Open the .xcodeproj file in Xcode.

Since the downloaded solution does not contain authentication credentials, you must first set up authentication to create credentials, and then add the developer credentials to the solution.

Set up authentication

To access the secure ArcGIS location services ArcGIS Location Services, also referred to as Location Services, are services hosted by Esri that provide geospatial functionality for developing mapping applications. They include the ArcGIS Basemap Styles service, ArcGIS Static Basemap Tiles service, ArcGIS Places service, ArcGIS Geocoding service, ArcGIS Routing service, ArcGIS GeoEnrichment service, and ArcGIS Elevation service. An ArcGIS Location Platform or ArcGIS Online account is required to use the services. Learn more used in this tutorial, you must implement API key authentication API key authentication is a type of authentication that uses an API key to authenticate requests to ArcGIS services and secure portal items. Learn more or user authentication User authentication is a type of authentication that allows users with an ArcGIS account to sign into an application and allow it to access ArcGIS content, services, and resources on their behalf. The typical authorization protocol used is OAuth2.0. Learn more using an ArcGIS Location Platform An ArcGIS Location Platform account, formerly known as an ArcGIS Developer account, is an identity associated with an ArcGIS Location Platform subscription. Learn more or an ArcGIS Online An ArcGIS Online account, also known as an ArcGIS Organization account, is an identity associated with an ArcGIS Online subscription. It can be used to access ArcGIS tools and develop applications with ArcGIS location services for an organization. Learn more account.

You can implement API key authentication or user authentication in this tutorial. Compare the differences below:

API key authentication API key authentication is a type of authentication that uses an API key to authenticate requests to ArcGIS services and secure portal items. Learn more

Users are not required to sign in.
Requires creating an API key credential API key credentials are an item that contains the parameters used to create and manage long-lived access tokens for API key authentication. They are a type of developer credential. Learn more with the correct privileges.
API keys An API key is a long-lived access token created using API key credentials. They are valid for up to one year and are typically embedded directly into client applications. Learn more are long-lived access tokens.
Service usage is billed to the API key owner/developer.
Simplest authentication method to implement.
Recommended approach for new ArcGIS developers.

Learn more in API key authentication.

User authentication User authentication is a type of authentication that allows users with an ArcGIS account to sign into an application and allow it to access ArcGIS content, services, and resources on their behalf. The typical authorization protocol used is OAuth2.0. Learn more

Users are required to sign in with an ArcGIS account An ArcGIS account is an identity with a user type and set of privileges that can access specific ArcGIS products, tools, APIs, services, and resources. The main account types that can be used for development are an ArcGIS Location Platform account, ArcGIS Online account, and ArcGIS Enterprise account. ArcGIS Location Platform and ArcGIS Online accounts are also associated with a subscription. Learn more .
User accounts must have privilege Privileges are a set of permissions assigned to ArcGIS accounts, developer credentials, and applications that grant access to secure resources and functionality in ArcGIS. Learn more to access the ArcGIS services A service, also known as an ArcGIS service, is software that supports an ArcGIS REST API and provides geospatial functionality or data. A service can be hosted by Esri or in ArcGIS Enterprise. Learn more used in application.
Requires creating OAuth credentials OAuth credentials are an item that contains parameters required to implement user authentication or app authentication, including a client_id, client_secret, and redirect URIs. They are a type of developer credential. Learn more .
Application uses a redirect URL and client ID.
Service usage is billed to the organization of the user signed into the application.

Learn more in User authentication.

To complete this tutorial, click on the tab in the switcher below for your authentication type of choice, either API key authentication or User authentication.

Create a new API key access token An access token is an authorization string that provides access to secure ArcGIS content, data, and services. Its capabilities are determined by the privileges it supports. It is obtained by implementing API key authentication, User authentication, or App authentication. Learn more with privileges Privileges are a set of permissions assigned to ArcGIS accounts, developer credentials, and applications that grant access to secure resources and functionality in ArcGIS. Learn more to access the secure resources used in this tutorial.

Complete the Create an API key tutorial and create an API key with the following privilege(s) Privileges are a set of permissions assigned to ArcGIS accounts, developer credentials, and applications that grant access to secure resources and functionality in ArcGIS. Learn more :
- Privileges
  - Location services > Basemaps
Copy and paste the API key access token into a safe location. It will be used in a later step.

Create new OAuth credentials to access the secure resources used in this tutorial.

Complete the Create OAuth credentials for user authentication tutorial to obtain a Client ID and Redirect URL.

A Client ID uniquely identifies your app on the authenticating server. If the server cannot find an app with the provided Client ID, it will not proceed with authentication.
The Redirect URL (also referred to as a callback url) is used to identify a response from the authenticating server when the system returns control back to your app after an OAuth login. Since it does not necessarily represent a valid endpoint that a user could navigate to, the redirect URL can use a custom scheme, such as my-app://auth. It is important to make sure the redirect URL used in your app’s code matches a redirect URL configured on the authenticating server.
Copy and paste the Client ID and Redirect URL into a safe location. They will be used in a later step.

All users that access this application need account privileges Privileges are a set of permissions assigned to ArcGIS accounts, developer credentials, and applications that grant access to secure resources and functionality in ArcGIS. Learn more to access the ArcGIS Basemap Styles service The ArcGIS Basemap Styles service, also referred to as the Basemap Styles service, is a location service that provides basemap styles and data for the world. It returns styles as Mapbox styles and web maps, and data as vector tiles and/or map tiles. It supports all of the styles in the ArcGIS Basemap style and Open Basemap style family. An ArcGIS Location Platform or ArcGIS Online account is required to use the service. Learn more .

Set developer credentials in the solution

To allow your app users to access ArcGIS location services ArcGIS Location Services, also referred to as Location Services, are services hosted by Esri that provide geospatial functionality for developing mapping applications. They include the ArcGIS Basemap Styles service, ArcGIS Static Basemap Tiles service, ArcGIS Places service, ArcGIS Geocoding service, ArcGIS Routing service, ArcGIS GeoEnrichment service, and ArcGIS Elevation service. An ArcGIS Location Platform or ArcGIS Online account is required to use the services. Learn more , use the developer credentials that you created in the Set up authentication step to authenticate requests for resources.

Pass your API Key access token to the ArcGISEnvironment.

In the Project Navigator, click MainApp.swift.

Set the AuthenticationMode to .apiKey.

MainApp.swift

    // Change the `AuthenticationMode` to `.apiKey` if your application uses API key authentication.

    private var authenticationMode: AuthenticationMode { .apiKey }

Set the apiKey property with your API key access token.

MainApp.swift

31 collapsed lines
// Copyright 2022 Esri
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import SwiftUI
import ArcGIS
import ArcGISToolkit
@main

struct MainApp: App {

    // The authentication mode.
    private enum AuthenticationMode {
        case apiKey
        case user
    }

    // Change the `AuthenticationMode` to `.apiKey` if your application uses API key authentication.

    private var authenticationMode: AuthenticationMode { .apiKey }


    // Please enter an API key access token if your application uses API key authentication.

    private let apiKey = APIKey("<#YOUR-ACCESS-TOKEN#>")

43 collapsed lines

    // Setup an `Authenticator` with OAuth configuration if your application uses OAuth credentials.
    @ObservedObject var authenticator = Authenticator(
        oAuthUserConfigurations: [
            OAuthUserConfiguration(

                // Please enter OAuth credentials for user authentication.

                portalURL: URL(string: "<#YOUR-PORTAL-URL#>")!,
                clientID: "<#YOUR-CLIENT-ID#>",
                redirectURL: URL(string: "<#YOUR-REDIRECT-URL#>")!

            )
        ]
    )

    func setAuthentication() {
        switch authenticationMode {
        case .apiKey:
            ArcGISEnvironment.apiKey = apiKey
        case .user:
            ArcGISEnvironment.authenticationManager.arcGISAuthenticationChallengeHandler = authenticator
        }
    }

    init() {
        setAuthentication()
    }


    var body: some SwiftUI.Scene {

        WindowGroup {
            ContentView()

                .authenticator(authenticator)

                .ignoresSafeArea()

        }
    }

}

Best Practice: The access token is stored directly in the code as a convenience for this tutorial. Do not store credentials directly in source code in a production environment.

Use the Authenticator toolkit component to manage your OAuth credentials OAuth credentials are an item that contains parameters required to implement user authentication or app authentication, including a client_id, client_secret, and redirect URIs. They are a type of developer credential. Learn more and pass it to the ArcGISEnvironment.

In the Project Navigator, click MainApp.swift.

Set the AuthenticationMode to .user.

MainApp.swift

// Change the `AuthenticationMode` to `.user` if your application uses OAuth credentials.

private var authenticationMode: AuthenticationMode { .user }

Set your portalURL, clientID and redirectURL values.

MainApp.swift

36 collapsed lines
// Copyright 2022 Esri
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import SwiftUI
import ArcGIS
import ArcGISToolkit
@main

struct MainApp: App {

    // The authentication mode.
    private enum AuthenticationMode {
        case apiKey
        case user
    }

    // Change the `AuthenticationMode` to `.user` if your application uses OAuth credentials.

    private var authenticationMode: AuthenticationMode { .apiKey }


    // Please enter an API key access token if your application uses API key authentication.

    private let apiKey = APIKey("<#YOUR-ACCESS-TOKEN#>")


    // Setup an `Authenticator` with OAuth configuration if your application uses OAuth credentials.
    @ObservedObject var authenticator = Authenticator(
        oAuthUserConfigurations: [
            OAuthUserConfiguration(

                // Please enter OAuth credentials for user authentication.

                portalURL: URL(string: "<#YOUR-PORTAL-URL#>")!,
                clientID: "<#YOUR-CLIENT-ID#>",
                redirectURL: URL(string: "<#YOUR-REDIRECT-URL#>")!

            )
        ]
    )
28 collapsed lines

    func setAuthentication() {
        switch authenticationMode {
        case .apiKey:
            ArcGISEnvironment.apiKey = apiKey
        case .user:
            ArcGISEnvironment.authenticationManager.arcGISAuthenticationChallengeHandler = authenticator
        }
    }

    init() {
        setAuthentication()
    }


    var body: some SwiftUI.Scene {

        WindowGroup {
            ContentView()

                .authenticator(authenticator)

                .ignoresSafeArea()

        }
    }

}

Best Practice: The OAuth credentials are stored directly in the code as a convenience for this tutorial. Do not store credentials directly in source code in a production environment.

Run the solution

Press Command + R to run the app.

What’s next?

Learn how to use additional API features, ArcGIS location services, and ArcGIS tools in these tutorials:

QueryIntroduction NextEdit features