Пример #1
0
def showQueryBuilder(gtoObj, debug, *args, **kwargs):
    try:
        iface = gtoObj.iface
        info = gtoObj.info

        layer = iface.activeLayer()
        query_builder = QgsQueryBuilder(layer, iface.mainWindow())
        query_builder.show()
    except Exception as e:
        info.err(e)
Пример #2
0
    def setFilter(self):
        from qgis.gui import QgsQueryBuilder
        layer = self._getSqlLayer("")
        if not layer:
            return

        dlg = QgsQueryBuilder(layer)
        dlg.setSql(self.filter)
        if dlg.exec_():
            self.filter = dlg.sql()
        layer.deleteLater()
 def showQueryBuilder(self, layer, filter, sql=None):
     try:
         if not layer: layer = self.iface.activeLayer()
         self.query_builder = QgsQueryBuilder(layer,
                                              self.iface.mainWindow())
         if sql: self.query_builder.setSql(sql)
         self.query_builder.accept()
         result = self.query_builder.exec_()
         if self.debug:
             self.info.log("QueryBuilder", self.query_builder.sql(), result,
                           layer.subsetString())
         if not filter: layer.setSubsetString(None)
         return result, self.query_builder.sql()
     except Exception as e:
         self.info.err(e)
    def run_filter(self):
        """Run method that performs the filter"""

        #Retrieve selected layers (or group members)
        selectedLayers = iface.layerTreeView().selectedLayersRecursive()
        #Sadly, the layer order is not good, so will sort it by name
        sortedSelectedLayers = sorted(selectedLayers, key=lambda x: x.name())

        # To creates layer
        # layer = QgsVectorLayer("Point?crs=epsg:4326&index=yes",
        #                     "temporary_points", "memory")
        # QgsProject.instance().addMapLayer(layer)

        # Look up for the first valid layer
        for layer in sortedSelectedLayers:

            if layer and layer.isValid():

                #Fire up the query builder based on the first layer
                query_builder = QgsQueryBuilder(layer)
                #query_builder.setSql(u'"age" > 30')
                query_builder.accept()

                if query_builder.exec_():  #exec_ waits, show not

                    expression = query_builder.sql()

                    #Set filter for all selected layers
                    for layer in sortedSelectedLayers:
                        layer.setSubsetString(expression)
                        layer.triggerRepaint()
                        #print(layer)
                        #print(layer.id())

                del (query_builder)
                del (layer)

                #exit loop
                break
pr = vl.dataProvider()

# add fields
pr.addAttributes([
    QgsField("name", QVariant.String),
    QgsField("age", QVariant.Int),
    QgsField("size", QVariant.Double)
])
vl.updateFields()  # tell the vector layer to fetch changes from the provider

infos = [[10, 10, "John", 24, 1.73], [40, -60, "Paul", 29, 1.86],
         [60, 5, "George", 34, 1.69], [0, 45, "Ringo", 73, 1.75]]

# add features
for i in infos:
    fet = QgsFeature()
    fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(i[0], i[1])))
    fet.setAttributes(i[2:5])
    pr.addFeatures([fet])

# update layer's extent when new features have been added
# because change of extent in provider is not propagated to the layer
vl.updateExtents()

QgsMapLayerRegistry.instance().addMapLayer(vl)

query_builder = QgsQueryBuilder(vl)
query_builder.setSql(u'"age" > 30')
query_builder.accept()
query_builder.show()