int main (int argc, char *argv[])
{
if (strcmp(spatialite_version(), VERSION) != 0) {
fprintf(stderr, "SpatiaLite version mismatch: %s and %s\n",
VERSION, spatialite_version());
return -1;
}
return 0;
}
int main (int argc, char *argv[])
{
if (argc > 1 || argv[0] == NULL)
argc = 1; /* silencing stupid compiler warnings */
if (strcmp(spatialite_version(), VERSION) != 0) {
fprintf(stderr, "SpatiaLite version mismatch: %s and %s\n",
VERSION, spatialite_version());
return -1;
}
return 0;
}
std::string SpatiaLiteDB::version() {
std::stringstream s;
s << SQLiteDB::version() << ", ";
s << "SpatiaLite version: " << spatialite_version();
return s.str();
}
string WrapperSpatialite::versions(void) const
{
return string("SQLite3 version ") + sqlite3_libversion() + "\n" +
"Spatialite version " + spatialite_version() + "\n";
// "Proj4 version " + proj4_version() + "\n" +
// "Geos version " + geos_version() + "\n";
}
SpatialiteBackend::SpatialiteBackend(const QString& filename)
: SpatialiteBase(), p(new SpatialBackendPrivate)
{
/*
VERY IMPORTANT:
you must initialize the SpatiaLite extension [and related]
BEFORE attempting to perform any other SQLite call
*/
spatialite_init (0);
/* showing the SQLite version */
qDebug ("SQLite version: %s", sqlite3_libversion ());
/* showing the SpatiaLite version */
qDebug ("SpatiaLite version: %s", spatialite_version ());
isTemp = false;
theFilename = filename;
open(theFilename, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
InitializeNew();
}
SpatialiteBackend::SpatialiteBackend()
: SpatialiteBase(), p(new SpatialBackendPrivate)
{
/*
VERY IMPORTANT:
you must initialize the SpatiaLite extension [and related]
BEFORE attempting to perform any other SQLite call
*/
spatialite_init (0);
/* showing the SQLite version */
qDebug ("SQLite version: %s", sqlite3_libversion ());
/* showing the SpatiaLite version */
qDebug ("SpatiaLite version: %s", spatialite_version ());
isTemp = true;
theFilename = HOMEDIR + "/" + QDateTime::currentDateTime().toString("yyyyMMdd-hhmmsszzz") + ".spatialite";
open(HOMEDIR + "/temDb.spatialite", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
InitializeNew();
}
int
main (int argc, char *argv[])
{
int ret;
sqlite3 *handle;
sqlite3_stmt *stmt;
gaiaGeomCollPtr geom;
char sql[256];
int i;
int ic;
char **results;
int n_rows;
int n_columns;
char *err_msg = NULL;
int len;
char *table_name;
char **p_geotables = NULL;
int n_geotables = 0;
int row_no;
const void *blob;
int blob_size;
int geom_type;
double measure;
void *cache;
if (argc != 2)
{
fprintf (stderr, "usage: %s test_db_path\n", argv[0]);
return -1;
}
/*
trying to connect the test DB:
- this demo was designed in order to connect the standard
TEST-2.3.SQLITE sample DB
- but you can try to use any SQLite/SpatiaLite DB at your will
Please notice: we'll establish a READ ONLY connection
*/
ret = sqlite3_open_v2 (argv[1], &handle, SQLITE_OPEN_READONLY, NULL);
if (ret != SQLITE_OK)
{
printf ("cannot open '%s': %s\n", argv[1], sqlite3_errmsg (handle));
sqlite3_close (handle);
return -1;
}
/*
VERY IMPORTANT:
you must initialize the SpatiaLite extension [and related]
BEFORE attempting to perform any other SQLite call
==========================================================
Please note: starting since 4.1.0 this is completely canged:
- a separate memory block (internal cache) is required by
each single connection
- allocating/freeing this block falls under the responsibility
of the program handling the connection
- in multithreaded programs a connection can never be share by
different threads; the internal-cache block must be allocated
by the same thread holding the connection
*/
cache = spatialite_alloc_connection ();
spatialite_init_ex (handle, cache, 0);
/* showing the SQLite version */
printf ("SQLite version: %s\n", sqlite3_libversion ());
/* showing the SpatiaLite version */
printf ("SpatiaLite version: %s\n", spatialite_version ());
printf ("\n\n");
/*
SQL query #1
we'll retrieve GEOMETRY tables from Spatial Metadata
we are assuming this query will return only few rows,
so this time we'll use the sqlite3_get_table() interface
this interface is very simple to use
the result set is returned as a rectangular array [rows/columns]
allocated in a temporary memory storage
so, this interface is well suited for small sized result sets,
but performs badly when accessing a large sized resul set
as a side effect, each column value is returned as text, and
isn't possible at all to retrieve true column types
(INTEGER, FLOAT ...)
*/
strcpy (sql,
"SELECT DISTINCT f_table_name FROM geometry_columns ORDER BY 1");
ret = sqlite3_get_table (handle, sql, &results, &n_rows, &n_columns,
&err_msg);
if (ret != SQLITE_OK)
{
/* some error occurred */
printf ("query#1 SQL error: %s\n", err_msg);
sqlite3_free (err_msg);
goto abort;
}
if (n_rows > 1)
{
/* first row always contains column names and is meaningless in this context */
n_geotables = n_rows;
/* allocating a dynamic pointer array to store geotable names */
p_geotables = malloc (sizeof (char *) * n_geotables);
for (i = 1; i <= n_rows; i++)
{
/*
now we'll fetch one row at each time [and we have only one column to fetch]
this one is is a simplified demo; but when writing a real application
you always must check for NULL values !!!!
*/
table_name = results[(i * n_columns) + 0];
/* and we'll store each geotable name into the dynamic pointer array */
len = strlen (table_name);
p_geotables[i - 1] = malloc (len + 1);
strcpy (p_geotables[i - 1], table_name);
}
/* we can now free the table results */
sqlite3_free_table (results);
}
for (i = 0; i < n_geotables; i++)
{
/* now we'll scan each geotable we've found in Spatial Metadata */
printf ("========= table '%s' ========================\n",
p_geotables[i]);
/*
SQL query #2
we'll retrieve any column from the current geotable
we are assuming this query will return lots of rows,
so we have to use sqlite3_prepare_v2() interface
this interface is a more complex one, but is well
suited in order to access huge sized result sets
and true value type control is supported
*/
sprintf (sql, "SELECT * FROM %s", p_geotables[i]);
ret = sqlite3_prepare_v2 (handle, sql, strlen (sql), &stmt, NULL);
if (ret != SQLITE_OK)
{
/* some error occurred */
printf ("query#2 SQL error: %s\n", sqlite3_errmsg (handle));
goto abort;
}
/*
the sqlite3_prepare_v2() call simply parses the SQL statement,
checking for syntax validity, allocating internal structs etc
but no result set row is really yet available
*/
/* we'll now save the #columns within the result set */
n_columns = sqlite3_column_count (stmt);
row_no = 0;
while (1)
{
/* this is an infinite loop, intended to fetch any row */
/* we are now trying to fetch the next available row */
ret = sqlite3_step (stmt);
if (ret == SQLITE_DONE)
{
/* there are no more rows to fetch - we can stop looping */
break;
}
if (ret == SQLITE_ROW)
{
/* ok, we've just fetched a valid row to process */
row_no++;
printf ("row #%d\n", row_no);
for (ic = 0; ic < n_columns; ic++)
{
/*
and now we'll fetch column values
for each column we'll then get:
- the column name
- a column value, that can be of type: SQLITE_NULL, SQLITE_INTEGER,
SQLITE_FLOAT, SQLITE_TEXT or SQLITE_BLOB, according to internal DB storage type
*/
printf ("\t%-10s = ",
sqlite3_column_name (stmt, ic));
switch (sqlite3_column_type (stmt, ic))
{
case SQLITE_NULL:
printf ("NULL");
break;
case SQLITE_INTEGER:
printf ("%d", sqlite3_column_int (stmt, ic));
break;
case SQLITE_FLOAT:
printf ("%1.4f",
sqlite3_column_double (stmt, ic));
break;
case SQLITE_TEXT:
printf ("'%s'",
sqlite3_column_text (stmt, ic));
break;
case SQLITE_BLOB:
blob = sqlite3_column_blob (stmt, ic);
blob_size = sqlite3_column_bytes (stmt, ic);
/* checking if this BLOB actually is a GEOMETRY */
geom =
gaiaFromSpatiaLiteBlobWkb (blob,
blob_size);
if (!geom)
{
/* for sure this one is not a GEOMETRY */
printf ("BLOB [%d bytes]", blob_size);
}
else
{
geom_type = gaiaGeometryType (geom);
if (geom_type == GAIA_UNKNOWN)
printf ("EMPTY or NULL GEOMETRY");
else
{
char *geom_name;
if (geom_type == GAIA_POINT)
geom_name = "POINT";
if (geom_type == GAIA_LINESTRING)
geom_name = "LINESTRING";
if (geom_type == GAIA_POLYGON)
geom_name = "POLYGON";
if (geom_type == GAIA_MULTIPOINT)
geom_name = "MULTIPOINT";
if (geom_type ==
GAIA_MULTILINESTRING)
geom_name = "MULTILINESTRING";
if (geom_type ==
GAIA_MULTIPOLYGON)
geom_name = "MULTIPOLYGON";
if (geom_type ==
GAIA_GEOMETRYCOLLECTION)
geom_name =
"GEOMETRYCOLLECTION";
printf ("%s SRID=%d", geom_name,
geom->Srid);
if (geom_type == GAIA_LINESTRING
|| geom_type ==
GAIA_MULTILINESTRING)
{
#ifndef OMIT_GEOS /* GEOS is required */
gaiaGeomCollLength (geom,
&measure);
printf (" length=%1.2f",
measure);
#else
printf
(" length=?? [no GEOS support available]");
#endif /* GEOS enabled/disabled */
}
if (geom_type == GAIA_POLYGON ||
geom_type ==
GAIA_MULTIPOLYGON)
{
#ifndef OMIT_GEOS /* GEOS is required */
gaiaGeomCollArea (geom,
&measure);
printf (" area=%1.2f",
measure);
#else
printf
("area=?? [no GEOS support available]");
#endif /* GEOS enabled/disabled */
}
}
/* we have now to free the GEOMETRY */
gaiaFreeGeomColl (geom);
}
break;
};
printf ("\n");
}
if (row_no >= 5)
{
/* we'll exit the loop after the first 5 rows - this is only a demo :-) */
break;
}
}
else
{
/* some unexpected error occurred */
printf ("sqlite3_step() error: %s\n",
sqlite3_errmsg (handle));
sqlite3_finalize (stmt);
goto abort;
}
}
/* we have now to finalize the query [memory cleanup] */
sqlite3_finalize (stmt);
printf ("\n\n");
}
/* disconnecting the test DB */
ret = sqlite3_close (handle);
if (ret != SQLITE_OK)
{
printf ("close() error: %s\n", sqlite3_errmsg (handle));
return -1;
}
/* freeing the internal-cache memory block */
spatialite_cleanup_ex (cache);
printf ("\n\nsample successfully terminated\n");
/* we have to free the dynamic pointer array used to store geotable names */
for (i = 0; i < n_geotables; i++)
{
/* freeing each tablename */
free (p_geotables[i]);
}
free (p_geotables);
spatialite_shutdown();
return 0;
abort:
sqlite3_close (handle);
/* freeing the internal-cache memory block */
spatialite_cleanup_ex (cache);
if (p_geotables)
{
/* we have to free the dynamic pointer array used to store geotable names */
for (i = 0; i < n_geotables; i++)
{
/* freeing each tablename */
free (p_geotables[i]);
}
free (p_geotables);
}
spatialite_shutdown();
return -1;
}
int
main (int argc, char *argv[])
{
int ret;
sqlite3 *handle;
sqlite3_stmt *stmt;
char sql[256];
char *err_msg = NULL;
double x;
double y;
int pk;
int ix;
int iy;
gaiaGeomCollPtr geo = NULL;
unsigned char *blob;
int blob_size;
int i;
char **results;
int n_rows;
int n_columns;
char *count;
clock_t t0;
clock_t t1;
void *cache;
if (argc != 2)
{
fprintf (stderr, "usage: %s test_db_path\n", argv[0]);
return -1;
}
/*
trying to connect the test DB:
- this demo is intended to create a new, empty database
*/
ret = sqlite3_open_v2 (argv[1], &handle,
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
if (ret != SQLITE_OK)
{
printf ("cannot open '%s': %s\n", argv[1], sqlite3_errmsg (handle));
sqlite3_close (handle);
return -1;
}
cache = spatialite_alloc_connection ();
spatialite_init_ex (handle, cache, 0);
/* showing the SQLite version */
printf ("SQLite version: %s\n", sqlite3_libversion ());
/* showing the SpatiaLite version */
printf ("SpatiaLite version: %s\n", spatialite_version ());
printf ("\n\n");
/*
we are supposing this one is an empty database,
so we have to create the Spatial Metadata
*/
strcpy (sql, "SELECT InitSpatialMetadata(1)");
ret = sqlite3_exec (handle, sql, NULL, NULL, &err_msg);
if (ret != SQLITE_OK)
{
/* an error occurred */
printf ("InitSpatialMetadata() error: %s\n", err_msg);
sqlite3_free (err_msg);
goto abort;
}
/*
now we can create the test table
for simplicity we'll define only one column, the primary key
*/
strcpy (sql, "CREATE TABLE test (");
strcat (sql, "PK INTEGER NOT NULL PRIMARY KEY)");
ret = sqlite3_exec (handle, sql, NULL, NULL, &err_msg);
if (ret != SQLITE_OK)
{
/* an error occurred */
printf ("CREATE TABLE 'test' error: %s\n", err_msg);
sqlite3_free (err_msg);
goto abort;
}
/*
... we'll add a Geometry column of POINT type to the test table
*/
strcpy (sql, "SELECT AddGeometryColumn('test', 'geom', 3003, 'POINT', 2)");
ret = sqlite3_exec (handle, sql, NULL, NULL, &err_msg);
if (ret != SQLITE_OK)
{
/* an error occurred */
printf ("AddGeometryColumn() error: %s\n", err_msg);
sqlite3_free (err_msg);
goto abort;
}
/*
and finally we'll enable this geo-column to have a Spatial Index based on R*Tree
*/
strcpy (sql, "SELECT CreateSpatialIndex('test', 'geom')");
ret = sqlite3_exec (handle, sql, NULL, NULL, &err_msg);
if (ret != SQLITE_OK)
{
/* an error occurred */
printf ("CreateSpatialIndex() error: %s\n", err_msg);
sqlite3_free (err_msg);
goto abort;
}
printf
("\nnow we are going to insert 1 million POINTs; wait, please ...\n\n");
t0 = clock ();
/*
beginning a transaction
*** this step is absolutely critical ***
the SQLite engine is a TRANSACTIONAL one
the whole batch of INSERTs has to be performed as an unique transaction,
otherwise performance will be surely very poor
*/
strcpy (sql, "BEGIN");
ret = sqlite3_exec (handle, sql, NULL, NULL, &err_msg);
if (ret != SQLITE_OK)
{
/* an error occurred */
printf ("BEGIN error: %s\n", err_msg);
sqlite3_free (err_msg);
goto abort;
}
/*
preparing to populate the test table
we'll use a Prepared Statement we can reuse in order to insert each row
*/
strcpy (sql, "INSERT INTO test (pk, geom) VALUES (?, ?)");
ret = sqlite3_prepare_v2 (handle, sql, strlen (sql), &stmt, NULL);
if (ret != SQLITE_OK)
{
/* an error occurred */
printf ("INSERT SQL error: %s\n", sqlite3_errmsg (handle));
goto abort;
}
pk = 0;
for (ix = 0; ix < 1000; ix++)
{
x = 1000000.0 + (ix * 10.0);
for (iy = 0; iy < 1000; iy++)
{
/* this double loop will insert 1 million rows into the the test table */
y = 4000000.0 + (iy * 10.0);
pk++;
if ((pk % 25000) == 0)
{
t1 = clock ();
printf ("insert row: %d\t\t[elapsed time: %1.3f]\n",
pk, (double) (t1 - t0) / CLOCKS_PER_SEC);
}
/* preparing the geometry to insert */
geo = gaiaAllocGeomColl ();
geo->Srid = 3003;
gaiaAddPointToGeomColl (geo, x, y);
/* transforming this geometry into the SpatiaLite BLOB format */
gaiaToSpatiaLiteBlobWkb (geo, &blob, &blob_size);
/* we can now destroy the geometry object */
gaiaFreeGeomColl (geo);
/* resetting Prepared Statement and bindings */
sqlite3_reset (stmt);
sqlite3_clear_bindings (stmt);
/* binding parameters to Prepared Statement */
sqlite3_bind_int64 (stmt, 1, pk);
sqlite3_bind_blob (stmt, 2, blob, blob_size, free);
/* performing actual row insert */
ret = sqlite3_step (stmt);
if (ret == SQLITE_DONE || ret == SQLITE_ROW)
;
else
{
/* an unexpected error occurred */
printf ("sqlite3_step() error: %s\n",
sqlite3_errmsg (handle));
sqlite3_finalize (stmt);
goto abort;
}
}
}
/* we have now to finalize the query [memory cleanup] */
sqlite3_finalize (stmt);
/*
committing the transaction
*** this step is absolutely critical ***
if we don't confirm the still pending transaction,
any update will be lost
*/
strcpy (sql, "COMMIT");
ret = sqlite3_exec (handle, sql, NULL, NULL, &err_msg);
if (ret != SQLITE_OK)
{
/* an error occurred */
printf ("COMMIT error: %s\n", err_msg);
sqlite3_free (err_msg);
goto abort;
}
/*
now we'll optimize the table
*/
strcpy (sql, "ANALYZE test");
ret = sqlite3_exec (handle, sql, NULL, NULL, &err_msg);
if (ret != SQLITE_OK)
{
/* an error occurred */
printf ("ANALYZE error: %s\n", err_msg);
sqlite3_free (err_msg);
goto abort;
}
for (ix = 0; ix < 3; ix++)
{
printf ("\nperforming test#%d - not using Spatial Index\n", ix);
/*
now we'll perform the spatial query WITHOUT using the Spatial Index
we'll loop 3 times in order to avoid buffering-caching side effects
*/
strcpy (sql, "SELECT Count(*) FROM test ");
strcat (sql, "WHERE MbrWithin(geom, BuildMbr(");
strcat (sql, "1000400.5, 4000400.5, ");
strcat (sql, "1000450.5, 4000450.5))");
t0 = clock ();
ret = sqlite3_get_table (handle, sql, &results, &n_rows, &n_columns,
&err_msg);
if (ret != SQLITE_OK)
{
/* an error occurred */
printf ("NoSpatialIndex SQL error: %s\n", err_msg);
sqlite3_free (err_msg);
goto abort;
}
count = "";
for (i = 1; i <= n_rows; i++)
{
count = results[(i * n_columns) + 0];
}
t1 = clock ();
printf ("Count(*) = %d\t\t[elapsed time: %1.4f]\n", atoi (count),
(double) (t1 - t0) / CLOCKS_PER_SEC);
/* we can now free the table results */
sqlite3_free_table (results);
}
for (ix = 0; ix < 3; ix++)
{
printf ("\nperforming test#%d - using the R*Tree Spatial Index\n",
ix);
/*
now we'll perform the spatial query USING the R*Tree Spatial Index
we'll loop 3 times in order to avoid buffering-caching side effects
*/
strcpy (sql, "SELECT Count(*) FROM test ");
strcat (sql, "WHERE MbrWithin(geom, BuildMbr(");
strcat (sql, "1000400.5, 4000400.5, ");
strcat (sql, "1000450.5, 4000450.5)) AND ROWID IN (");
strcat (sql, "SELECT pkid FROM idx_test_geom WHERE ");
strcat (sql, "xmin > 1000400.5 AND ");
strcat (sql, "xmax < 1000450.5 AND ");
strcat (sql, "ymin > 4000400.5 AND ");
strcat (sql, "ymax < 4000450.5)");
/*
YES, this query is a very unhappy one
the idea is simply to simulate exactly the same conditions as above
*/
t0 = clock ();
ret = sqlite3_get_table (handle, sql, &results, &n_rows, &n_columns,
&err_msg);
if (ret != SQLITE_OK)
{
/* an error occurred */
printf ("SpatialIndex SQL error: %s\n", err_msg);
sqlite3_free (err_msg);
goto abort;
}
count = "";
for (i = 1; i <= n_rows; i++)
{
count = results[(i * n_columns) + 0];
}
t1 = clock ();
printf ("Count(*) = %d\t\t[elapsed time: %1.4f]\n", atoi (count),
(double) (t1 - t0) / CLOCKS_PER_SEC);
/* we can now free the table results */
sqlite3_free_table (results);
}
/* disconnecting the test DB */
ret = sqlite3_close (handle);
if (ret != SQLITE_OK)
{
printf ("close() error: %s\n", sqlite3_errmsg (handle));
return -1;
}
spatialite_cleanup_ex (cache);
printf ("\n\nsample successfully terminated\n");
return 0;
abort:
sqlite3_close (handle);
spatialite_cleanup_ex (cache);
spatialite_shutdown();
return -1;
}
// only if libspatialite version is >= 4.0.0
bool QgsSpatiaLiteConnection::getTableInfoAbstractInterface( sqlite3 *handle, bool loadGeometrylessTables )
{
int ret;
int i;
char **results = nullptr;
int rows;
int columns;
char *errMsg = nullptr;
QString sql;
gaiaVectorLayersListPtr list;
const char *version = spatialite_version();
if ( isdigit( *version ) && *version >= '4' )
; // OK, linked against libspatialite v.4.0 (or any subsequent)
else
{
mErrorMsg = tr( "obsolete libspatialite: AbstractInterface is unsupported" );
return false;
}
// attempting to load the VectorLayersList
list = gaiaGetVectorLayersList( handle, nullptr, nullptr, GAIA_VECTORS_LIST_FAST );
if ( list )
{
gaiaVectorLayerPtr lyr = list->First;
while ( lyr )
{
// populating the QGIS own Layers List
if ( lyr->AuthInfos )
{
if ( lyr->AuthInfos->IsHidden )
{
// skipping any Hidden layer
lyr = lyr->Next;
continue;
}
}
QString tableName = QString::fromUtf8( lyr->TableName );
QString column = QString::fromUtf8( lyr->GeometryName );
QString type = tr( "UNKNOWN" );
switch ( lyr->GeometryType )
{
case GAIA_VECTOR_GEOMETRY:
type = tr( "GEOMETRY" );
break;
case GAIA_VECTOR_POINT:
type = tr( "POINT" );
break;
case GAIA_VECTOR_LINESTRING:
type = tr( "LINESTRING" );
break;
case GAIA_VECTOR_POLYGON:
type = tr( "POLYGON" );
break;
case GAIA_VECTOR_MULTIPOINT:
type = tr( "MULTIPOINT" );
break;
case GAIA_VECTOR_MULTILINESTRING:
type = tr( "MULTILINESTRING" );
break;
case GAIA_VECTOR_MULTIPOLYGON:
type = tr( "MULTIPOLYGON" );
break;
case GAIA_VECTOR_GEOMETRYCOLLECTION:
type = tr( "GEOMETRYCOLLECTION" );
break;
}
mTables.append( TableEntry( tableName, column, type ) );
lyr = lyr->Next;
}
gaiaFreeVectorLayersList( list );
}
if ( loadGeometrylessTables )
{
// get all tables
sql = "SELECT name "
"FROM sqlite_master "
"WHERE type in ('table', 'view')";
ret = sqlite3_get_table( handle, sql.toUtf8(), &results, &rows, &columns, &errMsg );
if ( ret != SQLITE_OK )
goto error;
if ( rows < 1 )
;
else
{
for ( i = 1; i <= rows; i++ )
{
QString tableName = QString::fromUtf8( results[( i * columns ) + 0] );
mTables.append( TableEntry( tableName, QString(), QStringLiteral( "qgis_table" ) ) );
}
}
sqlite3_free_table( results );
}
return true;
error:
// unexpected IO error
mErrorMsg = tr( "unknown error cause" );
if ( errMsg )
{
mErrorMsg = errMsg;
sqlite3_free( errMsg );
}
return false;
}
static void
open_db (const char *path, sqlite3 ** handle, void *cache)
{
/* opening the DB */
sqlite3 *db_handle;
int ret;
char sql[1024];
int spatialite_rs = 0;
int spatialite_gc = 0;
int rs_srid = 0;
int auth_name = 0;
int auth_srid = 0;
int ref_sys_name = 0;
int proj4text = 0;
int f_table_name = 0;
int f_geometry_column = 0;
int coord_dimension = 0;
int gc_srid = 0;
int type = 0;
int geometry_type = 0;
int spatial_index_enabled = 0;
const char *name;
int i;
char **results;
int rows;
int columns;
*handle = NULL;
printf ("SQLite version: %s\n", sqlite3_libversion ());
printf ("SpatiaLite version: %s\n\n", spatialite_version ());
ret =
sqlite3_open_v2 (path, &db_handle,
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
if (ret != SQLITE_OK)
{
fprintf (stderr, "cannot open '%s': %s\n", path,
sqlite3_errmsg (db_handle));
sqlite3_close (db_handle);
db_handle = NULL;
return;
}
spatialite_init_ex (db_handle, cache, 0);
spatialite_autocreate (db_handle);
/* checking the GEOMETRY_COLUMNS table */
strcpy (sql, "PRAGMA table_info(geometry_columns)");
ret = sqlite3_get_table (db_handle, sql, &results, &rows, &columns, NULL);
if (ret != SQLITE_OK)
goto unknown;
if (rows < 1)
;
else
{
for (i = 1; i <= rows; i++)
{
name = results[(i * columns) + 1];
if (strcasecmp (name, "f_table_name") == 0)
f_table_name = 1;
if (strcasecmp (name, "f_geometry_column") == 0)
f_geometry_column = 1;
if (strcasecmp (name, "coord_dimension") == 0)
coord_dimension = 1;
if (strcasecmp (name, "srid") == 0)
gc_srid = 1;
if (strcasecmp (name, "type") == 0)
type = 1;
if (strcasecmp (name, "geometry_type") == 0)
geometry_type = 1;
if (strcasecmp (name, "spatial_index_enabled") == 0)
spatial_index_enabled = 1;
}
}
sqlite3_free_table (results);
if (f_table_name && f_geometry_column && type && coord_dimension
&& gc_srid && spatial_index_enabled)
spatialite_gc = 1;
if (f_table_name && f_geometry_column && geometry_type && coord_dimension
&& gc_srid && spatial_index_enabled)
spatialite_gc = 3;
/* checking the SPATIAL_REF_SYS table */
strcpy (sql, "PRAGMA table_info(spatial_ref_sys)");
ret = sqlite3_get_table (db_handle, sql, &results, &rows, &columns, NULL);
if (ret != SQLITE_OK)
goto unknown;
if (rows < 1)
;
else
{
for (i = 1; i <= rows; i++)
{
name = results[(i * columns) + 1];
if (strcasecmp (name, "srid") == 0)
rs_srid = 1;
if (strcasecmp (name, "auth_name") == 0)
auth_name = 1;
if (strcasecmp (name, "auth_srid") == 0)
auth_srid = 1;
if (strcasecmp (name, "ref_sys_name") == 0)
ref_sys_name = 1;
if (strcasecmp (name, "proj4text") == 0)
proj4text = 1;
}
}
sqlite3_free_table (results);
if (rs_srid && auth_name && auth_srid && ref_sys_name && proj4text)
spatialite_rs = 1;
/* verifying the MetaData format */
if (spatialite_gc && spatialite_rs)
;
else
goto unknown;
*handle = db_handle;
return;
unknown:
if (db_handle)
sqlite3_close (db_handle);
fprintf (stderr, "DB '%s'\n", path);
fprintf (stderr, "doesn't seems to contain valid Spatial Metadata ...\n\n");
fprintf (stderr, "Please, initialize Spatial Metadata\n\n");
return;
}
