JNIEXPORT void JNICALL Java_es_gva_cit_jogr_OGRFeatureDefn_setGeomTypeNat
(JNIEnv *env, jobject obj, jlong cPtr, jstring eGType){
OGRFeatureDefn *fd = (OGRFeatureDefn *) 0 ;
OGRwkbGeometryType geomtype;
fd = *(OGRFeatureDefn **)&cPtr;
if(fd!=NULL){
const char *type = env->GetStringUTFChars( eGType, 0);
if(strcmp(type,"wkbUnknown")==0)geomtype = wkbUnknown;
else if(strcmp(type,"wkbPoint")==0)geomtype = wkbPoint;
else if(strcmp(type,"wkbLineString")==0)geomtype = wkbLineString;
else if(strcmp(type,"wkbPolygon")==0)geomtype = wkbPolygon;
else if(strcmp(type,"wkbMultiPoint")==0)geomtype = wkbMultiPoint;
else if(strcmp(type,"wkbMultiLineString")==0)geomtype = wkbMultiLineString;
else if(strcmp(type,"wkbMultiPolygon")==0)geomtype = wkbMultiPolygon;
else if(strcmp(type,"wkbGeometryCollection")==0)geomtype = wkbGeometryCollection;
else if(strcmp(type,"wkbNone")==0)geomtype = wkbNone;
else if(strcmp(type,"wkbLinearRing")==0)geomtype = wkbLinearRing;
else if(strcmp(type,"wkbPoint25D")==0)geomtype = wkbPoint25D;
else if(strcmp(type,"wkbLineString25D")==0)geomtype = wkbLineString25D;
else if(strcmp(type,"wkbPolygon25D")==0)geomtype = wkbPolygon25D;
else if(strcmp(type,"wkbMultiPoint25D")==0)geomtype = wkbMultiPoint25D;
else if(strcmp(type,"wkbMultiLineString25D")==0)geomtype = wkbMultiLineString25D;
else if(strcmp(type,"wkbMultiPolygon25D")==0)geomtype = wkbMultiPolygon25D;
else if(strcmp(type,"wkbGeometryCollection25D")==0)geomtype = wkbGeometryCollection25D;
fd->SetGeomType(geomtype);
env->ReleaseStringUTFChars( eGType, type );
}
}
OGRLayer *
OGRILI2DataSource::CreateLayer( const char * pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
if (fpOutput == NULL)
return NULL;
FeatureDefnInfo featureDefnInfo = poImdReader->GetFeatureDefnInfo(pszLayerName);
OGRFeatureDefn* poFeatureDefn = featureDefnInfo.poTableDefn;
if (poFeatureDefn == NULL)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Layer '%s' not found in model definition. Creating adhoc layer", pszLayerName);
poFeatureDefn = new OGRFeatureDefn(pszLayerName);
poFeatureDefn->SetGeomType( eType );
}
OGRILI2Layer *poLayer = new OGRILI2Layer(poFeatureDefn, featureDefnInfo.poGeomFieldInfos, this);
nLayers++;
papoLayers = (OGRILI2Layer**)CPLRealloc(papoLayers, sizeof(OGRILI2Layer*) * nLayers);
papoLayers[nLayers-1] = poLayer;
return poLayer;
}
OGRLayer *OGRSOSIDataSource::ICreateLayer( const char *pszNameIn,
OGRSpatialReference *poSpatialRef,
OGRwkbGeometryType eGType,
CPL_UNUSED char **papszOptions ) {
/* SOSI does not really support layers - so let's first see that the global settings are consistent */
if (poSRS == NULL) {
if (poSpatialRef!=NULL) {
poSRS = poSpatialRef;
poSRS->Reference();
const char *pszKoosys = poSRS->GetAuthorityCode("PROJCS");
if (pszKoosys == NULL) {
OGRErr err = poSRS->AutoIdentifyEPSG();
if (err == OGRERR_UNSUPPORTED_SRS) {
CPLError( CE_Failure, CPLE_OpenFailed,
"Could not identify EPSG code for spatial reference system");
return NULL;
}
pszKoosys = poSRS->GetAuthorityCode("PROJCS");
}
if (pszKoosys != NULL) {
int nKoosys = epsg2sosi(atoi(pszKoosys));
CPLDebug( "[CreateLayer]","Projection set to SOSI %i", nKoosys);
LC_PutTrans(nKoosys,0,0,0.01,0.01,0.01);
} else {
pszKoosys = poSRS->GetAuthorityCode("GEOGCS");
if (pszKoosys != NULL) {
int nKoosys = epsg2sosi(atoi(pszKoosys));
LC_PutTrans(nKoosys,0,0,0.01,0.01,0.01);
} else {
CPLError( CE_Failure, CPLE_OpenFailed,
"Could not retrieve EPSG code for spatial reference system");
return NULL;
}
}
}
LC_WsGr(poFileadm); /* Writing the header here! */
} else {
if (!poSRS->IsSame(poSpatialRef)) {
CPLError( CE_Failure, CPLE_AppDefined,
"SOSI driver does not support different spatial reference systems in one file.");
}
}
OGRFeatureDefn *poFeatureDefn = new OGRFeatureDefn( pszNameIn );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( eGType );
OGRSOSILayer *poLayer = new OGRSOSILayer( this, poFeatureDefn, poFileadm, NULL /*poHeaderDefn*/);
/* todo: where do we delete poLayer and poFeatureDefn? */
return poLayer;
}
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 *S57GenerateGeomFeatureDefn( OGRwkbGeometryType eGType,
int nOptionFlags )
{
OGRFeatureDefn *poFDefn = NULL;
if( eGType == wkbPoint )
{
poFDefn = new OGRFeatureDefn( "Point" );
poFDefn->SetGeomType( eGType );
}
else if( eGType == wkbLineString )
{
poFDefn = new OGRFeatureDefn( "Line" );
poFDefn->SetGeomType( eGType );
}
else if( eGType == wkbPolygon )
{
poFDefn = new OGRFeatureDefn( "Area" );
poFDefn->SetGeomType( eGType );
}
else if( eGType == wkbNone )
{
poFDefn = new OGRFeatureDefn( "Meta" );
poFDefn->SetGeomType( eGType );
}
else if( eGType == wkbUnknown )
{
poFDefn = new OGRFeatureDefn( "Generic" );
poFDefn->SetGeomType( eGType );
}
else
return NULL;
poFDefn->Reference();
S57GenerateStandardAttributes( poFDefn, nOptionFlags );
return poFDefn;
}
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;
}
OGRLayer *
OGRILI1DataSource::ICreateLayer( const char * pszLayerName,
CPL_UNUSED OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
CPL_UNUSED char ** papszOptions )
{
FeatureDefnInfo featureDefnInfo
= poImdReader->GetFeatureDefnInfo(pszLayerName);
const char *table = pszLayerName;
char * topic = ExtractTopic(pszLayerName);
if (nLayers) VSIFPrintf( fpTransfer, "ETAB\n" );
if (topic)
{
table = pszLayerName+strlen(topic)+2; //after "__"
if (pszTopic == NULL || !EQUAL(topic, pszTopic))
{
if (pszTopic)
{
VSIFPrintf( fpTransfer, "ETOP\n" );
CPLFree(pszTopic);
}
pszTopic = topic;
VSIFPrintf( fpTransfer, "TOPI %s\n", pszTopic );
}
else
{
CPLFree(topic);
}
}
else
{
if (pszTopic == NULL) pszTopic = CPLStrdup("Unknown");
VSIFPrintf( fpTransfer, "TOPI %s\n", pszTopic );
}
VSIFPrintf( fpTransfer, "TABL %s\n", table );
OGRFeatureDefn* poFeatureDefn = new OGRFeatureDefn(table);
poFeatureDefn->SetGeomType( eType );
OGRILI1Layer *poLayer
= new OGRILI1Layer(poFeatureDefn, featureDefnInfo.poGeomFieldInfos,
this);
nLayers ++;
papoLayers = static_cast<OGRILI1Layer **>(
CPLRealloc(papoLayers, sizeof(OGRILI1Layer*) * nLayers) );
papoLayers[nLayers-1] = poLayer;
return poLayer;
}
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 *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 *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;
}
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 *
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;
}
int ILI1Reader::ReadFeatures() {
char **tokens = NULL;
const char *pszLine = NULL;
char *topic = CPLStrdup("(null)");
int ret = TRUE;
while (ret && (tokens = ReadParseLine()) != NULL)
{
const char *firsttok = tokens[0];
if (EQUAL(firsttok, "SCNT"))
{
//read description
do
{
pszLine = CPLReadLine( fpItf );
}
while (pszLine && !STARTS_WITH_CI(pszLine, "////"));
ret = (pszLine != NULL);
}
else if (EQUAL(firsttok, "MOTR"))
{
//read model
do
{
pszLine = CPLReadLine( fpItf );
}
while (pszLine && !STARTS_WITH_CI(pszLine, "////"));
ret = (pszLine != NULL);
}
else if (EQUAL(firsttok, "MTID"))
{
}
else if (EQUAL(firsttok, "MODL"))
{
}
else if (EQUAL(firsttok, "TOPI") && CSLCount(tokens) >= 2)
{
CPLFree(topic);
topic = CPLStrdup(CSLGetField(tokens, 1));
}
else if (EQUAL(firsttok, "TABL") && CSLCount(tokens) >= 2)
{
const char *layername
= GetLayerNameString(topic, CSLGetField(tokens, 1));
CPLDebug( "OGR_ILI", "Reading table '%s'", layername );
curLayer = GetLayerByName(layername);
if (curLayer == NULL) { //create one
CPLError( CE_Warning, CPLE_AppDefined,
"No model definition for table '%s' found, "
"using default field names.", layername );
OGRFeatureDefn* poFeatureDefn
= new OGRFeatureDefn(
GetLayerNameString(topic, CSLGetField(tokens, 1)));
poFeatureDefn->SetGeomType( wkbUnknown );
GeomFieldInfos oGeomFieldInfos;
curLayer = new OGRILI1Layer(poFeatureDefn, oGeomFieldInfos, NULL);
AddLayer(curLayer);
}
if(curLayer != NULL) {
for (int i=0; i < curLayer->GetLayerDefn()->GetFieldCount(); i++) {
CPLDebug( "OGR_ILI", "Field %d: %s", i,
curLayer->GetLayerDefn()->GetFieldDefn(i)->GetNameRef());
}
}
ret = ReadTable(layername);
}
else if (EQUAL(firsttok, "ETOP"))
{
}
else if (EQUAL(firsttok, "EMOD"))
{
}
else if (EQUAL(firsttok, "ENDE"))
{
CSLDestroy(tokens);
CPLFree(topic);
return TRUE;
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"Unexpected token: %s", firsttok );
}
CSLDestroy(tokens);
tokens = NULL;
}
CSLDestroy(tokens);
CPLFree(topic);
return ret;
}
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;
}
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;
}
OGRFeatureDefn *
OGROCISelectLayer::ReadTableDefinition( OGROCIStatement *poCommand )
{
OGROCISession *poSession = poDS->GetSession();
/* -------------------------------------------------------------------- */
/* Parse the returned table information. */
/* -------------------------------------------------------------------- */
for( int iParm = 0; TRUE; iParm++ )
{
OGRFieldDefn oField( "", OFTString );
int nStatus;
OCIParam *hParmDesc;
ub2 nOCIType;
ub4 nOCILen;
nStatus =
OCIParamGet( poCommand->GetStatement(), OCI_HTYPE_STMT,
poSession->hError, (dvoid**)&hParmDesc,
(ub4) iParm+1 );
if( nStatus == OCI_ERROR )
break;
if( poSession->GetParmInfo( hParmDesc, &oField, &nOCIType, &nOCILen )
!= CE_None )
break;
if( oField.GetType() == OFTBinary && nOCIType == 108 )
{
CPLFree( pszGeomName );
pszGeomName = CPLStrdup( oField.GetNameRef() );
iGeomColumn = iParm;
break;
}
}
/* -------------------------------------------------------------------- */
/* Use the schema off the statement. */
/* -------------------------------------------------------------------- */
OGRFeatureDefn *poDefn;
poDefn = poCommand->GetResultDefn();
if( iGeomColumn >= 0 )
poDefn->SetGeomType(wkbUnknown);
poDefn->Reference();
/* -------------------------------------------------------------------- */
/* Do we have an FID? */
/* -------------------------------------------------------------------- */
const char *pszExpectedFIDName =
CPLGetConfigOption( "OCI_FID", "OGR_FID" );
if( poDefn->GetFieldIndex(pszExpectedFIDName) > -1 )
{
iFIDColumn = poDefn->GetFieldIndex(pszExpectedFIDName);
pszFIDName = CPLStrdup(poDefn->GetFieldDefn(iFIDColumn)->GetNameRef());
}
if( EQUAL(pszExpectedFIDName, "OGR_FID") && pszFIDName )
{
for(int i=0;i<poDefn->GetFieldCount();i++)
{
// This is presumably a Integer since we always create Integer64 with a
// defined precision
if( poDefn->GetFieldDefn(i)->GetType() == OFTInteger64 &&
poDefn->GetFieldDefn(i)->GetWidth() == 0 )
{
poDefn->GetFieldDefn(i)->SetType(OFTInteger);
}
}
}
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;
}
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;
}
