static
void OGR2SQLITE_ST_AsText(sqlite3_context* pContext,
int argc, sqlite3_value** argv)
{
OGRGeometry* poGeom = OGR2SQLITE_GetGeom(pContext, argc, argv, NULL);
if( poGeom != NULL )
{
char* pszWKT = NULL;
if( poGeom->exportToWkt(&pszWKT) == OGRERR_NONE )
sqlite3_result_text( pContext, pszWKT, -1, CPLFree);
else
sqlite3_result_null (pContext);
delete poGeom;
}
else
sqlite3_result_null (pContext);
}
OGRErr OGRMSSQLSpatialTableLayer::CreateFeature( OGRFeature *poFeature )
{
GetLayerDefn();
if( NULL == poFeature )
{
CPLError( CE_Failure, CPLE_AppDefined,
"NULL pointer to OGRFeature passed to CreateFeature()." );
return OGRERR_FAILURE;
}
ClearStatement();
CPLODBCStatement oStatement( poDS->GetSession() );
/* the fid values are retieved from the source layer */
if( poFeature->GetFID() != OGRNullFID && pszFIDColumn != NULL )
oStatement.Appendf("SET IDENTITY_INSERT [%s].[%s] ON;", pszSchemaName, pszTableName );
/* -------------------------------------------------------------------- */
/* Form the INSERT command. */
/* -------------------------------------------------------------------- */
oStatement.Appendf( "INSERT INTO [%s].[%s] (", pszSchemaName, pszTableName );
OGRMSSQLGeometryValidator oValidator(poFeature->GetGeometryRef());
OGRGeometry *poGeom = oValidator.GetValidGeometryRef();
if (poFeature->GetGeometryRef() != poGeom)
{
CPLError( CE_Warning, CPLE_NotSupported,
"Geometry with FID = %ld has been modified.", poFeature->GetFID() );
}
int bNeedComma = FALSE;
if (poGeom != NULL && pszGeomColumn != NULL)
{
oStatement.Append( pszGeomColumn );
bNeedComma = TRUE;
}
if( poFeature->GetFID() != OGRNullFID && pszFIDColumn != NULL )
{
if (bNeedComma)
oStatement.Appendf( ", [%s]", pszFIDColumn );
else
{
oStatement.Appendf( "[%s]", pszFIDColumn );
bNeedComma = TRUE;
}
}
int nFieldCount = poFeatureDefn->GetFieldCount();
int i;
for( i = 0; i < nFieldCount; i++ )
{
if( !poFeature->IsFieldSet( i ) )
continue;
if (bNeedComma)
oStatement.Appendf( ", [%s]", poFeatureDefn->GetFieldDefn(i)->GetNameRef() );
else
{
oStatement.Appendf( "[%s]", poFeatureDefn->GetFieldDefn(i)->GetNameRef() );
bNeedComma = TRUE;
}
}
oStatement.Appendf( ") VALUES (" );
/* Set the geometry */
bNeedComma = FALSE;
if(poGeom != NULL && pszGeomColumn != NULL)
{
char *pszWKT = NULL;
//poGeom->setCoordinateDimension( nCoordDimension );
poGeom->exportToWkt( &pszWKT );
if( pszWKT != NULL && (nGeomColumnType == MSSQLCOLTYPE_GEOMETRY
|| nGeomColumnType == MSSQLCOLTYPE_GEOGRAPHY))
{
if (nGeomColumnType == MSSQLCOLTYPE_GEOGRAPHY)
{
oStatement.Append( "geography::STGeomFromText(" );
OGRMSSQLAppendEscaped(&oStatement, pszWKT);
oStatement.Appendf(",%d)", nSRSId );
}
else
{
oStatement.Append( "geometry::STGeomFromText(" );
OGRMSSQLAppendEscaped(&oStatement, pszWKT);
oStatement.Appendf(",%d).MakeValid()", nSRSId );
}
}
else
oStatement.Append( "null" );
bNeedComma = TRUE;
CPLFree(pszWKT);
}
/* Set the FID */
if( poFeature->GetFID() != OGRNullFID && pszFIDColumn != NULL )
{
if (bNeedComma)
oStatement.Appendf( ", %ld", poFeature->GetFID() );
else
{
oStatement.Appendf( "%ld", poFeature->GetFID() );
bNeedComma = TRUE;
}
}
for( i = 0; i < nFieldCount; i++ )
{
if( !poFeature->IsFieldSet( i ) )
continue;
if (bNeedComma)
oStatement.Append( ", " );
else
bNeedComma = TRUE;
AppendFieldValue(&oStatement, poFeature, i);
}
oStatement.Append( ");" );
if( poFeature->GetFID() != OGRNullFID && pszFIDColumn != NULL )
oStatement.Appendf("SET IDENTITY_INSERT [%s].[%s] OFF;", pszSchemaName, pszTableName );
/* -------------------------------------------------------------------- */
/* Execute the insert. */
/* -------------------------------------------------------------------- */
if( !oStatement.ExecuteSQL() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"INSERT command for new feature failed. %s",
poDS->GetSession()->GetLastError() );
return OGRERR_FAILURE;
}
return OGRERR_NONE;
}
OGRErr OGRMSSQLSpatialTableLayer::SetFeature( OGRFeature *poFeature )
{
OGRErr eErr = OGRERR_FAILURE;
GetLayerDefn();
if( NULL == poFeature )
{
CPLError( CE_Failure, CPLE_AppDefined,
"NULL pointer to OGRFeature passed to SetFeature()." );
return eErr;
}
if( poFeature->GetFID() == OGRNullFID )
{
CPLError( CE_Failure, CPLE_AppDefined,
"FID required on features given to SetFeature()." );
return eErr;
}
if( !pszFIDColumn )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to update features in tables without\n"
"a recognised FID column.");
return eErr;
}
ClearStatement();
/* -------------------------------------------------------------------- */
/* Form the UPDATE command. */
/* -------------------------------------------------------------------- */
CPLODBCStatement oStmt( poDS->GetSession() );
oStmt.Appendf( "UPDATE [%s].[%s] SET ", pszSchemaName, pszTableName);
OGRMSSQLGeometryValidator oValidator(poFeature->GetGeometryRef());
OGRGeometry *poGeom = oValidator.GetValidGeometryRef();
if (poFeature->GetGeometryRef() != poGeom)
{
CPLError( CE_Warning, CPLE_NotSupported,
"Geometry with FID = %ld has been modified.", poFeature->GetFID() );
}
int bNeedComma = FALSE;
if(pszGeomColumn != NULL)
{
char *pszWKT = NULL;
if (poGeom != NULL)
poGeom->exportToWkt( &pszWKT );
oStmt.Appendf( "[%s] = ", pszGeomColumn );
if( pszWKT != NULL && (nGeomColumnType == MSSQLCOLTYPE_GEOMETRY
|| nGeomColumnType == MSSQLCOLTYPE_GEOGRAPHY))
{
if (nGeomColumnType == MSSQLCOLTYPE_GEOGRAPHY)
{
oStmt.Append( "geography::STGeomFromText(" );
OGRMSSQLAppendEscaped(&oStmt, pszWKT);
oStmt.Appendf(",%d)", nSRSId );
}
else
{
oStmt.Append( "geometry::STGeomFromText(" );
OGRMSSQLAppendEscaped(&oStmt, pszWKT);
oStmt.Appendf(",%d).MakeValid()", nSRSId );
}
}
else
oStmt.Append( "null" );
bNeedComma = TRUE;
CPLFree(pszWKT);
}
int nFieldCount = poFeatureDefn->GetFieldCount();
int i;
for( i = 0; i < nFieldCount; i++ )
{
if (bNeedComma)
oStmt.Appendf( ", [%s] = ", poFeatureDefn->GetFieldDefn(i)->GetNameRef() );
else
{
oStmt.Appendf( "[%s] = ", poFeatureDefn->GetFieldDefn(i)->GetNameRef() );
bNeedComma = TRUE;
}
if( !poFeature->IsFieldSet( i ) )
oStmt.Append( "null" );
else
AppendFieldValue(&oStmt, poFeature, i);
}
/* Add the WHERE clause */
oStmt.Appendf( " WHERE [%s] = %ld" , pszFIDColumn, poFeature->GetFID());
/* -------------------------------------------------------------------- */
/* Execute the update. */
/* -------------------------------------------------------------------- */
if( !oStmt.ExecuteSQL() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error updating feature with FID:%ld, %s", poFeature->GetFID(),
poDS->GetSession()->GetLastError() );
return OGRERR_FAILURE;
}
return OGRERR_NONE;
}
CPLString OGRPLScenesLayer::BuildURL(int nFeatures)
{
CPLString osURL = osBaseURL + CPLSPrintf("?count=%d", nFeatures);
if( bAcquiredAscending == 1 )
osURL += "&order_by=acquired%20asc";
else if( bAcquiredAscending == 0 )
osURL += "&order_by=acquired%20desc";
if( m_poFilterGeom != NULL || poMainFilter != NULL )
{
OGRGeometry* poIntersection = NULL;
OGRGeometry* poFilterGeom = m_poFilterGeom;
if( poFilterGeom )
{
OGREnvelope sEnvelope;
poFilterGeom->getEnvelope(&sEnvelope);
if( sEnvelope.MinX <= -180 && sEnvelope.MinY <= -90 &&
sEnvelope.MaxX >= 180 && sEnvelope.MaxY >= 90 )
poFilterGeom = NULL;
}
if( poFilterGeom && poMainFilter )
poIntersection = poFilterGeom->Intersection(poMainFilter);
else if( poFilterGeom )
poIntersection = poFilterGeom;
else if( poMainFilter )
poIntersection = poMainFilter;
if( poIntersection )
{
char* pszWKT = NULL;
OGREnvelope sEnvelope;
poIntersection->getEnvelope(&sEnvelope);
if( sEnvelope.MinX == sEnvelope.MaxX && sEnvelope.MinY == sEnvelope.MaxY )
{
pszWKT = CPLStrdup(CPLSPrintf("POINT(%.18g %.18g)",
sEnvelope.MinX, sEnvelope.MinY));
}
else
poIntersection->exportToWkt(&pszWKT);
osURL += "&intersects=";
char* pszWKTEscaped = CPLEscapeString(pszWKT, -1, CPLES_URL);
osURL += pszWKTEscaped;
CPLFree(pszWKTEscaped);
CPLFree(pszWKT);
}
if( poIntersection != m_poFilterGeom && poIntersection != poMainFilter )
delete poIntersection;
}
if( osFilterURLPart.size() )
{
if( osFilterURLPart[0] == '&' )
osURL += osFilterURLPart;
else
osURL = osBaseURL + osFilterURLPart;
}
return osURL;
}
OGRErr OGRCSVLayer::CreateFeature( OGRFeature *poNewFeature )
{
int iField;
if( !bInWriteMode )
{
CPLError( CE_Failure, CPLE_AppDefined,
"The CreateFeature() operation is not permitted on a read-only CSV." );
return OGRERR_FAILURE;
}
/* If we need rewind, it means that we have just written a feature before */
/* so there's no point seeking to the end of the file, as we're already */
/* at the end */
int bNeedSeekEnd = !bNeedRewindBeforeRead;
bNeedRewindBeforeRead = TRUE;
/* -------------------------------------------------------------------- */
/* Write field names if we haven't written them yet. */
/* Write .csvt file if needed */
/* -------------------------------------------------------------------- */
if( bNew )
{
OGRErr eErr = WriteHeader();
if (eErr != OGRERR_NONE)
return eErr;
bNeedSeekEnd = FALSE;
}
if (fpCSV == NULL)
return OGRERR_FAILURE;
/* -------------------------------------------------------------------- */
/* Make sure we are at the end of the file. */
/* -------------------------------------------------------------------- */
if (bNeedSeekEnd)
{
if (bFirstFeatureAppendedDuringSession)
{
/* Add a newline character to the end of the file if necessary */
bFirstFeatureAppendedDuringSession = FALSE;
VSIFSeekL( fpCSV, 0, SEEK_END );
VSIFSeekL( fpCSV, VSIFTellL(fpCSV) - 1, SEEK_SET);
char chLast;
VSIFReadL( &chLast, 1, 1, fpCSV );
VSIFSeekL( fpCSV, 0, SEEK_END );
if (chLast != '\n')
{
if( bUseCRLF )
VSIFPutcL( 13, fpCSV );
VSIFPutcL( '\n', fpCSV );
}
}
else
{
VSIFSeekL( fpCSV, 0, SEEK_END );
}
}
/* -------------------------------------------------------------------- */
/* Write out the geometry */
/* -------------------------------------------------------------------- */
if (eGeometryFormat == OGR_CSV_GEOM_AS_WKT)
{
OGRGeometry *poGeom = poNewFeature->GetGeometryRef();
char* pszWKT = NULL;
if (poGeom && poGeom->exportToWkt(&pszWKT) == OGRERR_NONE)
{
VSIFPrintfL( fpCSV, "\"%s\"", pszWKT);
}
else
{
VSIFPrintfL( fpCSV, "\"\"");
}
CPLFree(pszWKT);
if (poFeatureDefn->GetFieldCount() > 0)
VSIFPrintfL( fpCSV, "%c", chDelimiter);
}
else if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ ||
eGeometryFormat == OGR_CSV_GEOM_AS_XY ||
eGeometryFormat == OGR_CSV_GEOM_AS_YX)
{
OGRGeometry *poGeom = poNewFeature->GetGeometryRef();
if (poGeom && wkbFlatten(poGeom->getGeometryType()) == wkbPoint)
{
OGRPoint* poPoint = (OGRPoint*) poGeom;
char szBuffer[75];
if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ )
OGRMakeWktCoordinate(szBuffer, poPoint->getX(), poPoint->getY(), poPoint->getZ(), 3);
else if (eGeometryFormat == OGR_CSV_GEOM_AS_XY )
OGRMakeWktCoordinate(szBuffer, poPoint->getX(), poPoint->getY(), 0, 2);
else
OGRMakeWktCoordinate(szBuffer, poPoint->getY(), poPoint->getX(), 0, 2);
char* pc = szBuffer;
while(*pc != '\0')
{
if (*pc == ' ')
*pc = chDelimiter;
pc ++;
}
VSIFPrintfL( fpCSV, "%s", szBuffer );
}
else
{
VSIFPrintfL( fpCSV, "%c", chDelimiter );
if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ)
VSIFPrintfL( fpCSV, "%c", chDelimiter );
}
if (poFeatureDefn->GetFieldCount() > 0)
VSIFPrintfL( fpCSV, "%c", chDelimiter );
}
/* -------------------------------------------------------------------- */
/* Write out all the field values. */
/* -------------------------------------------------------------------- */
int bNonEmptyLine = FALSE;
for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
char *pszEscaped;
if( iField > 0 )
VSIFPrintfL( fpCSV, "%c", chDelimiter );
if (poFeatureDefn->GetFieldDefn(iField)->GetType() == OFTReal)
{
pszEscaped = CPLStrdup(poNewFeature->GetFieldAsString(iField));
/* Use point as decimal separator */
char* pszComma = strchr(pszEscaped, ',');
if (pszComma)
*pszComma = '.';
}
else
{
pszEscaped =
CPLEscapeString( poNewFeature->GetFieldAsString(iField),
-1, CPLES_CSV );
}
int nLen = (int)strlen(pszEscaped);
bNonEmptyLine |= (nLen != 0);
VSIFWriteL( pszEscaped, 1, nLen, fpCSV );
CPLFree( pszEscaped );
}
if( poFeatureDefn->GetFieldCount() == 1 && !bNonEmptyLine )
VSIFPrintfL( fpCSV, "%c", chDelimiter );
if( bUseCRLF )
VSIFPutcL( 13, fpCSV );
VSIFPutcL( '\n', fpCSV );
return OGRERR_NONE;
}
OGRErr OGRPGDumpLayer::CreateFeatureViaInsert( OGRFeature *poFeature )
{
CPLString osCommand;
int i = 0;
int bNeedComma = FALSE;
OGRErr eErr = OGRERR_FAILURE;
int bEmptyInsert = FALSE;
if( NULL == poFeature )
{
CPLError( CE_Failure, CPLE_AppDefined,
"NULL pointer to OGRFeature passed to CreateFeatureViaInsert()." );
return eErr;
}
/* -------------------------------------------------------------------- */
/* Form the INSERT command. */
/* -------------------------------------------------------------------- */
osCommand.Printf( "INSERT INTO %s (", pszSqlTableName );
for(i = 0; i < poFeatureDefn->GetGeomFieldCount(); i++ )
{
OGRGeometry *poGeom = poFeature->GetGeomFieldRef(i);
if( poGeom != NULL )
{
if( bNeedComma )
osCommand += ", ";
OGRGeomFieldDefn* poGFldDefn = poFeature->GetGeomFieldDefnRef(i);
osCommand = osCommand + OGRPGDumpEscapeColumnName(poGFldDefn->GetNameRef()) + " ";
bNeedComma = TRUE;
}
}
if( poFeature->GetFID() != OGRNullFID && pszFIDColumn != NULL )
{
if( bNeedComma )
osCommand += ", ";
osCommand = osCommand + OGRPGDumpEscapeColumnName(pszFIDColumn) + " ";
bNeedComma = TRUE;
}
for( i = 0; i < poFeatureDefn->GetFieldCount(); i++ )
{
if( !poFeature->IsFieldSet( i ) )
continue;
if( !bNeedComma )
bNeedComma = TRUE;
else
osCommand += ", ";
osCommand = osCommand
+ OGRPGDumpEscapeColumnName(poFeatureDefn->GetFieldDefn(i)->GetNameRef());
}
if (!bNeedComma)
bEmptyInsert = TRUE;
osCommand += ") VALUES (";
/* Set the geometry */
bNeedComma = FALSE;
for(i = 0; i < poFeatureDefn->GetGeomFieldCount(); i++ )
{
OGRGeometry *poGeom = poFeature->GetGeomFieldRef(i);
if( poGeom != NULL )
{
char *pszWKT = NULL;
OGRPGDumpGeomFieldDefn* poGFldDefn =
(OGRPGDumpGeomFieldDefn*) poFeature->GetGeomFieldDefnRef(i);
poGeom->closeRings();
poGeom->setCoordinateDimension( poGFldDefn->nCoordDimension );
if( bNeedComma )
osCommand += ", ";
if( bWriteAsHex )
{
char* pszHex = OGRGeometryToHexEWKB( poGeom, poGFldDefn->nSRSId );
osCommand += "'";
if (pszHex)
osCommand += pszHex;
osCommand += "'";
CPLFree(pszHex);
}
else
{
poGeom->exportToWkt( &pszWKT );
if( pszWKT != NULL )
{
osCommand +=
CPLString().Printf(
"GeomFromEWKT('SRID=%d;%s'::TEXT) ", poGFldDefn->nSRSId, pszWKT );
OGRFree( pszWKT );
}
else
osCommand += "''";
}
bNeedComma = TRUE;
}
}
/* Set the FID */
if( poFeature->GetFID() != OGRNullFID && pszFIDColumn != NULL )
{
if( bNeedComma )
osCommand += ", ";
osCommand += CPLString().Printf( "%ld ", poFeature->GetFID() );
bNeedComma = TRUE;
}
for( i = 0; i < poFeatureDefn->GetFieldCount(); i++ )
{
if( !poFeature->IsFieldSet( i ) )
continue;
if( bNeedComma )
osCommand += ", ";
else
bNeedComma = TRUE;
AppendFieldValue(osCommand, poFeature, i);
}
osCommand += ")";
if (bEmptyInsert)
osCommand.Printf( "INSERT INTO %s DEFAULT VALUES", pszSqlTableName );
/* -------------------------------------------------------------------- */
/* Execute the insert. */
/* -------------------------------------------------------------------- */
poDS->Log(osCommand);
return OGRERR_NONE;
}
OGRErr OGRSQLiteTableLayer::CreateFeature( OGRFeature *poFeature )
{
sqlite3 *hDB = poDS->GetDB();
CPLString osCommand;
CPLString osValues;
int bNeedComma = FALSE;
if (bSpatialiteReadOnly || !poDS->GetUpdate())
{
CPLError( CE_Failure, CPLE_NotSupported,
"Can't create feature on a read-only layer.");
return OGRERR_FAILURE;
}
ResetReading();
/* -------------------------------------------------------------------- */
/* Form the INSERT command. */
/* -------------------------------------------------------------------- */
osCommand += CPLSPrintf( "INSERT INTO '%s' (", pszEscapedTableName );
/* -------------------------------------------------------------------- */
/* Add FID if we have a cleartext FID column. */
/* -------------------------------------------------------------------- */
if( pszFIDColumn != NULL // && !EQUAL(pszFIDColumn,"OGC_FID")
&& poFeature->GetFID() != OGRNullFID )
{
osCommand += pszFIDColumn;
osValues += CPLSPrintf( "%ld", poFeature->GetFID() );
bNeedComma = TRUE;
}
/* -------------------------------------------------------------------- */
/* Add geometry. */
/* -------------------------------------------------------------------- */
OGRGeometry *poGeom = poFeature->GetGeometryRef();
if( osGeomColumn.size() != 0 &&
poGeom != NULL &&
eGeomFormat != OSGF_FGF )
{
if( bNeedComma )
{
osCommand += ",";
osValues += ",";
}
osCommand += osGeomColumn;
osValues += "?";
bNeedComma = TRUE;
}
/* -------------------------------------------------------------------- */
/* Add field values. */
/* -------------------------------------------------------------------- */
int iField;
int nFieldCount = poFeatureDefn->GetFieldCount();
for( iField = 0; iField < nFieldCount; iField++ )
{
if( !poFeature->IsFieldSet( iField ) )
continue;
if( bNeedComma )
{
osCommand += ",";
osValues += ",";
}
osCommand += "'";
osCommand +=poFeatureDefn->GetFieldDefn(iField)->GetNameRef();
osCommand += "'";
osValues += "?";
bNeedComma = TRUE;
}
/* -------------------------------------------------------------------- */
/* Merge final command. */
/* -------------------------------------------------------------------- */
osCommand += ") VALUES (";
osCommand += osValues;
osCommand += ")";
/* -------------------------------------------------------------------- */
/* Prepare the statement. */
/* -------------------------------------------------------------------- */
int rc;
sqlite3_stmt *hInsertStmt;
#ifdef DEBUG
CPLDebug( "OGR_SQLITE", "prepare(%s)", osCommand.c_str() );
#endif
rc = sqlite3_prepare( hDB, osCommand, -1, &hInsertStmt, NULL );
if( rc != SQLITE_OK )
{
CPLError( CE_Failure, CPLE_AppDefined,
"In CreateFeature(): sqlite3_prepare(%s):\n %s",
osCommand.c_str(), sqlite3_errmsg(hDB) );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Bind the geometry */
/* -------------------------------------------------------------------- */
int nBindField = 1;
if( osGeomColumn.size() != 0 &&
poGeom != NULL &&
eGeomFormat != OSGF_FGF )
{
if ( eGeomFormat == OSGF_WKT )
{
char *pszWKT = NULL;
poGeom->exportToWkt( &pszWKT );
rc = sqlite3_bind_text( hInsertStmt, nBindField++, pszWKT, -1, CPLFree );
}
else if( eGeomFormat == OSGF_WKB )
{
int nWKBLen = poGeom->WkbSize();
GByte *pabyWKB = (GByte *) CPLMalloc(nWKBLen + 1);
poGeom->exportToWkb( wkbNDR, pabyWKB );
rc = sqlite3_bind_blob( hInsertStmt, nBindField++, pabyWKB, nWKBLen, CPLFree );
}
else if ( eGeomFormat == OSGF_SpatiaLite )
{
int nBLOBLen;
GByte *pabySLBLOB;
ExportSpatiaLiteGeometry( poGeom, nSRSId, wkbNDR, bHasM,
bSpatialite2D, &pabySLBLOB, &nBLOBLen );
rc = sqlite3_bind_blob( hInsertStmt, nBindField++, pabySLBLOB,
nBLOBLen, CPLFree );
}
else
{
CPLAssert(0);
}
if( rc != SQLITE_OK )
{
CPLError( CE_Failure, CPLE_AppDefined,
"sqlite3_bind_blob/text() failed:\n %s",
sqlite3_errmsg(hDB) );
sqlite3_finalize( hInsertStmt );
return OGRERR_FAILURE;
}
}
/* -------------------------------------------------------------------- */
/* Bind field values. */
/* -------------------------------------------------------------------- */
for( iField = 0; iField < nFieldCount; iField++ )
{
const char *pszRawValue;
if( !poFeature->IsFieldSet( iField ) )
continue;
switch( poFeatureDefn->GetFieldDefn(iField)->GetType() )
{
case OFTInteger:
{
int nFieldVal = poFeature->GetFieldAsInteger( iField );
rc = sqlite3_bind_int(hInsertStmt, nBindField++, nFieldVal);
break;
}
case OFTReal:
{
double dfFieldVal = poFeature->GetFieldAsDouble( iField );
rc = sqlite3_bind_double(hInsertStmt, nBindField++, dfFieldVal);
break;
}
case OFTBinary:
{
int nDataLength = 0;
GByte* pabyData =
poFeature->GetFieldAsBinary( iField, &nDataLength );
rc = sqlite3_bind_blob(hInsertStmt, nBindField++,
pabyData, nDataLength, SQLITE_TRANSIENT);
break;
}
default:
{
pszRawValue = poFeature->GetFieldAsString( iField );
rc = sqlite3_bind_text(hInsertStmt, nBindField++,
pszRawValue, -1, SQLITE_TRANSIENT);
break;
}
}
if( rc != SQLITE_OK )
{
CPLError( CE_Failure, CPLE_AppDefined,
"sqlite3_bind_() for column %s failed:\n %s",
poFeatureDefn->GetFieldDefn(iField)->GetNameRef(),
sqlite3_errmsg(hDB) );
sqlite3_finalize( hInsertStmt );
return OGRERR_FAILURE;
}
}
/* -------------------------------------------------------------------- */
/* Execute the insert. */
/* -------------------------------------------------------------------- */
rc = sqlite3_step( hInsertStmt );
if( rc != SQLITE_OK && rc != SQLITE_DONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"sqlite3_step() failed:\n %s",
sqlite3_errmsg(hDB) );
sqlite3_finalize( hInsertStmt );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Capture the FID/rowid. */
/* -------------------------------------------------------------------- */
const sqlite_int64 nFID = sqlite3_last_insert_rowid( hDB );
if(nFID > 0)
{
poFeature->SetFID( (long)nFID ); /* Possible truncation if nFID is 64bit */
}
sqlite3_finalize( hInsertStmt );
return OGRERR_NONE;
}
OGRErr OGRMySQLTableLayer::CreateFeature( OGRFeature *poFeature )
{
MYSQL_RES *hResult=NULL;
CPLString osCommand;
int i, bNeedComma = FALSE;
/* -------------------------------------------------------------------- */
/* Form the INSERT command. */
/* -------------------------------------------------------------------- */
osCommand.Printf( "INSERT INTO `%s` (", poFeatureDefn->GetName() );
if( poFeature->GetGeometryRef() != NULL )
{
osCommand = osCommand + "`" + pszGeomColumn + "` ";
bNeedComma = TRUE;
}
if( poFeature->GetFID() != OGRNullFID && pszFIDColumn != NULL )
{
if( bNeedComma )
osCommand += ", ";
osCommand = osCommand + "`" + pszFIDColumn + "` ";
bNeedComma = TRUE;
}
for( i = 0; i < poFeatureDefn->GetFieldCount(); i++ )
{
if( !poFeature->IsFieldSet( i ) )
continue;
if( !bNeedComma )
bNeedComma = TRUE;
else
osCommand += ", ";
osCommand = osCommand + "`"
+ poFeatureDefn->GetFieldDefn(i)->GetNameRef() + "`";
}
osCommand += ") VALUES (";
// Set the geometry
bNeedComma = poFeature->GetGeometryRef() != NULL;
if( poFeature->GetGeometryRef() != NULL)
{
char *pszWKT = NULL;
if( poFeature->GetGeometryRef() != NULL )
{
OGRGeometry *poGeom = (OGRGeometry *) poFeature->GetGeometryRef();
poGeom->closeRings();
poGeom->flattenTo2D();
poGeom->exportToWkt( &pszWKT );
}
if( pszWKT != NULL )
{
osCommand +=
CPLString().Printf(
"GeometryFromText('%s',%d) ", pszWKT, nSRSId );
OGRFree( pszWKT );
}
else
osCommand += "''";
}
// Set the FID
if( poFeature->GetFID() != OGRNullFID && pszFIDColumn != NULL )
{
if( bNeedComma )
osCommand += ", ";
osCommand += CPLString().Printf( "%ld ", poFeature->GetFID() );
bNeedComma = TRUE;
}
for( i = 0; i < poFeatureDefn->GetFieldCount(); i++ )
{
if( !poFeature->IsFieldSet( i ) )
continue;
if( bNeedComma )
osCommand += ", ";
else
bNeedComma = TRUE;
const char *pszStrValue = poFeature->GetFieldAsString(i);
if( poFeatureDefn->GetFieldDefn(i)->GetType() != OFTInteger
&& poFeatureDefn->GetFieldDefn(i)->GetType() != OFTReal
&& poFeatureDefn->GetFieldDefn(i)->GetType() != OFTBinary )
{
int iChar;
//We need to quote and escape string fields.
osCommand += "'";
for( iChar = 0; pszStrValue[iChar] != '\0'; iChar++ )
{
if( poFeatureDefn->GetFieldDefn(i)->GetType() != OFTIntegerList
&& poFeatureDefn->GetFieldDefn(i)->GetType() != OFTRealList
&& poFeatureDefn->GetFieldDefn(i)->GetWidth() > 0
&& iChar == poFeatureDefn->GetFieldDefn(i)->GetWidth() )
{
CPLDebug( "MYSQL",
"Truncated %s field value, it was too long.",
poFeatureDefn->GetFieldDefn(i)->GetNameRef() );
break;
}
if( pszStrValue[iChar] == '\\'
|| pszStrValue[iChar] == '\'' )
{
osCommand += '\\';
osCommand += pszStrValue[iChar];
}
else
osCommand += pszStrValue[iChar];
}
osCommand += "'";
}
else if( poFeatureDefn->GetFieldDefn(i)->GetType() == OFTBinary )
{
int binaryCount = 0;
GByte* binaryData = poFeature->GetFieldAsBinary(i, &binaryCount);
char* pszHexValue = CPLBinaryToHex( binaryCount, binaryData );
osCommand += "x'";
osCommand += pszHexValue;
osCommand += "'";
CPLFree( pszHexValue );
}
else
{
osCommand += pszStrValue;
}
}
osCommand += ")";
int nQueryResult = mysql_query(poDS->GetConn(), osCommand.c_str() );
const my_ulonglong nFID = mysql_insert_id( poDS->GetConn() );
if( nQueryResult ){
int eErrorCode = mysql_errno(poDS->GetConn());
if (eErrorCode == 1153) {//ER_NET_PACKET_TOO_LARGE)
poDS->ReportError("CreateFeature failed because the MySQL server " \
"cannot read the entire query statement. Increase " \
"the size of statements your server will allow by " \
"altering the 'max_allowed_packet' parameter in "\
"your MySQL server configuration.");
}
else
{
CPLDebug("MYSQL","Error number %d", eErrorCode);
poDS->ReportError( osCommand.c_str() );
}
// make sure to attempt to free results
hResult = mysql_store_result( poDS->GetConn() );
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
return OGRERR_FAILURE;
}
if( nFID > 0 ) {
poFeature->SetFID( nFID );
}
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( poDS->GetConn() );
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
return OGRERR_NONE;
}
bool QgsShapeFile::insertLayer(QString dbname, QString schema, QString geom_col, QString srid, PGconn * conn, QProgressDialog * pro, bool &fin){
connect(pro, SIGNAL(cancelled()), this, SLOT(cancelImport()));
import_cancelled = false;
bool result = true;
QString query = "CREATE TABLE "+schema+"."+table_name+"(gid int4 PRIMARY KEY, ";
for(int n=0; n<column_names.size() && result; n++){
if(!column_names[n][0].isLetter())
result = false;
char * esc_str = new char[column_names[n].length()*2+1];
PQescapeString(esc_str, (const char *)column_names[n].lower(), column_names[n].length());
query += esc_str;
query += " ";
query += column_types[n];
if(n<column_names.size()-1)
query += ", ";
delete[] esc_str;
}
query += " )";
PGresult *res = PQexec(conn, (const char *)query);
qWarning(query);
if(PQresultStatus(res)!=PGRES_COMMAND_OK){
// flag error and send query and error message to stdout on debug
result = false;
qWarning(PQresultErrorMessage(res));
}
else {
PQclear(res);
}
query = "SELECT AddGeometryColumn(\'" + dbname + "\', \'" + table_name + "\', \'"+geom_col+"\', " + srid +
", \'" + geom_type + "\', 2)";
if(result) res = PQexec(conn, (const char *)query);
if(PQresultStatus(res)!=PGRES_TUPLES_OK){
result = false;
}
else{
qWarning(query);
qWarning(PQresultErrorMessage(res));
PQclear(res);
}
//adding the data into the table
for(int m=0;m<features && result; m++){
if(import_cancelled){
fin = true;
break;
}
OGRFeature *feat = ogrLayer->GetNextFeature();
if(feat){
OGRGeometry *geom = feat->GetGeometryRef();
if(geom){
query = "INSERT INTO "+schema+"."+table_name+QString(" VALUES( %1, ").arg(m);
int num = geom->WkbSize();
char * geo_temp = new char[num*3];
geom->exportToWkt(&geo_temp);
QString geometry(geo_temp);
QString quotes;
for(int n=0; n<column_types.size(); n++){
if(column_types[n] == "int" || column_types[n] == "float")
quotes = " ";
else
quotes = "\'";
query += quotes;
// escape the string value
QString val = feat->GetFieldAsString(n);
char * esc_str = new char[val.length()*2+1];
PQescapeString(esc_str, (const char *)val.lower(), val.length());
// add escaped value to the query
query += esc_str;
query += QString(quotes + ", ");
delete[] esc_str;
}
query += QString("GeometryFromText(\'")+geometry+QString("\', ")+srid+QString("))");
if(result)
res = PQexec(conn, (const char *)query);
if(PQresultStatus(res)!=PGRES_COMMAND_OK){
// flag error and send query and error message to stdout on debug
result = false;
qWarning(PQresultErrorMessage(res));
}
else {
PQclear(res);
}
pro->setProgress(pro->progress()+1);
qApp->processEvents();
delete[] geo_temp;
}
delete feat;
}
}
ogrLayer->ResetReading();
return result;
}
OGRErr OGRIDBTableLayer::ICreateFeature( OGRFeature *poFeature )
{
OGRErr eErr(OGRERR_FAILURE);
if ( ! bUpdateAccess )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error create feature. Layer is read only." );
return eErr;
}
if( NULL == poFeature )
{
CPLError( CE_Failure, CPLE_AppDefined,
"NULL pointer to OGRFeature passed to CreateFeature()." );
return eErr;
}
if( poFeature->GetFID() != OGRNullFID && pszFIDColumn == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"FID ignored on feature given to CreateFeature(). Unknown FID column." );
return eErr;
}
int bUpdateGeom = TRUE;
CPLString osGeomFunc;
if ( poFeature->GetGeometryRef() )
{
OGRwkbGeometryType nGeomType = poFeature->GetGeometryRef()->getGeometryType();
switch (nGeomType)
{
case wkbPoint:
osGeomFunc = "ST_PointFromText";
break;
case wkbLineString:
osGeomFunc = "ST_LineFromText";
break;
case wkbPolygon:
osGeomFunc = "ST_PolyFromText";
break;
case wkbMultiPoint:
osGeomFunc = "ST_MPointFromText";
break;
case wkbMultiLineString:
osGeomFunc = "ST_MLineFromText";
break;
case wkbMultiPolygon:
osGeomFunc = "ST_MPolyFromText";
break;
default:
bUpdateGeom = FALSE;
CPLDebug("OGR_IDB", "SetFeature(): Unknown geometry type. Geometry will not be updated.");
}
}
else
bUpdateGeom = FALSE;
// Create query
CPLString osSql;
CPLString osFields;
CPLString osValues;
if ( pszGeomColumn && bUpdateGeom )
{
OGRGeometry * poGeom = poFeature->GetGeometryRef();
char * wkt;
poGeom->exportToWkt( &wkt );
osFields += pszGeomColumn;
osValues.Printf( "%s( '%s', %d )", osGeomFunc.c_str(), wkt, nSRSId );
CPLFree( wkt );
}
for( int i = 0; i < poFeatureDefn->GetFieldCount(); i++ )
{
const char * pszFieldName = poFeatureDefn->GetFieldDefn(i)->GetNameRef();
// Skip NULL fields
if ( ! poFeature->IsFieldSet( i ) )
{
continue;
}
if ( ! osFields.empty() )
{
osFields += ",";
osValues += ",";
}
osFields += pszFieldName;
CPLString osVal;
switch ( poFeatureDefn->GetFieldDefn( i )->GetType() )
{
case OFTInteger:
osVal.Printf( "%d", poFeature->GetFieldAsInteger( i ) );
break;
case OFTReal:
if ( poFeatureDefn->GetFieldDefn( i )->GetPrecision() )
{
// have a decimal format width.precision
CPLString osFormatString;
osFormatString.Printf( "%%%d.%df",
poFeatureDefn->GetFieldDefn( i )->GetWidth(),
poFeatureDefn->GetFieldDefn( i )->GetPrecision() );
osVal.Printf( osFormatString.c_str(), poFeature->GetFieldAsDouble( i ) );
}
else
osVal.Printf( "%f", poFeature->GetFieldAsDouble( i ) );
break;
case OFTIntegerList:
case OFTRealList:
case OFTStringList:
// FIXME Prepare array of values field
//cv->ConvertFrom( poFeature->GetFieldAsStringList( i ) );
//break;
case OFTBinary:
// FIXME Prepare binary field
case OFTString:
case OFTDate:
case OFTTime:
case OFTDateTime:
default:
osVal.Printf( "'%s'", poFeature->GetFieldAsString( i ) );
break;
}
osValues += osVal;
}
osSql.Printf( "INSERT INTO %s (%s) VALUES (%s)",
poFeatureDefn->GetName(),
osFields.c_str(),
osValues.c_str() );
ITStatement oQuery( *poDS->GetConnection() );
if ( ! oQuery.Prepare( osSql.c_str() ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error prepare SQL.\n%s",osSql.c_str() );
return eErr;
}
CPLDebug( "OGR_IDB", "Exec(%s)", oQuery.QueryText().Data() );
if( !oQuery.Exec() )
{
CPLError( CE_Failure, CPLE_AppDefined, "Error create Feature.");
return eErr;
}
ITQuery oFidQuery( *poDS->GetConnection() );
osSql.Printf( "SELECT MAX(%s) from %s", pszFIDColumn, poFeatureDefn->GetName() );
CPLDebug( "OGR_IDB", "Exec(%s)", osSql.c_str() );
ITRow * row = oFidQuery.ExecOneRow( osSql.c_str() );
if( ! row || row->NumColumns() < 1 )
{
CPLError( CE_Failure, CPLE_AppDefined, "Error create Feature.");
return eErr;
}
int fid = atoi( row->Column(0)->Printable() );
if ( fid > 0 )
poFeature->SetFID( fid );
else
{
CPLError( CE_Failure, CPLE_AppDefined, "Error create Feature. Unable to get new fid" );
return eErr;
}
return OGRERR_NONE;
}
OGRErr OGRIDBTableLayer::ISetFeature( OGRFeature *poFeature )
{
OGRErr eErr(OGRERR_FAILURE);
if ( ! bUpdateAccess )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error update feature. Layer is read only." );
return eErr;
}
if( NULL == poFeature )
{
CPLError( CE_Failure, CPLE_AppDefined,
"NULL pointer to OGRFeature passed to SetFeature()." );
return eErr;
}
if( poFeature->GetFID() == OGRNullFID )
{
CPLError( CE_Failure, CPLE_AppDefined,
"FID required on features given to SetFeature()." );
return eErr;
}
ITStatement oQuery( *poDS->GetConnection() );
int bUpdateGeom = TRUE;
CPLString osGeomFunc;
if ( poFeature->GetGeometryRef() )
{
OGRwkbGeometryType nGeomType = poFeature->GetGeometryRef()->getGeometryType();
switch (nGeomType)
{
case wkbPoint:
osGeomFunc = "ST_PointFromText";
break;
case wkbLineString:
osGeomFunc = "ST_LineFromText";
break;
case wkbPolygon:
osGeomFunc = "ST_PolyFromText";
break;
case wkbMultiPoint:
osGeomFunc = "ST_MPointFromText";
break;
case wkbMultiLineString:
osGeomFunc = "ST_MLineFromText";
break;
case wkbMultiPolygon:
osGeomFunc = "ST_MPolyFromText";
break;
default:
bUpdateGeom = FALSE;
CPLDebug("OGR_IDB", "SetFeature(): Unknown geometry type. Geometry will not be updated.");
}
}
else
bUpdateGeom = FALSE;
// Create query
CPLString osSql;
CPLString osFields;
if ( pszGeomColumn && bUpdateGeom )
{
OGRGeometry * poGeom = poFeature->GetGeometryRef();
char * wkt;
poGeom->exportToWkt( &wkt );
osFields.Printf( "%s = %s( '%s', %d )", pszGeomColumn, osGeomFunc.c_str(), wkt, nSRSId );
CPLFree( wkt );
}
for( int i = 0; i < poFeatureDefn->GetFieldCount(); i++ )
{
const char * pszFieldName = poFeatureDefn->GetFieldDefn(i)->GetNameRef();
// skip fid column from update
if ( EQUAL( pszFIDColumn, pszFieldName ) )
continue;
if ( ! osFields.empty() )
{
osFields += ",";
}
osFields += pszFieldName;
osFields += "=";
if ( ! poFeature->IsFieldSet( i ) )
{
osFields += "NULL";
continue;
}
CPLString osVal;
switch ( poFeatureDefn->GetFieldDefn( i )->GetType() )
{
case OFTInteger:
osVal.Printf( "%d", poFeature->GetFieldAsInteger( i ) );
break;
case OFTReal:
if ( poFeatureDefn->GetFieldDefn( i )->GetPrecision() )
{
// have a decimal format width.precision
CPLString osFormatString;
osFormatString.Printf( "%%%d.%df",
poFeatureDefn->GetFieldDefn( i )->GetWidth(),
poFeatureDefn->GetFieldDefn( i )->GetPrecision() );
osVal.Printf( osFormatString.c_str(), poFeature->GetFieldAsDouble( i ) );
}
else
osVal.Printf( "%f", poFeature->GetFieldAsDouble( i ) );
break;
case OFTIntegerList:
case OFTRealList:
case OFTStringList:
// FIXME Prepare array of values field
//cv->ConvertFrom( poFeature->GetFieldAsStringList( i ) );
//break;
case OFTBinary:
// FIXME Prepare binary field
case OFTString:
case OFTDate:
case OFTTime:
case OFTDateTime:
default:
osVal.Printf( "'%s'", poFeature->GetFieldAsString( i ) );
break;
}
osFields += osVal;
}
osSql.Printf( "UPDATE %s SET %s WHERE %s = %d",
poFeatureDefn->GetName(),
osFields.c_str(),
pszFIDColumn,
poFeature->GetFID() );
if ( ! oQuery.Prepare( osSql.c_str() ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error prepare SQL.\n%s",osSql.c_str() );
return eErr;
}
CPLDebug( "OGR_IDB", "Exec(%s)", oQuery.QueryText().Data() );
if( !oQuery.Exec() )
{
CPLError( CE_Failure, CPLE_AppDefined, "Error update Feature.");
return eErr;
}
return OGRERR_NONE;
}
OGRErr OGRIDBTableLayer::ISetFeature( OGRFeature *poFeature )
{
OGRErr eErr(OGRERR_FAILURE);
if ( ! bUpdateAccess )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error update feature. Layer is read only." );
return eErr;
}
if( NULL == poFeature )
{
CPLError( CE_Failure, CPLE_AppDefined,
"NULL pointer to OGRFeature passed to SetFeature()." );
return eErr;
}
if( poFeature->GetFID() == OGRNullFID )
{
CPLError( CE_Failure, CPLE_AppDefined,
"FID required on features given to SetFeature()." );
return eErr;
}
ITStatement oQuery( *poDS->GetConnection() );
int bUpdateGeom = TRUE;
OGRwkbGeometryType nGeomType = poFeature->GetGeometryRef()->getGeometryType();
CPLString osGeomFunc;
int nSrid = 0; // FIXME Obtain geometry SRID
switch (nGeomType)
{
case wkbPoint:
osGeomFunc = "ST_PointFromText";
break;
case wkbLineString:
osGeomFunc = "ST_LineFromText";
break;
case wkbPolygon:
osGeomFunc = "ST_PolyFromText";
break;
case wkbMultiPoint:
osGeomFunc = "ST_MPointFromText";
break;
case wkbMultiLineString:
osGeomFunc = "ST_MLineFromText";
break;
case wkbMultiPolygon:
osGeomFunc = "ST_MPolyFromText";
break;
default:
bUpdateGeom = FALSE;
CPLDebug("OGR_IDB", "SetFeature(): Unknown geometry type. Geometry will not be updated.");
}
// Create query
CPLString osSql;
CPLString osFields;
if ( pszGeomColumn && bUpdateGeom )
{
osFields.Printf( "%s = %s( ?, %d )", pszGeomColumn, osGeomFunc.c_str(), nSrid );
}
for( int i = 0; i < poFeatureDefn->GetFieldCount(); i++ )
{
const char * pszFieldName = poFeatureDefn->GetFieldDefn(i)->GetNameRef();
// skip fid column from update
if ( EQUAL( pszFIDColumn, pszFieldName ) )
continue;
if ( ! osFields.empty() )
{
osFields += ",";
}
osFields += pszFieldName;
osFields += "=?";
}
osSql.Printf( "UPDATE %s SET %s WHERE %s = %d",
poFeatureDefn->GetName(),
osFields.c_str(),
pszFIDColumn,
poFeature->GetFID() );
if ( ! oQuery.Prepare( osSql.c_str() ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error prepare SQL.\n%s",osSql.c_str() );
return eErr;
}
int iParam = 0;
if ( pszGeomColumn && bUpdateGeom )
{
ITValue * par = oQuery.Param( iParam ); // it should be a geom value
if ( ! par )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error prepare geom param");
return eErr;
}
OGRGeometry * poGeom = poFeature->GetGeometryRef();
char * wkt;
poGeom->exportToWkt( &wkt );
if( ! par->FromPrintable( wkt ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error prepare geom param");
par->Release();
return eErr;
}
CPLFree( wkt );
par->Release();
iParam++;
}
for ( int i = 0; i < poFeatureDefn->GetFieldCount(); i++ )
{
ITValue * par = oQuery.Param( iParam );
if ( ! par )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error prepare param %d", iParam);
return eErr;
}
if ( ! poFeature->IsFieldSet( i ) )
{
if ( ! par->SetNull() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error set param %d to NULL", iParam);
par->Release();
return eErr;
}
par->Release();
continue;
}
ITConversions * cv = 0;
bool res = FALSE;
if ( par->QueryInterface( ITConversionsIID, (void **) &cv) !=
IT_QUERYINTERFACE_SUCCESS )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error prepare param %d", iParam);
par->Release();
return eErr;
}
switch ( poFeatureDefn->GetFieldDefn( i )->GetType() )
{
case OFTInteger:
res = cv->ConvertFrom( poFeature->GetFieldAsInteger( i ) );
break;
case OFTReal:
res = cv->ConvertFrom( poFeature->GetFieldAsDouble( i ) );
break;
case OFTIntegerList:
case OFTRealList:
case OFTStringList:
// FIXME Prepare array of values field
//cv->ConvertFrom( poFeature->GetFieldAsStringList( i ) );
//break;
case OFTBinary:
// FIXME Prepare binary field
case OFTString:
case OFTDate:
case OFTTime:
case OFTDateTime:
res = cv->ConvertFrom( poFeature->GetFieldAsString( i ) );
break;
default:
CPLError( CE_Failure, CPLE_AppDefined,
"Error prepare param %d. Unknown data type.", iParam);
cv->Release();
par->Release();
return eErr;
}
if ( res != TRUE )
CPLError( CE_Failure, CPLE_AppDefined,
"Error prepare param.");
cv->Release();
par->Release();
}
CPLDebug( "OGR_IDB", "ExecuteSQL(%s)", oQuery.QueryText().Data() );
if( !oQuery.Exec() )
{
CPLError( CE_Failure, CPLE_AppDefined, "Error update Feature.");
return eErr;
}
return OGRERR_NONE;
}
OGRErr OGRCSVLayer::CreateFeature( OGRFeature *poNewFeature )
{
int iField;
if( !bInWriteMode )
{
CPLError( CE_Failure, CPLE_AppDefined,
"The CreateFeature() operation is not permitted on a read-only CSV." );
return OGRERR_FAILURE;
}
/* If we need rewind, it means that we have just written a feature before */
/* so there's no point seeking to the end of the file, as we're already */
/* at the end */
int bNeedSeekEnd = !bNeedRewindBeforeRead;
bNeedRewindBeforeRead = TRUE;
/* -------------------------------------------------------------------- */
/* Write field names if we haven't written them yet. */
/* Write .csvt file if needed */
/* -------------------------------------------------------------------- */
if( !bHasFieldNames )
{
bHasFieldNames = TRUE;
bNeedSeekEnd = FALSE;
for(int iFile=0;iFile<((bCreateCSVT) ? 2 : 1);iFile++)
{
VSILFILE* fpCSVT = NULL;
if (bCreateCSVT && iFile == 0)
{
char* pszDirName = CPLStrdup(CPLGetDirname(pszFilename));
char* pszBaseName = CPLStrdup(CPLGetBasename(pszFilename));
fpCSVT = VSIFOpenL(CPLFormFilename(pszDirName, pszBaseName, ".csvt"), "wb");
CPLFree(pszDirName);
CPLFree(pszBaseName);
}
else
{
if( strncmp(pszFilename, "/vsistdout/", 11) == 0 ||
strncmp(pszFilename, "/vsizip/", 8) == 0 )
fpCSV = VSIFOpenL( pszFilename, "wb" );
else
fpCSV = VSIFOpenL( pszFilename, "w+b" );
if( fpCSV == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to create %s:\n%s",
pszFilename, VSIStrerror( errno ) );
return NULL;
}
}
if (eGeometryFormat == OGR_CSV_GEOM_AS_WKT)
{
if (fpCSV) VSIFPrintfL( fpCSV, "%s", "WKT");
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", "String");
if (poFeatureDefn->GetFieldCount() > 0)
{
if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter );
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ",");
}
}
else if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ)
{
if (fpCSV) VSIFPrintfL( fpCSV, "X%cY%cZ", chDelimiter, chDelimiter);
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", "Real,Real,Real");
if (poFeatureDefn->GetFieldCount() > 0)
{
if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter );
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ",");
}
}
else if (eGeometryFormat == OGR_CSV_GEOM_AS_XY)
{
if (fpCSV) VSIFPrintfL( fpCSV, "X%cY", chDelimiter);
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", "Real,Real");
if (poFeatureDefn->GetFieldCount() > 0)
{
if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter );
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ",");
}
}
else if (eGeometryFormat == OGR_CSV_GEOM_AS_YX)
{
if (fpCSV) VSIFPrintfL( fpCSV, "Y%cX", chDelimiter);
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", "Real,Real");
if (poFeatureDefn->GetFieldCount() > 0)
{
if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter );
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ",");
}
}
for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
char *pszEscaped;
if( iField > 0 )
{
if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter );
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ",");
}
pszEscaped =
CPLEscapeString( poFeatureDefn->GetFieldDefn(iField)->GetNameRef(),
-1, CPLES_CSV );
if (fpCSV) VSIFPrintfL( fpCSV, "%s", pszEscaped );
CPLFree( pszEscaped );
if (fpCSVT)
{
switch( poFeatureDefn->GetFieldDefn(iField)->GetType() )
{
case OFTInteger: VSIFPrintfL( fpCSVT, "%s", "Integer"); break;
case OFTReal: VSIFPrintfL( fpCSVT, "%s", "Real"); break;
case OFTDate: VSIFPrintfL( fpCSVT, "%s", "Date"); break;
case OFTTime: VSIFPrintfL( fpCSVT, "%s", "Time"); break;
case OFTDateTime: VSIFPrintfL( fpCSVT, "%s", "DateTime"); break;
default: VSIFPrintfL( fpCSVT, "%s", "String"); break;
}
int nWidth = poFeatureDefn->GetFieldDefn(iField)->GetWidth();
int nPrecision = poFeatureDefn->GetFieldDefn(iField)->GetPrecision();
if (nWidth != 0)
{
if (nPrecision != 0)
VSIFPrintfL( fpCSVT, "(%d.%d)", nWidth, nPrecision);
else
VSIFPrintfL( fpCSVT, "(%d)", nWidth);
}
}
}
if( bUseCRLF )
{
if (fpCSV) VSIFPutcL( 13, fpCSV );
if (fpCSVT) VSIFPutcL( 13, fpCSVT );
}
if (fpCSV) VSIFPutcL( '\n', fpCSV );
if (fpCSVT) VSIFPutcL( '\n', fpCSVT );
if (fpCSVT) VSIFCloseL(fpCSVT);
}
}
if (fpCSV == NULL)
return OGRERR_FAILURE;
/* -------------------------------------------------------------------- */
/* Make sure we are at the end of the file. */
/* -------------------------------------------------------------------- */
if (bNeedSeekEnd)
{
if (bFirstFeatureAppendedDuringSession)
{
/* Add a newline character to the end of the file if necessary */
bFirstFeatureAppendedDuringSession = FALSE;
VSIFSeekL( fpCSV, 0, SEEK_END );
VSIFSeekL( fpCSV, VSIFTellL(fpCSV) - 1, SEEK_SET);
char chLast;
VSIFReadL( &chLast, 1, 1, fpCSV );
VSIFSeekL( fpCSV, 0, SEEK_END );
if (chLast != '\n')
{
if( bUseCRLF )
VSIFPutcL( 13, fpCSV );
VSIFPutcL( '\n', fpCSV );
}
}
else
{
VSIFSeekL( fpCSV, 0, SEEK_END );
}
}
/* -------------------------------------------------------------------- */
/* Write out the geometry */
/* -------------------------------------------------------------------- */
if (eGeometryFormat == OGR_CSV_GEOM_AS_WKT)
{
OGRGeometry *poGeom = poNewFeature->GetGeometryRef();
char* pszWKT = NULL;
if (poGeom && poGeom->exportToWkt(&pszWKT) == OGRERR_NONE)
{
VSIFPrintfL( fpCSV, "\"%s\"", pszWKT);
}
else
{
VSIFPrintfL( fpCSV, "\"\"");
}
CPLFree(pszWKT);
if (poFeatureDefn->GetFieldCount() > 0)
VSIFPrintfL( fpCSV, "%c", chDelimiter);
}
else if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ ||
eGeometryFormat == OGR_CSV_GEOM_AS_XY ||
eGeometryFormat == OGR_CSV_GEOM_AS_YX)
{
OGRGeometry *poGeom = poNewFeature->GetGeometryRef();
if (poGeom && wkbFlatten(poGeom->getGeometryType()) == wkbPoint)
{
OGRPoint* poPoint = (OGRPoint*) poGeom;
char szBuffer[75];
if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ )
OGRMakeWktCoordinate(szBuffer, poPoint->getX(), poPoint->getY(), poPoint->getZ(), 3);
else if (eGeometryFormat == OGR_CSV_GEOM_AS_XY )
OGRMakeWktCoordinate(szBuffer, poPoint->getX(), poPoint->getY(), 0, 2);
else
OGRMakeWktCoordinate(szBuffer, poPoint->getY(), poPoint->getX(), 0, 2);
char* pc = szBuffer;
while(*pc != '\0')
{
if (*pc == ' ')
*pc = chDelimiter;
pc ++;
}
VSIFPrintfL( fpCSV, "%s", szBuffer );
}
else
{
VSIFPrintfL( fpCSV, "%c", chDelimiter );
if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ)
VSIFPrintfL( fpCSV, "%c", chDelimiter );
}
if (poFeatureDefn->GetFieldCount() > 0)
VSIFPrintfL( fpCSV, "%c", chDelimiter );
}
/* -------------------------------------------------------------------- */
/* Write out all the field values. */
/* -------------------------------------------------------------------- */
for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
char *pszEscaped;
if( iField > 0 )
VSIFPrintfL( fpCSV, "%c", chDelimiter );
pszEscaped =
CPLEscapeString( poNewFeature->GetFieldAsString(iField),
-1, CPLES_CSV );
if (poFeatureDefn->GetFieldDefn(iField)->GetType() == OFTReal)
{
/* Use point as decimal separator */
char* pszComma = strchr(pszEscaped, ',');
if (pszComma)
*pszComma = '.';
}
VSIFWriteL( pszEscaped, 1, strlen(pszEscaped), fpCSV );
CPLFree( pszEscaped );
}
if( bUseCRLF )
VSIFPutcL( 13, fpCSV );
VSIFPutcL( '\n', fpCSV );
return OGRERR_NONE;
}
OGRErr OGRMySQLTableLayer::ICreateFeature( OGRFeature *poFeature )
{
int bNeedComma = FALSE;
CPLString osCommand;
/* -------------------------------------------------------------------- */
/* Form the INSERT command. */
/* -------------------------------------------------------------------- */
osCommand.Printf( "INSERT INTO `%s` (", poFeatureDefn->GetName() );
if( poFeature->GetGeometryRef() != nullptr )
{
osCommand = osCommand + "`" + pszGeomColumn + "` ";
bNeedComma = TRUE;
}
if( poFeature->GetFID() != OGRNullFID && pszFIDColumn != nullptr )
{
if( bNeedComma )
osCommand += ", ";
osCommand = osCommand + "`" + pszFIDColumn + "` ";
bNeedComma = TRUE;
}
for( int i = 0; i < poFeatureDefn->GetFieldCount(); i++ )
{
if( !poFeature->IsFieldSet( i ) )
continue;
if( !bNeedComma )
bNeedComma = TRUE;
else
osCommand += ", ";
osCommand = osCommand + "`"
+ poFeatureDefn->GetFieldDefn(i)->GetNameRef() + "`";
}
osCommand += ") VALUES (";
// Set the geometry
bNeedComma = poFeature->GetGeometryRef() != nullptr;
if( poFeature->GetGeometryRef() != nullptr)
{
char *pszWKT = nullptr;
if( poFeature->GetGeometryRef() != nullptr )
{
OGRGeometry *poGeom = (OGRGeometry *) poFeature->GetGeometryRef();
poGeom->closeRings();
poGeom->flattenTo2D();
poGeom->exportToWkt( &pszWKT );
}
if( pszWKT != nullptr )
{
const char* pszAxisOrder = "";
OGRSpatialReference* l_poSRS = GetSpatialRef();
if( poDS->GetMajorVersion() >= 8 && !poDS->IsMariaDB() &&
l_poSRS && l_poSRS->IsGeographic() )
{
pszAxisOrder = ", 'axis-order=long-lat'";
}
osCommand +=
CPLString().Printf(
"%s('%s',%d%s) ",
poDS->GetMajorVersion() >= 8 ? "ST_GeomFromText" : "GeometryFromText",
pszWKT, nSRSId, pszAxisOrder );
CPLFree( pszWKT );
}
else
osCommand += "''";
}
// Set the FID
if( poFeature->GetFID() != OGRNullFID && pszFIDColumn != nullptr )
{
GIntBig nFID = poFeature->GetFID();
if( !CPL_INT64_FITS_ON_INT32(nFID) &&
GetMetadataItem(OLMD_FID64) == nullptr )
{
CPLString osCommand2;
osCommand2.Printf(
"ALTER TABLE `%s` MODIFY COLUMN `%s` BIGINT UNIQUE NOT NULL AUTO_INCREMENT",
poFeatureDefn->GetName(), pszFIDColumn );
if( mysql_query(poDS->GetConn(), osCommand2 ) )
{
poDS->ReportError( osCommand2 );
return OGRERR_FAILURE;
}
// make sure to attempt to free results of successful queries
MYSQL_RES *hResult = mysql_store_result( poDS->GetConn() );
if( hResult != nullptr )
mysql_free_result( hResult );
hResult = nullptr;
SetMetadataItem(OLMD_FID64, "YES");
}
if( bNeedComma )
osCommand += ", ";
osCommand += CPLString().Printf( CPL_FRMT_GIB, nFID );
bNeedComma = TRUE;
}
for( int i = 0; i < poFeatureDefn->GetFieldCount(); i++ )
{
if( !poFeature->IsFieldSet( i ) )
continue;
if( bNeedComma )
osCommand += ", ";
else
bNeedComma = TRUE;
const char *pszStrValue = poFeature->GetFieldAsString(i);
if( poFeature->IsFieldNull(i) )
{
osCommand += "NULL";
}
else if( poFeatureDefn->GetFieldDefn(i)->GetType() != OFTInteger
&& poFeatureDefn->GetFieldDefn(i)->GetType() != OFTInteger64
&& poFeatureDefn->GetFieldDefn(i)->GetType() != OFTReal
&& poFeatureDefn->GetFieldDefn(i)->GetType() != OFTBinary )
{
// We need to quote and escape string fields.
osCommand += "'";
for( int iChar = 0; pszStrValue[iChar] != '\0'; iChar++ )
{
if( poFeatureDefn->GetFieldDefn(i)->GetType() != OFTIntegerList
&& poFeatureDefn->GetFieldDefn(i)->GetType() != OFTInteger64List
&& poFeatureDefn->GetFieldDefn(i)->GetType() != OFTRealList
&& poFeatureDefn->GetFieldDefn(i)->GetWidth() > 0
&& iChar == poFeatureDefn->GetFieldDefn(i)->GetWidth() )
{
CPLDebug( "MYSQL",
"Truncated %s field value, it was too long.",
poFeatureDefn->GetFieldDefn(i)->GetNameRef() );
break;
}
if( pszStrValue[iChar] == '\\'
|| pszStrValue[iChar] == '\'' )
{
osCommand += '\\';
osCommand += pszStrValue[iChar];
}
else
osCommand += pszStrValue[iChar];
}
osCommand += "'";
}
else if( poFeatureDefn->GetFieldDefn(i)->GetType() == OFTBinary )
{
int binaryCount = 0;
GByte* binaryData = poFeature->GetFieldAsBinary(i, &binaryCount);
char* pszHexValue = CPLBinaryToHex( binaryCount, binaryData );
osCommand += "x'";
osCommand += pszHexValue;
osCommand += "'";
CPLFree( pszHexValue );
}
else
{
osCommand += pszStrValue;
}
}
osCommand += ")";
//CPLDebug("MYSQL", "%s", osCommand.c_str());
int nQueryResult = mysql_query(poDS->GetConn(), osCommand.c_str() );
const my_ulonglong nFID = mysql_insert_id( poDS->GetConn() );
if( nQueryResult ){
int eErrorCode = mysql_errno(poDS->GetConn());
if (eErrorCode == 1153) {//ER_NET_PACKET_TOO_LARGE)
poDS->ReportError("CreateFeature failed because the MySQL server " \
"cannot read the entire query statement. Increase " \
"the size of statements your server will allow by " \
"altering the 'max_allowed_packet' parameter in "\
"your MySQL server configuration.");
}
else
{
CPLDebug("MYSQL","Error number %d", eErrorCode);
poDS->ReportError( osCommand.c_str() );
}
// make sure to attempt to free results
MYSQL_RES *hResult = mysql_store_result( poDS->GetConn() );
if( hResult != nullptr )
mysql_free_result( hResult );
hResult = nullptr;
return OGRERR_FAILURE;
}
if( nFID > 0 ) {
poFeature->SetFID( nFID );
}
// make sure to attempt to free results of successful queries
MYSQL_RES *hResult = mysql_store_result( poDS->GetConn() );
if( hResult != nullptr )
mysql_free_result( hResult );
hResult = nullptr;
return OGRERR_NONE;
}