1855_selectpkey.diff

patch to implement optional key selection for views - Jürgen Fischer, 2009-08-12 01:54 PM

     #include <QMap>
     #include <QPair>
     #include <QIcon>
     #include <QItemDelegate>
     class QStringList;
     class QTableWidgetItem;
     class QgsGeomColumnTypeThread;
     class QgisApp;
     class QgsDbSourceSelectDelegate : public QItemDelegate
+    {
         Q_OBJECT;
       public:
         QgsDbSourceSelectDelegate( QObject *parent = NULL ) : QItemDelegate( parent )
+        {
+        }
         /** Used to create an editor for when the user tries to
          * change the contents of a cell */
         QWidget *createEditor(
           QWidget *parent,
           const QStyleOptionViewItem &option,
           const QModelIndex &index ) const
+        {
           QComboBox *cb = new QComboBox( parent );
           cb->addItems( index.data( Qt::UserRole + 1 ).toStringList() );
           return cb;
+        }
         void setModelData( QWidget *editor, QAbstractItemModel *model, const QModelIndex &index ) const
+        {
           QComboBox *cb = dynamic_cast<QComboBox *>( editor );
           if ( !cb )
             return;
           model->setData( index, cb->currentText() );
+        }
     };
     /*! \class QgsDbSourceSelect
      * \brief Dialog to create connections and add tables from PostgresQL.
+     *
-...
         QString connectionInfo();
         // Store the selected database
         void dbChanged();
         // Utility function to construct the query for finding out the
         // geometry type of a column
         static QString makeGeomQuery( QString schema, QString table, QString column );
       public slots:
         /*! Connects to the database using the stored connection parameters.
-...
         void setSearchExpression( const QString& regexp );
       private:
         enum columns
+        {
           dbssType = 0,
           dbssDetail,
           dbssSql,
           dbssColumns
         };
         typedef std::pair<QString, QString> geomPair;
         typedef std::list<geomPair > geomCol;
-...
         /**Inserts information about the spatial tables into mTableModel*/
         bool getTableInfo( PGconn *pg, bool searchGeometryColumnsOnly, bool searchPublicOnly );
         /** get primary key candidates (all int4 columns) */
         QStringList pkCandidates( PGconn *pg, QString schemaName, QString tableName );
         // queue another query for the thread
         void addSearchGeometryColumn( const QString &schema, const QString &table, const QString &column );

src/app/qgsdbtablemodel.cpp (working copy)
26	26	headerLabels << tr( "Table" );
27	27	headerLabels << tr( "Type" );
28	28	headerLabels << tr( "Geometry column" );
	29	headerLabels << tr( "Primary key column" );
29	30	headerLabels << tr( "Sql" );
30	31	setHorizontalHeaderLabels( headerLabels );
31	32	}
...	...
35	36
36	37	}
37	38
38		void QgsDbTableModel::addTableEntry( QString type, QString schemaName, QString tableName, QString geometryColName, QString sql )
	39	void QgsDbTableModel::addTableEntry( QString type, QString schemaName, QString tableName, QString geometryColName, const QStringList &pkCols, QString sql )
39	40	{
40	41	//is there already a root item with the given scheme Name?
41	42	QStandardItem* schemaItem;
...	...
68	69	tableItem->setFlags( Qt::ItemIsEnabled \| Qt::ItemIsSelectable );
69	70	QStandardItem* geomItem = new QStandardItem( geometryColName );
70	71	geomItem->setFlags( Qt::ItemIsEnabled \| Qt::ItemIsSelectable );
	72	QStandardItem* pkItem = new QStandardItem( "" );
	73	pkItem->setData( pkCols );
	74	pkItem->setFlags( Qt::ItemIsEnabled \| Qt::ItemIsSelectable \| Qt::ItemIsEditable );
71	75	QStandardItem* sqlItem = new QStandardItem( sql );
72	76	sqlItem->setFlags( Qt::ItemIsEnabled \| Qt::ItemIsSelectable );
73	77
...	...
76	80	childItemList.push_back( tableItem );
77	81	childItemList.push_back( typeItem );
78	82	childItemList.push_back( geomItem );
	83	childItemList.push_back( pkItem );
79	84	childItemList.push_back( sqlItem );
80	85
81	86	schemaItem->appendRow( childItemList );
82	87	++mTableCount;
83	88	}
84	89
85		void QgsDbTableModel::setSql( const QModelIndex& index, const QString& sql )
	90	void QgsDbTableModel::setSql( const QModelIndex& index, const QString &sql )
86	91	{
87	92	if ( !index.isValid() \|\| !index.parent().isValid() )
88	93	{
...	...
138	143	if ( itemFromIndex( currentTableIndex )->text() == tableName &&
139	144	itemFromIndex( currentGeomIndex )->text() == geomName )
140	145	{
141		QModelIndex sqlIndex = currentChildIndex.sibling( i, 4 );
	146	QModelIndex sqlIndex = currentChildIndex.sibling( i, dbtmSql );
142	147	if ( sqlIndex.isValid() )
143	148	{
144	149	itemFromIndex( sqlIndex )->setText( sql );
...	...
168	173	QModelIndex currentTableIndex;
169	174	QModelIndex currentTypeIndex;
170	175	QModelIndex currentGeomColumnIndex;
	176	QModelIndex currentPkColumnIndex;
171	177
172	178	for ( int i = 0; i < numChildren; ++i )
173	179	{
...	...
176	182	{
177	183	continue;
178	184	}
179		currentTableIndex = currentChildIndex.sibling( i, 1 );
180		currentTypeIndex = currentChildIndex.sibling( i, 2 );
181		currentGeomColumnIndex = currentChildIndex.sibling( i, 3 );
	185	currentTableIndex = currentChildIndex.sibling( i, dbtmTable );
	186	currentTypeIndex = currentChildIndex.sibling( i, dbtmType );
	187	currentGeomColumnIndex = currentChildIndex.sibling( i, dbtmGeomCol );
	188	currentPkColumnIndex = currentChildIndex.sibling( i, dbtmPkCol );
182	189	QString geomColText = itemFromIndex( currentGeomColumnIndex )->text();
	190	QStringList pkCols = itemFromIndex( currentPkColumnIndex )->data().toStringList();
183	191
184	192	if ( !currentTypeIndex.isValid() \|\| !currentTableIndex.isValid() \|\| !currentGeomColumnIndex.isValid() )
185	193	{
...	...
207	215	for ( int j = 1; j < typeList.size(); ++j )
208	216	{
209	217	//todo: add correct type
210		addTableEntry( typeList.at( j ), schema, table, geomColText + " AS " + typeList.at( j ), "" );
	218	addTableEntry( typeList.at( j ), schema, table, geomColText + " AS " + typeList.at( j ), pkCols, "" );
211	219	}
212	220	}
213	221	}

         QgsDbTableModel();
         ~QgsDbTableModel();
         /**Adds entry for one database table to the model*/
         void addTableEntry( QString type, QString schemaName, QString tableName, QString geometryColName, QString Sql );
         void addTableEntry( QString type, QString schemaName, QString tableName, QString geometryColName, const QStringList &pkCols, QString Sql );
         /**Sets an sql statement that belongs to a cell specified by a model index*/
         void setSql( const QModelIndex& index, const QString& sql );
         /**Sets one or more geometry types to a row. In case of several types, additional rows are inserted.
-...
         /**Returns the number of tables in the model*/
         int tableCount() const {return mTableCount;}
         enum columns
+        {
           dbtmSchema = 0,
           dbtmTable,
           dbtmType,
           dbtmGeomCol,
           dbtmPkCol,
           dbtmSql,
           dbtmColumns
         };
       private:
         /**Number of tables in the model*/
         int mTableCount;

     #include <QMessageBox>
     #include <QSettings>
     #include <QTextStream>
     #include <QTableWidgetItem>
     #include <QHeaderView>
     #include <QStringList>
     #include <cassert>
     #include <iostream>
     #ifdef HAVE_PGCONFIG
     #include <pg_config.h>
     #endif
-...
       mSearchColumnComboBox->addItem( tr( "Table" ) );
       mSearchColumnComboBox->addItem( tr( "Type" ) );
       mSearchColumnComboBox->addItem( tr( "Geometry column" ) );
       mSearchColumnComboBox->addItem( tr( "Primary key column" ) );
       mSearchColumnComboBox->addItem( tr( "Sql" ) );
       mProxyModel.setParent( this );
-...
       mTablesTreeView->setModel( &mProxyModel );
       mTablesTreeView->setSortingEnabled( true );
       mTablesTreeView->setEditTriggers( QAbstractItemView::CurrentChanged );
       mTablesTreeView->setItemDelegateForColumn( QgsDbTableModel::dbtmPkCol, new QgsDbSourceSelectDelegate( this ) );
       QSettings settings;
       mTablesTreeView->setSelectionMode( settings.value( "/qgis/addPostgisDC", false ).toBool() ?
                                          QAbstractItemView::ExtendedSelection :
-...
+      }
       else if ( text == tr( "Schema" ) )
+      {
         mProxyModel.setFilterKeyColumn( 0 );
         mProxyModel.setFilterKeyColumn( QgsDbTableModel::dbtmSchema );
+      }
       else if ( text == tr( "Table" ) )
+      {
         mProxyModel.setFilterKeyColumn( 1 );
         mProxyModel.setFilterKeyColumn( QgsDbTableModel::dbtmTable );
+      }
       else if ( text == tr( "Type" ) )
+      {
         mProxyModel.setFilterKeyColumn( 2 );
         mProxyModel.setFilterKeyColumn( QgsDbTableModel::dbtmType );
+      }
       else if ( text == tr( "Geometry column" ) )
+      {
         mProxyModel.setFilterKeyColumn( 3 );
         mProxyModel.setFilterKeyColumn( QgsDbTableModel::dbtmGeomCol );
+      }
       else if ( text == tr( "Primay key column" ) )
+      {
         mProxyModel.setFilterKeyColumn( QgsDbTableModel::dbtmPkCol );
+      }
       else if ( text == tr( "Sql" ) )
+      {
         mProxyModel.setFilterKeyColumn( 4 );
         mProxyModel.setFilterKeyColumn( QgsDbTableModel::dbtmSql );
+      }
+    }
-...
                                           QString type )
+    {
       mTableModel.setGeometryTypesForTable( schema, table, column, type );
       mTablesTreeView->sortByColumn( 1, Qt::AscendingOrder );
       mTablesTreeView->sortByColumn( 0, Qt::AscendingOrder );
       mTablesTreeView->sortByColumn( QgsDbTableModel::dbtmTable, Qt::AscendingOrder );
       mTablesTreeView->sortByColumn( QgsDbTableModel::dbtmSchema, Qt::AscendingOrder );
+    }
     QString QgsDbSourceSelect::makeGeomQuery( QString schema,
         QString table, QString column )
+    {
       return QString( "select distinct "
                       "case"
                       " when geometrytype(%1) IN ('POINT','MULTIPOINT') THEN 'POINT'"
                       " when geometrytype(%1) IN ('LINESTRING','MULTILINESTRING') THEN 'LINESTRING'"
                       " when geometrytype(%1) IN ('POLYGON','MULTIPOLYGON') THEN 'POLYGON'"
                       " end "
                       "from \"%2\".\"%3\"" ).arg( "\"" + column + "\"" ).arg( schema ).arg( table );
+    }
     QgsDbSourceSelect::~QgsDbSourceSelect()
+    {
       PQfinish( pd );
+    }
     void QgsDbSourceSelect::populateConnectionList()
+    {
       QSettings settings;
-...
       settings.endGroup();
       setConnectionListPosition();
+    }
     void QgsDbSourceSelect::addNewConnection()
+    {
       QgsNewConnection *nc = new QgsNewConnection( this );
-...
         populateConnectionList();
+      }
+    }
     void QgsDbSourceSelect::editConnection()
+    {
       QgsNewConnection *nc = new QgsNewConnection( this, cmbConnections->currentText() );
-...
         setConnectionListPosition();
+      }
+    }
     void QgsDbSourceSelect::addTables()
+    {
       m_selectedTables.clear();
-...
         if ( dbInfo[currentSchemaName][currentRow].size() == 0 )
+        {
           dbInfo[currentSchemaName][currentRow].resize( 5 );
           dbInfo[currentSchemaName][currentRow].resize( QgsDbTableModel::dbtmColumns );
+        }
         dbInfo[currentSchemaName][currentRow][currentColumn] = currentItem->text();
+      }
       //now traverse all the schemas and table infos
       QString schemaName, tableName, geomColumnName, sql;
       QString query;
       QMap<QString, schemaInfo>::const_iterator schema_it = dbInfo.constBegin();
       for ( ; schema_it != dbInfo.constEnd(); ++schema_it )
+      {
-...
         schemaInfo::const_iterator entry_it = scheme.constBegin();
         for ( ; entry_it != scheme.constEnd(); ++entry_it )
+        {
           schemaName = entry_it->at( 0 );
           tableName = entry_it->at( 1 );
           geomColumnName = entry_it->at( 3 );
           sql = entry_it->at( 4 );
           QString schemaName = entry_it->at( QgsDbTableModel::dbtmSchema );
           QString tableName = entry_it->at( QgsDbTableModel::dbtmTable );
           QString geomColumnName = entry_it->at( QgsDbTableModel::dbtmGeomCol );
           QString pkColumnName = entry_it->at( QgsDbTableModel::dbtmPkCol );
           QString sql = entry_it->at( QgsDbTableModel::dbtmSql );
           if ( geomColumnName.contains( " AS " ) )
+          {
             int a = geomColumnName.indexOf( " AS " );
             QString typeName = geomColumnName.mid( a + 4 ); //only the type name
             geomColumnName = geomColumnName.mid( 0, a ); //only the geom column name
             geomColumnName = geomColumnName.left( a ); //only the geom column name
             if ( !sql.isEmpty() )
+            {
-...
+            }
+          }
           query = "\"" + schemaName + "\".\"" + tableName + "\" " + "(" + geomColumnName + ") sql=" + sql;
           QString query;
           if ( !pkColumnName.isEmpty() )
+          {
             query += QString( "key=\"%1\" " ).arg( pkColumnName );
+          }
           query += QString( "table=\"%1\".\"%2\" (%3) sql=%4" )
                    .arg( schemaName ).arg( tableName )
                    .arg( geomColumnName )
                    .arg( sql );
           m_selectedTables.push_back( query );
+        }
+      }
-...
                               .arg( QString::fromUtf8( PQerrorMessage( pd ) ) ) );
+      }
       mTablesTreeView->sortByColumn( 1, Qt::AscendingOrder );
       mTablesTreeView->sortByColumn( 0, Qt::AscendingOrder );
       mTablesTreeView->sortByColumn( QgsDbTableModel::dbtmTable, Qt::AscendingOrder );
       mTablesTreeView->sortByColumn( QgsDbTableModel::dbtmSchema, Qt::AscendingOrder );
       //if we have only one schema item, expand it by default
       int numTopLevelItems = mTableModel.invisibleRootItem()->rowCount();
-...
+      }
       //create "Schema"."Table" and find out existing sql string
       QModelIndex schemaSibling = index.sibling( index.row(), 0 );
       QModelIndex tableSibling = index.sibling( index.row(), 1 );
       QModelIndex schemaSibling = index.sibling( index.row(), QgsDbTableModel::dbtmSchema );
       QModelIndex tableSibling = index.sibling( index.row(), QgsDbTableModel::dbtmTable );
       if ( !schemaSibling.isValid() || !tableSibling.isValid() )
+      {
         return;
-...
       QgsDebugMsg( tableString );
       QString currentSql;
       QModelIndex sqlSibling = index.sibling( index.row(), 4 );
       QModelIndex sqlSibling = index.sibling( index.row(), QgsDbTableModel::dbtmSql );
       if ( sqlSibling.isValid() )
+      {
         currentSql = mTableModel.itemFromIndex( mProxyModel.mapToSource( sqlSibling ) )->text();
-...
       mColumnTypeThread->addGeometryColumn( schema, table, column );
+    }
     QStringList QgsDbSourceSelect::pkCandidates( PGconn *pg, QString schemaName, QString tableName )
+    {
       QStringList cols;
       cols << QString::null;
       QString sql = QString( "select attname from pg_attribute join pg_type on atttypid=pg_type.oid WHERE pg_type.typname='int4' AND attrelid=regclass('\"%1\".\"%2\"')" ).arg( schemaName ).arg( tableName );
       QgsDebugMsg( sql );
       PGresult *colRes = PQexec( pg, sql.toUtf8() );
       if ( PQresultStatus( colRes ) == PGRES_TUPLES_OK )
+      {
         for ( int i = 0; i < PQntuples( colRes ); i++ )
+        {
           QgsDebugMsg( PQgetvalue( colRes, i, 0 ) );
           cols << QString::fromUtf8( PQgetvalue( colRes, i, 0 ) );
+        }
+      }
       else
+      {
         QgsDebugMsg( QString( "SQL:%1\nresult:%2\nerror:%3\n" ).arg( sql ).arg( PQresultStatus( colRes ) ).arg( PQerrorMessage( pg ) ) );
+      }
       PQclear( colRes );
       return cols;
+    }
     bool QgsDbSourceSelect::getTableInfo( PGconn *pg, bool searchGeometryColumnsOnly, bool searchPublicOnly )
+    {
       int n = 0;
-...
       // The following query returns only tables that exist and the user has SELECT privilege on.
       // Can't use regclass here because table must exist, else error occurs.
       QString sql = "select * from geometry_columns,pg_class,pg_namespace "
                     "where relname=f_table_name and f_table_schema=nspname "
                     "and pg_namespace.oid = pg_class.relnamespace "
                     "and has_schema_privilege(pg_namespace.nspname,'usage') "
                     "and has_table_privilege('\"'||pg_namespace.nspname||'\".\"'||pg_class.relname||'\"','select') " // user has select privilege
                     "order by f_table_schema,f_table_name,f_geometry_column";
       QString sql = "select "
                     "f_table_name,"
                     "f_table_schema,"
                     "f_geometry_column,"
                     "type"
                     " from "
                     "geometry_columns,"
                     "pg_class,"
                     "pg_namespace"
                     " where "
                     "relname=f_table_name"
                     " and f_table_schema=nspname"
                     " and pg_namespace.oid=pg_class.relnamespace"
                     " and has_schema_privilege(pg_namespace.nspname,'usage')"
                     " and has_table_privilege('\"'||pg_namespace.nspname||'\".\"'||pg_class.relname||'\"','select')" // user has select privilege
                     " order by "
                     "f_table_schema,f_table_name,f_geometry_column";
       PGresult *result = PQexec( pg, sql.toUtf8() );
       if ( result )
-...
+        {
           for ( int idx = 0; idx < PQntuples( result ); idx++ )
+          {
             QString tableName = QString::fromUtf8( PQgetvalue( result, idx, PQfnumber( result, QString( "f_table_name" ).toUtf8() ) ) );
             QString schemaName = QString::fromUtf8( PQgetvalue( result, idx, PQfnumber( result, QString( "f_table_schema" ).toUtf8() ) ) );
             QString tableName = QString::fromUtf8( PQgetvalue( result, idx, 0 ) );
             QString schemaName = QString::fromUtf8( PQgetvalue( result, idx, 1 ) );
             QString column = QString::fromUtf8( PQgetvalue( result, idx, 2 ) );
             QString type = QString::fromUtf8( PQgetvalue( result, idx, 3 ) );
             QString column = QString::fromUtf8( PQgetvalue( result, idx, PQfnumber( result, QString( "f_geometry_column" ).toUtf8() ) ) );
             QString type = QString::fromUtf8( PQgetvalue( result, idx, PQfnumber( result, QString( "type" ).toUtf8() ) ) );
             QString as = "";
             if ( type == "GEOMETRY" && !searchGeometryColumnsOnly )
+            {
-...
               as = type = "WAITING";
+            }
             mTableModel.addTableEntry( type, schemaName, tableName, column, "" );
             mTableModel.addTableEntry( type, schemaName, tableName, column, pkCandidates( pg, schemaName, tableName ), "" );
             n++;
+          }
+        }
-...
         // geometry_columns table. This code is specific to postgresql,
         // but an equivalent query should be possible in other
         // databases.
         sql = "select pg_class.relname,pg_namespace.nspname,pg_attribute.attname,pg_class.relkind "
               "from pg_attribute, pg_class, pg_namespace "
               "where pg_namespace.oid = pg_class.relnamespace "
               "and pg_attribute.attrelid = pg_class.oid "
               "and ("
         sql = "select "
               "pg_class.relname,"
               "pg_namespace.nspname,"
               "pg_attribute.attname,"
               "pg_class.relkind"
               " from "
               "pg_attribute,"
               "pg_class,"
               "pg_namespace"
               " where "
               "pg_namespace.oid = pg_class.relnamespace"
               " and pg_attribute.attrelid = pg_class.oid "
               " and ("
               "pg_attribute.atttypid = regtype('geometry')"
               " or "
               "pg_attribute.atttypid IN (select oid FROM pg_type WHERE typbasetype=regtype('geometry'))"
               ") "
               "and has_schema_privilege(pg_namespace.nspname,'usage') "
               "and has_table_privilege('\"'||pg_namespace.nspname||'\".\"'||pg_class.relname||'\"','select') ";
               " or pg_attribute.atttypid IN (select oid FROM pg_type WHERE typbasetype=regtype('geometry'))"
               ")"
               " and has_schema_privilege(pg_namespace.nspname,'usage')"
               " and has_table_privilege('\"'||pg_namespace.nspname||'\".\"'||pg_class.relname||'\"','select')";
         // user has select privilege
         if ( searchPublicOnly )
           sql += "and pg_namespace.nspname = 'public' ";
           sql += " and pg_namespace.nspname = 'public'";
         if ( n > 0 )
+        {
           sql += "and not exists (select * from geometry_columns WHERE pg_namespace.nspname=f_table_schema AND pg_class.relname=f_table_name) ";
           sql += " and not exists (select * from geometry_columns WHERE pg_namespace.nspname=f_table_schema AND pg_class.relname=f_table_name)";
+        }
         else
+        {
           n = 0;
+        }
         sql += "and pg_class.relkind in ('v', 'r')"; // only from views and relations (tables)
         sql += " and pg_class.relkind in ('v', 'r')"; // only from views and relations (tables)
         result = PQexec( pg, sql.toUtf8() );
-...
             addSearchGeometryColumn( schema, table, column );
             //details.push_back(geomPair(fullDescription(schema, table, column, "WAITING"), "WAITING"));
             mTableModel.addTableEntry( "Waiting", schema, table, column, "" );
             mTableModel.addTableEntry( "Waiting", schema, table, column, pkCandidates( pg, schema, table ), "" );
             n++;
+          }
+        }
-...
         for ( uint i = 0; i < schemas.size(); i++ )
+        {
           QString query = QgsDbSourceSelect::makeGeomQuery( schemas[i],
                           tables[i],
                           columns[i] );
           QString query = QString( "select distinct "
                                    "case"
                                    " when geometrytype(%1) IN ('POINT','MULTIPOINT') THEN 'POINT'"
                                    " when geometrytype(%1) IN ('LINESTRING','MULTILINESTRING') THEN 'LINESTRING'"
                                    " when geometrytype(%1) IN ('POLYGON','MULTIPOLYGON') THEN 'POLYGON'"
                                    " end "
                                    "from "
                                    "\"%2\".\"%3\"" ).arg( "\"" + columns[i] + "\"" ).arg( schemas[i] ).arg( tables[i] );
           PGresult* gresult = PQexec( pd, query.toUtf8() );
           QString type;
           if ( PQresultStatus( gresult ) == PGRES_TUPLES_OK )

           // create the layer
           //qWarning("creating layer");
           QgsVectorLayer *layer = new QgsVectorLayer( connectionInfo + " table=" + *it, *it, "postgres" );
           QgsVectorLayer *layer = new QgsVectorLayer( connectionInfo + " " + *it, *it, "postgres" );
           if ( layer->isValid() )
+          {
             // register this layer with the central layers registry

src/core/qgsmaprenderer.cpp (working copy)
637	637	}
638	638	catch ( QgsCsException &cse )
639	639	{
	640	Q_UNUSED( cse );
640	641	QgsDebugMsg( QString( "Transform error caught:%s" ).arg( cse.what() ) );
641	642	}
642	643	}

QGIS » QGIS Application

1855_selectpkey.diff