command::command(connection& conn, ExceptionSink* xsink) :
m_conn(conn),
m_cmd(0),
rowcount(-1),
lastRes(RES_NONE) {
CS_RETCODE err = ct_cmd_alloc(m_conn.getConnection(), &m_cmd);
if (err != CS_SUCCEED) {
xsink->raiseException("DBI-EXEC-EXCEPTION", "Sybase call ct_cmd_alloc() failed with error %d", (int)err);
return;
}
}
CAMLprim value mltds_ct_cmd_alloc(value conn)
{
CAMLparam1(conn);
CS_COMMAND* command;
CAMLlocal1(result);
retval_inspect( "ct_cmd_alloc",
ct_cmd_alloc(connection_ptr(conn), &command) );
result = alloc_custom(&command_operations, sizeof(CS_COMMAND*), 0, 1);
command_ptr(result) = command;
CAMLreturn(result);
}
PyObject *cmd_alloc(CS_CONNECTIONObj *conn)
{
CS_COMMANDObj *self;
CS_RETCODE status;
CS_COMMAND *cmd;
self = PyObject_NEW(CS_COMMANDObj, &CS_COMMANDType);
if (self == NULL)
return NULL;
SY_LEAK_REG(self);
self->is_eed = 0;
self->cmd = NULL;
self->conn = NULL;
self->strip = conn->strip;
self->debug = conn->debug;
self->serial = cmd_serial++;
/* PyErr_Clear(); */
SY_CONN_BEGIN_THREADS(conn);
status = ct_cmd_alloc(conn->conn, &cmd);
SY_CONN_END_THREADS(conn);
if (self->debug)
debug_msg("ct_cmd_alloc(conn%d, &cmd) -> %s",
conn->serial, value_str(VAL_STATUS, status));
if (PyErr_Occurred()) {
if (self->debug)
debug_msg("\n");
Py_DECREF(self);
return NULL;
}
if (status != CS_SUCCEED) {
Py_DECREF(self);
if (self->debug)
debug_msg(", None\n");
return Py_BuildValue("iO", status, Py_None);
}
self->cmd = cmd;
self->conn = conn;
Py_INCREF(self->conn);
if (self->debug)
debug_msg(", cmd%d\n", self->serial);
return Py_BuildValue("iN", CS_SUCCEED, self);
}
int
main(int argc, char *argv[])
{
int errCode = 1;
CS_RETCODE ret;
CS_RETCODE results_ret;
CS_CHAR cmdbuf[4096];
CS_CHAR name[257];
CS_INT datalength;
CS_SMALLINT ind;
CS_INT count;
CS_INT num_cols;
CS_INT row_count = 0;
CS_DATAFMT datafmt;
CS_DATAFMT descfmt;
CS_INT intvar;
CS_INT intvarsize;
CS_SMALLINT intvarind;
CS_INT res_type;
int i;
if (argc > 1 && (0 == strcmp(argv[1], "-v")))
verbose = 1;
printf("%s: use ct_dynamic to prepare and execute a statement\n", __FILE__);
if (verbose) {
printf("Trying login\n");
}
ret = try_ctlogin(&ctx, &conn, &cmd, verbose);
if (ret != CS_SUCCEED) {
fprintf(stderr, "Login failed\n");
return 1;
}
ct_callback(ctx, NULL, CS_SET, CS_CLIENTMSG_CB, (CS_VOID *) ex_clientmsg_cb);
ct_callback(ctx, NULL, CS_SET, CS_SERVERMSG_CB, (CS_VOID *) ex_servermsg_cb);
ret = ct_cmd_alloc(conn, &cmd2);
chk(ret == CS_SUCCEED, "cmd2_alloc failed\n");
/* do not test error */
ret = run_command(cmd, "IF OBJECT_ID('tempdb..#ct_dynamic') IS NOT NULL DROP table #ct_dynamic");
strcpy(cmdbuf, "create table #ct_dynamic (id numeric identity not null, \
name varchar(30), age int, cost money, bdate datetime, fval float) ");
ret = run_command(cmd, cmdbuf);
chk(ret == CS_SUCCEED, "create table failed\n");
strcpy(cmdbuf, "insert into #ct_dynamic ( name , age , cost , bdate , fval ) ");
strcat(cmdbuf, "values ('Bill', 44, 2000.00, 'May 21 1960', 60.97 ) ");
ret = run_command(cmd, cmdbuf);
chk(ret == CS_SUCCEED, "insert table failed\n");
strcpy(cmdbuf, "insert into #ct_dynamic ( name , age , cost , bdate , fval ) ");
strcat(cmdbuf, "values ('Freddy', 32, 1000.00, 'Jan 21 1972', 70.97 ) ");
ret = run_command(cmd, cmdbuf);
chk(ret == CS_SUCCEED, "insert table failed\n");
strcpy(cmdbuf, "insert into #ct_dynamic ( name , age , cost , bdate , fval ) ");
strcat(cmdbuf, "values ('James', 42, 5000.00, 'May 21 1962', 80.97 ) ");
ret = run_command(cmd, cmdbuf);
chk(ret == CS_SUCCEED, "insert table failed\n");
strcpy(cmdbuf, "select name from #ct_dynamic where age = ?");
ret = ct_dynamic(cmd, CS_PREPARE, "age", CS_NULLTERM, cmdbuf, CS_NULLTERM);
chk(ret == CS_SUCCEED, "ct_dynamic failed\n");
chk(ct_send(cmd) == CS_SUCCEED, "ct_send(CS_PREPARE) failed\n");
while ((ret = ct_results(cmd, &res_type)) == CS_SUCCEED) {
switch ((int) res_type) {
case CS_CMD_SUCCEED:
case CS_CMD_DONE:
break;
case CS_CMD_FAIL:
break;
default:
goto ERR;
}
}
chk(ret == CS_END_RESULTS, "ct_results() unexpected return.\n", (int) ret);
ret = ct_dynamic(cmd, CS_DESCRIBE_INPUT, "age", CS_NULLTERM, NULL, CS_UNUSED);
chk(ret == CS_SUCCEED, "ct_dynamic failed\n");
chk(ct_send(cmd) == CS_SUCCEED, "ct_send(CS_DESCRIBE_INPUT) failed\n");
while ((ret = ct_results(cmd, &res_type)) == CS_SUCCEED) {
switch ((int) res_type) {
case CS_DESCRIBE_RESULT:
ret = ct_res_info(cmd, CS_NUMDATA, &num_cols, CS_UNUSED, NULL);
chk(ret == CS_SUCCEED, "ct_res_info() failed");
for (i = 1; i <= num_cols; i++) {
ret = ct_describe(cmd, i, &descfmt);
chk(ret == CS_SUCCEED, "ct_describe() failed");
fprintf(stderr, "CS_DESCRIBE_INPUT parameter %d :\n", i);
if (descfmt.namelen == 0)
fprintf(stderr, "\t\tNo name...\n");
else
fprintf(stderr, "\t\tName = %*.*s\n", descfmt.namelen, descfmt.namelen, descfmt.name);
fprintf(stderr, "\t\tType = %d\n", descfmt.datatype);
fprintf(stderr, "\t\tLength = %d\n", descfmt.maxlength);
}
break;
case CS_CMD_SUCCEED:
case CS_CMD_DONE:
break;
case CS_CMD_FAIL:
break;
default:
goto ERR;
}
}
ret = ct_dynamic(cmd, CS_DESCRIBE_OUTPUT, "age", CS_NULLTERM, NULL, CS_UNUSED);
chk(ret == CS_SUCCEED, "ct_dynamic failed\n");
chk(ct_send(cmd) == CS_SUCCEED, "ct_send(CS_DESCRIBE_OUTPUT) failed\n");
while ((ret = ct_results(cmd, &res_type)) == CS_SUCCEED) {
switch ((int) res_type) {
case CS_DESCRIBE_RESULT:
ret = ct_res_info(cmd, CS_NUMDATA, &num_cols, CS_UNUSED, NULL);
chk(ret == CS_SUCCEED, "ct_res_info() failed");
chk(num_cols == 1, "CS_DESCRIBE_OUTPUT showed %d columns , expected 1\n", num_cols);
for (i = 1; i <= num_cols; i++) {
ret = ct_describe(cmd, i, &descfmt);
chk(ret == CS_SUCCEED, "ct_describe() failed");
if (descfmt.namelen == 0)
fprintf(stderr, "\t\tNo name...\n");
else
fprintf(stderr, "\t\tName = %*.*s\n", descfmt.namelen, descfmt.namelen, descfmt.name);
fprintf(stderr, "\t\tType = %d\n", descfmt.datatype);
fprintf(stderr, "\t\tLength = %d\n", descfmt.maxlength);
}
break;
case CS_CMD_SUCCEED:
case CS_CMD_DONE:
break;
case CS_CMD_FAIL:
break;
default:
goto ERR;
}
}
/* execute dynamic on a second command to check it still works */
ret = ct_dynamic(cmd2, CS_EXECUTE, "age", CS_NULLTERM, NULL, CS_UNUSED);
chk(ret == CS_SUCCEED, "ct_dynamic failed\n");
intvar = 44;
intvarsize = 4;
intvarind = 0;
datafmt.name[0] = 0;
datafmt.namelen = 0;
datafmt.datatype = CS_INT_TYPE;
datafmt.status = CS_INPUTVALUE;
ret = ct_setparam(cmd2, &datafmt, (CS_VOID *) & intvar, &intvarsize, &intvarind);
chk(ret == CS_SUCCEED, "ct_setparam(int) failed\n");
chk(ct_send(cmd2) == CS_SUCCEED, "ct_send(CS_EXECUTE) failed\n");
while ((results_ret = ct_results(cmd2, &res_type)) == CS_SUCCEED) {
chk(res_type != CS_CMD_FAIL, "1: ct_results() result_type CS_CMD_FAIL.\n");
chk(res_type != CS_COMPUTE_RESULT, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
switch ((int) res_type) {
case CS_CMD_SUCCEED:
break;
case CS_CMD_DONE:
break;
case CS_ROW_RESULT:
datafmt.datatype = CS_CHAR_TYPE;
datafmt.format = CS_FMT_NULLTERM;
datafmt.maxlength = 256;
datafmt.count = 1;
datafmt.locale = NULL;
ret = ct_bind(cmd2, 1, &datafmt, name, &datalength, &ind);
chk(ret == CS_SUCCEED, "ct_bind() failed\n");
while (((ret = ct_fetch(cmd2, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED)
|| (ret == CS_ROW_FAIL)) {
row_count += count;
chk(ret != CS_ROW_FAIL, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
if (ret == CS_SUCCEED) {
chk(!strcmp(name, "Bill"), "fetched value '%s' expected 'Bill'\n", name);
} else {
break;
}
}
chk(ret == CS_END_DATA, "ct_fetch() unexpected return %d.\n", (int) ret);
break;
default:
fprintf(stderr, "ct_results() unexpected result_type.\n");
return 1;
}
}
chk(results_ret == CS_END_RESULTS, "ct_results() unexpected return.\n", (int) results_ret);
intvar = 32;
chk(ct_send(cmd2) == CS_SUCCEED, "ct_send(CS_EXECUTE) failed\n");
while ((results_ret = ct_results(cmd2, &res_type)) == CS_SUCCEED) {
chk(res_type != CS_CMD_FAIL, "2: ct_results() result_type CS_CMD_FAIL.\n");
chk(res_type != CS_COMPUTE_RESULT, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
switch ((int) res_type) {
case CS_CMD_SUCCEED:
break;
case CS_CMD_DONE:
break;
case CS_ROW_RESULT:
datafmt.datatype = CS_CHAR_TYPE;
datafmt.format = CS_FMT_NULLTERM;
datafmt.maxlength = 256;
datafmt.count = 1;
datafmt.locale = NULL;
ret = ct_bind(cmd2, 1, &datafmt, name, &datalength, &ind);
chk(ret == CS_SUCCEED, "ct_bind() failed\n");
while (((ret = ct_fetch(cmd2, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED)
|| (ret == CS_ROW_FAIL)) {
row_count += count;
chk(ret != CS_ROW_FAIL, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
if (ret == CS_SUCCEED) {
chk(!strcmp(name, "Freddy"), "fetched value '%s' expected 'Freddy'\n", name);
} else {
break;
}
}
chk(ret == CS_END_DATA, "ct_fetch() unexpected return %d.\n", (int) ret);
break;
default:
fprintf(stderr, "ct_results() unexpected result_type.\n");
return 1;
}
}
chk(results_ret == CS_END_RESULTS, "ct_results() unexpected return.\n", (int) results_ret);
ret = ct_dynamic(cmd, CS_DEALLOC, "age", CS_NULLTERM, NULL, CS_UNUSED);
chk(ret == CS_SUCCEED, "ct_dynamic failed\n");
chk(ct_send(cmd) == CS_SUCCEED, "ct_send(CS_DEALLOC) failed\n");
while ((ret = ct_results(cmd, &res_type)) == CS_SUCCEED) {
switch ((int) res_type) {
case CS_CMD_SUCCEED:
case CS_CMD_DONE:
break;
case CS_CMD_FAIL:
break;
default:
goto ERR;
}
}
chk(ret == CS_END_RESULTS, "ct_results() unexpected return.\n", (int) ret);
/*
* check we can prepare again dynamic with same name after deallocation
*/
strcpy(cmdbuf, "select name from #ct_dynamic where age = ?");
ret = ct_dynamic(cmd, CS_PREPARE, "age", CS_NULLTERM, cmdbuf, CS_NULLTERM);
chk(ret == CS_SUCCEED, "ct_dynamic failed\n");
chk(ct_send(cmd) == CS_SUCCEED, "ct_send(CS_PREPARE) failed\n");
while ((ret = ct_results(cmd, &res_type)) == CS_SUCCEED) {
switch ((int) res_type) {
case CS_CMD_SUCCEED:
case CS_CMD_DONE:
break;
case CS_CMD_FAIL:
break;
default:
goto ERR;
}
}
chk(ret == CS_END_RESULTS, "ct_results() unexpected return.\n", (int) ret);
ct_dynamic(cmd, CS_DEALLOC, "invalid", CS_NULLTERM, NULL, CS_UNUSED);
ct_send(cmd);
while ((ret = ct_results(cmd, &res_type)) == CS_SUCCEED)
chk(res_type != CS_ROW_RESULT, "Rows not expected\n");
chk(ret == CS_END_RESULTS, "ct_results() unexpected return.\n", (int) ret);
ret = ct_dynamic(cmd2, CS_EXECUTE, "age", CS_NULLTERM, NULL, CS_UNUSED);
chk(ret == CS_SUCCEED, "ct_dynamic failed\n");
intvar = 32;
intvarsize = 4;
intvarind = 0;
datafmt.name[0] = 0;
datafmt.namelen = 0;
datafmt.datatype = CS_INT_TYPE;
datafmt.status = CS_INPUTVALUE;
ret = ct_setparam(cmd2, &datafmt, (CS_VOID *) & intvar, &intvarsize, &intvarind);
chk(ct_send(cmd2) == CS_SUCCEED, "ct_send(CS_EXECUTE) failed\n");
/* all tests succeeded */
errCode = 0;
ERR:
cleanup();
return errCode;
}
static VALUE statement_Execute(VALUE self) {
int i;
CS_DATAFMT col;
CS_DATAFMT *cols;
EX_COLUMN_DATA *col_data;
CS_INT rc;
CS_INT resulttype;
CS_INT num_cols;
CS_INT col_len;
CS_INT row_count = 0;
CS_INT rows_read;
CS_INT num_errors = 0;
CS_SERVERMSG servermsg;
VALUE err;
char *error_msg;
struct timeval start, stop;
int print_rows = 1;
char message[128];
char* buf;
CS_DATEREC date_rec;
char output[200];
CS_INT output_len;
int tempInt;
CS_BIGINT tempBigInt;
double tempDouble;
CS_NUMERIC tempNumeric;
char* tempText;
char* newTempText;
int tempTextLen;
CS_INT data_rc;
int isNull = 0;
CS_DATE tempDate;
CS_DATETIME tempDateTime;
TDS_Connection* conn;
CS_COMMAND * cmd;
VALUE connection;
VALUE query;
VALUE columns;
VALUE rows;
VALUE status;
VALUE errors;
VALUE date_parts[8];
VALUE column;
VALUE row;
VALUE column_name = rb_str_new2("name");
VALUE column_type = rb_str_new2("type");
VALUE column_size = rb_str_new2("size");
VALUE column_scale = rb_str_new2("scale");
VALUE column_precision = rb_str_new2("precision");
VALUE column_value;
connection = rb_iv_get(self, "@connection");
query = rb_iv_get(self, "@query");
columns = rb_ary_new();
rb_iv_set(self, "@columns", columns);
rows = rb_ary_new();
rb_iv_set(self, "@rows", rows);
Data_Get_Struct(connection, TDS_Connection, conn);
buf = value_to_cstr(query);
rb_iv_set(self, "@status", Qnil);
rb_iv_set(self, "@messages", rb_ary_new());
errors = rb_ary_new();
rb_iv_set(self, "@errors", errors);
ct_diag(conn->connection, CS_INIT, CS_UNUSED, CS_UNUSED, NULL);
// if ( ct_callback(conn->context, NULL, CS_SET, CS_CLIENTMSG_CB, (CS_VOID *)clientmsg_cb) != CS_SUCCEED ) {
// error_message("ct_callback CS_CLIENTMSG_CB failed\n");
// }
// if ( ct_callback(conn->context, NULL, CS_SET, CS_SERVERMSG_CB, (CS_VOID *)servermsg_cb) != CS_SUCCEED ) {
// error_message("ct_callback CS_SERVERMSG_CB failed\n");
// }
ct_cmd_alloc(conn->connection, &cmd);
ct_command(cmd, CS_LANG_CMD, buf, CS_NULLTERM, CS_UNUSED);
ct_send(cmd);
if ( ct_diag(conn->connection, CS_STATUS, CS_SERVERMSG_TYPE, CS_UNUSED, &num_errors) != CS_SUCCEED ) {
error_message("ct_diag CS_STATUS CS_SERVERMSG_TYPE failed");
}
if (num_errors > 0) {
// fprintf(stderr, "%d errors found\n", num_errors);
for (i = 0; i < num_errors; i++) {
if ( ct_diag(conn->connection, CS_GET, CS_SERVERMSG_TYPE, i+1, &servermsg) != CS_SUCCEED ) {
error_message("ct_diag CS_GET CS_SERVERMSG_TYPE failed");
}
if (servermsg.severity > 0) {
// error_message(servermsg.text);
rb_ary_push(errors, rb_str_new2(servermsg.text));
}
}
if ( ct_diag(conn->connection, CS_CLEAR, CS_SERVERMSG_TYPE, CS_UNUSED, NULL) != CS_SUCCEED ) {
error_message("ct_diag CS_CLEAR CS_SERVERMSG_TYPE failed");
}
}
// Raise errors from ct_command/ct_send
err = rb_funcall(errors, rb_intern("first"), 0); // FIXME: should probably display all errors instead of just first
if(RTEST(err)) {
error_msg = value_to_cstr(err);
rb_raise(rb_eIOError, error_msg);
ct_cmd_drop(cmd);
return Qnil;
}
// TODO:
// - We should have an array of malloc'd cols
// - Then we bind / fetch to those
// - Finish conversions...
while ((rc = ct_results(cmd, &resulttype)) == CS_SUCCEED) {
switch (resulttype) {
case CS_ROW_RESULT:
rc = ct_res_info(cmd, CS_NUMDATA, &num_cols, sizeof(num_cols), &col_len);
if (rc != CS_SUCCEED)
{
fprintf(stderr, "ct_res_info() failed\n");
return 1;
}
col_data = (EX_COLUMN_DATA *)malloc(num_cols * sizeof (EX_COLUMN_DATA));
if (col_data == NULL)
{
fprintf(stderr, "ex_fetch_data: malloc() failed");
return CS_MEM_ERROR;
}
cols = (CS_DATAFMT *)malloc(num_cols * sizeof (CS_DATAFMT));
if (cols == NULL)
{
fprintf(stderr, "ex_fetch_data: malloc() failed");
free(col_data);
return CS_MEM_ERROR;
}
// Get column information
for (i = 0; i < num_cols; i++) {
rc = ct_describe(cmd, (i+1), &cols[i]);
if ( rc != CS_SUCCEED ) {
fprintf(stderr, "ct_describe failed on col #%d", i+1);
}
column_value = rb_hash_new();
// fprintf(stderr, "%s\n", cols[i].name);
if (cols[i].name) {
rb_hash_aset(column_value, column_name, rb_str_new2(cols[i].name));
} else {
rb_hash_aset(column_value, column_name, Qnil);
}
rb_hash_aset(column_value, column_type, rb_str_new2(column_type_name(cols[i])));
rb_hash_aset(column_value, column_size, INT2FIX(cols[i].maxlength));
rb_hash_aset(column_value, column_scale, INT2FIX(cols[i].scale));
rb_hash_aset(column_value, column_precision, INT2FIX(cols[i].precision));
rb_ary_push(columns, column_value);
}
// Fetch data
while (((rc = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &rows_read)) == CS_SUCCEED) || (rc == CS_ROW_FAIL)) {
row_count = row_count + rows_read;
row = rb_hash_new();
rb_ary_push(rows, row);
// Create Ruby objects
for (i = 0; i < num_cols; i++) {
// if (col_data[i].indicator == -1) {
// rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil);
// continue;
// }
switch (cols[i].datatype) {
case CS_TINYINT_TYPE:
case CS_BIT_TYPE:
data_rc = ct_get_data(cmd, (i + 1), &tempInt, sizeof(tempInt), &output_len);
if (output_len == 0 && (data_rc == CS_END_DATA || data_rc == CS_END_ITEM)) {
rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil);
} else {
if(tempInt == 1) {
rb_hash_aset(row, rb_str_new2(cols[i].name), Qtrue);
} else {
rb_hash_aset(row, rb_str_new2(cols[i].name), Qfalse);
}
}
tempInt = -1;
break;
case CS_INT_TYPE:
case CS_SMALLINT_TYPE:
data_rc = ct_get_data(cmd, (i + 1), &tempInt, sizeof(tempInt), &output_len);
if (output_len == 0 && (data_rc == CS_END_DATA || data_rc == CS_END_ITEM)) {
rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil);
} else {
rb_hash_aset(row, rb_str_new2(cols[i].name), INT2FIX(tempInt));
}
tempInt = -1;
break;
case CS_DATETIME_TYPE:
case CS_DATETIME4_TYPE:
data_rc = ct_get_data(cmd, (i + 1), &tempDateTime, sizeof(tempDateTime), &output_len);
if (output_len == 0 && (data_rc == CS_END_DATA || data_rc == CS_END_ITEM)) {
rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil);
} else {
if ( cs_dt_crack(conn->context, CS_DATETIME_TYPE, &tempDateTime, &date_rec) == CS_SUCCEED ) {
if(date_rec.dateyear && date_rec.datemonth && date_rec.datedmonth) {
date_parts[0] = INT2FIX(date_rec.dateyear);
date_parts[1] = INT2FIX(date_rec.datemonth+1);
date_parts[2] = INT2FIX(date_rec.datedmonth);
date_parts[3] = INT2FIX(date_rec.datehour);
date_parts[4] = INT2FIX(date_rec.dateminute);
date_parts[5] = INT2FIX(date_rec.datesecond);
date_parts[6] = INT2FIX(date_rec.datemsecond);
date_parts[7] = INT2FIX(date_rec.datetzone);
// String (fastest known so far, but pushes the burden to ActiveRecord for parsing)
sprintf(output, "%d-%02d-%02d %02d:%02d:%02d.%03d", date_rec.dateyear, date_rec.datemonth+1, date_rec.datedmonth, date_rec.datehour, date_rec.dateminute, date_rec.datesecond, date_rec.datemsecond);
rb_hash_aset(row, rb_str_new2(cols[i].name), rb_str_new2(output));
// DateTime - this is slow a f*ck
//rb_hash_aset(row, rb_str_new2(cols[i].name), rb_funcall2(rb_DateTime, rb_intern("civil"), 6, &date_parts[0]));
// Time - way faster than DateTime
// FIXME: should we be assuming utc?!
// rb_hash_aset(row, rb_str_new2(cols[i].name), rb_funcall2(rb_cTime, rb_intern("utc"), 6, &date_parts[0]));
} else {
rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil);
}
} else {
fprintf(stderr, "cs_dt_crack failed\n");
}
}
// tempDateTime = 0; // not sure how to clear this...
break;
// case CS_REAL_TYPE:
case CS_FLOAT_TYPE:
// case CS_MONEY_TYPE:
// case CS_MONEY4_TYPE:
data_rc = ct_get_data(cmd, (i + 1), &tempDouble, sizeof(tempDouble), &output_len);
if (output_len == 0 && (data_rc == CS_END_DATA || data_rc == CS_END_ITEM)) {
rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil);
} else {
rb_hash_aset(row, rb_str_new2(cols[i].name), rb_float_new(tempDouble));
}
tempDouble = -1.0;
break;
// case CS_BIGINT_TYPE:
// error_message("HELLO BIGINT!");
// break;
case CS_DECIMAL_TYPE:
case CS_NUMERIC_TYPE:
// fprintf(stderr, "CS_NUMERIC_TYPE detected - name: %s\n", cols[i].name);
data_rc = ct_get_data(cmd, (i + 1), &tempNumeric, sizeof(tempNumeric), &output_len);
if (output_len == 0 && (data_rc == CS_END_DATA || data_rc == CS_END_ITEM)) {
rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil);
} else {
// fprintf(stderr, "tempNumeric output_len: %d, precision: %d, scale: %d, array: %s\n", output_len, tempNumeric.precision, tempNumeric.scale, tempNumeric.array);
col.datatype = CS_CHAR_TYPE;
col.format = CS_FMT_NULLTERM;
col.maxlength = 200;
// col.maxlength = cols[i].precision + 1;
data_rc = cs_convert(conn->context, &cols[i], &tempNumeric, &col, output, &output_len);
if ( data_rc != CS_SUCCEED ) {
error_message("CS_NUMERIC_TYPE conversion failed");
fprintf(stderr, "cs_convert returned: %d\n", data_rc);
}
// fprintf(stderr, "numeric output_len: %d, output: %s\n", output_len, output);
rb_hash_aset(row, rb_str_new2(cols[i].name), LL2NUM(strtoll(output, NULL, 10)));
}
break;
case CS_CHAR_TYPE:
case CS_LONGCHAR_TYPE:
case CS_TEXT_TYPE:
case CS_VARCHAR_TYPE:
case CS_UNICHAR_TYPE:
case CS_UNIQUE_TYPE: // @todo should this one be handled differently?
isNull = 0;
tempTextLen = 1; // 1 for \0
do {
newTempText = realloc((tempTextLen == 1 ? NULL : tempText), tempTextLen + (1000 * sizeof(char))); // allocate another 1000 chars
if (newTempText != NULL) {
tempText = newTempText;
} else {
fprintf(stderr, "realloc error\n");
}
data_rc = ct_get_data(cmd, (i + 1), tempText + tempTextLen - 1, 1000, &output_len);
if (tempTextLen == 1 && output_len == 0 && (data_rc == CS_END_DATA || data_rc == CS_END_ITEM)) {
isNull = 1;
}
tempTextLen = tempTextLen + output_len;
} while (data_rc == CS_SUCCEED);
if (data_rc != CS_END_DATA && data_rc != CS_END_ITEM)
{
fprintf(stderr, "ct_get_data failed, data_rc = %d\n", data_rc);
return data_rc;
}
tempText[tempTextLen-1] = '\0';
if (isNull == 1) {
rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil);
} else {
rb_hash_aset(row, rb_str_new2(cols[i].name), rb_str_new2(tempText));
}
free(tempText);
tempText = NULL;
break;
case CS_BINARY_TYPE:
case CS_LONGBINARY_TYPE:
case CS_VARBINARY_TYPE:
case CS_IMAGE_TYPE:
// rb_hash_aset(row, rb_str_new2(tds->res_info->columns[i]->column_name), rb_str_new((char *) ((TDSBLOB *) src)->textvalue, tds->res_info->columns[i]->column_cur_size));
rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil);
break;
default:
rb_hash_aset(row, rb_str_new2(cols[i].name), Qnil);
printf("\nUnexpected datatype: %d\n", cols[i].datatype);
}
}
}
if( rc != CS_END_DATA )
{
fprintf(stderr, "ct_fetch failed");
}
free(cols);
cols = NULL;
free(col_data);
col_data = NULL;
break;
case CS_CMD_SUCCEED:
rb_iv_set(self, "@status", Qnil);
break;
case CS_CMD_FAIL:
if ( ct_diag(conn->connection, CS_STATUS, CS_SERVERMSG_TYPE, CS_UNUSED, &num_errors) != CS_SUCCEED ) {
error_message("ct_diag CS_STATUS CS_SERVERMSG_TYPE failed");
}
if (num_errors > 0) {
// fprintf(stderr, "%d errors found\n", num_errors);
for (i = 0; i < num_errors; i++) {
if ( ct_diag(conn->connection, CS_GET, CS_SERVERMSG_TYPE, i+1, &servermsg) != CS_SUCCEED ) {
error_message("ct_diag CS_GET CS_SERVERMSG_TYPE failed");
}
if (servermsg.severity > 0) {
// error_message(servermsg.text);
rb_ary_push(errors, rb_str_new2(servermsg.text));
}
}
if ( ct_diag(conn->connection, CS_CLEAR, CS_SERVERMSG_TYPE, CS_UNUSED, NULL) != CS_SUCCEED ) {
error_message("ct_diag CS_CLEAR CS_SERVERMSG_TYPE failed");
}
}
err = rb_funcall(errors, rb_intern("first"), 0); // FIXME: should probably display all errors instead of just first
if(RTEST(err)) {
error_msg = value_to_cstr(err);
rb_raise(rb_eIOError, error_msg);
} else {
rb_raise(rb_eIOError, "CS_CMD_FAIL without server error message");
}
// rb_iv_set(self, "@status", INT2FIX(0));
break;
case CS_CMD_DONE:
rb_iv_set(self, "@status", Qnil);
break;
case CS_STATUS_RESULT:
// FIXME: We should probably do something here, right?
break;
default:
fprintf(stderr, "ct_results returned unexpected result type: %d\n", resulttype);
break;
}
}
ct_cmd_drop(cmd);
return Qnil;
}
CS_RETCODE
try_ctlogin(CS_CONTEXT ** ctx, CS_CONNECTION ** conn, CS_COMMAND ** cmd, int verbose)
{
CS_RETCODE ret;
char query[30];
TDSCONTEXT *tds_ctx;
/* read login information from PWD file */
ret = read_login_info();
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "read_login_info() failed!\n");
}
return ret;
}
ret = cs_ctx_alloc(CS_VERSION_100, ctx);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Context Alloc failed!\n");
}
return ret;
}
/* Force default date format, some tests rely on it */
tds_ctx = (TDSCONTEXT *) (*ctx)->tds_ctx;
if (tds_ctx && tds_ctx->locale && tds_ctx->locale->date_fmt) {
free(tds_ctx->locale->date_fmt);
tds_ctx->locale->date_fmt = tds_strdup("%b %d %Y %I:%M%p");
}
ret = ct_init(*ctx, CS_VERSION_100);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Library Init failed!\n");
}
return ret;
}
ret = ct_con_alloc(*ctx, conn);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Connect Alloc failed!\n");
}
return ret;
}
ret = ct_con_props(*conn, CS_SET, CS_USERNAME, USER, CS_NULLTERM, NULL);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "ct_con_props() SET USERNAME failed!\n");
}
return ret;
}
ret = ct_con_props(*conn, CS_SET, CS_PASSWORD, PASSWORD, CS_NULLTERM, NULL);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "ct_con_props() SET PASSWORD failed!\n");
}
return ret;
}
ret = ct_connect(*conn, SERVER, CS_NULLTERM);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Connection failed!\n");
}
return ret;
}
ret = ct_cmd_alloc(*conn, cmd);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Command Alloc failed!\n");
}
return ret;
}
strcpy(query, "use ");
strncat(query, DATABASE, 20);
ret = run_command(*cmd, query);
if (ret != CS_SUCCEED)
return ret;
return CS_SUCCEED;
}
int
main(int argc, char **argv)
{
CS_CONTEXT *ctx;
CS_CONNECTION *conn;
CS_COMMAND *cmd;
CS_COMMAND *cmd2;
CS_COMMAND *cmd3;
CS_RETCODE ret;
CS_RETCODE ret2;
CS_RETCODE results_ret;
CS_INT result_type;
CS_INT count, count2, row_count = 0;
CS_DATAFMT datafmt;
CS_DATAFMT datafmt2;
CS_SMALLINT ind;
int verbose = 1;
CS_CHAR *name = "c1";
CS_CHAR *name2 = "c2";
CS_CHAR col1[6];
CS_CHAR col2[6];
CS_INT datalength;
CS_CHAR text[128];
CS_INT num_cols, i;
int is_return_status = 0;
fprintf(stdout, "%s: use multiple cursors on the same connection\n", __FILE__);
if (verbose) {
fprintf(stdout, "Trying login\n");
}
ret = try_ctlogin(&ctx, &conn, &cmd, verbose);
if (ret != CS_SUCCEED) {
fprintf(stderr, "Login failed\n");
return 1;
}
ret = ct_cmd_alloc(conn, &cmd2);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Command Alloc failed!\n");
}
return ret;
}
ret = ct_cmd_alloc(conn, &cmd3);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Command Alloc failed!\n");
}
return ret;
}
ret = run_command(cmd, "CREATE TABLE #test_table (col1 char(4))");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd, "INSERT #test_table (col1) VALUES ('AAA')");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd, "INSERT #test_table (col1) VALUES ('BBB')");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd, "INSERT #test_table (col1) VALUES ('CCC')");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd, "CREATE TABLE #test_table2 (col1 char(4))");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd, "INSERT #test_table2 (col1) VALUES ('XXX')");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd, "INSERT #test_table2 (col1) VALUES ('YYY')");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd, "INSERT #test_table2 (col1) VALUES ('ZZZ')");
if (ret != CS_SUCCEED)
return 1;
if (verbose) {
fprintf(stdout, "opening first cursor on connection\n");
}
strcpy(text, "select col1 from #test_table order by col1");
ret = ct_cursor(cmd, CS_CURSOR_DECLARE, name, CS_NULLTERM, text, CS_NULLTERM, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor declare failed\n");
return 1;
}
ret = ct_cursor(cmd, CS_CURSOR_ROWS, name, CS_NULLTERM, NULL, CS_UNUSED, (CS_INT) 1);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor set cursor rows failed");
return 1;
}
ret = ct_cursor(cmd, CS_CURSOR_OPEN, name, CS_NULLTERM, text, CS_NULLTERM, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor open failed\n");
return 1;
}
ret = ct_send(cmd);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_send failed\n");
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
switch ((int) result_type) {
case CS_CMD_SUCCEED:
case CS_CMD_DONE:
case CS_CMD_FAIL:
case CS_STATUS_RESULT:
break;
case CS_CURSOR_RESULT:
ret = ct_res_info(cmd, CS_NUMDATA, &num_cols, CS_UNUSED, NULL);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_res_info() failed");
return 1;
}
if (num_cols != 1) {
fprintf(stderr, "unexpected num of columns = %d \n", num_cols);
return 1;
}
for (i = 0; i < num_cols; i++) {
/* here we can finally test for the return status column */
ret = ct_describe(cmd, i + 1, &datafmt);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_describe() failed for column %d\n", i);
return 1;
}
if (datafmt.status & CS_RETURN) {
fprintf(stdout, "ct_describe() column %d \n", i);
is_return_status = i + 1;
}
datafmt.datatype = CS_CHAR_TYPE;
datafmt.format = CS_FMT_NULLTERM;
datafmt.maxlength = 6;
datafmt.count = 1;
datafmt.locale = NULL;
ret = ct_bind(cmd, 1, &datafmt, col1, &datalength, &ind);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_bind() failed\n");
return 1;
}
}
break;
case CS_COMPUTE_RESULT:
fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
return 1;
default:
fprintf(stderr, "ct_results() unexpected result_type.\n");
return 1;
}
}
if (verbose) {
fprintf(stdout, "opening second cursor on connection\n");
}
strcpy(text, "select col1 from #test_table2 order by col1");
ret = ct_cursor(cmd2, CS_CURSOR_DECLARE, name2, CS_NULLTERM, text, CS_NULLTERM, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor declare failed\n");
return 1;
}
ret = ct_cursor(cmd2, CS_CURSOR_ROWS, name2, CS_NULLTERM, NULL, CS_UNUSED, (CS_INT) 1);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor set cursor rows failed");
return 1;
}
ret = ct_cursor(cmd2, CS_CURSOR_OPEN, name2, CS_NULLTERM, text, CS_NULLTERM, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor open failed\n");
return 1;
}
ret = ct_send(cmd2);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_send failed\n");
return 1;
}
while ((results_ret = ct_results(cmd2, &result_type)) == CS_SUCCEED) {
switch ((int) result_type) {
case CS_CMD_SUCCEED:
case CS_CMD_DONE:
case CS_CMD_FAIL:
case CS_STATUS_RESULT:
break;
case CS_CURSOR_RESULT:
ret = ct_res_info(cmd2, CS_NUMDATA, &num_cols, CS_UNUSED, NULL);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_res_info() failed");
return 1;
}
if (num_cols != 1) {
fprintf(stderr, "unexpected num of columns = %d \n", num_cols);
return 1;
}
for (i = 0; i < num_cols; i++) {
/* here we can finally test for the return status column */
ret = ct_describe(cmd2, i + 1, &datafmt2);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_describe() failed for column %d\n", i);
return 1;
}
if (datafmt2.status & CS_RETURN) {
fprintf(stdout, "ct_describe() column %d \n", i);
is_return_status = i + 1;
}
datafmt2.datatype = CS_CHAR_TYPE;
datafmt2.format = CS_FMT_NULLTERM;
datafmt2.maxlength = 6;
datafmt2.count = 1;
datafmt2.locale = NULL;
ret = ct_bind(cmd2, 1, &datafmt2, col2, &datalength, &ind);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_bind() failed\n");
return 1;
}
}
break;
case CS_COMPUTE_RESULT:
fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
return 1;
default:
fprintf(stderr, "ct_results() unexpected result_type.\n");
return 1;
}
}
row_count = 0;
while (((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED)
|| (ret == CS_ROW_FAIL)) {
ret2 = ct_fetch(cmd2, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count2);
if (ret == CS_SUCCEED && ret2 == CS_SUCCEED) {
printf("%s\t\t\t%s\n", col1, col2);
}
}
switch ((int) ret) {
case CS_END_DATA:
break;
case CS_ROW_FAIL:
fprintf(stderr, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
return 1;
case CS_FAIL:
fprintf(stderr, "ct_fetch() returned CS_FAIL.\n");
return 1;
default:
fprintf(stderr, "ct_fetch() unexpected return.\n");
return 1;
}
if (verbose) {
fprintf(stdout, "closing first cursor on connection\n");
}
ret = ct_cursor(cmd, CS_CURSOR_CLOSE, name, CS_NULLTERM, NULL, CS_UNUSED, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor(close) failed\n");
return ret;
}
if ((ret = ct_send(cmd)) != CS_SUCCEED) {
fprintf(stderr, "BILL ct_send() failed\n");
return ret;
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
if (result_type == CS_CMD_FAIL) {
fprintf(stderr, "ct_results(2) result_type CS_CMD_FAIL.\n");
return 1;
}
}
if (results_ret != CS_END_RESULTS) {
fprintf(stderr, "ct_results() returned BAD.\n");
return 1;
}
ret = ct_cursor(cmd, CS_CURSOR_DEALLOC, name, CS_NULLTERM, NULL, CS_UNUSED, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor(dealloc) failed\n");
return ret;
}
if ((ret = ct_send(cmd)) != CS_SUCCEED) {
fprintf(stderr, "ct_send() failed\n");
return ret;
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
if (result_type == CS_CMD_FAIL) {
fprintf(stderr, "ct_results(3) result_type CS_CMD_FAIL.\n");
return 1;
}
}
if (results_ret != CS_END_RESULTS) {
fprintf(stderr, "ct_results() returned BAD.\n");
return 1;
}
if (verbose) {
fprintf(stdout, "closing second cursor on connection\n");
}
ret = ct_cursor(cmd2, CS_CURSOR_CLOSE, name2, CS_NULLTERM, NULL, CS_UNUSED, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor(close) failed\n");
return ret;
}
if ((ret = ct_send(cmd2)) != CS_SUCCEED) {
fprintf(stderr, "BILL ct_send() failed\n");
return ret;
}
while ((results_ret = ct_results(cmd2, &result_type)) == CS_SUCCEED) {
if (result_type == CS_CMD_FAIL) {
fprintf(stderr, "ct_results(2) result_type CS_CMD_FAIL.\n");
return 1;
}
}
if (results_ret != CS_END_RESULTS) {
fprintf(stderr, "ct_results() returned BAD.\n");
return 1;
}
ret = ct_cursor(cmd2, CS_CURSOR_DEALLOC, name2, CS_NULLTERM, NULL, CS_UNUSED, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor(dealloc) failed\n");
return ret;
}
if ((ret = ct_send(cmd2)) != CS_SUCCEED) {
fprintf(stderr, "ct_send() failed\n");
return ret;
}
while ((results_ret = ct_results(cmd2, &result_type)) == CS_SUCCEED) {
if (result_type == CS_CMD_FAIL) {
fprintf(stderr, "ct_results(3) result_type CS_CMD_FAIL.\n");
return 1;
}
}
if (results_ret != CS_END_RESULTS) {
fprintf(stderr, "ct_results() returned BAD.\n");
return 1;
}
ct_cmd_drop(cmd2);
ct_cmd_drop(cmd3);
if (verbose) {
fprintf(stdout, "Trying logout\n");
}
ret = try_ctlogout(ctx, conn, cmd, verbose);
if (ret != CS_SUCCEED) {
fprintf(stderr, "Logout failed\n");
return 2;
}
if (verbose) {
fprintf(stdout, "Test succeded\n");
}
return 0;
}
/**
* @brief read data from sybase ASE server TBL_DataUpdateFlag
*
* @return
*/
int CSybClient::read_DataUpdateFlag(int connId, char* tablename, int flagid, stDataUpdateTime* pData)
{
CS_CONNECTION *connection = getConnection(connId);
if(NULL == connection || NULL == tablename) return -1;
CLEAR_ALL_MESSAGE(connection);
CS_RETCODE retcode;
CS_COMMAND *cmd;
CS_INT res_type; /* result type from ct_results */
CS_INT row_count = 0;
/*
** Use the dbname database
*/
//CS_CHAR usetable[64] = {0};
//sprintf(usetable, "use %s\n", dbname);
//if(execNoReplyCmd(connection, usetable) < 0)
//{
// return -1;
//}
/*
** Allocate a command handle to send the query with
*/
if ((retcode = ct_cmd_alloc(connection, &cmd)) != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
return -1;
}
/*
** Define a language command.
*/
CS_CHAR select[256] = {0};
sprintf(select, "select UpdateTime, UpdateFlag from %s where UpdateIndex=%d", tablename, flagid);
retcode = ct_command(cmd, CS_LANG_CMD, select, CS_NULLTERM, CS_UNUSED);
if (retcode != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
ct_cancel(NULL, cmd, CS_CANCEL_ALL);
ct_cmd_drop(cmd);
return -1;
}
/*
** Send the command to the server
*/
if (ct_send(cmd) != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
ct_cancel(NULL, cmd, CS_CANCEL_ALL);
ct_cmd_drop(cmd);
return -1;
}
/*
** Process the results. Loop while ct_results() returns CS_SUCCEED.
*/
while ((retcode = ct_results(cmd, &res_type)) == CS_SUCCEED)
{
switch ((int)res_type)
{
case CS_CMD_SUCCEED:
/*
** This means no rows were returned.
*/
break;
case CS_CMD_DONE:
/*
** This means we're done with one result set.
*/
break;
case CS_CMD_FAIL:
/*
** This means that the server encountered an error
** while processing our command.
*/
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
ct_cancel(NULL, cmd, CS_CANCEL_ALL);
ct_cmd_drop(cmd);
return -1;
case CS_ROW_RESULT:
{
#define FIELD_UpdateTime 1 //ÒÔselect Óï¾äΪ׼
#define FIELD_UpdateFlag 2
CS_DATETIME updateTime;
CS_TINYINT updateFlag;
CS_INT i;
CS_INT rows_read;
CS_DATAFMT dfmt;
/*
** Bind to column
*/
dfmt.datatype = CS_DATETIME_TYPE;
dfmt.maxlength = CS_SIZEOF(CS_DATETIME);
dfmt.format = CS_FMT_UNUSED;
dfmt.count = 0;
dfmt.locale = NULL;
retcode = ct_bind(cmd, FIELD_UpdateTime, &dfmt, &updateTime, NULL, NULL);
if (retcode != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
ct_cmd_drop(cmd);
return -1;
}
//
dfmt.datatype = CS_TINYINT_TYPE;
dfmt.maxlength= CS_SIZEOF(CS_TINYINT);
retcode = ct_bind(cmd, FIELD_UpdateFlag, &dfmt, &updateFlag, NULL, NULL);
if (retcode != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
ct_cmd_drop(cmd);
return -1;
}
CS_DATEREC userdatetime;
/*
** Fetch the rows. Loop while ct_fetch() returns CS_SUCCEED or
** CS_ROW_FAIL
*/
while (((retcode = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &rows_read)) == CS_SUCCEED) ||
(retcode == CS_ROW_FAIL))
{
/*
** Increment our row count by the number of rows just fetched.
*/
row_count = row_count + rows_read;
/*
** Check if we hit a recoverable error.
*/
if (retcode == CS_ROW_FAIL)
{
}
/*
** We have a row. Loop through the columns displaying the
** column values.
*/
//printf("%ld rows read from TBL_DataUpdateFlag\n", (long)rows_read);
for (i = 0; i < rows_read; i++)
{
if(cs_dt_crack(context, CS_DATETIME_TYPE, &updateTime, &userdatetime) == CS_SUCCEED)
{
sprintf(pData->UpdateTime, "%04d-%02d-%02d %02d:%02d:%02d", userdatetime.dateyear, userdatetime.datemonth+1, userdatetime.datedmonth, userdatetime.datehour, userdatetime.dateminute, userdatetime.datesecond);
pData->UpdateIndex = flagid;
pData->UpdateFlag = updateFlag;
}
}
}
/*
** We're done processing rows. Let's check the final return
** value of ct_fetch().
*/
switch ((int)retcode)
{
case CS_END_DATA:
/*
** Everything went fine.
*/
retcode = CS_SUCCEED;
break;
case CS_FAIL:
/*
** Something terrible happened.
*/
break;
default:
/*
** We got an unexpected return value.
*/
break;
}
}
///////////////////////
if (retcode != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
ct_cmd_drop(cmd);
return -1;
}
break;
default:
/*
** We got an unexpected result type.
*/
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
ct_cancel(NULL, cmd, CS_CANCEL_ALL);
ct_cmd_drop(cmd);
return -1;
}
}
/*
** We're done processing results. Let's check the
** return value of ct_results() to see if everything
** went ok.
*/
switch ((int)retcode)
{
case CS_END_RESULTS:
/*
** Everything went fine.
*/
break;
case CS_FAIL:
/*
** Something went wrong.
*/
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
ct_cmd_drop(cmd);
return -1;
default:
/*
** We got an unexpected return value.
*/
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
ct_cmd_drop(cmd);
return -1;
}
/*
** Drop our command structure
*/
if ((retcode = ct_cmd_drop(cmd)) != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
return -1;
}
return retcode == CS_SUCCEED ? row_count : -1;
}
int CSybClient::write_ImsiMsisdn(int connId, char* tablename, stImsiMsisdn* pNum)
{
CS_CONNECTION *connection = getConnection(connId);
if(NULL == connection || NULL == tablename) return -1;
if(NULL == pNum) return -1;
CLEAR_ALL_MESSAGE(connection);
//
CS_RETCODE retcode;
CS_INT restype;
CS_COMMAND *cmd = NULL;
CS_RETCODE query_code;
/*
** Get a command handle, store the command string in it, and
** send it to the server.
*/
if ((retcode = ct_cmd_alloc(connection, &cmd)) != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
return -1;
}
//
CS_CHAR cmdstring[1024] = {0};
char strimsi[32] = {0};
memcpy(strimsi, pNum->strImsi, MINIX(sizeof(strimsi) - 1, pNum->ImsiLen));
sprintf(cmdstring, "insert into %s (IMSI, MSISDN, UpdateTime, AreaCode, SARNumber, ExchangeHouse) values (\"%s\", \"%s\", getdate(), \"%s\", %hhu, %hhu)",
tablename, strimsi, pNum->strMsisdn, pNum->strAreaCode, pNum->admCenter, pNum->switchCenter);
if ((retcode = ct_command(cmd, CS_LANG_CMD, cmdstring, CS_NULLTERM, CS_UNUSED)) != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
ct_cancel(NULL, cmd, CS_CANCEL_ALL);
ct_cmd_drop(cmd);
return -1;
}
if ((retcode = ct_send(cmd)) != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
ct_cancel(NULL, cmd, CS_CANCEL_ALL);
ct_cmd_drop(cmd);
return -1;
}
/*
** Examine the results coming back. If any errors are seen, the query
** result code (which we will return from this function) will be
** set to FAIL.
*/
query_code = CS_SUCCEED;
while ((retcode = ct_results(cmd, &restype)) == CS_SUCCEED)
{
switch((int)restype)
{
case CS_CMD_SUCCEED:
case CS_CMD_DONE:
break;
case CS_CMD_FAIL:
query_code = CS_FAIL;
break;
case CS_STATUS_RESULT:
retcode = ct_cancel(NULL, cmd, CS_CANCEL_CURRENT);
if (retcode != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
query_code = CS_FAIL;
}
break;
default:
/*
** Unexpected result type.
*/
query_code = CS_FAIL;
break;
}
if (query_code == CS_FAIL)
{
/*
** Terminate results processing and break out of
** the results loop
*/
retcode = ct_cancel(NULL, cmd, CS_CANCEL_ALL);
if (retcode != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
}
break;
}
}
/*
** Clean up the command handle used
*/
if (retcode == CS_END_RESULTS)
{
retcode = ct_cmd_drop(cmd);
if (retcode != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
query_code = CS_FAIL;
}
}
else
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
(void)ct_cmd_drop(cmd);
query_code = CS_FAIL;
}
return query_code == CS_SUCCEED ? 0 : -1;
}
int CSybClient::delMsisdnImsiByMsisdn(int connId, char* tablename, stImsiMsisdn* pmsisdn)
{
CS_CONNECTION *connection = getConnection(connId);
if(NULL == connection || NULL == tablename) return -1;
if(NULL == pmsisdn) return -1;
CLEAR_ALL_MESSAGE(connection);
//
CS_RETCODE retcode;
CS_INT restype;
CS_COMMAND *cmd = NULL;
CS_RETCODE query_code;
/*
** Get a command handle, store the command string in it, and
** send it to the server.
*/
if ((retcode = ct_cmd_alloc(connection, &cmd)) != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
return -1;
}
//
CS_CHAR cmdstring[1024] = {0};
sprintf(cmdstring, "delete from %s where MSISDN='%s'", tablename, pmsisdn->strMsisdn);
if ((retcode = ct_command(cmd, CS_LANG_CMD, cmdstring, CS_NULLTERM, CS_UNUSED)) != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
ct_cancel(NULL, cmd, CS_CANCEL_ALL);
ct_cmd_drop(cmd);
return -1;
}
if ((retcode = ct_send(cmd)) != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
ct_cancel(NULL, cmd, CS_CANCEL_ALL);
ct_cmd_drop(cmd);
return -1;
}
/*
** Examine the results coming back. If any errors are seen, the query
** result code (which we will return from this function) will be
** set to FAIL.
*/
query_code = CS_SUCCEED;
while ((retcode = ct_results(cmd, &restype)) == CS_SUCCEED)
{
switch((int)restype)
{
case CS_CMD_SUCCEED:
case CS_CMD_DONE:
break;
case CS_CMD_FAIL:
query_code = CS_FAIL;
break;
case CS_STATUS_RESULT:
retcode = ct_cancel(NULL, cmd, CS_CANCEL_CURRENT);
if (retcode != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
query_code = CS_FAIL;
}
break;
default:
/*
** Unexpected result type.
*/
query_code = CS_FAIL;
break;
}
if (query_code == CS_FAIL)
{
/*
** Terminate results processing and break out of
** the results loop
*/
retcode = ct_cancel(NULL, cmd, CS_CANCEL_ALL);
if (retcode != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
}
break;
}
}
/*
** Clean up the command handle used
*/
if (retcode == CS_END_RESULTS)
{
retcode = ct_cmd_drop(cmd);
if (retcode != CS_SUCCEED)
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
query_code = CS_FAIL;
}
}
else
{
DIAG_CLIENT_MESSAGE(connection);
DIAG_SERVER_MESSAGE(connection);
(void)ct_cmd_drop(cmd);
query_code = CS_FAIL;
}
return query_code == CS_SUCCEED ? 0 : -1;
}
CS_RETCODE
continue_logging_in(CS_CONTEXT ** ctx, CS_CONNECTION ** conn, CS_COMMAND ** cmd, int verbose)
{
CS_RETCODE ret;
char query[30];
#ifdef TDS_STATIC_CAST
TDSCONTEXT *tds_ctx;
#endif
ret = cs_ctx_alloc(CS_VERSION_100, ctx);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Context Alloc failed!\n");
}
return ret;
}
#ifdef TDS_STATIC_CAST
/* Force default date format, some tests rely on it */
tds_ctx = (TDSCONTEXT *) (*ctx)->tds_ctx;
if (tds_ctx && tds_ctx->locale && tds_ctx->locale->date_fmt) {
free(tds_ctx->locale->date_fmt);
tds_ctx->locale->date_fmt = strdup("%b %d %Y %I:%M%p");
}
#endif
ret = ct_init(*ctx, CS_VERSION_100);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Library Init failed!\n");
}
return ret;
}
if ((ret = ct_callback(*ctx, NULL, CS_SET, CS_CLIENTMSG_CB,
(CS_VOID*) clientmsg_cb)) != CS_SUCCEED) {
fprintf(stderr, "ct_callback() failed\n");
return ret;
}
if ((ret = ct_callback(*ctx, NULL, CS_SET, CS_SERVERMSG_CB, servermsg_cb)) != CS_SUCCEED) {
fprintf(stderr, "ct_callback() failed\n");
return ret;
}
ret = ct_con_alloc(*ctx, conn);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Connect Alloc failed!\n");
}
return ret;
}
ret = ct_con_props(*conn, CS_SET, CS_USERNAME, USER, CS_NULLTERM, NULL);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "ct_con_props() SET USERNAME failed!\n");
}
return ret;
}
ret = ct_con_props(*conn, CS_SET, CS_PASSWORD, PASSWORD, CS_NULLTERM, NULL);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "ct_con_props() SET PASSWORD failed!\n");
}
return ret;
}
printf("connecting as %s to %s.%s\n", USER, SERVER, DATABASE);
ret = ct_connect(*conn, SERVER, CS_NULLTERM);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Connection failed!\n");
}
return ret;
}
ret = ct_cmd_alloc(*conn, cmd);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Command Alloc failed!\n");
}
return ret;
}
strcpy(query, "use ");
strncat(query, DATABASE, 20);
ret = run_command(*cmd, query);
if (ret != CS_SUCCEED)
return ret;
return CS_SUCCEED;
}
int
main(int argc, char **argv)
{
CS_CONTEXT *ctx;
CS_CONNECTION *conn;
CS_COMMAND *cmd;
CS_COMMAND *cmd2;
CS_RETCODE ret;
CS_RETCODE results_ret;
CS_INT result_type;
CS_INT count, row_count = 0;
CS_DATAFMT datafmt;
CS_SMALLINT ind;
int verbose = 1;
CS_CHAR name[3];
CS_CHAR col1[6];
CS_INT datalength;
CS_CHAR text[128];
CS_INT num_cols, i, j;
int is_return_status = 0;
CS_INT props_value;
fprintf(stdout, "%s: Testing ct_cursor()\n", __FILE__);
if (verbose) {
fprintf(stdout, "Trying login\n");
}
ret = try_ctlogin(&ctx, &conn, &cmd, verbose);
if (ret != CS_SUCCEED) {
fprintf(stderr, "Login failed\n");
return 1;
}
ret = ct_cmd_alloc(conn, &cmd2);
if (ret != CS_SUCCEED) {
if (verbose) {
fprintf(stderr, "Command Alloc failed!\n");
}
return ret;
}
ret = run_command(cmd, "CREATE TABLE #test_table (col1 char(4))");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd, "INSERT #test_table (col1) VALUES ('AAA')");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd, "INSERT #test_table (col1) VALUES ('BBB')");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd, "INSERT #test_table (col1) VALUES ('CCC')");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd2, "CREATE TABLE #test_table2 (col1 char(4))");
if (ret != CS_SUCCEED)
return 1;
ret = run_command(cmd2, "INSERT #test_table2 (col1) VALUES ('---')");
if (ret != CS_SUCCEED)
return 1;
if (verbose) {
fprintf(stdout, "Trying declare, rows , open in one SEND\n");
}
strcpy(text, "select col1 from #test_table where 1 = 1");
strcpy(name, "c1");
ret = ct_cursor(cmd, CS_CURSOR_DECLARE, name, CS_NULLTERM, text, CS_NULLTERM, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor declare failed\n");
return 1;
}
ret = ct_cursor(cmd, CS_CURSOR_ROWS, name, CS_NULLTERM, NULL, CS_UNUSED, (CS_INT) 1);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor set cursor rows failed");
return 1;
}
ret = ct_cursor(cmd, CS_CURSOR_OPEN, name, CS_NULLTERM, text, CS_NULLTERM, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor open failed\n");
return 1;
}
ret = ct_send(cmd);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_send failed\n");
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
switch ((int) result_type) {
case CS_CMD_SUCCEED:
case CS_CMD_DONE:
case CS_CMD_FAIL:
case CS_STATUS_RESULT:
break;
case CS_CURSOR_RESULT:
ret = ct_cmd_props(cmd, CS_GET, CS_CUR_STATUS, &props_value, sizeof(CS_INT), NULL);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cmd_props() failed\n");
return 1;
}
if (props_value & CS_CURSTAT_DECLARED) {
fprintf(stderr, "ct_cmd_props claims cursor is in DECLARED state when it should be OPEN\n");
return 1;
}
if (!(props_value & CS_CURSTAT_OPEN)) {
fprintf(stderr, "ct_cmd_props claims cursor is not in OPEN state when it should be \n");
return 1;
}
if (props_value & CS_CURSTAT_CLOSED) {
fprintf(stderr, "ct_cmd_props claims cursor is in CLOSED state when it should be OPEN\n");
return 1;
}
ret = ct_res_info(cmd, CS_NUMDATA, &num_cols, CS_UNUSED, NULL);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_res_info() failed");
return 1;
}
if (num_cols != 1) {
fprintf(stderr, "unexpected num of columns = %d \n", num_cols);
return 1;
}
for (i = 0; i < num_cols; i++) {
/* here we can finally test for the return status column */
ret = ct_describe(cmd, i + 1, &datafmt);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_describe() failed for column %d\n", i);
return 1;
}
if (datafmt.status & CS_RETURN) {
fprintf(stdout, "ct_describe() column %d \n", i);
is_return_status = i + 1;
}
datafmt.datatype = CS_CHAR_TYPE;
datafmt.format = CS_FMT_NULLTERM;
datafmt.maxlength = 6;
datafmt.count = 1;
datafmt.locale = NULL;
ret = ct_bind(cmd, 1, &datafmt, col1, &datalength, &ind);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_bind() failed\n");
return 1;
}
}
row_count = 0;
while (((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED)
|| (ret == CS_ROW_FAIL)) {
if (row_count == 0) {
for (j = 0; j < num_cols; j++) {
fprintf(stdout, "\n%s\n", datafmt.name);
}
fprintf(stdout, "------\n\n");
}
for (j = 0; j < num_cols; j++) {
fprintf(stdout, "%s\n\n", col1);
row_count++;
}
ret = update_second_table(cmd2, col1);
if (ret)
return ret;
}
switch ((int) ret) {
case CS_END_DATA:
break;
case CS_ROW_FAIL:
fprintf(stderr, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
return 1;
case CS_FAIL:
fprintf(stderr, "ct_fetch() returned CS_FAIL.\n");
return 1;
default:
fprintf(stderr, "ct_fetch() unexpected return. %d\n", ret);
return 1;
}
break;
case CS_COMPUTE_RESULT:
fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
return 1;
default:
fprintf(stderr, "ct_results() unexpected result_type.\n");
return 1;
}
}
ret = ct_cursor(cmd, CS_CURSOR_CLOSE, name, CS_NULLTERM, NULL, CS_UNUSED, CS_DEALLOC);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor(close) failed\n");
return ret;
}
if ((ret = ct_send(cmd)) != CS_SUCCEED) {
fprintf(stderr, "BILL ct_send() failed\n");
return ret;
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
if (result_type == CS_CMD_FAIL) {
fprintf(stderr, "ct_results(2) result_type CS_CMD_FAIL.\n");
return 1;
}
}
if (results_ret != CS_END_RESULTS) {
fprintf(stderr, "ct_results() returned BAD.\n");
return 1;
}
ret = ct_cmd_props(cmd, CS_GET, CS_CUR_STATUS, &props_value, sizeof(CS_INT), NULL);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cmd_props() failed");
return 1;
}
if (props_value != CS_CURSTAT_NONE) {
fprintf(stderr, "ct_cmd_props() CS_CUR_STATUS != CS_CURSTAT_NONE \n");
return 1;
}
if (verbose) {
fprintf(stdout, "Trying declare, rows, open one at a time \n");
}
strcpy(text, "select col1 from #test_table where 2 = 2");
ret = ct_cursor(cmd, CS_CURSOR_DECLARE, name, 3, text, CS_NULLTERM, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor declare failed\n");
return 1;
}
ret = ct_send(cmd);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_send failed\n");
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
if (result_type == CS_CMD_FAIL) {
fprintf(stderr, "ct_results(4) result_type CS_CMD_FAIL.\n");
return 1;
}
}
if (results_ret != CS_END_RESULTS) {
fprintf(stderr, "ct_results() returned BAD.\n");
return 1;
}
ret = ct_cursor(cmd, CS_CURSOR_ROWS, name, 3, NULL, CS_UNUSED, (CS_INT) 1);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor set cursor rows failed");
return 1;
}
ret = ct_send(cmd);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_send failed\n");
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
if (result_type == CS_CMD_FAIL) {
fprintf(stderr, "ct_results(5) result_type CS_CMD_FAIL.\n");
return 1;
}
}
if (results_ret != CS_END_RESULTS) {
fprintf(stderr, "ct_results() returned BAD.\n");
return 1;
}
ret = ct_cursor(cmd, CS_CURSOR_OPEN, name, 3, text, 26, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor open failed\n");
return 1;
}
ret = ct_send(cmd);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_send failed\n");
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
switch ((int) result_type) {
case CS_CMD_SUCCEED:
break;
case CS_CMD_DONE:
break;
case CS_CMD_FAIL:
fprintf(stderr, "ct_results(6) result_type CS_CMD_FAIL.\n");
break;
case CS_STATUS_RESULT:
fprintf(stdout, "ct_results: CS_STATUS_RESULT detected for sp_who\n");
case CS_CURSOR_RESULT:
ret = ct_res_info(cmd, CS_NUMDATA, &num_cols, CS_UNUSED, NULL);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_res_info() failed");
return 1;
}
if (num_cols != 1) {
fprintf(stderr, "unexpected num of columns = %d \n", num_cols);
return 1;
}
for (i = 0; i < num_cols; i++) {
/* here we can finally test for the return status column */
ret = ct_describe(cmd, i + 1, &datafmt);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_describe() failed for column %d\n", i);
return 1;
}
if (datafmt.status & CS_RETURN) {
fprintf(stdout, "ct_describe() column %d \n", i);
is_return_status = i + 1;
}
datafmt.datatype = CS_CHAR_TYPE;
datafmt.format = CS_FMT_NULLTERM;
datafmt.maxlength = 6;
datafmt.count = 1;
datafmt.locale = NULL;
ret = ct_bind(cmd, 1, &datafmt, col1, &datalength, &ind);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_bind() failed\n");
return 1;
}
}
row_count = 0;
while (((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED)
|| (ret == CS_ROW_FAIL)) {
if (row_count == 0) {
for (j = 0; j < num_cols; j++) {
fprintf(stdout, "\n%s\n", datafmt.name);
}
fprintf(stdout, "------\n\n");
}
for (j = 0; j < num_cols; j++) {
fprintf(stdout, "%s\n\n", col1);
row_count++;
}
}
switch ((int) ret) {
case CS_END_DATA:
break;
case CS_ROW_FAIL:
fprintf(stderr, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
return 1;
case CS_FAIL:
fprintf(stderr, "ct_fetch() returned CS_FAIL.\n");
return 1;
default:
fprintf(stderr, "ct_fetch() unexpected return. %d\n", ret);
return 1;
}
break;
case CS_COMPUTE_RESULT:
fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
return 1;
default:
fprintf(stderr, "ct_results() unexpected result_type.\n");
return 1;
}
}
ret = ct_cursor(cmd, CS_CURSOR_CLOSE, name, 3, NULL, CS_UNUSED, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor(close) failed\n");
return ret;
}
if ((ret = ct_send(cmd)) != CS_SUCCEED) {
fprintf(stderr, "ct_send() failed\n");
return ret;
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
if (result_type == CS_CMD_FAIL) {
fprintf(stderr, "ct_results(7) result_type CS_CMD_FAIL.\n");
return 1;
}
}
if (results_ret != CS_END_RESULTS) {
fprintf(stderr, "ct_results() returned BAD.\n");
return 1;
}
ret = ct_cursor(cmd, CS_CURSOR_DEALLOC, name, 3, NULL, CS_UNUSED, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_cursor(dealloc) failed\n");
return ret;
}
if ((ret = ct_send(cmd)) != CS_SUCCEED) {
fprintf(stderr, "ct_send() failed\n");
return ret;
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
if (result_type == CS_CMD_FAIL) {
fprintf(stderr, "ct_results(8) result_type CS_CMD_FAIL.\n");
return 1;
}
}
if (results_ret != CS_END_RESULTS) {
fprintf(stderr, "ct_results() returned BAD.\n");
return 1;
}
if (verbose) {
fprintf(stdout, "Running normal select command after cursor operations\n");
}
ret = ct_command(cmd, CS_LANG_CMD, "select col1 from #test_table", CS_NULLTERM, CS_UNUSED);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_command() failed\n");
return 1;
}
ret = ct_send(cmd);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_send() failed\n");
return 1;
}
while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
switch ((int) result_type) {
case CS_CMD_SUCCEED:
break;
case CS_CMD_DONE:
break;
case CS_CMD_FAIL:
fprintf(stderr, "ct_results() result_type CS_CMD_FAIL.\n");
return 1;
case CS_ROW_RESULT:
datafmt.datatype = CS_CHAR_TYPE;
datafmt.format = CS_FMT_NULLTERM;
datafmt.maxlength = 6;
datafmt.count = 1;
datafmt.locale = NULL;
ret = ct_bind(cmd, 1, &datafmt, col1, &datalength, &ind);
if (ret != CS_SUCCEED) {
fprintf(stderr, "ct_bind() failed\n");
return 1;
}
while (((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED)
|| (ret == CS_ROW_FAIL)) {
row_count += count;
if (ret == CS_ROW_FAIL) {
fprintf(stderr, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
return 1;
} else if (ret == CS_SUCCEED) {
;
} else {
break;
}
}
switch ((int) ret) {
case CS_END_DATA:
break;
case CS_FAIL:
fprintf(stderr, "ct_fetch() returned CS_FAIL.\n");
return 1;
default:
fprintf(stderr, "ct_fetch() unexpected return.%d\n", ret);
return 1;
}
break;
case CS_COMPUTE_RESULT:
fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
return 1;
default:
fprintf(stderr, "ct_results() unexpected result_type. %d\n", result_type);
return 1;
}
}
switch ((int) results_ret) {
case CS_END_RESULTS:
break;
case CS_FAIL:
fprintf(stderr, "ct_results() failed.\n");
return 1;
break;
default:
fprintf(stderr, "ct_results() unexpected return.\n");
return 1;
}
if (verbose) {
fprintf(stdout, "Trying logout\n");
}
ct_cmd_drop(cmd2);
ret = try_ctlogout(ctx, conn, cmd, verbose);
if (ret != CS_SUCCEED) {
fprintf(stderr, "Logout failed\n");
return 2;
}
if (verbose) {
fprintf(stdout, "Test suceeded\n");
}
return 0;
}