void print_columns(const struct Map_info *Map, const char *input_opt, const char *field_opt)
{
int num_dblinks, col, ncols;
struct field_info *fi;
dbDriver *driver = NULL;
dbHandle handle;
dbString table_name;
dbTable *table;
num_dblinks = Vect_get_num_dblinks(Map);
if (num_dblinks <= 0) {
G_fatal_error(_("Database connection for map <%s> is not defined in DB file"),
input_opt);
}
G_message(_("Displaying column types/names for database connection of layer <%s>:"),
field_opt);
if ((fi = Vect_get_field2(Map, field_opt)) == NULL)
G_fatal_error(_("Database connection not defined for layer <%s>"),
field_opt);
driver = db_start_driver(fi->driver);
if (driver == NULL)
G_fatal_error(_("Unable to open 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);
db_init_string(&table_name);
db_set_string(&table_name, fi->table);
if (db_describe_table(driver, &table_name, &table) != DB_OK)
G_fatal_error(_("Unable to describe table <%s>"),
fi->table);
ncols = db_get_table_number_of_columns(table);
for (col = 0; col < ncols; col++)
fprintf(stdout, "%s|%s\n",
db_sqltype_name(db_get_column_sqltype
(db_get_table_column
(table, col))),
db_get_column_name(db_get_table_column
(table, col)));
db_close_database(driver);
db_shutdown_driver(driver);
}
/*!
\brief Get field number of given field
\param Map pointer to Map_info structure
\param field layer name
\return layer number
\return -1 for all layers
\return 0 if layer not found
*/
int Vect_get_field_number(const struct Map_info *Map, const char *field)
{
struct field_info *fi;
G_debug(1, "Vect_get_field_number(): field = %s", field);
if (strcmp(field, "-1") == 0)
return -1;
if (Vect_get_num_dblinks(Map) == 0)
return atoi(field);
fi = Vect_get_field2(Map, field);
if (fi)
return fi->number;
return atoi(field);
}
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 check_thematic(const struct GParams *params, int vlines)
{
int i, type;
struct Map_info Map;
struct Option *map, *layer, *color, *size, *width, *marker;
struct field_info *Fi;
dbDriver *driver;
dbColumn *column;
if (vlines) {
map = params->vlines;
layer = params->vline_layer;
color = params->vline_color_column;
size = NULL;
width = params->vline_width_column;
marker = NULL;
}
else {
map = params->vpoints;
layer = params->vpoint_layer;
color = params->vpoint_color_column;
size = params->vpoint_size_column;
width = params->vpoint_width_column;
marker = params->vpoint_marker_column;
}
for (i = 0; map->answers[i]; i++) {
if (1 > Vect_open_old(&Map, map->answers[i], ""))
G_fatal_error(_("Unable to open vector map <%s>"), map->answers[i]);
Fi = Vect_get_field2(&Map, layer->answers[i]);
if (!Fi)
G_fatal_error(_("Database connection not defined for layer %s"),
layer->answers[i]);
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 (color->answers && color->answers[i]) {
db_get_column(driver, Fi->table, color->answers[i], &column);
if (!column)
G_fatal_error(_("Column <%s> in table <%s> not found"),
color->answers[i], Fi->table);
if (db_column_Ctype(driver, Fi->table, color->answers[i]) != DB_C_TYPE_STRING)
G_fatal_error(_("Data type of color column must be character"));
}
if (size && size->answers && size->answers[i]) {
db_get_column(driver, Fi->table, size->answers[i], &column);
if (!column)
G_fatal_error(_("Column <%s> in table <%s> not found"),
size->answers[i], Fi->table);
type = db_column_Ctype(driver, Fi->table, size->answers[i]);
if (type != DB_C_TYPE_INT && type != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Data type of size column must be numeric"));
}
if (width->answers && width->answers[i]) {
db_get_column(driver, Fi->table, width->answers[i], &column);
if (!column)
G_fatal_error(_("Column <%s> in table <%s> not found"),
width->answers[i], Fi->table);
type = db_column_Ctype(driver, Fi->table, width->answers[i]);
if (type != DB_C_TYPE_INT && type != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Data type of width column must be numeric"));
}
if (marker && marker->answers && marker->answers[i]) {
db_get_column(driver, Fi->table, marker->answers[i], &column);
if (!column)
G_fatal_error(_("Column <%s> in table <%s> not found"),
marker->answers[i], Fi->table);
type = db_column_Ctype(driver, Fi->table, marker->answers[i]);
if (db_column_Ctype(driver, Fi->table, marker->answers[i]) != DB_C_TYPE_STRING)
G_fatal_error(_("Data type of marker column must be character"));
}
}
return Fi->number;
}
void print_shell(const struct Map_info *Map, const char *field_opt)
{
int map_type;
int time_ok, first_time_ok, second_time_ok;
char timebuff[256];
struct field_info *fi;
struct TimeStamp ts;
time_ok = first_time_ok = second_time_ok = FALSE;
/* Check the Timestamp */
time_ok = G_read_vector_timestamp(Vect_get_name(Map), NULL, "", &ts);
/* Check for valid entries, show none if no timestamp available */
if (time_ok == TRUE) {
if (ts.count > 0)
first_time_ok = TRUE;
if (ts.count > 1)
second_time_ok = TRUE;
}
map_type = Vect_maptype(Map);
fprintf(stdout, "name=%s\n",
Vect_get_name(Map));
fprintf(stdout, "mapset=%s\n",
Vect_get_mapset(Map));
fprintf(stdout, "location=%s\n",
G_location());
fprintf(stdout, "database=%s\n",
G_gisdbase());
fprintf(stdout, "title=%s\n",
Vect_get_map_name(Map));
fprintf(stdout, "scale=1:%d\n",
Vect_get_scale(Map));
fprintf(stdout, "creator=%s\n",
Vect_get_person(Map));
fprintf(stdout, "organization=%s\n",
Vect_get_organization(Map));
fprintf(stdout, "source_date=%s\n",
Vect_get_map_date(Map));
/* This shows the TimeStamp (if present) */
if (time_ok == TRUE && (first_time_ok || second_time_ok)) {
G_format_timestamp(&ts, timebuff);
fprintf(stdout, "timestamp=%s\n", timebuff);
}
else {
fprintf(stdout, "timestamp=none\n");
}
if (map_type == GV_FORMAT_OGR ||
map_type == GV_FORMAT_OGR_DIRECT) {
fprintf(stdout, "format=%s,%s\n",
Vect_maptype_info(Map), Vect_get_finfo_format_info(Map));
fprintf(stdout, "ogr_layer=%s\n",
Vect_get_finfo_layer_name(Map));
fprintf(stdout, "ogr_dsn=%s\n",
Vect_get_finfo_dsn_name(Map));
fprintf(stdout, "feature_type=%s\n",
Vect_get_finfo_geometry_type(Map));
}
else if (map_type == GV_FORMAT_POSTGIS) {
int topo_format;
char *toposchema_name, *topogeom_column;
const struct Format_info *finfo;
finfo = Vect_get_finfo(Map);
fprintf(stdout, "format=%s,%s\n",
Vect_maptype_info(Map), Vect_get_finfo_format_info(Map));
fprintf(stdout, "pg_table=%s\n",
Vect_get_finfo_layer_name(Map));
fprintf(stdout, "pg_dbname=%s\n",
Vect_get_finfo_dsn_name(Map));
fprintf(stdout, "geometry_column=%s\n",
finfo->pg.geom_column);
fprintf(stdout, "feature_type=%s\n",
Vect_get_finfo_geometry_type(Map));
topo_format = Vect_get_finfo_topology_info(Map, &toposchema_name, &topogeom_column, NULL);
if (topo_format == GV_TOPO_POSTGIS) {
fprintf(stdout, "pg_topo_schema=%s\n",
toposchema_name);
fprintf(stdout, "pg_topo_column=%s\n",
topogeom_column);
}
}
else {
fprintf(stdout, "format=%s\n",
Vect_maptype_info(Map));
}
fprintf(stdout, "level=%d\n",
Vect_level(Map));
if (Vect_level(Map) > 0) {
fprintf(stdout, "num_dblinks=%d\n",
Vect_get_num_dblinks(Map));
if (Vect_get_num_dblinks(Map) > 0) {
fi = Vect_get_field2(Map, field_opt);
if(fi != NULL) {
fprintf(stdout, "attribute_layer_number=%i\n",fi->number);
fprintf(stdout, "attribute_layer_name=%s\n",fi->name);
fprintf(stdout, "attribute_database=%s\n",fi->database);
fprintf(stdout, "attribute_database_driver=%s\n",fi->driver);
fprintf(stdout, "attribute_table=%s\n",fi->table);
fprintf(stdout, "attribute_primary_key=%s\n",fi->key);
}
}
}
fprintf(stdout, "projection=%s\n",
Vect_get_proj_name(Map));
if (G_projection() == PROJECTION_UTM) {
fprintf(stdout, "zone=%d\n",
Vect_get_zone(Map));
}
fprintf(stdout, "digitization_threshold=%f\n",
Vect_get_thresh(Map));
fprintf(stdout, "comment=%s\n",
Vect_get_comment(Map));
}
/*!
\brief Check vector map
\param params parameters
\param index answers array index
\param vlines TRUE for lines otherwise points
\param[out] field number
\param[out] WITH_Z for 3D maps
\return 0 on success otherwise 1
*/
int check_map(const struct GParams *params, int index, int vlines,
int *field, int *with_z)
{
int type;
struct Map_info Map;
const char *map, *layer, *color, *size, *width, *marker;
struct field_info *Fi;
dbDriver *driver;
dbColumn *column;
Fi = NULL;
driver = NULL;
if (vlines) {
map = params->vlines->answers[index];
layer = params->vline_layer->answers[index];
color = params->vline_color_column->answers ?
params->vline_color_column->answers[index] : NULL;
size = NULL;
width = params->vline_width_column->answers ?
params->vline_width_column->answers[index] : NULL;
marker = NULL;
}
else {
map = params->vpoints->answers[index];
layer = params->vpoint_layer->answers[index];
color = params->vpoint_color_column->answers ?
params->vpoint_color_column->answers[index] : NULL;
size = params->vpoint_size_column->answers ?
params->vpoint_size_column->answers[index] : NULL;
width = params->vpoint_width_column->answers ?
params->vpoint_width_column->answers[index] : NULL;
marker = params->vpoint_marker_column->answers ?
params->vpoint_marker_column->answers[index] : NULL;
}
if (!map)
return 1;
if (1 > Vect_open_old(&Map, map, ""))
G_fatal_error(_("Unable to open vector map <%s>"), map);
Vect_set_error_handler_io(&Map, NULL);
if (with_z)
*with_z = Vect_is_3d(&Map);
*field = -1;
Fi = Vect_get_field2(&Map, layer);
if (Fi) {
*field = Fi->number;
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);
db_set_error_handler_driver(driver);
if (color) {
db_get_column(driver, Fi->table, color, &column);
if (!column)
G_fatal_error(_("Column <%s> in table <%s> not found"),
color, Fi->table);
if (db_column_Ctype(driver, Fi->table, color) != DB_C_TYPE_STRING)
G_fatal_error(_("Data type of color column must be character"));
}
if (size) {
db_get_column(driver, Fi->table, size, &column);
if (!column)
G_fatal_error(_("Column <%s> in table <%s> not found"),
size, Fi->table);
type = db_column_Ctype(driver, Fi->table, size);
if (type != DB_C_TYPE_INT && type != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Data type of size column must be numeric"));
}
if (width) {
db_get_column(driver, Fi->table, width, &column);
if (!column)
G_fatal_error(_("Column <%s> in table <%s> not found"),
width, Fi->table);
type = db_column_Ctype(driver, Fi->table, width);
if (type != DB_C_TYPE_INT && type != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Data type of width column must be numeric"));
}
if (marker) {
db_get_column(driver, Fi->table, marker, &column);
if (!column)
G_fatal_error(_("Column <%s> in table <%s> not found"),
marker, Fi->table);
type = db_column_Ctype(driver, Fi->table, marker);
if (db_column_Ctype(driver, Fi->table, marker) !=
DB_C_TYPE_STRING)
G_fatal_error(_("Data type of marker column must be character"));
}
db_close_database_shutdown_driver(driver);
}
Vect_close(&Map);
return 0;
}
