DatabaseResultSet* TdsDatabaseLayer::RunQueryWithResults(const wxString& strQuery)
{
ResetErrorCodes();
if (m_pDatabase != NULL)
{
FreeAllocatedResultSets();
wxArrayString QueryArray = ParseQueries(strQuery);
for (unsigned int i=0; i<(QueryArray.size()-1); i++)
{
char* szErrorMessage = NULL;
wxString strErrorMessage = wxT("");
wxString sql = RemoveLastSemiColon(QueryArray[i]);
wxCharBuffer sqlBuffer = ConvertToUnicodeStream(sql);
//fprintf(stderr, "Running query '%s'\n", sqlBuffer);
int nReturn = tds_submit_query(m_pDatabase, sqlBuffer);
if (nReturn != TDS_SUCCEED)
{
//fprintf(stderr, "tds_submit_query() failed for query '%s'\n", sql.c_str());
FreeAllocatedResultSets();
ThrowDatabaseException();
return NULL;
}
FreeAllocatedResultSets();
}
// Create a Prepared statement for the last SQL statement and get a result set from it
wxString strQuery = RemoveLastSemiColon(QueryArray[QueryArray.size()-1]);
wxCharBuffer sqlBuffer = ConvertToUnicodeStream(strQuery);
//fprintf(stderr, "Running query (with results) '%s'\n", sqlBuffer);
int nReturn = tds_submit_query(m_pDatabase, sqlBuffer);
if (nReturn != TDS_SUCCEED)
{
//fprintf(stderr, "tds_submit_query() failed for query '%s'\n", sqlBuffer);
//fprintf(stderr, "tds_submit_query() failed for query '%s'\n", strQuery.c_str());
FreeAllocatedResultSets();
ThrowDatabaseException();
return NULL;
}
TdsResultSet* pResultSet = new TdsResultSet(m_pDatabase);
if (pResultSet)
pResultSet->SetEncoding(GetEncoding());
LogResultSetForCleanup(pResultSet);
//fprintf(stderr, "Returning result set\n");
return pResultSet;
}
else
{
return NULL;
}
}
SQLConn(Module* m, const SQLhost& hi)
: mod(m), host(hi), login(NULL), sock(NULL), context(NULL)
{
if (OpenDB())
{
std::string query("USE " + host.name);
if (tds_submit_query(sock, query.c_str()) == TDS_SUCCEED)
{
if (tds_process_simple_query(sock) != TDS_SUCCEED)
{
LoggingMutex->Lock();
ServerInstance->Logs->Log("m_mssql",LOG_DEFAULT, "WARNING: Could not select database " + host.name + " for DB with id: " + host.id);
LoggingMutex->Unlock();
CloseDB();
}
}
else
{
LoggingMutex->Lock();
ServerInstance->Logs->Log("m_mssql",LOG_DEFAULT, "WARNING: Could not select database " + host.name + " for DB with id: " + host.id);
LoggingMutex->Unlock();
CloseDB();
}
}
else
{
LoggingMutex->Lock();
ServerInstance->Logs->Log("m_mssql",LOG_DEFAULT, "WARNING: Could not connect to DB with id: " + host.id);
LoggingMutex->Unlock();
CloseDB();
}
}
/*
* pool_mbr_login open a single pool login, to be call at init time or
* to reconnect.
*/
static TDSSOCKET *
pool_mbr_login(TDS_POOL * pool)
{
TDSCONTEXT *context;
TDSLOGIN *login;
TDSSOCKET *tds;
TDSCONNECTION *connection;
int rc;
char *query;
char hostname[MAXHOSTNAMELEN];
login = tds_alloc_login();
tds_set_passwd(login, pool->password);
tds_set_user(login, pool->user);
tds_set_app(login, "tdspool");
#if HAVE_GETHOSTNAME
if (gethostname(hostname, MAXHOSTNAMELEN) < 0)
#endif
tds_strlcpy(hostname, "tdspool", MAXHOSTNAMELEN);
tds_set_host(login, hostname);
tds_set_library(login, "TDS-Library");
tds_set_server(login, pool->server);
tds_set_client_charset(login, "iso_1");
tds_set_language(login, "us_english");
tds_set_packet(login, 512);
context = tds_alloc_context(NULL);
tds = tds_alloc_socket(context, 512);
connection = tds_read_config_info(tds, login, context->locale);
if (!connection || tds_connect_and_login(tds, connection) != TDS_SUCCEED) {
tds_free_socket(tds);
tds_free_connection(connection);
/* what to do? */
fprintf(stderr, "Could not open connection to server %s\n", pool->server);
return NULL;
}
tds_free_connection(connection);
/*
* FIXME -- tds_connect_and_login no longer preallocates the in_buf need to
* do something like what tds_read_packet does
*/
tds->in_buf = (unsigned char *) calloc(BLOCKSIZ, 1);
if (pool->database && strlen(pool->database)) {
query = (char *) malloc(strlen(pool->database) + 5);
sprintf(query, "use %s", pool->database);
rc = tds_submit_query(tds, query);
free(query);
if (rc != TDS_SUCCEED) {
fprintf(stderr, "changing database failed\n");
return NULL;
}
if (tds_process_simple_query(tds) != TDS_SUCCEED)
return NULL;
}
return tds;
}
static void
exec_query(const char *query)
{
if (tds_submit_query(tds, query) != TDS_SUCCEED || tds_process_simple_query(tds) != TDS_SUCCEED) {
fprintf(stderr, "executing query failed\n");
exit(1);
}
}
static VALUE dh_do(VALUE self, VALUE sqlstring)
{
TDSSOCKET *tds;
Data_Get_Struct(rb_iv_get(self, "@tds_socket"), TDSSOCKET, tds);
if(tds_submit_query(tds,STR2CSTR(sqlstring)) != TDS_SUCCEED)
{
rb_raise(rb_eRuntimeError, "SQL-query failed (1)");
}
else
{
process_results(tds);
}
return Qnil;
} // dh_do
static VALUE dh_init(int argc, VALUE* argv, VALUE self)
{
VALUE db_user,
db_pass,
db_args,
db_name,
db_host,
tds_socket;
TDSSOCKET *tds;
/* Let's fill our variables... */
rb_scan_args(argc, argv, "2*", &db_user, &db_pass, &db_args);
db_args = rb_ary_shift(db_args);
if(db_args != Qnil)
{
db_args = rb_str_split(db_args, ":");
db_name = rb_ary_entry(db_args, 0);
db_host = rb_ary_entry(db_args, 1);
}
if(db_host == Qnil) { db_host = rb_str_new2("localhost"); }
/* Get a TDSSOCKET */
tds_socket = tdss_new(db_host, db_user, db_pass);
rb_iv_set(self, "@tds_socket", tds_socket);
Data_Get_Struct(tds_socket, TDSSOCKET, tds);
/* If the user submited a database-name, change to it */
if(db_name != Qnil)
{
if(tds_submit_query(tds,STR2CSTR(rb_str_concat(rb_str_new2("USE "), db_name))) != TDS_SUCCEED)
{
rb_raise(rb_eRuntimeError, "SQL-USE failed (1)");
}
else
{
process_results(tds);
}
}
return self;
} // dh_init
int
main(int argc, char **argv)
{
TDSLOGIN *login;
TDSSOCKET *tds;
int verbose = 0;
int rc;
fprintf(stdout, "%s: Testing DB change -- 'use tempdb'\n", __FILE__);
rc = try_tds_login(&login, &tds, __FILE__, verbose);
if (rc != TDS_SUCCESS) {
fprintf(stderr, "try_tds_login() failed\n");
return 1;
}
rc = tds_submit_query(tds, "use tempdb");
if (rc != TDS_SUCCESS) {
fprintf(stderr, "tds_submit_query() failed\n");
return 1;
}
/* warning: this mucks with some internals to get the env chg message */
if (tds_process_simple_query(tds) != TDS_SUCCESS) {
fprintf(stderr, "query results failed\n");
return 1;
}
if (!tds || !tds->conn->env.database) {
fprintf(stderr, "No database ??\n");
return 1;
}
/* Test currently disabled during TDSENV changes */
if (verbose) {
fprintf(stdout, "database changed to %s\n", tds->conn->env.database);
}
if (strcmp(tds->conn->env.database, "tempdb")) {
fprintf(stderr, "Wrong database, %s != tempdb\n", tds->conn->env.database);
return 1;
}
try_tds_logout(login, tds, verbose);
return 0;
}
static void
test_begin(const char *cmd)
{
TDS_INT result_type;
fprintf(stdout, "%s: Testing query\n", cmd);
if (tds_submit_query(tds, cmd) != TDS_SUCCESS)
fatal_error("tds_submit_query() failed");
if (tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_RESULTS) != TDS_SUCCESS)
fatal_error("tds_process_tokens() failed");
if (result_type != TDS_ROWFMT_RESULT)
fatal_error("expected row fmt() failed");
/* test columns results */
if (tds->current_results != tds->res_info)
fatal_error("wrong current_results");
}
// query database
int TdsDatabaseLayer::RunQuery(const wxString& strQuery, bool bParseQuery)
{
ResetErrorCodes();
if (m_pDatabase == NULL)
return false;
FreeAllocatedResultSets();
wxArrayString QueryArray;
if (bParseQuery)
QueryArray = ParseQueries(strQuery);
else
QueryArray.push_back(strQuery);
wxArrayString::iterator start = QueryArray.begin();
wxArrayString::iterator stop = QueryArray.end();
while (start != stop)
{
char* szErrorMessage = NULL;
wxString strErrorMessage = wxT("");
wxString sql = RemoveLastSemiColon(*start);
wxCharBuffer sqlBuffer = ConvertToUnicodeStream(sql);
//fprintf(stderr, "Running query '%s'\n", (const char*)sqlBuffer);
int nReturn = tds_submit_query(m_pDatabase, sqlBuffer);
if (nReturn != TDS_SUCCEED)
{
//fprintf(stderr, "tds_submit_query() failed for query '%s'\n", sqlBuffer);
//fprintf(stderr, "tds_submit_query() failed for query '%s'\n", (sql).c_str());
FreeAllocatedResultSets();
ThrowDatabaseException();
return false;
}
FreeAllocatedResultSets();
start++;
}
return true;
}
/* Run query for which there should be no return results */
int
run_query(TDSSOCKET * tds, const char *query)
{
int rc;
int result_type;
rc = tds_submit_query(tds, query);
if (rc != TDS_SUCCESS) {
fprintf(stderr, "tds_submit_query() failed for query '%s'\n", query);
return TDS_FAIL;
}
while ((rc = tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_RESULTS)) == TDS_SUCCESS) {
switch (result_type) {
case TDS_DONE_RESULT:
case TDS_DONEPROC_RESULT:
case TDS_DONEINPROC_RESULT:
/* ignore possible spurious result (TDS7+ send it) */
case TDS_STATUS_RESULT:
break;
default:
fprintf(stderr, "Error: query should not return results\n");
return TDS_FAIL;
}
}
if (rc == TDS_FAIL) {
fprintf(stderr, "tds_process_tokens() returned TDS_FAIL for '%s'\n", query);
return TDS_FAIL;
} else if (rc != TDS_NO_MORE_RESULTS) {
fprintf(stderr, "tds_process_tokens() unexpected return\n");
return TDS_FAIL;
}
return TDS_SUCCESS;
}
int
main(int argc, char **argv)
{
TDSLOGIN *login;
TDSSOCKET *tds;
int verbose = 0;
int rc;
int row_count, i;
/* variables for conversions */
TDSCOLUMN *curcol;
TDSRESULTINFO *resinfo;
unsigned char *src;
CONV_RESULT cr;
TDS_INT srctype, srclen;
int src_id = 0;
double src_val;
double src_err;
double tolerance = 0.000001;
char sql[256];
int num_sybreal = 5;
float sybreal[5];
int num_sybflt8 = 7;
double sybflt8[7];
int result_type;
memset(&ctx, 0, sizeof(ctx));
sybreal[0] = 1.1;
sybreal[1] = 12345678;
sybreal[2] = 0.012345678;
sybreal[3] = 1.234567890e+20;
sybreal[4] = 1.234567890e-20;
sybflt8[0] = 1.1;
sybflt8[1] = 1234567890123456.0;
sybflt8[2] = 0.01234567890123456;
sybflt8[3] = 1.234567890123456e+20;
sybflt8[4] = 1.234567890123456e-20;
sybflt8[5] = 1.234567890123456e+200;
sybflt8[6] = 1.234567890123456e-200;
printf("%s: Test SYBREAL, SYBFLT8 values\n", __FILE__);
rc = try_tds_login(&login, &tds, __FILE__, verbose);
if (rc != TDS_SUCCEED) {
fprintf(stderr, "try_tds_login() failed\n");
return 1;
}
/*
* SYBREAL tests
*/
if (verbose)
printf("Starting SYBREAL tests\n");
rc = run_query(tds, "DROP TABLE #test_table");
if (rc != TDS_SUCCEED) {
return 1;
}
rc = run_query(tds, "CREATE TABLE #test_table (id int, val real)");
if (rc != TDS_SUCCEED) {
return 1;
}
for (i = 0; i < num_sybreal; i++) {
sprintf(sql, "INSERT #test_table (id, val) VALUES (%d, %.8g)", i, sybreal[i]);
if (verbose)
printf("%s\n", sql);
rc = run_query(tds, sql);
if (rc != TDS_SUCCEED) {
return 1;
}
}
rc = tds_submit_query(tds, "SELECT * FROM #test_table");
row_count = 0;
while ((rc = tds_process_tokens(tds, &result_type, NULL, TDS_RETURN_ROW|TDS_RETURN_COMPUTE)) == TDS_SUCCEED) {
switch (result_type) {
case TDS_ROW_RESULT:
resinfo = tds->res_info;
for (i = 0; i < resinfo->num_cols; i++) {
curcol = resinfo->columns[i];
src = curcol->column_data;
if (verbose) {
srctype = curcol->column_type;
srclen = curcol->column_size;
tds_convert(&ctx, srctype, (TDS_CHAR *) src, srclen, SYBCHAR, &cr);
printf("col %i is %s\n", i, cr.c);
}
if (i == 0) {
src_id = *(int *) src;
} else {
src_val = *(float *) src;
src_err = src_val - sybreal[src_id];
if (src_err != 0.0) {
src_err = src_err / src_val;
}
if (src_err < -tolerance || src_err > tolerance) {
fprintf(stderr, "SYBREAL expected %.8g got %.8g\n",
sybreal[src_id], src_val);
fprintf(stderr, "Error was %.4g%%\n", 100 * src_err);
return 1;
}
}
}
row_count++;
case TDS_COMPUTE_RESULT:
break;
default:
fprintf(stderr, "tds_process_tokens() unexpected result\n");
break;
}
}
if (rc != TDS_NO_MORE_RESULTS) {
fprintf(stderr, "tds_process_tokens() unexpected return\n");
}
/*
* SYBFLT8 tests
*/
if (verbose)
printf("Starting SYBFLT8 tests\n");
rc = run_query(tds, "DROP TABLE #test_table");
if (rc != TDS_SUCCEED) {
return 1;
}
rc = run_query(tds, "CREATE TABLE #test_table (id int, val float(48))");
if (rc != TDS_SUCCEED) {
return 1;
}
for (i = 0; i < num_sybflt8; i++) {
sprintf(sql, "INSERT #test_table (id, val) VALUES (%d, %.15g)", i, sybflt8[i]);
if (verbose)
printf("%s\n", sql);
rc = run_query(tds, sql);
if (rc != TDS_SUCCEED) {
return 1;
}
}
rc = tds_submit_query(tds, "SELECT * FROM #test_table");
while ((rc = tds_process_tokens(tds, &result_type, NULL, TDS_RETURN_ROW|TDS_RETURN_COMPUTE)) == TDS_SUCCEED) {
switch (result_type) {
case TDS_ROW_RESULT:
resinfo = tds->res_info;
for (i = 0; i < resinfo->num_cols; i++) {
curcol = resinfo->columns[i];
src = curcol->column_data;
if (verbose) {
srctype = curcol->column_type;
srclen = curcol->column_size;
tds_convert(&ctx, srctype, (TDS_CHAR *) src, srclen, SYBCHAR, &cr);
printf("col %i is %s\n", i, cr.c);
}
if (i == 0) {
src_id = *(int *) src;
} else {
memcpy(&src_val, src, 8);
src_err = src_val - sybflt8[src_id];
if (src_err != 0.0) {
src_err = src_err / src_val;
}
if (src_err < -tolerance || src_err > tolerance) {
fprintf(stderr, "SYBFLT8 expected %.16g got %.16g\n",
sybflt8[src_id], src_val);
fprintf(stderr, "Error was %.4g%%\n", 100 * src_err);
return 1;
}
}
}
case TDS_COMPUTE_RESULT:
break;
default:
fprintf(stderr, "tds_process_tokens() returned unexpected result\n");
break;
}
}
if (rc != TDS_NO_MORE_RESULTS) {
fprintf(stderr, "tds_process_tokens() unexpected return\n");
}
try_tds_logout(login, tds, verbose);
return 0;
}
static void
test(const char *type, const char *test_name)
{
char buf[256];
char tmp[256];
int i;
const char **s;
int rc;
TDS_INT result_type;
int done_flags;
sprintf(buf, "CREATE TABLE #tmp (i INT, t %s)", type);
query(buf);
/* insert all test strings in table */
for (i = 0, s = strings; *s; ++s, ++i) {
sprintf(buf, "insert into #tmp values(%d, N'%s')", i, to_utf8(*s, tmp));
query(buf);
}
/* do a select and check all results */
rc = tds_submit_query(tds, "select t from #tmp order by i");
if (rc != TDS_SUCCESS) {
fprintf(stderr, "tds_submit_query() failed\n");
exit(1);
}
if (tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_RESULTS) != TDS_SUCCESS) {
fprintf(stderr, "tds_process_tokens() failed\n");
exit(1);
}
if (result_type != TDS_ROWFMT_RESULT) {
fprintf(stderr, "expected row fmt() failed\n");
exit(1);
}
if (tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_RESULTS) != TDS_SUCCESS) {
fprintf(stderr, "tds_process_tokens() failed\n");
exit(1);
}
if (result_type != TDS_ROW_RESULT) {
fprintf(stderr, "expected row result() failed\n");
exit(1);
}
i = 0;
while ((rc = tds_process_tokens(tds, &result_type, NULL, TDS_RETURN_ROWFMT|TDS_RETURN_ROW|TDS_RETURN_COMPUTE)) == TDS_SUCCESS) {
switch (result_type) {
case TDS_ROW_RESULT: {
TDSCOLUMN *curcol = tds->current_results->columns[0];
char *src = (char *) curcol->column_data;
if (is_blob_col(curcol)) {
TDSBLOB *blob = (TDSBLOB *) src;
src = blob->textvalue;
}
strcpy(buf, to_utf8(strings[i], tmp));
if (strlen(buf) != curcol->column_cur_size || strncmp(buf, src, curcol->column_cur_size) != 0) {
int l = curcol->column_cur_size;
if (l > 200)
l = 200;
strncpy(tmp, src, l);
tmp[l] = 0;
fprintf(stderr, "Wrong result in test %s\n Got: '%s' len %d\n Expected: '%s' len %u\n", test_name, tmp,
curcol->column_cur_size, buf, (unsigned int) strlen(buf));
exit(1);
}
++i;
} break;
default:
fprintf(stderr, "Unexpected result\n");
exit(1);
break;
}
}
if (rc != TDS_NO_MORE_RESULTS) {
fprintf(stderr, "tds_process_tokens() unexpected return\n");
exit(1);
}
while ((rc = tds_process_tokens(tds, &result_type, &done_flags, TDS_TOKEN_RESULTS)) == TDS_SUCCESS) {
switch (result_type) {
case TDS_NO_MORE_RESULTS:
return;
case TDS_DONE_RESULT:
case TDS_DONEPROC_RESULT:
case TDS_DONEINPROC_RESULT:
if (!(done_flags & TDS_DONE_ERROR))
break;
default:
fprintf(stderr, "tds_process_tokens() unexpected result_type\n");
exit(1);
break;
}
}
query("DROP TABLE #tmp");
/* do sone select to test results */
/*
* for (s = strings; *s; ++s) {
* printf("%s\n", to_utf8(*s, tmp));
* }
*/
}
static int tds_log(struct ast_cdr *cdr)
{
char sqlcmd[2048], start[80], answer[80], end[80];
char *accountcode, *src, *dst, *dcontext, *clid, *channel, *dstchannel, *lastapp, *lastdata, *uniqueid;
int res = 0;
int retried = 0;
#ifdef FREETDS_PRE_0_62
TDS_INT result_type;
#endif
ast_mutex_lock(&tds_lock);
memset(sqlcmd, 0, 2048);
accountcode = anti_injection(cdr->accountcode, 20);
src = anti_injection(cdr->src, 80);
dst = anti_injection(cdr->dst, 80);
dcontext = anti_injection(cdr->dcontext, 80);
clid = anti_injection(cdr->clid, 80);
channel = anti_injection(cdr->channel, 80);
dstchannel = anti_injection(cdr->dstchannel, 80);
lastapp = anti_injection(cdr->lastapp, 80);
lastdata = anti_injection(cdr->lastdata, 80);
uniqueid = anti_injection(cdr->uniqueid, 32);
get_date(start, cdr->start);
get_date(answer, cdr->answer);
get_date(end, cdr->end);
sprintf(
sqlcmd,
"INSERT INTO cdr "
"("
"accountcode, "
"src, "
"dst, "
"dcontext, "
"clid, "
"channel, "
"dstchannel, "
"lastapp, "
"lastdata, "
"start, "
"answer, "
"[end], "
"duration, "
"billsec, "
"disposition, "
"amaflags, "
"uniqueid"
") "
"VALUES "
"("
"'%s', " /* accountcode */
"'%s', " /* src */
"'%s', " /* dst */
"'%s', " /* dcontext */
"'%s', " /* clid */
"'%s', " /* channel */
"'%s', " /* dstchannel */
"'%s', " /* lastapp */
"'%s', " /* lastdata */
"%s, " /* start */
"%s, " /* answer */
"%s, " /* end */
"%ld, " /* duration */
"%ld, " /* billsec */
"'%s', " /* disposition */
"'%s', " /* amaflags */
"'%s'" /* uniqueid */
")",
accountcode,
src,
dst,
dcontext,
clid,
channel,
dstchannel,
lastapp,
lastdata,
start,
answer,
end,
cdr->duration,
cdr->billsec,
ast_cdr_disp2str(cdr->disposition),
ast_cdr_flags2str(cdr->amaflags),
uniqueid
);
do {
if (!connected) {
if (mssql_connect())
ast_log(LOG_ERROR, "Failed to reconnect to SQL database.\n");
else
ast_log(LOG_WARNING, "Reconnected to SQL database.\n");
retried = 1; /* note that we have now tried */
}
#ifdef FREETDS_PRE_0_62
if (!connected || (tds_submit_query(tds, sqlcmd) != TDS_SUCCEED) || (tds_process_simple_query(tds, &result_type) != TDS_SUCCEED || result_type != TDS_CMD_SUCCEED))
#else
if (!connected || (tds_submit_query(tds, sqlcmd) != TDS_SUCCEED) || (tds_process_simple_query(tds) != TDS_SUCCEED))
#endif
{
ast_log(LOG_ERROR, "Failed to insert Call Data Record into SQL database.\n");
mssql_disconnect(); /* this is ok even if we are already disconnected */
}
} while (!connected && !retried);
free(accountcode);
free(src);
free(dst);
free(dcontext);
free(clid);
free(channel);
free(dstchannel);
free(lastapp);
free(lastdata);
free(uniqueid);
ast_mutex_unlock(&tds_lock);
return res;
}
static int mssql_connect(void)
{
#if (defined(FREETDS_0_63) || defined(FREETDS_0_64))
TDSCONNECTION *connection = NULL;
#else
TDSCONNECTINFO *connection = NULL;
#endif
char query[128];
/* Connect to M$SQL Server */
if (!(login = tds_alloc_login()))
{
ast_log(LOG_ERROR, "tds_alloc_login() failed.\n");
return -1;
}
tds_set_server(login, hostname);
tds_set_user(login, dbuser);
tds_set_passwd(login, password);
tds_set_app(login, "TSQL");
tds_set_library(login, "TDS-Library");
#ifndef FREETDS_PRE_0_62
tds_set_client_charset(login, charset);
#endif
tds_set_language(login, language);
tds_set_packet(login, 512);
tds_set_version(login, 7, 0);
#ifdef FREETDS_0_64
if (!(context = tds_alloc_context(NULL)))
#else
if (!(context = tds_alloc_context()))
#endif
{
ast_log(LOG_ERROR, "tds_alloc_context() failed.\n");
goto connect_fail;
}
if (!(tds = tds_alloc_socket(context, 512))) {
ast_log(LOG_ERROR, "tds_alloc_socket() failed.\n");
goto connect_fail;
}
tds_set_parent(tds, NULL);
connection = tds_read_config_info(tds, login, context->locale);
if (!connection)
{
ast_log(LOG_ERROR, "tds_read_config() failed.\n");
goto connect_fail;
}
if (tds_connect(tds, connection) == TDS_FAIL)
{
ast_log(LOG_ERROR, "Failed to connect to MSSQL server.\n");
tds = NULL; /* freed by tds_connect() on error */
#if (defined(FREETDS_0_63) || defined(FREETDS_0_64))
tds_free_connection(connection);
#else
tds_free_connect(connection);
#endif
connection = NULL;
goto connect_fail;
}
#if (defined(FREETDS_0_63) || defined(FREETDS_0_64))
tds_free_connection(connection);
#else
tds_free_connect(connection);
#endif
connection = NULL;
sprintf(query, "USE %s", dbname);
#ifdef FREETDS_PRE_0_62
if ((tds_submit_query(tds, query) != TDS_SUCCEED) || (tds_process_simple_query(tds, &result_type) != TDS_SUCCEED || result_type != TDS_CMD_SUCCEED))
#else
if ((tds_submit_query(tds, query) != TDS_SUCCEED) || (tds_process_simple_query(tds) != TDS_SUCCEED))
#endif
{
ast_log(LOG_ERROR, "Could not change database (%s)\n", dbname);
goto connect_fail;
}
connected = 1;
return 0;
connect_fail:
mssql_disconnect();
return -1;
}
bool
pool_user_send_login_ack(TDS_POOL * pool, TDS_POOL_USER * puser)
{
char msg[256];
char block[32];
TDSSOCKET *tds = puser->sock.tds, *mtds = puser->assigned_member->sock.tds;
TDSLOGIN *login = puser->login;
const char *database;
const char *server = mtds->conn->server ? mtds->conn->server : "JDBC";
bool dbname_mismatch, odbc_mismatch;
pool->user_logins++;
/* copy a bit of information, resize socket with block */
tds->conn->tds_version = mtds->conn->tds_version;
tds->conn->product_version = mtds->conn->product_version;
memcpy(tds->conn->collation, mtds->conn->collation, sizeof(tds->conn->collation));
tds->conn->tds71rev1 = mtds->conn->tds71rev1;
free(tds->conn->product_name);
tds->conn->product_name = strdup(mtds->conn->product_name);
tds_realloc_socket(tds, mtds->conn->env.block_size);
tds->conn->env.block_size = mtds->conn->env.block_size;
tds->conn->client_spid = mtds->conn->spid;
/* if database is different use USE statement */
database = pool->database;
dbname_mismatch = !tds_dstr_isempty(&login->database)
&& strcasecmp(tds_dstr_cstr(&login->database), database) != 0;
odbc_mismatch = (login->option_flag2 & TDS_ODBC_ON) == 0;
if (dbname_mismatch || odbc_mismatch) {
char *str;
int len = 128 + tds_quote_id(mtds, NULL, tds_dstr_cstr(&login->database),-1);
TDSRET ret;
if ((str = (char *) malloc(len)) == NULL)
return false;
str[0] = 0;
/* swicth to dblib options */
if (odbc_mismatch)
strcat(str, "SET ANSI_DEFAULTS OFF\nSET CONCAT_NULL_YIELDS_NULL OFF\n");
if (dbname_mismatch) {
strcat(str, "USE ");
tds_quote_id(mtds, strchr(str, 0), tds_dstr_cstr(&login->database), -1);
}
ret = tds_submit_query(mtds, str);
free(str);
if (TDS_FAILED(ret) || TDS_FAILED(tds_process_simple_query(mtds)))
return false;
if (dbname_mismatch)
database = tds_dstr_cstr(&login->database);
else
database = mtds->conn->env.database;
}
// 7.0
// env database
// database change message (with server name correct)
// env language
// language change message
// env 0x3 charset ("iso_1")
// env 0x5 lcid ("1033")
// env 0x6 ("196609" ?? 0x30001)
// loginack
// env 0x4 packet size
// done
//
// 7.1/7.2/7.3
// env database
// database change message (with server name correct)
// env 0x7 collation
// env language
// language change message
// loginack
// env 0x4 packet size
// done
tds->out_flag = TDS_REPLY;
tds_env_change(tds, TDS_ENV_DATABASE, "master", database);
sprintf(msg, "Changed database context to '%s'.", database);
tds_send_msg(tds, 5701, 2, 0, msg, server, NULL, 1);
if (!login->suppress_language) {
tds_env_change(tds, TDS_ENV_LANG, NULL, "us_english");
tds_send_msg(tds, 5703, 1, 0, "Changed language setting to 'us_english'.", server, NULL, 1);
}
if (IS_TDS71_PLUS(tds->conn)) {
tds_put_byte(tds, TDS_ENVCHANGE_TOKEN);
tds_put_smallint(tds, 8);
tds_put_byte(tds, TDS_ENV_SQLCOLLATION);
tds_put_byte(tds, 5);
tds_put_n(tds, tds->conn->collation, 5);
tds_put_byte(tds, 0);
}
tds_send_login_ack(tds, mtds->conn->product_name);
sprintf(block, "%d", tds->conn->env.block_size);
tds_env_change(tds, TDS_ENV_PACKSIZE, block, block);
/* tds_send_capabilities_token(tds); */
tds_send_done_token(tds, 0, 0);
/* send it! */
tds_flush_packet(tds);
tds_free_login(login);
puser->login = NULL;
return true;
}
int
main(int argc, char **argv)
{
TDSLOGIN *login;
TDSSOCKET *tds;
int verbose = 0;
int num_cols = 2;
TDS_INT result_type;
int rc;
int i, done_flags;
fprintf(stdout, "%s: Test basic submit query, results\n", __FILE__);
rc = try_tds_login(&login, &tds, __FILE__, verbose);
if (rc != TDS_SUCCESS) {
fprintf(stderr, "try_tds_login() failed\n");
return 1;
}
rc = tds_submit_query(tds, "select db_name() dbname, user_name() username");
if (rc != TDS_SUCCESS) {
fprintf(stderr, "tds_submit_query() failed\n");
return 1;
}
while ((rc = tds_process_tokens(tds, &result_type, &done_flags, TDS_TOKEN_RESULTS)) == TDS_SUCCESS) {
switch (result_type) {
case TDS_ROWFMT_RESULT:
if (tds->res_info->num_cols != num_cols) {
fprintf(stderr, "Error: num_cols != %d in %s\n", num_cols, __FILE__);
return 1;
}
if (tds->res_info->columns[0]->column_type != SYBVARCHAR
|| tds->res_info->columns[1]->column_type != SYBVARCHAR) {
fprintf(stderr, "Wrong column_type in %s\n", __FILE__);
return 1;
}
if (strcmp(tds_dstr_cstr(&tds->res_info->columns[0]->column_name), "dbname")
|| strcmp(tds_dstr_cstr(&tds->res_info->columns[1]->column_name), "username")) {
fprintf(stderr, "Wrong column_name in %s\n", __FILE__);
return 1;
}
break;
case TDS_ROW_RESULT:
while ((rc = tds_process_tokens(tds, &result_type, NULL, TDS_STOPAT_ROWFMT|TDS_RETURN_DONE|TDS_RETURN_ROW|TDS_RETURN_COMPUTE)) == TDS_SUCCESS) {
if (result_type != TDS_ROW_RESULT || result_type != TDS_COMPUTE_RESULT)
break;
if (verbose) {
for (i = 0; i < num_cols; i++) {
printf("col %i is %s\n", i, value_as_string(tds, i));
}
}
}
if (rc != TDS_SUCCESS) {
fprintf(stderr, "tds_process_tokens() unexpected return\n");
}
break;
case TDS_DONE_RESULT:
case TDS_DONEPROC_RESULT:
case TDS_DONEINPROC_RESULT:
if (!(done_flags & TDS_DONE_ERROR))
break;
default:
fprintf(stderr, "tds_process_tokens() unexpected result_type\n");
break;
}
}
if (rc != TDS_NO_MORE_RESULTS) {
fprintf(stderr, "tds_process_tokens() unexpected return\n");
}
try_tds_logout(login, tds, verbose);
return 0;
}
static VALUE rh_init(VALUE self)
{
SYBRESULT *sybres;
int i,
rc;
VALUE aRow,
allRows;
char *mystring;
int mystrlen;
Data_Get_Struct(self, SYBRESULT, sybres);
if(tds_submit_query(sybres->tds,sybres->sqlstring) != TDS_SUCCEED)
{
rb_raise(rb_eRuntimeError, "SQL-query failed (1)");
}
else
{
/*
Based on FreeTDS's src/tds/unittest/t0005.c
*/
allRows = rb_ary_new();
while ((rc=tds_process_result_tokens(sybres->tds))==TDS_SUCCEED)
{
while ((rc=tds_process_row_tokens(sybres->tds))==TDS_SUCCEED)
{
aRow = rb_ary_new();
for (i=0; i<sybres->tds->res_info->num_cols; i++)
{
/*
We're calling calloc for every column in every row to get the
memory for the string-conversion.
There are probably faster ways...
*/
if(sybres->tds->res_info->columns[i]->column_textvalue)
{ mystrlen=(sybres->tds->res_info->columns[i]->column_textsize)+1; }
else
{ mystrlen = 256; }
mystring = calloc(1, mystrlen);
if(mystring == NULL)
{
rb_raise(rb_eRuntimeError, "Couldn't malloc - out of memory? (1)");
}
value_as_string(mystring, mystrlen, sybres->tds, i);
rb_ary_push(aRow, rb_str_new2(mystring));
free(mystring);
}
rb_ary_push(allRows, aRow);
}
if (rc == TDS_FAIL)
{
rb_raise(rb_eRuntimeError, "tds_process_row_tokens() returned TDS_FAIL\n");
}
else if (rc != TDS_NO_MORE_ROWS)
{
rb_raise(rb_eRuntimeError, "tds_process_row_tokens() unexpected return\n");
}
}
if (rc == TDS_FAIL)
{
rb_raise(rb_eRuntimeError, "tds_process_result_tokens() returned TDS_FAIL for SELECT\n");
return 1;
}
else
if (rc != TDS_NO_MORE_RESULTS)
{
rb_raise(rb_eRuntimeError, "tds_process_result_tokens() unexpected return\n");
}
}
rb_iv_set(self, "@allRows", allRows);
return self;
} // rh_init
SQLerror Query(SQLrequest* req)
{
if (!sock)
return SQLerror(SQL_BAD_CONN, "Socket was NULL, check if SQL server is running.");
/* Pointer to the buffer we screw around with substitution in */
char* query;
/* Pointer to the current end of query, where we append new stuff */
char* queryend;
/* Total length of the unescaped parameters */
unsigned long maxparamlen, paramcount;
/* The length of the longest parameter */
maxparamlen = 0;
for(ParamL::iterator i = req->query.p.begin(); i != req->query.p.end(); i++)
{
if (i->size() > maxparamlen)
maxparamlen = i->size();
}
/* How many params are there in the query? */
paramcount = count(req->query.q.c_str(), '?');
/* This stores copy of params to be inserted with using numbered params 1;3B*/
ParamL paramscopy(req->query.p);
/* To avoid a lot of allocations, allocate enough memory for the biggest the escaped query could possibly be.
* sizeofquery + (maxtotalparamlength*2) + 1
*
* The +1 is for null-terminating the string
*/
query = new char[req->query.q.length() + (maxparamlen*paramcount*2) + 1];
queryend = query;
for(unsigned long i = 0; i < req->query.q.length(); i++)
{
if(req->query.q[i] == '?')
{
/* We found a place to substitute..what fun.
* use mssql calls to escape and write the
* escaped string onto the end of our query buffer,
* then we "just" need to make sure queryend is
* pointing at the right place.
*/
/* Is it numbered parameter?
*/
bool numbered;
numbered = false;
/* Numbered parameter number :|
*/
unsigned int paramnum;
paramnum = 0;
/* Let's check if it's a numbered param. And also calculate it's number.
*/
while ((i < req->query.q.length() - 1) && (req->query.q[i+1] >= '0') && (req->query.q[i+1] <= '9'))
{
numbered = true;
++i;
paramnum = paramnum * 10 + req->query.q[i] - '0';
}
if (paramnum > paramscopy.size() - 1)
{
/* index is out of range!
*/
numbered = false;
}
if (numbered)
{
/* Custom escaping for this one. converting ' to '' should make SQL Server happy. Ugly but fast :]
*/
char* escaped = new char[(paramscopy[paramnum].length() * 2) + 1];
char* escend = escaped;
for (std::string::iterator p = paramscopy[paramnum].begin(); p < paramscopy[paramnum].end(); p++)
{
if (*p == '\'')
{
*escend = *p;
escend++;
*escend = *p;
}
*escend = *p;
escend++;
}
*escend = 0;
for (char* n = escaped; *n; n++)
{
*queryend = *n;
queryend++;
}
delete[] escaped;
}
else if (req->query.p.size())
{
/* Custom escaping for this one. converting ' to '' should make SQL Server happy. Ugly but fast :]
*/
char* escaped = new char[(req->query.p.front().length() * 2) + 1];
char* escend = escaped;
for (std::string::iterator p = req->query.p.front().begin(); p < req->query.p.front().end(); p++)
{
if (*p == '\'')
{
*escend = *p;
escend++;
*escend = *p;
}
*escend = *p;
escend++;
}
*escend = 0;
for (char* n = escaped; *n; n++)
{
*queryend = *n;
queryend++;
}
delete[] escaped;
req->query.p.pop_front();
}
else
break;
}
else
{
*queryend = req->query.q[i];
queryend++;
}
}
*queryend = 0;
req->query.q = query;
MsSQLResult* res = new MsSQLResult((Module*)mod, req->source, req->id);
res->dbid = host.id;
res->query = req->query.q;
char* msquery = strdup(req->query.q.data());
LoggingMutex->Lock();
ServerInstance->Logs->Log("m_mssql",LOG_DEBUG,"doing Query: %s",msquery);
LoggingMutex->Unlock();
if (tds_submit_query(sock, msquery) != TDS_SUCCEED)
{
std::string error("failed to execute: "+std::string(req->query.q.data()));
delete[] query;
delete res;
free(msquery);
return SQLerror(SQL_QSEND_FAIL, error);
}
delete[] query;
free(msquery);
int tds_res;
while (tds_process_tokens(sock, &tds_res, NULL, TDS_TOKEN_RESULTS) == TDS_SUCCEED)
{
//ServerInstance->Logs->Log("m_mssql",LOG_DEBUG,"<******> result type: %d", tds_res);
//ServerInstance->Logs->Log("m_mssql",LOG_DEBUG,"AFFECTED ROWS: %d", sock->rows_affected);
switch (tds_res)
{
case TDS_ROWFMT_RESULT:
break;
case TDS_DONE_RESULT:
if (sock->rows_affected > -1)
{
for (int c = 0; c < sock->rows_affected; c++) res->UpdateAffectedCount();
continue;
}
break;
case TDS_ROW_RESULT:
while (tds_process_tokens(sock, &tds_res, NULL, TDS_STOPAT_ROWFMT|TDS_RETURN_DONE|TDS_RETURN_ROW) == TDS_SUCCEED)
{
if (tds_res != TDS_ROW_RESULT)
break;
if (!sock->current_results)
continue;
if (sock->res_info->row_count > 0)
{
int cols = sock->res_info->num_cols;
char** name = new char*[MAXBUF];
char** data = new char*[MAXBUF];
for (int j=0; j<cols; j++)
{
TDSCOLUMN* col = sock->current_results->columns[j];
name[j] = col->column_name;
int ctype;
int srclen;
unsigned char* src;
CONV_RESULT dres;
ctype = tds_get_conversion_type(col->column_type, col->column_size);
#if _TDSVER >= 82
src = col->column_data;
#else
src = &(sock->current_results->current_row[col->column_offset]);
#endif
srclen = col->column_cur_size;
tds_convert(sock->tds_ctx, ctype, (TDS_CHAR *) src, srclen, SYBCHAR, &dres);
data[j] = (char*)dres.ib;
}
ResultReady(res, cols, data, name);
}
}
break;
default:
break;
}
}
ResultsMutex->Lock();
results.push_back(res);
ResultsMutex->Unlock();
return SQLerror();
}
static int
do_query(TDSSOCKET * tds, char *buf, int opt_flags)
{
int rows = 0;
TDSRET rc;
int i;
TDSCOLUMN *col;
int ctype;
CONV_RESULT dres;
unsigned char *src;
TDS_INT srclen;
TDS_INT resulttype;
struct timeval start, stop;
int print_rows = 1;
char message[128];
rc = tds_submit_query(tds, buf);
if (TDS_FAILED(rc)) {
fprintf(stderr, "tds_submit_query() failed\n");
return 1;
}
while ((rc = tds_process_tokens(tds, &resulttype, NULL, TDS_TOKEN_RESULTS)) == TDS_SUCCESS) {
const int stop_mask = TDS_STOPAT_ROWFMT|TDS_RETURN_DONE|TDS_RETURN_ROW|TDS_RETURN_COMPUTE;
if (opt_flags & OPT_TIMER) {
gettimeofday(&start, NULL);
print_rows = 0;
}
switch (resulttype) {
case TDS_ROWFMT_RESULT:
if ((!(opt_flags & OPT_NOHEADER)) && tds->current_results) {
for (i = 0; i < tds->current_results->num_cols; i++) {
if (i) fputs(opt_col_term, stdout);
fputs(tds_dstr_cstr(&tds->current_results->columns[i]->column_name), stdout);
}
fputs(opt_row_term, stdout);
}
break;
case TDS_COMPUTE_RESULT:
case TDS_ROW_RESULT:
rows = 0;
while ((rc = tds_process_tokens(tds, &resulttype, NULL, stop_mask)) == TDS_SUCCESS) {
if (resulttype != TDS_ROW_RESULT && resulttype != TDS_COMPUTE_RESULT)
break;
rows++;
if (!tds->current_results)
continue;
for (i = 0; i < tds->current_results->num_cols; i++) {
col = tds->current_results->columns[i];
if (col->column_cur_size < 0) {
if (print_rows) {
if (i) fputs(opt_col_term, stdout);
fputs("NULL", stdout);
}
continue;
}
ctype = tds_get_conversion_type(col->column_type, col->column_size);
src = col->column_data;
if (is_blob_col(col) && col->column_type != SYBVARIANT)
src = (unsigned char *) ((TDSBLOB *) src)->textvalue;
srclen = col->column_cur_size;
if (tds_convert(tds_get_ctx(tds), ctype, (TDS_CHAR *) src, srclen, SYBVARCHAR, &dres) < 0)
continue;
if (print_rows) {
if (i) fputs(opt_col_term, stdout);
fputs(dres.c, stdout);
}
free(dres.c);
}
if (print_rows)
fputs(opt_row_term, stdout);
}
if (!QUIET) fprintf(stdout, "(%d row%s affected)\n", rows, rows == 1 ? "" : "s");
break;
case TDS_STATUS_RESULT:
if (!QUIET)
printf("(return status = %d)\n", tds->ret_status);
break;
default:
break;
}
if (opt_flags & OPT_VERSION) {
char version[64];
int line = 0;
line = tds_version(tds->conn, version);
if (line) {
TDSMESSAGE msg;
memset(&msg, 0, sizeof(TDSMESSAGE));
msg.server = "tsql";
sprintf(message, "using TDS version %s", version);
msg.message = message;
tsql_handle_message(tds_get_ctx(tds), tds, &msg);
}
}
if (opt_flags & OPT_TIMER) {
TDSMESSAGE msg;
gettimeofday(&stop, NULL);
sprintf(message, "Total time for processing %d rows: %ld msecs\n",
rows, (long) ((stop.tv_sec - start.tv_sec) * 1000) + ((stop.tv_usec - start.tv_usec) / 1000));
memset(&msg, 0, sizeof(TDSMESSAGE));
msg.server = "tsql";
msg.message = message;
tsql_handle_message(tds_get_ctx(tds), tds, &msg);
}
}
return 0;
}
static void
test(int n, int type)
{
int rc;
TDS_INT result_type;
char buf[1024], tmp[1024];
TDSCOLUMN *curcol;
char *src;
int done_flags;
int i;
char prefix[32], suffix[32];
sprintf(test_name, "test %d len %d", type, n);
/* do a select and check all results */
prefix[0] = 0;
suffix[0] = 0;
tmp[0] = 0;
switch (type) {
case 0:
strcpy(suffix, "C280C290");
break;
case 1:
/* try two invalid in different part */
strcpy(prefix, "C480C290");
strcpy(suffix, "C480C290");
break;
}
for (i = 0; i < n; ++i)
sprintf(strchr(tmp, 0), "%02X", 0x30 + (i % 10));
sprintf(buf, "select convert(varchar(255), 0x%s%s%s)", prefix, tmp, suffix);
rc = tds_submit_query(tds, buf);
if (rc != TDS_SUCCEED) {
fprintf(stderr, "tds_submit_query() failed\n");
exit(1);
}
if (tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_RESULTS) != TDS_SUCCEED) {
fprintf(stderr, "tds_process_tokens() failed\n");
exit(1);
}
if (result_type != TDS_ROWFMT_RESULT) {
fprintf(stderr, "expected row fmt() failed\n");
exit(1);
}
if (tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_RESULTS) != TDS_SUCCEED) {
fprintf(stderr, "tds_process_tokens() failed\n");
exit(1);
}
if (result_type != TDS_ROW_RESULT) {
fprintf(stderr, "expected row result() failed\n");
exit(1);
}
/* force tds to convert from utf8 to iso8859-1 (even on Sybase) */
tds_srv_charset_changed(tds, "UTF-8");
tds->current_results->columns[0]->char_conv = tds->char_convs[client2server_chardata];
rc = tds_process_tokens(tds, &result_type, NULL, TDS_STOPAT_ROWFMT|TDS_RETURN_DONE|TDS_RETURN_ROW|TDS_RETURN_COMPUTE);
if (rc != TDS_SUCCEED) {
fprintf(stderr, "tds_process_tokens() failed\n");
exit(1);
}
curcol = tds->current_results->columns[0];
src = (char*) curcol->column_data;
if (is_blob_type(curcol->column_type)) {
TDSBLOB *blob = (TDSBLOB *) src;
src = blob->textvalue;
}
prefix[0] = 0;
suffix[0] = 0;
tmp[0] = 0;
switch (type) {
case 0:
strcpy(suffix, "\x80\x90");
break;
case 1:
/* try two invalid in different part */
strcpy(prefix, "?\x90");
strcpy(suffix, "?\x90");
/* some platforms replace invalid sequence with a fixed char */
if (invalid_char < 0)
invalid_char = (unsigned char) src[0];
prefix[0] = (char) invalid_char;
suffix[0] = (char) invalid_char;
break;
}
for (i = 0; i < n; ++i)
sprintf(strchr(tmp, 0), "%c", "0123456789"[i % 10]);
sprintf(buf, "%s%s%s", prefix, tmp, suffix);
if (strlen(buf) != curcol->column_cur_size || strncmp(buf, src, curcol->column_cur_size) != 0) {
int l = curcol->column_cur_size;
if (l > 1000)
l = 1000;
strncpy(tmp, src, l);
tmp[l] = 0;
fprintf(stderr, "Wrong result in %s\n Got: '%s' len %d\n Expected: '%s' len %u\n", test_name, tmp,
curcol->column_cur_size, buf, (unsigned int) strlen(buf));
exit(1);
}
rc = tds_process_tokens(tds, &result_type, NULL, TDS_STOPAT_ROWFMT|TDS_RETURN_DONE|TDS_RETURN_ROW|TDS_RETURN_COMPUTE);
if (rc != TDS_SUCCEED || result_type == TDS_ROW_RESULT) {
fprintf(stderr, "tds_process_tokens() unexpected return\n");
exit(1);
}
while ((rc = tds_process_tokens(tds, &result_type, &done_flags, TDS_TOKEN_RESULTS)) == TDS_SUCCEED) {
switch (result_type) {
case TDS_NO_MORE_RESULTS:
break;
case TDS_DONE_RESULT:
case TDS_DONEPROC_RESULT:
case TDS_DONEINPROC_RESULT:
if (!(done_flags & TDS_DONE_ERROR))
break;
default:
fprintf(stderr, "tds_process_tokens() unexpected result_type\n");
exit(1);
break;
}
}
}
static void
test(const char *buf)
{
char query[1024];
char tmp[129 * 3];
int i;
int rc;
TDS_INT result_type;
int done_flags;
to_utf8(buf, tmp);
sprintf(query, "SELECT 1 AS [%s]", tmp);
/* do a select and check all results */
rc = tds_submit_query(tds, query);
if (rc != TDS_SUCCESS) {
fprintf(stderr, "tds_submit_query() failed\n");
exit(1);
}
if (tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_RESULTS) != TDS_SUCCESS) {
fprintf(stderr, "tds_process_tokens() failed\n");
exit(1);
}
if (result_type != TDS_ROWFMT_RESULT) {
fprintf(stderr, "expected row fmt() failed\n");
exit(1);
}
if (tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_RESULTS) != TDS_SUCCESS) {
fprintf(stderr, "tds_process_tokens() failed\n");
exit(1);
}
if (result_type != TDS_ROW_RESULT) {
fprintf(stderr, "expected row result() failed\n");
exit(1);
}
i = 0;
while ((rc = tds_process_tokens(tds, &result_type, NULL, TDS_STOPAT_ROWFMT|TDS_STOPAT_DONE|TDS_RETURN_ROW|TDS_RETURN_COMPUTE)) == TDS_SUCCESS) {
TDSCOLUMN *curcol;
if (result_type != TDS_ROW_RESULT)
break;
curcol = tds->current_results->columns[0];
if (strcmp(tmp, tds_dstr_cstr(&curcol->column_name)) != 0) {
strlcpy(query, tds_dstr_cstr(&curcol->column_name), sizeof(query));
fprintf(stderr, "Wrong result Got: '%s' len %u\n Expected: '%s' len %u\n", query,
(unsigned) tds_dstr_len(&curcol->column_name), tmp, (unsigned int) strlen(tmp));
exit(1);
}
++i;
}
if (rc != TDS_SUCCESS || result_type == TDS_ROW_RESULT || result_type == TDS_COMPUTE_RESULT) {
fprintf(stderr, "tds_process_tokens() unexpected return\n");
exit(1);
}
while ((rc = tds_process_tokens(tds, &result_type, &done_flags, TDS_TOKEN_RESULTS)) == TDS_SUCCESS) {
switch (result_type) {
case TDS_NO_MORE_RESULTS:
return;
case TDS_DONE_RESULT:
case TDS_DONEPROC_RESULT:
case TDS_DONEINPROC_RESULT:
if (!(done_flags & TDS_DONE_ERROR))
break;
default:
fprintf(stderr, "tds_proces_tokens() unexpected result_type\n");
exit(1);
break;
}
}
}
int
main(int argc, char **argv)
{
TDSLOGIN *login;
TDSSOCKET *tds;
int verbose = 0;
int rc, i;
int result_type;
int rows_returned = 0;
const char *len200 =
"01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789";
char *long_query = (char*) malloc(5000);
strcpy(long_query, "SELECT name FROM #longquerytest WHERE (");
for (i = 0; i < 20; ++i)
sprintf(strchr(long_query, 0), "name = '%c%s' OR ", 'A'+i, len200);
strcat(long_query, "name = 'correct')");
fprintf(stdout, "%s: Test large (>4096 bytes) queries\n", __FILE__);
rc = try_tds_login(&login, &tds, __FILE__, verbose);
if (rc != TDS_SUCCESS) {
fprintf(stderr, "try_tds_login() failed\n");
return 1;
}
/* do not check error here, if TABLE is not create this give error */
rc = run_query(tds, "DROP TABLE #longquerytest");
rc = run_query(tds, "CREATE TABLE #longquerytest (name varchar(255))");
if (rc != TDS_SUCCESS) {
return 1;
}
rc = run_query(tds, "INSERT #longquerytest (name) VALUES ('incorrect')");
if (rc != TDS_SUCCESS) {
return 1;
}
rc = run_query(tds, "INSERT #longquerytest (name) VALUES ('correct')");
if (rc != TDS_SUCCESS) {
return 1;
}
/*
* The heart of the test
*/
if (verbose) {
fprintf(stdout, "block size %d\n", tds->conn->env.block_size);
}
rc = tds_submit_query(tds, long_query);
while ((rc = tds_process_tokens(tds, &result_type, NULL, TDS_RETURN_ROWFMT|TDS_RETURN_ROW)) == TDS_SUCCESS) {
switch (result_type) {
case TDS_ROWFMT_RESULT:
if (tds->res_info->columns[0]->column_type != SYBVARCHAR) {
fprintf(stderr, "Wrong column_type in %s\n", __FILE__);
return 1;
}
break;
case TDS_ROW_RESULT:
++rows_returned;
if (verbose) {
printf("col 0 is %s\n", varchar_as_string(tds, 0));
}
break;
default:
break;
}
}
if (rc == TDS_FAIL) {
fprintf(stderr, "tds_process_tokens() returned TDS_FAIL for long query\n");
return 1;
} else if (rc != TDS_NO_MORE_RESULTS) {
fprintf(stderr, "tds_process_tokens() unexpected return\n");
}
if (rows_returned != 1) {
fprintf(stderr, "%d rows returned, 1 expected\n", rows_returned);
return 1;
}
/* do not check error here, if TABLE is not create this give error */
rc = run_query(tds, "DROP TABLE #longquerytest");
try_tds_logout(login, tds, verbose);
free(long_query);
return 0;
}
static void
test0(const char *type, ...)
{
char buf[512];
CONV_RESULT cr;
int rc;
TDS_INT result_type;
int done_flags;
va_list ap;
struct {
const char *value;
const char *result;
} data[10];
int num_data = 0, i_row;
sprintf(buf, "CREATE TABLE #tmp(a %s)", type);
exec_query(buf);
va_start(ap, type);
for (;;) {
const char * value = va_arg(ap, const char *);
const char * result;
if (!value)
break;
result = va_arg(ap, const char *);
if (!result)
result = value;
data[num_data].value = value;
data[num_data].result = result;
sprintf(buf, "INSERT INTO #tmp VALUES(CONVERT(%s,'%s'))", type, value);
exec_query(buf);
++num_data;
}
va_end(ap);
assert(num_data > 0);
/* execute it */
rc = tds_submit_query(tds, "SELECT * FROM #tmp");
if (rc != TDS_SUCCEED) {
fprintf(stderr, "tds_submit_query() failed\n");
exit(1);
}
if (tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_RESULTS) != TDS_SUCCEED) {
fprintf(stderr, "tds_process_tokens() failed\n");
exit(1);
}
if (result_type != TDS_ROWFMT_RESULT) {
fprintf(stderr, "expected row fmt() failed\n");
exit(1);
}
if (tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_RESULTS) != TDS_SUCCEED) {
fprintf(stderr, "tds_process_tokens() failed\n");
exit(1);
}
if (result_type != TDS_ROW_RESULT) {
fprintf(stderr, "expected row result() failed\n");
exit(1);
}
i_row = 0;
while ((rc = tds_process_tokens(tds, &result_type, NULL, TDS_STOPAT_ROWFMT|TDS_RETURN_DONE|TDS_RETURN_ROW|TDS_RETURN_COMPUTE)) == TDS_SUCCEED && (result_type == TDS_ROW_RESULT || result_type == TDS_COMPUTE_RESULT)) {
TDSCOLUMN *curcol = tds->current_results->columns[0];
TDS_CHAR *src = (TDS_CHAR *) curcol->column_data;
int conv_type = tds_get_conversion_type(curcol->column_type, curcol->column_size);
assert(i_row < num_data);
if (is_blob_type(curcol->column_type)) {
TDSBLOB *blob = (TDSBLOB *) src;
src = blob->textvalue;
}
if (tds_convert(test_context, conv_type, src, curcol->column_cur_size, SYBVARCHAR, &cr) < 0) {
fprintf(stderr, "Error converting\n");
g_result = 1;
} else {
if (strcmp(data[i_row].result, cr.c) != 0) {
fprintf(stderr, "Failed! Is \n%s\nShould be\n%s\n", cr.c, data[i_row].result);
g_result = 1;
}
free(cr.c);
}
++i_row;
}
if (rc != TDS_NO_MORE_RESULTS && rc != TDS_SUCCEED) {
fprintf(stderr, "tds_process_tokens() unexpected return\n");
exit(1);
}
while ((rc = tds_process_tokens(tds, &result_type, &done_flags, TDS_TOKEN_RESULTS)) == TDS_SUCCEED) {
switch (result_type) {
case TDS_NO_MORE_RESULTS:
return;
case TDS_DONE_RESULT:
case TDS_DONEPROC_RESULT:
case TDS_DONEINPROC_RESULT:
if (!(done_flags & TDS_DONE_ERROR))
break;
default:
fprintf(stderr, "tds_process_tokens() unexpected result_type\n");
exit(1);
break;
}
}
exec_query("DROP TABLE #tmp");
}
