static int csv_write_record(TABDCA *dca, struct csv *csv)
{ /* write next record to csv data file */
int k, nf, ret = 0;
const char *c;
xassert(csv->mode == 'W');
nf = mpl_tab_num_flds(dca);
for (k = 1; k <= nf; k++)
{ switch (mpl_tab_get_type(dca, k))
{ case 'N':
fprintf(csv->fp, "%.*g", DBL_DIG,
mpl_tab_get_num(dca, k));
break;
case 'S':
fputc('"', csv->fp);
for (c = mpl_tab_get_str(dca, k); *c != '\0'; c++)
{ if (*c == '"')
fputc('"', csv->fp), fputc('"', csv->fp);
else
fputc(*c, csv->fp);
}
fputc('"', csv->fp);
break;
default:
xassert(dca != dca);
}
fputc(k < nf ? ',' : '\n', csv->fp);
}
csv->count++;
if (ferror(csv->fp))
{ xprintf("%s:%d: write error - %s\n", csv->fname, csv->count,
strerror(errno));
ret = 1;
}
return ret;
}
static char *db_generate_select_stmt(TABDCA *dca)
/* generate select statement */
{
char *arg;
char const *field;
char *query;
int j;
int narg;
int nf;
int total;
total = 50;
nf = mpl_tab_num_flds(dca);
narg = mpl_tab_num_args(dca);
for (j=1; j <= nf && j <= SQL_FIELD_MAX; j++)
{
field = mpl_tab_get_name(dca, j);
total += strlen(field);
total += 2;
}
arg = (char *) mpl_tab_get_arg(dca, narg);
total += strlen(arg);
query = xmalloc( total * sizeof(char));
strcpy (query, "SELECT ");
for (j=1; j <= nf && j <= SQL_FIELD_MAX; j++)
{
field = mpl_tab_get_name(dca, j);
strcat(query, field);
if ( j < nf )
strcat(query, ", ");
}
strcat(query, " FROM ");
strcat(query, arg);
return query;
}
static int dbf_write_record(TABDCA *dca, struct dbf *dbf)
{ /* write next record to xBASE data file */
int j, k, ret = 0;
char buf[255+1];
xassert(dbf->mode == 'W');
if (setjmp(dbf->jump))
{ ret = 1;
goto done;
}
/* record flag */
write_byte(dbf, 0x20);
xassert(dbf->nf == mpl_tab_num_flds(dca));
for (k = 1; k <= dbf->nf; k++)
{ if (dbf->type[k] == 'C')
{ /* character field */
const char *str;
if (mpl_tab_get_type(dca, k) == 'N')
{ sprintf(buf, "%.*g", DBL_DIG, mpl_tab_get_num(dca, k));
str = buf;
}
else if (mpl_tab_get_type(dca, k) == 'S')
str = mpl_tab_get_str(dca, k);
else
xassert(dca != dca);
if ((int)strlen(str) > dbf->len[k])
{ xprintf("xBASE driver: field %s: cannot convert %.15s..."
" to field format\n", mpl_tab_get_name(dca, k), str);
longjmp(dbf->jump, 0);
}
for (j = 0; j < dbf->len[k] && str[j] != '\0'; j++)
write_byte(dbf, str[j]);
for (j = j; j < dbf->len[k]; j++)
write_byte(dbf, ' ');
}
else if (dbf->type[k] == 'N')
{ /* numeric field */
double num = mpl_tab_get_num(dca, k);
if (fabs(num) > 1e20)
err: { xprintf("xBASE driver: field %s: cannot convert %g to fi"
"eld format\n", mpl_tab_get_name(dca, k), num);
longjmp(dbf->jump, 0);
}
sprintf(buf, "%*.*f", dbf->len[k], dbf->prec[k], num);
xassert(strlen(buf) < sizeof(buf));
if ((int)strlen(buf) != dbf->len[k]) goto err;
for (j = 0; j < dbf->len[k]; j++)
write_byte(dbf, buf[j]);
}
else
xassert(dbf != dbf);
}
/* increase record count */
dbf->count++;
done: return ret;
}
static char *db_generate_insert_stmt(TABDCA *dca)
/* generate insert statement */
{
char *arg;
char const *field;
char *query;
int j;
int narg;
int nf;
int total;
total = 50;
nf = mpl_tab_num_flds(dca);
narg = mpl_tab_num_args(dca);
for (j=1; j <= nf && j <= SQL_FIELD_MAX; j++)
{
field = mpl_tab_get_name(dca, j);
total += strlen(field);
total += 5;
}
arg = (char *) mpl_tab_get_arg(dca, narg);
total += strlen(arg);
query = xmalloc( (total+1) * sizeof(char));
strcpy (query, "INSERT INTO ");
strcat(query, arg);
strcat(query, " ( ");
for (j=1; j <= nf && j <= SQL_FIELD_MAX; j++)
{
field = mpl_tab_get_name(dca, j);
strcat(query, field);
if ( j < nf )
strcat(query, ", ");
}
strcat(query, " ) VALUES ( ");
for (j=1; j <= nf && j <= SQL_FIELD_MAX; j++)
{
strcat(query, "?");
if ( j < nf )
strcat(query, ", ");
}
strcat(query, " )");
return query;
}
static void parse_third_arg(TABDCA *dca, struct dbf *dbf)
{ /* parse xBASE file format (third argument) */
int j, k, temp;
const char *arg;
dbf->nf = mpl_tab_num_flds(dca);
arg = mpl_tab_get_arg(dca, 3), j = 0;
for (k = 1; k <= dbf->nf; k++)
{ /* parse specification of k-th field */
if (arg[j] == '\0')
{ xprintf("xBASE driver: field %s: specification missing\n",
mpl_tab_get_name(dca, k));
longjmp(dbf->jump, 0);
}
/* parse field type */
if (arg[j] == 'C' || arg[j] == 'N')
dbf->type[k] = arg[j], j++;
else
{ xprintf("xBASE driver: field %s: invalid field type\n",
mpl_tab_get_name(dca, k));
longjmp(dbf->jump, 0);
}
/* check for left parenthesis */
if (arg[j] == '(')
j++;
else
err: { xprintf("xBASE driver: field %s: invalid field format\n",
mpl_tab_get_name(dca, k));
longjmp(dbf->jump, 0);
}
/* parse field length */
temp = 0;
while (isdigit(arg[j]))
{ if (temp > DBF_FDLEN_MAX) break;
temp = 10 * temp + (arg[j] - '0'), j++;
}
if (!(1 <= temp && temp <= DBF_FDLEN_MAX))
{ xprintf("xBASE driver: field %s: invalid field length\n",
mpl_tab_get_name(dca, k));
longjmp(dbf->jump, 0);
}
dbf->len[k] = temp;
/* parse optional field precision */
if (dbf->type[k] == 'N' && arg[j] == ',')
{ j++;
temp = 0;
while (isdigit(arg[j]))
{ if (temp > dbf->len[k]) break;
temp = 10 * temp + (arg[j] - '0'), j++;
}
if (temp > dbf->len[k])
{ xprintf("xBASE driver: field %s: invalid field precision"
"\n", mpl_tab_get_name(dca, k));
longjmp(dbf->jump, 0);
}
dbf->prec[k] = temp;
}
else
dbf->prec[k] = 0;
/* check for right parenthesis */
if (arg[j] == ')')
j++;
else
goto err;
}
/* ignore other specifications */
return;
}
static void read_header(TABDCA *dca, struct dbf *dbf)
{ /* read xBASE data file header */
int b, j, k, recl;
char name[10+1];
/* (ignored) */
for (j = 1; j <= 10; j++)
read_byte(dbf);
/* length of each record, in bytes */
recl = read_byte(dbf);
recl += read_byte(dbf) << 8;
/* (ignored) */
for (j = 1; j <= 20; j++)
read_byte(dbf);
/* field descriptor array */
xassert(dbf->nf == 0);
for (;;)
{ /* check for end of array */
b = read_byte(dbf);
if (b == 0x0D) break;
if (dbf->nf == DBF_FIELD_MAX)
{ xprintf("%s:0x%X: too many fields\n", dbf->fname,
dbf->offset);
longjmp(dbf->jump, 0);
}
dbf->nf++;
/* field name */
name[0] = (char)b;
for (j = 1; j < 10; j++)
{ b = read_byte(dbf);
name[j] = (char)b;
}
name[10] = '\0';
b = read_byte(dbf);
if (b != 0x00)
{ xprintf("%s:0x%X: invalid field name\n", dbf->fname,
dbf->offset);
longjmp(dbf->jump, 0);
}
/* find corresponding field in the table statement */
for (k = mpl_tab_num_flds(dca); k >= 1; k--)
if (strcmp(mpl_tab_get_name(dca, k), name) == 0) break;
dbf->ref[dbf->nf] = k;
/* field type */
b = read_byte(dbf);
if (!(b == 'C' || b == 'N'))
{ xprintf("%s:0x%X: invalid field type\n", dbf->fname,
dbf->offset);
longjmp(dbf->jump, 0);
}
dbf->type[dbf->nf] = b;
/* (ignored) */
for (j = 1; j <= 4; j++)
read_byte(dbf);
/* field length */
b = read_byte(dbf);
if (b == 0)
{ xprintf("%s:0x%X: invalid field length\n", dbf->fname,
dbf->offset);
longjmp(dbf->jump, 0);
}
if (b > DBF_FDLEN_MAX)
{ xprintf("%s:0x%X: field too long\n", dbf->fname,
dbf->offset);
longjmp(dbf->jump, 0);
}
dbf->len[dbf->nf] = b;
recl -= b;
/* (ignored) */
for (j = 1; j <= 15; j++)
read_byte(dbf);
}
if (recl != 1)
{ xprintf("%s:0x%X: invalid file header\n", dbf->fname,
dbf->offset);
longjmp(dbf->jump, 0);
}
/* find dummy RECNO field in the table statement */
for (k = mpl_tab_num_flds(dca); k >= 1; k--)
if (strcmp(mpl_tab_get_name(dca, k), "RECNO") == 0) break;
dbf->ref[0] = k;
return;
}
static struct csv *csv_open_file(TABDCA *dca, int mode)
{ /* open csv data file */
struct csv *csv;
/* create control structure */
csv = xmalloc(sizeof(struct csv));
csv->mode = mode;
csv->fname = NULL;
csv->fp = NULL;
if (setjmp(csv->jump)) goto fail;
csv->count = 0;
csv->c = '\n';
csv->what = 0;
csv->field[0] = '\0';
csv->nf = 0;
/* try to open the csv data file */
if (mpl_tab_num_args(dca) < 2)
{ xprintf("csv_driver: file name not specified\n");
longjmp(csv->jump, 0);
}
csv->fname = xmalloc(strlen(mpl_tab_get_arg(dca, 2))+1);
strcpy(csv->fname, mpl_tab_get_arg(dca, 2));
if (mode == 'R')
{ /* open the file for reading */
int k;
csv->fp = fopen(csv->fname, "r");
if (csv->fp == NULL)
{ xprintf("csv_driver: unable to open %s - %s\n",
csv->fname, strerror(errno));
longjmp(csv->jump, 0);
}
#if 1 /* 01/VI-2010 */
csv->nskip = 0;
#endif
/* skip fake new-line */
read_field(csv);
xassert(csv->what == CSV_EOR);
/* read field names */
xassert(csv->nf == 0);
for (;;)
{ read_field(csv);
if (csv->what == CSV_EOR)
break;
if (csv->what != CSV_STR)
{ xprintf("%s:%d: invalid field name\n", csv->fname,
csv->count);
longjmp(csv->jump, 0);
}
if (csv->nf == CSV_FIELD_MAX)
{ xprintf("%s:%d: too many fields\n", csv->fname,
csv->count);
longjmp(csv->jump, 0);
}
csv->nf++;
/* find corresponding field in the table statement */
for (k = mpl_tab_num_flds(dca); k >= 1; k--)
{ if (strcmp(mpl_tab_get_name(dca, k), csv->field) == 0)
break;
}
csv->ref[csv->nf] = k;
}
/* find dummy RECNO field in the table statement */
for (k = mpl_tab_num_flds(dca); k >= 1; k--)
if (strcmp(mpl_tab_get_name(dca, k), "RECNO") == 0) break;
csv->ref[0] = k;
}
else if (mode == 'W')
{ /* open the file for writing */
int k, nf;
csv->fp = fopen(csv->fname, "w");
if (csv->fp == NULL)
{ xprintf("csv_driver: unable to create %s - %s\n",
csv->fname, strerror(errno));
longjmp(csv->jump, 0);
}
/* write field names */
nf = mpl_tab_num_flds(dca);
for (k = 1; k <= nf; k++)
fprintf(csv->fp, "%s%c", mpl_tab_get_name(dca, k),
k < nf ? ',' : '\n');
csv->count++;
}
else
xassert(mode != mode);
/* the file has been open */
return csv;
fail: /* the file cannot be open */
if (csv->fname != NULL) xfree(csv->fname);
if (csv->fp != NULL) fclose(csv->fp);
xfree(csv);
return NULL;
}
static void *db_iodbc_open_int(TABDCA *dca, int mode, const char
**sqllines)
{
struct db_odbc *sql;
SQLRETURN ret;
SQLCHAR FAR *dsn;
SQLCHAR info[256];
SQLSMALLINT colnamelen;
SQLSMALLINT nullable;
SQLSMALLINT scale;
const char *arg;
int narg;
int i, j;
int total;
if (libodbc == NULL)
{
xprintf("No loader for shared ODBC library available\n");
return NULL;
}
if (h_odbc == NULL)
{
h_odbc = xdlopen(libodbc);
if (h_odbc == NULL)
{ xprintf("unable to open library %s\n", libodbc);
xprintf("%s\n", xerrmsg());
return NULL;
}
}
sql = (struct db_odbc *) xmalloc(sizeof(struct db_odbc));
if (sql == NULL)
return NULL;
sql->mode = mode;
sql->hdbc = NULL;
sql->henv = NULL;
sql->hstmt = NULL;
sql->query = NULL;
narg = mpl_tab_num_args(dca);
dsn = (SQLCHAR FAR *) mpl_tab_get_arg(dca, 2);
/* allocate an environment handle */
ret = dl_SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,
&(sql->henv));
/* set attribute to enable application to run as ODBC 3.0
application */
ret = dl_SQLSetEnvAttr(sql->henv, SQL_ATTR_ODBC_VERSION,
(void *) SQL_OV_ODBC3, 0);
/* allocate a connection handle */
ret = dl_SQLAllocHandle(SQL_HANDLE_DBC, sql->henv, &(sql->hdbc));
/* connect */
ret = dl_SQLDriverConnect(sql->hdbc, NULL, dsn, SQL_NTS, NULL, 0,
NULL, SQL_DRIVER_COMPLETE);
if (SQL_SUCCEEDED(ret))
{ /* output information about data base connection */
xprintf("Connected to ");
dl_SQLGetInfo(sql->hdbc, SQL_DBMS_NAME, (SQLPOINTER)info,
sizeof(info), NULL);
xprintf("%s ", info);
dl_SQLGetInfo(sql->hdbc, SQL_DBMS_VER, (SQLPOINTER)info,
sizeof(info), NULL);
xprintf("%s - ", info);
dl_SQLGetInfo(sql->hdbc, SQL_DATABASE_NAME, (SQLPOINTER)info,
sizeof(info), NULL);
xprintf("%s\n", info);
}
else
{ /* describe error */
xprintf("Failed to connect\n");
extract_error("SQLDriverConnect", sql->hdbc, SQL_HANDLE_DBC);
dl_SQLFreeHandle(SQL_HANDLE_DBC, sql->hdbc);
dl_SQLFreeHandle(SQL_HANDLE_ENV, sql->henv);
xfree(sql);
return NULL;
}
/* set AUTOCOMMIT on*/
ret = dl_SQLSetConnectAttr(sql->hdbc, SQL_ATTR_AUTOCOMMIT,
(SQLPOINTER)SQL_AUTOCOMMIT_ON, 0);
/* allocate a statement handle */
ret = dl_SQLAllocHandle(SQL_HANDLE_STMT, sql->hdbc, &(sql->hstmt));
/* initialization queries */
for(j = 0; sqllines[j+1] != NULL; j++)
{
sql->query = (SQLCHAR *) sqllines[j];
xprintf("%s\n", sql->query);
ret = dl_SQLExecDirect(sql->hstmt, sql->query, SQL_NTS);
switch (ret)
{
case SQL_SUCCESS:
case SQL_SUCCESS_WITH_INFO:
case SQL_NO_DATA_FOUND:
break;
default:
xprintf("db_iodbc_open: Query\n\"%s\"\nfailed.\n",
sql->query);
extract_error("SQLExecDirect", sql->hstmt, SQL_HANDLE_STMT);
dl_SQLFreeHandle(SQL_HANDLE_STMT, sql->hstmt);
dl_SQLDisconnect(sql->hdbc);
dl_SQLFreeHandle(SQL_HANDLE_DBC, sql->hdbc);
dl_SQLFreeHandle(SQL_HANDLE_ENV, sql->henv);
xfree(sql);
return NULL;
}
/* commit statement */
dl_SQLEndTran(SQL_HANDLE_ENV, sql->henv, SQL_COMMIT);
}
if ( sql->mode == 'R' )
{ sql->nf = mpl_tab_num_flds(dca);
for(j = 0; sqllines[j] != NULL; j++)
arg = sqllines[j];
total = strlen(arg);
if (total > 7 && 0 == strncmp(arg, "SELECT ", 7))
{
total = strlen(arg);
sql->query = xmalloc( (total+1) * sizeof(char));
strcpy (sql->query, arg);
}
else
{
sql->query = db_generate_select_stmt(dca);
}
xprintf("%s\n", sql->query);
if (dl_SQLExecDirect(sql->hstmt, sql->query, SQL_NTS) !=
SQL_SUCCESS)
{
xprintf("db_iodbc_open: Query\n\"%s\"\nfailed.\n", sql->query);
extract_error("SQLExecDirect", sql->hstmt, SQL_HANDLE_STMT);
dl_SQLFreeHandle(SQL_HANDLE_STMT, sql->hstmt);
dl_SQLDisconnect(sql->hdbc);
dl_SQLFreeHandle(SQL_HANDLE_DBC, sql->hdbc);
dl_SQLFreeHandle(SQL_HANDLE_ENV, sql->henv);
xfree(sql->query);
xfree(sql);
return NULL;
}
xfree(sql->query);
/* determine number of result columns */
ret = dl_SQLNumResultCols(sql->hstmt, &sql->nresultcols);
total = sql->nresultcols;
if (total > SQL_FIELD_MAX)
{ xprintf("db_iodbc_open: Too many fields (> %d) in query.\n"
"\"%s\"\n", SQL_FIELD_MAX, sql->query);
dl_SQLFreeHandle(SQL_HANDLE_STMT, sql->hstmt);
dl_SQLDisconnect(sql->hdbc);
dl_SQLFreeHandle(SQL_HANDLE_DBC, sql->hdbc);
dl_SQLFreeHandle(SQL_HANDLE_ENV, sql->henv);
xfree(sql->query);
return NULL;
}
for (i = 1; i <= total; i++)
{ /* return a set of attributes for a column */
ret = dl_SQLDescribeCol(sql->hstmt, (SQLSMALLINT) i,
sql->colname[i], SQL_FDLEN_MAX,
&colnamelen, &(sql->coltype[i]), &(sql->collen[i]), &scale,
&nullable);
sql->isnumeric[i] = is_numeric(sql->coltype[i]);
/* bind columns to program vars, converting all types to CHAR*/
if (sql->isnumeric[i])
{ dl_SQLBindCol(sql->hstmt, i, SQL_DOUBLE, sql->data[i],
SQL_FDLEN_MAX, &(sql->outlen[i]));
} else
{ dl_SQLBindCol(sql->hstmt, i, SQL_CHAR, sql->data[i],
SQL_FDLEN_MAX, &(sql->outlen[i]));
}
for (j = sql->nf; j >= 1; j--)
{ if (strcmp(mpl_tab_get_name(dca, j), sql->colname[i]) == 0)
break;
}
sql->ref[i] = j;
}
}
else if ( sql->mode == 'W' )
{ for(j = 0; sqllines[j] != NULL; j++)
arg = sqllines[j];
if ( NULL != strchr(arg, '?') )
{
total = strlen(arg);
sql->query = xmalloc( (total+1) * sizeof(char));
strcpy (sql->query, arg);
}
else
{
sql->query = db_generate_insert_stmt(dca);
}
xprintf("%s\n", sql->query);
}
return sql;
}
char *query;
char *template;
char num[50];
int k;
int len;
int nf;
sql = (struct db_odbc *) link;
xassert(sql != NULL);
xassert(sql->mode == 'W');
len = strlen(sql->query);
template = (char *) xmalloc( (len + 1) * sizeof(char) );
strcpy(template, sql->query);
nf = mpl_tab_num_flds(dca);
for (k = 1; k <= nf; k++)
{ switch (mpl_tab_get_type(dca, k))
{ case 'N':
len += 20;
break;
case 'S':
len += db_escaped_string_length(mpl_tab_get_str(dca, k));
len += 2;
break;
default:
xassert(dca != dca);
}
}
query = xmalloc( (len + 1 ) * sizeof(char) );
query[0] = 0x00;
