static struct dbf *dbf_open_file(TABDCA *dca, int mode)
{ /* open xBASE data file */
struct dbf *dbf;
/* create control structure */
dbf = xmalloc(sizeof(struct dbf));
dbf->mode = mode;
dbf->fname = NULL;
dbf->fp = NULL;
if (setjmp(dbf->jump)) goto fail;
dbf->offset = 0;
dbf->count = 0;
dbf->nf = 0;
/* try to open the xBASE data file */
if (mpl_tab_num_args(dca) < 2)
{ xprintf("xBASE driver: file name not specified\n");
longjmp(dbf->jump, 0);
}
dbf->fname = xmalloc(strlen(mpl_tab_get_arg(dca, 2))+1);
strcpy(dbf->fname, mpl_tab_get_arg(dca, 2));
if (mode == 'R')
{ /* open the file for reading */
dbf->fp = fopen(dbf->fname, "rb");
if (dbf->fp == NULL)
{ xprintf("xBASE driver: unable to open %s - %s\n",
dbf->fname, strerror(errno));
longjmp(dbf->jump, 0);
}
read_header(dca, dbf);
}
else if (mode == 'W')
{ /* open the file for writing */
if (mpl_tab_num_args(dca) < 3)
{ xprintf("xBASE driver: file format not specified\n");
longjmp(dbf->jump, 0);
}
parse_third_arg(dca, dbf);
dbf->fp = fopen(dbf->fname, "wb");
if (dbf->fp == NULL)
{ xprintf("xBASE driver: unable to create %s - %s\n",
dbf->fname, strerror(errno));
longjmp(dbf->jump, 0);
}
write_header(dca, dbf);
}
else
xassert(mode != mode);
/* the file has been open */
return dbf;
fail: /* the file cannot be open */
if (dbf->fname != NULL) xfree(dbf->fname);
if (dbf->fp != NULL) fclose(dbf->fp);
xfree(dbf);
return NULL;
}
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 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 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;
}