/*------------------------------------------------------------------------------------------------*/
int P_Create_Aux4_Table(dbDriver * driver, char *tab_name)
{
dbTable *auxiliar_tab;
dbColumn *column;
auxiliar_tab = db_alloc_table(4);
db_set_table_name(auxiliar_tab, tab_name);
db_set_table_description(auxiliar_tab,
"Intermediate interpolated values");
column = db_get_table_column(auxiliar_tab, 0);
db_set_column_name(column, "ID");
db_set_column_sqltype(column, DB_SQL_TYPE_INTEGER);
column = db_get_table_column(auxiliar_tab, 1);
db_set_column_name(column, "Interp");
db_set_column_sqltype(column, DB_SQL_TYPE_REAL);
column = db_get_table_column(auxiliar_tab, 2);
db_set_column_name(column, "X");
db_set_column_sqltype(column, DB_SQL_TYPE_DOUBLE_PRECISION);
column = db_get_table_column(auxiliar_tab, 3);
db_set_column_name(column, "Y");
db_set_column_sqltype(column, DB_SQL_TYPE_DOUBLE_PRECISION);
if (db_create_table(driver, auxiliar_tab) == DB_OK) {
G_debug(1, _("<%s> created in database."), tab_name);
return TRUE;
}
else
G_warning(_("<%s> has not been created in database."), tab_name);
return FALSE;
}
int execute_random(struct rr_state *theState)
{
long nt;
long nc;
struct Cell_head window;
int nrows, ncols, row, col;
int infd, cinfd, outfd;
struct Map_info Out;
struct field_info *fi;
dbTable *table;
dbColumn *column;
dbString sql;
dbDriver *driver;
struct line_pnts *Points;
struct line_cats *Cats;
int cat;
RASTER_MAP_TYPE type;
int do_check;
G_get_window(&window);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
/* open the data files, input raster should be set-up already */
if ((infd = theState->fd_old) < 0)
G_fatal_error(_("Unable to open raster map <%s>"),
theState->inraster);
if (theState->docover == TRUE) {
if ((cinfd = theState->fd_cold) < 0)
G_fatal_error(_("Unable to open raster map <%s>"),
theState->inrcover);
}
if (theState->outraster != NULL) {
if (theState->docover == TRUE)
type = theState->cover.type;
else
type = theState->buf.type;
outfd = Rast_open_new(theState->outraster, type);
theState->fd_new = outfd;
}
if (theState->outvector) {
if (Vect_open_new(&Out, theState->outvector, theState->z_geometry) < 0)
G_fatal_error(_("Unable to create vector map <%s>"),
theState->outvector);
Vect_hist_command(&Out);
fi = Vect_default_field_info(&Out, 1, NULL, GV_1TABLE);
driver =
db_start_driver_open_database(fi->driver,
Vect_subst_var(fi->database, &Out));
if (!driver)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Vect_subst_var(fi->database, &Out), fi->driver);
db_set_error_handler_driver(driver);
Vect_map_add_dblink(&Out, 1, NULL, fi->table, GV_KEY_COLUMN, fi->database,
fi->driver);
if (theState->docover == TRUE)
table = db_alloc_table(3);
else
table = db_alloc_table(2);
db_set_table_name(table, fi->table);
column = db_get_table_column(table, 0);
db_set_column_name(column, GV_KEY_COLUMN);
db_set_column_sqltype(column, DB_SQL_TYPE_INTEGER);
column = db_get_table_column(table, 1);
db_set_column_name(column, "value");
db_set_column_sqltype(column, DB_SQL_TYPE_DOUBLE_PRECISION);
if (theState->docover == TRUE) {
column = db_get_table_column(table, 2);
db_set_column_name(column, "covervalue");
db_set_column_sqltype(column, DB_SQL_TYPE_DOUBLE_PRECISION);
}
if (db_create_table(driver, table) != DB_OK)
G_warning(_("Cannot create new table"));
db_begin_transaction(driver);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
db_init_string(&sql);
}
if (theState->outvector && theState->outraster)
G_message(_("Writing raster map <%s> and vector map <%s> ..."),
theState->outraster, theState->outvector);
else if (theState->outraster)
G_message(_("Writing raster map <%s> ..."), theState->outraster);
else if (theState->outvector)
G_message(_("Writing vector map <%s> ..."), theState->outvector);
G_percent(0, theState->nRand, 2);
init_rand();
nc = (theState->use_nulls) ? theState->nCells :
theState->nCells - theState->nNulls;
nt = theState->nRand; /* Number of points to generate */
cat = 1;
/* Execute for loop for every row if nt>1 */
for (row = 0; row < nrows && nt; row++) {
Rast_get_row(infd, theState->buf.data.v, row, theState->buf.type);
if (theState->docover == TRUE) {
Rast_get_row(cinfd, theState->cover.data.v, row,
theState->cover.type);
}
for (col = 0; col < ncols && nt; col++) {
do_check = 0;
if (theState->use_nulls || !is_null_value(theState->buf, col))
do_check = 1;
if (do_check && theState->docover == TRUE) { /* skip no data cover points */
if (!theState->use_nulls &&
is_null_value(theState->cover, col))
do_check = 0;
}
if (do_check && make_rand() % nc < nt) {
nt--;
if (is_null_value(theState->buf, col))
cpvalue(&theState->nulls, 0, &theState->buf, col);
if (theState->docover == TRUE) {
if (is_null_value(theState->cover, col))
cpvalue(&theState->cnulls, 0, &theState->cover, col);
}
if (theState->outvector) {
double x, y, val, coverval;
char buf[500];
Vect_reset_line(Points);
Vect_reset_cats(Cats);
x = window.west + (col + .5) * window.ew_res;
y = window.north - (row + .5) * window.ns_res;
val = cell_as_dbl(&theState->buf, col);
if (theState->docover == 1)
coverval = cell_as_dbl(&theState->cover, col);
if (theState->z_geometry)
Vect_append_point(Points, x, y, val);
else
Vect_append_point(Points, x, y, 0.0);
Vect_cat_set(Cats, 1, cat);
Vect_write_line(&Out, GV_POINT, Points, Cats);
if (theState->docover == 1)
if (is_null_value(theState->cover, col))
sprintf(buf,
"insert into %s values ( %d, %f, NULL )",
fi->table, cat, val);
else
sprintf(buf,
"insert into %s values ( %d, %f, %f )",
fi->table, cat, val, coverval);
else
sprintf(buf, "insert into %s values ( %d, %f )",
fi->table, cat, val);
db_set_string(&sql, buf);
if (db_execute_immediate(driver, &sql) != DB_OK)
G_fatal_error(_("Cannot insert new record: %s"),
db_get_string(&sql));
cat++;
}
G_percent((theState->nRand - nt), theState->nRand, 2);
}
else {
set_to_null(&theState->buf, col);
if (theState->docover == 1)
set_to_null(&theState->cover, col);
}
if (do_check)
nc--;
}
while (col < ncols) {
set_to_null(&theState->buf, col);
if (theState->docover == 1)
set_to_null(&theState->cover, col);
col++;
}
if (theState->outraster) {
if (theState->docover == 1)
Rast_put_row(outfd, theState->cover.data.v,
theState->cover.type);
else
Rast_put_row(outfd, theState->buf.data.v,
theState->buf.type);
}
}
/* Catch any remaining rows in the window */
if (theState->outraster && row < nrows) {
for (col = 0; col < ncols; col++) {
if (theState->docover == 1)
set_to_null(&theState->cover, col);
else
set_to_null(&theState->buf, col);
}
for (; row < nrows; row++) {
if (theState->docover == 1)
Rast_put_row(outfd, theState->cover.data.v,
theState->cover.type);
else
Rast_put_row(outfd, theState->buf.data.v,
theState->buf.type);
}
}
if (nt > 0)
G_warning(_("Only [%ld] random points created"),
theState->nRand - nt);
/* close files */
Rast_close(infd);
if (theState->docover == TRUE)
Rast_close(cinfd);
if (theState->outvector) {
db_commit_transaction(driver);
if (db_create_index2(driver, fi->table, GV_KEY_COLUMN) != DB_OK)
G_warning(_("Unable to create index"));
if (db_grant_on_table
(driver, fi->table, DB_PRIV_SELECT,
DB_GROUP | DB_PUBLIC) != DB_OK) {
G_fatal_error(_("Unable to grant privileges on table <%s>"),
fi->table);
}
db_close_database_shutdown_driver(driver);
if (theState->notopol != 1)
Vect_build(&Out);
Vect_close(&Out);
}
if (theState->outraster)
Rast_close(outfd);
return 0;
} /* execute_random() */
/* describe table, if c is not NULL cur->cols and cur->ncols is also set
* cursor may be null
*/
int describe_table(OGRLayerH hLayer, dbTable ** table, cursor * c)
{
int i, ncols, kcols;
dbColumn *column;
OGRFeatureDefnH hFeatureDefn;
OGRFieldDefnH hFieldDefn;
const char *fieldName;
int ogrType;
int *cols;
G_debug(3, "describe_table()");
hFeatureDefn = OGR_L_GetLayerDefn(hLayer);
ncols = OGR_FD_GetFieldCount(hFeatureDefn);
G_debug(3, "ncols = %d", ncols);
/* Identify known columns */
cols = (int *)G_malloc(ncols * sizeof(int));
kcols = 0;
for (i = 0; i < ncols; i++) {
hFieldDefn = OGR_FD_GetFieldDefn(hFeatureDefn, i);
ogrType = OGR_Fld_GetType(hFieldDefn);
OGR_Fld_GetNameRef(hFieldDefn);
fieldName = OGR_Fld_GetNameRef(hFieldDefn);
if (ogrType != OFTInteger && ogrType != OFTReal &&
ogrType != OFTString && ogrType != OFTDate &&
ogrType != OFTTime && ogrType != OFTDateTime ) {
G_warning(_("OGR driver: column '%s', OGR type %d is not supported"),
fieldName, ogrType);
cols[i] = 0;
}
else {
cols[i] = 1;
kcols++;
}
}
if (!(*table = db_alloc_table(kcols))) {
return DB_FAILED;
}
/* set the table name */
/* TODO */
db_set_table_name(*table, "");
/* set the table description */
db_set_table_description(*table, "");
/* TODO */
/*
db_set_table_delete_priv_granted (*table);
db_set_table_insert_priv_granted (*table);
db_set_table_delete_priv_not_granted (*table);
db_set_table_insert_priv_not_granted (*table);
*/
for (i = 0; i < ncols; i++) {
int sqlType;
int size, precision, scale;
if (!(cols[i]))
continue; /* unknown type */
hFieldDefn = OGR_FD_GetFieldDefn(hFeatureDefn, i);
ogrType = OGR_Fld_GetType(hFieldDefn);
fieldName = OGR_Fld_GetNameRef(hFieldDefn);
G_debug(3, "field %d : ogrType = %d, name = %s", i, ogrType,
fieldName);
switch (ogrType) {
case OFTInteger:
sqlType = DB_SQL_TYPE_INTEGER;
size = OGR_Fld_GetWidth(hFieldDefn); /* OK ? */
precision = 0;
break;
case OFTReal:
sqlType = DB_SQL_TYPE_DOUBLE_PRECISION;
size = OGR_Fld_GetWidth(hFieldDefn); /* OK ? */
precision = OGR_Fld_GetPrecision(hFieldDefn);
break;
case OFTString:
case OFTDate:
case OFTTime:
case OFTDateTime:
sqlType = DB_SQL_TYPE_CHARACTER;
size = OGR_Fld_GetWidth(hFieldDefn);
if (size == 0) {
G_warning(_("column '%s', type 'string': unknown width -> stored as varchar(250) "
"some data may be lost"), fieldName);
size = 250;
}
precision = 0;
break;
default:
G_warning(_("Unknown type"));
break;
}
column = db_get_table_column(*table, i);
db_set_column_host_type(column, ogrType);
db_set_column_sqltype(column, sqlType);
db_set_column_name(column, fieldName);
db_set_column_length(column, size);
db_set_column_precision(column, precision);
/* TODO */
scale = 0;
/*
db_set_column_scale (column, scale);
*/
/* TODO */
db_set_column_null_allowed(column);
db_set_column_has_undefined_default_value(column);
db_unset_column_use_default_value(column);
/* TODO */
/*
db_set_column_select_priv_granted (column);
db_set_column_update_priv_granted (column);
db_set_column_update_priv_not_granted (column);
*/
}
if (c) {
c->cols = cols;
c->ncols = ncols;
}
else {
G_free(cols);
}
return DB_OK;
}
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;
}
/* describe table, if c is not NULL cur->cols and cur->ncols is also set */
int describe_table(PGresult * res, dbTable ** table, cursor * c)
{
int i, ncols, kcols;
int pgtype, gpgtype;
char *fname;
int sqltype, fsize, precision, scale;
dbColumn *column;
G_debug(3, "describe_table()");
ncols = PQnfields(res);
/* Count columns of known type */
kcols = 0;
for (i = 0; i < ncols; i++) {
get_column_info(res, i, &pgtype, &gpgtype, &sqltype, &fsize);
if (sqltype == DB_SQL_TYPE_UNKNOWN)
continue;
kcols++; /* known types */
}
G_debug(3, "kcols = %d", kcols);
if (!(*table = db_alloc_table(kcols))) {
return DB_FAILED;
}
if (c) {
c->ncols = kcols;
c->cols = (int *)G_malloc(kcols * sizeof(int));
}
/* set the table name */
/* TODO */
db_set_table_name(*table, "");
/* set the table description */
db_set_table_description(*table, "");
/* TODO */
/*
db_set_table_delete_priv_granted (*table);
db_set_table_insert_priv_granted (*table);
db_set_table_delete_priv_not_granted (*table);
db_set_table_insert_priv_not_granted (*table);
*/
kcols = 0;
for (i = 0; i < ncols; i++) {
fname = PQfname(res, i);
get_column_info(res, i, &pgtype, &gpgtype, &sqltype, &fsize);
G_debug(3,
"col: %s, kcols %d, pgtype : %d, gpgtype : %d, sqltype %d, fsize : %d",
fname, kcols, pgtype, gpgtype, sqltype, fsize);
/* PG types defined in globals.h (and pg_type.h) */
if (sqltype == DB_SQL_TYPE_UNKNOWN) {
if (gpgtype == PG_TYPE_POSTGIS_GEOM) {
G_warning(_("PostgreSQL driver: PostGIS column '%s', type 'geometry' "
"will not be converted"),
fname);
continue;
}
else {
/* Warn, ignore and continue */
G_warning(_("PostgreSQL driver: column '%s', type %d is not supported"),
fname, pgtype);
continue;
}
}
if (gpgtype == PG_TYPE_INT8)
G_warning(_("column '%s' : type int8 (bigint) is stored as integer (4 bytes) "
"some data may be damaged"), fname);
if (gpgtype == PG_TYPE_VARCHAR && fsize < 0) {
G_warning(_("column '%s' : type character varying is stored as varchar(250) "
"some data may be lost"), fname);
fsize = 250;
}
if (gpgtype == PG_TYPE_BOOL)
G_warning(_("column '%s' : type bool (boolean) is stored as char(1), values: 0 (false), "
"1 (true)"), fname);
column = db_get_table_column(*table, kcols);
db_set_column_name(column, fname);
db_set_column_length(column, fsize);
db_set_column_host_type(column, gpgtype);
db_set_column_sqltype(column, sqltype);
/* TODO */
precision = 0;
scale = 0;
/*
db_set_column_precision (column, precision);
db_set_column_scale (column, scale);
*/
/* TODO */
db_set_column_null_allowed(column);
db_set_column_has_undefined_default_value(column);
db_unset_column_use_default_value(column);
/* TODO */
/*
db_set_column_select_priv_granted (column);
db_set_column_update_priv_granted (column);
db_set_column_update_priv_not_granted (column);
*/
if (c) {
c->cols[kcols] = i;
}
kcols++;
}
return DB_OK;
}
/* describe table, if c is not NULL cur->cols and cur->ncols is also set */
int describe_table(MYSQL_RES * res, dbTable ** table, cursor * c)
{
int i, ncols, kcols;
char *name;
int sqltype, length;
dbColumn *column;
MYSQL_FIELD *fields;
G_debug(3, "describe_table()");
ncols = mysql_num_fields(res);
fields = mysql_fetch_fields(res);
/* Count columns of known type */
kcols = 0;
for (i = 0; i < ncols; i++) {
field_info(&(fields[i]), &sqltype, &length);
if (sqltype == DB_SQL_TYPE_UNKNOWN)
continue;
kcols++; /* known types */
}
G_debug(3, "kcols = %d", kcols);
if (!(*table = db_alloc_table(kcols))) {
return DB_FAILED;
}
if (c) {
c->ncols = kcols;
c->cols = (int *)G_malloc(kcols * sizeof(int));
}
db_set_table_name(*table, "");
db_set_table_description(*table, "");
/* Currently not used in GRASS */
/*
db_set_table_delete_priv_granted (*table);
db_set_table_insert_priv_granted (*table);
db_set_table_delete_priv_not_granted (*table);
db_set_table_insert_priv_not_granted (*table);
*/
kcols = 0;
for (i = 0; i < ncols; i++) {
name = fields[i].name;
field_info(&(fields[i]), &sqltype, &length);
G_debug(3, "col: %s, kcols %d, sqltype %d", name, kcols, sqltype);
G_debug(3, "flags = %d", fields[i].flags);
if (sqltype == DB_SQL_TYPE_UNKNOWN) {
/* Print warning and continue */
G_warning(_("MySQL driver: column '%s', type %d "
"is not supported"), name, fields[i].type);
continue;
}
if (fields[i].type == MYSQL_TYPE_LONGLONG)
G_warning(_("column '%s' : type BIGINT is stored as "
"integer (4 bytes) some data may be damaged"), name);
column = db_get_table_column(*table, kcols);
db_set_column_name(column, name);
db_set_column_length(column, length);
db_set_column_host_type(column, (int)fields[i].type);
db_set_column_sqltype(column, sqltype);
db_set_column_precision(column, (int)fields[i].decimals);
db_set_column_scale(column, 0);
if (!(fields[i].flags & NOT_NULL_FLAG)) {
db_set_column_null_allowed(column);
}
db_set_column_has_undefined_default_value(column);
db_unset_column_use_default_value(column);
/* Currently not used in GRASS */
/*
db_set_column_select_priv_granted (column);
db_set_column_update_priv_granted (column);
db_set_column_update_priv_not_granted (column);
*/
if (c) {
c->cols[kcols] = i;
}
kcols++;
}
return DB_OK;
}
