OGRLayer *
OGRMemDataSource::ICreateLayer( const char *pszLayerName,
OGRSpatialReference *poSRSIn,
OGRwkbGeometryType eType,
char **papszOptions )
{
// Create the layer object.
OGRSpatialReference* poSRS = poSRSIn;
if( poSRS )
{
poSRS = poSRS->Clone();
poSRS->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
}
OGRMemLayer *poLayer = new OGRMemLayer(pszLayerName, poSRS, eType);
if( poSRS )
{
poSRS->Release();
}
if( CPLFetchBool(papszOptions, "ADVERTIZE_UTF8", false) )
poLayer->SetAdvertizeUTF8(true);
// Add layer to data source layer list.
papoLayers = static_cast<OGRMemLayer **>(
CPLRealloc(papoLayers, sizeof(OGRMemLayer *) * (nLayers + 1)));
papoLayers[nLayers++] = poLayer;
return poLayer;
}
OGRMemLayer::OGRMemLayer( const char * pszName, OGRSpatialReference *poSRSIn,
OGRwkbGeometryType eReqType )
{
iNextReadFID = 0;
iNextCreateFID = 0;
nFeatureCount = 0;
nMaxFeatureCount = 0;
papoFeatures = NULL;
poFeatureDefn = new OGRFeatureDefn( pszName );
SetDescription( poFeatureDefn->GetName() );
poFeatureDefn->SetGeomType( eReqType );
if( eReqType != wkbNone && poSRSIn != NULL )
{
OGRSpatialReference* poSRS = poSRSIn->Clone();
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS);
poSRS->Release();
}
poFeatureDefn->Reference();
bUpdatable = TRUE;
bAdvertizeUTF8 = FALSE;
bHasHoles = FALSE;
}
OGRLayer *OGRAmigoCloudDataSource::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;
}
CPLString osName(pszNameIn);
OGRAmigoCloudTableLayer* poLayer = new OGRAmigoCloudTableLayer(this, osName);
const bool bGeomNullable =
CPLFetchBool(papszOptions, "GEOMETRY_NULLABLE", true);
OGRSpatialReference* poSRSClone = poSpatialRef;
if( poSRSClone )
{
poSRSClone = poSRSClone->Clone();
poSRSClone->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
}
poLayer->SetDeferredCreation(eGType, poSRSClone, bGeomNullable);
if( poSRSClone )
poSRSClone->Release();
papoLayers = (OGRAmigoCloudTableLayer**) CPLRealloc(
papoLayers, (nLayers + 1) * sizeof(OGRAmigoCloudTableLayer*));
papoLayers[nLayers ++] = poLayer;
return poLayer;
}
void OGRUnionLayer::AutoWarpLayerIfNecessary(int iLayer)
{
if( !pabCheckIfAutoWrap[iLayer] )
{
pabCheckIfAutoWrap[iLayer] = TRUE;
for(int i=0; i<GetLayerDefn()->GetGeomFieldCount();i++)
{
OGRSpatialReference* poSRS = GetLayerDefn()->GetGeomFieldDefn(i)->GetSpatialRef();
if( poSRS != NULL )
poSRS->Reference();
OGRFeatureDefn* poSrcFeatureDefn = papoSrcLayers[iLayer]->GetLayerDefn();
int iSrcGeomField = poSrcFeatureDefn->GetGeomFieldIndex(
GetLayerDefn()->GetGeomFieldDefn(i)->GetNameRef());
if( iSrcGeomField >= 0 )
{
OGRSpatialReference* poSRS2 =
poSrcFeatureDefn->GetGeomFieldDefn(iSrcGeomField)->GetSpatialRef();
if( (poSRS == NULL && poSRS2 != NULL) ||
(poSRS != NULL && poSRS2 == NULL) )
{
CPLError(CE_Warning, CPLE_AppDefined,
"SRS of geometry field '%s' layer %s not consistent with UnionLayer SRS",
GetLayerDefn()->GetGeomFieldDefn(i)->GetNameRef(),
papoSrcLayers[iLayer]->GetName());
}
else if (poSRS != NULL && poSRS2 != NULL &&
poSRS != poSRS2 && !poSRS->IsSame(poSRS2))
{
CPLDebug("VRT", "SRS of geometry field '%s' layer %s not consistent with UnionLayer SRS. "
"Trying auto warping",
GetLayerDefn()->GetGeomFieldDefn(i)->GetNameRef(),
papoSrcLayers[iLayer]->GetName());
OGRCoordinateTransformation* poCT =
OGRCreateCoordinateTransformation( poSRS2, poSRS );
OGRCoordinateTransformation* poReversedCT = (poCT != NULL) ?
OGRCreateCoordinateTransformation( poSRS, poSRS2 ) : NULL;
if( poReversedCT != NULL )
papoSrcLayers[iLayer] = new OGRWarpedLayer(
papoSrcLayers[iLayer], iSrcGeomField, TRUE, poCT, poReversedCT);
else
{
CPLError(CE_Warning, CPLE_AppDefined,
"AutoWarpLayerIfNecessary failed to create "
"poCT or poReversedCT.");
if ( poCT != NULL )
delete poCT;
}
}
}
if( poSRS != NULL )
poSRS->Release();
}
}
}
void OGRESRIJSONReader::ReadLayers( OGRGeoJSONDataSource* poDS,
GeoJSONSourceType eSourceType )
{
CPLAssert( nullptr == poLayer_ );
if( nullptr == poGJObject_ )
{
CPLDebug( "ESRIJSON",
"Missing parsed ESRIJSON data. Forgot to call Parse()?" );
return;
}
OGRSpatialReference* poSRS = OGRESRIJSONReadSpatialReference( poGJObject_ );
const char* pszName = "ESRIJSON";
if( eSourceType == eGeoJSONSourceFile )
{
pszName = poDS->GetDescription();
if( STARTS_WITH_CI(pszName, "ESRIJSON:") )
pszName += strlen("ESRIJSON:");
pszName = CPLGetBasename(pszName);
}
auto eGeomType = OGRESRIJSONGetGeometryType(poGJObject_);
if( eGeomType == wkbNone && poSRS != nullptr )
{
eGeomType = wkbUnknown;
}
poLayer_ = new OGRGeoJSONLayer( pszName, poSRS,
eGeomType,
poDS, nullptr );
if( poSRS != nullptr )
poSRS->Release();
if( !GenerateLayerDefn() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer schema generation failed." );
delete poLayer_;
return;
}
OGRGeoJSONLayer *poThisLayer = ReadFeatureCollection( poGJObject_ );
if( poThisLayer == nullptr )
{
delete poLayer_;
return;
}
CPLErrorReset();
poLayer_->DetectGeometryType();
poDS->AddLayer(poLayer_);
}
// [[Rcpp::export]]
Rcpp::List CPL_transform(Rcpp::List sfc, Rcpp::CharacterVector proj4) {
// import proj4string:
OGRSpatialReference *dest = new OGRSpatialReference;
handle_error(dest->importFromProj4((const char *) (proj4[0])));
// transform geometries:
std::vector<OGRGeometry *> g = ogr_from_sfc(sfc, NULL);
if (g.size() == 0) {
dest->Release(); // #nocov
Rcpp::stop("CPL_transform: zero length geometry list"); // #nocov
}
OGRCoordinateTransformation *ct =
OGRCreateCoordinateTransformation(g[0]->getSpatialReference(), dest);
if (ct == NULL) {
dest->Release(); // #nocov
Rcpp::stop("OGRCreateCoordinateTransformation() returned NULL: PROJ.4 available?"); // #nocov
}
for (size_t i = 0; i < g.size(); i++) {
CPLPushErrorHandler(CPLQuietErrorHandler);
OGRErr err = 0;
if (! g[i]->IsEmpty())
err = g[i]->transform(ct);
CPLPopErrorHandler();
if (err == 1 || err == 6) {
OGRwkbGeometryType geomType = g[i]->getGeometryType();
OGRGeometryFactory f;
f.destroyGeometry(g[i]);
g[i] = f.createGeometry(geomType);
} else
handle_error(err);
}
Rcpp::List ret = sfc_from_ogr(g, true); // destroys g;
ct->DestroyCT(ct);
dest->Release();
return ret;
}
const char *NWT_GRCDataset::GetProjectionRef()
{
if (pszProjection == NULL)
{
OGRSpatialReference *poSpatialRef
= MITABCoordSys2SpatialRef( pGrd->cMICoordSys );
if (poSpatialRef)
{
poSpatialRef->exportToWkt( &pszProjection );
poSpatialRef->Release();
}
}
return ( (const char *) pszProjection );
}
const char *SDEDataset::GetProjectionRef()
{
long nSDEErr;
SE_COORDREF coordref;
nSDEErr = SE_coordref_create(&coordref);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_coordref_create" );
return FALSE;
}
if (!hRasterColumn){
CPLError ( CE_Failure, CPLE_AppDefined,
"Raster Column not defined");
return ("");
}
nSDEErr = SE_rascolinfo_get_coordref(hRasterColumn, coordref);
if (nSDEErr == SE_NO_COORDREF) {
return ("");
}
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rascolinfo_get_coordref" );
}
char szWKT[SE_MAX_SPATIALREF_SRTEXT_LEN];
nSDEErr = SE_coordref_get_description(coordref, szWKT);
if (nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_coordref_get_description");
}
SE_coordref_free(coordref);
OGRSpatialReference *poSRS;
CPLDebug ("SDERASTER", "SDE says the coordinate system is: %s'", szWKT);
poSRS = new OGRSpatialReference(szWKT);
poSRS->morphFromESRI();
poSRS->exportToWkt(&pszWKT);
poSRS->Release();
return pszWKT;
}
void OGRESRIJSONReader::ReadLayers( OGRGeoJSONDataSource* poDS )
{
CPLAssert( NULL == poLayer_ );
if( NULL == poGJObject_ )
{
CPLDebug( "ESRIJSON",
"Missing parset ESRIJSON data. Forgot to call Parse()?" );
return;
}
OGRSpatialReference* poSRS = NULL;
poSRS = OGRESRIJSONReadSpatialReference( poGJObject_ );
poLayer_ = new OGRGeoJSONLayer( OGRGeoJSONLayer::DefaultName, poSRS,
OGRESRIJSONGetGeometryType(poGJObject_),
poDS );
if( poSRS != NULL )
poSRS->Release();
if( !GenerateLayerDefn() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer schema generation failed." );
delete poLayer_;
return;
}
OGRGeoJSONLayer* poThisLayer = NULL;
poThisLayer = ReadFeatureCollection( poGJObject_ );
if (poThisLayer == NULL)
{
delete poLayer_;
return;
}
CPLErrorReset();
poDS->AddLayer(poLayer_);
}
void OGRUnionLayer::AutoWarpLayerIfNecessary(int iLayer)
{
if( !pabCheckIfAutoWrap[iLayer] )
{
pabCheckIfAutoWrap[iLayer] = TRUE;
OGRSpatialReference* poSRS = GetSpatialRef();
if( poSRS != NULL )
poSRS->Reference();
OGRSpatialReference* poSRS2 = papoSrcLayers[iLayer]->GetSpatialRef();
if( (poSRS == NULL && poSRS2 != NULL) ||
(poSRS != NULL && poSRS2 == NULL) )
{
CPLError(CE_Warning, CPLE_AppDefined,
"SRS of layer %s not consistant with layer SRS",
papoSrcLayers[iLayer]->GetName());
}
else if (poSRS != NULL && poSRS2 != NULL &&
poSRS != poSRS2 && !poSRS->IsSame(poSRS2))
{
CPLDebug("VRT", "SRS of layer %s not consistant with layer SRS. "
"Trying auto warping",
papoSrcLayers[iLayer]->GetName());
OGRCoordinateTransformation* poCT =
OGRCreateCoordinateTransformation( poSRS2, poSRS );
OGRCoordinateTransformation* poReversedCT = (poCT != NULL) ?
OGRCreateCoordinateTransformation( poSRS, poSRS2 ) : NULL;
if( poCT != NULL && poReversedCT != NULL )
papoSrcLayers[iLayer] = new OGRWarpedLayer(
papoSrcLayers[iLayer], TRUE, poCT, poReversedCT);
}
if( poSRS != NULL )
poSRS->Release();
}
}
static OGRSpatialReference* BuildSRS(const char* pszWKT) {
OGRSpatialReference* poSRS = new OGRSpatialReference(pszWKT);
if (poSRS->morphFromESRI() != OGRERR_NONE) {
delete poSRS;
return nullptr;
} else {
if (poSRS->AutoIdentifyEPSG() != OGRERR_NONE) {
int nEntries = 0;
int* panConfidence = nullptr;
OGRSpatialReferenceH* pahSRS = poSRS->FindMatches(nullptr,
&nEntries, &panConfidence);
if (nEntries == 1 && panConfidence[0] == 100) {
poSRS->Release();
poSRS = reinterpret_cast<OGRSpatialReference*>(pahSRS[0]);
CPLFree(pahSRS);
} else {
OSRFreeSRSArray(pahSRS);
}
CPLFree(panConfidence);
}
return poSRS;
}
}
int OGRKMLDataSource::Open( const char * pszNewName, int bTestOpen )
{
CPLAssert( NULL != pszNewName );
int nCount = 0;
OGRKMLLayer *poLayer = NULL;
OGRwkbGeometryType poGeotype;
/* -------------------------------------------------------------------- */
/* Create a KML object and open the source file. */
/* -------------------------------------------------------------------- */
poKMLFile_ = new KMLVector();
if( !poKMLFile_->open( pszNewName ) )
{
delete poKMLFile_;
poKMLFile_ = NULL;
return FALSE;
}
pszName_ = CPLStrdup( pszNewName );
/* -------------------------------------------------------------------- */
/* If we aren't sure it is KML, validate it by start parsing */
/* -------------------------------------------------------------------- */
if( bTestOpen && !poKMLFile_->isValid() )
{
delete poKMLFile_;
poKMLFile_ = NULL;
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Prescan the KML file so we can later work with the structure */
/* -------------------------------------------------------------------- */
poKMLFile_->parse();
/* -------------------------------------------------------------------- */
/* Classify the nodes */
/* -------------------------------------------------------------------- */
if( !poKMLFile_->classifyNodes() )
{
delete poKMLFile_;
poKMLFile_ = NULL;
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Eliminate the empty containers (if there is at least one */
/* valid container !) */
/* -------------------------------------------------------------------- */
int bHasOnlyEmpty = poKMLFile_->hasOnlyEmpty();
if (bHasOnlyEmpty)
CPLDebug("KML", "Has only empty containers");
else
poKMLFile_->eliminateEmpty();
/* -------------------------------------------------------------------- */
/* Find layers to use in the KML structure */
/* -------------------------------------------------------------------- */
poKMLFile_->findLayers(NULL, bHasOnlyEmpty);
/* -------------------------------------------------------------------- */
/* Print the structure */
/* -------------------------------------------------------------------- */
if( CPLGetConfigOption("KML_DEBUG",NULL) != NULL )
poKMLFile_->print(3);
nLayers_ = poKMLFile_->getNumLayers();
/* -------------------------------------------------------------------- */
/* Allocate memory for the Layers */
/* -------------------------------------------------------------------- */
papoLayers_ = (OGRKMLLayer **)
CPLMalloc( sizeof(OGRKMLLayer *) * nLayers_ );
OGRSpatialReference *poSRS = new OGRSpatialReference("GEOGCS[\"WGS 84\", "
" DATUM[\"WGS_1984\","
" SPHEROID[\"WGS 84\",6378137,298.257223563,"
" AUTHORITY[\"EPSG\",\"7030\"]],"
" AUTHORITY[\"EPSG\",\"6326\"]],"
" PRIMEM[\"Greenwich\",0,"
" AUTHORITY[\"EPSG\",\"8901\"]],"
" UNIT[\"degree\",0.01745329251994328,"
" AUTHORITY[\"EPSG\",\"9122\"]],"
" AUTHORITY[\"EPSG\",\"4326\"]]");
/* -------------------------------------------------------------------- */
/* Create the Layers and fill them */
/* -------------------------------------------------------------------- */
for( nCount = 0; nCount < nLayers_; nCount++ )
{
if( !poKMLFile_->selectLayer(nCount) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"There are no layers or a layer can not be found!");
break;
}
if( poKMLFile_->getCurrentType() == Point )
poGeotype = wkbPoint;
else if( poKMLFile_->getCurrentType() == LineString )
poGeotype = wkbLineString;
else if( poKMLFile_->getCurrentType() == Polygon )
poGeotype = wkbPolygon;
else if( poKMLFile_->getCurrentType() == MultiPoint )
poGeotype = wkbMultiPoint;
else if( poKMLFile_->getCurrentType() == MultiLineString )
poGeotype = wkbMultiLineString;
else if( poKMLFile_->getCurrentType() == MultiPolygon )
poGeotype = wkbMultiPolygon;
else if( poKMLFile_->getCurrentType() == MultiGeometry )
poGeotype = wkbGeometryCollection;
else
poGeotype = wkbUnknown;
if (poGeotype != wkbUnknown && poKMLFile_->is25D())
poGeotype = wkbSetZ(poGeotype);
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
CPLString sName( poKMLFile_->getCurrentName() );
if( sName.empty() )
{
sName.Printf( "Layer #%d", nCount );
}
poLayer = new OGRKMLLayer( sName.c_str(), poSRS, FALSE, poGeotype, this );
poLayer->SetLayerNumber( nCount );
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers_[nCount] = poLayer;
}
poSRS->Release();
return TRUE;
}
int OGRGTMDataSource::Open(const char* pszFilename, int bUpdate)
{
CPLAssert( pszFilename != NULL );
/* Should not happen as the driver already returned if bUpdate == NULL */
if (bUpdate)
{
CPLError(CE_Failure, CPLE_NotSupported,
"GTM driver does not support opening in update mode");
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Create a GTM object and open the source file. */
/* -------------------------------------------------------------------- */
poGTMFile = new GTM();
if ( !poGTMFile->Open( pszFilename ) )
{
delete poGTMFile;
poGTMFile = NULL;
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Validate it by start parsing */
/* -------------------------------------------------------------------- */
if( !poGTMFile->isValid() )
{
delete poGTMFile;
poGTMFile = NULL;
return FALSE;
}
pszName = CPLStrdup( pszFilename );
/* -------------------------------------------------------------------- */
/* Now, we are able to read the file header and find the position */
/* of the first waypoint and the position of the first track. */
/* -------------------------------------------------------------------- */
if ( !poGTMFile->readHeaderNumbers() )
return FALSE;
/* -------------------------------------------------------------------- */
/* We can start reading the file elements */
/* We are going to translate GTM features into layers */
/* -------------------------------------------------------------------- */
char* pszBaseFileName = CPLStrdup( CPLGetBasename(pszFilename) );
/* We are going to create two layers, one for storing waypoints and
another for storing tracks */
papoLayers = (OGRGTMLayer **) CPLMalloc(sizeof(void*) * 2);
/* Create a spatial reference for WGS8*/
OGRSpatialReference* poSRS = new OGRSpatialReference(NULL);
poSRS->SetWellKnownGeogCS( "WGS84" );
/* Waypoint layer */
size_t layerNameSize = strlen(pszBaseFileName) + sizeof("_waypoints");
char* pszLayerName = (char*) CPLMalloc(layerNameSize);
/* The layer name will be "<basename>_waypoints" */
strcpy (pszLayerName, pszBaseFileName);
CPLStrlcat (pszLayerName, "_waypoints", layerNameSize);
/* Store the layer of waypoints */
GTMWaypointLayer* poWaypointLayer = new GTMWaypointLayer ( pszLayerName,
poSRS,
FALSE,
this );
papoLayers[nLayers++] = poWaypointLayer;
CPLFree(pszLayerName);
/* Track layer */
layerNameSize = strlen(pszBaseFileName) + sizeof("_tracks");
pszLayerName = (char*) CPLMalloc(layerNameSize);
/* The layer name will be "<basename>_tracks" */
strcpy (pszLayerName, pszBaseFileName);
CPLStrlcat (pszLayerName, "_tracks", layerNameSize);
CPLFree(pszBaseFileName);
/* Store the layer of tracks */
GTMTrackLayer* poTrackLayer = new GTMTrackLayer ( pszLayerName,
poSRS,
FALSE,
this );
papoLayers[nLayers++] = poTrackLayer;
CPLFree(pszLayerName);
poSRS->Release();
return TRUE;
}
OGRFeatureDefn * OGRCARTODBTableLayer::GetLayerDefnInternal(CPL_UNUSED json_object* poObjIn)
{
if( poFeatureDefn != NULL )
return poFeatureDefn;
CPLString osCommand;
if( poDS->IsAuthenticatedConnection() )
{
// Get everything !
osCommand.Printf(
"SELECT a.attname, t.typname, a.attlen, "
"format_type(a.atttypid,a.atttypmod), "
"a.attnum, "
"a.attnotnull, "
"i.indisprimary, "
"pg_get_expr(def.adbin, c.oid) AS defaultexpr, "
"postgis_typmod_dims(a.atttypmod) dim, "
"postgis_typmod_srid(a.atttypmod) srid, "
"postgis_typmod_type(a.atttypmod)::text geomtyp, "
"srtext "
"FROM pg_class c "
"JOIN pg_attribute a ON a.attnum > 0 AND "
"a.attrelid = c.oid AND c.relname = '%s' "
"JOIN pg_type t ON a.atttypid = t.oid "
"JOIN pg_namespace n ON c.relnamespace=n.oid AND n.nspname= '%s' "
"LEFT JOIN pg_index i ON c.oid = i.indrelid AND "
"i.indisprimary = 't' AND a.attnum = ANY(i.indkey) "
"LEFT JOIN pg_attrdef def ON def.adrelid = c.oid AND "
"def.adnum = a.attnum "
"LEFT JOIN spatial_ref_sys srs ON srs.srid = postgis_typmod_srid(a.atttypmod) "
"ORDER BY a.attnum",
OGRCARTODBEscapeLiteral(osName).c_str(),
OGRCARTODBEscapeLiteral(poDS->GetCurrentSchema()).c_str());
}
else if( poDS->HasOGRMetadataFunction() != FALSE )
{
osCommand.Printf( "SELECT * FROM ogr_table_metadata('%s', '%s')",
OGRCARTODBEscapeLiteral(poDS->GetCurrentSchema()).c_str(),
OGRCARTODBEscapeLiteral(osName).c_str() );
}
if( osCommand.size() )
{
if( !poDS->IsAuthenticatedConnection() && poDS->HasOGRMetadataFunction() < 0 )
CPLPushErrorHandler(CPLQuietErrorHandler);
OGRLayer* poLyr = poDS->ExecuteSQLInternal(osCommand);
if( !poDS->IsAuthenticatedConnection() && poDS->HasOGRMetadataFunction() < 0 )
{
CPLPopErrorHandler();
if( poLyr == NULL )
{
CPLDebug("CARTODB", "ogr_table_metadata(text, text) not available");
CPLErrorReset();
}
else if( poLyr->GetLayerDefn()->GetFieldCount() != 12 )
{
CPLDebug("CARTODB", "ogr_table_metadata(text, text) has unexpected column count");
poDS->ReleaseResultSet(poLyr);
poLyr = NULL;
}
poDS->SetOGRMetadataFunction(poLyr != NULL);
}
if( poLyr )
{
OGRFeature* poFeat;
while( (poFeat = poLyr->GetNextFeature()) != NULL )
{
if( poFeatureDefn == NULL )
{
// We could do that outside of the while() loop, but
// by doing that here, we are somewhat robust to
// ogr_table_metadata() returning suddenly an empty result set
// for example if CDB_UserTables() no longer works
poFeatureDefn = new OGRFeatureDefn(osName);
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType(wkbNone);
}
const char* pszAttname = poFeat->GetFieldAsString("attname");
const char* pszType = poFeat->GetFieldAsString("typname");
int nWidth = poFeat->GetFieldAsInteger("attlen");
const char* pszFormatType = poFeat->GetFieldAsString("format_type");
int bNotNull = poFeat->GetFieldAsInteger("attnotnull");
int bIsPrimary = poFeat->GetFieldAsInteger("indisprimary");
int iDefaultExpr = poLyr->GetLayerDefn()->GetFieldIndex("defaultexpr");
const char* pszDefault = (iDefaultExpr >= 0 && poFeat->IsFieldSet(iDefaultExpr)) ?
poFeat->GetFieldAsString(iDefaultExpr) : NULL;
if( bIsPrimary &&
(EQUAL(pszType, "int2") ||
EQUAL(pszType, "int4") ||
EQUAL(pszType, "int8") ||
EQUAL(pszType, "serial") ||
EQUAL(pszType, "bigserial")) )
{
osFIDColName = pszAttname;
}
else if( strcmp(pszAttname, "created_at") == 0 ||
strcmp(pszAttname, "updated_at") == 0 ||
strcmp(pszAttname, "the_geom_webmercator") == 0)
{
/* ignored */
}
else
{
if( EQUAL(pszType,"geometry") )
{
int nDim = poFeat->GetFieldAsInteger("dim");
int nSRID = poFeat->GetFieldAsInteger("srid");
const char* pszGeomType = poFeat->GetFieldAsString("geomtyp");
const char* pszSRText = (poFeat->IsFieldSet(
poLyr->GetLayerDefn()->GetFieldIndex("srtext"))) ?
poFeat->GetFieldAsString("srtext") : NULL;
OGRwkbGeometryType eType = OGRFromOGCGeomType(pszGeomType);
if( nDim == 3 )
eType = wkbSetZ(eType);
OGRCartoDBGeomFieldDefn *poFieldDefn =
new OGRCartoDBGeomFieldDefn(pszAttname, eType);
if( bNotNull )
poFieldDefn->SetNullable(FALSE);
OGRSpatialReference* poSRS = NULL;
if( pszSRText != NULL )
{
poSRS = new OGRSpatialReference();
char* pszTmp = (char* )pszSRText;
if( poSRS->importFromWkt(&pszTmp) != OGRERR_NONE )
{
delete poSRS;
poSRS = NULL;
}
if( poSRS != NULL )
{
poFieldDefn->SetSpatialRef(poSRS);
poSRS->Release();
}
}
poFieldDefn->nSRID = nSRID;
poFeatureDefn->AddGeomFieldDefn(poFieldDefn, FALSE);
}
else
{
OGRFieldDefn oField(pszAttname, OFTString);
if( bNotNull )
oField.SetNullable(FALSE);
OGRPGCommonLayerSetType(oField, pszType, pszFormatType, nWidth);
if( pszDefault )
OGRPGCommonLayerNormalizeDefault(&oField, pszDefault);
poFeatureDefn->AddFieldDefn( &oField );
}
}
delete poFeat;
}
poDS->ReleaseResultSet(poLyr);
}
}
if( poFeatureDefn == NULL )
{
osBaseSQL.Printf("SELECT * FROM %s", OGRCARTODBEscapeIdentifier(osName).c_str());
EstablishLayerDefn(osName, NULL);
osBaseSQL = "";
}
if( osFIDColName.size() > 0 )
{
osBaseSQL = "SELECT ";
osBaseSQL += OGRCARTODBEscapeIdentifier(osFIDColName);
}
for(int i=0; i<poFeatureDefn->GetGeomFieldCount(); i++)
{
if( osBaseSQL.size() == 0 )
osBaseSQL = "SELECT ";
else
osBaseSQL += ", ";
osBaseSQL += OGRCARTODBEscapeIdentifier(poFeatureDefn->GetGeomFieldDefn(i)->GetNameRef());
}
for(int i=0; i<poFeatureDefn->GetFieldCount(); i++)
{
if( osBaseSQL.size() == 0 )
osBaseSQL = "SELECT ";
else
osBaseSQL += ", ";
osBaseSQL += OGRCARTODBEscapeIdentifier(poFeatureDefn->GetFieldDefn(i)->GetNameRef());
}
if( osBaseSQL.size() == 0 )
osBaseSQL = "SELECT *";
osBaseSQL += " FROM ";
osBaseSQL += OGRCARTODBEscapeIdentifier(osName);
osSELECTWithoutWHERE = osBaseSQL;
return poFeatureDefn;
}
/** This function parses the beginning of the file to detect the fields */
void OGRJMLLayer::LoadSchema()
{
if (bHasReadSchema)
return;
bHasReadSchema = true;
oParser = OGRCreateExpatXMLParser();
XML_SetElementHandler(oParser, ::startElementLoadSchemaCbk,
::endElementLoadSchemaCbk);
XML_SetCharacterDataHandler(oParser, ::dataHandlerCbk);
XML_SetUserData(oParser, this);
VSIFSeekL( fp, 0, SEEK_SET );
char aBuf[BUFSIZ];
int nDone = 0;
do
{
nDataHandlerCounter = 0;
const unsigned int nLen = static_cast<unsigned int>(
VSIFReadL( aBuf, 1, sizeof(aBuf), fp ) );
nDone = VSIFEofL(fp);
if (XML_Parse(oParser, aBuf, nLen, nDone) == XML_STATUS_ERROR)
{
CPLError( CE_Failure, CPLE_AppDefined,
"XML parsing of JML file failed : %s at line %d, "
"column %d",
XML_ErrorString(XML_GetErrorCode(oParser)),
static_cast<int>(XML_GetCurrentLineNumber(oParser)),
static_cast<int>(XML_GetCurrentColumnNumber(oParser)) );
bStopParsing = true;
}
nWithoutEventCounter ++;
} while ( !nDone && !bStopParsing && !bSchemaFinished &&
nWithoutEventCounter < 10 );
XML_ParserFree(oParser);
oParser = nullptr;
if (nWithoutEventCounter == 10)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Too much data inside one element. File probably corrupted");
bStopParsing = true;
}
if( osCollectionElement.empty() || osFeatureElement.empty() ||
osGeometryElement.empty() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Missing CollectionElement, FeatureElement or "
"GeometryElement" );
bStopParsing = true;
}
if( !osSRSName.empty() )
{
if( osSRSName.find("http://www.opengis.net/gml/srs/epsg.xml#") == 0 )
{
OGRSpatialReference* poSRS = new OGRSpatialReference();
poSRS->importFromEPSG(atoi(osSRSName.substr(
strlen("http://www.opengis.net/gml/srs/epsg.xml#")).c_str()));
poSRS->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS);
poSRS->Release();
}
}
nJCSGMLInputTemplateDepth = 0;
nCollectionElementDepth = 0;
nFeatureCollectionDepth = 0;
nFeatureElementDepth = 0;
nGeometryElementDepth = 0;
nColumnDepth = 0;
nNameDepth = 0;
nTypeDepth = 0;
nAttributeElementDepth = 0;
ResetReading();
}