/**
* Set schema version of DB
*/
void
set_schema_version( db_t hdb, int version )
{
/* Use manual binding both to seek and update. */
db_table_cursor_t p = { NULL, DB_CAN_MODIFY | DB_LOCK_EXCLUSIVE };
db_cursor_t c;
uint32_t db_version = 0;
db_bind_t row_def[] = {
DB_BIND_VAR( SCHEMA_VERSION_VERSION, DB_VARTYPE_UINT32, db_version )
};
c = db_open_table_cursor(hdb, SCHEMA_VERSION_TABLE, &p);
/* Goto 1'st row. */
if (db_seek_first(c) == DB_FAIL) {
print_error_message("DB_FAIL in set_schema_version()", c );
return;
}
if (db_eof( c )) {
db_version = version;
// No versioned DB yet. Insert row with version
if (db_qinsert( c, row_def, DB_ARRAY_DIM( row_def ), &db_version, 0 ) == DB_FAIL) {
print_error_message( "Error in set_schema_version()", c );
}
} else if ( db_version != version ) {
// Update version with a new value
db_version = version;
if (db_qupdate( c, row_def, DB_ARRAY_DIM( row_def ), NULL ) == DB_FAIL) {
print_error_message("Error in set_schema_version()", c);
}
}
(void)db_close_cursor(c);
}
int
load_data( db_t hdb )
{
db_result_t rc = DB_OK;
int i;
db_row_t row;
db_table_cursor_t p = {
NULL, //< No index
DB_CAN_MODIFY | DB_LOCK_EXCLUSIVE
};
db_cursor_t c;
c = db_open_table_cursor(hdb, STORAGE_TABLE, &p);
row = db_alloc_row( binds_def, DB_ARRAY_DIM( binds_def ) );
if( NULL == row ) {
print_error_message( "Couldn't allocate row to pupulate 'storage' table\n" );
return EXIT_FAILURE;
}
for( i = 0; i < DB_ARRAY_DIM(texts) && DB_OK == rc; ++i ) {
rc = db_insert(c, row, &texts[i], 0);
}
db_free_row( row );
rc = DB_OK == rc ? db_commit_tx( hdb, 0 ) : rc;
if( DB_OK != rc ) {
print_error_message( "Couldn't pupulate 'storage' table\n" );
}
db_close_cursor(c);
return DB_OK == rc ? EXIT_SUCCESS : EXIT_FAILURE;
}
OGRGRASSLayer::~OGRGRASSLayer()
{
if ( bCursorOpened )
{
db_close_cursor ( poCursor);
}
if ( poDriver )
{
StopDbDriver();
}
if ( pszName ) CPLFree ( pszName );
if ( poFeatureDefn )
poFeatureDefn->Release();
if ( poSRS )
poSRS->Release();
if ( pszQuery ) CPLFree ( pszQuery );
if ( paFeatureIndex ) CPLFree ( paFeatureIndex );
if ( poLink ) CPLFree ( poLink );
Vect_destroy_line_struct ( poPoints );
Vect_destroy_cats_struct ( poCats );
db_free_string ( poDbString );
CPLFree ( poDbString );
CPLFree ( poCursor );
if ( paSpatialMatch ) CPLFree ( paSpatialMatch );
if ( paQueryMatch ) CPLFree ( paQueryMatch );
}
/**
Get schema version of DB
*/
int
get_schema_version( db_t hdb )
{
/* Use manual binding both to seek and update. */
db_table_cursor_t p = { NULL, 0 };
db_cursor_t c;
uint32_t db_version = 0;
db_bind_t row_def[] = {
DB_BIND_VAR( SCHEMA_VERSION_VERSION, DB_VARTYPE_UINT32, db_version )
};
c = db_open_table_cursor(hdb, SCHEMA_VERSION_TABLE, &p);
/* Go to first row. */
if (db_seek_first(c) == DB_FAIL) {
print_error_message( "DBFAIL in get_schema_version", c );
return 0;
}
if( db_eof(c) ) {
db_version = 0;
}
else {
db_qfetch( c, row_def, DB_ARRAY_DIM(row_def), NULL );
}
(void)db_close_cursor(c);
return (int)db_version;
}
int
find_text( db_t hdb, const char * textid, const char * locale )
{
int rc = EXIT_FAILURE;
db_result_t db_rc = DB_OK;
db_row_t row;
db_cursor_t c;
db_table_cursor_t p = {
STORAGE_PKEY_INDEX_NAME, //< No index
DB_SCAN_FORWARD | DB_LOCK_EXCLUSIVE
};
char en[MAX_TEXT_LEN + 1] = {0};
char tr[MAX_TEXT_LEN + 1] = {0};
int target_fno = EN_FNO;
if( 0 == strncmp( "jp", locale, 2 ) ) {
target_fno = JP_FNO;
}
else if( 0 == strncmp( "fr", locale, 2 ) ) {
target_fno = FR_FNO;
}
else if( 0 == strncmp( "es", locale, 2 ) ) {
target_fno = ES_FNO;
}
else if( 0 == strncmp( "ru", locale, 2 ) ) {
target_fno = RU_FNO;
}
c = db_open_table_cursor(hdb, STORAGE_TABLE, &p);
row = db_alloc_row( NULL, 2 );
if( NULL == row ) {
print_error_message( "Couldn't pupulate 'storage' table\n" );
return EXIT_FAILURE;
}
dbs_bind_addr( row, ID_FNO, DB_VARTYPE_ANSISTR, (char*)textid, strlen(textid), NULL );
if( DB_OK == db_seek( c, DB_SEEK_FIRST_EQUAL, row, 0, 1 ) )
{
db_unbind_field( row, ID_FNO );
dbs_bind_addr( row, EN_FNO, DB_VARTYPE_UTF8STR, en, MAX_TEXT_LEN, NULL );
if( target_fno != EN_FNO ) {
dbs_bind_addr( row, target_fno, DB_VARTYPE_UTF8STR, tr, MAX_TEXT_LEN, NULL );
}
if( DB_OK == db_fetch( c, row, 0 ) ) {
fprintf( stdout, "Message. Id: %s, en: [%s], %s: [%s]\n",
textid, en, locale, target_fno == EN_FNO ? "" : tr
);
rc = EXIT_SUCCESS;
}
}
if( rc != EXIT_SUCCESS ) {
print_error_message( "Couldn't find translated text for messageid %s\n", textid );
}
db_free_row( row );
db_close_cursor( c );
return rc;
}
int
populate_data( db_t hdb )
{
db_result_t rc = DB_OK;
int i;
/* Populate "storage" table using relative bounds fields. See
ittiadb/manuals/users-guide/api-c-database-access.html#relative-bound-fields
*/
typedef struct {
db_ansi_t f0[MAX_STRING_FIELD + 1]; /* Extra char for null termination. */
uint64_t f1;
double f2;
char f3[MAX_STRING_FIELD*2 + 1];
} storage_t;
static const db_bind_t binds_def[] = {
{ 0, DB_VARTYPE_ANSISTR, DB_BIND_OFFSET( storage_t, f0 ), DB_BIND_SIZE( storage_t, f0 ), -1, DB_BIND_RELATIVE },
{ 1, DB_VARTYPE_SINT64, DB_BIND_OFFSET( storage_t, f1 ), DB_BIND_SIZE( storage_t, f1 ), -1, DB_BIND_RELATIVE },
{ 2, DB_VARTYPE_FLOAT64, DB_BIND_OFFSET( storage_t, f2 ), DB_BIND_SIZE( storage_t, f2 ), -1, DB_BIND_RELATIVE },
{ 3, DB_VARTYPE_UTF8STR, DB_BIND_OFFSET( storage_t, f3 ), DB_BIND_SIZE( storage_t, f3 ), -1, DB_BIND_RELATIVE },
};
static storage_t rows2ins[] = {
{ "ansi_str1", 1, 1.231, "utf8" },
{ "ansi_str2", 2, 2.231, "utf8" },
{ "ansi_str3", 3, 3.231, "УТФ-8" },
{ "ansi_str4", 4, 4.231, "utf8" },
{ "ansi_str5", 5, 5.231, "utf8" },
};
db_row_t row;
db_table_cursor_t p = {
NULL, //< No index
DB_CAN_MODIFY | DB_LOCK_EXCLUSIVE
};
db_cursor_t c;
row = db_alloc_row( binds_def, DB_ARRAY_DIM( binds_def ) );
if( NULL == row ) {
print_error_message( "Couldn't pupulate 'storage' table\n" );
return EXIT_FAILURE;
}
c = db_open_table_cursor(hdb, STORAGE_TABLE, &p);
for( i = 0; i < DB_ARRAY_DIM(rows2ins) && DB_OK == rc; ++i ) {
rc = db_insert(c, row, &rows2ins[i], 0);
}
db_free_row( row );
rc = DB_OK == rc ? db_commit_tx( hdb, 0 ) : rc;
if( DB_OK != rc ) {
print_error_message( "Couldn't pupulate 'storage' table\n" );
}
db_close_cursor(c);
return DB_OK == rc ? EXIT_SUCCESS : EXIT_FAILURE;
}
int Select(double *PartialX, double *PartialY, double *Interp,
int line_num, dbDriver * driver, char *tab_name)
{
int more;
char buf[1024];
dbString sql;
dbTable *table;
dbCursor cursor;
dbColumn *PartialX_col, *PartialY_col, *Interp_col;
dbValue *PartialX_value, *PartialY_value, *Interp_value;
db_init_string(&sql);
sprintf(buf,
"SELECT ID, Interp, X, Y FROM %s WHERE ID=%d",
tab_name, line_num);
db_append_string(&sql, buf);
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) != DB_OK)
return -1;
table = db_get_cursor_table(&cursor);
while (db_fetch(&cursor, DB_NEXT, &more) == DB_OK && more) {
Interp_col = db_get_table_column(table, 1);
PartialX_col = db_get_table_column(table, 2);
PartialY_col = db_get_table_column(table, 3);
if (db_sqltype_to_Ctype(db_get_column_sqltype(Interp_col)) ==
DB_C_TYPE_DOUBLE)
Interp_value = db_get_column_value(Interp_col);
else
continue;
if (db_sqltype_to_Ctype(db_get_column_sqltype(PartialX_col)) ==
DB_C_TYPE_DOUBLE)
PartialX_value = db_get_column_value(PartialX_col);
else
continue;
if (db_sqltype_to_Ctype(db_get_column_sqltype(PartialY_col)) ==
DB_C_TYPE_DOUBLE)
PartialY_value = db_get_column_value(PartialY_col);
else
continue;
*Interp += db_get_value_double(Interp_value);
*PartialX += db_get_value_double(PartialX_value);
*PartialY += db_get_value_double(PartialY_value);
}
db_close_cursor(&cursor);
db_free_string(&sql);
return DB_OK;
}
int
perform_transactions( db_t hdb, trans_stat_t *stat )
{
int i;
db_row_t row;
db_table_cursor_t p = {
NULL, //< No index
DB_CAN_MODIFY | DB_LOCK_EXCLUSIVE
};
db_cursor_t c;
db_result_t db_rc;
storage_t row2ins = { "ansi_str1", 1, 1.231, "utf8" };
// Allocate row. binds_def see in db_schema.h
row = db_alloc_row( binds_def, DB_ARRAY_DIM( binds_def ) );
if( NULL == row ) {
print_error_message( "Couldn't allocate db_row_t\n", NULL );
return EXIT_FAILURE;
}
// Open cursor
c = db_open_table_cursor(hdb, STORAGE_TABLE, &p);
db_rc = DB_OK;
for( i = 0; i < 100 && DB_OK == db_rc; ++i ) {
int do_lazy_commit = i % 5;
db_rc = db_begin_tx( hdb, 0 );
row2ins.f1 = i+1;
row2ins.f2 = do_lazy_commit ? 50 : 16;
db_rc = db_insert(c, row, &row2ins, 0);
db_commit_tx( hdb, do_lazy_commit ? DB_LAZY_COMPLETION : DB_DEFAULT_COMPLETION );
if( do_lazy_commit ) {
stat->lazy_tx++;
}
else {
stat->forced_tx++;
}
if( i % 30 ) {
db_flush_tx( hdb, DB_FLUSH_JOURNAL );
}
}
if( DB_OK != db_rc ) {
print_error_message( "Error inserting or commiting\n", c );
}
db_close_cursor( c );
db_free_row( row );
return DB_OK == db_rc ? EXIT_SUCCESS : EXIT_FAILURE;
}
/*!
\brief Select one (first) value from table/column for key/id
\param driver DB driver
\param tab table name
\param key key column name
\param id identifier in key column
\param col name of column to select the value from
\param[out] val dbValue to store within
\return number of selected values
\return -1 on error
*/
int db_select_value(dbDriver * driver, const char *tab, const char *key,
int id, const char *col, dbValue * val)
{
int more, count;
char buf[1024];
dbString stmt;
dbCursor cursor;
dbColumn *column;
dbValue *value;
dbTable *table;
if (key == NULL || strlen(key) == 0) {
G_warning(_("Missing key column name"));
return -1;
}
if (col == NULL || strlen(col) == 0) {
G_warning(_("Missing column name"));
return -1;
}
G_zero(val, sizeof(dbValue));
sprintf(buf, "SELECT %s FROM %s WHERE %s = %d\n", col, tab, key, id);
db_init_string(&stmt);
db_append_string(&stmt, buf);
if (db_open_select_cursor(driver, &stmt, &cursor, DB_SEQUENTIAL) != DB_OK)
return (-1);
table = db_get_cursor_table(&cursor);
column = db_get_table_column(table, 0); /* first column */
value = db_get_column_value(column);
/* fetch the data */
count = 0;
while (1) {
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK)
return (-1);
if (!more)
break;
if (count == 0)
db_copy_value(val, value);
count++;
}
db_close_cursor(&cursor);
db_free_string(&stmt);
return (count);
}
bool OGRGRASSLayer::OpenSequentialCursor()
{
CPLDebug ( "GRASS", "OpenSequentialCursor: %s", pszQuery );
if ( !poDriver )
{
CPLError( CE_Failure, CPLE_AppDefined, "Driver not opened.");
return false;
}
if ( bCursorOpened )
{
db_close_cursor ( poCursor );
bCursorOpened = false;
}
char buf[2000];
sprintf ( buf, "SELECT * FROM %s ", poLink->table );
db_set_string ( poDbString, buf);
if ( pszQuery ) {
sprintf ( buf, "WHERE %s ", pszQuery );
db_append_string ( poDbString, buf);
}
sprintf ( buf, "ORDER BY %s", poLink->key);
db_append_string ( poDbString, buf);
CPLDebug ( "GRASS", "Query: %s", db_get_string(poDbString) );
if ( db_open_select_cursor ( poDriver, poDbString,
poCursor, DB_SCROLL) == DB_OK )
{
iCurrentCat = -1;
bCursorOpened = true;
CPLDebug ( "GRASS", "num rows = %d", db_get_num_rows ( poCursor ) );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined, "Cannot open cursor.");
return false;
}
return true;
}
/*!
\brief Select pairs key/value to array, values are sorted by key (must be integer)
\param driver DB driver
\param tab table name
\param key key column name
\param col value column name
\param[out] cvarr dbCatValArray to store within
\return number of selected values
\return -1 on error
*/
int db_select_CatValArray(dbDriver * driver, const char *tab, const char *key,
const char *col, const char *where,
dbCatValArray * cvarr)
{
int i, type, more, nrows;
char buf[1024];
dbString stmt;
dbCursor cursor;
dbColumn *column;
dbValue *value;
dbTable *table;
G_debug(3, "db_select_CatValArray ()");
if (key == NULL || strlen(key) == 0) {
G_warning(_("Missing key column name"));
return -1;
}
if (col == NULL || strlen(col) == 0) {
G_warning(_("Missing column name"));
return -1;
}
db_init_string(&stmt);
sprintf(buf, "SELECT %s, %s FROM %s", key, col, tab);
db_set_string(&stmt, buf);
if (where != NULL && strlen(where) > 0) {
db_append_string(&stmt, " WHERE ");
db_append_string(&stmt, where);
}
G_debug(3, " SQL: %s", db_get_string(&stmt));
if (db_open_select_cursor(driver, &stmt, &cursor, DB_SEQUENTIAL) != DB_OK)
return (-1);
nrows = db_get_num_rows(&cursor);
G_debug(3, " %d rows selected", nrows);
if (nrows < 0) {
G_warning(_("Unable select records from table <%s>"), tab);
db_close_cursor(&cursor);
db_free_string(&stmt);
return -1;
}
db_CatValArray_alloc(cvarr, nrows);
table = db_get_cursor_table(&cursor);
/* Check if key column is integer */
column = db_get_table_column(table, 0);
type = db_sqltype_to_Ctype(db_get_column_sqltype(column));
G_debug(3, " key type = %d", type);
if (type != DB_C_TYPE_INT) {
G_warning(_("Key column type is not integer"));
db_close_cursor(&cursor);
db_free_string(&stmt);
return -1;
}
column = db_get_table_column(table, 1);
type = db_sqltype_to_Ctype(db_get_column_sqltype(column));
G_debug(3, " col type = %d", type);
/*
if ( type != DB_C_TYPE_INT && type != DB_C_TYPE_DOUBLE ) {
G_fatal_error ( "Column type not supported by db_select_to_array()" );
}
*/
cvarr->ctype = type;
/* fetch the data */
for (i = 0; i < nrows; i++) {
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK)
return (-1);
column = db_get_table_column(table, 0); /* first column */
value = db_get_column_value(column);
cvarr->value[i].cat = db_get_value_int(value);
column = db_get_table_column(table, 1);
value = db_get_column_value(column);
cvarr->value[i].isNull = value->isNull;
switch (type) {
case (DB_C_TYPE_INT):
if (value->isNull)
cvarr->value[i].val.i = 0;
else
cvarr->value[i].val.i = db_get_value_int(value);
break;
case (DB_C_TYPE_DOUBLE):
if (value->isNull)
cvarr->value[i].val.d = 0.0;
else
cvarr->value[i].val.d = db_get_value_double(value);
break;
case (DB_C_TYPE_STRING):
cvarr->value[i].val.s = (dbString *) malloc(sizeof(dbString));
db_init_string(cvarr->value[i].val.s);
if (!(value->isNull))
db_set_string(cvarr->value[i].val.s,
db_get_value_string(value));
break;
case (DB_C_TYPE_DATETIME):
cvarr->value[i].val.t =
(dbDateTime *) calloc(1, sizeof(dbDateTime));
if (!(value->isNull))
memcpy(cvarr->value[i].val.t, &(value->t),
sizeof(dbDateTime));
break;
default:
return (-1);
}
}
cvarr->n_values = nrows;
db_close_cursor(&cursor);
db_free_string(&stmt);
db_CatValArray_sort(cvarr);
return (nrows);
}
/*!
\brief Select array of ordered integers from table/column
\param driver DB driver
\param tab table name
\param col column name
\param where where statement
\param[out] pval array of ordered integer values
\return number of selected values
\return -1 on error
*/
int db_select_int(dbDriver * driver, const char *tab, const char *col,
const char *where, int **pval)
{
int type, more, alloc, count;
int *val;
char buf[1024];
const char *sval;
dbString stmt;
dbCursor cursor;
dbColumn *column;
dbValue *value;
dbTable *table;
G_debug(3, "db_select_int()");
if (col == NULL || strlen(col) == 0) {
G_warning(_("Missing column name"));
return -1;
}
/* allocate */
alloc = 1000;
val = (int *)G_malloc(alloc * sizeof(int));
if (where == NULL || strlen(where) == 0)
G_snprintf(buf, 1023, "SELECT %s FROM %s", col, tab);
else
G_snprintf(buf, 1023, "SELECT %s FROM %s WHERE %s", col, tab, where);
G_debug(3, " SQL: %s", buf);
db_init_string(&stmt);
db_append_string(&stmt, buf);
if (db_open_select_cursor(driver, &stmt, &cursor, DB_SEQUENTIAL) != DB_OK)
return (-1);
table = db_get_cursor_table(&cursor);
column = db_get_table_column(table, 0); /* first column */
if (column == NULL) {
return -1;
}
value = db_get_column_value(column);
type = db_get_column_sqltype(column);
type = db_sqltype_to_Ctype(type);
/* fetch the data */
count = 0;
while (1) {
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK)
return (-1);
if (!more)
break;
if (count == alloc) {
alloc += 1000;
val = (int *)G_realloc(val, alloc * sizeof(int));
}
switch (type) {
case (DB_C_TYPE_INT):
val[count] = db_get_value_int(value);
break;
case (DB_C_TYPE_STRING):
sval = db_get_value_string(value);
val[count] = atoi(sval);
break;
case (DB_C_TYPE_DOUBLE):
val[count] = (int)db_get_value_double(value);
break;
default:
return (-1);
}
count++;
}
db_close_cursor(&cursor);
db_free_string(&stmt);
qsort((void *)val, count, sizeof(int), cmp);
*pval = val;
return (count);
}
int check_data( db_t hdb, const trans_stat_t * stat )
{
int rc = EXIT_FAILURE;
db_result_t db_rc = DB_OK;
db_row_t row;
storage_t row_data;
db_cursor_t c; // Cursor to scan table to check
// Cursor parameters
db_table_cursor_t p = {
PKEY_INDEX_NAME, //< Index by which to sort the table
DB_SCAN_FORWARD | DB_LOCK_DEFAULT
};
// Open cursor
c = db_open_table_cursor(hdb, STORAGE_TABLE, &p);
row = db_alloc_row( binds_def, DB_ARRAY_DIM( binds_def ) );
db_rc = db_seek_first(c);
// Scan table and check that pkey values are monotonically increase
{
int counter = 0;
trans_stat_t s = { 0, 0 };
for(; !db_eof(c) && DB_OK == db_rc; db_rc = db_seek_next(c) )
{
db_rc = db_fetch(c, row, &row_data);
if( row_data.f1 != ++counter ) {
break;
}
s.lazy_tx += row_data.f2 == 50 ? 1 : 0;
s.forced_tx += row_data.f2 == 16 ? 1 : 0;
}
if( DB_OK != db_rc ) {
print_error_message( "Error to scan table of backup db\n", c );
}
else if( row_data.f1 != counter ) {
fprintf( stderr, "Pkey field values sequence violation detected in backup db: (%" PRId64 ", %d)\n",
row_data.f1, counter
);
}
else if( s.lazy_tx != stat->lazy_tx ) {
fprintf( stderr, "Unexpected count of records which was commited in lazy-commit mode: %d, but expected %d.\n",
s.lazy_tx, stat->lazy_tx );
}
else if( s.forced_tx != stat->forced_tx ) {
fprintf( stderr, "Unexpected count of records which was commited in force-commit mode: %d, but expected %d.\n",
s.forced_tx, stat->forced_tx );
}
else {
fprintf( stdout, "%d records is inside\n", counter );
rc = EXIT_SUCCESS;
}
}
db_close_cursor( c );
db_free_row( row );
db_shutdown(hdb, DB_SOFT_SHUTDOWN, NULL);
return rc;
}
int main(int argc, char **argv)
{
struct GModule *module;
struct Option *map_opt, *field_opt, *fs_opt, *vs_opt, *nv_opt, *col_opt,
*where_opt, *file_opt;
struct Flag *c_flag, *v_flag, *r_flag;
dbDriver *driver;
dbString sql, value_string;
dbCursor cursor;
dbTable *table;
dbColumn *column;
dbValue *value;
struct field_info *Fi;
int ncols, col, more;
struct Map_info Map;
char query[1024];
struct ilist *list_lines;
struct bound_box *min_box, *line_box;
int i, line, area, init_box, cat;
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("database"));
G_add_keyword(_("attribute table"));
module->description = _("Prints vector map attributes.");
map_opt = G_define_standard_option(G_OPT_V_MAP);
field_opt = G_define_standard_option(G_OPT_V_FIELD);
col_opt = G_define_standard_option(G_OPT_DB_COLUMNS);
where_opt = G_define_standard_option(G_OPT_DB_WHERE);
fs_opt = G_define_standard_option(G_OPT_F_SEP);
fs_opt->description = _("Output field separator");
fs_opt->guisection = _("Format");
vs_opt = G_define_standard_option(G_OPT_F_SEP);
vs_opt->key = "vs";
vs_opt->description = _("Output vertical record separator");
vs_opt->answer = NULL;
vs_opt->guisection = _("Format");
nv_opt = G_define_option();
nv_opt->key = "nv";
nv_opt->type = TYPE_STRING;
nv_opt->required = NO;
nv_opt->description = _("Null value indicator");
nv_opt->guisection = _("Format");
file_opt = G_define_standard_option(G_OPT_F_OUTPUT);
file_opt->key = "file";
file_opt->required = NO;
file_opt->description =
_("Name for output file (if omitted or \"-\" output to stdout)");
r_flag = G_define_flag();
r_flag->key = 'r';
r_flag->description =
_("Print minimal region extent of selected vector features instead of attributes");
c_flag = G_define_flag();
c_flag->key = 'c';
c_flag->description = _("Do not include column names in output");
c_flag->guisection = _("Format");
v_flag = G_define_flag();
v_flag->key = 'v';
v_flag->description = _("Vertical output (instead of horizontal)");
v_flag->guisection = _("Format");
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* set input vector map name and mapset */
if (file_opt->answer && strcmp(file_opt->answer, "-") != 0) {
if (NULL == freopen(file_opt->answer, "w", stdout)) {
G_fatal_error(_("Unable to open file <%s> for writing"), file_opt->answer);
}
}
if (r_flag->answer) {
min_box = (struct bound_box *) G_malloc(sizeof(struct bound_box));
G_zero((void *)min_box, sizeof(struct bound_box));
line_box = (struct bound_box *) G_malloc(sizeof(struct bound_box));
list_lines = Vect_new_list();
}
else {
min_box = line_box = NULL;
list_lines = NULL;
}
db_init_string(&sql);
db_init_string(&value_string);
/* open input vector */
if (!r_flag->answer)
Vect_open_old_head2(&Map, map_opt->answer, "", field_opt->answer);
else {
if (2 > Vect_open_old2(&Map, map_opt->answer, "", field_opt->answer)) {
Vect_close(&Map);
G_fatal_error(_("Unable to open vector map <%s> at topology level. "
"Flag '%c' requires topology level."),
map_opt->answer, r_flag->key);
}
}
if ((Fi = Vect_get_field2(&Map, field_opt->answer)) == NULL)
G_fatal_error(_("Database connection not defined for layer <%s>"),
field_opt->answer);
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (!driver)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
if (col_opt->answer)
sprintf(query, "SELECT %s FROM ", col_opt->answer);
else
sprintf(query, "SELECT * FROM ");
db_set_string(&sql, query);
db_append_string(&sql, Fi->table);
if (where_opt->answer) {
char *buf = NULL;
buf = G_malloc((strlen(where_opt->answer) + 8));
sprintf(buf, " WHERE %s", where_opt->answer);
db_append_string(&sql, buf);
G_free(buf);
}
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) != DB_OK)
G_fatal_error(_("Unable to open select cursor"));
table = db_get_cursor_table(&cursor);
ncols = db_get_table_number_of_columns(table);
/* column names if horizontal output (ignore for -r) */
if (!v_flag->answer && !c_flag->answer && !r_flag->answer) {
for (col = 0; col < ncols; col++) {
column = db_get_table_column(table, col);
if (col)
fprintf(stdout, "%s", fs_opt->answer);
fprintf(stdout, "%s", db_get_column_name(column));
}
fprintf(stdout, "\n");
}
init_box = 1;
/* fetch the data */
while (1) {
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK)
G_fatal_error(_("Unable to fetch data from table <%s>"),
Fi->table);
if (!more)
break;
cat = -1;
for (col = 0; col < ncols; col++) {
column = db_get_table_column(table, col);
value = db_get_column_value(column);
if (cat < 0 && strcmp(Fi->key, db_get_column_name(column)) == 0) {
cat = db_get_value_int(value);
if (r_flag->answer)
break;
}
if (r_flag->answer)
continue;
db_convert_column_value_to_string(column, &value_string);
if (!c_flag->answer && v_flag->answer)
fprintf(stdout, "%s%s", db_get_column_name(column),
fs_opt->answer);
if (col && !v_flag->answer)
fprintf(stdout, "%s", fs_opt->answer);
if (nv_opt->answer && db_test_value_isnull(value))
fprintf(stdout, "%s", nv_opt->answer);
else
fprintf(stdout, "%s", db_get_string(&value_string));
if (v_flag->answer)
fprintf(stdout, "\n");
}
if (r_flag->answer) {
/* get minimal region extent */
Vect_cidx_find_all(&Map, Vect_get_field_number(&Map, field_opt->answer), -1, cat, list_lines);
for (i = 0; i < list_lines->n_values; i++) {
line = list_lines->value[i];
area = Vect_get_centroid_area(&Map, line);
if (area > 0) {
if (!Vect_get_area_box(&Map, area, line_box))
G_fatal_error(_("Unable to get bounding box of area %d"),
area);
}
else {
if (!Vect_get_line_box(&Map, line, line_box))
G_fatal_error(_("Unable to get bounding box of line %d"),
line);
}
if (init_box) {
Vect_box_copy(min_box, line_box);
init_box = 0;
}
else {
Vect_box_extend(min_box, line_box);
}
}
}
else {
if (!v_flag->answer)
fprintf(stdout, "\n");
else if (vs_opt->answer)
fprintf(stdout, "%s\n", vs_opt->answer);
}
}
if (r_flag->answer) {
fprintf(stdout, "n=%f\n", min_box->N);
fprintf(stdout, "s=%f\n", min_box->S);
fprintf(stdout, "w=%f\n", min_box->W);
fprintf(stdout, "e=%f\n", min_box->E);
if (Vect_is_3d(&Map)) {
fprintf(stdout, "t=%f\n", min_box->T);
fprintf(stdout, "b=%f\n", min_box->B);
}
fflush(stdout);
G_free((void *)min_box);
G_free((void *)line_box);
Vect_destroy_list(list_lines);
}
db_close_cursor(&cursor);
db_close_database_shutdown_driver(driver);
Vect_close(&Map);
exit(EXIT_SUCCESS);
}
int write_attributes(dbDriver *driver, int cat, const struct field_info *Fi,
OGRLayerH Ogr_layer, OGRFeatureH Ogr_feature)
{
int j, ogrfieldnum;
char buf[2000];
int ncol, sqltype, ctype, ogrtype, more;
const char *fidcol, *colname;
dbTable *table;
dbString dbstring;
dbColumn *column;
dbCursor cursor;
dbValue *value;
OGRFieldDefnH hFieldDefn;
G_debug(3, "write_attributes(): cat = %d", cat);
if (cat < 0) {
G_warning(_("Feature without category of layer %d"), Fi->number);
return 0;
}
db_init_string(&dbstring);
/* read & set attributes */
sprintf(buf, "SELECT * FROM %s WHERE %s = %d", Fi->table, Fi->key,
cat);
G_debug(4, "SQL: %s", buf);
db_set_string(&dbstring, buf);
/* select data */
if (db_open_select_cursor(driver, &dbstring, &cursor, DB_SEQUENTIAL) != DB_OK) {
G_fatal_error(_("Unable to select attributes for category %d"),
cat);
}
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK) {
G_fatal_error(_("Unable to fetch data from table <%s>"),
Fi->table);
}
if (!more) {
G_warning(_("No database record for category %d, "
"no attributes will be written"),
cat);
return -1;
}
fidcol = OGR_L_GetFIDColumn(Ogr_layer);
table = db_get_cursor_table(&cursor);
ncol = db_get_table_number_of_columns(table);
for (j = 0; j < ncol; j++) {
column = db_get_table_column(table, j);
colname = db_get_column_name(column);
if (fidcol && *fidcol && strcmp(colname, fidcol) == 0) {
/* skip fid column */
continue;
}
value = db_get_column_value(column);
/* for debug only */
db_convert_column_value_to_string(column, &dbstring);
G_debug(2, "col %d : val = %s", j,
db_get_string(&dbstring));
sqltype = db_get_column_sqltype(column);
ctype = db_sqltype_to_Ctype(sqltype);
ogrtype = sqltype_to_ogrtype(sqltype);
G_debug(2, " colctype = %d", ctype);
ogrfieldnum = OGR_F_GetFieldIndex(Ogr_feature, colname);
if (ogrfieldnum < 0) {
/* create field if not exists */
hFieldDefn = OGR_Fld_Create(colname, ogrtype);
if (OGR_L_CreateField(Ogr_layer, hFieldDefn, TRUE) != OGRERR_NONE)
G_warning(_("Unable to create field <%s>"), colname);
ogrfieldnum = OGR_F_GetFieldIndex(Ogr_feature, colname);
}
/* Reset */
OGR_F_UnsetField(Ogr_feature, ogrfieldnum);
/* prevent writing NULL values */
if (!db_test_value_isnull(value)) {
switch (ctype) {
case DB_C_TYPE_INT:
OGR_F_SetFieldInteger(Ogr_feature, ogrfieldnum,
db_get_value_int(value));
break;
case DB_C_TYPE_DOUBLE:
OGR_F_SetFieldDouble(Ogr_feature, ogrfieldnum,
db_get_value_double(value));
break;
case DB_C_TYPE_STRING:
OGR_F_SetFieldString(Ogr_feature, ogrfieldnum,
db_get_value_string(value));
break;
case DB_C_TYPE_DATETIME:
db_convert_column_value_to_string(column,
&dbstring);
OGR_F_SetFieldString(Ogr_feature, ogrfieldnum,
db_get_string(&dbstring));
break;
}
}
}
db_close_cursor (&cursor);
db_free_string(&dbstring);
return 1;
}
int db__copy_table(const char *from_drvname, const char *from_dbname,
const char *from_tblname, const char *to_drvname,
const char *to_dbname, const char *to_tblname,
const char *where, const char *select, const char *selcol,
int *ivals, int nvals)
{
int col, ncols, sqltype, ctype, more, selcol_found;
char buf[1000];
int *ivalues;
dbHandle from_handle, to_handle;
dbString tblname, sql;
dbString value_string;
dbString *tblnames;
dbTable *table, *out_table;
dbCursor cursor;
dbColumn *column;
dbValue *value;
const char *colname;
dbDriver *from_driver, *to_driver;
int count, i;
G_debug(3, "db_copy_table():\n from driver = %s, db = %s, table = %s\n"
" to driver = %s, db = %s, table = %s, where = %s, select = %s",
from_drvname, from_dbname, from_tblname, to_drvname, to_dbname,
to_tblname, where, select);
db_init_handle(&from_handle);
db_init_handle(&to_handle);
db_init_string(&tblname);
db_init_string(&sql);
db_init_string(&value_string);
/* Make a copy of input values and sort it */
if (ivals) {
ivalues = (int *)G_malloc(nvals * sizeof(int));
memcpy(ivalues, ivals, nvals * sizeof(int));
qsort((void *)ivalues, nvals, sizeof(int), cmp);
}
/* Open input driver and database */
from_driver = db_start_driver(from_drvname);
if (from_driver == NULL) {
G_warning(_("Unable to start driver <%s>"), from_drvname);
return DB_FAILED;
}
db_set_handle(&from_handle, from_dbname, NULL);
if (db_open_database(from_driver, &from_handle) != DB_OK) {
G_warning(_("Unable to open database <%s> by driver <%s>"),
from_dbname, from_drvname);
db_close_database_shutdown_driver(from_driver);
return DB_FAILED;
}
/* Open output driver and database */
if (strcmp(from_drvname, to_drvname) == 0
&& strcmp(from_dbname, to_dbname) == 0) {
G_debug(3, "Use the same driver");
to_driver = from_driver;
}
else {
to_driver = db_start_driver(to_drvname);
if (to_driver == NULL) {
G_warning(_("Unable to start driver <%s>"), to_drvname);
db_close_database_shutdown_driver(from_driver);
return DB_FAILED;
}
db_set_handle(&to_handle, to_dbname, NULL);
if (db_open_database(to_driver, &to_handle) != DB_OK) {
G_warning(_("Unable to open database <%s> by driver <%s>"),
to_dbname, to_drvname);
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver) {
db_close_database_shutdown_driver(from_driver);
}
return DB_FAILED;
}
}
db_begin_transaction(to_driver);
/* Because in SQLite3 an opened cursor is no more valid
if 'schema' is modified (create table), we have to open
cursor twice */
/* test if the table exists */
if (db_list_tables(to_driver, &tblnames, &count, 0) != DB_OK) {
G_warning(_("Unable to get list tables in database <%s>"),
to_dbname);
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver)
db_close_database_shutdown_driver(from_driver);
return DB_FAILED;
}
for (i = 0; i < count; i++) {
const char *tblname = db_get_string(&tblnames[i]);
if (strcmp(to_tblname, tblname) == 0) {
G_warning(_("Table <%s> already exists in database <%s>"),
to_tblname, to_dbname);
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver)
db_close_database_shutdown_driver(from_driver);
return DB_FAILED;
}
}
/* Create new table */
/* Open cursor for data structure */
if (select) {
db_set_string(&sql, select);
/* TODO!: cannot use this because it will not work if a query
* ends with 'group by' for example */
/*
tmp = strdup ( select );
G_tolcase ( tmp );
if ( !strstr( tmp,"where") )
{
db_append_string ( &sql, " where 0 = 1");
}
else
{
db_append_string ( &sql, " and 0 = 1");
}
free (tmp);
*/
}
else {
db_set_string(&sql, "select * from ");
db_append_string(&sql, from_tblname);
db_append_string(&sql, " where 0 = 1"); /* to get no data */
}
G_debug(3, db_get_string(&sql));
if (db_open_select_cursor(from_driver, &sql, &cursor, DB_SEQUENTIAL) !=
DB_OK) {
G_warning(_("Unable to open select cursor: '%s'"),
db_get_string(&sql));
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver) {
db_close_database_shutdown_driver(from_driver);
}
return DB_FAILED;
}
G_debug(3, "Select cursor opened");
table = db_get_cursor_table(&cursor);
ncols = db_get_table_number_of_columns(table);
G_debug(3, "ncols = %d", ncols);
out_table = db_alloc_table(ncols);
db_set_table_name(out_table, to_tblname);
selcol_found = 0;
for (col = 0; col < ncols; col++) {
dbColumn *out_column;
column = db_get_table_column(table, col);
colname = db_get_column_name(column);
sqltype = db_get_column_sqltype(column);
ctype = db_sqltype_to_Ctype(sqltype);
G_debug(3, "%s (%s)", colname, db_sqltype_name(sqltype));
out_column = db_get_table_column(out_table, col);
if (selcol && G_strcasecmp(colname, selcol) == 0) {
if (ctype != DB_C_TYPE_INT)
G_fatal_error(_("Column <%s> is not integer"),
colname);
selcol_found = 1;
}
db_set_column_name(out_column, db_get_column_name(column));
db_set_column_description(out_column,
db_get_column_description(column));
db_set_column_sqltype(out_column, db_get_column_sqltype(column));
db_set_column_length(out_column, db_get_column_length(column));
db_set_column_precision(out_column, db_get_column_precision(column));
db_set_column_scale(out_column, db_get_column_scale(column));
}
db_close_cursor(&cursor);
if (selcol && !selcol_found)
G_fatal_error(_("Column <%s> not found"), selcol);
if (db_create_table(to_driver, out_table) != DB_OK) {
G_warning(_("Unable to create table <%s>"),
to_tblname);
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver) {
db_close_database_shutdown_driver(from_driver);
}
return DB_FAILED;
}
/* Open cursor with data */
if (select) {
db_set_string(&sql, select);
}
else {
db_set_string(&sql, "select * from ");
db_append_string(&sql, from_tblname);
if (where) {
db_append_string(&sql, " where ");
db_append_string(&sql, where);
}
}
G_debug(3, db_get_string(&sql));
if (db_open_select_cursor(from_driver, &sql, &cursor, DB_SEQUENTIAL) !=
DB_OK) {
G_warning(_("Unable to open select cursor: '%s'"),
db_get_string(&sql));
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver) {
db_close_database_shutdown_driver(from_driver);
}
return DB_FAILED;
}
G_debug(3, "Select cursor opened");
table = db_get_cursor_table(&cursor);
ncols = db_get_table_number_of_columns(table);
G_debug(3, "ncols = %d", ncols);
/* Copy all rows */
while (1) {
int select;
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK) {
G_warning(_("Unable to fetch data from table <%s>"),
from_tblname);
db_close_cursor(&cursor);
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver) {
db_close_database_shutdown_driver(from_driver);
}
return DB_FAILED;
}
if (!more)
break;
sprintf(buf, "insert into %s values ( ", to_tblname);
db_set_string(&sql, buf);
select = 1;
for (col = 0; col < ncols; col++) {
column = db_get_table_column(table, col);
colname = db_get_column_name(column);
sqltype = db_get_column_sqltype(column);
ctype = db_sqltype_to_Ctype(sqltype);
value = db_get_column_value(column);
if (selcol && G_strcasecmp(colname, selcol) == 0) {
if (db_test_value_isnull(value))
continue;
if (!bsearch(&(value->i), ivalues, nvals, sizeof(int), cmp)) {
select = 0;
break;
}
}
if (col > 0)
db_append_string(&sql, ", ");
db_convert_value_to_string(value, sqltype, &value_string);
switch (ctype) {
case DB_C_TYPE_STRING:
case DB_C_TYPE_DATETIME:
if (db_test_value_isnull(value)) {
db_append_string(&sql, "null");
}
else {
db_double_quote_string(&value_string);
db_append_string(&sql, "'");
db_append_string(&sql, db_get_string(&value_string));
db_append_string(&sql, "'");
}
break;
case DB_C_TYPE_INT:
case DB_C_TYPE_DOUBLE:
if (db_test_value_isnull(value)) {
db_append_string(&sql, "null");
}
else {
db_append_string(&sql, db_get_string(&value_string));
}
break;
default:
G_warning(_("Unknown column type (column <%s>)"),
colname);
db_close_cursor(&cursor);
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver) {
db_close_database_shutdown_driver(from_driver);
}
return DB_FAILED;
}
}
if (!select)
continue;
db_append_string(&sql, ")");
G_debug(3, db_get_string(&sql));
if (db_execute_immediate(to_driver, &sql) != DB_OK) {
G_warning("Unable to insert new record: '%s'",
db_get_string(&sql));
db_close_cursor(&cursor);
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver) {
db_close_database_shutdown_driver(from_driver);
}
return DB_FAILED;
}
}
if (selcol)
G_free(ivalues);
G_debug(3, "Table copy OK");
db_close_cursor(&cursor);
db_commit_transaction(to_driver);
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver) {
db_close_database_shutdown_driver(from_driver);
}
return DB_OK;
}
OGRErr OGRGRASSLayer::SetAttributeFilter( const char *query )
{
CPLDebug ( "GRASS", "SetAttributeFilter: %s", query );
if ( query == NULL ) {
// Release old if any
if ( pszQuery ) {
CPLFree ( pszQuery );
pszQuery = NULL;
}
if ( paQueryMatch ) {
CPLFree ( paQueryMatch );
paQueryMatch = NULL;
}
return OGRERR_NONE;
}
paQueryMatch = (char *) CPLMalloc ( nTotalCount );
memset ( paQueryMatch, 0x0, nTotalCount );
pszQuery = strdup ( query );
OGRLayer::SetAttributeFilter(query); // Otherwise crash on delete
if ( bHaveAttributes ) {
if ( !poDriver )
{
StartDbDriver();
}
if ( poDriver )
{
if ( bCursorOpened )
{
db_close_cursor ( poCursor );
bCursorOpened = false;
}
OpenSequentialCursor();
if ( bCursorOpened )
{
SetQueryMatch();
db_close_cursor ( poCursor );
bCursorOpened = false;
}
else
{
CPLFree ( pszQuery );
pszQuery = NULL;
return OGRERR_FAILURE;
}
db_close_database_shutdown_driver ( poDriver );
poDriver = NULL;
}
else
{
CPLFree ( pszQuery );
pszQuery = NULL;
return OGRERR_FAILURE;
}
}
else
{
// Use OGR to evaluate category match
for ( int i = 0; i < nTotalCount; i++ )
{
OGRFeature *feature = GetFeature(i);
CPLDebug ( "GRASS", "i = %d eval = %d", i, m_poAttrQuery->Evaluate ( feature ) );
if ( m_poAttrQuery->Evaluate ( feature ) )
{
paQueryMatch[i] = 1;
}
}
}
return OGRERR_NONE;
}
/* Returns 0 - ok , 1 - error */
int
plot(int ctype, struct Map_info *Map, int type, int field,
char *columns, int ncols, char *sizecol, int size, double scale,
COLOR * ocolor, COLOR * colors, int y_center, double *max_reference,
int do3d)
{
int ltype, nlines, line, col, more, coltype, nselcols;
double x, y, csize, len;
struct line_pnts *Points;
struct line_cats *Cats;
int cat;
double *val;
char buf[2000];
struct field_info *Fi;
dbDriver *driver;
dbValue *value;
dbString sql;
dbCursor cursor;
dbTable *table;
dbColumn *column;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
db_init_string(&sql);
Fi = Vect_get_field(Map, field);
if (Fi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
field);
/* Open driver */
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (driver == NULL) {
G_warning(_("Unable to open database <%s> by driver <%s>"),
Fi->database,
Fi->driver);
return 1;
}
db_set_error_handler_driver(driver);
val = (double *)G_malloc((ncols + 1) * sizeof(double)); /* + 1 for sizecol */
Vect_rewind(Map);
nlines = Vect_get_num_lines(Map);
/* loop through each vector feature */
for (line = 1; line <= nlines; line++) {
G_debug(3, "line = %d", line);
ltype = Vect_read_line(Map, Points, Cats, line);
if (!(ltype & type))
continue;
Vect_cat_get(Cats, field, &cat);
if (cat < 0)
continue;
/* Select values from DB */
if (ctype == CTYPE_PIE && sizecol != NULL) {
sprintf(buf, "select %s, %s from %s where %s = %d", columns,
sizecol, Fi->table, Fi->key, cat);
nselcols = ncols + 1;
}
else {
sprintf(buf, "select %s from %s where %s = %d", columns,
Fi->table, Fi->key, cat);
nselcols = ncols;
}
db_set_string(&sql, buf);
G_debug(3, "SQL: %s", buf);
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) !=
DB_OK) {
G_warning(_("Unable to open select cursor: '%s'"),
buf);
return 1;
}
table = db_get_cursor_table(&cursor);
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK || !more)
continue;
for (col = 0; col < nselcols; col++) {
column = db_get_table_column(table, col);
value = db_get_column_value(column);
coltype = db_sqltype_to_Ctype(db_get_column_sqltype(column));
switch (coltype) {
case DB_C_TYPE_INT:
val[col] = (double)db_get_value_int(value);
break;
case DB_C_TYPE_DOUBLE:
val[col] = db_get_value_double(value);
break;
default:
G_warning("Column type not supported (must be INT or FLOAT)");
return 1;
}
G_debug(4, " val[%d]: %f", col, val[col]);
}
db_close_cursor(&cursor);
/* Center of chart */
if (ltype & GV_LINES) { /* find center */
len = Vect_line_length(Points) / 2;
Vect_point_on_line(Points, len, &x, &y, NULL, NULL, NULL);
}
else {
x = Points->x[0];
y = Points->y[0];
}
if (ctype == CTYPE_PIE) {
if (sizecol != NULL) {
csize = val[ncols];
size = scale * csize;
}
pie(x, y, size, val, ncols, ocolor, colors, do3d);
}
else {
bar(x, y, size, scale, val, ncols, ocolor, colors, y_center,
max_reference, do3d);
}
}
db_close_database_shutdown_driver(driver);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
return 0;
}
static db_result_t
upgrade_to_schema_v2( db_t hdb )
{
db_result_t rc = DB_OK;
/* 1. Convert string type v1's 'sex_title' column to int-type 'sex' column, as v2 schema declares */
/* 1.1. Append a new uint8 type 'sex' column */
db_fielddef_t sex = { CONTACT_NFIELDS, "sex", DB_COLTYPE_UINT8, 0, 0, DB_NULLABLE, 0 };
/* 1.2. Fill 'sex' column with data according to schema: Mr->0, Mrs->1,Other->2 */
// Use absolute bound fields ( see ittiadb/manuals/users-guide/api-c-database-access.html#absolute-bound-fields )
db_ansi_t sex_old[ MAX_SEX_TITLE + 1 ];
db_len_t sex_ind = DB_FIELD_NULL, sex_ind_new = DB_FIELD_NULL;
uint8_t sex_new = 0;
db_bind_t binds_def[] = {
{CONTACT_SEX, DB_VARTYPE_ANSISTR, DB_BIND_ADDRESS(sex_old), sizeof(sex_old), DB_BIND_ADDRESS(&sex_ind), DB_BIND_ABSOLUTE},
{CONTACT_NFIELDS, DB_VARTYPE_UINT8, DB_BIND_ADDRESS(&sex_new), sizeof(sex_new), DB_BIND_ADDRESS(&sex_ind_new), DB_BIND_ABSOLUTE},
};
db_row_t row = db_alloc_row( binds_def, 2 );
db_table_cursor_t p = {
NULL, //< No index
DB_CAN_MODIFY | DB_LOCK_EXCLUSIVE
};
db_cursor_t c;
rc = db_add_field( hdb, CONTACT_TABLE, &sex );
if( DB_OK != rc ) {
print_error_message( "Couldn't append 'sex' column on v1->v2 upgrade", 0 );
return DB_FAIL;
}
c = db_open_table_cursor(hdb, CONTACT_TABLE, &p);
db_begin_tx( hdb, DB_DEFAULT_ISOLATION | DB_LOCK_DEFAULT );
for ( rc = db_seek_first( c ); DB_OK == rc && !db_eof( c ); db_seek_next( c ) ) {
rc = db_fetch( c, row, 0 );
if( 0 == strcmp( "Mr", sex_old ) ) {
sex_new = 0;
}
else if( 0 == strcmp( "Mrs", sex_old ) ) {
sex_new = 1;
}
else {
sex_new = 2;
}
sex_ind_new = 0;
rc = db_update( c, row, 0 );
}
db_commit_tx( hdb, DB_DEFAULT_COMPLETION );
if( DB_OK != rc ) {
print_error_message( "Couldn't fill appended 'sex' column with data", c );
}
db_free_row( row );
db_close_cursor( c );
/* 1.3 Drop v1 sex_title column. */
/* Note: Dropping columns isn't available in ITTIA evaluation version. */
rc = db_drop_field( hdb, CONTACT_TABLE, "sex_title" );
if( DB_OK != rc ) {
if( DB_EEVALUATION == get_db_error() ) {
rc = DB_OK;
fprintf( stdout, "No db_drop_field() feature supported in ITTIA Evaluation version\n" );
}
else {
print_error_message( "Couldn't drop 'sex_title' v1 schema column", c );
}
}
/* 2. Indexes modifications */
// 2.1. drop old pkey
rc = db_drop_index( hdb, CONTACT_TABLE, CONTACT_BY_ID );
if ( DB_OK != rc ) {
print_error_message( "Couldn't drop v1 pkey index", c );
}
// 2.2. create a new one
// 2.2.1. Set NOT NULL property on ring_id field
// Note: this feature isn't supported in evaluation version of ittiadb.
{
extern db_fielddef_t contact_fields[]; //< Defined in schema_upgrade_schema_v2.c
rc = db_update_field( hdb, CONTACT_TABLE, "ring_id", &contact_fields[ CONTACT_RING_ID ] );
if ( DB_OK != rc ) {
print_error_message( "Couldn't set not null on ring_id column", c );
}
}
// 2.2.2. Create PKey index
{
extern db_indexdef_t contact_indexes[]; //< Defined in schema_upgrade_schema_v2.c
rc = db_create_index( hdb, CONTACT_TABLE, CONTACT_BY_ID_RING_ID, &contact_indexes[0] );
if ( DB_OK != rc ) {
print_error_message( "Couldn't create v2 pkey index", c );
}
}
}
int
init_data_cb( db_t hdb, int version )
{
db_result_t rc = DB_OK;
int i;
/* Populate "contact" table using relative bounds fields. See
ittiadb/manuals/users-guide/api-c-database-access.html#relative-bound-fields
*/
static const db_bind_t binds_def[] = {
{ CONTACT_ID, DB_VARTYPE_UINT64, DB_BIND_OFFSET( contact_t, id ), DB_BIND_SIZE( contact_t, id ), -1, DB_BIND_RELATIVE },
{ CONTACT_NAME, DB_VARTYPE_WCHARSTR, DB_BIND_OFFSET( contact_t, name ), DB_BIND_SIZE( contact_t, name ), -1, DB_BIND_RELATIVE },
{ CONTACT_RING_ID, DB_VARTYPE_UINT64, DB_BIND_OFFSET( contact_t, ring_id ), DB_BIND_SIZE( contact_t, ring_id ), -1, DB_BIND_RELATIVE },
{ CONTACT_SEX, DB_VARTYPE_ANSISTR, DB_BIND_OFFSET( contact_t, sex ), DB_BIND_SIZE( contact_t, sex ), -1, DB_BIND_RELATIVE },
};
contact_t contacts2ins[] = {
{ 1, L"Bob", 1, "Mr" },
{ 2, L"Alice", 1, "Mrs" },
{ 3, L"Fred", 1, "Mr" },
{ 4, L"Mary", 1, "Mrs" },
};
db_row_t row;
db_table_cursor_t p = {
NULL, //< No index
DB_CAN_MODIFY | DB_LOCK_EXCLUSIVE
};
db_cursor_t c;
if( 1 > version || 2 < version ) {
print_error_message("Wrong DB schema version. Can't insert data.", NULL);
return -1;
}
fprintf( stdout, "Populating just creating DB v%d with data\n", version );
row = db_alloc_row( binds_def, DB_ARRAY_DIM( binds_def ) );
c = db_open_table_cursor(hdb, CONTACT_TABLE, &p);
for( i = 0; i < DB_ARRAY_DIM(contacts2ins) && DB_OK == rc; ++i ) {
if( 2 == version ) {
if( 0 == strcmp( contacts2ins[i].sex, "Mrs" ) ) {
strcpy( contacts2ins[i].sex, "1" );
}
else if( 0 == strcmp( contacts2ins[i].sex, "Mr" ) ) {
strcpy( contacts2ins[i].sex, "0" );
}
else {
strcpy( contacts2ins[i].sex, "2" );
}
}
rc = db_insert(c, row, &contacts2ins[i], 0);
}
db_free_row( row );
if( DB_OK != rc ) {
print_error_message( "Couldn't pupulate 'contact' table\n", c );
}
db_close_cursor(c);
return DB_OK == rc ? 0 : -1;
}
OGRFeature *OGRGRASSLayer::GetNextFeature()
{
CPLDebug ( "GRASS", "OGRGRASSLayer::GetNextFeature" );
OGRFeature *poFeature = NULL;
int cat;
// Get next iNextId
while ( true ) {
if( iNextId >= nTotalCount ) // No more features
{
// Close cursor / driver if opened
if ( bCursorOpened )
{
db_close_cursor ( poCursor);
bCursorOpened = false;
}
if ( poDriver )
{
db_close_database_shutdown_driver ( poDriver );
poDriver = NULL;
}
return NULL;
}
// Attributes
if( pszQuery != NULL && !paQueryMatch[iNextId] ) {
iNextId++;
continue;
}
// Spatial
if( m_poFilterGeom && !paSpatialMatch[iNextId] ) {
iNextId++;
continue;
}
break; // Attributes & spatial filter match
}
OGRGeometry *poOGR = GetFeatureGeometry ( iNextId, &cat );
poFeature = new OGRFeature( poFeatureDefn );
poFeature->SetGeometryDirectly( poOGR );
poFeature->SetFID ( iNextId );
iNextId++;
// Get attributes
CPLDebug ( "GRASS", "bHaveAttributes = %d", bHaveAttributes );
if ( bHaveAttributes )
{
if ( !poDriver )
{
StartDbDriver();
}
if ( poDriver ) {
if ( !bCursorOpened )
{
OpenSequentialCursor();
}
if ( bCursorOpened )
{
dbTable *table = db_get_cursor_table ( poCursor );
if ( iCurrentCat < cat )
{
while ( true ) {
int more;
if( db_fetch ( poCursor, DB_NEXT, &more) != DB_OK )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cannot fetch attributes.");
break;
}
if ( !more ) break;
dbColumn *column = db_get_table_column ( table, iCatField );
dbValue *value = db_get_column_value ( column );
iCurrentCat = db_get_value_int ( value );
if ( iCurrentCat >= cat ) break;
}
}
if ( cat == iCurrentCat )
{
SetAttributes ( poFeature, table );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined, "Attributes not found.");
}
}
}
}
else if ( iLayer > 0 ) // Add category
{
poFeature->SetField( 0, cat );
}
m_nFeaturesRead++;
return poFeature;
}
int query(struct Map_info *Map)
{
int i, j, idx, cat_no, nlines, type;
register int line_num;
struct line_pnts *Points;
struct line_cats *Cats;
struct field_info *Fi;
dbString stmt, value_string;
dbDriver *driver;
/* Initialize the Point struct */
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
G_message(_("Reading features..."));
/* Cycle through all lines and make a list of categories of 'qfield' for each category given by 'field' */
nlines = Vect_get_num_lines(Map);
for (line_num = 1; line_num <= nlines; line_num++) {
type = Vect_read_line(Map, Points, Cats, line_num);
if (!(type & options.type))
continue;
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == options.field) {
cat_no = Cats->cat[i];
idx = find_cat(cat_no, 1);
for (j = 0; j < Cats->n_cats; j++) {
if (Cats->field[j] == options.qfield) { /* Add to list */
if (Values[idx].nqcats == Values[idx].aqcats) { /* Alloc space */
Values[idx].aqcats += 2;
Values[idx].qcat =
(int *)G_realloc(Values[idx].qcat,
Values[idx].aqcats *
sizeof(int));
}
Values[idx].qcat[Values[idx].nqcats] = Cats->cat[j];
Values[idx].nqcats++;
}
}
}
}
/* If there is no field cat add cat -1, values for cat -1 are reported at the end */
Vect_cat_get(Cats, options.field, &cat_no);
if (cat_no == -1) {
idx = find_cat(cat_no, 1);
for (j = 0; j < Cats->n_cats; j++) {
if (Cats->field[j] == options.qfield) { /* Add to list */
if (Values[idx].nqcats == Values[idx].aqcats) { /* Alloc space */
Values[idx].aqcats += 2;
Values[idx].qcat =
(int *)G_realloc(Values[idx].qcat,
Values[idx].aqcats *
sizeof(int));
}
Values[idx].qcat[Values[idx].nqcats] = Cats->cat[j];
Values[idx].nqcats++;
}
}
}
G_percent(line_num, nlines, 2);
}
db_init_string(&stmt);
db_init_string(&value_string);
if ((Fi = Vect_get_field(Map, options.qfield)) == NULL)
G_fatal_error(_("Database connection not defined for layer %d. Use v.db.connect first."),
options.qfield);
/* Open driver */
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
/* Query the database for each category */
G_message(_("Querying database... "));
for (i = 0; i < vstat.rcat; i++) {
int j, ctype, nrows, more;
char buf[2000];
dbCursor cursor;
dbTable *table;
dbColumn *column;
dbValue *value;
G_debug(3, "cat %d", Values[i].cat);
G_percent(i + 1, vstat.rcat, 1);
/* Skip if cat is zero and large number of query categories (many features without category).
* It would cause problems on server side and take long time. Postgres limit is 10000 */
/* TODO: verify because no category is encoded as cat = -1, not cat = zero */
if (Values[i].cat == 0 && Values[i].nqcats > 1000) {
G_warning(_("Query for category '0' (no category) was not executed because of too many "
"(%d) query categories. All later reported values for cat 0 are not valid."),
Values[i].nqcats);
continue;
}
if (Values[i].nqcats > 0) {
sprintf(buf, "SELECT %s FROM %s WHERE", options.qcol, Fi->table);
db_set_string(&stmt, buf);
for (j = 0; j < Values[i].nqcats; j++) {
G_debug(4, " qcat %d", Values[i].qcat[j]);
if (j > 0)
db_append_string(&stmt, " OR");
sprintf(buf, " %s = %d", Fi->key, Values[i].qcat[j]);
db_append_string(&stmt, buf);
}
G_debug(4, " SQL: '%s'", db_get_string(&stmt));
if (db_open_select_cursor(driver, &stmt, &cursor, DB_SEQUENTIAL)
!= DB_OK)
G_fatal_error("Cannot open cursor: '%s'",
db_get_string(&stmt));
table = db_get_cursor_table(&cursor);
column = db_get_table_column(table, 0); /* first column */
value = db_get_column_value(column);
ctype = db_sqltype_to_Ctype(db_get_column_sqltype(column));
vstat.qtype = ctype;
nrows = db_get_num_rows(&cursor);
G_debug(4, " nrows = %d, columnt type = %d", nrows, ctype);
if (nrows != 1) {
if (nrows > 1) {
G_warning(_("Multiple query results, output value set to NULL (category [%d])"),
Values[i].cat);
}
Values[i].null = 1;
}
else {
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK)
G_fatal_error(_("Unable to fetch record"));
db_convert_column_value_to_string(column, &stmt);
G_debug(4, " value = %s", db_get_string(&stmt));
if (db_test_value_isnull(value)) {
Values[i].null = 1;
}
else {
switch (ctype) {
case (DB_C_TYPE_INT):
Values[i].i1 = db_get_value_int(value);
break;
case (DB_C_TYPE_DOUBLE):
Values[i].d1 = db_get_value_double(value);
break;
case (DB_C_TYPE_STRING):
Values[i].str1 = G_store(db_get_value_string(value));
break;
case (DB_C_TYPE_DATETIME):
db_convert_column_value_to_string(column,
&value_string);
Values[i].str1 =
G_store(db_get_string(&value_string));
}
Values[i].null = 0;
}
}
db_close_cursor(&cursor);
}
else { /* no qcats -> upload NULL */
Values[i].null = 1;
}
}
db_close_database_shutdown_driver(driver);
return 0;
}
OGRFeature *OGRGRASSLayer::GetFeature( long nFeatureId )
{
CPLDebug ( "GRASS", "OGRGRASSLayer::GetFeature nFeatureId = %d", nFeatureId );
int cat;
OGRFeature *poFeature = NULL;
OGRGeometry *poOGR = GetFeatureGeometry ( nFeatureId, &cat );
poFeature = new OGRFeature( poFeatureDefn );
poFeature->SetGeometryDirectly( poOGR );
poFeature->SetFID ( nFeatureId );
// Get attributes
if ( bHaveAttributes && !poDriver )
{
StartDbDriver();
}
if ( poDriver )
{
if ( bCursorOpened )
{
db_close_cursor ( poCursor);
bCursorOpened = false;
}
CPLDebug ( "GRASS", "Open cursor for key = %d", cat );
char buf[2000];
sprintf ( buf, "SELECT * FROM %s WHERE %s = %d",
poLink->table, poLink->key, cat );
db_set_string ( poDbString, buf);
if ( db_open_select_cursor ( poDriver, poDbString,
poCursor, DB_SEQUENTIAL) == DB_OK )
{
iCurrentCat = cat; // Not important
bCursorOpened = true;
}
else
{
CPLError( CE_Failure, CPLE_AppDefined, "Cannot open cursor.");
}
if ( bCursorOpened )
{
int more;
if( db_fetch ( poCursor, DB_NEXT, &more) != DB_OK )
{
CPLError( CE_Failure, CPLE_AppDefined, "Cannot fetch attributes.");
}
else
{
if ( !more )
{
CPLError( CE_Failure, CPLE_AppDefined, "Attributes not found.");
}
else
{
dbTable *table = db_get_cursor_table ( poCursor );
SetAttributes ( poFeature, table );
}
}
db_close_cursor ( poCursor);
bCursorOpened = false;
}
}
else if ( iLayer > 0 ) // Add category
{
poFeature->SetField( 0, cat );
}
m_nFeaturesRead++;
return poFeature;
}
int display_attr(struct Map_info *Map, int type, char *attrcol,
struct cat_list *Clist, LATTR *lattr, int chcat)
{
int i, ltype, more;
struct line_pnts *Points;
struct line_cats *Cats;
int cat;
char buf[2000];
struct field_info *fi;
dbDriver *driver;
dbString stmt, valstr, text;
dbCursor cursor;
dbTable *table;
dbColumn *column;
G_debug(2, "attr()");
if (attrcol == NULL || *attrcol == '\0') {
G_fatal_error(_("attrcol not specified, cannot display attributes"));
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
db_init_string(&stmt);
db_init_string(&valstr);
db_init_string(&text);
fi = Vect_get_field(Map, lattr->field);
if (fi == NULL)
return 1;
driver = db_start_driver_open_database(fi->driver, fi->database);
if (driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
fi->database,
fi->driver);
Vect_rewind(Map);
while (1) {
ltype = Vect_read_next_line(Map, Points, Cats);
if (ltype == -1)
G_fatal_error(_("Unable to read vector map"));
else if (ltype == -2) /* EOF */
break;
if (!(type & ltype) && !((type & GV_AREA) && (ltype & GV_CENTROID)))
continue; /* used for both lines and labels */
D_RGB_color(lattr->color.R, lattr->color.G, lattr->color.B);
D_text_size(lattr->size, lattr->size);
if (lattr->font)
D_font(lattr->font);
if (lattr->enc)
D_encoding(lattr->enc);
if (chcat) {
int found = 0;
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == Clist->field &&
Vect_cat_in_cat_list(Cats->cat[i], Clist)) {
found = 1;
break;
}
}
if (!found)
continue;
}
else if (Clist->field > 0) {
int found = 0;
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == Clist->field) {
found = 1;
break;
}
}
/* lines with no category will be displayed */
if (Cats->n_cats > 0 && !found)
continue;
}
if (Vect_cat_get(Cats, lattr->field, &cat)) {
int ncats = 0;
/* Read attribute from db */
db_free_string(&text);
for (i = 0; i < Cats->n_cats; i++) {
int nrows;
if (Cats->field[i] != lattr->field)
continue;
db_init_string(&stmt);
sprintf(buf, "select %s from %s where %s = %d", attrcol,
fi->table, fi->key, Cats->cat[i]);
G_debug(2, "SQL: %s", buf);
db_append_string(&stmt, buf);
if (db_open_select_cursor
(driver, &stmt, &cursor, DB_SEQUENTIAL) != DB_OK)
G_fatal_error(_("Unable to open select cursor: '%s'"),
db_get_string(&stmt));
nrows = db_get_num_rows(&cursor);
if (ncats > 0)
db_append_string(&text, "/");
if (nrows > 0) {
table = db_get_cursor_table(&cursor);
column = db_get_table_column(table, 0); /* first column */
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK)
continue;
db_convert_column_value_to_string(column, &valstr);
db_append_string(&text, db_get_string(&valstr));
}
else {
G_warning(_("No attribute found for cat %d: %s"), cat,
db_get_string(&stmt));
}
db_close_cursor(&cursor);
ncats++;
}
show_label_line(Points, ltype, lattr, db_get_string(&text));
}
}
db_close_database_shutdown_driver(driver);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
return 0;
}
/*!
\brief Write data to GRASS ASCII vector format
Prints message if some features without category are skipped.
\param[out] ascii pointer to the output ASCII file
\param[out] att att file (< version 5 only)
\param Map pointer to Map_info structure
\param ver version number 4 or 5
\param format format GV_ASCII_FORMAT_POINT or GV_ASCII_FORMAT_STD
\param dp number of significant digits
\param fs field separator
\param region_flag check region
\param type feature type filter
\param field field number
\param Clist list of categories to filter features or NULL
\param where SQL select where statement to filter features or NULL
\param column_names array of columns to be included to the output or NULL
"*" as the first item in the array indicates all columns
\param header TRUE to print also header
\return number of written features
\return -1 on error
*/
int Vect_write_ascii(FILE *ascii,
FILE *att, struct Map_info *Map, int ver,
int format, int dp, char *fs, int region_flag, int type,
int field, const struct cat_list *Clist, const char* where,
const char **column_names, int header)
{
int ltype, ctype, i, cat, line, left, right, found;
double *xptr, *yptr, *zptr, x, y;
static struct line_pnts *Points;
struct line_cats *Cats, *ACats;
char *xstring, *ystring, *zstring;
size_t xsize, ysize, zsize;
struct Cell_head window;
struct ilist *fcats;
int count, n_skipped;
/* where || columns */
struct field_info *Fi;
dbDriver *driver;
dbValue value;
dbHandle handle;
int *cats, ncats, more;
dbTable *Table;
dbString dbstring;
dbColumn *Column;
dbValue *Value;
char *buf;
size_t bufsize;
dbCursor cursor;
/* columns */
char **columns;
int *coltypes;
char *all_columns;
Fi = NULL;
driver = NULL;
columns = NULL;
coltypes = NULL;
all_columns = NULL;
G_zero(&value, sizeof(dbValue));
db_init_string(&dbstring);
xstring = NULL;
ystring = NULL;
zstring = NULL;
xsize = 0;
ysize = 0;
zsize = 0;
buf = NULL;
bufsize = 0;
/* get the region */
G_get_window(&window);
count = ncats = 0;
xstring = ystring = zstring = NULL;
cats = NULL;
if (field > 0 && (where || column_names)) {
Fi = Vect_get_field(Map, field);
if (!Fi) {
G_fatal_error(_("Database connection not defined for layer %d"),
field);
}
driver = db_start_driver(Fi->driver);
if (!driver)
G_fatal_error(_("Unable to start driver <%s>"), Fi->driver);
db_init_handle(&handle);
db_set_handle(&handle, Fi->database, NULL);
if (db_open_database(driver, &handle) != DB_OK)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
/* select cats (sorted array) */
ncats = db_select_int(driver, Fi->table, Fi->key, where, &cats);
G_debug(3, "%d categories selected from table <%s>", ncats, Fi->table);
if (!column_names) {
db_close_database(driver);
db_shutdown_driver(driver);
}
else {
int icol, ncols;
const char *col_name;
int len_all = 0;
db_set_string(&dbstring, Fi->table);
if (db_describe_table(driver, &dbstring, &Table) != DB_OK) {
G_warning(_("Unable to describe table <%s>"), Fi->table);
return -1;
}
ncols = db_get_table_number_of_columns(Table);
columns = (char **) G_malloc((ncols + 1) * sizeof(char *));
if (column_names[0] && strcmp(column_names[0], "*") == 0) {
/* all columns */
icol = 0;
for (i = 0; i < ncols; i++) {
col_name = db_get_column_name(db_get_table_column(Table, i));
/* key column skipped */
if (strcmp(Fi->key, col_name) != 0)
columns[icol++] = G_store(col_name);
}
columns[icol] = NULL;
}
else {
int j;
icol = 0;
i = 0;
while (column_names[i]) {
/* key column skipped */
if (strcmp(Fi->key, column_names[i]) != 0) {
found = 0;
for (j = 0; j < ncols; j++) {
col_name = db_get_column_name(db_get_table_column(Table, j));
if (strcmp(col_name, column_names[i]) == 0) {
columns[icol++] = G_store(col_name);
found = 1;
break;
}
}
if (!found) {
G_warning(_("Column <%s> does not exist"),
column_names[i]);
G_important_message(_("Available columns:"));
for (j = 0; j < ncols; j++) {
col_name = db_get_column_name(db_get_table_column(Table, j));
G_important_message("%s", col_name);
}
G_warning(_("Export cancelled"));
db_close_database(driver);
db_shutdown_driver(driver);
return -1;
}
}
i++;
}
columns[icol] = NULL;
}
db_zero_string(&dbstring);
db_free_table(Table);
Table = NULL;
if (columns[0]) {
/* selected columns only */
i = 0;
while (columns[i])
len_all += strlen(columns[i++]);
coltypes = G_malloc(i * sizeof(int));
all_columns = G_malloc(len_all + i + 2);
i = 0;
strcpy(all_columns, columns[0]);
while (columns[i]) {
/* get column types */
coltypes[i] = db_column_Ctype(driver, Fi->table, columns[i]);
if (coltypes[i] < 0) {
db_close_database(driver);
db_shutdown_driver(driver);
G_warning(_("Unknown type of column <%s>, export cancelled"),
columns[i]);
return -1;
}
if (i > 0) {
strcat(all_columns, ",");
strcat(all_columns, columns[i]);
}
i++;
}
}
else {
/* no column or only key column selected */
G_free(columns);
columns = NULL;
db_close_database(driver);
db_shutdown_driver(driver);
}
}
}
if (format == GV_ASCII_FORMAT_POINT && header) {
/* print header */
if (Map->head.with_z)
fprintf(ascii, "east%snorth%sheight%scat", fs, fs, fs);
else
fprintf(ascii, "east%snorth%scat", fs, fs);
if (columns) {
for (i = 0; columns[i]; i++) {
if (db_select_value
(driver, Fi->table, Fi->key, cat,
columns[i], &value) < 0)
G_fatal_error(_("Unable to select record from table <%s> (key %s, column %s)"),
Fi->table, Fi->key, columns[i]);
if (columns[i])
fprintf(ascii, "%s%s", fs, columns[i]);
else
fprintf(ascii, "%s", columns[i]); /* can not happen */
}
}
fprintf(ascii, "%s", HOST_NEWLINE);
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
ACats = Vect_new_cats_struct();
fcats = Vect_new_list();
/* by default, read_next_line will NOT read Dead lines */
/* but we can override that (in Level I only) by specifying */
/* the type -1, which means match all line types */
Vect_rewind(Map);
count = n_skipped = line = 0;
while (TRUE) {
ltype = Vect_read_next_line(Map, Points, Cats);
if (ltype == -1 ) { /* failure */
if (columns) {
db_close_database(driver);
db_shutdown_driver(driver);
free_col_arrays(coltypes, all_columns,
column_names && strcmp(column_names[0], "*") == 0 ? columns : NULL);
}
return -1;
}
if (ltype == -2) { /* EOF */
if (columns) {
db_close_database(driver);
db_shutdown_driver(driver);
free_col_arrays(coltypes, all_columns,
column_names && strcmp(column_names[0], "*") == 0 ? columns : NULL);
}
break;
}
line++;
if (!(ltype & type))
continue;
if (format == GV_ASCII_FORMAT_POINT && !(ltype & GV_POINTS))
continue;
found = get_cat(Cats, Clist, cats, ncats, field, &cat);
if (!found && field > 0 && ltype == GV_BOUNDARY &&
type & GV_AREA && Vect_level(Map) > 1) {
Vect_get_line_areas(Map, line, &left, &right);
if (left < 0)
left = Vect_get_isle_area(Map, abs(left));
if (left > 0) {
Vect_get_area_cats(Map, left, ACats);
found = get_cat(ACats, Clist, cats, ncats, field, &cat);
}
if (right < 0)
right = Vect_get_isle_area(Map, abs(right));
if (!found && right > 0) {
Vect_get_area_cats(Map, right, ACats);
found = get_cat(ACats, Clist, cats, ncats, field, &cat);
}
}
if (!found) {
if (Cats->n_cats < 1)
n_skipped++;
continue;
}
if (ver < 5) {
Vect_cat_get(Cats, 1, &cat);
}
switch (ltype) {
case GV_BOUNDARY:
if (ver == 5)
ctype = 'B';
else
ctype = 'A';
break;
case GV_CENTROID:
if (ver < 5) {
if (att != NULL) {
if (cat > 0) {
G_rasprintf(&xstring, &xsize, "%.*f", dp, Points->x[0]);
G_trim_decimal(xstring);
G_rasprintf(&ystring, &ysize, "%.*f", dp, Points->y[0]);
G_trim_decimal(ystring);
fprintf(att, "A %s %s %d%s", xstring, ystring, cat, HOST_NEWLINE);
}
}
continue;
}
ctype = 'C';
break;
case GV_LINE:
ctype = 'L';
break;
case GV_POINT:
ctype = 'P';
break;
case GV_FACE:
ctype = 'F';
break;
case GV_KERNEL:
ctype = 'K';
break;
default:
ctype = 'X';
G_warning(_("Unknown feature type %d"), (int)ltype);
break;
}
if (format == GV_ASCII_FORMAT_POINT) {
if (region_flag) {
if ((window.east < Points->x[0]) ||
(window.west > Points->x[0]))
continue;
}
G_rasprintf(&xstring, &xsize, "%.*f", dp, Points->x[0]);
G_trim_decimal(xstring);
if (region_flag) {
if ((window.north < Points->y[0]) ||
(window.south > Points->y[0]))
continue;
}
G_rasprintf(&ystring, &ysize, "%.*f", dp, Points->y[0]);
G_trim_decimal(ystring);
Vect_field_cat_get(Cats, field, fcats);
if (Map->head.with_z && ver == 5) {
if (region_flag) {
if ((window.top < Points->z[0]) ||
(window.bottom > Points->z[0]))
continue;
}
G_rasprintf(&zstring, &zsize, "%.*f", dp, Points->z[0]);
G_trim_decimal(zstring);
fprintf(ascii, "%s%s%s%s%s", xstring, fs, ystring, fs,
zstring);
}
else {
fprintf(ascii, "%s%s%s", xstring, fs, ystring);
}
if (fcats->n_values > 0 && cat > -1) {
if (fcats->n_values > 1) {
G_warning(_("Feature has more categories. Only one category (%d) "
"is exported."), cat);
}
fprintf(ascii, "%s%d", fs, cat);
/* print attributes */
if (columns) {
G_rasprintf(&buf, &bufsize, "SELECT %s FROM %s WHERE %s = %d",
all_columns, Fi->table, Fi->key, cat);
G_debug(2, "SQL: %s", buf);
db_set_string(&dbstring, buf);
if (db_open_select_cursor
(driver, &dbstring, &cursor, DB_SEQUENTIAL) != DB_OK) {
db_close_database(driver);
db_shutdown_driver(driver);
G_fatal_error(_("Cannot select attributes for cat = %d"),
cat);
}
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK) {
db_close_database(driver);
db_shutdown_driver(driver);
G_fatal_error(_("Unable to fetch data from table"));
}
Table = db_get_cursor_table(&cursor);
for (i = 0; columns[i]; i++) {
Column = db_get_table_column(Table, i);
Value = db_get_column_value(Column);
if (db_test_value_isnull(Value)) {
fprintf(ascii, "%s", fs);
}
else {
switch(coltypes[i])
{
case DB_C_TYPE_INT: {
fprintf(ascii, "%s%d", fs, db_get_value_int(Value));
break;
}
case DB_C_TYPE_DOUBLE: {
fprintf(ascii, "%s%.*f", fs, dp, db_get_value_double(Value));
break;
}
case DB_C_TYPE_STRING: {
fprintf(ascii, "%s%s", fs, db_get_value_string(Value));
break;
}
case DB_C_TYPE_DATETIME: {
break;
}
case -1:
G_fatal_error(_("Column <%s> not found in table <%s>"),
columns[i], Fi->table);
default: G_fatal_error(_("Column <%s>: unsupported data type"),
columns[i]);
}
}
}
db_close_cursor(&cursor);
}
}
fprintf(ascii, "%s", HOST_NEWLINE);
}
else if (format == GV_ASCII_FORMAT_STD) {
/* FORMAT_STANDARD */
if (ver == 5 && Cats->n_cats > 0)
fprintf(ascii, "%c %d %d%s", ctype, Points->n_points,
Cats->n_cats, HOST_NEWLINE);
else
fprintf(ascii, "%c %d%s", ctype, Points->n_points, HOST_NEWLINE);
xptr = Points->x;
yptr = Points->y;
zptr = Points->z;
while (Points->n_points--) {
G_rasprintf(&xstring, &xsize, "%.*f", dp, *xptr++);
G_trim_decimal(xstring);
G_rasprintf(&ystring, &ysize, "%.*f", dp, *yptr++);
G_trim_decimal(ystring);
if (ver == 5) {
if (Map->head.with_z) {
G_rasprintf(&zstring, &zsize, "%.*f", dp, *zptr++);
G_trim_decimal(zstring);
fprintf(ascii, " %-12s %-12s %-12s%s", xstring,
ystring, zstring, HOST_NEWLINE);
}
else {
fprintf(ascii, " %-12s %-12s%s", xstring, ystring, HOST_NEWLINE);
}
} /*Version 4 */
else {
fprintf(ascii, " %-12s %-12s%s", ystring, xstring, HOST_NEWLINE);
}
}
if (ver == 5) {
for (i = 0; i < Cats->n_cats; i++) {
fprintf(ascii, " %-5d %-10d%s", Cats->field[i],
Cats->cat[i], HOST_NEWLINE);
}
}
else {
if (cat > -1) {
if (ltype == GV_POINT) {
G_rasprintf(&xstring, &xsize, "%.*f", dp, Points->x[0]);
G_trim_decimal(xstring);
G_rasprintf(&ystring, &ysize, "%.*f", dp, Points->y[0]);
G_trim_decimal(ystring);
fprintf(att, "P %s %s %d%s", xstring, ystring, cat, HOST_NEWLINE);
}
else {
x = (Points->x[1] + Points->x[0]) / 2;
y = (Points->y[1] + Points->y[0]) / 2;
G_rasprintf(&xstring, &xsize, "%.*f", dp, x);
G_trim_decimal(xstring);
G_rasprintf(&ystring, &ysize, "%.*f", dp, y);
G_trim_decimal(ystring);
fprintf(att, "L %s %s %d%s", xstring, ystring, cat, HOST_NEWLINE);
}
}
}
}
else if (format == GV_ASCII_FORMAT_WKT) {
if (ltype & (GV_BOUNDARY | GV_CENTROID | GV_FACE | GV_KERNEL))
continue;
/* Well-Known Text */
Vect_sfa_line_astext(Points, ltype, Vect_is_3d(Map), dp, ascii);
count++;
}
else {
G_fatal_error(_("Unknown format"));
}
count++;
}
if (format == GV_ASCII_FORMAT_WKT) {
/* process areas - topology required */
int i, area, nareas, isle, nisles;
if (Vect_level(Map) < 2) {
G_warning(_("Topology not available, unable to process areas"));
nareas = 0;
}
else {
nareas = Vect_get_num_areas(Map);
}
for (area = 1; area <= nareas; area++) {
if (!Vect_area_alive(Map, area)) /* skip dead areas */
continue;
if (Vect_get_area_cat(Map, area, field) < 0)
continue;
/* get boundary -> linearring */
if (Vect_get_area_points(Map, area, Points) < 0) {
G_warning(_("Unable to get boundary of area id %d"), area);
continue;
}
fprintf(ascii, "POLYGON(");
/* write outter ring */
Vect_sfa_line_astext(Points, GV_BOUNDARY, 0, dp, ascii); /* boundary is always 2D */
/* get isles (holes) -> inner rings */
nisles = Vect_get_area_num_isles(Map, area);
for (i = 0; i < nisles; i++) {
/* get isle boundary -> linearring */
isle = Vect_get_area_isle(Map, area, i);
if (Vect_get_isle_points(Map, isle, Points) < 0) {
G_warning(_("Unable to get boundary of isle id %d (area id %d)"), isle, area);
continue;
}
fprintf(ascii, ", ");
/* write inner ring */
Vect_sfa_line_astext(Points, GV_BOUNDARY, 0, dp, ascii); /* boundary is always 2D */
}
fprintf(ascii, ")%s", HOST_NEWLINE);
count++;
}
}
if (n_skipped > 0)
G_important_message(_("%d features without category skipped. To export also "
"features without category use '%s=-1'."), n_skipped, "layer");
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
Vect_destroy_cats_struct(ACats);
return count;
}
void QgsGrassVectorMapLayer::load()
{
clear();
if ( !mMap )
{
return;
}
// Attributes are not loaded for topo layers in which case field == 0
if ( mField == 0 )
{
return;
}
QgsDebugMsg( QString( "cidxFieldIndex() = %1 cidxFieldNumCats() = %2" ).arg( cidxFieldIndex() ).arg( cidxFieldNumCats() ) );
mFieldInfo = Vect_get_field( mMap->map(), mField ); // should work also with field = 0
if ( !mFieldInfo )
{
QgsDebugMsg( "No field info -> no attribute table" );
}
else
{
QgsDebugMsg( "Field info found -> open database" );
QFileInfo di( mMap->grassObject().mapsetPath() + "/vector/" + mMap->grassObject().name() + "/dbln" );
mLastLoaded = di.lastModified();
QString error;
dbDriver *databaseDriver = openDriver( error );
if ( !databaseDriver || !error.isEmpty() )
{
QgsDebugMsg( error );
}
else
{
QgsDebugMsg( "Database opened -> open select cursor" );
QgsGrass::lock(); // not sure if lock is necessary
dbString dbstr;
db_init_string( &dbstr );
db_set_string( &dbstr, ( char * )"select * from " );
db_append_string( &dbstr, mFieldInfo->table );
QgsDebugMsg( QString( "SQL: %1" ).arg( db_get_string( &dbstr ) ) );
dbCursor databaseCursor;
if ( db_open_select_cursor( databaseDriver, &dbstr, &databaseCursor, DB_SCROLL ) != DB_OK )
{
db_close_database_shutdown_driver( databaseDriver );
QgsGrass::warning( "Cannot select attributes from table '" + QString( mFieldInfo->table ) + "'" );
}
else
{
#ifdef QGISDEBUG
int nRecords = db_get_num_rows( &databaseCursor );
QgsDebugMsg( QString( "Number of records: %1" ).arg( nRecords ) );
#endif
dbTable *databaseTable = db_get_cursor_table( &databaseCursor );
int nColumns = db_get_table_number_of_columns( databaseTable );
// Read columns' description
for ( int i = 0; i < nColumns; i++ )
{
QPair<double, double> minMax( DBL_MAX, -DBL_MAX );
dbColumn *column = db_get_table_column( databaseTable, i );
int ctype = db_sqltype_to_Ctype( db_get_column_sqltype( column ) );
QVariant::Type qtype = QVariant::String; //default to string
QgsDebugMsg( QString( "column = %1 ctype = %2" ).arg( db_get_column_name( column ) ).arg( ctype ) );
QString ctypeStr;
switch ( ctype )
{
case DB_C_TYPE_INT:
ctypeStr = QStringLiteral( "integer" );
qtype = QVariant::Int;
break;
case DB_C_TYPE_DOUBLE:
ctypeStr = QStringLiteral( "double" );
qtype = QVariant::Double;
break;
case DB_C_TYPE_STRING:
ctypeStr = QStringLiteral( "string" );
qtype = QVariant::String;
break;
case DB_C_TYPE_DATETIME:
ctypeStr = QStringLiteral( "datetime" );
qtype = QVariant::String;
break;
}
mTableFields.append( QgsField( db_get_column_name( column ), qtype, ctypeStr,
db_get_column_length( column ), db_get_column_precision( column ) ) );
mMinMax << minMax;
if ( G_strcasecmp( db_get_column_name( column ), mFieldInfo->key ) == 0 )
{
mKeyColumn = i;
}
}
if ( mKeyColumn < 0 )
{
mTableFields.clear();
QgsGrass::warning( QObject::tr( "Key column '%1' not found in the table '%2'" ).arg( mFieldInfo->key, mFieldInfo->table ) );
}
else
{
mHasTable = true;
// Read attributes to the memory
for ( ;; )
{
int more;
if ( db_fetch( &databaseCursor, DB_NEXT, &more ) != DB_OK )
{
QgsDebugMsg( "Cannot fetch DB record" );
break;
}
if ( !more )
{
break; // no more records
}
// Check cat value
dbColumn *column = db_get_table_column( databaseTable, mKeyColumn );
dbValue *value = db_get_column_value( column );
if ( db_test_value_isnull( value ) )
{
continue;
}
int cat = db_get_value_int( value );
if ( cat < 0 )
{
continue;
}
QList<QVariant> values;
for ( int i = 0; i < nColumns; i++ )
{
column = db_get_table_column( databaseTable, i );
int sqltype = db_get_column_sqltype( column );
int ctype = db_sqltype_to_Ctype( sqltype );
value = db_get_column_value( column );
db_convert_value_to_string( value, sqltype, &dbstr );
QgsDebugMsgLevel( QString( "column = %1 value = %2" ).arg( db_get_column_name( column ), db_get_string( &dbstr ) ), 3 );
QVariant variant;
if ( !db_test_value_isnull( value ) )
{
int iv;
double dv;
//layer.mAttributes[layer.nAttributes].values[i] = strdup( db_get_string( &dbstr ) );
switch ( ctype )
{
case DB_C_TYPE_INT:
iv = db_get_value_int( value );
variant = QVariant( iv );
mMinMax[i].first = std::min( mMinMax[i].first, ( double )iv );
mMinMax[i].second = std::min( mMinMax[i].second, ( double )iv );
break;
case DB_C_TYPE_DOUBLE:
dv = db_get_value_double( value );
variant = QVariant( dv );
mMinMax[i].first = std::min( mMinMax[i].first, dv );
mMinMax[i].second = std::min( mMinMax[i].second, dv );
break;
case DB_C_TYPE_STRING:
// Store as byte array so that codec may be used later
variant = QVariant( QByteArray( db_get_value_string( value ) ) );
break;
case DB_C_TYPE_DATETIME:
variant = QVariant( QByteArray( db_get_string( &dbstr ) ) );
break;
default:
variant = QVariant( QByteArray( db_get_string( &dbstr ) ) );
}
}
QgsDebugMsgLevel( QString( "column = %1 variant = %2" ).arg( db_get_column_name( column ), variant.toString() ), 3 );
values << variant;
}
mAttributes.insert( cat, values );
}
}
mValid = true;
db_close_cursor( &databaseCursor );
db_close_database_shutdown_driver( databaseDriver );
db_free_string( &dbstr );
QgsDebugMsg( QString( "mTableFields.size = %1" ).arg( mTableFields.size() ) );
QgsDebugMsg( QString( "number of attributes = %1" ).arg( mAttributes.size() ) );
}
QgsGrass::unlock();
}
}
// Add cat if no attribute fields exist (otherwise qgis crashes)
if ( mTableFields.size() == 0 )
{
mKeyColumn = 0;
mTableFields.append( QgsField( QStringLiteral( "cat" ), QVariant::Int, QStringLiteral( "integer" ) ) );
QPair<double, double> minMax( 0, 0 );
if ( cidxFieldIndex() >= 0 )
{
int ncats, cat, type, id;
ncats = Vect_cidx_get_num_cats_by_index( mMap->map(), cidxFieldIndex() );
if ( ncats > 0 )
{
Vect_cidx_get_cat_by_index( mMap->map(), cidxFieldIndex(), 0, &cat, &type, &id );
minMax.first = cat;
Vect_cidx_get_cat_by_index( mMap->map(), cidxFieldIndex(), ncats - 1, &cat, &type, &id );
minMax.second = cat;
}
}
mMinMax << minMax;
}
mFields = mTableFields;
mAttributeFields = mTableFields;
QgsDebugMsg( QString( "layer loaded mTableFields.size() = %1 mAttributes.size() = %2" ).arg( mTableFields.size() ).arg( mAttributes.size() ) );
mValid = true;
}
/* return -1 on error */
static int read_dblinks_ogr(struct Map_info *Map)
{
struct dblinks *dbl;
dbl = Map->dblnk;
G_debug(3, "Searching for FID column in OGR DB");
#ifndef HAVE_OGR
G_warning(_("GRASS is not compiled with OGR support"));
#else
#if GDAL_VERSION_NUM > 1320 && HAVE_OGR /* seems to be fixed after 1320 release */
int nLayers;
char *ogr_fid_col;
G_debug(3, "GDAL_VERSION_NUM: %d", GDAL_VERSION_NUM);
if (Map->fInfo.ogr.ds == NULL) {
/* open the connection to fetch the FID column name */
OGRRegisterAll();
/* data source handle */
Map->fInfo.ogr.ds = OGROpen(Map->fInfo.ogr.dsn, FALSE, NULL);
if (Map->fInfo.ogr.ds == NULL) {
G_warning(_("Unable to open OGR data source '%s'"),
Map->fInfo.ogr.dsn);
return -1;
}
}
if (Map->fInfo.ogr.layer == NULL) {
/* get layer number */
nLayers = OGR_DS_GetLayerCount(Map->fInfo.ogr.ds); /* Layers = Maps in OGR DB */
G_debug(3, "%d layers (maps) found in data source", nLayers);
G_debug(3, "Trying to open OGR layer: %s", Map->fInfo.ogr.layer_name);
if (Map->fInfo.ogr.layer_name) {
Map->fInfo.ogr.layer = OGR_DS_GetLayerByName(Map->fInfo.ogr.ds, Map->fInfo.ogr.layer_name);
if (Map->fInfo.ogr.layer == NULL) {
OGR_DS_Destroy(Map->fInfo.ogr.ds);
Map->fInfo.ogr.ds = NULL;
G_warning(_("Unable to open OGR layer <%s>"),
Map->fInfo.ogr.layer_name);
return -1;
}
}
}
/* get fid column */
ogr_fid_col = G_store(OGR_L_GetFIDColumn(Map->fInfo.ogr.layer));
G_debug(3, "Using FID column <%s> in OGR DB", ogr_fid_col);
Vect_add_dblink(dbl, 1, Map->fInfo.ogr.layer_name,
Map->fInfo.ogr.layer_name, ogr_fid_col,
Map->fInfo.ogr.dsn, "ogr");
#else
dbDriver *driver;
dbCursor cursor;
dbString sql;
int FID = 0, OGC_FID = 0, OGR_FID = 0, GID = 0;
G_debug(3, "GDAL_VERSION_NUM: %d", GDAL_VERSION_NUM);
/* FID is not available for all OGR drivers */
db_init_string(&sql);
driver = db_start_driver_open_database("ogr", Map->fInfo.ogr.dsn);
if (driver == NULL) {
G_warning(_("Unable to open OGR DBMI driver"));
return -1;
}
/* this is a bit stupid, but above FID auto-detection doesn't work yet...: */
db_auto_print_errors(0);
sprintf(buf, "select FID from %s where FID > 0",
Map->fInfo.ogr.layer_name);
db_set_string(&sql, buf);
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) !=
DB_OK) {
/* FID not available, so we try ogc_fid */
G_debug(3, "Failed. Now searching for ogc_fid column in OGR DB");
sprintf(buf, "select ogc_fid from %s where ogc_fid > 0",
Map->fInfo.ogr.layer_name);
db_set_string(&sql, buf);
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) !=
DB_OK) {
/* Neither FID nor ogc_fid available, so we try ogr_fid */
G_debug(3,
"Failed. Now searching for ogr_fid column in OGR DB");
sprintf(buf, "select ogr_fid from %s where ogr_fid > 0",
Map->fInfo.ogr.layer_name);
db_set_string(&sql, buf);
if (db_open_select_cursor
(driver, &sql, &cursor, DB_SEQUENTIAL) != DB_OK) {
/* Neither FID nor ogc_fid available, so we try gid */
G_debug(3,
"Failed. Now searching for gid column in OGR DB");
sprintf(buf, "select gid from %s where gid > 0",
Map->fInfo.ogr.layer_name);
db_set_string(&sql, buf);
if (db_open_select_cursor
(driver, &sql, &cursor, DB_SEQUENTIAL) != DB_OK) {
/* neither FID nor ogc_fid nor ogr_fid nor gid available */
G_warning(_("All FID tests failed. Neither 'FID' nor 'ogc_fid' "
"nor 'ogr_fid' nor 'gid' available in OGR DB table"));
db_close_database_shutdown_driver(driver);
return 0;
}
else
GID = 1;
}
else
OGR_FID = 1;
}
else
OGC_FID = 1;
}
else
FID = 1;
G_debug(3, "FID: %d, OGC_FID: %d, OGR_FID: %d, GID: %d", FID, OGC_FID,
OGR_FID, GID);
db_close_cursor(&cursor);
db_close_database_shutdown_driver(driver);
db_auto_print_errors(1);
if (FID) {
G_debug(3, "Using FID column in OGR DB");
Vect_add_dblink(dbl, 1, Map->fInfo.ogr.layer_name, Map->fInfo.ogr.layer_name, "FID",
Map->fInfo.ogr.dsn, "ogr");
}
else {
if (OGC_FID) {
G_debug(3, "Using ogc_fid column in OGR DB");
Vect_add_dblink(dbl, 1, Map->fInfo.ogr.layer_name, Map->fInfo.ogr.layer_name,
"ogc_fid", Map->fInfo.ogr.dsn, "ogr");
}
else {
if (OGR_FID) {
G_debug(3, "Using ogr_fid column in OGR DB");
Vect_add_dblink(dbl, 1, Map->fInfo.ogr.layer_name, Map->fInfo.ogr.layer_name,
"ogr_fid", Map->fInfo.ogr.dsn, "ogr");
}
else {
if (GID) {
G_debug(3, "Using gid column in OGR DB");
Vect_add_dblink(dbl, 1, Map->fInfo.ogr.layer_name,
Map->fInfo.ogr.layer_name, "gid",
Map->fInfo.ogr.dsn, "ogr");
}
}
}
}
#endif /* GDAL_VERSION_NUM > 1320 && HAVE_OGR */
return 1;
#endif /* HAVE_GDAL */
}