mirror of
https://git.postgresql.org/git/postgresql.git
synced 2024-07-24 01:29:38 +02:00
4fec55af6c
the entered password would get echoed on some platforms, eg HPUX. We have enough copies of this code that I'm thinking it ought to be moved into libpq, but that's a task for another day.
837 lines
20 KiB
C
837 lines
20 KiB
C
/* This program reads in an xbase-dbf file and sends 'inserts' to an
|
|
PostgreSQL-server with the records in the xbase-file
|
|
|
|
M. Boekhold (boekhold@cindy.et.tudelft.nl) okt. 1995
|
|
oktober 1996: merged sources of dbf2msql.c and dbf2pg.c
|
|
oktober 1997: removed msql support
|
|
*/
|
|
#include "postgres_fe.h"
|
|
|
|
#define HAVE_ICONV_H /* should be somewhere else */
|
|
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <ctype.h>
|
|
#ifdef HAVE_TERMIOS_H
|
|
#include <termios.h>
|
|
#endif
|
|
#ifdef HAVE_ICONV_H
|
|
#include <iconv.h>
|
|
#endif
|
|
|
|
#include "libpq-fe.h"
|
|
#include "dbf.h"
|
|
|
|
int verbose = 0, upper = 0, lower = 0, create = 0, fieldlow = 0;
|
|
int del = 0;
|
|
unsigned int begin = 0, end = 0;
|
|
unsigned int t_block = 0;
|
|
|
|
#ifdef HAVE_ICONV_H
|
|
char *charset_from=NULL;
|
|
char *charset_to="ISO-8859-1";
|
|
iconv_t iconv_d;
|
|
char convert_charset_buff[8192];
|
|
#endif
|
|
|
|
char *host = NULL;
|
|
char *dbase = "test";
|
|
char *table = "test";
|
|
char *username = NULL;
|
|
char *password = NULL;
|
|
char *subarg = NULL;
|
|
char escape_buff[8192];
|
|
|
|
void do_substitute(char *subarg, dbhead *dbh);
|
|
inline void strtoupper(char *string);
|
|
|
|
inline void strtolower(char *string);
|
|
void do_create(PGconn *, char*, dbhead*);
|
|
void do_inserts(PGconn *, char*, dbhead*);
|
|
int check_table(PGconn *, char*);
|
|
|
|
char *Escape(char*);
|
|
#ifdef HAVE_ICONV_H
|
|
char *convert_charset(char *string);
|
|
#endif
|
|
void usage(void);
|
|
unsigned int isinteger(char *);
|
|
|
|
char *simple_prompt(const char *prompt, int maxlen, bool echo);
|
|
|
|
|
|
unsigned int isinteger(char *buff) {
|
|
char *i=buff;
|
|
|
|
while (*i != '\0') {
|
|
if (i==buff)
|
|
if ((*i == '-') ||
|
|
(*i == '+')) {
|
|
i++; continue;
|
|
}
|
|
if (!isdigit((int)*i)) return 0;
|
|
i++;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
inline void strtoupper(char *string) {
|
|
while(*string != '\0') {
|
|
*string = toupper(*string);
|
|
string++;
|
|
}
|
|
}
|
|
|
|
inline void strtolower(char *string) {
|
|
while(*string != '\0') {
|
|
*string = tolower(*string);
|
|
string++;
|
|
}
|
|
}
|
|
|
|
/* FIXME: should this check for overflow? */
|
|
char *Escape(char *string) {
|
|
char *foo, *bar;
|
|
|
|
foo = escape_buff;
|
|
|
|
bar = string;
|
|
while (*bar != '\0') {
|
|
if ((*bar == '\t') ||
|
|
(*bar == '\n') ||
|
|
(*bar == '\\')) {
|
|
*foo++ = '\\';
|
|
}
|
|
*foo++ = *bar++;
|
|
}
|
|
*foo = '\0';
|
|
|
|
return escape_buff;
|
|
}
|
|
|
|
#ifdef HAVE_ICONV_H
|
|
char *convert_charset(char *string) {
|
|
size_t in_size, out_size, nconv;
|
|
char *in_ptr,*out_ptr;
|
|
|
|
in_size=strlen(string)+1;
|
|
out_size=sizeof(convert_charset_buff);
|
|
in_ptr=string;
|
|
out_ptr=convert_charset_buff;
|
|
|
|
iconv(iconv_d, NULL, &in_size, &out_ptr, &out_size); /* necessary to reset state information */
|
|
while(in_size>0)
|
|
{
|
|
nconv = iconv(iconv_d, &in_ptr, &in_size, &out_ptr, &out_size);
|
|
if(nconv == (size_t) -1)
|
|
{
|
|
printf("WARNING: cannot convert charset of string \"%s\".\n",
|
|
string);
|
|
strcpy(convert_charset_buff,string);
|
|
return convert_charset_buff;
|
|
}
|
|
}
|
|
*out_ptr = 0; /* terminate output string */
|
|
return convert_charset_buff;
|
|
}
|
|
#endif
|
|
|
|
int check_table(PGconn *conn, char *table) {
|
|
char *q = "select relname from pg_class where "
|
|
"relkind='r' and relname !~* '^pg'";
|
|
PGresult *res;
|
|
int i = 0;
|
|
|
|
if (!(res = PQexec(conn, q))) {
|
|
printf("%s\n", PQerrorMessage(conn));
|
|
return 0;
|
|
}
|
|
|
|
for (i = 0; i < PQntuples(res); i++) {
|
|
if (!strcmp(table, PQgetvalue(res, i, PQfnumber(res, "relname")))) {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void usage(void){
|
|
printf("dbf2pg\n"
|
|
"usage: dbf2pg [-u | -l] [-h hostname] [-W] [-U username]\n"
|
|
" [-B transaction_size] [-F charset_from [-T charset_to]]\n"
|
|
" [-s oldname=newname[,oldname=newname[...]]] [-d dbase]\n"
|
|
" [-t table] [-c | -D] [-f] [-v[v]] dbf-file\n");
|
|
}
|
|
|
|
/* patch submitted by Jeffrey Y. Sue <jysue@aloha.net> */
|
|
/* Provides functionallity for substituting dBase-fieldnames for others */
|
|
/* Mainly for avoiding conflicts between fieldnames and SQL-reserved */
|
|
/* keywords */
|
|
|
|
void do_substitute(char *subarg, dbhead *dbh)
|
|
{
|
|
/* NOTE: subarg is modified in this function */
|
|
int i,bad;
|
|
char *p,*oldname,*newname;
|
|
if (!subarg) {
|
|
return;
|
|
}
|
|
if (verbose>1) {
|
|
printf("Substituting new field names\n");
|
|
}
|
|
/* use strstr instead of strtok because of possible empty tokens */
|
|
oldname = subarg;
|
|
while (oldname && strlen(oldname) && (p=strstr(oldname,"=")) ) {
|
|
*p = '\0'; /* mark end of oldname */
|
|
newname = ++p; /* point past \0 of oldname */
|
|
if (strlen(newname)) { /* if not an empty string */
|
|
p = strstr(newname,",");
|
|
if (p) {
|
|
*p = '\0'; /* mark end of newname */
|
|
p++; /* point past where the comma was */
|
|
}
|
|
}
|
|
if (strlen(newname)>=DBF_NAMELEN) {
|
|
printf("Truncating new field name %s to %d chars\n",
|
|
newname,DBF_NAMELEN-1);
|
|
newname[DBF_NAMELEN-1] = '\0';
|
|
}
|
|
bad = 1;
|
|
for (i=0;i<dbh->db_nfields;i++) {
|
|
if (strcmp(dbh->db_fields[i].db_name,oldname)==0) {
|
|
bad = 0;
|
|
strcpy(dbh->db_fields[i].db_name,newname);
|
|
if (verbose>1) {
|
|
printf("Substitute old:%s new:%s\n",
|
|
oldname,newname);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (bad) {
|
|
printf("Warning: old field name %s not found\n",
|
|
oldname);
|
|
}
|
|
oldname = p;
|
|
}
|
|
} /* do_substitute */
|
|
|
|
void do_create(PGconn *conn, char *table, dbhead *dbh) {
|
|
char *query;
|
|
char t[20];
|
|
int i, length;
|
|
PGresult *res;
|
|
|
|
if (verbose > 1) {
|
|
printf("Building CREATE-clause\n");
|
|
}
|
|
|
|
if (!(query = (char *)malloc(
|
|
(dbh->db_nfields * 40) + 29 + strlen(table)))) {
|
|
fprintf(stderr, "Memory allocation error in function do_create\n");
|
|
PQfinish(conn);
|
|
close(dbh->db_fd);
|
|
free(dbh);
|
|
exit(1);
|
|
}
|
|
|
|
sprintf(query, "CREATE TABLE %s (", table);
|
|
length = strlen(query);
|
|
for ( i = 0; i < dbh->db_nfields; i++) {
|
|
if (!strlen(dbh->db_fields[i].db_name)) {
|
|
continue;
|
|
/* skip field if length of name == 0 */
|
|
}
|
|
if ((strlen(query) != length)) {
|
|
strcat(query, ",");
|
|
}
|
|
|
|
if (fieldlow)
|
|
strtolower(dbh->db_fields[i].db_name);
|
|
|
|
strcat(query, dbh->db_fields[i].db_name);
|
|
switch(dbh->db_fields[i].db_type) {
|
|
case 'D':
|
|
strcat(query, " date");
|
|
break;
|
|
case 'C':
|
|
if (dbh->db_fields[i].db_flen > 1) {
|
|
strcat(query, " varchar");
|
|
sprintf(t, "(%d)",
|
|
dbh->db_fields[i].db_flen);
|
|
strcat(query, t);
|
|
} else {
|
|
strcat(query, " char");
|
|
}
|
|
break;
|
|
case 'N':
|
|
if (dbh->db_fields[i].db_dec != 0) {
|
|
strcat(query, " real");
|
|
} else {
|
|
strcat(query, " int");
|
|
}
|
|
break;
|
|
case 'L':
|
|
strcat(query, " char");
|
|
break;
|
|
}
|
|
}
|
|
|
|
strcat(query, ")");
|
|
|
|
if (verbose > 1) {
|
|
printf("Sending create-clause\n");
|
|
printf("%s\n", query);
|
|
}
|
|
|
|
if ((res = PQexec(conn, query)) == NULL) {
|
|
fprintf(stderr, "Error creating table!\n");
|
|
fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
|
|
close(dbh->db_fd);
|
|
free(dbh);
|
|
free(query);
|
|
PQfinish(conn);
|
|
exit(1);
|
|
}
|
|
|
|
PQclear(res);
|
|
free(query);
|
|
}
|
|
|
|
/* FIXME: can be optimized to not use strcat, but it is worth the effort? */
|
|
void do_inserts(PGconn *conn, char *table, dbhead *dbh) {
|
|
PGresult *res;
|
|
field *fields;
|
|
int i, h, result;
|
|
char *query, *foo;
|
|
char pgdate[10];
|
|
|
|
if (verbose > 1) {
|
|
printf("Inserting records\n");
|
|
}
|
|
|
|
h = 2; /* 2 because of terminating \n\0 */
|
|
|
|
for ( i = 0 ; i < dbh->db_nfields ; i++ ) {
|
|
h += dbh->db_fields[i].db_flen > 2 ?
|
|
dbh->db_fields[i].db_flen :
|
|
2; /* account for possible NULL values (\N) */
|
|
h += 1; /* the delimiter */
|
|
}
|
|
|
|
/* make sure we can build the COPY query, note that we don't need to just
|
|
add this value, since the COPY query is a separate query (see below) */
|
|
if (h < 17+strlen(table)) h = 17+strlen(table);
|
|
|
|
if (!(query = (char *)malloc(h))) {
|
|
PQfinish(conn);
|
|
fprintf(stderr,
|
|
"Memory allocation error in function do_inserts (query)\n");
|
|
close(dbh->db_fd);
|
|
free(dbh);
|
|
exit(1);
|
|
}
|
|
|
|
if ((fields = dbf_build_record(dbh)) == (field *)DBF_ERROR) {
|
|
fprintf(stderr,
|
|
"Couldn't allocate memory for record in do_insert\n");
|
|
PQfinish(conn);
|
|
free(query);
|
|
dbf_close(dbh);
|
|
exit(1);
|
|
}
|
|
|
|
if (end == 0) /* "end" is a user option, if not specified, */
|
|
end = dbh->db_records; /* then all records are processed. */
|
|
|
|
if (t_block == 0) /* user not specified transaction block size */
|
|
t_block = end-begin; /* then we set it to be the full data */
|
|
|
|
for (i = begin; i < end; i++) {
|
|
/* we need to start a new transaction and COPY statement */
|
|
if (((i-begin) % t_block) == 0) {
|
|
if (verbose > 1)
|
|
fprintf(stderr, "Transaction: START\n");
|
|
res = PQexec(conn, "BEGIN");
|
|
if (res == NULL) {
|
|
fprintf(stderr, "Error starting transaction!\n");
|
|
fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
|
|
exit(1);
|
|
}
|
|
sprintf(query, "COPY %s FROM stdin", table);
|
|
res = PQexec(conn, query);
|
|
if (res == NULL) {
|
|
fprintf(stderr, "Error starting COPY!\n");
|
|
fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
/* build line and submit */
|
|
result = dbf_get_record(dbh, fields, i);
|
|
if (result == DBF_VALID) {
|
|
query[0] = '\0';
|
|
for (h = 0; h < dbh->db_nfields; h++) {
|
|
if (!strlen(fields[h].db_name)) {
|
|
continue;
|
|
}
|
|
|
|
if (h!=0) /* not for the first field! */
|
|
strcat(query, "\t"); /* COPY statement field separator */
|
|
|
|
if (upper) {
|
|
strtoupper(fields[h].db_contents);
|
|
}
|
|
if (lower) {
|
|
strtolower(fields[h].db_contents);
|
|
}
|
|
|
|
foo = fields[h].db_contents;
|
|
#ifdef HAVE_ICONV_H
|
|
if(charset_from)
|
|
foo = convert_charset(foo);
|
|
#endif
|
|
foo = Escape(foo);
|
|
|
|
/* handle the date first - liuk */
|
|
if(fields[h].db_type=='D') {
|
|
if((strlen(foo)==8) && isinteger(foo)) {
|
|
sprintf(pgdate,"%c%c%c%c-%c%c-%c%c",
|
|
foo[0],foo[1],foo[2],foo[3],
|
|
foo[4],foo[5],foo[6],foo[7]);
|
|
strcat(query,pgdate);
|
|
} else {
|
|
/* empty field must be inserted as NULL value in this
|
|
way */
|
|
strcat(query,"\\N");
|
|
}
|
|
}
|
|
else if ((fields[h].db_type == 'N') &&
|
|
(fields[h].db_dec == 0)){
|
|
if (isinteger(foo)) {
|
|
strcat(query, foo);
|
|
} else {
|
|
strcat(query, "\\N");
|
|
if (verbose)
|
|
fprintf(stderr, "Illegal numeric value found "
|
|
"in record %d, field \"%s\"\n",
|
|
i, fields[h].db_name);
|
|
}
|
|
} else {
|
|
strcat(query, foo); /* must be character */
|
|
}
|
|
}
|
|
strcat(query, "\n");
|
|
|
|
if ((verbose > 1) && (( i % 100) == 0)) {/* Only show every 100 */
|
|
printf("Inserting record %d\n", i); /* records. */
|
|
}
|
|
PQputline(conn, query);
|
|
|
|
}
|
|
/* we need to end this copy and transaction */
|
|
if (((i-begin) % t_block) == t_block-1) {
|
|
if (verbose > 1)
|
|
fprintf(stderr, "Transaction: END\n");
|
|
PQputline(conn, "\\.\n");
|
|
if (PQendcopy(conn) != 0) {
|
|
fprintf(stderr, "Something went wrong while copying. Check "
|
|
"your tables!\n");
|
|
exit(1);
|
|
}
|
|
res = PQexec(conn, "END");
|
|
if (res == NULL) {
|
|
fprintf(stderr, "Error committing work!\n");
|
|
fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* last row copied in, end copy and transaction */
|
|
/* remember, i is now 1 greater then when we left the loop */
|
|
if (((i-begin) % t_block) != 0) {
|
|
if (verbose > 1)
|
|
fprintf(stderr, "Transaction: END\n");
|
|
PQputline(conn, "\\.\n");
|
|
|
|
if (PQendcopy(conn) != 0) {
|
|
fprintf(stderr, "Something went wrong while copying. Check "
|
|
"your tables!\n");
|
|
}
|
|
res = PQexec(conn, "END");
|
|
if (res == NULL) {
|
|
fprintf(stderr, "Error committing work!\n");
|
|
fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
|
|
exit(1);
|
|
}
|
|
}
|
|
dbf_free_record(dbh, fields);
|
|
|
|
free(query);
|
|
}
|
|
|
|
|
|
/*
|
|
* simple_prompt --- borrowed from psql
|
|
*
|
|
* Generalized function especially intended for reading in usernames and
|
|
* password interactively. Reads from /dev/tty or stdin/stderr.
|
|
*
|
|
* prompt: The prompt to print
|
|
* maxlen: How many characters to accept
|
|
* echo: Set to false if you want to hide what is entered (for passwords)
|
|
*
|
|
* Returns a malloc()'ed string with the input (w/o trailing newline).
|
|
*/
|
|
static bool prompt_state = false;
|
|
|
|
char *
|
|
simple_prompt(const char *prompt, int maxlen, bool echo)
|
|
{
|
|
int length;
|
|
char *destination;
|
|
FILE *termin, *termout;
|
|
#ifdef HAVE_TERMIOS_H
|
|
struct termios t_orig,
|
|
t;
|
|
#endif
|
|
|
|
destination = (char *) malloc(maxlen + 2);
|
|
if (!destination)
|
|
return NULL;
|
|
|
|
prompt_state = true; /* disable SIGINT */
|
|
|
|
/*
|
|
* Do not try to collapse these into one "w+" mode file.
|
|
* Doesn't work on some platforms (eg, HPUX 10.20).
|
|
*/
|
|
termin = fopen("/dev/tty", "r");
|
|
termout = fopen("/dev/tty", "w");
|
|
if (!termin || !termout)
|
|
{
|
|
if (termin)
|
|
fclose(termin);
|
|
if (termout)
|
|
fclose(termout);
|
|
termin = stdin;
|
|
termout = stderr;
|
|
}
|
|
|
|
#ifdef HAVE_TERMIOS_H
|
|
if (!echo)
|
|
{
|
|
tcgetattr(fileno(termin), &t);
|
|
t_orig = t;
|
|
t.c_lflag &= ~ECHO;
|
|
tcsetattr(fileno(termin), TCSAFLUSH, &t);
|
|
}
|
|
#endif
|
|
|
|
if (prompt)
|
|
{
|
|
fputs(gettext(prompt), termout);
|
|
fflush(termout);
|
|
}
|
|
|
|
if (fgets(destination, maxlen, termin) == NULL)
|
|
destination[0] = '\0';
|
|
|
|
length = strlen(destination);
|
|
if (length > 0 && destination[length - 1] != '\n')
|
|
{
|
|
/* eat rest of the line */
|
|
char buf[128];
|
|
int buflen;
|
|
|
|
do
|
|
{
|
|
if (fgets(buf, sizeof(buf), termin) == NULL)
|
|
break;
|
|
buflen = strlen(buf);
|
|
} while (buflen > 0 && buf[buflen - 1] != '\n');
|
|
}
|
|
|
|
if (length > 0 && destination[length - 1] == '\n')
|
|
/* remove trailing newline */
|
|
destination[length - 1] = '\0';
|
|
|
|
#ifdef HAVE_TERMIOS_H
|
|
if (!echo)
|
|
{
|
|
tcsetattr(fileno(termin), TCSAFLUSH, &t_orig);
|
|
fputs("\n", termout);
|
|
fflush(termout);
|
|
}
|
|
#endif
|
|
|
|
if (termin != stdin)
|
|
{
|
|
fclose(termin);
|
|
fclose(termout);
|
|
}
|
|
|
|
prompt_state = false; /* SIGINT okay again */
|
|
|
|
return destination;
|
|
}
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
PGconn *conn;
|
|
int i;
|
|
extern int optind;
|
|
extern char *optarg;
|
|
char *query;
|
|
dbhead *dbh;
|
|
|
|
while ((i = getopt(argc, argv, "DWflucvh:b:e:d:t:s:B:U:F:T:")) != EOF) {
|
|
switch (i) {
|
|
case 'D':
|
|
if (create) {
|
|
usage();
|
|
printf("Can't use -c and -D at the same time!\n");
|
|
exit(1);
|
|
}
|
|
del = 1;
|
|
break;
|
|
case 'W':
|
|
password=simple_prompt("Password: ",100,0);
|
|
break;
|
|
case 'f':
|
|
fieldlow=1;
|
|
break;
|
|
case 'v':
|
|
verbose++;
|
|
break;
|
|
case 'c':
|
|
if (del) {
|
|
usage();
|
|
printf("Can't use -c and -D at the same time!\n");
|
|
exit(1);
|
|
}
|
|
create=1;
|
|
break;
|
|
case 'l':
|
|
lower=1;
|
|
break;
|
|
case 'u':
|
|
if (lower) {
|
|
usage();
|
|
printf("Can't use -u and -l at the same time!\n");
|
|
exit(1);
|
|
}
|
|
upper=1;
|
|
break;
|
|
case 'b':
|
|
begin = atoi(optarg);
|
|
break;
|
|
case 'e':
|
|
end = atoi(optarg);
|
|
break;
|
|
case 'h':
|
|
host = (char *)strdup(optarg);
|
|
break;
|
|
case 'd':
|
|
dbase = (char *)strdup(optarg);
|
|
break;
|
|
case 't':
|
|
table = (char *)strdup(optarg);
|
|
break;
|
|
case 's':
|
|
subarg = (char *)strdup(optarg);
|
|
break;
|
|
case 'B':
|
|
t_block = atoi(optarg);
|
|
break;
|
|
case 'U':
|
|
username = (char *)strdup(optarg);
|
|
break;
|
|
case 'F':
|
|
charset_from = (char *)strdup(optarg);
|
|
break;
|
|
case 'T':
|
|
charset_to = (char *)strdup(optarg);
|
|
break;
|
|
case ':':
|
|
usage();
|
|
printf("missing argument!\n");
|
|
exit(1);
|
|
break;
|
|
case '?':
|
|
usage();
|
|
/* FIXME: Ivan thinks this is bad: printf("unknown argument: %s\n", argv[0]); */
|
|
exit(1);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
argc -= optind;
|
|
argv = &argv[optind];
|
|
|
|
if (argc != 1) {
|
|
usage();
|
|
if(username)
|
|
free(username);
|
|
if(password)
|
|
free(password);
|
|
exit(1);
|
|
}
|
|
|
|
#ifdef HAVE_ICONV_H
|
|
if(charset_from)
|
|
{
|
|
if(verbose>1)
|
|
printf("Setting conversion from charset \"%s\" to \"%s\".\n",
|
|
charset_from,charset_to);
|
|
iconv_d = iconv_open(charset_to,charset_from);
|
|
if(iconv_d == (iconv_t) -1)
|
|
{
|
|
printf("Cannot convert from charset \"%s\" to charset \"%s\".\n",
|
|
charset_from,charset_to);
|
|
exit(1);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (verbose > 1) {
|
|
printf("Opening dbf-file\n");
|
|
}
|
|
|
|
if ((dbh = dbf_open(argv[0], O_RDONLY)) == (dbhead *)-1) {
|
|
fprintf(stderr, "Couldn't open xbase-file %s\n", argv[0]);
|
|
if(username)
|
|
free(username);
|
|
if(password)
|
|
free(password);
|
|
if(charset_from)
|
|
iconv_close(iconv_d);
|
|
exit(1);
|
|
}
|
|
|
|
if (fieldlow)
|
|
for ( i = 0 ; i < dbh->db_nfields ; i++ )
|
|
strtolower(dbh->db_fields[i].db_name);
|
|
|
|
if (verbose) {
|
|
printf("dbf-file: %s, PG-dbase: %s, PG-table: %s\n", argv[0],
|
|
dbase,
|
|
table);
|
|
printf("Number of records: %ld\n", dbh->db_records);
|
|
printf("NAME:\t\tLENGTH:\t\tTYPE:\n");
|
|
printf("-------------------------------------\n");
|
|
for (i = 0; i < dbh->db_nfields ; i++) {
|
|
printf("%-12s\t%7d\t\t%5c\n",dbh->db_fields[i].db_name,
|
|
dbh->db_fields[i].db_flen,
|
|
dbh->db_fields[i].db_type);
|
|
}
|
|
}
|
|
|
|
if (verbose > 1) {
|
|
printf("Making connection to PG-server\n");
|
|
}
|
|
|
|
conn = PQsetdbLogin(host,NULL,NULL,NULL, dbase, username, password);
|
|
if (PQstatus(conn) != CONNECTION_OK) {
|
|
fprintf(stderr, "Couldn't get a connection with the ");
|
|
fprintf(stderr, "designated host!\n");
|
|
fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
|
|
close(dbh->db_fd);
|
|
free(dbh);
|
|
if(username)
|
|
free(username);
|
|
if(password)
|
|
free(password);
|
|
if(charset_from)
|
|
iconv_close(iconv_d);
|
|
exit(1);
|
|
}
|
|
|
|
/* Substitute field names */
|
|
do_substitute(subarg, dbh);
|
|
|
|
/* create table if specified, else check if target table exists */
|
|
if (!create) {
|
|
if (!check_table(conn, table)) {
|
|
printf("Table does not exist!\n");
|
|
if(username)
|
|
free(username);
|
|
if(password)
|
|
free(password);
|
|
if(charset_from)
|
|
iconv_close(iconv_d);
|
|
exit(1);
|
|
}
|
|
if (del) {
|
|
if (!(query = (char *)malloc(13 + strlen(table)))) {
|
|
printf("Memory-allocation error in main (delete)!\n");
|
|
close(dbh->db_fd);
|
|
free(dbh);
|
|
PQfinish(conn);
|
|
if(username)
|
|
free(username);
|
|
if(password)
|
|
free(password);
|
|
if(charset_from)
|
|
iconv_close(iconv_d);
|
|
exit(1);
|
|
}
|
|
if (verbose > 1) {
|
|
printf("Deleting from original table\n");
|
|
}
|
|
sprintf(query, "DELETE FROM %s", table);
|
|
PQexec(conn, query);
|
|
free(query);
|
|
}
|
|
} else {
|
|
if (!(query = (char *)malloc(12 + strlen(table)))) {
|
|
printf("Memory-allocation error in main (drop)!\n");
|
|
close(dbh->db_fd);
|
|
free(dbh);
|
|
PQfinish(conn);
|
|
if(username)
|
|
free(username);
|
|
if(password)
|
|
free(password);
|
|
if(charset_from)
|
|
iconv_close(iconv_d);
|
|
exit(1);
|
|
}
|
|
if (verbose > 1) {
|
|
printf("Dropping original table (if one exists)\n");
|
|
}
|
|
sprintf(query, "DROP TABLE %s", table);
|
|
PQexec(conn, query);
|
|
free(query);
|
|
|
|
/* Build a CREATE-clause
|
|
*/
|
|
do_create(conn, table, dbh);
|
|
}
|
|
|
|
/* Build an INSERT-clause
|
|
*/
|
|
PQexec(conn, "SET DATESTYLE TO 'ISO';");
|
|
do_inserts(conn, table, dbh);
|
|
|
|
if (verbose > 1) {
|
|
printf("Closing up....\n");
|
|
}
|
|
|
|
close(dbh->db_fd);
|
|
free(dbh);
|
|
PQfinish(conn);
|
|
if(username)
|
|
free(username);
|
|
if(password)
|
|
free(password);
|
|
if(charset_from)
|
|
iconv_close(iconv_d);
|
|
exit(0);
|
|
}
|