diff --git a/src/providers/postgres/qgspostgresconn.cpp b/src/providers/postgres/qgspostgresconn.cpp
@@ -336,8 +336,7 @@ bool QgsPostgresConn::getTableInfo( bool searchGeometryColumnsOnly, bool searchP
                            " ORDER BY f_table_schema,f_table_name,%2" ).arg( gtableName ).arg( columnName );
 
     QgsDebugMsg( "getting table info: " + sql );
-
-    result = PQexec( sql );
+    result = PQexec( sql, i == 0 );
     if ( result.PQresultStatus() != PGRES_TUPLES_OK )
     {
       PQexecNR( "COMMIT" );
@@ -369,6 +368,7 @@ bool QgsPostgresConn::getTableInfo( bool searchGeometryColumnsOnly, bool searchP
         layerProperty.pkCols = relkind == "v" ? pkCandidates( schemaName, tableName ) : QStringList();
         layerProperty.srid = srid.toInt();
         layerProperty.sql = "";
+        layerProperty.isGeography = i == 1;
 
         mLayersSupported << layerProperty;
         nColumns++;
@@ -385,10 +385,7 @@ bool QgsPostgresConn::getTableInfo( bool searchGeometryColumnsOnly, bool searchP
   //search for geometry columns in tables that are not in the geometry_columns metatable
   if ( !searchGeometryColumnsOnly )
   {
-    // Now have a look for geometry columns that aren't in the
-    // geometry_columns table. This code is specific to postgresql,
-    // but an equivalent query should be possible in other
-    // databases.
+    // Now have a look for geometry columns that aren't in the geometry_columns table.
     QString sql = "SELECT "
                   "pg_class.relname"
                   ",pg_namespace.nspname"
@@ -456,21 +453,23 @@ bool QgsPostgresConn::getTableInfo( bool searchGeometryColumnsOnly, bool searchP
         QString column  = result.PQgetvalue( i, 2 ); // attname
         QString relkind = result.PQgetvalue( i, 3 ); // relation kind
 
-        QgsDebugMsg( QString( "%1.%2.%3: %4" ).arg( schema ).arg( table ).arg( column ).arg( relkind ) );
+        QgsDebugMsg( QString( "%1.%2.%3: %4 %5" ).arg( schema ).arg( table ).arg( column ).arg( relkind ) );
 
         layerProperty.type = QString::null;
         layerProperty.schemaName = schema;
         layerProperty.tableName = table;
         layerProperty.geometryColName = column;
         layerProperty.pkCols = relkind == "v" ? pkCandidates( schema, table ) : QStringList();
         layerProperty.sql = "";
+        layerProperty.isGeography = false;	// TODO might be geography after all
 
         mLayersSupported << layerProperty;
         nColumns++;
       }
     }
   }
 
+
   if ( allowGeometrylessTables )
   {
     QString sql = "SELECT "
@@ -518,6 +517,7 @@ bool QgsPostgresConn::getTableInfo( bool searchGeometryColumnsOnly, bool searchP
         layerProperty.pkCols = relkind == "v" ? pkCandidates( schema, table ) : QStringList();
         layerProperty.srid = -1;
         layerProperty.sql = "";
+        layerProperty.isGeography = false;
 
         mLayersSupported << layerProperty;
         nColumns++;
@@ -689,24 +689,27 @@ QString QgsPostgresConn::quotedValue( QVariant value )
   }
 }
 
-PGresult *QgsPostgresConn::PQexec( QString query )
+PGresult *QgsPostgresConn::PQexec( QString query, bool logError )
 {
   QgsDebugMsgLevel( QString( "Executing SQL: %1" ).arg( query ), 3 );
   PGresult *res = ::PQexec( mConn, query.toUtf8() );
 
-  if ( res )
+  if ( logError )
   {
-    int errorStatus = PQresultStatus( res );
-    if ( errorStatus != PGRES_COMMAND_OK && errorStatus != PGRES_TUPLES_OK )
+    if ( res )
     {
-      QgsMessageLog::logMessage( tr( "Errornous query: %1 returned %2 [%3]" )
-                                 .arg( query ).arg( errorStatus ).arg( PQresultErrorMessage( res ) ),
-                                 tr( "PostGIS" ) );
+      int errorStatus = PQresultStatus( res );
+      if ( errorStatus != PGRES_COMMAND_OK && errorStatus != PGRES_TUPLES_OK )
+      {
+        QgsMessageLog::logMessage( tr( "Errornous query: %1 returned %2 [%3]" )
+                                   .arg( query ).arg( errorStatus ).arg( PQresultErrorMessage( res ) ),
+                                   tr( "PostGIS" ) );
+      }
+    }
+    else
+    {
+      QgsMessageLog::logMessage( tr( "Query failed: %1\nError: %2" ).arg( query ), tr( "PostGIS" ) );
     }
-  }
-  else
-  {
-    QgsMessageLog::logMessage( tr( "Query failed: %1\nError: %2" ).arg( query ), tr( "PostGIS" ) );
   }
 
   return res;
@@ -1014,14 +1017,17 @@ void QgsPostgresConn::retrieveLayerTypes( QgsPostgresLayerProperty &layerPropert
 
   QString query = QString( "SELECT DISTINCT"
                            " CASE"
-                           " WHEN upper(geometrytype(%1)) IN ('POINT','MULTIPOINT') THEN 'POINT'"
-                           " WHEN upper(geometrytype(%1)) IN ('LINESTRING','MULTILINESTRING') THEN 'LINESTRING'"
-                           " WHEN upper(geometrytype(%1)) IN ('POLYGON','MULTIPOLYGON') THEN 'POLYGON'"
+                           " WHEN %1 THEN 'POINT'"
+                           " WHEN %2 THEN 'LINESTRING'"
+                           " WHEN %3 THEN 'POLYGON'"
                            " END,"
-                           " coalesce(%2(%1),-1)"
-                           " FROM %3" )
-                  .arg( quotedIdentifier( layerProperty.geometryColName ) )
+                           " coalesce(%4(%5),-1)"
+                           " FROM %6" )
+                  .arg( postgisTypeFilter( layerProperty.geometryColName, QGis::Point, layerProperty.isGeography ) )
+                  .arg( postgisTypeFilter( layerProperty.geometryColName, QGis::Line, layerProperty.isGeography ) )
+                  .arg( postgisTypeFilter( layerProperty.geometryColName, QGis::Polygon, layerProperty.isGeography ) )
                   .arg( majorVersion() < 2 ? "srid" : "st_srid" )
+                  .arg( quotedIdentifier( layerProperty.geometryColName ) )
                   .arg( table );
 
   QgsDebugMsg( "Retrieving geometry types: " + query );
@@ -1050,7 +1056,7 @@ void QgsPostgresConn::retrieveLayerTypes( QgsPostgresLayerProperty &layerPropert
   layerProperty.srid = srid;
 }
 
-void QgsPostgresConn::postgisGeometryType( QGis::WkbType wkbType, QString &geometryType, int &dim )
+void QgsPostgresConn::postgisWkbType( QGis::WkbType wkbType, QString &geometryType, int &dim )
 {
   switch ( wkbType )
   {
@@ -1101,22 +1107,47 @@ void QgsPostgresConn::postgisGeometryType( QGis::WkbType wkbType, QString &geome
   }
 }
 
-QString QgsPostgresConn::postgisGeometryTypeName( QGis::WkbType wkbType )
+QString QgsPostgresConn::postgisWkbTypeName( QGis::WkbType wkbType )
 {
   QString geometryType;
   int dim;
 
-  postgisGeometryType( wkbType, geometryType, dim );
+  postgisWkbType( wkbType, geometryType, dim );
 
   return geometryType;
 }
 
-int QgsPostgresConn::postgisGeometryTypeDim( QGis::WkbType wkbType )
+QString QgsPostgresConn::postgisTypeFilter( QString geomCol, QGis::GeometryType geomType, bool isGeography )
+{
+  geomCol = quotedIdentifier( geomCol );
+  if ( isGeography )
+    geomCol += "::geometry";
+
+  switch ( geomType )
+  {
+    case QGis::Point:
+      return QString( "upper(geometrytype(%1)) IN ('POINT','MULTIPOINT','POINTM','MULTIPOINTM')" ).arg( geomCol );
+    case QGis::Line:
+      return QString( "upper(geometrytype(%1)) IN ('LINESTRING','MULTILINESTRING','LINESTRINGM','MULTILINESTRINGM')" ).arg( geomCol );
+    case QGis::Polygon:
+      return QString( "upper(geometrytype(%1)) IN ('POLYGON','MULTIPOLYGON','POLYGONM','MULTIPOLYGONM')" ).arg( geomCol );
+    case QGis::NoGeometry:
+      return QString( "geometrytype(%1) IS NULL" ).arg( geomCol );
+    case QGis::UnknownGeometry:
+      Q_ASSERT( !"unknown geometry unexpected" );
+      return QString::null;
+  }
+
+  Q_ASSERT( !"unexpected geomType" );
+  return QString::null;
+}
+
+int QgsPostgresConn::postgisWkbTypeDim( QGis::WkbType wkbType )
 {
   QString geometryType;
   int dim;
 
-  postgisGeometryType( wkbType, geometryType, dim );
+  postgisWkbType( wkbType, geometryType, dim );
 
   return dim;
 }
@@ -1153,6 +1184,107 @@ QGis::WkbType QgsPostgresConn::wkbTypeFromPostgis( QString type )
   }
 }
 
+QString QgsPostgresConn::displayStringForGeomType( QGis::GeometryType type )
+{
+  switch ( type )
+  {
+    case QGis::Point:
+      return tr( "Point" );
+    case QGis::Line:
+      return tr( "Line" );
+    case QGis::Polygon:
+      return tr( "Polygon" );
+    case QGis::NoGeometry:
+      return tr( "No Geometry" );
+    case QGis::UnknownGeometry:
+      return tr( "Unknown" );
+  }
+
+  Q_ASSERT( !"unexpected geometryType" );
+  return QString::null;
+}
+
+QString QgsPostgresConn::displayStringForWkbType( QGis::WkbType type )
+{
+  switch ( type )
+  {
+    case QGis::WKBPoint:
+    case QGis::WKBPoint25D:
+      return tr( "Point" );
+
+    case QGis::WKBMultiPoint:
+    case QGis::WKBMultiPoint25D:
+      return tr( "Multipoint" );
+
+    case QGis::WKBLineString:
+    case QGis::WKBLineString25D:
+      return tr( "Line" );
+
+    case QGis::WKBMultiLineString:
+    case QGis::WKBMultiLineString25D:
+      return tr( "Multiline" );
+
+    case QGis::WKBPolygon:
+    case QGis::WKBPolygon25D:
+      return tr( "Polygon" );
+
+    case QGis::WKBMultiPolygon:
+    case QGis::WKBMultiPolygon25D:
+      return tr( "Multipolygon" );
+
+    case QGis::WKBNoGeometry:
+      return tr( "No Geometry" );
+
+    case QGis::WKBUnknown:
+      return tr( "Unknown Geometry" );
+  }
+
+  Q_ASSERT( !"unexpected wkbType" );
+  return QString::null;
+}
+
+QGis::GeometryType QgsPostgresConn::geomTypeFromPostgis( QString dbType )
+{
+  dbType = dbType.toUpper();
+
+  if ( dbType == "POINT" || dbType == "MULTIPOINT" || dbType == "POINTM" || dbType == "MULTIPOINTM" )
+  {
+    return QGis::Point;
+  }
+  else if ( dbType == "LINESTRING" || dbType == "MULTILINESTRING" || dbType == "LINESTRINGM" || dbType == "MULTILINESTRINGM" )
+  {
+    return QGis::Line;
+  }
+  else if ( dbType == "POLYGON" || dbType == "MULTIPOLYGON" || dbType == "POLYGONM" || dbType == "MULTIPOLYGONM" )
+  {
+    return QGis::Polygon;
+  }
+  else
+  {
+    return QGis::UnknownGeometry;
+  }
+}
+
+QGis::WkbType QgsPostgresConn::wkbTypeFromGeomType( QGis::GeometryType geomType )
+{
+  switch ( geomType )
+  {
+    case QGis::Point:
+      return QGis::WKBPoint;
+    case QGis::Line:
+      return QGis::WKBLineString;
+    case QGis::Polygon:
+      return QGis::WKBPolygon;
+    case QGis::NoGeometry:
+      return QGis::WKBNoGeometry;
+    case QGis::UnknownGeometry:
+      return QGis::WKBUnknown;
+  }
+
+  Q_ASSERT( !"unexpected geomType" );
+  return QGis::WKBUnknown;
+}
+
 QStringList QgsPostgresConn::connectionList()
 {
   QSettings settings;

diff --git a/src/providers/postgres/qgspostgresconn.h b/src/providers/postgres/qgspostgresconn.h
@@ -22,7 +22,6 @@
 #include <QStringList>
 #include <QVector>
 #include <QMap>
-#include <QMutex>
 
 #include "qgis.h"
 #include "qgsdatasourceuri.h"
@@ -45,6 +44,7 @@ struct QgsPostgresLayerProperty
   QString     geometryColName;
   QStringList pkCols;
   int         srid;
+  bool        isGeography;
   QString     sql;
 };
 
@@ -123,7 +123,7 @@ class QgsPostgresConn : public QObject
     //
 
     // run a query and check for errors
-    PGresult *PQexec( QString query );
+    PGresult *PQexec( QString query, bool logError = true );
     void PQfinish();
     QString PQerrorMessage();
     int PQsendQuery( QString query );
@@ -162,10 +162,19 @@ class QgsPostgresConn : public QObject
 
     static const int sGeomTypeSelectLimit;
 
-    static QString postgisGeometryTypeName( QGis::WkbType wkbType );
-    static int postgisGeometryTypeDim( QGis::WkbType wkbType );
-    static void postgisGeometryType( QGis::WkbType wkbType, QString &geometryType, int &dim );
+    static QString displayStringForGeomType( QGis::GeometryType geomType );
+    static QString displayStringForWkbType( QGis::WkbType wkbType );
+
     static QGis::WkbType wkbTypeFromPostgis( QString type );
+    static QGis::GeometryType geomTypeFromPostgis( QString dbType );
+
+    static QString postgisWkbTypeName( QGis::WkbType wkbType );
+    static int postgisWkbTypeDim( QGis::WkbType wkbType );
+    static void postgisWkbType( QGis::WkbType wkbType, QString &geometryType, int &dim );
+
+    static QString postgisTypeFilter( QString geomCol, QGis::GeometryType geomtype, bool isGeography );
+
+    static QGis::WkbType wkbTypeFromGeomType( QGis::GeometryType geomtype );
 
     static QStringList connectionList();
     static QString selectedConnection();

diff --git a/src/providers/postgres/qgspostgresdataitems.cpp b/src/providers/postgres/qgspostgresdataitems.cpp
@@ -28,7 +28,7 @@ QVector<QgsDataItem*> QgsPGConnectionItem::createChildren()
     return children;
 
   QVector<QgsPostgresLayerProperty> layerProperties;
-  if ( !mConn->supportedLayers( layerProperties, true, false, false ) )
+  if ( !mConn->supportedLayers( layerProperties, false, true, false ) )
   {
     children.append( new QgsErrorItem( this, tr( "Failed to retrieve layers" ), mPath + "/error" ) );
     return children;
@@ -57,16 +57,22 @@ QVector<QgsDataItem*> QgsPGConnectionItem::createChildren()
 
           connect( columnTypeThread, SIGNAL( setLayerType( QgsPostgresLayerProperty ) ),
                    this, SLOT( setLayerType( QgsPostgresLayerProperty ) ) );
-          columnTypeThread->start();
+          connect( this, SIGNAL( addGeometryColumn( QgsPostgresLayerProperty ) ),
+                   columnTypeThread, SLOT( addGeometryColumn( QgsPostgresLayerProperty ) ) );
         }
       }
-      columnTypeThread->addGeometryColumn( layerProperty );
+
+      emit addGeometryColumn( layerProperty );
+
       continue;
     }
 
     schemaItem->addLayer( layerProperty );
   }
 
+  if ( columnTypeThread )
+    columnTypeThread->start();
+
   return children;
 }
 
@@ -82,8 +88,8 @@ void QgsPGConnectionItem::setLayerType( QgsPostgresLayerProperty layerProperty )
 
   foreach( QString type, layerProperty.type.split( ",", QString::SkipEmptyParts ) )
   {
-    QGis::WkbType wkbType = QgsPgTableModel::qgisTypeFromDbType( type );
-    if ( wkbType == QGis::WKBUnknown )
+    QGis::GeometryType geomType = QgsPostgresConn::geomTypeFromPostgis( type );
+    if ( geomType == QGis::UnknownGeometry )
     {
       QgsDebugMsg( QString( "unsupported geometry type:%1" ).arg( type ) );
       continue;
@@ -166,7 +172,7 @@ QString QgsPGLayerItem::createUri()
   QgsDataSourceURI uri( connItem->connection()->connInfo() );
   uri.setDataSource( mLayerProperty.schemaName, mLayerProperty.tableName, mLayerProperty.geometryColName, mLayerProperty.sql, pkColName );
   uri.setSrid( QString::number( mLayerProperty.srid ) );
-  uri.setGeometryType( QgsPgTableModel::qgisTypeFromDbType( mLayerProperty.type ) );
+  uri.setGeometryType( QgsPostgresConn::geomTypeFromPostgis( mLayerProperty.type ) );
   QgsDebugMsg( QString( "layer uri: %1" ).arg( uri.uri() ) );
   return uri.uri();
 }
@@ -190,35 +196,35 @@ QgsPGSchemaItem::~QgsPGSchemaItem()
 
 void QgsPGSchemaItem::addLayer( QgsPostgresLayerProperty layerProperty )
 {
-  QGis::WkbType wkbType = QgsPgTableModel::qgisTypeFromDbType( layerProperty.type );
-  QString name = layerProperty.tableName + "." + layerProperty.geometryColName;
+  QGis::GeometryType geomType = QgsPostgresConn::geomTypeFromPostgis( layerProperty.type );
+  QString tip = tr( "%1 as %2" ).arg( layerProperty.geometryColName ).arg( QgsPostgresConn::displayStringForGeomType( geomType ) );
 
   QgsLayerItem::LayerType layerType;
-  if ( layerProperty.type.contains( "POINT" ) )
-  {
-    layerType = QgsLayerItem::Point;
-  }
-  else if ( layerProperty.type.contains( "LINE" ) )
-  {
-    layerType = QgsLayerItem::Line;
-  }
-  else if ( layerProperty.type.contains( "POLYGON" ) )
-  {
-    layerType = QgsLayerItem::Polygon;
-  }
-  else if ( layerProperty.type.isEmpty() && layerProperty.geometryColName.isEmpty() )
+  switch ( geomType )
   {
-    layerType = QgsLayerItem::TableLayer;
-    name = layerProperty.tableName;
-  }
-  else
-  {
-    return;
+    case QGis::Point:
+      layerType = QgsLayerItem::Point;
+      break;
+    case QGis::Line:
+      layerType = QgsLayerItem::Line;
+      break;
+    case QGis::Polygon:
+      layerType = QgsLayerItem::Polygon;
+      break;
+    default:
+      if ( layerProperty.type.isEmpty() && layerProperty.geometryColName.isEmpty() )
+      {
+        layerType = QgsLayerItem::TableLayer;
+        tip = tr( "as geometryless table" );
+      }
+      else
+      {
+        return;
+      }
   }
 
-  name += " (" + QgsPgTableModel::displayStringForType( wkbType ) + ")";
-
-  QgsPGLayerItem *layerItem = new QgsPGLayerItem( this, name, mPath + "/" + name, layerType, layerProperty );
+  QgsPGLayerItem *layerItem = new QgsPGLayerItem( this, layerProperty.tableName, mPath + "/" + layerProperty.tableName, layerType, layerProperty );
+  layerItem->setToolTip( tip );
   addChild( layerItem );
 }
 

diff --git a/src/providers/postgres/qgspostgresdataitems.h b/src/providers/postgres/qgspostgresdataitems.h
@@ -42,6 +42,9 @@ class QgsPGConnectionItem : public QgsDataCollectionItem
 
     QgsPostgresConn *connection() const { return mConn; }
 
+  signals:
+    void addGeometryColumn( QgsPostgresLayerProperty );
+
   public slots:
     void editConnection();
     void deleteConnection();

diff --git a/src/providers/postgres/qgspostgresprovider.cpp b/src/providers/postgres/qgspostgresprovider.cpp
@@ -44,8 +44,9 @@ QgsPostgresProvider::QgsPostgresProvider( QString const & uri )
     : QgsVectorDataProvider( uri )
     , mFetching( false )
     , mValid( false )
-    , mDetectedGeomType( QGis::WKBUnknown )
-    , mRequestedGeomType( QGis::WKBUnknown )
+    , mPrimaryKeyType( pktUnknown )
+    , mDetectedGeomType( QGis::UnknownGeometry )
+    , mRequestedGeomType( QGis::UnknownGeometry )
     , mFeatureQueueSize( sFeatureQueueSize )
     , mUseEstimatedMetadata( false )
     , mSelectAtIdDisabled( false )
@@ -253,18 +254,11 @@ bool QgsPostgresProvider::declareCursor(
 
     if ( fetchGeometry )
     {
-      if ( mIsGeography )
-      {
-        query += QString( "st_asbinary(%1)" )
-                 .arg( quotedIdentifier( mGeometryColumn ) );
-      }
-      else
-      {
-        query += QString( "%1(%2,'%3')" )
-                 .arg( mConnectionRO->majorVersion() < 2 ? "asbinary" : "st_asbinary" )
-                 .arg( quotedIdentifier( mGeometryColumn ) )
-                 .arg( endianString() );
-      }
+      query += QString( "%1(%2(%3::geometry),'%4')" )
+               .arg( mConnectionRO->majorVersion() < 2 ? "asbinary" : "st_asbinary" )
+               .arg( mConnectionRO->majorVersion() < 2 ? "force_2d" : "st_force_2d" )
+               .arg( quotedIdentifier( mGeometryColumn ) )
+               .arg( endianString() );
       delim = ",";
     }
 
@@ -576,11 +570,9 @@ void QgsPostgresProvider::select( QgsAttributeList fetchAttributes, QgsRectangle
                      .arg( mRequestedSrid );
     }
 
-    if ( mRequestedGeomType != QGis::WKBUnknown && mRequestedGeomType != mDetectedGeomType )
+    if ( mRequestedGeomType != QGis::UnknownGeometry && mRequestedGeomType != mDetectedGeomType )
     {
-      whereClause += QString( " AND upper(geometrytype(%1))=%2" )
-                     .arg( quotedIdentifier( mGeometryColumn ) )
-                     .arg( quotedValue( QgsPostgresConn::postgisGeometryTypeName( mRequestedGeomType ) ) );
+      whereClause += QString( " AND %1" ).arg( QgsPostgresConn::postgisTypeFilter( mGeometryColumn, mRequestedGeomType, mIsGeography ) );
     }
   }
 
@@ -909,7 +901,9 @@ void QgsPostgresProvider::setExtent( QgsRectangle& newExtent )
  */
 QGis::WkbType QgsPostgresProvider::geometryType() const
 {
-  return mRequestedGeomType != QGis::WKBUnknown ? mRequestedGeomType : mDetectedGeomType;
+  return mRequestedGeomType != QGis::UnknownGeometry
+         ? QgsPostgresConn::wkbTypeFromGeomType( mRequestedGeomType )
+         : QgsPostgresConn::wkbTypeFromGeomType( mDetectedGeomType );
 }
 
 const QgsField &QgsPostgresProvider::field( int index ) const
@@ -1344,7 +1338,6 @@ bool QgsPostgresProvider::hasSufficientPermsAndCapabilities()
 
 bool QgsPostgresProvider::determinePrimaryKey()
 {
-  mPrimaryKeyType = pktUnknown;
   if ( !loadFields() )
   {
     return false;
@@ -1389,7 +1382,7 @@ bool QgsPostgresProvider::determinePrimaryKey()
         sql = QString( "SELECT attname FROM pg_attribute WHERE attname='oid' AND attrelid=regclass(%1)" ).arg( quotedValue( mQuery ) );
 
         res = mConnectionRO->PQexec( sql );
-        if ( res.PQntuples() == 0 )
+        if ( res.PQntuples() == 1 )
         {
           // Could warn the user here that performance will suffer if
           // oid isn't indexed (and that they may want to add a
@@ -2531,7 +2524,7 @@ bool QgsPostgresProvider::getGeometryDetails()
 {
   if ( mGeometryColumn.isNull() )
   {
-    mDetectedGeomType = QGis::WKBNoGeometry;
+    mDetectedGeomType = QGis::NoGeometry;
     mValid = true;
     return true;
   }
@@ -2637,12 +2630,9 @@ bool QgsPostgresProvider::getGeometryDetails()
       delim = " AND ";
     }
 
-    if ( mRequestedGeomType != QGis::WKBUnknown )
+    if ( mRequestedGeomType != QGis::UnknownGeometry )
     {
-      layerProperty.sql += QString( "%1upper(geometrytype(%2))=%3" )
-                           .arg( delim )
-                           .arg( quotedIdentifier( mGeometryColumn ) )
-                           .arg( quotedValue( QgsPostgresConn::postgisGeometryTypeName( mRequestedGeomType ) ) );
+      layerProperty.sql += delim + QgsPostgresConn::postgisTypeFilter( mGeometryColumn, mRequestedGeomType, mIsGeography );
       delim = " AND ";
     }
 
@@ -2671,10 +2661,10 @@ bool QgsPostgresProvider::getGeometryDetails()
 
   if ( !type.isEmpty() && !srid.isEmpty() )
   {
-    mDetectedGeomType = QgsPostgresConn::wkbTypeFromPostgis( type );
+    mDetectedGeomType = QgsPostgresConn::geomTypeFromPostgis( type );
     mDetectedSrid = srid;
 
-    mValid = mDetectedGeomType != QGis::WKBUnknown || mRequestedGeomType != QGis::WKBUnknown;
+    mValid = mDetectedGeomType != QGis::UnknownGeometry || mRequestedGeomType != QGis::UnknownGeometry;
 
     if ( !mValid )
     {
@@ -2898,7 +2888,7 @@ QgsVectorLayerImport::ImportError QgsPostgresProvider::createEmptyLayer(
     int dim = 2;
     long srid = srs->postgisSrid();
 
-    QgsPostgresConn::postgisGeometryType( wkbType, geometryType, dim );
+    QgsPostgresConn::postgisWkbType( wkbType, geometryType, dim );
 
     // create geometry column
     if ( !geometryType.isEmpty() )

diff --git a/src/providers/postgres/qgspostgresprovider.h b/src/providers/postgres/qgspostgresprovider.h
@@ -124,12 +124,8 @@ class QgsPostgresProvider : public QgsVectorDataProvider
      */
     QGis::WkbType geometryType() const;
 
-
     /** return the number of layers for the current data source
-
-    @note
-
-    Should this be subLayerCount() instead?
+     * @note Should this be subLayerCount() instead?
     */
     size_t layerCount() const;
 
@@ -421,10 +417,10 @@ class QgsPostgresProvider : public QgsVectorDataProvider
     QgsRectangle mLayerExtent;       //! Rectangle that contains the extent (bounding box) of the layer
     mutable long mFeaturesCounted;   //! Number of features in the layer
 
-    QGis::WkbType mDetectedGeomType;  //! geometry type detected in the database
-    QGis::WkbType mRequestedGeomType; //! geometry type requested in the uri
-    QString mDetectedSrid;            //! Spatial reference detected in the database
-    QString mRequestedSrid;           //! Spatial reference requested in the uri
+    QGis::GeometryType mDetectedGeomType;  //! geometry type detected in the database
+    QGis::GeometryType mRequestedGeomType; //! geometry type requested in the uri
+    QString mDetectedSrid;                 //! Spatial reference detected in the database
+    QString mRequestedSrid;                //! Spatial reference requested in the uri
 
     /**
      * Feature queue that GetNextFeature will retrieve from