static int pdo_dblib_stmt_execute(pdo_stmt_t *stmt)
{
pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
pdo_dblib_db_handle *H = S->H;
RETCODE ret;
dbsetuserdata(H->link, (BYTE*) &S->err);
pdo_dblib_stmt_cursor_closer(stmt);
if (FAIL == dbcmd(H->link, stmt->active_query_string)) {
return 0;
}
if (FAIL == dbsqlexec(H->link)) {
return 0;
}
ret = pdo_dblib_stmt_next_rowset(stmt);
stmt->row_count = DBCOUNT(H->link);
stmt->column_count = dbnumcols(H->link);
return 1;
}
CDBL_RowResult::CDBL_RowResult(CDBL_Connection& conn,
DBPROCESS* cmd,
unsigned int* res_status,
bool need_init) :
CDBL_ResultBase(conn, cmd, res_status)
{
if (!need_init)
return;
unsigned int col_num = Check(dbnumcols(cmd));
m_CmdNum = DBCURCMD(cmd);
m_ColFmt = new SDBL_ColDescr[col_num];
for (unsigned int n = 0; n < col_num; n++) {
m_ColFmt[n].max_length = Check(dbcollen(GetCmd(), n + 1));
m_ColFmt[n].data_type = GetDataType(n + 1);
const char* s = Check(dbcolname(GetCmd(), n + 1));
m_ColFmt[n].col_name = s ? s : "";
m_CachedRowInfo.Add(
s ? s : "",
Check(dbcollen(GetCmd(), n + 1)),
GetDataType(n + 1)
);
}
}
static int
start_query(DBPROCESS * dbproc)
{
int i;
if (SUCCEED != sql_cmd(dbproc)) {
return 0;
}
if (SUCCEED != dbsqlexec(dbproc)) {
return 0;
}
add_bread_crumb();
if (dbresults(dbproc) != SUCCEED) {
add_bread_crumb();
return 0;
}
add_bread_crumb();
for (i = 1; i <= dbnumcols(dbproc); i++) {
add_bread_crumb();
printf("col %d is named \"%s\"\n", i, dbcolname(dbproc, i));
add_bread_crumb();
}
return 1;
}
static int pdo_dblib_stmt_next_rowset_no_cancel(pdo_stmt_t *stmt)
{
pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
pdo_dblib_db_handle *H = S->H;
RETCODE ret;
int num_fields;
do {
ret = dbresults(H->link);
num_fields = dbnumcols(H->link);
} while (H->skip_empty_rowsets && num_fields <= 0 && ret == SUCCEED);
if (FAIL == ret) {
pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO_DBLIB: dbresults() returned FAIL");
return 0;
}
if (NO_MORE_RESULTS == ret) {
return 0;
}
if (H->skip_empty_rowsets && num_fields <= 0) {
return 0;
}
stmt->row_count = DBCOUNT(H->link);
stmt->column_count = num_fields;
return 1;
}
static zend_long dblib_handle_doer(pdo_dbh_t *dbh, const char *sql, size_t sql_len)
{
pdo_dblib_db_handle *H = (pdo_dblib_db_handle *)dbh->driver_data;
RETCODE ret, resret;
dbsetuserdata(H->link, (BYTE*)&H->err);
if (FAIL == dbcmd(H->link, sql)) {
return -1;
}
if (FAIL == dbsqlexec(H->link)) {
return -1;
}
resret = dbresults(H->link);
if (resret == FAIL) {
return -1;
}
ret = dbnextrow(H->link);
if (ret == FAIL) {
return -1;
}
if (dbnumcols(H->link) <= 0) {
return DBCOUNT(H->link);
}
/* throw away any rows it might have returned */
dbcanquery(H->link);
return DBCOUNT(H->link);
}
static int
select_rows(DBPROCESS * dbproc, int bind_type)
{
char teststr[1024];
char teststr2[1024];
char testvstr[1024];
DBINT testint;
DBINT i;
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));
}
if (SUCCEED != dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint)) {
fprintf(stderr, "Had problem with bind\n");
return 1;
}
if (SUCCEED != dbbind(dbproc, 2, bind_type, 0, (BYTE *) teststr)) {
fprintf(stderr, "Had problem with bind\n");
return 1;
}
if (SUCCEED != dbbind(dbproc, 3, bind_type, 0, (BYTE *) teststr2)) {
fprintf(stderr, "Had problem with bind\n");
return 1;
}
if (SUCCEED != dbbind(dbproc, 4, bind_type, 0, (BYTE *) testvstr)) {
fprintf(stderr, "Had problem with bind\n");
return 1;
}
i = 0;
while (dbnextrow(dbproc) == REG_ROW) {
i++;
if (testint != i) {
printf("Failed. Expected i to be |%d|, was |%d|\n", testint, i);
return 1;
}
printf("c: %s$\n", teststr);
printf("c2: %s$\n", teststr2);
printf("vc: %s$\n", testvstr);
if (bind_type == STRINGBIND) {
} else {
}
}
return 0;
}
int
main(int argc, char *argv[])
{
LOGINREC *login;
DBPROCESS *dbproc;
int ret_code;
int num_cols;
int num_res;
set_malloc_options();
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, "t0012");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE)) {
dbuse(dbproc, DATABASE);
}
dbloginfree(login);
printf("After logon\n");
/* select */
sql_cmd(dbproc);
dbsqlexec(dbproc);
num_res = 0;
while ((ret_code = dbresults(dbproc)) == SUCCEED) {
num_cols = dbnumcols(dbproc);
printf("Result %d has %d columns\n", num_res, num_cols);
if (!(num_res % 2) && num_cols)
set_failed();
while(dbnextrow(dbproc) != NO_MORE_ROWS) {};
num_res++;
}
if (ret_code == FAIL)
set_failed();
dbclose(dbproc);
dbexit();
printf("%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
static VALUE rb_tinytds_result_fields(VALUE self) {
RETCODE dbsqlok_rc, dbresults_rc;
VALUE fields_processed;
GET_RESULT_WRAPPER(self);
dbsqlok_rc = rb_tinytds_result_ok_helper(rwrap->client);
dbresults_rc = rb_tinytds_result_dbresults_retcode(self);
fields_processed = rb_ary_entry(rwrap->fields_processed, rwrap->number_of_results);
if ((dbsqlok_rc == SUCCEED) && (dbresults_rc == SUCCEED) && (fields_processed == Qnil)) {
/* Default query options. */
int symbolize_keys = 0;
VALUE qopts = rb_iv_get(self, "@query_options");
if (rb_hash_aref(qopts, sym_symbolize_keys) == Qtrue)
symbolize_keys = 1;
/* Set number_of_fields count for this result set. */
rwrap->number_of_fields = dbnumcols(rwrap->client);
if (rwrap->number_of_fields > 0) {
/* Create fields for this result set. */
unsigned int fldi = 0;
VALUE fields = rb_ary_new2(rwrap->number_of_fields);
for (fldi = 0; fldi < rwrap->number_of_fields; fldi++) {
char *colname = dbcolname(rwrap->client, fldi+1);
VALUE field = symbolize_keys ? rb_str_intern(ENCODED_STR_NEW2(colname)) : rb_obj_freeze(ENCODED_STR_NEW2(colname));
rb_ary_store(fields, fldi, field);
}
/* Store the fields. */
if (rwrap->number_of_results == 0) {
rwrap->fields = fields;
} else if (rwrap->number_of_results == 1) {
VALUE multi_rs_fields = rb_ary_new();
rb_ary_store(multi_rs_fields, 0, rwrap->fields);
rb_ary_store(multi_rs_fields, 1, fields);
rwrap->fields = multi_rs_fields;
} else {
rb_ary_store(rwrap->fields, rwrap->number_of_results, fields);
}
}
rb_ary_store(rwrap->fields_processed, rwrap->number_of_results, Qtrue);
}
return rwrap->fields;
}
static int pdo_dblib_stmt_next_rowset(pdo_stmt_t *stmt)
{
pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
pdo_dblib_db_handle *H = S->H;
RETCODE ret;
ret = dbresults(H->link);
if (FAIL == ret) {
pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO_DBLIB: dbresults() returned FAIL");
return 0;
}
if(NO_MORE_RESULTS == ret) {
return 0;
}
stmt->row_count = DBCOUNT(H->link);
stmt->column_count = dbnumcols(H->link);
return 1;
}
static int
create_target_table(char *sobjname, char *owner, char *dobjname, DBPROCESS * dbsrc, DBPROCESS * dbdest)
{
char ls_command[2048];
int i;
DBINT num_cols;
DBCHAR column_type[33];
DBCOL colinfo;
sprintf(ls_command, "SET FMTONLY ON select * from %s SET FMTONLY OFF", sobjname);
if (dbcmd(dbsrc, ls_command) == FAIL) {
printf("dbcmd failed\n");
return FALSE;
}
if (dbsqlexec(dbsrc) == FAIL) {
printf("table %s not found on SOURCE\n", sobjname);
return FALSE;
}
while (NO_MORE_RESULTS != dbresults(dbsrc));
sprintf(ls_command, "CREATE TABLE %s.%s ", owner, dobjname);
num_cols = dbnumcols(dbsrc);
for (i = 1; i <= num_cols; i++) {
if (dbtablecolinfo(dbsrc, i, &colinfo) != SUCCEED)
return FALSE;
if (i == 1)
strcat(ls_command, "( ");
else
strcat(ls_command, ", ");
strcat(ls_command, colinfo.Name);
strcat(ls_command, " ");
switch (colinfo.Type) {
case SYBINT1:
strcat(ls_command, "tinyint");
break;
case SYBBIT:
strcat(ls_command, "bit");
break;
case SYBINT2:
strcat(ls_command, "smallint");
break;
case SYBINT4:
strcat(ls_command, "int");
break;
case SYBDATETIME:
strcat(ls_command, "datetime");
break;
case SYBDATETIME4:
strcat(ls_command, "smalldatetime");
break;
case SYBREAL:
strcat(ls_command, "real");
break;
case SYBMONEY:
strcat(ls_command, "money");
break;
case SYBMONEY4:
strcat(ls_command, "smallmoney");
break;
case SYBFLT8:
strcat(ls_command, "float");
break;
case SYBDECIMAL:
sprintf(column_type, "decimal(%d,%d)", colinfo.Precision, colinfo.Scale);
strcat(ls_command, column_type);
break;
case SYBNUMERIC:
sprintf(column_type, "numeric(%d,%d)", colinfo.Precision, colinfo.Scale);
strcat(ls_command, column_type);
break;
case SYBCHAR:
sprintf(column_type, "char(%d)", colinfo.MaxLength);
strcat(ls_command, column_type);
break;
case SYBVARCHAR:
sprintf(column_type, "varchar(%d)", colinfo.MaxLength);
strcat(ls_command, column_type);
break;
case SYBTEXT:
strcat(ls_command, "text");
break;
case SYBIMAGE:
strcat(ls_command, "image");
break;
}
if (colinfo.Null == TRUE) {
strcat(ls_command, " NULL");
} else {
strcat(ls_command, " NOT NULL");
}
}
strcat(ls_command, " ) ");
if (dbcmd(dbdest, ls_command) == FAIL) {
printf("dbcmd failed\n");
return FALSE;
}
if (dbsqlexec(dbdest) == FAIL) {
printf("create table on DESTINATION failed\n");
return FALSE;
}
while (NO_MORE_RESULTS != dbresults(dbdest));
return TRUE;
}
/*************************************************************************
*
* Function: sql_num_fields
*
* Purpose: database specific num_fields function. Returns number
* of columns from query
*
*************************************************************************/
static int sql_num_fields(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
{
rlm_sql_freetds_sock *freetds_sock = sqlsocket->conn;
return dbnumcols(freetds_sock->dbproc);
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
int i;
DBINT erc;
RETCODE results_retcode;
int rowcount;
int colcount;
int row_retcode;
set_malloc_options();
read_login_info(argc, argv);
if (argc > 1) {
argc -= optind;
argv += optind;
}
printf("Starting %s\n", argv[0]);
/* Fortify_EnterScope(); */
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
printf("About to logon as \"%s\"\n", USER);
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "wf_dbresults");
if (argc > 1) {
printf("server and login timeout overrides (%s and %s) detected\n", argv[0], argv[1]);
strcpy(SERVER, argv[0]);
i = atoi(argv[1]);
if (i) {
i = dbsetlogintime(i);
printf("dbsetlogintime returned %s.\n", (i == SUCCEED) ? "SUCCEED" : "FAIL");
}
}
printf("About to open \"%s\"\n", SERVER);
dbproc = dbopen(login, SERVER);
if (!dbproc) {
fprintf(stderr, "Unable to connect to %s\n", SERVER);
return 1;
}
dbloginfree(login);
printf("Using database \"%s\"\n", DATABASE);
if (strlen(DATABASE)) {
erc = dbuse(dbproc, DATABASE);
assert(erc == SUCCEED);
}
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
/*
* This test is written to simulate how dblib is used in PDO
* functions are called in the same order they would be if doing
* PDO::query followed by some number of PDO::statement->nextRowset
*/
/*
* First, call everything that happens in PDO::query
* this will return the results of the CREATE TABLE statement
*/
dbcancel(dbproc);
printf("using sql_cmd\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
results_retcode = dbresults(dbproc);
rowcount = DBCOUNT(dbproc);
colcount = dbnumcols(dbproc);
printf("** CREATE TABLE **\n");
printf("RETCODE: %d\n", results_retcode);
printf("ROWCOUNT: %d\n", rowcount);
printf("COLCOUNT: %d\n\n", colcount);
/* check that the results correspond to the create table statement */
assert(results_retcode == SUCCEED);
assert(rowcount == -1);
assert(colcount == 0);
/* now simulate calling nextRowset() for each remaining statement in our batch */
/*
* INSERT
*/
printf("** INSERT **\n");
/* there shouldn't be any rows in this resultset yet, it's still from the CREATE TABLE */
row_retcode = dbnextrow(dbproc);
printf("dbnextrow retcode: %d\n", results_retcode);
assert(row_retcode == NO_MORE_ROWS);
results_retcode = dbresults(dbproc);
rowcount = DBCOUNT(dbproc);
colcount = dbnumcols(dbproc);
printf("RETCODE: %d\n", results_retcode);
printf("ROWCOUNT: %d\n", rowcount);
printf("COLCOUNT: %d\n\n", colcount);
assert(results_retcode == SUCCEED);
assert(rowcount == 3);
assert(colcount == 0);
/*
* SELECT
*/
printf("** SELECT **\n");
/* the rowset is still from the INSERT and should have no rows */
row_retcode = dbnextrow(dbproc);
printf("dbnextrow retcode: %d\n", results_retcode);
assert(row_retcode == NO_MORE_ROWS);
results_retcode = dbresults(dbproc);
rowcount = DBCOUNT(dbproc);
colcount = dbnumcols(dbproc);
printf("RETCODE: %d\n", results_retcode);
printf("ROWCOUNT: %d\n", rowcount);
printf("COLCOUNT: %d\n\n", colcount);
assert(results_retcode == SUCCEED);
assert(rowcount == -1);
assert(colcount == 1);
/* now we expect to find three rows in the rowset */
row_retcode = dbnextrow(dbproc);
printf("dbnextrow retcode: %d\n", row_retcode);
assert(row_retcode == REG_ROW);
row_retcode = dbnextrow(dbproc);
printf("dbnextrow retcode: %d\n", row_retcode);
assert(row_retcode == REG_ROW);
row_retcode = dbnextrow(dbproc);
printf("dbnextrow retcode: %d\n\n", row_retcode);
assert(row_retcode == REG_ROW);
/*
* UPDATE
*/
printf("** UPDATE **\n");
/* check that there are no rows left, then we'll get the results from the UPDATE */
row_retcode = dbnextrow(dbproc);
printf("dbnextrow retcode: %d\n", row_retcode);
assert(row_retcode == NO_MORE_ROWS);
results_retcode = dbresults(dbproc);
rowcount = DBCOUNT(dbproc);
colcount = dbnumcols(dbproc);
printf("RETCODE: %d\n", results_retcode);
printf("ROWCOUNT: %d\n", rowcount);
printf("COLCOUNT: %d\n\n", colcount);
assert(results_retcode == SUCCEED);
assert(rowcount == 3);
/*assert(colcount == 0); TODO: why does an update get a column? */
/*
* SELECT
*/
printf("** SELECT **\n");
row_retcode = dbnextrow(dbproc);
printf("dbnextrow retcode: %d\n", row_retcode);
assert(row_retcode == NO_MORE_ROWS);
results_retcode = dbresults(dbproc);
rowcount = DBCOUNT(dbproc);
colcount = dbnumcols(dbproc);
printf("RETCODE: %d\n", results_retcode);
printf("ROWCOUNT: %d\n", rowcount);
printf("COLCOUNT: %d\n\n", colcount);
assert(results_retcode == SUCCEED);
assert(rowcount == -1);
assert(colcount == 1);
/* now we expect to find three rows in the rowset again */
row_retcode = dbnextrow(dbproc);
printf("dbnextrow retcode: %d\n", row_retcode);
assert(row_retcode == REG_ROW);
row_retcode = dbnextrow(dbproc);
printf("dbnextrow retcode: %d\n", row_retcode);
assert(row_retcode == REG_ROW);
row_retcode = dbnextrow(dbproc);
printf("dbnextrow retcode: %d\n\n", row_retcode);
assert(row_retcode == REG_ROW);
/*
* DROP
*/
printf("** DROP **\n");
row_retcode = dbnextrow(dbproc);
printf("dbnextrow retcode: %d\n", row_retcode);
assert(row_retcode == NO_MORE_ROWS);
results_retcode = dbresults(dbproc);
rowcount = DBCOUNT(dbproc);
colcount = dbnumcols(dbproc);
printf("RETCODE: %d\n", results_retcode);
printf("ROWCOUNT: %d\n", rowcount);
printf("COLCOUNT: %d\n\n", colcount);
assert(results_retcode == SUCCEED);
assert(rowcount == -1);
/* assert(colcount == 0); */
/* Call one more time to be sure we get NO_MORE_RESULTS */
row_retcode = dbnextrow(dbproc);
printf("dbnextrow retcode: %d\n", row_retcode);
assert(row_retcode == NO_MORE_ROWS);
results_retcode = dbresults(dbproc);
rowcount = DBCOUNT(dbproc);
colcount = dbnumcols(dbproc);
printf("RETCODE: %d\n", results_retcode);
printf("ROWCOUNT: %d\n", rowcount);
printf("COLCOUNT: %d\n\n", colcount);
assert(results_retcode == NO_MORE_RESULTS);
assert(rowcount == -1);
/* assert(colcount == 0); */
dbexit();
printf("%s OK\n", __FILE__);
return 0;
}
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;
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
int i;
DBINT testint = -1;
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, "pending");
printf("About to open\n");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
/* first query, start transactions */
sql_cmd(dbproc);
dbsqlexec(dbproc);
/* second query, select */
printf("second select\n");
if (SUCCEED != sql_cmd(dbproc) || SUCCEED != dbsqlexec(dbproc)) {
fprintf(stderr, "%s:%d: dbcmd failed\n", __FILE__, __LINE__);
exit(1);
}
if (dbresults(dbproc) != SUCCEED) {
fprintf(stderr, "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);
if (REG_ROW != dbnextrow(dbproc)) {
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
if (testint != 634) {
fprintf(stderr, "Failed. Expected i to be %d, was %d\n", i, (int) testint);
exit(1);
}
if (dbnextrow(dbproc) != NO_MORE_ROWS) {
fprintf(stderr, "No other rows expected\n");
}
/* third query, commit */
if (SUCCEED != sql_cmd(dbproc)) {
fprintf(stderr, "%s:%d: dbcmd failed\n", __FILE__, __LINE__);
exit(1);
}
while (dbresults(dbproc) != NO_MORE_RESULTS)
continue;
dbexit();
printf("ok\n");
return 0;
}
void
print_results(DBPROCESS *dbproc)
{
static const char empty_string[] = "";
static const char dashes[] = "----------------------------------------------------------------" /* each line is 64 */
"----------------------------------------------------------------"
"----------------------------------------------------------------"
"----------------------------------------------------------------";
struct METADATA *metadata = NULL, return_status;
struct DATA { char *buffer; int status; } *data = NULL;
struct METACOMP { int numalts; struct METADATA *meta; struct DATA *data; } **metacompute = NULL;
RETCODE erc;
int row_code;
int i, c, ret;
int iresultset;
int ncomputeids = 0, ncols = 0;
/*
* Set up each result set with dbresults()
* This is more commonly implemented as a while() loop, but we're counting the result sets.
*/
fprintf(options.verbose, "%s:%d: calling dbresults OK:\n", options.appname, __LINE__);
for (iresultset=1; (erc = dbresults(dbproc)) != NO_MORE_RESULTS; iresultset++) {
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbresults(), result set %d failed\n", options.appname, __LINE__, iresultset);
return;
}
fprintf(options.verbose, "Result set %d\n", iresultset);
/* Free prior allocations, if any. */
fprintf(options.verbose, "Freeing prior allocations\n", iresultset);
for (c=0; c < ncols; c++) {
free(metadata[c].format_string);
free(data[c].buffer);
}
free(metadata);
metadata = NULL;
free(data);
data = NULL;
ncols = 0;
for (i=0; i < ncomputeids; i++) {
for (c=0; c < metacompute[i]->numalts; c++) {
free(metacompute[i]->meta[c].name);
free(metacompute[i]->meta[c].format_string);
}
free(metacompute[i]->meta);
free(metacompute[i]->data);
free(metacompute[i]);
}
free(metacompute);
metacompute = NULL;
ncomputeids = 0;
/*
* Allocate memory for metadata and bound columns
*/
fprintf(options.verbose, "Allocating buffers\n", iresultset);
ncols = dbnumcols(dbproc);
metadata = (struct METADATA*) calloc(ncols, sizeof(struct METADATA));
assert(metadata);
data = (struct DATA*) calloc(ncols, sizeof(struct DATA));
assert(data);
/* metadata is more complicated only because there may be several compute ids for each result set */
fprintf(options.verbose, "Allocating compute buffers\n", iresultset);
ncomputeids = dbnumcompute(dbproc);
if (ncomputeids > 0) {
metacompute = (struct METACOMP**) calloc(ncomputeids, sizeof(struct METACOMP*));
assert(metacompute);
}
for (i=0; i < ncomputeids; i++) {
metacompute[i] = (struct METACOMP*) calloc(ncomputeids, sizeof(struct METACOMP));
assert(metacompute[i]);
metacompute[i]->numalts = dbnumalts(dbproc, 1+i);
fprintf(options.verbose, "%d columns found in computeid %d\n", metacompute[i]->numalts, 1+i);
if (metacompute[i]->numalts > 0) {
fprintf(options.verbose, "allocating column %d\n", 1+i);
metacompute[i]->meta = (struct METADATA*) calloc(metacompute[i]->numalts, sizeof(struct METADATA));
assert(metacompute[i]->meta);
metacompute[i]->data = (struct DATA*) calloc(metacompute[i]->numalts, sizeof(struct DATA));
assert(metacompute[i]->data);
}
}
/*
* For each column, get its name, type, and size.
* Allocate a buffer to hold the data, and bind the buffer to the column.
* "bind" here means to give db-lib the address of the buffer we want filled as each row is fetched.
* TODO: Implement dbcoltypeinfo() for numeric/decimal datatypes.
*/
fprintf(options.verbose, "Metadata\n", iresultset);
fprintf(options.verbose, "%-6s %-30s %-30s %-15s %-6s %-6s \n", "col", "name", "source", "type", "size", "varys");
fprintf(options.verbose, "%.6s %.30s %.30s %.15s %.6s %.6s \n", dashes, dashes, dashes, dashes, dashes, dashes);
for (c=0; c < ncols; c++) {
int width;
/* Get and print the metadata. Optional: get only what you need. */
char *name = dbcolname(dbproc, c+1);
metadata[c].name = (name)? name : empty_string;
name = dbcolsource(dbproc, c+1);
metadata[c].source = (name)? name : empty_string;
metadata[c].type = dbcoltype(dbproc, c+1);
metadata[c].size = dbcollen(dbproc, c+1);
assert(metadata[c].size != -1); /* -1 means indicates an out-of-range request*/
fprintf(options.verbose, "%6d %30s %30s %15s %6d %6d \n",
c+1, metadata[c].name, metadata[c].source, dbprtype(metadata[c].type),
metadata[c].size, dbvarylen(dbproc, c+1));
/*
* Build the column header format string, based on the column width.
* This is just one solution to the question, "How wide should my columns be when I print them out?"
*/
width = get_printable_size(metadata[c].type, metadata[c].size);
if (width < strlen(metadata[c].name))
width = strlen(metadata[c].name);
ret = set_format_string(&metadata[c], (c+1 < ncols)? " " : "\n");
if (ret <= 0) {
fprintf(stderr, "%s:%d: asprintf(), column %d failed\n", options.appname, __LINE__, c+1);
return;
}
/*
* Bind the column to our variable.
* We bind everything to strings, because we want db-lib to convert everything to strings for us.
* If you're performing calculations on the data in your application, you'd bind the numeric data
* to C integers and floats, etc. instead.
*
* It is not necessary to bind to every column returned by the query.
* Data in unbound columns are simply never copied to the user's buffers and are thus
* inaccesible to the application.
*/
data[c].buffer = calloc(1, metadata[c].size);
assert(data[c].buffer);
erc = dbbind(dbproc, c+1, STRINGBIND, -1, (BYTE *) data[c].buffer);
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbbind(), column %d failed\n", options.appname, __LINE__, c+1);
return;
}
erc = dbnullbind(dbproc, c+1, &data[c].status);
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbnullbind(), column %d failed\n", options.appname, __LINE__, c+1);
return;
}
}
/*
* Get metadata and bind the columns for any compute rows.
*/
for (i=0; i < ncomputeids; i++) {
fprintf(options.verbose, "For computeid %d:\n", 1+i);
for (c=0; c < metacompute[i]->numalts; c++) {
/* read metadata */
struct METADATA *meta = &metacompute[i]->meta[c];
int nbylist, ibylist;
BYTE *bylist;
char *colname, bynames[256] = "by (";
int altcolid = dbaltcolid(dbproc, i+1, c+1);
metacompute[i]->meta[c].type = dbalttype(dbproc, i+1, c+1);
metacompute[i]->meta[c].size = dbaltlen(dbproc, i+1, c+1);
/*
* Jump through hoops to determine a useful name for the computed column
* If the query says "compute count(c) by a,b", we get a "by list" indicating a & b.
*/
bylist = dbbylist(dbproc, c+1, &nbylist);
for (ibylist=0; ibylist < nbylist; ibylist++) {
int ret;
char *s = strchr(bynames, '\0');
int remaining = bynames + sizeof(bynames) - s;
assert(remaining > 0);
ret = snprintf(s, remaining, "%s%s", dbcolname(dbproc, bylist[ibylist]),
(ibylist+1 < nbylist)? ", " : ")");
if (ret <= 0) {
fprintf(options.verbose, "Insufficient room to create name for column %d:\n", 1+c);
break;
}
}
if( altcolid == -1 ) {
colname = "*";
} else {
colname = metadata[altcolid].name;
}
asprintf(&metacompute[i]->meta[c].name, "%s(%s)", dbprtype(dbaltop(dbproc, i+1, c+1)), colname);
assert(metacompute[i]->meta[c].name);
ret = set_format_string(meta, (c+1 < metacompute[i]->numalts)? " " : "\n");
if (ret <= 0) {
fprintf(stderr, "%s:%d: asprintf(), column %d failed\n", options.appname, __LINE__, c+1);
return;
}
fprintf(options.verbose, "\tcolumn %d is %s, type %s, size %d %s\n",
c+1, metacompute[i]->meta[c].name, dbprtype(metacompute[i]->meta[c].type), metacompute[i]->meta[c].size,
(nbylist > 0)? bynames : "");
/* allocate buffer */
assert(metacompute[i]->data);
metacompute[i]->data[c].buffer = calloc(1, metacompute[i]->meta[c].size);
assert(metacompute[i]->data[c].buffer);
/* bind */
erc = dbaltbind(dbproc, i+1, c+1, STRINGBIND, -1, metacompute[i]->data[c].buffer);
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbaltbind(), column %d failed\n", options.appname, __LINE__, c+1);
return;
}
}
}
fprintf(options.verbose, "\n");
fprintf(options.verbose, "Data\n", iresultset);
/* Print the column headers to stderr to keep them separate from the data. */
for (c=0; c < ncols; c++) {
char fmt[256] = "%-";
/* left justify the names */
strcat(fmt, &metadata[c].format_string[1]);
fprintf(stderr, fmt, metadata[c].name);
}
/* Underline the column headers. */
for (c=0; c < ncols; c++) {
fprintf(stderr, metadata[c].format_string, dashes);
}
/*
* Print the data to stdout.
*/
while ((row_code = dbnextrow(dbproc)) != NO_MORE_ROWS) {
switch (row_code) {
case REG_ROW:
for (c=0; c < ncols; c++) {
switch (data[c].status) { /* handle nulls */
case -1: /* is null */
/* TODO: FreeTDS 0.62 does not support dbsetnull() */
fprintf(stdout, metadata[c].format_string, "NULL");
break;
case 0:
/* case >1 is datlen when buffer is too small */
default:
fprintf(stdout, metadata[c].format_string, data[c].buffer);
break;
}
}
break;
case BUF_FULL:
assert(row_code != BUF_FULL);
break;
default: /* computeid */
fprintf(options.verbose, "Data for computeid %d\n", row_code);
for (c=0; c < metacompute[row_code-1]->numalts; c++) {
char fmt[256] = "%-";
struct METADATA *meta = &metacompute[row_code-1]->meta[c];
/* left justify the names */
strcat(fmt, &meta->format_string[1]);
fprintf(stderr, fmt, meta->name);
}
/* Underline the column headers. */
for (c=0; c < metacompute[row_code-1]->numalts; c++) {
fprintf(stderr, metacompute[row_code-1]->meta[c].format_string, dashes);
}
for (c=0; c < metacompute[row_code-1]->numalts; c++) {
struct METADATA *meta = &metacompute[row_code-1]->meta[c];
struct DATA *data = &metacompute[row_code-1]->data[c];
switch (data->status) { /* handle nulls */
case -1: /* is null */
/* TODO: FreeTDS 0.62 does not support dbsetnull() */
fprintf(stdout, meta->format_string, "NULL");
break;
case 0:
/* case >1 is datlen when buffer is too small */
default:
fprintf(stdout, meta->format_string, data->buffer);
break;
}
}
}
}
/* Check return status */
fprintf(options.verbose, "Retrieving return status... ");
if (dbhasretstat(dbproc) == TRUE) {
fprintf(stderr, "Procedure returned %d\n", dbretstatus(dbproc));
} else {
fprintf(options.verbose, "none\n");
}
/*
* Get row count, if available.
*/
if (DBCOUNT(dbproc) > -1)
fprintf(stderr, "%d rows affected\n", DBCOUNT(dbproc));
/*
* Check return parameter values
*/
fprintf(options.verbose, "Retrieving output parameters... ");
if (dbnumrets(dbproc) > 0) {
for (i = 1; i <= dbnumrets(dbproc); i++) {
char parameter_string[1024];
return_status.name = dbretname(dbproc, i);
fprintf(stderr, "ret name %d is %s\n", i, return_status.name);
return_status.type = dbrettype(dbproc, i);
fprintf(options.verbose, "\n\tret type %d is %d", i, return_status.type);
return_status.size = dbretlen(dbproc, i);
fprintf(options.verbose, "\n\tret len %d is %d\n", i, return_status.size);
dbconvert(dbproc, return_status.type, dbretdata(dbproc, i), return_status.size,
SYBVARCHAR, (BYTE *) parameter_string, -1);
fprintf(stderr, "ret data %d is %s\n", i, parameter_string);
}
} else {
fprintf(options.verbose, "none\n");
}
} /* wend dbresults */
fprintf(options.verbose, "%s:%d: dbresults() returned NO_MORE_RESULTS (%d):\n", options.appname, __LINE__, erc);
}
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;
}
bool QTDSResult::reset (const QString& query)
{
cleanup();
if (!driver() || !driver()-> isOpen() || driver()->isOpenError())
return false;
setActive(false);
setAt(QSql::BeforeFirstRow);
if (dbcmd(d->dbproc, const_cast<char*>(query.toLocal8Bit().constData())) == FAIL) {
setLastError(d->lastError);
return false;
}
if (dbsqlexec(d->dbproc) == FAIL) {
setLastError(d->lastError);
dbfreebuf(d->dbproc);
return false;
}
if (dbresults(d->dbproc) != SUCCEED) {
setLastError(d->lastError);
dbfreebuf(d->dbproc);
return false;
}
setSelect((DBCMDROW(d->dbproc) == SUCCEED)); // decide whether or not we are dealing with a SELECT query
int numCols = dbnumcols(d->dbproc);
if (numCols > 0) {
d->buffer.resize(numCols * 2);
init(numCols);
}
for (int i = 0; i < numCols; ++i) {
int dbType = dbcoltype(d->dbproc, i+1);
QVariant::Type vType = qDecodeTDSType(dbType);
QSqlField f(QString::fromAscii(dbcolname(d->dbproc, i+1)), vType);
f.setSqlType(dbType);
f.setLength(dbcollen(d->dbproc, i+1));
d->rec.append(f);
RETCODE ret = -1;
void* p = 0;
switch (vType) {
case QVariant::Int:
p = malloc(4);
ret = dbbind(d->dbproc, i+1, INTBIND, (DBINT) 4, (unsigned char *)p);
break;
case QVariant::Double:
// use string binding to prevent loss of precision
p = malloc(50);
ret = dbbind(d->dbproc, i+1, STRINGBIND, 50, (unsigned char *)p);
break;
case QVariant::String:
p = malloc(dbcollen(d->dbproc, i+1) + 1);
ret = dbbind(d->dbproc, i+1, STRINGBIND, DBINT(dbcollen(d->dbproc, i+1) + 1), (unsigned char *)p);
break;
case QVariant::DateTime:
p = malloc(8);
ret = dbbind(d->dbproc, i+1, DATETIMEBIND, (DBINT) 8, (unsigned char *)p);
break;
case QVariant::ByteArray:
p = malloc(dbcollen(d->dbproc, i+1) + 1);
ret = dbbind(d->dbproc, i+1, BINARYBIND, DBINT(dbcollen(d->dbproc, i+1) + 1), (unsigned char *)p);
break;
default: //don't bind the field since we do not support it
qWarning("QTDSResult::reset: Unsupported type for field \"%s\"", dbcolname(d->dbproc, i+1));
break;
}
if (ret == SUCCEED) {
d->buffer[i * 2] = p;
ret = dbnullbind(d->dbproc, i+1, (DBINT*)(&d->buffer[i * 2 + 1]));
} else {
d->buffer[i * 2] = 0;
d->buffer[i * 2 + 1] = 0;
free(p);
}
if ((ret != SUCCEED) && (ret != -1)) {
setLastError(d->lastError);
return false;
}
}
setActive(true);
return true;
}
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;
}
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
print_results(DBPROCESS *dbproc)
{
static const char empty_string[] = "";
static const char dashes[] = "----------------------------------------------------------------" /* each line is 64 */
"----------------------------------------------------------------"
"----------------------------------------------------------------"
"----------------------------------------------------------------";
struct METADATA *metadata = NULL, return_status;
struct DATA { char *buffer; int status; } *data = NULL;
struct METACOMP { int numalts; struct METADATA *meta; struct DATA *data; } **metacompute = NULL;
RETCODE erc;
int row_code;
int i, c, ret;
int iresultset;
int ncomputeids = 0, ncols = 0;
/*
* If using default column separator, we want columns to line up vertically,
* so we use blank padding (STRINGBIND).
* For any other separator, we use no padding.
*/
const int bindtype = (0 == strcmp(options.colsep, default_colsep))? STRINGBIND : NTBSTRINGBIND;
/*
* Set up each result set with dbresults()
* This is more commonly implemented as a while() loop, but we're counting the result sets.
*/
fprintf(options.verbose, "%s:%d: calling dbresults: OK\n", options.appname, __LINE__);
for (iresultset=1; (erc = dbresults(dbproc)) != NO_MORE_RESULTS; iresultset++) {
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbresults(), result set %d failed\n", options.appname, __LINE__, iresultset);
return;
}
if (options.pivot.func) {
const struct key_t *rk = &options.pivot.row_key, *ck = &options.pivot.col_key;
erc = dbpivot(dbproc, rk->nkeys, rk->keys, ck->nkeys, ck->keys,
options.pivot.func, options.pivot.val_col);
}
fprintf(options.verbose, "Result set %d\n", iresultset);
/* Free prior allocations, if any. */
for (c=0; c < ncols; c++) {
free(metadata[c].format_string);
free(data[c].buffer);
}
free(metadata);
metadata = NULL;
free(data);
data = NULL;
ncols = 0;
for (i=0; i < ncomputeids; i++) {
for (c=0; c < metacompute[i]->numalts; c++) {
free(metacompute[i]->meta[c].name);
free(metacompute[i]->meta[c].format_string);
}
free(metacompute[i]->meta);
free(metacompute[i]->data);
free(metacompute[i]);
}
free(metacompute);
metacompute = NULL;
ncomputeids = 0;
/*
* Allocate memory for metadata and bound columns
*/
fprintf(options.verbose, "Allocating buffers\n");
ncols = dbnumcols(dbproc);
metadata = (struct METADATA*) calloc(ncols, sizeof(struct METADATA));
assert(metadata);
data = (struct DATA*) calloc(ncols, sizeof(struct DATA));
assert(data);
/* metadata is more complicated only because there may be several compute ids for each result set */
fprintf(options.verbose, "Allocating compute buffers\n");
ncomputeids = dbnumcompute(dbproc);
if (ncomputeids > 0) {
metacompute = (struct METACOMP**) calloc(ncomputeids, sizeof(struct METACOMP*));
assert(metacompute);
}
for (i=0; i < ncomputeids; i++) {
metacompute[i] = (struct METACOMP*) calloc(ncomputeids, sizeof(struct METACOMP));
assert(metacompute[i]);
metacompute[i]->numalts = dbnumalts(dbproc, 1+i);
fprintf(options.verbose, "%d columns found in computeid %d\n", metacompute[i]->numalts, 1+i);
if (metacompute[i]->numalts > 0) {
fprintf(options.verbose, "allocating column %d\n", 1+i);
metacompute[i]->meta = (struct METADATA*) calloc(metacompute[i]->numalts, sizeof(struct METADATA));
assert(metacompute[i]->meta);
metacompute[i]->data = (struct DATA*) calloc(metacompute[i]->numalts, sizeof(struct DATA));
assert(metacompute[i]->data);
}
}
/*
* For each column, get its name, type, and size.
* Allocate a buffer to hold the data, and bind the buffer to the column.
* "bind" here means to give db-lib the address of the buffer we want filled as each row is fetched.
* TODO: Implement dbcoltypeinfo() for numeric/decimal datatypes.
*/
fprintf(options.verbose, "Metadata\n");
fprintf(options.verbose, "%-6s %-30s %-30s %-15s %-6s %-6s \n", "col", "name", "source", "type", "size", "varies");
fprintf(options.verbose, "%.6s %.30s %.30s %.15s %.6s %.6s \n", dashes, dashes, dashes, dashes, dashes, dashes);
for (c=0; c < ncols; c++) {
/* Get and print the metadata. Optional: get only what you need. */
char *name = dbcolname(dbproc, c+1);
metadata[c].name = strdup(name ? (const char *) name : empty_string);
name = dbcolsource(dbproc, c+1);
metadata[c].source = (name)? name : empty_string;
metadata[c].type = dbcoltype(dbproc, c+1);
metadata[c].size = dbcollen(dbproc, c+1);
assert(metadata[c].size != -1); /* -1 means indicates an out-of-range request*/
fprintf(options.verbose, "%6d %30s %30s %15s %6d %6d \n",
c+1, metadata[c].name, metadata[c].source, dbprtype(metadata[c].type),
metadata[c].size, dbvarylen(dbproc, c+1));
/*
* Build the column header format string, based on the column width.
* This is just one solution to the question, "How wide should my columns be when I print them out?"
*/
metadata[c].width = get_printable_size(metadata[c].type, metadata[c].size);
if (metadata[c].width < strlen(metadata[c].name))
metadata[c].width = strlen(metadata[c].name);
ret = set_format_string(&metadata[c], (c+1 < ncols)? options.colsep : "\n");
if (ret <= 0) {
fprintf(stderr, "%s:%d: asprintf(), column %d failed\n", options.appname, __LINE__, c+1);
return;
}
/*
* Bind the column to our variable.
* We bind everything to strings, because we want db-lib to convert everything to strings for us.
* If you're performing calculations on the data in your application, you'd bind the numeric data
* to C integers and floats, etc. instead.
*
* It is not necessary to bind to every column returned by the query.
* Data in unbound columns are simply never copied to the user's buffers and are thus
* inaccesible to the application.
*/
if (metadata[c].width < INT_MAX) {
data[c].buffer = calloc(1, 1 + metadata[c].width); /* allow for null terminator */
assert(data[c].buffer);
erc = dbbind(dbproc, c+1, bindtype, 0, (BYTE *) data[c].buffer);
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbbind(), column %d failed\n", options.appname, __LINE__, c+1);
return;
}
erc = dbnullbind(dbproc, c+1, &data[c].status);
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbnullbind(), column %d failed\n", options.appname, __LINE__, c+1);
return;
}
} else {
/* We don't bind text buffers, but use dbreadtext instead. */
data[c].buffer = NULL;
}
}
/*
* Get metadata and bind the columns for any compute rows.
*/
for (i=0; i < ncomputeids; i++) {
fprintf(options.verbose, "For computeid %d:\n", 1+i);
for (c=0; c < metacompute[i]->numalts; c++) {
/* read metadata */
struct METADATA *meta = &metacompute[i]->meta[c];
int nby, iby;
BYTE *bylist;
char *colname, *bynames;
int altcolid = dbaltcolid(dbproc, i+1, c+1);
metacompute[i]->meta[c].type = dbalttype(dbproc, i+1, c+1);
metacompute[i]->meta[c].size = dbaltlen(dbproc, i+1, c+1);
/*
* Jump through hoops to determine a useful name for the computed column
* If the query says "compute count(c) by a,b", we get a "by list" indicating a & b.
*/
bylist = dbbylist(dbproc, c+1, &nby);
bynames = strdup("by (");
for (iby=0; iby < nby; iby++) {
char *s = NULL;
int ret = asprintf(&s, "%s%s%s", bynames, dbcolname(dbproc, bylist[iby]),
(iby+1 < nby)? ", " : ")");
if (ret < 0) {
fprintf(options.verbose, "Insufficient room to create name for column %d:\n", 1+c);
break;
}
free(bynames);
bynames = s;
}
if( altcolid == -1 ) {
colname = "*";
} else {
assert(0 < altcolid && altcolid <= dbnumcols(dbproc));
colname = metadata[--altcolid].name;
}
asprintf(&metacompute[i]->meta[c].name, "%s(%s)", dbprtype(dbaltop(dbproc, i+1, c+1)), colname);
assert(metacompute[i]->meta[c].name);
metacompute[i]->meta[c].width = get_printable_size(metacompute[i]->meta[c].type,
metacompute[i]->meta[c].size);
if (metacompute[i]->meta[c].width < strlen(metacompute[i]->meta[c].name))
metacompute[i]->meta[c].width = strlen(metacompute[i]->meta[c].name);
ret = set_format_string(meta, (c+1 < metacompute[i]->numalts)? options.colsep : "\n");
if (ret <= 0) {
free(bynames);
fprintf(stderr, "%s:%d: asprintf(), column %d failed\n", options.appname, __LINE__, c+1);
return;
}
fprintf(options.verbose, "\tcolumn %d is %s, type %s, size %d %s\n",
c+1, metacompute[i]->meta[c].name, dbprtype(metacompute[i]->meta[c].type),
metacompute[i]->meta[c].size, (nby > 0)? bynames : "");
free(bynames);
/* allocate buffer */
assert(metacompute[i]->data);
metacompute[i]->data[c].buffer = calloc(1, metacompute[i]->meta[c].width);
assert(metacompute[i]->data[c].buffer);
/* bind */
erc = dbaltbind(dbproc, i+1, c+1, bindtype, -1, (BYTE*) metacompute[i]->data[c].buffer);
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbaltbind(), column %d failed\n", options.appname, __LINE__, c+1);
return;
}
}
}
fprintf(options.verbose, "\n");
fprintf(options.verbose, "Data\n");
if (!options.fquiet) {
/* Print the column headers to stderr to keep them separate from the data. */
for (c=0; c < ncols; c++) {
fprintf(options.headers, metadata[c].format_string, metadata[c].name);
}
/* Underline the column headers. */
for (c=0; c < ncols; c++) {
fprintf(options.headers, metadata[c].format_string, dashes);
}
}
/*
* Print the data to stdout.
*/
while ((row_code = dbnextrow(dbproc)) != NO_MORE_ROWS) {
switch (row_code) {
case REG_ROW:
for (c=0; c < ncols; c++) {
if (metadata[c].width == INT_MAX) { /* TEXT/IMAGE */
BYTE *p = dbdata(dbproc, c+1);
size_t len = dbdatlen(dbproc, c+1);
if (len == 0) {
fputs("NULL", stdout);
} else {
BYTE *pend = p + len;
switch(dbcoltype(dbproc, c+1)) {
case SYBTEXT:
if (fwrite(p, len, 1, stdout) != 1) {
perror("could not write to output file");
exit(EXIT_FAILURE);
}
break;
default: /* image, binary */
fprintf(stdout, "0x");
for (; p < pend; p++) {
printf("%02hx", (unsigned short int)*p);
}
break;
}
}
fprintf(stdout, metadata[c].format_string, ""); /* col/row separator */
continue;
}
switch (data[c].status) { /* handle nulls */
case -1: /* is null */
/* TODO: FreeTDS 0.62 does not support dbsetnull() */
fprintf(stdout, metadata[c].format_string, "NULL");
break;
case 0:
/* case >1 is datlen when buffer is too small */
default:
fprintf(stdout, metadata[c].format_string, data[c].buffer);
break;
}
}
break;
case BUF_FULL:
assert(row_code != BUF_FULL);
break;
case FAIL:
fprintf(stderr, "bsqldb: fatal error: dbnextrow returned FAIL\n");
assert(row_code != FAIL);
exit(EXIT_FAILURE);
break;
default: /* computeid */
fprintf(options.verbose, "Data for computeid %d\n", row_code);
for (c=0; c < metacompute[row_code-1]->numalts; c++) {
char fmt[256] = "%-";
struct METADATA *meta = &metacompute[row_code-1]->meta[c];
/* left justify the names */
strcat(fmt, &meta->format_string[1]);
fprintf(options.headers, fmt, meta->name);
}
/* Underline the column headers. */
for (c=0; c < metacompute[row_code-1]->numalts; c++) {
fprintf(options.headers, metacompute[row_code-1]->meta[c].format_string, dashes);
}
for (c=0; c < metacompute[row_code-1]->numalts; c++) {
struct METADATA *meta = &metacompute[row_code-1]->meta[c];
struct DATA *data = &metacompute[row_code-1]->data[c];
switch (data->status) { /* handle nulls */
case -1: /* is null */
/* TODO: FreeTDS 0.62 does not support dbsetnull() */
fprintf(stdout, meta->format_string, "NULL");
break;
case 0:
/* case >1 is datlen when buffer is too small */
default:
fprintf(stdout, meta->format_string, data->buffer);
break;
}
}
}
}
/* Check return status */
if (!options.fquiet) {
fprintf(options.verbose, "Retrieving return status... ");
if (dbhasretstat(dbproc) == TRUE) {
fprintf(stderr, "Procedure returned %d\n", dbretstatus(dbproc));
} else {
fprintf(options.verbose, "none\n");
}
}
/*
* Get row count, if available.
*/
if (!options.fquiet) {
if (DBCOUNT(dbproc) > -1)
fprintf(stderr, "%d rows affected\n", DBCOUNT(dbproc));
else
fprintf(stderr, "@@rowcount not available\n");
}
/*
* Check return parameter values
*/
fprintf(options.verbose, "Retrieving output parameters... ");
if (dbnumrets(dbproc) > 0) {
for (i = 1; i <= dbnumrets(dbproc); i++) {
char parameter_string[1024];
return_status.name = dbretname(dbproc, i);
fprintf(stderr, "ret name %d is %s\n", i, return_status.name);
return_status.type = dbrettype(dbproc, i);
fprintf(options.verbose, "\n\tret type %d is %d", i, return_status.type);
return_status.size = dbretlen(dbproc, i);
fprintf(options.verbose, "\n\tret len %d is %d\n", i, return_status.size);
dbconvert(dbproc, return_status.type, dbretdata(dbproc, i), return_status.size,
SYBVARCHAR, (BYTE *) parameter_string, -1);
fprintf(stderr, "ret data %d is %s\n", i, parameter_string);
}
} else {
fprintf(options.verbose, "none\n");
}
} /* wend dbresults */
fprintf(options.verbose, "%s:%d: dbresults() returned NO_MORE_RESULTS (%d):\n", options.appname, __LINE__, erc);
}
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;
}
static int
check_table_structures(char *sobjname, char *dobjname, DBPROCESS * dbsrc, DBPROCESS * dbdest)
{
char ls_command[256];
int i;
DBINT src_numcols = 0;
DBINT dest_numcols = 0;
DBINT src_coltype, dest_coltype;
DBINT src_collen, dest_collen;
sprintf(ls_command, "SET FMTONLY ON select * from %s SET FMTONLY OFF", sobjname);
if (dbcmd(dbsrc, ls_command) == FAIL) {
printf("dbcmd failed\n");
return FALSE;
}
if (dbsqlexec(dbsrc) == FAIL) {
printf("table %s not found on SOURCE\n", sobjname);
return FALSE;
}
while (NO_MORE_RESULTS != dbresults(dbsrc));
{
if (0 == (src_numcols = dbnumcols(dbsrc))) {
printf("Error in dbnumcols\n");
return FALSE;
}
}
sprintf(ls_command, "SET FMTONLY ON select * from %s SET FMTONLY OFF", dobjname);
if (dbcmd(dbdest, ls_command) == FAIL) {
printf("dbcmd failed\n");
return FALSE;
}
if (dbsqlexec(dbdest) == FAIL) {
printf("table %s not found on DEST\n", sobjname);
return FALSE;
}
while (NO_MORE_RESULTS != dbresults(dbdest));
{
if (0 == (dest_numcols = dbnumcols(dbdest))) {
printf("Error in dbnumcols\n");
return FALSE;
}
}
if (src_numcols != dest_numcols) {
printf("number of columns do not match. source : %d , dest: %d\n", src_numcols, dest_numcols);
return FALSE;
}
for (i = 1; i <= src_numcols; i++) {
src_coltype = dbcoltype(dbsrc, i);
src_collen = dbcollen(dbsrc, i);
dest_coltype = dbcoltype(dbdest, i);
dest_collen = dbcollen(dbdest, i);
if ((src_coltype == SYBNUMERIC && dest_coltype == SYBNUMERIC) ||
(src_coltype == SYBDECIMAL && dest_coltype == SYBDECIMAL)
) {
continue;
}
if (src_coltype != dest_coltype || src_collen != dest_collen) {
printf("COLUMN TYPE MISMATCH: column %d\n", i);
printf("source: type %d, length %d\n", src_coltype, src_collen);
printf("dest : type %d, length %d\n", dest_coltype, dest_collen);
return FALSE;
}
}
return TRUE;
}
static int
transfer_data(BCPPARAMDATA params, DBPROCESS * dbsrc, DBPROCESS * dbdest)
{
char ls_command[256];
int col;
DBINT src_numcols = 0;
DBINT src_datlen;
typedef struct migcoldata
{
DBINT coltype;
DBINT collen;
DBINT nullind;
DBCHAR *data;
} MIGCOLDATA;
MIGCOLDATA **srcdata;
DBINT rows_read = 0;
DBINT rows_sent = 0;
DBINT rows_done = 0;
DBINT ret;
struct timeval start_time;
struct timeval end_time;
double elapsed_time;
struct timeval batch_start;
struct timeval batch_end;
double elapsed_batch = 0.0;
if (params.vflag) {
printf("\nStarting copy...\n");
}
if (params.tflag) {
sprintf(ls_command, "truncate table %s", params.ddbobject);
if (dbcmd(dbdest, ls_command) == FAIL) {
printf("dbcmd failed\n");
return FALSE;
}
if (dbsqlexec(dbdest) == FAIL) {
printf("dbsqlexec failed\n");
return FALSE;
}
if (dbresults(dbdest) == FAIL) {
printf("Error in dbresults\n");
return FALSE;
}
}
sprintf(ls_command, "select * from %s", params.sdbobject);
if (dbcmd(dbsrc, ls_command) == FAIL) {
printf("dbcmd failed\n");
return FALSE;
}
if (dbsqlexec(dbsrc) == FAIL) {
printf("dbsqlexec failed\n");
return FALSE;
}
if (NO_MORE_RESULTS != dbresults(dbsrc));
{
if (0 == (src_numcols = dbnumcols(dbsrc))) {
printf("Error in dbnumcols\n");
return FALSE;
}
}
if (bcp_init(dbdest, params.ddbobject, (char *) NULL, (char *) NULL, DB_IN) == FAIL) {
printf("Error in bcp_init\n");
return FALSE;
}
srcdata = (MIGCOLDATA **) malloc(sizeof(MIGCOLDATA *) * src_numcols);
for (col = 0; col < src_numcols; col++) {
srcdata[col] = (MIGCOLDATA *) malloc(sizeof(MIGCOLDATA));
memset(srcdata[col], '\0', sizeof(MIGCOLDATA));
srcdata[col]->coltype = dbcoltype(dbsrc, col + 1);
srcdata[col]->collen = dbcollen(dbsrc, col + 1);
switch (srcdata[col]->coltype) {
case SYBBIT:
srcdata[col]->data = malloc(sizeof(DBBIT));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, BITBIND, sizeof(DBBIT), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBBIT, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBINT1:
srcdata[col]->data = malloc(sizeof(DBTINYINT));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, TINYBIND, sizeof(DBTINYINT), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBINT1, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBINT2:
srcdata[col]->data = malloc(sizeof(DBSMALLINT));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, SMALLBIND, sizeof(DBSMALLINT), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBINT2, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBINT4:
srcdata[col]->data = malloc(sizeof(DBINT));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, INTBIND, sizeof(DBINT), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBINT4, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBFLT8:
srcdata[col]->data = malloc(sizeof(DBFLT8));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, FLT8BIND, sizeof(DBFLT8), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBFLT8, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBREAL:
srcdata[col]->data = malloc(sizeof(DBREAL));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, REALBIND, sizeof(DBREAL), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBREAL, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBMONEY:
srcdata[col]->data = malloc(sizeof(DBMONEY));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, MONEYBIND, sizeof(DBMONEY), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBMONEY, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBMONEY4:
srcdata[col]->data = malloc(sizeof(DBMONEY4));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, SMALLMONEYBIND, sizeof(DBMONEY4), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBMONEY4, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBDATETIME:
srcdata[col]->data = malloc(sizeof(DBDATETIME));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, DATETIMEBIND, sizeof(DBDATETIME), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBDATETIME, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBDATETIME4:
srcdata[col]->data = malloc(sizeof(DBDATETIME4));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, SMALLDATETIMEBIND, sizeof(DBDATETIME), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBDATETIME4, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBNUMERIC:
srcdata[col]->data = malloc(sizeof(DBNUMERIC));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, NUMERICBIND, sizeof(DBNUMERIC), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, sizeof(DBNUMERIC), NULL, 0, SYBNUMERIC, col + 1) ==
FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBDECIMAL:
srcdata[col]->data = malloc(sizeof(DBDECIMAL));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, DECIMALBIND, sizeof(DBDECIMAL), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, sizeof(DBDECIMAL), NULL, 0, SYBDECIMAL, col + 1) ==
FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBTEXT:
case SYBCHAR:
srcdata[col]->data = malloc(srcdata[col]->collen + 1);
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, NTBSTRINGBIND, srcdata[col]->collen + 1, (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBCHAR, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
}
}
gettimeofday(&start_time, 0);
while (dbnextrow(dbsrc) != NO_MORE_ROWS) {
rows_read++;
for (col = 0; col < src_numcols; col++) {
switch (srcdata[col]->coltype) {
case SYBBIT:
case SYBINT1:
case SYBINT2:
case SYBINT4:
case SYBFLT8:
case SYBREAL:
case SYBDATETIME:
case SYBDATETIME4:
case SYBMONEY:
case SYBMONEY4:
if (srcdata[col]->nullind == -1) { /* NULL data retrieved from source */
bcp_collen(dbdest, 0, col + 1);
} else {
bcp_collen(dbdest, -1, col + 1);
}
break;
case SYBNUMERIC:
if (srcdata[col]->nullind == -1) { /* NULL data retrieved from source */
bcp_collen(dbdest, 0, col + 1);
} else {
bcp_collen(dbdest, sizeof(DBNUMERIC), col + 1);
}
break;
case SYBDECIMAL:
if (srcdata[col]->nullind == -1) { /* NULL data retrieved from source */
bcp_collen(dbdest, 0, col + 1);
} else {
bcp_collen(dbdest, sizeof(DBDECIMAL), col + 1);
}
break;
case SYBTEXT:
case SYBCHAR:
if (srcdata[col]->nullind == -1) { /* NULL data retrieved from source */
bcp_collen(dbdest, 0, col + 1);
} else {
/*
* if there is zero length data, then the
* input data MUST have been all blanks,
* trimmed down to nothing by the bind
* type of NTBSTRINGBIND.
* so find out the source data length and
* re-set the data accordingly...
*/
if (strlen(srcdata[col]->data) == 0) {
src_datlen = dbdatlen(dbsrc, col + 1);
memset(srcdata[col]->data, ' ', src_datlen);
srcdata[col]->data[src_datlen] = '\0';
}
bcp_collen(dbdest, strlen(srcdata[col]->data), col + 1);
}
break;
}
}
if (bcp_sendrow(dbdest) == FAIL) {
fprintf(stderr, "bcp_sendrow failed. \n");
return FALSE;
} else {
rows_sent++;
if (rows_sent == params.batchsize) {
gettimeofday(&batch_start, 0);
ret = bcp_batch(dbdest);
gettimeofday(&batch_end, 0);
elapsed_batch = elapsed_batch +
((double) (batch_end.tv_sec - batch_start.tv_sec) +
((double) (batch_end.tv_usec - batch_start.tv_usec) / 1000000.00)
);
if (ret == -1) {
printf("bcp_batch error\n");
return FALSE;
} else {
rows_done += ret;
printf("%d rows successfully copied (total %d)\n", ret, rows_done);
rows_sent = 0;
}
}
}
}
if (rows_read) {
gettimeofday(&batch_start, 0);
ret = bcp_done(dbdest);
gettimeofday(&batch_end, 0);
elapsed_batch = elapsed_batch +
((double) (batch_end.tv_sec - batch_start.tv_sec) +
((double) (batch_end.tv_usec - batch_start.tv_usec) / 1000000.00)
);
if (ret == -1) {
fprintf(stderr, "bcp_done failed. \n");
return FALSE;
} else {
rows_done += ret;
}
}
gettimeofday(&end_time, 0);
elapsed_time = (double) (end_time.tv_sec - start_time.tv_sec) +
((double) (end_time.tv_usec - start_time.tv_usec) / 1000000.00);
if (params.vflag) {
printf("\n");
printf("rows read : %d\n", rows_read);
printf("rows written : %d\n", rows_done);
printf("elapsed time (secs) : %f\n", elapsed_time);
printf("rows per second : %f\n", rows_done / elapsed_time);
}
return TRUE;
}
int /* return count of SQL text rows */
print_results(DBPROCESS *dbproc)
{
static const char empty_string[] = "";
struct METADATA *metadata = NULL;
struct DATA { char *buffer; int status; } *data = NULL;
RETCODE erc;
int row_code;
int c, ret;
int iresultset;
int nrows=0, ncols=0, ncomputeids;
/*
* Set up each result set with dbresults()
*/
for (iresultset=1; (erc = dbresults(dbproc)) != NO_MORE_RESULTS; iresultset++) {
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbresults(), result set %d failed\n", options.appname, __LINE__, iresultset);
return -1;
}
if (SUCCEED != dbrows(dbproc)) {
return 0;
}
/* Free prior allocations, if any. */
for (c=0; c < ncols; c++) {
free(metadata[c].format_string);
free(data[c].buffer);
}
free(metadata);
metadata = NULL;
free(data);
data = NULL;
ncols = 0;
/*
* Allocate memory for metadata and bound columns
*/
ncols = dbnumcols(dbproc);
metadata = (struct METADATA*) calloc(ncols, sizeof(struct METADATA));
assert(metadata);
data = (struct DATA*) calloc(ncols, sizeof(struct DATA));
assert(data);
/* The hard-coded queries don't generate compute rows. */
ncomputeids = dbnumcompute(dbproc);
assert(0 == ncomputeids);
/*
* For each column, get its name, type, and size.
* Allocate a buffer to hold the data, and bind the buffer to the column.
* "bind" here means to give db-lib the address of the buffer we want filled as each row is fetched.
*/
for (c=0; c < ncols; c++) {
int width;
/* Get and print the metadata. Optional: get only what you need. */
char *name = dbcolname(dbproc, c+1);
metadata[c].name = (name)? name : (char*) empty_string;
name = dbcolsource(dbproc, c+1);
metadata[c].source = (name)? name : (char*) empty_string;
metadata[c].type = dbcoltype(dbproc, c+1);
metadata[c].size = dbcollen(dbproc, c+1);
assert(metadata[c].size != -1); /* -1 means indicates an out-of-range request*/
#if 0
fprintf(stderr, "%6d %30s %30s %15s %6d %6d \n",
c+1, metadata[c].name, metadata[c].source, dbprtype(metadata[c].type),
metadata[c].size, dbvarylen(dbproc, c+1));
#endif
/*
* Build the column header format string, based on the column width.
* This is just one solution to the question, "How wide should my columns be when I print them out?"
*/
width = get_printable_size(metadata[c].type, metadata[c].size);
if (width < strlen(metadata[c].name))
width = strlen(metadata[c].name);
ret = set_format_string(&metadata[c], (c+1 < ncols)? " " : "\n");
if (ret <= 0) {
fprintf(stderr, "%s:%d: asprintf(), column %d failed\n", options.appname, __LINE__, c+1);
return -1;
}
/*
* Bind the column to our variable.
* We bind everything to strings, because we want db-lib to convert everything to strings for us.
* If you're performing calculations on the data in your application, you'd bind the numeric data
* to C integers and floats, etc. instead.
*
* It is not necessary to bind to every column returned by the query.
* Data in unbound columns are simply never copied to the user's buffers and are thus
* inaccesible to the application.
*/
data[c].buffer = calloc(1, metadata[c].size);
assert(data[c].buffer);
erc = dbbind(dbproc, c+1, STRINGBIND, -1, (BYTE *) data[c].buffer);
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbbind(), column %d failed\n", options.appname, __LINE__, c+1);
return -1;
}
erc = dbnullbind(dbproc, c+1, &data[c].status);
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbnullbind(), column %d failed\n", options.appname, __LINE__, c+1);
return -1;
}
}
/*
* Print the data to stdout.
*/
for (;(row_code = dbnextrow(dbproc)) != NO_MORE_ROWS; nrows++) {
switch (row_code) {
case REG_ROW:
for (c=0; c < ncols; c++) {
switch (data[c].status) { /* handle nulls */
case -1: /* is null */
fprintf(stderr, "defncopy: error: unexpected NULL row in SQL text\n");
break;
case 0: /* OK */
default: /* >1 is datlen when buffer is too small */
fprintf(stdout, "%s", data[c].buffer);
break;
}
}
break;
case BUF_FULL:
default:
fprintf(stderr, "defncopy: error: expected REG_ROW (%d), got %d instead\n", REG_ROW, row_code);
assert(row_code == REG_ROW);
break;
} /* row_code */
} /* wend dbnextrow */
fprintf(stdout, "\n");
} /* wend dbresults */
return nrows;
}
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;
}
static int
test(int argc, char **argv, int over4k)
{
const int rows_to_add = 3;
LOGINREC *login;
DBPROCESS *dbproc;
DBPROCESS *blobproc;
int i;
DBINT testint;
FILE *fp;
long result, isiz;
char *blob, *rblob;
unsigned char *textPtr, *timeStamp;
char objname[256];
char sqlCmd[256];
char rbuf[BLOB_BLOCK_SIZE];
long numread;
int numtowrite, numwritten;
set_malloc_options();
read_login_info(argc, argv);
fprintf(stdout, "Starting %s\n", argv[0]);
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, "t0014");
fprintf(stdout, "About to open %s..%s for user '%s'\n", SERVER, DATABASE, USER);
dbproc = dbopen(login, SERVER);
blobproc = dbopen(login, SERVER);
if (strlen(DATABASE)) {
dbuse(dbproc, DATABASE);
dbuse(blobproc, DATABASE);
}
dbloginfree(login);
fprintf(stdout, "After logon\n");
fprintf(stdout, "About to read binary input file\n");
if (argc == 1) {
argv = testargs;
argc = 3;
}
if (argc < 3) {
fprintf(stderr, "Usage: %s infile outfile\n", argv[0]);
return 1;
}
if ((fp = fopen(argv[1], "rb")) == NULL) {
fprintf(stderr, "Cannot open input file: %s\n", argv[1]);
return 2;
}
result = fseek(fp, 0, SEEK_END);
isiz = ftell(fp);
result = fseek(fp, 0, SEEK_SET);
blob = (char *) malloc(isiz);
result = fread((void *) blob, isiz, 1, fp);
assert(result == 1);
fclose(fp);
/* FIXME this test seem to not work using temporary tables (sybase?)... */
fprintf(stdout, "Dropping table\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
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 */
}
}
for (i = 0; i < rows_to_add; i++) {
sql_cmd(dbproc);
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
fprintf(stderr, "Error inserting blob\n");
return 4;
}
while ((result = dbnextrow(dbproc)) != NO_MORE_ROWS) {
result = REG_ROW;
result = DBTXPLEN;
strcpy(objname, "dblib0014.PigTure");
textPtr = dbtxptr(dbproc, 1);
timeStamp = dbtxtimestamp(dbproc, 1);
if (!textPtr && !timeStamp && dbtds(dbproc) >= DBTDS_7_2) {
printf("Protocol 7.2+ detected, test not supported\n");
free(blob);
dbexit();
exit(0);
}
/*
* Use #ifdef if you want to test dbmoretext mode (needed for 16-bit apps)
* Use #ifndef for big buffer version (32-bit)
*/
if (over4k) {
if (dbwritetext(blobproc, objname, textPtr, DBTXPLEN, timeStamp, TRUE, isiz, (BYTE*) blob) != SUCCEED)
return 5;
} else {
if (dbwritetext(blobproc, objname, textPtr, DBTXPLEN, timeStamp, TRUE, isiz, NULL) != SUCCEED)
return 15;
dbsqlok(blobproc);
dbresults(blobproc);
numtowrite = 0;
/* Send the update value in chunks. */
for (numwritten = 0; numwritten < isiz; numwritten += numtowrite) {
numtowrite = (isiz - numwritten);
if (numtowrite > BLOB_BLOCK_SIZE)
numtowrite = BLOB_BLOCK_SIZE;
dbmoretext(blobproc, (DBINT) numtowrite, (BYTE *) (blob + numwritten));
}
dbsqlok(blobproc);
while (dbresults(blobproc) != NO_MORE_RESULTS);
}
}
}
fprintf(stdout, "select\n");
sql_cmd(dbproc);
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));
}
if (SUCCEED != dbbind(dbproc, 1, INTBIND, -1, (BYTE *) & testint)) {
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)) {
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
if (testint != i) {
fprintf(stderr, "Failed. Expected i to be %d, was %d\n", i, (int) testint);
abort();
}
/* get the image */
strcpy(sqlCmd, "SET TEXTSIZE 2147483647");
dbcmd(blobproc, sqlCmd);
dbsqlexec(blobproc);
if (dbresults(blobproc) != SUCCEED) {
dbcancel(blobproc);
return 16;
}
sprintf(sqlCmd, "SELECT PigTure FROM dblib0014 WHERE i = %d", i);
dbcmd(blobproc, sqlCmd);
dbsqlexec(blobproc);
if (dbresults(blobproc) != SUCCEED) {
fprintf(stderr, "Error extracting blob\n");
return 6;
}
numread = 0;
rblob = NULL;
while ((result = dbreadtext(blobproc, rbuf, BLOB_BLOCK_SIZE)) != NO_MORE_ROWS) {
if (result != 0) { /* this indicates not end of row */
rblob = (char*) realloc(rblob, result + numread);
memcpy((void *) (rblob + numread), (void *) rbuf, result);
numread += result;
}
}
if (i == 0) {
printf("Saving first blob data row to file: %s\n", argv[2]);
if ((fp = fopen(argv[2], "wb")) == NULL) {
fprintf(stderr, "Unable to open output file: %s\n", argv[2]);
return 3;
}
result = fwrite((void *) rblob, numread, 1, fp);
fclose(fp);
}
printf("Read blob data row %d --> %s %ld byte comparison\n",
(int) testint, (memcmp(blob, rblob, numread)) ? "failed" : "PASSED", numread);
free(rblob);
}
if (dbnextrow(dbproc) != NO_MORE_ROWS) {
fprintf(stderr, "Was expecting no more rows\n");
exit(1);
}
free(blob);
fprintf(stdout, "Dropping table\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
dbexit();
return 0;
}
int
main(int argc, char **argv)
{
const int rows_to_add = 50;
LOGINREC *login;
DBPROCESS *dbproc;
int i, expected_error;
char *s, teststr[1024];
DBINT testint;
int failed = 0;
set_malloc_options();
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, "t0004");
printf("About to open\n");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
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 */
}
}
sql_cmd(dbproc); /* select */
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
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 <= 24; i++) {
char expected[1024];
sprintf(expected, "row %04d", i);
if (i % 5 == 0) {
dbclrbuf(dbproc, 5);
}
testint = -1;
strcpy(teststr, "bogus");
if (REG_ROW != dbnextrow(dbproc)) {
fprintf(stderr, "Failed. Expected a row\n");
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))) {
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);
}
printf("second select\n");
printf("testing dbgetchar...\n");
for (i=0; (s = dbgetchar(dbproc, i)) != NULL; i++) {
putchar(*s);
if (!(isprint((unsigned char)*s) || iscntrl((unsigned char)*s))) {
fprintf(stderr, "%s:%d: dbgetchar failed with %x at position %d\n", __FILE__, __LINE__, *s, i);
failed = 1;
break;
}
}
printf("<== end of command buffer\n");
if (SUCCEED != sql_cmd(dbproc)) {
fprintf(stderr, "%s:%d: dbcmd failed\n", __FILE__, __LINE__);
failed = 1;
}
printf("About to exec for the second time. Should fail\n");
expected_error = 20019;
dbsetuserdata(dbproc, (BYTE*) &expected_error);
if (FAIL != dbsqlexec(dbproc)) {
fprintf(stderr, "%s:%d: dbsqlexec should have failed but didn't\n", __FILE__, __LINE__);
failed = 1;
}
dbexit();
printf("%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 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 syb_get_count (int no_des)
{
return dbnumcols (descriptor[no_des]);
}
static int onDataResponse(eio_req *req) {
v8::HandleScope scope;
data_callback_t *callbackData = (data_callback_t *) req->data;
if(req->result == FAIL){
Local<Value> argv[1];
argv[0] = v8::Exception::Error(v8::String::New("An error occurred executing that statement"));
callbackData->callback->Call(Context::GetCurrent()->Global(), 1, argv);
}
uint32_t rownum = 0;
bool err = false;
COL *columns, *pcol;
int ncols = 0;
v8::Local<v8::Array> results = v8::Array::New();
while(dbresults(callbackData->dbconn) != NO_MORE_RESULTS){
ncols = dbnumcols(callbackData->dbconn);
columns = (COL *) calloc(ncols, sizeof(struct COL));
for (pcol = columns; pcol - columns < ncols; pcol++) {
int i = pcol - columns + 1;
pcol->name = v8::String::New(dbcolname(callbackData->dbconn, i));
pcol->type = dbcoltype(callbackData->dbconn, i);
pcol->size = dbcollen(callbackData->dbconn, i);
if (SYBCHAR != pcol->type) {
pcol->size = dbwillconvert(pcol->type, SYBCHAR);
}
//todo: work out if I'm leaking
if((pcol->buffer = (void *) malloc(pcol->size + 1)) == NULL) {
err = true;
break;
}
}
if(err){
for (pcol = columns; pcol - columns < ncols; pcol++) {
free(pcol->buffer);
free(columns);
}
Local<Value> argv[1];
argv[0] = v8::Exception::Error(v8::String::New("Could not allocate memory for columns"));
callbackData->callback->Call(Context::GetCurrent()->Global(), 1, argv);
return 0;
}
for (pcol = columns; pcol - columns < ncols; pcol++) {
int i = pcol - columns + 1;
int binding = NTBSTRINGBIND;
// switch(pcol->type){
// case TINYBIND:
// case SMALLBIND:
// case INTBIND:
// case FLT8BIND:
// case REALBIND:
// case SMALLDATETIMEBIND:
// case MONEYBIND:
// case SMALLMONEYBIND:
// case BINARYBIND:
// case BITBIND:
// case NUMERICBIND:
// case DECIMALBIND:
// case BIGINTBIND:
// // all numbers in JS are doubles
// binding = REALBIND;
// break;
// }
if(dbbind(callbackData->dbconn, i, binding, pcol->size + 1, (BYTE*)pcol->buffer) == FAIL){
err = true;
}else if(dbnullbind(callbackData->dbconn, i, &pcol->status) == FAIL){
err = true;
}
}
if(err){
for (pcol = columns; pcol - columns < ncols; pcol++) {
free(pcol->buffer);
free(columns);
}
Local<Value> argv[1];
argv[0] = v8::Exception::Error(v8::String::New("Could not allocate memory for columns"));
callbackData->callback->Call(Context::GetCurrent()->Global(), 1, argv);
return 0;
}
int row_code;
while ((row_code = dbnextrow(callbackData->dbconn)) != NO_MORE_ROWS){
if(row_code == REG_ROW) {
v8::Local<v8::Object> tuple = v8::Object::New();
for (pcol = columns; pcol - columns < ncols; pcol++) {
if(pcol->status == -1){
tuple->Set(pcol->name, v8::Null());
continue;
}
switch(pcol->type){
case SQLINTN:
case SQLINT1:
case SQLINT2:
case SQLINT4:
case SQLINT8:
case SQLFLT8:
case SQLDATETIME:
case SQLDATETIM4:
case SQLBIT:
case SQLFLT4:
case SQLNUMERIC:
case SQLDECIMAL:
case SQLFLTN:
case SQLDATETIMN:
case 36:
case SQLCHAR:
case SQLVARCHAR:
case SQLTEXT:
tuple->Set(pcol->name, v8::String::New((char*) pcol->buffer));
break;
// case SQLINTN:
// case SQLINT1:
// case SQLINT2:
// case SQLINT4:
// case SQLINT8:
// case SQLFLT8:
// case SQLDATETIME:
// case SQLDATETIM4:
// case SQLBIT:
// case SQLFLT4:
// case SQLNUMERIC:
// case SQLDECIMAL:
// case SQLFLTN:
// case SQLDATETIMN:
// DBREAL val;
// memcpy(&val, pcol->buffer, pcol->size);
// tuple->Set(pcol->name, v8::Number::New((double)val));
break;
case SQLIMAGE:
case SQLMONEY4:
case SQLMONEY:
case SQLBINARY:
case SQLVARBINARY:
case SQLMONEYN:
case SQLVOID:
default:
printf("unsupported col type %d\n", pcol->type);
break;
}
}
results->Set(rownum++, tuple);
}
}
for (pcol = columns; pcol - columns < ncols; pcol++) {
free(pcol->buffer);
}
free(columns);
}
v8::Local<v8::Value> argv[2] = { Local<Value>::New(Null()), results };
callbackData->callback->Call(Context::GetCurrent()->Global(), 2, argv);
callbackData->callback.Dispose();
delete callbackData;
return 0;
}
