Geografic-Information-System/vector/v.to.db/main.c

/****************************************************************************
 *
 * MODULE:       v.to.db
 * AUTHOR(S):    Radim Blazek <radim.blazek gmail.com> (original contributor)
 *               Wolf Bergenheim <wolf+grass bergenheim net>,
 *               Glynn Clements <glynn gclements.plus.com>,
 *               Markus Neteler <neteler itc.it>
 * PURPOSE:      load values from vector to database
 * COPYRIGHT:    (C) 2000-2020 by the GRASS Development Team
 *
 *               This program is free software under the GNU General Public
 *               License (>=v2). Read the file COPYING that comes with GRASS
 *               for details.
 *
 *****************************************************************************/

#include <stdlib.h>
#include <grass/dbmi.h>
#include <grass/glocale.h>
#include "global.h"

struct value *Values;
struct options options;
struct vstat vstat;

int main(int argc, char *argv[])
{
    int n, i, j, cat, lastcat, type, id, findex;
    struct Map_info Map;
    struct GModule *module;
    struct field_info *Fi, *qFi;
    int ncols;

    G_gisinit(argv[0]);

    module = G_define_module();
    G_add_keyword(_("vector"));
    G_add_keyword(_("attribute table"));
    G_add_keyword(_("database"));
    G_add_keyword(_("area"));
    G_add_keyword(_("azimuth"));
    G_add_keyword(_("bounding box"));
    G_add_keyword(_("category"));
    G_add_keyword(_("compactness"));
    G_add_keyword(_("coordinates"));
    G_add_keyword(_("fractal"));
    G_add_keyword(_("geometry"));
    G_add_keyword(_("length"));
    G_add_keyword(_("perimeter"));
    G_add_keyword(_("sides"));
    G_add_keyword(_("sinuous"));
    G_add_keyword(_("slope"));
    module->description = _("Populates attribute values from vector features.");
    module->overwrite = 1;

    parse_command_line(argc, argv);

    if (!options.print && !options.total) {
        const char *mapset;

        mapset = G_find_vector2(options.name, "");
        if (!mapset || (strcmp(mapset, G_mapset()) != 0))
            G_fatal_error(_("Vector map <%s> not found in the current mapset. "
                            "Unable to modify vector maps from different mapsets."),
                          options.name);
    }

    G_begin_distance_calculations();
    G_begin_polygon_area_calculations();

    /* open map */
    Vect_set_open_level(2);
    if (Vect_open_old(&Map, options.name, "") < 0)
	G_fatal_error(_("Unable to open vector map <%s>"), options.name);
    Vect_set_error_handler_io(&Map, NULL);
   
    Fi = Vect_get_field(&Map, options.field);

    if (!options.print && Fi == NULL) {
	G_fatal_error(_("Database connection not defined for layer %d. "
			"Use v.db.connect first."),
		      options.field);
    }

    qFi = Vect_get_field(&Map, options.qfield);
    if (options.option == O_QUERY && qFi == NULL)
        G_fatal_error(_("Database connection not defined for layer %d. Use v.db.connect first."),
                      options.qfield);

    if (!options.print) {
	dbDriver *driver = NULL;
	dbString table_name;
	dbTable *table;
	dbColumn *column;
	const char *colname;
	int col, fncols, icol;
	int col_sqltype[4];
	int create_col[4], create_cols;
	int qlength;

	/* get required column types */
	col_sqltype[0] = col_sqltype[1] = col_sqltype[2] = col_sqltype[3] = -1;
	ncols = 1;
	qlength = 0;

	switch (options.option) {
	case O_CAT:
	case O_COUNT:
	    col_sqltype[0] = DB_SQL_TYPE_INTEGER;
	    break;

	case O_LENGTH:
	case O_AREA:
	case O_PERIMETER:
	case O_SLOPE:
	case O_SINUOUS:
	case O_AZIMUTH:
	case O_COMPACT:
	case O_FD:
	    col_sqltype[0] = DB_SQL_TYPE_DOUBLE_PRECISION;
	    break;
	
	case O_BBOX:
	    col_sqltype[0] = col_sqltype[1] = col_sqltype[2] = col_sqltype[3] = DB_SQL_TYPE_DOUBLE_PRECISION;
	    ncols = 4;
	    break;

	case O_COOR:
	case O_START:
	case O_END:
	    col_sqltype[0] = col_sqltype[1] = col_sqltype[2] = DB_SQL_TYPE_DOUBLE_PRECISION;
	    ncols = 2;
	    if (options.col[2])
		ncols = 3;
	    break;

	case O_SIDES:
	    col_sqltype[0] = col_sqltype[1] = DB_SQL_TYPE_INTEGER;
	    ncols = 2;
	    break;

	case O_QUERY:
	    driver = db_start_driver_open_database(qFi->driver, qFi->database);
	    db_init_string(&table_name);
	    db_set_string(&table_name, qFi->table);
	    if (db_describe_table(driver, &table_name, &table) != DB_OK)
		G_fatal_error(_("Unable to describe table <%s>"),
			      qFi->table);

	    fncols = db_get_table_number_of_columns(table);
	    for (col = 0; col < fncols; col++) {
		column = db_get_table_column(table, col);
		colname = db_get_column_name(column);
		if (strcmp(options.qcol, colname) == 0) {
		    col_sqltype[0] = db_get_column_sqltype(column);
		    qlength = db_get_column_length(column);
		    break;
		}
	    }
	    db_close_database_shutdown_driver(driver);
	    driver = NULL;
	    db_free_string(&table_name);
	    break;
	}

	/* check if columns exist */
	create_col[0] = create_col[1] = create_col[2] = create_col[3] = 0;
	create_cols = 0;
	/* does not work if the query column is not a column, but
	 * e.g. count(x) or avg(x) */
	if (options.option != O_QUERY) {
	    driver = db_start_driver_open_database(Fi->driver, Fi->database);
	    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>"),
			      qFi->table);

	    fncols = db_get_table_number_of_columns(table);
	    for (col = 0; col < ncols; col++) {
		int col_exists = 0;

		if (options.col[col] == NULL)
		    G_fatal_error(_("Missing column name for input column number %d"), col + 1);

		for (icol = 0; icol < fncols; icol++) {
		    column = db_get_table_column(table, icol);
		    colname = db_get_column_name(column);
		    if (colname == NULL)
			G_fatal_error(_("Missing column name for table column number %d"), col + 1);
		    if (strcmp(options.col[col], colname) == 0) {
			int isqltype;

			col_exists = 1;
			isqltype = db_get_column_sqltype(column);

			if (isqltype != col_sqltype[col]) {
			    int ctype1, ctype2;

			    ctype1 = db_sqltype_to_Ctype(isqltype);
			    ctype2 = db_sqltype_to_Ctype(col_sqltype[col]);
			    
			    if (ctype1 == ctype2) {
				G_warning(_("Existing column <%s> has a different but maybe compatible type"),
					      options.col[col]);
			    }
			    else {
				G_fatal_error(_("Existing column <%s> has the wrong type"),
					      options.col[col]);
			    }
			}

			if (G_get_overwrite())
			    G_warning(_("Values in column <%s> will be overwritten"),
				      options.col[col]);
			else
			    G_fatal_error(_("Column <%s> exists. To overwrite, use the --overwrite flag"),
					  options.col[col]);

			break;
		    }
		}
		if (!col_exists) {
		    create_col[col] = 1;
		    create_cols = 1;
		}
	    }
	    db_close_database_shutdown_driver(driver);
	    driver = NULL;
	    db_free_string(&table_name);
	}

	/* create columns if not existing */
	if (create_cols) {
	    char sqlbuf[4096];
	    dbString stmt;

	    db_init_string(&stmt);
	    driver = db_start_driver_open_database(Fi->driver, Fi->database);
	    db_begin_transaction(driver);
	    for (col = 0; col < ncols; col++) {
		if (!create_col[col])
		    continue;

		if (col_sqltype[col] == DB_SQL_TYPE_INTEGER) {
		    sprintf(sqlbuf, "ALTER TABLE %s ADD COLUMN %s integer",
			    Fi->table, options.col[col]);
		}
		else if (col_sqltype[col] == DB_SQL_TYPE_DOUBLE_PRECISION ||
		         col_sqltype[col] == DB_SQL_TYPE_REAL) {
		    sprintf(sqlbuf, "ALTER TABLE %s ADD COLUMN %s double precision",
			    Fi->table, options.col[col]);
		}
		else if (col_sqltype[col] == DB_SQL_TYPE_CHARACTER) {
		    if (qlength > 0) {
			sprintf(sqlbuf, "ALTER TABLE %s ADD COLUMN %s varchar(%d)",
				Fi->table, options.col[col], qlength);
		    }
		    else {
			sprintf(sqlbuf, "ALTER TABLE %s ADD COLUMN %s text",
				Fi->table, options.col[col]);
		    }
		}
		else if (col_sqltype[col] == DB_SQL_TYPE_TEXT) {
		    sprintf(sqlbuf, "ALTER TABLE %s ADD COLUMN %s text",
			    Fi->table, options.col[col]);
		}
		else if (col_sqltype[col] == DB_SQL_TYPE_DATE) {
		    sprintf(sqlbuf, "ALTER TABLE %s ADD COLUMN %s date",
			    Fi->table, options.col[col]);
		}
		else if (col_sqltype[col] == DB_SQL_TYPE_TIME) {
		    sprintf(sqlbuf, "ALTER TABLE %s ADD COLUMN %s time",
			    Fi->table, options.col[col]);
		}
		else {
		    sprintf(sqlbuf, "ALTER TABLE %s ADD COLUMN %s %s",
			    Fi->table, options.col[col],
			    db_sqltype_name(col_sqltype[col]));
		}
		db_set_string(&stmt, sqlbuf);
		if (db_execute_immediate(driver, &stmt) != DB_OK) {
		    G_fatal_error(_("Unable to create column <%s>"),
				  options.col[col]);
		}
	    }
	    db_commit_transaction(driver);
	    db_close_database_shutdown_driver(driver);
	    db_free_string(&stmt);
	}
    }

    /* allocate array for values */
    /* (+1 is for cat -1 (no category) reported at the end ) */
    findex = Vect_cidx_get_field_index(&Map, options.field);
    if (findex > -1) {
	n = Vect_cidx_get_num_unique_cats_by_index(&Map, findex);
    }
    else {
	n = 0;
    }
    G_debug(2, "%d unique cats", n);
    Values = (struct value *) G_calloc(n + 1, sizeof(struct value));

    /* prepopulate Values */
    if (findex > -1)
	n = Vect_cidx_get_num_cats_by_index(&Map, findex);
    i = 0;
    Values[i].cat = -1;		/* features without category */
    Values[i].used = 0;
    Values[i].count1 = 0;
    Values[i].count2 = 0;
    Values[i].i1 = -1;
    Values[i].i2 = -1;
    Values[i].d1 = 0.0;
    Values[i].d2 = 0.0;
    Values[i].d3 = 0.0;
    Values[i].d4 = 0.0;
    if (options.option == O_BBOX) {
	Values[i].d1 = -PORT_DOUBLE_MAX;
	Values[i].d2 = PORT_DOUBLE_MAX;
	Values[i].d3 = -PORT_DOUBLE_MAX;
	Values[i].d4 = PORT_DOUBLE_MAX;
    }
    Values[i].qcat = NULL;
    Values[i].nqcats = 0;
    Values[i].aqcats = 0;

    i = 1;
    lastcat = -1;
    /* category index must be sorted,
     * i.e. topology must have been built with GV_BUILD_ALL */
    for (j = 0; j < n; j++) {
	Vect_cidx_get_cat_by_index(&Map, findex, j, &cat, &type, &id);
	if (lastcat > cat) {
	    Vect_close(&Map);
	    G_fatal_error(_("Category index for vector map <%s> is not sorted"),
	                  options.name);
	}

	if (lastcat != cat) {
	    Values[i].cat = cat;
	    Values[i].used = 0;
	    Values[i].count1 = 0;
	    Values[i].count2 = 0;
	    Values[i].i1 = -1;
	    Values[i].i2 = -1;
	    Values[i].d1 = 0.0;
	    Values[i].d2 = 0.0;
	    Values[i].d3 = 0.0;
	    Values[i].d4 = 0.0;
	    if (options.option == O_BBOX) {
		Values[i].d1 = -PORT_DOUBLE_MAX;
		Values[i].d2 = PORT_DOUBLE_MAX;
		Values[i].d3 = -PORT_DOUBLE_MAX;
		Values[i].d4 = PORT_DOUBLE_MAX;
	    }
	    Values[i].qcat = NULL;
	    Values[i].nqcats = 0;
	    Values[i].aqcats = 0;

	    lastcat = cat;
	    i++;
	}
    }

    vstat.rcat = i;

    /* Read values from map */
    if (options.option == O_QUERY) {
	query(&Map);
    }
    else if ((options.option == O_AREA) || (options.option == O_COMPACT) ||
	     (options.option == O_PERIMETER) || (options.option == O_FD) || 
	     (options.option == O_BBOX)) {
	read_areas(&Map);
    }
    else {
	read_lines(&Map);
    }

    /* prune unused values */
    n = vstat.rcat;
    j = 0;
    for (i = 0; i < n; i++) {
	if (Values[i].used) {
	    Values[j] = Values[i];
	    j++;
	}
    }
    vstat.rcat = j;

    conv_units();

    if (options.print || options.total) {
	report();
    }
    else {
	update(&Map);
	Vect_set_db_updated(&Map);
    }

    Vect_close(&Map);

    if (!(options.print || options.total)) {
	print_stat();

	if (Vect_open_update_head(&Map, options.name, "") < 0)
	    G_warning(_("Unable to write history for vector map <%s>"),
		      options.name);
	else {
	    Vect_hist_command(&Map);
	    Vect_close(&Map);
	}
    }

    /* free list */
    G_free(Values);

    exit(EXIT_SUCCESS);
}