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; }