/*ARGSUSED*/
static
/*
* patch_string(DBPROCESSdb,charstr,intsize)
*/
int patch_string( DBPROCESS *db, char *str, int size )
{
DBBINARY patches[PATCH_BUFFER_SIZE];
DBINT patch_length = 0, item = 0;
DBCHAR buffer[TEXT_BUFFER_SIZE];
int rv;
char *ptr;
/* Get the title patches from the input string */
if( ! DBROWS( db ) ) return( False );
rv = load_patch( db, patches, sizeof(patches), &item, &patch_length, True );
if( rv != True ) return( rv );
/* We have the patches, apply them */
if( ApplyIsoPatches( str, size, buffer, sizeof(buffer),
patches, patch_length ) > 0 )
{
return( Error );
}
/* Done - put the stuff back */
strcpy( str, buffer );
return( True );
}
static VALUE rb_tinytds_result_insert(VALUE self) {
GET_RESULT_WRAPPER(self);
if (rwrap->client) {
VALUE identity = Qnil;
rb_tinytds_result_exec_helper(rwrap->client);
dbcmd(rwrap->client, rwrap->cwrap->identity_insert_sql);
if (nogvl_dbsqlexec(rwrap->client) != FAIL
&& nogvl_dbresults(rwrap->client) != FAIL
&& DBROWS(rwrap->client) != FAIL) {
while (nogvl_dbnextrow(rwrap->client) != NO_MORE_ROWS) {
int col = 1;
BYTE *data = dbdata(rwrap->client, col);
DBINT data_len = dbdatlen(rwrap->client, col);
int null_val = ((data == NULL) && (data_len == 0));
if (!null_val)
identity = LL2NUM(*(DBBIGINT *)data);
}
}
return identity;
} else {
return Qnil;
}
}
int
main(int argc, char **argv)
{
char cmd[1024];
LOGINREC *login;
DBPROCESS *dbproc;
int i;
char teststr[1024];
int erc, failed = 0;
char *retname = NULL;
int rettype = 0, retlen = 0;
set_malloc_options();
read_login_info(argc, argv);
fprintf(stdout, "Start\n");
add_bread_crumb();
dbinit();
add_bread_crumb();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
add_bread_crumb();
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0022");
fprintf(stdout, "About to open\n");
add_bread_crumb();
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
add_bread_crumb();
dbloginfree(login);
add_bread_crumb();
fprintf(stdout, "Dropping proc\n");
add_bread_crumb();
dbcmd(dbproc, "if object_id('t0022') is not null drop proc t0022");
add_bread_crumb();
dbsqlexec(dbproc);
add_bread_crumb();
while ((erc = dbresults(dbproc)) == SUCCEED) {
fprintf(stdout, "dbresult succeeded dropping procedure\n");
while ((erc = dbnextrow(dbproc)) == SUCCEED) {
fprintf(stdout, "dbnextrow returned spurious rows dropping procedure\n");
assert(0); /* dropping a procedure returns no rows */
}
assert(erc == NO_MORE_ROWS);
}
assert(erc == NO_MORE_RESULTS);
add_bread_crumb();
fprintf(stdout, "creating proc\n");
dbcmd(dbproc, "create proc t0022 (@b int out) as\nbegin\n select @b = 42\n return 66\nend\n");
if (dbsqlexec(dbproc) == FAIL) {
add_bread_crumb();
fprintf(stdout, "Failed to create proc t0022.\n");
exit(1);
}
while ((erc = dbresults(dbproc)) != NO_MORE_RESULTS) {
assert(erc != FAIL);
while ((erc = dbnextrow(dbproc)) == SUCCEED) {
assert(0); /* creating a procedure returns no rows */
}
assert(erc == NO_MORE_ROWS);
}
sprintf(cmd, "declare @b int\nexec t0022 @b = @b output\n");
fprintf(stdout, "%s\n", cmd);
dbcmd(dbproc, cmd);
dbsqlexec(dbproc);
add_bread_crumb();
while ((erc = dbresults(dbproc)) != NO_MORE_RESULTS) {
if (erc == FAIL) {
add_bread_crumb();
fprintf(stdout, "Was expecting a result set.\n");
exit(1);
}
while ((erc = dbnextrow(dbproc)) == SUCCEED) {
assert(0); /* procedure returns no rows */
}
assert(erc == NO_MORE_ROWS);
}
add_bread_crumb();
#if defined(DBTDS_7_0) && defined(DBTDS_8_0) && defined(DBTDS_9_0)
if ((dbnumrets(dbproc) == 0)
&& ((DBTDS(dbproc) == DBTDS_7_0)
|| (DBTDS(dbproc) == DBTDS_8_0)
|| (DBTDS(dbproc) == DBTDS_9_0))) {
fprintf(stdout, "WARNING: Received no return parameters from server!\n");
fprintf(stdout, "WARNING: This is likely due to a bug in Microsoft\n");
fprintf(stdout, "WARNING: SQL Server 7.0 SP3 and later.\n");
fprintf(stdout, "WARNING: Please try again using TDS protocol 4.2.\n");
dbcmd(dbproc, "drop proc t0022");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
dbexit();
free_bread_crumb();
exit(0);
}
#endif
for (i = 1; i <= dbnumrets(dbproc); i++) {
add_bread_crumb();
retname = dbretname(dbproc, i);
printf("ret name %d is %s\n", i, retname);
rettype = dbrettype(dbproc, i);
printf("ret type %d is %d\n", i, rettype);
retlen = dbretlen(dbproc, i);
printf("ret len %d is %d\n", i, retlen);
dbconvert(dbproc, rettype, dbretdata(dbproc, i), retlen, SYBVARCHAR, (BYTE*) teststr, -1);
printf("ret data %d is %s\n", i, teststr);
add_bread_crumb();
}
if ((retname == NULL) || strcmp(retname, "@b")) {
fprintf(stdout, "Was expecting a retname to be @b.\n");
exit(1);
}
if (strcmp(teststr, "42")) {
fprintf(stdout, "Was expecting a retdata to be 42.\n");
exit(1);
}
if (rettype != SYBINT4) {
fprintf(stdout, "Was expecting a rettype to be SYBINT4 was %d.\n", rettype);
exit(1);
}
if (retlen != 4) {
fprintf(stdout, "Was expecting a retlen to be 4.\n");
exit(1);
}
fprintf(stdout, "Dropping proc\n");
add_bread_crumb();
dbcmd(dbproc, "drop proc t0022");
add_bread_crumb();
dbsqlexec(dbproc);
add_bread_crumb();
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
/*
* Chapter 2: test for resultsets containing only a return status
*/
fprintf(stdout, "Dropping proc t0022a\n");
dbcmd(dbproc, "if object_id('t0022a') is not null drop proc t0022a");
dbsqlexec(dbproc);
while ((erc = dbresults(dbproc)) == SUCCEED) {
fprintf(stdout, "dbresult succeeded dropping procedure\n");
while ((erc = dbnextrow(dbproc)) == SUCCEED) {
fprintf(stdout, "dbnextrow returned spurious rows dropping procedure\n");
assert(0); /* dropping a procedure returns no rows */
}
assert(erc == NO_MORE_ROWS);
}
assert(erc == NO_MORE_RESULTS);
fprintf(stdout, "creating proc t0022a\n");
dbcmd(dbproc, "create proc t0022a (@b int) as\nreturn @b\n");
if (dbsqlexec(dbproc) == FAIL) {
fprintf(stdout, "Failed to create proc t0022a.\n");
exit(1);
}
while ((erc = dbresults(dbproc)) != NO_MORE_RESULTS) {
assert(erc != FAIL);
while ((erc = dbnextrow(dbproc)) == SUCCEED) {
assert(0); /* creating a procedure returns no rows */
}
assert(erc == NO_MORE_ROWS);
}
sprintf(cmd, "exec t0022a 17 exec t0022a 1024\n");
fprintf(stdout, "%s\n", cmd);
dbcmd(dbproc, cmd);
dbsqlexec(dbproc);
for (i=1; (erc = dbresults(dbproc)) != NO_MORE_RESULTS; i++) {
enum {expected_iterations = 2};
DBBOOL fret;
DBINT status;
if (erc == FAIL) {
fprintf(stdout, "t0022a failed for some reason.\n");
exit(1);
}
printf("procedure returned %srows\n", DBROWS(dbproc)==SUCCEED? "" : "no ");
while ((erc = dbnextrow(dbproc)) == SUCCEED) {
assert(0); /* procedure returns no rows */
}
assert(erc == NO_MORE_ROWS);
fret = dbhasretstat(dbproc);
printf("procedure has %sreturn status\n", fret==TRUE? "" : "no ");
assert(fret == TRUE);
status = dbretstatus(dbproc);
printf("return status %d is %d\n", i, (int) status);
switch (i) {
case 1: assert(status == 17); break;
case 2: assert(status == 1024); break;
default: assert(i <= expected_iterations);
}
}
assert(erc == NO_MORE_RESULTS);
fprintf(stdout, "Dropping proc t0022a\n");
dbcmd(dbproc, "drop proc t0022a");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
/* end chapter 2 */
add_bread_crumb();
dbexit();
add_bread_crumb();
fprintf(stdout, "dblib %s on %s\n", (failed ? "failed!" : "okay"), __FILE__);
free_bread_crumb();
return failed ? 1 : 0;
}
static void
test(int bind_type)
{
LOGINREC *login;
DBPROCESS *dbproc;
DBNUMERIC *num = NULL, *num2 = NULL;
RETCODE ret;
int i;
sql_rewind();
login = dblogin();
DBSETLUSER(login, USER);
DBSETLPWD(login, PASSWORD);
DBSETLAPP(login, "numeric");
dbsetmaxprocs(25);
DBSETLHOST(login, SERVER);
dbproc = dbopen(login, SERVER);
dbloginfree(login);
login = NULL;
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
if (DBTDS_5_0 < DBTDS(dbproc)) {
ret = dbcmd(dbproc,
"SET ARITHABORT ON;"
"SET CONCAT_NULL_YIELDS_NULL ON;"
"SET ANSI_NULLS ON;"
"SET ANSI_NULL_DFLT_ON ON;"
"SET ANSI_PADDING ON;"
"SET ANSI_WARNINGS ON;"
"SET ANSI_NULL_DFLT_ON ON;"
"SET CURSOR_CLOSE_ON_COMMIT ON;"
"SET QUOTED_IDENTIFIER ON");
chk(ret, "dbcmd");
ret = dbsqlexec(dbproc);
chk(ret, "dbsqlexec");
ret = dbcancel(dbproc);
chk(ret, "dbcancel");
}
ret = dbrpcinit(dbproc, "testDecimal", 0);
chk(ret, "dbrpcinit");
num = (DBDECIMAL *) calloc(1, sizeof(DBDECIMAL));
num->scale = 5;
num->precision = 16;
dbconvert(dbproc, SYBVARCHAR, (const BYTE *) "123.45", -1, SYBDECIMAL, (BYTE *) num, sizeof(*num));
ret = dbrpcparam(dbproc, "@idecimal", 0, SYBDECIMAL, -1, sizeof(DBDECIMAL), (BYTE *) num);
chk(ret, "dbrpcparam");
ret = dbrpcsend(dbproc);
chk(ret, "dbrpcsend");
ret = dbsqlok(dbproc);
chk(ret, "dbsqlok");
/* TODO check MS/Sybase format */
num2 = (DBDECIMAL *) calloc(1, sizeof(DBDECIMAL));
num2->precision = 20;
num2->scale = 10;
dbconvert(dbproc, SYBVARCHAR, (const BYTE *) "246.9", -1, SYBDECIMAL, (BYTE *) num2, sizeof(*num2));
for (i=0; (ret = dbresults(dbproc)) != NO_MORE_RESULTS; ++i) {
RETCODE row_code;
switch (ret) {
case SUCCEED:
if (DBROWS(dbproc) == FAIL)
continue;
assert(DBROWS(dbproc) == SUCCEED);
printf("dbrows() returned SUCCEED, processing rows\n");
memset(num, 0, sizeof(*num));
num->precision = num2->precision;
num->scale = num2->scale;
dbbind(dbproc, 1, bind_type, 0, (BYTE *) num);
while ((row_code = dbnextrow(dbproc)) != NO_MORE_ROWS) {
if (row_code == REG_ROW) {
if (memcmp(num, num2, sizeof(*num)) != 0) {
fprintf(stderr, "Failed. Output results does not match\n");
dump_addr(stderr, "numeric: ", num, sizeof(*num));
dump_addr(stderr, "numeric2:", num2, sizeof(*num2));
exit(1);
}
} else {
/* not supporting computed rows in this unit test */
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
}
break;
case FAIL:
fprintf(stderr, "dbresults returned FAIL\n");
exit(1);
default:
fprintf(stderr, "unexpected return code %d from dbresults\n", ret);
exit(1);
}
} /* while dbresults */
sql_cmd(dbproc);
free(num2);
free(num);
dbclose(dbproc);
}
static VALUE rb_tinytds_result_each(int argc, VALUE * argv, VALUE self) {
/* Local Vars */
VALUE qopts, opts, block;
ID timezone;
int symbolize_keys = 0, as_array = 0, cache_rows = 0, first = 0, empty_sets = 0;
tinytds_client_userdata *userdata;
GET_RESULT_WRAPPER(self);
userdata = (tinytds_client_userdata *)dbgetuserdata(rwrap->client);
/* Merge Options Hash To Query Options. Populate Opts & Block Var. */
qopts = rb_iv_get(self, "@query_options");
if (rb_scan_args(argc, argv, "01&", &opts, &block) == 1)
qopts = rb_funcall(qopts, intern_merge, 1, opts);
rb_iv_set(self, "@query_options", qopts);
/* Locals From Options */
if (rb_hash_aref(qopts, sym_first) == Qtrue)
first = 1;
if (rb_hash_aref(qopts, sym_symbolize_keys) == Qtrue)
symbolize_keys = 1;
if (rb_hash_aref(qopts, sym_as) == sym_array)
as_array = 1;
if (rb_hash_aref(qopts, sym_cache_rows) == Qtrue)
cache_rows = 1;
if (rb_hash_aref(qopts, sym_timezone) == sym_local) {
timezone = intern_local;
} else if (rb_hash_aref(qopts, sym_timezone) == sym_utc) {
timezone = intern_utc;
} else {
rb_warn(":timezone option must be :utc or :local - defaulting to :local");
timezone = intern_local;
}
if (rb_hash_aref(qopts, sym_empty_sets) == Qtrue)
empty_sets = 1;
/* Make The Results Or Yield Existing */
if (NIL_P(rwrap->results)) {
RETCODE dbsqlok_rc, dbresults_rc;
rwrap->results = rb_ary_new();
dbsqlok_rc = rb_tinytds_result_ok_helper(rwrap->client);
dbresults_rc = rb_tinytds_result_dbresults_retcode(self);
while ((dbsqlok_rc == SUCCEED) && (dbresults_rc == SUCCEED)) {
int has_rows = (DBROWS(rwrap->client) == SUCCEED) ? 1 : 0;
if (has_rows || empty_sets || (rwrap->number_of_results == 0))
rb_tinytds_result_fields(self);
if ((has_rows || empty_sets) && rwrap->number_of_fields > 0) {
/* Create rows for this result set. */
unsigned long rowi = 0;
VALUE result = rb_ary_new();
while (nogvl_dbnextrow(rwrap->client) != NO_MORE_ROWS) {
VALUE row = rb_tinytds_result_fetch_row(self, timezone, symbolize_keys, as_array);
if (cache_rows)
rb_ary_store(result, rowi, row);
if (!NIL_P(block))
rb_yield(row);
if (first) {
dbcanquery(rwrap->client);
userdata->dbcancel_sent = 1;
}
rowi++;
}
rwrap->number_of_rows = rowi;
/* Store the result. */
if (cache_rows) {
if (rwrap->number_of_results == 0) {
rwrap->results = result;
} else if (rwrap->number_of_results == 1) {
VALUE multi_resultsets = rb_ary_new();
rb_ary_store(multi_resultsets, 0, rwrap->results);
rb_ary_store(multi_resultsets, 1, result);
rwrap->results = multi_resultsets;
} else {
rb_ary_store(rwrap->results, rwrap->number_of_results, result);
}
}
// If we find results increment the counter that helpers use and setup the next loop.
rwrap->number_of_results = rwrap->number_of_results + 1;
dbresults_rc = rb_tinytds_result_dbresults_retcode(self);
rb_ary_store(rwrap->fields_processed, rwrap->number_of_results, Qnil);
} else {
// If we do not find results, side step the rb_tinytds_result_dbresults_retcode helper and
// manually populate its memoized array while nullifing any memoized fields too before loop.
dbresults_rc = nogvl_dbresults(rwrap->client);
rb_ary_store(rwrap->dbresults_retcodes, rwrap->number_of_results, INT2FIX(dbresults_rc));
rb_ary_store(rwrap->fields_processed, rwrap->number_of_results, Qnil);
}
}
if (dbresults_rc == FAIL)
rb_warn("TinyTDS: Something in the dbresults() while loop set the return code to FAIL.\n");
userdata->dbsql_sent = 0;
} else if (!NIL_P(block)) {
unsigned long i;
for (i = 0; i < rwrap->number_of_rows; i++) {
rb_yield(rb_ary_entry(rwrap->results, i));
}
}
return rwrap->results;
}
int
main(int argc, char *argv[])
{
int echo = 0;
#ifdef notyet
int print_statistics = 0;
#endif
int fipsflagger = 0;
int perfstats = 0;
int no_prompt = 0;
int use_encryption = 0;
int chained_transactions = 0;
const char *cmdend = "go";
int headers = 0;
char *columnwidth = NULL;
const char *colseparator = " ";
const char *lineseparator = "\n";
int timeout = 0;
char *username = NULL;
char *password = NULL;
char *server = NULL;
DBCHAR *char_set = NULL;
const char *editor;
char *hostname = NULL;
char *sqlch;
char *interfaces_filename = NULL;
char *input_filename = NULL;
char *output_filename = NULL;
int logintime = -1;
char *language = NULL;
int size = 0;
char *sybenv;
DBPROCESS *dbproc;
LOGINREC *login;
char **ibuf = NULL;
int ibuflines = 0;
int printedlines;
int i;
char *line;
int dbrc;
char foobuf[512];
char *firstword;
char *cp;
int c;
int errflg = 0;
char *prbuf;
int prbuflen;
FILE *fp;
FILE *tmpfp;
FILE *tmpfp2;
char *tfn;
char tmpfn[256];
int num_cols;
int selcol;
int col;
int collen;
DBINT colid;
const char *opname;
char adbuf[512];
DBINT convlen;
int printedcompute = 0;
char adash;
const char *database_name = NULL;
int default_exit = EXIT_SUCCESS;
setlocale(LC_ALL, "");
#ifdef __VMS
/* Convert VMS-style arguments to Unix-style */
parse_vms_args(&argc, &argv);
#endif
editor = getenv("EDITOR");
if (!editor) {
editor = getenv("VISUAL");
}
if (!editor) {
editor = "vi";
}
opterr = 0;
optarg = NULL;
while (!errflg && (c = getopt(argc, argv, "eFgpnvXYa:c:D:E:h:H:i:I:J:l:m:o:P:s:S:t:U:w:y:z:A:"))
!= -1) {
switch (c) {
case 'e':
echo = 1;
break;
case 'F':
fipsflagger = 1;
break;
case 'g':
errflg++;
break;
case 'p':
errflg++;
perfstats = 1;
break;
case 'n':
no_prompt = 1;
break;
case 'v':
puts("fisql, a free isql replacement by Nicholas S. Castellano");
exit(EXIT_SUCCESS);
break;
case 'X':
/* XXX: We get a different error message than isql gives; neither seems
* to work
*/
use_encryption = 1;
break;
case 'Y':
chained_transactions = 1;
break;
case 'c':
cmdend = optarg;
break;
case 'E':
editor = optarg;
break;
case 'h':
headers = atoi(optarg);
break;
case 'H':
hostname = optarg;
break;
case 'i':
input_filename = optarg;
break;
case 'I':
interfaces_filename = optarg;
break;
case 'J':
errflg++;
break;
case 'l':
logintime = atoi(optarg);
break;
case 'm':
global_errorlevel = atoi(optarg);
break;
case 'o':
output_filename = optarg;
break;
case 'P':
password = optarg;
break;
case 's':
colseparator = optarg;
break;
case 'S':
server = optarg;
break;
case 't':
timeout = atoi(optarg);
break;
case 'U':
username = optarg;
break;
case 'w':
columnwidth = optarg;
break;
case 'y':
/* XXX: this doesn't seem to be what isql does with -y...it doesn't
* seem to do anything actually
*/
sybenv = (char *) xmalloc((strlen(optarg) + 8) * sizeof(char));
strcpy(sybenv, "SYBASE=");
strcat(sybenv, optarg);
putenv(sybenv);
break;
case 'z':
language = optarg;
break;
case 'A':
size = atoi(optarg);
break;
case 'D':
database_name = optarg;
break;
default:
errflg++;
break;
}
}
if (errflg) {
fprintf(stderr, "usage: fisql [-e] [-F] [-g] [-p] [-n] [-v] [-X] [-Y]\n");
fprintf(stderr, "\t[-c cmdend] [-D database_name] [-E editor]\n");
fprintf(stderr, "\t[-h headers] [-H hostname] [-i inputfile]\n");
fprintf(stderr, "\t[-I interfaces_file] [-J client character set]\n");
fprintf(stderr, "\t[-l login_timeout] [-m errorlevel]\n");
fprintf(stderr, "\t[-o outputfile]\n");
fprintf(stderr, "\t[-P password] [-s colseparator] [-S server]\n");
fprintf(stderr, "\t[-t timeout] [-U username] [-w columnwidth]\n");
fprintf(stderr, "\t[-y sybase_dir] [-z language]\n");
exit(EXIT_FAILURE);
}
if (!(isatty(fileno(stdin)))) {
no_prompt = 1;
rl_outstream = fopen("/dev/null", "rw");
}
rl_readline_name = "fisql";
rl_bind_key('\t', rl_insert);
if (password == NULL) {
password = (char *) xmalloc(READPASSPHRASE_MAXLEN);
readpassphrase("Password: "******"r", stdin) == NULL) {
/* XXX: sybase isql generates this error while parsing the options,
* but doesn't redirect the input until after the Password: prompt
*/
/* lack of newline for bug-compatibility with isql */
fprintf(stderr, "Unable to open input file '%s'.", optarg);
exit(EXIT_FAILURE);
}
}
if (output_filename) {
if (freopen(output_filename, "w", stdout) == NULL) {
/* XXX: sybase isql generates this error while parsing the options,
* but doesn't redirect the output until after the Password: prompt
*/
/* lack of newline for bug-compatibility with isql */
fprintf(stderr, "Unable to open output file '%s'.", output_filename);
exit(EXIT_FAILURE);
}
}
if (isatty(fileno(stdin))) {
rl_outstream = stdout;
}
dbinit();
#if 0
#ifdef DBVERSION_100
dbsetversion(DBVERSION_100);
#endif
#endif
if ((login = dblogin()) == NULL) {
reset_term();
exit(EXIT_FAILURE);
}
dbmsghandle(msg_handler);
dberrhandle(err_handler);
DBSETLAPP(login, "fisql");
if (username) {
DBSETLUSER(login, username);
}
DBSETLPWD(login, password);
memset(password, 0, strlen(password));
if (char_set) {
DBSETLCHARSET(login, char_set);
}
if (use_encryption) {
DBSETLENCRYPT(login, TRUE);
}
if (hostname) {
DBSETLHOST(login, hostname);
}
if (language) {
DBSETLNATLANG(login, language);
}
if (size) {
DBSETLPACKET(login, (short) size);
}
if (interfaces_filename) {
dbsetifile(interfaces_filename);
}
dbsettime(timeout);
if (logintime >= 0) {
dbsetlogintime(logintime);
}
if ((dbproc = dbopen(login, server)) == NULL) {
fprintf(stderr, "fisql: dbopen() failed.\n");
reset_term();
exit(EXIT_FAILURE);
}
dbsetopt(dbproc, DBPRLINESEP, lineseparator, strlen(lineseparator));
if (colseparator) {
dbsetopt(dbproc, DBPRCOLSEP, colseparator, strlen(colseparator));
}
if (columnwidth) {
dbsetopt(dbproc, DBPRLINELEN, columnwidth, 0);
}
if (chained_transactions) {
dbsetopt(dbproc, DBCHAINXACTS, NULL, 0);
}
if (fipsflagger) {
dbsetopt(dbproc, DBFIPSFLAG, NULL, 0);
}
if (perfstats) {
dbsetopt(dbproc, DBSTAT, "time", 0);
}
if (database_name) {
dbuse(dbproc, database_name);
}
while (1) {
if (sigsetjmp(restart, 1)) {
if (ibuf) {
for (i = 0; i < ibuflines; i++) {
free(ibuf[i]);
}
ibuflines = 0;
free(ibuf);
ibuf = NULL;
}
fputc('\n', stdout);
rl_on_new_line();
rl_reset_line_state();
}
dbcancel(dbproc);
signal(SIGINT, inactive_interrupt_handler);
ibuf = (char **) xmalloc(sizeof(char *));
ibuflines = 0;
while (1) {
if (no_prompt) {
foobuf[0] = '\0';
} else {
sprintf(foobuf, "%d>> ", ibuflines + 1);
}
line = readline(foobuf);
if (line == NULL) {
line = "exit";
}
for (cp = line; *cp && isspace((unsigned char) *cp); cp++)
continue;
if (*cp) {
add_history(line);
}
if (!(strncasecmp(line, "!!", 2))) {
int rv;
cp = line + 2;
switch (rv = system(cp)) {
case 0:
continue;
case -1:
fprintf(stderr,
"Failed to execute `%s'\n", cp);
continue;
default:
fprintf(stderr, "Command `%s' exited "
"with code %d\n", cp, rv);
continue;
}
}
/* XXX: isql off-by-one line count error for :r not duplicated */
if (!(strncasecmp(line, ":r", 2))) {
for (cp = line + 2; *cp && (isspace((unsigned char) *cp)); cp++)
continue;
tfn = cp;
for (; *cp && !(isspace((unsigned char) *cp)); cp++)
continue;
*cp = '\0';
if ((fp = fopen(tfn, "r")) == NULL) {
fprintf(stderr, "Operating system error: Failed to open %s.\n", tfn);
continue;
}
tmpfp = rl_instream;
tmpfp2 = rl_outstream;
rl_instream = fp;
rl_outstream = fopen("/dev/null", "w");
while ((line = readline("")) != NULL) {
ibuf[ibuflines++] = line;
ibuf = (char **) xrealloc(ibuf, (ibuflines + 1) * sizeof(char *));
}
rl_instream = tmpfp;
fclose(rl_outstream);
rl_outstream = tmpfp2;
fclose(fp);
fputc('\r', stdout);
fflush(stdout);
continue;
}
firstword = (char *) xmalloc((strlen(line) + 1) * sizeof(char));
strcpy(firstword, line);
for (cp = firstword; *cp; cp++) {
if (isspace((unsigned char) *cp)) {
*cp = '\0';
break;
}
}
if ((!(strcasecmp(firstword, "exit")))
|| (!(strcasecmp(firstword, "quit")))) {
reset_term();
dbexit();
exit(default_exit);
}
if (!(strcasecmp(firstword, "reset"))) {
for (i = 0; i < ibuflines; i++) {
free(ibuf[i]);
}
ibuflines = 0;
continue;
}
if (!(strcasecmp(firstword, cmdend))) {
if (ibuflines == 0) {
continue;
}
free(firstword);
break;
}
if ((!(strcasecmp(firstword, "vi")))
|| (!(strcasecmp(firstword, editor)))) {
int tmpfd;
strcpy(tmpfn, "/tmp/fisqlXXXXXX");
tmpfd = mkstemp(tmpfn);
if ((fp = fdopen(tmpfd, "w")) == NULL) {
perror("fisql");
reset_term();
dbexit();
exit(2);
}
if (ibuflines) {
for (i = 0; i < ibuflines; i++) {
fputs(ibuf[i], fp);
fputc('\n', fp);
free(ibuf[i]);
}
} else {
for (i = 0; ((sqlch = dbgetchar(dbproc, i)) != NULL); i++) {
fputc(*sqlch, fp);
}
}
fclose(fp);
if (!(strcmp(firstword, "vi"))) {
edit("vi", tmpfn);
} else {
edit(editor, tmpfn);
}
ibuflines = 0;
fp = fopen(tmpfn, "r");
tmpfp = rl_instream;
rl_instream = fp;
strcpy(foobuf, "1>> ");
while ((line = readline(foobuf)) != NULL) {
ibuf[ibuflines++] = line;
sprintf(foobuf, "%d>> ", ibuflines + 1);
ibuf = (char **) xrealloc(ibuf, (ibuflines + 1) * sizeof(char *));
}
rl_instream = tmpfp;
fclose(fp);
fputc('\r', stdout);
fflush(stdout);
unlink(tmpfn);
continue;
}
free(firstword);
ibuf[ibuflines++] = line;
ibuf = (char **) xrealloc(ibuf, (ibuflines + 1) * sizeof(char *));
}
dbfreebuf(dbproc);
for (i = 0; i < ibuflines; i++) {
if (echo) {
puts(ibuf[i]);
}
dbcmd(dbproc, ibuf[i]);
dbcmd(dbproc, "\n");
free(ibuf[i]);
}
free(ibuf);
ibuf = NULL;
signal(SIGINT, active_interrupt_handler);
dbsetinterrupt(dbproc, (void *) active_interrupt_pending, (void *) active_interrupt_servhandler);
if (dbsqlexec(dbproc) == SUCCEED) {
maybe_handle_active_interrupt();
while ((dbrc = dbresults(dbproc)) != NO_MORE_RESULTS) {
printedlines = 0;
#define USE_DBPRROW 0
#if USE_DBPRROW
dbprhead(dbproc);
dbprrow(dbproc);
#else
if ((dbrc == SUCCEED) && (DBROWS(dbproc) == SUCCEED)) {
prbuflen = dbspr1rowlen(dbproc);
prbuf = (char *) xmalloc(prbuflen * sizeof(char));
dbsprhead(dbproc, prbuf, prbuflen);
fputs(prbuf, stdout);
fputc('\n', stdout);
dbsprline(dbproc, prbuf, prbuflen, '-');
fputs(prbuf, stdout);
fputc('\n', stdout);
maybe_handle_active_interrupt();
while ((dbrc = dbnextrow(dbproc)) != NO_MORE_ROWS) {
if (dbrc == FAIL) {
break;
}
if (dbrc != REG_ROW) {
num_cols = dbnumalts(dbproc, dbrc);
for (selcol = col = 1; col <= num_cols; col++) {
colid = dbaltcolid(dbproc, dbrc, col);
while (selcol < colid) {
collen = get_printable_column_size(dbproc, selcol);
for (i = 0; i < collen; i++) {
putchar(' ');
}
selcol++;
printf("%s", colseparator);
}
opname = dbprtype(dbaltop(dbproc, dbrc, col));
printf("%s", opname);
collen = get_printable_column_size(dbproc, colid);
collen -= strlen(opname);
while (collen-- > 0) {
putchar(' ');
}
selcol++;
printf("%s", colseparator);
}
printf("%s", lineseparator);
for (selcol = col = 1; col <= num_cols; col++) {
colid = dbaltcolid(dbproc, dbrc, col);
while (selcol < colid) {
collen = get_printable_column_size(dbproc, selcol);
for (i = 0; i < collen; i++) {
putchar(' ');
}
selcol++;
printf("%s", colseparator);
}
collen = get_printable_column_size(dbproc, colid);
adash = '-';
for (i = 0; i < collen; i++) {
putchar(adash);
}
selcol++;
printf("%s", colseparator);
}
printf("%s", lineseparator);
for (selcol = col = 1; col <= num_cols; col++) {
colid = dbaltcolid(dbproc, dbrc, col);
while (selcol < colid) {
collen = get_printable_column_size(dbproc, selcol);
for (i = 0; i < collen; i++) {
putchar(' ');
}
selcol++;
printf("%s", colseparator);
}
convlen = dbconvert(dbproc,
dbalttype(dbproc, dbrc, col),
dbadata(dbproc, dbrc, col),
dbadlen(dbproc, dbrc, col),
SYBCHAR, (BYTE *) adbuf, sizeof(adbuf));
printf("%.*s", (int) convlen, adbuf);
collen = get_printable_column_size(dbproc, colid);
collen -= convlen;
while (collen-- > 0) {
putchar(' ');
}
selcol++;
printf("%s", colseparator);
}
printf("%s", lineseparator);
printedcompute = 1;
continue;
}
if (printedcompute || (headers && (printedlines >= headers)
&& ((printedlines % headers) == 0))) {
fputc('\n', stdout);
dbsprhead(dbproc, prbuf, prbuflen);
fputs(prbuf, stdout);
fputc('\n', stdout);
dbsprline(dbproc, prbuf, prbuflen, '-');
fputs(prbuf, stdout);
fputc('\n', stdout);
printedcompute = 0;
}
printedlines++;
dbspr1row(dbproc, prbuf, prbuflen);
fputs(prbuf, stdout);
fputc('\n', stdout);
maybe_handle_active_interrupt();
}
fputc('\n', stdout);
free(prbuf);
maybe_handle_active_interrupt();
}
#endif
if (dbrc != FAIL) {
if ((DBCOUNT(dbproc) >= 0) || dbhasretstat(dbproc)) {
if (DBCOUNT(dbproc) >= 0) {
fprintf(stdout, "(%d rows affected", (int) DBCOUNT(dbproc));
if (dbhasretstat(dbproc)) {
dbrc = dbretstatus(dbproc);
fprintf(stdout, ", return status = %d", dbrc);
}
fprintf(stdout, ")\n");
} else {
if (dbhasretstat(dbproc)) {
dbrc = dbretstatus(dbproc);
fprintf(stdout, "(return status = %d)\n", dbrc);
}
}
}
}
}
} else {
/* Something failed, so change the default
* exit status to reflect that.
*/
default_exit = EXIT_FAILURE;
}
}
reset_term();
dbexit();
exit(EXIT_FAILURE);
return (0);
}
int
main(int argc, char **argv)
{
const int rows_to_add = 50;
LOGINREC *login;
DBPROCESS *dbproc;
int i;
char teststr[1024];
DBINT testint;
set_malloc_options();
read_login_info(argc, argv);
fprintf(stdout, "Starting %s\n", argv[0]);
/* Fortify_EnterScope(); */
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0018");
fprintf(stdout, "About to open\n");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
fprintf(stdout, "creating table\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "insert\n");
for (i = 0; i < rows_to_add; i++) {
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
if (DBCOUNT(dbproc) != 1) {
failed = 1;
fprintf(stdout, "Was expecting a rows affect to be 1.");
exit(1);
}
}
fprintf(stdout, "select\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
fprintf(stdout, "Checking for an empty result set.\n");
if (dbresults(dbproc) != SUCCEED) {
failed = 1;
fprintf(stdout, "Was expecting a result set.\n");
exit(1);
}
if(DBROWS(dbproc) != FAIL) {
failed = 1;
fprintf(stdout, "Was expecting no rows to be available.\n");
exit(1);
}
fprintf(stdout, "Checking for a result set with content.\n");
if (dbresults(dbproc) != SUCCEED) {
failed = 1;
fprintf(stdout, "Was expecting a result set.");
exit(1);
}
for (i = 1; i <= dbnumcols(dbproc); i++)
printf("col %d is %s\n", i, dbcolname(dbproc, i));
if (SUCCEED != dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint)) {
failed = 1;
fprintf(stderr, "Had problem with bind\n");
abort();
}
if (SUCCEED != dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr)) {
failed = 1;
fprintf(stderr, "Had problem with bind\n");
abort();
}
for (i = 0; i < rows_to_add; i++) {
char expected[1024];
sprintf(expected, "row %03d", i);
if (REG_ROW != dbnextrow(dbproc)) {
failed = 1;
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
if (testint != i) {
failed = 1;
fprintf(stderr, "Failed. Expected i to be %d, was %d\n", i, (int) testint);
abort();
}
if (0 != strncmp(teststr, expected, strlen(expected))) {
failed = 1;
fprintf(stdout, "Failed. Expected s to be |%s|, was |%s|\n", expected, teststr);
abort();
}
printf("Read a row of data -> %d %s\n", (int) testint, teststr);
}
if (dbnextrow(dbproc) != NO_MORE_ROWS) {
failed = 1;
fprintf(stderr, "Was expecting no more rows\n");
exit(1);
}
if (DBCOUNT(dbproc) != rows_to_add) {
failed = 1;
fprintf(stdout, "Was expecting a rows affect to be %d was %d.\n", rows_to_add, DBCOUNT(dbproc));
exit(1);
}
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
if (DBCOUNT(dbproc) != rows_to_add) {
failed = 1;
fprintf(stdout, "Was expecting a rows affect to be %d was %d.\n", rows_to_add, DBCOUNT(dbproc));
exit(1);
} else {
fprintf(stdout, "Number of rows affected by update = %d.\n", DBCOUNT(dbproc));
}
dbexit();
fprintf(stdout, "%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
int i,r, failed = 0;
RETCODE erc, row_code;
int num_resultset = 0;
char teststr[1024];
/*
* Connect to server
*/
set_malloc_options();
read_login_info(argc, argv);
fprintf(stdout, "Starting %s\n", argv[0]);
dbinit();
dberrhandle(timeout_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "#t0022");
fprintf(stdout, "About to open %s.%s\n", SERVER, DATABASE);
/*
* One way to test the login timeout is to connect to a discard server (grep discard /etc/services).
* It's normally supported by inetd.
*/
printf ("using %d 1-second login timeouts\n", max_timeouts);
dbsetlogintime(1);
start_time = time(NULL); /* keep track of when we started for reporting purposes */
if (NULL == (dbproc = dbopen(login, SERVER))){
fprintf(stderr, "Failed: dbopen\n");
exit(1);
}
printf ("connected.\n");
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
/* send something that will take awhile to execute */
printf ("using %d %d-second query timeouts\n", max_timeouts, timeout_seconds);
if (FAIL == dbsettime(timeout_seconds)) {
fprintf(stderr, "Failed: dbsettime\n");
exit(1);
}
printf ("issuing a query that will take 30 seconds\n");
if (FAIL == sql_cmd(dbproc)) {
fprintf(stderr, "Failed: dbcmd\n");
exit(1);
}
start_time = time(NULL);
ntimeouts = 0;
dbsetinterrupt(dbproc, (void*)chkintr, (void*)hndlintr);
if (FAIL == dbsqlsend(dbproc)) {
fprintf(stderr, "Failed: dbsend\n");
exit(1);
}
/* wait for it to execute */
printf("executing dbsqlok\n");
erc = dbsqlok(dbproc);
if (erc != FAIL) {
fprintf(stderr, "dbsqlok should fail for timeout\n");
exit(1);
}
/* retrieve outputs per usual */
r = 0;
for (i=0; (erc = dbresults(dbproc)) != NO_MORE_RESULTS; i++) {
int nrows, ncols;
switch (erc) {
case SUCCEED:
if (DBROWS(dbproc) == FAIL){
r++;
continue;
}
assert(DBROWS(dbproc) == SUCCEED);
printf("dbrows() returned SUCCEED, processing rows\n");
ncols = dbnumcols(dbproc);
++num_resultset;
printf("bound 1 of %d columns ('%s') in result %d.\n", ncols, dbcolname(dbproc, 1), ++r);
dbbind(dbproc, 1, STRINGBIND, 0, (BYTE *) teststr);
printf("\t%s\n\t-----------\n", dbcolname(dbproc, 1));
while ((row_code = dbnextrow(dbproc)) != NO_MORE_ROWS) {
if (row_code == REG_ROW) {
printf("\t%s\n", teststr);
} else {
/* not supporting computed rows in this unit test */
failed = 1;
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
}
nrows = (int) dbcount(dbproc);
printf("row count %d\n", nrows);
if (nrows < 0){
failed++;
printf("error: dbrows() returned SUCCEED, but dbcount() returned -1\n");
}
break;
case FAIL:
printf("dbresults returned FAIL\n");
exit(1);
default:
printf("unexpected return code %d from dbresults\n", erc);
exit(1);
}
if ( i > 1) {
failed++;
break;
}
} /* while dbresults */
dbexit();
fprintf(stdout, "%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}