static void parse_command_line(int argc, char **argv) { struct Option *driver, *database; struct GModule *module; /* Initialize the GIS calls */ G_gisinit(argv[0]); driver = G_define_standard_option(G_OPT_DRIVER); driver->options = db_list_drivers(); driver->required = YES; database = G_define_standard_option(G_OPT_DATABASE); database->required = YES; /* Set description */ module = G_define_module(); module->keywords = _("database, SQL"); module->description = _("Creates an empty database."); if (G_parser(argc, argv)) exit(EXIT_FAILURE); parms.driver = driver->answer; parms.database = database->answer; }
static void parse_command_line(int argc, char **argv) { struct Option *driver, *database; struct GModule *module; /* Initialize the GIS calls */ G_gisinit(argv[0]); driver = G_define_standard_option(G_OPT_DB_DRIVER); driver->options = db_list_drivers(); driver->required = YES; driver->answer = (char *) db_get_default_driver_name(); database = G_define_standard_option(G_OPT_DB_DATABASE); database->required = YES; /* Set description */ module = G_define_module(); G_add_keyword(_("database")); G_add_keyword(_("attribute table")); G_add_keyword(_("SQL")); module->description = _("Removes an existing database."); if (G_parser(argc, argv)) exit(EXIT_FAILURE); parms.driver = driver->answer; parms.database = database->answer; }
static void parse_command_line(int argc, char **argv) { struct Option *driver, *database, *schema, *input; struct Flag *i; struct GModule *module; const char *drv, *db, *schema_name; /* Initialize the GIS calls */ G_gisinit(argv[0]); /* Set description */ module = G_define_module(); G_add_keyword(_("database")); G_add_keyword(_("attribute table")); G_add_keyword(_("SQL")); module->label = _("Executes any SQL statement."); module->description = _("For SELECT statements use 'db.select'."); input = G_define_standard_option(G_OPT_F_INPUT); input->label = _("Name of file containing SQL statements"); input->description = _("'-' to read from standard input"); driver = G_define_standard_option(G_OPT_DB_DRIVER); driver->options = db_list_drivers(); driver->guisection = _("Connection"); if ((drv = db_get_default_driver_name())) driver->answer = (char *) drv; database = G_define_standard_option(G_OPT_DB_DATABASE); database->guisection = _("Connection"); if ((db = db_get_default_database_name())) database->answer = (char *) db; schema = G_define_standard_option(G_OPT_DB_SCHEMA); schema->guisection = _("Connection"); if ((schema_name = db_get_default_schema_name())) schema->answer = (char *) schema_name; i = G_define_flag(); i->key = 'i'; i->description = _("Ignore SQL errors and continue"); i->guisection = _("Errors"); if (G_parser(argc, argv)) exit(EXIT_SUCCESS); parms.driver = driver->answer; parms.database = database->answer; parms.schema = schema->answer; parms.input = input->answer; parms.i = i->answer; }
int main(int argc, char *argv[]) { struct Option *driver, *database, *user, *password; struct GModule *module; /* Initialize the GIS calls */ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("database")); G_add_keyword(_("connection settings")); module->description = _("Sets user/password for driver/database."); driver = G_define_standard_option(G_OPT_DB_DRIVER); driver->options = db_list_drivers(); driver->required = YES; driver->answer = (char *) db_get_default_driver_name(); database = G_define_standard_option(G_OPT_DB_DATABASE); database->required = YES; database->answer = (char *) db_get_default_database_name(); user = G_define_option(); user->key = "user"; user->type = TYPE_STRING; user->required = NO; user->multiple = NO; user->description = _("Username"); password = G_define_option(); password->key = "password"; password->type = TYPE_STRING; password->required = NO; password->multiple = NO; password->description = _("Password"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); if (db_set_login(driver->answer, database->answer, user->answer, password->answer) == DB_FAILED) { G_fatal_error(_("Unable to set user/password")); } if (password->answer) G_important_message(_("The password was stored in file (%s/dblogin)"), CONFIG_DIR); exit(EXIT_SUCCESS); }
static void parse_command_line(int argc, char **argv) { struct Option *driver, *database; struct Flag *p, *s; struct GModule *module; const char *drv, *db; /* Initialize the GIS calls */ G_gisinit(argv[0]); driver = G_define_standard_option(G_OPT_DB_DRIVER); driver->options = db_list_drivers(); if ((drv = db_get_default_driver_name())) driver->answer = (char *) drv; database = G_define_standard_option(G_OPT_DB_DATABASE); if ((db = db_get_default_database_name())) database->answer = (char *) db; p = G_define_flag(); p->key = 'p'; p->description = _("Print tables and exit"); s = G_define_flag(); s->key = 's'; s->description = _("System tables instead of user tables"); /* Set description */ module = G_define_module(); G_add_keyword(_("database")); G_add_keyword(_("attribute table")); module->description = _("Lists all tables for a given database."); if (G_parser(argc, argv)) exit(EXIT_SUCCESS); parms.driver = driver->answer; parms.database = database->answer; parms.s = s->answer; }
int main(int argc, char *argv[]) { int i, cat, with_z, more, ctype, nrows; char buf[DB_SQL_MAX]; int count; double coor[3]; int ncoor; struct Option *driver_opt, *database_opt, *table_opt; struct Option *xcol_opt, *ycol_opt, *zcol_opt, *keycol_opt, *where_opt, *outvect; struct Flag *same_table_flag; struct GModule *module; struct Map_info Map; struct line_pnts *Points; struct line_cats *Cats; dbString sql; dbDriver *driver; dbCursor cursor; dbTable *table; dbColumn *column; dbValue *value; struct field_info *fi; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("vector")); G_add_keyword(_("import")); G_add_keyword(_("database")); G_add_keyword(_("points")); module->description = _("Creates new vector (points) map from database table containing coordinates."); table_opt = G_define_standard_option(G_OPT_DB_TABLE); table_opt->required = YES; table_opt->description = _("Input table name"); driver_opt = G_define_standard_option(G_OPT_DB_DRIVER); driver_opt->options = db_list_drivers(); driver_opt->answer = (char *)db_get_default_driver_name(); driver_opt->guisection = _("Input DB"); database_opt = G_define_standard_option(G_OPT_DB_DATABASE); database_opt->answer = (char *)db_get_default_database_name(); database_opt->guisection = _("Input DB"); xcol_opt = G_define_standard_option(G_OPT_DB_COLUMN); xcol_opt->key = "x"; xcol_opt->required = YES; xcol_opt->description = _("Name of column containing x coordinate"); ycol_opt = G_define_standard_option(G_OPT_DB_COLUMN); ycol_opt->key = "y"; ycol_opt->required = YES; ycol_opt->description = _("Name of column containing y coordinate"); zcol_opt = G_define_standard_option(G_OPT_DB_COLUMN); zcol_opt->key = "z"; zcol_opt->description = _("Name of column containing z coordinate"); zcol_opt->guisection = _("3D output"); keycol_opt = G_define_standard_option(G_OPT_DB_COLUMN); keycol_opt->key = "key"; keycol_opt->required = NO; keycol_opt->label = _("Name of column containing category number"); keycol_opt->description = _("Must refer to an integer column"); where_opt = G_define_standard_option(G_OPT_DB_WHERE); where_opt->guisection = _("Selection"); outvect = G_define_standard_option(G_OPT_V_OUTPUT); same_table_flag = G_define_flag(); same_table_flag->key = 't'; same_table_flag->description = _("Use imported table as attribute table for new map"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); if (zcol_opt->answer) { with_z = WITH_Z; ncoor = 3; } else { with_z = WITHOUT_Z; ncoor = 2; } Points = Vect_new_line_struct(); Cats = Vect_new_cats_struct(); db_init_string(&sql); if (G_get_overwrite()) { /* We don't want to delete the input table when overwriting the output * vector. */ char name[GNAME_MAX], mapset[GMAPSET_MAX]; if (!G_name_is_fully_qualified(outvect->answer, name, mapset)) { strcpy(name, outvect->answer); strcpy(mapset, G_mapset()); } Vect_set_open_level(1); /* no topo needed */ if (strcmp(mapset, G_mapset()) == 0 && G_find_vector2(name, mapset) && Vect_open_old(&Map, name, mapset) >= 0) { int num_dblinks; num_dblinks = Vect_get_num_dblinks(&Map); for (i = 0; i < num_dblinks; i++) { if ((fi = Vect_get_dblink(&Map, i)) != NULL && strcmp(fi->driver, driver_opt->answer) == 0 && strcmp(fi->database, database_opt->answer) == 0 && strcmp(fi->table, table_opt->answer) == 0) G_fatal_error(_("Vector map <%s> cannot be overwritten " "because input table <%s> is linked to " "this map."), outvect->answer, table_opt->answer); } Vect_close(&Map); } } if (Vect_open_new(&Map, outvect->answer, with_z) < 0) G_fatal_error(_("Unable to create vector map <%s>"), outvect->answer); Vect_set_error_handler_io(NULL, &Map); Vect_hist_command(&Map); fi = Vect_default_field_info(&Map, 1, NULL, GV_1TABLE); /* Open driver */ driver = db_start_driver_open_database(driver_opt->answer, database_opt->answer); if (driver == NULL) { G_fatal_error(_("Unable to open database <%s> by driver <%s>"), fi->database, fi->driver); } db_set_error_handler_driver(driver); /* check if target table already exists */ G_debug(3, "Output vector table <%s>, driver: <%s>, database: <%s>", outvect->answer, db_get_default_driver_name(), db_get_default_database_name()); if (!same_table_flag->answer && db_table_exists(db_get_default_driver_name(), db_get_default_database_name(), outvect->answer) == 1) G_fatal_error(_("Output vector map, table <%s> (driver: <%s>, database: <%s>) " "already exists"), outvect->answer, db_get_default_driver_name(), db_get_default_database_name()); if (keycol_opt->answer) { int coltype; coltype = db_column_Ctype(driver, table_opt->answer, keycol_opt->answer); if (coltype == -1) G_fatal_error(_("Column <%s> not found in table <%s>"), keycol_opt->answer, table_opt->answer); if (coltype != DB_C_TYPE_INT) G_fatal_error(_("Data type of key column must be integer")); } else { if (same_table_flag->answer) { G_fatal_error(_("Option <%s> must be specified when -%c flag is given"), keycol_opt->key, same_table_flag->key); } if (strcmp(db_get_default_driver_name(), "sqlite") != 0) G_fatal_error(_("Unable to define key column. This operation is not supported " "by <%s> driver. You need to define <%s> option."), fi->driver, keycol_opt->key); } /* Open select cursor */ sprintf(buf, "SELECT %s, %s", xcol_opt->answer, ycol_opt->answer); db_set_string(&sql, buf); if (with_z) { sprintf(buf, ", %s", zcol_opt->answer); db_append_string(&sql, buf); } if (keycol_opt->answer) { sprintf(buf, ", %s", keycol_opt->answer); db_append_string(&sql, buf); } sprintf(buf, " FROM %s", table_opt->answer); db_append_string(&sql, buf); if (where_opt->answer) { sprintf(buf, " WHERE %s", where_opt->answer); db_append_string(&sql, buf); } G_debug(2, "SQL: %s", db_get_string(&sql)); if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) != DB_OK) { G_fatal_error(_("Unable to open select cursor: '%s'"), db_get_string(&sql)); } table = db_get_cursor_table(&cursor); nrows = db_get_num_rows(&cursor); G_debug(2, "%d points selected", nrows); count = cat = 0; G_message(_("Writing features...")); while (db_fetch(&cursor, DB_NEXT, &more) == DB_OK && more) { G_percent(count, nrows, 2); /* key column */ if (keycol_opt->answer) { column = db_get_table_column(table, with_z ? 3 : 2); ctype = db_sqltype_to_Ctype(db_get_column_sqltype(column)); if (ctype != DB_C_TYPE_INT) G_fatal_error(_("Key column must be integer")); value = db_get_column_value(column); cat = db_get_value_int(value); } else { cat++; } /* coordinates */ for (i = 0; i < ncoor; i++) { column = db_get_table_column(table, i); ctype = db_sqltype_to_Ctype(db_get_column_sqltype(column)); if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE) G_fatal_error(_("x/y/z column must be integer or double")); value = db_get_column_value(column); if (ctype == DB_C_TYPE_INT) coor[i] = (double)db_get_value_int(value); else coor[i] = db_get_value_double(value); } Vect_reset_line(Points); Vect_reset_cats(Cats); Vect_append_point(Points, coor[0], coor[1], coor[2]); Vect_cat_set(Cats, 1, cat); Vect_write_line(&Map, GV_POINT, Points, Cats); count++; } G_percent(1, 1, 1); /* close connection to input DB before copying attributes */ db_close_database_shutdown_driver(driver); /* Copy table */ if (!same_table_flag->answer) { G_message(_("Copying attributes...")); if (DB_FAILED == db_copy_table_where(driver_opt->answer, database_opt->answer, table_opt->answer, fi->driver, fi->database, fi->table, where_opt->answer)) { /* where can be NULL */ G_warning(_("Unable to copy table")); } else { Vect_map_add_dblink(&Map, 1, NULL, fi->table, keycol_opt->answer ? keycol_opt->answer : GV_KEY_COLUMN, fi->database, fi->driver); } if (!keycol_opt->answer) { /* TODO: implement for all DB drivers in generic way if * possible */ 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); } db_set_error_handler_driver(driver); /* add key column */ sprintf(buf, "ALTER TABLE %s ADD COLUMN %s INTEGER", fi->table, GV_KEY_COLUMN); db_set_string(&sql, buf); if (db_execute_immediate(driver, &sql) != DB_OK) { G_fatal_error(_("Unable to add key column <%s>: " "SERIAL type is not supported by <%s>"), GV_KEY_COLUMN, fi->driver); } /* update key column */ sprintf(buf, "UPDATE %s SET %s = _ROWID_", fi->table, GV_KEY_COLUMN); db_set_string(&sql, buf); if (db_execute_immediate(driver, &sql) != DB_OK) { G_fatal_error(_("Failed to update key column <%s>"), GV_KEY_COLUMN); } } } else { /* do not copy attributes, link original table */ Vect_map_add_dblink(&Map, 1, NULL, table_opt->answer, keycol_opt->answer ? keycol_opt->answer : GV_KEY_COLUMN, database_opt->answer, driver_opt->answer); } Vect_build(&Map); Vect_close(&Map); G_done_msg(_n("%d point written to vector map.", "%d points written to vector map.", count), count); return (EXIT_SUCCESS); }
int main(int argc, char *argv[]) { struct Option *driver, *database, *user, *password, *host, *port; struct Flag *print; struct GModule *module; /* Initialize the GIS calls */ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("database")); G_add_keyword(_("connection settings")); module->description = _("Sets user/password for DB driver/database."); module->overwrite = TRUE; driver = G_define_standard_option(G_OPT_DB_DRIVER); driver->options = db_list_drivers(); driver->required = YES; driver->answer = (char *) db_get_default_driver_name(); database = G_define_standard_option(G_OPT_DB_DATABASE); database->required = YES; database->answer = (char *) db_get_default_database_name(); user = G_define_option(); user->key = "user"; user->type = TYPE_STRING; user->required = NO; user->multiple = NO; user->description = _("Username"); user->guisection = _("Settings"); password = G_define_option(); password->key = "password"; password->type = TYPE_STRING; password->required = NO; password->multiple = NO; password->description = _("Password"); password->guisection = _("Settings"); host = G_define_option(); host->key = "host"; host->type = TYPE_STRING; host->required = NO; host->multiple = NO; host->label = _("Hostname"); host->description = _("Relevant only for pg and mysql driver"); host->guisection = _("Settings"); port = G_define_option(); port->key = "port"; port->type = TYPE_STRING; port->required = NO; port->multiple = NO; port->label = _("Port"); port->description = _("Relevant only for pg and mysql driver"); port->guisection = _("Settings"); print = G_define_flag(); print->key = 'p'; print->description = _("Print connection settings and exit"); print->guisection = _("Print"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); if (print->answer) { /* print all settings to standard output and exit */ db_get_login_dump(stdout); exit(EXIT_SUCCESS); } if (db_set_login2(driver->answer, database->answer, user->answer, password->answer, host->answer, port->answer, G_get_overwrite()) == DB_FAILED) { G_fatal_error(_("Unable to set user/password")); } if (password->answer) G_important_message(_("The password was stored in file (%s%cdblogin)"), G_config_path(), HOST_DIRSEP); exit(EXIT_SUCCESS); }
void parse_command_line(int argc, char **argv) { struct Option *driver, *database, *table, *sql, *fs, *vs, *nv, *input, *output; struct Flag *c, *d, *v, *flag_test; struct GModule *module; const char *drv, *db; /* Initialize the GIS calls */ G_gisinit(argv[0]); sql = G_define_standard_option(G_OPT_DB_SQL); sql->guisection = _("Query"); input = G_define_standard_option(G_OPT_F_INPUT); input->required = NO; input->label = _("Name of file containing SQL select statement(s)"); input->description = _("'-' for standard input"); input->guisection = _("Query"); table = G_define_standard_option(G_OPT_DB_TABLE); table->description = _("Name of table to query"); table->guisection = _("Query"); driver = G_define_standard_option(G_OPT_DB_DRIVER); driver->options = db_list_drivers(); if ((drv = db_get_default_driver_name())) driver->answer = (char *) drv; driver->guisection = _("Connection"); database = G_define_standard_option(G_OPT_DB_DATABASE); if ((db = db_get_default_database_name())) database->answer = (char *) db; database->guisection = _("Connection"); fs = G_define_standard_option(G_OPT_F_SEP); fs->guisection = _("Format"); vs = G_define_standard_option(G_OPT_F_SEP); vs->key = "vseparator"; vs->label = _("Vertical record separator (requires -v flag)"); vs->answer = NULL; vs->guisection = _("Format"); nv = G_define_option(); nv->key = "nv"; nv->type = TYPE_STRING; nv->required = NO; nv->description = _("Null value indicator"); nv->guisection = _("Format"); output = G_define_standard_option(G_OPT_F_OUTPUT); output->required = NO; output->description = _("Name for output file (if omitted or \"-\" output to stdout)"); c = G_define_flag(); c->key = 'c'; c->description = _("Do not include column names in output"); c->guisection = _("Format"); d = G_define_flag(); d->key = 'd'; d->description = _("Describe query only (don't run it)"); d->guisection = _("Query"); v = G_define_flag(); v->key = 'v'; v->description = _("Vertical output (instead of horizontal)"); v->guisection = _("Format"); flag_test = G_define_flag(); flag_test->key = 't'; flag_test->description = _("Only test query, do not execute"); flag_test->guisection = _("Query"); /* Set description */ module = G_define_module(); G_add_keyword(_("database")); G_add_keyword(_("attribute table")); G_add_keyword(_("SQL")); module->label = _("Selects data from attribute table."); module->description = _("Performs SQL query statement(s)."); if (G_parser(argc, argv)) exit(EXIT_FAILURE); parms.driver = driver->answer; parms.database = database->answer; parms.table = table->answer; parms.sql = sql->answer; parms.fs = G_option_to_separator(fs); parms.vs = '\0'; if (vs->answer) parms.vs = G_option_to_separator(vs); parms.nv = nv->answer; parms.input = input->answer; parms.output = output->answer; if (!c->answer) parms.c = TRUE; else parms.c = FALSE; parms.d = d->answer; if (!v->answer) parms.h = TRUE; else parms.h = FALSE; parms.test_only = flag_test->answer; if (parms.input && *parms.input == 0) { G_usage(); exit(EXIT_FAILURE); } if (!parms.input && !parms.sql && !parms.table) G_fatal_error(_("You must provide one of these options: <%s>, <%s>, or <%s>"), sql->key, input->key, table->key); }
int main(int argc, char **argv) { int lfield, pfield, n_points, n_outside, n_found, n_no_record, n_many_records; int line, type, nlines; double thresh, multip; struct Option *lines_opt, *points_opt; struct Option *lfield_opt, *pfield_opt; struct Option *driver_opt, *database_opt, *table_opt, *thresh_opt; struct GModule *module; const char *mapset; struct Map_info LMap, PMap; struct line_cats *LCats, *PCats; struct line_pnts *LPoints, *PPoints; dbDriver *rsdriver; dbHandle rshandle; dbString rsstmt; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("vector")); G_add_keyword(_("Linear Reference System")); G_add_keyword(_("networking")); module->description = _("Finds line id and real km+offset for given points in vector map " "using linear reference system."); lines_opt = G_define_standard_option(G_OPT_V_INPUT); lines_opt->key = "lines"; lines_opt->description = _("Input vector map containing lines"); points_opt = G_define_standard_option(G_OPT_V_INPUT); points_opt->key = "points"; points_opt->description = _("Input vector map containing points"); lfield_opt = G_define_standard_option(G_OPT_V_FIELD); lfield_opt->key = "llayer"; lfield_opt->answer = "1"; lfield_opt->description = _("Line layer"); pfield_opt = G_define_standard_option(G_OPT_V_FIELD); pfield_opt->key = "player"; pfield_opt->answer = "1"; pfield_opt->description = _("Point layer"); driver_opt = G_define_option(); driver_opt->key = "rsdriver"; driver_opt->type = TYPE_STRING; driver_opt->required = NO; driver_opt->description = _("Driver name for reference system table"); driver_opt->options = db_list_drivers(); driver_opt->answer = db_get_default_driver_name(); database_opt = G_define_option(); database_opt->key = "rsdatabase"; database_opt->type = TYPE_STRING; database_opt->required = NO; database_opt->description = _("Database name for reference system table"); database_opt->answer = db_get_default_database_name(); table_opt = G_define_option(); table_opt->key = "rstable"; table_opt->type = TYPE_STRING; table_opt->required = YES; table_opt->description = _("Name of the reference system table"); thresh_opt = G_define_option(); thresh_opt->key = "threshold"; thresh_opt->type = TYPE_DOUBLE; thresh_opt->required = NO; thresh_opt->answer = "1000"; thresh_opt->description = _("Maximum distance to nearest line"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); LCats = Vect_new_cats_struct(); PCats = Vect_new_cats_struct(); LPoints = Vect_new_line_struct(); PPoints = Vect_new_line_struct(); lfield = atoi(lfield_opt->answer); pfield = atoi(pfield_opt->answer); multip = 1000; /* Number of map units per MP unit */ thresh = atof(thresh_opt->answer); /* Open input lines */ mapset = G_find_vector2(lines_opt->answer, NULL); if (mapset == NULL) G_fatal_error(_("Vector map <%s> not found"), lines_opt->answer); Vect_set_open_level(2); if (Vect_open_old(&LMap, lines_opt->answer, mapset) < 0) G_fatal_error(_("Unable to open vector map <%s>"), lines_opt->answer); /* Open input points */ mapset = G_find_vector2(points_opt->answer, NULL); if (mapset == NULL) G_fatal_error(_("Vector map <%s> not found"), points_opt->answer); Vect_set_open_level(2); if (Vect_open_old(&PMap, points_opt->answer, mapset) < 0) G_fatal_error(_("Unable to open vector map <%s>"), points_opt->answer); db_init_handle(&rshandle); db_init_string(&rsstmt); rsdriver = db_start_driver(driver_opt->answer); db_set_handle(&rshandle, database_opt->answer, NULL); if (db_open_database(rsdriver, &rshandle) != DB_OK) G_fatal_error(_("Unable to open database for reference table")); n_points = n_outside = n_found = n_no_record = n_many_records = 0; nlines = Vect_get_num_lines(&PMap); G_debug(2, "nlines = %d", nlines); G_message("pcat|lid|mpost|offset"); for (line = 1; line <= nlines; line++) { int nearest, pcat, lcat, lid, ret; double along, mpost, offset; G_debug(3, "point = %d", line); type = Vect_read_line(&PMap, PPoints, PCats, line); if (type != GV_POINT) continue; Vect_cat_get(PCats, pfield, &pcat); if (pcat < 0) continue; n_points++; nearest = Vect_find_line(&LMap, PPoints->x[0], PPoints->y[0], 0.0, GV_LINE, thresh, 0, 0); fprintf(stdout, "%d", pcat); if (nearest <= 0) { fprintf(stdout, "|-|- # outside threshold\n"); n_outside++; continue; } /* Read nearest line */ Vect_read_line(&LMap, LPoints, LCats, nearest); Vect_cat_get(LCats, lfield, &lcat); Vect_line_distance(LPoints, PPoints->x[0], PPoints->y[0], 0.0, 0, NULL, NULL, NULL, NULL, NULL, &along); G_debug(3, " nearest = %d lcat = %d along = %f", nearest, lcat, along); if (lcat >= 0) { ret = LR_get_milepost(rsdriver, table_opt->answer, "lcat", "lid", "start_map", "end_map", "start_mp", "start_off", "end_mp", "end_off", lcat, along, multip, &lid, &mpost, &offset); } else { ret = 0; } if (ret == 0) { n_no_record++; fprintf(stdout, "|-|- # no record\n"); continue; } if (ret == 2) { n_many_records++; fprintf(stdout, "|-|- # too many records\n"); continue; } G_debug(3, " lid = %d mpost = %f offset = %f", lid, mpost, offset); fprintf(stdout, "|%d|%f+%f\n", lid, mpost, offset); n_found++; } db_close_database(rsdriver); /* Free, close ... */ Vect_close(&LMap); Vect_close(&PMap); G_message(_n("[%d] point read from input", "[%d] points read from input", n_points), n_points); G_message(_n("[%d] position found", "[%d] positions found", n_found), n_found); if (n_outside) G_message(_n("[%d] point outside threshold", "[%d] points outside threshold", n_outside), n_outside); if (n_no_record) G_message(_n("[%d] point - no record found", "[%d] points - no record found", n_no_record), n_no_record); if (n_many_records) G_message(_n("[%d] point - too many records found", "[%d] points - too many records found", n_many_records), n_many_records); exit(EXIT_SUCCESS); }
static void parse_command_line(int argc, char **argv) { struct Option *driver, *database, *schema, *sql, *input; struct Flag *i; struct GModule *module; const char *drv, *db, *schema_name; /* Initialize the GIS calls */ G_gisinit(argv[0]); /* Set description */ module = G_define_module(); G_add_keyword(_("database")); G_add_keyword(_("attribute table")); G_add_keyword(_("SQL")); module->label = _("Executes any SQL statement."); module->description = _("For SELECT statements use 'db.select'."); sql = G_define_standard_option(G_OPT_DB_SQL); sql->label = _("SQL statement"); sql->description = _("Example: update rybniky set kapri = 'hodne' where kapri = 'malo'"); sql->guisection = _("SQL"); input = G_define_standard_option(G_OPT_F_INPUT); input->required = NO; input->label = _("Name of file containing SQL statement(s)"); input->description = _("'-' for standard input"); input->guisection = _("SQL"); driver = G_define_standard_option(G_OPT_DB_DRIVER); driver->options = db_list_drivers(); driver->guisection = _("Connection"); if ((drv = db_get_default_driver_name())) driver->answer = (char *) drv; database = G_define_standard_option(G_OPT_DB_DATABASE); database->guisection = _("Connection"); if ((db = db_get_default_database_name())) database->answer = (char *) db; schema = G_define_standard_option(G_OPT_DB_SCHEMA); schema->guisection = _("Connection"); if ((schema_name = db_get_default_schema_name())) schema->answer = (char *) schema_name; i = G_define_flag(); i->key = 'i'; i->description = _("Ignore SQL errors and continue"); i->guisection = _("Errors"); if (G_parser(argc, argv)) exit(EXIT_SUCCESS); if (!sql->answer && !input->answer) { G_fatal_error(_("You must provide <%s> or <%s> option"), sql->key, input->key); } parms.driver = driver->answer; parms.database = database->answer; parms.schema = schema->answer; parms.sql = sql->answer; parms.input = input->answer; parms.i = i->answer ? TRUE : FALSE; }
int main(int argc, char *argv[]) { dbConnection conn; struct Flag *print, *check_set_default, *def; /* struct Option *driver, *database, *user, *password, *keycol; */ struct Option *driver, *database, *schema, *group; struct GModule *module; /* Initialize the GIS calls */ G_gisinit(argv[0]); /* Set description */ module = G_define_module(); G_add_keyword(_("database")); G_add_keyword(_("attribute table")); G_add_keyword(_("connection settings")); module->description = _("Prints/sets general DB connection for current mapset."); print = G_define_flag(); print->key = 'p'; print->description = _("Print current connection parameters and exit"); print->guisection = _("Print"); check_set_default = G_define_flag(); check_set_default->key = 'c'; check_set_default->description = _("Check connection parameters, set if uninitialized, and exit"); check_set_default->guisection = _("Set"); def = G_define_flag(); def->key = 'd'; def->label = _("Set from default settings and exit"); def->description = _("Overwrite current settings if initialized"); def->guisection = _("Set"); driver = G_define_standard_option(G_OPT_DB_DRIVER); driver->options = db_list_drivers(); driver->answer = (char *) db_get_default_driver_name(); driver->guisection = _("Set"); database = G_define_standard_option(G_OPT_DB_DATABASE); database->answer = (char *) db_get_default_database_name(); database->guisection = _("Set"); schema = G_define_standard_option(G_OPT_DB_SCHEMA); schema->answer = (char *) db_get_default_schema_name(); schema->guisection = _("Set"); group = G_define_option(); group->key = "group"; group->type = TYPE_STRING; group->required = NO; group->multiple = NO; group->answer = (char*) db_get_default_group_name(); group->description = _("Default group of database users to which " "select privilege is granted"); group->guisection = _("Set"); /* commented due to new mechanism: user = G_define_option() ; user->key = "user" ; user->type = TYPE_STRING ; user->required = NO ; user->multiple = NO ; user->description= "User:"******"password" ; password->type = TYPE_STRING ; password->required = NO ; password->multiple = NO ; password->description= "Password:"******"driver:%s\n", conn.driverName ? conn.driverName : ""); fprintf(stdout, "database:%s\n", conn.databaseName ? conn.databaseName : ""); fprintf(stdout, "schema:%s\n", conn.schemaName ? conn.schemaName : ""); fprintf(stdout, "group:%s\n", conn.group ? conn.group : ""); } else G_fatal_error(_("Database connection not defined. " "Run db.connect.")); exit(EXIT_SUCCESS); } if (check_set_default->answer) { /* check connection and set to system-wide default in required */ /* * TODO: improve db_{get,set}_connection() to not return DB_OK on error * (thus currently there is no point in checking for that here) */ db_get_connection(&conn); if (!conn.driverName && !conn.databaseName) { db_set_default_connection(); db_get_connection(&conn); G_important_message(_("Default driver / database set to:\n" "driver: %s\ndatabase: %s"), conn.driverName, conn.databaseName); } /* they must be a matched pair, so if one is set but not the other then give up and let the user figure it out */ else if (!conn.driverName) { G_fatal_error(_("Default driver is not set")); } else if (!conn.databaseName) { G_fatal_error(_("Default database is not set")); } /* connection either already existed or now exists */ exit(EXIT_SUCCESS); } if (def->answer) { db_set_default_connection(); db_get_connection(&conn); G_important_message(_("Default driver / database set to:\n" "driver: %s\ndatabase: %s"), conn.driverName, conn.databaseName); exit(EXIT_SUCCESS); } /* set connection */ db_get_connection(&conn); /* read current */ if (driver->answer) conn.driverName = driver->answer; if (database->answer) conn.databaseName = database->answer; if (schema->answer) conn.schemaName = schema->answer; if (group->answer) conn.group = group->answer; db_set_connection(&conn); exit(EXIT_SUCCESS); }