OGRSpatialReference* OGRGeomediaDataSource::GetGeomediaSRS(const char* pszGCoordSystemTable,
const char* pszGCoordSystemGUID)
{
if (pszGCoordSystemTable == NULL || pszGCoordSystemGUID == NULL)
return NULL;
OGRLayer* poGCoordSystemTable = GetLayerByName(pszGCoordSystemTable);
if (poGCoordSystemTable == NULL)
return NULL;
poGCoordSystemTable->ResetReading();
OGRFeature* poFeature;
while((poFeature = poGCoordSystemTable->GetNextFeature()) != NULL)
{
const char* pszCSGUID = poFeature->GetFieldAsString("CSGUID");
if (pszCSGUID && strcmp(pszCSGUID, pszGCoordSystemGUID) == 0)
{
OGRSpatialReference* poSRS = OGRGetGeomediaSRS(poFeature);
delete poFeature;
return poSRS;
}
delete poFeature;
}
return NULL;
}
/*
* ExecuteSQL()
*/
OGRLayer *OGRNGWDataset::ExecuteSQL( const char *pszStatement,
OGRGeometry *poSpatialFilter, const char *pszDialect )
{
// Clean statement string.
CPLString osStatement(pszStatement);
osStatement = osStatement.Trim().replaceAll(" ", " ");
if( STARTS_WITH_CI(osStatement.c_str(), "DELLAYER:") )
{
CPLString osLayerName = osStatement.substr(9);
if( osLayerName.endsWith(";") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 1);
osLayerName.Trim();
}
CPLDebug("NGW", "Delete layer with name %s.", osLayerName.c_str());
for( int iLayer = 0; iLayer < nLayers; ++iLayer )
{
if( EQUAL(papoLayers[iLayer]->GetName(), osLayerName.c_str() ) )
{
DeleteLayer( iLayer );
break;
}
}
return nullptr;
}
if( STARTS_WITH_CI(osStatement.c_str(), "DELETE FROM") )
{
// Get layer name from pszStatement DELETE FROM layer;.
CPLString osLayerName = osStatement.substr(12);
if( osLayerName.endsWith(";") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 1);
osLayerName.Trim();
}
CPLDebug("NGW", "Delete features from layer with name %s.", osLayerName.c_str());
OGRNGWLayer *poLayer = static_cast<OGRNGWLayer*>(GetLayerByName(osLayerName));
if( poLayer )
{
poLayer->DeleteAllFeatures();
}
else
{
CPLError(CE_Failure, CPLE_AppDefined, "Unknown layer : %s",
osLayerName.c_str());
}
return nullptr;
}
return GDALDataset::ExecuteSQL(pszStatement, poSpatialFilter, pszDialect);
}
OGRLayer* OGRTABDataSource::ExecuteSQL( const char *pszStatement,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
char **papszTokens = CSLTokenizeString(pszStatement);
if( CSLCount(papszTokens) == 6 &&
EQUAL(papszTokens[0], "CREATE") &&
EQUAL(papszTokens[1], "INDEX") &&
EQUAL(papszTokens[2], "ON") &&
EQUAL(papszTokens[4], "USING") )
{
IMapInfoFile* poLayer = dynamic_cast<IMapInfoFile*>(
GetLayerByName(papszTokens[3]));
if( poLayer == nullptr )
{
CPLError(CE_Failure, CPLE_AppDefined,
"`%s' failed failed, no such layer as `%s'.",
pszStatement, papszTokens[3]);
CSLDestroy(papszTokens);
return nullptr;
}
int nFieldIdx = poLayer->GetLayerDefn()->GetFieldIndex(papszTokens[5]);
CSLDestroy(papszTokens);
if( nFieldIdx < 0 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"`%s' failed, field not found.",
pszStatement);
return nullptr;
}
poLayer->SetFieldIndexed(nFieldIdx);
return nullptr;
}
CSLDestroy(papszTokens);
return GDALDataset::ExecuteSQL(pszStatement, poSpatialFilter, pszDialect);
}
OGRLayer *
OGRShapeDataSource::ICreateLayer( const char * pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
SHPHandle hSHP;
DBFHandle hDBF;
int nShapeType;
/* To ensure that existing layers are created */
GetLayerCount();
/* -------------------------------------------------------------------- */
/* Check that the layer doesn't already exist. */
/* -------------------------------------------------------------------- */
if (GetLayerByName(pszLayerName) != NULL)
{
CPLError( CE_Failure, CPLE_AppDefined, "Layer '%s' already exists",
pszLayerName);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Verify we are in update mode. */
/* -------------------------------------------------------------------- */
if( !bDSUpdate )
{
CPLError( CE_Failure, CPLE_NoWriteAccess,
"Data source %s opened read-only.\n"
"New layer %s cannot be created.\n",
pszName, pszLayerName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Figure out what type of layer we need. */
/* -------------------------------------------------------------------- */
if( eType == wkbUnknown || eType == wkbLineString )
nShapeType = SHPT_ARC;
else if( eType == wkbPoint )
nShapeType = SHPT_POINT;
else if( eType == wkbPolygon )
nShapeType = SHPT_POLYGON;
else if( eType == wkbMultiPoint )
nShapeType = SHPT_MULTIPOINT;
else if( eType == wkbPoint25D )
nShapeType = SHPT_POINTZ;
else if( eType == wkbLineString25D )
nShapeType = SHPT_ARCZ;
else if( eType == wkbMultiLineString )
nShapeType = SHPT_ARC;
else if( eType == wkbMultiLineString25D )
nShapeType = SHPT_ARCZ;
else if( eType == wkbPolygon25D )
nShapeType = SHPT_POLYGONZ;
else if( eType == wkbMultiPolygon )
nShapeType = SHPT_POLYGON;
else if( eType == wkbMultiPolygon25D )
nShapeType = SHPT_POLYGONZ;
else if( eType == wkbMultiPoint25D )
nShapeType = SHPT_MULTIPOINTZ;
else if( eType == wkbNone )
nShapeType = SHPT_NULL;
else
nShapeType = -1;
/* -------------------------------------------------------------------- */
/* Has the application overridden this with a special creation */
/* option? */
/* -------------------------------------------------------------------- */
const char *pszOverride = CSLFetchNameValue( papszOptions, "SHPT" );
if( pszOverride == NULL )
/* ignore */;
else if( EQUAL(pszOverride,"POINT") )
{
nShapeType = SHPT_POINT;
eType = wkbPoint;
}
else if( EQUAL(pszOverride,"ARC") )
{
nShapeType = SHPT_ARC;
eType = wkbLineString;
}
else if( EQUAL(pszOverride,"POLYGON") )
{
nShapeType = SHPT_POLYGON;
eType = wkbPolygon;
}
else if( EQUAL(pszOverride,"MULTIPOINT") )
{
nShapeType = SHPT_MULTIPOINT;
eType = wkbMultiPoint;
}
else if( EQUAL(pszOverride,"POINTZ") )
{
nShapeType = SHPT_POINTZ;
eType = wkbPoint25D;
}
else if( EQUAL(pszOverride,"ARCZ") )
{
nShapeType = SHPT_ARCZ;
eType = wkbLineString25D;
}
else if( EQUAL(pszOverride,"POLYGONZ") )
{
nShapeType = SHPT_POLYGONZ;
eType = wkbPolygon25D;
}
else if( EQUAL(pszOverride,"MULTIPOINTZ") )
{
nShapeType = SHPT_MULTIPOINTZ;
eType = wkbMultiPoint25D;
}
else if( EQUAL(pszOverride,"NONE") || EQUAL(pszOverride,"NULL") )
{
nShapeType = SHPT_NULL;
eType = wkbNone;
}
else
{
CPLError( CE_Failure, CPLE_NotSupported,
"Unknown SHPT value of `%s' passed to Shapefile layer\n"
"creation. Creation aborted.\n",
pszOverride );
return NULL;
}
if( nShapeType == -1 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Geometry type of `%s' not supported in shapefiles.\n"
"Type can be overridden with a layer creation option\n"
"of SHPT=POINT/ARC/POLYGON/MULTIPOINT/POINTZ/ARCZ/POLYGONZ/MULTIPOINTZ.\n",
OGRGeometryTypeToName(eType) );
return NULL;
}
/* -------------------------------------------------------------------- */
/* What filename do we use, excluding the extension? */
/* -------------------------------------------------------------------- */
char *pszFilenameWithoutExt;
if( bSingleFileDataSource && nLayers == 0 )
{
char *pszPath = CPLStrdup(CPLGetPath(pszName));
char *pszFBasename = CPLStrdup(CPLGetBasename(pszName));
pszFilenameWithoutExt = CPLStrdup(CPLFormFilename(pszPath, pszFBasename, NULL));
CPLFree( pszFBasename );
CPLFree( pszPath );
}
else if( bSingleFileDataSource )
{
/* This is a very weird use case : the user creates/open a datasource */
/* made of a single shapefile 'foo.shp' and wants to add a new layer */
/* to it, 'bar'. So we create a new shapefile 'bar.shp' in the same */
/* directory as 'foo.shp' */
/* So technically, we will not be any longer a single file */
/* datasource ... Ahem ahem */
char *pszPath = CPLStrdup(CPLGetPath(pszName));
pszFilenameWithoutExt = CPLStrdup(CPLFormFilename(pszPath,pszLayerName,NULL));
CPLFree( pszPath );
}
else
pszFilenameWithoutExt = CPLStrdup(CPLFormFilename(pszName,pszLayerName,NULL));
/* -------------------------------------------------------------------- */
/* Create the shapefile. */
/* -------------------------------------------------------------------- */
char *pszFilename;
int b2GBLimit = CSLTestBoolean(CSLFetchNameValueDef( papszOptions, "2GB_LIMIT", "FALSE" ));
if( nShapeType != SHPT_NULL )
{
pszFilename = CPLStrdup(CPLFormFilename( NULL, pszFilenameWithoutExt, "shp" ));
hSHP = SHPCreateLL( pszFilename, nShapeType, (SAHooks*) VSI_SHP_GetHook(b2GBLimit) );
if( hSHP == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open Shapefile `%s'.\n",
pszFilename );
CPLFree( pszFilename );
CPLFree( pszFilenameWithoutExt );
return NULL;
}
SHPSetFastModeReadObject( hSHP, TRUE );
CPLFree( pszFilename );
}
else
hSHP = NULL;
/* -------------------------------------------------------------------- */
/* Has a specific LDID been specified by the caller? */
/* -------------------------------------------------------------------- */
const char *pszLDID = CSLFetchNameValue( papszOptions, "ENCODING" );
/* -------------------------------------------------------------------- */
/* Create a DBF file. */
/* -------------------------------------------------------------------- */
pszFilename = CPLStrdup(CPLFormFilename( NULL, pszFilenameWithoutExt, "dbf" ));
if( pszLDID != NULL )
hDBF = DBFCreateLL( pszFilename, pszLDID, (SAHooks*) VSI_SHP_GetHook(b2GBLimit) );
else
hDBF = DBFCreateLL( pszFilename, "LDID/87",(SAHooks*) VSI_SHP_GetHook(b2GBLimit) );
if( hDBF == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open Shape DBF file `%s'.\n",
pszFilename );
CPLFree( pszFilename );
CPLFree( pszFilenameWithoutExt );
SHPClose(hSHP);
return NULL;
}
CPLFree( pszFilename );
/* -------------------------------------------------------------------- */
/* Create the .prj file, if required. */
/* -------------------------------------------------------------------- */
if( poSRS != NULL )
{
char *pszWKT = NULL;
CPLString osPrjFile = CPLFormFilename( NULL, pszFilenameWithoutExt, "prj");
VSILFILE *fp;
/* the shape layer needs it's own copy */
poSRS = poSRS->Clone();
poSRS->morphToESRI();
if( poSRS->exportToWkt( &pszWKT ) == OGRERR_NONE
&& (fp = VSIFOpenL( osPrjFile, "wt" )) != NULL )
{
VSIFWriteL( pszWKT, strlen(pszWKT), 1, fp );
VSIFCloseL( fp );
}
CPLFree( pszWKT );
poSRS->morphFromESRI();
}
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRShapeLayer *poLayer;
/* OGRShapeLayer constructor expects a filename with an extension (that could be */
/* random actually), otherwise this is going to cause problems with layer */
/* names that have a dot (not speaking about the one before the shp) */
pszFilename = CPLStrdup(CPLFormFilename( NULL, pszFilenameWithoutExt, "shp" ));
poLayer = new OGRShapeLayer( this, pszFilename, hSHP, hDBF, poSRS, TRUE, TRUE,
eType );
CPLFree( pszFilenameWithoutExt );
CPLFree( pszFilename );
poLayer->SetResizeAtClose( CSLFetchBoolean( papszOptions, "RESIZE", FALSE ) );
poLayer->CreateSpatialIndexAtClose( CSLFetchBoolean( papszOptions, "SPATIAL_INDEX", FALSE ) );
poLayer->SetModificationDate(
CSLFetchNameValue( papszOptions, "DBF_DATE_LAST_UPDATE" ) );
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
AddLayer(poLayer);
return poLayer;
}
int ILI1Reader::ReadTable(const char *layername) {
char **tokens = NULL;
const char *firsttok = NULL;
int ret = TRUE;
int warned = FALSE;
int fIndex;
int geomIdx;
// curLayer is NULL if we have more than one
// point geometry column
if(curLayer == NULL) {
OGRFeature *metaFeature = NULL;
metaLayer->ResetReading();
while((metaFeature = metaLayer->GetNextFeature()) != NULL ) {
if(EQUAL(layername, metaFeature->GetFieldAsString(0))) {
const char *geomlayername = metaFeature->GetFieldAsString(2);
curLayer = GetLayerByName(geomlayername);
break;
}
}
}
OGRFeatureDefn *featureDef = curLayer->GetLayerDefn();
OGRFeature *feature = NULL;
// get the geometry index of the current layer
// only if the model is read
if(featureDef->GetFieldCount() != 0) {
OGRFeature *metaFeature = NULL;
metaLayer->ResetReading();
while((metaFeature = metaLayer->GetNextFeature()) != NULL ) {
if(EQUAL(curLayer->GetLayerDefn()->GetName(), metaFeature->GetFieldAsString(2))) {
geomIdx = metaFeature->GetFieldAsInteger(1);
}
}
}
long fpos = VSIFTell(fpItf);
while (ret && (tokens = ReadParseLine()))
{
firsttok = CSLGetField(tokens, 0);
if (EQUAL(firsttok, "OBJE"))
{
//Check for features spread over multiple objects
if (featureDef->GetGeomType() == wkbPolygon)
{
//Multiple polygon rings
feature = curLayer->GetFeatureRef(atol(CSLGetField(tokens, 2)));
}
else if (featureDef->GetGeomType() == wkbGeometryCollection)
{
//AREA lines spread over mutltiple objects
}
else
{
feature = NULL;
}
if (feature == NULL)
{
if (featureDef->GetFieldCount() == 0)
{
CPLDebug( "OGR_ILI", "No field definition found for table: %s", featureDef->GetName() );
//Model not read - use heuristics
for (fIndex=1; fIndex<CSLCount(tokens); fIndex++)
{
char szFieldName[32];
sprintf(szFieldName, "Field%02d", fIndex);
OGRFieldDefn oFieldDefn(szFieldName, OFTString);
featureDef->AddFieldDefn(&oFieldDefn);
}
}
//start new feature
feature = new OGRFeature(featureDef);
int fieldno = 0;
for (fIndex=1; fIndex<CSLCount(tokens) && fieldno < featureDef->GetFieldCount(); fIndex++, fieldno++)
{
if (!EQUAL(tokens[fIndex], "@")) {
//CPLDebug( "READ TABLE OGR_ILI", "Adding Field %d: %s", fieldno, tokens[fIndex]);
feature->SetField(fieldno, tokens[fIndex]);
if (featureDef->GetFieldDefn(fieldno)->GetType() == OFTReal
&& fieldno > 0
&& featureDef->GetFieldDefn(fieldno-1)->GetType() == OFTReal
&& featureDef->GetGeomType() == wkbPoint
/*
// if there is no ili model read,
// we have no chance to detect the
// geometry column!!
*/
&& (fieldno-2) == geomIdx) {
//add Point geometry
OGRPoint *ogrPoint = new OGRPoint(atof(tokens[fIndex-1]), atof(tokens[fIndex]));
feature->SetGeometryDirectly(ogrPoint);
}
}
}
if (!warned && featureDef->GetFieldCount() != CSLCount(tokens)-1 && !(featureDef->GetFieldCount() == CSLCount(tokens) && EQUAL(featureDef->GetFieldDefn(featureDef->GetFieldCount()-1)->GetNameRef(), "ILI_Geometry"))) {
CPLDebug( "OGR_ILI", "Field count doesn't match. %d declared, %d found", featureDef->GetFieldCount(), CSLCount(tokens)-1);
warned = TRUE;
}
if (featureDef->GetGeomType() == wkbPolygon)
feature->SetFID(atol(feature->GetFieldAsString(1)));
else if (feature->GetFieldCount() > 0)
feature->SetFID(atol(feature->GetFieldAsString(0)));
curLayer->AddFeature(feature);
}
}
else if (EQUAL(firsttok, "STPT"))
{
ReadGeom(tokens, featureDef->GetGeomType(), feature);
if (EQUAL(featureDef->GetFieldDefn(featureDef->GetFieldCount()-1)->GetNameRef(), "ILI_Geometry"))
{
AddIliGeom(feature, featureDef->GetFieldCount()-1, fpos); //TODO: append multi-OBJECT geometries
}
}
else if (EQUAL(firsttok, "ELIN"))
{
//empty geom
}
else if (EQUAL(firsttok, "EDGE"))
{
tokens = ReadParseLine(); //STPT
ReadGeom(tokens, wkbMultiLineString, feature);
if (EQUAL(featureDef->GetFieldDefn(featureDef->GetFieldCount()-1)->GetNameRef(), "ILI_Geometry"))
{
AddIliGeom(feature, featureDef->GetFieldCount()-1, fpos);
}
}
else if (EQUAL(firsttok, "PERI"))
{
}
else if (EQUAL(firsttok, "ETAB"))
{
if(HasMultiplePointGeom(layername) > 0) {
OGRFeature *metaFeature = NULL;
metaLayer->ResetReading();
while((metaFeature = metaLayer->GetNextFeature()) != NULL ) {
int pntCln = 1;
if(EQUAL(layername, metaFeature->GetFieldAsString(0)) && !EQUAL(curLayer->GetLayerDefn()->GetName(), metaFeature->GetFieldAsString(2))) {
pntCln++;
OGRILI1Layer *curLayerTmp = GetLayerByName(metaFeature->GetFieldAsString(2));
OGRFeature *tmpFeature = NULL;
int geomIdxTmp = metaFeature->GetFieldAsInteger(1);
curLayer->ResetReading();
while((tmpFeature = curLayer->GetNextFeature()) != NULL ) {
OGRPoint *ogrPoint = new OGRPoint(atof(tmpFeature->GetFieldAsString(geomIdxTmp + pntCln)), atof(tmpFeature->GetFieldAsString(geomIdxTmp + pntCln + 1)));
tmpFeature->SetGeometryDirectly(ogrPoint);
curLayerTmp->AddFeature(tmpFeature);
}
}
}
}
CSLDestroy(tokens);
return TRUE;
}
else
{
CPLDebug( "OGR_ILI", "Unexpected token: %s", firsttok );
}
CSLDestroy(tokens);
fpos = VSIFTell(fpItf);
}
return ret;
}
int ILI1Reader::ReadFeatures() {
char **tokens = NULL;
const char *firsttok = NULL;
const char *pszLine;
char *topic = NULL;
int ret = TRUE;
while (ret && (tokens = ReadParseLine()))
{
firsttok = tokens[0];
if (EQUAL(firsttok, "SCNT"))
{
//read description
do
{
pszLine = CPLReadLine( fpItf );
}
while (pszLine && !EQUALN(pszLine, "////", 4));
ret = (pszLine != NULL);
}
else if (EQUAL(firsttok, "MOTR"))
{
//read model
do
{
pszLine = CPLReadLine( fpItf );
}
while (pszLine && !EQUALN(pszLine, "////", 4));
ret = (pszLine != NULL);
}
else if (EQUAL(firsttok, "MTID"))
{
}
else if (EQUAL(firsttok, "MODL"))
{
}
else if (EQUAL(firsttok, "TOPI"))
{
CPLFree(topic);
topic = CPLStrdup(CSLGetField(tokens, 1));
}
else if (EQUAL(firsttok, "TABL"))
{
CPLDebug( "OGR_ILI", "Reading table '%s'", GetLayerNameString(topic, CSLGetField(tokens, 1)) );
const char *layername = GetLayerNameString(topic, CSLGetField(tokens, 1));
curLayer = GetLayerByName(layername);
int multiple = HasMultiplePointGeom(layername);
// create only a new layer if there is no curLayer AND
// if there are more than one point geometry columns
if (curLayer == NULL && multiple < 1) { //create one
CPLDebug( "OGR_ILI", "No model found, using default field names." );
OGRSpatialReference *poSRSIn = NULL;
int bWriterIn = 0;
OGRwkbGeometryType eReqType = wkbUnknown;
OGRILI1DataSource *poDSIn = NULL;
curLayer = new OGRILI1Layer(GetLayerNameString(topic, CSLGetField(tokens, 1)), poSRSIn, bWriterIn, eReqType, poDSIn);
AddLayer(curLayer);
}
if(curLayer != NULL) {
for (int i=0; i < curLayer->GetLayerDefn()->GetFieldCount(); i++) {
CPLDebug( "OGR_ILI", "Field %d: %s", i, curLayer->GetLayerDefn()->GetFieldDefn(i)->GetNameRef());
}
}
ret = ReadTable(layername);
}
else if (EQUAL(firsttok, "ETOP"))
{
}
else if (EQUAL(firsttok, "EMOD"))
{
}
else if (EQUAL(firsttok, "ENDE"))
{
CSLDestroy(tokens);
CPLFree(topic);
return TRUE;
}
else
{
CPLDebug( "OGR_ILI", "Unexpected token: %s", firsttok );
}
CSLDestroy(tokens);
tokens = NULL;
}
CSLDestroy(tokens);
CPLFree(topic);
return ret;
}
CPLErr GNMGenericNetwork::ChangeBlockState(GNMGFID nFID, bool bIsBlock)
{
if(!m_bIsGraphLoaded && LoadGraph() != CE_None)
{
return CE_Failure;
}
// change block state in layer
OGRLayer* poLayer = GetLayerByName(m_moFeatureFIDMap[nFID]);
if(NULL == poLayer)
{
CPLError( CE_Failure, CPLE_AppDefined, "Failed to get layer '%s'.",
m_moFeatureFIDMap[nFID].c_str() );
return CE_Failure;
}
OGRFeature* poFeature = poLayer->GetFeature(nFID);
if(NULL == poFeature)
{
CPLError( CE_Failure, CPLE_AppDefined, "Failed to get feature '"
GNMGFIDFormat"'.", nFID );
return CE_Failure;
}
if(bIsBlock)
{
poFeature->SetField( GNM_SYSFIELD_BLOCKED, GNM_BLOCK_ALL );
}
else
{
poFeature->SetField( GNM_SYSFIELD_BLOCKED, GNM_BLOCK_NONE );
}
if( poLayer->SetFeature( poFeature ) != OGRERR_NONE )
{
OGRFeature::DestroyFeature( poFeature );
CPLError( CE_Failure, CPLE_AppDefined, "Failed to update feature." );
return CE_Failure;
}
OGRFeature::DestroyFeature( poFeature );
GNMGFID nSrcFID, nTgtFID, nConFID;
// change block state in graph layer
m_poGraphLayer->ResetReading();
while ((poFeature = m_poGraphLayer->GetNextFeature()) != NULL)
{
nSrcFID = poFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_SOURCE);
nTgtFID = poFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_TARGET);
nConFID = poFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_CONNECTOR);
int nBlockState = poFeature->GetFieldAsInteger(GNM_SYSFIELD_BLOCKED);
if(bIsBlock)
{
if(nSrcFID == nFID)
nBlockState |= GNM_BLOCK_SRC;
else if(nTgtFID == nFID)
nBlockState |= GNM_BLOCK_TGT;
else if(nConFID == nFID)
nBlockState |= GNM_BLOCK_CONN;
poFeature->SetField( GNM_SYSFIELD_BLOCKED, nBlockState );
}
else
{
if(nSrcFID == nFID)
nBlockState &= ~GNM_BLOCK_SRC;
else if(nTgtFID == nFID)
nBlockState &= ~GNM_BLOCK_TGT;
else if(nConFID == nFID)
nBlockState &= ~GNM_BLOCK_CONN;
poFeature->SetField( GNM_SYSFIELD_BLOCKED, nBlockState );
}
if( m_poGraphLayer->SetFeature( poFeature ) != OGRERR_NONE )
{
OGRFeature::DestroyFeature( poFeature );
CPLError( CE_Failure, CPLE_AppDefined, "Failed to update feature." );
return CE_Failure;
}
OGRFeature::DestroyFeature( poFeature );
}
// change block state in graph
m_oGraph.ChangeBlockState(nFID, bIsBlock);
return CE_None;
}
OGRLayer* OGROpenFileGDBDataSource::ExecuteSQL( const char *pszSQLCommand,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
/* -------------------------------------------------------------------- */
/* Special case GetLayerDefinition */
/* -------------------------------------------------------------------- */
if (EQUALN(pszSQLCommand, "GetLayerDefinition ", strlen("GetLayerDefinition ")))
{
OGROpenFileGDBLayer* poLayer = (OGROpenFileGDBLayer*)
GetLayerByName(pszSQLCommand + strlen("GetLayerDefinition "));
if (poLayer)
{
OGRLayer* poRet = new OGROpenFileGDBSingleFeatureLayer(
"LayerDefinition", poLayer->GetXMLDefinition().c_str() );
return poRet;
}
else
return NULL;
}
/* -------------------------------------------------------------------- */
/* Special case GetLayerMetadata */
/* -------------------------------------------------------------------- */
if (EQUALN(pszSQLCommand, "GetLayerMetadata ", strlen("GetLayerMetadata ")))
{
OGROpenFileGDBLayer* poLayer = (OGROpenFileGDBLayer*)
GetLayerByName(pszSQLCommand + strlen("GetLayerMetadata "));
if (poLayer)
{
OGRLayer* poRet = new OGROpenFileGDBSingleFeatureLayer(
"LayerMetadata", poLayer->GetXMLDocumentation().c_str() );
return poRet;
}
else
return NULL;
}
/* -------------------------------------------------------------------- */
/* Special case GetLayerAttrIndexUse (only for debugging purposes) */
/* -------------------------------------------------------------------- */
if (EQUALN(pszSQLCommand, "GetLayerAttrIndexUse ", strlen("GetLayerAttrIndexUse ")))
{
OGROpenFileGDBLayer* poLayer = (OGROpenFileGDBLayer*)
GetLayerByName(pszSQLCommand + strlen("GetLayerAttrIndexUse "));
if (poLayer)
{
OGRLayer* poRet = new OGROpenFileGDBSingleFeatureLayer(
"LayerAttrIndexUse", CPLSPrintf("%d", poLayer->GetAttrIndexUse()) );
return poRet;
}
else
return NULL;
}
/* -------------------------------------------------------------------- */
/* Special case GetLayerSpatialIndexState (only for debugging purposes) */
/* -------------------------------------------------------------------- */
if (EQUALN(pszSQLCommand, "GetLayerSpatialIndexState ", strlen("GetLayerSpatialIndexState ")))
{
OGROpenFileGDBLayer* poLayer = (OGROpenFileGDBLayer*)
GetLayerByName(pszSQLCommand + strlen("GetLayerSpatialIndexState "));
if (poLayer)
{
OGRLayer* poRet = new OGROpenFileGDBSingleFeatureLayer(
"LayerSpatialIndexState", CPLSPrintf("%d", poLayer->GetSpatialIndexState()) );
return poRet;
}
else
return NULL;
}
/* -------------------------------------------------------------------- */
/* Special case GetLastSQLUsedOptimizedImplementation (only for debugging purposes) */
/* -------------------------------------------------------------------- */
if (EQUAL(pszSQLCommand, "GetLastSQLUsedOptimizedImplementation"))
{
OGRLayer* poRet = new OGROpenFileGDBSingleFeatureLayer(
"GetLastSQLUsedOptimizedImplementation",
CPLSPrintf("%d", bLastSQLUsedOptimizedImplementation) );
return poRet;
}
bLastSQLUsedOptimizedImplementation = FALSE;
/* -------------------------------------------------------------------- */
/* Special cases for SQL optimizations */
/* -------------------------------------------------------------------- */
if( EQUALN(pszSQLCommand, "SELECT ", strlen("SELECT ")) &&
(pszDialect == NULL || EQUAL(pszDialect, "") || EQUAL(pszDialect, "OGRSQL")) &&
CSLTestBoolean(CPLGetConfigOption("OPENFILEGDB_USE_INDEX", "YES")) )
{
swq_select oSelect;
if( oSelect.preparse(pszSQLCommand) != CE_None )
return NULL;
/* -------------------------------------------------------------------- */
/* MIN/MAX/SUM/AVG/COUNT optimization */
/* -------------------------------------------------------------------- */
if( oSelect.join_count == 0 && oSelect.poOtherSelect == NULL &&
oSelect.table_count == 1 && oSelect.order_specs == 0 &&
oSelect.query_mode != SWQM_DISTINCT_LIST )
{
OGROpenFileGDBLayer* poLayer =
(OGROpenFileGDBLayer*)GetLayerByName( oSelect.table_defs[0].table_name);
if( poLayer )
{
OGRMemLayer* poMemLayer = NULL;
int i;
for(i = 0; i < oSelect.result_columns; i ++ )
{
swq_col_func col_func = oSelect.column_defs[i].col_func;
if( !(col_func == SWQCF_MIN || col_func == SWQCF_MAX ||
col_func == SWQCF_COUNT || col_func == SWQCF_AVG ||
col_func == SWQCF_SUM) )
break;
if( oSelect.column_defs[i].field_name == NULL )
break;
if( oSelect.column_defs[i].distinct_flag )
break;
if( oSelect.column_defs[i].target_type != SWQ_OTHER )
break;
int idx = poLayer->GetLayerDefn()->GetFieldIndex(
oSelect.column_defs[i].field_name);
if( idx < 0 )
break;
OGRFieldDefn* poFieldDefn = poLayer->GetLayerDefn()->GetFieldDefn(idx);
if( col_func == SWQCF_SUM && poFieldDefn->GetType() == OFTDateTime )
break;
int eOutOGRType = -1;
int nCount = 0;
double dfSum = 0.0;
const OGRField* psField = NULL;
OGRField sField;
if( col_func == SWQCF_MIN || col_func == SWQCF_MAX )
{
psField = poLayer->GetMinMaxValue(
poFieldDefn, col_func == SWQCF_MIN, eOutOGRType);
if( eOutOGRType < 0 )
break;
}
else
{
double dfMin = 0.0, dfMax = 0.0;
if( !poLayer->GetMinMaxSumCount(poFieldDefn, dfMin, dfMax,
dfSum, nCount) )
break;
psField = &sField;
if( col_func == SWQCF_AVG )
{
if( nCount == 0 )
{
eOutOGRType = OFTReal;
psField = NULL;
}
else
{
if( poFieldDefn->GetType() == OFTDateTime )
{
eOutOGRType = OFTDateTime;
FileGDBDoubleDateToOGRDate(dfSum / nCount, &sField);
}
else
{
eOutOGRType = OFTReal;
sField.Real = dfSum / nCount;
}
}
}
else if( col_func == SWQCF_COUNT )
{
sField.Integer = nCount;
eOutOGRType = OFTInteger;
}
else
{
sField.Real = dfSum;
eOutOGRType = OFTReal;
}
}
if( poMemLayer == NULL )
{
poMemLayer = new OGRMemLayer("SELECT", NULL, wkbNone);
OGRFeature* poFeature = new OGRFeature(poMemLayer->GetLayerDefn());
poMemLayer->CreateFeature(poFeature);
delete poFeature;
}
const char* pszMinMaxFieldName =
CPLSPrintf( "%s_%s", (col_func == SWQCF_MIN) ? "MIN" :
(col_func == SWQCF_MAX) ? "MAX" :
(col_func == SWQCF_AVG) ? "AVG" :
(col_func == SWQCF_SUM) ? "SUM" :
"COUNT",
oSelect.column_defs[i].field_name);
OGRFieldDefn oFieldDefn(pszMinMaxFieldName,
(OGRFieldType) eOutOGRType);
poMemLayer->CreateField(&oFieldDefn);
if( psField != NULL )
{
OGRFeature* poFeature = poMemLayer->GetFeature(0);
poFeature->SetField(oFieldDefn.GetNameRef(), (OGRField*) psField);
poMemLayer->SetFeature(poFeature);
delete poFeature;
}
}
if( i != oSelect.result_columns )
{
delete poMemLayer;
}
else
{
CPLDebug("OpenFileGDB",
"Using optimized MIN/MAX/SUM/AVG/COUNT implementation");
bLastSQLUsedOptimizedImplementation = TRUE;
return poMemLayer;
}
}
}
/* -------------------------------------------------------------------- */
/* ORDER BY optimization */
/* -------------------------------------------------------------------- */
if( oSelect.join_count == 0 && oSelect.poOtherSelect == NULL &&
oSelect.table_count == 1 && oSelect.order_specs == 1 &&
oSelect.query_mode != SWQM_DISTINCT_LIST )
{
OGROpenFileGDBLayer* poLayer =
(OGROpenFileGDBLayer*)GetLayerByName( oSelect.table_defs[0].table_name);
if( poLayer != NULL &&
poLayer->HasIndexForField(oSelect.order_defs[0].field_name) )
{
OGRErr eErr = OGRERR_NONE;
if( oSelect.where_expr != NULL )
{
/* The where must be a simple comparison on the column */
/* that is used for ordering */
if( oSelect.where_expr->eNodeType == SNT_OPERATION &&
OGROpenFileGDBIsComparisonOp(oSelect.where_expr->nOperation) &&
oSelect.where_expr->nOperation != SWQ_NE &&
oSelect.where_expr->nSubExprCount == 2 &&
(oSelect.where_expr->papoSubExpr[0]->eNodeType == SNT_COLUMN ||
oSelect.where_expr->papoSubExpr[0]->eNodeType == SNT_CONSTANT) &&
oSelect.where_expr->papoSubExpr[0]->field_type == SWQ_STRING &&
EQUAL(oSelect.where_expr->papoSubExpr[0]->string_value,
oSelect.order_defs[0].field_name) &&
oSelect.where_expr->papoSubExpr[1]->eNodeType == SNT_CONSTANT )
{
/* ok */
}
else
eErr = OGRERR_FAILURE;
}
if( eErr == OGRERR_NONE )
{
int i;
for(i = 0; i < oSelect.result_columns; i ++ )
{
if( oSelect.column_defs[i].col_func != SWQCF_NONE )
break;
if( oSelect.column_defs[i].field_name == NULL )
break;
if( oSelect.column_defs[i].distinct_flag )
break;
if( oSelect.column_defs[i].target_type != SWQ_OTHER )
break;
if( strcmp(oSelect.column_defs[i].field_name, "*") != 0 &&
poLayer->GetLayerDefn()->GetFieldIndex(
oSelect.column_defs[i].field_name) < 0 )
break;
}
if( i != oSelect.result_columns )
eErr = OGRERR_FAILURE;
}
if( eErr == OGRERR_NONE )
{
int op = -1;
swq_expr_node* poValue = NULL;
if( oSelect.where_expr != NULL )
{
op = oSelect.where_expr->nOperation;
poValue = oSelect.where_expr->papoSubExpr[1];
}
FileGDBIterator *poIter = poLayer->BuildIndex(
oSelect.order_defs[0].field_name,
oSelect.order_defs[0].ascending_flag,
op, poValue);
/* Check that they are no NULL values */
if( oSelect.where_expr == NULL &&
poIter->GetRowCount() != poLayer->GetFeatureCount(FALSE) )
{
delete poIter;
poIter = NULL;
}
if( poIter != NULL )
{
CPLDebug("OpenFileGDB", "Using OGROpenFileGDBSimpleSQLLayer");
bLastSQLUsedOptimizedImplementation = TRUE;
return new OGROpenFileGDBSimpleSQLLayer(poLayer,
poIter,
oSelect.result_columns,
oSelect.column_defs);
}
}
}
}
}
return OGRDataSource::ExecuteSQL(pszSQLCommand, poSpatialFilter, pszDialect);
}
OGRLayer * OGRCouchDBDataSource::ExecuteSQLStats( const char *pszSQLCommand )
{
swq_select sSelectInfo;
if( sSelectInfo.preparse( pszSQLCommand ) != CE_None )
{
return NULL;
}
if (sSelectInfo.table_count != 1)
{
return NULL;
}
swq_table_def *psTableDef = &sSelectInfo.table_defs[0];
if( psTableDef->data_source != NULL )
{
return NULL;
}
OGRCouchDBLayer* _poSrcLayer =
(OGRCouchDBLayer* )GetLayerByName( psTableDef->table_name );
if (_poSrcLayer == NULL)
{
return NULL;
}
if (_poSrcLayer->GetLayerType() != COUCHDB_TABLE_LAYER)
return NULL;
OGRCouchDBTableLayer* poSrcLayer = (OGRCouchDBTableLayer* ) _poSrcLayer;
int nFieldCount = poSrcLayer->GetLayerDefn()->GetFieldCount();
swq_field_list sFieldList;
memset( &sFieldList, 0, sizeof(sFieldList) );
sFieldList.table_count = sSelectInfo.table_count;
sFieldList.table_defs = sSelectInfo.table_defs;
sFieldList.count = 0;
sFieldList.names = static_cast<char **>(
CPLMalloc( sizeof(char *) * nFieldCount ));
sFieldList.types = static_cast<swq_field_type *>(
CPLMalloc( sizeof(swq_field_type) * nFieldCount ));
sFieldList.table_ids = static_cast<int *>(
CPLMalloc( sizeof(int) * nFieldCount ));
sFieldList.ids = static_cast<int *>(
CPLMalloc( sizeof(int) * nFieldCount ));
PointerAutoFree oHolderNames(sFieldList.names);
PointerAutoFree oHolderTypes(sFieldList.types);
PointerAutoFree oHolderTableIds(sFieldList.table_ids);
PointerAutoFree oHolderIds(sFieldList.ids);
for( int iField = 0;
iField < poSrcLayer->GetLayerDefn()->GetFieldCount();
iField++ )
{
OGRFieldDefn *poFDefn=poSrcLayer->GetLayerDefn()->GetFieldDefn(iField);
int iOutField = sFieldList.count++;
sFieldList.names[iOutField] = (char *) poFDefn->GetNameRef();
if( poFDefn->GetType() == OFTInteger )
sFieldList.types[iOutField] = SWQ_INTEGER;
else if( poFDefn->GetType() == OFTReal )
sFieldList.types[iOutField] = SWQ_FLOAT;
else if( poFDefn->GetType() == OFTString )
sFieldList.types[iOutField] = SWQ_STRING;
else
sFieldList.types[iOutField] = SWQ_OTHER;
sFieldList.table_ids[iOutField] = 0;
sFieldList.ids[iOutField] = iField;
}
CPLString osLastFieldName;
for( int iField = 0; iField < sSelectInfo.result_columns; iField++ )
{
swq_col_def *psColDef = sSelectInfo.column_defs + iField;
if (psColDef->field_name == NULL)
return NULL;
if (strcmp(psColDef->field_name, "*") != 0)
{
if (osLastFieldName.empty())
osLastFieldName = psColDef->field_name;
else if (strcmp(osLastFieldName, psColDef->field_name) != 0)
return NULL;
if (poSrcLayer->GetLayerDefn()->GetFieldIndex(psColDef->field_name) == -1)
return NULL;
}
if (!(psColDef->col_func == SWQCF_AVG ||
psColDef->col_func == SWQCF_MIN ||
psColDef->col_func == SWQCF_MAX ||
psColDef->col_func == SWQCF_COUNT ||
psColDef->col_func == SWQCF_SUM))
return NULL;
if (psColDef->distinct_flag) /* TODO: could perhaps be relaxed */
return NULL;
}
if (osLastFieldName.empty())
return NULL;
/* Normalize field name */
int nIndex = poSrcLayer->GetLayerDefn()->GetFieldIndex(osLastFieldName);
osLastFieldName = poSrcLayer->GetLayerDefn()->GetFieldDefn(nIndex)->GetNameRef();
/* -------------------------------------------------------------------- */
/* Finish the parse operation. */
/* -------------------------------------------------------------------- */
if( sSelectInfo.parse( &sFieldList, NULL ) != CE_None )
{
return NULL;
}
if (sSelectInfo.join_defs != NULL ||
sSelectInfo.where_expr != NULL ||
sSelectInfo.order_defs != NULL ||
sSelectInfo.query_mode != SWQM_SUMMARY_RECORD)
{
return NULL;
}
for( int iField = 0; iField < sSelectInfo.result_columns; iField++ )
{
swq_col_def *psColDef = sSelectInfo.column_defs + iField;
if (psColDef->field_index == -1)
{
if (psColDef->col_func == SWQCF_COUNT)
continue;
return NULL;
}
if (psColDef->field_type != SWQ_INTEGER &&
psColDef->field_type != SWQ_FLOAT)
{
return NULL;
}
}
const bool bFoundFilter = CPL_TO_BOOL(
poSrcLayer->HasFilterOnFieldOrCreateIfNecessary(osLastFieldName));
if( !bFoundFilter )
return NULL;
CPLString osURI = "/";
osURI += poSrcLayer->GetName();
osURI += "/_design/ogr_filter_";
osURI += osLastFieldName;
osURI += "/_view/filter?reduce=true";
json_object* poAnswerObj = GET(osURI);
json_object* poRows = NULL;
if (!(poAnswerObj != NULL &&
json_object_is_type(poAnswerObj, json_type_object) &&
(poRows = CPL_json_object_object_get(poAnswerObj, "rows")) != NULL &&
json_object_is_type(poRows, json_type_array)))
{
json_object_put(poAnswerObj);
return NULL;
}
int nLength = json_object_array_length(poRows);
if (nLength != 1)
{
json_object_put(poAnswerObj);
return NULL;
}
json_object* poRow = json_object_array_get_idx(poRows, 0);
if (!(poRow && json_object_is_type(poRow, json_type_object)))
{
json_object_put(poAnswerObj);
return NULL;
}
json_object* poValue = CPL_json_object_object_get(poRow, "value");
if (!(poValue != NULL && json_object_is_type(poValue, json_type_object)))
{
json_object_put(poAnswerObj);
return NULL;
}
json_object* poSum = CPL_json_object_object_get(poValue, "sum");
json_object* poCount = CPL_json_object_object_get(poValue, "count");
json_object* poMin = CPL_json_object_object_get(poValue, "min");
json_object* poMax = CPL_json_object_object_get(poValue, "max");
if (poSum != NULL && (json_object_is_type(poSum, json_type_int) ||
json_object_is_type(poSum, json_type_double)) &&
poCount != NULL && (json_object_is_type(poCount, json_type_int) ||
json_object_is_type(poCount, json_type_double)) &&
poMin != NULL && (json_object_is_type(poMin, json_type_int) ||
json_object_is_type(poMin, json_type_double)) &&
poMax != NULL && (json_object_is_type(poMax, json_type_int) ||
json_object_is_type(poMax, json_type_double)) )
{
double dfSum = json_object_get_double(poSum);
int nCount = json_object_get_int(poCount);
double dfMin = json_object_get_double(poMin);
double dfMax = json_object_get_double(poMax);
json_object_put(poAnswerObj);
//CPLDebug("CouchDB", "sum=%f, count=%d, min=%f, max=%f",
// dfSum, nCount, dfMin, dfMax);
OGRFeatureDefn* poFeatureDefn = new OGRFeatureDefn(poSrcLayer->GetName());
poFeatureDefn->Reference();
for( int iField = 0; iField < sSelectInfo.result_columns; iField++ )
{
swq_col_def *psColDef = sSelectInfo.column_defs + iField;
OGRFieldDefn oFDefn( "", OFTInteger );
if( psColDef->field_alias != NULL )
{
oFDefn.SetName(psColDef->field_alias);
}
else
{
const swq_operation *op = swq_op_registrar::GetOperator(
(swq_op) psColDef->col_func );
oFDefn.SetName( CPLSPrintf( "%s_%s",
op->pszName,
psColDef->field_name ) );
}
if( psColDef->col_func == SWQCF_COUNT )
oFDefn.SetType( OFTInteger );
else if (psColDef->field_type == SWQ_INTEGER)
oFDefn.SetType( OFTInteger );
else if (psColDef->field_type == SWQ_FLOAT)
oFDefn.SetType( OFTReal );
poFeatureDefn->AddFieldDefn(&oFDefn);
}
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
for( int iField = 0; iField < sSelectInfo.result_columns; iField++ )
{
swq_col_def *psColDef = sSelectInfo.column_defs + iField;
switch(psColDef->col_func)
{
case SWQCF_AVG:
if (nCount)
poFeature->SetField(iField, dfSum / nCount);
break;
case SWQCF_MIN:
poFeature->SetField(iField, dfMin);
break;
case SWQCF_MAX:
poFeature->SetField(iField, dfMax);
break;
case SWQCF_COUNT:
poFeature->SetField(iField, nCount);
break;
case SWQCF_SUM:
poFeature->SetField(iField, dfSum);
break;
default:
break;
}
}
poFeature->SetFID(0);
OGRCouchDBOneLineLayer* poAnswerLayer = new OGRCouchDBOneLineLayer();
poAnswerLayer->poFeatureDefn = poFeatureDefn;
poAnswerLayer->poFeature = poFeature;
return poAnswerLayer;
}
json_object_put(poAnswerObj);
return NULL;
}
void World::UpdateLayer(Renderable* element, String newLayerName)
{
UpdateLayer(element, GetLayerByName(newLayerName));
}
int OGRPDSDataSource::LoadTable(const char* pszFilename,
int nRecordSize,
CPLString osTableID )
{
CPLString osTableFilename;
int nStartBytes;
CPLString osTableLink = "^";
osTableLink += osTableID;
CPLString osTable = oKeywords.GetKeyword( osTableLink, "" );
if( osTable[0] == '(' )
{
osTableFilename = GetKeywordSub(osTableLink, 1, "");
CPLString osStartRecord = GetKeywordSub(osTableLink, 2, "");
nStartBytes = (atoi(osStartRecord.c_str()) - 1) * nRecordSize;
if (osTableFilename.size() == 0 || osStartRecord.size() == 0 ||
nStartBytes < 0)
{
CPLError(CE_Failure, CPLE_NotSupported,
"Cannot parse %s line", osTableLink.c_str());
return FALSE;
}
CPLString osTPath = CPLGetPath(pszFilename);
CleanString( osTableFilename );
osTableFilename = CPLFormCIFilename( osTPath, osTableFilename, NULL );
}
else
{
osTableFilename = oKeywords.GetKeyword( osTableLink, "" );
if (osTableFilename.size() != 0 && osTableFilename[0] >= '0' &&
osTableFilename[0] <= '9')
{
nStartBytes = atoi(osTableFilename.c_str()) - 1;
if (strstr(osTableFilename.c_str(), "<BYTES>") == NULL)
nStartBytes *= nRecordSize;
osTableFilename = pszFilename;
}
else
{
CPLString osTPath = CPLGetPath(pszFilename);
CleanString( osTableFilename );
osTableFilename = CPLFormCIFilename( osTPath, osTableFilename, NULL );
nStartBytes = 0;
}
}
CPLString osTableName = oKeywords.GetKeyword( MakeAttr(osTableID, "NAME"), "" );
if (osTableName.size() == 0)
{
if (GetLayerByName(osTableID.c_str()) == NULL)
osTableName = osTableID;
else
osTableName = CPLSPrintf("Layer_%d", nLayers+1);
}
CleanString(osTableName);
CPLString osTableInterchangeFormat =
oKeywords.GetKeyword( MakeAttr(osTableID, "INTERCHANGE_FORMAT"), "" );
CPLString osTableRows = oKeywords.GetKeyword( MakeAttr(osTableID, "ROWS"), "" );
int nRecords = atoi(osTableRows);
if (osTableInterchangeFormat.size() == 0 ||
osTableRows.size() == 0 || nRecords < 0)
{
CPLError(CE_Failure, CPLE_NotSupported,
"One of TABLE.INTERCHANGE_FORMAT or TABLE.ROWS is missing");
return FALSE;
}
CleanString(osTableInterchangeFormat);
if (osTableInterchangeFormat.compare("ASCII") != 0 &&
osTableInterchangeFormat.compare("BINARY") != 0)
{
CPLError(CE_Failure, CPLE_NotSupported,
"Only INTERCHANGE_FORMAT=ASCII or BINARY is supported");
return FALSE;
}
VSILFILE* fp = VSIFOpenL(osTableFilename, "rb");
if (fp == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot open %s",
osTableFilename.c_str());
return FALSE;
}
CPLString osTableStructure = oKeywords.GetKeyword( MakeAttr(osTableID, "^STRUCTURE"), "" );
if (osTableStructure.size() != 0)
{
CPLString osTPath = CPLGetPath(pszFilename);
CleanString( osTableStructure );
osTableStructure = CPLFormCIFilename( osTPath, osTableStructure, NULL );
}
GByte* pabyRecord = (GByte*) VSIMalloc(nRecordSize + 1);
if (pabyRecord == NULL)
{
VSIFCloseL(fp);
return FALSE;
}
pabyRecord[nRecordSize] = 0;
papoLayers = (OGRLayer**) CPLRealloc(papoLayers, (nLayers + 1) * sizeof(OGRLayer*));
papoLayers[nLayers] = new OGRPDSLayer(osTableID, osTableName, fp,
pszFilename,
osTableStructure,
nRecords, nStartBytes,
nRecordSize, pabyRecord,
osTableInterchangeFormat.compare("ASCII") == 0);
nLayers++;
return TRUE;
}
OGRLayer * OGRMSSQLSpatialDataSource::ExecuteSQL( const char *pszSQLCommand,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
/* -------------------------------------------------------------------- */
/* Use generic implementation for recognized dialects */
/* -------------------------------------------------------------------- */
if( IsGenericSQLDialect(pszDialect) )
return OGRDataSource::ExecuteSQL( pszSQLCommand,
poSpatialFilter,
pszDialect );
/* -------------------------------------------------------------------- */
/* Special case DELLAYER: command. */
/* -------------------------------------------------------------------- */
if( EQUALN(pszSQLCommand,"DELLAYER:",9) )
{
const char *pszLayerName = pszSQLCommand + 9;
while( *pszLayerName == ' ' )
pszLayerName++;
OGRLayer* poLayer = GetLayerByName(pszLayerName);
for( int iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( papoLayers[iLayer] == poLayer )
{
DeleteLayer( iLayer );
break;
}
}
return NULL;
}
CPLDebug( "MSSQLSpatial", "ExecuteSQL(%s) called.", pszSQLCommand );
if( EQUALN(pszSQLCommand, "DROP SPATIAL INDEX ON ", 22) )
{
/* Handle command to drop a spatial index. */
OGRMSSQLSpatialTableLayer *poLayer = new OGRMSSQLSpatialTableLayer( this );
if (poLayer)
{
if( poLayer->Initialize( "dbo", pszSQLCommand + 22, NULL, 0, 0, NULL, wkbUnknown ) != CE_None )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to initialize layer '%s'", pszSQLCommand + 22 );
}
poLayer->DropSpatialIndex();
delete poLayer;
}
return NULL;
}
else if( EQUALN(pszSQLCommand, "CREATE SPATIAL INDEX ON ", 24) )
{
/* Handle command to create a spatial index. */
OGRMSSQLSpatialTableLayer *poLayer = new OGRMSSQLSpatialTableLayer( this );
if (poLayer)
{
if( poLayer->Initialize( "dbo", pszSQLCommand + 24, NULL, 0, 0, NULL, wkbUnknown ) != CE_None )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to initialize layer '%s'", pszSQLCommand + 24 );
}
poLayer->CreateSpatialIndex();
delete poLayer;
}
return NULL;
}
/* Execute the command natively */
CPLODBCStatement *poStmt = new CPLODBCStatement( &oSession );
poStmt->Append( pszSQLCommand );
if( !poStmt->ExecuteSQL() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s", oSession.GetLastError() );
delete poStmt;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Are there result columns for this statement? */
/* -------------------------------------------------------------------- */
if( poStmt->GetColCount() == 0 )
{
delete poStmt;
CPLErrorReset();
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a results layer. It will take ownership of the */
/* statement. */
/* -------------------------------------------------------------------- */
OGRMSSQLSpatialSelectLayer *poLayer = NULL;
poLayer = new OGRMSSQLSpatialSelectLayer( this, poStmt );
if( poSpatialFilter != NULL )
poLayer->SetSpatialFilter( poSpatialFilter );
return poLayer;
}
OGRLayer * OGRShapeDataSource::ExecuteSQL( const char *pszStatement,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
/* ==================================================================== */
/* Handle command to drop a spatial index. */
/* ==================================================================== */
if( EQUALN(pszStatement, "REPACK ", 7) )
{
OGRShapeLayer *poLayer = (OGRShapeLayer *)
GetLayerByName( pszStatement + 7 );
if( poLayer != NULL )
poLayer->Repack();
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"No such layer as '%s' in REPACK.",
pszStatement + 7 );
}
return NULL;
}
/* ==================================================================== */
/* Handle command to drop a spatial index. */
/* ==================================================================== */
if( EQUALN(pszStatement, "DROP SPATIAL INDEX ON ", 22) )
{
OGRShapeLayer *poLayer = (OGRShapeLayer *)
GetLayerByName( pszStatement + 22 );
if( poLayer != NULL )
poLayer->DropSpatialIndex();
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"No such layer as '%s' in DROP SPATIAL INDEX.",
pszStatement + 19 );
}
return NULL;
}
/* ==================================================================== */
/* Handle all comands except spatial index creation generically. */
/* ==================================================================== */
if( !EQUALN(pszStatement,"CREATE SPATIAL INDEX ON ",24) )
return OGRDataSource::ExecuteSQL( pszStatement, poSpatialFilter,
pszDialect );
/* -------------------------------------------------------------------- */
/* Parse into keywords. */
/* -------------------------------------------------------------------- */
char **papszTokens = CSLTokenizeString( pszStatement );
if( CSLCount(papszTokens) < 5
|| !EQUAL(papszTokens[0],"CREATE")
|| !EQUAL(papszTokens[1],"SPATIAL")
|| !EQUAL(papszTokens[2],"INDEX")
|| !EQUAL(papszTokens[3],"ON")
|| CSLCount(papszTokens) > 7
|| (CSLCount(papszTokens) == 7 && !EQUAL(papszTokens[5],"DEPTH")) )
{
CSLDestroy( papszTokens );
CPLError( CE_Failure, CPLE_AppDefined,
"Syntax error in CREATE SPATIAL INDEX command.\n"
"Was '%s'\n"
"Should be of form 'CREATE SPATIAL INDEX ON <table> [DEPTH <n>]'",
pszStatement );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Get depth if provided. */
/* -------------------------------------------------------------------- */
int nDepth = 0;
if( CSLCount(papszTokens) == 7 )
nDepth = atoi(papszTokens[6]);
/* -------------------------------------------------------------------- */
/* What layer are we operating on. */
/* -------------------------------------------------------------------- */
OGRShapeLayer *poLayer = (OGRShapeLayer *) GetLayerByName(papszTokens[4]);
CSLDestroy( papszTokens );
if( poLayer == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s not recognised.",
papszTokens[4] );
return NULL;
}
poLayer->CreateSpatialIndex( nDepth );
return NULL;
}
OGRLayer * OGRGeoPackageDataSource::ExecuteSQL( const char *pszSQLCommand,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
if( EQUALN(pszSQLCommand, "SELECT ", 7) ||
(pszDialect != NULL && EQUAL(pszDialect,"OGRSQL")) )
return OGRDataSource::ExecuteSQL( pszSQLCommand,
poSpatialFilter,
pszDialect );
/* -------------------------------------------------------------------- */
/* Prepare statement. */
/* -------------------------------------------------------------------- */
int rc;
sqlite3_stmt *hSQLStmt = NULL;
CPLString osSQLCommand = pszSQLCommand;
#if 0
/* This will speed-up layer creation */
/* ORDER BY are costly to evaluate and are not necessary to establish */
/* the layer definition. */
int bUseStatementForGetNextFeature = TRUE;
int bEmptyLayer = FALSE;
if( osSQLCommand.ifind("SELECT ") == 0 &&
osSQLCommand.ifind(" UNION ") == std::string::npos &&
osSQLCommand.ifind(" INTERSECT ") == std::string::npos &&
osSQLCommand.ifind(" EXCEPT ") == std::string::npos )
{
size_t nOrderByPos = osSQLCommand.ifind(" ORDER BY ");
if( nOrderByPos != std::string::npos )
{
osSQLCommand.resize(nOrderByPos);
bUseStatementForGetNextFeature = FALSE;
}
}
#endif
rc = sqlite3_prepare( m_poDb, osSQLCommand.c_str(), osSQLCommand.size(),
&hSQLStmt, NULL );
if( rc != SQLITE_OK )
{
CPLError( CE_Failure, CPLE_AppDefined,
"In ExecuteSQL(): sqlite3_prepare(%s):\n %s",
pszSQLCommand, sqlite3_errmsg(m_poDb) );
if( hSQLStmt != NULL )
{
sqlite3_finalize( hSQLStmt );
}
return NULL;
}
/* -------------------------------------------------------------------- */
/* Do we get a resultset? */
/* -------------------------------------------------------------------- */
rc = sqlite3_step( hSQLStmt );
if( rc != SQLITE_ROW )
{
if ( rc != SQLITE_DONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"In ExecuteSQL(): sqlite3_step(%s):\n %s",
pszSQLCommand, sqlite3_errmsg(m_poDb) );
sqlite3_finalize( hSQLStmt );
return NULL;
}
if( EQUAL(pszSQLCommand, "VACUUM") )
{
sqlite3_finalize( hSQLStmt );
/* VACUUM rewrites the DB, so we need to reset the application id */
SetApplicationId();
return NULL;
}
if( EQUALN(pszSQLCommand, "ALTER TABLE ", strlen("ALTER TABLE ")) )
{
char **papszTokens = CSLTokenizeString( pszSQLCommand );
/* ALTER TABLE src_table RENAME TO dst_table */
if( CSLCount(papszTokens) == 6 && EQUAL(papszTokens[3], "RENAME") &&
EQUAL(papszTokens[4], "TO") )
{
const char* pszSrcTableName = papszTokens[2];
const char* pszDstTableName = papszTokens[5];
OGRLayer* poSrcLayer = GetLayerByName(pszSrcTableName);
if( poSrcLayer )
{
/* We also need to update GeoPackage metadata tables */
char* pszSQL;
pszSQL = sqlite3_mprintf(
"UPDATE gpkg_geometry_columns SET table_name = '%s' WHERE table_name = '%s'",
pszDstTableName, pszSrcTableName);
SQLCommand(m_poDb, pszSQL);
sqlite3_free(pszSQL);
pszSQL = sqlite3_mprintf(
"UPDATE gpkg_contents SET table_name = '%s' WHERE table_name = '%s'",
pszDstTableName, pszSrcTableName);
SQLCommand(m_poDb, pszSQL);
sqlite3_free(pszSQL);
}
}
CSLDestroy(papszTokens);
}
if( !EQUALN(pszSQLCommand, "SELECT ", 7) )
{
sqlite3_finalize( hSQLStmt );
return NULL;
}
#if 0
bUseStatementForGetNextFeature = FALSE;
bEmptyLayer = TRUE;
#endif
}
/* -------------------------------------------------------------------- */
/* Create layer. */
/* -------------------------------------------------------------------- */
#if 0
OGRSQLiteSelectLayer *poLayer = NULL;
CPLString osSQL = pszSQLCommand;
poLayer = new OGRGeopackageSelectLayer( this, osSQL, hSQLStmt,
bUseStatementForGetNextFeature, bEmptyLayer, TRUE );
if( poSpatialFilter != NULL )
poLayer->SetSpatialFilter( 0, poSpatialFilter );
return poLayer;
#else
return OGRDataSource::ExecuteSQL( pszSQLCommand,
poSpatialFilter,
pszDialect );
#endif
}
OGRLayer * OGRShapeDataSource::ExecuteSQL( const char *pszStatement,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
/* ==================================================================== */
/* Handle command to drop a spatial index. */
/* ==================================================================== */
if( EQUALN(pszStatement, "REPACK ", 7) )
{
OGRShapeLayer *poLayer = (OGRShapeLayer *)
GetLayerByName( pszStatement + 7 );
if( poLayer != NULL )
{
if( poLayer->Repack() != OGRERR_NONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"REPACK of layer '%s' failed.",
pszStatement + 7 );
}
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"No such layer as '%s' in REPACK.",
pszStatement + 7 );
}
return NULL;
}
/* ==================================================================== */
/* Handle command to shrink columns to their minimum size. */
/* ==================================================================== */
if( EQUALN(pszStatement, "RESIZE ", 7) )
{
OGRShapeLayer *poLayer = (OGRShapeLayer *)
GetLayerByName( pszStatement + 7 );
if( poLayer != NULL )
poLayer->ResizeDBF();
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"No such layer as '%s' in RESIZE.",
pszStatement + 7 );
}
return NULL;
}
/* ==================================================================== */
/* Handle command to recompute extent */
/* ==================================================================== */
if( EQUALN(pszStatement, "RECOMPUTE EXTENT ON ", 20) )
{
OGRShapeLayer *poLayer = (OGRShapeLayer *)
GetLayerByName( pszStatement + 20 );
if( poLayer != NULL )
poLayer->RecomputeExtent();
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"No such layer as '%s' in RECOMPUTE EXTENT.",
pszStatement + 20 );
}
return NULL;
}
/* ==================================================================== */
/* Handle command to drop a spatial index. */
/* ==================================================================== */
if( EQUALN(pszStatement, "DROP SPATIAL INDEX ON ", 22) )
{
OGRShapeLayer *poLayer = (OGRShapeLayer *)
GetLayerByName( pszStatement + 22 );
if( poLayer != NULL )
poLayer->DropSpatialIndex();
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"No such layer as '%s' in DROP SPATIAL INDEX.",
pszStatement + 22 );
}
return NULL;
}
/* ==================================================================== */
/* Handle all comands except spatial index creation generically. */
/* ==================================================================== */
if( !EQUALN(pszStatement,"CREATE SPATIAL INDEX ON ",24) )
{
char **papszTokens = CSLTokenizeString( pszStatement );
if( CSLCount(papszTokens) >=4
&& (EQUAL(papszTokens[0],"CREATE") || EQUAL(papszTokens[0],"DROP"))
&& EQUAL(papszTokens[1],"INDEX")
&& EQUAL(papszTokens[2],"ON") )
{
OGRShapeLayer *poLayer = (OGRShapeLayer *) GetLayerByName(papszTokens[3]);
if (poLayer != NULL)
poLayer->InitializeIndexSupport( poLayer->GetFullName() );
}
CSLDestroy( papszTokens );
return OGRDataSource::ExecuteSQL( pszStatement, poSpatialFilter,
pszDialect );
}
/* -------------------------------------------------------------------- */
/* Parse into keywords. */
/* -------------------------------------------------------------------- */
char **papszTokens = CSLTokenizeString( pszStatement );
if( CSLCount(papszTokens) < 5
|| !EQUAL(papszTokens[0],"CREATE")
|| !EQUAL(papszTokens[1],"SPATIAL")
|| !EQUAL(papszTokens[2],"INDEX")
|| !EQUAL(papszTokens[3],"ON")
|| CSLCount(papszTokens) > 7
|| (CSLCount(papszTokens) == 7 && !EQUAL(papszTokens[5],"DEPTH")) )
{
CSLDestroy( papszTokens );
CPLError( CE_Failure, CPLE_AppDefined,
"Syntax error in CREATE SPATIAL INDEX command.\n"
"Was '%s'\n"
"Should be of form 'CREATE SPATIAL INDEX ON <table> [DEPTH <n>]'",
pszStatement );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Get depth if provided. */
/* -------------------------------------------------------------------- */
int nDepth = 0;
if( CSLCount(papszTokens) == 7 )
nDepth = atoi(papszTokens[6]);
/* -------------------------------------------------------------------- */
/* What layer are we operating on. */
/* -------------------------------------------------------------------- */
OGRShapeLayer *poLayer = (OGRShapeLayer *) GetLayerByName(papszTokens[4]);
if( poLayer == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s not recognised.",
papszTokens[4] );
CSLDestroy( papszTokens );
return NULL;
}
CSLDestroy( papszTokens );
poLayer->CreateSpatialIndex( nDepth );
return NULL;
}
void World::Add(Renderable *newElement, String layer)
{
Add(newElement, GetLayerByName(layer));
}
void OGRDXFDataSource::ReadBlocksSection()
{
char szLineBuf[257];
int nCode;
OGRDXFLayer *poReaderLayer = (OGRDXFLayer *) GetLayerByName( "Entities" );
iEntitiesSectionOffset = oReader.iSrcBufferFileOffset + oReader.iSrcBufferOffset;
while( (nCode = ReadValue( szLineBuf, sizeof(szLineBuf) )) > -1
&& !EQUAL(szLineBuf,"ENDSEC") )
{
// We are only interested in extracting blocks.
if( nCode != 0 || !EQUAL(szLineBuf,"BLOCK") )
continue;
// Process contents of BLOCK definition till we find the
// first entity.
CPLString osBlockName;
while( (nCode = ReadValue( szLineBuf,sizeof(szLineBuf) )) > 0 )
{
if( nCode == 2 )
osBlockName = szLineBuf;
// anything else we want?
}
if( EQUAL(szLineBuf,"ENDBLK") )
continue;
UnreadValue();
// Now we will process entities till we run out at the ENDBLK code.
// we aggregate the geometries of the features into a multi-geometry,
// but throw away other stuff attached to the features.
OGRFeature *poFeature;
OGRGeometryCollection *poColl = new OGRGeometryCollection();
std::vector<OGRFeature*> apoFeatures;
while( (poFeature = poReaderLayer->GetNextUnfilteredFeature()) != NULL )
{
if( poFeature->GetStyleString() != NULL
&& strstr(poFeature->GetStyleString(),"LABEL") != NULL )
{
apoFeatures.push_back( poFeature );
}
else
{
poColl->addGeometryDirectly( poFeature->StealGeometry() );
delete poFeature;
}
}
if( poColl->getNumGeometries() == 0 )
delete poColl;
else
oBlockMap[osBlockName].poGeometry = SimplifyBlockGeometry(poColl);
if( apoFeatures.size() > 0 )
oBlockMap[osBlockName].apoFeatures = apoFeatures;
}
CPLDebug( "DXF", "Read %d blocks with meaningful geometry.",
(int) oBlockMap.size() );
}
OGRLayer * OGRCouchDBDataSource::ExecuteSQL( const char *pszSQLCommand,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
/* -------------------------------------------------------------------- */
/* Use generic implementation for recognized dialects */
/* -------------------------------------------------------------------- */
if( IsGenericSQLDialect(pszDialect) )
return OGRDataSource::ExecuteSQL( pszSQLCommand,
poSpatialFilter,
pszDialect );
/* -------------------------------------------------------------------- */
/* Special case DELLAYER: command. */
/* -------------------------------------------------------------------- */
if( STARTS_WITH_CI(pszSQLCommand, "DELLAYER:") )
{
const char *pszLayerName = pszSQLCommand + 9;
while( *pszLayerName == ' ' )
pszLayerName++;
DeleteLayer( pszLayerName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Special case 'COMPACT ON ' command. */
/* -------------------------------------------------------------------- */
if( STARTS_WITH_CI(pszSQLCommand, "COMPACT ON ") )
{
const char *pszLayerName = pszSQLCommand + 11;
while( *pszLayerName == ' ' )
pszLayerName++;
CPLString osURI("/");
osURI += pszLayerName;
osURI += "/_compact";
json_object* poAnswerObj = POST(osURI, NULL);
IsError(poAnswerObj, "Database compaction failed");
json_object_put(poAnswerObj);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Special case 'VIEW CLEANUP ON ' command. */
/* -------------------------------------------------------------------- */
if( STARTS_WITH_CI(pszSQLCommand, "VIEW CLEANUP ON ") )
{
const char *pszLayerName = pszSQLCommand + 16;
while( *pszLayerName == ' ' )
pszLayerName++;
CPLString osURI("/");
osURI += pszLayerName;
osURI += "/_view_cleanup";
json_object* poAnswerObj = POST(osURI, NULL);
IsError(poAnswerObj, "View cleanup failed");
json_object_put(poAnswerObj);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Deal with "DELETE FROM layer_name WHERE expression" statement */
/* -------------------------------------------------------------------- */
if( STARTS_WITH_CI(pszSQLCommand, "DELETE FROM ") )
{
const char* pszIter = pszSQLCommand + 12;
while(*pszIter && *pszIter != ' ')
pszIter ++;
if (*pszIter == 0)
{
CPLError(CE_Failure, CPLE_AppDefined, "Invalid statement");
return NULL;
}
CPLString osName = pszSQLCommand + 12;
osName.resize(pszIter - (pszSQLCommand + 12));
OGRCouchDBLayer* poLayer = (OGRCouchDBLayer*)GetLayerByName(osName);
if (poLayer == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Unknown layer : %s", osName.c_str());
return NULL;
}
if (poLayer->GetLayerType() != COUCHDB_TABLE_LAYER)
return NULL;
OGRCouchDBTableLayer* poTableLayer = (OGRCouchDBTableLayer*)poLayer;
while( *pszIter == ' ' )
pszIter ++;
if (!STARTS_WITH_CI(pszIter, "WHERE "))
{
CPLError(CE_Failure, CPLE_AppDefined, "WHERE clause missing");
return NULL;
}
pszIter += 5;
const char* pszQuery = pszIter;
/* Check with the generic SQL engine that this is a valid WHERE clause */
OGRFeatureQuery oQuery;
OGRErr eErr = oQuery.Compile( poLayer->GetLayerDefn(), pszQuery );
if( eErr != OGRERR_NONE )
{
return NULL;
}
swq_expr_node * pNode = (swq_expr_node *) oQuery.GetSWQExpr();
if (pNode->eNodeType == SNT_OPERATION &&
pNode->nOperation == SWQ_EQ &&
pNode->nSubExprCount == 2 &&
pNode->papoSubExpr[0]->eNodeType == SNT_COLUMN &&
pNode->papoSubExpr[1]->eNodeType == SNT_CONSTANT &&
pNode->papoSubExpr[0]->field_index == COUCHDB_ID_FIELD &&
pNode->papoSubExpr[1]->field_type == SWQ_STRING)
{
poTableLayer->DeleteFeature(pNode->papoSubExpr[1]->string_value);
}
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid WHERE clause. Expecting '_id' = 'a_value'");
return NULL;
}
return NULL;
}
/* -------------------------------------------------------------------- */
/* Try an optimized implementation when doing only stats */
/* -------------------------------------------------------------------- */
if (poSpatialFilter == NULL && STARTS_WITH_CI(pszSQLCommand, "SELECT"))
{
OGRLayer* poRet = ExecuteSQLStats(pszSQLCommand);
if (poRet)
return poRet;
}
return OGRDataSource::ExecuteSQL( pszSQLCommand,
poSpatialFilter,
pszDialect );
}
int ILI1Reader::ReadFeatures() {
char **tokens = NULL;
const char *pszLine = NULL;
char *topic = CPLStrdup("(null)");
int ret = TRUE;
while (ret && (tokens = ReadParseLine()) != NULL)
{
const char *firsttok = tokens[0];
if (EQUAL(firsttok, "SCNT"))
{
//read description
do
{
pszLine = CPLReadLine( fpItf );
}
while (pszLine && !STARTS_WITH_CI(pszLine, "////"));
ret = (pszLine != NULL);
}
else if (EQUAL(firsttok, "MOTR"))
{
//read model
do
{
pszLine = CPLReadLine( fpItf );
}
while (pszLine && !STARTS_WITH_CI(pszLine, "////"));
ret = (pszLine != NULL);
}
else if (EQUAL(firsttok, "MTID"))
{
}
else if (EQUAL(firsttok, "MODL"))
{
}
else if (EQUAL(firsttok, "TOPI") && CSLCount(tokens) >= 2)
{
CPLFree(topic);
topic = CPLStrdup(CSLGetField(tokens, 1));
}
else if (EQUAL(firsttok, "TABL") && CSLCount(tokens) >= 2)
{
const char *layername
= GetLayerNameString(topic, CSLGetField(tokens, 1));
CPLDebug( "OGR_ILI", "Reading table '%s'", layername );
curLayer = GetLayerByName(layername);
if (curLayer == NULL) { //create one
CPLError( CE_Warning, CPLE_AppDefined,
"No model definition for table '%s' found, "
"using default field names.", layername );
OGRFeatureDefn* poFeatureDefn
= new OGRFeatureDefn(
GetLayerNameString(topic, CSLGetField(tokens, 1)));
poFeatureDefn->SetGeomType( wkbUnknown );
GeomFieldInfos oGeomFieldInfos;
curLayer = new OGRILI1Layer(poFeatureDefn, oGeomFieldInfos, NULL);
AddLayer(curLayer);
}
if(curLayer != NULL) {
for (int i=0; i < curLayer->GetLayerDefn()->GetFieldCount(); i++) {
CPLDebug( "OGR_ILI", "Field %d: %s", i,
curLayer->GetLayerDefn()->GetFieldDefn(i)->GetNameRef());
}
}
ret = ReadTable(layername);
}
else if (EQUAL(firsttok, "ETOP"))
{
}
else if (EQUAL(firsttok, "EMOD"))
{
}
else if (EQUAL(firsttok, "ENDE"))
{
CSLDestroy(tokens);
CPLFree(topic);
return TRUE;
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"Unexpected token: %s", firsttok );
}
CSLDestroy(tokens);
tokens = NULL;
}
CSLDestroy(tokens);
CPLFree(topic);
return ret;
}
CPLErr GNMGenericNetwork::ConnectPointsByLines(char **papszLayerList,
double dfTolerance, double dfCost,
double dfInvCost, GNMDirection eDir)
{
if( CSLCount(papszLayerList) < 2 )
{
CPLError( CE_Failure, CPLE_IllegalArg, "Minimum 2 layers needed to connect" );
return CE_Failure;
}
std::vector<OGRLayer*> paLineLayers;
std::vector<OGRLayer*> paPointLayers;
int eType;
int iLayer;
OGRLayer* poLayer;
for(iLayer = 0; papszLayerList[iLayer] != NULL; ++iLayer)
{
poLayer = GetLayerByName(papszLayerList[iLayer]);
if(NULL == poLayer)
continue;
eType = wkbFlatten(poLayer->GetGeomType());
if(eType == wkbLineString || eType == wkbMultiLineString)
{
paLineLayers.push_back(poLayer);
}
else if(eType == wkbPoint)
{
paPointLayers.push_back(poLayer);
}
}
if (paLineLayers.empty() || paPointLayers.empty() )
{
CPLError( CE_Failure, CPLE_IllegalArg, "Need at least one line (or "
"multiline) layer and one point layer to connect" );
return CE_Failure;
}
// now walk through all lines and find nearest points for line start and end
OGRFeature* poFeature;
for(size_t i = 0; i < paLineLayers.size(); ++i)
{
poLayer = paLineLayers[i];
eType = wkbFlatten(poLayer->GetGeomType());
poLayer->ResetReading();
while((poFeature = poLayer->GetNextFeature()) != NULL)
{
const OGRGeometry* poGeom = poFeature->GetGeometryRef();
if(NULL != poGeom)
{
if(eType == wkbLineString)
{
const OGRLineString* poLineString =
(const OGRLineString*) poGeom;
ConnectPointsByLine(poFeature->GetFID(), poLineString,
paPointLayers, dfTolerance, dfCost,
dfInvCost, eDir);
}
else if( eType == wkbMultiLineString)
{
const OGRMultiLineString* poMultiLineString =
(const OGRMultiLineString*) poGeom;
ConnectPointsByMultiline(poFeature->GetFID(), poMultiLineString,
paPointLayers, dfTolerance, dfCost,
dfInvCost, eDir);
}
}
OGRFeature::DestroyFeature(poFeature);
}
}
return CE_None;
}
void OGRDWGDataSource::ReadBlocksSection()
{
OGRDWGLayer *poReaderLayer = (OGRDWGLayer *) GetLayerByName( "Entities" );
int bMergeBlockGeometries = CSLTestBoolean(
CPLGetConfigOption( "DWG_MERGE_BLOCK_GEOMETRIES", "TRUE" ) );
/* -------------------------------------------------------------------- */
/* Loop over all the block tables, skipping *Model_Space which */
/* we assume is primary entities. */
/* -------------------------------------------------------------------- */
OdDbBlockTableRecordPtr poModelSpace, poBlock;
OdDbBlockTablePtr pTable = GetDB()->getBlockTableId().safeOpenObject();
OdDbSymbolTableIteratorPtr pBlkIter = pTable->newIterator();
for (pBlkIter->start(); ! pBlkIter->done(); pBlkIter->step())
{
poBlock = pBlkIter->getRecordId().safeOpenObject();
CPLString osBlockName = (const char *) poBlock->getName();
if( EQUAL(osBlockName,"*Model_Space") )
{
poModelSpace = poBlock;
continue;
}
poReaderLayer->SetBlockTable( poBlock );
// Now we will process entities till we run out.
// We aggregate the geometries of the features into a multi-geometry,
// but throw away other stuff attached to the features.
OGRFeature *poFeature;
OGRGeometryCollection *poColl = new OGRGeometryCollection();
std::vector<OGRFeature*> apoFeatures;
while( (poFeature = poReaderLayer->GetNextUnfilteredFeature()) != NULL )
{
if( (poFeature->GetStyleString() != NULL
&& strstr(poFeature->GetStyleString(),"LABEL") != NULL)
|| !bMergeBlockGeometries )
{
apoFeatures.push_back( poFeature );
}
else
{
poColl->addGeometryDirectly( poFeature->StealGeometry() );
delete poFeature;
}
}
if( poColl->getNumGeometries() == 0 )
delete poColl;
else
oBlockMap[osBlockName].poGeometry = SimplifyBlockGeometry(poColl);
if( apoFeatures.size() > 0 )
oBlockMap[osBlockName].apoFeatures = apoFeatures;
}
CPLDebug( "DWG", "Read %d blocks with meaningful geometry.",
(int) oBlockMap.size() );
poReaderLayer->SetBlockTable( poModelSpace );
}