OGRPGeoSelectLayer::OGRPGeoSelectLayer( OGRPGeoDataSource *poDSIn,
CPLODBCStatement * poStmtIn )
{
poDS = poDSIn;
iNextShapeId = 0;
nSRSId = -1;
poFeatureDefn = NULL;
poStmt = poStmtIn;
pszBaseStatement = CPLStrdup( poStmtIn->GetCommand() );
/* Just to make test_ogrsf happy, but would/could need be extended to */
/* other cases */
if( EQUALN(pszBaseStatement, "SELECT * FROM ", strlen("SELECT * FROM ")) )
{
OGRLayer* poBaseLayer =
poDSIn->GetLayerByName(pszBaseStatement + strlen("SELECT * FROM "));
if( poBaseLayer != NULL )
{
poSRS = poBaseLayer->GetSpatialRef();
if( poSRS != NULL )
poSRS->Reference();
}
}
BuildFeatureDefn( "SELECT", poStmt );
}
CPLErr OGRMDBLayer::Initialize( const char *pszTableName,
const char *pszGeomCol,
OGRSpatialReference* poSRS )
{
CPLFree( pszGeomColumn );
if( pszGeomCol == NULL )
pszGeomColumn = NULL;
else
{
pszGeomColumn = CPLStrdup( pszGeomCol );
iGeomColumn = poMDBTable->GetColumnIndex( pszGeomColumn );
}
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
eGeometryType = MDB_GEOM_GEOMEDIA;
this->poSRS = poSRS;
CPLErr eErr;
eErr = BuildFeatureDefn();
if( eErr != CE_None )
return eErr;
return CE_None;
}
OGRMSSQLSpatialSelectLayer::OGRMSSQLSpatialSelectLayer( OGRMSSQLSpatialDataSource *poDSIn,
CPLODBCStatement * poStmtIn )
{
poDS = poDSIn;
iNextShapeId = 0;
nSRSId = -1;
poFeatureDefn = NULL;
poStmt = poStmtIn;
pszBaseStatement = CPLStrdup( poStmtIn->GetCommand() );
/* identify the geometry column */
pszGeomColumn = NULL;
for ( int iColumn = 0; iColumn < poStmt->GetColCount(); iColumn++ )
{
if ( EQUAL(poStmt->GetColTypeName( iColumn ), "image") )
{
SQLCHAR szTableName[256];
SQLSMALLINT nTableNameLength = 0;
SQLColAttribute(poStmt->GetStatement(), (SQLSMALLINT)(iColumn + 1), SQL_DESC_TABLE_NAME,
szTableName, sizeof(szTableName),
&nTableNameLength, NULL);
if (nTableNameLength > 0)
{
OGRLayer *poBaseLayer = poDS->GetLayerByName((const char*)szTableName);
if (poBaseLayer != NULL && EQUAL(poBaseLayer->GetGeometryColumn(), poStmt->GetColName(iColumn)))
{
nGeomColumnType = MSSQLCOLTYPE_BINARY;
pszGeomColumn = CPLStrdup(poStmt->GetColName(iColumn));
/* copy spatial reference */
if (!poSRS && poBaseLayer->GetSpatialRef())
poSRS = poBaseLayer->GetSpatialRef()->Clone();
break;
}
}
}
else if ( EQUAL(poStmt->GetColTypeName( iColumn ), "geometry") )
{
nGeomColumnType = MSSQLCOLTYPE_GEOMETRY;
pszGeomColumn = CPLStrdup(poStmt->GetColName(iColumn));
break;
}
else if ( EQUAL(poStmt->GetColTypeName( iColumn ), "geography") )
{
nGeomColumnType = MSSQLCOLTYPE_GEOGRAPHY;
pszGeomColumn = CPLStrdup(poStmt->GetColName(iColumn));
break;
}
}
BuildFeatureDefn( "SELECT", poStmt );
if ( GetSpatialRef() && poFeatureDefn->GetGeomFieldCount() == 1)
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef( poSRS );
}
OGRWalkSelectLayer::OGRWalkSelectLayer( OGRWalkDataSource *poDSIn,
CPLODBCStatement * poStmtIn ) :
pszBaseStatement(CPLStrdup(poStmtIn->GetCommand()))
{
poDS = poDSIn;
iNextShapeId = 0;
poFeatureDefn = NULL;
poStmt = poStmtIn;
BuildFeatureDefn( "SELECT", poStmt );
}
OGRGeomediaSelectLayer::OGRGeomediaSelectLayer( OGRGeomediaDataSource *poDSIn,
CPLODBCStatement * poStmtIn ) :
pszBaseStatement(CPLStrdup( poStmtIn->GetCommand() ))
{
poDS = poDSIn;
iNextShapeId = 0;
nSRSId = -1;
poFeatureDefn = nullptr;
poStmt = poStmtIn;
BuildFeatureDefn( "SELECT", poStmt );
}
OGRODBCSelectLayer::OGRODBCSelectLayer( OGRODBCDataSource *poDSIn,
CPLODBCStatement * poStmtIn )
{
poDS = poDSIn;
iNextShapeId = 0;
nSRSId = -1;
poFeatureDefn = NULL;
poStmt = poStmtIn;
pszBaseStatement = CPLStrdup( poStmtIn->GetCommand() );
BuildFeatureDefn( "SELECT", poStmt );
}
OGROGDILayer::OGROGDILayer( OGROGDIDataSource *poODS,
const char * pszName, ecs_Family eFamily ) :
m_poODS(poODS),
m_nClientID(poODS->GetClientID()),
m_pszOGDILayerName(CPLStrdup(pszName)),
m_eFamily(eFamily),
m_poFeatureDefn(NULL),
// Keep a reference on the SpatialRef (owned by the dataset).
m_poSpatialRef(m_poODS->GetSpatialRef()),
m_sFilterBounds(*(m_poODS->GetGlobalBounds())),
m_iNextShapeId(0),
m_nTotalShapeCount(-1),
m_nFilteredOutShapes(0)
{
// Select layer and feature family.
ResetReading();
BuildFeatureDefn();
}
OGROGDILayer::OGROGDILayer( OGROGDIDataSource *poODS,
const char * pszName, ecs_Family eFamily )
{
m_poODS = poODS;
m_nClientID = m_poODS->GetClientID();
m_eFamily = eFamily;
m_pszOGDILayerName = CPLStrdup(pszName);
m_sFilterBounds = *(m_poODS->GetGlobalBounds());
m_iNextShapeId = 0;
m_nTotalShapeCount = -1;
m_poFeatureDefn = NULL;
// Keep a reference on the SpatialRef (owned by the dataset).
m_poSpatialRef = m_poODS->GetSpatialRef();
// Select layer and feature family.
ResetReading();
BuildFeatureDefn();
}
OGRFeatureDefn* OGRMSSQLSpatialTableLayer::GetLayerDefn()
{
if (poFeatureDefn)
return poFeatureDefn;
CPLODBCSession *poSession = poDS->GetSession();
/* -------------------------------------------------------------------- */
/* Do we have a simple primary key? */
/* -------------------------------------------------------------------- */
CPLODBCStatement oGetKey( poSession );
if( oGetKey.GetPrimaryKeys( pszTableName, poDS->GetCatalog(), pszSchemaName )
&& oGetKey.Fetch() )
{
pszFIDColumn = CPLStrdup(oGetKey.GetColData( 3 ));
if( oGetKey.Fetch() ) // more than one field in key!
{
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
CPLDebug( "OGR_MSSQLSpatial", "Table %s has multiple primary key fields, "
"ignoring them all.", pszTableName );
}
}
/* -------------------------------------------------------------------- */
/* Get the column definitions for this table. */
/* -------------------------------------------------------------------- */
CPLODBCStatement oGetCol( poSession );
CPLErr eErr;
if( !oGetCol.GetColumns( pszTableName, poDS->GetCatalog(), pszSchemaName ) )
return NULL;
eErr = BuildFeatureDefn( pszLayerName, &oGetCol );
if( eErr != CE_None )
return NULL;
poFeatureDefn->SetGeomType(eGeomType);
if( poFeatureDefn->GetFieldCount() == 0 &&
pszFIDColumn == NULL && pszGeomColumn == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"No column definitions found for table '%s', layer not usable.",
pszLayerName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* If we got a geometry column, does it exist? Is it binary? */
/* -------------------------------------------------------------------- */
if( pszGeomColumn != NULL )
{
int iColumn = oGetCol.GetColId( pszGeomColumn );
if( iColumn < 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Column %s requested for geometry, but it does not exist.",
pszGeomColumn );
CPLFree( pszGeomColumn );
pszGeomColumn = NULL;
}
else
{
if ( nGeomColumnType < 0 )
{
/* last attempt to identify the geometry column type */
if ( EQUAL(oGetCol.GetColTypeName( iColumn ), "geometry") )
nGeomColumnType = MSSQLCOLTYPE_GEOMETRY;
else if ( EQUAL(oGetCol.GetColTypeName( iColumn ), "geography") )
nGeomColumnType = MSSQLCOLTYPE_GEOGRAPHY;
else if ( EQUAL(oGetCol.GetColTypeName( iColumn ), "varchar") )
nGeomColumnType = MSSQLCOLTYPE_TEXT;
else if ( EQUAL(oGetCol.GetColTypeName( iColumn ), "nvarchar") )
nGeomColumnType = MSSQLCOLTYPE_TEXT;
else if ( EQUAL(oGetCol.GetColTypeName( iColumn ), "text") )
nGeomColumnType = MSSQLCOLTYPE_TEXT;
else if ( EQUAL(oGetCol.GetColTypeName( iColumn ), "ntext") )
nGeomColumnType = MSSQLCOLTYPE_TEXT;
else if ( EQUAL(oGetCol.GetColTypeName( iColumn ), "image") )
nGeomColumnType = MSSQLCOLTYPE_BINARY;
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Column type %s is not supported for geometry column.",
oGetCol.GetColTypeName( iColumn ) );
CPLFree( pszGeomColumn );
pszGeomColumn = NULL;
}
}
}
}
return poFeatureDefn;
}
OGRDB2SelectLayer::OGRDB2SelectLayer( OGRDB2DataSource *poDSIn,
OGRDB2Statement * poStmtIn )
{
SQLCHAR szTableName[256];
SQLCHAR szSchemaName[256];
SQLSMALLINT nNameLength = 0;
OGRDB2Layer *poBaseLayer = NULL;
poDS = poDSIn;
iNextShapeId = 0;
nSRSId = -1;
poFeatureDefn = NULL;
m_poStmt = poStmtIn;
pszBaseStatement = CPLStrdup( poStmtIn->GetCommand() );
CPLDebug("OGR_DB2SelectLayer::OGRDB2SelectLayer", "SQL: '%s'",
pszBaseStatement);
pszGeomColumn = NULL;
/* get schema and table names for first column, column 1 */
SQLColAttribute(m_poStmt->GetStatement(), (SQLSMALLINT)(1),
SQL_DESC_SCHEMA_NAME,
szSchemaName, sizeof(szSchemaName),
&nNameLength, NULL);
/* The schema name is sometimes right padded with blanks */
/* Replace blanks with nulls to terminate string for sprintf below */
for (int i = 0; i < nNameLength; i++) {
if (szSchemaName[i] == ' ') szSchemaName[i] = 0;
};
SQLColAttribute(m_poStmt->GetStatement(), (SQLSMALLINT)(1),
SQL_DESC_TABLE_NAME,
szTableName, sizeof(szTableName),
&nNameLength, NULL);
CPLDebug("OGR_DB2SelectLayer::OGRDB2SelectLayer",
"szSchemaName: '%s'; szTableName: '%s'",
szSchemaName, szTableName);
if (nNameLength > 0)
{
char szLayerName[512];
sprintf(szLayerName, "%s.%s",szSchemaName, szTableName);
poBaseLayer = (OGRDB2Layer *) poDS->GetLayerByName((const char*)
szLayerName);
if (poBaseLayer != NULL)
CPLDebug("OGR_DB2SelectLayer::OGRDB2SelectLayer",
"base geom col: '%s'", poBaseLayer->GetGeometryColumn());
else CPLDebug("OGR_DB2SelectLayer::OGRDB2SelectLayer",
"base layer not found");
}
/* identify the geometry column */
for ( int iColumn = 0; iColumn < m_poStmt->GetColCount(); iColumn++ )
{
if ( EQUAL(m_poStmt->GetColTypeName( iColumn ), "CLOB") ||
EQUAL(m_poStmt->GetColTypeName( iColumn ),
"VARCHAR () FOR BIT DATA"))
{
if (poBaseLayer != NULL
&& EQUAL(poBaseLayer->GetGeometryColumn(),
m_poStmt->GetColName(iColumn)))
{
pszGeomColumn = CPLStrdup(m_poStmt->GetColName(iColumn));
/* copy spatial reference */
if (!poSRS && poBaseLayer->GetSpatialRef())
poSRS = poBaseLayer->GetSpatialRef()->Clone();
nSRSId = poBaseLayer->GetSRSId();
break;
}
}
}
BuildFeatureDefn( "SELECT", m_poStmt );
if ( GetSpatialRef() && poFeatureDefn->GetGeomFieldCount() == 1)
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef( poSRS );
}
CPLErr OGRSQLiteTableLayer::Initialize( const char *pszTableName,
const char *pszGeomCol,
OGRwkbGeometryType eGeomType,
const char *pszGeomFormat,
OGRSpatialReference *poSRS,
int nSRSId,
int bHasSpatialIndex,
int bHasM,
int bSpatialiteReadOnly,
int bSpatialiteLoaded,
int iSpatialiteVersion )
{
int rc;
sqlite3 *hDB = poDS->GetDB();
if( pszGeomCol == NULL )
osGeomColumn = "";
else
osGeomColumn = pszGeomCol;
if( pszGeomFormat )
{
if ( EQUAL(pszGeomFormat, "WKT") )
eGeomFormat = OSGF_WKT;
else if ( EQUAL(pszGeomFormat,"WKB") )
eGeomFormat = OSGF_WKB;
else if ( EQUAL(pszGeomFormat,"FGF") )
eGeomFormat = OSGF_FGF;
else if( EQUAL(pszGeomFormat,"SpatiaLite") )
eGeomFormat = OSGF_SpatiaLite;
}
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
this->poSRS = poSRS;
this->nSRSId = nSRSId;
this->bHasSpatialIndex = bHasSpatialIndex;
this->bHasM = bHasM;
this->bSpatialiteReadOnly = bSpatialiteReadOnly;
this->bSpatialiteLoaded = bSpatialiteLoaded;
this->iSpatialiteVersion = iSpatialiteVersion;
pszEscapedTableName = CPLStrdup(OGRSQLiteEscape(pszTableName));
CPLErr eErr;
sqlite3_stmt *hColStmt = NULL;
const char *pszSQL;
if ( eGeomFormat == OSGF_SpatiaLite &&
bSpatialiteLoaded == TRUE &&
iSpatialiteVersion < 24 && poDS->GetUpdate() )
{
// we need to test version required by Spatialite TRIGGERs
hColStmt = NULL;
pszSQL = CPLSPrintf( "SELECT sql FROM sqlite_master WHERE type = 'trigger' AND tbl_name = '%s' AND sql LIKE '%%RTreeAlign%%'",
pszEscapedTableName );
int nRowTriggerCount, nColTriggerCount;
char **papszTriggerResult, *pszErrMsg;
rc = sqlite3_get_table( hDB, pszSQL, &papszTriggerResult,
&nRowTriggerCount, &nColTriggerCount, &pszErrMsg );
if( nRowTriggerCount >= 1 )
{
// obsolete library version not supporting new triggers
// enforcing ReadOnly mode
CPLDebug("SQLITE", "Enforcing ReadOnly mode : obsolete library version not supporting new triggers");
this->bSpatialiteReadOnly = TRUE;
}
sqlite3_free_table( papszTriggerResult );
}
if( poSRS )
poSRS->Reference();
/* -------------------------------------------------------------------- */
/* Get the column definitions for this table. */
/* -------------------------------------------------------------------- */
hColStmt = NULL;
pszSQL = CPLSPrintf( "SELECT _rowid_, * FROM '%s' LIMIT 1",
pszEscapedTableName );
rc = sqlite3_prepare( hDB, pszSQL, strlen(pszSQL), &hColStmt, NULL );
if( rc != SQLITE_OK )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to query table %s for column definitions : %s.",
pszTableName, sqlite3_errmsg(hDB) );
return CE_Failure;
}
rc = sqlite3_step( hColStmt );
if ( rc != SQLITE_DONE && rc != SQLITE_ROW )
{
CPLError( CE_Failure, CPLE_AppDefined,
"In Initialize(): sqlite3_step(%s):\n %s",
pszSQL, sqlite3_errmsg(hDB) );
sqlite3_finalize( hColStmt );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* What should we use as FID? If there is a primary key */
/* integer field, then this will be used as the _rowid_, and we */
/* will pick up the real column name here. Otherwise, we will */
/* just use fid. */
/* */
/* Note that the select _rowid_ will return the real column */
/* name if the rowid corresponds to another primary key */
/* column. */
/* -------------------------------------------------------------------- */
pszFIDColumn = CPLStrdup(sqlite3_column_name( hColStmt, 0 ));
/* -------------------------------------------------------------------- */
/* Collect the rest of the fields. */
/* -------------------------------------------------------------------- */
eErr = BuildFeatureDefn( pszTableName, hColStmt );
sqlite3_finalize( hColStmt );
if( eErr != CE_None )
return eErr;
/* -------------------------------------------------------------------- */
/* Set the geometry type if we know it. */
/* -------------------------------------------------------------------- */
if( eGeomType != wkbUnknown )
poFeatureDefn->SetGeomType( eGeomType );
return CE_None;
}
OGRMSSQLSpatialSelectLayer::OGRMSSQLSpatialSelectLayer( OGRMSSQLSpatialDataSource *poDSIn,
CPLODBCStatement * poStmtIn )
{
poDS = poDSIn;
iNextShapeId = 0;
nSRSId = 0;
poFeatureDefn = nullptr;
poStmt = poStmtIn;
pszBaseStatement = CPLStrdup( poStmtIn->GetCommand() );
/* identify the geometry column */
pszGeomColumn = nullptr;
int iImageCol = -1;
for ( int iColumn = 0; iColumn < poStmt->GetColCount(); iColumn++ )
{
if ( EQUAL(poStmt->GetColTypeName( iColumn ), "image") )
{
SQLCHAR szTableName[256];
SQLSMALLINT nTableNameLength = 0;
SQLColAttribute(poStmt->GetStatement(), (SQLSMALLINT)(iColumn + 1), SQL_DESC_TABLE_NAME,
szTableName, sizeof(szTableName),
&nTableNameLength, nullptr);
if (nTableNameLength > 0)
{
OGRLayer *poBaseLayer = poDS->GetLayerByName((const char*)szTableName);
if (poBaseLayer != nullptr && EQUAL(poBaseLayer->GetGeometryColumn(), poStmt->GetColName(iColumn)))
{
nGeomColumnType = MSSQLCOLTYPE_BINARY;
pszGeomColumn = CPLStrdup(poStmt->GetColName(iColumn));
/* copy spatial reference */
if (!poSRS && poBaseLayer->GetSpatialRef())
poSRS = poBaseLayer->GetSpatialRef()->Clone();
break;
}
}
else if (iImageCol == -1)
iImageCol = iColumn;
}
else if ( EQUAL(poStmt->GetColTypeName( iColumn ), "geometry") )
{
nGeomColumnType = MSSQLCOLTYPE_GEOMETRY;
pszGeomColumn = CPLStrdup(poStmt->GetColName(iColumn));
break;
}
else if ( EQUAL(poStmt->GetColTypeName( iColumn ), "geography") )
{
nGeomColumnType = MSSQLCOLTYPE_GEOGRAPHY;
pszGeomColumn = CPLStrdup(poStmt->GetColName(iColumn));
break;
}
else if ( EQUAL(poStmt->GetColTypeName( iColumn ), "udt") )
{
SQLCHAR szUDTTypeName[256];
SQLSMALLINT nUDTTypeNameLength = 0;
SQLColAttribute(poStmt->GetStatement(), (SQLSMALLINT)(iColumn + 1), SQL_CA_SS_UDT_TYPE_NAME,
szUDTTypeName, sizeof(szUDTTypeName),
&nUDTTypeNameLength, nullptr);
// For some reason on unixODBC, a UCS2 string is returned
if ( EQUAL((char*)szUDTTypeName, "geometry") ||
(nUDTTypeNameLength == 16 &&
memcmp(szUDTTypeName, "g\0e\0o\0m\0e\0t\0r\0y", 16) == 0) )
{
nGeomColumnType = MSSQLCOLTYPE_GEOMETRY;
pszGeomColumn = CPLStrdup(poStmt->GetColName(iColumn));
}
else if ( EQUAL((char*)szUDTTypeName, "geography") ||
(nUDTTypeNameLength == 18 &&
memcmp(szUDTTypeName, "g\0e\0o\0g\0r\0a\0p\0h\0y", 18) == 0) )
{
nGeomColumnType = MSSQLCOLTYPE_GEOGRAPHY;
pszGeomColumn = CPLStrdup(poStmt->GetColName(iColumn));
}
break;
}
}
if (pszGeomColumn == nullptr && iImageCol >= 0)
{
/* set the image col as geometry column as the last resort */
nGeomColumnType = MSSQLCOLTYPE_BINARY;
pszGeomColumn = CPLStrdup(poStmt->GetColName(iImageCol));
}
BuildFeatureDefn( "SELECT", poStmt );
if ( GetSpatialRef() && poFeatureDefn->GetGeomFieldCount() == 1)
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef( poSRS );
}
CPLErr OGRPGeoTableLayer::Initialize( const char *pszTableName,
const char *pszGeomCol,
int nShapeType,
double dfExtentLeft,
double dfExtentRight,
double dfExtentBottom,
double dfExtentTop,
int nSRID,
int bHasZ )
{
CPLODBCSession *poSession = poDS->GetSession();
SetDescription( pszTableName );
CPLFree( pszGeomColumn );
if( pszGeomCol == NULL )
pszGeomColumn = NULL;
else
pszGeomColumn = CPLStrdup( pszGeomCol );
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
sExtent.MinX = dfExtentLeft;
sExtent.MaxX = dfExtentRight;
sExtent.MinY = dfExtentBottom;
sExtent.MaxY = dfExtentTop;
LookupSRID( nSRID );
/* -------------------------------------------------------------------- */
/* Setup geometry type. */
/* -------------------------------------------------------------------- */
OGRwkbGeometryType eOGRType;
switch( nShapeType )
{
case ESRI_LAYERGEOMTYPE_NULL:
eOGRType = wkbNone;
break;
case ESRI_LAYERGEOMTYPE_POINT:
eOGRType = wkbPoint;
break;
case ESRI_LAYERGEOMTYPE_MULTIPOINT:
eOGRType = wkbMultiPoint;
break;
case ESRI_LAYERGEOMTYPE_POLYLINE:
eOGRType = wkbLineString;
break;
case ESRI_LAYERGEOMTYPE_POLYGON:
case ESRI_LAYERGEOMTYPE_MULTIPATCH:
eOGRType = wkbPolygon;
break;
default:
CPLDebug("PGeo", "Unexpected value for shape type : %d", nShapeType);
eOGRType = wkbUnknown;
break;
}
if( eOGRType != wkbUnknown && eOGRType != wkbNone && bHasZ )
eOGRType = wkbSetZ(eOGRType);
/* -------------------------------------------------------------------- */
/* Do we have a simple primary key? */
/* -------------------------------------------------------------------- */
CPLODBCStatement oGetKey( poSession );
if( oGetKey.GetPrimaryKeys( pszTableName ) && oGetKey.Fetch() )
{
pszFIDColumn = CPLStrdup(oGetKey.GetColData( 3 ));
if( oGetKey.Fetch() ) // more than one field in key!
{
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
CPLDebug( "PGeo", "%s: Compound primary key, ignoring.",
pszTableName );
}
else
CPLDebug( "PGeo",
"%s: Got primary key %s.",
pszTableName, pszFIDColumn );
}
else
CPLDebug( "PGeo", "%s: no primary key", pszTableName );
/* -------------------------------------------------------------------- */
/* Get the column definitions for this table. */
/* -------------------------------------------------------------------- */
CPLODBCStatement oGetCol( poSession );
CPLErr eErr;
if( !oGetCol.GetColumns( pszTableName ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"GetColumns() failed on %s.\n%s",
pszTableName, poSession->GetLastError() );
return CE_Failure;
}
eErr = BuildFeatureDefn( pszTableName, &oGetCol );
if( eErr != CE_None )
return eErr;
if( poFeatureDefn->GetFieldCount() == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"No column definitions found for table '%s', layer not usable.",
pszTableName );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Set geometry type. */
/* */
/* NOTE: per reports from Craig Miller, it seems we cannot really */
/* trust the ShapeType value. At the very least "line" tables */
/* sometimes have multilinestrings. So for now we just always */
/* return wkbUnknown. */
/* */
/* TODO - mloskot: Similar issue has been reported in Ticket #1484 */
/* -------------------------------------------------------------------- */
#ifdef notdef
poFeatureDefn->SetGeomType( eOGRType );
#endif
return CE_None;
}
OGRSQLiteSelectLayer::OGRSQLiteSelectLayer( OGRSQLiteDataSource *poDSIn,
CPLString osSQLIn,
sqlite3_stmt *hStmtIn,
int bUseStatementForGetNextFeature,
int bEmptyLayer )
{
poDS = poDSIn;
iNextShapeId = 0;
poFeatureDefn = NULL;
bAllowResetReadingEvenIfIndexAtZero = FALSE;
std::set<CPLString> aosEmpty;
BuildFeatureDefn( "SELECT", hStmtIn, aosEmpty );
if( bUseStatementForGetNextFeature )
{
hStmt = hStmtIn;
bDoStep = FALSE;
// Try to extract SRS from first geometry
if( !bEmptyLayer && osGeomColumn.size() != 0 )
{
int nRawColumns = sqlite3_column_count( hStmt );
for( int iCol = 0; iCol < nRawColumns; iCol++ )
{
int nBytes;
if( sqlite3_column_type( hStmt, iCol ) == SQLITE_BLOB &&
strcmp(OGRSQLiteParamsUnquote(sqlite3_column_name( hStmt, iCol )).c_str(), osGeomColumn.c_str()) == 0 &&
(nBytes = sqlite3_column_bytes( hStmt, iCol )) > 39 )
{
const GByte* pabyBlob = (const GByte*)sqlite3_column_blob( hStmt, iCol );
int eByteOrder = pabyBlob[1];
if( pabyBlob[0] == 0x00 &&
(eByteOrder == wkbNDR || eByteOrder == wkbXDR) &&
pabyBlob[38] == 0x7C )
{
memcpy(&nSRSId, pabyBlob + 2, 4);
#ifdef CPL_LSB
if( eByteOrder != wkbNDR)
CPL_SWAP32PTR(&nSRSId);
#else
if( eByteOrder == wkbNDR)
CPL_SWAP32PTR(&nSRSId);
#endif
CPLPushErrorHandler(CPLQuietErrorHandler);
poSRS = poDS->FetchSRS( nSRSId );
CPLPopErrorHandler();
if( poSRS != NULL )
poSRS->Reference();
else
CPLErrorReset();
}
#ifdef SQLITE_HAS_COLUMN_METADATA
else
{
const char* pszTableName = sqlite3_column_table_name( hStmt, iCol );
if( pszTableName != NULL )
{
OGRLayer* poLayer = poDS->GetLayerByName(pszTableName);
if( poLayer != NULL )
{
poSRS = poLayer->GetSpatialRef();
if( poSRS != NULL )
poSRS->Reference();
}
}
}
#endif
break;
}
}
}
}
else
sqlite3_finalize( hStmtIn );
osSQLBase = osSQLIn;
osSQLCurrent = osSQLIn;
this->bEmptyLayer = bEmptyLayer;
bSpatialFilterInSQL = TRUE;
}
CPLErr OGRMSSQLSpatialTableLayer::Initialize( const char *pszSchema,
const char *pszLayerName,
const char *pszGeomCol,
int nCoordDimension,
int nSRId,
OGRwkbGeometryType eType )
{
CPLODBCSession *poSession = poDS->GetSession();
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
/* -------------------------------------------------------------------- */
/* Parse out schema name if present in layer. We assume a */
/* schema is provided if there is a dot in the name, and that */
/* it is in the form <schema>.<tablename> */
/* -------------------------------------------------------------------- */
const char *pszDot = strstr(pszLayerName,".");
if( pszDot != NULL )
{
pszTableName = CPLStrdup(pszDot + 1);
pszSchemaName = CPLStrdup(pszLayerName);
pszSchemaName[pszDot - pszLayerName] = '\0';
}
else
{
pszTableName = CPLStrdup(pszLayerName);
pszSchemaName = CPLStrdup(pszSchema);
}
/* -------------------------------------------------------------------- */
/* Do we have a simple primary key? */
/* -------------------------------------------------------------------- */
CPLODBCStatement oGetKey( poSession );
if( oGetKey.GetPrimaryKeys( pszTableName, poDS->GetCatalog(), pszSchemaName )
&& oGetKey.Fetch() )
{
pszFIDColumn = CPLStrdup(oGetKey.GetColData( 3 ));
if( oGetKey.Fetch() ) // more than one field in key!
{
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
CPLDebug( "OGR_MSSQLSpatial", "Table %s has multiple primary key fields, "
"ignoring them all.", pszTableName );
}
}
/* -------------------------------------------------------------------- */
/* Have we been provided a geometry column? */
/* -------------------------------------------------------------------- */
CPLFree( pszGeomColumn );
if( pszGeomCol == NULL )
pszGeomColumn = NULL;
else
pszGeomColumn = CPLStrdup( pszGeomCol );
/* -------------------------------------------------------------------- */
/* Get the column definitions for this table. */
/* -------------------------------------------------------------------- */
CPLODBCStatement oGetCol( poSession );
CPLErr eErr;
if( !oGetCol.GetColumns( pszTableName, poDS->GetCatalog(), pszSchemaName ) )
return CE_Failure;
eErr = BuildFeatureDefn( pszLayerName, &oGetCol );
if( eErr != CE_None )
return eErr;
poFeatureDefn->SetGeomType(eType);
if( poFeatureDefn->GetFieldCount() == 0 &&
pszFIDColumn == NULL && pszGeomColumn == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"No column definitions found for table '%s', layer not usable.",
pszLayerName );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* If we got a geometry column, does it exist? Is it binary? */
/* -------------------------------------------------------------------- */
if( pszGeomColumn != NULL )
{
int iColumn = oGetCol.GetColId( pszGeomColumn );
if( iColumn < 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Column %s requested for geometry, but it does not exist.",
pszGeomColumn );
CPLFree( pszGeomColumn );
pszGeomColumn = NULL;
}
else
{
if ( nGeomColumnType < 0 )
{
/* last attempt to identify the geometry column type */
if ( EQUAL(oGetCol.GetColTypeName( iColumn ), "geometry") )
nGeomColumnType = MSSQLCOLTYPE_GEOMETRY;
else if ( EQUAL(oGetCol.GetColTypeName( iColumn ), "geography") )
nGeomColumnType = MSSQLCOLTYPE_GEOGRAPHY;
else if ( EQUAL(oGetCol.GetColTypeName( iColumn ), "varchar") )
nGeomColumnType = MSSQLCOLTYPE_TEXT;
else if ( EQUAL(oGetCol.GetColTypeName( iColumn ), "nvarchar") )
nGeomColumnType = MSSQLCOLTYPE_TEXT;
else if ( EQUAL(oGetCol.GetColTypeName( iColumn ), "text") )
nGeomColumnType = MSSQLCOLTYPE_TEXT;
else if ( EQUAL(oGetCol.GetColTypeName( iColumn ), "ntext") )
nGeomColumnType = MSSQLCOLTYPE_TEXT;
else if ( EQUAL(oGetCol.GetColTypeName( iColumn ), "image") )
nGeomColumnType = MSSQLCOLTYPE_BINARY;
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Column type %s is not supported for geometry column.",
oGetCol.GetColTypeName( iColumn ) );
CPLFree( pszGeomColumn );
pszGeomColumn = NULL;
}
}
}
}
/* -------------------------------------------------------------------- */
/* Try to find out the spatial reference */
/* -------------------------------------------------------------------- */
nSRSId = nSRId;
if (nSRSId < 0)
nSRSId = FetchSRSId();
GetSpatialRef();
return CE_None;
}
OGRSQLiteSelectLayer::OGRSQLiteSelectLayer( OGRSQLiteDataSource *poDSIn,
CPLString osSQLIn,
sqlite3_stmt *hStmtIn,
int bUseStatementForGetNextFeature,
int bEmptyLayer,
int bAllowMultipleGeomFieldsIn )
{
poBehaviour = new OGRSQLiteSelectLayerCommonBehaviour(poDSIn, this, osSQLIn, bEmptyLayer);
poDS = poDSIn;
this->bAllowMultipleGeomFields = bAllowMultipleGeomFieldsIn;
std::set<CPLString> aosEmpty;
BuildFeatureDefn( "SELECT", hStmtIn, aosEmpty, aosEmpty );
SetDescription( "SELECT" );
if( bUseStatementForGetNextFeature )
{
hStmt = hStmtIn;
bDoStep = FALSE;
// Try to extract SRS from first geometry
for( int iField = 0;
!bEmptyLayer && iField < poFeatureDefn->GetGeomFieldCount();
iField ++)
{
OGRSQLiteGeomFieldDefn* poGeomFieldDefn =
poFeatureDefn->myGetGeomFieldDefn(iField);
if( wkbFlatten(poGeomFieldDefn->GetType()) != wkbUnknown )
continue;
int nBytes;
if( sqlite3_column_type( hStmt, poGeomFieldDefn->iCol ) == SQLITE_BLOB &&
(nBytes = sqlite3_column_bytes( hStmt, poGeomFieldDefn->iCol )) > 39 )
{
const GByte* pabyBlob = (const GByte*)sqlite3_column_blob( hStmt, poGeomFieldDefn->iCol );
int eByteOrder = pabyBlob[1];
if( pabyBlob[0] == 0x00 &&
(eByteOrder == wkbNDR || eByteOrder == wkbXDR) &&
pabyBlob[38] == 0x7C )
{
int nSRSId;
memcpy(&nSRSId, pabyBlob + 2, 4);
#ifdef CPL_LSB
if( eByteOrder != wkbNDR)
CPL_SWAP32PTR(&nSRSId);
#else
if( eByteOrder == wkbNDR)
CPL_SWAP32PTR(&nSRSId);
#endif
CPLPushErrorHandler(CPLQuietErrorHandler);
OGRSpatialReference* poSRS = poDS->FetchSRS( nSRSId );
CPLPopErrorHandler();
if( poSRS != NULL )
{
poGeomFieldDefn->nSRSId = nSRSId;
poGeomFieldDefn->SetSpatialRef(poSRS);
}
else
CPLErrorReset();
}
#ifdef SQLITE_HAS_COLUMN_METADATA
else if( iField == 0 )
{
const char* pszTableName = sqlite3_column_table_name( hStmt, poGeomFieldDefn->iCol );
if( pszTableName != NULL )
{
OGRSQLiteLayer* poLayer = (OGRSQLiteLayer*)
poDS->GetLayerByName(pszTableName);
if( poLayer != NULL && poLayer->GetLayerDefn()->GetGeomFieldCount() > 0)
{
OGRSQLiteGeomFieldDefn* poSrcGFldDefn =
poLayer->myGetLayerDefn()->myGetGeomFieldDefn(0);
poGeomFieldDefn->nSRSId = poSrcGFldDefn->nSRSId;
poGeomFieldDefn->SetSpatialRef(poSrcGFldDefn->GetSpatialRef());
}
}
}
#endif
}
}
}
else
sqlite3_finalize( hStmtIn );
}
CPLErr OGRIDBTableLayer::Initialize( const char *pszTableName,
const char *pszGeomCol,
int bUpdate )
{
bUpdateAccess = bUpdate;
ITConnection *poConn = poDS->GetConnection();
if ( pszFIDColumn )
{
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
}
/* -------------------------------------------------------------------- */
/* Do we have a simple primary key? */
/* -------------------------------------------------------------------- */
if ( pszFIDColumn == NULL )
{
ITCursor oGetKey( *poConn );
CPLString osSql =
" select sc.colname"
" from syscolumns sc, sysindexes si, systables st"
" where st.tabid = si.tabid"
" and st.tabid = sc.tabid"
" and si.idxtype = 'U'"
" and sc.colno = si.part1"
" and si.part2 = 0" // only one-column keys
" and st.tabname='";
osSql += pszTableName;
osSql += "'";
if( oGetKey.Prepare( osSql.c_str() ) &&
oGetKey.Open(ITCursor::ReadOnly) )
{
ITValue * poVal = oGetKey.Fetch();
if ( poVal && poVal->IsNull() == false )
{
pszFIDColumn = CPLStrdup(poVal->Printable());
poVal->Release();
}
if( oGetKey.Fetch() ) // more than one field in key!
{
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
CPLDebug("OGR_IDB", "Table %s has multiple primary key fields,"
" ignoring them all.", pszTableName );
}
}
}
/* -------------------------------------------------------------------- */
/* Have we been provided a geometry column? */
/* -------------------------------------------------------------------- */
CPLFree( pszGeomColumn );
if( pszGeomCol == NULL )
pszGeomColumn = NULL;
else
pszGeomColumn = CPLStrdup( pszGeomCol );
/* -------------------------------------------------------------------- */
/* Get the column definitions for this table. */
/* -------------------------------------------------------------------- */
ITCursor oGetCol( *poConn );
CPLErr eErr;
CPLString sql;
sql.Printf( "select * from %s where 1=0", pszTableName );
if( ! oGetCol.Prepare( sql.c_str() ) ||
! oGetCol.Open(ITCursor::ReadOnly) )
return CE_Failure;
eErr = BuildFeatureDefn( pszTableName, &oGetCol );
if( eErr != CE_None )
return eErr;
if( poFeatureDefn->GetFieldCount() == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"No column definitions found for table '%s', layer not usable.",
pszTableName );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Do we have XMIN, YMIN, XMAX, YMAX extent fields? */
/* -------------------------------------------------------------------- */
if( poFeatureDefn->GetFieldIndex( "XMIN" ) != -1
&& poFeatureDefn->GetFieldIndex( "XMAX" ) != -1
&& poFeatureDefn->GetFieldIndex( "YMIN" ) != -1
&& poFeatureDefn->GetFieldIndex( "YMAX" ) != -1 )
{
bHaveSpatialExtents = TRUE;
CPLDebug( "OGR_IDB", "Table %s has geometry extent fields.",
pszTableName );
}
/* -------------------------------------------------------------------- */
/* If we got a geometry column, does it exist? Is it binary? */
/* -------------------------------------------------------------------- */
if( pszGeomColumn != NULL )
{
int iColumn = oGetCol.RowType()->ColumnId( pszGeomColumn );
if( iColumn < 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Column %s requested for geometry, but it does not exist.",
pszGeomColumn );
CPLFree( pszGeomColumn );
pszGeomColumn = NULL;
}
bGeomColumnWKB = TRUE;
/*else
{
if( ITCursor::GetTypeMapping(
oGetCol.GetColType( iColumn )) == SQL_C_BINARY )
bGeomColumnWKB = TRUE;
}*/
}
return CE_None;
}
CPLErr OGRODBCTableLayer::Initialize( const char *pszLayerName,
const char *pszGeomCol )
{
CPLODBCSession *poSession = poDS->GetSession();
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
/* -------------------------------------------------------------------- */
/* Parse out schema name if present in layer. We assume a */
/* schema is provided if there is a dot in the name, and that */
/* it is in the form <schema>.<tablename> */
/* -------------------------------------------------------------------- */
const char *pszDot = strstr(pszLayerName,".");
if( pszDot != NULL )
{
pszTableName = CPLStrdup(pszDot + 1);
pszSchemaName = CPLStrdup(pszLayerName);
pszSchemaName[pszDot - pszLayerName] = '\0';
}
else
{
pszTableName = CPLStrdup(pszLayerName);
}
/* -------------------------------------------------------------------- */
/* Do we have a simple primary key? */
/* -------------------------------------------------------------------- */
CPLODBCStatement oGetKey( poSession );
if( oGetKey.GetPrimaryKeys( pszTableName, NULL, pszSchemaName )
&& oGetKey.Fetch() )
{
pszFIDColumn = CPLStrdup(oGetKey.GetColData( 3 ));
if( oGetKey.Fetch() ) // more than one field in key!
{
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
CPLDebug( "OGR_ODBC", "Table %s has multiple primary key fields, "
"ignoring them all.", pszTableName );
}
}
/* -------------------------------------------------------------------- */
/* Have we been provided a geometry column? */
/* -------------------------------------------------------------------- */
CPLFree( pszGeomColumn );
if( pszGeomCol == NULL )
pszGeomColumn = NULL;
else
pszGeomColumn = CPLStrdup( pszGeomCol );
/* -------------------------------------------------------------------- */
/* Get the column definitions for this table. */
/* -------------------------------------------------------------------- */
CPLODBCStatement oGetCol( poSession );
CPLErr eErr;
if( !oGetCol.GetColumns( pszTableName, NULL, pszSchemaName ) )
return CE_Failure;
eErr = BuildFeatureDefn( pszLayerName, &oGetCol );
if( eErr != CE_None )
return eErr;
if( poFeatureDefn->GetFieldCount() == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"No column definitions found for table '%s', layer not usable.",
pszLayerName );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Do we have XMIN, YMIN, XMAX, YMAX extent fields? */
/* -------------------------------------------------------------------- */
if( poFeatureDefn->GetFieldIndex( "XMIN" ) != -1
&& poFeatureDefn->GetFieldIndex( "XMAX" ) != -1
&& poFeatureDefn->GetFieldIndex( "YMIN" ) != -1
&& poFeatureDefn->GetFieldIndex( "YMAX" ) != -1 )
{
bHaveSpatialExtents = TRUE;
CPLDebug( "OGR_ODBC", "Table %s has geometry extent fields.",
pszLayerName );
}
/* -------------------------------------------------------------------- */
/* If we got a geometry column, does it exist? Is it binary? */
/* -------------------------------------------------------------------- */
if( pszGeomColumn != NULL )
{
int iColumn = oGetCol.GetColId( pszGeomColumn );
if( iColumn < 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Column %s requested for geometry, but it does not exist.",
pszGeomColumn );
CPLFree( pszGeomColumn );
pszGeomColumn = NULL;
}
else
{
if( CPLODBCStatement::GetTypeMapping(
oGetCol.GetColType( iColumn )) == SQL_C_BINARY )
bGeomColumnWKB = TRUE;
}
}
return CE_None;
}
CPLErr OGRMDBLayer::Initialize( const char *pszTableName,
const char *pszGeomCol,
int nShapeType,
double dfExtentLeft,
double dfExtentRight,
double dfExtentBottom,
double dfExtentTop,
int nSRID,
int bHasZ )
{
CPLFree( pszGeomColumn );
if( pszGeomCol == NULL )
pszGeomColumn = NULL;
else
{
pszGeomColumn = CPLStrdup( pszGeomCol );
iGeomColumn = poMDBTable->GetColumnIndex( pszGeomColumn );
}
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
bHasExtent = TRUE;
sExtent.MinX = dfExtentLeft;
sExtent.MaxX = dfExtentRight;
sExtent.MinY = dfExtentBottom;
sExtent.MaxY = dfExtentTop;
LookupSRID( nSRID );
eGeometryType = MDB_GEOM_PGEO;
CPLErr eErr;
eErr = BuildFeatureDefn();
if( eErr != CE_None )
return eErr;
/* -------------------------------------------------------------------- */
/* Setup geometry type. */
/* -------------------------------------------------------------------- */
OGRwkbGeometryType eOGRType;
switch( nShapeType )
{
case ESRI_LAYERGEOMTYPE_NULL:
eOGRType = wkbNone;
break;
case ESRI_LAYERGEOMTYPE_POINT:
eOGRType = wkbPoint;
break;
case ESRI_LAYERGEOMTYPE_MULTIPOINT:
eOGRType = wkbMultiPoint;
break;
case ESRI_LAYERGEOMTYPE_POLYLINE:
eOGRType = wkbLineString;
break;
case ESRI_LAYERGEOMTYPE_POLYGON:
case ESRI_LAYERGEOMTYPE_MULTIPATCH:
eOGRType = wkbPolygon;
break;
default:
CPLDebug("MDB", "Unexpected value for shape type : %d", nShapeType);
eOGRType = wkbUnknown;
break;
}
if( eOGRType != wkbUnknown && eOGRType != wkbNone && bHasZ )
eOGRType = (OGRwkbGeometryType)(((int) eOGRType) | wkb25DBit);
poFeatureDefn->SetGeomType(eOGRType);
return CE_None;
}
CPLErr OGRSQLiteViewLayer::EstablishFeatureDefn()
{
int rc;
sqlite3 *hDB = poDS->GetDB();
sqlite3_stmt *hColStmt = NULL;
const char *pszSQL;
OGRSQLiteLayer* poUnderlyingLayer = (OGRSQLiteLayer*) poDS->GetLayerByName(osUnderlyingTableName);
if (poUnderlyingLayer == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot find underlying layer %s for view %s",
osUnderlyingTableName.c_str(), pszViewName);
return CE_Failure;
}
if ( !poUnderlyingLayer->IsTableLayer() )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Underlying layer %s for view %s is not a regular table",
osUnderlyingTableName.c_str(), pszViewName);
return CE_Failure;
}
const char* pszRealUnderlyingGeometryColumn = poUnderlyingLayer->GetGeometryColumn();
if ( pszRealUnderlyingGeometryColumn == NULL ||
!EQUAL(pszRealUnderlyingGeometryColumn, osUnderlyingGeometryColumn.c_str()) )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Underlying layer %s for view %s has not expected geometry column name (%s instead of %s)",
osUnderlyingTableName.c_str(), pszViewName,
pszRealUnderlyingGeometryColumn ? pszRealUnderlyingGeometryColumn : "(null)",
osUnderlyingGeometryColumn.c_str());
return CE_Failure;
}
poSRS = poUnderlyingLayer->GetSpatialRef();
if (poSRS)
poSRS->Reference();
this->bHasSpatialIndex = poUnderlyingLayer->HasSpatialIndex();
/* -------------------------------------------------------------------- */
/* Get the column definitions for this table. */
/* -------------------------------------------------------------------- */
hColStmt = NULL;
pszSQL = CPLSPrintf( "SELECT %s, * FROM '%s' LIMIT 1", pszFIDColumn, pszEscapedTableName );
rc = sqlite3_prepare( hDB, pszSQL, strlen(pszSQL), &hColStmt, NULL );
if( rc != SQLITE_OK )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to query table %s for column definitions : %s.",
pszViewName, sqlite3_errmsg(hDB) );
return CE_Failure;
}
rc = sqlite3_step( hColStmt );
if ( rc != SQLITE_DONE && rc != SQLITE_ROW )
{
CPLError( CE_Failure, CPLE_AppDefined,
"In Initialize(): sqlite3_step(%s):\n %s",
pszSQL, sqlite3_errmsg(hDB) );
sqlite3_finalize( hColStmt );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Collect the rest of the fields. */
/* -------------------------------------------------------------------- */
BuildFeatureDefn( pszViewName, hColStmt );
sqlite3_finalize( hColStmt );
/* -------------------------------------------------------------------- */
/* Set the geometry type if we know it. */
/* -------------------------------------------------------------------- */
poFeatureDefn->SetGeomType( poUnderlyingLayer->GetGeomType() );
return CE_None;
}
CPLErr OGRWalkTableLayer::Initialize( const char *pszLayerName,
const char *pszGeomCol,
double minE,
double maxE,
double minN,
double maxN,
const char *pszMemo)
{
SetDescription( pszLayerName );
CPLODBCSession *poSession = poDS->GetSession();
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
sExtent.MinX = minE;
sExtent.MaxX = maxE;
sExtent.MinY = minN;
sExtent.MaxY = maxN;
/* -------------------------------------------------------------------- */
/* Look up the Spatial Reference */
/* -------------------------------------------------------------------- */
LookupSpatialRef( pszMemo );
/* -------------------------------------------------------------------- */
/* Generate the Feature Tablename from the Layer Name */
/* which is in the form <layername>Features */
/* -------------------------------------------------------------------- */
char* pszFeatureTableName = (char *) CPLMalloc(strlen(pszLayerName)+10);
sprintf(pszFeatureTableName, "%sFeatures", pszLayerName);
/* -------------------------------------------------------------------- */
/* Do we have a simple primary key? */
/* -------------------------------------------------------------------- */
CPLODBCStatement oGetKey( poSession );
if( oGetKey.GetPrimaryKeys( pszFeatureTableName, NULL, NULL )
&& oGetKey.Fetch() )
{
pszFIDColumn = CPLStrdup(oGetKey.GetColData( 3 ));
if( oGetKey.Fetch() ) // more than one field in key!
{
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
CPLDebug( "Walk", "Table %s has multiple primary key fields, "
"ignoring them all.", pszFeatureTableName );
}
}
/* -------------------------------------------------------------------- */
/* Have we been provided a geometry column? */
/* -------------------------------------------------------------------- */
CPLFree( pszGeomColumn );
if( pszGeomCol == NULL )
pszGeomColumn = NULL;
else
pszGeomColumn = CPLStrdup( pszGeomCol );
/* -------------------------------------------------------------------- */
/* Get the column definitions for this table. */
/* -------------------------------------------------------------------- */
CPLODBCStatement oGetCol( poSession );
CPLErr eErr;
if( !oGetCol.GetColumns( pszFeatureTableName, NULL, NULL ) )
{
CPLFree( pszFeatureTableName );
return CE_Failure;
}
eErr = BuildFeatureDefn( pszLayerName, &oGetCol );
if( eErr != CE_None )
{
CPLFree( pszFeatureTableName );
return eErr;
}
if( poFeatureDefn->GetFieldCount() == 0 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"No column definitions found for table '%s', layer not usable.",
pszLayerName );
CPLFree( pszFeatureTableName );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* If we got a geometry column, does it exist? Is it binary? */
/* -------------------------------------------------------------------- */
if( pszGeomColumn != NULL )
{
int iColumn = oGetCol.GetColId( pszGeomColumn );
if( iColumn < 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Column %s requested for geometry, but it does not exist.",
pszGeomColumn );
CPLFree( pszGeomColumn );
pszGeomColumn = NULL;
}
else
{
if( CPLODBCStatement::GetTypeMapping(
oGetCol.GetColType( iColumn )) == SQL_C_BINARY )
bGeomColumnWKB = TRUE;
}
}
CPLFree( pszFeatureTableName );
return CE_None;
}
CPLErr OGRGeomediaTableLayer::Initialize( const char *pszTableName,
const char *pszGeomCol,
OGRSpatialReference* poSRSIn )
{
CPLODBCSession *poSession = poDS->GetSession();
CPLFree( pszGeomColumn );
if( pszGeomCol == NULL )
pszGeomColumn = NULL;
else
pszGeomColumn = CPLStrdup( pszGeomCol );
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
this->poSRS = poSRSIn;
/* -------------------------------------------------------------------- */
/* Do we have a simple primary key? */
/* -------------------------------------------------------------------- */
{
CPLODBCStatement oGetKey( poSession );
if( oGetKey.GetPrimaryKeys( pszTableName ) && oGetKey.Fetch() )
{
pszFIDColumn = CPLStrdup(oGetKey.GetColData( 3 ));
if( oGetKey.Fetch() ) // more than one field in key!
{
CPLFree( pszFIDColumn );
pszFIDColumn = NULL;
CPLDebug( "Geomedia", "%s: Compound primary key, ignoring.",
pszTableName );
}
else
CPLDebug( "Geomedia",
"%s: Got primary key %s.",
pszTableName, pszFIDColumn );
}
else
CPLDebug( "Geomedia", "%s: no primary key", pszTableName );
}
/* -------------------------------------------------------------------- */
/* Get the column definitions for this table. */
/* -------------------------------------------------------------------- */
CPLODBCStatement oGetCol( poSession );
CPLErr eErr;
if( !oGetCol.GetColumns( pszTableName ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"GetColumns() failed on %s.\n%s",
pszTableName, poSession->GetLastError() );
return CE_Failure;
}
eErr = BuildFeatureDefn( pszTableName, &oGetCol );
if( eErr != CE_None )
return eErr;
if( poFeatureDefn->GetFieldCount() == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"No column definitions found for table '%s', layer not usable.",
pszTableName );
return CE_Failure;
}
return CE_None;
}
CPLErr OGRSQLiteViewLayer::EstablishFeatureDefn()
{
int rc;
sqlite3 *hDB = poDS->GetDB();
sqlite3_stmt *hColStmt = NULL;
const char *pszSQL;
OGRSQLiteLayer* poUnderlyingLayer = GetUnderlyingLayer();
if (poUnderlyingLayer == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot find underlying layer %s for view %s",
osUnderlyingTableName.c_str(), pszViewName);
return CE_Failure;
}
if ( !poUnderlyingLayer->IsTableLayer() )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Underlying layer %s for view %s is not a regular table",
osUnderlyingTableName.c_str(), pszViewName);
return CE_Failure;
}
int nUnderlyingLayerGeomFieldIndex =
poUnderlyingLayer->GetLayerDefn()->GetGeomFieldIndex(osUnderlyingGeometryColumn);
if ( nUnderlyingLayerGeomFieldIndex < 0 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Underlying layer %s for view %s has not expected geometry column name %s",
osUnderlyingTableName.c_str(), pszViewName,
osUnderlyingGeometryColumn.c_str());
return CE_Failure;
}
this->bHasSpatialIndex = poUnderlyingLayer->HasSpatialIndex(nUnderlyingLayerGeomFieldIndex);
/* -------------------------------------------------------------------- */
/* Get the column definitions for this table. */
/* -------------------------------------------------------------------- */
hColStmt = NULL;
pszSQL = CPLSPrintf( "SELECT \"%s\", * FROM '%s' LIMIT 1",
OGRSQLiteEscapeName(pszFIDColumn).c_str(),
pszEscapedTableName );
rc = sqlite3_prepare( hDB, pszSQL, strlen(pszSQL), &hColStmt, NULL );
if( rc != SQLITE_OK )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to query table %s for column definitions : %s.",
pszViewName, sqlite3_errmsg(hDB) );
return CE_Failure;
}
rc = sqlite3_step( hColStmt );
if ( rc != SQLITE_DONE && rc != SQLITE_ROW )
{
CPLError( CE_Failure, CPLE_AppDefined,
"In Initialize(): sqlite3_step(%s):\n %s",
pszSQL, sqlite3_errmsg(hDB) );
sqlite3_finalize( hColStmt );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Collect the rest of the fields. */
/* -------------------------------------------------------------------- */
std::set<CPLString> aosGeomCols;
std::set<CPLString> aosIgnoredCols;
aosGeomCols.insert(osGeomColumn);
BuildFeatureDefn( pszViewName, hColStmt, aosGeomCols, aosIgnoredCols );
sqlite3_finalize( hColStmt );
/* -------------------------------------------------------------------- */
/* Set the properties of the geometry column. */
/* -------------------------------------------------------------------- */
if( poFeatureDefn->GetGeomFieldCount() != 0 )
{
OGRSQLiteGeomFieldDefn* poSrcGeomFieldDefn =
poUnderlyingLayer->myGetLayerDefn()->myGetGeomFieldDefn(nUnderlyingLayerGeomFieldIndex);
OGRSQLiteGeomFieldDefn* poGeomFieldDefn =
poFeatureDefn->myGetGeomFieldDefn(0);
poGeomFieldDefn->SetType(poSrcGeomFieldDefn->GetType());
poGeomFieldDefn->SetSpatialRef(poSrcGeomFieldDefn->GetSpatialRef());
poGeomFieldDefn->nSRSId = poSrcGeomFieldDefn->nSRSId;
if( eGeomFormat != OSGF_None )
poGeomFieldDefn->eGeomFormat = eGeomFormat;
}
return CE_None;
}
