void OGROCIDataSource::DeleteLayer( const char *pszLayerName )
{
int iLayer;
/* -------------------------------------------------------------------- */
/* Try to find layer. */
/* -------------------------------------------------------------------- */
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszLayerName,papoLayers[iLayer]->GetLayerDefn()->GetName()) )
{
break;
}
}
if( iLayer == nLayers )
{
CPLDebug( "OCI", "DeleteLayer: %s not found in layer list." \
" Layer *not* deleted.", pszLayerName );
return;
}
DeleteLayer( iLayer );
}
CWaveLayers::CWaveLayers(QWidget *parent) :
QFrame(parent),
ui(new Ui::CWaveLayers)
{
ui->setupUi(this);
connect(ui->VolSpin,SIGNAL(valueChanged(int)),this,SLOT(UpdateGraph()));
connect(ui->TransposeSpin,SIGNAL(valueChanged(int)),this,SLOT(UpdateGraph()));
connect(ui->TuneSpin,SIGNAL(valueChanged(int)),this,SLOT(UpdateGraph()));
connect(ui->LowVelFullSpin,SIGNAL(valueChanged(int)),this,SLOT(UpdateGraph()));
connect(ui->HighVelFullSpin,SIGNAL(valueChanged(int)),this,SLOT(UpdateGraph()));
connect(ui->LowVelXSpin,SIGNAL(valueChanged(int)),this,SLOT(UpdateGraph()));
connect(ui->HighVelXSpin,SIGNAL(valueChanged(int)),this,SLOT(UpdateGraph()));
connect(ui->ADSRWidget,SIGNAL(Changed(CADSR::ADSRParams)),this,SLOT(UpdateADSRs(CADSR::ADSRParams)));
connect(ui->LayersControl,SIGNAL(CurrentLayerChanged(CLayer::LayerParams)),this,SLOT(UpdateControls(CLayer::LayerParams)));
connect(ui->LayersControl,SIGNAL(LayerIndexChanged(int)),this,SLOT(SelectLayer(int)));
connect(ui->LayersControl,SIGNAL(Add(int,int)),this,SLOT(AddLayer(int,int)));
//connect(ui->KeyLayoutControl,SIGNAL(ReleaseLoop()),this,SLOT(ReleaseLoop()));
connect(ui->FixLayerButton,SIGNAL(clicked()),this,SLOT(FixLayer()));
connect(ui->FixAllButton,SIGNAL(clicked()),this,SLOT(FixAll()));
connect(ui->PitchLayerButton,SIGNAL(clicked()),this,SLOT(PitchLayer()));
connect(ui->PitchAllButton,SIGNAL(clicked()),this,SLOT(PitchAll()));
connect(ui->DeleteLayerButton,SIGNAL(clicked()),this,SLOT(DeleteLayer()));
MD=false;
Working=false;
//Update();
}
OGRLayer *OGRCARTODBDataSource::ICreateLayer( const char *pszName,
OGRSpatialReference *poSpatialRef,
OGRwkbGeometryType eGType,
char ** papszOptions )
{
if (!bReadWrite)
{
CPLError(CE_Failure, CPLE_AppDefined, "Operation not available in read-only mode");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszName,papoLayers[iLayer]->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( iLayer );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszName );
return NULL;
}
}
}
CPLString osName(pszName);
if( CSLFetchBoolean(papszOptions,"LAUNDER", TRUE) )
{
char* pszTmp = OGRPGCommonLaunderName(pszName);
osName = pszTmp;
CPLFree(pszTmp);
}
OGRCARTODBTableLayer* poLayer = new OGRCARTODBTableLayer(this, osName);
int bGeomNullable = CSLFetchBoolean(papszOptions, "GEOMETRY_NULLABLE", TRUE);
int bCartoDBify = CSLFetchBoolean(papszOptions, "CARTODBFY",
CSLFetchBoolean(papszOptions, "CARTODBIFY", TRUE));
poLayer->SetLaunderFlag( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) );
poLayer->SetDeferedCreation(eGType, poSpatialRef, bGeomNullable, bCartoDBify);
papoLayers = (OGRCARTODBTableLayer**) CPLRealloc(
papoLayers, (nLayers + 1) * sizeof(OGRCARTODBTableLayer*));
papoLayers[nLayers ++] = poLayer;
return poLayer;
}
CPLErr GNMFileNetwork::DeleteNetworkLayers()
{
while(GetLayerCount() > 0)
{
OGRErr eErr = DeleteLayer(0);
if(eErr != OGRERR_NONE)
return CE_Failure;
}
return CE_None;
}
/*
* 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 * OGRCARTODBDataSource::ExecuteSQL( const char *pszSQLCommand,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
/* Skip leading spaces */
while(*pszSQLCommand == ' ')
pszSQLCommand ++;
/* -------------------------------------------------------------------- */
/* 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++;
for( int iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(papoLayers[iLayer]->GetName(),
pszLayerName ))
{
DeleteLayer( iLayer );
break;
}
}
return NULL;
}
OGRCARTODBResultLayer* poLayer = new OGRCARTODBResultLayer( this, pszSQLCommand );
if( poSpatialFilter != NULL )
poLayer->SetSpatialFilter( poSpatialFilter );
CPLErrorReset();
poLayer->GetLayerDefn();
if( CPLGetLastErrorNo() != 0 )
{
delete poLayer;
return NULL;
}
return poLayer;
}
void freelayers(void)
{
int i;
for (i=0; i < 10; i++)
{
if (NULL != layers[i])
{
DeleteLayer(0, layers[i]);
if (layers[i]->SuperBitMap)
FreeBitMap(layers[i]->SuperBitMap);
}
}
}
OGRLayer *OGRGFTDataSource::CreateLayer( const char *pszName,
CPL_UNUSED OGRSpatialReference *poSpatialRef,
OGRwkbGeometryType eGType,
char ** papszOptions )
{
if (!bReadWrite)
{
CPLError(CE_Failure, CPLE_AppDefined, "Operation not available in read-only mode");
return NULL;
}
if (osAccessToken.size() == 0)
{
CPLError(CE_Failure, CPLE_AppDefined, "Operation not available in unauthenticated mode");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszName,papoLayers[iLayer]->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( pszName );
break;
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszName );
return NULL;
}
}
}
OGRGFTTableLayer* poLayer = new OGRGFTTableLayer(this, pszName);
poLayer->SetGeometryType(eGType);
papoLayers = (OGRLayer**) CPLRealloc(papoLayers, (nLayers + 1) * sizeof(OGRLayer*));
papoLayers[nLayers ++] = poLayer;
return poLayer;
}
void DemoC()
{
int i;
printf("Generating a few layers\n");
GenerateLayers2();
if (layers[1])
{
printf("Moving layer 1...\n");
Delay(30);
i = 50;
while (i>0 && (TRUE == MoveLayer(0, layers[1], 1,1)))
i--;
}
if (layers[2])
{
printf("Moving layer 2...\n");
Delay(30);
i = 50;
while (i>0 && (TRUE == MoveLayer(0, layers[2], 2, -1)))
i--;
}
if (layers[3])
{
printf("Moving layer 3...\n");
Delay(30);
i = 50;
while (i>0 && TRUE == MoveLayer(0, layers[3], 1, 3))
i--;
}
if (layers[0])
{
printf("Moving layer 0...\n");
Delay(30);
i = 150;
while (i>0 && TRUE == MoveLayer(0, layers[0], 0 ,1))
i--;
}
printf("Deleting all visible layers!\n");
i = 0;
while (i < 10)
{
if (layers[i])
DeleteLayer(0, layers[i]);
layers[i] = NULL;
i++;
}
}
DBInt DBGridIF::DeleteLayers(char *firstLayer, char *lastLayer) {
DBInt layerID;
DBObjRecord *layerRec;
if ((layerRec = LayerTable->Item(firstLayer)) == (DBObjRecord *) NULL) {
CMmsgPrint(CMmsgAppError, "Invalid layer name in: %s %d", __FILE__, __LINE__);
return (DBFault);
}
layerID = layerRec->RowID();
while (strcmp(layerRec->Name(), lastLayer) != 0) {
DeleteLayer(layerRec->Name());
if ((layerRec = LayerTable->Item(layerID)) == (DBObjRecord *) NULL) break;
}
return (DBSuccess);
}
OGRLayer * OGRGFTDataSource::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++;
DeleteLayer( pszLayerName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create layer. */
/* -------------------------------------------------------------------- */
OGRGFTResultLayer *poLayer = NULL;
CPLString osSQL = pszSQLCommand;
poLayer = new OGRGFTResultLayer( this, osSQL );
if (!poLayer->RunSQL())
{
delete poLayer;
return NULL;
}
if( poSpatialFilter != NULL )
poLayer->SetSpatialFilter( poSpatialFilter );
return poLayer;
}
void deletelayer(void)
{
int i;
printf("Delete layer with id: ");
scanf("%d", &i);
if (layers[i])
{
DeleteLayer(0, layers[i]);
if (layers[i]->SuperBitMap)
FreeBitMap(layers[i]->SuperBitMap);
printf("Deleted layer with id %d\n",i);
layers[i] = NULL;
}
else
{
printf("No layer with id %d\n",i);
}
}
/******************************************************************************
* DeleteByLayer
*/
short API::DeleteByLayer(short layerNumber, BOOL RemoveLayerFromLayerList)
{
#ifdef SHAREWARE
return RC_NO_LICENSE;
#endif
if (apiView == NULL)
return RC_NO_ACTIVE_DOC;
CCEtoODBDoc *doc = apiView->GetDocument();
if (layerNumber < 0 || layerNumber >= doc->getMaxLayerIndex())
return RC_INDEX_OUT_OF_RANGE;
LayerStruct *layer = doc->getLayerArray()[layerNumber];
DeleteLayer(doc, layer, RemoveLayerFromLayerList);
return RC_SUCCESS;
}
void OGRCouchDBDataSource::DeleteLayer( const char *pszLayerName )
{
/* -------------------------------------------------------------------- */
/* Try to find layer. */
/* -------------------------------------------------------------------- */
int iLayer = 0; // Used after for.
for( ; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszLayerName,papoLayers[iLayer]->GetName()) )
break;
}
if( iLayer == nLayers )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Attempt to delete layer '%s', but this layer is not known to OGR.",
pszLayerName );
return;
}
DeleteLayer(iLayer);
}
OGRLayer *OGRCouchDBDataSource::ICreateLayer( const char *pszNameIn,
OGRSpatialReference *poSpatialRef,
OGRwkbGeometryType eGType,
char ** papszOptions )
{
if( !bReadWrite )
{
CPLError(CE_Failure, CPLE_AppDefined, "Operation not available in read-only mode");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
for( int iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszNameIn,papoLayers[iLayer]->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( pszNameIn );
break;
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszNameIn );
return NULL;
}
}
}
char* pszEscapedName = CPLEscapeString(pszNameIn, -1, CPLES_URL);
CPLString osEscapedName = pszEscapedName;
CPLFree(pszEscapedName);
/* -------------------------------------------------------------------- */
/* Create "database" */
/* -------------------------------------------------------------------- */
CPLString osURI;
osURI = "/";
osURI += osEscapedName;
json_object* poAnswerObj = PUT(osURI, NULL);
if (poAnswerObj == NULL)
return NULL;
if( !IsOK(poAnswerObj, "Layer creation failed") )
{
json_object_put(poAnswerObj);
return NULL;
}
json_object_put(poAnswerObj);
/* -------------------------------------------------------------------- */
/* Create "spatial index" */
/* -------------------------------------------------------------------- */
int nUpdateSeq = 0;
if (eGType != wkbNone)
{
osURI = "/";
osURI += osEscapedName;
osURI += "/_design/ogr_spatial";
CPLString osContent("{ \"spatial\": { \"spatial\" : \"function(doc) { if (doc.geometry && doc.geometry.coordinates && doc.geometry.coordinates.length != 0) { emit(doc.geometry, null); } } \" } }");
poAnswerObj = PUT(osURI, osContent);
if( IsOK(poAnswerObj, "Spatial index creation failed") )
nUpdateSeq ++;
json_object_put(poAnswerObj);
}
/* -------------------------------------------------------------------- */
/* Create validation function */
/* -------------------------------------------------------------------- */
const char* pszUpdatePermissions = CSLFetchNameValueDef(papszOptions, "UPDATE_PERMISSIONS", "LOGGED_USER");
CPLString osValidation;
if (EQUAL(pszUpdatePermissions, "LOGGED_USER"))
{
osValidation = "{\"validate_doc_update\": \"function(new_doc, old_doc, userCtx) { if(!userCtx.name) { throw({forbidden: \\\"Please log in first.\\\"}); } }\" }";
}
else if (EQUAL(pszUpdatePermissions, "ALL"))
{
osValidation = "{\"validate_doc_update\": \"function(new_doc, old_doc, userCtx) { }\" }";
}
else if (EQUAL(pszUpdatePermissions, "ADMIN"))
{
osValidation = "{\"validate_doc_update\": \"function(new_doc, old_doc, userCtx) {if (userCtx.roles.indexOf('_admin') === -1) { throw({forbidden: \\\"No changes allowed except by admin.\\\"}); } }\" }";
}
else if (STARTS_WITH(pszUpdatePermissions, "function("))
{
osValidation = "{\"validate_doc_update\": \"";
osValidation += pszUpdatePermissions;
osValidation += "\"}";
}
if (!osValidation.empty() )
{
osURI = "/";
osURI += osEscapedName;
osURI += "/_design/ogr_validation";
poAnswerObj = PUT(osURI, osValidation);
if( IsOK(poAnswerObj, "Validation function creation failed") )
nUpdateSeq ++;
json_object_put(poAnswerObj);
}
const bool bGeoJSONDocument =
CPLTestBool(CSLFetchNameValueDef(papszOptions, "GEOJSON", "TRUE"));
int nCoordPrecision = atoi(CSLFetchNameValueDef(papszOptions, "COORDINATE_PRECISION", "-1"));
OGRCouchDBTableLayer* poLayer = new OGRCouchDBTableLayer(this, pszNameIn);
if (nCoordPrecision != -1)
poLayer->SetCoordinatePrecision(nCoordPrecision);
poLayer->SetInfoAfterCreation(eGType, poSpatialRef,
nUpdateSeq, bGeoJSONDocument);
papoLayers = (OGRLayer**) CPLRealloc(papoLayers, (nLayers + 1) * sizeof(OGRLayer*));
papoLayers[nLayers ++] = poLayer;
return poLayer;
}
OGRLayer * OGRMSSQLSpatialDataSource::ExecuteSQL( const char *pszSQLCommand,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
/* -------------------------------------------------------------------- */
/* Use generic imlplementation for OGRSQL dialect. */
/* -------------------------------------------------------------------- */
if( pszDialect != NULL && EQUAL(pszDialect,"OGRSQL") )
return OGRDataSource::ExecuteSQL( pszSQLCommand,
poSpatialFilter,
pszDialect );
/* -------------------------------------------------------------------- */
/* Special case DELLAYER: command. */
/* -------------------------------------------------------------------- */
if( EQUALN(pszSQLCommand,"DELLAYER:",9) )
{
const char *pszLayerName = pszSQLCommand + 9;
while( *pszLayerName == ' ' )
pszLayerName++;
for( int iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(papoLayers[iLayer]->GetName(),
pszLayerName ))
{
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, 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, 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 * OGRMSSQLSpatialDataSource::CreateLayer( const char * pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
char *pszTableName = NULL;
char *pszSchemaName = NULL;
const char *pszGeomType = NULL;
const char *pszGeomColumn = NULL;
int nCoordDimension = 3;
/* determine the dimension */
if( eType == wkbFlatten(eType) )
nCoordDimension = 2;
if( CSLFetchNameValue( papszOptions, "DIM") != NULL )
nCoordDimension = atoi(CSLFetchNameValue( papszOptions, "DIM"));
/* MSSQL Schema handling:
Extract schema name from input layer name or passed with -lco SCHEMA.
Set layer name to "schema.table" or to "table" if schema is not
specified
*/
const char* pszDotPos = strstr(pszLayerName,".");
if ( pszDotPos != NULL )
{
int length = pszDotPos - pszLayerName;
pszSchemaName = (char*)CPLMalloc(length+1);
strncpy(pszSchemaName, pszLayerName, length);
pszSchemaName[length] = '\0';
if( CSLFetchBoolean(papszOptions,"LAUNDER", TRUE) )
pszTableName = LaunderName( pszDotPos + 1 ); //skip "."
else
pszTableName = CPLStrdup( pszDotPos + 1 ); //skip "."
}
else
{
pszSchemaName = NULL;
if( CSLFetchBoolean(papszOptions,"LAUNDER", TRUE) )
pszTableName = LaunderName( pszLayerName ); //skip "."
else
pszTableName = CPLStrdup( pszLayerName ); //skip "."
}
if( CSLFetchNameValue( papszOptions, "SCHEMA" ) != NULL )
{
CPLFree(pszSchemaName);
pszSchemaName = CPLStrdup(CSLFetchNameValue( papszOptions, "SCHEMA" ));
}
if (pszSchemaName == NULL)
pszSchemaName = CPLStrdup("dbo");
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszLayerName,papoLayers[iLayer]->GetTableName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
if (!pszSchemaName)
pszSchemaName = CPLStrdup(papoLayers[iLayer]->GetSchemaName());
DeleteLayer( iLayer );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszLayerName );
CPLFree( pszSchemaName );
CPLFree( pszTableName );
return NULL;
}
}
}
/* -------------------------------------------------------------------- */
/* Handle the GEOM_TYPE option. */
/* -------------------------------------------------------------------- */
pszGeomType = CSLFetchNameValue( papszOptions, "GEOM_TYPE" );
if( !pszGeomType )
pszGeomType = "geometry";
if( !EQUAL(pszGeomType, "geometry")
&& !EQUAL(pszGeomType, "geography"))
{
CPLError( CE_Failure, CPLE_AppDefined,
"FORMAT=%s not recognised or supported.",
pszGeomType );
CPLFree( pszSchemaName );
CPLFree( pszTableName );
return NULL;
}
/* determine the geometry column name */
pszGeomColumn = CSLFetchNameValue( papszOptions, "GEOM_NAME");
if (!pszGeomColumn)
pszGeomColumn = "ogr_geometry";
/* -------------------------------------------------------------------- */
/* Initialize the metadata tables */
/* -------------------------------------------------------------------- */
if (InitializeMetadataTables() != OGRERR_NONE)
{
CPLFree( pszSchemaName );
CPLFree( pszTableName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Try to get the SRS Id of this spatial reference system, */
/* adding to the srs table if needed. */
/* -------------------------------------------------------------------- */
int nSRSId = 0;
if( CSLFetchNameValue( papszOptions, "SRID") != NULL )
nSRSId = atoi(CSLFetchNameValue( papszOptions, "SRID"));
if( nSRSId == 0 && poSRS != NULL )
nSRSId = FetchSRSId( poSRS );
/* -------------------------------------------------------------------- */
/* Create a new table and create a new entry in the geometry, */
/* geometry_columns metadata table. */
/* -------------------------------------------------------------------- */
if( eType != wkbNone )
{
const char *pszGeometryType = OGRToOGCGeomType(eType);
CPLODBCStatement oStmt( &oSession );
oStmt.Appendf( "DELETE FROM geometry_columns WHERE f_table_schema = '%s' "
"AND f_table_name = '%s'\n", pszSchemaName, pszTableName );
oStmt.Appendf("INSERT INTO [geometry_columns] ([f_table_catalog], [f_table_schema] ,[f_table_name], "
"[f_geometry_column],[coord_dimension],[srid],[geometry_type]) VALUES ('%s', '%s', '%s', '%s', %d, %d, '%s')\n",
pszCatalog, pszSchemaName, pszTableName, pszGeomColumn, nCoordDimension, nSRSId, pszGeometryType );
oStmt.Appendf("CREATE TABLE [%s].[%s] ([ogr_fid] [int] IDENTITY(1,1) NOT NULL, "
"[%s] [%s] NULL, CONSTRAINT [PK_%s] PRIMARY KEY CLUSTERED ([ogr_fid] ASC))",
pszSchemaName, pszTableName, pszGeomColumn, pszGeomType, pszTableName);
oSession.BeginTransaction();
if( !oStmt.ExecuteSQL() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error creating layer: %s", GetSession()->GetLastError() );
return NULL;
}
oSession.CommitTransaction();
}
CPLFree( pszSchemaName );
CPLFree( pszTableName );
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRMSSQLSpatialTableLayer *poLayer;
poLayer = new OGRMSSQLSpatialTableLayer( this );
poLayer->SetLaunderFlag( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) );
poLayer->SetPrecisionFlag( CSLFetchBoolean(papszOptions,"PRECISION",TRUE));
if (poLayer->Initialize("dbo", pszLayerName, pszGeomColumn, nCoordDimension, nSRSId, eType) == OGRERR_FAILURE)
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGRMSSQLSpatialTableLayer **)
CPLRealloc( papoLayers, sizeof(OGRMSSQLSpatialTableLayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
return poLayer;
}
OGRLayer *
OGRMySQLDataSource::CreateLayer( const char * pszLayerNameIn,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
MYSQL_RES *hResult=NULL;
CPLString osCommand;
const char *pszGeometryType;
const char *pszGeomColumnName;
const char *pszExpectedFIDName;
char *pszLayerName;
int nDimension = 3; // MySQL only supports 2d currently
/* -------------------------------------------------------------------- */
/* Make sure there isn't an active transaction already. */
/* -------------------------------------------------------------------- */
InterruptLongResult();
if( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) )
pszLayerName = LaunderName( pszLayerNameIn );
else
pszLayerName = CPLStrdup( pszLayerNameIn );
if( wkbFlatten(eType) == eType )
nDimension = 2;
CPLDebug("MYSQL","Creating layer %s.", pszLayerName);
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszLayerName,papoLayers[iLayer]->GetLayerDefn()->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( iLayer );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszLayerName );
CPLFree( pszLayerName );
return NULL;
}
}
}
pszGeomColumnName = CSLFetchNameValue( papszOptions, "GEOMETRY_NAME" );
if (!pszGeomColumnName)
pszGeomColumnName="SHAPE";
pszExpectedFIDName = CSLFetchNameValue( papszOptions, "MYSQL_FID" );
if (!pszExpectedFIDName)
pszExpectedFIDName="OGR_FID";
CPLDebug("MYSQL","Geometry Column Name %s.", pszGeomColumnName);
CPLDebug("MYSQL","FID Column Name %s.", pszExpectedFIDName);
if( wkbFlatten(eType) == wkbNone )
{
osCommand.Printf(
"CREATE TABLE `%s` ( "
" %s INT UNIQUE NOT NULL AUTO_INCREMENT )",
pszLayerName, pszExpectedFIDName );
}
else
{
osCommand.Printf(
"CREATE TABLE `%s` ( "
" %s INT UNIQUE NOT NULL AUTO_INCREMENT, "
" %s GEOMETRY NOT NULL )",
pszLayerName, pszExpectedFIDName, pszGeomColumnName );
}
if( CSLFetchNameValue( papszOptions, "ENGINE" ) != NULL )
{
osCommand += " ENGINE = ";
osCommand += CSLFetchNameValue( papszOptions, "ENGINE" );
}
if( !mysql_query(GetConn(), osCommand ) )
{
if( mysql_field_count( GetConn() ) == 0 )
CPLDebug("MYSQL","Created table %s.", pszLayerName);
else
{
ReportError( osCommand );
return NULL;
}
}
else
{
ReportError( osCommand );
return NULL;
}
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( GetConn() );
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
// Calling this does no harm
InitializeMetadataTables();
/* -------------------------------------------------------------------- */
/* Try to get the SRS Id of this spatial reference system, */
/* adding tot the srs table if needed. */
/* -------------------------------------------------------------------- */
int nSRSId = -1;
if( poSRS != NULL )
nSRSId = FetchSRSId( poSRS );
/* -------------------------------------------------------------------- */
/* Sometimes there is an old crufty entry in the geometry_columns */
/* table if things were not properly cleaned up before. We make */
/* an effort to clean out such cruft. */
/* */
/* -------------------------------------------------------------------- */
osCommand.Printf(
"DELETE FROM geometry_columns WHERE f_table_name = '%s'",
pszLayerName );
if( mysql_query(GetConn(), osCommand ) )
{
ReportError( osCommand );
return NULL;
}
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( GetConn() );
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
/* -------------------------------------------------------------------- */
/* Attempt to add this table to the geometry_columns table, if */
/* it is a spatial layer. */
/* -------------------------------------------------------------------- */
if( eType != wkbNone )
{
int nCoordDimension;
if( eType == wkbFlatten(eType) )
nCoordDimension = 2;
else
nCoordDimension = 3;
pszGeometryType = OGRToOGCGeomType(eType);
if( nSRSId == -1 )
osCommand.Printf(
"INSERT INTO geometry_columns "
" (F_TABLE_NAME, "
" F_GEOMETRY_COLUMN, "
" COORD_DIMENSION, "
" TYPE) values "
" ('%s', '%s', %d, '%s')",
pszLayerName,
pszGeomColumnName,
nCoordDimension,
pszGeometryType );
else
osCommand.Printf(
"INSERT INTO geometry_columns "
" (F_TABLE_NAME, "
" F_GEOMETRY_COLUMN, "
" COORD_DIMENSION, "
" SRID, "
" TYPE) values "
" ('%s', '%s', %d, %d, '%s')",
pszLayerName,
pszGeomColumnName,
nCoordDimension,
nSRSId,
pszGeometryType );
if( mysql_query(GetConn(), osCommand ) )
{
ReportError( osCommand );
return NULL;
}
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( GetConn() );
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
}
/* -------------------------------------------------------------------- */
/* Create the spatial index. */
/* */
/* We're doing this before we add geometry and record to the table */
/* so this may not be exactly the best way to do it. */
/* -------------------------------------------------------------------- */
const char *pszSI = CSLFetchNameValue( papszOptions, "SPATIAL_INDEX" );
if( eType != wkbNone && (pszSI == NULL || CSLTestBoolean(pszSI)) )
{
osCommand.Printf(
"ALTER TABLE `%s` ADD SPATIAL INDEX(`%s`) ",
pszLayerName,
pszGeomColumnName);
if( mysql_query(GetConn(), osCommand ) )
{
ReportError( osCommand );
return NULL;
}
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( GetConn() );
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
}
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRMySQLTableLayer *poLayer;
OGRErr eErr;
poLayer = new OGRMySQLTableLayer( this, pszLayerName, TRUE, nSRSId );
eErr = poLayer->Initialize(pszLayerName);
if (eErr == OGRERR_FAILURE)
return NULL;
poLayer->SetLaunderFlag( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) );
poLayer->SetPrecisionFlag( CSLFetchBoolean(papszOptions,"PRECISION",TRUE));
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGRMySQLLayer **)
CPLRealloc( papoLayers, sizeof(OGRMySQLLayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
CPLFree( pszLayerName );
return poLayer;
}
OGRLayer * OGRMySQLDataSource::ExecuteSQL( const char *pszSQLCommand,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
if( poSpatialFilter != NULL )
{
CPLDebug( "OGR_MYSQL",
"Spatial filter ignored for now in OGRMySQLDataSource::ExecuteSQL()" );
}
/* -------------------------------------------------------------------- */
/* Use generic implementation for OGRSQL dialect. */
/* -------------------------------------------------------------------- */
if( pszDialect != NULL && EQUAL(pszDialect,"OGRSQL") )
return OGRDataSource::ExecuteSQL( pszSQLCommand,
poSpatialFilter,
pszDialect );
/* -------------------------------------------------------------------- */
/* Special case DELLAYER: command. */
/* -------------------------------------------------------------------- */
#ifdef notdef
if( EQUALN(pszSQLCommand,"DELLAYER:",9) )
{
const char *pszLayerName = pszSQLCommand + 9;
while( *pszLayerName == ' ' )
pszLayerName++;
DeleteLayer( pszLayerName );
return NULL;
}
#endif
/* -------------------------------------------------------------------- */
/* Make sure there isn't an active transaction already. */
/* -------------------------------------------------------------------- */
InterruptLongResult();
/* -------------------------------------------------------------------- */
/* Execute the statement. */
/* -------------------------------------------------------------------- */
MYSQL_RES *hResultSet;
if( mysql_query( hConn, pszSQLCommand ) )
{
ReportError( pszSQLCommand );
return NULL;
}
hResultSet = mysql_use_result( hConn );
if( hResultSet == NULL )
{
if( mysql_field_count( hConn ) == 0 )
{
CPLDebug( "MYSQL", "Command '%s' succeeded, %d rows affected.",
pszSQLCommand,
(int) mysql_affected_rows(hConn) );
return NULL;
}
else
{
ReportError( pszSQLCommand );
return NULL;
}
}
/* -------------------------------------------------------------------- */
/* Do we have a tuple result? If so, instantiate a results */
/* layer for it. */
/* -------------------------------------------------------------------- */
OGRMySQLResultLayer *poLayer = NULL;
poLayer = new OGRMySQLResultLayer( this, pszSQLCommand, hResultSet );
return poLayer;
}
OGRLayer * OGROCIDataSource::ExecuteSQL( const char *pszSQLCommand,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
/* -------------------------------------------------------------------- */
/* Use generic implementation for recognized dialects */
/* -------------------------------------------------------------------- */
if( IsGenericSQLDialect(pszDialect) )
return OGRDataSource::ExecuteSQL( pszSQLCommand,
poSpatialFilter,
pszDialect );
/* -------------------------------------------------------------------- */
/* Ensure any pending stuff is flushed to the database. */
/* -------------------------------------------------------------------- */
FlushCache();
CPLDebug( "OCI", "ExecuteSQL(%s)", pszSQLCommand );
/* -------------------------------------------------------------------- */
/* Special case DELLAYER: command. */
/* -------------------------------------------------------------------- */
if( STARTS_WITH_CI(pszSQLCommand, "DELLAYER:") )
{
const char *pszLayerName = pszSQLCommand + 9;
while( *pszLayerName == ' ' )
pszLayerName++;
DeleteLayer( pszLayerName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Special case VALLAYER: command. */
/* -------------------------------------------------------------------- */
if( STARTS_WITH_CI(pszSQLCommand, "VALLAYER:") )
{
const char *pszLayerName = pszSQLCommand + 9;
while( *pszLayerName == ' ' )
pszLayerName++;
ValidateLayer( pszLayerName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Just execute simple command. */
/* -------------------------------------------------------------------- */
if( !STARTS_WITH_CI(pszSQLCommand, "SELECT") )
{
OGROCIStatement oCommand( poSession );
oCommand.Execute( pszSQLCommand, OCI_COMMIT_ON_SUCCESS );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Otherwise instantiate a layer. */
/* -------------------------------------------------------------------- */
else
{
OGROCIStatement oCommand( poSession );
if( oCommand.Execute( pszSQLCommand, OCI_DESCRIBE_ONLY ) == CE_None )
return new OGROCISelectLayer( this, pszSQLCommand, &oCommand );
else
return NULL;
}
}
/*
* ICreateLayer
*/
OGRLayer *OGRNGWDataset::ICreateLayer( const char *pszNameIn,
OGRSpatialReference *poSpatialRef,
OGRwkbGeometryType eGType,
char **papszOptions )
{
if( !bReadWrite )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Operation not available in read-only mode");
return nullptr;
}
// Check permissions as we create new layer in memory and will create in during SyncToDisk.
FetchPermissions();
if( !stPermissions.bResourceCanCreate )
{
CPLError(CE_Failure, CPLE_AppDefined, "Operation not permitted.");
return nullptr;
}
// Check input parameters.
if( eGType < wkbPoint || eGType > wkbMultiPolygon )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Unsupported geometry type: %s", OGRGeometryTypeToName(eGType));
return nullptr;
}
if( !poSpatialRef )
{
CPLError(CE_Failure, CPLE_AppDefined, "Undefined spatial reference");
return nullptr;
}
poSpatialRef->AutoIdentifyEPSG();
const char *pszEPSG = poSpatialRef->GetAuthorityCode( nullptr );
int nEPSG = -1;
if( pszEPSG != nullptr )
{
nEPSG = atoi( pszEPSG );
}
if( nEPSG != 3857 ) // TODO: Check NextGIS Web supported SRS.
{
CPLError(CE_Failure, CPLE_AppDefined,
"Unsupported spatial reference EPSG code: %d", nEPSG);
return nullptr;
}
// Do we already have this layer? If so, should we blow it away?
bool bOverwrite = CPLFetchBool(papszOptions, "OVERWRITE", "NO");
for( int iLayer = 0; iLayer < nLayers; ++iLayer )
{
if( EQUAL(pszNameIn, papoLayers[iLayer]->GetName()) )
{
if( bOverwrite )
{
DeleteLayer( iLayer );
break;
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszNameIn );
return nullptr;
}
}
}
// Create layer.
std::string osKey = CSLFetchNameValueDef( papszOptions, "KEY", "");
std::string osDesc = CSLFetchNameValueDef( papszOptions, "DESCRIPTION", "");
OGRNGWLayer *poLayer = new OGRNGWLayer( this, pszNameIn, poSpatialRef, eGType,
osKey, osDesc );
papoLayers = (OGRNGWLayer**) CPLRealloc(papoLayers, (nLayers + 1) *
sizeof(OGRNGWLayer*));
papoLayers[nLayers++] = poLayer;
return poLayer;
}
FOR_EACH_COLLECTION(i, names)
{
DeleteLayer(*i, deleteFlags);
}
OGRLayer *
OGRIngresDataSource::CreateLayer( const char * pszLayerNameIn,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
const char *pszGeometryType = NULL;
const char *pszGeomColumnName;
const char *pszExpectedFIDName;
char *pszLayerName;
int nDimension = 3; // Ingres only supports 2d currently
if( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) )
pszLayerName = LaunderName( pszLayerNameIn );
else
pszLayerName = CPLStrdup( pszLayerNameIn );
if( wkbFlatten(eType) == eType )
nDimension = 2;
CPLDebug("INGRES","Creating layer %s.", pszLayerName);
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszLayerName,papoLayers[iLayer]->GetLayerDefn()->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( iLayer );
}
else
{
CPLFree( pszLayerName );
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszLayerName );
return NULL;
}
}
}
/* -------------------------------------------------------------------- */
/* What do we want to use for geometry and FID columns? */
/* -------------------------------------------------------------------- */
pszGeomColumnName = CSLFetchNameValue( papszOptions, "GEOMETRY_NAME" );
if (!pszGeomColumnName)
pszGeomColumnName="SHAPE";
pszExpectedFIDName = CSLFetchNameValue( papszOptions, "INGRES_FID" );
if (!pszExpectedFIDName)
pszExpectedFIDName="OGR_FID";
CPLDebug("INGRES","Geometry Column Name %s.", pszGeomColumnName);
CPLDebug("INGRES","FID Column Name %s.", pszExpectedFIDName);
/* -------------------------------------------------------------------- */
/* What sort of geometry column do we want to create? */
/* -------------------------------------------------------------------- */
pszGeometryType = CSLFetchNameValue( papszOptions, "GEOMETRY_TYPE" );
if( pszGeometryType != NULL )
/* user selected type */;
else if( wkbFlatten(eType) == wkbPoint )
pszGeometryType = "POINT";
else if( wkbFlatten(eType) == wkbLineString)
{
if( IsNewIngres() )
{
pszGeometryType = "LINESTRING";
}
else
{
pszGeometryType = "LONG LINE";
}
}
else if( wkbFlatten(eType) == wkbPolygon )
{
if( IsNewIngres() )
{
pszGeometryType = "POLYGON";
}
else
{
pszGeometryType = "LONG POLYGON";
}
}
else if( wkbFlatten(eType) == wkbMultiPolygon )
{
if( IsNewIngres() )
pszGeometryType = "MULTIPOLYGON";
}
else if( wkbFlatten(eType) == wkbMultiLineString )
{
if( IsNewIngres() )
pszGeometryType = "MULTILINESTRING";
}
else if( wkbFlatten(eType) == wkbMultiPoint )
{
if( IsNewIngres() )
pszGeometryType = "MULTIPOINT";
}
else if( wkbFlatten(eType) == wkbGeometryCollection )
{
if( IsNewIngres() )
pszGeometryType = "GEOMETRYCOLLECTION";
}
else if( wkbFlatten(eType) == wkbUnknown )
{
if( IsNewIngres() )
// this is also used as the generic geometry type.
pszGeometryType = "GEOMETRYCOLLECTION";
}
/* -------------------------------------------------------------------- */
/* Try to get the SRS Id of this spatial reference system, */
/* adding tot the srs table if needed. */
/* -------------------------------------------------------------------- */
int nSRSId = -1;
if( poSRS != NULL && IsNewIngres() == TRUE )
nSRSId = FetchSRSId( poSRS );
/* -------------------------------------------------------------------- */
/* Form table creation command. */
/* -------------------------------------------------------------------- */
CPLString osCommand;
if( pszGeometryType == NULL )
{
osCommand.Printf( "CREATE TABLE %s ( "
" %s INTEGER )",
pszLayerName, pszExpectedFIDName );
}
else
{
if(nSRSId != -1)
{
osCommand.Printf( "CREATE TABLE %s ("
" %s INTEGER NOT NULL PRIMARY KEY GENERATED BY DEFAULT AS seq_%s IDENTITY (START WITH 1 INCREMENT BY 1),"
" %s %s SRID %d ) ",
pszLayerName,
pszExpectedFIDName,
pszLayerName,
pszGeomColumnName,
pszGeometryType,
nSRSId);
}
else
{
osCommand.Printf( "CREATE TABLE %s ("
" %s INTEGER NOT NULL PRIMARY KEY GENERATED BY DEFAULT AS seq_%s IDENTITY (START WITH 1 INCREMENT BY 1),"
" %s %s )",
pszLayerName,
pszExpectedFIDName,
pszLayerName,
pszGeomColumnName,
pszGeometryType);
}
}
/* -------------------------------------------------------------------- */
/* Execute the create table command. */
/* -------------------------------------------------------------------- */
{
OGRIngresStatement oStmt( hConn );
if( !oStmt.ExecuteSQL( osCommand ) )
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRIngresTableLayer *poLayer;
OGRErr eErr;
poLayer = new OGRIngresTableLayer( this, pszLayerName, TRUE, nSRSId );
eErr = poLayer->Initialize(pszLayerName);
if (eErr == OGRERR_FAILURE)
{
delete poLayer;
return NULL;
}
poLayer->SetLaunderFlag( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) );
poLayer->SetPrecisionFlag( CSLFetchBoolean(papszOptions,"PRECISION",TRUE));
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGRIngresLayer **)
CPLRealloc( papoLayers, sizeof(OGRIngresLayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
CPLFree( pszLayerName );
return poLayer;
}
OGRLayer *OGRCARTODataSource::ICreateLayer( const char *pszNameIn,
OGRSpatialReference *poSpatialRef,
OGRwkbGeometryType eGType,
char ** papszOptions )
{
if (!bReadWrite)
{
CPLError(CE_Failure, CPLE_AppDefined, "Operation not available in read-only mode");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszNameIn,papoLayers[iLayer]->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( iLayer );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszNameIn );
return NULL;
}
}
}
CPLString osName(pszNameIn);
if( CPLFetchBool(const_cast<const char**>(papszOptions), "LAUNDER", true) )
{
char* pszTmp = OGRPGCommonLaunderName(pszNameIn);
osName = pszTmp;
CPLFree(pszTmp);
}
OGRCARTOTableLayer* poLayer = new OGRCARTOTableLayer(this, osName);
const bool bGeomNullable = CPLFetchBool(const_cast<const char**>(papszOptions), "GEOMETRY_NULLABLE", true);
int nSRID = (poSpatialRef && eGType != wkbNone) ? FetchSRSId( poSpatialRef ) : 0;
bool bCartoify = CPLFetchBool(const_cast<const char**>(papszOptions), "CARTODBFY",
CPLFetchBool(const_cast<const char**>(papszOptions), "CARTODBIFY",
true));
if( bCartoify )
{
if( nSRID != 4326 )
{
if( eGType != wkbNone )
{
CPLError(CE_Warning, CPLE_AppDefined,
"Cannot register table in dashboard with "
"cdb_cartodbfytable() since its SRS is not EPSG:4326");
}
bCartoify = false;
}
}
poLayer->SetLaunderFlag( CPLFetchBool(const_cast<const char**>(papszOptions), "LAUNDER", true) );
poLayer->SetDeferredCreation(eGType, poSpatialRef, bGeomNullable, bCartoify);
papoLayers = (OGRCARTOTableLayer**) CPLRealloc(
papoLayers, (nLayers + 1) * sizeof(OGRCARTOTableLayer*));
papoLayers[nLayers ++] = poLayer;
return poLayer;
}
OGRLayer *
OGROCIDataSource::CreateLayer( const char * pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
char szCommand[1024];
char *pszSafeLayerName = CPLStrdup(pszLayerName);
poSession->CleanName( pszSafeLayerName );
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszSafeLayerName,
papoLayers[iLayer]->GetLayerDefn()->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( pszSafeLayerName );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszSafeLayerName );
CPLFree( pszSafeLayerName );
return NULL;
}
}
}
/* -------------------------------------------------------------------- */
/* Try to get the SRS Id of this spatial reference system, */
/* adding tot the srs table if needed. */
/* -------------------------------------------------------------------- */
char szSRSId[100];
if( CSLFetchNameValue( papszOptions, "SRID" ) != NULL )
strcpy( szSRSId, CSLFetchNameValue( papszOptions, "SRID" ) );
else if( poSRS != NULL )
sprintf( szSRSId, "%d", FetchSRSId( poSRS ) );
else
strcpy( szSRSId, "NULL" );
/* -------------------------------------------------------------------- */
/* Determine name of geometry column to use. */
/* -------------------------------------------------------------------- */
const char *pszGeometryName =
CSLFetchNameValue( papszOptions, "GEOMETRY_NAME" );
if( pszGeometryName == NULL )
pszGeometryName = "ORA_GEOMETRY";
/* -------------------------------------------------------------------- */
/* Create a basic table with the FID. Also include the */
/* geometry if this is not a PostGIS enabled table. */
/* -------------------------------------------------------------------- */
const char *pszExpectedFIDName =
CPLGetConfigOption( "OCI_FID", "OGR_FID" );
OGROCIStatement oStatement( poSession );
/* -------------------------------------------------------------------- */
/* If geometry type is wkbNone, do not create a geoemtry column */
/* -------------------------------------------------------------------- */
if (eType == wkbNone)
{
sprintf( szCommand,
"CREATE TABLE \"%s\" ( "
"%s INTEGER)",
pszSafeLayerName, pszExpectedFIDName);
}
else
{
sprintf( szCommand,
"CREATE TABLE \"%s\" ( "
"%s INTEGER, "
"%s %s )",
pszSafeLayerName, pszExpectedFIDName, pszGeometryName, SDO_GEOMETRY );
}
if( oStatement.Execute( szCommand ) != CE_None )
{
CPLFree( pszSafeLayerName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
const char *pszLoaderFile = CSLFetchNameValue(papszOptions,"LOADER_FILE");
OGROCIWritableLayer *poLayer;
if( pszLoaderFile == NULL )
poLayer = new OGROCITableLayer( this, pszSafeLayerName,
EQUAL(szSRSId,"NULL") ? -1 : atoi(szSRSId),
TRUE, TRUE );
else
poLayer =
new OGROCILoaderLayer( this, pszSafeLayerName,
pszGeometryName,
EQUAL(szSRSId,"NULL") ? -1 : atoi(szSRSId),
pszLoaderFile );
/* -------------------------------------------------------------------- */
/* Set various options on the layer. */
/* -------------------------------------------------------------------- */
poLayer->SetLaunderFlag( CSLFetchBoolean(papszOptions,"LAUNDER",FALSE) );
poLayer->SetPrecisionFlag( CSLFetchBoolean(papszOptions,"PRECISION",TRUE));
if( CSLFetchNameValue(papszOptions,"DIM") != NULL )
poLayer->SetDimension( atoi(CSLFetchNameValue(papszOptions,"DIM")) );
poLayer->SetOptions( papszOptions );
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGROCILayer **)
CPLRealloc( papoLayers, sizeof(OGROCILayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
CPLFree( pszSafeLayerName );
return poLayer;
}
OGRLayer * OGRCARTODataSource::ExecuteSQLInternal( const char *pszSQLCommand,
OGRGeometry *poSpatialFilter,
const char *pszDialect,
int bRunDeferredActions )
{
if( bRunDeferredActions )
{
for( int iLayer = 0; iLayer < nLayers; iLayer++ )
{
papoLayers[iLayer]->RunDeferredCreationIfNecessary();
CPL_IGNORE_RET_VAL(papoLayers[iLayer]->FlushDeferredInsert());
papoLayers[iLayer]->RunDeferredCartofy();
}
}
/* Skip leading spaces */
while(*pszSQLCommand == ' ')
pszSQLCommand ++;
/* -------------------------------------------------------------------- */
/* 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++;
for( int iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(papoLayers[iLayer]->GetName(),
pszLayerName ))
{
DeleteLayer( iLayer );
break;
}
}
return NULL;
}
if( !STARTS_WITH_CI(pszSQLCommand, "SELECT") &&
!STARTS_WITH_CI(pszSQLCommand, "EXPLAIN") &&
!STARTS_WITH_CI(pszSQLCommand, "WITH") )
{
RunSQL(pszSQLCommand);
return NULL;
}
OGRCARTOResultLayer* poLayer = new OGRCARTOResultLayer( this, pszSQLCommand );
if( poSpatialFilter != NULL )
poLayer->SetSpatialFilter( poSpatialFilter );
if( !poLayer->IsOK() )
{
delete poLayer;
return NULL;
}
return poLayer;
}
OGRLayer *OGRCARTODBDataSource::ICreateLayer( const char *pszName,
OGRSpatialReference *poSpatialRef,
OGRwkbGeometryType eGType,
char ** papszOptions )
{
if (!bReadWrite)
{
CPLError(CE_Failure, CPLE_AppDefined, "Operation not available in read-only mode");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszName,papoLayers[iLayer]->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( iLayer );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszName );
return NULL;
}
}
}
int nSRID = 0;
if( poSpatialRef != NULL )
nSRID = FetchSRSId( poSpatialRef );
CPLString osGeomType;
if( eGType != wkbNone )
{
osGeomType = OGRToOGCGeomType(eGType);
if( eGType & wkb25DBit )
osGeomType += "Z";
}
CPLString osSQL;
osSQL.Printf("CREATE TABLE %s ( %s SERIAL, ",
OGRCARTODBEscapeIdentifier(pszName).c_str(),
"cartodb_id");
if( osGeomType.size() > 0 )
{
osSQL += CPLSPrintf("%s GEOMETRY(%s, %d), %s GEOMETRY(%s, %d),",
"the_geom",
osGeomType.c_str(),
nSRID,
"the_geom_webmercator",
osGeomType.c_str(),
3857);
}
osSQL += CPLSPrintf("PRIMARY KEY (%s) )", "cartodb_id");
osSQL += ";";
osSQL += CPLSPrintf("DROP SEQUENCE IF EXISTS %s",
OGRCARTODBEscapeIdentifier(CPLSPrintf("%s_%s_seq", pszName, "cartodb_id")).c_str());
osSQL += ";";
osSQL += CPLSPrintf("CREATE SEQUENCE %s START 1",
OGRCARTODBEscapeIdentifier(CPLSPrintf("%s_%s_seq", pszName, "cartodb_id")).c_str());
osSQL += ";";
osSQL += CPLSPrintf("ALTER TABLE %s ALTER COLUMN %s SET DEFAULT nextval('%s')",
pszName,
"cartodb_id",
OGRCARTODBEscapeLiteral(CPLSPrintf("%s_%s_seq", pszName, "cartodb_id")).c_str());
json_object* poObj = RunSQL(osSQL);
if( poObj == NULL )
return NULL;
json_object_put(poObj);
OGRCARTODBTableLayer* poLayer = new OGRCARTODBTableLayer(this, pszName);
papoLayers = (OGRLayer**) CPLRealloc(
papoLayers, (nLayers + 1) * sizeof(OGRLayer*));
papoLayers[nLayers ++] = poLayer;
return poLayer;
}
OGRLayer *
OGROCIDataSource::ICreateLayer( const char * pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
char szCommand[1024];
char *pszSafeLayerName = CPLStrdup(pszLayerName);
poSession->CleanName( pszSafeLayerName );
CPLDebug( "OCI", "In Create Layer ..." );
bNoLogging = CPLFetchBool( papszOptions, "NO_LOGGING", false );
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
if( CPLFetchBool( papszOptions, "TRUNCATE", false ) )
{
CPLDebug( "OCI", "Calling TruncateLayer for %s", pszLayerName );
TruncateLayer( pszSafeLayerName );
}
else
{
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszSafeLayerName,
papoLayers[iLayer]->GetLayerDefn()->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( pszSafeLayerName );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszSafeLayerName );
CPLFree( pszSafeLayerName );
return NULL;
}
}
}
}
/* -------------------------------------------------------------------- */
/* Try to get the SRS Id of this spatial reference system, */
/* adding tot the srs table if needed. */
/* -------------------------------------------------------------------- */
char szSRSId[100];
if( CSLFetchNameValue( papszOptions, "SRID" ) != NULL )
strcpy( szSRSId, CSLFetchNameValue( papszOptions, "SRID" ) );
else if( poSRS != NULL )
snprintf( szSRSId, sizeof(szSRSId), "%d", FetchSRSId( poSRS ) );
else
strcpy( szSRSId, "NULL" );
/* -------------------------------------------------------------------- */
/* Determine name of geometry column to use. */
/* -------------------------------------------------------------------- */
const char *pszGeometryName =
CSLFetchNameValue( papszOptions, "GEOMETRY_NAME" );
if( pszGeometryName == NULL )
pszGeometryName = "ORA_GEOMETRY";
const bool bGeomNullable =
CPLFetchBool(papszOptions, "GEOMETRY_NULLABLE", true);
/* -------------------------------------------------------------------- */
/* Create a basic table with the FID. Also include the */
/* geometry if this is not a PostGIS enabled table. */
/* -------------------------------------------------------------------- */
const char *pszExpectedFIDName =
CPLGetConfigOption( "OCI_FID", "OGR_FID" );
OGROCIStatement oStatement( poSession );
/* -------------------------------------------------------------------- */
/* If geometry type is wkbNone, do not create a geometry column. */
/* -------------------------------------------------------------------- */
if ( CSLFetchNameValue( papszOptions, "TRUNCATE" ) == NULL )
{
if (eType == wkbNone)
{
snprintf( szCommand, sizeof(szCommand),
"CREATE TABLE \"%s\" ( "
"%s INTEGER PRIMARY KEY)",
pszSafeLayerName, pszExpectedFIDName);
}
else
{
snprintf( szCommand, sizeof(szCommand),
"CREATE TABLE \"%s\" ( "
"%s INTEGER PRIMARY KEY, "
"%s %s%s )",
pszSafeLayerName, pszExpectedFIDName,
pszGeometryName, SDO_GEOMETRY,
(!bGeomNullable) ? " NOT NULL":"");
}
if (bNoLogging)
{
char szCommand2[1024];
strncpy( szCommand2, szCommand, sizeof(szCommand) );
snprintf( szCommand, sizeof(szCommand), "%s NOLOGGING "
"VARRAY %s.SDO_ELEM_INFO STORE AS SECUREFILE LOB (NOCACHE NOLOGGING) "
"VARRAY %s.SDO_ORDINATES STORE AS SECUREFILE LOB (NOCACHE NOLOGGING) ",
szCommand2, pszGeometryName, pszGeometryName);
}
if( oStatement.Execute( szCommand ) != CE_None )
{
CPLFree( pszSafeLayerName );
return NULL;
}
}
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
const char *pszLoaderFile = CSLFetchNameValue(papszOptions,"LOADER_FILE");
OGROCIWritableLayer *poLayer;
if( pszLoaderFile == NULL )
poLayer = new OGROCITableLayer( this, pszSafeLayerName, eType,
EQUAL(szSRSId,"NULL") ? -1 : atoi(szSRSId),
TRUE, TRUE );
else
poLayer =
new OGROCILoaderLayer( this, pszSafeLayerName,
pszGeometryName,
EQUAL(szSRSId,"NULL") ? -1 : atoi(szSRSId),
pszLoaderFile );
/* -------------------------------------------------------------------- */
/* Set various options on the layer. */
/* -------------------------------------------------------------------- */
poLayer->SetLaunderFlag( CPLFetchBool(papszOptions, "LAUNDER", false) );
poLayer->SetPrecisionFlag( CPLFetchBool(papszOptions, "PRECISION", true));
if( CSLFetchNameValue(papszOptions,"DIM") != NULL )
poLayer->SetDimension( atoi(CSLFetchNameValue(papszOptions,"DIM")) );
poLayer->SetOptions( papszOptions );
if( eType != wkbNone && !bGeomNullable )
poLayer->GetLayerDefn()->GetGeomFieldDefn(0)->SetNullable(FALSE);
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGROCILayer **)
CPLRealloc( papoLayers, sizeof(OGROCILayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
CPLFree( pszSafeLayerName );
return poLayer;
}
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* OGRGeoPackageDataSource::CreateLayer( const char * pszLayerName,
OGRSpatialReference * poSpatialRef,
OGRwkbGeometryType eGType,
char **papszOptions )
{
int iLayer;
OGRErr err;
if( !m_bUpdate )
return NULL;
/* Read GEOMETRY_COLUMN option */
const char* pszGeomColumnName = CSLFetchNameValue(papszOptions, "GEOMETRY_COLUMN");
if (pszGeomColumnName == NULL)
pszGeomColumnName = "geom";
/* Read FID option */
const char* pszFIDColumnName = CSLFetchNameValue(papszOptions, "FID");
if (pszFIDColumnName == NULL)
pszFIDColumnName = "fid";
if ( strspn(pszFIDColumnName, "`~!@#$%^&*()+-={}|[]\\:\";'<>?,./") > 0 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"The primary key (%s) name may not contain special characters or spaces",
pszFIDColumnName);
return NULL;
}
/* Avoiding gpkg prefixes is not an official requirement, but seems wise */
if (strncmp(pszLayerName, "gpkg", 4) == 0)
{
CPLError(CE_Failure, CPLE_AppDefined,
"The layer name may not begin with 'gpkg' as it is a reserved geopackage prefix");
return NULL;
}
/* Pre-emptively try and avoid sqlite3 syntax errors due to */
/* illegal characters */
if ( strspn(pszLayerName, "`~!@#$%^&*()+-={}|[]\\:\";'<>?,./") > 0 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"The layer name may not contain special characters or spaces");
return NULL;
}
/* Check for any existing layers that already use this name */
for( iLayer = 0; iLayer < m_nLayers; iLayer++ )
{
if( EQUAL(pszLayerName, m_papoLayers[iLayer]->GetName()) )
{
const char *pszOverwrite = CSLFetchNameValue(papszOptions,"OVERWRITE");
if( pszOverwrite != NULL && CSLTestBoolean(pszOverwrite) )
{
DeleteLayer( iLayer );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszLayerName );
return NULL;
}
}
}
/* Read our SRS_ID from the OGRSpatialReference */
int nSRSId = UNDEFINED_SRID;
if( poSpatialRef != NULL )
nSRSId = GetSrsId( poSpatialRef );
/* Requirement 25: The geometry_type_name value in a gpkg_geometry_columns */
/* row SHALL be one of the uppercase geometry type names specified in */
/* Geometry Types (Normative). */
const char *pszGeometryType = OGRToOGCGeomType(eGType);
/* Create the table! */
char *pszSQL = NULL;
if ( eGType != wkbNone )
{
pszSQL = sqlite3_mprintf(
"CREATE TABLE %s ( "
"%s INTEGER PRIMARY KEY AUTOINCREMENT, "
"%s %s )",
pszLayerName, pszFIDColumnName, pszGeomColumnName, pszGeometryType);
}
else
{
pszSQL = sqlite3_mprintf(
"CREATE TABLE %s ( "
"%s INTEGER PRIMARY KEY AUTOINCREMENT )",
pszLayerName, pszFIDColumnName);
}
err = SQLCommand(m_poDb, pszSQL);
sqlite3_free(pszSQL);
if ( OGRERR_NONE != err )
return NULL;
/* Only spatial tables need to be registered in the metadata (hmmm) */
if ( eGType != wkbNone )
{
/* Requirement 27: The z value in a gpkg_geometry_columns table row */
/* SHALL be one of 0 (none), 1 (mandatory), or 2 (optional) */
int bGeometryTypeHasZ = (wkb25DBit & eGType) != 0;
/* Update gpkg_geometry_columns with the table info */
pszSQL = sqlite3_mprintf(
"INSERT INTO gpkg_geometry_columns "
"(table_name,column_name,geometry_type_name,srs_id,z,m)"
" VALUES "
"('%q','%q','%q',%d,%d,%d)",
pszLayerName,pszGeomColumnName,pszGeometryType,
nSRSId,bGeometryTypeHasZ,0);
err = SQLCommand(m_poDb, pszSQL);
sqlite3_free(pszSQL);
if ( err != OGRERR_NONE )
return NULL;
/* Update gpkg_contents with the table info */
pszSQL = sqlite3_mprintf(
"INSERT INTO gpkg_contents "
"(table_name,data_type,identifier,last_change,srs_id)"
" VALUES "
"('%q','features','%q',strftime('%%Y-%%m-%%dT%%H:%%M:%%fZ',CURRENT_TIMESTAMP),%d)",
pszLayerName, pszLayerName, nSRSId);
err = SQLCommand(m_poDb, pszSQL);
sqlite3_free(pszSQL);
if ( err != OGRERR_NONE )
return NULL;
}
/* This is where spatial index logic will go in the future */
const char *pszSI = CSLFetchNameValue( papszOptions, "SPATIAL_INDEX" );
int bCreateSpatialIndex = ( pszSI == NULL || CSLTestBoolean(pszSI) );
if( eGType != wkbNone && bCreateSpatialIndex )
{
/* This is where spatial index logic will go in the future */
}
/* The database is now all set up, so create a blank layer and read in the */
/* info from the database. */
OGRGeoPackageLayer *poLayer = new OGRGeoPackageLayer(this, pszLayerName);
if( OGRERR_NONE != poLayer->ReadTableDefinition() )
{
delete poLayer;
return NULL;
}
m_papoLayers = (OGRLayer**)CPLRealloc(m_papoLayers, sizeof(OGRGeoPackageLayer*) * (m_nLayers+1));
m_papoLayers[m_nLayers++] = poLayer;
return poLayer;
}
