Query a feature layer (SQL)

Learn how to execute a SQL query to return features from a feature layer based on spatial and attribute criteria.

A feature layer can contain a large number of features stored in ArcGIS. You can query a layer to access a subset of its features using any combination of spatial and attribute criteria. You can control whether or not each feature's geometry 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 in the LA County Parcel feature layer (containing over 2.4 million features). Features that meet the query criteria are selected in the map.

Prerequisites

Steps

Open the Xcode project

1. To start the tutorial, complete the Display a map tutorial or download and unzip the solution.

2. Open the .xcodeproj file in Xcode.

3. If you downloaded the solution, get an access token and set the API key.

   Instructions to set the API Key

   An API Key gives your app access to secure resources used in this tutorial.

   1. Go to the Create an API key tutorial to obtain a new API key access token. Ensure that the following privilege is enabled: Location services > Basemaps > Basemap styles service. Copy the access token as it will be used in the next step.

   2. In Xcode, in the Project Navigator, click MainApp.swift.

   3. In the Editor, set the ArcGISEnvironment.apiKey property on the ArcGISEnvironment with your access token.

      MainApp.swift

      Expand

      Use dark colors for code blocks

      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
          init() {
              ArcGISEnvironment.apiKey = APIKey("<#YOUR-ACCESS-TOKEN#>")
          }
      

      Expand

Update the map

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

2. In the editor, modify the map variable's initial viewpoint.

   ContentView.swift

   Use dark colors for code blocks

   78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 78 79 80 81 82 83 83 83 83 83 83 84 85 85 85 85 85 85 85 85 85 85 85 85 85 85 85 85 85 85 85 85 85 85 85 85 85 85

   Change line

   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
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
           let map: Map = {
               let map = Map(basemapStyle: .arcGISTopographic)
   
               map.initialViewpoint = Viewpoint(latitude: 34.03000, longitude: -118.80500, scale: 6e4)
   
               return map
           }()
   

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

   ContentView.swift

   Use dark colors for code blocks

   58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 59 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 60 61 62 63 64 65 66 67 67 67 67 67 67 68 69 70 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 72 73 74

   Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.

   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
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   private extension ContentView {
   
       class Model: ObservableObject {
   
           let map: Map = {
               let map = Map(basemapStyle: .arcGISTopographic)
   
               map.initialViewpoint = Viewpoint(latitude: 34.03000, longitude: -118.80500, scale: 6e4)
   
               return map
           }()
   
   
       }
   
   }

4. 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

   Use dark colors for code blocks

   76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 75 74 73 72 71 70 69 68 67 66 65 64 63 62 61 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 77 77 77

   Add line.Add line.Add line.Add line.

   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
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
       class Model: ObservableObject {
   
           let map: Map = {
               let map = Map(basemapStyle: .arcGISTopographic)
   
               map.initialViewpoint = Viewpoint(latitude: 34.03000, longitude: -118.80500, scale: 6e4)
   
               let parcelsURL = URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0")!
               let featureTable = ServiceFeatureTable(url: parcelsURL)
               let featureLayer = FeatureLayer(featureTable: featureTable)
               map.addOperationalLayer(featureLayer)
   
               return map
           }()
   
   
       }
   

5. 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

   Use dark colors for code blocks

   18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 19 20 21 22 23 24 24 24 25 26 27 28 29 30 31 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 33 34 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35

   Add line.Change line

   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
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   struct ContentView: View {
   
       @StateObject private var model = Model()
   
       @State private var geoViewExtent: Envelope?
   
       var body: some View {
   
           MapView(map: model.map)
   
               .onVisibleAreaChanged { newVisibleArea in
                   geoViewExtent = newVisibleArea.extent
               }
   
       }
   
   }
   

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.

1. 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

   Use dark colors for code blocks

   58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 92 93 94 95

   Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.

   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
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   private extension ContentView {
   
       enum WhereClause: CaseIterable, Equatable {
           case government, residential, farm, taxRate10853, taxRate10860, landValueGreaterThan, landValueLessThan
   
           var expression: String {
               switch self {
               case .government: return "UseType = 'Government'"
               case .residential: return "UseType = 'Residential'"
               case .farm: return "UseType = 'Irrigated Farm'"
               case .taxRate10853: return "TaxRateArea = 10853"
               case .taxRate10860: return "TaxRateArea = 10860"
               case .landValueGreaterThan: return "Roll_LandValue > 1000000"
               case .landValueLessThan: return "Roll_LandValue < 1000000"
               }
           }
       }
   
       class Model: ObservableObject {
   
           let map: Map = {
               let map = Map(basemapStyle: .arcGISTopographic)
   
               map.initialViewpoint = Viewpoint(latitude: 34.03000, longitude: -118.80500, scale: 6e4)
   
               let parcelsURL = URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0")!
               let featureTable = ServiceFeatureTable(url: parcelsURL)
               let featureLayer = FeatureLayer(featureTable: featureTable)
               map.addOperationalLayer(featureLayer)
   
               return map
           }()
   
   
       }
   
   }

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.

1. 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

   Expand

   Use dark colors for code blocks

   18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 19 20 21 22 23 24 24 24 25 26 27 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 28 29 30 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31

   Add line.

   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
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   struct ContentView: View {
   
       @StateObject private var model = Model()
   
       @State private var geoViewExtent: Envelope?
   
       var body: some View {
   
           MapView(map: model.map)
   
       }
   
   }
   

   Expand

2. 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

   Expand

   Use dark colors for code blocks

   18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 19 20 21 22 23 24 24 24 25 26 27 28 29 30 31 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 33 34 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35

   Add line.Add line.Add line.

   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
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   struct ContentView: View {
   
       @StateObject private var model = Model()
   
       @State private var geoViewExtent: Envelope?
   
       var body: some View {
   
           MapView(map: model.map)
   
               .onVisibleAreaChanged { newVisibleArea in
                   geoViewExtent = newVisibleArea.extent
               }
   
       }
   
   }
   

   Expand

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

   ContentView.swift

   Expand

   Use dark colors for code blocks

   76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 76 75 74 74 74 74 74 74 74 74 74 73 72 71 70 69 68 67 66 65 64 63 62 61 60 59 58 57 56 55 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 91 91

   Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.

   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
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
       class Model: ObservableObject {
   
           let map: Map = {
               let map = Map(basemapStyle: .arcGISTopographic)
   
               map.initialViewpoint = Viewpoint(latitude: 34.03000, longitude: -118.80500, scale: 6e4)
   
               let parcelsURL = URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0")!
               let featureTable = ServiceFeatureTable(url: parcelsURL)
               let featureLayer = FeatureLayer(featureTable: featureTable)
               map.addOperationalLayer(featureLayer)
   
               return map
           }()
   
   
           func queryFeatureLayer(with selectedWhereClause: WhereClause, in extent: Envelope) async {
               guard
                   let parcelsFeatureLayer = map.operationalLayers.first as? FeatureLayer,
                   let featureTable = parcelsFeatureLayer.featureTable
               else { return }
               parcelsFeatureLayer.clearSelection()
   
               let parameters = QueryParameters()
               parameters.whereClause = selectedWhereClause.expression
               parameters.geometry = extent
   
               do {
                   let result = try await featureTable.queryFeatures(using: parameters)
                   let features = result.features()
                   parcelsFeatureLayer.selectFeatures(features)
               } catch {
                   print(error)
               }
           }
   
       }
   

   Expand

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.

1. 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

   Expand

   Use dark colors for code blocks

   18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 34 34 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 20 20 20 21 22 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23

   Add line.

   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
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   struct ContentView: View {
   
       @StateObject private var model = Model()
   
       @State private var geoViewExtent: Envelope?
   
       @State private var selectedWhereClause: WhereClause = .government
   
       var body: some View {
   
           MapView(map: model.map)
   
               .onVisibleAreaChanged { newVisibleArea in
                   geoViewExtent = newVisibleArea.extent
               }
   
       }
   
   }
   

   Expand

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

   ContentView.swift

   Expand

   Use dark colors for code blocks

   26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 27 28 29 30 31 32 33 34 35 36 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 38 39 40 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41

   Add line.Add line.Add line.Add line.Add line.

   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
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
       var body: some View {
   
           MapView(map: model.map)
   
               .onVisibleAreaChanged { newVisibleArea in
                   geoViewExtent = newVisibleArea.extent
               }
   
               .toolbar {
                   ToolbarItemGroup(placement: .bottomBar) {
   
                   }
               }
   
       }
   

   Expand

3. 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

   Expand

   Use dark colors for code blocks

   26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 43 43 43 43 43 44 45 46 47 48 49 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50

   Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.

   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
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
       var body: some View {
   
           MapView(map: model.map)
   
               .onVisibleAreaChanged { newVisibleArea in
                   geoViewExtent = newVisibleArea.extent
               }
   
               .toolbar {
                   ToolbarItemGroup(placement: .bottomBar) {
   
                       Spacer()
                       Picker("Choose an SQL `where` clause", selection: $selectedWhereClause) {
                           ForEach(WhereClause.allCases, id: \.self) { clause in
                               Text(clause.expression)
                           }
   
                       }
                       Spacer()
   
                   }
               }
   
       }
   

   Expand

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

   ContentView.swift

   Expand

   Use dark colors for code blocks

   26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 26 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 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55

   Add line.Add line.Add line.Add line.

   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
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
       var body: some View {
   
           MapView(map: model.map)
   
               .onVisibleAreaChanged { newVisibleArea in
                   geoViewExtent = newVisibleArea.extent
               }
   
               .toolbar {
                   ToolbarItemGroup(placement: .bottomBar) {
   
                       Spacer()
                       Picker("Choose an SQL `where` clause", selection: $selectedWhereClause) {
                           ForEach(WhereClause.allCases, id: \.self) { clause in
                               Text(clause.expression)
                           }
   
                           .task(id: selectedWhereClause) {
                               guard let geoViewExtent = geoViewExtent else { return }
                               await model.queryFeatureLayer(with: selectedWhereClause, in: geoViewExtent)
                           }
   
                       }
                       Spacer()
   
                   }
               }
   
       }
   

   Expand

Run the app

Press Command + R to run the app.

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.

What's next?

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

• Add a point, line, and polygon
• Add a feature layer