/*
* ExecuteSQL()
*/
OGRLayer *OGRNGWDataset::ExecuteSQL( const char *pszStatement,
OGRGeometry *poSpatialFilter, const char *pszDialect )
{
// Clean statement string.
CPLString osStatement(pszStatement);
osStatement = osStatement.Trim().replaceAll(" ", " ");
if( STARTS_WITH_CI(osStatement.c_str(), "DELLAYER:") )
{
CPLString osLayerName = osStatement.substr(9);
if( osLayerName.endsWith(";") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 1);
osLayerName.Trim();
}
CPLDebug("NGW", "Delete layer with name %s.", osLayerName.c_str());
for( int iLayer = 0; iLayer < nLayers; ++iLayer )
{
if( EQUAL(papoLayers[iLayer]->GetName(), osLayerName.c_str() ) )
{
DeleteLayer( iLayer );
break;
}
}
return nullptr;
}
if( STARTS_WITH_CI(osStatement.c_str(), "DELETE FROM") )
{
// Get layer name from pszStatement DELETE FROM layer;.
CPLString osLayerName = osStatement.substr(12);
if( osLayerName.endsWith(";") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 1);
osLayerName.Trim();
}
CPLDebug("NGW", "Delete features from layer with name %s.", osLayerName.c_str());
OGRNGWLayer *poLayer = static_cast<OGRNGWLayer*>(GetLayerByName(osLayerName));
if( poLayer )
{
poLayer->DeleteAllFeatures();
}
else
{
CPLError(CE_Failure, CPLE_AppDefined, "Unknown layer : %s",
osLayerName.c_str());
}
return nullptr;
}
return GDALDataset::ExecuteSQL(pszStatement, poSpatialFilter, pszDialect);
}
void NTv2Dataset::CaptureMetadataItem( char *pszItem )
{
CPLString osKey;
CPLString osValue;
osKey.assign( pszItem, 8 );
osValue.assign( pszItem+8, 8 );
SetMetadataItem( osKey.Trim(), osValue.Trim() );
}
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;
}
GDALDataset *NTv2Dataset::Open( GDALOpenInfo * poOpenInfo )
{
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Are we targetting a particular grid? */
/* -------------------------------------------------------------------- */
CPLString osFilename;
int iTargetGrid = -1;
if( EQUALN(poOpenInfo->pszFilename,"NTv2:",5) )
{
const char *pszRest = poOpenInfo->pszFilename+5;
iTargetGrid = atoi(pszRest);
while( *pszRest != '\0' && *pszRest != ':' )
pszRest++;
if( *pszRest == ':' )
pszRest++;
osFilename = pszRest;
}
else
osFilename = poOpenInfo->pszFilename;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
NTv2Dataset *poDS;
poDS = new NTv2Dataset();
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_ReadOnly )
poDS->fpImage = VSIFOpenL( osFilename, "rb" );
else
poDS->fpImage = VSIFOpenL( osFilename, "rb+" );
if( poDS->fpImage == NULL )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read the file header. */
/* -------------------------------------------------------------------- */
char achHeader[11*16];
GInt32 nSubFileCount;
double dfValue;
CPLString osFValue;
VSIFSeekL( poDS->fpImage, 0, SEEK_SET );
VSIFReadL( achHeader, 11, 16, poDS->fpImage );
CPL_LSBPTR32( achHeader + 2*16 + 8 );
memcpy( &nSubFileCount, achHeader + 2*16 + 8, 4 );
if (nSubFileCount <= 0 || nSubFileCount >= 1024)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid value for NUM_FILE : %d", nSubFileCount);
delete poDS;
return NULL;
}
poDS->CaptureMetadataItem( achHeader + 3*16 );
poDS->CaptureMetadataItem( achHeader + 4*16 );
poDS->CaptureMetadataItem( achHeader + 5*16 );
poDS->CaptureMetadataItem( achHeader + 6*16 );
memcpy( &dfValue, achHeader + 7*16 + 8, 8 );
CPL_LSBPTR64( &dfValue );
osFValue.Printf( "%.15g", dfValue );
poDS->SetMetadataItem( "MAJOR_F", osFValue );
memcpy( &dfValue, achHeader + 8*16 + 8, 8 );
CPL_LSBPTR64( &dfValue );
osFValue.Printf( "%.15g", dfValue );
poDS->SetMetadataItem( "MINOR_F", osFValue );
memcpy( &dfValue, achHeader + 9*16 + 8, 8 );
CPL_LSBPTR64( &dfValue );
osFValue.Printf( "%.15g", dfValue );
poDS->SetMetadataItem( "MAJOR_T", osFValue );
memcpy( &dfValue, achHeader + 10*16 + 8, 8 );
CPL_LSBPTR64( &dfValue );
osFValue.Printf( "%.15g", dfValue );
poDS->SetMetadataItem( "MINOR_T", osFValue );
/* ==================================================================== */
/* Loop over grids. */
/* ==================================================================== */
int iGrid;
vsi_l_offset nGridOffset = sizeof(achHeader);
for( iGrid = 0; iGrid < nSubFileCount; iGrid++ )
{
CPLString osSubName;
int i;
GUInt32 nGSCount;
VSIFSeekL( poDS->fpImage, nGridOffset, SEEK_SET );
if (VSIFReadL( achHeader, 11, 16, poDS->fpImage ) != 16)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot read header for subfile %d", iGrid);
delete poDS;
return NULL;
}
for( i = 4; i <= 9; i++ )
CPL_LSBPTR64( achHeader + i*16 + 8 );
CPL_LSBPTR32( achHeader + 10*16 + 8 );
memcpy( &nGSCount, achHeader + 10*16 + 8, 4 );
osSubName.assign( achHeader + 8, 8 );
osSubName.Trim();
// If this is our target grid, open it as a dataset.
if( iTargetGrid == iGrid || (iTargetGrid == -1 && iGrid == 0) )
{
if( !poDS->OpenGrid( achHeader, nGridOffset ) )
{
delete poDS;
return NULL;
}
}
// If we are opening the file as a whole, list subdatasets.
if( iTargetGrid == -1 )
{
CPLString osKey, osValue;
osKey.Printf( "SUBDATASET_%d_NAME", iGrid );
osValue.Printf( "NTv2:%d:%s", iGrid, osFilename.c_str() );
poDS->SetMetadataItem( osKey, osValue, "SUBDATASETS" );
osKey.Printf( "SUBDATASET_%d_DESC", iGrid );
osValue.Printf( "%s", osSubName.c_str() );
poDS->SetMetadataItem( osKey, osValue, "SUBDATASETS" );
}
nGridOffset += (11+(vsi_l_offset)nGSCount) * 16;
}
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
GDALDataset *CTable2Dataset::Open( GDALOpenInfo * poOpenInfo )
{
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
CTable2Dataset *poDS = new CTable2Dataset();
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
CPLString osFilename = poOpenInfo->pszFilename;
if( poOpenInfo->eAccess == GA_ReadOnly )
poDS->fpImage = VSIFOpenL( osFilename, "rb" );
else
poDS->fpImage = VSIFOpenL( osFilename, "rb+" );
if( poDS->fpImage == NULL )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read the file header. */
/* -------------------------------------------------------------------- */
CPL_IGNORE_RET_VAL(VSIFSeekL( poDS->fpImage, 0, SEEK_SET ));
char achHeader[160] = { '\0' };
CPL_IGNORE_RET_VAL(VSIFReadL( achHeader, 1, 160, poDS->fpImage ));
achHeader[16+79] = '\0';
CPLString osDescription = reinterpret_cast<const char *>( achHeader + 16 );
osDescription.Trim();
poDS->SetMetadataItem( "DESCRIPTION", osDescription );
/* -------------------------------------------------------------------- */
/* Convert from LSB to local machine byte order. */
/* -------------------------------------------------------------------- */
CPL_LSBPTR64( achHeader + 96 );
CPL_LSBPTR64( achHeader + 104 );
CPL_LSBPTR64( achHeader + 112 );
CPL_LSBPTR64( achHeader + 120 );
CPL_LSBPTR32( achHeader + 128 );
CPL_LSBPTR32( achHeader + 132 );
/* -------------------------------------------------------------------- */
/* Extract size, and geotransform. */
/* -------------------------------------------------------------------- */
int nRasterXSize, nRasterYSize;
memcpy( &nRasterXSize, achHeader + 128, 4 );
memcpy( &nRasterYSize, achHeader + 132, 4 );
if (!GDALCheckDatasetDimensions(nRasterXSize, nRasterYSize))
{
delete poDS;
return NULL;
}
poDS->nRasterXSize = nRasterXSize;
poDS->nRasterYSize = nRasterYSize;
double adfValues[4];
memcpy( adfValues, achHeader + 96, sizeof(double)*4 );
for( int i = 0; i < 4; i++ )
adfValues[i] *= 180/M_PI; // Radians to degrees.
poDS->adfGeoTransform[0] = adfValues[0] - adfValues[2]*0.5;
poDS->adfGeoTransform[1] = adfValues[2];
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = adfValues[1] + adfValues[3]*(nRasterYSize-0.5);
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = -adfValues[3];
/* -------------------------------------------------------------------- */
/* Setup the bands. */
/* -------------------------------------------------------------------- */
RawRasterBand *poBand =
new RawRasterBand( poDS, 1, poDS->fpImage,
160 + 4 + nRasterXSize * (nRasterYSize-1) * 2 * 4,
8, -8 * nRasterXSize,
GDT_Float32, CPL_IS_LSB, TRUE, FALSE );
poBand->SetDescription( "Latitude Offset (radians)" );
poDS->SetBand( 1, poBand );
poBand =
new RawRasterBand( poDS, 2, poDS->fpImage,
160 + nRasterXSize * (nRasterYSize-1) * 2 * 4,
8, -8 * nRasterXSize,
GDT_Float32, CPL_IS_LSB, TRUE, FALSE );
poBand->SetDescription( "Longitude Offset (radians)" );
poDS->SetBand( 2, poBand );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
int ERSHdrNode::ParseChildren( VSILFILE * fp, int nRecLevel )
{
if( nRecLevel == 100 ) // arbitrary limit
{
CPLError(CE_Failure, CPLE_AppDefined,
"Too many recursion level while parsing .ers header");
return false;
}
while( true )
{
/* -------------------------------------------------------------------- */
/* Read the next line (or multi-line for bracketed value). */
/* -------------------------------------------------------------------- */
CPLString osLine;
if( !ReadLine( fp, osLine ) )
return FALSE;
/* -------------------------------------------------------------------- */
/* Got a Name=Value. */
/* -------------------------------------------------------------------- */
size_t iOff;
if( (iOff = osLine.find_first_of( '=' )) != std::string::npos )
{
CPLString osName = osLine.substr(0,iOff-1);
osName.Trim();
CPLString osValue = osLine.c_str() + iOff + 1;
osValue.Trim();
MakeSpace();
papszItemName[nItemCount] = CPLStrdup(osName);
papszItemValue[nItemCount] = CPLStrdup(osValue);
papoItemChild[nItemCount] = nullptr;
nItemCount++;
}
/* -------------------------------------------------------------------- */
/* Got a Begin for an object. */
/* -------------------------------------------------------------------- */
else if( (iOff = osLine.ifind( " Begin" )) != std::string::npos )
{
CPLString osName = osLine.substr(0,iOff);
osName.Trim();
MakeSpace();
papszItemName[nItemCount] = CPLStrdup(osName);
papszItemValue[nItemCount] = nullptr;
papoItemChild[nItemCount] = new ERSHdrNode();
nItemCount++;
if( !papoItemChild[nItemCount-1]->ParseChildren( fp, nRecLevel + 1 ) )
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Got an End for our object. Well, at least we *assume* it */
/* must be for our object. */
/* -------------------------------------------------------------------- */
else if( osLine.ifind( " End" ) != std::string::npos )
{
return TRUE;
}
/* -------------------------------------------------------------------- */
/* Error? */
/* -------------------------------------------------------------------- */
else if( osLine.Trim().length() > 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unexpected line parsing .ecw:\n%s",
osLine.c_str() );
return FALSE;
}
}
}
int OGRIngresDataSource::Open( const char *pszFullName,
char **papszOptions, int bUpdate )
{
CPLAssert( nLayers == 0 );
#define MAX_TARGET_STRING_LENGTH 512
char pszDBTarget[MAX_TARGET_STRING_LENGTH];
/* -------------------------------------------------------------------- */
/* Verify we have a dbname, this parameter is required. */
/* -------------------------------------------------------------------- */
const char *pszDBName = CSLFetchNameValue(papszOptions,"dbname");
if( pszDBName == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"No DBNAME item provided in INGRES datasource name." );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Do we have a table list? */
/* -------------------------------------------------------------------- */
char **papszTableNames = NULL;
const char *pszTables = CSLFetchNameValue(papszOptions,"tables");
if( pszTables != NULL )
papszTableNames = CSLTokenizeStringComplex(pszTables,"/",TRUE,FALSE);
/* -------------------------------------------------------------------- */
/* Add support to dynamic vnode if passed */
/* -------------------------------------------------------------------- */
const char *pszHost = CSLFetchNameValue(papszOptions,"host");
if (pszHost)
{
const char *pszInstance = CSLFetchNameValue(papszOptions,"instance");
if (pszInstance == NULL || strlen(pszInstance) != 2)
{
CPLError( CE_Failure, CPLE_OpenFailed,
"instance name must be specified with host." );
return FALSE;
}
/*
** make sure the user name and password are passed too,
** note it could not be zero length.
*/
const char *pszUsername = CSLFetchNameValue(papszOptions,"username");
const char *pszPassword = CSLFetchNameValue(papszOptions,"password");
if (pszUsername == NULL || strlen(pszUsername) == 0)
{
CPLError( CE_Failure, CPLE_OpenFailed,
"user name must be specified in dynamic vnode." );
return FALSE;
}
if (pszPassword == NULL || strlen(pszPassword) == 0)
{
CPLError( CE_Failure, CPLE_OpenFailed,
"password must be specified in dynamic vnode." );
return FALSE;
}
/*
** construct the vnode string, like :
** @host,protocol,port[;attribute=value{;attribute=value}][[user,password]],
** visit for detail
** http://docs.actian.com/ingres/10.0/command-reference-guide/1207-dynamic-vnode-specificationconnect-to-remote-node
*/
sprintf(pszDBTarget, "@%s,%s,%s;%s[%s,%s]::%s ",
pszHost, /* host, compute name or IP address */
"TCP_IP", /* protocal, default with TCP/IP */
pszInstance, /* instance Name */
"" , /* option, Null */
pszUsername, /* user name, could not be empty */
pszPassword, /* pwd */
pszDBName /* database name */
);
CPLDebug("INGRES", pszDBTarget);
}
else
{
/* Remain the database name */
strcpy(pszDBTarget, pszDBName);
}
/* -------------------------------------------------------------------- */
/* Initialize the Ingres API. Should we only do this once per */
/* program run? Really we should also try to terminate the api */
/* on program exit. */
/* -------------------------------------------------------------------- */
IIAPI_INITPARM initParm;
initParm.in_version = IIAPI_VERSION_1;
initParm.in_timeout = -1;
IIapi_initialize( &initParm );
/* -------------------------------------------------------------------- */
/* check effective user and db password */
/* -------------------------------------------------------------------- */
hConn = NULL;
const char *pszEffuser = CSLFetchNameValue(papszOptions,"effuser");
const char *pszDBpwd = CSLFetchNameValue(papszOptions,"dbpwd");
if ( pszEffuser
&& strlen(pszEffuser) > 0
&& pszDBpwd
&& strlen(pszDBpwd) > 0 )
{
if (SetConnParam(&hConn, IIAPI_CP_EFFECTIVE_USER,
(II_PTR)pszEffuser) != IIAPI_ST_SUCCESS
|| SetConnParam(&hConn, IIAPI_CP_DBMS_PASSWORD,
(II_PTR)pszDBpwd) != IIAPI_ST_SUCCESS )
{
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* Try to connect to the database. */
/* -------------------------------------------------------------------- */
IIAPI_CONNPARM connParm;
IIAPI_WAITPARM waitParm = { -1 };
memset( &connParm, 0, sizeof(connParm) );
connParm.co_genParm.gp_callback = NULL;
connParm.co_genParm.gp_closure = NULL;
connParm.co_target = (II_CHAR *) pszDBTarget;
connParm.co_connHandle = hConn;
connParm.co_tranHandle = NULL;
connParm.co_username =
(II_CHAR*) CSLFetchNameValue(papszOptions,"username");
connParm.co_password =
(II_CHAR*)CSLFetchNameValue(papszOptions,"password");
connParm.co_timeout = -1;
if( CSLFetchNameValue(papszOptions,"timeout") != NULL )
connParm.co_timeout = atoi(CSLFetchNameValue(papszOptions,"timeout"));
IIapi_connect( &connParm );
while( connParm.co_genParm.gp_completed == FALSE )
IIapi_wait( &waitParm );
hConn = connParm.co_connHandle;
if( connParm.co_genParm.gp_status != IIAPI_ST_SUCCESS
|| hConn == NULL )
{
OGRIngresStatement::ReportError( &(connParm.co_genParm),
"Failed to connect to Ingres database." );
return FALSE;
}
pszName = CPLStrdup( pszFullName );
bDSUpdate = bUpdate;
// Check for new or old Ingres spatial library
{
OGRIngresStatement oStmt( hConn );
if( oStmt.ExecuteSQL("SELECT COUNT(*) FROM iicolumns WHERE table_name = 'iiattribute' AND column_name = 'attgeomtype'" ) )
{
char **papszFields;
while( (papszFields = oStmt.GetRow()) )
{
CPLString osCount = papszFields[0];
if( osCount[0] == '0' )
{
bNewIngres = FALSE;
}
else
{
bNewIngres = TRUE;
}
}
}
}
/* -------------------------------------------------------------------- */
/* Get a list of available tables. */
/* -------------------------------------------------------------------- */
if( papszTableNames == NULL )
{
OGRIngresStatement oStmt( hConn );
if( oStmt.ExecuteSQL( "select table_name from iitables where system_use = 'U' and table_name not like 'iietab_%'" ) )
{
char **papszFields;
while( (papszFields = oStmt.GetRow()) )
{
CPLString osTableName = papszFields[0];
osTableName.Trim();
papszTableNames = CSLAddString( papszTableNames,
osTableName );
}
}
}
/* -------------------------------------------------------------------- */
/* Get the schema of the available tables. */
/* -------------------------------------------------------------------- */
int iRecord;
for( iRecord = 0;
papszTableNames != NULL && papszTableNames[iRecord] != NULL;
iRecord++ )
{
OpenTable( papszTableNames[iRecord], bUpdate );
}
CSLDestroy( papszTableNames );
return TRUE;
}
int ERSHdrNode::ParseChildren( VSILFILE * fp )
{
while( TRUE )
{
size_t iOff;
CPLString osLine;
/* -------------------------------------------------------------------- */
/* Read the next line (or multi-line for bracketed value). */
/* -------------------------------------------------------------------- */
if( !ReadLine( fp, osLine ) )
return FALSE;
/* -------------------------------------------------------------------- */
/* Got a Name=Value. */
/* -------------------------------------------------------------------- */
if( (iOff = osLine.find_first_of( '=' )) != std::string::npos )
{
CPLString osName = osLine.substr(0,iOff-1);
osName.Trim();
CPLString osValue = osLine.c_str() + iOff + 1;
osValue.Trim();
MakeSpace();
papszItemName[nItemCount] = CPLStrdup(osName);
papszItemValue[nItemCount] = CPLStrdup(osValue);
papoItemChild[nItemCount] = NULL;
nItemCount++;
}
/* -------------------------------------------------------------------- */
/* Got a Begin for an object. */
/* -------------------------------------------------------------------- */
else if( (iOff = osLine.ifind( " Begin" )) != std::string::npos )
{
CPLString osName = osLine.substr(0,iOff);
osName.Trim();
MakeSpace();
papszItemName[nItemCount] = CPLStrdup(osName);
papszItemValue[nItemCount] = NULL;
papoItemChild[nItemCount] = new ERSHdrNode();
nItemCount++;
if( !papoItemChild[nItemCount-1]->ParseChildren( fp ) )
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Got an End for our object. Well, at least we *assume* it */
/* must be for our object. */
/* -------------------------------------------------------------------- */
else if( osLine.ifind( " End" ) != std::string::npos )
{
return TRUE;
}
/* -------------------------------------------------------------------- */
/* Error? */
/* -------------------------------------------------------------------- */
else if( osLine.Trim().length() > 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unexpected line parsing .ecw:\n%s",
osLine.c_str() );
return FALSE;
}
}
}
int OGRIngresDataSource::Open( const char *pszFullName,
char **papszOptions, int bUpdate )
{
CPLAssert( nLayers == 0 );
/* -------------------------------------------------------------------- */
/* Verify we have a dbname, this parameter is required. */
/* -------------------------------------------------------------------- */
const char *pszDBName = CSLFetchNameValue(papszOptions,"dbname");
if( pszDBName == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"No DBNAME item provided in INGRES datasource name." );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Do we have a table list? */
/* -------------------------------------------------------------------- */
char **papszTableNames = NULL;
const char *pszTables = CSLFetchNameValue(papszOptions,"tables");
if( pszTables != NULL )
papszTableNames = CSLTokenizeStringComplex(pszTables,"/",TRUE,FALSE);
/* -------------------------------------------------------------------- */
/* Initialize the Ingres API. Should we only do this once per */
/* program run? Really we should also try to terminate the api */
/* on program exit. */
/* -------------------------------------------------------------------- */
IIAPI_INITPARM initParm;
initParm.in_version = IIAPI_VERSION_1;
initParm.in_timeout = -1;
IIapi_initialize( &initParm );
/* -------------------------------------------------------------------- */
/* Try to connect to the database. */
/* -------------------------------------------------------------------- */
IIAPI_CONNPARM connParm;
IIAPI_WAITPARM waitParm = { -1 };
memset( &connParm, 0, sizeof(connParm) );
connParm.co_genParm.gp_callback = NULL;
connParm.co_genParm.gp_closure = NULL;
connParm.co_target = (II_CHAR *) pszDBName;
connParm.co_connHandle = NULL;
connParm.co_tranHandle = NULL;
connParm.co_username =
(II_CHAR*) CSLFetchNameValue(papszOptions,"username");
connParm.co_password =
(II_CHAR*)CSLFetchNameValue(papszOptions,"password");
connParm.co_timeout = -1;
if( CSLFetchNameValue(papszOptions,"timeout") != NULL )
connParm.co_timeout = atoi(CSLFetchNameValue(papszOptions,"timeout"));
IIapi_connect( &connParm );
while( connParm.co_genParm.gp_completed == FALSE )
IIapi_wait( &waitParm );
hConn = connParm.co_connHandle;
if( connParm.co_genParm.gp_status != IIAPI_ST_SUCCESS
|| hConn == NULL )
{
OGRIngresStatement::ReportError( &(connParm.co_genParm),
"Failed to connect to Ingres database." );
return FALSE;
}
pszName = CPLStrdup( pszFullName );
bDSUpdate = bUpdate;
// Check for new or old Ingres spatial library
{
OGRIngresStatement oStmt( hConn );
if( oStmt.ExecuteSQL("SELECT COUNT(*) FROM iicolumns WHERE table_name = 'iiattribute' AND column_name = 'attgeomtype'" ) )
{
char **papszFields;
while( (papszFields = oStmt.GetRow()) )
{
CPLString osCount = papszFields[0];
if( osCount[0] == '0' )
{
bNewIngres = FALSE;
}
else
{
bNewIngres = TRUE;
}
}
}
}
/* -------------------------------------------------------------------- */
/* Get a list of available tables. */
/* -------------------------------------------------------------------- */
if( papszTableNames == NULL )
{
OGRIngresStatement oStmt( hConn );
if( oStmt.ExecuteSQL( "select table_name from iitables where system_use = 'U' and table_name not like 'iietab_%'" ) )
{
char **papszFields;
while( (papszFields = oStmt.GetRow()) )
{
CPLString osTableName = papszFields[0];
osTableName.Trim();
papszTableNames = CSLAddString( papszTableNames,
osTableName );
}
}
}
/* -------------------------------------------------------------------- */
/* Get the schema of the available tables. */
/* -------------------------------------------------------------------- */
int iRecord;
for( iRecord = 0;
papszTableNames != NULL && papszTableNames[iRecord] != NULL;
iRecord++ )
{
OpenTable( papszTableNames[iRecord], bUpdate );
}
CSLDestroy( papszTableNames );
return TRUE;
}