void OGRCloudantTableLayer::GetSpatialView()
{
if (pszSpatialView == NULL)
{
char **papszTokens;
if (bHasStandardSpatial < 0 || bHasStandardSpatial == FALSE)
{
pszSpatialView = CPLGetConfigOption("CLOUDANT_SPATIAL_FILTER" , NULL);
if (pszSpatialView)
bHasStandardSpatial = FALSE;
}
if (bHasStandardSpatial < 0)
{
// get standard cloudant geo spatial view
CPLString osURI("/");
osURI += osEscapedName;
osURI += "/_design/SpatialView";
json_object* poAnswerObj = poDS->GET(osURI);
bHasStandardSpatial = (poAnswerObj != NULL &&
json_object_is_type(poAnswerObj, json_type_object) &&
json_object_object_get(poAnswerObj, "st_indexes") != NULL);
json_object_put(poAnswerObj);
}
if (bHasStandardSpatial)
pszSpatialView = "_design/SpatialView/_geo/spatial";
papszTokens =
CSLTokenizeString2( pszSpatialView, "/", 0);
if ((papszTokens[0] == NULL) || (papszTokens[1] == NULL))
{
CPLError(CE_Failure, CPLE_AppDefined, "GetSpatialView() failed, invalid spatial design doc.");
return;
}
pszSpatialDDoc = (char*) calloc(strlen(papszTokens[0]) + strlen(papszTokens[1]) + 2, 1);
sprintf(pszSpatialDDoc, "%s/%s", papszTokens[0], papszTokens[1]);
CSLDestroy(papszTokens);
}
}
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 );
}
OGRLayer* OGRCouchDBDataSource::OpenDatabase(const char* pszLayerName)
{
CPLString osTableName;
CPLString osEscapedName;
if (pszLayerName)
{
osTableName = pszLayerName;
char* pszEscapedName = CPLEscapeString(pszLayerName, -1, CPLES_URL);
osEscapedName = pszEscapedName;
CPLFree(pszEscapedName);
}
else
{
char* pszURL = CPLStrdup(osURL);
char* pszLastSlash = strrchr(pszURL, '/');
if (pszLastSlash)
{
osEscapedName = pszLastSlash + 1;
char* l_pszName = CPLUnescapeString(osEscapedName, NULL, CPLES_URL);
osTableName = l_pszName;
CPLFree(l_pszName);
*pszLastSlash = 0;
}
osURL = pszURL;
CPLFree(pszURL);
pszURL = NULL;
if (pszLastSlash == NULL)
return NULL;
}
CPLString osURI("/");
osURI += osEscapedName;
json_object* poAnswerObj = GET(osURI);
if (poAnswerObj == NULL)
return NULL;
if ( !json_object_is_type(poAnswerObj, json_type_object) ||
CPL_json_object_object_get(poAnswerObj, "db_name") == NULL )
{
IsError(poAnswerObj, "Database opening failed");
json_object_put(poAnswerObj);
return NULL;
}
OGRCouchDBTableLayer* poLayer = new OGRCouchDBTableLayer(this, osTableName);
if ( CPL_json_object_object_get(poAnswerObj, "update_seq") != NULL )
{
int nUpdateSeq = json_object_get_int(CPL_json_object_object_get(poAnswerObj, "update_seq"));
poLayer->SetUpdateSeq(nUpdateSeq);
}
json_object_put(poAnswerObj);
papoLayers = (OGRLayer**) CPLRealloc(papoLayers, (nLayers + 1) * sizeof(OGRLayer*));
papoLayers[nLayers ++] = poLayer;
return poLayer;
}
bool OGRCloudantTableLayer::RunSpatialFilterQueryIfNecessary()
{
if( !bMustRunSpatialFilter )
return true;
bMustRunSpatialFilter = false;
CPLAssert(nOffset == 0);
aosIdsToFetch.resize(0);
if (pszSpatialView == nullptr)
GetSpatialView();
OGREnvelope sEnvelope;
m_poFilterGeom->getEnvelope( &sEnvelope );
CPLString osURI("/");
osURI += osEscapedName;
osURI += "/";
osURI += pszSpatialView;
osURI += "?bbox=";
osURI += CPLSPrintf("%.9f,%.9f,%.9f,%.9f",
sEnvelope.MinX, sEnvelope.MinY,
sEnvelope.MaxX, sEnvelope.MaxY);
json_object* poAnswerObj = poDS->GET(osURI);
if (poAnswerObj == nullptr)
{
CPLDebug("Cloudant",
"Cloudant geo not working --> client-side spatial filtering");
bServerSideSpatialFilteringWorks = false;
return false;
}
if ( !json_object_is_type(poAnswerObj, json_type_object) )
{
CPLDebug("Cloudant",
"Cloudant geo not working --> client-side spatial filtering");
bServerSideSpatialFilteringWorks = false;
CPLError(CE_Failure, CPLE_AppDefined,
"FetchNextRowsSpatialFilter() failed");
json_object_put(poAnswerObj);
return false;
}
/* Catch error for a non cloudant geo database */
json_object* poError = CPL_json_object_object_get(poAnswerObj, "error");
json_object* poReason = CPL_json_object_object_get(poAnswerObj, "reason");
const char* pszError = json_object_get_string(poError);
const char* pszReason = json_object_get_string(poReason);
if (pszError && pszReason && strcmp(pszError, "not_found") == 0 &&
strcmp(pszReason, "Document is missing attachment") == 0)
{
CPLDebug("Cloudant",
"Cloudant geo not working --> client-side spatial filtering");
bServerSideSpatialFilteringWorks = false;
json_object_put(poAnswerObj);
return false;
}
if (poDS->IsError(poAnswerObj, "FetchNextRowsSpatialFilter() failed"))
{
CPLDebug("Cloudant",
"Cloudant geo not working --> client-side spatial filtering");
bServerSideSpatialFilteringWorks = false;
json_object_put(poAnswerObj);
return false;
}
json_object* poRows = CPL_json_object_object_get(poAnswerObj, "rows");
if (poRows == nullptr ||
!json_object_is_type(poRows, json_type_array))
{
CPLDebug("Cloudant",
"Cloudant geo not working --> client-side spatial filtering");
bServerSideSpatialFilteringWorks = false;
CPLError(CE_Failure, CPLE_AppDefined,
"FetchNextRowsSpatialFilter() failed");
json_object_put(poAnswerObj);
return false;
}
int nRows = json_object_array_length(poRows);
for(int i=0;i<nRows;i++)
{
json_object* poRow = json_object_array_get_idx(poRows, i);
if ( poRow == nullptr ||
!json_object_is_type(poRow, json_type_object) )
{
CPLError(CE_Failure, CPLE_AppDefined,
"FetchNextRowsSpatialFilter() failed");
json_object_put(poAnswerObj);
return false;
}
json_object* poId = CPL_json_object_object_get(poRow, "id");
const char* pszId = json_object_get_string(poId);
if (pszId != nullptr)
{
aosIdsToFetch.push_back(pszId);
}
}
std::sort(aosIdsToFetch.begin(), aosIdsToFetch.end());
json_object_put(poAnswerObj);
return true;
}
void OGRCloudantTableLayer::LoadMetadata()
{
if( bHasLoadedMetadata )
return;
bHasLoadedMetadata = true;
if (pszSpatialDDoc == nullptr)
GetSpatialView();
if( pszSpatialDDoc == nullptr )
return;
CPLString osURI("/");
osURI += osEscapedName;
osURI += "/";
osURI += pszSpatialDDoc;
json_object* poAnswerObj = poDS->GET(osURI);
if (poAnswerObj == nullptr)
return;
if ( !json_object_is_type(poAnswerObj, json_type_object) )
{
CPLError(CE_Failure, CPLE_AppDefined, "LoadMetadata() failed");
json_object_put(poAnswerObj);
return;
}
json_object* poRev = CPL_json_object_object_get(poAnswerObj, "_rev");
const char* pszRev = json_object_get_string(poRev);
if (pszRev)
osMetadataRev = pszRev;
json_object* poError = CPL_json_object_object_get(poAnswerObj, "error");
const char* pszError = json_object_get_string(poError);
if (pszError && strcmp(pszError, "not_found") == 0)
{
json_object_put(poAnswerObj);
return;
}
if (poDS->IsError(poAnswerObj, "LoadMetadata() failed"))
{
json_object_put(poAnswerObj);
return;
}
json_object* poJsonSRS = CPL_json_object_object_get(poAnswerObj, "srsid");
const char* pszSRS = json_object_get_string(poJsonSRS);
if (pszSRS != nullptr)
{
poSRS = new OGRSpatialReference();
if (poSRS->importFromURN(pszSRS) != OGRERR_NONE)
{
delete poSRS;
poSRS = nullptr;
}
}
json_object* poGeomType = CPL_json_object_object_get(poAnswerObj, "geomtype");
const char* pszGeomType = json_object_get_string(poGeomType);
if (pszGeomType)
{
if (EQUAL(pszGeomType, "NONE"))
{
eGeomType = wkbNone;
bExtentValid = true;
}
else
{
eGeomType = OGRFromOGCGeomType(pszGeomType);
json_object* poIs25D = CPL_json_object_object_get(poAnswerObj, "is_25D");
if (poIs25D && json_object_get_boolean(poIs25D))
eGeomType = wkbSetZ(eGeomType);
json_object* poExtent = CPL_json_object_object_get(poAnswerObj, "extent");
if (poExtent && json_object_get_type(poExtent) == json_type_object)
{
json_object* poBbox = CPL_json_object_object_get(poExtent, "bbox");
if (poBbox &&
json_object_get_type(poBbox) == json_type_array &&
json_object_array_length(poBbox) == 4 &&
OGRCloudantIsNumericObject(json_object_array_get_idx(poBbox, 0)) &&
OGRCloudantIsNumericObject(json_object_array_get_idx(poBbox, 1)) &&
OGRCloudantIsNumericObject(json_object_array_get_idx(poBbox, 2)) &&
OGRCloudantIsNumericObject(json_object_array_get_idx(poBbox, 3)))
{
dfMinX = json_object_get_double(json_object_array_get_idx(poBbox, 0));
dfMinY = json_object_get_double(json_object_array_get_idx(poBbox, 1));
dfMaxX = json_object_get_double(json_object_array_get_idx(poBbox, 2));
dfMaxY = json_object_get_double(json_object_array_get_idx(poBbox, 3));
bExtentValid = true;
bExtentSet = true;
}
}
}
}
json_object* poGeoJSON = CPL_json_object_object_get(poAnswerObj, "geojson_documents");
if (poGeoJSON && json_object_is_type(poGeoJSON, json_type_boolean))
bGeoJSONDocument = CPL_TO_BOOL(json_object_get_boolean(poGeoJSON));
json_object* poFields = CPL_json_object_object_get(poAnswerObj, "fields");
if (poFields && json_object_is_type(poFields, json_type_array))
{
poFeatureDefn = new OGRFeatureDefn( osName );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType(eGeomType);
if( poFeatureDefn->GetGeomFieldCount() != 0 )
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS);
OGRFieldDefn oFieldId("_id", OFTString);
poFeatureDefn->AddFieldDefn(&oFieldId);
OGRFieldDefn oFieldRev("_rev", OFTString);
poFeatureDefn->AddFieldDefn(&oFieldRev);
int nFields = json_object_array_length(poFields);
for(int i=0;i<nFields;i++)
{
json_object* poField = json_object_array_get_idx(poFields, i);
if (poField && json_object_is_type(poField, json_type_object))
{
json_object* poName = CPL_json_object_object_get(poField, "name");
const char* pszName = json_object_get_string(poName);
if (pszName)
{
json_object* poType = CPL_json_object_object_get(poField, "type");
const char* pszType = json_object_get_string(poType);
OGRFieldType eType = OFTString;
if (pszType)
{
if (strcmp(pszType, "integer") == 0)
eType = OFTInteger;
else if (strcmp(pszType, "integerlist") == 0)
eType = OFTIntegerList;
else if (strcmp(pszType, "real") == 0)
eType = OFTReal;
else if (strcmp(pszType, "reallist") == 0)
eType = OFTRealList;
else if (strcmp(pszType, "string") == 0)
eType = OFTString;
else if (strcmp(pszType, "stringlist") == 0)
eType = OFTStringList;
}
OGRFieldDefn oField(pszName, eType);
poFeatureDefn->AddFieldDefn(&oField);
}
}
}
}
std::sort(aosIdsToFetch.begin(), aosIdsToFetch.end());
json_object_put(poAnswerObj);
return;
}
