// 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; }