[FEATURE] [DBManager] Add a GeoPackage dedicated plugin

python/plugins/db_manager/db_model.py

@@ -300,6 +300,7 @@ class DBModel(QAbstractItemModel):
             self.importVector.connect(self.vectorImport)
 
         self.hasSpatialiteSupport = "spatialite" in supportedDbTypes()
+        self.hasGPKGSupport = "gpkg" in supportedDbTypes()
 
         self.rootItem = TreeItem(None, None)
         for dbtype in supportedDbTypes():
@@ -401,7 +402,7 @@ class DBModel(QAbstractItemModel):
                     flags |= Qt.ItemIsDropEnabled
 
             # SL/Geopackage db files can be dropped everywhere in the tree
-            if self.hasSpatialiteSupport:
+            if self.hasSpatialiteSupport or self.hasGPKGSupport:
                 flags |= Qt.ItemIsDropEnabled
 
         return flags

python/plugins/db_manager/db_plugins/CMakeLists.txt

@@ -1,5 +1,6 @@
 ADD_SUBDIRECTORY(postgis)
 ADD_SUBDIRECTORY(spatialite)
+ADD_SUBDIRECTORY(gpkg)
 IF(WITH_ORACLE)
   ADD_SUBDIRECTORY(oracle)
 ENDIF(WITH_ORACLE)

python/plugins/db_manager/db_plugins/__init__.py

@@ -25,7 +25,8 @@ from builtins import str
 class NotSupportedDbType(Exception):
 
     def __init__(self, dbtype):
-        self.msg = self.tr("%s is not supported yet") % dbtype
+        from qgis.PyQt.QtWidgets import QApplication
+        self.msg = QApplication.translate("DBManagerPlugin", "%s is not supported yet" % dbtype)
         Exception(self, self.msg)
 
     def __str__(self):

python/plugins/db_manager/db_plugins/gpkg/CMakeLists.txt

@@ -0,0 +1,9 @@
+
+FILE(GLOB PY_FILES *.py)
+FILE(GLOB ICON_FILES icons/*.png)
+
+PYQT_ADD_RESOURCES(PYRC_FILES resources.qrc)
+
+PLUGIN_INSTALL(db_manager db_plugins/gpkg ${PY_FILES} ${PYRC_FILES})
+PLUGIN_INSTALL(db_manager db_plugins/gpkg/icons ${ICON_FILES})
+

python/plugins/db_manager/db_plugins/gpkg/connector.py

@@ -0,0 +1,796 @@
+# -*- coding: utf-8 -*-
+
+"""
+/***************************************************************************
+Name                 : DB Manager
+Description          : Database manager plugin for QGIS
+Date                 : Oct 14 2016
+copyright            : (C) 2016 by Even Rouault
+                       (C) 2011 by Giuseppe Sucameli
+email                : even.rouault at spatialys.com
+
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+"""
+from builtins import str
+
+from functools import cmp_to_key
+
+from qgis.PyQt.QtWidgets import QApplication
+
+from ..connector import DBConnector
+from ..plugin import ConnectionError, DbError, Table
+
+from qgis.utils import spatialite_connect
+import sqlite3
+
+from osgeo import gdal, ogr, osr
+
+
+def classFactory():
+    return GPKGDBConnector
+
+
+class GPKGDBConnector(DBConnector):
+
+    def __init__(self, uri):
+        DBConnector.__init__(self, uri)
+
+        self.dbname = uri.database()
+        self.has_raster = False
+        self.mapSridToName = {}
+
+        if hasattr(gdal, 'OpenEx'):
+            # GDAL >= 2
+            self.gdal_ds = gdal.OpenEx(self.dbname, gdal.OF_UPDATE)
+            if self.gdal_ds is None:
+                self.gdal_ds = gdal.OpenEx(self.dbname)
+            if self.gdal_ds is None or self.gdal_ds.GetDriver().ShortName != 'GPKG':
+                raise ConnectionError(QApplication.translate("DBManagerPlugin", '"{0}" not found').format(self.dbname))
+            self.has_raster = self.gdal_ds.RasterCount != 0 or self.gdal_ds.GetMetadata('SUBDATASETS') is not None
+            self.connection = None
+            self.gdal2 = True
+        else:
+            # GDAL 1.X compat. To be removed at some point
+            self.gdal_ds = ogr.Open(self.dbname, update=1)
+            if self.gdal_ds is None:
+                self.gdal_ds = ogr.Open(self.dbname)
+            if self.gdal_ds is None or self.gdal_ds.GetDriver().GetName() != 'GPKG':
+                raise ConnectionError(QApplication.translate("DBManagerPlugin", '"{0}" not found').format(self.dbname))
+            # For GDAL 1.X, we cannot issue direct SQL SELECT to the OGR datasource
+            # so we need a direct sqlite connection
+            try:
+                self.connection = spatialite_connect(str(self.dbname))
+            except self.connection_error_types() as e:
+                raise ConnectionError(e)
+            self.gdal2 = False
+
+    def unquoteId(self, quotedId):
+        if len(quotedId) <= 2 or quotedId[0] != '"' or quotedId[len(quotedId) - 1] != '"':
+            return quotedId
+        unquoted = ''
+        i = 1
+        while i < len(quotedId) - 1:
+            if quotedId[i] == '"' and quotedId[i + 1] == '"':
+                unquoted += '"'
+                i += 2
+            else:
+                unquoted += quotedId[i]
+                i += 1
+        return unquoted
+
+    def _fetchOne(self, sql):
+        if not self.gdal2:
+            # GDAL 1.X compat. To be removed at some point
+            c = self._get_cursor()
+            self._execute(c, sql)
+            res = c.fetchone()
+            if res is not None:
+                return res
+            else:
+                return None
+        else:
+            sql_lyr = self.gdal_ds.ExecuteSQL(sql)
+            if sql_lyr is None:
+                return None
+            f = sql_lyr.GetNextFeature()
+            if f is None:
+                ret = None
+            else:
+                ret = [f.GetField(i) for i in range(f.GetFieldCount())]
+            self.gdal_ds.ReleaseResultSet(sql_lyr)
+            return ret
+
+    def _fetchAll(self, sql, include_fid_and_geometry=False):
+        if not self.gdal2:
+            # GDAL 1.X compat. To be removed at some point
+            c = self._get_cursor()
+            self._execute(c, sql)
+            return c.fetchall()
+        else:
+            sql_lyr = self.gdal_ds.ExecuteSQL(sql)
+            if sql_lyr is None:
+                return None
+            ret = []
+            while True:
+                f = sql_lyr.GetNextFeature()
+                if f is None:
+                    break
+                else:
+                    if include_fid_and_geometry:
+                        field_vals = [f.GetFID()]
+                        if sql_lyr.GetLayerDefn().GetGeomType() != ogr.wkbNone:
+                            geom = f.GetGeometryRef()
+                            if geom is not None:
+                                geom = geom.ExportToWkt()
+                            field_vals += [geom]
+                        field_vals += [f.GetField(i) for i in range(f.GetFieldCount())]
+                        ret.append(field_vals)
+                    else:
+                        ret.append([f.GetField(i) for i in range(f.GetFieldCount())])
+            self.gdal_ds.ReleaseResultSet(sql_lyr)
+            return ret
+
+    def _fetchAllFromLayer(self, table):
+
+        lyr = self.gdal_ds.GetLayerByName(table.name)
+        if lyr is None:
+            return []
+
+        lyr.ResetReading()
+        ret = []
+        while True:
+            f = lyr.GetNextFeature()
+            if f is None:
+                break
+            else:
+                field_vals = [f.GetFID()]
+                if lyr.GetLayerDefn().GetGeomType() != ogr.wkbNone:
+                    geom = f.GetGeometryRef()
+                    if geom is not None:
+                        geom = geom.ExportToWkt()
+                    field_vals += [geom]
+                field_vals += [f.GetField(i) for i in range(f.GetFieldCount())]
+                ret.append(field_vals)
+        return ret
+
+    def _execute_and_commit(self, sql):
+        if not self.gdal2:
+            DBConnector._execute_and_commit(self, sql)
+        else:
+            sql_lyr = self.gdal_ds.ExecuteSQL(sql)
+            self.gdal_ds.ReleaseResultSet(sql_lyr)
+
+    def _execute(self, cursor, sql):
+
+        if self.gdal2 and self.connection is None:
+            # Needed when evaluating a SQL query
+            try:
+                self.connection = spatialite_connect(str(self.dbname))
+            except self.connection_error_types() as e:
+                raise ConnectionError(e)
+
+        return DBConnector._execute(self, cursor, sql)
+
+    def _commit(self):
+        if not self.gdal2:
+            return
+
+        try:
+            self.connection.commit()
+
+        except self.connection_error_types() as e:
+            raise ConnectionError(e)
+
+        except self.execution_error_types() as e:
+            # do the rollback to avoid a "current transaction aborted, commands ignored" errors
+            self._rollback()
+            raise DbError(e)
+
+    @classmethod
+    def isValidDatabase(self, path):
+        if hasattr(gdal, 'OpenEx'):
+            ds = gdal.OpenEx(self.dbname)
+            if ds is None or ds.GetDriver().ShortName != 'GPKG':
+                return False
+        else:
+            ds = ogr.Open(path)
+            if ds is None or ds.GetDriver().GetName() != 'GPKG':
+                return False
+        return True
+
+    def getInfo(self):
+        return None
+
+    def getSpatialInfo(self):
+        return None
+
+    def hasSpatialSupport(self):
+        return True
+
+    def hasRasterSupport(self):
+        return self.has_raster
+
+    def hasCustomQuerySupport(self):
+        return True
+
+    def hasTableColumnEditingSupport(self):
+        return True
+
+    def hasCreateSpatialViewSupport(self):
+        return False
+
+    def fieldTypes(self):
+        # From "Table 1. GeoPackage Data Types" (http://www.geopackage.org/spec/)
+        return [
+            "TEXT",
+            "MEDIUMINT",
+            "INTEGER",
+            "TINYINT",
+            "SMALLINT",
+            "DOUBLE",
+            "FLOAT"
+            "DATE",
+            "DATETIME",
+            "BOOLEAN",
+        ]
+
+    def getSchemas(self):
+        return None
+
+    def getTables(self, schema=None, add_sys_tables=False):
+        """ get list of tables """
+        items = []
+
+        try:
+            vectors = self.getVectorTables(schema)
+            for tbl in vectors:
+                items.append(tbl)
+        except DbError:
+            pass
+
+        try:
+            rasters = self.getRasterTables(schema)
+            for tbl in rasters:
+                items.append(tbl)
+        except DbError:
+            pass
+
+        for i, tbl in enumerate(items):
+            tbl.insert(3, False) # not system table
+
+        return sorted(items, key=cmp_to_key(lambda x, y: (x[1] > y[1]) - (x[1] < y[1])))
+
+    def getVectorTables(self, schema=None):
+
+        items = []
+        for i in range(self.gdal_ds.GetLayerCount()):
+            lyr = self.gdal_ds.GetLayer(i)
+            geomtype = lyr.GetGeomType()
+            if hasattr(ogr, 'GT_Flatten'):
+                geomtype_flatten = ogr.GT_Flatten(geomtype)
+            else:
+                geomtype_flatten = geomtype
+            geomname = ogr.GeometryTypeToName(geomtype_flatten).upper()
+            geomdim = 'XY'
+            if hasattr(ogr, 'GT_HasZ') and ogr.GT_HasZ(lyr.GetGeomType()):
+                geomdim += 'Z'
+            if hasattr(ogr, 'GT_HasM') and ogr.GT_HasM(lyr.GetGeomType()):
+                geomdim += 'M'
+            srs = lyr.GetSpatialRef()
+            srid = None
+            if srs is not None:
+                if srs.IsProjected():
+                    name = srs.GetAttrValue('PROJCS', 0)
+                elif srs.IsGeographic():
+                    name = srs.GetAttrValue('GEOGCS', 0)
+                else:
+                    name = None
+                srid = srs.GetAuthorityCode(None)
+                if srid is not None:
+                    srid = int(srid)
+                else:
+                    srid = self._fetchOne('SELECT srid FROM gpkg_spatial_ref_sys WHERE table_name = %s' % self.quoteString(lyr.GetName()))
+                    if srid is not None:
+                        srid = int(srid)
+                self.mapSridToName[srid] = name
+
+            if geomtype == ogr.wkbNone:
+                item = list([Table.TableType,
+                            lyr.GetName(),
+                            False, # is_view
+                             ])
+            else:
+                item = list([Table.VectorType,
+                            lyr.GetName(),
+                            False, # is_view
+                            lyr.GetName(),
+                            lyr.GetGeometryColumn(),
+                            geomname,
+                            geomdim,
+                            srid])
+            items.append(item)
+        return items
+
+    def getRasterTables(self, schema=None):
+        """ get list of table with a geometry column
+                it returns:
+                        name (table name)
+                        type = 'view' (is a view?)
+                        geometry_column:
+                                r.table_name (the prefix table name, use this to load the layer)
+                                r.geometry_column
+                                srid
+        """
+
+        sql = u"""SELECT table_name, 0 AS is_view, table_name AS r_table_name, '' AS r_geometry_column, srs_id FROM gpkg_contents WHERE data_type = 'tiles'"""
+        ret = self._fetchAll(sql)
+        if ret is None:
+            return []
+        items = []
+        for i, tbl in enumerate(ret):
+            item = list(tbl)
+            item.insert(0, Table.RasterType)
+            items.append(item)
+        return items
+
+    def getTableRowCount(self, table):
+        lyr = self.gdal_ds.GetLayerByName(self.getSchemaTableName(table)[1])
+        return lyr.GetFeatureCount() if lyr is not None else None
+
+    def getTableFields(self, table):
+        """ return list of columns in table """
+        sql = u"PRAGMA table_info(%s)" % (self.quoteId(table))
+        ret = self._fetchAll(sql)
+        if ret is None:
+            ret = []
+        return ret
+
+    def getTableIndexes(self, table):
+        """ get info about table's indexes """
+        sql = u"PRAGMA index_list(%s)" % (self.quoteId(table))
+        indexes = self._fetchAll(sql)
+        if indexes is None:
+            return []
+
+        for i, idx in enumerate(indexes):
+            # sqlite has changed the number of columns returned by index_list since 3.8.9
+            # I am not using self.getInfo() here because this behaviour
+            # can be changed back without notice as done for index_info, see:
+            # http://repo.or.cz/sqlite.git/commit/53555d6da78e52a430b1884b5971fef33e9ccca4
+            if len(idx) == 3:
+                num, name, unique = idx
+            if len(idx) == 5:
+                num, name, unique, createdby, partial = idx
+            sql = u"PRAGMA index_info(%s)" % (self.quoteId(name))
+
+            idx = [num, name, unique]
+            cols = []
+            for seq, cid, cname in self._fetchAll(sql):
+                cols.append(cid)
+            idx.append(cols)
+            indexes[i] = idx
+
+        return indexes
+
+    def getTableConstraints(self, table):
+        return None
+
+    def getTableTriggers(self, table):
+
+        _, tablename = self.getSchemaTableName(table)
+        # Do not list rtree related triggers as we don't want them to be dropped
+        sql = u"SELECT name, sql FROM sqlite_master WHERE tbl_name = %s AND type = 'trigger'" % (self.quoteString(tablename))
+        if self.isVectorTable(table):
+            sql += u" AND name NOT LIKE 'rtree_%%'"
+        elif self.isRasterTable(table):
+            sql += u" AND name NOT LIKE '%%_zoom_insert'"
+            sql += u" AND name NOT LIKE '%%_zoom_update'"
+            sql += u" AND name NOT LIKE '%%_tile_column_insert'"
+            sql += u" AND name NOT LIKE '%%_tile_column_update'"
+            sql += u" AND name NOT LIKE '%%_tile_row_insert'"
+            sql += u" AND name NOT LIKE '%%_tile_row_update'"
+        return self._fetchAll(sql)
+
+    def deleteTableTrigger(self, trigger, table=None):
+        """ delete trigger """
+        sql = u"DROP TRIGGER %s" % self.quoteId(trigger)
+        self._execute_and_commit(sql)
+
+    def getTableExtent(self, table, geom, force=False):
+        """ find out table extent """
+        _, tablename = self.getSchemaTableName(table)
+
+        if self.isRasterTable(table):
+
+            md = self.gdal_ds.GetMetadata('SUBDATASETS')
+            if md is None or len(md) == 0:
+                ds = self.gdal_ds
+            else:
+                subdataset_name = 'GPKG:%s:%s' % (self.gdal_ds.GetDescription(), tablename)
+                ds = gdal.Open(subdataset_name)
+            if ds is None:
+                return None
+            gt = ds.GetGeoTransform()
+            minx = gt[0]
+            maxx = gt[0] + gt[1] * ds.RasterYSize
+            maxy = gt[3]
+            miny = gt[3] + gt[5] * ds.RasterYSize
+
+            return (minx, miny, maxx, maxy)
+
+        lyr = self.gdal_ds.GetLayerByName(tablename)
+        if lyr is None:
+            return None
+        ret = lyr.GetExtent(force=force, can_return_null=True)
+        if ret is None:
+            return None
+        minx, maxx, miny, maxy = ret
+        return (minx, miny, maxx, maxy)
+
+    def getViewDefinition(self, view):
+        """ returns definition of the view """
+        return None
+
+    def getSpatialRefInfo(self, srid):
+        if srid in self.mapSridToName:
+            return self.mapSridToName[srid]
+
+        sql = u"SELECT srs_name FROM gpkg_spatial_ref_sys WHERE srs_id = %s" % self.quoteString(srid)
+        res = self._fetchOne(sql)
+        if res is not None:
+            res = res[0]
+        self.mapSridToName[srid] = res
+        return res
+
+    def isVectorTable(self, table):
+
+        _, tablename = self.getSchemaTableName(table)
+        return self.gdal_ds.GetLayerByName(tablename) is not None
+
+    def isRasterTable(self, table):
+        if self.has_raster and not self.isVectorTable(table):
+            _, tablename = self.getSchemaTableName(table)
+            md = self.gdal_ds.GetMetadata('SUBDATASETS')
+            if md is None or len(md) == 0:
+                sql = u"SELECT COUNT(*) FROM gpkg_contents WHERE data_type = 'tiles' AND table_name = %s" % self.quoteString(tablename)
+                ret = self._fetchOne(sql)
+                return ret is not None and ret[0] == 1
+            else:
+                subdataset_name = 'GPKG:%s:%s' % (self.gdal_ds.GetDescription(), tablename)
+                for key in md:
+                    if md[key] == subdataset_name:
+                        return True
+
+        return False
+
+    def getOGRFieldTypeFromSQL(self, sql_type):
+        ogr_type = ogr.OFTString
+        ogr_subtype = ogr.OFSTNone
+        width = 0
+        if not sql_type.startswith('TEXT ('):
+            pos = sql_type.find(' (')
+            if pos >= 0:
+                sql_type = sql_type[0:pos]
+        if sql_type == 'BOOLEAN':
+            ogr_type = ogr.OFTInteger
+            ogr_subtype = ogr.OFSTBoolean
+        elif sql_type in ('TINYINT', 'SMALLINT', 'MEDIUMINT'):
+            ogr_type = ogr.OFTInteger
+        elif sql_type == 'INTEGER':
+            ogr_type = ogr.OFTInteger64
+        elif sql_type == 'FLOAT':
+            ogr_type = ogr.OFTReal
+            ogr_subtype = ogr.OFSTFloat32
+        elif sql_type == 'DOUBLE':
+            ogr_type = ogr.OFTReal
+        elif sql_type == 'DATE':
+            ogr_type = ogr.OFTDate
+        elif sql_type == 'DATETIME':
+            ogr_type = ogr.OFTDateTime
+        elif sql_type.startswith('TEXT (') and sql_type.endswith(')'):
+            width = int(sql_type[len('TEXT ('):-1])
+        return (ogr_type, ogr_subtype, width)
+
+    def createOGRFieldDefnFromSQL(self, sql_fielddef):
+        f_split = sql_fielddef.split(' ')
+        quoted_name = f_split[0]
+        name = self.unquoteId(quoted_name)
+        sql_type = f_split[1].upper()
+        ogr_type, ogr_subtype, width = self.getOGRFieldTypeFromSQL(sql_type)
+        fld_defn = ogr.FieldDefn(name, ogr_type)
+        fld_defn.SetSubType(ogr_subtype)
+        fld_defn.SetWidth(width)
+        if len(f_split) >= 4 and f_split[2] == 'NOT' and f_split[3] == 'NULL':
+            fld_defn.SetNullable(False)
+        return fld_defn
+
+    def createTable(self, table, field_defs, pkey):
+        """ create ordinary table
+                        'fields' is array containing field definitions
+                        'pkey' is the primary key name
+        """
+        if len(field_defs) == 0:
+            return False
+
+        options = []
+        if pkey is not None and pkey != "":
+            options += ['FID=' + pkey]
+        _, tablename = self.getSchemaTableName(table)
+        lyr = self.gdal_ds.CreateLayer(tablename, geom_type=ogr.wkbNone, options=options)
+        if lyr is None:
+            return False
+        for field_def in field_defs:
+            fld_defn = self.createOGRFieldDefnFromSQL(field_def)
+            if fld_defn.GetName() == pkey:
+                continue
+            if lyr.CreateField(fld_defn) != 0:
+                return False
+
+        return True
+
+    def deleteTable(self, table):
+        """ delete table from the database """
+        if self.isRasterTable(table):
+            return False
+
+        _, tablename = self.getSchemaTableName(table)
+        for i in range(self.gdal_ds.GetLayerCount()):
+            if self.gdal_ds.GetLayer(i).GetName() == tablename:
+                return self.gdal_ds.DeleteLayer(i) == 0
+        return False
+
+    def emptyTable(self, table):
+        """ delete all rows from table """
+        if self.isRasterTable(table):
+            return False
+
+        sql = u"DELETE FROM %s" % self.quoteId(table)
+        self._execute_and_commit(sql)
+
+    def renameTable(self, table, new_table):
+        """ rename a table """
+
+        if self.isRasterTable(table):
+            return False
+
+        _, tablename = self.getSchemaTableName(table)
+        if new_table == tablename:
+            return True
+
+        if tablename.find('"') >= 0:
+            tablename = self.quotedId(tablename)
+        if new_table.find('"') >= 0:
+            new_table = self.quotedId(new_table)
+
+        gdal.ErrorReset()
+        self.gdal_ds.ExecuteSQL('ALTER TABLE %s RENAME TO %s' % (tablename, new_table))
+        return gdal.GetLastErrorMsg() == ''
+
+    def moveTable(self, table, new_table, new_schema=None):
+        return self.renameTable(table, new_table)
+
+    def runVacuum(self):
+        """ run vacuum on the db """
+        self._execute_and_commit("VACUUM")
+
+    def addTableColumn(self, table, field_def):
+        """ add a column to table """
+
+        _, tablename = self.getSchemaTableName(table)
+        lyr = self.gdal_ds.GetLayerByName(tablename)
+        if lyr is None:
+            return False
+        fld_defn = self.createOGRFieldDefnFromSQL(field_def)
+        return lyr.CreateField(fld_defn) == 0
+
+    def deleteTableColumn(self, table, column):
+        """ delete column from a table """
+        if self.isGeometryColumn(table, column):
+            return False
+
+        _, tablename = self.getSchemaTableName(table)
+        lyr = self.gdal_ds.GetLayerByName(tablename)
+        if lyr is None:
+            return False
+        idx = lyr.GetLayerDefn().GetFieldIndex(column)
+        if idx >= 0:
+            return lyr.DeleteField(idx) == 0
+        return False
+
+    def updateTableColumn(self, table, column, new_name, new_data_type=None, new_not_null=None, new_default=None):
+        if self.isGeometryColumn(table, column):
+            return False
+
+        _, tablename = self.getSchemaTableName(table)
+        lyr = self.gdal_ds.GetLayerByName(tablename)
+        if lyr is None:
+            return False
+        if lyr.TestCapability(ogr.OLCAlterFieldDefn) == 0:
+            return False
+        idx = lyr.GetLayerDefn().GetFieldIndex(column)
+        if idx >= 0:
+            old_fielddefn = lyr.GetLayerDefn().GetFieldDefn(idx)
+            flag = 0
+            if new_name is not None:
+                flag |= ogr.ALTER_NAME_FLAG
+            else:
+                new_name = column
+            if new_data_type is None:
+                ogr_type = old_fielddefn.GetType()
+                ogr_subtype = old_fielddefn.GetSubType()
+                width = old_fielddefn.GetWidth()
+            else:
+                flag |= ogr.ALTER_TYPE_FLAG
+                flag |= ogr.ALTER_WIDTH_PRECISION_FLAG
+                ogr_type, ogr_subtype, width = self.getOGRFieldTypeFromSQL(new_data_type)
+            new_fielddefn = ogr.FieldDefn(new_name, ogr_type)
+            new_fielddefn.SetSubType(ogr_subtype)
+            new_fielddefn.SetWidth(width)
+            if new_default is not None:
+                flag |= ogr.ALTER_DEFAULT_FLAG
+                if new_default == '':
+                    new_fielddefn.SetDefault(None)
+                elif new_default == 'NULL' or ogr_type in (ogr.OFTInteger, ogr.OFTReal):
+                    new_fielddefn.SetDefault(str(new_default))
+                else:
+                    new_fielddefn.SetDefault(self.quoteString(new_default))
+            else:
+                new_fielddefn.SetDefault(old_fielddefn.GetDefault())
+            if new_not_null is not None:
+                flag |= ogr.ALTER_NULLABLE_FLAG
+                new_fielddefn.SetNullable(not new_not_null)
+            else:
+                new_fielddefn.SetNullable(old_fielddefn.IsNullable())
+            return lyr.AlterFieldDefn(idx, new_fielddefn, flag) == 0
+
+        return False
+
+    def isGeometryColumn(self, table, column):
+
+        _, tablename = self.getSchemaTableName(table)
+        lyr = self.gdal_ds.GetLayerByName(tablename)
+        if lyr is None:
+            return False
+        return column == lyr.GetGeometryColumn()
+
+    def addGeometryColumn(self, table, geom_column='geometry', geom_type='POINT', srid=-1, dim=2):
+
+        _, tablename = self.getSchemaTableName(table)
+        lyr = self.gdal_ds.GetLayerByName(tablename)
+        if lyr is None:
+            return False
+        ogr_type = ogr.wkbUnknown
+        if geom_type == 'POINT':
+            ogr_type = ogr.wkbPoint
+        elif geom_type == 'LINESTRING':
+            ogr_type = ogr.wkbLineString
+        elif geom_type == 'POLYGON':
+            ogr_type = ogr.wkbPolygon
+        elif geom_type == 'MULTIPOINT':
+            ogr_type = ogr.wkbMultiPoint
+        elif geom_type == 'MULTILINESTRING':
+            ogr_type = ogr.wkbMultiLineString
+        elif geom_type == 'MULTIPOLYGON':
+            ogr_type = ogr.wkbMultiPolygon
+        elif geom_type == 'GEOMETRYCOLLECTION':
+            ogr_type = ogr.wkbGeometryCollection
+
+        if dim == 3:
+            ogr_type = ogr_type | ogr.wkb25DBit
+        elif dim == 4:
+            if hasattr(ogr, 'GT_HasZ'):
+                ogr_type = ogr.GT_SetZ(ogr_type)
+            else:
+                ogr_type = ogr_type | ogr.wkb25DBit
+            if hasattr(ogr, 'GT_HasM'):
+                ogr_type = ogr.GT_SetM(ogr_type)
+
+        geom_field_defn = ogr.GeomFieldDefn(self.unquoteId(geom_column), ogr_type)
+        if srid > 0:
+            sr = osr.SpatialReference()
+            if sr.ImportFromEPSG(srid) == 0:
+                geom_field_defn.SetSpatialRef(sr)
+
+        return lyr.CreateGeomField(geom_field_defn) == 0
+
+    def deleteGeometryColumn(self, table, geom_column):
+        return False # not supported
+
+    def addTableUniqueConstraint(self, table, column):
+        """ add a unique constraint to a table """
+        return False  # constraints not supported
+
+    def deleteTableConstraint(self, table, constraint):
+        """ delete constraint in a table """
+        return False  # constraints not supported
+
+    def addTablePrimaryKey(self, table, column):
+        """ add a primery key (with one column) to a table """
+        sql = u"ALTER TABLE %s ADD PRIMARY KEY (%s)" % (self.quoteId(table), self.quoteId(column))
+        self._execute_and_commit(sql)
+
+    def createTableIndex(self, table, name, column, unique=False):
+        """ create index on one column using default options """
+        unique_str = u"UNIQUE" if unique else ""
+        sql = u"CREATE %s INDEX %s ON %s (%s)" % (
+            unique_str, self.quoteId(name), self.quoteId(table), self.quoteId(column))
+        self._execute_and_commit(sql)
+
+    def deleteTableIndex(self, table, name):
+        schema, tablename = self.getSchemaTableName(table)
+        sql = u"DROP INDEX %s" % self.quoteId((schema, name))
+        self._execute_and_commit(sql)
+
+    def createSpatialIndex(self, table, geom_column):
+        if self.isRasterTable(table):
+            return False
+        _, tablename = self.getSchemaTableName(table)
+        sql = u"SELECT CreateSpatialIndex(%s, %s)" % (
+            self.quoteId(tablename), self.quoteId(geom_column))
+        res = self._fetchOne(sql)
+        return res is not None and res[0] == 1
+
+    def deleteSpatialIndex(self, table, geom_column):
+        if self.isRasterTable(table):
+            return False
+        _, tablename = self.getSchemaTableName(table)
+        sql = u"SELECT DisableSpatialIndex(%s, %s)" % (
+            self.quoteId(tablename), self.quoteId(geom_column))
+        res = self._fetchOne(sql)
+        return res is not None and res[0] == 1
+
+    def hasSpatialIndex(self, table, geom_column):
+        if self.isRasterTable(table) or geom_column is None:
+            return False
+        _, tablename = self.getSchemaTableName(table)
+        if self.gdal2:
+            # Only try this for GDAL >= 2 (but only available in >= 2.1.2)
+            sql = u"SELECT HasSpatialIndex(%s, %s)" % (self.quoteString(tablename), self.quoteString(geom_column))
+            gdal.PushErrorHandler()
+            ret = self._fetchOne(sql)
+            gdal.PopErrorHandler()
+        else:
+            ret = None
+        if ret is None:
+            # might be the case for GDAL < 2.1.2
+            sql = u"SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name LIKE %s" % self.quoteString("%%rtree_" + tablename + "_%%")
+            ret = self._fetchOne(sql)
+        if ret is None:
+            return False
+        else:
+            return ret[0] >= 1
+
+    def execution_error_types(self):
+        return sqlite3.Error, sqlite3.ProgrammingError, sqlite3.Warning
+
+    def connection_error_types(self):
+        return sqlite3.InterfaceError, sqlite3.OperationalError
+
+    def getSqlDictionary(self):
+        from .sql_dictionary import getSqlDictionary
+
+        sql_dict = getSqlDictionary()
+
+        items = []
+        for tbl in self.getTables():
+            items.append(tbl[1])  # table name
+
+            for fld in self.getTableFields(tbl[0]):
+                items.append(fld[1])  # field name
+
+        sql_dict["identifier"] = items
+        return sql_dict
+
+    def getQueryBuilderDictionary(self):
+        from .sql_dictionary import getQueryBuilderDictionary
+
+        return getQueryBuilderDictionary()

python/plugins/db_manager/db_plugins/gpkg/data_model.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+
+"""
+/***************************************************************************
+Name                 : DB Manager
+Description          : Database manager plugin for QGIS
+Date                 : May 23, 2011
+copyright            : (C) 2011 by Giuseppe Sucameli
+email                : brush.tyler@gmail.com
+
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+"""
+
+from ..data_model import TableDataModel, SqlResultModel
+
+
+class GPKGTableDataModel(TableDataModel):
+
+    def __init__(self, table, parent=None):
+        TableDataModel.__init__(self, table, parent)
+
+        #fields_txt = u", ".join(self.fields)
+        #table_txt = self.db.quoteId((self.table.schemaName(), self.table.name))
+
+        # run query and get results
+        #sql = u"SELECT %s FROM %s" % (fields_txt, table_txt)
+        #self.resdata = self.db._fetchAll(sql, include_fid_and_geometry = True)
+
+        self.resdata = self.db._fetchAllFromLayer(table)
+
+        self.fetchedFrom = 0
+        self.fetchedCount = len(self.resdata)
+
+    def _sanitizeTableField(self, field):
+        return self.db.quoteId(field.name)
+
+    def rowCount(self, index=None):
+        return self.fetchedCount
+
+
+class GPKGSqlResultModel(SqlResultModel):
+    pass

python/plugins/db_manager/db_plugins/gpkg/info_model.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+"""
+/***************************************************************************
+Name                 : DB Manager
+Description          : Database manager plugin for QGIS
+Date                 : May 23, 2011
+copyright            : (C) 2011 by Giuseppe Sucameli
+email                : brush.tyler@gmail.com
+
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+"""
+
+from qgis.PyQt.QtWidgets import QApplication
+
+from ..info_model import DatabaseInfo
+from ..html_elems import HtmlTable
+
+
+class GPKGDatabaseInfo(DatabaseInfo):
+
+    def __init__(self, db):
+        self.db = db
+
+    def connectionDetails(self):
+        tbl = [
+            (QApplication.translate("DBManagerPlugin", "Filename:"), self.db.connector.dbname)
+        ]
+        return HtmlTable(tbl)
+
+    def generalInfo(self):
+        return None
+
+    def spatialInfo(self):
+        return None
+
+    def privilegesDetails(self):
+        return None

python/plugins/db_manager/db_plugins/gpkg/plugin.py

@@ -0,0 +1,314 @@
+# -*- coding: utf-8 -*-
+
+"""
+/***************************************************************************
+Name                 : DB Manager
+Description          : Database manager plugin for QGIS
+Date                 : May 23, 2011
+copyright            : (C) 2011 by Giuseppe Sucameli
+email                : brush.tyler@gmail.com
+
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+"""
+from builtins import str
+
+# this will disable the dbplugin if the connector raise an ImportError
+from .connector import GPKGDBConnector
+
+from qgis.PyQt.QtCore import Qt, QSettings, QFileInfo
+from qgis.PyQt.QtGui import QIcon
+from qgis.PyQt.QtWidgets import QApplication, QAction, QFileDialog
+from qgis.core import QgsDataSourceUri
+from qgis.gui import QgsMessageBar
+
+from ..plugin import DBPlugin, Database, Table, VectorTable, RasterTable, TableField, TableIndex, TableTrigger, \
+    InvalidDataException
+
+from . import resources_rc
+hasattr(resources_rc, 'foo')
+
+
+def classFactory():
+    return GPKGDBPlugin
+
+
+class GPKGDBPlugin(DBPlugin):
+
+    @classmethod
+    def icon(self):
+        return QIcon(":/db_manager/gpkg/icon")
+
+    @classmethod
+    def typeName(self):
+        return 'gpkg'
+
+    @classmethod
+    def typeNameString(self):
+        return 'GeoPackage'
+
+    @classmethod
+    def providerName(self):
+        return 'ogr'
+
+    @classmethod
+    def connectionSettingsKey(self):
+        return '/GPKG/connections'
+
+    def databasesFactory(self, connection, uri):
+        return GPKGDatabase(connection, uri)
+
+    def connect(self, parent=None):
+        conn_name = self.connectionName()
+        settings = QSettings()
+        settings.beginGroup(u"/%s/%s" % (self.connectionSettingsKey(), conn_name))
+
+        if not settings.contains("gpkgpath"):  # non-existent entry?
+            raise InvalidDataException(u'there is no defined database connection "%s".' % conn_name)
+
+        database = settings.value("gpkgpath")
+
+        uri = QgsDataSourceUri()
+        uri.setDatabase(database)
+        return self.connectToUri(uri)
+
+    @classmethod
+    def addConnection(self, conn_name, uri):
+        settings = QSettings()
+        settings.beginGroup(u"/%s/%s" % (self.connectionSettingsKey(), conn_name))
+        settings.setValue("gpkgpath", uri.database())
+        return True
+
+    @classmethod
+    def addConnectionActionSlot(self, item, action, parent, index):
+        QApplication.restoreOverrideCursor()
+        try:
+            filename, selected_filter = QFileDialog.getOpenFileName(parent,
+                                                                    parent.tr("Choose GeoPackage file"), None, "GeoPackage (*.gpkg)")
+            if not filename:
+                return
+        finally:
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+
+        conn_name = QFileInfo(filename).fileName()
+        uri = QgsDataSourceUri()
+        uri.setDatabase(filename)
+        self.addConnection(conn_name, uri)
+        index.internalPointer().itemChanged()
+
+
+class GPKGDatabase(Database):
+
+    def __init__(self, connection, uri):
+        Database.__init__(self, connection, uri)
+
+    def connectorsFactory(self, uri):
+        return GPKGDBConnector(uri)
+
+    def dataTablesFactory(self, row, db, schema=None):
+        return GPKGTable(row, db, schema)
+
+    def vectorTablesFactory(self, row, db, schema=None):
+        return GPKGVectorTable(row, db, schema)
+
+    def rasterTablesFactory(self, row, db, schema=None):
+        return GPKGRasterTable(row, db, schema)
+
+    def info(self):
+        from .info_model import GPKGDatabaseInfo
+
+        return GPKGDatabaseInfo(self)
+
+    def sqlResultModel(self, sql, parent):
+        from .data_model import GPKGSqlResultModel
+
+        return GPKGSqlResultModel(self, sql, parent)
+
+    def registerDatabaseActions(self, mainWindow):
+        action = QAction(self.tr("Run &Vacuum"), self)
+        mainWindow.registerAction(action, self.tr("&Database"), self.runVacuumActionSlot)
+
+        Database.registerDatabaseActions(self, mainWindow)
+
+    def runVacuumActionSlot(self, item, action, parent):
+        QApplication.restoreOverrideCursor()
+        try:
+            if not isinstance(item, (DBPlugin, Table)) or item.database() is None:
+                parent.infoBar.pushMessage(self.tr("No database selected or you are not connected to it."),
+                                           QgsMessageBar.INFO, parent.iface.messageTimeout())
+                return
+        finally:
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+
+        self.runVacuum()
+
+    def runVacuum(self):
+        self.database().aboutToChange.emit()
+        self.database().connector.runVacuum()
+        self.database().refresh()
+
+    def runAction(self, action):
+        action = str(action)
+
+        if action.startswith("vacuum/"):
+            if action == "vacuum/run":
+                self.runVacuum()
+                return True
+
+        return Database.runAction(self, action)
+
+    def uniqueIdFunction(self):
+        return None
+
+    def toSqlLayer(self, sql, geomCol, uniqueCol, layerName="QueryLayer", layerType=None, avoidSelectById=False, filter=""):
+        from qgis.core import QgsVectorLayer
+
+        vl = QgsVectorLayer(self.uri().database(), layerName, 'ogr')
+        vl.setSubsetString(sql)
+        return vl
+
+
+class GPKGTable(Table):
+
+    def __init__(self, row, db, schema=None):
+        Table.__init__(self, db, None)
+        self.name, self.isView, self.isSysTable = row
+
+    def ogrUri(self):
+        ogrUri = u"%s|layername=%s" % (self.uri().database(), self.name)
+        return ogrUri
+
+    def mimeUri(self):
+
+        # QGIS has no provider to load Geopackage vectors, let's use OGR
+        return u"vector:ogr:%s:%s" % (self.name, self.ogrUri())
+
+    def toMapLayer(self):
+        from qgis.core import QgsVectorLayer
+
+        provider = "ogr"
+        uri = self.ogrUri()
+
+        return QgsVectorLayer(uri, self.name, provider)
+
+    def tableFieldsFactory(self, row, table):
+        return GPKGTableField(row, table)
+
+    def tableIndexesFactory(self, row, table):
+        return GPKGTableIndex(row, table)
+
+    def tableTriggersFactory(self, row, table):
+        return GPKGTableTrigger(row, table)
+
+    def tableDataModel(self, parent):
+        from .data_model import GPKGTableDataModel
+
+        return GPKGTableDataModel(self, parent)
+
+
+class GPKGVectorTable(GPKGTable, VectorTable):
+
+    def __init__(self, row, db, schema=None):
+        GPKGTable.__init__(self, row[:-5], db, schema)
+        VectorTable.__init__(self, db, schema)
+        # GPKG does case-insensitive checks for table names, but the
+        # GPKG provider didn't do the same in Qgis < 1.9, so self.geomTableName
+        # stores the table name like stored in the geometry_columns table
+        self.geomTableName, self.geomColumn, self.geomType, self.geomDim, self.srid = row[-5:]
+        self.extent = self.database().connector.getTableExtent((self.schemaName(), self.name), self.geomColumn, force=False)
+
+    def uri(self):
+        uri = self.database().uri()
+        uri.setDataSource('', self.geomTableName, self.geomColumn)
+        return uri
+
+    def hasSpatialIndex(self, geom_column=None):
+        geom_column = geom_column if geom_column is not None else self.geomColumn
+        return self.database().connector.hasSpatialIndex((self.schemaName(), self.name), geom_column)
+
+    def createSpatialIndex(self, geom_column=None):
+        self.aboutToChange.emit()
+        ret = VectorTable.createSpatialIndex(self, geom_column)
+        if ret is not False:
+            self.database().refresh()
+        return ret
+
+    def deleteSpatialIndex(self, geom_column=None):
+        self.aboutToChange.emit()
+        ret = VectorTable.deleteSpatialIndex(self, geom_column)
+        if ret is not False:
+            self.database().refresh()
+        return ret
+
+    def refreshTableEstimatedExtent(self):
+        return
+
+    def refreshTableExtent(self):
+        prevExtent = self.extent
+        self.extent = self.database().connector.getTableExtent((self.schemaName(), self.name), self.geomColumn, force=True)
+        if self.extent != prevExtent:
+            self.refresh()
+
+    def runAction(self, action):
+        if GPKGTable.runAction(self, action):
+            return True
+        return VectorTable.runAction(self, action)
+
+
+class GPKGRasterTable(GPKGTable, RasterTable):
+
+    def __init__(self, row, db, schema=None):
+        GPKGTable.__init__(self, row[:-3], db, schema)
+        RasterTable.__init__(self, db, schema)
+        self.prefixName, self.geomColumn, self.srid = row[-3:]
+        self.geomType = 'RASTER'
+        self.extent = self.database().connector.getTableExtent((self.schemaName(), self.name), self.geomColumn)
+
+    def gpkgGdalUri(self):
+        gdalUri = u'GPKG:%s:%s' % (self.uri().database(), self.prefixName)
+        return gdalUri
+
+    def mimeUri(self):
+        # QGIS has no provider to load rasters, let's use GDAL
+        uri = u"raster:gdal:%s:%s" % (self.name, self.uri().database())
+        return uri
+
+    def toMapLayer(self):
+        from qgis.core import QgsRasterLayer, QgsContrastEnhancement
+
+        # QGIS has no provider to load rasters, let's use GDAL
+        uri = self.gpkgGdalUri()
+        rl = QgsRasterLayer(uri, self.name)
+        if rl.isValid():
+            rl.setContrastEnhancement(QgsContrastEnhancement.StretchToMinimumMaximum)
+        return rl
+
+
+class GPKGTableField(TableField):
+
+    def __init__(self, row, table):
+        TableField.__init__(self, table)
+        self.num, self.name, self.dataType, self.notNull, self.default, self.primaryKey = row
+        self.hasDefault = self.default
+
+
+class GPKGTableIndex(TableIndex):
+
+    def __init__(self, row, table):
+        TableIndex.__init__(self, table)
+        self.num, self.name, self.isUnique, self.columns = row
+
+
+class GPKGTableTrigger(TableTrigger):
+
+    def __init__(self, row, table):
+        TableTrigger.__init__(self, table)
+        self.name, self.function = row

python/plugins/db_manager/db_plugins/gpkg/resources.qrc

@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/db_manager/gpkg">
+        <file alias="icon">icons/gpkg_icon.png</file>
+    </qresource>
+</RCC>

python/plugins/db_manager/db_plugins/gpkg/sql_dictionary.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+"""
+***************************************************************************
+    sql_dictionary.py
+    ---------------------
+    Date                 : April 2012
+    Copyright            : (C) 2012 by Giuseppe Sucameli
+    Email                : brush dot tyler at gmail dot com
+***************************************************************************
+*                                                                         *
+*   This program is free software; you can redistribute it and/or modify  *
+*   it under the terms of the GNU General Public License as published by  *
+*   the Free Software Foundation; either version 2 of the License, or     *
+*   (at your option) any later version.                                   *
+*                                                                         *
+***************************************************************************
+"""
+
+
+def getSqlDictionary(spatial=True):
+    from ..spatialite.sql_dictionary import getSqlDictionary
+    return getSqlDictionary(spatial)
+
+
+def getQueryBuilderDictionary():
+    from ..spatialite.sql_dictionary import getQueryBuilderDictionary
+    return getQueryBuilderDictionary()

python/plugins/db_manager/db_tree.py

@@ -137,7 +137,7 @@ class DBTree(QTreeView):
                 menu.addAction(self.tr("Re-connect"), self.reconnect)
             menu.addAction(self.tr("Remove"), self.delete)
 
-        elif not index.parent().isValid() and item.typeName() == "spatialite":
+        elif not index.parent().isValid() and item.typeName() in ("spatialite", "gpkg"):
             menu.addAction(self.tr("New Connection..."), self.newConnection)
 
         if not menu.isEmpty():

python/plugins/db_manager/dlg_sql_layer_window.py

@@ -71,6 +71,8 @@ class DlgSqlLayerWindow(QWidget, Ui_Dialog):
             dbplugin = createDbPlugin('oracle', 'oracle')
         elif layer.dataProvider().name() == 'virtual':
             dbplugin = createDbPlugin('vlayers', 'virtual')
+        elif layer.dataProvider().name() == 'ogr':
+            dbplugin = createDbPlugin('gpkg', 'gpkg')
         if dbplugin:
             dbplugin.connectToUri(uri)
             db = dbplugin.db