// Add additional Geometry table for Interlis 1
void AddGeomTable(CPLString layerName, const char* psFieldName, OGRwkbGeometryType eType, bool bRefTIDField = false)
{
OGRFeatureDefn* poGeomTableDefn = new OGRFeatureDefn(layerName);
OGRFieldDefn fieldDef("_TID", OFTString);
poGeomTableDefn->AddFieldDefn(&fieldDef);
if (bRefTIDField)
{
OGRFieldDefn fieldDefRef("_RefTID", OFTString);
poGeomTableDefn->AddFieldDefn(&fieldDefRef);
}
poGeomTableDefn->DeleteGeomFieldDefn(0);
OGRGeomFieldDefn fieldDefGeom(psFieldName, eType);
poGeomTableDefn->AddGeomFieldDefn(&fieldDefGeom);
CPLDebug( "OGR_ILI", "Adding geometry table %s for field %s", poGeomTableDefn->GetName(), psFieldName);
poGeomFieldInfos[psFieldName].geomTable = poGeomTableDefn;
}
OGRErr OGRLayerWithTransaction::CreateField( OGRFieldDefn *poField,
int bApproxOK )
{
if( !m_poDecoratedLayer ) return OGRERR_FAILURE;
int nFields = m_poDecoratedLayer->GetLayerDefn()->GetFieldCount();
OGRErr eErr = m_poDecoratedLayer->CreateField(poField, bApproxOK);
if( m_poFeatureDefn && eErr == OGRERR_NONE && m_poDecoratedLayer->GetLayerDefn()->GetFieldCount() == nFields + 1 )
{
m_poFeatureDefn->AddFieldDefn( m_poDecoratedLayer->GetLayerDefn()->GetFieldDefn(nFields) );
}
return eErr;
}
JNIEXPORT void JNICALL Java_es_gva_cit_jogr_OGRFeatureDefn_addFieldDefnNat
(JNIEnv *env, jobject obj, jlong cPtr, jlong fdefn){
OGRFeatureDefn *fd = (OGRFeatureDefn *) 0 ;
OGRFieldDefn *fielddefn;
fd = *(OGRFeatureDefn **)&cPtr;
fielddefn = *(OGRFieldDefn **)&fdefn;
if(fd!=NULL){
fd->AddFieldDefn(fielddefn);
}
}
int ILI2Reader::AddFeature(DOMElement *elem) {
bool newLayer = true;
OGRLayer *curLayer = NULL;
char *pszName = tr_strdup(elem->getTagName());
//CPLDebug( "OGR_ILI", "Reading layer: %s", pszName );
// test if this layer exist
curLayer = GetLayer(pszName);
newLayer = (curLayer == NULL);
// add a layer
if (newLayer) {
CPLDebug( "OGR_ILI", "Adding layer: %s", pszName );
OGRFeatureDefn* poFeatureDefn = new OGRFeatureDefn(pszName);
poFeatureDefn->SetGeomType( wkbUnknown );
GeomFieldInfos oGeomFieldInfos;
curLayer = new OGRILI2Layer(poFeatureDefn, oGeomFieldInfos, NULL);
m_listLayer.push_back(curLayer);
}
// the feature and field definition
OGRFeatureDefn *featureDef = curLayer->GetLayerDefn();
if (newLayer) {
// add TID field
OGRFieldDefn ofieldDefn (ILI2_TID, OFTString);
featureDef->AddFieldDefn(&ofieldDefn);
setFieldDefn(featureDef, elem);
}
// add the features
OGRFeature *feature = new OGRFeature(featureDef);
// assign TID
int fIndex = feature->GetFieldIndex(ILI2_TID);
if (fIndex != -1) {
XMLCh *pszIli2_tid = XMLString::transcode(ILI2_TID);
char *fChVal = tr_strdup(elem->getAttribute(pszIli2_tid));
feature->SetField(fIndex, fChVal);
XMLString::release(&pszIli2_tid);
CPLFree(fChVal);
} else {
CPLDebug( "OGR_ILI","'%s' not found", ILI2_TID);
}
SetFieldValues(feature, elem);
CPL_IGNORE_RET_VAL(curLayer->SetFeature(feature));
CPLFree(pszName);
return 0;
}
OGRFeatureDefn *AoIIntersection::buildFeatureDefinition ( int& acreIndex, int& areaIndex, OGRFieldDefn*& acreFldDefn, OGRFieldDefn*& areaPctFldDefn )
{
OGRFeatureDefn *ogrFeatureDefn = NULL;
// Create two Field Definitions
acreFldDefn = new OGRFieldDefn( "Acres in AoI", OFTReal );
areaPctFldDefn = new OGRFieldDefn( "Percent of AOI", OFTReal );
if ( acreFldDefn && areaPctFldDefn )
{
// Create Feature Definition
ogrFeatureDefn = new OGRFeatureDefn( "Intersection Features" );
if ( ogrFeatureDefn )
{
// Add Field Definitions to Feature Definition
ogrFeatureDefn->AddFieldDefn( acreFldDefn );
ogrFeatureDefn->AddFieldDefn( areaPctFldDefn );
// Get the field Indices from the Feature Def.
acreIndex = ogrFeatureDefn->GetFieldIndex( "Acres in AoI" );
areaIndex = ogrFeatureDefn->GetFieldIndex( "Percent of AOI" );
}
}
return ogrFeatureDefn;
}
void InitFieldDefinitions()
{
// Delete default geometry field
poTableDefn->DeleteGeomFieldDefn(0);
const char* psKind = CPLGetXMLValue( node, "Kind", NULL );
//CPLDebug( "OGR_ILI", "InitFieldDefinitions of '%s' kind: %s", GetName(), psKind);
if (EQUAL(psKind, "Structure"))
{
// add foreign_key field
OGRFieldDefn ofieldDefn1("REF_NAME", OFTString);
poTableDefn->AddFieldDefn(&ofieldDefn1);
OGRFieldDefn ofieldDefn2("REF_ID", OFTString);
poTableDefn->AddFieldDefn(&ofieldDefn2);
} else { // Class
// add TID field
const char* psTidColName = (iliVersion == 1) ? "_TID" : "TID";
OGRFieldDefn ofieldDefn(psTidColName, OFTString);
poTableDefn->AddFieldDefn(&ofieldDefn);
}
if (CSLTestBoolean(CPLGetXMLValue( node, "Abstract", "FALSE" )))
hasDerivedClasses = true;
}
OGRFeatureDefn *defineLayer(char *szName, OGRwkbGeometryType szType, S2I *poHeaders) {
OGRFeatureDefn *poFeatureDefn = new OGRFeatureDefn( szName );
poFeatureDefn->SetGeomType( szType );
for (unsigned int n=0; n<poHeaders->size(); n++) { /* adding headers in the correct order again */
for (S2I::iterator i=poHeaders->begin(); i!=poHeaders->end(); i++) {
if (n==i->second) {
OGRFieldDefn oFieldTemplate( i->first.c_str(), OFTString );
poFeatureDefn->AddFieldDefn( &oFieldTemplate );
}
}
}
return poFeatureDefn;
}
OGRFeatureDefn *OGRFeatureDefn::Clone()
{
OGRFeatureDefn *poCopy;
poCopy = new OGRFeatureDefn( GetName() );
poCopy->SetGeomType( GetGeomType() );
for( int i = 0; i < GetFieldCount(); i++ )
poCopy->AddFieldDefn( GetFieldDefn( i ) );
return poCopy;
}
bool OGRESRIJSONReader::GenerateLayerDefn()
{
CPLAssert( nullptr != poGJObject_ );
CPLAssert( nullptr != poLayer_->GetLayerDefn() );
CPLAssert( 0 == poLayer_->GetLayerDefn()->GetFieldCount() );
bool bSuccess = true;
/* -------------------------------------------------------------------- */
/* Scan all features and generate layer definition. */
/* -------------------------------------------------------------------- */
json_object* poFields =
OGRGeoJSONFindMemberByName( poGJObject_, "fields" );
if( nullptr != poFields &&
json_type_array == json_object_get_type( poFields ) )
{
const int nFeatures = json_object_array_length( poFields );
for( int i = 0; i < nFeatures; ++i )
{
json_object* poField =
json_object_array_get_idx( poFields, i );
if( !ParseField( poField ) )
{
CPLDebug( "GeoJSON", "Create feature schema failure." );
bSuccess = false;
}
}
}
else
{
poFields = OGRGeoJSONFindMemberByName(
poGJObject_, "fieldAliases" );
if( nullptr != poFields &&
json_object_get_type(poFields) == json_type_object )
{
OGRFeatureDefn* poDefn = poLayer_->GetLayerDefn();
json_object_iter it;
it.key = nullptr;
it.val = nullptr;
it.entry = nullptr;
json_object_object_foreachC( poFields, it )
{
OGRFieldDefn fldDefn( it.key, OFTString );
poDefn->AddFieldDefn( &fldDefn );
}
}
OGRFeatureDefn * cvct2gdal::CVCT2GDALFeatureDefn ( VCTFeatureDefn * poVCTFeatDefn )
{
OGRFeatureDefn * poOGRFeatDefn = new OGRFeatureDefn();
for ( auto iVCTFieldDefn = poVCTFeatDefn->fielddefnlist.begin();
iVCTFieldDefn != poVCTFeatDefn->fielddefnlist.end(); ++iVCTFieldDefn )
{
OGRFieldDefn oOGRFieldDefn ( "", OFTInteger );
oOGRFieldDefn.SetName ( iVCTFieldDefn->name.c_str() );
oOGRFieldDefn.SetWidth ( iVCTFieldDefn->width );
oOGRFieldDefn.SetPrecision ( iVCTFieldDefn->precision );
oOGRFieldDefn.SetType ( CVCT2GDALFieldType ( iVCTFieldDefn->type ) );
poOGRFeatDefn->AddFieldDefn ( &oOGRFieldDefn );
}
return poOGRFeatDefn;
}
static
OGRFeatureDefn *defineLayer(const char *szName, OGRwkbGeometryType szType, S2I *poHeaders, S2I **ppoHeadersNew) {
OGRFeatureDefn *poFeatureDefn = new OGRFeatureDefn( szName );
poFeatureDefn->SetGeomType( szType );
S2I* poHeadersNew = *ppoHeadersNew;
for (S2I::iterator i=poHeaders->begin(); i!=poHeaders->end(); i++) {
OGRSOSIDataType* poType = SOSIGetType(i->first);
OGRSOSISimpleDataType* poElements = poType->getElements();
for (int k=0; k<poType->getElementCount(); k++) {
if (strcmp(poElements[k].GetName(),"")==0) continue;
OGRFieldDefn oFieldTemplate( poElements[k].GetName(), poElements[k].GetType() );
(*poHeadersNew)[CPLString(poElements[k].GetName())] = poFeatureDefn->GetFieldCount();
poFeatureDefn->AddFieldDefn( &oFieldTemplate );
}
}
return poFeatureDefn;
}
OGRFeatureDefn *OGRFeatureDefn::Clone()
{
int i;
OGRFeatureDefn *poCopy;
poCopy = new OGRFeatureDefn( GetName() );
GetFieldCount();
for( i = 0; i < nFieldCount; i++ )
poCopy->AddFieldDefn( GetFieldDefn( i ) );
/* There is a default geometry field created at OGRFeatureDefn instanciation */
poCopy->DeleteGeomFieldDefn(0);
GetGeomFieldCount();
for( i = 0; i < nGeomFieldCount; i++ )
poCopy->AddGeomFieldDefn( GetGeomFieldDefn( i ) );
return poCopy;
}
int ILI2Reader::AddFeature(DOMElement *elem) {
bool newLayer = true;
OGRLayer *curLayer = 0;
char *pszName = XMLString::transcode(elem->getTagName());
// test if this layer exist
for (list<OGRLayer *>::reverse_iterator layerIt = m_listLayer.rbegin();
layerIt != m_listLayer.rend();
++layerIt) {
OGRFeatureDefn *fDef = (*layerIt)->GetLayerDefn();
if (cmpStr(fDef->GetName(), pszName) == 0) {
newLayer = false;
curLayer = *layerIt;
break;
}
}
// add a layer
if (newLayer) { // FIXME in Layer: SRS Writer Type datasource
CPLDebug( "OGR_ILI", "Adding layer: %s", pszName );
// new layer data
OGRSpatialReference *poSRSIn = NULL; // FIXME fix values for initial layer
int bWriterIn = 0;
OGRwkbGeometryType eReqType = wkbUnknown;
OGRILI2DataSource *poDSIn = NULL;
curLayer = new OGRILI2Layer(pszName, poSRSIn, bWriterIn, eReqType, poDSIn);
m_listLayer.push_back(curLayer);
}
// the feature and field definition
OGRFeatureDefn *featureDef = curLayer->GetLayerDefn();
if (newLayer) {
// add TID field
OGRFieldDefn ofieldDefn (ILI2_TID, OFTString);
featureDef->AddFieldDefn(&ofieldDefn);
setFieldDefn(featureDef, elem);
}
// add the features
OGRFeature *feature = new OGRFeature(featureDef);
// assign TID
int fIndex = feature->GetFieldIndex(ILI2_TID);
if (fIndex != -1) {
XMLCh *pszIli2_tid = XMLString::transcode(ILI2_TID);
char *fChVal = XMLString::transcode(elem->getAttribute(pszIli2_tid));
feature->SetField(fIndex, fChVal);
XMLString::release (&pszIli2_tid);
XMLString::release (&fChVal);
} else {
CPLDebug( "OGR_ILI","'%s' not found", ILI2_TID);
}
SetFieldValues(feature, elem);
curLayer->SetFeature(feature);
XMLString::release (&pszName);
return 0;
}
OGRErr OGRNULLLayer::CreateField( OGRFieldDefn *poField,
int bApproxOK )
{
poFeatureDefn->AddFieldDefn(poField);
return OGRERR_NONE;
}
int ILI1Reader::ReadTable(const char *layername) {
char **tokens = NULL;
const char *firsttok = NULL;
int ret = TRUE;
int warned = FALSE;
int fIndex;
int geomIdx;
// curLayer is NULL if we have more than one
// point geometry column
if(curLayer == NULL) {
OGRFeature *metaFeature = NULL;
metaLayer->ResetReading();
while((metaFeature = metaLayer->GetNextFeature()) != NULL ) {
if(EQUAL(layername, metaFeature->GetFieldAsString(0))) {
const char *geomlayername = metaFeature->GetFieldAsString(2);
curLayer = GetLayerByName(geomlayername);
break;
}
}
}
OGRFeatureDefn *featureDef = curLayer->GetLayerDefn();
OGRFeature *feature = NULL;
// get the geometry index of the current layer
// only if the model is read
if(featureDef->GetFieldCount() != 0) {
OGRFeature *metaFeature = NULL;
metaLayer->ResetReading();
while((metaFeature = metaLayer->GetNextFeature()) != NULL ) {
if(EQUAL(curLayer->GetLayerDefn()->GetName(), metaFeature->GetFieldAsString(2))) {
geomIdx = metaFeature->GetFieldAsInteger(1);
}
}
}
long fpos = VSIFTell(fpItf);
while (ret && (tokens = ReadParseLine()))
{
firsttok = CSLGetField(tokens, 0);
if (EQUAL(firsttok, "OBJE"))
{
//Check for features spread over multiple objects
if (featureDef->GetGeomType() == wkbPolygon)
{
//Multiple polygon rings
feature = curLayer->GetFeatureRef(atol(CSLGetField(tokens, 2)));
}
else if (featureDef->GetGeomType() == wkbGeometryCollection)
{
//AREA lines spread over mutltiple objects
}
else
{
feature = NULL;
}
if (feature == NULL)
{
if (featureDef->GetFieldCount() == 0)
{
CPLDebug( "OGR_ILI", "No field definition found for table: %s", featureDef->GetName() );
//Model not read - use heuristics
for (fIndex=1; fIndex<CSLCount(tokens); fIndex++)
{
char szFieldName[32];
sprintf(szFieldName, "Field%02d", fIndex);
OGRFieldDefn oFieldDefn(szFieldName, OFTString);
featureDef->AddFieldDefn(&oFieldDefn);
}
}
//start new feature
feature = new OGRFeature(featureDef);
int fieldno = 0;
for (fIndex=1; fIndex<CSLCount(tokens) && fieldno < featureDef->GetFieldCount(); fIndex++, fieldno++)
{
if (!EQUAL(tokens[fIndex], "@")) {
//CPLDebug( "READ TABLE OGR_ILI", "Adding Field %d: %s", fieldno, tokens[fIndex]);
feature->SetField(fieldno, tokens[fIndex]);
if (featureDef->GetFieldDefn(fieldno)->GetType() == OFTReal
&& fieldno > 0
&& featureDef->GetFieldDefn(fieldno-1)->GetType() == OFTReal
&& featureDef->GetGeomType() == wkbPoint
/*
// if there is no ili model read,
// we have no chance to detect the
// geometry column!!
*/
&& (fieldno-2) == geomIdx) {
//add Point geometry
OGRPoint *ogrPoint = new OGRPoint(atof(tokens[fIndex-1]), atof(tokens[fIndex]));
feature->SetGeometryDirectly(ogrPoint);
}
}
}
if (!warned && featureDef->GetFieldCount() != CSLCount(tokens)-1 && !(featureDef->GetFieldCount() == CSLCount(tokens) && EQUAL(featureDef->GetFieldDefn(featureDef->GetFieldCount()-1)->GetNameRef(), "ILI_Geometry"))) {
CPLDebug( "OGR_ILI", "Field count doesn't match. %d declared, %d found", featureDef->GetFieldCount(), CSLCount(tokens)-1);
warned = TRUE;
}
if (featureDef->GetGeomType() == wkbPolygon)
feature->SetFID(atol(feature->GetFieldAsString(1)));
else if (feature->GetFieldCount() > 0)
feature->SetFID(atol(feature->GetFieldAsString(0)));
curLayer->AddFeature(feature);
}
}
else if (EQUAL(firsttok, "STPT"))
{
ReadGeom(tokens, featureDef->GetGeomType(), feature);
if (EQUAL(featureDef->GetFieldDefn(featureDef->GetFieldCount()-1)->GetNameRef(), "ILI_Geometry"))
{
AddIliGeom(feature, featureDef->GetFieldCount()-1, fpos); //TODO: append multi-OBJECT geometries
}
}
else if (EQUAL(firsttok, "ELIN"))
{
//empty geom
}
else if (EQUAL(firsttok, "EDGE"))
{
tokens = ReadParseLine(); //STPT
ReadGeom(tokens, wkbMultiLineString, feature);
if (EQUAL(featureDef->GetFieldDefn(featureDef->GetFieldCount()-1)->GetNameRef(), "ILI_Geometry"))
{
AddIliGeom(feature, featureDef->GetFieldCount()-1, fpos);
}
}
else if (EQUAL(firsttok, "PERI"))
{
}
else if (EQUAL(firsttok, "ETAB"))
{
if(HasMultiplePointGeom(layername) > 0) {
OGRFeature *metaFeature = NULL;
metaLayer->ResetReading();
while((metaFeature = metaLayer->GetNextFeature()) != NULL ) {
int pntCln = 1;
if(EQUAL(layername, metaFeature->GetFieldAsString(0)) && !EQUAL(curLayer->GetLayerDefn()->GetName(), metaFeature->GetFieldAsString(2))) {
pntCln++;
OGRILI1Layer *curLayerTmp = GetLayerByName(metaFeature->GetFieldAsString(2));
OGRFeature *tmpFeature = NULL;
int geomIdxTmp = metaFeature->GetFieldAsInteger(1);
curLayer->ResetReading();
while((tmpFeature = curLayer->GetNextFeature()) != NULL ) {
OGRPoint *ogrPoint = new OGRPoint(atof(tmpFeature->GetFieldAsString(geomIdxTmp + pntCln)), atof(tmpFeature->GetFieldAsString(geomIdxTmp + pntCln + 1)));
tmpFeature->SetGeometryDirectly(ogrPoint);
curLayerTmp->AddFeature(tmpFeature);
}
}
}
}
CSLDestroy(tokens);
return TRUE;
}
else
{
CPLDebug( "OGR_ILI", "Unexpected token: %s", firsttok );
}
CSLDestroy(tokens);
fpos = VSIFTell(fpItf);
}
return ret;
}
int ILI1Reader::ReadTable(CPL_UNUSED const char *layername) {
char **tokens = NULL;
int ret = TRUE;
int warned = FALSE;
int geomIdx = -1;
OGRFeatureDefn *featureDef = curLayer->GetLayerDefn();
OGRFeature *feature = NULL;
bool bFeatureAdded = false;
while (ret && (tokens = ReadParseLine()) != NULL)
{
const char *firsttok = CSLGetField(tokens, 0);
if (EQUAL(firsttok, "OBJE"))
{
if (featureDef->GetFieldCount() == 0 && curLayer->GetFeatureCount() == 0)
{
CPLError( CE_Warning, CPLE_AppDefined,
"No field definition found for table: %s",
featureDef->GetName() );
// Model not read - use heuristics.
for( int fIndex=1; fIndex<CSLCount(tokens); fIndex++ )
{
char szFieldName[32];
snprintf(szFieldName, sizeof(szFieldName), "Field%02d", fIndex);
OGRFieldDefn oFieldDefn(szFieldName, OFTString);
featureDef->AddFieldDefn(&oFieldDefn);
}
}
//start new feature
if( !bFeatureAdded )
delete feature;
feature = new OGRFeature(featureDef);
for( int fIndex=1, fieldno = 0;
fIndex<CSLCount(tokens) && fieldno < featureDef->GetFieldCount();
fIndex++, fieldno++ )
{
if (!(tokens[fIndex][0] == codeUndefined && tokens[fIndex][1] == '\0')) {
#ifdef DEBUG_VERBOSE
CPLDebug( "READ TABLE OGR_ILI", "Setting Field %d (Type %d): %s",
fieldno, featureDef->GetFieldDefn(fieldno)->GetType(),
tokens[fIndex] );
#endif
if (featureDef->GetFieldDefn(fieldno)->GetType() == OFTString) {
// Interlis 1 encoding is ISO 8859-1 (Latin1) -> Recode to UTF-8
char* pszRecoded = CPLRecode(
tokens[fIndex], CPL_ENC_ISO8859_1, CPL_ENC_UTF8);
// Replace space marks
for( char* pszString = pszRecoded;
*pszString != '\0';
pszString++ ) {
if (*pszString == codeBlank) *pszString = ' ';
}
feature->SetField(fieldno, pszRecoded);
CPLFree(pszRecoded);
} else {
feature->SetField(fieldno, tokens[fIndex]);
}
if (featureDef->GetFieldDefn(fieldno)->GetType() == OFTReal
&& fieldno > 0
&& featureDef->GetFieldDefn(fieldno-1)->GetType() == OFTReal) {
// Check for Point geometry (Coord type).
// If there is no ili model read,
// we have no chance to detect the
// geometry column.
CPLString geomfldname
= featureDef->GetFieldDefn(fieldno)->GetNameRef();
// Check if name ends with _1.
if (geomfldname.size() >= 2 && geomfldname[geomfldname.size()-2]
== '_') {
geomfldname = geomfldname.substr(0, geomfldname.size()-2);
geomIdx = featureDef->GetGeomFieldIndex(geomfldname.c_str());
if (geomIdx == -1)
{
CPLError( CE_Warning, CPLE_AppDefined,
"No matching definition for field '%s' of "
"table %s found",
geomfldname.c_str(), featureDef->GetName() );
}
} else {
geomIdx = -1;
}
if (geomIdx >= 0) {
if (featureDef->GetGeomFieldDefn(geomIdx)->GetType() ==
wkbPoint) {
// Add Point geometry.
OGRPoint *ogrPoint = new OGRPoint(
CPLAtof(tokens[fIndex-1]), CPLAtof(tokens[fIndex]));
feature->SetGeomFieldDirectly(geomIdx, ogrPoint);
} else if (featureDef->GetGeomFieldDefn(geomIdx)->GetType() ==
wkbPoint25D && fieldno > 1 &&
featureDef->GetFieldDefn(fieldno-2)->GetType() ==
OFTReal) {
// Add 3D Point geometry.
OGRPoint *ogrPoint = new OGRPoint(
CPLAtof(tokens[fIndex-2]), CPLAtof(tokens[fIndex-1]),
CPLAtof(tokens[fIndex]) );
feature->SetGeomFieldDirectly(geomIdx, ogrPoint);
}
}
}
}
}
if (!warned && featureDef->GetFieldCount() != CSLCount(tokens)-1) {
CPLError( CE_Warning, CPLE_AppDefined,
"Field count of table %s doesn't match. %d declared, "
"%d found (e.g. ignored LINEATTR)",
featureDef->GetName(), featureDef->GetFieldCount(),
CSLCount(tokens) - 1 );
warned = TRUE;
}
if (feature->GetFieldCount() > 0) {
// USE _TID as FID. TODO: respect IDENT field from model.
feature->SetFID(feature->GetFieldAsInteger64(0));
}
curLayer->AddFeature(feature);
bFeatureAdded = true;
geomIdx = -1; //Reset
}
else if (EQUAL(firsttok, "STPT") && feature != NULL)
{
//Find next non-Point geometry
if (geomIdx < 0) geomIdx = 0;
while (geomIdx < featureDef->GetGeomFieldCount() &&
featureDef->GetGeomFieldDefn(geomIdx)->GetType() == wkbPoint) {
geomIdx++;
}
OGRwkbGeometryType geomType
= (geomIdx < featureDef->GetGeomFieldCount()) ?
featureDef->GetGeomFieldDefn(geomIdx)->GetType() : wkbNone;
if( CSLCount(tokens) >= 3 )
ReadGeom(tokens, geomIdx, geomType, feature);
}
else if (EQUAL(firsttok, "ELIN"))
{
// Empty geom.
}
else if (EQUAL(firsttok, "EDGE") && feature != NULL)
{
CSLDestroy(tokens);
tokens = ReadParseLine(); //STPT
//Find next non-Point geometry
do {
geomIdx++;
} while (geomIdx < featureDef->GetGeomFieldCount() &&
featureDef->GetGeomFieldDefn(geomIdx)->GetType() == wkbPoint);
if( CSLCount(tokens) >= 3 )
ReadGeom(tokens, geomIdx, wkbMultiLineString, feature);
}
else if (EQUAL(firsttok, "PERI"))
{
}
else if (EQUAL(firsttok, "ETAB"))
{
CPLDebug( "OGR_ILI", "Total features: " CPL_FRMT_GIB,
curLayer->GetFeatureCount() );
CSLDestroy(tokens);
if( !bFeatureAdded )
delete feature;
return TRUE;
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"Unexpected token: %s", firsttok );
}
CSLDestroy(tokens);
}
if( !bFeatureAdded )
delete feature;
return ret;
}
OGRFeatureDefn *OGRMySQLResultLayer::ReadResultDefinition()
{
/* -------------------------------------------------------------------- */
/* Parse the returned table information. */
/* -------------------------------------------------------------------- */
OGRFeatureDefn *poDefn = new OGRFeatureDefn( "sql_statement" );
SetDescription( poDefn->GetName() );
poDefn->Reference();
mysql_field_seek( hResultSet, 0 );
for( int iRawField = 0;
iRawField < (int) mysql_num_fields(hResultSet);
iRawField++ )
{
MYSQL_FIELD *psMSField = mysql_fetch_field( hResultSet );
OGRFieldDefn oField( psMSField->name, OFTString);
switch( psMSField->type )
{
case FIELD_TYPE_TINY:
case FIELD_TYPE_SHORT:
case FIELD_TYPE_LONG:
case FIELD_TYPE_INT24:
case FIELD_TYPE_LONGLONG:
{
oField.SetType( OFTInteger );
const int width = (int)psMSField->length;
oField.SetWidth(width);
poDefn->AddFieldDefn( &oField );
break;
}
case FIELD_TYPE_DECIMAL:
#ifdef FIELD_TYPE_NEWDECIMAL
case FIELD_TYPE_NEWDECIMAL:
#endif
{
oField.SetType( OFTReal );
// a bunch of hackery to munge the widths that MySQL gives
// us into corresponding widths and precisions for OGR
const int precision = (int)psMSField->decimals;
int width = (int)psMSField->length;
if (!precision)
width = width - 1;
width = width - precision;
oField.SetWidth(width);
oField.SetPrecision(precision);
poDefn->AddFieldDefn( &oField );
break;
}
case FIELD_TYPE_FLOAT:
case FIELD_TYPE_DOUBLE:
/* MYSQL_FIELD is always reporting ->length = 22 and ->decimals = 31
for double type regardless of the data it returned. In an example,
the data it returned had only 5 or 6 decimal places which were
exactly as entered into the database but reported the decimals
as 31. */
/* Assuming that a length of 22 means no particular width and 31
decimals means no particular precision. */
{
const int width = (int)psMSField->length;
const int precision = (int)psMSField->decimals;
oField.SetType( OFTReal );
if( width != 22 )
oField.SetWidth(width);
if( precision != 31 )
oField.SetPrecision(precision);
poDefn->AddFieldDefn( &oField );
break;
}
case FIELD_TYPE_DATE:
{
oField.SetType( OFTDate );
oField.SetWidth(0);
poDefn->AddFieldDefn( &oField );
break;
}
case FIELD_TYPE_TIME:
{
oField.SetType( OFTTime );
oField.SetWidth(0);
poDefn->AddFieldDefn( &oField );
break;
}
case FIELD_TYPE_TIMESTAMP:
case FIELD_TYPE_DATETIME:
{
oField.SetType( OFTDateTime );
oField.SetWidth(0);
poDefn->AddFieldDefn( &oField );
break;
}
case FIELD_TYPE_YEAR:
case FIELD_TYPE_STRING:
case FIELD_TYPE_VAR_STRING:
{
oField.SetType( OFTString );
oField.SetWidth((int)psMSField->length);
poDefn->AddFieldDefn( &oField );
break;
}
case FIELD_TYPE_TINY_BLOB:
case FIELD_TYPE_MEDIUM_BLOB:
case FIELD_TYPE_LONG_BLOB:
case FIELD_TYPE_BLOB:
{
if( psMSField->charsetnr == 63 )
oField.SetType( OFTBinary );
else
oField.SetType( OFTString );
oField.SetWidth((int)psMSField->max_length);
poDefn->AddFieldDefn( &oField );
break;
}
case FIELD_TYPE_GEOMETRY:
{
if (pszGeomColumn == nullptr)
{
pszGeomColumnTable = CPLStrdup( psMSField->table);
pszGeomColumn = CPLStrdup( psMSField->name);
}
break;
}
default:
// any other field we ignore.
break;
}
// assume a FID name first, and if it isn't there
// take a field that is not null, a primary key,
// and is an integer-like field
if( EQUAL(psMSField->name,"ogc_fid") )
{
bHasFid = TRUE;
pszFIDColumn = CPLStrdup(oField.GetNameRef());
continue;
} else
if (IS_NOT_NULL(psMSField->flags)
&& IS_PRI_KEY(psMSField->flags)
&&
(
psMSField->type == FIELD_TYPE_TINY
|| psMSField->type == FIELD_TYPE_SHORT
|| psMSField->type == FIELD_TYPE_LONG
|| psMSField->type == FIELD_TYPE_INT24
|| psMSField->type == FIELD_TYPE_LONGLONG
)
)
{
bHasFid = TRUE;
pszFIDColumn = CPLStrdup(oField.GetNameRef());
continue;
}
}
poDefn->SetGeomType( wkbNone );
if (pszGeomColumn)
{
char* pszType=nullptr;
CPLString osCommand;
char **papszRow;
// set to unknown first
poDefn->SetGeomType( wkbUnknown );
poDefn->GetGeomFieldDefn(0)->SetName( pszGeomColumn );
osCommand.Printf(
"SELECT type FROM geometry_columns WHERE f_table_name='%s'",
pszGeomColumnTable );
if( hResultSet != nullptr )
mysql_free_result( hResultSet );
hResultSet = nullptr;
if( !mysql_query( poDS->GetConn(), osCommand ) )
hResultSet = mysql_store_result( poDS->GetConn() );
papszRow = nullptr;
if( hResultSet != nullptr )
papszRow = mysql_fetch_row( hResultSet );
if( papszRow != nullptr && papszRow[0] != nullptr )
{
pszType = papszRow[0];
OGRwkbGeometryType l_nGeomType = OGRFromOGCGeomType(pszType);
poDefn->SetGeomType( l_nGeomType );
}
nSRSId = FetchSRSId();
}
return poDefn;
}
OGRFeatureDefn *S57GenerateObjectClassDefn( S57ClassRegistrar *poCR,
int nOBJL, int nOptionFlags )
{
OGRFeatureDefn *poFDefn = NULL;
char **papszGeomPrim;
if( !poCR->SelectClass( nOBJL ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Create the feature definition based on the object class */
/* acronym. */
/* -------------------------------------------------------------------- */
poFDefn = new OGRFeatureDefn( poCR->GetAcronym() );
poFDefn->Reference();
/* -------------------------------------------------------------------- */
/* Try and establish the geometry type. If more than one */
/* geometry type is allowed we just fall back to wkbUnknown. */
/* -------------------------------------------------------------------- */
papszGeomPrim = poCR->GetPrimitives();
if( CSLCount(papszGeomPrim) == 0 )
{
poFDefn->SetGeomType( wkbNone );
}
else if( CSLCount(papszGeomPrim) > 1 )
{
// leave as unknown geometry type.
}
else if( papszGeomPrim[0][0] == 'P' )
{
if( EQUAL(poCR->GetAcronym(),"SOUNDG") )
{
if( nOptionFlags & S57M_SPLIT_MULTIPOINT )
poFDefn->SetGeomType( wkbPoint25D );
else
poFDefn->SetGeomType( wkbMultiPoint25D );
}
else
poFDefn->SetGeomType( wkbPoint );
}
else if( papszGeomPrim[0][0] == 'A' )
{
poFDefn->SetGeomType( wkbPolygon );
}
else if( papszGeomPrim[0][0] == 'L' )
{
// unfortunately this could be a multilinestring
poFDefn->SetGeomType( wkbUnknown );
}
/* -------------------------------------------------------------------- */
/* Add the standard attributes. */
/* -------------------------------------------------------------------- */
S57GenerateStandardAttributes( poFDefn, nOptionFlags );
/* -------------------------------------------------------------------- */
/* Add the attributes specific to this object class. */
/* -------------------------------------------------------------------- */
char **papszAttrList = poCR->GetAttributeList();
for( int iAttr = 0;
papszAttrList != NULL && papszAttrList[iAttr] != NULL;
iAttr++ )
{
int iAttrIndex = poCR->FindAttrByAcronym( papszAttrList[iAttr] );
if( iAttrIndex == -1 )
{
CPLDebug( "S57", "Can't find attribute %s from class %s:%s.",
papszAttrList[iAttr],
poCR->GetAcronym(),
poCR->GetDescription() );
continue;
}
OGRFieldDefn oField( papszAttrList[iAttr], OFTInteger );
switch( poCR->GetAttrType( iAttrIndex ) )
{
case SAT_ENUM:
case SAT_INT:
oField.SetType( OFTInteger );
break;
case SAT_FLOAT:
oField.SetType( OFTReal );
break;
case SAT_CODE_STRING:
case SAT_FREE_TEXT:
oField.SetType( OFTString );
break;
case SAT_LIST:
oField.SetType( OFTString );
break;
}
poFDefn->AddFieldDefn( &oField );
}
/* -------------------------------------------------------------------- */
/* Do we need to add DEPTH attributes to soundings? */
/* -------------------------------------------------------------------- */
if( EQUAL(poCR->GetAcronym(),"SOUNDG")
&& (nOptionFlags & S57M_ADD_SOUNDG_DEPTH) )
{
OGRFieldDefn oField( "DEPTH", OFTReal );
poFDefn->AddFieldDefn( &oField );
}
return poFDefn;
}
OGRFeatureDefn *S57GenerateDSIDFeatureDefn()
{
OGRFeatureDefn *poFDefn = new OGRFeatureDefn( "DSID" );
OGRFieldDefn oField( "", OFTInteger );
poFDefn->SetGeomType( wkbNone );
poFDefn->Reference();
/* -------------------------------------------------------------------- */
/* DSID fields. */
/* -------------------------------------------------------------------- */
oField.Set( "DSID_EXPP", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSID_INTU", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSID_DSNM", OFTString, 0, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSID_EDTN", OFTString, 0, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSID_UPDN", OFTString, 0, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSID_UADT", OFTString, 8, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSID_ISDT", OFTString, 8, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSID_STED", OFTReal, 11, 6 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSID_PRSP", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSID_PSDN", OFTString, 0, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSID_PRED", OFTString, 0, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSID_PROF", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSID_AGEN", OFTInteger, 5, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSID_COMT", OFTString, 0, 0 );
poFDefn->AddFieldDefn( &oField );
/* -------------------------------------------------------------------- */
/* DSSI fields. */
/* -------------------------------------------------------------------- */
oField.Set( "DSSI_DSTR", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSSI_AALL", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSSI_NALL", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSSI_NOMR", OFTInteger, 10, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSSI_NOCR", OFTInteger, 10, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSSI_NOGR", OFTInteger, 10, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSSI_NOLR", OFTInteger, 10, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSSI_NOIN", OFTInteger, 10, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSSI_NOCN", OFTInteger, 10, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSSI_NOED", OFTInteger, 10, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSSI_NOFA", OFTInteger, 10, 0 );
poFDefn->AddFieldDefn( &oField );
/* -------------------------------------------------------------------- */
/* DSPM fields. */
/* -------------------------------------------------------------------- */
oField.Set( "DSPM_HDAT", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSPM_VDAT", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSPM_SDAT", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSPM_CSCL", OFTInteger, 10, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSPM_DUNI", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSPM_HUNI", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSPM_PUNI", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSPM_COUN", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSPM_COMF", OFTInteger, 10, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSPM_SOMF", OFTInteger, 10, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "DSPM_COMT", OFTString, 0, 0 );
poFDefn->AddFieldDefn( &oField );
return poFDefn;
}
void AddField(const char* psName, OGRFieldType fieldType)
{
OGRFieldDefn fieldDef(psName, fieldType);
poTableDefn->AddFieldDefn(&fieldDef);
CPLDebug( "OGR_ILI", "Adding field '%s' to Class %s", psName, GetName());
}
OGRFeatureDefn *
S57GenerateVectorPrimitiveFeatureDefn( int nRCNM, int nOptionFlags )
{
OGRFeatureDefn *poFDefn = NULL;
if( nRCNM == RCNM_VI )
{
poFDefn = new OGRFeatureDefn( OGRN_VI );
poFDefn->SetGeomType( wkbPoint );
}
else if( nRCNM == RCNM_VC )
{
poFDefn = new OGRFeatureDefn( OGRN_VC );
poFDefn->SetGeomType( wkbPoint );
}
else if( nRCNM == RCNM_VE )
{
poFDefn = new OGRFeatureDefn( OGRN_VE );
poFDefn->SetGeomType( wkbUnknown );
}
else if( nRCNM == RCNM_VF )
{
poFDefn = new OGRFeatureDefn( OGRN_VF );
poFDefn->SetGeomType( wkbPolygon );
}
else
return NULL;
poFDefn->Reference();
/* -------------------------------------------------------------------- */
/* Core vector primitive attributes */
/* -------------------------------------------------------------------- */
OGRFieldDefn oField("",OFTInteger);
oField.Set( "RCNM", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "RCID", OFTInteger, 8, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "RVER", OFTInteger, 2, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "RUIN", OFTInteger, 2, 0 );
poFDefn->AddFieldDefn( &oField );
/* -------------------------------------------------------------------- */
/* For lines we want to capture the point links for the first */
/* and last nodes. */
/* -------------------------------------------------------------------- */
if( nRCNM == RCNM_VE )
{
oField.Set( "NAME_RCNM_0", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "NAME_RCID_0", OFTInteger, 8, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "ORNT_0", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "USAG_0", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "TOPI_0", OFTInteger, 1, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "MASK_0", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "NAME_RCNM_1", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "NAME_RCID_1", OFTInteger, 8, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "ORNT_1", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "USAG_1", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "TOPI_1", OFTInteger, 1, 0 );
poFDefn->AddFieldDefn( &oField );
oField.Set( "MASK_1", OFTInteger, 3, 0 );
poFDefn->AddFieldDefn( &oField );
}
return poFDefn;
}
OGRFeatureDefn *OGRMySQLTableLayer::ReadTableDefinition( const char *pszTable )
{
MYSQL_RES *hResult;
CPLString osCommand;
/* -------------------------------------------------------------------- */
/* Fire off commands to get back the schema of the table. */
/* -------------------------------------------------------------------- */
osCommand.Printf("DESCRIBE `%s`", pszTable );
pszGeomColumnTable = CPLStrdup(pszTable);
if( mysql_query( poDS->GetConn(), osCommand ) )
{
poDS->ReportError( "DESCRIBE Failed" );
return NULL;
}
hResult = mysql_store_result( poDS->GetConn() );
if( hResult == NULL )
{
poDS->ReportError( "mysql_store_result() failed on DESCRIBE result." );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Parse the returned table information. */
/* -------------------------------------------------------------------- */
OGRFeatureDefn *poDefn = new OGRFeatureDefn( pszTable );
char **papszRow;
OGRwkbGeometryType eForcedGeomType = wkbUnknown;
int bGeomColumnNotNullable = FALSE;
poDefn->Reference();
while( (papszRow = mysql_fetch_row( hResult )) != NULL )
{
const char *pszType;
OGRFieldDefn oField( papszRow[0], OFTString);
int nLenType;
pszType = papszRow[1];
if( pszType == NULL )
continue;
nLenType = (int)strlen(pszType);
if( EQUAL(pszType,"varbinary")
|| (nLenType>=4 && EQUAL(pszType+nLenType-4,"blob")))
{
oField.SetType( OFTBinary );
}
else if( EQUAL(pszType,"varchar")
|| (nLenType>=4 && EQUAL(pszType+nLenType-4,"enum"))
|| (nLenType>=3 && EQUAL(pszType+nLenType-3,"set")) )
{
oField.SetType( OFTString );
}
else if( STARTS_WITH_CI(pszType, "char") )
{
oField.SetType( OFTString );
char ** papszTokens;
papszTokens = CSLTokenizeString2(pszType,"(),",0);
if (CSLCount(papszTokens) >= 2)
{
/* width is the second */
oField.SetWidth(atoi(papszTokens[1]));
}
CSLDestroy( papszTokens );
oField.SetType( OFTString );
}
if(nLenType>=4 && EQUAL(pszType+nLenType-4,"text"))
{
oField.SetType( OFTString );
}
else if( STARTS_WITH_CI(pszType,"varchar") )
{
/*
pszType is usually in the form "varchar(15)"
so we'll split it up and get the width and precision
*/
oField.SetType( OFTString );
char ** papszTokens;
papszTokens = CSLTokenizeString2(pszType,"(),",0);
if (CSLCount(papszTokens) >= 2)
{
/* width is the second */
oField.SetWidth(atoi(papszTokens[1]));
}
CSLDestroy( papszTokens );
oField.SetType( OFTString );
}
else if( STARTS_WITH_CI(pszType, "int") )
{
oField.SetType( OFTInteger );
}
else if( STARTS_WITH_CI(pszType, "tinyint") )
{
oField.SetType( OFTInteger );
}
else if( STARTS_WITH_CI(pszType, "smallint") )
{
oField.SetType( OFTInteger );
}
else if( STARTS_WITH_CI(pszType, "mediumint") )
{
oField.SetType( OFTInteger );
}
else if( STARTS_WITH_CI(pszType, "bigint") )
{
oField.SetType( OFTInteger64 );
}
else if( STARTS_WITH_CI(pszType, "decimal") )
{
/*
pszType is usually in the form "decimal(15,2)"
so we'll split it up and get the width and precision
*/
oField.SetType( OFTReal );
char ** papszTokens;
papszTokens = CSLTokenizeString2(pszType,"(),",0);
if (CSLCount(papszTokens) >= 3)
{
/* width is the second and precision is the third */
oField.SetWidth(atoi(papszTokens[1]));
oField.SetPrecision(atoi(papszTokens[2]));
}
CSLDestroy( papszTokens );
}
else if( STARTS_WITH_CI(pszType, "float") )
{
oField.SetType( OFTReal );
}
else if( EQUAL(pszType,"double") )
{
oField.SetType( OFTReal );
}
else if( STARTS_WITH_CI(pszType, "double") )
{
// double can also be double(15,2)
// so we'll handle this case here after
// we check for just a regular double
// without a width and precision specified
char ** papszTokens=NULL;
papszTokens = CSLTokenizeString2(pszType,"(),",0);
if (CSLCount(papszTokens) >= 3)
{
/* width is the second and precision is the third */
oField.SetWidth(atoi(papszTokens[1]));
oField.SetPrecision(atoi(papszTokens[2]));
}
CSLDestroy( papszTokens );
oField.SetType( OFTReal );
}
else if( EQUAL(pszType,"decimal") )
{
oField.SetType( OFTReal );
}
else if( EQUAL(pszType, "date") )
{
oField.SetType( OFTDate );
}
else if( EQUAL(pszType, "time") )
{
oField.SetType( OFTTime );
}
else if( EQUAL(pszType, "datetime")
|| EQUAL(pszType, "timestamp") )
{
oField.SetType( OFTDateTime );
}
else if( EQUAL(pszType, "year") )
{
oField.SetType( OFTString );
oField.SetWidth( 10 );
}
else if( EQUAL(pszType, "geometry") ||
OGRFromOGCGeomType(pszType) != wkbUnknown)
{
if (pszGeomColumn == NULL)
{
pszGeomColumn = CPLStrdup(papszRow[0]);
eForcedGeomType = OGRFromOGCGeomType(pszType);
bGeomColumnNotNullable = ( papszRow[2] != NULL && EQUAL(papszRow[2], "NO") );
}
else
{
CPLDebug("MYSQL",
"Ignoring %s as geometry column. Another one(%s) has already been found before",
papszRow[0], pszGeomColumn);
}
continue;
}
// Is this an integer primary key field?
if( !bHasFid && papszRow[3] != NULL && EQUAL(papszRow[3],"PRI")
&& (oField.GetType() == OFTInteger || oField.GetType() == OFTInteger64) )
{
bHasFid = TRUE;
pszFIDColumn = CPLStrdup(oField.GetNameRef());
if( oField.GetType() == OFTInteger64 )
SetMetadataItem(OLMD_FID64, "YES");
continue;
}
// Is not nullable ?
if( papszRow[2] != NULL && EQUAL(papszRow[2], "NO") )
oField.SetNullable(FALSE);
// Has default ?
const char* pszDefault = papszRow[4];
if( pszDefault != NULL )
{
if( !EQUAL(pszDefault, "NULL") &&
!STARTS_WITH_CI(pszDefault, "CURRENT_") &&
pszDefault[0] != '(' &&
pszDefault[0] != '\'' &&
CPLGetValueType(pszDefault) == CPL_VALUE_STRING )
{
int nYear, nMonth, nDay, nHour, nMinute;
float fSecond;
if( oField.GetType() == OFTDateTime &&
sscanf(pszDefault, "%d-%d-%d %d:%d:%f", &nYear, &nMonth, &nDay,
&nHour, &nMinute, &fSecond) == 6 )
{
oField.SetDefault(CPLSPrintf("'%04d/%02d/%02d %02d:%02d:%02d'",
nYear, nMonth, nDay, nHour, nMinute, (int)(fSecond+0.5)));
}
else
{
CPLString osDefault("'");
char* pszTmp = CPLEscapeString(pszDefault, -1, CPLES_SQL);
osDefault += pszTmp;
CPLFree(pszTmp);
osDefault += "'";
oField.SetDefault(osDefault);
}
}
else
{
oField.SetDefault(pszDefault);
}
}
poDefn->AddFieldDefn( &oField );
}
// set to none for now... if we have a geometry column it will be set layer.
poDefn->SetGeomType( wkbNone );
if( hResult != NULL )
{
mysql_free_result( hResult );
hResultSet = NULL;
}
if( bHasFid )
CPLDebug( "MySQL", "table %s has FID column %s.",
pszTable, pszFIDColumn );
else
CPLDebug( "MySQL",
"table %s has no FID column, FIDs will not be reliable!",
pszTable );
if (pszGeomColumn)
{
char* pszType=NULL;
// set to unknown first
poDefn->SetGeomType( wkbUnknown );
osCommand = "SELECT type, coord_dimension FROM geometry_columns WHERE f_table_name='";
osCommand += pszTable;
osCommand += "'";
hResult = NULL;
if( !mysql_query( poDS->GetConn(), osCommand ) )
hResult = mysql_store_result( poDS->GetConn() );
papszRow = NULL;
if( hResult != NULL )
papszRow = mysql_fetch_row( hResult );
if( papszRow != NULL && papszRow[0] != NULL )
{
pszType = papszRow[0];
OGRwkbGeometryType l_nGeomType = OGRFromOGCGeomType(pszType);
if( papszRow[1] != NULL && atoi(papszRow[1]) == 3 )
l_nGeomType = wkbSetZ(l_nGeomType);
poDefn->SetGeomType( l_nGeomType );
}
else if (eForcedGeomType != wkbUnknown)
poDefn->SetGeomType(eForcedGeomType);
if( bGeomColumnNotNullable )
poDefn->GetGeomFieldDefn(0)->SetNullable(FALSE);
if( hResult != NULL )
mysql_free_result( hResult ); //Free our query results for finding type.
hResult = NULL;
}
// Fetch the SRID for this table now
nSRSId = FetchSRSId();
return poDefn;
}
OGRFeatureDefn *OGRIngresTableLayer::ReadTableDefinition( const char *pszTable )
{
poDS->EstablishActiveLayer( NULL );
/* -------------------------------------------------------------------- */
/* Fire off commands to get back the schema of the table. */
/* -------------------------------------------------------------------- */
CPLString osCommand;
OGRIngresStatement oStatement( poDS->GetConn() );
osCommand.Printf( "select column_name, column_datatype, column_length, "
"column_scale, column_ingdatatype, "
"column_internal_datatype "
"from iicolumns where table_name = '%s'",
pszTable );
if( !oStatement.ExecuteSQL( osCommand ) )
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Parse the returned table information. */
/* -------------------------------------------------------------------- */
OGRFeatureDefn *poDefn = new OGRFeatureDefn( pszTable );
char **papszRow;
poDefn->Reference();
poDefn->SetGeomType( wkbNone );
while( (papszRow = oStatement.GetRow()) != NULL )
{
CPLString osFieldName = papszRow[0];
CPLString osIngresType = papszRow[1];
CPLString osInternalType = papszRow[5];
GInt32 nWidth, nScale;
osIngresType.Trim();
osFieldName.Trim();
osInternalType.Trim();
memcpy( &nWidth, papszRow[2], 4 );
memcpy( &nScale, papszRow[3], 4 );
OGRFieldDefn oField(osFieldName, OFTString);
if( osGeomColumn.size() == 0
&& (EQUAL(osInternalType,"POINT")
|| EQUAL(osInternalType,"IPOINT")
|| EQUAL(osInternalType,"BOX")
|| EQUAL(osInternalType,"IBOX")
|| EQUAL(osInternalType,"LSEG")
|| EQUAL(osInternalType,"ILSEG")
|| EQUAL(osInternalType,"LINE")
|| EQUAL(osInternalType,"ILINE")
|| EQUAL(osInternalType,"LONG LINE")
|| EQUAL(osInternalType,"POLYGON")
|| EQUAL(osInternalType,"IPOLYGON")
|| EQUAL(osInternalType,"LONG POLYGON")
|| EQUAL(osInternalType,"CIRCLE")
|| EQUAL(osInternalType,"LINESTRING")
|| EQUAL(osInternalType,"MULTIPOINT")
|| EQUAL(osInternalType,"MULTIPOLYGON")
|| EQUAL(osInternalType,"MULTILINESTRING")
|| EQUAL(osInternalType,"GEOMETRYCOLLECTION")
|| EQUAL(osInternalType,"ICIRCLE")) )
{
osGeomColumn = osFieldName;
osIngresGeomType = osInternalType;
if( strstr(osInternalType,"POINT") )
poDefn->SetGeomType( wkbPoint );
else if( strstr(osInternalType,"LINE")
|| strstr(osInternalType,"SEG")
|| strstr(osInternalType, "LINESTRING"))
poDefn->SetGeomType( wkbLineString );
else if( strstr(osInternalType,"MULTIPOINT"))
poDefn->SetGeomType(wkbMultiPoint);
else if( strstr(osInternalType,"MULTIPOLYGON"))
poDefn->SetGeomType(wkbMultiPolygon);
else if( strstr(osInternalType,"MULTILINESTRING"))
poDefn->SetGeomType(wkbMultiLineString);
// Oddly this is the standin for a generic geometry type.
else if( strstr(osInternalType,"GEOMETRYCOLLECTION"))
poDefn->SetGeomType(wkbUnknown);
else
poDefn->SetGeomType( wkbPolygon );
continue;
}
else if( EQUALN(osIngresType,"byte",4)
|| EQUALN(osIngresType,"long byte",9) )
{
oField.SetType( OFTBinary );
}
else if( EQUALN(osIngresType,"varchar",7)
|| EQUAL(osIngresType,"text")
|| EQUALN(osIngresType,"long varchar",12) )
{
oField.SetType( OFTString );
oField.SetWidth( nWidth );
}
else if( EQUALN(osIngresType,"char",4) || EQUAL(osIngresType,"c") )
{
oField.SetType( OFTString );
oField.SetWidth( nWidth );
}
else if( EQUAL(osIngresType,"integer") )
{
oField.SetType( OFTInteger );
}
else if( EQUALN(osIngresType,"decimal", 7) )
{
if( nScale != 0 )
{
oField.SetType( OFTReal );
oField.SetPrecision( nScale );
oField.SetWidth( nWidth );
}
else
{
oField.SetType( OFTInteger );
oField.SetWidth( nWidth );
}
}
else if( EQUALN(osIngresType,"float", 5) )
{
oField.SetType( OFTReal );
}
#ifdef notdef
else if( EQUAL(osIngresType,"date")
|| EQUAL(osIngresType,"ansidate")
|| EQUAL(osIngresType,"ingresdate") )
{
oField.SetType( OFTDate );
}
#endif
// Is this an integer primary key field?
if( osFIDColumn.size() == 0
&& oField.GetType() == OFTInteger
&& EQUAL(oField.GetNameRef(),"ogr_fid") )
{
osFIDColumn = oField.GetNameRef();
continue;
}
poDefn->AddFieldDefn( &oField );
}
if( osFIDColumn.size() )
CPLDebug( "Ingres", "table %s has FID column %s.",
pszTable, osFIDColumn.c_str() );
else
CPLDebug( "Ingres",
"table %s has no FID column, FIDs will not be reliable!",
pszTable );
//We must close the current statement before calling this or else
//The query within FetchSRSId will fail
oStatement.Close();
// Fetch the SRID for this table now
// But only if it's the new Ingres Geospatial
if(poDS->IsNewIngres() == TRUE)
nSRSId = FetchSRSId(poDefn);
return poDefn;
}
OGRErr OGRGeoJSONSeqWriteLayer::CreateField( OGRFieldDefn* poField,
int /* bApproxOK */ )
{
m_poFeatureDefn->AddFieldDefn( poField );
return OGRERR_NONE;
}
OGRFeatureDefn *OGRMySQLTableLayer::ReadTableDefinition( const char *pszTable )
{
MYSQL_RES *hResult;
char szCommand[1024];
/* -------------------------------------------------------------------- */
/* Fire off commands to get back the schema of the table. */
/* -------------------------------------------------------------------- */
sprintf( szCommand, "DESCRIBE `%s`", pszTable );
pszGeomColumnTable = CPLStrdup(pszTable);
if( mysql_query( poDS->GetConn(), szCommand ) )
{
poDS->ReportError( "DESCRIBE Failed" );
return FALSE;
}
hResult = mysql_store_result( poDS->GetConn() );
if( hResult == NULL )
{
poDS->ReportError( "mysql_store_result() failed on DESCRIBE result." );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Parse the returned table information. */
/* -------------------------------------------------------------------- */
OGRFeatureDefn *poDefn = new OGRFeatureDefn( pszTable );
char **papszRow;
poDefn->Reference();
while( (papszRow = mysql_fetch_row( hResult )) != NULL )
{
const char *pszType;
OGRFieldDefn oField( papszRow[0], OFTString);
pszType = papszRow[1];
if( pszType == NULL )
continue;
if( EQUAL(pszType,"varbinary")
|| (strlen(pszType)>3 && EQUAL(pszType+strlen(pszType)-4,"blob")))
{
oField.SetType( OFTBinary );
}
else if( EQUAL(pszType,"varchar")
|| EQUAL(pszType+strlen(pszType)-4,"enum")
|| EQUAL(pszType+strlen(pszType)-4,"set") )
{
oField.SetType( OFTString );
}
else if( EQUALN(pszType,"char",4) )
{
oField.SetType( OFTString );
char ** papszTokens;
papszTokens = CSLTokenizeString2(pszType,"(),",0);
/* width is the second */
oField.SetWidth(atoi(papszTokens[1]));
CSLDestroy( papszTokens );
oField.SetType( OFTString );
}
if(strlen(pszType)>3 && EQUAL(pszType+strlen(pszType)-4,"text"))
{
oField.SetType( OFTString );
}
else if( EQUALN(pszType,"varchar",6) )
{
/*
pszType is usually in the form "varchar(15)"
so we'll split it up and get the width and precision
*/
oField.SetType( OFTString );
char ** papszTokens;
papszTokens = CSLTokenizeString2(pszType,"(),",0);
/* width is the second */
oField.SetWidth(atoi(papszTokens[1]));
CSLDestroy( papszTokens );
oField.SetType( OFTString );
}
else if( EQUALN(pszType,"int", 3) )
{
oField.SetType( OFTInteger );
}
else if( EQUALN(pszType,"tinyint", 7) )
{
oField.SetType( OFTInteger );
}
else if( EQUALN(pszType,"smallint", 8) )
{
oField.SetType( OFTInteger );
}
else if( EQUALN(pszType,"mediumint",9) )
{
oField.SetType( OFTInteger );
}
else if( EQUALN(pszType,"bigint",6) )
{
oField.SetType( OFTInteger );
}
else if( EQUALN(pszType,"decimal",7) )
{
/*
pszType is usually in the form "decimal(15,2)"
so we'll split it up and get the width and precision
*/
oField.SetType( OFTReal );
char ** papszTokens;
papszTokens = CSLTokenizeString2(pszType,"(),",0);
/* width is the second and precision is the third */
oField.SetWidth(atoi(papszTokens[1]));
oField.SetPrecision(atoi(papszTokens[2]));
CSLDestroy( papszTokens );
}
else if( EQUALN(pszType,"float", 5) )
{
oField.SetType( OFTReal );
}
else if( EQUAL(pszType,"double") )
{
oField.SetType( OFTReal );
}
else if( EQUALN(pszType,"double",6) )
{
// double can also be double(15,2)
// so we'll handle this case here after
// we check for just a regular double
// without a width and precision specified
char ** papszTokens=NULL;
papszTokens = CSLTokenizeString2(pszType,"(),",0);
/* width is the second and precision is the third */
oField.SetWidth(atoi(papszTokens[1]));
oField.SetPrecision(atoi(papszTokens[2]));
CSLDestroy( papszTokens );
oField.SetType( OFTReal );
}
else if( EQUAL(pszType,"decimal") )
{
oField.SetType( OFTReal );
}
else if( EQUAL(pszType, "date") )
{
oField.SetType( OFTDate );
}
else if( EQUAL(pszType, "time") )
{
oField.SetType( OFTTime );
}
else if( EQUAL(pszType, "datetime")
|| EQUAL(pszType, "timestamp") )
{
oField.SetType( OFTDateTime );
}
else if( EQUAL(pszType, "year") )
{
oField.SetType( OFTString );
oField.SetWidth( 10 );
}
else if( EQUAL(pszType, "geometry") )
{
pszGeomColumn = CPLStrdup(papszRow[0]);
continue;
}
// Is this an integer primary key field?
if( !bHasFid && papszRow[3] != NULL && EQUAL(papszRow[3],"PRI")
&& oField.GetType() == OFTInteger )
{
bHasFid = TRUE;
pszFIDColumn = CPLStrdup(oField.GetNameRef());
continue;
}
poDefn->AddFieldDefn( &oField );
}
// set to none for now... if we have a geometry column it will be set layer.
poDefn->SetGeomType( wkbNone );
if( hResult != NULL )
{
mysql_free_result( hResult );
hResultSet = NULL;
}
if( bHasFid )
CPLDebug( "MySQL", "table %s has FID column %s.",
pszTable, pszFIDColumn );
else
CPLDebug( "MySQL",
"table %s has no FID column, FIDs will not be reliable!",
pszTable );
if (pszGeomColumn)
{
char* pszType=NULL;
// set to unknown first
poDefn->SetGeomType( wkbUnknown );
sprintf(szCommand, "SELECT type, coord_dimension FROM geometry_columns WHERE f_table_name='%s'",
pszTable );
hResult = NULL;
if( !mysql_query( poDS->GetConn(), szCommand ) )
hResult = mysql_store_result( poDS->GetConn() );
papszRow = NULL;
if( hResult != NULL )
papszRow = mysql_fetch_row( hResult );
if( papszRow != NULL && papszRow[0] != NULL )
{
pszType = papszRow[0];
OGRwkbGeometryType nGeomType = wkbUnknown;
// check only standard OGC geometry types
if ( EQUAL(pszType, "POINT") )
nGeomType = wkbPoint;
else if ( EQUAL(pszType,"LINESTRING"))
nGeomType = wkbLineString;
else if ( EQUAL(pszType,"POLYGON"))
nGeomType = wkbPolygon;
else if ( EQUAL(pszType,"MULTIPOINT"))
nGeomType = wkbMultiPoint;
else if ( EQUAL(pszType,"MULTILINESTRING"))
nGeomType = wkbMultiLineString;
else if ( EQUAL(pszType,"MULTIPOLYGON"))
nGeomType = wkbMultiPolygon;
else if ( EQUAL(pszType,"GEOMETRYCOLLECTION"))
nGeomType = wkbGeometryCollection;
if( papszRow[1] != NULL && atoi(papszRow[1]) == 3 )
nGeomType = (OGRwkbGeometryType) (nGeomType | wkb25DBit);
poDefn->SetGeomType( nGeomType );
}
if( hResult != NULL )
mysql_free_result( hResult ); //Free our query results for finding type.
hResult = NULL;
}
// Fetch the SRID for this table now
nSRSId = FetchSRSId();
return poDefn;
}
bool OGRGeoJSONReader::GenerateFeatureDefn( json_object* poObj )
{
OGRFeatureDefn* poDefn = poLayer_->GetLayerDefn();
CPLAssert( NULL != poDefn );
bool bSuccess = false;
/* -------------------------------------------------------------------- */
/* Read collection of properties. */
/* -------------------------------------------------------------------- */
json_object* poObjProps = NULL;
poObjProps = OGRGeoJSONFindMemberByName( poObj, "properties" );
if( NULL != poObjProps &&
json_object_get_type(poObjProps) == json_type_object )
{
if (bIsGeocouchSpatiallistFormat)
{
poObjProps = json_object_object_get(poObjProps, "properties");
if( NULL == poObjProps ||
json_object_get_type(poObjProps) != json_type_object )
{
return true;
}
}
json_object_iter it;
it.key = NULL;
it.val = NULL;
it.entry = NULL;
json_object_object_foreachC( poObjProps, it )
{
int nFldIndex = poDefn->GetFieldIndex( it.key );
if( -1 == nFldIndex )
{
/* Detect the special kind of GeoJSON output by a spatiallist of GeoCouch */
/* such as http://gd.iriscouch.com/cphosm/_design/geo/_rewrite/data?bbox=12.53%2C55.73%2C12.54%2C55.73 */
if (strcmp(it.key, "_id") == 0)
bFoundId = true;
else if (bFoundId && strcmp(it.key, "_rev") == 0)
bFoundRev = true;
else if (bFoundRev && strcmp(it.key, "type") == 0 &&
it.val != NULL && json_object_get_type(it.val) == json_type_string &&
strcmp(json_object_get_string(it.val), "Feature") == 0)
bFoundTypeFeature = true;
else if (bFoundTypeFeature && strcmp(it.key, "properties") == 0 &&
it.val != NULL && json_object_get_type(it.val) == json_type_object)
{
if (bFlattenGeocouchSpatiallistFormat < 0)
bFlattenGeocouchSpatiallistFormat = CSLTestBoolean(
CPLGetConfigOption("GEOJSON_FLATTEN_GEOCOUCH", "TRUE"));
if (bFlattenGeocouchSpatiallistFormat)
{
poDefn->DeleteFieldDefn(poDefn->GetFieldIndex("type"));
bIsGeocouchSpatiallistFormat = true;
return GenerateFeatureDefn(poObj);
}
}
OGRFieldDefn fldDefn( it.key,
GeoJSONPropertyToFieldType( it.val ) );
poDefn->AddFieldDefn( &fldDefn );
}
else
{
OGRFieldDefn* poFDefn = poDefn->GetFieldDefn(nFldIndex);
OGRFieldType eType = poFDefn->GetType();
if( eType == OFTInteger )
{
OGRFieldType eNewType = GeoJSONPropertyToFieldType( it.val );
if( eNewType == OFTReal )
poFDefn->SetType(eNewType);
}
}
}
bSuccess = true; // SUCCESS
}
OGRLayer * OGRCouchDBDataSource::ExecuteSQLStats( const char *pszSQLCommand )
{
swq_select sSelectInfo;
if( sSelectInfo.preparse( pszSQLCommand ) != CE_None )
{
return NULL;
}
if (sSelectInfo.table_count != 1)
{
return NULL;
}
swq_table_def *psTableDef = &sSelectInfo.table_defs[0];
if( psTableDef->data_source != NULL )
{
return NULL;
}
OGRCouchDBLayer* _poSrcLayer =
(OGRCouchDBLayer* )GetLayerByName( psTableDef->table_name );
if (_poSrcLayer == NULL)
{
return NULL;
}
if (_poSrcLayer->GetLayerType() != COUCHDB_TABLE_LAYER)
return NULL;
OGRCouchDBTableLayer* poSrcLayer = (OGRCouchDBTableLayer* ) _poSrcLayer;
int nFieldCount = poSrcLayer->GetLayerDefn()->GetFieldCount();
swq_field_list sFieldList;
memset( &sFieldList, 0, sizeof(sFieldList) );
sFieldList.table_count = sSelectInfo.table_count;
sFieldList.table_defs = sSelectInfo.table_defs;
sFieldList.count = 0;
sFieldList.names = static_cast<char **>(
CPLMalloc( sizeof(char *) * nFieldCount ));
sFieldList.types = static_cast<swq_field_type *>(
CPLMalloc( sizeof(swq_field_type) * nFieldCount ));
sFieldList.table_ids = static_cast<int *>(
CPLMalloc( sizeof(int) * nFieldCount ));
sFieldList.ids = static_cast<int *>(
CPLMalloc( sizeof(int) * nFieldCount ));
PointerAutoFree oHolderNames(sFieldList.names);
PointerAutoFree oHolderTypes(sFieldList.types);
PointerAutoFree oHolderTableIds(sFieldList.table_ids);
PointerAutoFree oHolderIds(sFieldList.ids);
for( int iField = 0;
iField < poSrcLayer->GetLayerDefn()->GetFieldCount();
iField++ )
{
OGRFieldDefn *poFDefn=poSrcLayer->GetLayerDefn()->GetFieldDefn(iField);
int iOutField = sFieldList.count++;
sFieldList.names[iOutField] = (char *) poFDefn->GetNameRef();
if( poFDefn->GetType() == OFTInteger )
sFieldList.types[iOutField] = SWQ_INTEGER;
else if( poFDefn->GetType() == OFTReal )
sFieldList.types[iOutField] = SWQ_FLOAT;
else if( poFDefn->GetType() == OFTString )
sFieldList.types[iOutField] = SWQ_STRING;
else
sFieldList.types[iOutField] = SWQ_OTHER;
sFieldList.table_ids[iOutField] = 0;
sFieldList.ids[iOutField] = iField;
}
CPLString osLastFieldName;
for( int iField = 0; iField < sSelectInfo.result_columns; iField++ )
{
swq_col_def *psColDef = sSelectInfo.column_defs + iField;
if (psColDef->field_name == NULL)
return NULL;
if (strcmp(psColDef->field_name, "*") != 0)
{
if (osLastFieldName.empty())
osLastFieldName = psColDef->field_name;
else if (strcmp(osLastFieldName, psColDef->field_name) != 0)
return NULL;
if (poSrcLayer->GetLayerDefn()->GetFieldIndex(psColDef->field_name) == -1)
return NULL;
}
if (!(psColDef->col_func == SWQCF_AVG ||
psColDef->col_func == SWQCF_MIN ||
psColDef->col_func == SWQCF_MAX ||
psColDef->col_func == SWQCF_COUNT ||
psColDef->col_func == SWQCF_SUM))
return NULL;
if (psColDef->distinct_flag) /* TODO: could perhaps be relaxed */
return NULL;
}
if (osLastFieldName.empty())
return NULL;
/* Normalize field name */
int nIndex = poSrcLayer->GetLayerDefn()->GetFieldIndex(osLastFieldName);
osLastFieldName = poSrcLayer->GetLayerDefn()->GetFieldDefn(nIndex)->GetNameRef();
/* -------------------------------------------------------------------- */
/* Finish the parse operation. */
/* -------------------------------------------------------------------- */
if( sSelectInfo.parse( &sFieldList, NULL ) != CE_None )
{
return NULL;
}
if (sSelectInfo.join_defs != NULL ||
sSelectInfo.where_expr != NULL ||
sSelectInfo.order_defs != NULL ||
sSelectInfo.query_mode != SWQM_SUMMARY_RECORD)
{
return NULL;
}
for( int iField = 0; iField < sSelectInfo.result_columns; iField++ )
{
swq_col_def *psColDef = sSelectInfo.column_defs + iField;
if (psColDef->field_index == -1)
{
if (psColDef->col_func == SWQCF_COUNT)
continue;
return NULL;
}
if (psColDef->field_type != SWQ_INTEGER &&
psColDef->field_type != SWQ_FLOAT)
{
return NULL;
}
}
const bool bFoundFilter = CPL_TO_BOOL(
poSrcLayer->HasFilterOnFieldOrCreateIfNecessary(osLastFieldName));
if( !bFoundFilter )
return NULL;
CPLString osURI = "/";
osURI += poSrcLayer->GetName();
osURI += "/_design/ogr_filter_";
osURI += osLastFieldName;
osURI += "/_view/filter?reduce=true";
json_object* poAnswerObj = GET(osURI);
json_object* poRows = NULL;
if (!(poAnswerObj != NULL &&
json_object_is_type(poAnswerObj, json_type_object) &&
(poRows = CPL_json_object_object_get(poAnswerObj, "rows")) != NULL &&
json_object_is_type(poRows, json_type_array)))
{
json_object_put(poAnswerObj);
return NULL;
}
int nLength = json_object_array_length(poRows);
if (nLength != 1)
{
json_object_put(poAnswerObj);
return NULL;
}
json_object* poRow = json_object_array_get_idx(poRows, 0);
if (!(poRow && json_object_is_type(poRow, json_type_object)))
{
json_object_put(poAnswerObj);
return NULL;
}
json_object* poValue = CPL_json_object_object_get(poRow, "value");
if (!(poValue != NULL && json_object_is_type(poValue, json_type_object)))
{
json_object_put(poAnswerObj);
return NULL;
}
json_object* poSum = CPL_json_object_object_get(poValue, "sum");
json_object* poCount = CPL_json_object_object_get(poValue, "count");
json_object* poMin = CPL_json_object_object_get(poValue, "min");
json_object* poMax = CPL_json_object_object_get(poValue, "max");
if (poSum != NULL && (json_object_is_type(poSum, json_type_int) ||
json_object_is_type(poSum, json_type_double)) &&
poCount != NULL && (json_object_is_type(poCount, json_type_int) ||
json_object_is_type(poCount, json_type_double)) &&
poMin != NULL && (json_object_is_type(poMin, json_type_int) ||
json_object_is_type(poMin, json_type_double)) &&
poMax != NULL && (json_object_is_type(poMax, json_type_int) ||
json_object_is_type(poMax, json_type_double)) )
{
double dfSum = json_object_get_double(poSum);
int nCount = json_object_get_int(poCount);
double dfMin = json_object_get_double(poMin);
double dfMax = json_object_get_double(poMax);
json_object_put(poAnswerObj);
//CPLDebug("CouchDB", "sum=%f, count=%d, min=%f, max=%f",
// dfSum, nCount, dfMin, dfMax);
OGRFeatureDefn* poFeatureDefn = new OGRFeatureDefn(poSrcLayer->GetName());
poFeatureDefn->Reference();
for( int iField = 0; iField < sSelectInfo.result_columns; iField++ )
{
swq_col_def *psColDef = sSelectInfo.column_defs + iField;
OGRFieldDefn oFDefn( "", OFTInteger );
if( psColDef->field_alias != NULL )
{
oFDefn.SetName(psColDef->field_alias);
}
else
{
const swq_operation *op = swq_op_registrar::GetOperator(
(swq_op) psColDef->col_func );
oFDefn.SetName( CPLSPrintf( "%s_%s",
op->pszName,
psColDef->field_name ) );
}
if( psColDef->col_func == SWQCF_COUNT )
oFDefn.SetType( OFTInteger );
else if (psColDef->field_type == SWQ_INTEGER)
oFDefn.SetType( OFTInteger );
else if (psColDef->field_type == SWQ_FLOAT)
oFDefn.SetType( OFTReal );
poFeatureDefn->AddFieldDefn(&oFDefn);
}
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
for( int iField = 0; iField < sSelectInfo.result_columns; iField++ )
{
swq_col_def *psColDef = sSelectInfo.column_defs + iField;
switch(psColDef->col_func)
{
case SWQCF_AVG:
if (nCount)
poFeature->SetField(iField, dfSum / nCount);
break;
case SWQCF_MIN:
poFeature->SetField(iField, dfMin);
break;
case SWQCF_MAX:
poFeature->SetField(iField, dfMax);
break;
case SWQCF_COUNT:
poFeature->SetField(iField, nCount);
break;
case SWQCF_SUM:
poFeature->SetField(iField, dfSum);
break;
default:
break;
}
}
poFeature->SetFID(0);
OGRCouchDBOneLineLayer* poAnswerLayer = new OGRCouchDBOneLineLayer();
poAnswerLayer->poFeatureDefn = poFeatureDefn;
poAnswerLayer->poFeature = poFeature;
return poAnswerLayer;
}
json_object_put(poAnswerObj);
return NULL;
}
OGRFeatureDefn *OGRIngresResultLayer::ReadResultDefinition()
{
/* -------------------------------------------------------------------- */
/* Parse the returned table information. */
/* -------------------------------------------------------------------- */
OGRFeatureDefn *poDefn = new OGRFeatureDefn( "sql_statement" );
int iRawField;
poDefn->Reference();
for( iRawField = 0;
iRawField < (int) poResultSet->getDescrParm.gd_descriptorCount;
iRawField++ )
{
IIAPI_DESCRIPTOR *psFDesc =
poResultSet->getDescrParm.gd_descriptor + iRawField;
OGRFieldDefn oField( psFDesc->ds_columnName, OFTString);
switch( psFDesc->ds_dataType )
{
case IIAPI_CHR_TYPE:
case IIAPI_CHA_TYPE:
// string - fixed width.
oField.SetWidth( psFDesc->ds_length );
poDefn->AddFieldDefn( &oField );
break;
case IIAPI_LVCH_TYPE:
case IIAPI_LTXT_TYPE:
case IIAPI_VCH_TYPE:
case IIAPI_TXT_TYPE:
// default variable length string
poDefn->AddFieldDefn( &oField );
break;
case IIAPI_INT_TYPE:
oField.SetType( OFTInteger );
poDefn->AddFieldDefn( &oField );
break;
case IIAPI_FLT_TYPE:
oField.SetType( OFTReal );
poDefn->AddFieldDefn( &oField );
break;
case IIAPI_DEC_TYPE:
oField.SetWidth( psFDesc->ds_precision );
if( psFDesc->ds_scale == 0 )
oField.SetType( OFTInteger );
else
{
oField.SetType( OFTReal );
oField.SetPrecision( psFDesc->ds_scale );
}
poDefn->AddFieldDefn( &oField );
break;
default:
// any other field we ignore.
break;
}
}
poDefn->SetGeomType( wkbNone );
return poDefn;
}
