bool PDOSqliteStatement::getColumnMeta(int64_t colno, Array &ret) { if (!m_stmt) { return false; } if (colno >= sqlite3_data_count(m_stmt)) { /* error invalid column */ handleError(__FILE__, __LINE__); return false; } ret = Array::Create(); Array flags = Array::Create(); switch (sqlite3_column_type(m_stmt, colno)) { case SQLITE_NULL: ret.set(s_native_type, s_null); break; case SQLITE_FLOAT: ret.set(s_native_type, s_double); break; case SQLITE_BLOB: flags.append(s_blob); case SQLITE_TEXT: ret.set(s_native_type, s_string); break; case SQLITE_INTEGER: ret.set(s_native_type, s_integer); break; } const char *str = sqlite3_column_decltype(m_stmt, colno); if (str) { ret.set(s_sqlite_decl_type, String((char *)str, CopyString)); } #ifdef SQLITE_ENABLE_COLUMN_METADATA str = sqlite3_column_table_name(m_stmt, colno); if (str) { ret.set(s_table, String((char *)str, CopyString)); } #endif ret.set(s_flags, flags); return true; }
int column_metadata_helper( sqlite3 *db, sqlite3_stmt *stmt, int col, struct metadata *p ){ const char *zTableName, *zColumnName; int rc = 0; p->pNotNull = 0; p->pPrimaryKey = 0; p->pAutoinc = 0; zTableName = sqlite3_column_table_name(stmt, col); zColumnName = sqlite3_column_name(stmt, col); if (zTableName && zColumnName) { rc = sqlite3_table_column_metadata( db, 0, zTableName, zColumnName, 0, 0, &p->pNotNull, &p->pPrimaryKey, &p->pAutoinc ); } return rc; }
static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, zend_long colno, zval *return_value) { pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data; const char *str; zval flags; if (!S->stmt) { return FAILURE; } if(colno >= sqlite3_data_count(S->stmt)) { /* error invalid column */ pdo_sqlite_error_stmt(stmt); return FAILURE; } array_init(return_value); array_init(&flags); switch (sqlite3_column_type(S->stmt, colno)) { case SQLITE_NULL: add_assoc_string(return_value, "native_type", "null"); break; case SQLITE_FLOAT: add_assoc_string(return_value, "native_type", "double"); break; case SQLITE_BLOB: add_next_index_string(&flags, "blob"); case SQLITE_TEXT: add_assoc_string(return_value, "native_type", "string"); break; case SQLITE_INTEGER: add_assoc_string(return_value, "native_type", "integer"); break; } str = sqlite3_column_decltype(S->stmt, colno); if (str) { add_assoc_string(return_value, "sqlite:decl_type", (char *)str); } #ifdef SQLITE_ENABLE_COLUMN_METADATA str = sqlite3_column_table_name(S->stmt, colno); if (str) { add_assoc_string(return_value, "table", (char *)str); } #endif add_assoc_zval(return_value, "flags", &flags); return SUCCESS; }
SWIGEXPORT jstring JNICALL Java_com_almworks_sqlite4java__1SQLiteSwiggedJNI_sqlite3_1column_1table_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { jstring jresult = 0 ; sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; int arg2 ; char *result = 0 ; (void)jenv; (void)jcls; arg1 = *(sqlite3_stmt **)&jarg1; arg2 = (int)jarg2; result = (char *)sqlite3_column_table_name(arg1,arg2); if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); return jresult; }
static int sqlite3_odbx_column_type( odbx_result_t* result, unsigned long pos ) { #ifdef HAVE_SQLITE3_TABLE_COLUMN_METADATA const char *type, *collation; int notnull, primarykey, autoinc; #endif switch( sqlite3_column_type( (sqlite3_stmt*) result->generic, pos ) ) { case SQLITE_INTEGER: return ODBX_TYPE_BIGINT; case SQLITE_FLOAT: return ODBX_TYPE_DOUBLE; case SQLITE_BLOB: return ODBX_TYPE_BLOB; case SQLITE_TEXT: return ODBX_TYPE_CLOB; default: #ifdef HAVE_SQLITE3_TABLE_COLUMN_METADATA if( sqlite3_table_column_metadata( (sqlite3*) result->handle->generic, sqlite3_column_database_name( (sqlite3_stmt*) result->generic, pos ), sqlite3_column_table_name( (sqlite3_stmt*) result->generic, pos ), sqlite3_column_origin_name( (sqlite3_stmt*) result->generic, pos ), &type, &collation, ¬null, &primarykey, &autoinc ) != SQLITE_OK ) { return ODBX_TYPE_UNKNOWN; } if( strstr( type, "DOUBLE" ) != NULL || strcmp( type, "FLOAT" ) == 0 || strcmp( type, "REAL" ) == 0 ) { return ODBX_TYPE_DOUBLE; } else if( strstr( type, "INT" ) != NULL || strcmp( type, "BOOLEAN" ) == 0 ) { return ODBX_TYPE_BIGINT; } else if( strstr( type, "CHAR" ) != NULL || strcmp( type, "CLOB" ) == 0 || strcmp( type, "TEXT" ) == 0 ) { return ODBX_TYPE_CLOB; } else if( strstr( type, "DATE" ) != NULL || strstr( type, "TIME" ) != NULL || strstr( type, "DECIMAL" ) != NULL ) { return ODBX_TYPE_CLOB; } else if( strcmp( type, "BLOB" ) == 0 ) { return ODBX_TYPE_BLOB; } else { return ODBX_TYPE_UNKNOWN; } #else return ODBX_TYPE_UNKNOWN; #endif } }
jstring JNICALL Java_com_baidu_javalite_PrepareStmt_sqlite3_1column_1table_1name( JNIEnv *env, jclass cls, jlong handle, jint column) { if (handle == 0) { throwSqliteException(env, "handle is NULL"); return 0; } sqlite3_stmt* stmt = (sqlite3_stmt*) handle; const char* cn = sqlite3_column_table_name(stmt, column); if (cn == 0) { return (*env)->NewStringUTF(env, ""); } else { return (*env)->NewStringUTF(env, cn); } }
void sqlite_source::prepare_data( const std::string & database_name, const std::string & sql) throw( std::logic_error, std::invalid_argument) { check_not_running(); delete_data(); sqlite3_stmt* data = get_stmt(database_name, sql); int column_count = sqlite3_column_count(data); if (column_count == 0) //statement is no SELECT statement { throw std::invalid_argument("Statement is no SQL SELECT statement."); } m_data = data; m_column_count = column_count; m_time_column = sqlite3_bind_parameter_index(m_data, get_duration_string().c_str()); m_database_name = database_name; m_sql = sql; std::vector<column_info> column_infos; sqlite3* db_handle = sqlite3_db_handle(m_data); char const* data_type = NULL; char const* coll_seq = NULL; int not_null = 0; int primary_key = 0; int auto_inc = 0; for (int i = 0; i < m_column_count; ++i) { std::string column_name = sqlite3_column_origin_name(m_data, i); int result_code = sqlite3_table_column_metadata( db_handle, sqlite3_column_database_name(m_data, i), sqlite3_column_table_name(m_data, i), column_name.c_str(), &data_type, &coll_seq, ¬_null, &primary_key, &auto_inc); if (result_code != SQLITE_OK) { //TODO: do something with the error...this error can only be an internal db error } if (i + 1 != m_time_column) { std::string type(data_type); column_info info(column_name, m_source_name, get_data_type(data_type)); column_infos.push_back(info); } } m_stream_schema = stream_schema_ptr(new stream_schema(m_source_name, column_infos)); }
const char *StatementHandle::getColumnTableName(int index) { return sqlite3_column_table_name((sqlite3_stmt *) m_stmt, index); }
void OGRGeoPackageLayer::BuildFeatureDefn( const char *pszLayerName, sqlite3_stmt *hStmt ) { m_poFeatureDefn = new OGRSQLiteFeatureDefn( pszLayerName ); SetDescription( m_poFeatureDefn->GetName() ); m_poFeatureDefn->SetGeomType(wkbNone); m_poFeatureDefn->Reference(); int nRawColumns = sqlite3_column_count( hStmt ); panFieldOrdinals = (int *) CPLMalloc( sizeof(int) * nRawColumns ); int iCol; for( iCol = 0; iCol < nRawColumns; iCol++ ) { OGRFieldDefn oField( OGRSQLiteParamsUnquote(sqlite3_column_name( hStmt, iCol )), OFTString ); // In some cases, particularly when there is a real name for // the primary key/_rowid_ column we will end up getting the // primary key column appearing twice. Ignore any repeated names. if( m_poFeatureDefn->GetFieldIndex( oField.GetNameRef() ) != -1 ) continue; if( EQUAL(oField.GetNameRef(), "FID") ) { CPLFree(m_pszFidColumn); m_pszFidColumn = CPLStrdup(oField.GetNameRef()); iFIDCol = iCol; } if( m_pszFidColumn != NULL && EQUAL(m_pszFidColumn, oField.GetNameRef())) continue; // The rowid is for internal use, not a real column. if( EQUAL(oField.GetNameRef(),"_rowid_") ) continue; // this will avoid the old geom field to appear when running something // like "select st_buffer(geom,5) as geom, * from my_layer" if( m_poFeatureDefn->GetGeomFieldCount() && EQUAL(oField.GetNameRef(), m_poFeatureDefn->GetGeomFieldDefn(0)->GetNameRef()) ) continue; int nColType = sqlite3_column_type( hStmt, iCol ); const char * pszDeclType = sqlite3_column_decltype(hStmt, iCol); // Recognize a geometry column from trying to build the geometry // Useful for OGRSQLiteSelectLayer if( nColType == SQLITE_BLOB && m_poFeatureDefn->GetGeomFieldCount() == 0 ) { const int nBytes = sqlite3_column_bytes( hStmt, iCol ); if( nBytes > 4 ) { int iGpkgSize = sqlite3_column_bytes(hStmt, iCol); const GByte* pabyGpkg = (const GByte*)sqlite3_column_blob( hStmt, iCol ); GPkgHeader oHeader; OGRGeometry* poGeom = NULL; int nSRID; if( GPkgHeaderFromWKB(pabyGpkg, &oHeader) == OGRERR_NONE ) { OGRGeomFieldDefn oGeomField(oField.GetNameRef(), wkbUnknown); /* Read the SRS */ OGRSpatialReference *poSRS = m_poDS->GetSpatialRef(oHeader.iSrsId); if ( poSRS ) { oGeomField.SetSpatialRef(poSRS); poSRS->Dereference(); } OGRwkbGeometryType eGeomType = wkbUnknown; if( pszDeclType != NULL ) { eGeomType = GPkgGeometryTypeToWKB(pszDeclType, (oHeader.iDims == 3)); if( eGeomType != wkbNone ) oGeomField.SetType( eGeomType ); } #ifdef SQLITE_HAS_COLUMN_METADATA const char* pszTableName = sqlite3_column_table_name( hStmt, iCol ); if( oGeomField.GetType() == wkbUnknown && pszTableName != NULL ) { OGRGeoPackageLayer* poLayer = (OGRGeoPackageLayer*) m_poDS->GetLayerByName(pszTableName); if( poLayer != NULL && poLayer->GetLayerDefn()->GetGeomFieldCount() > 0) { oGeomField.SetType( poLayer->GetLayerDefn()->GetGeomFieldDefn(0)->GetType() ); } } #endif m_poFeatureDefn->AddGeomFieldDefn(&oGeomField); iGeomCol = iCol; continue; } // Try also spatialite geometry blobs else if( OGRSQLiteLayer::ImportSpatiaLiteGeometry( pabyGpkg, iGpkgSize, &poGeom, &nSRID ) == OGRERR_NONE ) { OGRGeomFieldDefn oGeomField(oField.GetNameRef(), wkbUnknown); /* Read the SRS */ OGRSpatialReference *poSRS = m_poDS->GetSpatialRef(nSRID); if ( poSRS ) { oGeomField.SetSpatialRef(poSRS); poSRS->Dereference(); } delete poGeom; m_poFeatureDefn->AddGeomFieldDefn(&oGeomField); iGeomCol = iCol; continue; } } } switch( nColType ) { case SQLITE_INTEGER: if( CSLTestBoolean(CPLGetConfigOption("OGR_PROMOTE_TO_INTEGER64", "FALSE")) ) oField.SetType( OFTInteger64 ); else { GIntBig nVal = sqlite3_column_int64(hStmt, iCol); if( (GIntBig)(int)nVal == nVal ) oField.SetType( OFTInteger ); else oField.SetType( OFTInteger64 ); } break; case SQLITE_FLOAT: oField.SetType( OFTReal ); break; case SQLITE_BLOB: oField.SetType( OFTBinary ); break; default: /* leave it as OFTString */; } if (pszDeclType != NULL) { OGRFieldSubType eSubType; int nMaxWidth; OGRFieldType eFieldType = GPkgFieldToOGR(pszDeclType, eSubType, nMaxWidth); if( (int)eFieldType <= OFTMaxType ) { oField.SetType(eFieldType); oField.SetSubType(eSubType); oField.SetWidth(nMaxWidth); } } m_poFeatureDefn->AddFieldDefn( &oField ); panFieldOrdinals[m_poFeatureDefn->GetFieldCount() - 1] = iCol; } }
//----------------------------------------------------------------// cc8* USSqlStatement::GetColumnTableName ( u32 iCol ) { assert ( this->mStatement ); return sqlite3_column_table_name ( this->mStatement, iCol ); }
__declspec(dllexport) const char * WINAPI sqlite3_column_table_name_interop(sqlite3_stmt *stmt, int iCol, int *plen) { const char *pval = sqlite3_column_table_name(stmt, iCol); *plen = (pval != 0) ? strlen(pval) : 0; return pval; }
OGRSQLiteSelectLayer::OGRSQLiteSelectLayer( OGRSQLiteDataSource *poDSIn, CPLString osSQLIn, sqlite3_stmt *hStmtIn, int bUseStatementForGetNextFeature, int bEmptyLayer, int bAllowMultipleGeomFieldsIn ) { poBehaviour = new OGRSQLiteSelectLayerCommonBehaviour(poDSIn, this, osSQLIn, bEmptyLayer); poDS = poDSIn; this->bAllowMultipleGeomFields = bAllowMultipleGeomFieldsIn; std::set<CPLString> aosEmpty; BuildFeatureDefn( "SELECT", hStmtIn, aosEmpty, aosEmpty ); SetDescription( "SELECT" ); if( bUseStatementForGetNextFeature ) { hStmt = hStmtIn; bDoStep = FALSE; // Try to extract SRS from first geometry for( int iField = 0; !bEmptyLayer && iField < poFeatureDefn->GetGeomFieldCount(); iField ++) { OGRSQLiteGeomFieldDefn* poGeomFieldDefn = poFeatureDefn->myGetGeomFieldDefn(iField); if( wkbFlatten(poGeomFieldDefn->GetType()) != wkbUnknown ) continue; int nBytes; if( sqlite3_column_type( hStmt, poGeomFieldDefn->iCol ) == SQLITE_BLOB && (nBytes = sqlite3_column_bytes( hStmt, poGeomFieldDefn->iCol )) > 39 ) { const GByte* pabyBlob = (const GByte*)sqlite3_column_blob( hStmt, poGeomFieldDefn->iCol ); int eByteOrder = pabyBlob[1]; if( pabyBlob[0] == 0x00 && (eByteOrder == wkbNDR || eByteOrder == wkbXDR) && pabyBlob[38] == 0x7C ) { int nSRSId; memcpy(&nSRSId, pabyBlob + 2, 4); #ifdef CPL_LSB if( eByteOrder != wkbNDR) CPL_SWAP32PTR(&nSRSId); #else if( eByteOrder == wkbNDR) CPL_SWAP32PTR(&nSRSId); #endif CPLPushErrorHandler(CPLQuietErrorHandler); OGRSpatialReference* poSRS = poDS->FetchSRS( nSRSId ); CPLPopErrorHandler(); if( poSRS != NULL ) { poGeomFieldDefn->nSRSId = nSRSId; poGeomFieldDefn->SetSpatialRef(poSRS); } else CPLErrorReset(); } #ifdef SQLITE_HAS_COLUMN_METADATA else if( iField == 0 ) { const char* pszTableName = sqlite3_column_table_name( hStmt, poGeomFieldDefn->iCol ); if( pszTableName != NULL ) { OGRSQLiteLayer* poLayer = (OGRSQLiteLayer*) poDS->GetLayerByName(pszTableName); if( poLayer != NULL && poLayer->GetLayerDefn()->GetGeomFieldCount() > 0) { OGRSQLiteGeomFieldDefn* poSrcGFldDefn = poLayer->myGetLayerDefn()->myGetGeomFieldDefn(0); poGeomFieldDefn->nSRSId = poSrcGFldDefn->nSRSId; poGeomFieldDefn->SetSpatialRef(poSrcGFldDefn->GetSpatialRef()); } } } #endif } } } else sqlite3_finalize( hStmtIn ); }
const char* Database::Query::getTableName(int column) { return _stmt ? sqlite3_column_table_name(_stmt, column) : ""; }
OGRSQLiteSelectLayer::OGRSQLiteSelectLayer( OGRSQLiteDataSource *poDSIn, CPLString osSQLIn, sqlite3_stmt *hStmtIn, int bUseStatementForGetNextFeature, int bEmptyLayer ) { poDS = poDSIn; iNextShapeId = 0; poFeatureDefn = NULL; bAllowResetReadingEvenIfIndexAtZero = FALSE; std::set<CPLString> aosEmpty; BuildFeatureDefn( "SELECT", hStmtIn, aosEmpty ); if( bUseStatementForGetNextFeature ) { hStmt = hStmtIn; bDoStep = FALSE; // Try to extract SRS from first geometry if( !bEmptyLayer && osGeomColumn.size() != 0 ) { int nRawColumns = sqlite3_column_count( hStmt ); for( int iCol = 0; iCol < nRawColumns; iCol++ ) { int nBytes; if( sqlite3_column_type( hStmt, iCol ) == SQLITE_BLOB && strcmp(OGRSQLiteParamsUnquote(sqlite3_column_name( hStmt, iCol )).c_str(), osGeomColumn.c_str()) == 0 && (nBytes = sqlite3_column_bytes( hStmt, iCol )) > 39 ) { const GByte* pabyBlob = (const GByte*)sqlite3_column_blob( hStmt, iCol ); int eByteOrder = pabyBlob[1]; if( pabyBlob[0] == 0x00 && (eByteOrder == wkbNDR || eByteOrder == wkbXDR) && pabyBlob[38] == 0x7C ) { memcpy(&nSRSId, pabyBlob + 2, 4); #ifdef CPL_LSB if( eByteOrder != wkbNDR) CPL_SWAP32PTR(&nSRSId); #else if( eByteOrder == wkbNDR) CPL_SWAP32PTR(&nSRSId); #endif CPLPushErrorHandler(CPLQuietErrorHandler); poSRS = poDS->FetchSRS( nSRSId ); CPLPopErrorHandler(); if( poSRS != NULL ) poSRS->Reference(); else CPLErrorReset(); } #ifdef SQLITE_HAS_COLUMN_METADATA else { const char* pszTableName = sqlite3_column_table_name( hStmt, iCol ); if( pszTableName != NULL ) { OGRLayer* poLayer = poDS->GetLayerByName(pszTableName); if( poLayer != NULL ) { poSRS = poLayer->GetSpatialRef(); if( poSRS != NULL ) poSRS->Reference(); } } } #endif break; } } } } else sqlite3_finalize( hStmtIn ); osSQLBase = osSQLIn; osSQLCurrent = osSQLIn; this->bEmptyLayer = bEmptyLayer; bSpatialFilterInSQL = TRUE; }
static void DoTestStatement() { int err, val; sqlite_int64 val64; double dblval; const unsigned char* textval; const unsigned short* textval16; const unsigned char* blob; const char *coltype, *colname; const unsigned short *coltype16, *colname16; sqlite3* db; TEST(TheDb != 0); TEST(TheStmt != 0); val = sqlite3_column_count(TheStmt); TEST2(val, 5); db = sqlite3_db_handle(TheStmt); TEST2((unsigned int)db, (unsigned int)TheDb); err = sqlite3_step(TheStmt); TEST2(err, SQLITE_ROW); #ifdef SQLITE_ENABLE_COLUMN_METADATA sqlite3_column_database_name(TheStmt, 0); sqlite3_column_database_name16(TheStmt, 1); sqlite3_column_table_name(TheStmt, 2); sqlite3_column_table_name16(TheStmt, 3); sqlite3_column_origin_name(TheStmt, 4); sqlite3_column_origin_name16(TheStmt, 0); #endif coltype = sqlite3_column_decltype(TheStmt, 0); TEST2(strcmp(coltype, "INTEGER"), 0); coltype16 = (const unsigned short*)sqlite3_column_decltype16(TheStmt, 2); TEST2(wcscmp(coltype16, L"REAL"), 0); colname = sqlite3_column_name(TheStmt, 1); TEST2(strcmp(colname, "F2"), 0); colname16 = (const unsigned short *)sqlite3_column_name16(TheStmt, 4); TEST2(wcscmp(colname16, L"F5"), 0); val = sqlite3_column_int(TheStmt, 0); TEST2(val, 1); val64 = sqlite3_column_int64(TheStmt, 1); TEST64(val64, 1234567891234LL); dblval = sqlite3_column_double(TheStmt, 2); TEST(dabs(dblval - 56.12) < 0.00001); textval = sqlite3_column_text(TheStmt, 3); TEST2(strcmp((const char*)textval, "TEXT"), 0); textval16 = sqlite3_column_text16(TheStmt, 3); TEST2(wcscmp(textval16, L"TEXT"), 0); blob = (const unsigned char*)sqlite3_column_blob(TheStmt, 4); TEST2(memcmp(blob, "123456", 6), 0); err = sqlite3_step(TheStmt); TEST2(err, SQLITE_DONE); }
void OGRGeoPackageLayer::BuildFeatureDefn( const char *pszLayerName, sqlite3_stmt *hStmt ) { m_poFeatureDefn = new OGRSQLiteFeatureDefn( pszLayerName ); SetDescription( m_poFeatureDefn->GetName() ); m_poFeatureDefn->SetGeomType(wkbNone); m_poFeatureDefn->Reference(); int nRawColumns = sqlite3_column_count( hStmt ); panFieldOrdinals = (int *) CPLMalloc( sizeof(int) * nRawColumns ); int iCol; for( iCol = 0; iCol < nRawColumns; iCol++ ) { OGRFieldDefn oField( OGRSQLiteParamsUnquote(sqlite3_column_name( hStmt, iCol )), OFTString ); // In some cases, particularly when there is a real name for // the primary key/_rowid_ column we will end up getting the // primary key column appearing twice. Ignore any repeated names. if( m_poFeatureDefn->GetFieldIndex( oField.GetNameRef() ) != -1 ) continue; if( EQUAL(oField.GetNameRef(), "FID") ) { CPLFree(m_pszFidColumn); m_pszFidColumn = CPLStrdup(oField.GetNameRef()); iFIDCol = iCol; } if( m_pszFidColumn != NULL && EQUAL(m_pszFidColumn, oField.GetNameRef())) continue; // The rowid is for internal use, not a real column. if( EQUAL(oField.GetNameRef(),"_rowid_") ) continue; int nColType = sqlite3_column_type( hStmt, iCol ); const char * pszDeclType = sqlite3_column_decltype(hStmt, iCol); // Recognize a geometry column from trying to build the geometry // Usefull for OGRSQLiteSelectLayer if( nColType == SQLITE_BLOB && m_poFeatureDefn->GetGeomFieldCount() == 0 ) { const int nBytes = sqlite3_column_bytes( hStmt, iCol ); if( nBytes > 4 ) { const GByte* pabyGpkg = (const GByte*)sqlite3_column_blob( hStmt, iCol ); GPkgHeader oHeader; if( GPkgHeaderFromWKB(pabyGpkg, &oHeader) == OGRERR_NONE ) { OGRGeomFieldDefn oGeomField(oField.GetNameRef(), wkbUnknown); /* Read the SRS */ OGRSpatialReference *poSRS = m_poDS->GetSpatialRef(oHeader.iSrsId); if ( poSRS ) { oGeomField.SetSpatialRef(poSRS); poSRS->Dereference(); } OGRwkbGeometryType eGeomType = wkbUnknown; if( pszDeclType != NULL ) { eGeomType = GPkgGeometryTypeToWKB(pszDeclType, (oHeader.iDims == 3)); if( eGeomType != wkbNone ) oGeomField.SetType( eGeomType ); } #ifdef SQLITE_HAS_COLUMN_METADATA const char* pszTableName = sqlite3_column_table_name( hStmt, iCol ); if( oGeomField.GetType() == wkbUnknown && pszTableName != NULL ) { OGRGeoPackageLayer* poLayer = (OGRGeoPackageLayer*) m_poDS->GetLayerByName(pszTableName); if( poLayer != NULL && poLayer->GetLayerDefn()->GetGeomFieldCount() > 0) { oGeomField.SetType( poLayer->GetLayerDefn()->GetGeomFieldDefn(0)->GetType() ); } } #endif m_poFeatureDefn->AddGeomFieldDefn(&oGeomField); iGeomCol = iCol; continue; } } } switch( nColType ) { case SQLITE_INTEGER: oField.SetType( OFTInteger ); break; case SQLITE_FLOAT: oField.SetType( OFTReal ); break; case SQLITE_BLOB: oField.SetType( OFTBinary ); break; default: /* leave it as OFTString */; } if (pszDeclType != NULL) { OGRFieldType eFieldType = GPkgFieldToOGR(pszDeclType); if( (int)eFieldType <= OFTMaxType ) oField.SetType(eFieldType); } m_poFeatureDefn->AddFieldDefn( &oField ); panFieldOrdinals[m_poFeatureDefn->GetFieldCount() - 1] = iCol; } }