QGIS » QGIS Application

    bool checkPermsAndCapabilities();

    bool isCustomQuery;

    QString sqlCustomSelect;

  if ( mSchemaName.isEmpty() && mTableName.isEmpty() )

  {

    isCustomQuery = true;

    sqlCustomSelect = mUri.sql();

    sqlCustomSelect.remove( QRegExp( "\\;.*") );

    sqlWhereClause = QString();

  }

  else

  {

    isCustomQuery = false;

    sqlWhereClause = mUri.sql();

    // Keep a schema qualified table name for convenience later on.

    mSchemaTableName = mUri.quotedTablename();

  }

  QgsDebugMsg( "SQL is " + !isCustomQuery ? sqlWhereClause : sqlCustomSelect );

  if ( !checkPermsAndCapabilities() ) // check permissions and set capabilities

    query += QString(" from %1" ).arg( !isCustomQuery ? mSchemaTableName : sqlCustomSelect );

  QString sql;

  if ( !isCustomQuery )

  {

    QgsDebugMsg( "Loading fields for table " + mTableName );

    // Get the relation oid for use in later queries

    sql = QString( "SELECT regclass(%1)::oid" ).arg( quotedValue( mSchemaTableName ) );

    Result tresult = connectionRO->PQexec( sql );

    QString tblOid = QString::fromUtf8( PQgetvalue( tresult, 0, 0 ) );

    // Get the table description

    sql = QString( "SELECT description FROM pg_description WHERE objoid=%1 AND objsubid=0" ).arg( tblOid );

    tresult = connectionRO->PQexec( sql );

    if ( PQntuples( tresult ) > 0 )

      mDataComment = QString::fromUtf8( PQgetvalue( tresult, 0, 0 ) );

    // Populate the field vector for this layer. The field vector contains

    // field name, type, length, and precision (if numeric)

    sql = QString( "select * from %1 limit 0" ).arg( mSchemaTableName );

  }

  else

  {

    sql = QString( "select * from %1 limit 0" ).arg( sqlCustomSelect );

  }

    int tbloid = PQftable( result, i );

    if ( tbloid >= 0 )

    {

      QString tableOid = QString().setNum( tbloid );

      sql = QString( "SELECT attnum FROM pg_attribute WHERE attrelid=%1 AND attname=%2" )

            .arg( tableOid ).arg( quotedValue( fieldName ) );

      Result tresult = connectionRO->PQexec( sql );

      QString attnum = QString::fromUtf8( PQgetvalue( tresult, 0, 0 ) );

      sql = QString( "SELECT description FROM pg_description WHERE objoid=%1 AND objsubid=%2" )

            .arg( tableOid ).arg( attnum );

      tresult = connectionRO->PQexec( sql );

      if ( PQntuples( tresult ) > 0 )

        fieldComment = QString::fromUtf8( PQgetvalue( tresult, 0, 0 ) );

    }

bool QgsPostgresProvider::checkPermsAndCapabilities()

{

  QgsDebugMsg( "Checking for permissions on the relation" );

  Result testAccess;

  if ( !isCustomQuery )

  {

    // Check that we can read from the table (i.e., we have

    // select permission).

    QString sql = QString( "select * from %1 limit 1" ).arg( mSchemaTableName );

    Result testAccess = connectionRO->PQexec( sql );

    if ( PQresultStatus( testAccess ) != PGRES_TUPLES_OK )

    {

      showMessageBox( tr( "Unable to access relation" ),

                      tr( "Unable to access the %1 relation.\nThe error message from the database was:\n%2.\nSQL: %3" )

                      .arg( mSchemaTableName )

                      .arg( QString::fromUtf8( PQresultErrorMessage( testAccess ) ) )

                      .arg( sql ) );

      return false;

    }

    if ( connectionRO->pgVersion() >= 80400 )

    {

      sql = QString( "SELECT "

                     "has_table_privilege(%1,'DELETE'),"

                     "has_any_column_privilege(%1,'UPDATE'),"

                     "has_column_privilege(%1,%2,'UPDATE'),"

                     "has_table_privilege(%1,'INSERT'),"

                     "current_schema()" )

            .arg( quotedValue( mSchemaTableName ) ).arg( quotedValue( geometryColumn ) );

    }

    else

    {

      sql = QString( "SELECT "

                     "has_table_privilege(%1,'DELETE'),"

                     "has_table_privilege(%1,'UPDATE'),"

                     "has_table_privilege(%1,'UPDATE'),"

                     "has_table_privilege(%1,'INSERT'),"

                     "current_schema()" )

            .arg( quotedValue( mSchemaTableName ) );

    }

    testAccess = connectionRO->PQexec( sql );

    if ( PQresultStatus( testAccess ) != PGRES_TUPLES_OK )

    {

      showMessageBox( tr( "Unable to access relation" ),

                      tr( "Unable to determine table access privileges for the %1 relation.\nThe error message from the database was:\n%2.\nSQL: %3" )

                      .arg( mSchemaTableName )

                      .arg( QString::fromUtf8( PQresultErrorMessage( testAccess ) ) )

                      .arg( sql ) );

      return false;

    }

    // postgres has fast access to features at id (thanks to primary key / unique index)

    // the latter flag is here just for compatibility

    enabledCapabilities = QgsVectorDataProvider::SelectAtId | QgsVectorDataProvider::SelectGeometryAtId;

    if ( QString::fromUtf8( PQgetvalue( testAccess, 0, 0 ) ) == "t" )

    {

      // DELETE

      enabledCapabilities |= QgsVectorDataProvider::DeleteFeatures;

    }

    if ( QString::fromUtf8( PQgetvalue( testAccess, 0, 1 ) ) == "t" )

    {

      // UPDATE

      enabledCapabilities |= QgsVectorDataProvider::ChangeAttributeValues;

    }

    if ( QString::fromUtf8( PQgetvalue( testAccess, 0, 2 ) ) == "t" )

    {

      // UPDATE

      enabledCapabilities |= QgsVectorDataProvider::ChangeGeometries;

    }

    if ( QString::fromUtf8( PQgetvalue( testAccess, 0, 3 ) ) == "t" )

    {

      // INSERT

      enabledCapabilities |= QgsVectorDataProvider::AddFeatures;

    }

    mCurrentSchema = QString::fromUtf8( PQgetvalue( testAccess, 0, 4 ) );

    if ( mCurrentSchema == mSchemaName )

    {

      mUri.clearSchema();

    }

    if ( mSchemaName == "" )

      mSchemaName = mCurrentSchema;

    sql = QString( "SELECT 1 FROM pg_class,pg_namespace WHERE "

                   "pg_class.relnamespace=pg_namespace.oid AND "

                   "pg_get_userbyid(relowner)=current_user AND "

                   "relname=%1 AND nspname=%2" )

          .arg( quotedValue( mTableName ) )

          .arg( quotedValue( mSchemaName ) );

    testAccess = connectionRO->PQexec( sql );

    if ( PQresultStatus( testAccess ) == PGRES_TUPLES_OK && PQntuples( testAccess ) == 1 )

    {

      enabledCapabilities |= QgsVectorDataProvider::AddAttributes | QgsVectorDataProvider::DeleteAttributes;

    }

  }

  else

  {

    // Check if the sql is a select query

    if ( !sqlCustomSelect.startsWith( "select", Qt::CaseInsensitive ) )

    {

      QgsDebugMsg( "The custom query is not a select query." );

      //TODO show a message by showMessageBox()

      return false;

    }

    // get a new alias for the neasted query

    int index = 0;

    QString alias;

    QRegExp regex;

    do

    {

      alias = QString( "subQuery_%1" ).arg( QString::number( index++ ) );

      QString pattern = QString( "(\\\"?)%1\\1" ).arg( QRegExp::escape( alias ) );

      regex.setPattern( pattern );

      regex.setCaseSensitivity( Qt::CaseInsensitive );

    }

    while( sqlCustomSelect.contains( regex ) );

    // convert the custom query into a neasted query

    sqlCustomSelect = QString( "( %1 ) as %2" )

                  .arg( sqlCustomSelect )

                  .arg( quotedIdentifier( alias ) );

    QString sql = QString( "select * from %1 limit 1" )

                  .arg( sqlCustomSelect );

    testAccess = connectionRO->PQexec( sql );

    if ( PQresultStatus( testAccess ) != PGRES_TUPLES_OK )

    {

      showMessageBox( tr( "Unable execute the query" ),

                      tr( "Unable to execute the query.\nThe error message from the database was:\n%1.\nSQL: %2" )

                      .arg( QString::fromUtf8( PQresultErrorMessage( testAccess ) ) )

                      .arg( sql ) );

      return false;

    }

    enabledCapabilities = QgsVectorDataProvider::SelectAtId | QgsVectorDataProvider::SelectGeometryAtId;

  }

  return true;

}

  QString sql;

  if ( !isCustomQuery )

  {

    sql = QString( "select indkey from pg_index where indisunique and indrelid=regclass(%1)::oid and indpred is null" )

          .arg( quotedValue( mSchemaTableName ) );

    QgsDebugMsg( "Getting unique index using '" + sql + "'" );

    Result pk = connectionRO->PQexec( sql );

    QgsDebugMsg( "Got " + QString::number( PQntuples( pk ) ) + " rows." );

    QStringList log;

    // if we got no tuples we ain't got no unique index :)

    if ( PQntuples( pk ) == 0 )

      QgsDebugMsg( "Relation has no unique index -- investigating alternatives" );

      // Two options here. If the relation is a table, see if there is

      // an oid column that can be used instead.

      // If the relation is a view try to find a suitable column to use as

      // the primary key.

      sql = QString( "SELECT relkind FROM pg_class WHERE oid=regclass(%1)::oid" )

      Result tableType = connectionRO->PQexec( sql );

      QString type = QString::fromUtf8( PQgetvalue( tableType, 0, 0 ) );

      if ( type == "r" ) // the relation is a table

        QgsDebugMsg( "Relation is a table. Checking to see if it has an oid column." );

        primaryKey = "";

        // If there is an oid on the table, use that instead,

        // otherwise give up

        sql = QString( "SELECT attname FROM pg_attribute WHERE attname='oid' AND attrelid=regclass(%1)" )

        Result oidCheck = connectionRO->PQexec( sql );

        if ( PQntuples( oidCheck ) != 0 )

          // Could warn the user here that performance will suffer if

          // oid isn't indexed (and that they may want to add a

          // primary key to the table)

          primaryKey = "oid";

          primaryKeyType = "int4";

          mIsDbPrimaryKey = true;

        }

        else

        {

          sql = QString( "SELECT attname FROM pg_attribute WHERE attname='ctid' AND attrelid=regclass(%1)" )

                .arg( quotedValue( mSchemaTableName ) );

            sql = QString( "SELECT max(substring(ctid::text from E'\\\\((\\\\d+),\\\\d+\\\\)')::integer) from %1" )

                  .arg( mSchemaTableName );

            Result ctidCheck = connectionRO->PQexec( sql );

            if ( PQntuples( ctidCheck ) == 1 )

              int id = QString( PQgetvalue( ctidCheck, 0, 0 ) ).toInt();

              if ( id < 0x10000 )

              {

                // fallback to ctid

                primaryKey = "ctid";

                primaryKeyType = "tid";

                mIsDbPrimaryKey = true;

              }

        if ( primaryKey.isEmpty() )

          showMessageBox( tr( "No suitable key column in table" ),

                          tr( "The table has no column suitable for use as a key.\n\n"

                              "Quantum GIS requires that the table either has a column of type\n"

                              "int4 with a unique constraint on it (which includes the\n"

                              "primary key), has a PostgreSQL oid column or has a ctid\n"

                              "column with a 16bit block number.\n" ) );

        else

        {

          mPrimaryKeyDefault = defaultValue( primaryKey ).toString();

          if ( mPrimaryKeyDefault.isNull() )

          {

            mPrimaryKeyDefault = QString( "max(%1)+1 from %2.%3" )

                                 .arg( quotedIdentifier( primaryKey ) )

                                 .arg( quotedIdentifier( mSchemaName ) )

                                 .arg( quotedIdentifier( mTableName ) );

          }

        }

      else if ( type == "v" ) // the relation is a view

        if ( !primaryKey.isEmpty() )

          // check last used candidate

          sql = QString( "select pg_type.typname from pg_attribute,pg_type where atttypid=pg_type.oid and attname=%1 and attrelid=regclass(%2)" )

                .arg( quotedValue( primaryKey ) ).arg( quotedValue( mSchemaTableName ) );

          QgsDebugMsg( "checking candidate: " + sql );

          Result result = connectionRO->PQexec( sql );

          QString type;

          if ( PQresultStatus( result ) == PGRES_TUPLES_OK &&

               PQntuples( result ) == 1 )

          {

            type = PQgetvalue( result, 0, 0 );

          }

          // mPrimaryKeyDefault stays null and is retrieved later on demand

          if (( type != "int4" && type != "oid" ) ||

              !uniqueData( mSchemaName, mTableName, primaryKey ) )

          {

            primaryKey = "";

          }

        if ( primaryKey.isEmpty() )

          parseView();

      else

        QgsDebugMsg( "Unexpected relation type of '" + type + "'." );

    else // have some unique indices on the table. Now choose one...

      // choose which (if more than one) unique index to use

      std::vector<std::pair<QString, QString> > suitableKeyColumns;

      for ( int i = 0; i < PQntuples( pk ); ++i )

        QString col = QString::fromUtf8( PQgetvalue( pk, i, 0 ) );

        QStringList columns = col.split( " ", QString::SkipEmptyParts );

        if ( columns.count() == 1 )

          // Get the column name and data type

          sql = QString( "select attname,pg_type.typname from pg_attribute,pg_type where atttypid=pg_type.oid and attnum=%1 and attrelid=regclass(%2)" )

                .arg( col ).arg( quotedValue( mSchemaTableName ) );

          Result types = connectionRO->PQexec( sql );

          if ( PQntuples( types ) > 0 )

          {

            QString columnName = QString::fromUtf8( PQgetvalue( types, 0, 0 ) );

            QString columnType = QString::fromUtf8( PQgetvalue( types, 0, 1 ) );

            if ( columnType != "int4" )

              log.append( tr( "The unique index on column '%1' is unsuitable because Quantum GIS does not currently "

                              "support non-int4 type columns as a key into the table.\n" ).arg( columnName ) );

            else

            {

              mIsDbPrimaryKey = true;

              suitableKeyColumns.push_back( std::make_pair( columnName, columnType ) );

            }

          }

            //QgsDebugMsg( QString("name and type of %3. column of %1.%2 not found").arg(mSchemaName).arg(mTables).arg(col) );

          sql = QString( "select attname from pg_attribute, pg_type where atttypid=pg_type.oid and attnum in (%1) and attrelid=regclass(%2)::oid" )

                .arg( col.replace( " ", "," ) )

                .arg( quotedValue( mSchemaTableName ) );

          Result types = connectionRO->PQexec( sql );

          QString colNames;

          int numCols = PQntuples( types );

          for ( int j = 0; j < numCols; ++j )

          {

            if ( j == numCols - 1 )

              colNames += tr( "and " );

            colNames += quotedValue( QString::fromUtf8( PQgetvalue( types, j, 0 ) ) );

            if ( j < numCols - 2 )

              colNames += ",";

          }

          log.append( tr( "The unique index based on columns %1 is unsuitable because Quantum GIS does not currently "

                          "support multiple columns as a key into the table.\n" ).arg( colNames ) );

      // suitableKeyColumns now contains the name of columns (and their

      // data type) that

      // are suitable for use as a key into the table. If there is

      // more than one we need to choose one. For the moment, just

      // choose the first in the list.

      if ( suitableKeyColumns.size() > 0 )

      {

        primaryKey = suitableKeyColumns[0].first;

        primaryKeyType = suitableKeyColumns[0].second;

      }

        // If there is an oid on the table, use that instead,

        // otherwise give up

        sql = QString( "select attname from pg_attribute where attname='oid' and attrelid=regclass(%1)::oid" ).arg( quotedValue( mSchemaTableName ) );

        Result oidCheck = connectionRO->PQexec( sql );

        if ( PQntuples( oidCheck ) != 0 )

          primaryKey = "oid";

          primaryKeyType = "int4";

        else

        {

          log.prepend( "There were no columns in the table that were suitable "

                       "as a qgis key into the table (either a column with a "

                       "unique index and type int4 or a PostgreSQL oid column.\n" );

        }

      // Either primaryKey has been set by the above code, or it

      // hasn't. If not, present some info to the user to give them some

      // idea of why not.

      if ( primaryKey.isEmpty() )

        // Give some info to the user about why things didn't work out.

        valid = false;

        showMessageBox( tr( "Unable to find a key column" ), log );

        mPrimaryKeyDefault = defaultValue( primaryKey ).toString();

        if ( mPrimaryKeyDefault.isNull() )

        {

          mPrimaryKeyDefault = QString( "max(%1)+1 from %2.%3" )

                               .arg( quotedIdentifier( primaryKey ) )

                               .arg( quotedIdentifier( mSchemaName ) )

                               .arg( quotedIdentifier( mTableName ) );

        }

    QString sql = QString( "select min(%1) from %2" )

                  .arg( quotedIdentifier( fld.name() ) )

                  .arg( !isCustomQuery ? mSchemaTableName : sqlCustomSelect );

    if ( !sqlWhereClause.isEmpty() )

      sql += QString( " where %1" ).arg( sqlWhereClause );

    QString sql = QString( "select distinct %1 from %2" )

                  .arg( quotedIdentifier( fld.name() ) )

                  .arg( !isCustomQuery ? mSchemaTableName : sqlCustomSelect );

    if ( !sqlWhereClause.isEmpty() )

      sql += QString( " where %1" ).arg( sqlWhereClause );

    sql +=  QString( " order by %1" )

            .arg( quotedIdentifier( fld.name() ) );

  QString enumRangeSql = QString( "SELECT enum_range(%1) from %2 limit 1" )

                         .arg( quotedIdentifier( attributeName ) )

                         .arg( !isCustomQuery ? mSchemaTableName : sqlCustomSelect );

    QString sql = QString( "select max(%1) from %2" )

                  .arg( quotedIdentifier( fld.name() ) )

                  .arg( !isCustomQuery ? mSchemaTableName : sqlCustomSelect );

    if ( !sqlWhereClause.isEmpty() )

      sql += QString( " where %1" ).arg( sqlWhereClause );

  if ( !isCustomQuery && mUseEstimatedMetadata )

    sql = QString( "select count(*) from %1" ).arg( !isCustomQuery ? mSchemaTableName : sqlCustomSelect );

    if ( !sqlWhereClause.isEmpty() )

  if ( !isCustomQuery && ( mUseEstimatedMetadata || sqlWhereClause.isEmpty() ) )

          .arg( !isCustomQuery ? mSchemaTableName : sqlCustomSelect );

      sql += QString( " where %1" ).arg( sqlWhereClause );

  QString oidValue;

  QString schemaTableName;

  if ( isCustomQuery )

  {

    QString sql = QString( "select * from %1 limit 0" ).arg( sqlCustomSelect );

    Result res = connectionRO->PQexec( sql );

    // loop through the returned fields to get a valid oid

    // TODO check if we have found a table oid at loop exit

    for ( int i = 0; i < PQnfields( res ); i++ )

    {

      int tableOid = PQftable( res, i );

      if ( tableOid >= 0 )

      {

        oidValue = QString::number( tableOid );

        break;

      }

    }

    // get the table name

    res = connectionRO->PQexec( QString( "SELECT relname FROM pg_class WHERE oid=%1" ).arg( oidValue ) );

    schemaTableName = QString::fromUtf8( PQgetvalue( res, 0, 0 ) );

  }

  else

  {

    schemaTableName = mSchemaTableName;

    QString firstOid = QString( "select regclass(%1)::oid" ).arg( quotedValue( schemaTableName ) );

    Result oidResult = connectionRO->PQexec( firstOid );

    // get the int value from a "normal" select

    oidValue = QString::fromUtf8( PQgetvalue( oidResult, 0, 0 ) );

  }

  connectionRO->openCursor( "oidcursor", QString( "select regclass(%1)::oid" ).arg( quotedValue( schemaTableName ) ) );

  Result result;

  QString sql;

  if ( !isCustomQuery )

  {

    sql = QString( "select type,srid from geometry_columns"

                   " where f_table_name=%1 and f_geometry_column=%2 and f_table_schema=%3" )

          .arg( quotedValue( mTableName ) )

          .arg( quotedValue( geometryColumn ) )

          .arg( quotedValue( mSchemaName ) );

    QgsDebugMsg( "Getting geometry column: " + sql );

    Result result = connectionRO->PQexec( sql );

    QgsDebugMsg( "geometry column query returned " + QString::number( PQntuples( result ) ) );

    if ( PQntuples( result ) > 0 )

    {

      fType = QString::fromUtf8( PQgetvalue( result, 0, 0 ) );

      srid = QString::fromUtf8( PQgetvalue( result, 0, 1 ) );

    }

  if ( srid.isEmpty() || fType.isEmpty() )

          .arg( !isCustomQuery ? mSchemaTableName : sqlCustomSelect );

        sql += !isCustomQuery ? mSchemaTableName : sqlCustomSelect;

      if ( !sqlWhereClause.isEmpty() )

          sql += " where " + sqlWhereClause;