int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
int i;
char teststr[1024];
DBINT testint;
set_malloc_options();
read_login_info(argc, argv);
printf("Starting %s\n", argv[0]);
/* Fortify_EnterScope(); */
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
printf("About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "text_buffer");
DBSETLHOST(login, "ntbox.dntis.ro");
printf("About to open\n");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
#ifdef MICROSOFT_DBLIB
dbsetopt(dbproc, DBBUFFER, "100");
#else
dbsetopt(dbproc, DBBUFFER, "100", 0);
#endif
printf("creating table\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
printf("insert\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
printf("select\n");
dbcmd(dbproc, "select * from #dblib order by i");
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
printf("Was expecting a result set.");
return 1;
}
for (i = 1; i <= dbnumcols(dbproc); i++) {
printf("col %d is %s\n", i, dbcolname(dbproc, i));
}
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
if (REG_ROW != dbnextrow(dbproc)) {
fprintf(stderr, "dblib failed for %s:%d\n", __FILE__, __LINE__);
return 1;
}
if (dbdatlen(dbproc, 2) != 6 || 0 != strcmp("ABCDEF", teststr)) {
fprintf(stderr, "Expected |%s|, found |%s|\n", "ABCDEF", teststr);
fprintf(stderr, "dblib failed for %s:%d\n", __FILE__, __LINE__);
return 1;
}
if (REG_ROW != dbnextrow(dbproc)) {
fprintf(stderr, "dblib failed for %s:%d\n", __FILE__, __LINE__);
return 1;
}
if (dbdatlen(dbproc, 2) != 3 || 0 != strcmp("abc", teststr)) {
fprintf(stderr, "Expected |%s|, found |%s|\n", "abc", teststr);
fprintf(stderr, "dblib failed for %s:%d\n", __FILE__, __LINE__);
return 1;
}
/* get again row 1 */
dbgetrow(dbproc, 1);
/* here length and string should be ok */
if (dbdatlen(dbproc, 2) != 6 || 0 != strcmp("ABCDEF", teststr)) {
fprintf(stderr, "Expected |%s|, found |%s|\n", "ABCDEF", teststr);
fprintf(stderr, "dblib failed for %s:%d\n", __FILE__, __LINE__);
return 1;
}
dbgetrow(dbproc, 2);
if (dbdatlen(dbproc, 2) != 3 || 0 != strcmp("abc", teststr)) {
fprintf(stderr, "Expected |%s|, found |%s|\n", "abc", teststr);
fprintf(stderr, "dblib failed for %s:%d\n", __FILE__, __LINE__);
return 1;
}
dbexit();
printf("%s %s\n", __FILE__, (0 ? "failed!" : "OK"));
return 0;
}
int
main(int argc, char **argv)
{
RETCODE rc;
const int rows_to_add = 50;
LOGINREC *login;
DBPROCESS *dbproc;
int i;
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, "t0006");
DBSETLHOST(login, "ntbox.dntis.ro");
fprintf(stdout, "About to open\n");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
#ifdef MICROSOFT_DBLIB
dbsetopt(dbproc, DBBUFFER, "5000");
#else
dbsetopt(dbproc, DBBUFFER, "5000", 0);
#endif
fprintf(stdout, "creating table\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "insert\n");
for (i = 1; i < rows_to_add; i++) {
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
fprintf(stdout, "first select\n");
if (SUCCEED != sql_cmd(dbproc)) {
fprintf(stderr, "%s:%d: dbcmd failed\n", __FILE__, __LINE__);
failed = 1;
}
if (SUCCEED != dbsqlexec(dbproc)) {
fprintf(stderr, "%s:%d: dbsqlexec failed\n", __FILE__, __LINE__);
failed = 1;
}
if (dbresults(dbproc) != SUCCEED) {
fprintf(stdout, "%s:%d: Was expecting a result set.", __FILE__, __LINE__);
failed = 1;
exit(1);
}
for (i = 1; i <= dbnumcols(dbproc); i++)
printf("col %d is %s\n", i, dbcolname(dbproc, i));
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
get_results(dbproc, 1);
testint = -1;
strcpy(teststr, "bogus");
fprintf(stdout, "second select\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
if ((rc = dbresults(dbproc)) != SUCCEED) {
fprintf(stdout, "%s:%d: Was expecting a result set. (rc=%d)\n", __FILE__, __LINE__, rc);
failed = 1;
}
if (!failed) {
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
get_results(dbproc, 25);
}
dbexit();
fprintf(stdout, "%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
int
main(int argc, char **argv)
{
const int rows_to_add = 48;
LOGINREC *login;
DBPROCESS *dbproc;
int i;
char teststr[1024];
DBINT testint;
DBINT last_read = -1;
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, "t0008");
DBSETLHOST(login, "ntbox.dntis.ro");
fprintf(stdout, "About to open\n");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
#ifdef MICROSOFT_DBLIB
dbsetopt(dbproc, DBBUFFER, "25");
#else
dbsetopt(dbproc, DBBUFFER, "25", 0);
#endif
fprintf(stdout, "creating table\n");
dbcmd(dbproc, "create table #dblib0008 (i int not null, s char(10) not null)");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "insert\n");
for (i = 1; i <= rows_to_add; i++) {
char cmd[1024];
sprintf(cmd, "insert into #dblib0008 values (%d, 'row %03d')", i, i);
dbcmd(dbproc, cmd);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
fprintf(stdout, "select\n");
dbcmd(dbproc, "select * from #dblib0008 order by i");
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
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));
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
for (i = 1; i <= rows_to_add; i++) {
char expected[1024];
sprintf(expected, "row %03d", i);
if (i % 25 == 0) {
dbclrbuf(dbproc, 25);
}
if (REG_ROW != dbnextrow(dbproc)) {
fprintf(stderr, "dblib failed for %s, dbnextrow1\n", __FILE__);
dbexit();
return 1;
}
last_read = testint;
if (testint < 1 || testint > rows_to_add) {
fprintf(stderr, "dblib failed for %s testint = %d\n", __FILE__, (int) testint);
exit(1);
}
if (testint != i) {
fprintf(stderr, "Failed. Expected i to be %d, was %d\n", i, (int) testint);
abort();
}
if (0 != strncmp(teststr, expected, strlen(expected))) {
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 (REG_ROW == dbnextrow(dbproc)) {
fprintf(stderr, "dblib failed for %s, dbnextrow2\n", __FILE__);
dbexit();
return 1;
}
dbexit();
fprintf(stdout, "%s %s (last_read: %d)\n", __FILE__, ((last_read != rows_to_add)? "failed!" : "OK"), (int) last_read);
return (last_read == rows_to_add) ? 0 : 1;
}
static ngx_int_t
ngx_dbd_freetds_query(ngx_dbd_t *dbd)
{
ngx_dbd_freetds_ctx_t *ctx;
ngx_log_debug0(NGX_LOG_DEBUG_MYSQL, dbd->log, 0, "dbd freetds query");
ctx = dbd->ctx;
#if 0
if (dbrpcinit(ctx->db, ctx->sql, 0) != SUCCEED) {
return NGX_ERROR;
}
/* TODO: dbreginit */
/* dbrpcparam */
if (dbrpcexec(ctx->db) != SUCCEED) {
return NGX_ERROR;
}
if (dbrpcsend(ctx->db) != SUCCEED) {
return NGX_ERROR;
}
/* dbregparam */
/* dbregexec */
ctx->err = dbfcmd(ctx->db, ctx->sql);
if (ctx->err != SUCCEED) {
return NGX_ERROR;
}
/* dbbind */
/* dbhasretstat */
/* dbretstatus */
/* dbnumrets */
/* dbretdata */
/* dbrettype */
/* dbretlen */
/* dbretname */
if (dbsqlok(ctx->db) != SUCCEED) {
return NGX_ERROR;
}
#endif
ctx->err = dbcmd(ctx->db, (LPCSTR) ctx->sql);
if (ctx->err != SUCCEED) {
ngx_log_error(NGX_LOG_ALERT, dbd->log, 0, "dbcmd() failed");
return NGX_ERROR;
}
ctx->err = dbsqlexec(ctx->db);
if (ctx->err != SUCCEED) {
ngx_log_error(NGX_LOG_ALERT, dbd->log, 0, "dbsqlexec() failed");
return NGX_ERROR;
}
/* TODO: dbsetopt(DBBUFFER); */
/* dbclropt(ctx->db, DBBUFFER, "100"); */
/* dbisopt; */
#if 0
ctx->err = dbsetopt(ctx->db, DBBUFFER, "100");
#endif
ctx->err = dbresults(ctx->db);
if (ctx->err != SUCCEED) {
ngx_log_error(NGX_LOG_ALERT, dbd->log, 0, "dbresults() failed");
return NGX_ERROR;
}
ctx->cur_col = 0;
ctx->num_fields = (uint64_t) dbnumcols(ctx->db);
/* dbnumcompute(ctx->db); */
/* dbnumalts */
return NGX_OK;
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
int i;
char teststr[1024];
DBINT testint;
set_malloc_options();
read_login_info();
fprintf(stdout, "Start\n");
add_bread_crumb();
/* Fortify_EnterScope(); */
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, "t0010");
DBSETLHOST(login, "ntbox.dntis.ro");
fprintf(stdout, "About to open\n");
add_bread_crumb();
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
add_bread_crumb();
#ifdef MICROSOFT_DBLIB
dbsetopt(dbproc, DBBUFFER, "100");
#else
dbsetopt(dbproc, DBBUFFER, "100", 0);
#endif
add_bread_crumb();
fprintf(stdout, "Dropping table\n");
add_bread_crumb();
dbcmd(dbproc, "drop table #dblib0010");
add_bread_crumb();
dbsqlexec(dbproc);
add_bread_crumb();
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
add_bread_crumb();
fprintf(stdout, "creating table\n");
dbcmd(dbproc, "create table #dblib0010 (i int not null, s char(10) not null)");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "insert\n");
dbcmd(dbproc, "insert into #dblib0010 values (1, 'abcdef')");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
dbcmd(dbproc, "insert into #dblib0010 values (2, 'abc')");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "select\n");
dbcmd(dbproc, "select * from #dblib0010 order by i");
dbsqlexec(dbproc);
add_bread_crumb();
if (dbresults(dbproc) != SUCCEED) {
add_bread_crumb();
fprintf(stdout, "Was expecting a result set.");
exit(1);
}
add_bread_crumb();
for (i = 1; i <= dbnumcols(dbproc); i++) {
add_bread_crumb();
printf("col %d is %s\n", i, dbcolname(dbproc, i));
add_bread_crumb();
}
add_bread_crumb();
dbbind(dbproc, 1, INTBIND, -1, (BYTE *) & testint);
add_bread_crumb();
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
add_bread_crumb();
add_bread_crumb();
if (REG_ROW != dbnextrow(dbproc)) {
fprintf(stderr, "dblib failed for %s\n", __FILE__);
exit(1);
}
if (0 != strcmp("abcdef ", teststr)) {
fprintf(stderr, "Expected |%s|, found |%s|\n", "abcdef", teststr);
fprintf(stderr, "dblib failed for %s\n", __FILE__);
exit(1);
}
if (REG_ROW != dbnextrow(dbproc)) {
fprintf(stderr, "dblib failed for %s\n", __FILE__);
exit(1);
}
if (0 != strcmp("abc ", teststr)) {
fprintf(stderr, "Expected |%s|, found |%s|\n", "abc", teststr);
fprintf(stderr, "dblib failed for %s\n", __FILE__);
exit(1);
}
fprintf(stderr, "dblib passed for %s\n", __FILE__);
return 0;
}
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);
}
static VALUE rb_tinytds_connect(VALUE self, VALUE opts) {
/* Parsing options hash to local vars. */
VALUE user, pass, dataserver, database, app, version, ltimeout, timeout, charset, azure, contained, use_utf16;
GET_CLIENT_WRAPPER(self);
user = rb_hash_aref(opts, sym_username);
pass = rb_hash_aref(opts, sym_password);
dataserver = rb_hash_aref(opts, sym_dataserver);
database = rb_hash_aref(opts, sym_database);
app = rb_hash_aref(opts, sym_appname);
version = rb_hash_aref(opts, sym_tds_version);
ltimeout = rb_hash_aref(opts, sym_login_timeout);
timeout = rb_hash_aref(opts, sym_timeout);
charset = rb_hash_aref(opts, sym_encoding);
azure = rb_hash_aref(opts, sym_azure);
contained = rb_hash_aref(opts, sym_contained);
use_utf16 = rb_hash_aref(opts, sym_use_utf16);
cwrap->userdata->message_handler = rb_hash_aref(opts, sym_message_handler);
/* Dealing with options. */
if (dbinit() == FAIL) {
rb_raise(cTinyTdsError, "failed dbinit() function");
return self;
}
dberrhandle(tinytds_err_handler);
dbmsghandle(tinytds_msg_handler);
cwrap->login = dblogin();
if (!NIL_P(version))
dbsetlversion(cwrap->login, NUM2INT(version));
if (!NIL_P(user))
dbsetluser(cwrap->login, StringValueCStr(user));
if (!NIL_P(pass))
dbsetlpwd(cwrap->login, StringValueCStr(pass));
if (!NIL_P(app))
dbsetlapp(cwrap->login, StringValueCStr(app));
if (!NIL_P(ltimeout))
dbsetlogintime(NUM2INT(ltimeout));
if (!NIL_P(charset))
DBSETLCHARSET(cwrap->login, StringValueCStr(charset));
if (!NIL_P(database)) {
if (azure == Qtrue || contained == Qtrue) {
#ifdef DBSETLDBNAME
DBSETLDBNAME(cwrap->login, StringValueCStr(database));
#else
if (azure == Qtrue) {
rb_warn("TinyTds: :azure option is not supported in this version of FreeTDS.\n");
}
if (contained == Qtrue) {
rb_warn("TinyTds: :contained option is not supported in this version of FreeTDS.\n");
}
#endif
}
}
#ifdef DBSETUTF16
if (use_utf16 == Qtrue) { DBSETLUTF16(cwrap->login, 1); }
if (use_utf16 == Qfalse) { DBSETLUTF16(cwrap->login, 0); }
#else
if (use_utf16 == Qtrue || use_utf16 == Qfalse) {
rb_warning("TinyTds: Please consider upgrading to FreeTDS 0.99 or higher for better unicode support.\n");
}
#endif
cwrap->client = dbopen(cwrap->login, StringValueCStr(dataserver));
if (cwrap->client) {
VALUE transposed_encoding, timeout_string;
cwrap->closed = 0;
cwrap->charset = charset;
if (!NIL_P(version))
dbsetversion(NUM2INT(version));
if (!NIL_P(timeout)) {
timeout_string = rb_sprintf("%"PRIsVALUE"", timeout);
if (dbsetopt(cwrap->client, DBSETTIME, StringValueCStr(timeout_string), 0) == FAIL) {
dbsettime(NUM2INT(timeout));
}
}
dbsetuserdata(cwrap->client, (BYTE*)cwrap->userdata);
cwrap->userdata->closed = 0;
if (!NIL_P(database) && (azure != Qtrue)) {
dbuse(cwrap->client, StringValueCStr(database));
}
transposed_encoding = rb_funcall(cTinyTdsClient, intern_transpose_iconv_encoding, 1, charset);
cwrap->encoding = rb_enc_find(StringValueCStr(transposed_encoding));
if (dbtds(cwrap->client) <= 7) {
cwrap->identity_insert_sql = "SELECT CAST(@@IDENTITY AS bigint) AS Ident";
} else {
cwrap->identity_insert_sql = "SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident";
}
}
return self;
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
DBINT testint;
STATUS rc;
int i, iresults;
char teststr[1024];
int rows_in_buffer, limit_rows;
const int buffer_count = 10;
const int rows_to_add = 50;
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, "t0002");
fprintf(stdout, "About to open %s..%s\n", SERVER, DATABASE);
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
fprintf(stdout, "Setting row buffer to 10 rows\n");
#ifdef MICROSOFT_DBLIB
dbsetopt(dbproc, DBBUFFER, "10");
#else
dbsetopt(dbproc, DBBUFFER, "10", 0);
#endif
sql_cmd(dbproc); /* drop table if exists */
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
if (dbresults(dbproc) != NO_MORE_RESULTS) {
fprintf(stdout, "Failed: dbresults call after NO_MORE_RESULTS should return NO_MORE_RESULTS.\n");
failed = 1;
}
sql_cmd(dbproc); /* create table */
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
for (i = 1; i <= rows_to_add; i++) {
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
sql_cmd(dbproc); /* two result sets */
dbsqlexec(dbproc);
for (iresults=1; iresults <= 2; iresults++ ) {
fprintf(stdout, "fetching resultset %i\n", iresults);
if (dbresults(dbproc) != SUCCEED) {
fprintf(stderr, "Was expecting a result set %d.\n", iresults);
if( iresults == 2 )
fprintf(stderr, "Buffering with multiple resultsets is broken.\n");
exit(1);
}
rows_in_buffer = 0;
for (i = 1; i <= dbnumcols(dbproc); i++)
printf("col %d is [%s]\n", i, dbcolname(dbproc, i));
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
/* Fetch a result set */
/* Second resultset stops at row 46 */
limit_rows = rows_to_add - (iresults == 2 ? 4 : 0);
for (i=0; i < limit_rows;) {
fprintf(stdout, "clearing %d rows from buffer\n", rows_in_buffer ? buffer_count - 1 : buffer_count);
#ifdef MICROSOFT_DBLIB
if (i == 0) {
rc = dbnextrow(dbproc);
assert(rc == REG_ROW);
++i;
rows_in_buffer = 1;
}
#endif
dbclrbuf(dbproc, buffer_count);
rows_in_buffer = rows_in_buffer ? 1 : 0;
do {
int rc;
i++;
if (REG_ROW != (rc = dbnextrow(dbproc))) {
failed = 1;
fprintf(stderr, "Failed: Expected a row (%s:%d)\n", __FILE__, __LINE__);
if (rc == BUF_FULL)
fprintf(stderr, "Failed: dbnextrow returned BUF_FULL (%d). Fix dbclrbuf.\n", rc);
exit(1);
}
++rows_in_buffer;
verify(i, testint, teststr);
} while (rows_in_buffer < buffer_count && i < limit_rows);
if (rows_in_buffer == buffer_count) {
/* The buffer should be full */
assert(BUF_FULL == dbnextrow(dbproc));
}
}
if (iresults == 1) {
fprintf(stdout, "clearing %d rows from buffer\n", buffer_count);
dbclrbuf(dbproc, buffer_count);
while (dbnextrow(dbproc) != NO_MORE_ROWS) {
abort(); /* All rows were read: should not enter loop */
}
}
}
printf("\n");
/*
* Now test the buffered rows.
* Should be operating on rows 37-46 of 2nd resultset
*/
rc = dbgetrow(dbproc, 1);
if(rc != NO_MORE_ROWS) /* row 1 is not among the 31-40 in the buffer */
fprintf(stderr, "Failed: dbgetrow returned %d.\n", rc);
assert(rc == NO_MORE_ROWS);
rc = dbgetrow(dbproc, 37);
if(rc != REG_ROW)
fprintf(stderr, "Failed: dbgetrow returned %d.\n", rc);
assert(rc == REG_ROW);
verify(37, testint, teststr); /* first buffered row should be 37 */
rc = dbnextrow(dbproc);
if(rc != REG_ROW)
fprintf(stderr, "Failed: dbgetrow returned %d.\n", rc);
assert(rc == REG_ROW);
verify(38, testint, teststr); /* next buffered row should be 38 */
rc = dbgetrow(dbproc, 11);
assert(rc == NO_MORE_ROWS); /* only 10 (not 11) rows buffered */
rc = dbgetrow(dbproc, 46);
assert(rc == REG_ROW);
verify(46, testint, teststr); /* last buffered row should be 46 */
/* Attempt dbnextrow when buffer has no space (10 out of 10 in use). */
rc = dbnextrow(dbproc);
assert(rc == BUF_FULL);
dbclrbuf(dbproc, 3); /* remove rows 37, 38, and 39 */
rc = dbnextrow(dbproc);
assert(rc == REG_ROW);
verify(47, testint, teststr); /* fetch row from database, should be 47 */
rc = dbnextrow(dbproc);
assert(rc == REG_ROW);
verify(48, testint, teststr); /* fetch row from database, should be 48 */
/* buffer contains 8 rows (40-47) try removing 10 rows */
dbclrbuf(dbproc, buffer_count);
while (dbnextrow(dbproc) != NO_MORE_ROWS) {
/* waste rows 49-50 */
}
dbclose(dbproc); /* close while buffer not cleared: OK */
dbexit();
fprintf(stdout, "%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
DBINT testint;
STATUS rc;
int i, iresults;
char teststr[1024];
const int buffer_count = 10;
const int rows_to_add = 50;
const char tablename[] = "#dblib0002";
const char drop_if_exists[] = "if exists ( select 1 "
"from tempdb..sysobjects "
"where id = object_id('tempdb..%s') )\n"
"\tdrop table %s\n";
set_malloc_options();
read_login_info(argc, argv);
fprintf(stdout, "Start\n");
add_bread_crumb();
/* Fortify_EnterScope(); */
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, "t0002");
fprintf(stdout, "About to open %s..%s\n", SERVER, DATABASE);
add_bread_crumb();
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
add_bread_crumb();
dbloginfree(login);
add_bread_crumb();
fprintf(stdout, "Setting row buffer to 10 rows\n");
#ifdef MICROSOFT_DBLIB
dbsetopt(dbproc, DBBUFFER, "10");
#else
dbsetopt(dbproc, DBBUFFER, "10", 0);
#endif
add_bread_crumb();
add_bread_crumb();
fprintf(stdout, drop_if_exists, tablename, tablename);
dbfcmd(dbproc, drop_if_exists, tablename, tablename);
add_bread_crumb();
dbsqlexec(dbproc);
add_bread_crumb();
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
if (dbresults(dbproc) != NO_MORE_RESULTS) {
fprintf(stdout, "Failed: dbresults call after NO_MORE_RESULTS should return NO_MORE_RESULTS.\n");
failed = 1;
}
add_bread_crumb();
fprintf(stdout, "create table %s (i int not null, s char(10) not null)\n", tablename);
dbfcmd(dbproc, "create table %s (i int not null, s char(10) not null)", tablename);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "insert into %s [%d rows]\n", tablename, rows_to_add);
for (i = 1; i <= rows_to_add; i++) {
char cmd[1024];
sprintf(cmd, "insert into %s values (%d, 'row %03d')", tablename, i, i);
dbcmd(dbproc, cmd);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
fprintf(stdout, "select * from %s order by i\n", tablename);
dbfcmd(dbproc, "select * from %s order by i\n", tablename);
dbfcmd(dbproc, "select * from %s order by i\n", tablename); /* two result sets */
dbsqlexec(dbproc);
add_bread_crumb();
for (iresults=1; iresults <= 2; iresults++ ) {
fprintf(stdout, "fetching resultset %i\n", iresults);
if (dbresults(dbproc) != SUCCEED) {
add_bread_crumb();
fprintf(stderr, "Was expecting a result set %d.\n", iresults);
if( iresults == 2 )
fprintf(stderr, "Buffering with multiple resultsets is broken.\n");
exit(1);
}
add_bread_crumb();
for (i = 1; i <= dbnumcols(dbproc); i++) {
add_bread_crumb();
printf("col %d is [%s]\n", i, dbcolname(dbproc, i));
add_bread_crumb();
}
add_bread_crumb();
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
add_bread_crumb();
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
add_bread_crumb();
/* Fetch a result set */
/* Second resultset stops at row 40 */
for (i=0; i < rows_to_add - (iresults == 2 ? buffer_count : 0);) {
fprintf(stdout, "clearing %d rows from buffer\n", buffer_count);
dbclrbuf(dbproc, buffer_count);
do {
int rc;
i++;
add_bread_crumb();
if (REG_ROW != (rc = dbnextrow(dbproc))) {
failed = 1;
fprintf(stderr, "Failed: Expected a row (%s:%d)\n", __FILE__, __LINE__);
if (rc == BUF_FULL)
fprintf(stderr, "Failed: dbnextrow returned BUF_FULL (%d). Fix dbclrbuf.\n", rc);
exit(1);
}
add_bread_crumb();
verify(i, testint, teststr);
} while (i % buffer_count);
if (iresults == 1 && i == rows_to_add) {
/* The buffer should be full */
assert(BUF_FULL == dbnextrow(dbproc));
}
}
if (iresults == 1) {
fprintf(stdout, "clearing %d rows from buffer\n", buffer_count);
dbclrbuf(dbproc, buffer_count);
while (dbnextrow(dbproc) != NO_MORE_ROWS) {
abort(); /* All rows were read: should not enter loop */
}
}
}
/*
* Now test the buffered rows.
* Should be operating on rows 31-40 of 2nd resultset
*/
rc = dbgetrow(dbproc, 1);
add_bread_crumb();
if(rc != NO_MORE_ROWS) /* row 1 is not among the 31-40 in the buffer */
fprintf(stderr, "Failed: dbgetrow returned %d.\n", rc);
assert(rc == NO_MORE_ROWS);
rc = dbgetrow(dbproc, 31);
add_bread_crumb();
if(rc != REG_ROW)
fprintf(stderr, "Failed: dbgetrow returned %d.\n", rc);
assert(rc == REG_ROW);
verify(31, testint, teststr); /* first buffered row should be 31 */
rc = dbnextrow(dbproc);
add_bread_crumb();
if(rc != REG_ROW)
fprintf(stderr, "Failed: dbgetrow returned %d.\n", rc);
assert(rc == REG_ROW);
verify(32, testint, teststr); /* next buffered row should be 32 */
rc = dbgetrow(dbproc, 11);
add_bread_crumb();
assert(rc == NO_MORE_ROWS); /* only 10 (not 11) rows buffered */
rc = dbgetrow(dbproc, 40);
add_bread_crumb();
assert(rc == REG_ROW);
verify(40, testint, teststr); /* last buffered row should be 40 */
/* Attempt dbnextrow when buffer has no space (10 out of 10 in use). */
rc = dbnextrow(dbproc);
assert(rc == BUF_FULL);
dbclrbuf(dbproc, 3); /* remove rows 31, 32, and 33 */
rc = dbnextrow(dbproc);
add_bread_crumb();
assert(rc == REG_ROW);
verify(41, testint, teststr); /* fetch row from database, should be 41 */
rc = dbnextrow(dbproc);
add_bread_crumb();
assert(rc == REG_ROW);
verify(42, testint, teststr); /* fetch row from database, should be 42 */
/* buffer contains 9 rows (34-42) try removing 10 rows */
dbclrbuf(dbproc, buffer_count);
while (dbnextrow(dbproc) != NO_MORE_ROWS) {
/* waste rows 43-50 */
}
dbclose(dbproc); /* close while buffer not cleared: OK */
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;
}
int
main(int argc, char **argv)
{
RETCODE rc;
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);
printf("Starting %s\n", argv[0]);
/* Fortify_EnterScope(); */
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
printf("About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0003");
DBSETLHOST(login, "ntbox.dntis.ro");
printf("About to open\n");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
#ifdef MICROSOFT_DBLIB
dbsetopt(dbproc, DBBUFFER, "100");
#else
dbsetopt(dbproc, DBBUFFER, "100", 0);
#endif
printf("creating table\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
printf("insert\n");
for (i = 1; i < rows_to_add; i++) {
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
printf("select\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
failed = 1;
printf("Was expecting a result set.");
exit(1);
}
for (i = 1; i <= dbnumcols(dbproc); i++)
printf("col %d is %s\n", i, dbcolname(dbproc, i));
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
for (i = 1; i < rows_to_add; i++) {
char expected[1024];
sprintf(expected, "row %03d", i);
if (i % 100 == 0) {
dbclrbuf(dbproc, 100);
}
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;
printf("Failed. Expected s to be |%s|, was |%s|\n", expected, teststr);
abort();
}
printf("Read a row of data -> %d %s\n", (int) testint, teststr);
}
dbclrbuf(dbproc, 1);
rc = dbnextrow(dbproc);
if (rc != NO_MORE_ROWS) {
failed = 1;
fprintf(stderr, "Was expecting no more rows. (rc=%d)\n", rc);
exit(1);
}
dbexit();
printf("%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
