GIntBig OGRESRIFeatureServiceLayer::GetFeatureCount( int bForce )
{
GIntBig nFeatureCount = -1;
if( m_poAttrQuery == NULL && m_poFilterGeom == NULL )
{
CPLString osNewURL = CPLURLAddKVP(poDS->GetURL(), "returnCountOnly", "true");
CPLHTTPResult* pResult = NULL;
CPLErrorReset();
pResult = CPLHTTPFetch( osNewURL, NULL );
if( pResult != NULL && pResult->nDataLen != 0 && CPLGetLastErrorNo() == 0 &&
pResult->nStatus == 0 )
{
const char* pszCount = strstr((const char*)pResult->pabyData, "\"count\"");
if( pszCount )
{
pszCount = strchr(pszCount, ':');
if( pszCount )
{
pszCount++;
nFeatureCount = CPLAtoGIntBig(pszCount);
}
}
}
CPLHTTPDestroyResult( pResult );
}
if( nFeatureCount < 0 )
nFeatureCount = OGRLayer::GetFeatureCount(bForce);
return nFeatureCount;
}
OGRESRIFeatureServiceDataset::OGRESRIFeatureServiceDataset(const CPLString &osURL,
OGRGeoJSONDataSource* poFirst)
{
poCurrent = poFirst;
poLayer = new OGRESRIFeatureServiceLayer(this);
this->osURL = osURL;
if( CPLURLGetValue(this->osURL, "resultRecordCount").size() == 0 )
{
// We assume that if the server sets the exceededTransferLimit, the
// and resultRecordCount is not set, the number of features returned
// in our first request is the maximum allowed by the server
// So set it for following requests
this->osURL = CPLURLAddKVP(this->osURL, "resultRecordCount",
CPLSPrintf("%d", (int)poFirst->GetLayer(0)->GetFeatureCount()));
}
else
{
int nUserSetRecordCount = atoi(CPLURLGetValue(this->osURL, "resultRecordCount"));
if( nUserSetRecordCount > poFirst->GetLayer(0)->GetFeatureCount() )
{
CPLError(CE_Warning, CPLE_AppDefined,
"Specificied resultRecordCount=%d is greater than the maximum %d supported by the server",
nUserSetRecordCount, (int)poFirst->GetLayer(0)->GetFeatureCount() );
}
}
nFirstOffset = CPLAtoGIntBig(CPLURLGetValue(this->osURL, "resultOffset"));
nLastOffset = nFirstOffset;
}
//! @cond Doxygen_Suppress
int
PamParseHistogram( CPLXMLNode *psHistItem,
double *pdfMin, double *pdfMax,
int *pnBuckets, GUIntBig **ppanHistogram,
int * /* pbIncludeOutOfRange */,
int * /* pbApproxOK */ )
{
if( psHistItem == nullptr )
return FALSE;
*pdfMin = CPLAtofM(CPLGetXMLValue( psHistItem, "HistMin", "0"));
*pdfMax = CPLAtofM(CPLGetXMLValue( psHistItem, "HistMax", "1"));
*pnBuckets = atoi(CPLGetXMLValue( psHistItem, "BucketCount","2"));
if( *pnBuckets <= 0 || *pnBuckets > INT_MAX / 2 )
return FALSE;
if( ppanHistogram == nullptr )
return TRUE;
// Fetch the histogram and use it.
const char *pszHistCounts = CPLGetXMLValue( psHistItem,
"HistCounts", "" );
// Sanity check to test consistency of BucketCount and HistCounts.
if( strlen(pszHistCounts) < 2 * static_cast<size_t>(*pnBuckets) - 1 )
{
CPLError(
CE_Failure, CPLE_AppDefined,
"HistCounts content isn't consistent with BucketCount value" );
return FALSE;
}
*ppanHistogram = static_cast<GUIntBig *>(
VSICalloc(sizeof(GUIntBig),*pnBuckets) );
if( *ppanHistogram == nullptr )
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"Cannot allocate memory for %d buckets", *pnBuckets );
return FALSE;
}
for( int iBucket = 0; iBucket < *pnBuckets; iBucket++ )
{
(*ppanHistogram)[iBucket] = CPLAtoGIntBig(pszHistCounts);
// Skip to next number.
while( *pszHistCounts != '\0' && *pszHistCounts != '|' )
pszHistCounts++;
if( *pszHistCounts == '|' )
pszHistCounts++;
}
return TRUE;
}
static int FORCE_CDECL swq_compare_int( const void *item1, const void *item2 )
{
GIntBig v1, v2;
const char* pszStr1 = *((const char **) item1);
const char* pszStr2 = *((const char **) item2);
if (pszStr1 == NULL)
return (pszStr2 == NULL) ? 0 : -1;
else if (pszStr2 == NULL)
return 1;
v1 = CPLAtoGIntBig(pszStr1);
v2 = CPLAtoGIntBig(pszStr2);
if( v1 < v2 )
return -1;
else if( v1 == v2 )
return 0;
else
return 1;
}
GIntBig OGRMySQLTableLayer::GetFeatureCount( CPL_UNUSED int bForce )
{
/* -------------------------------------------------------------------- */
/* Ensure any active long result is interrupted. */
/* -------------------------------------------------------------------- */
poDS->InterruptLongResult();
/* -------------------------------------------------------------------- */
/* Issue the appropriate select command. */
/* -------------------------------------------------------------------- */
MYSQL_RES *hResult;
const char *pszCommand;
pszCommand = CPLSPrintf( "SELECT COUNT(*) FROM `%s` %s",
poFeatureDefn->GetName(), pszWHERE );
if( mysql_query( poDS->GetConn(), pszCommand ) )
{
poDS->ReportError( pszCommand );
return FALSE;
}
hResult = mysql_store_result( poDS->GetConn() );
if( hResult == NULL )
{
poDS->ReportError( "mysql_store_result() failed on SELECT COUNT(*)." );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Capture the result. */
/* -------------------------------------------------------------------- */
char **papszRow = mysql_fetch_row( hResult );
GIntBig nCount = 0;
if( papszRow != NULL && papszRow[0] != NULL )
nCount = CPLAtoGIntBig(papszRow[0]);
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
return nCount;
}
GIntBig OGRPGeoTableLayer::GetFeatureCount( int bForce )
{
if( m_poFilterGeom != NULL )
return OGRPGeoLayer::GetFeatureCount( bForce );
CPLODBCStatement oStmt( poDS->GetSession() );
oStmt.Append( "SELECT COUNT(*) FROM " );
oStmt.Append( poFeatureDefn->GetName() );
if( pszQuery != NULL )
oStmt.Appendf( " WHERE %s", pszQuery );
if( !oStmt.ExecuteSQL() || !oStmt.Fetch() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"GetFeatureCount() failed on query %s.\n%s",
oStmt.GetCommand(), poDS->GetSession()->GetLastError() );
return OGRPGeoLayer::GetFeatureCount(bForce);
}
return CPLAtoGIntBig(oStmt.GetColData(0));
}
swq_expr_node *SWQCastEvaluator( swq_expr_node *node,
swq_expr_node **sub_node_values )
{
swq_expr_node *poRetNode = NULL;
swq_expr_node *poSrcNode = sub_node_values[0];
switch( node->field_type )
{
case SWQ_INTEGER:
{
poRetNode = new swq_expr_node( 0 );
poRetNode->is_null = poSrcNode->is_null;
switch( poSrcNode->field_type )
{
case SWQ_INTEGER:
case SWQ_BOOLEAN:
poRetNode->int_value = poSrcNode->int_value;
break;
case SWQ_INTEGER64:
// TODO: warn in case of overflow ?
poRetNode->int_value = (int) poSrcNode->int_value;
break;
case SWQ_FLOAT:
poRetNode->int_value = (int) poSrcNode->float_value;
break;
default:
poRetNode->int_value = atoi(poSrcNode->string_value);
break;
}
}
break;
case SWQ_INTEGER64:
{
poRetNode = new swq_expr_node( 0 );
poRetNode->is_null = poSrcNode->is_null;
poRetNode->field_type = SWQ_INTEGER64;
switch( poSrcNode->field_type )
{
case SWQ_INTEGER:
case SWQ_INTEGER64:
case SWQ_BOOLEAN:
poRetNode->int_value = poSrcNode->int_value;
break;
case SWQ_FLOAT:
poRetNode->int_value = (GIntBig) poSrcNode->float_value;
break;
default:
poRetNode->int_value = CPLAtoGIntBig(poSrcNode->string_value);
break;
}
}
break;
case SWQ_FLOAT:
{
poRetNode = new swq_expr_node( 0.0 );
poRetNode->is_null = poSrcNode->is_null;
switch( poSrcNode->field_type )
{
case SWQ_INTEGER:
case SWQ_INTEGER64:
case SWQ_BOOLEAN:
poRetNode->float_value = (double) poSrcNode->int_value;
break;
case SWQ_FLOAT:
poRetNode->float_value = poSrcNode->float_value;
break;
default:
poRetNode->float_value = CPLAtof(poSrcNode->string_value);
break;
}
}
break;
case SWQ_GEOMETRY:
{
poRetNode = new swq_expr_node( (OGRGeometry*) NULL );
if( !poSrcNode->is_null )
{
switch( poSrcNode->field_type )
{
case SWQ_GEOMETRY:
{
poRetNode->geometry_value =
poSrcNode->geometry_value->clone();
poRetNode->is_null = FALSE;
break;
}
case SWQ_STRING:
{
char* pszTmp = poSrcNode->string_value;
OGRGeometryFactory::createFromWkt(&pszTmp, NULL,
&(poRetNode->geometry_value));
if( poRetNode->geometry_value != NULL )
poRetNode->is_null = FALSE;
break;
}
default:
break;
}
}
break;
}
// everything else is a string.
default:
{
CPLString osRet;
switch( poSrcNode->field_type )
{
case SWQ_INTEGER:
case SWQ_BOOLEAN:
case SWQ_INTEGER64:
osRet.Printf( CPL_FRMT_GIB, poSrcNode->int_value );
break;
case SWQ_FLOAT:
osRet.Printf( "%.15g", poSrcNode->float_value );
break;
case SWQ_GEOMETRY:
{
if( poSrcNode->geometry_value != NULL )
{
char* pszWKT = NULL;
poSrcNode->geometry_value->exportToWkt(&pszWKT);
osRet = pszWKT;
CPLFree(pszWKT);
}
else
osRet = "";
break;
}
default:
osRet = poSrcNode->string_value;
break;
}
if( node->nSubExprCount > 2 )
{
int nWidth;
nWidth = (int) sub_node_values[2]->int_value;
if( nWidth > 0 && (int) strlen(osRet) > nWidth )
osRet.resize(nWidth);
}
poRetNode = new swq_expr_node( osRet.c_str() );
poRetNode->is_null = poSrcNode->is_null;
}
}
return poRetNode;
}
bool VSIDIRAz::AnalyseAzureFileList(
const CPLString& osBaseURL,
const char* pszXML)
{
#if DEBUG_VERBOSE
CPLDebug("AZURE", "%s", pszXML);
#endif
CPLXMLNode* psTree = CPLParseXMLString(pszXML);
if( psTree == nullptr )
return false;
CPLXMLNode* psEnumerationResults = CPLGetXMLNode(psTree, "=EnumerationResults");
bool bNonEmpty = false;
if( psEnumerationResults )
{
CPLString osPrefix = CPLGetXMLValue(psEnumerationResults, "Prefix", "");
CPLXMLNode* psBlobs = CPLGetXMLNode(psEnumerationResults, "Blobs");
if( psBlobs == nullptr )
{
psBlobs = CPLGetXMLNode(psEnumerationResults, "Containers");
if( psBlobs != nullptr )
bNonEmpty = true;
}
// Count the number of occurrences of a path. Can be 1 or 2. 2 in the case
// that both a filename and directory exist
std::map<CPLString, int> aoNameCount;
for(CPLXMLNode* psIter = psBlobs ? psBlobs->psChild : nullptr;
psIter != nullptr; psIter = psIter->psNext )
{
if( psIter->eType != CXT_Element )
continue;
if( strcmp(psIter->pszValue, "Blob") == 0 )
{
const char* pszKey = CPLGetXMLValue(psIter, "Name", nullptr);
if( pszKey && strstr(pszKey, GDAL_MARKER_FOR_DIR) != nullptr )
{
bNonEmpty = true;
}
else if( pszKey && strlen(pszKey) > osPrefix.size() )
{
bNonEmpty = true;
aoNameCount[pszKey + osPrefix.size()] ++;
}
}
else if( strcmp(psIter->pszValue, "BlobPrefix") == 0 ||
strcmp(psIter->pszValue, "Container") == 0 )
{
bNonEmpty = true;
const char* pszKey = CPLGetXMLValue(psIter, "Name", nullptr);
if( pszKey && strncmp(pszKey, osPrefix, osPrefix.size()) == 0 )
{
CPLString osKey = pszKey;
if( !osKey.empty() && osKey.back() == '/' )
osKey.resize(osKey.size()-1);
if( osKey.size() > osPrefix.size() )
{
aoNameCount[osKey.c_str() + osPrefix.size()] ++;
}
}
}
}
for(CPLXMLNode* psIter = psBlobs ? psBlobs->psChild : nullptr;
psIter != nullptr; psIter = psIter->psNext )
{
if( psIter->eType != CXT_Element )
continue;
if( strcmp(psIter->pszValue, "Blob") == 0 )
{
const char* pszKey = CPLGetXMLValue(psIter, "Name", nullptr);
if( pszKey && strstr(pszKey, GDAL_MARKER_FOR_DIR) != nullptr )
{
if( nRecurseDepth < 0 )
{
aoEntries.push_back(
std::unique_ptr<VSIDIREntry>(new VSIDIREntry()));
auto& entry = aoEntries.back();
entry->pszName = CPLStrdup(pszKey + osPrefix.size());
char* pszMarker = strstr(entry->pszName, GDAL_MARKER_FOR_DIR);
if( pszMarker )
*pszMarker = '\0';
entry->nMode = S_IFDIR;
entry->bModeKnown = true;
}
}
else if( pszKey && strlen(pszKey) > osPrefix.size() )
{
aoEntries.push_back(
std::unique_ptr<VSIDIREntry>(new VSIDIREntry()));
auto& entry = aoEntries.back();
entry->pszName = CPLStrdup(pszKey + osPrefix.size());
entry->nSize = static_cast<GUIntBig>(
CPLAtoGIntBig(CPLGetXMLValue(psIter, "Properties.Content-Length", "0")));
entry->bSizeKnown = true;
entry->nMode = S_IFDIR;
entry->bModeKnown = true;
CPLString ETag = CPLGetXMLValue(psIter, "Etag", "");
if( !ETag.empty() )
{
entry->papszExtra = CSLSetNameValue(
entry->papszExtra, "ETag", ETag.c_str());
}
int nYear, nMonth, nDay, nHour, nMinute, nSecond;
if( CPLParseRFC822DateTime(
CPLGetXMLValue(psIter, "Properties.Last-Modified", ""),
&nYear,
&nMonth,
&nDay,
&nHour,
&nMinute,
&nSecond,
nullptr,
nullptr ) )
{
struct tm brokendowntime;
brokendowntime.tm_year = nYear - 1900;
brokendowntime.tm_mon = nMonth - 1;
brokendowntime.tm_mday = nDay;
brokendowntime.tm_hour = nHour;
brokendowntime.tm_min = nMinute;
brokendowntime.tm_sec = nSecond < 0 ? 0 : nSecond;
entry->nMTime =
CPLYMDHMSToUnixTime(&brokendowntime);
entry->bMTimeKnown = true;
}
if( bCacheResults )
{
FileProp prop;
prop.eExists = EXIST_YES;
prop.bHasComputedFileSize = true;
prop.fileSize = entry->nSize;
prop.bIsDirectory = false;
prop.mTime = static_cast<time_t>(entry->nMTime);
prop.ETag = ETag;
CPLString osCachedFilename =
osBaseURL + "/" + osPrefix + entry->pszName;
#if DEBUG_VERBOSE
CPLDebug("AZURE", "Cache %s", osCachedFilename.c_str());
#endif
poFS->SetCachedFileProp(osCachedFilename, prop);
}
}
}
else if( strcmp(psIter->pszValue, "BlobPrefix") == 0 ||
strcmp(psIter->pszValue, "Container") == 0 )
{
const char* pszKey = CPLGetXMLValue(psIter, "Name", nullptr);
if( pszKey && strncmp(pszKey, osPrefix, osPrefix.size()) == 0 )
{
CPLString osKey = pszKey;
if( !osKey.empty() && osKey.back() == '/' )
osKey.resize(osKey.size()-1);
if( osKey.size() > osPrefix.size() )
{
aoEntries.push_back(
std::unique_ptr<VSIDIREntry>(new VSIDIREntry()));
auto& entry = aoEntries.back();
entry->pszName = CPLStrdup(osKey.c_str() + osPrefix.size());
if( aoNameCount[entry->pszName] == 2 )
{
// Add a / suffix to disambiguish the situation
// Normally we don't suffix directories with /, but
// we have no alternative here
CPLString osTemp(entry->pszName);
osTemp += '/';
CPLFree(entry->pszName);
entry->pszName = CPLStrdup(osTemp);
}
entry->nMode = S_IFDIR;
entry->bModeKnown = true;
if( bCacheResults )
{
FileProp prop;
prop.eExists = EXIST_YES;
prop.bIsDirectory = true;
prop.bHasComputedFileSize = true;
prop.fileSize = 0;
prop.mTime = 0;
CPLString osCachedFilename =
osBaseURL + "/" + osPrefix + entry->pszName;
#if DEBUG_VERBOSE
CPLDebug("AZURE", "Cache %s", osCachedFilename.c_str());
#endif
poFS->SetCachedFileProp(osCachedFilename, prop);
}
}
}
}
if( nMaxFiles > 0 && aoEntries.size() > static_cast<unsigned>(nMaxFiles) )
break;
}
osNextMarker = CPLGetXMLValue(psEnumerationResults, "NextMarker", "");
}
CPLDestroyXMLNode(psTree);
return bNonEmpty;
}
int GMLFeatureClass::InitializeFromXML( CPLXMLNode *psRoot )
{
/* -------------------------------------------------------------------- */
/* Do some rudimentary checking that this is a well formed */
/* node. */
/* -------------------------------------------------------------------- */
if( psRoot == NULL
|| psRoot->eType != CXT_Element
|| !EQUAL(psRoot->pszValue,"GMLFeatureClass") )
{
CPLError( CE_Failure, CPLE_AppDefined,
"GMLFeatureClass::InitializeFromXML() called on %s node!",
psRoot->pszValue );
return FALSE;
}
if( CPLGetXMLValue( psRoot, "Name", NULL ) == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"GMLFeatureClass has no <Name> element." );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Collect base info. */
/* -------------------------------------------------------------------- */
CPLFree( m_pszName );
m_pszName = CPLStrdup( CPLGetXMLValue( psRoot, "Name", NULL ) );
n_nNameLen = strlen(m_pszName);
SetElementName( CPLGetXMLValue( psRoot, "ElementPath", m_pszName ) );
/* -------------------------------------------------------------------- */
/* Collect geometry properties. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psThis;
int bHasValidGeometryName = FALSE;
int bHasValidGeometryElementPath = FALSE;
int bHasFoundGeomType = FALSE;
int bHasFoundGeomElements = FALSE;
const char* pszGName = "";
const char* pszGPath = "";
int nGeomType = wkbUnknown;
for( psThis = psRoot->psChild; psThis != NULL; psThis = psThis->psNext )
{
if( psThis->eType == CXT_Element &&
EQUAL(psThis->pszValue, "GeomPropertyDefn") )
{
const char *pszName = CPLGetXMLValue( psThis, "Name", "" );
const char *pszElementPath = CPLGetXMLValue( psThis, "ElementPath", "" );
const char *pszType = CPLGetXMLValue( psThis, "Type", NULL );
int bNullable = CSLTestBoolean(CPLGetXMLValue( psThis, "Nullable", "true") );
nGeomType = wkbUnknown;
if( pszType != NULL && !EQUAL(pszType, "0") )
{
nGeomType = atoi(pszType);
OGRwkbGeometryType nFlattenGeomType = wkbFlatten(nGeomType);
if( nGeomType != 0 && !(nFlattenGeomType >= wkbPoint && nFlattenGeomType <= wkbMultiSurface) )
{
nGeomType = wkbUnknown;
CPLError(CE_Warning, CPLE_AppDefined, "Unrecognised geometry type : %s",
pszType);
}
else if( nGeomType == 0 )
nGeomType = OGRFromOGCGeomType(pszType);
}
bHasFoundGeomElements = TRUE;
AddGeometryProperty( new GMLGeometryPropertyDefn( pszName, pszElementPath, nGeomType, -1, bNullable ) );
bHasValidGeometryName = FALSE;
bHasValidGeometryElementPath = FALSE;
bHasFoundGeomType = FALSE;
}
else if( psThis->eType == CXT_Element &&
strcmp(psThis->pszValue, "GeometryName") == 0 )
{
bHasFoundGeomElements = TRUE;
if( bHasValidGeometryName )
{
AddGeometryProperty( new GMLGeometryPropertyDefn( pszGName, pszGPath, nGeomType, -1, TRUE ) );
bHasValidGeometryName = FALSE;
bHasValidGeometryElementPath = FALSE;
bHasFoundGeomType = FALSE;
pszGPath = "";
nGeomType = wkbUnknown;
}
pszGName = CPLGetXMLValue( psThis, NULL, "" );
bHasValidGeometryName = TRUE;
}
else if( psThis->eType == CXT_Element &&
strcmp(psThis->pszValue, "GeometryElementPath") == 0 )
{
bHasFoundGeomElements = TRUE;
if( bHasValidGeometryElementPath )
{
AddGeometryProperty( new GMLGeometryPropertyDefn( pszGName, pszGPath, nGeomType, -1, TRUE ) );
bHasValidGeometryName = FALSE;
bHasValidGeometryElementPath = FALSE;
bHasFoundGeomType = FALSE;
pszGName = "";
nGeomType = wkbUnknown;
}
pszGPath = CPLGetXMLValue( psThis, NULL, "" );
bHasValidGeometryElementPath = TRUE;
}
else if( psThis->eType == CXT_Element &&
strcmp(psThis->pszValue, "GeometryType") == 0 )
{
bHasFoundGeomElements = TRUE;
if( bHasFoundGeomType )
{
AddGeometryProperty( new GMLGeometryPropertyDefn( pszGName, pszGPath, nGeomType, -1, TRUE ) );
bHasValidGeometryName = FALSE;
bHasValidGeometryElementPath = FALSE;
bHasFoundGeomType = FALSE;
pszGName = "";
pszGPath = "";
nGeomType = wkbUnknown;
}
const char* pszGeometryType = CPLGetXMLValue( psThis, NULL, NULL );
nGeomType = wkbUnknown;
if( pszGeometryType != NULL && !EQUAL(pszGeometryType, "0") )
{
nGeomType = atoi(pszGeometryType);
OGRwkbGeometryType nFlattenGeomType = wkbFlatten(nGeomType);
if( nGeomType == 100 || EQUAL(pszGeometryType, "NONE") )
{
bHasValidGeometryElementPath = FALSE;
bHasFoundGeomType = FALSE;
break;
}
else if( nGeomType != 0 && !(nFlattenGeomType >= wkbPoint && nFlattenGeomType <= wkbMultiSurface) )
{
nGeomType = wkbUnknown;
CPLError(CE_Warning, CPLE_AppDefined, "Unrecognised geometry type : %s",
pszGeometryType);
}
else if( nGeomType == 0 )
nGeomType = OGRFromOGCGeomType(pszGeometryType);
}
bHasFoundGeomType = TRUE;
}
}
/* If there was a dangling <GeometryElementPath> or <GeometryType> or */
/* that no explicit geometry information has been found, then add */
/* a geometry field */
if( bHasValidGeometryElementPath || bHasFoundGeomType || !bHasFoundGeomElements )
{
AddGeometryProperty( new GMLGeometryPropertyDefn( pszGName, pszGPath, nGeomType, -1, TRUE ) );
}
SetSRSName( CPLGetXMLValue( psRoot, "SRSName", NULL ) );
/* -------------------------------------------------------------------- */
/* Collect dataset specific info. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psDSI = CPLGetXMLNode( psRoot, "DatasetSpecificInfo" );
if( psDSI != NULL )
{
const char *pszValue;
pszValue = CPLGetXMLValue( psDSI, "FeatureCount", NULL );
if( pszValue != NULL )
SetFeatureCount( CPLAtoGIntBig(pszValue) );
// Eventually we should support XML subtrees.
pszValue = CPLGetXMLValue( psDSI, "ExtraInfo", NULL );
if( pszValue != NULL )
SetExtraInfo( pszValue );
if( CPLGetXMLValue( psDSI, "ExtentXMin", NULL ) != NULL
&& CPLGetXMLValue( psDSI, "ExtentXMax", NULL ) != NULL
&& CPLGetXMLValue( psDSI, "ExtentYMin", NULL ) != NULL
&& CPLGetXMLValue( psDSI, "ExtentYMax", NULL ) != NULL )
{
SetExtents( CPLAtof(CPLGetXMLValue( psDSI, "ExtentXMin", "0.0" )),
CPLAtof(CPLGetXMLValue( psDSI, "ExtentXMax", "0.0" )),
CPLAtof(CPLGetXMLValue( psDSI, "ExtentYMin", "0.0" )),
CPLAtof(CPLGetXMLValue( psDSI, "ExtentYMax", "0.0" )) );
}
}
/* -------------------------------------------------------------------- */
/* Collect property definitions. */
/* -------------------------------------------------------------------- */
for( psThis = psRoot->psChild; psThis != NULL; psThis = psThis->psNext )
{
if( psThis->eType == CXT_Element &&
EQUAL(psThis->pszValue, "PropertyDefn") )
{
const char *pszName = CPLGetXMLValue( psThis, "Name", NULL );
const char *pszType = CPLGetXMLValue( psThis, "Type", "Untyped" );
const char *pszSubType = CPLGetXMLValue( psThis, "Subtype", "" );
const char *pszCondition = CPLGetXMLValue( psThis, "Condition", NULL );
int bNullable = CSLTestBoolean(CPLGetXMLValue( psThis, "Nullable", "true") );
GMLPropertyDefn *poPDefn;
if( pszName == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"GMLFeatureClass %s has a PropertyDefn without a <Name>..",
m_pszName );
return FALSE;
}
poPDefn = new GMLPropertyDefn(
pszName, CPLGetXMLValue( psThis, "ElementPath", NULL ) );
poPDefn->SetNullable(bNullable);
if( EQUAL(pszType,"Untyped") )
poPDefn->SetType( GMLPT_Untyped );
else if( EQUAL(pszType,"String") )
{
if( EQUAL(pszSubType, "Boolean") )
{
poPDefn->SetType( GMLPT_Boolean );
poPDefn->SetWidth( 1 );
}
else
{
poPDefn->SetType( GMLPT_String );
poPDefn->SetWidth( atoi( CPLGetXMLValue( psThis, "Width", "0" ) ) );
}
}
else if( EQUAL(pszType,"Integer") )
{
if( EQUAL(pszSubType, "Short") )
{
poPDefn->SetType( GMLPT_Short );
}
else if( EQUAL(pszSubType, "Integer64") )
{
poPDefn->SetType( GMLPT_Integer64 );
}
else
{
poPDefn->SetType( GMLPT_Integer );
}
poPDefn->SetWidth( atoi( CPLGetXMLValue( psThis, "Width", "0" ) ) );
}
else if( EQUAL(pszType,"Real") )
{
if( EQUAL(pszSubType, "Float") )
{
poPDefn->SetType( GMLPT_Float );
}
else
{
poPDefn->SetType( GMLPT_Real );
}
poPDefn->SetWidth( atoi( CPLGetXMLValue( psThis, "Width", "0" ) ) );
poPDefn->SetPrecision( atoi( CPLGetXMLValue( psThis, "Precision", "0" ) ) );
}
else if( EQUAL(pszType,"StringList") )
{
if( EQUAL(pszSubType, "Boolean") )
poPDefn->SetType( GMLPT_BooleanList );
else
poPDefn->SetType( GMLPT_StringList );
}
else if( EQUAL(pszType,"IntegerList") )
{
if( EQUAL(pszSubType, "Integer64") )
poPDefn->SetType( GMLPT_Integer64List );
else
poPDefn->SetType( GMLPT_IntegerList );
}
else if( EQUAL(pszType,"RealList") )
poPDefn->SetType( GMLPT_RealList );
else if( EQUAL(pszType,"Complex") )
poPDefn->SetType( GMLPT_Complex );
else if( EQUAL(pszType,"FeatureProperty") )
poPDefn->SetType( GMLPT_FeatureProperty );
else if( EQUAL(pszType,"FeaturePropertyList") )
poPDefn->SetType( GMLPT_FeaturePropertyList );
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unrecognised property type %s.",
pszType );
delete poPDefn;
return FALSE;
}
if( pszCondition != NULL )
poPDefn->SetCondition(pszCondition);
AddProperty( poPDefn );
}
}
return TRUE;
}
MAIN_START(nArgc, papszArgv)
{
// Check strict compilation and runtime library version as we use C++ API.
if( !GDAL_CHECK_VERSION(papszArgv[0]) )
exit(1);
EarlySetConfigOptions(nArgc, papszArgv);
OGRRegisterAll();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = OGRGeneralCmdLineProcessor(nArgc, &papszArgv, 0);
if( nArgc < 1 )
exit(-nArgc);
char *pszWHERE = nullptr;
const char *pszDataSource = nullptr;
char **papszLayers = nullptr;
OGRGeometry *poSpatialFilter = nullptr;
int nRepeatCount = 1;
bool bAllLayers = false;
char *pszSQLStatement = nullptr;
const char *pszDialect = nullptr;
int nRet = 0;
const char* pszGeomField = nullptr;
char **papszOpenOptions = nullptr;
char **papszExtraMDDomains = nullptr;
bool bListMDD = false;
bool bShowMetadata = true;
bool bFeatureCount = true;
bool bExtent = true;
bool bDatasetGetNextFeature = false;
bool bReadOnly = false;
bool bUpdate = false;
const char* pszWKTFormat = "WKT2";
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and "
"is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME,
GDALVersionInfo("RELEASE_NAME"));
CSLDestroy(papszArgv);
return 0;
}
else if( EQUAL(papszArgv[iArg], "--help") )
{
Usage();
}
else if( EQUAL(papszArgv[iArg], "-ro") )
{
bReadOnly = true;
}
else if( EQUAL(papszArgv[iArg], "-update") )
{
bUpdate = true;
}
else if( EQUAL(papszArgv[iArg], "-q") ||
EQUAL(papszArgv[iArg], "-quiet"))
{
bVerbose = false;
}
else if( EQUAL(papszArgv[iArg], "-qq") )
{
/* Undocumented: mainly only useful for AFL testing */
bVerbose = false;
bSuperQuiet = true;
}
else if( EQUAL(papszArgv[iArg], "-fid") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
nFetchFID = CPLAtoGIntBig(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg], "-spat") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(4);
OGRLinearRing oRing;
oRing.addPoint(CPLAtof(papszArgv[iArg+1]),
CPLAtof(papszArgv[iArg+2]));
oRing.addPoint(CPLAtof(papszArgv[iArg+1]),
CPLAtof(papszArgv[iArg+4]));
oRing.addPoint(CPLAtof(papszArgv[iArg+3]),
CPLAtof(papszArgv[iArg+4]));
oRing.addPoint(CPLAtof(papszArgv[iArg+3]),
CPLAtof(papszArgv[iArg+2]));
oRing.addPoint(CPLAtof(papszArgv[iArg+1]),
CPLAtof(papszArgv[iArg+2]));
poSpatialFilter = new OGRPolygon();
static_cast<OGRPolygon *>(poSpatialFilter)->addRing(&oRing);
iArg += 4;
}
else if( EQUAL(papszArgv[iArg], "-geomfield") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszGeomField = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg], "-where") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
iArg++;
CPLFree(pszWHERE);
GByte* pabyRet = nullptr;
if( papszArgv[iArg][0] == '@' &&
VSIIngestFile(nullptr, papszArgv[iArg] + 1, &pabyRet,
nullptr, 1024*1024) )
{
RemoveBOM(pabyRet);
pszWHERE = reinterpret_cast<char *>(pabyRet);
}
else
{
pszWHERE = CPLStrdup(papszArgv[iArg]);
}
}
else if( EQUAL(papszArgv[iArg], "-sql") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
iArg++;
CPLFree(pszSQLStatement);
GByte* pabyRet = nullptr;
if( papszArgv[iArg][0] == '@' &&
VSIIngestFile(nullptr, papszArgv[iArg] + 1, &pabyRet,
nullptr, 1024*1024) )
{
RemoveBOM(pabyRet);
pszSQLStatement = reinterpret_cast<char *>(pabyRet);
RemoveSQLComments(pszSQLStatement);
}
else
{
pszSQLStatement = CPLStrdup(papszArgv[iArg]);
}
}
else if( EQUAL(papszArgv[iArg], "-dialect") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszDialect = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg], "-rc") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
nRepeatCount = atoi(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg], "-al") )
{
bAllLayers = true;
}
else if( EQUAL(papszArgv[iArg], "-so") ||
EQUAL(papszArgv[iArg], "-summary") )
{
bSummaryOnly = true;
}
else if( STARTS_WITH_CI(papszArgv[iArg], "-fields=") )
{
char* pszTemp =
static_cast<char *>(CPLMalloc(32 + strlen(papszArgv[iArg])));
snprintf(pszTemp,
32 + strlen(papszArgv[iArg]),
"DISPLAY_FIELDS=%s", papszArgv[iArg] + strlen("-fields="));
papszOptions = CSLAddString(papszOptions, pszTemp);
CPLFree(pszTemp);
}
else if( STARTS_WITH_CI(papszArgv[iArg], "-geom=") )
{
char* pszTemp =
static_cast<char *>(CPLMalloc(32 + strlen(papszArgv[iArg])));
snprintf(pszTemp,
32 + strlen(papszArgv[iArg]),
"DISPLAY_GEOMETRY=%s", papszArgv[iArg] + strlen("-geom="));
papszOptions = CSLAddString(papszOptions, pszTemp);
CPLFree(pszTemp);
}
else if( EQUAL(papszArgv[iArg], "-oo") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszOpenOptions = CSLAddString(papszOpenOptions,
papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg], "-nomd") )
{
bShowMetadata = false;
}
else if( EQUAL(papszArgv[iArg], "-listmdd") )
{
bListMDD = true;
}
else if( EQUAL(papszArgv[iArg], "-mdd") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszExtraMDDomains = CSLAddString(papszExtraMDDomains,
papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg], "-nocount") )
{
bFeatureCount = false;
}
else if( EQUAL(papszArgv[iArg], "-noextent") )
{
bExtent = false;
}
else if( EQUAL(papszArgv[iArg], "-rl"))
{
bDatasetGetNextFeature = true;
}
else if( EQUAL(papszArgv[iArg], "-wkt_format") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszWKTFormat = papszArgv[++iArg];
}
else if( papszArgv[iArg][0] == '-' )
{
Usage(CPLSPrintf("Unknown option name '%s'", papszArgv[iArg]));
}
else if( pszDataSource == nullptr )
{
pszDataSource = papszArgv[iArg];
}
else
{
papszLayers = CSLAddString(papszLayers, papszArgv[iArg]);
bAllLayers = false;
}
}
if( pszDataSource == nullptr )
Usage("No datasource specified.");
if( pszDialect != nullptr && pszWHERE != nullptr &&
pszSQLStatement == nullptr )
printf("Warning: -dialect is ignored with -where. Use -sql instead");
if( bDatasetGetNextFeature && pszSQLStatement )
{
Usage("-rl is incompatible with -sql");
}
#ifdef __AFL_HAVE_MANUAL_CONTROL
while (__AFL_LOOP(1000)) {
#endif
/* -------------------------------------------------------------------- */
/* Open data source. */
/* -------------------------------------------------------------------- */
GDALDataset *poDS = static_cast<GDALDataset *>(GDALOpenEx(
pszDataSource,
((bReadOnly || pszSQLStatement == nullptr) &&
!bUpdate ? GDAL_OF_READONLY : GDAL_OF_UPDATE) | GDAL_OF_VECTOR,
nullptr, papszOpenOptions, nullptr));
if( poDS == nullptr && !bReadOnly && !bUpdate &&
pszSQLStatement == nullptr )
{
// In some cases (empty geopackage for example), opening in read-only
// mode fails, so retry in update mode
if( GDALIdentifyDriverEx(pszDataSource, GDAL_OF_VECTOR,
nullptr, nullptr) )
{
poDS = static_cast<GDALDataset *>(GDALOpenEx(
pszDataSource,
GDAL_OF_UPDATE | GDAL_OF_VECTOR, nullptr,
papszOpenOptions, nullptr));
}
}
if( poDS == nullptr && !bReadOnly && !bUpdate &&
pszSQLStatement != nullptr )
{
poDS = static_cast<GDALDataset *>(GDALOpenEx(
pszDataSource,
GDAL_OF_READONLY | GDAL_OF_VECTOR, nullptr,
papszOpenOptions, nullptr));
if( poDS != nullptr && bVerbose )
{
printf("Had to open data source read-only.\n");
#ifdef __AFL_HAVE_MANUAL_CONTROL
bReadOnly = true;
#endif
}
}
GDALDriver *poDriver = nullptr;
if( poDS != nullptr )
poDriver = poDS->GetDriver();
/* -------------------------------------------------------------------- */
/* Report failure */
/* -------------------------------------------------------------------- */
if( poDS == nullptr )
{
printf("FAILURE:\n"
"Unable to open datasource `%s' with the following drivers.\n",
pszDataSource);
#ifdef __AFL_HAVE_MANUAL_CONTROL
continue;
#else
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
for( int iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
{
printf(" -> %s\n", poR->GetDriver(iDriver)->GetDescription());
}
nRet = 1;
goto end;
#endif
}
CPLAssert(poDriver != nullptr);
/* -------------------------------------------------------------------- */
/* Some information messages. */
/* -------------------------------------------------------------------- */
if( bVerbose )
printf("INFO: Open of `%s'\n"
" using driver `%s' successful.\n",
pszDataSource, poDriver->GetDescription());
if( bVerbose && !EQUAL(pszDataSource,poDS->GetDescription()) )
{
printf("INFO: Internal data source name `%s'\n"
" different from user name `%s'.\n",
poDS->GetDescription(), pszDataSource);
}
GDALInfoReportMetadata(static_cast<GDALMajorObjectH>(poDS),
bListMDD,
bShowMetadata,
papszExtraMDDomains);
if( bDatasetGetNextFeature )
{
nRepeatCount = 0; // skip layer reporting.
/* -------------------------------------------------------------------- */
/* Set filters if provided. */
/* -------------------------------------------------------------------- */
if( pszWHERE != nullptr || poSpatialFilter != nullptr )
{
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == nullptr )
{
printf("FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer);
exit(1);
}
if( pszWHERE != nullptr )
{
if( poLayer->SetAttributeFilter(pszWHERE) != OGRERR_NONE )
{
printf("WARNING: SetAttributeFilter(%s) "
"failed on layer %s.\n",
pszWHERE, poLayer->GetName());
}
}
if( poSpatialFilter != nullptr )
{
if( pszGeomField != nullptr )
{
OGRFeatureDefn *poDefn = poLayer->GetLayerDefn();
const int iGeomField =
poDefn->GetGeomFieldIndex(pszGeomField);
if( iGeomField >= 0 )
poLayer->SetSpatialFilter(iGeomField,
poSpatialFilter);
else
printf("WARNING: Cannot find geometry field %s.\n",
pszGeomField);
}
else
{
poLayer->SetSpatialFilter(poSpatialFilter);
}
}
}
}
std::set<OGRLayer*> oSetLayers;
while( true )
{
OGRLayer* poLayer = nullptr;
OGRFeature* poFeature = poDS->GetNextFeature(&poLayer, nullptr,
nullptr, nullptr);
if( poFeature == nullptr )
break;
if( papszLayers == nullptr || poLayer == nullptr ||
CSLFindString(papszLayers, poLayer->GetName()) >= 0 )
{
if( bVerbose && poLayer != nullptr &&
oSetLayers.find(poLayer) == oSetLayers.end() )
{
oSetLayers.insert(poLayer);
const bool bSummaryOnlyBackup = bSummaryOnly;
bSummaryOnly = true;
ReportOnLayer(poLayer, nullptr, nullptr, nullptr,
bListMDD, bShowMetadata,
papszExtraMDDomains,
bFeatureCount,
bExtent,
pszWKTFormat);
bSummaryOnly = bSummaryOnlyBackup;
}
if( !bSuperQuiet && !bSummaryOnly )
poFeature->DumpReadable(nullptr, papszOptions);
}
OGRFeature::DestroyFeature(poFeature);
}
}
/* -------------------------------------------------------------------- */
/* Special case for -sql clause. No source layers required. */
/* -------------------------------------------------------------------- */
else if( pszSQLStatement != nullptr )
{
nRepeatCount = 0; // skip layer reporting.
if( CSLCount(papszLayers) > 0 )
printf("layer names ignored in combination with -sql.\n");
OGRLayer *poResultSet =
poDS->ExecuteSQL(
pszSQLStatement,
pszGeomField == nullptr ? poSpatialFilter : nullptr,
pszDialect);
if( poResultSet != nullptr )
{
if( pszWHERE != nullptr )
{
if( poResultSet->SetAttributeFilter(pszWHERE) != OGRERR_NONE )
{
printf("FAILURE: SetAttributeFilter(%s) failed.\n",
pszWHERE);
exit(1);
}
}
if( pszGeomField != nullptr )
ReportOnLayer(poResultSet, nullptr,
pszGeomField, poSpatialFilter,
bListMDD, bShowMetadata, papszExtraMDDomains,
bFeatureCount, bExtent, pszWKTFormat);
else
ReportOnLayer(poResultSet, nullptr, nullptr, nullptr,
bListMDD, bShowMetadata, papszExtraMDDomains,
bFeatureCount, bExtent, pszWKTFormat);
poDS->ReleaseResultSet(poResultSet);
}
}
// coverity[tainted_data]
for( int iRepeat = 0; iRepeat < nRepeatCount; iRepeat++ )
{
if( papszLayers == nullptr || *papszLayers == nullptr )
{
if( iRepeat == 0 )
CPLDebug("OGR", "GetLayerCount() = %d\n",
poDS->GetLayerCount());
/* -------------------------------------------------------------------- */
/* Process each data source layer. */
/* -------------------------------------------------------------------- */
for( int iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
{
OGRLayer *poLayer = poDS->GetLayer(iLayer);
if( poLayer == nullptr )
{
printf("FAILURE: Couldn't fetch advertised layer %d!\n",
iLayer);
exit(1);
}
if( !bAllLayers )
{
printf("%d: %s", iLayer + 1, poLayer->GetName());
const int nGeomFieldCount =
poLayer->GetLayerDefn()->GetGeomFieldCount();
if( nGeomFieldCount > 1 )
{
printf(" (");
for( int iGeom = 0; iGeom < nGeomFieldCount; iGeom++ )
{
if( iGeom > 0 )
printf(", ");
OGRGeomFieldDefn* poGFldDefn =
poLayer->GetLayerDefn()->
GetGeomFieldDefn(iGeom);
printf(
"%s",
OGRGeometryTypeToName(
poGFldDefn->GetType()));
}
printf(")");
}
else if( poLayer->GetGeomType() != wkbUnknown )
printf(" (%s)",
OGRGeometryTypeToName(
poLayer->GetGeomType()));
printf("\n");
}
else
{
if( iRepeat != 0 )
poLayer->ResetReading();
ReportOnLayer(poLayer, pszWHERE,
pszGeomField, poSpatialFilter,
bListMDD, bShowMetadata, papszExtraMDDomains,
bFeatureCount, bExtent, pszWKTFormat);
}
}
}
else
{
/* -------------------------------------------------------------------- */
/* Process specified data source layers. */
/* -------------------------------------------------------------------- */
for( char** papszIter = papszLayers;
*papszIter != nullptr;
++papszIter )
{
OGRLayer *poLayer = poDS->GetLayerByName(*papszIter);
if( poLayer == nullptr )
{
printf("FAILURE: Couldn't fetch requested layer %s!\n",
*papszIter);
exit(1);
}
if( iRepeat != 0 )
poLayer->ResetReading();
ReportOnLayer(poLayer, pszWHERE, pszGeomField, poSpatialFilter,
bListMDD, bShowMetadata, papszExtraMDDomains,
bFeatureCount, bExtent, pszWKTFormat);
}
}
}
/* -------------------------------------------------------------------- */
/* Close down. */
/* -------------------------------------------------------------------- */
GDALClose(poDS);
#ifdef __AFL_HAVE_MANUAL_CONTROL
}
#else
end:
#endif
CSLDestroy(papszArgv);
CSLDestroy(papszLayers);
CSLDestroy(papszOptions);
CSLDestroy(papszOpenOptions);
CSLDestroy(papszExtraMDDomains);
if( poSpatialFilter )
OGRGeometryFactory::destroyGeometry(poSpatialFilter);
CPLFree(pszSQLStatement);
CPLFree(pszWHERE);
OGRCleanupAll();
return nRet;
}
GIntBig CPL_STDCALL GDALGetCacheMax64()
{
if( !bCacheMaxInitialized )
{
{
INITIALIZE_LOCK;
}
bSleepsForBockCacheDebug = CPLTestBool(
CPLGetConfigOption("GDAL_DEBUG_BLOCK_CACHE", "NO"));
const char* pszCacheMax = CPLGetConfigOption("GDAL_CACHEMAX","5%");
GIntBig nNewCacheMax;
if( strchr(pszCacheMax, '%') != NULL )
{
GIntBig nUsagePhysicalRAM = CPLGetUsablePhysicalRAM();
// For some reason, coverity pretends that this will overflow.
// "Multiply operation overflows on operands static_cast<double>(
// nUsagePhysicalRAM ) and CPLAtof(pszCacheMax). Example values for
// operands: CPLAtof( pszCacheMax ) = 2251799813685248,
// static_cast<double>(nUsagePhysicalRAM) = -9223372036854775808."
// coverity[overflow]
double dfCacheMax =
static_cast<double>(nUsagePhysicalRAM) *
CPLAtof(pszCacheMax) / 100.0;
if( dfCacheMax >= 0 && dfCacheMax < 1e15 )
nNewCacheMax = static_cast<GIntBig>(dfCacheMax);
else
nNewCacheMax = nCacheMax;
}
else
{
nNewCacheMax = CPLAtoGIntBig(pszCacheMax);
if( nNewCacheMax < 100000 )
{
if (nNewCacheMax < 0)
{
CPLError(
CE_Failure, CPLE_NotSupported,
"Invalid value for GDAL_CACHEMAX. "
"Using default value.");
GIntBig nUsagePhysicalRAM = CPLGetUsablePhysicalRAM();
if( nUsagePhysicalRAM )
nNewCacheMax = nUsagePhysicalRAM / 20;
else
nNewCacheMax = nCacheMax;
}
else
{
nNewCacheMax *= 1024 * 1024;
}
}
}
nCacheMax = nNewCacheMax;
CPLDebug( "GDAL", "GDAL_CACHEMAX = " CPL_FRMT_GIB " MB",
nCacheMax / (1024 * 1024));
bCacheMaxInitialized = true;
}
// coverity[overflow_sink]
return nCacheMax;
}
OGRFeature *OGRGMLLayer::GetNextFeature()
{
if (bWriter)
{
CPLError(CE_Failure, CPLE_NotSupported,
"Cannot read features when writing a GML file");
return NULL;
}
if( poDS->GetLastReadLayer() != this )
{
if( poDS->GetReadMode() != INTERLEAVED_LAYERS )
ResetReading();
poDS->SetLastReadLayer(this);
}
/* ==================================================================== */
/* Loop till we find and translate a feature meeting all our */
/* requirements. */
/* ==================================================================== */
while( true )
{
GMLFeature *poGMLFeature = NULL;
OGRGeometry *poGeom = NULL;
poGMLFeature = poDS->PeekStoredGMLFeature();
if (poGMLFeature != NULL)
poDS->SetStoredGMLFeature(NULL);
else
{
poGMLFeature = poDS->GetReader()->NextFeature();
if( poGMLFeature == NULL )
return NULL;
// We count reading low level GML features as a feature read for
// work checking purposes, though at least we didn't necessary
// have to turn it into an OGRFeature.
m_nFeaturesRead++;
}
/* -------------------------------------------------------------------- */
/* Is it of the proper feature class? */
/* -------------------------------------------------------------------- */
if( poGMLFeature->GetClass() != poFClass )
{
if( poDS->GetReadMode() == INTERLEAVED_LAYERS ||
(poDS->GetReadMode() == SEQUENTIAL_LAYERS && iNextGMLId != 0) )
{
CPLAssert(poDS->PeekStoredGMLFeature() == NULL);
poDS->SetStoredGMLFeature(poGMLFeature);
return NULL;
}
else
{
delete poGMLFeature;
continue;
}
}
/* -------------------------------------------------------------------- */
/* Extract the fid: */
/* -Assumes the fids are non-negative integers with an optional */
/* prefix */
/* -If a prefix differs from the prefix of the first feature from */
/* the poDS then the fids from the poDS are ignored and are */
/* assigned serially thereafter */
/* -------------------------------------------------------------------- */
GIntBig nFID = -1;
const char * pszGML_FID = poGMLFeature->GetFID();
if( bInvalidFIDFound )
{
nFID = iNextGMLId++;
}
else if( pszGML_FID == NULL )
{
bInvalidFIDFound = true;
nFID = iNextGMLId++;
}
else if( iNextGMLId == 0 )
{
int j = 0;
int i = static_cast<int>(strlen( pszGML_FID ))-1;
while( i >= 0 && pszGML_FID[i] >= '0'
&& pszGML_FID[i] <= '9' && j<20)
i--, j++;
/* i points the last character of the fid */
if( i >= 0 && j < 20 && pszFIDPrefix == NULL)
{
pszFIDPrefix = (char *) CPLMalloc(i+2);
pszFIDPrefix[i+1] = '\0';
strncpy(pszFIDPrefix, pszGML_FID, i+1);
}
/* pszFIDPrefix now contains the prefix or NULL if no prefix is found */
if( j < 20 && sscanf(pszGML_FID+i+1, CPL_FRMT_GIB, &nFID)==1)
{
if( iNextGMLId <= nFID )
iNextGMLId = nFID + 1;
}
else
{
bInvalidFIDFound = true;
nFID = iNextGMLId++;
}
}
else if( iNextGMLId != 0 )
{
const char* pszFIDPrefix_notnull = pszFIDPrefix;
if (pszFIDPrefix_notnull == NULL) pszFIDPrefix_notnull = "";
int nLenPrefix = static_cast<int>(strlen(pszFIDPrefix_notnull));
if( strncmp(pszGML_FID, pszFIDPrefix_notnull, nLenPrefix) == 0 &&
strlen(pszGML_FID+nLenPrefix) < 20 &&
sscanf(pszGML_FID+nLenPrefix, CPL_FRMT_GIB, &nFID) == 1 )
{ /* fid with the prefix. Using its numerical part */
if( iNextGMLId < nFID )
iNextGMLId = nFID + 1;
}
else
{ /* fid without the aforementioned prefix or a valid numerical part */
bInvalidFIDFound = true;
nFID = iNextGMLId++;
}
}
/* -------------------------------------------------------------------- */
/* Does it satisfy the spatial query, if there is one? */
/* -------------------------------------------------------------------- */
OGRGeometry** papoGeometries = NULL;
const CPLXMLNode* const * papsGeometry = poGMLFeature->GetGeometryList();
if( poFeatureDefn->GetGeomFieldCount() > 1 )
{
papoGeometries = (OGRGeometry**)
CPLCalloc( poFeatureDefn->GetGeomFieldCount(), sizeof(OGRGeometry*) );
const char* pszSRSName = poDS->GetGlobalSRSName();
for( int i=0; i < poFeatureDefn->GetGeomFieldCount(); i++ )
{
const CPLXMLNode* psGeom = poGMLFeature->GetGeometryRef(i);
if( psGeom != NULL )
{
const CPLXMLNode* myGeometryList[2];
myGeometryList[0] = psGeom;
myGeometryList[1] = NULL;
poGeom = GML_BuildOGRGeometryFromList(myGeometryList, true,
poDS->GetInvertAxisOrderIfLatLong(),
pszSRSName,
poDS->GetConsiderEPSGAsURN(),
poDS->GetSecondaryGeometryOption(),
hCacheSRS,
bFaceHoleNegative );
/* Do geometry type changes if needed to match layer geometry type */
if (poGeom != NULL)
{
papoGeometries[i] = OGRGeometryFactory::forceTo(poGeom,
poFeatureDefn->GetGeomFieldDefn(i)->GetType());
poGeom = NULL;
}
else
// We assume the createFromGML() function would have already
// reported the error.
{
for( i=0; i < poFeatureDefn->GetGeomFieldCount(); i++)
{
delete papoGeometries[i];
}
CPLFree(papoGeometries);
delete poGMLFeature;
return NULL;
}
}
}
if( m_poFilterGeom != NULL &&
m_iGeomFieldFilter >= 0 &&
m_iGeomFieldFilter < poFeatureDefn->GetGeomFieldCount() &&
papoGeometries[m_iGeomFieldFilter] &&
!FilterGeometry( papoGeometries[m_iGeomFieldFilter] ) )
{
for( int i=0; i < poFeatureDefn->GetGeomFieldCount(); i++ )
{
delete papoGeometries[i];
}
CPLFree(papoGeometries);
delete poGMLFeature;
continue;
}
}
else if (papsGeometry[0] != NULL)
{
const char* pszSRSName = poDS->GetGlobalSRSName();
poGeom = GML_BuildOGRGeometryFromList(papsGeometry, true,
poDS->GetInvertAxisOrderIfLatLong(),
pszSRSName,
poDS->GetConsiderEPSGAsURN(),
poDS->GetSecondaryGeometryOption(),
hCacheSRS,
bFaceHoleNegative );
/* Do geometry type changes if needed to match layer geometry type */
if (poGeom != NULL)
{
poGeom = OGRGeometryFactory::forceTo(poGeom, GetGeomType());
}
else
// We assume the createFromGML() function would have already
// reported the error.
{
delete poGMLFeature;
return NULL;
}
if( m_poFilterGeom != NULL && !FilterGeometry( poGeom ) )
{
delete poGMLFeature;
delete poGeom;
continue;
}
}
/* -------------------------------------------------------------------- */
/* Convert the whole feature into an OGRFeature. */
/* -------------------------------------------------------------------- */
int iField;
int iDstField = 0;
OGRFeature *poOGRFeature = new OGRFeature( poFeatureDefn );
poOGRFeature->SetFID( nFID );
if (poDS->ExposeId())
{
if (pszGML_FID)
poOGRFeature->SetField( iDstField, pszGML_FID );
iDstField ++;
}
int nPropertyCount = poFClass->GetPropertyCount();
for( iField = 0; iField < nPropertyCount; iField++, iDstField ++ )
{
const GMLProperty *psGMLProperty = poGMLFeature->GetProperty( iField );
if( psGMLProperty == NULL || psGMLProperty->nSubProperties == 0 )
continue;
switch( poFClass->GetProperty(iField)->GetType() )
{
case GMLPT_Real:
{
poOGRFeature->SetField( iDstField, CPLAtof(psGMLProperty->papszSubProperties[0]) );
}
break;
case GMLPT_IntegerList:
{
int nCount = psGMLProperty->nSubProperties;
int *panIntList = (int *) CPLMalloc(sizeof(int) * nCount );
for( int i = 0; i < nCount; i++ )
panIntList[i]
= atoi(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iDstField, nCount, panIntList );
CPLFree( panIntList );
}
break;
case GMLPT_Integer64List:
{
int nCount = psGMLProperty->nSubProperties;
GIntBig *panIntList = (GIntBig *) CPLMalloc(sizeof(GIntBig) * nCount );
for( int i = 0; i < nCount; i++ )
panIntList[i]
= CPLAtoGIntBig(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iDstField, nCount, panIntList );
CPLFree( panIntList );
}
break;
case GMLPT_RealList:
{
int nCount = psGMLProperty->nSubProperties;
double *padfList = (double *)CPLMalloc(sizeof(double)*nCount);
for( int i = 0; i < nCount; i++ )
padfList[i]
= CPLAtof(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iDstField, nCount, padfList );
CPLFree( padfList );
}
break;
case GMLPT_StringList:
case GMLPT_FeaturePropertyList:
{
poOGRFeature->SetField( iDstField, psGMLProperty->papszSubProperties );
}
break;
case GMLPT_Boolean:
{
if( strcmp(psGMLProperty->papszSubProperties[0], "true") == 0 ||
strcmp(psGMLProperty->papszSubProperties[0], "1") == 0 )
{
poOGRFeature->SetField( iDstField, 1);
}
else if( strcmp(psGMLProperty->papszSubProperties[0], "false") == 0 ||
strcmp(psGMLProperty->papszSubProperties[0], "0") == 0 )
{
poOGRFeature->SetField( iDstField, 0);
}
else
poOGRFeature->SetField( iDstField, psGMLProperty->papszSubProperties[0] );
break;
}
case GMLPT_BooleanList:
{
int nCount = psGMLProperty->nSubProperties;
int *panIntList = (int *) CPLMalloc(sizeof(int) * nCount );
for( int i = 0; i < nCount; i++ )
{
panIntList[i] = (
strcmp(psGMLProperty->papszSubProperties[i],
"true") == 0 ||
strcmp(psGMLProperty->papszSubProperties[i],
"1") == 0 );
}
poOGRFeature->SetField( iDstField, nCount, panIntList );
CPLFree( panIntList );
break;
}
default:
poOGRFeature->SetField( iDstField, psGMLProperty->papszSubProperties[0] );
break;
}
}
delete poGMLFeature;
poGMLFeature = NULL;
/* Assign the geometry before the attribute filter because */
/* the attribute filter may use a special field like OGR_GEOMETRY */
if( papoGeometries != NULL )
{
for( int i=0; i < poFeatureDefn->GetGeomFieldCount(); i++ )
{
poOGRFeature->SetGeomFieldDirectly( i, papoGeometries[i] );
}
CPLFree(papoGeometries);
papoGeometries = NULL;
}
else
poOGRFeature->SetGeometryDirectly( poGeom );
/* Assign SRS */
for( int i=0; i < poFeatureDefn->GetGeomFieldCount(); i++ )
{
poGeom = poOGRFeature->GetGeomFieldRef(i);
if( poGeom != NULL )
{
OGRSpatialReference* poSRS
= poFeatureDefn->GetGeomFieldDefn(i)->GetSpatialRef();
if (poSRS != NULL)
poGeom->assignSpatialReference(poSRS);
}
}
/* -------------------------------------------------------------------- */
/* Test against the attribute query. */
/* -------------------------------------------------------------------- */
if( m_poAttrQuery != NULL
&& !m_poAttrQuery->Evaluate( poOGRFeature ) )
{
delete poOGRFeature;
continue;
}
/* -------------------------------------------------------------------- */
/* Wow, we got our desired feature. Return it. */
/* -------------------------------------------------------------------- */
return poOGRFeature;
}
return NULL;
}
int swqlex( YYSTYPE *ppNode, swq_parse_context *context )
{
const char *pszInput = context->pszNext;
*ppNode = NULL;
/* -------------------------------------------------------------------- */
/* Do we have a start symbol to return? */
/* -------------------------------------------------------------------- */
if( context->nStartToken != 0 )
{
int nRet = context->nStartToken;
context->nStartToken = 0;
return nRet;
}
/* -------------------------------------------------------------------- */
/* Skip white space. */
/* -------------------------------------------------------------------- */
while( *pszInput == ' ' || *pszInput == '\t'
|| *pszInput == 10 || *pszInput == 13 )
pszInput++;
context->pszLastValid = pszInput;
if( *pszInput == '\0' )
{
context->pszNext = pszInput;
return EOF;
}
/* -------------------------------------------------------------------- */
/* Handle string constants. */
/* -------------------------------------------------------------------- */
if( *pszInput == '"' || *pszInput == '\'' )
{
char *token;
int i_token;
char chQuote = *pszInput;
int bFoundEndQuote = FALSE;
int nRet = *pszInput == '"' ? SWQT_IDENTIFIER : SWQT_STRING;
pszInput++;
token = (char *) CPLMalloc(strlen(pszInput)+1);
i_token = 0;
while( *pszInput != '\0' )
{
if( chQuote == '"' && *pszInput == '\\' && pszInput[1] == '"' )
pszInput++;
else if( chQuote == '\'' && *pszInput == '\\' && pszInput[1] == '\'' )
pszInput++;
else if( chQuote == '\'' && *pszInput == '\'' && pszInput[1] == '\'' )
pszInput++;
else if( *pszInput == chQuote )
{
pszInput++;
bFoundEndQuote = TRUE;
break;
}
token[i_token++] = *(pszInput++);
}
token[i_token] = '\0';
if( !bFoundEndQuote )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Did not find end-of-string character");
CPLFree( token );
return 0;
}
*ppNode = new swq_expr_node( token );
CPLFree( token );
context->pszNext = pszInput;
return nRet;
}
/* -------------------------------------------------------------------- */
/* Handle numbers. */
/* -------------------------------------------------------------------- */
else if( *pszInput >= '0' && *pszInput <= '9' )
{
CPLString osToken;
const char *pszNext = pszInput + 1;
osToken += *pszInput;
// collect non-decimal part of number
while( *pszNext >= '0' && *pszNext <= '9' )
osToken += *(pszNext++);
// collect decimal places.
if( *pszNext == '.' )
{
osToken += *(pszNext++);
while( *pszNext >= '0' && *pszNext <= '9' )
osToken += *(pszNext++);
}
// collect exponent
if( *pszNext == 'e' || *pszNext == 'E' )
{
osToken += *(pszNext++);
if( *pszNext == '-' || *pszNext == '+' )
osToken += *(pszNext++);
while( *pszNext >= '0' && *pszNext <= '9' )
osToken += *(pszNext++);
}
context->pszNext = pszNext;
if( strstr(osToken,".")
|| strstr(osToken,"e")
|| strstr(osToken,"E") )
{
*ppNode = new swq_expr_node( CPLAtof(osToken) );
return SWQT_FLOAT_NUMBER;
}
else
{
GIntBig nVal = CPLAtoGIntBig(osToken);
if( (GIntBig)(int)nVal == nVal )
*ppNode = new swq_expr_node( (int)nVal );
else
*ppNode = new swq_expr_node( nVal );
return SWQT_INTEGER_NUMBER;
}
}
/* -------------------------------------------------------------------- */
/* Handle alpha-numerics. */
/* -------------------------------------------------------------------- */
else if( isalnum( *pszInput ) )
{
int nReturn = SWQT_IDENTIFIER;
CPLString osToken;
const char *pszNext = pszInput + 1;
osToken += *pszInput;
// collect text characters
while( isalnum( *pszNext ) || *pszNext == '_'
|| ((unsigned char) *pszNext) > 127 )
osToken += *(pszNext++);
context->pszNext = pszNext;
if( EQUAL(osToken,"IN") )
nReturn = SWQT_IN;
else if( EQUAL(osToken,"LIKE") )
nReturn = SWQT_LIKE;
else if( EQUAL(osToken,"ILIKE") )
nReturn = SWQT_LIKE;
else if( EQUAL(osToken,"ESCAPE") )
nReturn = SWQT_ESCAPE;
else if( EQUAL(osToken,"NULL") )
nReturn = SWQT_NULL;
else if( EQUAL(osToken,"IS") )
nReturn = SWQT_IS;
else if( EQUAL(osToken,"NOT") )
nReturn = SWQT_NOT;
else if( EQUAL(osToken,"AND") )
nReturn = SWQT_AND;
else if( EQUAL(osToken,"OR") )
nReturn = SWQT_OR;
else if( EQUAL(osToken,"BETWEEN") )
nReturn = SWQT_BETWEEN;
else if( EQUAL(osToken,"SELECT") )
nReturn = SWQT_SELECT;
else if( EQUAL(osToken,"LEFT") )
nReturn = SWQT_LEFT;
else if( EQUAL(osToken,"JOIN") )
nReturn = SWQT_JOIN;
else if( EQUAL(osToken,"WHERE") )
nReturn = SWQT_WHERE;
else if( EQUAL(osToken,"ON") )
nReturn = SWQT_ON;
else if( EQUAL(osToken,"ORDER") )
nReturn = SWQT_ORDER;
else if( EQUAL(osToken,"BY") )
nReturn = SWQT_BY;
else if( EQUAL(osToken,"FROM") )
nReturn = SWQT_FROM;
else if( EQUAL(osToken,"AS") )
nReturn = SWQT_AS;
else if( EQUAL(osToken,"ASC") )
nReturn = SWQT_ASC;
else if( EQUAL(osToken,"DESC") )
nReturn = SWQT_DESC;
else if( EQUAL(osToken,"DISTINCT") )
nReturn = SWQT_DISTINCT;
else if( EQUAL(osToken,"CAST") )
nReturn = SWQT_CAST;
else if( EQUAL(osToken,"UNION") )
nReturn = SWQT_UNION;
else if( EQUAL(osToken,"ALL") )
nReturn = SWQT_ALL;
/* Unhandled by OGR SQL */
else if( EQUAL(osToken,"LIMIT") ||
EQUAL(osToken,"OUTER") ||
EQUAL(osToken,"INNER") )
nReturn = SWQT_RESERVED_KEYWORD;
else
{
*ppNode = new swq_expr_node( osToken );
nReturn = SWQT_IDENTIFIER;
}
return nReturn;
}
/* -------------------------------------------------------------------- */
/* Handle special tokens. */
/* -------------------------------------------------------------------- */
else
{
context->pszNext = pszInput+1;
return *pszInput;
}
}
OGRFeature *OGRMySQLLayer::RecordToFeature( char **papszRow,
unsigned long *panLengths )
{
mysql_field_seek( hResultSet, 0 );
/* -------------------------------------------------------------------- */
/* Create a feature from the current result. */
/* -------------------------------------------------------------------- */
int iField;
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
poFeature->SetFID( iNextShapeId );
m_nFeaturesRead++;
/* ==================================================================== */
/* Transfer all result fields we can. */
/* ==================================================================== */
for( iField = 0;
iField < (int) mysql_num_fields(hResultSet);
iField++ )
{
int iOGRField;
MYSQL_FIELD *psMSField = mysql_fetch_field(hResultSet);
/* -------------------------------------------------------------------- */
/* Handle FID. */
/* -------------------------------------------------------------------- */
if( bHasFid && EQUAL(psMSField->name,pszFIDColumn) )
{
if( papszRow[iField] == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"NULL primary key in RecordToFeature()" );
return NULL;
}
poFeature->SetFID( CPLAtoGIntBig(papszRow[iField]) );
}
if( papszRow[iField] == NULL )
{
// CPLDebug("MYSQL", "%s was null for %d", psMSField->name,
// iNextShapeId);
continue;
}
/* -------------------------------------------------------------------- */
/* Handle MySQL geometry */
/* -------------------------------------------------------------------- */
if( pszGeomColumn && EQUAL(psMSField->name,pszGeomColumn))
{
OGRGeometry *poGeometry = NULL;
// Geometry columns will have the first 4 bytes contain the SRID.
OGRGeometryFactory::createFromWkb(
((GByte *)papszRow[iField]) + 4,
NULL,
&poGeometry,
panLengths[iField] - 4 );
if( poGeometry != NULL )
{
poGeometry->assignSpatialReference( GetSpatialRef() );
poFeature->SetGeometryDirectly( poGeometry );
}
continue;
}
/* -------------------------------------------------------------------- */
/* Transfer regular data fields. */
/* -------------------------------------------------------------------- */
iOGRField = poFeatureDefn->GetFieldIndex(psMSField->name);
if( iOGRField < 0 )
continue;
OGRFieldDefn *psFieldDefn = poFeatureDefn->GetFieldDefn( iOGRField );
if( psFieldDefn->GetType() == OFTBinary )
{
poFeature->SetField( iOGRField, panLengths[iField],
(GByte *) papszRow[iField] );
}
else
{
poFeature->SetField( iOGRField, papszRow[iField] );
}
}
return poFeature;
}
CPLErr MEMDataset::AddBand( GDALDataType eType, char **papszOptions )
{
const int nBandId = GetRasterCount() + 1;
const GSpacing nPixelSize = GDALGetDataTypeSizeBytes(eType);
/* -------------------------------------------------------------------- */
/* Do we need to allocate the memory ourselves? This is the */
/* simple case. */
/* -------------------------------------------------------------------- */
if( CSLFetchNameValue( papszOptions, "DATAPOINTER" ) == NULL )
{
const GSpacing nTmp = nPixelSize * GetRasterXSize();
GByte *pData = NULL;
#if SIZEOF_VOIDP == 4
if( nTmp > INT_MAX )
pData = NULL;
else
#endif
pData = reinterpret_cast<GByte *>(
VSI_CALLOC_VERBOSE((size_t)nTmp, GetRasterYSize() ) );
if( pData == NULL )
{
return CE_Failure;
}
SetBand( nBandId,
new MEMRasterBand( this, nBandId, pData, eType, nPixelSize,
nPixelSize * GetRasterXSize(), TRUE ) );
return CE_None;
}
/* -------------------------------------------------------------------- */
/* Get layout of memory and other flags. */
/* -------------------------------------------------------------------- */
const char *pszDataPointer = CSLFetchNameValue(papszOptions, "DATAPOINTER");
GByte *pData = reinterpret_cast<GByte *>(
CPLScanPointer( pszDataPointer,
static_cast<int>(strlen(pszDataPointer)) ) );
const char *pszOption = CSLFetchNameValue(papszOptions, "PIXELOFFSET");
GSpacing nPixelOffset;
if( pszOption == NULL )
nPixelOffset = nPixelSize;
else
nPixelOffset = CPLAtoGIntBig(pszOption);
pszOption = CSLFetchNameValue(papszOptions, "LINEOFFSET");
GSpacing nLineOffset;
if( pszOption == NULL )
nLineOffset = GetRasterXSize() * static_cast<size_t>( nPixelOffset );
else
nLineOffset = CPLAtoGIntBig(pszOption);
SetBand( nBandId,
new MEMRasterBand( this, nBandId, pData, eType,
nPixelOffset, nLineOffset, FALSE ) );
return CE_None;
}
OGRFeature *OGRMSSQLSpatialLayer::GetNextRawFeature()
{
if( GetStatement() == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* If we are marked to restart then do so, and fetch a record. */
/* -------------------------------------------------------------------- */
if( !poStmt->Fetch() )
{
delete poStmt;
poStmt = NULL;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a feature from the current result. */
/* -------------------------------------------------------------------- */
int iField;
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
if( pszFIDColumn != NULL && poStmt->GetColId(pszFIDColumn) > -1 )
poFeature->SetFID(
CPLAtoGIntBig(poStmt->GetColData(poStmt->GetColId(pszFIDColumn))) );
else
poFeature->SetFID( iNextShapeId );
iNextShapeId++;
m_nFeaturesRead++;
/* -------------------------------------------------------------------- */
/* Set the fields. */
/* -------------------------------------------------------------------- */
for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
if ( poFeatureDefn->GetFieldDefn(iField)->IsIgnored() )
continue;
int iSrcField = panFieldOrdinals[iField];
const char *pszValue = poStmt->GetColData( iSrcField );
if( pszValue == NULL )
/* no value */;
else if( poFeature->GetFieldDefnRef(iField)->GetType() == OFTBinary )
poFeature->SetField( iField,
poStmt->GetColDataLength(iSrcField),
(GByte *) pszValue );
else
poFeature->SetField( iField, pszValue );
}
/* -------------------------------------------------------------------- */
/* Try to extract a geometry. */
/* -------------------------------------------------------------------- */
if( pszGeomColumn != NULL && !poFeatureDefn->IsGeometryIgnored())
{
int iField = poStmt->GetColId( pszGeomColumn );
const char *pszGeomText = poStmt->GetColData( iField );
OGRGeometry *poGeom = NULL;
OGRErr eErr = OGRERR_NONE;
if( pszGeomText != NULL )
{
int nLength = poStmt->GetColDataLength( iField );
if ( nGeomColumnType == MSSQLCOLTYPE_GEOMETRY ||
nGeomColumnType == MSSQLCOLTYPE_GEOGRAPHY ||
nGeomColumnType == MSSQLCOLTYPE_BINARY)
{
switch ( poDS->GetGeometryFormat() )
{
case MSSQLGEOMETRY_NATIVE:
{
OGRMSSQLGeometryParser oParser( nGeomColumnType );
eErr = oParser.ParseSqlGeometry(
(unsigned char *) pszGeomText, nLength, &poGeom );
nSRSId = oParser.GetSRSId();
}
break;
case MSSQLGEOMETRY_WKB:
case MSSQLGEOMETRY_WKBZM:
eErr = OGRGeometryFactory::createFromWkb((unsigned char *) pszGeomText,
NULL, &poGeom, nLength);
break;
case MSSQLGEOMETRY_WKT:
eErr = OGRGeometryFactory::createFromWkt((char **) &pszGeomText,
NULL, &poGeom);
break;
}
}
else if (nGeomColumnType == MSSQLCOLTYPE_TEXT)
{
eErr = OGRGeometryFactory::createFromWkt((char **) &pszGeomText,
NULL, &poGeom);
}
}
if ( eErr != OGRERR_NONE )
{
const char *pszMessage;
switch ( eErr )
{
case OGRERR_NOT_ENOUGH_DATA:
pszMessage = "Not enough data to deserialize";
break;
case OGRERR_UNSUPPORTED_GEOMETRY_TYPE:
pszMessage = "Unsupported geometry type";
break;
case OGRERR_CORRUPT_DATA:
pszMessage = "Corrupt data";
break;
default:
pszMessage = "Unrecognized error";
}
CPLError(CE_Failure, CPLE_AppDefined,
"GetNextRawFeature(): %s", pszMessage);
}
if( poGeom != NULL )
{
if ( GetSpatialRef() )
poGeom->assignSpatialReference( poSRS );
poFeature->SetGeometryDirectly( poGeom );
}
}
return poFeature;
}
void GMLPropertyDefn::AnalysePropertyValue( const GMLProperty* psGMLProperty,
int bSetWidth )
{
/* -------------------------------------------------------------------- */
/* Does the string consist entirely of numeric values? */
/* -------------------------------------------------------------------- */
int bIsReal = FALSE;
int j;
for(j=0; j<psGMLProperty->nSubProperties; j++)
{
if (j > 0)
{
if( m_eType == GMLPT_Integer )
m_eType = GMLPT_IntegerList;
else if( m_eType == GMLPT_Integer64 )
m_eType = GMLPT_Integer64List;
else if( m_eType == GMLPT_Real )
m_eType = GMLPT_RealList;
else if( m_eType == GMLPT_String )
{
m_eType = GMLPT_StringList;
m_nWidth = 0;
}
else if( m_eType == GMLPT_Boolean )
m_eType = GMLPT_BooleanList;
}
const char* pszValue = psGMLProperty->papszSubProperties[j];
/* -------------------------------------------------------------------- */
/* If it is a zero length string, just return. We can't deduce */
/* much from this. */
/* -------------------------------------------------------------------- */
if( *pszValue == '\0' )
continue;
CPLValueType valueType = CPLGetValueType(pszValue);
if (valueType == CPL_VALUE_STRING
&& m_eType != GMLPT_String
&& m_eType != GMLPT_StringList )
{
if( (m_eType == GMLPT_Untyped || m_eType == GMLPT_Boolean) &&
(strcmp(pszValue, "true") == 0 ||
strcmp(pszValue, "false") == 0) )
m_eType = GMLPT_Boolean;
else if( m_eType == GMLPT_BooleanList )
{
if( !(strcmp(pszValue, "true") == 0 ||
strcmp(pszValue, "false") == 0) )
m_eType = GMLPT_StringList;
}
else if( m_eType == GMLPT_IntegerList ||
m_eType == GMLPT_Integer64List ||
m_eType == GMLPT_RealList )
m_eType = GMLPT_StringList;
else
m_eType = GMLPT_String;
}
else
bIsReal = (valueType == CPL_VALUE_REAL);
if( m_eType == GMLPT_String )
{
if( bSetWidth )
{
/* grow the Width to the length of the string passed in */
int nWidth;
nWidth = strlen(pszValue);
if ( m_nWidth < nWidth )
SetWidth( nWidth );
}
}
else if( m_eType == GMLPT_Untyped || m_eType == GMLPT_Integer ||
m_eType == GMLPT_Integer64 )
{
if( bIsReal )
m_eType = GMLPT_Real;
else if( m_eType != GMLPT_Integer64 )
{
GIntBig nVal = CPLAtoGIntBig(pszValue);
if( (GIntBig)(int)nVal != nVal )
m_eType = GMLPT_Integer64;
else
m_eType = GMLPT_Integer;
}
}
else if( (m_eType == GMLPT_IntegerList ||
m_eType == GMLPT_Integer64List) && bIsReal )
{
m_eType = GMLPT_RealList;
}
else if( m_eType == GMLPT_IntegerList && valueType == CPL_VALUE_INTEGER )
{
GIntBig nVal = CPLAtoGIntBig(pszValue);
if( (GIntBig)(int)nVal != nVal )
m_eType = GMLPT_Integer64List;
}
}
}
