Query a feature layer (SQL)

Before starting this tutorial:

1. You need an ArcGIS Location Platform or ArcGIS Online account.

2. Your system meets the system requirements.

3. The ArcGIS Maps SDK for Qt, version 200.6.0 or later is installed.

4. The Qt 6.5.6 software development framework is installed.

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.

Open a Qt Creator project

1. Open the project you created by completing the Display a map tutorial.
2. 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 header file

This app will use various functions and member variables that need to be declared in the header file.

1. In Projects, double-click Headers > Display_a_map.h to open the file.

2. Forward declare the following classes.

   Display_a_map.h

   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
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   namespace ArcGISRuntime
   {
   class Map;
   class MapQuickView;
   
   class FeatureLayer;
   class ServiceFeatureTable;
   

3. Add the following code to define a function called runQuery that will be invokable from the GUI.

   Display_a_map.h

   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
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   public:
       explicit Display_a_map(QObject* parent = nullptr);
       ~Display_a_map() override;
   
       Q_INVOKABLE void runQuery(const QString& expression);
   

4. Declare the following private function and member variables. Then save and close the file.

   Display_a_map.h

   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
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   private:
       Esri::ArcGISRuntime::MapQuickView* mapView() const;
       void setMapView(Esri::ArcGISRuntime::MapQuickView* mapView);
       void setupViewpoint();
   
       void addFeatureLayer();
       Esri::ArcGISRuntime::FeatureLayer* m_featureLayer = nullptr;
       Esri::ArcGISRuntime::ServiceFeatureTable* m_featureTable = nullptr;
   

   Expand

Include header files in the source code

To create this app you will need to include several class header files from the ArcGIS Maps Qt C++ API.

1. In Projects, double-click Sources > Display_a_map.cpp to open the file.

2. Add the following include statements. Each of these classes are needed for this tutorial.

   Display_a_map.cpp

   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
   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
   116
   117
   118
   119
   #include "Display_a_map.h"
   #include "Map.h"
   #include "MapTypes.h"
   #include "MapQuickView.h"
   #include "Point.h"
   #include "Viewpoint.h"
   #include "SpatialReference.h"
   #include <QFuture>
   
   #include "Envelope.h"
   #include "Feature.h"
   #include "FeatureLayer.h"
   #include "LayerListModel.h"
   #include "FeatureIterator.h"
   #include "FeatureQueryResult.h"
   #include "QueryParameters.h"
   #include "SelectionProperties.h"
   #include "ServiceFeatureTable.h"
   #include <memory>
   #include <QColor>
   #include <QList>
   #include <QUuid>
   #include <QUrl>
   

Add a feature layer, query features, and select results

You will add three functions to add a feature layer from ArcGIS online, execute a query of that layer, and create a features list from the query result.

1. Add code to create the addFeatureLayer function. This function adds the LA_County_Parcels feature layer hosted on ArcGIS Online to the map.

   Display_a_map.cpp

   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
   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
   116
   117
   118
   119
   void Display_a_map::setupViewpoint()
   {
       const Point center(-118.80543, 34.02700, SpatialReference::wgs84());
       const Viewpoint viewpoint(center, 100000.0);
       m_mapView->setViewpointAsync(viewpoint);
   }
   
   void Display_a_map::addFeatureLayer()
   {
       // Create a ServiceFeatureTable from a QUrl.
       m_featureTable = new ServiceFeatureTable(QUrl("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0"), this);
       // Create the feature layer using the feature table.
       m_featureLayer = new FeatureLayer(m_featureTable, this);
       // Add the feature layer to the map.
       m_map->operationalLayers()->append(m_featureLayer);
   }
   

2. Add the following function to implement the query. The runQuery function executes a query of the parcels layer. This function creates a QueryParameters object that includes the currently visible map extent and a SQL expression, and then executes the query on the parcels table. When a query completes, the code iterates the returned results and adds those features to a list. That list is then used to select features in the parcels layer.

   Display_a_map.cpp

   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
   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
   116
   117
   118
   119
   void Display_a_map::addFeatureLayer()
   {
       // Create a ServiceFeatureTable from a QUrl.
       m_featureTable = new ServiceFeatureTable(QUrl("https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/LA_County_Parcels/FeatureServer/0"), this);
       // Create the feature layer using the feature table.
       m_featureLayer = new FeatureLayer(m_featureTable, this);
       // Add the feature layer to the map.
       m_map->operationalLayers()->append(m_featureLayer);
   }
   
   void Display_a_map::runQuery(const QString& expression)
   {
       if (!m_featureTable)
           return;
   
       // Create a query parameter object and set the WhereClause.
       QueryParameters queryParams;
       queryParams.setGeometry(m_mapView->currentViewpoint(ViewpointType::BoundingGeometry).targetGeometry().extent());
       queryParams.setWhereClause(expression);
       m_featureTable->queryFeaturesAsync(queryParams).then(this,[this](FeatureQueryResult* rawQueryResult)
       {
           if (!rawQueryResult)
               return;
   
           // Wrap the FeatureQueryResult in a unique_ptr to manage the memory effectively.
           auto queryResult = std::unique_ptr<FeatureQueryResult>(rawQueryResult);
   
           // Clear any existing selection.
           m_featureLayer->clearSelection();
           QList<Feature*> features;
   
           // Iterate over the result object.
           while(queryResult->iterator().hasNext())
           {
               Feature* feature = queryResult->iterator().next(this);
               // Add each feature to the list.
               features.append(feature);
           }
           // Select features.
           m_featureLayer->selectFeatures(features);
       });
   }
   

3. By default, selected features in the map view are displayed in cyan. Modify the setMapView function to call your new function and also set the color for displaying selected parcel layer features (or any other selection) in your map view. Then save the file.

   Display_a_map.cpp

   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
   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
   116
   117
   118
   119
   // Set the view (created in QML)
   void Display_a_map::setMapView(MapQuickView* mapView)
   {
       if (!mapView || mapView == m_mapView)
       {
           return;
       }
       m_mapView = mapView;
       m_mapView->setMap(m_map);
   
       addFeatureLayer();
       m_mapView->setSelectionProperties(SelectionProperties(QColor(Qt::yellow)));
   

   Expand

Show a list of query expressions for the user to choose from

You will create a UI that allows the user to choose from a list of predefined query expressions. The expressions are presented in a ComboBox control and when the user makes a choice, the expression is passed to the runQuery method to find parcels that meet the selected criterion within the currently visible map extent.

1. In Projects, double-click Resources > qml\qml.qrc/qml/Display_a_mapForm.qml to open the file.

2. Add the following code to create a ComboBox control to execute a predefined query expression.

   Display_a_mapForm.qml

   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
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
       // Declare the C++ instance that creates the map etc., and supply the view.
       Display_a_map {
           id: model
           mapView: view
       }
   
       ComboBox {
           id: queryComboBox
           anchors {
               left: parent.left
               top: parent.top
               margins: 15
           }
   
           property int bestWidth: implicitWidth
           width: bestWidth + leftPadding + rightPadding
           model: ["Choose a SQL where clause",
               "UseType = 'Government'",
               "UseType = 'Residential'",
               "UseType = 'Irrigated Farm'",
               "TaxRateArea = 10853",
               "TaxRateArea = 10860",
               "Roll_LandValue > 1000000",
               "Roll_LandValue < 1000000"]
   
           onCurrentTextChanged: {
               model.runQuery(queryComboBox.currentText)
           }
       }
   

   Expand

3. Press Ctrl + 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 parcels in the current extent that meet the selected criteria will display in the specified selection color.

Option 2: Download the solution

1. Click the Download solution link under Solution and unzip the file to a location on your machine.

2. Open the project in Qt Creator.

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

Set up authentication

To access the secure ArcGIS location services used in this tutorial, you must implement API key authentication using an ArcGIS Location Platform or an ArcGIS Online account.

Set developer credentials in the solution

To allow your app users to access ArcGIS location services, use the developer credentials that you created in the Set up authentication step to authenticate requests for resources.

Run the solution

Press Ctrl + 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 parcels in the current extent that meet the selected criteria will display in the specified selection color.