static VALUE rb_tinytds_execute(VALUE self, VALUE sql) {
GET_CLIENT_WRAPPER(self);
rb_tinytds_client_reset_userdata(cwrap->userdata);
REQUIRE_OPEN_CLIENT(cwrap);
dbcmd(cwrap->client, StringValuePtr(sql));
if (dbsqlsend(cwrap->client) == FAIL) {
rb_warn("TinyTds: dbsqlsend() returned FAIL.\n");
return Qfalse;
}
cwrap->userdata->dbsql_sent = 1;
VALUE result = rb_tinytds_new_result_obj(cwrap);
rb_iv_set(result, "@query_options", rb_funcall(rb_iv_get(self, "@query_options"), intern_dup, 0));
GET_RESULT_WRAPPER(result);
rwrap->local_offset = rb_funcall(cTinyTdsClient, intern_local_offset, 0);
rwrap->encoding = cwrap->encoding;
return result;
}
// db, statement, callback
static v8::Handle<Value> ExecuteStatement(const Arguments& args) {
v8::HandleScope scope;
REQ_DBCONN_ARG(0);
REQ_STR_ARG(1, stmt);
REQ_FUN_ARG(2, cb);
v8::String::Utf8Value statement(stmt);
if(dbcmd(dbconn, *statement) == FAIL){
return v8::ThrowException(v8::Exception::Error(v8::String::New("FreeTDS could allocate enough memory for the statement")));
}
data_callback_t *callbackData = new data_callback_t();
callbackData->dbconn = dbconn;
callbackData->callback = Persistent<Function>::New(cb);
if(dbsqlsend(dbconn) == FAIL){
return v8::ThrowException(v8::Exception::Error(v8::String::New("FreeTDS could not send the statement")));
}
eio_custom(waitForDataResponse, EIO_PRI_DEFAULT, onDataResponse, callbackData);
return v8::Undefined();
}
/**
* The purpose of this program is threefold:
*
* 1. To provide a generalized SQL processor suitable for testing db-lib.
* 2. To offer a robust batch-oriented SQL processor suitable for use in a production environment.
* 3. To serve as a model example of how to use db-lib functions.
*
* These purposes may be somewhat at odds with one another. For instance, the tutorial aspect calls for
* explanatory comments that wouldn't appear in production code. Nevertheless, I hope the experienced
* reader will forgive the verbosity and still find the program useful.
*
* \todo The error/message handlers are not robust enough. They should anticipate certain conditions
* and cause the application to retry the operation.
*/
int
main(int argc, char *argv[])
{
LOGINREC *login;
DBPROCESS *dbproc;
RETCODE erc;
setlocale(LC_ALL, "");
/* Initialize db-lib */
erc = dbinit();
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbinit() failed\n", options.appname, __LINE__);
exit(1);
}
/* Install our error and message handlers */
dberrhandle(err_handler);
dbmsghandle(msg_handler);
memset(&options, 0, sizeof(options));
options.headers = stderr;
login = get_login(argc, argv, &options); /* get command-line parameters and call dblogin() */
assert(login != NULL);
/*
* Override stdin, stdout, and stderr, as required
*/
if (options.input_filename) {
if (freopen(options.input_filename, "r", stdin) == NULL) {
fprintf(stderr, "%s: unable to open %s: %s\n", options.appname, options.input_filename, strerror(errno));
exit(1);
}
}
if (options.output_filename) {
if (freopen(options.output_filename, "w", stdout) == NULL) {
fprintf(stderr, "%s: unable to open %s: %s\n", options.appname, options.output_filename, strerror(errno));
exit(1);
}
}
if (options.error_filename) {
if (freopen(options.error_filename, "w", stderr) == NULL) {
fprintf(stderr, "%s: unable to open %s: %s\n", options.appname, options.error_filename, strerror(errno));
exit(1);
}
}
if (options.fverbose) {
options.verbose = stderr;
} else {
static const char null_device[] = NULL_DEVICE;
options.verbose = fopen(null_device, "w");
if (options.verbose == NULL) {
fprintf(stderr, "%s:%d unable to open %s for verbose operation: %s\n",
options.appname, __LINE__, null_device, strerror(errno));
exit(1);
}
}
fprintf(options.verbose, "%s:%d: Verbose operation enabled\n", options.appname, __LINE__);
/*
* Connect to the server
*/
if ((dbproc = dbopen(login, options.servername)) == NULL)
return 1;
/* Switch to the specified database, if any */
if (options.database)
dbuse(dbproc, options.database);
/*
* Read the queries and write the results
*/
while (next_query(dbproc) != -1 ) {
/* Send the query to the server (we could use dbsqlexec(), instead) */
erc = dbsqlsend(dbproc);
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbsqlsend() failed\n", options.appname, __LINE__);
exit(1);
}
fprintf(options.verbose, "%s:%d: dbsqlsend(): OK\n", options.appname, __LINE__);
/* Wait for it to execute */
erc = dbsqlok(dbproc);
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbsqlok() failed\n", options.appname, __LINE__);
exit(1);
}
fprintf(options.verbose, "%s:%d: dbsqlok(): OK\n", options.appname, __LINE__);
/* Write the output */
print_results(dbproc);
}
return 0;
}
/**
* The purpose of this program is to load or extract the text of a stored procedure.
* This first cut does extract only.
* TODO: support loading procedures onto the server.
*/
int
main(int argc, char *argv[])
{
LOGINREC *login;
DBPROCESS *dbproc;
PROCEDURE procedure;
RETCODE erc;
int i, nrows;
/* Initialize db-lib */
erc = dbinit();
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbinit() failed\n", options.appname, __LINE__);
exit(1);
}
memset(&options, 0, sizeof(options));
login = get_login(argc, argv, &options); /* get command-line parameters and call dblogin() */
assert(login != NULL);
/* Install our error and message handlers */
dberrhandle(err_handler);
dbmsghandle(msg_handler);
/*
* Override stdin, stdout, and stderr, as required
*/
if (options.input_filename) {
if (freopen(options.input_filename, "r", stdin) == NULL) {
fprintf(stderr, "%s: unable to open %s: %s\n", options.appname, options.input_filename, strerror(errno));
exit(1);
}
}
if (options.output_filename) {
if (freopen(options.output_filename, "w", stdout) == NULL) {
fprintf(stderr, "%s: unable to open %s: %s\n", options.appname, options.output_filename, strerror(errno));
exit(1);
}
}
/*
* Connect to the server
*/
dbproc = dbopen(login, options.servername);
assert(dbproc != NULL);
/* Switch to the specified database, if any */
if (options.database)
dbuse(dbproc, options.database);
/*
* Read the procedure names and move their texts.
*/
for (i=options.optind; i < argc; i++) {
static const char query[] = " select c.text"
" from syscomments as c"
" join sysobjects as o"
" on o.id = c.id"
" where o.name = '%s'"
" and o.uid = user_id('%s')"
" and o.type not in ('U', 'S')" /* no user or system tables */
" order by c.colid"
;
static const char query_table[] = " execute sp_help '%s.%s' ";
parse_argument(argv[i], &procedure);
erc = dbfcmd(dbproc, query, procedure.name, procedure.owner);
/* Send the query to the server (we could use dbsqlexec(), instead) */
erc = dbsqlsend(dbproc);
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbsqlsend() failed\n", options.appname, __LINE__);
exit(1);
}
/* Wait for it to execute */
erc = dbsqlok(dbproc);
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbsqlok() failed\n", options.appname, __LINE__);
exit(1);
}
/* Write the output */
nrows = print_results(dbproc);
if (0 == nrows) {
erc = dbfcmd(dbproc, query_table, procedure.owner, procedure.name);
erc = dbsqlexec(dbproc);
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbsqlexec() failed\n", options.appname, __LINE__);
exit(1);
}
nrows = print_ddl(dbproc, &procedure);
}
switch (nrows) {
case -1:
return 1;
case 0:
fprintf(stderr, "%s: error: %s.%s.%s.%s not found\n", options.appname,
options.servername, options.database, procedure.owner, procedure.name);
return 2;
default:
break;
}
}
return 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;
}
