int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
RETPARAM save_param, save_varchar_tds7_param, save_nvarchar_tds7_param;
char teststr[8000+1], abbrev_data[10+3+1], *output;
char *retname = NULL;
int i, failed = 0;
int rettype = 0, retlen = 0, return_status = 0;
char proc[] = "#t0022";
char *proc_name = proc;
int num_resultset = 0, num_empty_resultset = 0;
int num_params = 6;
static const char dashes30[] = "------------------------------";
static const char *dashes5 = dashes30 + (sizeof(dashes30) - 5),
*dashes20 = dashes30 + (sizeof(dashes30) - 20);
RETCODE erc, row_code;
set_malloc_options();
memset(&save_param, 0, sizeof(save_param));
memset(&save_varchar_tds7_param, 0, sizeof(save_varchar_tds7_param));
memset(&save_nvarchar_tds7_param, 0, sizeof(save_nvarchar_tds7_param));
read_login_info(argc, argv);
printf("Starting %s\n", argv[0]);
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
printf("About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "rpc");
dberrhandle(ignore_err_handler);
DBSETLPACKET(login, -1);
dberrhandle(syb_err_handler);
printf("About to open %s.%s\n", SERVER, DATABASE);
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
printf("Check if server support long identifiers\n");
sql_cmd(dbproc);
i = 103;
dbsetuserdata(dbproc, (BYTE*) &i);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS)
while (dbnextrow(dbproc) != NO_MORE_ROWS)
continue;
dbsetuserdata(dbproc, NULL);
if (i == 0) {
fprintf(stderr, "This server does not support long identifiers\n");
dbexit();
return 0;
}
dberrhandle(ignore_err_handler);
dbmsghandle(ignore_msg_handler);
printf("trying to create a temporary stored procedure\n");
if (FAIL == init_proc(dbproc, proc_name)) {
num_params = 4;
printf("trying to create a permanent stored procedure\n");
if (FAIL == init_proc(dbproc, ++proc_name))
exit(EXIT_FAILURE);
}
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
printf("Created procedure %s\n", proc_name);
/* set up and send the rpc */
printf("executing dbrpcinit\n");
erc = dbrpcinit(dbproc, proc_name, 0); /* no options */
if (erc == FAIL) {
fprintf(stderr, "Failed line %d: dbrpcinit\n", __LINE__);
failed = 1;
}
for (pb = bindings, i = 0; pb < bindings + sizeof(bindings)/sizeof(bindings[0]); pb++, i++) {
printf("executing dbrpcparam for %s\n", pb->name);
if (num_params == 4 && (i == 3 || i == 4))
continue;
if ((erc = dbrpcparam(dbproc, pb->name, pb->status, pb->type, pb->maxlen, pb->datalen, pb->value)) == FAIL) {
fprintf(stderr, "Failed line %d: dbrpcparam\n", __LINE__);
failed++;
}
}
printf("executing dbrpcsend\n");
param_data5 = 0x11223344;
erc = dbrpcsend(dbproc);
if (erc == FAIL) {
fprintf(stderr, "Failed line %d: dbrpcsend\n", __LINE__);
exit(1);
}
/* wait for it to execute */
printf("executing dbsqlok\n");
erc = dbsqlok(dbproc);
if (erc == FAIL) {
fprintf(stderr, "Failed line %d: dbsqlok\n", __LINE__);
exit(1);
}
/* retrieve outputs per usual */
printf("fetching results\n");
while ((erc = dbresults(dbproc)) != NO_MORE_RESULTS) {
printf("fetched resultset %d %s:\n", 1+num_resultset, erc==SUCCEED? "successfully":"unsuccessfully");
if (erc == SUCCEED) {
const int ncol = dbnumcols(dbproc);
int empty_resultset = 1, c;
enum {buflen=1024, nbuf=5};
char bound_buffers[nbuf][buflen] = { "one", "two", "three", "four", "five" };
++num_resultset;
for( c=0; c < ncol && c < nbuf; c++ ) {
printf("column %d (%s) is %d wide, ", c+1, dbcolname(dbproc, c+1), colwidth(dbproc, c+1));
printf("buffer initialized to '%s'\n", bound_buffers[c]);
}
for( c=0; c < ncol && c < nbuf; c++ ) {
erc = dbbind(dbproc, c+1, STRINGBIND, 0, (BYTE *) bound_buffers[c]);
if (erc == FAIL) {
fprintf(stderr, "Failed line %d: dbbind\n", __LINE__);
exit(1);
}
printf("%-*s ", colwidth(dbproc, c+1), dbcolname(dbproc, c+1));
}
printf("\n");
while ((row_code = dbnextrow(dbproc)) != NO_MORE_ROWS) {
empty_resultset = 0;
if (row_code == REG_ROW) {
int c;
for( c=0; c < ncol && c < nbuf; c++ ) {
printf("%-*s ", colwidth(dbproc, c+1), bound_buffers[c]);
}
printf("\n");
} else {
/* not supporting computed rows in this unit test */
failed = 1;
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
}
printf("row count %d\n", (int) dbcount(dbproc));
printf("hasretstatus %d\n", dbhasretstat(dbproc));
if (num_resultset == 4 && !dbhasretstat(dbproc)) {
fprintf(stderr, "dbnextrow should have set hasretstatus after last recordset\n");
exit(1);
}
if (empty_resultset)
++num_empty_resultset;
} else {
fprintf(stderr, "Expected a result set.\n");
exit(1);
}
} /* while dbresults */
/* check return status */
printf("retrieving return status...\n");
if (dbhasretstat(dbproc) == TRUE) {
printf("%d\n", return_status = dbretstatus(dbproc));
} else {
printf("none\n");
}
/*
* Check output parameter values
*/
if (dbnumrets(dbproc) != num_params) { /* dbnumrets missed something */
fprintf(stderr, "Expected %d output parameters.\n", num_params);
exit(1);
}
printf("retrieving output parameters...\n");
printf("%-5s %-20s %5s %6s %-30s\n", "param", "name", "type", "length", "data");
printf("%-5s %-20s %5s %5s- %-30s\n", dashes5, dashes20, dashes5, dashes5, dashes30);
for (i = 1; i <= dbnumrets(dbproc); i++) {
retname = dbretname(dbproc, i);
rettype = dbrettype(dbproc, i);
retlen = dbretlen(dbproc, i);
dbconvert(dbproc, rettype, dbretdata(dbproc, i), retlen, SYBVARCHAR, (BYTE*) teststr, -1);
if(retlen <= 10) {
output = teststr;
} else {
memcpy(abbrev_data, teststr, 10);
sprintf(&abbrev_data[10], "...");
output = abbrev_data;
}
printf("%-5d %-20s %5d %6d %-30s\n", i, retname, rettype, retlen, output);
save_retparam(&save_param, retname, teststr, rettype, retlen);
if (i == 4) {
save_retparam(&save_varchar_tds7_param, retname, teststr, rettype, retlen);
}
if (i == 5) {
save_retparam(&save_nvarchar_tds7_param, retname, teststr, rettype, retlen);
}
}
/*
* Test the last parameter for expected outcome
*/
if ((save_param.name == NULL) || strcmp(save_param.name, bindings[5].name)) {
fprintf(stderr, "Expected retname to be '%s', got ", bindings[5].name);
if (save_param.name == NULL)
fprintf(stderr, "<NULL> instead.\n");
else
fprintf(stderr, "'%s' instead.\n", save_param.name);
exit(1);
}
if (strcmp(save_param.value, "3")) {
fprintf(stderr, "Expected retdata to be 3.\n");
exit(1);
}
if (save_param.type != SYBINT4) {
fprintf(stderr, "Expected rettype to be SYBINT4 was %d.\n", save_param.type);
exit(1);
}
if (save_param.len != 4) {
fprintf(stderr, "Expected retlen to be 4.\n");
exit(1);
}
if (num_params == 6) {
/*
* Test name, size, contents of the VARCHAR(8000) output parameter
*/
if ((save_varchar_tds7_param.name == NULL) || strcmp(save_varchar_tds7_param.name, bindings[3].name)) {
fprintf(stderr, "Expected retname to be '%s', got ", bindings[3].name);
if (save_varchar_tds7_param.name == NULL)
fprintf(stderr, "<NULL> instead.\n");
else
fprintf(stderr, "'%s' instead.\n", save_varchar_tds7_param.name);
exit(1);
}
if (save_varchar_tds7_param.type != SYBVARCHAR) {
fprintf(stderr, "Expected rettype to be SYBVARCHAR was %d.\n", save_varchar_tds7_param.type);
exit(1);
}
if (save_varchar_tds7_param.len != 8000) {
fprintf(stderr, "Expected retlen to be 8000 was %d.\n", save_varchar_tds7_param.len);
exit(1);
}
/*
* Test name, size, contents of the NVARCHAR(4000) output parameter
*/
if ((save_nvarchar_tds7_param.name == NULL) || strcmp(save_nvarchar_tds7_param.name, bindings[4].name)) {
fprintf(stderr, "Expected retname to be '%s', got ", bindings[4].name);
if (save_varchar_tds7_param.name == NULL)
fprintf(stderr, "<NULL> instead.\n");
else
fprintf(stderr, "'%s' instead.\n", save_nvarchar_tds7_param.name);
exit(1);
}
if (save_nvarchar_tds7_param.len != 4000) {
fprintf(stderr, "Expected retlen to be 4000 was %d.\n", save_nvarchar_tds7_param.len);
exit(1);
}
}
if(42 != return_status) {
fprintf(stderr, "Expected status to be 42.\n");
exit(1);
}
printf("Good: Got 6 output parameters and 1 return status of %d.\n", return_status);
/* Test number of result sets */
if (num_resultset != 4) {
fprintf(stderr, "Expected 4 resultset got %d.\n", num_resultset);
exit(1);
}
if (num_empty_resultset != 1) {
fprintf(stderr, "Expected an empty resultset got %d.\n", num_empty_resultset);
exit(1);
}
printf("Good: Got %d resultsets and %d empty resultset.\n", num_resultset, num_empty_resultset);
printf("Dropping procedure\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
dbexit();
printf("%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
free_retparam(&save_param);
free_retparam(&save_varchar_tds7_param);
free_retparam(&save_nvarchar_tds7_param);
return failed ? 1 : 0;
}
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;
}
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);
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
RETPARAM save_param;
int i, r;
char teststr[1024];
int failed = 0;
char *retname = NULL;
int rettype = 0, retlen = 0;
int return_status = 0;
char proc[] = "#t0022",
param0[] = "@null_input",
param1[] = "@first_type",
param2[] = "@nullout",
param3[] = "@nrows",
param4[] = "@c";
char *proc_name = proc;
char param_data1[64];
int param_data2;
int param_data3;
RETCODE erc, row_code;
int num_resultset = 0;
int num_empty_resultset = 0;
static const char dashes5[] = "-----",
dashes15[] = "---------------",
dashes30[] = "------------------------------";
set_malloc_options();
memset(&save_param, 0, sizeof(save_param));
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");
dberrhandle(ignore_err_handler);
DBSETLPACKET(login, -1);
dberrhandle(syb_err_handler);
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();
add_bread_crumb();
dberrhandle(ignore_err_handler);
dbmsghandle(ignore_msg_handler);
printf("trying to create a temporary stored procedure\n");
if (FAIL == init_proc(dbproc, proc_name)) {
printf("trying to create a permanent stored procedure\n");
if (FAIL == init_proc(dbproc, ++proc_name))
exit(EXIT_FAILURE);
}
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "Created procedure %s\n", proc_name);
/* set up and send the rpc */
printf("executing dbrpcinit\n");
erc = dbrpcinit(dbproc, proc_name, 0); /* no options */
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcinit\n");
failed = 1;
}
printf("executing dbrpcparam\n");
erc = dbrpcparam(dbproc, param0, DBRPCRETURN, SYBCHAR, /*maxlen= */ -1, /* datlen= */ 0, NULL);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcparam\n");
failed = 1;
}
printf("executing dbrpcparam\n");
erc = dbrpcparam(dbproc, param1, DBRPCRETURN, SYBCHAR, /*maxlen= */ sizeof(param_data1), /* datlen= */ 0, (BYTE *) & param_data1);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcparam\n");
failed = 1;
}
printf("executing dbrpcparam\n");
erc = dbrpcparam(dbproc, param2, DBRPCRETURN, SYBINT4, /*maxlen= */ -1, /* datalen= */ 0, (BYTE *) & param_data2);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcparam\n");
failed = 1;
}
printf("executing dbrpcparam\n");
erc = dbrpcparam(dbproc, param3, DBRPCRETURN, SYBINT4, /*maxlen= */ -1, /* datalen= */ -1, (BYTE *) & param_data3);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcparam\n");
failed = 1;
}
/* test for strange parameters using input */
printf("executing dbrpcparam\n");
erc = dbrpcparam(dbproc, param4, 0, SYBVARCHAR, /*maxlen= */ 0, /* datalen= */ 0, NULL);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcparam\n");
failed = 1;
}
printf("executing dbrpcsend\n");
param_data3 = 0x11223344;
erc = dbrpcsend(dbproc);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcsend\n");
exit(1);
}
/* wait for it to execute */
printf("executing dbsqlok\n");
erc = dbsqlok(dbproc);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbsqlok\n");
exit(1);
}
add_bread_crumb();
/* retrieve outputs per usual */
r = 0;
while ((erc = dbresults(dbproc)) != NO_MORE_RESULTS) {
if (erc == SUCCEED) {
const int ncols = dbnumcols(dbproc);
int empty_resultset = 1;
++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) {
empty_resultset = 0;
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);
}
}
printf("row count %d\n", (int) dbcount(dbproc));
if (empty_resultset)
++num_empty_resultset;
} else {
add_bread_crumb();
fprintf(stderr, "Expected a result set.\n");
exit(1);
}
} /* while dbresults */
/* check return status */
printf("retrieving return status...\n");
if (dbhasretstat(dbproc) == TRUE) {
printf("%d\n", return_status = dbretstatus(dbproc));
} else {
printf("none\n");
}
/*
* Check output parameter values
*/
if (dbnumrets(dbproc) < 4) { /* dbnumrets missed something */
fprintf(stderr, "Expected 4 output parameters.\n");
exit(1);
}
printf("retrieving output parameters...\n");
printf("%-5s %-15s %5s %6s %-30s\n", "param", "name", "type", "length", "data");
printf("%-5s %-15s %5s %5s- %-30s\n", dashes5, dashes15, dashes5, dashes5, dashes30);
for (i = 1; i <= dbnumrets(dbproc); i++) {
add_bread_crumb();
retname = dbretname(dbproc, i);
rettype = dbrettype(dbproc, i);
retlen = dbretlen(dbproc, i);
dbconvert(dbproc, rettype, dbretdata(dbproc, i), retlen, SYBVARCHAR, (BYTE*) teststr, -1);
printf("%-5d %-15s %5d %6d %-30s\n", i, retname, rettype, retlen, teststr);
add_bread_crumb();
save_retparam(&save_param, retname, teststr, rettype, retlen);
}
/*
* Test the last parameter for expected outcome
*/
if ((save_param.name == NULL) || strcmp(save_param.name, param3)) {
fprintf(stderr, "Expected retname to be '%s', got ", param3);
if (save_param.name == NULL)
fprintf(stderr, "<NULL> instead.\n");
else
fprintf(stderr, "'%s' instead.\n", save_param.name);
exit(1);
}
if (strcmp(save_param.value, "3")) {
fprintf(stderr, "Expected retdata to be 3.\n");
exit(1);
}
if (save_param.type != SYBINT4) {
fprintf(stderr, "Expected rettype to be SYBINT4 was %d.\n", save_param.type);
exit(1);
}
if (save_param.len != 4) {
fprintf(stderr, "Expected retlen to be 4.\n");
exit(1);
}
if(42 != return_status) {
fprintf(stderr, "Expected status to be 42.\n");
exit(1);
}
printf("Good: Got 4 output parameters and 1 return status of %d.\n", return_status);
/* Test number of result sets */
if (num_resultset != 3) {
fprintf(stderr, "Expected 3 resultset got %d.\n", num_resultset);
exit(1);
}
if (num_empty_resultset != 1) {
fprintf(stderr, "Expected an empty resultset got %d.\n", num_empty_resultset);
exit(1);
}
printf("Good: Got %d resultsets and %d empty resultset.\n", num_resultset, num_empty_resultset);
add_bread_crumb();
fprintf(stdout, "Dropping procedure\n");
add_bread_crumb();
sprintf(cmd, "DROP PROCEDURE %s", proc_name);
dbcmd(dbproc, cmd);
add_bread_crumb();
dbsqlexec(dbproc);
add_bread_crumb();
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
add_bread_crumb();
dbexit();
add_bread_crumb();
fprintf(stdout, "dblib %s on %s\n", (failed ? "failed!" : "okay"), __FILE__);
free_bread_crumb();
free(save_param.name);
free(save_param.value);
return failed ? 1 : 0;
}
