void mdb_table_dump(MdbCatalogEntry *entry)
{
MdbTableDef *table;
MdbColumn *col;
int coln;
MdbIndex *idx;
MdbHandle *mdb = entry->mdb;
unsigned int i, bitn;
guint32 pgnum;
table = mdb_read_table(entry);
fprintf(stdout,"definition page = %lu\n",entry->table_pg);
fprintf(stdout,"number of datarows = %d\n",table->num_rows);
fprintf(stdout,"number of columns = %d\n",table->num_cols);
fprintf(stdout,"number of indices = %d\n",table->num_real_idxs);
mdb_read_columns(table);
mdb_read_indices(table);
for (i=0;i<table->num_cols;i++) {
col = g_ptr_array_index(table->columns,i);
fprintf(stdout,"column %d Name: %-20s Type: %s(%d)\n",
i, col->name,
mdb_get_coltype_string(mdb->default_backend, col->col_type),
col->col_size);
}
for (i=0;i<table->num_idxs;i++) {
idx = g_ptr_array_index (table->indices, i);
mdb_index_dump(table, idx);
}
if (table->usage_map) {
printf("pages reserved by this object\n");
printf("usage map pg %" G_GUINT32_FORMAT "\n",
table->map_base_pg);
printf("free map pg %" G_GUINT32_FORMAT "\n",
table->freemap_base_pg);
pgnum = mdb_get_int32(table->usage_map,1);
/* the first 5 bytes of the usage map mean something */
coln = 0;
for (i=5;i<table->map_sz;i++) {
for (bitn=0;bitn<8;bitn++) {
if (table->usage_map[i] & 1 << bitn) {
coln++;
printf("%6" G_GUINT32_FORMAT, pgnum);
if (coln==10) {
printf("\n");
coln = 0;
} else {
printf(" ");
}
}
pgnum++;
}
}
printf("\n");
}
}
int
main(int argc, char **argv)
{
MdbHandle *mdb;
MdbTableDef *table;
char *colname, *tabname;
char *colval;
int colnum;
char *sargname = NULL;
char *updstr = NULL;
char data[255];
int len;
if (argc<4) {
fprintf(stderr,"Usage: %s <file> <table> <sargs> <updstr>\n",argv[0]);
exit(1);
}
mdb = mdb_open(argv[1], MDB_WRITABLE);
tabname = argv[2];
sargname = argv[3];
updstr = g_strdup(argv[4]);
table = mdb_read_table_by_name(mdb, tabname, MDB_TABLE);
if (table) {
mdb_read_columns(table);
mdb_read_indices(table);
printf("updstr %s\n",updstr);
colname = strtok(updstr,"=");
colval = strtok(NULL,"=");
colnum = mdb_bind_column_by_name(table, colname, data, &len);
printf("column %d\n", colnum);
read_to_row(table, sargname);
printf("current value of %s is %s, changing to %s\n", colname, data, colval);
len = strlen(colval);
strcpy(data,colval);
mdb_update_row(table);
mdb_free_tabledef(table);
}
mdb_close(mdb);
return 0;
}
/**
* mdb_print_indexes
* @output: Where to print the sql
* @table: Table to process
* @dbnamespace: Target namespace/schema name
*/
static void
mdb_print_indexes(FILE* outfile, MdbTableDef *table, char *dbnamespace)
{
unsigned int i, j;
char* quoted_table_name;
char* index_name;
char* quoted_name;
MdbHandle* mdb = table->entry->mdb;
MdbIndex *idx;
MdbColumn *col;
if (strcmp(mdb->backend_name, "postgres")) {
fprintf(outfile, "-- Indexes are not implemented for %s\n\n", mdb->backend_name);
return;
}
/* read indexes */
mdb_read_indices(table);
fprintf (outfile, "-- CREATE INDEXES ...\n");
quoted_table_name = mdb->default_backend->quote_schema_name(dbnamespace, table->name);
for (i=0;i<table->num_idxs;i++) {
idx = g_ptr_array_index (table->indices, i);
if (idx->index_type==2)
continue;
index_name = malloc(strlen(table->name)+strlen(idx->name)+5+1);
strcpy(index_name, table->name);
if (idx->index_type==1)
strcat(index_name, "_pkey");
else {
strcat(index_name, "_");
strcat(index_name, idx->name);
strcat(index_name, "_idx");
}
quoted_name = mdb->default_backend->quote_schema_name(dbnamespace, index_name);
if (idx->index_type==1) {
fprintf (outfile, "ALTER TABLE %s ADD CONSTRAINT %s PRIMARY KEY (", quoted_table_name, quoted_name);
} else {
fprintf(outfile, "CREATE");
if (idx->flags & MDB_IDX_UNIQUE)
fprintf (outfile, " UNIQUE");
fprintf(outfile, " INDEX %s ON %s (", quoted_name, quoted_table_name);
}
free(quoted_name);
free(index_name);
for (j=0;j<idx->num_keys;j++) {
if (j)
fprintf(outfile, ", ");
col=g_ptr_array_index(table->columns,idx->key_col_num[j]-1);
quoted_name = mdb->default_backend->quote_schema_name(NULL, col->name);
fprintf (outfile, "%s", quoted_name);
if (idx->index_type!=1 && idx->key_col_order[j])
/* no DESC for primary keys */
fprintf(outfile, " DESC");
free(quoted_name);
}
fprintf (outfile, ");\n");
}
fputc ('\n', outfile);
}
int
main(int argc, char **argv)
{
int i, row;
MdbHandle *mdb;
MdbTableDef *table;
MdbField fields[256];
char line[MAX_ROW_SIZE];
int num_fields;
/* doesn't handle tables > 256 columns. Can that happen? */
int opt;
FILE *in;
char delimiter[2] = ",";
char header_rows = 0;
while ((opt=getopt(argc, argv, "H:d:"))!=-1) {
switch (opt) {
case 'H':
header_rows = atol(optarg);
break;
case 'd':
delimiter[0] = optarg[0];
break;
default:
break;
}
}
/*
** optind is now the position of the first non-option arg,
** see getopt(3)
*/
if (argc-optind < 3) {
fprintf(stderr,"Usage: %s [options] <database> <table> <csv file>\n",argv[0]);
fprintf(stderr,"where options are:\n");
fprintf(stderr," -H <rows> skip <rows> header rows\n");
fprintf(stderr," -d <delimiter> specify a column delimiter\n");
exit(1);
}
if (!(mdb = mdb_open(argv[optind], MDB_WRITABLE))) {
exit(1);
}
table = mdb_read_table_by_name(mdb, argv[argc-2], MDB_TABLE);
if (!table) {
fprintf(stderr,"Table %s not found in database\n", argv[argc-2]);
exit(1);
}
mdb_read_columns(table);
mdb_read_indices(table);
mdb_rewind_table(table);
/*
* open the CSV file and read any header rows
*/
in = fopen(argv[argc-1], "r");
if (!in) {
fprintf(stderr, "Can not open file %s\n", argv[argc-1]);
exit(1);
}
for (i=0;i<header_rows;i++)
if (!fgets(line, MAX_ROW_SIZE, in)) {
fprintf(stderr, "Error while reading header column #%d. Check -H parameter.\n", i);
exit(1);
}
row = 1;
while (fgets(line, MAX_ROW_SIZE, in)) {
num_fields = prep_row(table, line, fields, delimiter);
if (!num_fields) {
fprintf(stderr, "Aborting import at row %d\n", row);
exit(1);
}
/*
* all the prep work is done, let's add the row
*/
mdb_insert_row(table, num_fields, fields);
}
mdb_free_tabledef(table);
fclose(in);
mdb_close(mdb);
return 0;
}
