int
main(int argc, const char *argv[])
{
LOGINREC *login;
DBPROCESS *dbproc;
int i;
DBINT testint;
FILE *fp;
long result, isiz;
char *blob, *rblob;
unsigned char *textPtr = NULL, *timeStamp = NULL;
char objname[256];
char sqlCmd[256];
char rbuf[BLOB_BLOCK_SIZE];
long numread;
BOOL readFirstImage;
char cmd[1024];
set_malloc_options();
read_login_info();
fprintf(stdout, "Start\n");
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, "t0013");
fprintf(stdout, "About to open, PASSWORD: %s, USER: %s, SERVER: %s\n", "", "", ""); /* PASSWORD, USER, SERVER); */
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE)) {
dbuse(dbproc, DATABASE);
}
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);
fread((void *) blob, isiz, 1, fp);
fclose(fp);
fprintf(stdout, "Dropping table\n");
dbcmd(dbproc, "drop table #dblib0013");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "creating table\n");
dbcmd(dbproc, "create table #dblib0013 (i int not null, PigTure image not null)");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "insert\n");
sprintf(cmd, "insert into #dblib0013 values (1, '')");
fprintf(stdout, "%s\n", cmd);
dbcmd(dbproc, cmd);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
sprintf(sqlCmd, "SELECT PigTure FROM #dblib0013 WHERE i = 1");
dbcmd(dbproc, sqlCmd);
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, "#dblib0013.PigTure");
textPtr = dbtxptr(dbproc, 1);
timeStamp = dbtxtimestamp(dbproc, 1);
}
/* Use #ifdef if you want to test dbmoretext mode (needed for 16-bit apps)
* Use #ifndef for big buffer version (32-bit) */
#ifndef DBWRITE_OK_FOR_OVER_4K
if (dbwritetext(dbproc, objname, textPtr, DBTXPLEN, timeStamp, FALSE, isiz, (BYTE*) blob) != SUCCEED)
return 5;
#else
if (dbwritetext(dbproc, objname, textPtr, DBTXPLEN, timeStamp, FALSE, isiz, NULL) != SUCCEED)
return 15;
dbsqlok(dbproc);
dbresults(dbproc);
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(dbproc, (DBINT) numtowrite, blob + numwritten);
}
dbsqlok(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS);
#endif
fprintf(stdout, "select\n");
dbcmd(dbproc, "select * from #dblib0013 order by i");
dbsqlexec(dbproc);
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, -1, (BYTE *) & testint)) {
failed = 1;
fprintf(stderr, "Had problem with bind\n");
abort();
}
if (REG_ROW != dbnextrow(dbproc)) {
failed = 1;
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
if (testint != 1) {
failed = 1;
fprintf(stderr, "Failed. Expected i to be %d, was %d\n", i, (int) testint);
abort();
}
dbnextrow(dbproc);
/* get the image */
strcpy(sqlCmd, "SET TEXTSIZE 2147483647");
dbcmd(dbproc, sqlCmd);
dbsqlexec(dbproc);
dbresults(dbproc);
fprintf(stdout, "select 2\n");
sprintf(sqlCmd, "SELECT PigTure FROM #dblib0013 WHERE i = 1");
dbcmd(dbproc, sqlCmd);
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
fprintf(stderr, "Error extracting blob\n");
return 6;
}
numread = 0;
rblob = NULL;
readFirstImage = FALSE;
while ((result = dbreadtext(dbproc, rbuf, BLOB_BLOCK_SIZE)) != NO_MORE_ROWS) {
if (result == 0) { /* this indicates end of row */
readFirstImage = TRUE;
} else {
rblob = (char*) realloc(rblob, result + numread);
memcpy((void *) (rblob + numread), (void *) rbuf, result);
numread += result;
}
}
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) {
failed = 1;
fprintf(stderr, "Was expecting no more rows\n");
exit(1);
}
dbexit();
fprintf(stdout, "dblib %s on %s\n", (failed ? "failed!" : "okay"), __FILE__);
return failed ? 1 : 0;
}
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);
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, "text_buffer");
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, "100");
#else
dbsetopt(dbproc, DBBUFFER, "100", 0);
#endif
fprintf(stdout, "creating table\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "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 */
}
fprintf(stdout, "select\n");
dbcmd(dbproc, "select * from #dblib order by i");
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
fprintf(stdout, "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();
fprintf(stdout, "%s %s\n", __FILE__, (0 ? "failed!" : "OK"));
return 0;
}
void MSSqlDatatable::update()
{
// clear.
this->clear();
# ifdef _FREETDS
DBPROCESS* proc = (DBPROCESS*)_proc;
// update.
uint const ncols = dbnumcols(proc);
struct COL
{
char *name;
char *buffer;
int type, size, status;
} *columns, *pcol;
if ((columns = (COL*)calloc(ncols, sizeof(struct COL))) == NULL) {
return;
}
RETCODE sta = 0;
rows_type& rows = this->_rows;
cols_type& cols = this->_cols;
cols.resize(ncols);
//Read metadata and bind.
for (pcol = columns; pcol - columns < ncols; pcol++) {
int c = (int)(pcol - columns + 1);
pcol->name = dbcolname(proc, c);
pcol->type = dbcoltype(proc, c);
pcol->size = dbcollen(proc, c);
// add cols.
cols[c - 1] = new variant_t(pcol->name, core::copy);
if (SYBCHAR != pcol->type) {
pcol->size = dbwillconvert(pcol->type, SYBCHAR);
}
if ((pcol->buffer = (char*)calloc(1, pcol->size + 1)) == NULL){
break;
}
sta = dbbind(proc,
c,
NTBSTRINGBIND,
pcol->size + 1,
(byte*)pcol->buffer);
if (sta == FAIL) {
break;
}
sta = dbnullbind(proc,
c,
&pcol->status);
if (sta == FAIL) {
break;
}
}
// Get rows.
while ((sta = dbnextrow(proc)) != NO_MORE_ROWS){
switch (sta) {
case REG_ROW:
{
DBMSqlDatatable::row_type *row = new DBMSqlDatatable::row_type;
row->resize(ncols);
for (pcol=columns; pcol - columns < ncols; ++pcol)
{
int c = (int)(pcol - columns + 1);
char const* buffer = pcol->status == -1 ? "" : pcol->buffer;
(*row)[c - 1] = new variant_t(buffer, core::copy);
}
rows.push_back(row);
} break;
}
}
/* free metadata and data buffers */
for (pcol=columns; pcol - columns < ncols; pcol++) {
free(pcol->buffer);
}
free(columns);
# endif
# ifdef _MSSQL
_RecordsetPtr& rcdset = *((_RecordsetPtr*)_proc);
usize const ncols = (usize const)rcdset->Fields->GetCount();
rows_type& rows = this->_rows;
cols_type& cols = this->_cols;
cols.resize(ncols);
// read cols.
for (uint idx = 0; idx < ncols; ++idx)
{
# ifdef NNT_DEBUG
try {
# endif
_bstr_t name = rcdset->Fields->GetItem((long)idx)->GetName();
cols[idx] = new variant_t((char const*)name, core::copy);
# ifdef NNT_DEBUG
} catch (_com_error& err) {
_bstr_t msg = err.ErrorMessage();
trace_msg((char const*)msg);
}
# endif
}
// read rows.
while (!rcdset->adoEOF)
{
row_type* row = new row_type;
row->resize(ncols);
for (uindex idx = 0; idx < ncols; ++idx)
{
# ifdef NNT_DEBUG
try {
# endif
_bstr_t val = rcdset->GetCollect((long)idx);
(*row)[idx] = new variant_t((char const*)val, core::copy);
# ifdef NNT_DEBUG
} catch (_com_error& err) {
_bstr_t msg = err.ErrorMessage();
trace_msg((char const*)msg);
}
# endif
}
rows.push_back(row);
rcdset->MoveNext();
}
# endif
}
static int
test(int argc, char **argv, int over4k)
{
LOGINREC *login;
int i;
DBINT testint;
FILE *fp;
long result, isiz;
char *blob, *rblob;
DBBINARY *textPtr = NULL, *timeStamp = NULL;
char objname[256];
char rbuf[BLOB_BLOCK_SIZE];
long numread;
int data_ok;
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, "t0013");
fprintf(stdout, "About to open, PASSWORD: %s, USER: %s, SERVER: %s\n", "", "", ""); /* PASSWORD, USER, SERVER); */
dbproc = dbopen(login, SERVER);
dbprocw = dbopen(login, SERVER);
if (strlen(DATABASE)) {
dbuse(dbproc, DATABASE);
dbuse(dbprocw, DATABASE);
}
dbloginfree(login);
fprintf(stdout, "logged in\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;
}
fprintf(stdout, "Reading binary input file\n");
fseek(fp, 0, SEEK_END);
isiz = ftell(fp);
fseek(fp, 0, SEEK_SET);
blob = malloc(isiz);
assert(blob);
result = fread((void *) blob, isiz, 1, fp);
assert(result == 1);
fclose(fp);
drop_table();
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
sql_cmd(dbproc);
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
fprintf(stderr, "Error inserting blob\n");
return 4;
}
for (i=0; (result = dbnextrow(dbproc)) != NO_MORE_ROWS; i++) {
assert(REG_ROW == result);
printf("fetching row %d\n", i+1);
strcpy(objname, TABLE_NAME ".PigTure");
textPtr = dbtxptr(dbproc, 1);
timeStamp = dbtxtimestamp(dbproc, 1);
break; /* can't proceed until no more rows */
}
assert(REG_ROW == result || 0 < i);
if (!textPtr && !timeStamp && dbtds(dbproc) >= DBTDS_7_2) {
printf("Protocol 7.2+ detected, test not supported\n");
free(blob);
dbclose(dbproc);
dbproc = NULL;
dbexit();
exit(0);
}
if (!textPtr) {
fprintf(stderr, "Error getting textPtr\n");
exit(1);
}
/*
* Use #ifdef if you want to test dbmoretext mode (needed for 16-bit apps)
* Use #ifndef for big buffer version (32-bit)
*/
fprintf(stdout, "writing text ... ");
if (over4k) {
if (dbwritetext(dbprocw, objname, textPtr, DBTXPLEN, timeStamp, FALSE, isiz, (BYTE*) blob) != SUCCEED)
return 5;
fprintf(stdout, "done (in one shot)\n");
for (; (result = dbnextrow(dbproc)) != NO_MORE_ROWS; i++) {
assert(REG_ROW == result);
printf("fetching row %d?\n", i+1);
}
} else {
if (dbwritetext(dbprocw, objname, textPtr, DBTXPLEN, timeStamp, FALSE, isiz, NULL) != SUCCEED)
return 15;
fprintf(stdout, "done\n");
fprintf(stdout, "dbsqlok\n");
dbsqlok(dbprocw);
fprintf(stdout, "dbresults\n");
dbresults(dbprocw);
numtowrite = 0;
/* Send the update value in chunks. */
for (numwritten = 0; numwritten < isiz; numwritten += numtowrite) {
fprintf(stdout, "dbmoretext %d\n", 1 + numwritten);
numtowrite = (isiz - numwritten);
if (numtowrite > BLOB_BLOCK_SIZE)
numtowrite = BLOB_BLOCK_SIZE;
dbmoretext(dbprocw, (DBINT) numtowrite, (BYTE *) (blob + numwritten));
}
dbsqlok(dbprocw);
while (dbresults(dbprocw) != NO_MORE_RESULTS){
printf("suprise!\n");
}
}
#if 0
if (SUCCEED != dbclose(dbproc)){
fprintf(stdout, "dbclose failed");
exit(1);
}
dbproc = dbopen(login, SERVER);
assert(dbproc);
if (strlen(DATABASE)) {
dbuse(dbproc, DATABASE);
}
#endif
sql_cmd(dbproc);
dbsqlexec(dbproc);
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, \"%s\", is type %s\n",
i, dbcolname(dbproc, i), dbprtype(dbcoltype(dbproc, i)));
}
if (2 != dbnumcols(dbproc)) {
fprintf(stderr, "Failed. Expected 2 columns\n");
exit(1);
}
if (SUCCEED != dbbind(dbproc, 1, INTBIND, -1, (BYTE *) & testint)) {
fprintf(stderr, "Had problem with bind\n");
exit(1);
}
if (REG_ROW != dbnextrow(dbproc)) {
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
if (testint != 1) {
failed = 1;
fprintf(stderr, "Failed. Expected i to be %d, was %d\n", 1, (int) testint);
exit(1);
}
dbnextrow(dbproc);
/* get the image */
sql_cmd(dbproc);
dbsqlexec(dbproc);
dbresults(dbproc);
fprintf(stdout, "select 2\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
fprintf(stderr, "Error extracting blob\n");
return 6;
}
numread = 0;
rblob = NULL;
while ((result = dbreadtext(dbproc, 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;
}
}
data_ok = 1;
if (memcmp(blob, rblob, numread) != 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;
}
fwrite((void *) rblob, numread, 1, fp);
fclose(fp);
failed = 1;
data_ok = 0;
}
printf("Read blob data row %d --> %s %ld byte comparison\n",
(int) testint, data_ok ? "PASSED" : "failed", numread);
free(rblob);
if (dbnextrow(dbproc) != NO_MORE_ROWS) {
failed = 1;
fprintf(stderr, "Was expecting no more rows\n");
exit(1);
}
free(blob);
drop_table();
dbclose(dbproc);
dbproc = NULL;
dbexit();
return 0;
}
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)
{
RETCODE rc;
const int rows_to_add = 50;
LOGINREC *login;
DBPROCESS *dbproc;
int i;
char teststr[1024];
DBINT testint;
set_malloc_options();
read_login_info(argc, argv);
printf("Starting %s\n", argv[0]);
/* Fortify_EnterScope(); */
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
printf("About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0003");
DBSETLHOST(login, "ntbox.dntis.ro");
printf("About to open\n");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
#ifdef MICROSOFT_DBLIB
dbsetopt(dbproc, DBBUFFER, "100");
#else
dbsetopt(dbproc, DBBUFFER, "100", 0);
#endif
printf("creating table\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
printf("insert\n");
for (i = 1; i < rows_to_add; i++) {
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
printf("select\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
failed = 1;
printf("Was expecting a result set.");
exit(1);
}
for (i = 1; i <= dbnumcols(dbproc); i++)
printf("col %d is %s\n", i, dbcolname(dbproc, i));
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
for (i = 1; i < rows_to_add; i++) {
char expected[1024];
sprintf(expected, "row %03d", i);
if (i % 100 == 0) {
dbclrbuf(dbproc, 100);
}
if (REG_ROW != dbnextrow(dbproc)) {
failed = 1;
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
if (testint != i) {
failed = 1;
fprintf(stderr, "Failed. Expected i to be %d, was %d\n", i, (int) testint);
abort();
}
if (0 != strncmp(teststr, expected, strlen(expected))) {
failed = 1;
printf("Failed. Expected s to be |%s|, was |%s|\n", expected, teststr);
abort();
}
printf("Read a row of data -> %d %s\n", (int) testint, teststr);
}
dbclrbuf(dbproc, 1);
rc = dbnextrow(dbproc);
if (rc != NO_MORE_ROWS) {
failed = 1;
fprintf(stderr, "Was expecting no more rows. (rc=%d)\n", rc);
exit(1);
}
dbexit();
printf("%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
int
main(int argc, char **argv)
{
char cmd[1024];
const int rows_to_add = 50;
LOGINREC *login;
DBPROCESS *dbproc;
int i;
char teststr[1024];
DBINT testint;
int failed = 0;
set_malloc_options();
read_login_info();
fprintf(stdout, "Start\n");
add_bread_crumb();
dbinit();
add_bread_crumb();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
add_bread_crumb();
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0004");
fprintf(stdout, "About to open\n");
add_bread_crumb();
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
add_bread_crumb();
add_bread_crumb();
fprintf(stdout, "Dropping table\n");
add_bread_crumb();
dbcmd(dbproc, "drop table #dblib0004");
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 #dblib0004 (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++) {
sprintf(cmd, "insert into #dblib0004 values (%d, 'row %04d')", i, i);
fprintf(stdout, "%s\n", cmd);
dbcmd(dbproc, cmd);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
sprintf(cmd, "select * from #dblib0004 where i<=25 order by i");
fprintf(stdout, "%s\n", cmd);
dbcmd(dbproc, cmd);
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, -1, (BYTE *) teststr);
add_bread_crumb();
add_bread_crumb();
for (i = 1; i <= 24; i++) {
char expected[1024];
sprintf(expected, "row %04d", i);
add_bread_crumb();
if (i % 5 == 0) {
dbclrbuf(dbproc, 5);
}
testint = -1;
strcpy(teststr, "bogus");
add_bread_crumb();
if (REG_ROW != dbnextrow(dbproc)) {
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
add_bread_crumb();
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);
}
fprintf(stdout, "second select\n");
sprintf(cmd, "select * from #dblib0004 where i>950 order by i");
fprintf(stdout, "%s\n", cmd);
if (SUCCEED != dbcmd(dbproc, cmd)) {
fprintf(stderr, "%s:%d: dbcmd failed\n", __FILE__, __LINE__);
failed = 1;
}
fprintf(stdout, "About to exec for the second time. Should fail\n");
if (FAIL != dbsqlexec(dbproc)) {
fprintf(stderr, "%s:%d: dbsqlexec should have failed but didn't\n", __FILE__, __LINE__);
failed = 1;
}
add_bread_crumb();
dbexit();
add_bread_crumb();
fprintf(stdout, "dblib %s on %s\n", (failed ? "failed!" : "okay"), __FILE__);
return failed ? 1 : 0;
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
DBINT testint;
STATUS rc;
int i, iresults;
char teststr[1024];
int rows_in_buffer, limit_rows;
const int buffer_count = 10;
const int rows_to_add = 50;
set_malloc_options();
read_login_info(argc, argv);
fprintf(stdout, "Starting %s\n", argv[0]);
/* Fortify_EnterScope(); */
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0002");
fprintf(stdout, "About to open %s..%s\n", SERVER, DATABASE);
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
fprintf(stdout, "Setting row buffer to 10 rows\n");
#ifdef MICROSOFT_DBLIB
dbsetopt(dbproc, DBBUFFER, "10");
#else
dbsetopt(dbproc, DBBUFFER, "10", 0);
#endif
sql_cmd(dbproc); /* drop table if exists */
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
if (dbresults(dbproc) != NO_MORE_RESULTS) {
fprintf(stdout, "Failed: dbresults call after NO_MORE_RESULTS should return NO_MORE_RESULTS.\n");
failed = 1;
}
sql_cmd(dbproc); /* create table */
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
for (i = 1; i <= rows_to_add; i++) {
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
sql_cmd(dbproc); /* two result sets */
dbsqlexec(dbproc);
for (iresults=1; iresults <= 2; iresults++ ) {
fprintf(stdout, "fetching resultset %i\n", iresults);
if (dbresults(dbproc) != SUCCEED) {
fprintf(stderr, "Was expecting a result set %d.\n", iresults);
if( iresults == 2 )
fprintf(stderr, "Buffering with multiple resultsets is broken.\n");
exit(1);
}
rows_in_buffer = 0;
for (i = 1; i <= dbnumcols(dbproc); i++)
printf("col %d is [%s]\n", i, dbcolname(dbproc, i));
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
/* Fetch a result set */
/* Second resultset stops at row 46 */
limit_rows = rows_to_add - (iresults == 2 ? 4 : 0);
for (i=0; i < limit_rows;) {
fprintf(stdout, "clearing %d rows from buffer\n", rows_in_buffer ? buffer_count - 1 : buffer_count);
#ifdef MICROSOFT_DBLIB
if (i == 0) {
rc = dbnextrow(dbproc);
assert(rc == REG_ROW);
++i;
rows_in_buffer = 1;
}
#endif
dbclrbuf(dbproc, buffer_count);
rows_in_buffer = rows_in_buffer ? 1 : 0;
do {
int rc;
i++;
if (REG_ROW != (rc = dbnextrow(dbproc))) {
failed = 1;
fprintf(stderr, "Failed: Expected a row (%s:%d)\n", __FILE__, __LINE__);
if (rc == BUF_FULL)
fprintf(stderr, "Failed: dbnextrow returned BUF_FULL (%d). Fix dbclrbuf.\n", rc);
exit(1);
}
++rows_in_buffer;
verify(i, testint, teststr);
} while (rows_in_buffer < buffer_count && i < limit_rows);
if (rows_in_buffer == buffer_count) {
/* The buffer should be full */
assert(BUF_FULL == dbnextrow(dbproc));
}
}
if (iresults == 1) {
fprintf(stdout, "clearing %d rows from buffer\n", buffer_count);
dbclrbuf(dbproc, buffer_count);
while (dbnextrow(dbproc) != NO_MORE_ROWS) {
abort(); /* All rows were read: should not enter loop */
}
}
}
printf("\n");
/*
* Now test the buffered rows.
* Should be operating on rows 37-46 of 2nd resultset
*/
rc = dbgetrow(dbproc, 1);
if(rc != NO_MORE_ROWS) /* row 1 is not among the 31-40 in the buffer */
fprintf(stderr, "Failed: dbgetrow returned %d.\n", rc);
assert(rc == NO_MORE_ROWS);
rc = dbgetrow(dbproc, 37);
if(rc != REG_ROW)
fprintf(stderr, "Failed: dbgetrow returned %d.\n", rc);
assert(rc == REG_ROW);
verify(37, testint, teststr); /* first buffered row should be 37 */
rc = dbnextrow(dbproc);
if(rc != REG_ROW)
fprintf(stderr, "Failed: dbgetrow returned %d.\n", rc);
assert(rc == REG_ROW);
verify(38, testint, teststr); /* next buffered row should be 38 */
rc = dbgetrow(dbproc, 11);
assert(rc == NO_MORE_ROWS); /* only 10 (not 11) rows buffered */
rc = dbgetrow(dbproc, 46);
assert(rc == REG_ROW);
verify(46, testint, teststr); /* last buffered row should be 46 */
/* Attempt dbnextrow when buffer has no space (10 out of 10 in use). */
rc = dbnextrow(dbproc);
assert(rc == BUF_FULL);
dbclrbuf(dbproc, 3); /* remove rows 37, 38, and 39 */
rc = dbnextrow(dbproc);
assert(rc == REG_ROW);
verify(47, testint, teststr); /* fetch row from database, should be 47 */
rc = dbnextrow(dbproc);
assert(rc == REG_ROW);
verify(48, testint, teststr); /* fetch row from database, should be 48 */
/* buffer contains 8 rows (40-47) try removing 10 rows */
dbclrbuf(dbproc, buffer_count);
while (dbnextrow(dbproc) != NO_MORE_ROWS) {
/* waste rows 49-50 */
}
dbclose(dbproc); /* close while buffer not cleared: OK */
dbexit();
fprintf(stdout, "%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
int
main(int argc, char **argv)
{
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]);
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, "t0008");
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();
dbloginfree(login);
add_bread_crumb();
#ifdef MICROSOFT_DBLIB
dbsetopt(dbproc, DBBUFFER, "25");
#else
dbsetopt(dbproc, DBBUFFER, "25", 0);
#endif
add_bread_crumb();
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);
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, 0, (BYTE *) & testint);
add_bread_crumb();
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
add_bread_crumb();
add_bread_crumb();
for (i = 1; i <= rows_to_add; i++) {
char expected[1024];
sprintf(expected, "row %03d", i);
add_bread_crumb();
if (i % 25 == 0) {
dbclrbuf(dbproc, 25);
}
add_bread_crumb();
if (REG_ROW != dbnextrow(dbproc)) {
fprintf(stderr, "dblib failed for %s, dbnextrow1\n", __FILE__);
add_bread_crumb();
dbexit();
add_bread_crumb();
free_bread_crumb();
return 1;
}
add_bread_crumb();
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__);
add_bread_crumb();
dbexit();
add_bread_crumb();
free_bread_crumb();
return 1;
}
add_bread_crumb();
dbexit();
add_bread_crumb();
fprintf(stdout, "%s %s (last_read: %d)\n", __FILE__, ((last_read != rows_to_add)? "failed!" : "OK"), (int) last_read);
free_bread_crumb();
return (last_read == rows_to_add) ? 0 : 1;
}
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);
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, "rpc");
dberrhandle(ignore_err_handler);
DBSETLPACKET(login, -1);
dberrhandle(syb_err_handler);
fprintf(stdout, "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);
fprintf(stdout, "Created procedure %s\n", proc_name);
/* set up and send the rpc */
printf("executing dbrpcinit\n");
erc = dbrpcinit(dbproc, proc_name, 0); /* no options */
if (erc == FAIL) {
fprintf(stderr, "Failed 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));
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);
fprintf(stdout, "Dropping procedure\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
dbexit();
fprintf(stdout, "%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;
}
/* get_name is the only one of these that is implemented */
static const char *dbd_freetds_get_name(const apr_dbd_results_t *res, int n)
{
return (const char*) dbcolname(res->proc, n+1); /* numbering starts at 1 */
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
DBINT testint;
STATUS rc;
int i, iresults;
char teststr[1024];
const int buffer_count = 10;
const int rows_to_add = 50;
const char tablename[] = "#dblib0002";
const char drop_if_exists[] = "if exists ( select 1 "
"from tempdb..sysobjects "
"where id = object_id('tempdb..%s') )\n"
"\tdrop table %s\n";
set_malloc_options();
read_login_info(argc, argv);
fprintf(stdout, "Start\n");
add_bread_crumb();
/* Fortify_EnterScope(); */
dbinit();
add_bread_crumb();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
add_bread_crumb();
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0002");
fprintf(stdout, "About to open %s..%s\n", SERVER, DATABASE);
add_bread_crumb();
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
add_bread_crumb();
dbloginfree(login);
add_bread_crumb();
fprintf(stdout, "Setting row buffer to 10 rows\n");
#ifdef MICROSOFT_DBLIB
dbsetopt(dbproc, DBBUFFER, "10");
#else
dbsetopt(dbproc, DBBUFFER, "10", 0);
#endif
add_bread_crumb();
add_bread_crumb();
fprintf(stdout, drop_if_exists, tablename, tablename);
dbfcmd(dbproc, drop_if_exists, tablename, tablename);
add_bread_crumb();
dbsqlexec(dbproc);
add_bread_crumb();
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
if (dbresults(dbproc) != NO_MORE_RESULTS) {
fprintf(stdout, "Failed: dbresults call after NO_MORE_RESULTS should return NO_MORE_RESULTS.\n");
failed = 1;
}
add_bread_crumb();
fprintf(stdout, "create table %s (i int not null, s char(10) not null)\n", tablename);
dbfcmd(dbproc, "create table %s (i int not null, s char(10) not null)", tablename);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "insert into %s [%d rows]\n", tablename, rows_to_add);
for (i = 1; i <= rows_to_add; i++) {
char cmd[1024];
sprintf(cmd, "insert into %s values (%d, 'row %03d')", tablename, i, i);
dbcmd(dbproc, cmd);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
fprintf(stdout, "select * from %s order by i\n", tablename);
dbfcmd(dbproc, "select * from %s order by i\n", tablename);
dbfcmd(dbproc, "select * from %s order by i\n", tablename); /* two result sets */
dbsqlexec(dbproc);
add_bread_crumb();
for (iresults=1; iresults <= 2; iresults++ ) {
fprintf(stdout, "fetching resultset %i\n", iresults);
if (dbresults(dbproc) != SUCCEED) {
add_bread_crumb();
fprintf(stderr, "Was expecting a result set %d.\n", iresults);
if( iresults == 2 )
fprintf(stderr, "Buffering with multiple resultsets is broken.\n");
exit(1);
}
add_bread_crumb();
for (i = 1; i <= dbnumcols(dbproc); i++) {
add_bread_crumb();
printf("col %d is [%s]\n", i, dbcolname(dbproc, i));
add_bread_crumb();
}
add_bread_crumb();
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
add_bread_crumb();
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
add_bread_crumb();
/* Fetch a result set */
/* Second resultset stops at row 40 */
for (i=0; i < rows_to_add - (iresults == 2 ? buffer_count : 0);) {
fprintf(stdout, "clearing %d rows from buffer\n", buffer_count);
dbclrbuf(dbproc, buffer_count);
do {
int rc;
i++;
add_bread_crumb();
if (REG_ROW != (rc = dbnextrow(dbproc))) {
failed = 1;
fprintf(stderr, "Failed: Expected a row (%s:%d)\n", __FILE__, __LINE__);
if (rc == BUF_FULL)
fprintf(stderr, "Failed: dbnextrow returned BUF_FULL (%d). Fix dbclrbuf.\n", rc);
exit(1);
}
add_bread_crumb();
verify(i, testint, teststr);
} while (i % buffer_count);
if (iresults == 1 && i == rows_to_add) {
/* The buffer should be full */
assert(BUF_FULL == dbnextrow(dbproc));
}
}
if (iresults == 1) {
fprintf(stdout, "clearing %d rows from buffer\n", buffer_count);
dbclrbuf(dbproc, buffer_count);
while (dbnextrow(dbproc) != NO_MORE_ROWS) {
abort(); /* All rows were read: should not enter loop */
}
}
}
/*
* Now test the buffered rows.
* Should be operating on rows 31-40 of 2nd resultset
*/
rc = dbgetrow(dbproc, 1);
add_bread_crumb();
if(rc != NO_MORE_ROWS) /* row 1 is not among the 31-40 in the buffer */
fprintf(stderr, "Failed: dbgetrow returned %d.\n", rc);
assert(rc == NO_MORE_ROWS);
rc = dbgetrow(dbproc, 31);
add_bread_crumb();
if(rc != REG_ROW)
fprintf(stderr, "Failed: dbgetrow returned %d.\n", rc);
assert(rc == REG_ROW);
verify(31, testint, teststr); /* first buffered row should be 31 */
rc = dbnextrow(dbproc);
add_bread_crumb();
if(rc != REG_ROW)
fprintf(stderr, "Failed: dbgetrow returned %d.\n", rc);
assert(rc == REG_ROW);
verify(32, testint, teststr); /* next buffered row should be 32 */
rc = dbgetrow(dbproc, 11);
add_bread_crumb();
assert(rc == NO_MORE_ROWS); /* only 10 (not 11) rows buffered */
rc = dbgetrow(dbproc, 40);
add_bread_crumb();
assert(rc == REG_ROW);
verify(40, testint, teststr); /* last buffered row should be 40 */
/* Attempt dbnextrow when buffer has no space (10 out of 10 in use). */
rc = dbnextrow(dbproc);
assert(rc == BUF_FULL);
dbclrbuf(dbproc, 3); /* remove rows 31, 32, and 33 */
rc = dbnextrow(dbproc);
add_bread_crumb();
assert(rc == REG_ROW);
verify(41, testint, teststr); /* fetch row from database, should be 41 */
rc = dbnextrow(dbproc);
add_bread_crumb();
assert(rc == REG_ROW);
verify(42, testint, teststr); /* fetch row from database, should be 42 */
/* buffer contains 9 rows (34-42) try removing 10 rows */
dbclrbuf(dbproc, buffer_count);
while (dbnextrow(dbproc) != NO_MORE_ROWS) {
/* waste rows 43-50 */
}
dbclose(dbproc); /* close while buffer not cleared: OK */
add_bread_crumb();
dbexit();
add_bread_crumb();
fprintf(stdout, "dblib %s on %s\n", (failed ? "failed!" : "okay"), __FILE__);
free_bread_crumb();
return failed ? 1 : 0;
}
int
main(int argc, char **argv)
{
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);
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, "t0004");
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 = 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) {
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 <= 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))) {
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);
}
fprintf(stdout, "second select\n");
fprintf(stdout, "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;
}
}
fprintf(stdout, "<== end of command buffer\n");
if (SUCCEED != sql_cmd(dbproc)) {
fprintf(stderr, "%s:%d: dbcmd failed\n", __FILE__, __LINE__);
failed = 1;
}
fprintf(stdout, "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();
fprintf(stdout, "%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
RETPARAM save_param;
int i, r;
char teststr[1024];
int failed = 0;
char *retname = NULL;
int rettype = 0, retlen = 0;
int return_status = 0;
char proc[] = "#t0022",
param0[] = "@null_input",
param1[] = "@first_type",
param2[] = "@nullout",
param3[] = "@nrows",
param4[] = "@c";
char *proc_name = proc;
char param_data1[64];
int param_data2;
int param_data3;
RETCODE erc, row_code;
int num_resultset = 0;
int num_empty_resultset = 0;
static const char dashes5[] = "-----",
dashes15[] = "---------------",
dashes30[] = "------------------------------";
set_malloc_options();
memset(&save_param, 0, sizeof(save_param));
read_login_info(argc, argv);
fprintf(stdout, "Start\n");
add_bread_crumb();
dbinit();
add_bread_crumb();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
add_bread_crumb();
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "#t0022");
dberrhandle(ignore_err_handler);
DBSETLPACKET(login, -1);
dberrhandle(syb_err_handler);
fprintf(stdout, "About to open %s.%s\n", SERVER, DATABASE);
add_bread_crumb();
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
add_bread_crumb();
dbloginfree(login);
add_bread_crumb();
add_bread_crumb();
dberrhandle(ignore_err_handler);
dbmsghandle(ignore_msg_handler);
printf("trying to create a temporary stored procedure\n");
if (FAIL == init_proc(dbproc, proc_name)) {
printf("trying to create a permanent stored procedure\n");
if (FAIL == init_proc(dbproc, ++proc_name))
exit(EXIT_FAILURE);
}
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "Created procedure %s\n", proc_name);
/* set up and send the rpc */
printf("executing dbrpcinit\n");
erc = dbrpcinit(dbproc, proc_name, 0); /* no options */
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcinit\n");
failed = 1;
}
printf("executing dbrpcparam\n");
erc = dbrpcparam(dbproc, param0, DBRPCRETURN, SYBCHAR, /*maxlen= */ -1, /* datlen= */ 0, NULL);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcparam\n");
failed = 1;
}
printf("executing dbrpcparam\n");
erc = dbrpcparam(dbproc, param1, DBRPCRETURN, SYBCHAR, /*maxlen= */ sizeof(param_data1), /* datlen= */ 0, (BYTE *) & param_data1);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcparam\n");
failed = 1;
}
printf("executing dbrpcparam\n");
erc = dbrpcparam(dbproc, param2, DBRPCRETURN, SYBINT4, /*maxlen= */ -1, /* datalen= */ 0, (BYTE *) & param_data2);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcparam\n");
failed = 1;
}
printf("executing dbrpcparam\n");
erc = dbrpcparam(dbproc, param3, DBRPCRETURN, SYBINT4, /*maxlen= */ -1, /* datalen= */ -1, (BYTE *) & param_data3);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcparam\n");
failed = 1;
}
/* test for strange parameters using input */
printf("executing dbrpcparam\n");
erc = dbrpcparam(dbproc, param4, 0, SYBVARCHAR, /*maxlen= */ 0, /* datalen= */ 0, NULL);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcparam\n");
failed = 1;
}
printf("executing dbrpcsend\n");
param_data3 = 0x11223344;
erc = dbrpcsend(dbproc);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbrpcsend\n");
exit(1);
}
/* wait for it to execute */
printf("executing dbsqlok\n");
erc = dbsqlok(dbproc);
if (erc == FAIL) {
fprintf(stderr, "Failed: dbsqlok\n");
exit(1);
}
add_bread_crumb();
/* retrieve outputs per usual */
r = 0;
while ((erc = dbresults(dbproc)) != NO_MORE_RESULTS) {
if (erc == SUCCEED) {
const int ncols = dbnumcols(dbproc);
int empty_resultset = 1;
++num_resultset;
printf("bound 1 of %d columns ('%s') in result %d.\n", ncols, dbcolname(dbproc, 1), ++r);
dbbind(dbproc, 1, STRINGBIND, 0, (BYTE *) teststr);
printf("\t%s\n\t-----------\n", dbcolname(dbproc, 1));
while ((row_code = dbnextrow(dbproc)) != NO_MORE_ROWS) {
empty_resultset = 0;
if (row_code == REG_ROW) {
printf("\t%s\n", teststr);
} else {
/* not supporting computed rows in this unit test */
failed = 1;
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
}
printf("row count %d\n", (int) dbcount(dbproc));
if (empty_resultset)
++num_empty_resultset;
} else {
add_bread_crumb();
fprintf(stderr, "Expected a result set.\n");
exit(1);
}
} /* while dbresults */
/* check return status */
printf("retrieving return status...\n");
if (dbhasretstat(dbproc) == TRUE) {
printf("%d\n", return_status = dbretstatus(dbproc));
} else {
printf("none\n");
}
/*
* Check output parameter values
*/
if (dbnumrets(dbproc) < 4) { /* dbnumrets missed something */
fprintf(stderr, "Expected 4 output parameters.\n");
exit(1);
}
printf("retrieving output parameters...\n");
printf("%-5s %-15s %5s %6s %-30s\n", "param", "name", "type", "length", "data");
printf("%-5s %-15s %5s %5s- %-30s\n", dashes5, dashes15, dashes5, dashes5, dashes30);
for (i = 1; i <= dbnumrets(dbproc); i++) {
add_bread_crumb();
retname = dbretname(dbproc, i);
rettype = dbrettype(dbproc, i);
retlen = dbretlen(dbproc, i);
dbconvert(dbproc, rettype, dbretdata(dbproc, i), retlen, SYBVARCHAR, (BYTE*) teststr, -1);
printf("%-5d %-15s %5d %6d %-30s\n", i, retname, rettype, retlen, teststr);
add_bread_crumb();
save_retparam(&save_param, retname, teststr, rettype, retlen);
}
/*
* Test the last parameter for expected outcome
*/
if ((save_param.name == NULL) || strcmp(save_param.name, param3)) {
fprintf(stderr, "Expected retname to be '%s', got ", param3);
if (save_param.name == NULL)
fprintf(stderr, "<NULL> instead.\n");
else
fprintf(stderr, "'%s' instead.\n", save_param.name);
exit(1);
}
if (strcmp(save_param.value, "3")) {
fprintf(stderr, "Expected retdata to be 3.\n");
exit(1);
}
if (save_param.type != SYBINT4) {
fprintf(stderr, "Expected rettype to be SYBINT4 was %d.\n", save_param.type);
exit(1);
}
if (save_param.len != 4) {
fprintf(stderr, "Expected retlen to be 4.\n");
exit(1);
}
if(42 != return_status) {
fprintf(stderr, "Expected status to be 42.\n");
exit(1);
}
printf("Good: Got 4 output parameters and 1 return status of %d.\n", return_status);
/* Test number of result sets */
if (num_resultset != 3) {
fprintf(stderr, "Expected 3 resultset got %d.\n", num_resultset);
exit(1);
}
if (num_empty_resultset != 1) {
fprintf(stderr, "Expected an empty resultset got %d.\n", num_empty_resultset);
exit(1);
}
printf("Good: Got %d resultsets and %d empty resultset.\n", num_resultset, num_empty_resultset);
add_bread_crumb();
fprintf(stdout, "Dropping procedure\n");
add_bread_crumb();
sprintf(cmd, "DROP PROCEDURE %s", proc_name);
dbcmd(dbproc, cmd);
add_bread_crumb();
dbsqlexec(dbproc);
add_bread_crumb();
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
add_bread_crumb();
dbexit();
add_bread_crumb();
fprintf(stdout, "dblib %s on %s\n", (failed ? "failed!" : "okay"), __FILE__);
free_bread_crumb();
free(save_param.name);
free(save_param.value);
return failed ? 1 : 0;
}
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)
continue;
}
}
}
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[])
{
LOGINREC *login;
DBPROCESS *dbproc;
int i;
DBINT rowint;
DBCHAR rowchar[2];
DBCHAR rowdate[32];
DBINT rowtype;
DBINT computeint;
DBCHAR computedate[32];
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, "t0023");
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) == SUCCEED) {
/* nop */
}
fprintf(stdout, "insert\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) == SUCCEED) {
/* nop */
}
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) == SUCCEED) {
/* nop */
}
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) == SUCCEED) {
/* nop */
}
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) == SUCCEED) {
/* nop */
}
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) == SUCCEED) {
/* nop */
}
fprintf(stdout, "select\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
failed = 1;
fprintf(stdout, "Was expecting a result set.\n");
exit(1);
}
for (i = 1; i <= dbnumcols(dbproc); i++)
printf("col %d is %s\n", i, dbcolname(dbproc, i));
fprintf(stdout, "binding row columns\n");
if (SUCCEED != dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & rowint)) {
failed = 1;
fprintf(stderr, "Had problem with bind col1\n");
abort();
}
if (SUCCEED != dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) rowchar)) {
failed = 1;
fprintf(stderr, "Had problem with bind col2\n");
abort();
}
if (SUCCEED != dbbind(dbproc, 3, STRINGBIND, 0, (BYTE *) rowdate)) {
failed = 1;
fprintf(stderr, "Had problem with bind col3\n");
abort();
}
fprintf(stdout, "testing compute clause 1\n");
if (dbnumalts(dbproc, 1) != 1) {
failed = 1;
fprintf(stderr, "Had problem with dbnumalts 1\n");
abort();
}
if (dbalttype(dbproc, 1, 1) != SYBINT4) {
failed = 1;
fprintf(stderr, "Had problem with dbalttype 1, 1\n");
abort();
}
if (dbaltcolid(dbproc, 1, 1) != 1) {
failed = 1;
fprintf(stderr, "Had problem with dbaltcolid 1, 1\n");
abort();
}
if (dbaltop(dbproc, 1, 1) != SYBAOPSUM) {
failed = 1;
fprintf(stderr, "Had problem with dbaltop 1, 1\n");
abort();
}
if (SUCCEED != dbaltbind(dbproc, 1, 1, INTBIND, 0, (BYTE *) & computeint)) {
failed = 1;
fprintf(stderr, "Had problem with dbaltbind 1, 1\n");
abort();
}
fprintf(stdout, "testing compute clause 2\n");
if (dbnumalts(dbproc, 2) != 1) {
failed = 1;
fprintf(stderr, "Had problem with dbnumalts 2\n");
abort();
}
if (dbalttype(dbproc, 2, 1) != SYBDATETIME) {
failed = 1;
fprintf(stderr, "Had problem with dbalttype 2, 1\n");
abort();
}
if (dbaltcolid(dbproc, 2, 1) != 3) {
failed = 1;
fprintf(stderr, "Had problem with dbaltcolid 2, 1\n");
abort();
}
if (dbaltop(dbproc, 2, 1) != SYBAOPMAX) {
failed = 1;
fprintf(stderr, "Had problem with dbaltop 2, 1\n");
abort();
}
if (SUCCEED != dbaltbind(dbproc, 2, 1, STRINGBIND, -1, (BYTE *) computedate)) {
failed = 1;
fprintf(stderr, "Had problem with dbaltbind 2, 1\n");
abort();
}
while ((rowtype = dbnextrow(dbproc)) != NO_MORE_ROWS) {
if (rowtype == REG_ROW) {
printf("gotten a regular row\n");
}
if (rowtype == 1) {
printf("gotten a compute row for clause 1\n");
printf("value of sum(col1) = %d\n", computeint);
}
if (rowtype == 2) {
printf("gotten a compute row for clause 2\n");
printf("value of max(col3) = %s\n", computedate);
}
}
dbexit();
fprintf(stdout, "%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, "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, "t0006");
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();
dbloginfree(login);
add_bread_crumb();
#ifdef MICROSOFT_DBLIB
dbsetopt(dbproc, DBBUFFER, "5000");
#else
dbsetopt(dbproc, DBBUFFER, "5000", 0);
#endif
add_bread_crumb();
fprintf(stdout, "creating table\n");
dbcmd(dbproc, "create table #dblib0006 (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 #dblib0006 values (%d, 'row %04d')", i, i);
dbcmd(dbproc, cmd);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
fprintf(stdout, "first select\n");
if (SUCCEED != dbcmd(dbproc, "select * from #dblib0006 where i<50 order by i")) {
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;
}
add_bread_crumb();
if (dbresults(dbproc) != SUCCEED) {
add_bread_crumb();
fprintf(stdout, "%s:%d: Was expecting a result set.", __FILE__, __LINE__);
failed = 1;
exit(1);
}
add_bread_crumb();
for (i = 1; i <= dbnumcols(dbproc); i++) {
add_bread_crumb();
printf("col %d is %s\n", i, dbcolname(dbproc, i));
add_bread_crumb();
}
add_bread_crumb();
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
add_bread_crumb();
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
add_bread_crumb();
get_results(dbproc, 1);
add_bread_crumb();
testint = -1;
strcpy(teststr, "bogus");
fprintf(stdout, "second select\n");
dbcmd(dbproc, "select * from #dblib0006 where i>=25 order by i");
dbsqlexec(dbproc);
add_bread_crumb();
if ((rc = dbresults(dbproc)) != SUCCEED) {
add_bread_crumb();
fprintf(stdout, "%s:%d: Was expecting a result set. (rc=%d)\n", __FILE__, __LINE__, rc);
failed = 1;
}
if (!failed) {
add_bread_crumb();
add_bread_crumb();
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
add_bread_crumb();
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
add_bread_crumb();
get_results(dbproc, 25);
}
add_bread_crumb();
dbexit();
add_bread_crumb();
fprintf(stdout, "dblib %s on %s\n", (failed ? "failed!" : "okay"), __FILE__);
free_bread_crumb();
return failed ? 1 : 0;
}
int
main(int argc, char **argv)
{
const int rows_to_add = 50;
LOGINREC *login;
DBPROCESS *dbproc;
int i;
char teststr[1024];
DBINT testint;
int failed = 0;
int expected_error;
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, "t0005");
DBSETLHOST(login, "ntbox.dntis.ro");
fprintf(stdout, "About to open\n");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
fprintf(stdout, "creating table\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: dbcmd failed\n", __FILE__, __LINE__);
failed = 1;
}
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 */
}
}
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));
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
for (i = 1; i < 5; i++) {
char expected[1024];
sprintf(expected, "row %04d", i);
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))) {
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);
}
fprintf(stdout, "This query should succeeded as we have fetched the exact\n"
"number of rows in the result set\n");
expected_error = 20019;
dbsetuserdata(dbproc, (BYTE*) &expected_error);
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 should have succeeded but didn't\n", __FILE__, __LINE__);
failed = 1;
}
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 < 5; i++) {
char expected[1024];
sprintf(expected, "row %04d", i);
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))) {
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);
}
fprintf(stdout, "Testing anticipated failure\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 should have failed but didn't\n", __FILE__, __LINE__);
failed = 1;
}
fprintf(stdout, "calling dbcancel to flush results\n");
dbcancel(dbproc);
fprintf(stdout, "Dropping proc\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "creating proc\n");
sql_cmd(dbproc);
if (dbsqlexec(dbproc) == FAIL) {
fprintf(stderr, "%s:%d: failed to create procedure\n", __FILE__, __LINE__);
failed = 1;
}
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "calling proc\n");
sql_cmd(dbproc);
if (dbsqlexec(dbproc) == FAIL) {
fprintf(stderr, "%s:%d: failed to call procedure\n", __FILE__, __LINE__);
failed = 1;
}
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 < 6; i++) {
char expected[1024];
sprintf(expected, "row %04d", i);
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))) {
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);
}
fprintf(stdout, "Calling dbsqlexec before dbnextrow returns NO_MORE_ROWS\n");
fprintf(stdout, "The following command should succeed because\n"
"we have fetched the exact number of rows in the result set\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 should have succeeded but didn't\n", __FILE__, __LINE__);
failed = 1;
}
dbcancel(dbproc);
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
dbexit();
fprintf(stdout, "%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
int i,r, failed = 0;
RETCODE erc, row_code;
int num_resultset = 0;
char teststr[1024];
/*
* Connect to server
*/
set_malloc_options();
read_login_info(argc, argv);
fprintf(stdout, "Starting %s\n", argv[0]);
dbinit();
dberrhandle(timeout_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "#t0022");
fprintf(stdout, "About to open %s.%s\n", SERVER, DATABASE);
/*
* One way to test the login timeout is to connect to a discard server (grep discard /etc/services).
* It's normally supported by inetd.
*/
printf ("using %d 1-second login timeouts\n", max_timeouts);
dbsetlogintime(1);
start_time = time(NULL); /* keep track of when we started for reporting purposes */
if (NULL == (dbproc = dbopen(login, SERVER))){
fprintf(stderr, "Failed: dbopen\n");
exit(1);
}
printf ("connected.\n");
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
/* send something that will take awhile to execute */
printf ("using %d %d-second query timeouts\n", max_timeouts, timeout_seconds);
if (FAIL == dbsettime(timeout_seconds)) {
fprintf(stderr, "Failed: dbsettime\n");
exit(1);
}
printf ("issuing a query that will take 30 seconds\n");
if (FAIL == sql_cmd(dbproc)) {
fprintf(stderr, "Failed: dbcmd\n");
exit(1);
}
start_time = time(NULL);
ntimeouts = 0;
dbsetinterrupt(dbproc, (void*)chkintr, (void*)hndlintr);
if (FAIL == dbsqlsend(dbproc)) {
fprintf(stderr, "Failed: dbsend\n");
exit(1);
}
/* wait for it to execute */
printf("executing dbsqlok\n");
erc = dbsqlok(dbproc);
if (erc != FAIL) {
fprintf(stderr, "dbsqlok should fail for timeout\n");
exit(1);
}
/* retrieve outputs per usual */
r = 0;
for (i=0; (erc = dbresults(dbproc)) != NO_MORE_RESULTS; i++) {
int nrows, ncols;
switch (erc) {
case SUCCEED:
if (DBROWS(dbproc) == FAIL){
r++;
continue;
}
assert(DBROWS(dbproc) == SUCCEED);
printf("dbrows() returned SUCCEED, processing rows\n");
ncols = dbnumcols(dbproc);
++num_resultset;
printf("bound 1 of %d columns ('%s') in result %d.\n", ncols, dbcolname(dbproc, 1), ++r);
dbbind(dbproc, 1, STRINGBIND, 0, (BYTE *) teststr);
printf("\t%s\n\t-----------\n", dbcolname(dbproc, 1));
while ((row_code = dbnextrow(dbproc)) != NO_MORE_ROWS) {
if (row_code == REG_ROW) {
printf("\t%s\n", teststr);
} else {
/* not supporting computed rows in this unit test */
failed = 1;
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
}
nrows = (int) dbcount(dbproc);
printf("row count %d\n", nrows);
if (nrows < 0){
failed++;
printf("error: dbrows() returned SUCCEED, but dbcount() returned -1\n");
}
break;
case FAIL:
printf("dbresults returned FAIL\n");
exit(1);
default:
printf("unexpected return code %d from dbresults\n", erc);
exit(1);
}
if ( i > 1) {
failed++;
break;
}
} /* while dbresults */
dbexit();
fprintf(stdout, "%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
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;
}
ret = asprintf(&metacompute[i]->meta[c].name, "%s(%s)", dbprtype(dbaltop(dbproc, i+1, c+1)), colname);
if (ret < 0) {
fprintf(stderr, "%s:%d: asprintf(), column %d failed\n", options.appname, __LINE__, c+1);
return;
}
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)
{
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, "t0015");
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 */
}
}
fprintf(stdout, "select\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
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();
}
if (REG_ROW != dbnextrow(dbproc)) {
failed = 1;
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
dbcancel(dbproc);
fprintf(stdout, "select 2\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
failed = 1;
fprintf(stdout, "Was expecting a result set.");
exit(1);
}
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 = 26; 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);
}
dbexit();
fprintf(stdout, "%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
