MyOGRHandler(const std::string& filename) :
m_data_source(NULL),
m_layer_point(NULL),
m_filter(true),
m_tohstore() {
OGRRegisterAll();
OGRSFDriver* driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName("PostgreSQL");
if (driver == NULL) {
std::cerr << "PostgreSQL OGR driver not available.\n";
exit(1);
}
// using COPY is much faster than INSERT
CPLSetConfigOption("PG_USE_COPY", "YES");
const char* options[] = { NULL };
m_data_source = driver->CreateDataSource(filename.c_str(), const_cast<char**>(options));
if (m_data_source == NULL) {
std::cerr << "Database open failed.\n";
exit(1);
}
// OGR can't create a table with hstore column, so we do it ourselves here
OGRLayer* dummy = m_data_source->ExecuteSQL("CREATE TABLE nodes (id VARCHAR, tags hstore);", NULL, NULL);
if (dummy) {
m_data_source->ReleaseResultSet(dummy);
}
dummy = m_data_source->ExecuteSQL("SELECT AddGeometryColumn('nodes', 'geom', 4326, 'POINT', 2);", NULL, NULL);
if (dummy) {
m_data_source->ReleaseResultSet(dummy);
}
m_layer_point = m_data_source->GetLayerByName("nodes");
if (!m_layer_point) {
std::cerr << "Something went wrong setting up the 'nodes' layer.\n";
exit(1);
}
// using transactions makes this much faster than without
m_layer_point->StartTransaction();
m_filter.add(false, "created_by");
m_filter.add(false, "odbl");
}
JNIEXPORT void JNICALL Java_es_gva_cit_jogr_OGRDataSource_releaseResultSetNat
(JNIEnv *env, jobject obj, jlong cPtr, jlong ptr_poResultsSet){
OGRDataSource *ds = (OGRDataSource *) 0 ;
OGRLayer *layer = (OGRLayer *) 0 ;
ds = *(OGRDataSource **)&cPtr;
layer = *(OGRLayer **)&ptr_poResultsSet;
if(ds!=NULL ){
ds->ReleaseResultSet(layer);
}
}
int main( int nArgc, char ** papszArgv )
{
const char *pszWHERE = NULL;
const char *pszDataSource = NULL;
char **papszLayers = NULL;
OGRGeometry *poSpatialFilter = NULL;
int nRepeatCount = 1, bAllLayers = FALSE;
const char *pszSQLStatement = NULL;
const char *pszDialect = NULL;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(papszArgv[0]))
exit(1);
/* -------------------------------------------------------------------- */
/* Register format(s). */
/* -------------------------------------------------------------------- */
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor( nArgc, &papszArgv, 0 );
if( nArgc < 1 )
exit( -nArgc );
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(papszArgv[iArg],"-ro") )
bReadOnly = TRUE;
else if( EQUAL(papszArgv[iArg],"-q") || EQUAL(papszArgv[iArg],"-quiet"))
bVerbose = FALSE;
else if( EQUAL(papszArgv[iArg],"-fid") && iArg < nArgc-1 )
nFetchFID = atoi(papszArgv[++iArg]);
else if( EQUAL(papszArgv[iArg],"-spat")
&& papszArgv[iArg+1] != NULL
&& papszArgv[iArg+2] != NULL
&& papszArgv[iArg+3] != NULL
&& papszArgv[iArg+4] != NULL )
{
OGRLinearRing oRing;
oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+2]) );
oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+4]) );
oRing.addPoint( atof(papszArgv[iArg+3]), atof(papszArgv[iArg+4]) );
oRing.addPoint( atof(papszArgv[iArg+3]), atof(papszArgv[iArg+2]) );
oRing.addPoint( atof(papszArgv[iArg+1]), atof(papszArgv[iArg+2]) );
poSpatialFilter = new OGRPolygon();
((OGRPolygon *) poSpatialFilter)->addRing( &oRing );
iArg += 4;
}
else if( EQUAL(papszArgv[iArg],"-where") && papszArgv[iArg+1] != NULL )
{
pszWHERE = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-sql") && papszArgv[iArg+1] != NULL )
{
pszSQLStatement = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-dialect")
&& papszArgv[iArg+1] != NULL )
{
pszDialect = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-rc") && papszArgv[iArg+1] != NULL )
{
nRepeatCount = atoi(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg],"-al") )
{
bAllLayers = TRUE;
}
else if( EQUAL(papszArgv[iArg],"-so")
|| EQUAL(papszArgv[iArg],"-summary") )
{
bSummaryOnly = TRUE;
}
else if( EQUALN(papszArgv[iArg],"-fields=", strlen("-fields=")) )
{
char* pszTemp = (char*)CPLMalloc(32 + strlen(papszArgv[iArg]));
sprintf(pszTemp, "DISPLAY_FIELDS=%s", papszArgv[iArg] + strlen("-fields="));
papszOptions = CSLAddString(papszOptions, pszTemp);
CPLFree(pszTemp);
}
else if( EQUALN(papszArgv[iArg],"-geom=", strlen("-geom=")) )
{
char* pszTemp = (char*)CPLMalloc(32 + strlen(papszArgv[iArg]));
sprintf(pszTemp, "DISPLAY_GEOMETRY=%s", papszArgv[iArg] + strlen("-geom="));
papszOptions = CSLAddString(papszOptions, pszTemp);
CPLFree(pszTemp);
}
else if( papszArgv[iArg][0] == '-' )
{
Usage();
}
else if( pszDataSource == NULL )
pszDataSource = papszArgv[iArg];
else
{
papszLayers = CSLAddString( papszLayers, papszArgv[iArg] );
bAllLayers = FALSE;
}
}
if( pszDataSource == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open data source. */
/* -------------------------------------------------------------------- */
OGRDataSource *poDS = NULL;
OGRSFDriver *poDriver = NULL;
poDS = OGRSFDriverRegistrar::Open( pszDataSource, !bReadOnly, &poDriver );
if( poDS == NULL && !bReadOnly )
{
poDS = OGRSFDriverRegistrar::Open( pszDataSource, FALSE, &poDriver );
if( poDS != NULL && bVerbose )
{
printf( "Had to open data source read-only.\n" );
bReadOnly = TRUE;
}
}
/* -------------------------------------------------------------------- */
/* Report failure */
/* -------------------------------------------------------------------- */
if( poDS == NULL )
{
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
printf( "FAILURE:\n"
"Unable to open datasource `%s' with the following drivers.\n",
pszDataSource );
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
printf( " -> %s\n", poR->GetDriver(iDriver)->GetName() );
}
exit( 1 );
}
CPLAssert( poDriver != NULL);
/* -------------------------------------------------------------------- */
/* Some information messages. */
/* -------------------------------------------------------------------- */
if( bVerbose )
printf( "INFO: Open of `%s'\n"
" using driver `%s' successful.\n",
pszDataSource, poDriver->GetName() );
if( bVerbose && !EQUAL(pszDataSource,poDS->GetName()) )
{
printf( "INFO: Internal data source name `%s'\n"
" different from user name `%s'.\n",
poDS->GetName(), pszDataSource );
}
/* -------------------------------------------------------------------- */
/* Special case for -sql clause. No source layers required. */
/* -------------------------------------------------------------------- */
if( pszSQLStatement != NULL )
{
OGRLayer *poResultSet = NULL;
nRepeatCount = 0; // skip layer reporting.
if( CSLCount(papszLayers) > 0 )
printf( "layer names ignored in combination with -sql.\n" );
poResultSet = poDS->ExecuteSQL( pszSQLStatement, poSpatialFilter,
pszDialect );
if( poResultSet != NULL )
{
if( pszWHERE != NULL )
poResultSet->SetAttributeFilter( pszWHERE );
ReportOnLayer( poResultSet, NULL, NULL );
poDS->ReleaseResultSet( poResultSet );
}
}
CPLDebug( "OGR", "GetLayerCount() = %d\n", poDS->GetLayerCount() );
for( int iRepeat = 0; iRepeat < nRepeatCount; iRepeat++ )
{
if ( CSLCount(papszLayers) == 0 )
{
/* -------------------------------------------------------------------- */
/* Process each data source layer. */
/* -------------------------------------------------------------------- */
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer );
exit( 1 );
}
if (!bAllLayers)
{
printf( "%d: %s",
iLayer+1,
poLayer->GetLayerDefn()->GetName() );
if( poLayer->GetLayerDefn()->GetGeomType() != wkbUnknown )
printf( " (%s)",
OGRGeometryTypeToName(
poLayer->GetLayerDefn()->GetGeomType() ) );
printf( "\n" );
}
else
{
if( iRepeat != 0 )
poLayer->ResetReading();
ReportOnLayer( poLayer, pszWHERE, poSpatialFilter );
}
}
}
else
{
/* -------------------------------------------------------------------- */
/* Process specified data source layers. */
/* -------------------------------------------------------------------- */
char** papszIter = papszLayers;
for( ; *papszIter != NULL; papszIter++ )
{
OGRLayer *poLayer = poDS->GetLayerByName(*papszIter);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch requested layer %s!\n",
*papszIter );
exit( 1 );
}
if( iRepeat != 0 )
poLayer->ResetReading();
ReportOnLayer( poLayer, pszWHERE, poSpatialFilter );
}
}
}
/* -------------------------------------------------------------------- */
/* Close down. */
/* -------------------------------------------------------------------- */
CSLDestroy( papszArgv );
CSLDestroy( papszLayers );
CSLDestroy( papszOptions );
OGRDataSource::DestroyDataSource( poDS );
if (poSpatialFilter)
OGRGeometryFactory::destroyGeometry( poSpatialFilter );
OGRCleanupAll();
return 0;
}
static OGRGeometryCollection* LoadGeometry( const char* pszDS,
const char* pszSQL,
const char* pszLyr,
const char* pszWhere )
{
OGRDataSource *poDS;
OGRLayer *poLyr;
OGRFeature *poFeat;
OGRGeometryCollection *poGeom = NULL;
poDS = OGRSFDriverRegistrar::Open( pszDS, FALSE );
if ( poDS == NULL )
return NULL;
if ( pszSQL != NULL )
poLyr = poDS->ExecuteSQL( pszSQL, NULL, NULL );
else if ( pszLyr != NULL )
poLyr = poDS->GetLayerByName( pszLyr );
else
poLyr = poDS->GetLayer(0);
if ( poLyr == NULL )
{
fprintf( stderr,
"FAILURE: Failed to identify source layer from datasource.\n" );
OGRDataSource::DestroyDataSource( poDS );
return NULL;
}
if ( pszWhere )
poLyr->SetAttributeFilter( pszWhere );
while ( (poFeat = poLyr->GetNextFeature()) != NULL )
{
OGRGeometry* poSrcGeom = poFeat->GetGeometryRef();
if ( poSrcGeom )
{
OGRwkbGeometryType eType =
wkbFlatten( poSrcGeom->getGeometryType() );
if ( poGeom == NULL )
poGeom = new OGRMultiPolygon();
if ( eType == wkbPolygon )
poGeom->addGeometry( poSrcGeom );
else if ( eType == wkbMultiPolygon )
{
int iGeom;
int nGeomCount =
((OGRMultiPolygon *)poSrcGeom)->getNumGeometries();
for ( iGeom = 0; iGeom < nGeomCount; iGeom++ )
{
poGeom->addGeometry(
((OGRMultiPolygon *)poSrcGeom)->getGeometryRef(iGeom) );
}
}
else
{
fprintf( stderr, "FAILURE: Geometry not of polygon type.\n" );
OGRGeometryFactory::destroyGeometry( poGeom );
OGRFeature::DestroyFeature( poFeat );
if ( pszSQL != NULL )
poDS->ReleaseResultSet( poLyr );
OGRDataSource::DestroyDataSource( poDS );
return NULL;
}
}
OGRFeature::DestroyFeature( poFeat );
}
if( pszSQL != NULL )
poDS->ReleaseResultSet( poLyr );
OGRDataSource::DestroyDataSource( poDS );
return poGeom;
}
void OGRDataSourceWithTransaction::ReleaseResultSet( OGRLayer * poResultsSet )
{
if( !m_poBaseDataSource ) return;
m_oSetExecuteSQLLayers.erase(poResultsSet);
m_poBaseDataSource->ReleaseResultSet(poResultsSet);
}
int main( int nArgc, char ** papszArgv )
{
const char *pszDataSource = NULL;
char** papszLayers = NULL;
const char *pszSQLStatement = NULL;
int bRet = TRUE;
/* Must process OGR_SKIP before OGRRegisterAll(), but we can't call */
/* OGRGeneralCmdLineProcessor before it needs the drivers to be registered */
/* for the --format or --formats options */
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--config") && iArg + 2 < nArgc &&
EQUAL(papszArgv[iArg+1], "OGR_SKIP") )
{
CPLSetConfigOption(papszArgv[iArg+1], papszArgv[iArg+2]);
break;
}
}
/* -------------------------------------------------------------------- */
/* Register format(s). */
/* -------------------------------------------------------------------- */
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor( nArgc, &papszArgv, 0 );
if( nArgc < 1 )
exit( -nArgc );
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(papszArgv[iArg],"-ro") )
bReadOnly = TRUE;
else if( EQUAL(papszArgv[iArg],"-q") || EQUAL(papszArgv[iArg],"-quiet"))
bVerbose = FALSE;
else if( EQUAL(papszArgv[iArg],"-sql") && iArg + 1 < nArgc)
pszSQLStatement = papszArgv[++iArg];
else if( papszArgv[iArg][0] == '-' )
{
Usage();
}
else if (pszDataSource == NULL)
pszDataSource = papszArgv[iArg];
else
papszLayers = CSLAddString(papszLayers, papszArgv[iArg]);
}
if( pszDataSource == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open data source. */
/* -------------------------------------------------------------------- */
OGRDataSource *poDS;
OGRSFDriver *poDriver;
poDS = OGRSFDriverRegistrar::Open( pszDataSource, !bReadOnly, &poDriver );
if( poDS == NULL && !bReadOnly )
{
poDS = OGRSFDriverRegistrar::Open( pszDataSource, FALSE, &poDriver );
if( poDS != NULL && bVerbose )
{
printf( "Had to open data source read-only.\n" );
bReadOnly = TRUE;
}
}
/* -------------------------------------------------------------------- */
/* Report failure */
/* -------------------------------------------------------------------- */
if( poDS == NULL )
{
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
printf( "FAILURE:\n"
"Unable to open datasource `%s' with the following drivers.\n",
pszDataSource );
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
printf( " -> %s\n", poR->GetDriver(iDriver)->GetName() );
}
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Some information messages. */
/* -------------------------------------------------------------------- */
if( bVerbose )
printf( "INFO: Open of `%s' using driver `%s' successful.\n",
pszDataSource, poDriver->GetName() );
if( bVerbose && !EQUAL(pszDataSource,poDS->GetName()) )
{
printf( "INFO: Internal data source name `%s'\n"
" different from user name `%s'.\n",
poDS->GetName(), pszDataSource );
}
/* -------------------------------------------------------------------- */
/* Process optionnal SQL request. */
/* -------------------------------------------------------------------- */
if (pszSQLStatement != NULL)
{
OGRLayer *poResultSet = poDS->ExecuteSQL(pszSQLStatement, NULL, NULL);
if (poResultSet == NULL)
exit(1);
printf( "INFO: Testing layer %s.\n",
poResultSet->GetName() );
bRet = TestOGRLayer( poDS, poResultSet, TRUE );
poDS->ReleaseResultSet(poResultSet);
}
/* -------------------------------------------------------------------- */
/* Process each data source layer. */
/* -------------------------------------------------------------------- */
else if (papszLayers == NULL)
{
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer );
exit( 1 );
}
printf( "INFO: Testing layer %s.\n",
poLayer->GetName() );
bRet &= TestOGRLayer( poDS, poLayer, FALSE );
}
}
else
{
/* -------------------------------------------------------------------- */
/* Or process layers specified by the user */
/* -------------------------------------------------------------------- */
char** papszLayerIter = papszLayers;
while (*papszLayerIter)
{
OGRLayer *poLayer = poDS->GetLayerByName(*papszLayerIter);
if( poLayer == NULL )
{
printf( "FAILURE: Couldn't fetch requested layer %s!\n",
*papszLayerIter );
exit( 1 );
}
printf( "INFO: Testing layer %s.\n",
poLayer->GetName() );
bRet &= TestOGRLayer( poDS, poLayer, FALSE );
papszLayerIter ++;
}
}
/* -------------------------------------------------------------------- */
/* Close down. */
/* -------------------------------------------------------------------- */
OGRDataSource::DestroyDataSource(poDS);
OGRCleanupAll();
CSLDestroy(papszLayers);
CSLDestroy(papszArgv);
#ifdef DBMALLOC
malloc_dump(1);
#endif
return (bRet) ? 0 : 1;
}
