/** * mdb_get_relationships * @mdb: Handle to open MDB database file * @tablename: Name of the table to process. Process all tables if NULL. * * Generates relationships by reading the MSysRelationships table. * 'szColumn' contains the column name of the child table. * 'szObject' contains the table name of the child table. * 'szReferencedColumn' contains the column name of the parent table. * 'szReferencedObject' contains the table name of the parent table. * 'grbit' contains integrity constraints. * * Returns: a string stating that relationships are not supported for the * selected backend, or a string containing SQL commands for setting up * the relationship, tailored for the selected backend. * Returns NULL on last iteration. * The caller is responsible for freeing this string. */ static char * mdb_get_relationships(MdbHandle *mdb, const gchar *dbnamespace, const char* tablename) { unsigned int i; gchar *text = NULL; /* String to be returned */ static char *bound[5]; /* Bound values */ static MdbTableDef *table; /* Relationships table */ int backend = 0; /* Backends: 1=oracle, 2=postgres */ char *quoted_table_1, *quoted_column_1, *quoted_table_2, *quoted_column_2, *constraint_name, *quoted_constraint_name; long grbit; if (!strcmp(mdb->backend_name, "oracle")) { backend = 1; } else if (!strcmp(mdb->backend_name, "postgres")) { backend = 2; } else { if (is_init == 0) { /* the first time through */ is_init = 1; return (char *) g_strconcat( "-- relationships are not implemented for ", mdb->backend_name, "\n", NULL); } else { /* the second time through */ is_init = 0; return NULL; } } if (is_init == 0) { table = mdb_read_table_by_name(mdb, "MSysRelationships", MDB_TABLE); if ((!table) || (table->num_rows == 0)) { fprintf(stderr, "No MSysRelationships\n"); return NULL; } mdb_read_columns(table); for (i=0;i<5;i++) { bound[i] = (char *) g_malloc0(MDB_BIND_SIZE); } mdb_bind_column_by_name(table, "szColumn", bound[0], NULL); mdb_bind_column_by_name(table, "szObject", bound[1], NULL); mdb_bind_column_by_name(table, "szReferencedColumn", bound[2], NULL); mdb_bind_column_by_name(table, "szReferencedObject", bound[3], NULL); mdb_bind_column_by_name(table, "grbit", bound[4], NULL); mdb_rewind_table(table); is_init = 1; } else { if (!table) { fprintf(stderr, "table is NULL\n"); } if (table->cur_row >= table->num_rows) { /* past the last row */ for (i=0;i<5;i++) g_free(bound[i]); is_init = 0; return NULL; } } while (1) { if (!mdb_fetch_row(table)) { for (i=0;i<5;i++) g_free(bound[i]); is_init = 0; return NULL; } if (!tablename || !strcmp(bound[1], tablename)) break; } quoted_table_1 = mdb->default_backend->quote_schema_name(dbnamespace, bound[1]); quoted_column_1 = mdb->default_backend->quote_schema_name(dbnamespace, bound[0]); quoted_table_2 = mdb->default_backend->quote_schema_name(dbnamespace, bound[3]); quoted_column_2 = mdb->default_backend->quote_schema_name(dbnamespace, bound[2]); grbit = atoi(bound[4]); constraint_name = g_strconcat(bound[1], "_", bound[0], "_fk", NULL); quoted_constraint_name = mdb->default_backend->quote_schema_name(dbnamespace, constraint_name); free(constraint_name); if (grbit & 0x00000002) { text = g_strconcat( "-- Relationship from ", quoted_table_1, " (", quoted_column_1, ")" " to ", quoted_table_2, "(", quoted_column_2, ")", " does not enforce integrity.\n", NULL); } else { switch (backend) { case 1: /* oracle */ case 2: /* postgres */ text = g_strconcat( "ALTER TABLE ", quoted_table_1, " ADD CONSTRAINT ", quoted_constraint_name, " FOREIGN KEY (", quoted_column_1, ")" " REFERENCES ", quoted_table_2, "(", quoted_column_2, ")", (grbit & 0x00000100) ? " ON UPDATE CASCADE" : "", (grbit & 0x00001000) ? " ON DELETE CASCADE" : "", ";\n", NULL); break; } } free(quoted_table_1); free(quoted_column_1); free(quoted_table_2); free(quoted_column_2); free(quoted_constraint_name); return (char *)text; }
static void generate_table_schema(FILE *outfile, MdbCatalogEntry *entry, char *dbnamespace, guint32 export_options) { MdbTableDef *table; MdbHandle *mdb = entry->mdb; MdbColumn *col; unsigned int i; char* quoted_table_name; char* quoted_name; MdbProperties *props; const char *prop_value; quoted_table_name = mdb->default_backend->quote_schema_name(dbnamespace, entry->object_name); /* drop the table if it exists */ if (export_options & MDB_SHEXP_DROPTABLE) fprintf (outfile, mdb->default_backend->drop_statement, quoted_table_name); /* create the table */ fprintf (outfile, "CREATE TABLE %s\n", quoted_table_name); fprintf (outfile, " (\n"); table = mdb_read_table (entry); /* get the columns */ mdb_read_columns (table); /* loop over the columns, dumping the names and types */ for (i = 0; i < table->num_cols; i++) { col = g_ptr_array_index (table->columns, i); quoted_name = mdb->default_backend->quote_schema_name(NULL, col->name); fprintf (outfile, "\t%s\t\t\t%s", quoted_name, mdb_get_colbacktype_string (col)); free(quoted_name); if (mdb_colbacktype_takes_length(col)) { /* more portable version from DW patch */ if (col->col_size == 0) fputs(" (255)", outfile); else fprintf(outfile, " (%d)", col->col_size); } if (export_options & MDB_SHEXP_CST_NOTNULL) { if (col->col_type == MDB_BOOL) { /* access booleans are never null */ fputs(" NOT NULL", outfile); } else { const gchar *not_null = mdb_col_get_prop(col, "Required"); if (not_null && not_null[0]=='y') fputs(" NOT NULL", outfile); } } if (export_options & MDB_SHEXP_DEFVALUES) { int done = 0; if (col->props) { gchar *defval = g_hash_table_lookup(col->props->hash, "DefaultValue"); if (defval) { size_t def_len = strlen(defval); fputs(" DEFAULT ", outfile); /* ugly hack to detect the type */ if (defval[0]=='"' && defval[def_len-1]=='"') { /* this is a string */ gchar *output_default = malloc(def_len-1); gchar *output_default_escaped = malloc(def_len-1); memcpy(output_default, defval+1, def_len-2); output_default[def_len-2] = 0; output_default_escaped = quote_with_squotes(output_default); fputs(output_default_escaped, outfile); g_free(output_default_escaped); free(output_default); } else if (!strcmp(defval, "Yes")) fputs("TRUE", outfile); else if (!strcmp(defval, "No")) fputs("FALSE", outfile); else if (!strcasecmp(defval, "date()")) { if (!strcmp(mdb_col_get_prop(col, "Format"), "Short Date")) fputs(mdb->default_backend->short_now, outfile); else fputs(mdb->default_backend->long_now, outfile); } else fputs(defval, outfile); done = 1; } } if (!done && col->col_type == MDB_BOOL) /* access booleans are false by default */ fputs(" DEFAULT FALSE", outfile); } if (i < table->num_cols - 1) fputs(", \n", outfile); else fputs("\n", outfile); } /* for */ fputs(");\n", outfile); /* Add the constraints on columns */ for (i = 0; i < table->num_cols; i++) { col = g_ptr_array_index (table->columns, i); props = col->props; if (!props) continue; quoted_name = mdb->default_backend->quote_schema_name(NULL, col->name); if (export_options & MDB_SHEXP_CST_NOTEMPTY) { prop_value = mdb_col_get_prop(col, "AllowZeroLength"); if (prop_value && prop_value[0]=='n') fprintf(outfile, mdb->default_backend->constaint_not_empty_statement, quoted_table_name, quoted_name); } if (export_options & MDB_SHEXP_COMMENTS) { prop_value = mdb_col_get_prop(col, "Description"); if (prop_value) { char *comment = quote_with_squotes(prop_value); fprintf(outfile, mdb->default_backend->column_comment_statement, quoted_table_name, quoted_name, comment); free(comment); } } free(quoted_name); } /* Add the constraints on table */ if (export_options & MDB_SHEXP_COMMENTS) { prop_value = mdb_table_get_prop(table, "Description"); if (prop_value) { char *comment = quote_with_squotes(prop_value); fprintf(outfile, mdb->default_backend->table_comment_statement, quoted_table_name, comment); free(comment); } } fputc('\n', outfile); if (export_options & MDB_SHEXP_INDEXES) // prints all the indexes of that table mdb_print_indexes(outfile, table, dbnamespace); free(quoted_table_name); mdb_free_tabledef (table); }
int main (int argc, char **argv) { unsigned int i, j, k; unsigned int unsupported = 0; MdbHandle *mdb; MdbCatalogEntry *entry; MdbTableDef *table; MdbColumn *col; FILE *typesfile; FILE *headerfile; FILE *cfile; if (argc < 2) { fprintf (stderr, "Usage: %s <file>\n",argv[0]); exit (1); } mdb_init(); /* open the database */ mdb = mdb_open (argv[1], MDB_NOFLAGS); if (!mdb) { mdb_exit(); exit(1); } typesfile = fopen ("types.h", "w"); headerfile = fopen ("dumptypes.h", "w"); cfile = fopen ("dumptypes.c", "w"); copy_header (typesfile); copy_header (headerfile); fprintf (headerfile, "#include \"types.h\"\n"); copy_header (cfile); fprintf (cfile, "#include <stdio.h>\n"); fprintf (cfile, "#include \"dumptypes.h\"\n"); /* read the catalog */ mdb_read_catalog (mdb, MDB_TABLE); /* loop over each entry in the catalog */ for (i=0; i < mdb->num_catalog; i++) { entry = g_ptr_array_index (mdb->catalog, i); if (!mdb_is_user_table(entry)) continue; fprintf (typesfile, "typedef struct _%s\n", entry->object_name); fprintf (typesfile, "{\n"); fprintf (headerfile, "void dump_%s (%s x);\n", entry->object_name, entry->object_name); fprintf (cfile, "void dump_%s (%s x)\n{\n", entry->object_name, entry->object_name); fprintf (cfile, "\tfprintf (stdout, \"**************** %s ****************\\n\");\n", entry->object_name); table = mdb_read_table (entry); /* get the columns */ mdb_read_columns (table); /* loop over the columns, dumping the names and types */ for (k = 0; k < table->num_cols; k++) { col = g_ptr_array_index (table->columns, k); fprintf (cfile, "\tfprintf (stdout, \"x."); for (j = 0; j < strlen (col->name); j++) { fprintf (cfile, "%c", tolower (col->name [j])); } fprintf (cfile, " = \");\n"); switch (col->col_type) { case MDB_INT: fprintf (typesfile, "\tint\t"); fprintf (cfile, "\tdump_int (x."); break; case MDB_LONGINT: fprintf (typesfile, "\tlong\t"); fprintf (cfile, "\tdump_long (x."); break; case MDB_TEXT: case MDB_MEMO: fprintf (typesfile, "\tchar *\t"); fprintf (cfile, "\tdump_string (x."); break; default: unsupported = 1; break; } for (j = 0; j < strlen (col->name); j++) { fprintf (typesfile, "%c", tolower (col->name [j])); fprintf (cfile, "%c", tolower (col->name [j])); } fprintf (typesfile, ";\n"); fprintf (cfile, ");\n"); } fprintf (typesfile, "\n} %s ;\n", entry->object_name); fprintf (typesfile, "\n"); fprintf (cfile, "}\n\n"); mdb_free_tabledef(table); } fclose (headerfile); fclose (typesfile); fclose (cfile); mdb_close (mdb); mdb_exit(); if (unsupported) fputs("ERROR: unsupported type.\n", stderr); exit(unsupported); }
void mdb_table_dump(MdbCatalogEntry *entry) { MdbTableDef *table; MdbColumn *col; int coln; MdbIndex *idx; 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); if (table->props) mdb_dump_props(table->props, stdout, 0); 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_colbacktype_string(col), col->col_size); if (col->props) mdb_dump_props(col->props, stdout, 0); } 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"); } }
void gmdb_table_export_button_cb(GtkWidget *w, gpointer data) { gchar *file_path; FILE *outfile; gchar *bound_data[256]; MdbTableDef *table; MdbColumn *col; int i; int need_headers = 0; int need_quote = 0; gchar delimiter[11]; gchar quotechar; gchar lineterm[5]; gchar *str; int rows=0; GtkWidget *exportwin, *dlg; gmdb_export_get_delimiter(exportwin_xml, delimiter, 10); gmdb_export_get_lineterm(exportwin_xml, lineterm, 5); need_quote = gmdb_export_get_quote(exportwin_xml); quotechar = gmdb_export_get_quotechar(exportwin_xml); need_headers = gmdb_export_get_headers(exportwin_xml); file_path = gmdb_export_get_filepath(exportwin_xml); // printf("file path %s\n",file_path); if ((outfile=fopen(file_path, "w"))==NULL) { GtkWidget* dlg = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (w)), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, _("Unable to open file.")); gtk_dialog_run (GTK_DIALOG (dlg)); gtk_widget_destroy (dlg); return; } /* read table */ table = mdb_read_table(cat_entry); mdb_read_columns(table); mdb_rewind_table(table); for (i=0;i<table->num_cols;i++) { /* bind columns */ bound_data[i] = (char *) g_malloc0(MDB_BIND_SIZE); mdb_bind_column(table, i+1, bound_data[i], NULL); /* display column titles */ col=g_ptr_array_index(table->columns,i); if (need_headers) { if (i>0) fprintf(outfile,delimiter); gmdb_print_quote(outfile, need_quote, quotechar, delimiter, col->name); fprintf(outfile,"%s", col->name); gmdb_print_quote(outfile, need_quote, quotechar, delimiter, col->name); } } if (need_headers) fprintf(outfile,lineterm); /* fetch those rows! */ while(mdb_fetch_row(table)) { for (i=0;i<table->num_cols;i++) { if (i>0) fprintf(outfile,delimiter); gmdb_print_quote(outfile, need_quote, quotechar, delimiter, bound_data[i]); fprintf(outfile,"%s", bound_data[i]); gmdb_print_quote(outfile, need_quote, quotechar, delimiter, bound_data[i]); } fprintf(outfile,lineterm); rows++; } /* free the memory used to bind */ for (i=0;i<table->num_cols;i++) { g_free(bound_data[i]); } fclose(outfile); exportwin = glade_xml_get_widget (exportwin_xml, "export_dialog"); gtk_widget_destroy(exportwin); dlg = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (w)), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, _("%d rows successfully exported."), rows); gtk_dialog_run (GTK_DIALOG (dlg)); gtk_widget_destroy (dlg); }
int main(int argc, char **argv) { MdbHandle *mdb; MdbTableDef *table; gchar name[256]; gchar *propColName; void *buf; int col_num; int found = 0; if (argc < 3) { fprintf(stderr,"Usage: %s <file> <object name> [<prop col>]\n", argv[0]); return 1; } if (argc < 4) propColName = "LvProp"; else propColName = argv[3]; mdb_init(); mdb = mdb_open(argv[1], MDB_NOFLAGS); if (!mdb) { mdb_exit(); return 1; } table = mdb_read_table_by_name(mdb, "MSysObjects", MDB_ANY); if (!table) { mdb_close(mdb); mdb_exit(); return 1; } mdb_read_columns(table); mdb_rewind_table(table); mdb_bind_column_by_name(table, "Name", name, NULL); buf = g_malloc(MDB_BIND_SIZE); col_num = mdb_bind_column_by_name(table, propColName, buf, NULL); if (col_num < 1) { g_free(buf); mdb_free_tabledef(table); mdb_close(mdb); mdb_exit(); printf("Column %s not found in MSysObjects!\n", argv[3]); return 1; } while(mdb_fetch_row(table)) { if (!strcmp(name, argv[2])) { found = 1; break; } } if (found) { MdbColumn *col = g_ptr_array_index(table->columns, col_num-1); size_t size; void *kkd = mdb_ole_read_full(mdb, col, &size); dump_kkd(mdb, kkd, size); free(kkd); } g_free(buf); mdb_free_tabledef(table); mdb_close(mdb); mdb_exit(); return 0; }
int main (int argc, char **argv) { unsigned int j; MdbHandle *mdb; MdbTableDef *table; MdbColumn *col; /* doesn't handle tables > 256 columns. Can that happen? */ char *bound_values [256]; char delimiter [] = ", "; char quote_text = 1; int count = 0; int started; if (argc < 3) { fprintf (stderr, "Usage: %s <file> <table>\n", argv [0]); exit (1); } mdb_init(); mdb = mdb_open (argv [1], MDB_NOFLAGS); table = mdb_read_table_by_name (mdb, argv[2], MDB_TABLE); if (table) { mdb_read_columns (table); mdb_rewind_table (table); for (j = 0; j < table->num_cols; j++) { bound_values [j] = (char *) g_malloc (MDB_BIND_SIZE); bound_values [j] [0] = '\0'; mdb_bind_column (table, j+1, bound_values[j], NULL); } fprintf (stdout, "/******************************************************************/\n"); fprintf (stdout, "/* THIS IS AN AUTOMATICALLY GENERATED FILE. DO NOT EDIT IT!!!!!! */\n"); fprintf (stdout, "/******************************************************************/\n"); fprintf (stdout, "\n"); fprintf (stdout, "#include <stdio.h>\n"); fprintf (stdout, "#include \"types.h\"\n"); fprintf (stdout, "#include \"dump.h\"\n"); fprintf (stdout, "\n"); fprintf (stdout, "const %s %s_array [] = {\n", argv [2], argv [2]); count = 0; started = 0; while (mdb_fetch_row (table)) { if (started != 0) { fprintf (stdout, ",\n"); } started = 1; fprintf (stdout, "{\t\t\t\t/* %6d */\n\t", count); for (j = 0; j < table->num_cols; j++) { fprintf (stdout, "\t"); col = g_ptr_array_index (table->columns, j); if (quote_text && (col->col_type == MDB_TEXT || col->col_type == MDB_MEMO)) { fprintf (stdout, "\"%s\"", bound_values [j]); } else { fprintf (stdout, "%s", bound_values [j]); } if (j != table->num_cols - 1) { fprintf (stdout, "%s\n", delimiter); } else { fprintf (stdout, "\n"); } } fprintf (stdout, "}"); count++; } fprintf (stdout, "\n};\n\n"); for (j = 0; j < table->num_cols; j++) { g_free (bound_values [j]); } mdb_free_tabledef(table); } mdb_close (mdb); mdb_exit(); fprintf (stdout, "const int %s_array_length = %d;\n", argv [2], count); exit(0); }
void gmdb_table_export_button_cb(GtkWidget *w, gpointer data) { gchar *file_path; FILE *outfile; gchar *bound_data[256]; MdbTableDef *table; MdbColumn *col; int i; int need_headers = 0; int need_quote = 0; gchar delimiter[11]; gchar quotechar; gchar lineterm[5]; gchar *str; int rows=0; char msg[100]; GtkWidget *exportwin; gmdb_export_get_delimiter(exportwin_xml, delimiter, 10); gmdb_export_get_lineterm(exportwin_xml, lineterm, 5); need_quote = gmdb_export_get_quote(exportwin_xml); quotechar = gmdb_export_get_quotechar(exportwin_xml); need_headers = gmdb_export_get_headers(exportwin_xml); file_path = gmdb_export_get_filepath(exportwin_xml); // printf("file path %s\n",file_path); if ((outfile=fopen(file_path, "w"))==NULL) { gnome_warning_dialog("Unable to Open File!"); return; } /* read table */ table = mdb_read_table(cat_entry); mdb_read_columns(table); mdb_rewind_table(table); for (i=0;i<table->num_cols;i++) { /* bind columns */ bound_data[i] = (char *) malloc(MDB_BIND_SIZE); bound_data[i][0] = '\0'; mdb_bind_column(table, i+1, bound_data[i]); /* display column titles */ col=g_ptr_array_index(table->columns,i); if (need_headers) { if (i>0) fprintf(outfile,delimiter); gmdb_print_quote(outfile, need_quote, quotechar, delimiter, col->name); fprintf(outfile,"%s", col->name); gmdb_print_quote(outfile, need_quote, quotechar, delimiter, col->name); } } if (need_headers) fprintf(outfile,lineterm); /* fetch those rows! */ while(mdb_fetch_row(table)) { for (i=0;i<table->num_cols;i++) { if (i>0) fprintf(outfile,delimiter); gmdb_print_quote(outfile, need_quote, quotechar, delimiter, bound_data[i]); fprintf(outfile,"%s", bound_data[i]); gmdb_print_quote(outfile, need_quote, quotechar, delimiter, bound_data[i]); } fprintf(outfile,lineterm); rows++; } /* free the memory used to bind */ for (i=0;i<table->num_cols;i++) { free(bound_data[i]); } fclose(outfile); exportwin = glade_xml_get_widget (exportwin_xml, "export_dialog"); gtk_widget_destroy(exportwin); sprintf(msg,"%d Rows exported successfully.\n", rows); gnome_ok_dialog(msg); }
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; }
main (int argc, char **argv) { int i, j, k; MdbHandle *mdb; MdbCatalogEntry *entry; MdbTableDef *table; MdbColumn *col; char *the_relation; char *tabname = NULL; int opt; if (argc < 2) { fprintf (stderr, "Usage: %s <file> [<backend>]\n",argv[0]); exit (1); } while ((opt=getopt(argc, argv, "T:"))!=-1) { switch (opt) { case 'T': tabname = (char *) malloc(strlen(optarg)+1); strcpy(tabname, optarg); break; } } mdb_init(); /* open the database */ mdb = mdb_open (argv[optind]); if (argc - optind >2) { if (!mdb_set_default_backend(mdb, argv[optind + 1])) { fprintf(stderr,"Invalid backend type\n"); mdb_exit(); exit(1); } } /* read the catalog */ mdb_read_catalog (mdb, MDB_TABLE); /* loop over each entry in the catalog */ for (i=0; i < mdb->num_catalog; i++) { entry = g_ptr_array_index (mdb->catalog, i); /* if it's a table */ if (entry->object_type == MDB_TABLE) { /* skip the MSys tables */ if ((tabname && !strcmp(entry->object_name,tabname)) || (!tabname && strncmp (entry->object_name, "MSys", 4))) { /* make sure it's a table (may be redundant) */ if (!strcmp (mdb_get_objtype_string (entry->object_type), "Table")) { /* drop the table if it exists */ fprintf (stdout, "DROP TABLE %s;\n", entry->object_name); /* create the table */ fprintf (stdout, "CREATE TABLE %s\n", entry->object_name); fprintf (stdout, " (\n"); table = mdb_read_table (entry); /* get the columns */ mdb_read_columns (table); /* loop over the columns, dumping the names and types */ for (k = 0; k < table->num_cols; k++) { col = g_ptr_array_index (table->columns, k); fprintf (stdout, "\t%s\t\t\t%s", col->name, mdb_get_coltype_string (mdb->default_backend, col->col_type)); if (col->col_size != 0) fprintf (stdout, " (%d)", col->col_size); if (k < table->num_cols - 1) fprintf (stdout, ", \n"); else fprintf (stdout, "\n"); } fprintf (stdout, "\n);\n"); fprintf (stdout, "-- CREATE ANY INDEXES ...\n"); fprintf (stdout, "\n"); } } } } fprintf (stdout, "\n\n"); fprintf (stdout, "-- CREATE ANY Relationships ...\n"); fprintf (stdout, "\n"); the_relation=mdb_get_relationships(mdb); while (the_relation[0] != '\0') { fprintf(stdout,"%s\n",the_relation); the_relation=mdb_get_relationships(mdb); } mdb_free_handle (mdb); mdb_exit(); exit(0); }
/* functions */ GtkWidget * gmdb_table_data_new(MdbCatalogEntry *entry) { MdbTableDef *table; MdbColumn *col; GtkWidget *clist; GtkWidget *scroll; int i, rownum; long row, maxrow; gchar *bound_data[256]; GMdbDataWindow *dataw = NULL; /* do we have an active window for this object? if so raise it */ for (i=0;i<g_list_length(window_list);i++) { dataw = g_list_nth_data(window_list, i); if (!strcmp(dataw->table_name, entry->object_name)) { gdk_window_raise (dataw->window->window); return dataw->window; } } dataw = g_malloc(sizeof(GMdbDataWindow)); strcpy(dataw->table_name, entry->object_name); dataw->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(dataw->window), entry->object_name); gtk_widget_set_usize(dataw->window, 300,200); gtk_widget_set_uposition(dataw->window, 50,50); gtk_widget_show(dataw->window); gtk_signal_connect (GTK_OBJECT (dataw->window), "delete_event", GTK_SIGNAL_FUNC (gmdb_table_data_close), dataw); scroll = gtk_scrolled_window_new(NULL,NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show (scroll); gtk_container_add(GTK_CONTAINER(dataw->window), scroll); /* read table */ table = mdb_read_table(entry); mdb_read_columns(table); mdb_rewind_table(table); clist = gtk_clist_new(table->num_cols); gtk_widget_show(clist); gtk_container_add(GTK_CONTAINER(scroll),clist); for (i=0;i<table->num_cols;i++) { /* bind columns */ bound_data[i] = (char *) g_malloc0(MDB_BIND_SIZE); mdb_bind_column(table, i+1, bound_data[i], NULL); /* display column titles */ col=g_ptr_array_index(table->columns,i); gtk_clist_set_column_title(GTK_CLIST(clist), i, col->name); } gtk_clist_column_titles_show(GTK_CLIST(clist)); maxrow = gmdb_prefs_get_maxrows(); /* fetch those rows! */ row = 0; while(mdb_fetch_row(table) && (!maxrow || (row < maxrow))) { row++; rownum = gtk_clist_append(GTK_CLIST(clist), bound_data); } /* free the memory used to bind */ for (i=0;i<table->num_cols;i++) { g_free(bound_data[i]); } /* add this one to the window list */ window_list = g_list_append(window_list, dataw); return dataw->window; }