def pg_layerNamesIDMapping():
    '''
    Returns a dictionary containing the original table names and corresponding layer IDs in the
    QGIS legend for only those layers from a postgres database.
    '''
    mapping = ReverseDict()
    layers = QgsMapLayerRegistry.instance().mapLayers()
    
    for name,layer in layers.iteritems():
        if hasattr(layer, 'dataProvider'):
            if layer.dataProvider().name() == 'postgres':
                layerConnStr = layer.dataProvider().dataSourceUri()
                dataSourceURI = QgsDataSourceURI(layerConnStr)
                mapping[dataSourceURI.table()] = layer.id()
    
    return mapping
    
    
    
    
    
    
    
    
    

	def connect(self, parent=None):
		conn_name = self.connectionName()
		settings = QSettings()
		settings.beginGroup( u"/%s/%s" % (self.connectionSettingsKey(), conn_name) )

		if not settings.contains( "database" ): # non-existent entry?
			raise InvalidDataException( u'there is no defined database connection "%s".' % conn_name )

		from qgis.core import QgsDataSourceURI
		uri = QgsDataSourceURI()
	
		get_value_str = lambda x: settings.value(x).toString()
		host, port, database, username, password = map(get_value_str, ["host", "port", "database", "username", "password"])

		# qgis1.5 use 'savePassword' instead of 'save' setting
		savedPassword = settings.value("save", False).toBool() or settings.value("savePassword", False).toBool()

		useEstimatedMetadata = settings.value("estimatedMetadata", False).toBool()
		sslmode = settings.value("sslmode", QgsDataSourceURI.SSLprefer).toInt()[0]

		settings.endGroup()

		uri.setConnection(host, port, database, username, password, sslmode)
		uri.setUseEstimatedMetadata(useEstimatedMetadata)

		err = QString()
		try:
			return DBPlugin.connect(self, uri)
		except ConnectionError, e:
			err = QString( str(e) )

 def onUpdateSqlLayer(self):
     l = self.iface.legendInterface().currentLayer()
     if l.dataProvider().name() in ['postgres', 'spatialite', 'oracle']:
         uri = QgsDataSourceURI(l.source())
         if re.search('^\(SELECT .+ FROM .+\)$', uri.table(), re.S):
             self.run()
             self.dlg.runSqlLayerWindow(l)

 def getAll(self, expression=None):
     uri = QgsDataSourceURI(expression)
     if uri.table() != self.layer:
         raise Exception('Invalid expression %s. Expected table %s but got %s'%(expression, self.layer, uri.table))
     qgsLayer = getLayerByUri(self.layer, uri.uri())
     if not qgsLayer:
         raise Exception('Layer with uri %s not found'%QgsDataSourceURI.removePassword(uri.uri()))

    def ogrConnectionString(self, uri):
        ogrstr = None

        layer = dataobjects.getObjectFromUri(uri, False)
        if layer is None:
            return uri
        provider = layer.dataProvider().name()
        if provider == 'spatialite':
            # dbname='/geodata/osm_ch.sqlite' table="places" (Geometry) sql=
            regex = re.compile("dbname='(.+)'")
            r = regex.search(unicode(layer.source()))
            ogrstr = r.groups()[0]
        elif provider == 'postgres':
            # dbname='ktryjh_iuuqef' host=spacialdb.com port=9999
            # user='ktryjh_iuuqef' password='xyqwer' sslmode=disable
            # key='gid' estimatedmetadata=true srid=4326 type=MULTIPOLYGON
            # table="t4" (geom) sql=
            dsUri = QgsDataSourceURI(layer.dataProvider().dataSourceUri())
            connInfo = dsUri.connectionInfo()
            (success, user, passwd ) = QgsCredentials.instance().get(connInfo, None, None)
            if success:
                QgsCredentials.instance().put(connInfo, user, passwd)
            ogrstr = ("PG:dbname='%s' host='%s' port='%s' user='%s' password='%s'"
                      % (dsUri.database(), dsUri.host(), dsUri.port(), user, passwd))
        else:
            ogrstr = unicode(layer.source()).split("|")[0]
        return '"' + ogrstr + '"'

 def get_db_tables(self):
     """Retrieve all tables from the selected database."""
     self.dlg.cmb_geo.clear()
     db_name = self.dlg.cmb_db.currentText()
     con_name = self.dlg.cmb_con.currentText()
     con_str = "{db}/connections/{con}/".format(db=db_name, con=con_name)
     qs = QSettings()
     db_host = qs.value(con_str + "host")
     db_port = qs.value(con_str + "port")
     db_name = qs.value(con_str + "database")
     con_usr = qs.value(con_str + "username")
     con_pwd = qs.value(con_str + "password")
     uri = QgsDataSourceURI()
     uri.setConnection(db_host, db_port, db_name, con_usr, con_pwd)
     post_c = pg_con.PostGisDBConnector(uri)
     tbl_list = []
     for table in post_c.getTables():
         if table[3] or table[1] == 'spatial_ref_sys':
             pass
         else:
             tbl_list.append(table[1])
     if len(tbl_list) == 0:
         QMessageBox.warning(None,
                             'Layer and Tables',
                             """There are no tables to geo-code in this database.""")
     else:
         self.dlg.cmb_geo.addItems(tbl_list)

 def createBlockLayer(self):
     uri = QgsDataSourceURI()
     uri.setConnection(self.db_hostName, str(self.db_Port), self.db_databaseName, self.db_UserName, self.db_password)
     uri.setDataSource("cadastre", "spatial_unit_group", "geom", "hierarchy_level=5")
     uri.uri()
     print uri.uri()
     rlayer = self.iface.addVectorLayer(uri.uri(), "Blocks", "postgres")
     rlayer.loadNamedStyle(self.plugin_dir + '/lga.qml')

 def getLayers(self, dbName):
     lyrList = []
     for lyr in self.iface.legendInterface().layers():
         if isinstance(lyr, QgsVectorLayer):
             candidateUri = QgsDataSourceURI(lyr.dataProvider().dataSourceUri())
             if candidateUri.database() == dbName and lyr.providerType() in ['postgres', 'spatialite']:
                 lyrList.append(lyr)
     return lyrList

def getLayerByUri(layerName, uri):
    reg = QgsMapLayerRegistry.instance()
    allLayers = reg.mapLayersByName(layerName)
    for a in allLayers:
        dsUri = QgsDataSourceURI(a.dataProvider().dataSourceUri())
        if dsUri.uri() == uri:
            return a
    return None

 def getDatabaseList(self):
     dbList = []
     for lyr in self.iface.legendInterface().layers():
         if isinstance(lyr, QgsVectorLayer):
             candidateUri = QgsDataSourceURI(lyr.dataProvider().dataSourceUri())
             dbName = candidateUri.database()
             if dbName not in dbList and lyr.providerType() in ['postgres', 'spatialite']:
                 dbList.append(dbName)
     return dbList

    def dropMimeData(self, data, action, row, column, parent):
        global isImportVectorAvail

        if action == Qt.IgnoreAction:
            return True

        # vectors/tables to be imported must be dropped on connected db, schema or table
        canImportLayer = isImportVectorAvail and parent.isValid() and \
            (isinstance(parent.internalPointer(), (SchemaItem, TableItem)) or
             (isinstance(parent.internalPointer(), ConnectionItem) and parent.internalPointer().populated))

        added = 0

        if data.hasUrls():
            for u in data.urls():
                filename = u.toLocalFile()
                if filename == "":
                    continue

                if self.hasSpatialiteSupport:
                    from .db_plugins.spatialite.connector import SpatiaLiteDBConnector

                    if SpatiaLiteDBConnector.isValidDatabase(filename):
                        # retrieve the SL plugin tree item using its path
                        index = self._rPath2Index(["spatialite"])
                        if not index.isValid():
                            continue
                        item = index.internalPointer()

                        conn_name = QFileInfo(filename).fileName()
                        uri = QgsDataSourceURI()
                        uri.setDatabase(filename)
                        item.getItemData().addConnection(conn_name, uri)
                        item.itemChanged.emit(item)
                        added += 1
                        continue

                if canImportLayer:
                    if QgsRasterLayer.isValidRasterFileName(filename):
                        layerType = 'raster'
                        providerKey = 'gdal'
                    else:
                        layerType = 'vector'
                        providerKey = 'ogr'

                    layerName = QFileInfo(filename).completeBaseName()
                    if self.importLayer(layerType, providerKey, layerName, filename, parent):
                        added += 1

        if data.hasFormat(self.QGIS_URI_MIME):
            for uri in QgsMimeDataUtils.decodeUriList(data):
                if canImportLayer:
                    if self.importLayer(uri.layerType, uri.providerKey, uri.name, uri.uri, parent):
                        added += 1

        return added > 0

    def toQgsDataSourceUri(self):
        """
        Returns a QgsDataSourceURI object with database connection properties
        defined.
        """
        dt_source = QgsDataSourceURI()
        dt_source.setConnection(self.Host, unicode(self.Port), self.Database,
                                self.User.UserName, unicode(self.User.Password))

        return dt_source

 def fromLayer(cls, layer):
     uri = QgsDataSourceURI(layer.dataProvider().dataSourceUri())
     connectioninfo = {
         "host": uri.host(),
         "database": uri.database(),
         "user": uri.username(),
         "password": uri.password(),
         "connectionname": layer.id()
     }
     database = Database.connect(**connectioninfo)
     return database

    def postgis_path_to_uri(path):
        """Convert layer path from QgsBrowserModel to full QgsDataSourceURI.

        :param path: The layer path from QgsBrowserModel
        :type path: string

        :returns: layer uri.
        :rtype: QgsDataSourceURI
        """

        connection_name = path.split('/')[1]
        schema = path.split('/')[2]
        table_name = path.split('/')[3]

        settings = QSettings()
        key = "/PostgreSQL/connections/" + connection_name
        service = settings.value(key + "/service")
        host = settings.value(key + "/host")
        port = settings.value(key + "/port")
        if not port:
            port = "5432"
        db = settings.value(key + "/database")
        use_estimated_metadata = settings.value(
            key + "/estimatedMetadata", False, type=bool)
        sslmode = settings.value(
            key + "/sslmode", QgsDataSourceURI.SSLprefer, type=int)
        username = ""
        password = ""
        if settings.value(key + "/saveUsername") == "true":
            username = settings.value(key + "/username")

        if settings.value(key + "/savePassword") == "true":
            password = settings.value(key + "/password")

        # Old save setting
        if settings.contains(key + "/save"):
            username = settings.value(key + "/username")
            if settings.value(key + "/save") == "true":
                password = settings.value(key + "/password")

        uri = QgsDataSourceURI()
        if service:
            uri.setConnection(service, db, username, password, sslmode)
        else:
            uri.setConnection(host, port, db, username, password, sslmode)

        uri.setUseEstimatedMetadata(use_estimated_metadata)

        # Obtain the geometry column name
        connector = PostGisDBConnector(uri)
        tables = connector.getVectorTables(schema)
        tables = [table for table in tables if table[1] == table_name]
        if not tables:
            return None
        table = tables[0]
        geom_col = table[8]

        uri.setDataSource(schema, table_name, geom_col)
        return 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("sqlitepath"):  # non-existent entry?
            raise InvalidDataException(u'there is no defined database connection "%s".' % conn_name)

        database = settings.value("sqlitepath")

        uri = QgsDataSourceURI()
        uri.setDatabase(database)
        return self.connectToUri(uri)

    def makeValueRelationDict(self, valueDict):
        ret = dict()

        codes = valueDict['FilterExpression'].replace('code in (', '').replace(')','').split(',')
        keyColumn = valueDict['Key']
        valueColumn = valueDict['Value']
        table = valueDict['Layer'][:-17]#removing the date-time characters
        
        uri = QgsDataSourceURI(self.currLayer.dataProvider().dataSourceUri())
        if uri.host() == '':
            db = QSqlDatabase('QSQLITE')
            db.setDatabaseName(uri.database())
        else:
            db = QSqlDatabase('QPSQL')
            db.setHostName(uri.host())
            db.setPort(int(uri.port()))
            db.setDatabaseName(uri.database())
            db.setUserName(uri.username())
            db.setPassword(uri.password())
        
        if not db.open():
            db.close()
            return ret

        in_clause = ','.join(map(str, codes))
        query = QSqlQuery('select code, code_name from dominios.%s where code in (%s)' % (table, in_clause), db)
        while query.next():
            code = str(query.value(0))
            code_name = query.value(1)
            ret[code_name] = code
            
        db.close()
                
        return ret

    def fromLayer(cls, layer):
        source = layer.source()
        uri = QgsDataSourceURI(layer.dataProvider().dataSourceUri())
        if ".sqlite" in source:
            try:
                index = source.index("|")
                source = source[:index]
            except ValueError:
                pass
            if uri.database():
                source = uri.database()

            connectioninfo = {"type": "QSQLITE",
                              "database": source}
        else:
            uri = QgsDataSourceURI(layer.dataProvider().dataSourceUri())
            connectioninfo = {
                "host": uri.host(),
                "database": uri.database(),
                "user": uri.username(),
                "password": uri.password()
            }
        connectioninfo["connectionname"] = layer.id()
        database = Database.connect(**connectioninfo)
        return database

 def checkLoaded(self, name, loadedLayers):
     """
     Checks if the layers is already loaded in the QGIS' TOC
     :param name:
     :param loadedLayers:
     :return:
     """
     loaded = None
     for ll in loadedLayers:
         if ll.name() == name:
             candidateUri = QgsDataSourceURI(ll.dataProvider().dataSourceUri())
             if self.host == candidateUri.host() and self.database == candidateUri.database() and self.port == int(candidateUri.port()):
                 return ll
     return loaded

    def addConnectionActionSlot(self, item, action, parent, index):
        QApplication.restoreOverrideCursor()
        try:
            filename = QFileDialog.getOpenFileName(parent, "Choose Sqlite/Spatialite/Geopackage file")
            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().emit(SIGNAL('itemChanged'), index.internalPointer())

    def importLayer(self, layerType, providerKey, layerName, uriString, parent):
        global isImportVectorAvail

        if not isImportVectorAvail:
            return False

        if layerType == 'raster':
            return False  # not implemented yet
            inLayer = QgsRasterLayer(uriString, layerName, providerKey)
        else:
            inLayer = QgsVectorLayer(uriString, layerName, providerKey)

        if not inLayer.isValid():
            # invalid layer
            QMessageBox.warning(None, self.tr("Invalid layer"), self.tr("Unable to load the layer %s") % inLayer.name())
            return False

        # retrieve information about the new table's db and schema
        outItem = parent.internalPointer()
        outObj = outItem.getItemData()
        outDb = outObj.database()
        outSchema = None
        if isinstance(outItem, SchemaItem):
            outSchema = outObj
        elif isinstance(outItem, TableItem):
            outSchema = outObj.schema()

        # toIndex will point to the parent item of the new table
        toIndex = parent
        if isinstance(toIndex.internalPointer(), TableItem):
            toIndex = toIndex.parent()

        if inLayer.type() == inLayer.VectorLayer:
            # create the output uri
            schema = outSchema.name if outDb.schemas() is not None and outSchema is not None else ""
            pkCol = geomCol = ""

            # default pk and geom field name value
            if providerKey in ['postgres', 'spatialite']:
                inUri = QgsDataSourceURI(inLayer.source())
                pkCol = inUri.keyColumn()
                geomCol = inUri.geometryColumn()

            outUri = outDb.uri()
            outUri.setDataSource(schema, layerName, geomCol, "", pkCol)

            self.importVector.emit(inLayer, outDb, outUri, toIndex)
            return True

        return False