OGRErr OGRMSSQLSpatialDataSource::InitializeMetadataTables()
{
CPLODBCStatement oStmt( &oSession );
oStmt.Append( "IF NOT EXISTS (SELECT * FROM sys.objects WHERE "
"object_id = OBJECT_ID(N'[dbo].[geometry_columns]') AND type in (N'U')) "
"CREATE TABLE geometry_columns (f_table_catalog varchar(128) not null, "
"f_table_schema varchar(128) not null, f_table_name varchar(256) not null, "
"f_geometry_column varchar(256) not null, coord_dimension integer not null, "
"srid integer not null, geometry_type varchar(30) not null, "
"CONSTRAINT geometry_columns_pk PRIMARY KEY (f_table_catalog, "
"f_table_schema, f_table_name, f_geometry_column));\n" );
oStmt.Append( "IF NOT EXISTS (SELECT * FROM sys.objects "
"WHERE object_id = OBJECT_ID(N'[dbo].[spatial_ref_sys]') AND type in (N'U')) "
"CREATE TABLE spatial_ref_sys (srid integer not null "
"PRIMARY KEY, auth_name varchar(256), auth_srid integer, srtext varchar(2048), proj4text varchar(2048))" );
oSession.BeginTransaction();
if( !oStmt.ExecuteSQL() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error initializing the metadata tables : %s", GetSession()->GetLastError() );
return OGRERR_FAILURE;
}
oSession.CommitTransaction();
return OGRERR_NONE;
}
OGRErr OGRIngresTableLayer::DeleteFeature( GIntBig nFID )
{
CPLString osCommand;
/* -------------------------------------------------------------------- */
/* We can only delete features if we have a well defined FID */
/* column to target. */
/* -------------------------------------------------------------------- */
if( osFIDColumn.empty() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"DeleteFeature(%ld) failed. Unable to delete features "
"in tables without\n a recognised FID column.",
nFID );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Form the statement to drop the record. */
/* -------------------------------------------------------------------- */
osCommand.Printf( "DELETE FROM %s WHERE %s = %ld",
poFeatureDefn->GetName(), osFIDColumn.c_str(), nFID );
/* -------------------------------------------------------------------- */
/* Execute the delete. */
/* -------------------------------------------------------------------- */
poDS->EstablishActiveLayer( NULL );
OGRIngresStatement oStmt( poDS->GetConn() );
if( !oStmt.ExecuteSQL( osCommand ) )
return OGRERR_FAILURE;
else
return OGRERR_NONE;
}
OGRSpatialReference *OGRMSSQLSpatialDataSource::FetchSRS( int nId )
{
if( nId <= 0 )
return NULL;
/* -------------------------------------------------------------------- */
/* First, we look through our SRID cache, is it there? */
/* -------------------------------------------------------------------- */
int i;
for( i = 0; i < nKnownSRID; i++ )
{
if( panSRID[i] == nId )
return papoSRS[i];
}
/* -------------------------------------------------------------------- */
/* Try looking up in spatial_ref_sys table */
/* -------------------------------------------------------------------- */
OGRSpatialReference *poSRS = NULL;
CPLODBCStatement oStmt( GetSession() );
oStmt.Appendf( "SELECT srtext FROM spatial_ref_sys WHERE srid = %d", nId );
if( !oStmt.ExecuteSQL() || !oStmt.Fetch() )
{
return NULL;
}
if ( oStmt.GetColData( 0 ) )
{
poSRS = new OGRSpatialReference();
char* pszWKT = (char*)oStmt.GetColData( 0 );
if( poSRS->importFromWkt( &pszWKT ) != OGRERR_NONE )
{
delete poSRS;
poSRS = NULL;
}
/* -------------------------------------------------------------------- */
/* Add to the cache. */
/* -------------------------------------------------------------------- */
panSRID = (int *) CPLRealloc(panSRID,sizeof(int) * (nKnownSRID+1) );
papoSRS = (OGRSpatialReference **)
CPLRealloc(papoSRS, sizeof(void*) * (nKnownSRID + 1) );
panSRID[nKnownSRID] = nId;
papoSRS[nKnownSRID] = poSRS;
nKnownSRID++;
}
return poSRS;
}
int OGRMSSQLSpatialDataSource::DeleteLayer( int iLayer )
{
if( iLayer < 0 || iLayer >= nLayers )
return OGRERR_FAILURE;
/* -------------------------------------------------------------------- */
/* Blow away our OGR structures related to the layer. This is */
/* pretty dangerous if anything has a reference to this layer! */
/* -------------------------------------------------------------------- */
const char* pszLayerName = papoLayers[iLayer]->GetTableName();
const char* pszSchemaName = papoLayers[iLayer]->GetSchemaName();
CPLODBCStatement oStmt( &oSession );
if (bUseGeometryColumns)
oStmt.Appendf( "DELETE FROM geometry_columns WHERE f_table_schema = '%s' AND f_table_name = '%s'\n",
pszSchemaName, pszLayerName );
oStmt.Appendf("DROP TABLE [%s].[%s]", pszSchemaName, pszLayerName );
CPLDebug( "MSSQLSpatial", "DeleteLayer(%s)", pszLayerName );
delete papoLayers[iLayer];
memmove( papoLayers + iLayer, papoLayers + iLayer + 1,
sizeof(void *) * (nLayers - iLayer - 1) );
nLayers--;
if ( strlen(pszLayerName) == 0 )
return OGRERR_NONE;
/* -------------------------------------------------------------------- */
/* Remove from the database. */
/* -------------------------------------------------------------------- */
oSession.BeginTransaction();
if( !oStmt.ExecuteSQL() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error deleting layer: %s", GetSession()->GetLastError() );
return OGRERR_FAILURE;
}
oSession.CommitTransaction();
return OGRERR_NONE;
}
CPLString OGRGeomediaDataSource::GetTableNameFromType(const char* pszTableType)
{
CPLODBCStatement oStmt( &oSession );
oStmt.Appendf( "SELECT TableName FROM GAliasTable WHERE TableType = '%s'", pszTableType );
if( !oStmt.ExecuteSQL() )
{
CPLDebug( "GEOMEDIA",
"SELECT for %s on GAliasTable fails, perhaps not a geomedia geodatabase?\n%s",
pszTableType,
oSession.GetLastError() );
return "";
}
while( oStmt.Fetch() )
{
return oStmt.GetColData(0);
}
return "";
}
GIntBig OGRPGeoTableLayer::GetFeatureCount( int bForce )
{
if( m_poFilterGeom != NULL )
return OGRPGeoLayer::GetFeatureCount( bForce );
CPLODBCStatement oStmt( poDS->GetSession() );
oStmt.Append( "SELECT COUNT(*) FROM " );
oStmt.Append( poFeatureDefn->GetName() );
if( pszQuery != NULL )
oStmt.Appendf( " WHERE %s", pszQuery );
if( !oStmt.ExecuteSQL() || !oStmt.Fetch() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"GetFeatureCount() failed on query %s.\n%s",
oStmt.GetCommand(), poDS->GetSession()->GetLastError() );
return OGRPGeoLayer::GetFeatureCount(bForce);
}
return CPLAtoGIntBig(oStmt.GetColData(0));
}
int OGRIngresDataSource::DeleteLayer( int iLayer)
{
if( iLayer < 0 || iLayer >= nLayers )
return OGRERR_FAILURE;
/* -------------------------------------------------------------------- */
/* Blow away our OGR structures related to the layer. This is */
/* pretty dangerous if anything has a reference to this layer! */
/* -------------------------------------------------------------------- */
CPLString osLayerName = papoLayers[iLayer]->GetLayerDefn()->GetName();
CPLDebug( "INGRES", "DeleteLayer(%s)", osLayerName.c_str() );
delete papoLayers[iLayer];
memmove( papoLayers + iLayer, papoLayers + iLayer + 1,
sizeof(void *) * (nLayers - iLayer - 1) );
nLayers--;
/* -------------------------------------------------------------------- */
/* Remove from the database. */
/* -------------------------------------------------------------------- */
char szCommand[1024];
OGRIngresStatement oStmt( hConn );
sprintf( szCommand,
"DROP TABLE %s ",
osLayerName.c_str() );
if( oStmt.ExecuteSQL( szCommand ) )
{
CPLDebug("INGRES","Dropped table %s.", osLayerName.c_str());
return OGRERR_NONE;
}
else
return OGRERR_FAILURE;
}
int OGRIngresDataSource::Open( const char *pszFullName,
char **papszOptions, int bUpdate )
{
CPLAssert( nLayers == 0 );
#define MAX_TARGET_STRING_LENGTH 512
char pszDBTarget[MAX_TARGET_STRING_LENGTH];
/* -------------------------------------------------------------------- */
/* Verify we have a dbname, this parameter is required. */
/* -------------------------------------------------------------------- */
const char *pszDBName = CSLFetchNameValue(papszOptions,"dbname");
if( pszDBName == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"No DBNAME item provided in INGRES datasource name." );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Do we have a table list? */
/* -------------------------------------------------------------------- */
char **papszTableNames = NULL;
const char *pszTables = CSLFetchNameValue(papszOptions,"tables");
if( pszTables != NULL )
papszTableNames = CSLTokenizeStringComplex(pszTables,"/",TRUE,FALSE);
/* -------------------------------------------------------------------- */
/* Add support to dynamic vnode if passed */
/* -------------------------------------------------------------------- */
const char *pszHost = CSLFetchNameValue(papszOptions,"host");
if (pszHost)
{
const char *pszInstance = CSLFetchNameValue(papszOptions,"instance");
if (pszInstance == NULL || strlen(pszInstance) != 2)
{
CPLError( CE_Failure, CPLE_OpenFailed,
"instance name must be specified with host." );
return FALSE;
}
/*
** make sure the user name and password are passed too,
** note it could not be zero length.
*/
const char *pszUsername = CSLFetchNameValue(papszOptions,"username");
const char *pszPassword = CSLFetchNameValue(papszOptions,"password");
if (pszUsername == NULL || strlen(pszUsername) == 0)
{
CPLError( CE_Failure, CPLE_OpenFailed,
"user name must be specified in dynamic vnode." );
return FALSE;
}
if (pszPassword == NULL || strlen(pszPassword) == 0)
{
CPLError( CE_Failure, CPLE_OpenFailed,
"password must be specified in dynamic vnode." );
return FALSE;
}
/*
** construct the vnode string, like :
** @host,protocol,port[;attribute=value{;attribute=value}][[user,password]],
** visit for detail
** http://docs.actian.com/ingres/10.0/command-reference-guide/1207-dynamic-vnode-specificationconnect-to-remote-node
*/
sprintf(pszDBTarget, "@%s,%s,%s;%s[%s,%s]::%s ",
pszHost, /* host, compute name or IP address */
"TCP_IP", /* protocal, default with TCP/IP */
pszInstance, /* instance Name */
"" , /* option, Null */
pszUsername, /* user name, could not be empty */
pszPassword, /* pwd */
pszDBName /* database name */
);
CPLDebug("INGRES", pszDBTarget);
}
else
{
/* Remain the database name */
strcpy(pszDBTarget, pszDBName);
}
/* -------------------------------------------------------------------- */
/* Initialize the Ingres API. Should we only do this once per */
/* program run? Really we should also try to terminate the api */
/* on program exit. */
/* -------------------------------------------------------------------- */
IIAPI_INITPARM initParm;
initParm.in_version = IIAPI_VERSION_1;
initParm.in_timeout = -1;
IIapi_initialize( &initParm );
/* -------------------------------------------------------------------- */
/* check effective user and db password */
/* -------------------------------------------------------------------- */
hConn = NULL;
const char *pszEffuser = CSLFetchNameValue(papszOptions,"effuser");
const char *pszDBpwd = CSLFetchNameValue(papszOptions,"dbpwd");
if ( pszEffuser
&& strlen(pszEffuser) > 0
&& pszDBpwd
&& strlen(pszDBpwd) > 0 )
{
if (SetConnParam(&hConn, IIAPI_CP_EFFECTIVE_USER,
(II_PTR)pszEffuser) != IIAPI_ST_SUCCESS
|| SetConnParam(&hConn, IIAPI_CP_DBMS_PASSWORD,
(II_PTR)pszDBpwd) != IIAPI_ST_SUCCESS )
{
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* Try to connect to the database. */
/* -------------------------------------------------------------------- */
IIAPI_CONNPARM connParm;
IIAPI_WAITPARM waitParm = { -1 };
memset( &connParm, 0, sizeof(connParm) );
connParm.co_genParm.gp_callback = NULL;
connParm.co_genParm.gp_closure = NULL;
connParm.co_target = (II_CHAR *) pszDBTarget;
connParm.co_connHandle = hConn;
connParm.co_tranHandle = NULL;
connParm.co_username =
(II_CHAR*) CSLFetchNameValue(papszOptions,"username");
connParm.co_password =
(II_CHAR*)CSLFetchNameValue(papszOptions,"password");
connParm.co_timeout = -1;
if( CSLFetchNameValue(papszOptions,"timeout") != NULL )
connParm.co_timeout = atoi(CSLFetchNameValue(papszOptions,"timeout"));
IIapi_connect( &connParm );
while( connParm.co_genParm.gp_completed == FALSE )
IIapi_wait( &waitParm );
hConn = connParm.co_connHandle;
if( connParm.co_genParm.gp_status != IIAPI_ST_SUCCESS
|| hConn == NULL )
{
OGRIngresStatement::ReportError( &(connParm.co_genParm),
"Failed to connect to Ingres database." );
return FALSE;
}
pszName = CPLStrdup( pszFullName );
bDSUpdate = bUpdate;
// Check for new or old Ingres spatial library
{
OGRIngresStatement oStmt( hConn );
if( oStmt.ExecuteSQL("SELECT COUNT(*) FROM iicolumns WHERE table_name = 'iiattribute' AND column_name = 'attgeomtype'" ) )
{
char **papszFields;
while( (papszFields = oStmt.GetRow()) )
{
CPLString osCount = papszFields[0];
if( osCount[0] == '0' )
{
bNewIngres = FALSE;
}
else
{
bNewIngres = TRUE;
}
}
}
}
/* -------------------------------------------------------------------- */
/* Get a list of available tables. */
/* -------------------------------------------------------------------- */
if( papszTableNames == NULL )
{
OGRIngresStatement oStmt( hConn );
if( oStmt.ExecuteSQL( "select table_name from iitables where system_use = 'U' and table_name not like 'iietab_%'" ) )
{
char **papszFields;
while( (papszFields = oStmt.GetRow()) )
{
CPLString osTableName = papszFields[0];
osTableName.Trim();
papszTableNames = CSLAddString( papszTableNames,
osTableName );
}
}
}
/* -------------------------------------------------------------------- */
/* Get the schema of the available tables. */
/* -------------------------------------------------------------------- */
int iRecord;
for( iRecord = 0;
papszTableNames != NULL && papszTableNames[iRecord] != NULL;
iRecord++ )
{
OpenTable( papszTableNames[iRecord], bUpdate );
}
CSLDestroy( papszTableNames );
return TRUE;
}
int OGRMSSQLSpatialDataSource::Open( const char * pszNewName, int bUpdate,
int bTestOpen )
{
CPLAssert( nLayers == 0 );
if( !EQUALN(pszNewName,"MSSQL:",6) )
{
if( !bTestOpen )
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not conform to MSSSQLSpatial naming convention,"
" MSSQL:*\n", pszNewName );
return FALSE;
}
/* Determine if the connection string contains specific values */
char* pszTableSpec = NULL;
char* pszGeometryFormat = NULL;
char* pszConnectionName = CPLStrdup(pszNewName + 6);
int nCurrent, nNext, nTerm;
nCurrent = nNext = nTerm = strlen(pszConnectionName);
while (nCurrent > 0)
{
--nCurrent;
if (pszConnectionName[nCurrent] == ';')
{
nNext = nCurrent;
continue;
}
if (ParseValue(&pszCatalog, pszConnectionName, "database=",
nCurrent, nNext, nTerm, FALSE))
continue;
if (ParseValue(&pszTableSpec, pszConnectionName, "tables=",
nCurrent, nNext, nTerm, TRUE))
continue;
if (ParseValue(&pszGeometryFormat, pszConnectionName,
"geometryformat=", nCurrent, nNext, nTerm, TRUE))
{
if (EQUALN(pszGeometryFormat, "wkb",3))
nGeometryFormat = MSSQLGEOMETRY_WKB;
else if (EQUALN(pszGeometryFormat,"wkt",3))
nGeometryFormat = MSSQLGEOMETRY_WKT;
else if (EQUALN(pszGeometryFormat,"native",3))
nGeometryFormat = MSSQLGEOMETRY_NATIVE;
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Invalid geometry type specified: %s,"
" MSSQL:*\n", pszGeometryFormat );
CPLFree(pszTableSpec);
CPLFree(pszGeometryFormat);
CPLFree(pszConnectionName);
return FALSE;
}
CPLFree(pszGeometryFormat);
pszGeometryFormat = NULL;
continue;
}
}
/* Determine if the connection string contains the catalog portion */
if( pszCatalog == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"'%s' does not contain the 'database' portion\n", pszNewName );
CPLFree(pszTableSpec);
CPLFree(pszGeometryFormat);
CPLFree(pszConnectionName);
return FALSE;
}
pszName = CPLStrdup(pszNewName);
char **papszTableNames=NULL;
char **papszSchemaNames=NULL;
char **papszGeomColumnNames=NULL;
char **papszCoordDimensions=NULL;
char **papszSRIds=NULL;
/* Determine if the connection string contains the TABLES portion */
if( pszTableSpec != NULL )
{
char **papszTableList;
int i;
papszTableList = CSLTokenizeString2( pszTableSpec, ",", 0 );
for( i = 0; i < CSLCount(papszTableList); i++ )
{
char **papszQualifiedParts;
// Get schema and table name
papszQualifiedParts = CSLTokenizeString2( papszTableList[i],
".", 0 );
/* Find the geometry column name if specified */
if( CSLCount( papszQualifiedParts ) >= 1 )
{
char* pszGeomColumnName = NULL;
char* pos = strchr(papszQualifiedParts[CSLCount( papszQualifiedParts ) - 1], '(');
if (pos != NULL)
{
*pos = '\0';
pszGeomColumnName = pos+1;
int len = strlen(pszGeomColumnName);
if (len > 0)
pszGeomColumnName[len - 1] = '\0';
}
papszGeomColumnNames = CSLAddString( papszGeomColumnNames,
pszGeomColumnName ? pszGeomColumnName : "");
}
if( CSLCount( papszQualifiedParts ) == 2 )
{
papszSchemaNames = CSLAddString( papszSchemaNames,
papszQualifiedParts[0] );
papszTableNames = CSLAddString( papszTableNames,
papszQualifiedParts[1] );
}
else if( CSLCount( papszQualifiedParts ) == 1 )
{
papszSchemaNames = CSLAddString( papszSchemaNames, "dbo");
papszTableNames = CSLAddString( papszTableNames,
papszQualifiedParts[0] );
}
CSLDestroy(papszQualifiedParts);
}
CSLDestroy(papszTableList);
}
CPLFree(pszTableSpec);
/* Initialize the SQL Server connection. */
CPLDebug( "OGR_MSSQLSpatial", "EstablishSession(Connection:\"%s\")", pszConnectionName);
if( !oSession.EstablishSession( CPLSPrintf("DRIVER=SQL Server;%s", pszConnectionName), "", "" ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to initialize connection to the server for %s,\n"
"%s", pszNewName, oSession.GetLastError() );
CSLDestroy( papszTableNames );
CSLDestroy( papszSchemaNames );
CSLDestroy( papszGeomColumnNames );
CSLDestroy( papszCoordDimensions );
CSLDestroy( papszSRIds );
CPLFree(pszGeometryFormat);
CPLFree(pszConnectionName);
return FALSE;
}
char** papszTypes = NULL;
/* Determine the available tables if not specified. */
if (papszTableNames == NULL)
{
CPLODBCStatement oStmt( &oSession );
oStmt.Append( "SELECT f_table_schema, f_table_name, f_geometry_column, coord_dimension, srid, geometry_type FROM dbo.geometry_columns");
if( oStmt.ExecuteSQL() )
{
while( oStmt.Fetch() )
{
papszSchemaNames =
CSLAddString( papszSchemaNames, oStmt.GetColData(0) );
papszTableNames =
CSLAddString( papszTableNames, oStmt.GetColData(1) );
papszGeomColumnNames =
CSLAddString( papszGeomColumnNames, oStmt.GetColData(2) );
papszCoordDimensions =
CSLAddString( papszCoordDimensions, oStmt.GetColData(3) );
papszSRIds =
CSLAddString( papszSRIds, oStmt.GetColData(4) );
papszTypes =
CSLAddString( papszTypes, oStmt.GetColData(5) );
}
}
}
int nSRId, nCoordDimension;
OGRwkbGeometryType eType;
for( int iTable = 0;
papszTableNames != NULL && papszTableNames[iTable] != NULL;
iTable++ )
{
if (papszSRIds != NULL)
nSRId = atoi(papszSRIds[iTable]);
else
nSRId = -1;
if (papszCoordDimensions != NULL)
nCoordDimension = atoi(papszCoordDimensions[iTable]);
else
nCoordDimension = 2;
if (papszTypes != NULL)
eType = OGRFromOGCGeomType(papszTypes[iTable]);
else
eType = wkbUnknown;
if( strlen(papszGeomColumnNames[iTable]) > 0 )
OpenTable( papszSchemaNames[iTable], papszTableNames[iTable], papszGeomColumnNames[iTable],
nCoordDimension, nSRId, eType, bUpdate );
else
OpenTable( papszSchemaNames[iTable], papszTableNames[iTable], NULL,
nCoordDimension, nSRId, eType, bUpdate );
}
CSLDestroy( papszTableNames );
CSLDestroy( papszSchemaNames );
CSLDestroy( papszGeomColumnNames );
CSLDestroy( papszCoordDimensions );
CSLDestroy( papszSRIds );
CSLDestroy( papszTypes );
CPLFree(pszGeometryFormat);
CPLFree(pszConnectionName);
bDSUpdate = bUpdate;
return TRUE;
}
OGRLayer * OGRMSSQLSpatialDataSource::CreateLayer( const char * pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
char *pszTableName = NULL;
char *pszSchemaName = NULL;
const char *pszGeomType = NULL;
const char *pszGeomColumn = NULL;
int nCoordDimension = 3;
/* determine the dimension */
if( eType == wkbFlatten(eType) )
nCoordDimension = 2;
if( CSLFetchNameValue( papszOptions, "DIM") != NULL )
nCoordDimension = atoi(CSLFetchNameValue( papszOptions, "DIM"));
/* MSSQL Schema handling:
Extract schema name from input layer name or passed with -lco SCHEMA.
Set layer name to "schema.table" or to "table" if schema is not
specified
*/
const char* pszDotPos = strstr(pszLayerName,".");
if ( pszDotPos != NULL )
{
int length = pszDotPos - pszLayerName;
pszSchemaName = (char*)CPLMalloc(length+1);
strncpy(pszSchemaName, pszLayerName, length);
pszSchemaName[length] = '\0';
if( CSLFetchBoolean(papszOptions,"LAUNDER", TRUE) )
pszTableName = LaunderName( pszDotPos + 1 ); //skip "."
else
pszTableName = CPLStrdup( pszDotPos + 1 ); //skip "."
}
else
{
pszSchemaName = NULL;
if( CSLFetchBoolean(papszOptions,"LAUNDER", TRUE) )
pszTableName = LaunderName( pszLayerName ); //skip "."
else
pszTableName = CPLStrdup( pszLayerName ); //skip "."
}
if( CSLFetchNameValue( papszOptions, "SCHEMA" ) != NULL )
{
CPLFree(pszSchemaName);
pszSchemaName = CPLStrdup(CSLFetchNameValue( papszOptions, "SCHEMA" ));
}
if (pszSchemaName == NULL)
pszSchemaName = CPLStrdup("dbo");
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszLayerName,papoLayers[iLayer]->GetTableName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
if (!pszSchemaName)
pszSchemaName = CPLStrdup(papoLayers[iLayer]->GetSchemaName());
DeleteLayer( iLayer );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszLayerName );
CPLFree( pszSchemaName );
CPLFree( pszTableName );
return NULL;
}
}
}
/* -------------------------------------------------------------------- */
/* Handle the GEOM_TYPE option. */
/* -------------------------------------------------------------------- */
pszGeomType = CSLFetchNameValue( papszOptions, "GEOM_TYPE" );
if( !pszGeomType )
pszGeomType = "geometry";
if( !EQUAL(pszGeomType, "geometry")
&& !EQUAL(pszGeomType, "geography"))
{
CPLError( CE_Failure, CPLE_AppDefined,
"FORMAT=%s not recognised or supported.",
pszGeomType );
CPLFree( pszSchemaName );
CPLFree( pszTableName );
return NULL;
}
/* determine the geometry column name */
pszGeomColumn = CSLFetchNameValue( papszOptions, "GEOM_NAME");
if (!pszGeomColumn)
pszGeomColumn = "ogr_geometry";
/* -------------------------------------------------------------------- */
/* Initialize the metadata tables */
/* -------------------------------------------------------------------- */
if (InitializeMetadataTables() != OGRERR_NONE)
{
CPLFree( pszSchemaName );
CPLFree( pszTableName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Try to get the SRS Id of this spatial reference system, */
/* adding to the srs table if needed. */
/* -------------------------------------------------------------------- */
int nSRSId = 0;
if( CSLFetchNameValue( papszOptions, "SRID") != NULL )
nSRSId = atoi(CSLFetchNameValue( papszOptions, "SRID"));
if( nSRSId == 0 && poSRS != NULL )
nSRSId = FetchSRSId( poSRS );
/* -------------------------------------------------------------------- */
/* Create a new table and create a new entry in the geometry, */
/* geometry_columns metadata table. */
/* -------------------------------------------------------------------- */
if( eType != wkbNone )
{
const char *pszGeometryType = OGRToOGCGeomType(eType);
CPLODBCStatement oStmt( &oSession );
oStmt.Appendf( "DELETE FROM geometry_columns WHERE f_table_schema = '%s' "
"AND f_table_name = '%s'\n", pszSchemaName, pszTableName );
oStmt.Appendf("INSERT INTO [geometry_columns] ([f_table_catalog], [f_table_schema] ,[f_table_name], "
"[f_geometry_column],[coord_dimension],[srid],[geometry_type]) VALUES ('%s', '%s', '%s', '%s', %d, %d, '%s')\n",
pszCatalog, pszSchemaName, pszTableName, pszGeomColumn, nCoordDimension, nSRSId, pszGeometryType );
oStmt.Appendf("CREATE TABLE [%s].[%s] ([ogr_fid] [int] IDENTITY(1,1) NOT NULL, "
"[%s] [%s] NULL, CONSTRAINT [PK_%s] PRIMARY KEY CLUSTERED ([ogr_fid] ASC))",
pszSchemaName, pszTableName, pszGeomColumn, pszGeomType, pszTableName);
oSession.BeginTransaction();
if( !oStmt.ExecuteSQL() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error creating layer: %s", GetSession()->GetLastError() );
return NULL;
}
oSession.CommitTransaction();
}
CPLFree( pszSchemaName );
CPLFree( pszTableName );
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRMSSQLSpatialTableLayer *poLayer;
poLayer = new OGRMSSQLSpatialTableLayer( this );
poLayer->SetLaunderFlag( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) );
poLayer->SetPrecisionFlag( CSLFetchBoolean(papszOptions,"PRECISION",TRUE));
if (poLayer->Initialize("dbo", pszLayerName, pszGeomColumn, nCoordDimension, nSRSId, eType) == OGRERR_FAILURE)
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGRMSSQLSpatialTableLayer **)
CPLRealloc( papoLayers, sizeof(OGRMSSQLSpatialTableLayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
return poLayer;
}
void OGRPGeoLayer::LookupSRID( int nSRID )
{
/* -------------------------------------------------------------------- */
/* Fetch the corresponding WKT from the SpatialRef table. */
/* -------------------------------------------------------------------- */
CPLODBCStatement oStmt( poDS->GetSession() );
oStmt.Appendf( "SELECT srtext FROM GDB_SpatialRefs WHERE srid = %d",
nSRID );
if( !oStmt.ExecuteSQL() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"'%s' failed.\n%s",
oStmt.GetCommand(),
poDS->GetSession()->GetLastError() );
return;
}
if( !oStmt.Fetch() )
{
CPLError( CE_Warning, CPLE_AppDefined,
"SRID %d lookup failed.\n%s",
nSRID, poDS->GetSession()->GetLastError() );
return;
}
/* -------------------------------------------------------------------- */
/* Check that it isn't just a GUID. We don't know how to */
/* translate those. */
/* -------------------------------------------------------------------- */
char *pszSRText = (char *) oStmt.GetColData(0);
if( pszSRText[0] == '{' )
{
CPLDebug( "PGEO", "Ignoreing GUID SRTEXT: %s", pszSRText );
return;
}
/* -------------------------------------------------------------------- */
/* Turn it into an OGRSpatialReference. */
/* -------------------------------------------------------------------- */
poSRS = new OGRSpatialReference();
if( poSRS->importFromWkt( &pszSRText ) != OGRERR_NONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"importFromWKT() failed on SRS '%s'.",
pszSRText);
delete poSRS;
poSRS = NULL;
}
else if( poSRS->morphFromESRI() != OGRERR_NONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"morphFromESRI() failed on SRS." );
delete poSRS;
poSRS = NULL;
}
else
nSRSId = nSRID;
}
OGRErr OGRIngresTableLayer::CreateFeature( OGRFeature *poFeature )
{
CPLString osCommand;
int i, bNeedComma = FALSE;
/* -------------------------------------------------------------------- */
/* Form the INSERT command. */
/* -------------------------------------------------------------------- */
osCommand.Printf( "INSERT INTO %s (", poFeatureDefn->GetName() );
/* -------------------------------------------------------------------- */
/* Accumulate fields to be inserted. */
/* -------------------------------------------------------------------- */
if( poFeature->GetGeometryRef() != NULL && osGeomColumn.size() )
{
osCommand = osCommand + osGeomColumn + " ";
bNeedComma = TRUE;
}
if( poFeature->GetFID() != OGRNullFID && osFIDColumn.size() )
{
if( bNeedComma )
osCommand += ", ";
osCommand = osCommand + osFIDColumn + " ";
bNeedComma = TRUE;
}
for( i = 0; i < poFeatureDefn->GetFieldCount(); i++ )
{
if( !poFeature->IsFieldSet( i ) )
continue;
if( !bNeedComma )
bNeedComma = TRUE;
else
osCommand += ", ";
osCommand = osCommand
+ poFeatureDefn->GetFieldDefn(i)->GetNameRef();
}
osCommand += ") VALUES (";
/* -------------------------------------------------------------------- */
/* Insert the geometry (as a place holder) */
/* -------------------------------------------------------------------- */
CPLString osGeomText;
// Set the geometry
bNeedComma = FALSE;
if( poFeature->GetGeometryRef() != NULL && osGeomColumn.size() )
{
bNeedComma = TRUE;
OGRErr localErr;
if( poDS->IsNewIngres() )
{
localErr = PrepareNewStyleGeometry( poFeature->GetGeometryRef(), osGeomText );
}
else
{
localErr = PrepareOldStyleGeometry( poFeature->GetGeometryRef(), osGeomText );
}
if( localErr == OGRERR_NONE )
{
if( CSLTestBoolean(
CPLGetConfigOption( "INGRES_INSERT_SUB", "NO") ) )
{
osCommand += " ~V";
}
else if( poDS->IsNewIngres() == FALSE )
{
osCommand += "'";
osCommand += osGeomText;
osCommand += "'";
osGeomText = "";
}
else
{
osCommand += osGeomText;
//osGeomText = "";
}
}
else
{
osGeomText = "";
osCommand += "NULL"; /* is this sort of empty geometry legal? */
}
}
/* -------------------------------------------------------------------- */
/* Set the FID */
/* -------------------------------------------------------------------- */
if( poFeature->GetFID() != OGRNullFID && osFIDColumn.size() )
{
if( bNeedComma )
osCommand += ", ";
osCommand += CPLString().Printf( "%ld ", poFeature->GetFID() );
bNeedComma = TRUE;
}
/* -------------------------------------------------------------------- */
/* Copy in the attribute values. */
/* -------------------------------------------------------------------- */
for( i = 0; i < poFeatureDefn->GetFieldCount(); i++ )
{
if( !poFeature->IsFieldSet( i ) )
continue;
if( bNeedComma )
osCommand += ", ";
else
bNeedComma = TRUE;
const char *pszStrValue = poFeature->GetFieldAsString(i);
if( poFeatureDefn->GetFieldDefn(i)->GetType() != OFTInteger
&& poFeatureDefn->GetFieldDefn(i)->GetType() != OFTReal
&& poFeatureDefn->GetFieldDefn(i)->GetType() != OFTBinary )
{
int iChar;
//We need to quote and escape string fields.
osCommand += "'";
for( iChar = 0; pszStrValue[iChar] != '\0'; iChar++ )
{
if( poFeatureDefn->GetFieldDefn(i)->GetType() != OFTIntegerList
&& poFeatureDefn->GetFieldDefn(i)->GetType() != OFTRealList
&& poFeatureDefn->GetFieldDefn(i)->GetWidth() > 0
&& iChar == poFeatureDefn->GetFieldDefn(i)->GetWidth() )
{
CPLDebug( "INGRES",
"Truncated %s field value, it was too long.",
poFeatureDefn->GetFieldDefn(i)->GetNameRef() );
break;
}
if( pszStrValue[iChar] == '\'' )
{
osCommand += '\'';
osCommand += pszStrValue[iChar];
}
else
osCommand += pszStrValue[iChar];
}
osCommand += "'";
}
else if( poFeatureDefn->GetFieldDefn(i)->GetType() == OFTBinary )
{
int binaryCount = 0;
GByte* binaryData = poFeature->GetFieldAsBinary(i, &binaryCount);
char* pszHexValue = CPLBinaryToHex( binaryCount, binaryData );
osCommand += "x'";
osCommand += pszHexValue;
osCommand += "'";
CPLFree( pszHexValue );
}
else
{
osCommand += pszStrValue;
}
}
osCommand += ")";
/* -------------------------------------------------------------------- */
/* Execute it. */
/* -------------------------------------------------------------------- */
poDS->EstablishActiveLayer( NULL );
OGRIngresStatement oStmt( poDS->GetConn() );
oStmt.bDebug = FALSE;
if( osGeomText.size() > 0 && poDS->IsNewIngres() == FALSE )
oStmt.addInputParameter( IIAPI_LVCH_TYPE, osGeomText.size(),
(GByte *) osGeomText.c_str() );
if( osGeomText.size() > 0 && poDS->IsNewIngres() == TRUE )
{
GByte * pabyWKB;
int nSize = poFeature->GetGeometryRef()->WkbSize();
pabyWKB = (GByte *) CPLMalloc(nSize);
poFeature->GetGeometryRef()->exportToWkb(wkbNDR, pabyWKB);
oStmt.addInputParameter( IIAPI_LBYTE_TYPE, nSize, pabyWKB );
CPLFree(pabyWKB);
/*
* Test code
char * pszWKT;
poFeature->GetGeometryRef()->exportToWkt(&pszWKT);
oStmt.addInputParameter(IIAPI_LVCH_TYPE, strlen(pszWKT), (GByte *) pszWKT);*/
}
if( !oStmt.ExecuteSQL( osCommand ) )
return OGRERR_FAILURE;
return OGRERR_NONE;
}
int OGRODBCDataSource::OpenMDB( const char * pszNewName, int bUpdate )
{
const char *pszDSNStringTemplate =
"DRIVER=Microsoft Access Driver (*.mdb);DBQ=%s";
char* pszDSN = (char *) CPLMalloc(strlen(pszNewName)+strlen(pszDSNStringTemplate)+100);
sprintf( pszDSN, pszDSNStringTemplate, pszNewName );
/* -------------------------------------------------------------------- */
/* Initialize based on the DSN. */
/* -------------------------------------------------------------------- */
CPLDebug( "ODBC", "EstablishSession(%s)", pszDSN );
if( !oSession.EstablishSession( pszDSN, NULL, NULL ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to initialize ODBC connection to DSN for %s,\n"
"%s", pszDSN, oSession.GetLastError() );
CPLFree( pszDSN );
return FALSE;
}
CPLFree( pszDSN );
pszName = CPLStrdup( pszNewName );
bDSUpdate = bUpdate;
/* -------------------------------------------------------------------- */
/* Check if it is a PGeo MDB. */
/* -------------------------------------------------------------------- */
{
CPLODBCStatement oStmt( &oSession );
oStmt.Append( "SELECT TableName, FieldName, ShapeType, ExtentLeft, ExtentRight, ExtentBottom, ExtentTop, SRID, HasZ FROM GDB_GeomColumns" );
if( oStmt.ExecuteSQL() )
{
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* Check if it is a Geomedia MDB. */
/* -------------------------------------------------------------------- */
{
CPLODBCStatement oStmt( &oSession );
oStmt.Append( "SELECT TableName FROM GAliasTable WHERE TableType = 'INGRFeatures'" );
if( oStmt.ExecuteSQL() )
{
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* Return all tables as non-spatial tables. */
/* -------------------------------------------------------------------- */
CPLODBCStatement oTableList( &oSession );
if( oTableList.GetTables() )
{
while( oTableList.Fetch() )
{
const char *pszSchema = oTableList.GetColData(1);
CPLString osLayerName;
if( pszSchema != NULL && strlen(pszSchema) > 0 )
{
osLayerName = pszSchema;
osLayerName += ".";
}
osLayerName += oTableList.GetColData(2);
OpenTable( osLayerName, NULL, bUpdate );
}
return TRUE;
}
else
return FALSE;
}
OGRErr OGRMSSQLSpatialTableLayer::CreateField( OGRFieldDefn *poFieldIn,
int bApproxOK )
{
char szFieldType[256];
OGRFieldDefn oField( poFieldIn );
GetLayerDefn();
/* -------------------------------------------------------------------- */
/* Do we want to "launder" the column names into MSSQL */
/* friendly format? */
/* -------------------------------------------------------------------- */
if( bLaunderColumnNames )
{
char *pszSafeName = poDS->LaunderName( oField.GetNameRef() );
oField.SetName( pszSafeName );
CPLFree( pszSafeName );
}
/* -------------------------------------------------------------------- */
/* Identify the MSSQL type. */
/* -------------------------------------------------------------------- */
if( oField.GetType() == OFTInteger )
{
if( oField.GetWidth() > 0 && bPreservePrecision )
sprintf( szFieldType, "numeric(%d,0)", oField.GetWidth() );
else
strcpy( szFieldType, "int" );
}
else if( oField.GetType() == OFTReal )
{
if( oField.GetWidth() > 0 && oField.GetPrecision() > 0
&& bPreservePrecision )
sprintf( szFieldType, "numeric(%d,%d)",
oField.GetWidth(), oField.GetPrecision() );
else
strcpy( szFieldType, "float" );
}
else if( oField.GetType() == OFTString )
{
if( oField.GetWidth() == 0 || !bPreservePrecision )
strcpy( szFieldType, "varchar(MAX)" );
else
sprintf( szFieldType, "varchar(%d)", oField.GetWidth() );
}
else if( oField.GetType() == OFTDate )
{
strcpy( szFieldType, "date" );
}
else if( oField.GetType() == OFTTime )
{
strcpy( szFieldType, "time(7)" );
}
else if( oField.GetType() == OFTDateTime )
{
strcpy( szFieldType, "datetime" );
}
else if( oField.GetType() == OFTBinary )
{
strcpy( szFieldType, "image" );
}
else if( bApproxOK )
{
CPLError( CE_Warning, CPLE_NotSupported,
"Can't create field %s with type %s on MSSQL layers. Creating as varchar.",
oField.GetNameRef(),
OGRFieldDefn::GetFieldTypeName(oField.GetType()) );
strcpy( szFieldType, "varchar" );
}
else
{
CPLError( CE_Failure, CPLE_NotSupported,
"Can't create field %s with type %s on MSSQL layers.",
oField.GetNameRef(),
OGRFieldDefn::GetFieldTypeName(oField.GetType()) );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Create the new field. */
/* -------------------------------------------------------------------- */
CPLODBCStatement oStmt( poDS->GetSession() );
oStmt.Appendf( "ALTER TABLE [%s].[%s] ADD [%s] %s",
pszSchemaName, pszTableName, oField.GetNameRef(), szFieldType);
if( !oStmt.ExecuteSQL() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error creating field %s, %s", oField.GetNameRef(),
poDS->GetSession()->GetLastError() );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Add the field to the OGRFeatureDefn. */
/* -------------------------------------------------------------------- */
poFeatureDefn->AddFieldDefn( &oField );
return OGRERR_NONE;
}
int OGRMSSQLSpatialDataSource::FetchSRSId( OGRSpatialReference * poSRS)
{
char *pszWKT = NULL;
int nSRSId = 0;
const char* pszAuthorityName;
if( poSRS == NULL )
return 0;
OGRSpatialReference oSRS(*poSRS);
poSRS = NULL;
pszAuthorityName = oSRS.GetAuthorityName(NULL);
if( pszAuthorityName == NULL || strlen(pszAuthorityName) == 0 )
{
/* -------------------------------------------------------------------- */
/* Try to identify an EPSG code */
/* -------------------------------------------------------------------- */
oSRS.AutoIdentifyEPSG();
pszAuthorityName = oSRS.GetAuthorityName(NULL);
if (pszAuthorityName != NULL && EQUAL(pszAuthorityName, "EPSG"))
{
const char* pszAuthorityCode = oSRS.GetAuthorityCode(NULL);
if ( pszAuthorityCode != NULL && strlen(pszAuthorityCode) > 0 )
{
/* Import 'clean' SRS */
oSRS.importFromEPSG( atoi(pszAuthorityCode) );
pszAuthorityName = oSRS.GetAuthorityName(NULL);
}
}
}
/* -------------------------------------------------------------------- */
/* Check whether the EPSG authority code is already mapped to a */
/* SRS ID. */
/* -------------------------------------------------------------------- */
int nAuthorityCode = 0;
if( pszAuthorityName != NULL && EQUAL( pszAuthorityName, "EPSG" ) )
{
/* For the root authority name 'EPSG', the authority code
* should always be integral
*/
nAuthorityCode = atoi( oSRS.GetAuthorityCode(NULL) );
CPLODBCStatement oStmt( &oSession );
oStmt.Appendf("SELECT srid FROM spatial_ref_sys WHERE "
"auth_name = '%s' AND auth_srid = %d",
pszAuthorityName,
nAuthorityCode );
if( oStmt.ExecuteSQL() && oStmt.Fetch() && oStmt.GetColData( 0 ) )
{
nSRSId = atoi(oStmt.GetColData( 0 ));
return nSRSId;
}
}
/* -------------------------------------------------------------------- */
/* Translate SRS to WKT. */
/* -------------------------------------------------------------------- */
if( oSRS.exportToWkt( &pszWKT ) != OGRERR_NONE )
{
CPLFree(pszWKT);
return 0;
}
/* -------------------------------------------------------------------- */
/* Try to find in the existing table. */
/* -------------------------------------------------------------------- */
CPLODBCStatement oStmt( &oSession );
oStmt.Append( "SELECT srid FROM spatial_ref_sys WHERE srtext = ");
OGRMSSQLAppendEscaped(&oStmt, pszWKT);
/* -------------------------------------------------------------------- */
/* We got it! Return it. */
/* -------------------------------------------------------------------- */
if( oStmt.ExecuteSQL() )
{
if ( oStmt.Fetch() && oStmt.GetColData( 0 ) )
{
nSRSId = atoi(oStmt.GetColData( 0 ));
CPLFree(pszWKT);
return nSRSId;
}
}
else
{
/* probably the table is missing at all */
if( InitializeMetadataTables() != OGRERR_NONE )
{
CPLFree(pszWKT);
return 0;
}
}
/* -------------------------------------------------------------------- */
/* Try adding the SRS to the SRS table. */
/* -------------------------------------------------------------------- */
char *pszProj4 = NULL;
if( oSRS.exportToProj4( &pszProj4 ) != OGRERR_NONE )
{
CPLFree( pszProj4 );
CPLFree(pszWKT);
return 0;
}
/* -------------------------------------------------------------------- */
/* Check whether the auth_code can be used as srid. */
/* -------------------------------------------------------------------- */
nSRSId = nAuthorityCode;
oStmt.Clear();
oSession.BeginTransaction();
if (nAuthorityCode > 0)
{
oStmt.Appendf("SELECT srid FROM spatial_ref_sys where srid = %d", nAuthorityCode);
if ( oStmt.ExecuteSQL() && oStmt.Fetch())
{
nSRSId = 0;
}
}
/* -------------------------------------------------------------------- */
/* Get the current maximum srid in the srs table. */
/* -------------------------------------------------------------------- */
if (nSRSId == 0)
{
oStmt.Clear();
oStmt.Append("SELECT COALESCE(MAX(srid) + 1, 32768) FROM spatial_ref_sys where srid between 32768 and 65536");
if ( oStmt.ExecuteSQL() && oStmt.Fetch() && oStmt.GetColData( 0 ) )
{
nSRSId = atoi(oStmt.GetColData( 0 ));
}
}
if (nSRSId == 0)
{
/* unable to allocate srid */
oSession.RollbackTransaction();
CPLFree( pszProj4 );
CPLFree(pszWKT);
return 0;
}
oStmt.Clear();
if( nAuthorityCode > 0 )
{
oStmt.Appendf(
"INSERT INTO spatial_ref_sys (srid, auth_srid, auth_name, srtext, proj4text) "
"VALUES (%d, %d, ", nSRSId, nAuthorityCode );
OGRMSSQLAppendEscaped(&oStmt, pszAuthorityName);
oStmt.Append(", ");
OGRMSSQLAppendEscaped(&oStmt, pszWKT);
oStmt.Append(", ");
OGRMSSQLAppendEscaped(&oStmt, pszProj4);
oStmt.Append(")");
}
else
{
oStmt.Appendf(
"INSERT INTO spatial_ref_sys (srid,srtext,proj4text) VALUES (%d, ", nSRSId);
OGRMSSQLAppendEscaped(&oStmt, pszWKT);
oStmt.Append(", ");
OGRMSSQLAppendEscaped(&oStmt, pszProj4);
oStmt.Append(")");
}
/* Free everything that was allocated. */
CPLFree( pszProj4 );
CPLFree( pszWKT);
if ( oStmt.ExecuteSQL() )
oSession.CommitTransaction();
else
oSession.RollbackTransaction();
return nSRSId;
}
int OGRMSSQLSpatialDataSource::Open( const char * pszNewName, int bUpdate,
int bTestOpen )
{
CPLAssert( nLayers == 0 );
if( !EQUALN(pszNewName,"MSSQL:",6) )
{
if( !bTestOpen )
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not conform to MSSSQLSpatial naming convention,"
" MSSQL:*\n", pszNewName );
return FALSE;
}
/* Determine if the connection string contains specific values */
char* pszTableSpec = NULL;
char* pszGeometryFormat = NULL;
char* pszConnectionName = CPLStrdup(pszNewName + 6);
char* pszDriver = NULL;
int nCurrent, nNext, nTerm;
nCurrent = nNext = nTerm = strlen(pszConnectionName);
while (nCurrent > 0)
{
--nCurrent;
if (pszConnectionName[nCurrent] == ';')
{
nNext = nCurrent;
continue;
}
if (ParseValue(&pszCatalog, pszConnectionName, "database=",
nCurrent, nNext, nTerm, FALSE))
continue;
if (ParseValue(&pszTableSpec, pszConnectionName, "tables=",
nCurrent, nNext, nTerm, TRUE))
continue;
if (ParseValue(&pszDriver, pszConnectionName, "driver=",
nCurrent, nNext, nTerm, FALSE))
continue;
if (ParseValue(&pszGeometryFormat, pszConnectionName,
"geometryformat=", nCurrent, nNext, nTerm, TRUE))
{
if (EQUALN(pszGeometryFormat,"wkbzm",5))
nGeometryFormat = MSSQLGEOMETRY_WKBZM;
else if (EQUALN(pszGeometryFormat, "wkb",3))
nGeometryFormat = MSSQLGEOMETRY_WKB;
else if (EQUALN(pszGeometryFormat,"wkt",3))
nGeometryFormat = MSSQLGEOMETRY_WKT;
else if (EQUALN(pszGeometryFormat,"native",6))
nGeometryFormat = MSSQLGEOMETRY_NATIVE;
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Invalid geometry type specified: %s,"
" MSSQL:*\n", pszGeometryFormat );
CPLFree(pszTableSpec);
CPLFree(pszGeometryFormat);
CPLFree(pszConnectionName);
CPLFree(pszDriver);
return FALSE;
}
CPLFree(pszGeometryFormat);
pszGeometryFormat = NULL;
continue;
}
}
/* Determine if the connection string contains the catalog portion */
if( pszCatalog == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"'%s' does not contain the 'database' portion\n", pszNewName );
CPLFree(pszTableSpec);
CPLFree(pszGeometryFormat);
CPLFree(pszConnectionName);
CPLFree(pszDriver);
return FALSE;
}
pszName = CPLStrdup(pszNewName);
char **papszTableNames=NULL;
char **papszSchemaNames=NULL;
char **papszGeomColumnNames=NULL;
char **papszCoordDimensions=NULL;
char **papszSRIds=NULL;
char **papszSRTexts=NULL;
/* Determine if the connection string contains the TABLES portion */
if( pszTableSpec != NULL )
{
char **papszTableList;
int i;
papszTableList = CSLTokenizeString2( pszTableSpec, ",", 0 );
for( i = 0; i < CSLCount(papszTableList); i++ )
{
char **papszQualifiedParts;
// Get schema and table name
papszQualifiedParts = CSLTokenizeString2( papszTableList[i],
".", 0 );
/* Find the geometry column name if specified */
if( CSLCount( papszQualifiedParts ) >= 1 )
{
char* pszGeomColumnName = NULL;
char* pos = strchr(papszQualifiedParts[CSLCount( papszQualifiedParts ) - 1], '(');
if (pos != NULL)
{
*pos = '\0';
pszGeomColumnName = pos+1;
int len = strlen(pszGeomColumnName);
if (len > 0)
pszGeomColumnName[len - 1] = '\0';
}
papszGeomColumnNames = CSLAddString( papszGeomColumnNames,
pszGeomColumnName ? pszGeomColumnName : "");
}
if( CSLCount( papszQualifiedParts ) == 2 )
{
papszSchemaNames = CSLAddString( papszSchemaNames,
papszQualifiedParts[0] );
papszTableNames = CSLAddString( papszTableNames,
papszQualifiedParts[1] );
}
else if( CSLCount( papszQualifiedParts ) == 1 )
{
papszSchemaNames = CSLAddString( papszSchemaNames, "dbo");
papszTableNames = CSLAddString( papszTableNames,
papszQualifiedParts[0] );
}
CSLDestroy(papszQualifiedParts);
}
CSLDestroy(papszTableList);
}
CPLFree(pszTableSpec);
/* Initialize the SQL Server connection. */
int nResult;
if ( pszDriver != NULL )
{
/* driver has been specified */
CPLDebug( "OGR_MSSQLSpatial", "EstablishSession(Connection:\"%s\")", pszConnectionName);
nResult = oSession.EstablishSession( pszConnectionName, "", "" );
}
else
{
/* no driver has been specified, defautls to SQL Server */
CPLDebug( "OGR_MSSQLSpatial", "EstablishSession(Connection:\"%s\")", pszConnectionName);
nResult = oSession.EstablishSession( CPLSPrintf("DRIVER=SQL Server;%s", pszConnectionName), "", "" );
}
CPLFree(pszDriver);
if( !nResult )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to initialize connection to the server for %s,\n"
"%s", pszNewName, oSession.GetLastError() );
CSLDestroy( papszTableNames );
CSLDestroy( papszSchemaNames );
CSLDestroy( papszGeomColumnNames );
CSLDestroy( papszCoordDimensions );
CSLDestroy( papszSRIds );
CSLDestroy( papszSRTexts );
CPLFree(pszGeometryFormat);
CPLFree(pszConnectionName);
return FALSE;
}
char** papszTypes = NULL;
/* read metadata for the specified tables */
if (papszTableNames != NULL && bUseGeometryColumns)
{
for( int iTable = 0;
papszTableNames != NULL && papszTableNames[iTable] != NULL;
iTable++ )
{
CPLODBCStatement oStmt( &oSession );
/* Use join to make sure the existence of the referred column/table */
oStmt.Appendf( "SELECT f_geometry_column, coord_dimension, g.srid, srtext, geometry_type FROM dbo.geometry_columns g JOIN INFORMATION_SCHEMA.COLUMNS ON f_table_schema = TABLE_SCHEMA and f_table_name = TABLE_NAME and f_geometry_column = COLUMN_NAME left outer join dbo.spatial_ref_sys s on g.srid = s.srid WHERE f_table_schema = '%s' AND f_table_name = '%s'", papszSchemaNames[iTable], papszTableNames[iTable]);
if( oStmt.ExecuteSQL() )
{
while( oStmt.Fetch() )
{
if (papszGeomColumnNames == NULL)
papszGeomColumnNames = CSLAddString( papszGeomColumnNames, oStmt.GetColData(0) );
else if (*papszGeomColumnNames[iTable] == 0)
{
CPLFree(papszGeomColumnNames[iTable]);
papszGeomColumnNames[iTable] = CPLStrdup( oStmt.GetColData(0) );
}
papszCoordDimensions =
CSLAddString( papszCoordDimensions, oStmt.GetColData(1, "2") );
papszSRIds =
CSLAddString( papszSRIds, oStmt.GetColData(2, "0") );
papszSRTexts =
CSLAddString( papszSRTexts, oStmt.GetColData(3, "") );
papszTypes =
CSLAddString( papszTypes, oStmt.GetColData(4, "GEOMETRY") );
}
}
else
{
/* probably the table is missing at all */
InitializeMetadataTables();
}
}
}
/* if requesting all user database table then this takes priority */
if (papszTableNames == NULL && bListAllTables)
{
CPLODBCStatement oStmt( &oSession );
oStmt.Append( "select sys.schemas.name, sys.schemas.name + '.' + sys.objects.name, sys.columns.name from sys.columns join sys.types on sys.columns.system_type_id = sys.types.system_type_id and sys.columns.user_type_id = sys.types.user_type_id join sys.objects on sys.objects.object_id = sys.columns.object_id join sys.schemas on sys.objects.schema_id = sys.schemas.schema_id where (sys.types.name = 'geometry' or sys.types.name = 'geography') and (sys.objects.type = 'U' or sys.objects.type = 'V') union all select sys.schemas.name, sys.schemas.name + '.' + sys.objects.name, '' from sys.objects join sys.schemas on sys.objects.schema_id = sys.schemas.schema_id where not exists (select * from sys.columns sc1 join sys.types on sc1.system_type_id = sys.types.system_type_id where (sys.types.name = 'geometry' or sys.types.name = 'geography') and sys.objects.object_id = sc1.object_id) and (sys.objects.type = 'U' or sys.objects.type = 'V')" );
if( oStmt.ExecuteSQL() )
{
while( oStmt.Fetch() )
{
papszSchemaNames =
CSLAddString( papszSchemaNames, oStmt.GetColData(0) );
papszTableNames =
CSLAddString( papszTableNames, oStmt.GetColData(1) );
papszGeomColumnNames =
CSLAddString( papszGeomColumnNames, oStmt.GetColData(2) );
}
}
}
/* Determine the available tables if not specified. */
if (papszTableNames == NULL && bUseGeometryColumns)
{
CPLODBCStatement oStmt( &oSession );
/* Use join to make sure the existence of the referred column/table */
oStmt.Append( "SELECT f_table_schema, f_table_name, f_geometry_column, coord_dimension, g.srid, srtext, geometry_type FROM dbo.geometry_columns g JOIN INFORMATION_SCHEMA.COLUMNS ON f_table_schema = TABLE_SCHEMA and f_table_name = TABLE_NAME and f_geometry_column = COLUMN_NAME left outer join dbo.spatial_ref_sys s on g.srid = s.srid");
if( oStmt.ExecuteSQL() )
{
while( oStmt.Fetch() )
{
papszSchemaNames =
CSLAddString( papszSchemaNames, oStmt.GetColData(0, "dbo") );
papszTableNames =
CSLAddString( papszTableNames, oStmt.GetColData(1) );
papszGeomColumnNames =
CSLAddString( papszGeomColumnNames, oStmt.GetColData(2) );
papszCoordDimensions =
CSLAddString( papszCoordDimensions, oStmt.GetColData(3, "2") );
papszSRIds =
CSLAddString( papszSRIds, oStmt.GetColData(4, "0") );
papszSRTexts =
CSLAddString( papszSRTexts, oStmt.GetColData(5, "") );
papszTypes =
CSLAddString( papszTypes, oStmt.GetColData(6, "GEOMETRY") );
}
}
else
{
/* probably the table is missing at all */
InitializeMetadataTables();
}
}
/* Query catalog for tables having geometry columns */
if (papszTableNames == NULL)
{
CPLODBCStatement oStmt( &oSession );
oStmt.Append( "SELECT sys.schemas.name, sys.schemas.name + '.' + sys.objects.name, sys.columns.name from sys.columns join sys.types on sys.columns.system_type_id = sys.types.system_type_id and sys.columns.user_type_id = sys.types.user_type_id join sys.objects on sys.objects.object_id = sys.columns.object_id join sys.schemas on sys.objects.schema_id = sys.schemas.schema_id where (sys.types.name = 'geometry' or sys.types.name = 'geography') and (sys.objects.type = 'U' or sys.objects.type = 'V')");
if( oStmt.ExecuteSQL() )
{
while( oStmt.Fetch() )
{
papszSchemaNames =
CSLAddString( papszSchemaNames, oStmt.GetColData(0) );
papszTableNames =
CSLAddString( papszTableNames, oStmt.GetColData(1) );
papszGeomColumnNames =
CSLAddString( papszGeomColumnNames, oStmt.GetColData(2) );
}
}
}
int nSRId, nCoordDimension;
OGRwkbGeometryType eType;
for( int iTable = 0;
papszTableNames != NULL && papszTableNames[iTable] != NULL;
iTable++ )
{
if (papszSRIds != NULL)
nSRId = atoi(papszSRIds[iTable]);
else
nSRId = -1;
if (papszCoordDimensions != NULL)
nCoordDimension = atoi(papszCoordDimensions[iTable]);
else
nCoordDimension = 2;
if (papszTypes != NULL)
eType = OGRFromOGCGeomType(papszTypes[iTable]);
else
eType = wkbUnknown;
if( strlen(papszGeomColumnNames[iTable]) > 0 )
OpenTable( papszSchemaNames[iTable], papszTableNames[iTable], papszGeomColumnNames[iTable],
nCoordDimension, nSRId, papszSRTexts? papszSRTexts[iTable] : NULL, eType, bUpdate );
else
OpenTable( papszSchemaNames[iTable], papszTableNames[iTable], NULL,
nCoordDimension, nSRId, papszSRTexts? papszSRTexts[iTable] : NULL, wkbNone, bUpdate );
}
CSLDestroy( papszTableNames );
CSLDestroy( papszSchemaNames );
CSLDestroy( papszGeomColumnNames );
CSLDestroy( papszCoordDimensions );
CSLDestroy( papszSRIds );
CSLDestroy( papszSRTexts );
CSLDestroy( papszTypes );
CPLFree(pszGeometryFormat);
CPLFree(pszConnectionName);
bDSUpdate = bUpdate;
return TRUE;
}
int OGRODBCDataSource::Open( const char * pszNewName, int bUpdate,
CPL_UNUSED int bTestOpen )
{
CPLAssert( nLayers == 0 );
if( !STARTS_WITH_CI(pszNewName, "ODBC:") && EQUAL(CPLGetExtension(pszNewName), "MDB") )
return OpenMDB(pszNewName, bUpdate);
/* -------------------------------------------------------------------- */
/* Start parsing dataset name from the end of string, fetching */
/* the name of spatial reference table and names for SRID and */
/* SRTEXT columns first. */
/* -------------------------------------------------------------------- */
char *pszWrkName = CPLStrdup( pszNewName + 5 ); // Skip the 'ODBC:' part
char **papszTables = nullptr;
char **papszGeomCol = nullptr;
char *pszSRSTableName = nullptr;
char *pszSRIDCol = nullptr;
char *pszSRTextCol = nullptr;
char *pszDelimiter = nullptr;
if ( (pszDelimiter = strrchr( pszWrkName, ':' )) != nullptr )
{
char *pszOBracket = strchr( pszDelimiter + 1, '(' );
if( strchr(pszDelimiter,'\\') != nullptr
|| strchr(pszDelimiter,'/') != nullptr )
{
/*
** if there are special tokens then this isn't really
** the srs table name, so avoid further processing.
*/
}
else if( pszOBracket == nullptr )
{
pszSRSTableName = CPLStrdup( pszDelimiter + 1 );
*pszDelimiter = '\0';
}
else
{
char *pszCBracket = strchr( pszOBracket, ')' );
if( pszCBracket != nullptr )
*pszCBracket = '\0';
char *pszComma = strchr( pszOBracket, ',' );
if( pszComma != nullptr )
{
*pszComma = '\0';
pszSRIDCol = CPLStrdup( pszComma + 1 );
}
*pszOBracket = '\0';
pszSRSTableName = CPLStrdup( pszDelimiter + 1 );
pszSRTextCol = CPLStrdup( pszOBracket + 1 );
*pszDelimiter = '\0';
}
}
/* -------------------------------------------------------------------- */
/* Strip off any comma delimited set of tables names to access */
/* from the end of the string first. Also allow an optional */
/* bracketed geometry column name after the table name. */
/* -------------------------------------------------------------------- */
while( (pszDelimiter = strrchr( pszWrkName, ',' )) != nullptr )
{
char *pszOBracket = strstr( pszDelimiter + 1, "(" );
if( pszOBracket == nullptr )
{
papszTables = CSLAddString( papszTables, pszDelimiter + 1 );
papszGeomCol = CSLAddString( papszGeomCol, "" );
}
else
{
char *pszCBracket = strstr(pszOBracket,")");
if( pszCBracket != nullptr )
*pszCBracket = '\0';
*pszOBracket = '\0';
papszTables = CSLAddString( papszTables, pszDelimiter + 1 );
papszGeomCol = CSLAddString( papszGeomCol, pszOBracket+1 );
}
*pszDelimiter = '\0';
}
/* -------------------------------------------------------------------- */
/* Split out userid, password and DSN. The general form is */
/* user/password@dsn. But if there are no @ characters the */
/* whole thing is assumed to be a DSN. */
/* -------------------------------------------------------------------- */
char *pszUserid = nullptr;
char *pszPassword = nullptr;
char *pszDSN = nullptr;
if( strstr(pszWrkName,"@") == nullptr )
{
pszDSN = CPLStrdup( pszWrkName );
}
else
{
pszDSN = CPLStrdup(strstr(pszWrkName, "@") + 1);
if( *pszWrkName == '/' )
{
pszPassword = CPLStrdup(pszWrkName + 1);
char *pszTarget = strstr(pszPassword,"@");
*pszTarget = '\0';
}
else
{
pszUserid = CPLStrdup(pszWrkName);
char *pszTarget = strstr(pszUserid,"@");
*pszTarget = '\0';
pszTarget = strstr(pszUserid,"/");
if( pszTarget != nullptr )
{
*pszTarget = '\0';
pszPassword = CPLStrdup(pszTarget+1);
}
}
}
CPLFree( pszWrkName );
/* -------------------------------------------------------------------- */
/* Initialize based on the DSN. */
/* -------------------------------------------------------------------- */
CPLDebug( "OGR_ODBC",
"EstablishSession(DSN:\"%s\", userid:\"%s\", password:\"%s\")",
pszDSN, pszUserid ? pszUserid : "",
pszPassword ? pszPassword : "" );
if( !oSession.EstablishSession( pszDSN, pszUserid, pszPassword ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to initialize ODBC connection to DSN for %s,\n"
"%s",
pszNewName+5, oSession.GetLastError() );
CSLDestroy( papszTables );
CSLDestroy( papszGeomCol );
CPLFree( pszDSN );
CPLFree( pszUserid );
CPLFree( pszPassword );
CPLFree( pszSRIDCol );
CPLFree( pszSRTextCol );
CPLFree( pszSRSTableName );
return FALSE;
}
CPLFree( pszDSN );
CPLFree( pszUserid );
CPLFree( pszPassword );
pszName = CPLStrdup( pszNewName );
bDSUpdate = bUpdate;
/* -------------------------------------------------------------------- */
/* If no explicit list of tables was given, check for a list in */
/* a geometry_columns table. */
/* -------------------------------------------------------------------- */
if( papszTables == nullptr )
{
CPLODBCStatement oStmt( &oSession );
oStmt.Append( "SELECT f_table_name, f_geometry_column, geometry_type"
" FROM geometry_columns" );
if( oStmt.ExecuteSQL() )
{
while( oStmt.Fetch() )
{
papszTables =
CSLAddString( papszTables, oStmt.GetColData(0) );
papszGeomCol =
CSLAddString( papszGeomCol, oStmt.GetColData(1) );
}
}
}
/* -------------------------------------------------------------------- */
/* Otherwise our final resort is to return all tables as */
/* non-spatial tables. */
/* -------------------------------------------------------------------- */
if( papszTables == nullptr )
{
CPLODBCStatement oTableList( &oSession );
if( oTableList.GetTables() )
{
while( oTableList.Fetch() )
{
const char *pszSchema = oTableList.GetColData(1);
CPLString osLayerName;
if( pszSchema != nullptr && strlen(pszSchema) > 0 )
{
osLayerName = pszSchema;
osLayerName += ".";
}
osLayerName += oTableList.GetColData(2);
papszTables = CSLAddString( papszTables, osLayerName );
papszGeomCol = CSLAddString(papszGeomCol,"");
}
}
}
/* -------------------------------------------------------------------- */
/* If we have an explicit list of requested tables, use them */
/* (non-spatial). */
/* -------------------------------------------------------------------- */
for( int iTable = 0;
papszTables != nullptr && papszTables[iTable] != nullptr;
iTable++ )
{
if( strlen(papszGeomCol[iTable]) > 0 )
OpenTable( papszTables[iTable], papszGeomCol[iTable], bUpdate );
else
OpenTable( papszTables[iTable], nullptr, bUpdate );
}
CSLDestroy( papszTables );
CSLDestroy( papszGeomCol );
/* -------------------------------------------------------------------- */
/* If no explicit list of tables was given, check for a list in */
/* a geometry_columns table. */
/* -------------------------------------------------------------------- */
if ( pszSRSTableName )
{
CPLODBCStatement oSRSList( &oSession );
if ( !pszSRTextCol )
pszSRTextCol = CPLStrdup( "srtext" );
if ( !pszSRIDCol )
pszSRIDCol = CPLStrdup( "srid" );
oSRSList.Append( "SELECT " );
oSRSList.Append( pszSRIDCol );
oSRSList.Append( "," );
oSRSList.Append( pszSRTextCol );
oSRSList.Append( " FROM " );
oSRSList.Append( pszSRSTableName );
CPLDebug( "OGR_ODBC", "ExecuteSQL(%s) to read SRS table",
oSRSList.GetCommand() );
if ( oSRSList.ExecuteSQL() )
{
int nRows = 256; // A reasonable number of SRIDs to start from
panSRID = (int *)CPLMalloc( nRows * sizeof(int) );
papoSRS = (OGRSpatialReference **)
CPLMalloc( nRows * sizeof(OGRSpatialReference*) );
while ( oSRSList.Fetch() )
{
const char *pszSRID = oSRSList.GetColData( pszSRIDCol );
if ( !pszSRID )
continue;
const char *pszSRText = oSRSList.GetColData( pszSRTextCol );
if ( pszSRText )
{
if ( nKnownSRID > nRows )
{
nRows *= 2;
panSRID = (int *)CPLRealloc( panSRID,
nRows * sizeof(int) );
papoSRS = (OGRSpatialReference **)
CPLRealloc( papoSRS,
nRows * sizeof(OGRSpatialReference*) );
}
panSRID[nKnownSRID] = atoi( pszSRID );
papoSRS[nKnownSRID] = new OGRSpatialReference();
papoSRS[nKnownSRID]->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
if ( papoSRS[nKnownSRID]->importFromWkt( pszSRText )
!= OGRERR_NONE )
{
delete papoSRS[nKnownSRID];
continue;
}
nKnownSRID++;
}
}
}
}
if ( pszSRIDCol )
CPLFree( pszSRIDCol );
if ( pszSRTextCol )
CPLFree( pszSRTextCol );
if ( pszSRSTableName )
CPLFree( pszSRSTableName );
return TRUE;
}
int OGRODBCDataSource::OpenMDB( const char * pszNewName, int bUpdate )
{
const char* pszOptionName = "PGEO_DRIVER_TEMPLATE";
const char* pszDSNStringTemplate = CPLGetConfigOption( pszOptionName, nullptr );
if( pszDSNStringTemplate == nullptr )
{
pszOptionName = "MDB_DRIVER_TEMPLATE";
pszDSNStringTemplate = CPLGetConfigOption( pszOptionName, nullptr );
if( pszDSNStringTemplate == nullptr )
{
pszOptionName = "";
pszDSNStringTemplate = "DRIVER=Microsoft Access Driver (*.mdb);DBQ=%s";
}
}
if (!CheckDSNStringTemplate(pszDSNStringTemplate))
{
CPLError( CE_Failure, CPLE_AppDefined,
"Illegal value for %s option", pszOptionName );
return FALSE;
}
char* pszDSN = (char *) CPLMalloc(strlen(pszNewName)+strlen(pszDSNStringTemplate)+100);
/* coverity[tainted_string] */
snprintf( pszDSN,
strlen(pszNewName)+strlen(pszDSNStringTemplate)+100,
pszDSNStringTemplate, pszNewName );
/* -------------------------------------------------------------------- */
/* Initialize based on the DSN. */
/* -------------------------------------------------------------------- */
CPLDebug( "ODBC", "EstablishSession(%s)", pszDSN );
if( !oSession.EstablishSession( pszDSN, nullptr, nullptr ) )
{
int bError = TRUE;
if( EQUAL(pszDSN, "") )
{
// Trying with another template (#5594)
pszDSNStringTemplate = "DRIVER=Microsoft Access Driver (*.mdb, *.accdb);DBQ=%s";
CPLFree( pszDSN );
pszDSN = (char *) CPLMalloc(strlen(pszNewName)+strlen(pszDSNStringTemplate)+100);
snprintf( pszDSN,
strlen(pszNewName)+strlen(pszDSNStringTemplate)+100,
pszDSNStringTemplate, pszNewName );
CPLDebug( "ODBC", "EstablishSession(%s)", pszDSN );
if( oSession.EstablishSession( pszDSN, nullptr, nullptr ) )
{
bError = FALSE;
}
}
if( bError )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to initialize ODBC connection to DSN for %s,\n"
"%s", pszDSN, oSession.GetLastError() );
CPLFree( pszDSN );
return FALSE;
}
}
CPLFree( pszDSN );
pszName = CPLStrdup( pszNewName );
bDSUpdate = bUpdate;
/* -------------------------------------------------------------------- */
/* Check if it is a PGeo MDB. */
/* -------------------------------------------------------------------- */
{
CPLODBCStatement oStmt( &oSession );
oStmt.Append( "SELECT TableName, FieldName, ShapeType, ExtentLeft, ExtentRight, ExtentBottom, ExtentTop, SRID, HasZ FROM GDB_GeomColumns" );
if( oStmt.ExecuteSQL() )
{
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* Check if it is a Geomedia MDB. */
/* -------------------------------------------------------------------- */
{
CPLODBCStatement oStmt( &oSession );
oStmt.Append( "SELECT TableName FROM GAliasTable WHERE TableType = 'INGRFeatures'" );
if( oStmt.ExecuteSQL() )
{
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* Check if it is a Walk MDB. */
/* -------------------------------------------------------------------- */
{
CPLODBCStatement oStmt( &oSession );
oStmt.Append( "SELECT LayerID, LayerName, minE, maxE, minN, maxN, Memo FROM WalkLayers" );
if( oStmt.ExecuteSQL() )
{
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* Return all tables as non-spatial tables. */
/* -------------------------------------------------------------------- */
CPLODBCStatement oTableList( &oSession );
if( oTableList.GetTables() )
{
while( oTableList.Fetch() )
{
const char *pszSchema = oTableList.GetColData(1);
const char* pszTableName = oTableList.GetColData(2);
if( pszTableName != nullptr )
{
CPLString osLayerName;
if( pszSchema != nullptr && strlen(pszSchema) > 0 )
{
osLayerName = pszSchema;
osLayerName += ".";
}
osLayerName += pszTableName;
OpenTable( osLayerName, nullptr, bUpdate );
}
}
return TRUE;
}
else
return FALSE;
}
int OGRWalkDataSource::Open( const char * pszNewName, int /* bUpdate */ )
{
/* -------------------------------------------------------------------- */
/* If this is the name of an MDB file, then construct the */
/* appropriate connection string. Otherwise clip of WALK: to */
/* get the DSN. */
/* -------------------------------------------------------------------- */
char *pszDSN = NULL;
if( STARTS_WITH_CI(pszNewName, "WALK:") )
{
pszDSN = CPLStrdup( pszNewName + 5 );
}
else
{
const char *pszDSNStringTemplate = "DRIVER=Microsoft Access Driver (*.mdb);DBQ=%s";
pszDSN = (char *) CPLMalloc(strlen(pszNewName)+strlen(pszDSNStringTemplate)+100);
snprintf( pszDSN,
strlen(pszNewName)+strlen(pszDSNStringTemplate)+100,
pszDSNStringTemplate, pszNewName );
}
/* -------------------------------------------------------------------- */
/* Initialize based on the DSN. */
/* -------------------------------------------------------------------- */
CPLDebug( "Walk", "EstablishSession(%s)", pszDSN );
if( !oSession.EstablishSession( pszDSN, NULL, NULL ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to initialize ODBC connection to DSN for %s,\n"
"%s", pszDSN, oSession.GetLastError() );
CPLFree( pszDSN );
return FALSE;
}
CPLFree( pszDSN );
pszName = CPLStrdup( pszNewName );
/* -------------------------------------------------------------------- */
/* Collect list of layers and their attributes. */
/* -------------------------------------------------------------------- */
std::vector<char **> apapszGeomColumns;
CPLODBCStatement oStmt( &oSession );
oStmt.Append( "SELECT LayerID, LayerName, minE, maxE, minN, maxN, Memo FROM WalkLayers" );
if( !oStmt.ExecuteSQL() )
{
CPLDebug( "Walk",
"SELECT on WalkLayers fails, perhaps not a walk database?\n%s",
oSession.GetLastError() );
return FALSE;
}
while( oStmt.Fetch() )
{
int i, iNew = static_cast<int>(apapszGeomColumns.size());
char **papszRecord = NULL;
for( i = 1; i < 7; i++ )
papszRecord = CSLAddString( papszRecord, oStmt.GetColData(i) ); //Add LayerName, Extent and Memo
apapszGeomColumns.resize(iNew+1);
apapszGeomColumns[iNew] = papszRecord;
}
/* -------------------------------------------------------------------- */
/* Create a layer for each spatial table. */
/* -------------------------------------------------------------------- */
papoLayers = (OGRWalkLayer **) CPLCalloc(apapszGeomColumns.size(),
sizeof( void * ));
for( unsigned int iTable = 0; iTable < apapszGeomColumns.size(); iTable++ )
{
char **papszRecord = apapszGeomColumns[iTable];
OGRWalkTableLayer *poLayer = new OGRWalkTableLayer( this );
if( poLayer->Initialize( papszRecord[0], // LayerName
"Geometry", // Geometry Column Name
CPLAtof(papszRecord[1]), // Extent MinE
CPLAtof(papszRecord[2]), // Extent MaxE
CPLAtof(papszRecord[3]), // Extent MinN
CPLAtof(papszRecord[4]), // Extent MaxN
papszRecord[5]) // Memo for SpatialRef
!= CE_None )
{
delete poLayer;
}
else
papoLayers[nLayers++] = poLayer;
CSLDestroy( papszRecord );
}
return TRUE;
}
OGRLayer *
OGRIngresDataSource::CreateLayer( const char * pszLayerNameIn,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
const char *pszGeometryType = NULL;
const char *pszGeomColumnName;
const char *pszExpectedFIDName;
char *pszLayerName;
int nDimension = 3; // Ingres only supports 2d currently
if( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) )
pszLayerName = LaunderName( pszLayerNameIn );
else
pszLayerName = CPLStrdup( pszLayerNameIn );
if( wkbFlatten(eType) == eType )
nDimension = 2;
CPLDebug("INGRES","Creating layer %s.", pszLayerName);
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszLayerName,papoLayers[iLayer]->GetLayerDefn()->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( iLayer );
}
else
{
CPLFree( pszLayerName );
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszLayerName );
return NULL;
}
}
}
/* -------------------------------------------------------------------- */
/* What do we want to use for geometry and FID columns? */
/* -------------------------------------------------------------------- */
pszGeomColumnName = CSLFetchNameValue( papszOptions, "GEOMETRY_NAME" );
if (!pszGeomColumnName)
pszGeomColumnName="SHAPE";
pszExpectedFIDName = CSLFetchNameValue( papszOptions, "INGRES_FID" );
if (!pszExpectedFIDName)
pszExpectedFIDName="OGR_FID";
CPLDebug("INGRES","Geometry Column Name %s.", pszGeomColumnName);
CPLDebug("INGRES","FID Column Name %s.", pszExpectedFIDName);
/* -------------------------------------------------------------------- */
/* What sort of geometry column do we want to create? */
/* -------------------------------------------------------------------- */
pszGeometryType = CSLFetchNameValue( papszOptions, "GEOMETRY_TYPE" );
if( pszGeometryType != NULL )
/* user selected type */;
else if( wkbFlatten(eType) == wkbPoint )
pszGeometryType = "POINT";
else if( wkbFlatten(eType) == wkbLineString)
{
if( IsNewIngres() )
{
pszGeometryType = "LINESTRING";
}
else
{
pszGeometryType = "LONG LINE";
}
}
else if( wkbFlatten(eType) == wkbPolygon )
{
if( IsNewIngres() )
{
pszGeometryType = "POLYGON";
}
else
{
pszGeometryType = "LONG POLYGON";
}
}
else if( wkbFlatten(eType) == wkbMultiPolygon )
{
if( IsNewIngres() )
pszGeometryType = "MULTIPOLYGON";
}
else if( wkbFlatten(eType) == wkbMultiLineString )
{
if( IsNewIngres() )
pszGeometryType = "MULTILINESTRING";
}
else if( wkbFlatten(eType) == wkbMultiPoint )
{
if( IsNewIngres() )
pszGeometryType = "MULTIPOINT";
}
else if( wkbFlatten(eType) == wkbGeometryCollection )
{
if( IsNewIngres() )
pszGeometryType = "GEOMETRYCOLLECTION";
}
else if( wkbFlatten(eType) == wkbUnknown )
{
if( IsNewIngres() )
// this is also used as the generic geometry type.
pszGeometryType = "GEOMETRYCOLLECTION";
}
/* -------------------------------------------------------------------- */
/* Try to get the SRS Id of this spatial reference system, */
/* adding tot the srs table if needed. */
/* -------------------------------------------------------------------- */
int nSRSId = -1;
if( poSRS != NULL && IsNewIngres() == TRUE )
nSRSId = FetchSRSId( poSRS );
/* -------------------------------------------------------------------- */
/* Form table creation command. */
/* -------------------------------------------------------------------- */
CPLString osCommand;
if( pszGeometryType == NULL )
{
osCommand.Printf( "CREATE TABLE %s ( "
" %s INTEGER )",
pszLayerName, pszExpectedFIDName );
}
else
{
if(nSRSId != -1)
{
osCommand.Printf( "CREATE TABLE %s ("
" %s INTEGER NOT NULL PRIMARY KEY GENERATED BY DEFAULT AS seq_%s IDENTITY (START WITH 1 INCREMENT BY 1),"
" %s %s SRID %d ) ",
pszLayerName,
pszExpectedFIDName,
pszLayerName,
pszGeomColumnName,
pszGeometryType,
nSRSId);
}
else
{
osCommand.Printf( "CREATE TABLE %s ("
" %s INTEGER NOT NULL PRIMARY KEY GENERATED BY DEFAULT AS seq_%s IDENTITY (START WITH 1 INCREMENT BY 1),"
" %s %s )",
pszLayerName,
pszExpectedFIDName,
pszLayerName,
pszGeomColumnName,
pszGeometryType);
}
}
/* -------------------------------------------------------------------- */
/* Execute the create table command. */
/* -------------------------------------------------------------------- */
{
OGRIngresStatement oStmt( hConn );
if( !oStmt.ExecuteSQL( osCommand ) )
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRIngresTableLayer *poLayer;
OGRErr eErr;
poLayer = new OGRIngresTableLayer( this, pszLayerName, TRUE, nSRSId );
eErr = poLayer->Initialize(pszLayerName);
if (eErr == OGRERR_FAILURE)
{
delete poLayer;
return NULL;
}
poLayer->SetLaunderFlag( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) );
poLayer->SetPrecisionFlag( CSLFetchBoolean(papszOptions,"PRECISION",TRUE));
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGRIngresLayer **)
CPLRealloc( papoLayers, sizeof(OGRIngresLayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
CPLFree( pszLayerName );
return poLayer;
}
int OGRPGeoDataSource::Open( const char * pszNewName, int bUpdate,
CPL_UNUSED int bTestOpen )
{
CPLAssert( nLayers == 0 );
/* -------------------------------------------------------------------- */
/* If this is the name of an MDB file, then construct the */
/* appropriate connection string. Otherwise clip of PGEO: to */
/* get the DSN. */
/* */
/* -------------------------------------------------------------------- */
char *pszDSN;
const char* pszOptionName = "";
const char* pszDSNStringTemplate = NULL;
if( EQUALN(pszNewName,"PGEO:",5) )
pszDSN = CPLStrdup( pszNewName + 5 );
else
{
pszOptionName = "PGEO_DRIVER_TEMPLATE";
pszDSNStringTemplate = CPLGetConfigOption( pszOptionName, NULL );
if( pszDSNStringTemplate == NULL )
{
pszOptionName = "";
pszDSNStringTemplate = "DRIVER=Microsoft Access Driver (*.mdb);DBQ=%s";
}
if (!CheckDSNStringTemplate(pszDSNStringTemplate))
{
CPLError( CE_Failure, CPLE_AppDefined,
"Illegal value for PGEO_DRIVER_TEMPLATE option");
return FALSE;
}
pszDSN = (char *) CPLMalloc(strlen(pszNewName)+strlen(pszDSNStringTemplate)+100);
sprintf( pszDSN, pszDSNStringTemplate, pszNewName );
}
/* -------------------------------------------------------------------- */
/* Initialize based on the DSN. */
/* -------------------------------------------------------------------- */
CPLDebug( "PGeo", "EstablishSession(%s)", pszDSN );
if( !oSession.EstablishSession( pszDSN, NULL, NULL ) )
{
int bError = TRUE;
if( !EQUALN(pszNewName,"PGEO:",5) )
{
// Trying with another template (#5594)
pszDSNStringTemplate = "DRIVER=Microsoft Access Driver (*.mdb, *.accdb);DBQ=%s";
CPLFree( pszDSN );
pszDSN = (char *) CPLMalloc(strlen(pszNewName)+strlen(pszDSNStringTemplate)+100);
sprintf( pszDSN, pszDSNStringTemplate, pszNewName );
CPLDebug( "PGeo", "EstablishSession(%s)", pszDSN );
if( oSession.EstablishSession( pszDSN, NULL, NULL ) )
{
bError = FALSE;
}
}
if( bError )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to initialize ODBC connection to DSN for %s,\n"
"%s", pszDSN, oSession.GetLastError() );
CPLFree( pszDSN );
return FALSE;
}
}
CPLFree( pszDSN );
pszName = CPLStrdup( pszNewName );
bDSUpdate = bUpdate;
/* -------------------------------------------------------------------- */
/* Collect list of tables and their supporting info from */
/* GDB_GeomColumns. */
/* -------------------------------------------------------------------- */
std::vector<char **> apapszGeomColumns;
CPLODBCStatement oStmt( &oSession );
oStmt.Append( "SELECT TableName, FieldName, ShapeType, ExtentLeft, ExtentRight, ExtentBottom, ExtentTop, SRID, HasZ FROM GDB_GeomColumns" );
if( !oStmt.ExecuteSQL() )
{
CPLDebug( "PGEO",
"SELECT on GDB_GeomColumns fails, perhaps not a personal geodatabase?\n%s",
oSession.GetLastError() );
return FALSE;
}
while( oStmt.Fetch() )
{
int i, iNew = apapszGeomColumns.size();
char **papszRecord = NULL;
for( i = 0; i < 9; i++ )
papszRecord = CSLAddString( papszRecord,
oStmt.GetColData(i) );
apapszGeomColumns.resize(iNew+1);
apapszGeomColumns[iNew] = papszRecord;
}
/* -------------------------------------------------------------------- */
/* Create a layer for each spatial table. */
/* -------------------------------------------------------------------- */
unsigned int iTable;
papoLayers = (OGRPGeoLayer **) CPLCalloc(apapszGeomColumns.size(),
sizeof(void*));
for( iTable = 0; iTable < apapszGeomColumns.size(); iTable++ )
{
char **papszRecord = apapszGeomColumns[iTable];
OGRPGeoTableLayer *poLayer;
poLayer = new OGRPGeoTableLayer( this );
if( poLayer->Initialize( papszRecord[0], // TableName
papszRecord[1], // FieldName
atoi(papszRecord[2]), // ShapeType
CPLAtof(papszRecord[3]), // ExtentLeft
CPLAtof(papszRecord[4]), // ExtentRight
CPLAtof(papszRecord[5]), // ExtentBottom
CPLAtof(papszRecord[6]), // ExtentTop
atoi(papszRecord[7]), // SRID
atoi(papszRecord[8])) // HasZ
!= CE_None )
{
delete poLayer;
}
else
papoLayers[nLayers++] = poLayer;
CSLDestroy( papszRecord );
}
return TRUE;
}
int OGRGeomediaDataSource::Open( const char * pszNewName, int bUpdate,
int bTestOpen )
{
CPLAssert( nLayers == 0 );
/* -------------------------------------------------------------------- */
/* If this is the name of an MDB file, then construct the */
/* appropriate connection string. Otherwise clip of GEOMEDIA: to */
/* get the DSN. */
/* */
/* -------------------------------------------------------------------- */
char *pszDSN;
if( EQUALN(pszNewName,"GEOMEDIA:",9) )
pszDSN = CPLStrdup( pszNewName + 9 );
else
{
const char *pszDSNStringTemplate = NULL;
pszDSNStringTemplate = CPLGetConfigOption( "GEOMEDIA_DRIVER_TEMPLATE", "DRIVER=Microsoft Access Driver (*.mdb);DBQ=%s");
if (!CheckDSNStringTemplate(pszDSNStringTemplate))
{
CPLError( CE_Failure, CPLE_AppDefined,
"Illegal value for GEOMEDIA_DRIVER_TEMPLATE option");
return FALSE;
}
pszDSN = (char *) CPLMalloc(strlen(pszNewName)+strlen(pszDSNStringTemplate)+100);
sprintf( pszDSN, pszDSNStringTemplate, pszNewName );
}
/* -------------------------------------------------------------------- */
/* Initialize based on the DSN. */
/* -------------------------------------------------------------------- */
CPLDebug( "Geomedia", "EstablishSession(%s)", pszDSN );
if( !oSession.EstablishSession( pszDSN, NULL, NULL ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to initialize ODBC connection to DSN for %s,\n"
"%s", pszDSN, oSession.GetLastError() );
CPLFree( pszDSN );
return FALSE;
}
CPLFree( pszDSN );
pszName = CPLStrdup( pszNewName );
bDSUpdate = bUpdate;
/* -------------------------------------------------------------------- */
/* Collect list of tables and their supporting info from */
/* GAliasTable. */
/* -------------------------------------------------------------------- */
CPLString osGFeaturesTable = GetTableNameFromType("INGRFeatures");
if (osGFeaturesTable.size() == 0)
return FALSE;
CPLString osGeometryProperties = GetTableNameFromType("INGRGeometryProperties");
CPLString osGCoordSystemTable = GetTableNameFromType("GCoordSystemTable");
std::vector<char **> apapszGeomColumns;
{
CPLODBCStatement oStmt( &oSession );
oStmt.Appendf( "SELECT FeatureName, PrimaryGeometryFieldName FROM %s", osGFeaturesTable.c_str() );
if( !oStmt.ExecuteSQL() )
{
CPLDebug( "GEOMEDIA",
"SELECT on %s fails, perhaps not a geomedia geodatabase?\n%s",
osGFeaturesTable.c_str(),
oSession.GetLastError() );
return FALSE;
}
while( oStmt.Fetch() )
{
int i, iNew = apapszGeomColumns.size();
char **papszRecord = NULL;
for( i = 0; i < 2; i++ )
papszRecord = CSLAddString( papszRecord,
oStmt.GetColData(i) );
apapszGeomColumns.resize(iNew+1);
apapszGeomColumns[iNew] = papszRecord;
}
}
std::vector<OGRSpatialReference*> apoSRS;
if (osGeometryProperties.size() != 0 && osGCoordSystemTable.size() != 0)
{
std::vector<CPLString> aosGUID;
{
CPLODBCStatement oStmt( &oSession );
oStmt.Appendf( "SELECT GCoordSystemGUID FROM %s", osGeometryProperties.c_str() );
if( !oStmt.ExecuteSQL() )
{
CPLDebug( "GEOMEDIA",
"SELECT on %s fails, perhaps not a geomedia geodatabase?\n%s",
osGeometryProperties.c_str(),
oSession.GetLastError() );
return FALSE;
}
while( oStmt.Fetch() )
{
aosGUID.push_back(oStmt.GetColData(0));
}
if (apapszGeomColumns.size() != aosGUID.size())
{
CPLDebug( "GEOMEDIA", "%s and %s don't have the same size",
osGFeaturesTable.c_str(), osGeometryProperties.c_str() );
return FALSE;
}
}
int i;
for(i=0; i<(int)aosGUID.size();i++)
{
apoSRS.push_back(GetGeomediaSRS(osGCoordSystemTable, aosGUID[i]));
}
}
/* -------------------------------------------------------------------- */
/* Create a layer for each spatial table. */
/* -------------------------------------------------------------------- */
unsigned int iTable;
papoLayers = (OGRGeomediaLayer **) CPLCalloc(apapszGeomColumns.size(),
sizeof(void*));
for( iTable = 0; iTable < apapszGeomColumns.size(); iTable++ )
{
char **papszRecord = apapszGeomColumns[iTable];
OGRGeomediaTableLayer *poLayer;
poLayer = new OGRGeomediaTableLayer( this );
if( poLayer->Initialize( papszRecord[0], papszRecord[1], (apoSRS.size()) ? apoSRS[iTable] : NULL )
!= CE_None )
{
delete poLayer;
}
else
{
papoLayers[nLayers++] = poLayer;
}
CSLDestroy(papszRecord);
}
return TRUE;
}
OGRErr OGRMSSQLSpatialTableLayer::SetFeature( OGRFeature *poFeature )
{
OGRErr eErr = OGRERR_FAILURE;
GetLayerDefn();
if( NULL == poFeature )
{
CPLError( CE_Failure, CPLE_AppDefined,
"NULL pointer to OGRFeature passed to SetFeature()." );
return eErr;
}
if( poFeature->GetFID() == OGRNullFID )
{
CPLError( CE_Failure, CPLE_AppDefined,
"FID required on features given to SetFeature()." );
return eErr;
}
if( !pszFIDColumn )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to update features in tables without\n"
"a recognised FID column.");
return eErr;
}
ClearStatement();
/* -------------------------------------------------------------------- */
/* Form the UPDATE command. */
/* -------------------------------------------------------------------- */
CPLODBCStatement oStmt( poDS->GetSession() );
oStmt.Appendf( "UPDATE [%s].[%s] SET ", pszSchemaName, pszTableName);
OGRMSSQLGeometryValidator oValidator(poFeature->GetGeometryRef());
OGRGeometry *poGeom = oValidator.GetValidGeometryRef();
if (poFeature->GetGeometryRef() != poGeom)
{
CPLError( CE_Warning, CPLE_NotSupported,
"Geometry with FID = %ld has been modified.", poFeature->GetFID() );
}
int bNeedComma = FALSE;
if(pszGeomColumn != NULL)
{
char *pszWKT = NULL;
if (poGeom != NULL)
poGeom->exportToWkt( &pszWKT );
oStmt.Appendf( "[%s] = ", pszGeomColumn );
if( pszWKT != NULL && (nGeomColumnType == MSSQLCOLTYPE_GEOMETRY
|| nGeomColumnType == MSSQLCOLTYPE_GEOGRAPHY))
{
if (nGeomColumnType == MSSQLCOLTYPE_GEOGRAPHY)
{
oStmt.Append( "geography::STGeomFromText(" );
OGRMSSQLAppendEscaped(&oStmt, pszWKT);
oStmt.Appendf(",%d)", nSRSId );
}
else
{
oStmt.Append( "geometry::STGeomFromText(" );
OGRMSSQLAppendEscaped(&oStmt, pszWKT);
oStmt.Appendf(",%d).MakeValid()", nSRSId );
}
}
else
oStmt.Append( "null" );
bNeedComma = TRUE;
CPLFree(pszWKT);
}
int nFieldCount = poFeatureDefn->GetFieldCount();
int i;
for( i = 0; i < nFieldCount; i++ )
{
if (bNeedComma)
oStmt.Appendf( ", [%s] = ", poFeatureDefn->GetFieldDefn(i)->GetNameRef() );
else
{
oStmt.Appendf( "[%s] = ", poFeatureDefn->GetFieldDefn(i)->GetNameRef() );
bNeedComma = TRUE;
}
if( !poFeature->IsFieldSet( i ) )
oStmt.Append( "null" );
else
AppendFieldValue(&oStmt, poFeature, i);
}
/* Add the WHERE clause */
oStmt.Appendf( " WHERE [%s] = %ld" , pszFIDColumn, poFeature->GetFID());
/* -------------------------------------------------------------------- */
/* Execute the update. */
/* -------------------------------------------------------------------- */
if( !oStmt.ExecuteSQL() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error updating feature with FID:%ld, %s", poFeature->GetFID(),
poDS->GetSession()->GetLastError() );
return OGRERR_FAILURE;
}
return OGRERR_NONE;
}
int OGRIngresDataSource::Open( const char *pszFullName,
char **papszOptions, int bUpdate )
{
CPLAssert( nLayers == 0 );
/* -------------------------------------------------------------------- */
/* Verify we have a dbname, this parameter is required. */
/* -------------------------------------------------------------------- */
const char *pszDBName = CSLFetchNameValue(papszOptions,"dbname");
if( pszDBName == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"No DBNAME item provided in INGRES datasource name." );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Do we have a table list? */
/* -------------------------------------------------------------------- */
char **papszTableNames = NULL;
const char *pszTables = CSLFetchNameValue(papszOptions,"tables");
if( pszTables != NULL )
papszTableNames = CSLTokenizeStringComplex(pszTables,"/",TRUE,FALSE);
/* -------------------------------------------------------------------- */
/* Initialize the Ingres API. Should we only do this once per */
/* program run? Really we should also try to terminate the api */
/* on program exit. */
/* -------------------------------------------------------------------- */
IIAPI_INITPARM initParm;
initParm.in_version = IIAPI_VERSION_1;
initParm.in_timeout = -1;
IIapi_initialize( &initParm );
/* -------------------------------------------------------------------- */
/* Try to connect to the database. */
/* -------------------------------------------------------------------- */
IIAPI_CONNPARM connParm;
IIAPI_WAITPARM waitParm = { -1 };
memset( &connParm, 0, sizeof(connParm) );
connParm.co_genParm.gp_callback = NULL;
connParm.co_genParm.gp_closure = NULL;
connParm.co_target = (II_CHAR *) pszDBName;
connParm.co_connHandle = NULL;
connParm.co_tranHandle = NULL;
connParm.co_username =
(II_CHAR*) CSLFetchNameValue(papszOptions,"username");
connParm.co_password =
(II_CHAR*)CSLFetchNameValue(papszOptions,"password");
connParm.co_timeout = -1;
if( CSLFetchNameValue(papszOptions,"timeout") != NULL )
connParm.co_timeout = atoi(CSLFetchNameValue(papszOptions,"timeout"));
IIapi_connect( &connParm );
while( connParm.co_genParm.gp_completed == FALSE )
IIapi_wait( &waitParm );
hConn = connParm.co_connHandle;
if( connParm.co_genParm.gp_status != IIAPI_ST_SUCCESS
|| hConn == NULL )
{
OGRIngresStatement::ReportError( &(connParm.co_genParm),
"Failed to connect to Ingres database." );
return FALSE;
}
pszName = CPLStrdup( pszFullName );
bDSUpdate = bUpdate;
// Check for new or old Ingres spatial library
{
OGRIngresStatement oStmt( hConn );
if( oStmt.ExecuteSQL("SELECT COUNT(*) FROM iicolumns WHERE table_name = 'iiattribute' AND column_name = 'attgeomtype'" ) )
{
char **papszFields;
while( (papszFields = oStmt.GetRow()) )
{
CPLString osCount = papszFields[0];
if( osCount[0] == '0' )
{
bNewIngres = FALSE;
}
else
{
bNewIngres = TRUE;
}
}
}
}
/* -------------------------------------------------------------------- */
/* Get a list of available tables. */
/* -------------------------------------------------------------------- */
if( papszTableNames == NULL )
{
OGRIngresStatement oStmt( hConn );
if( oStmt.ExecuteSQL( "select table_name from iitables where system_use = 'U' and table_name not like 'iietab_%'" ) )
{
char **papszFields;
while( (papszFields = oStmt.GetRow()) )
{
CPLString osTableName = papszFields[0];
osTableName.Trim();
papszTableNames = CSLAddString( papszTableNames,
osTableName );
}
}
}
/* -------------------------------------------------------------------- */
/* Get the schema of the available tables. */
/* -------------------------------------------------------------------- */
int iRecord;
for( iRecord = 0;
papszTableNames != NULL && papszTableNames[iRecord] != NULL;
iRecord++ )
{
OpenTable( papszTableNames[iRecord], bUpdate );
}
CSLDestroy( papszTableNames );
return TRUE;
}
