CAMLexport value mltds_add_messages_client(value vconnection, value vlist) { CAMLparam2(vconnection, vlist); CS_CONNECTION* conn = connection_ptr(vconnection); CS_INT msgcount; CS_INT msgno; retval_inspect( "ct_diag", ct_diag(conn, CS_STATUS, CS_CLIENTMSG_TYPE, CS_UNUSED, &msgcount)); for(msgno = msgcount; msgno > 0; msgno--) vlist = cons(get_client_message(conn, msgno), vlist); retval_inspect( "ct_diag", ct_diag(conn, CS_CLEAR, CS_CLIENTMSG_TYPE, CS_UNUSED, NULL)); CAMLreturn(vlist); }
CAMLprim value mltds_ct_con_alloc(value context) { CAMLparam1(context); CS_CONNECTION* conn; CAMLlocal1(result); retval_inspect( "ct_con_alloc", ct_con_alloc(context_ptr(context), &conn) ); retval_inspect( "ct_diag", ct_diag(conn, CS_INIT, CS_UNUSED, CS_UNUSED, NULL) ); result = alloc_custom(&connection_operations, sizeof(CS_CONNECTION*), 0, 1); connection_ptr(result) = conn; CAMLreturn(result); }
static value get_server_message(CS_CONNECTION* conn, CS_INT msgno) { CAMLparam0(); CAMLlocal2(result,str); CS_SERVERMSG msg; retval_inspect( "ct_diag", ct_diag(conn, CS_GET, CS_SERVERMSG_TYPE, msgno, &msg) ); str = caml_alloc_initialized_string(msg.textlen, msg.text); result = alloc(2, 0); Store_field(result, 0, value_of_severity(msg.severity)); Store_field(result, 1, str); CAMLreturn(result); }
/* Testing: Client Messages */ int main(int argc, char *argv[]) { CS_CONTEXT *ctx; CS_CONNECTION *conn; CS_COMMAND *cmd; int verbose = 0; CS_RETCODE ret; CS_RETCODE results_ret; CS_INT result_type; CS_INT num_cols; CS_DATAFMT datafmt; CS_INT datalength; CS_SMALLINT ind[2]; CS_INT count, row_count = 0; CS_INT cv; int i; CS_CHAR select[1024]; CS_INT col1[2]; CS_CHAR col2[2][5]; CS_INT num_msgs, totmsgs; CS_CLIENTMSG client_message; int result = 1; fprintf(stdout, "%s: Retrieve data using array binding \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; } if (ct_diag(conn, CS_INIT, CS_UNUSED, CS_UNUSED, NULL) != CS_SUCCEED) { fprintf(stderr, "ct_diag(CS_INIT) failed\n"); return 1; } totmsgs = 1; if (ct_diag(conn, CS_MSGLIMIT, CS_CLIENTMSG_TYPE, CS_UNUSED, &totmsgs) != CS_SUCCEED) { fprintf(stderr, "ct_diag(CS_MSGLIMIT) failed\n"); return 1; } fprintf(stdout, "Maximum message limit is set to: %d\n", totmsgs); ret = run_command(cmd, "CREATE TABLE #ctlibarray (col1 int not null, col2 char(4) not null, col3 datetime not null)"); if (ret != CS_SUCCEED) return 1; ret = run_command(cmd, "insert into #ctlibarray values (1, 'AAAA', 'Jan 1 2002 10:00:00AM')"); if (ret != CS_SUCCEED) return 1; ret = run_command(cmd, "insert into #ctlibarray values (2, 'BBBB', 'Jan 2 2002 10:00:00AM')"); if (ret != CS_SUCCEED) return 1; strcpy(select, "select col1, col2 from #ctlibarray order by col1 "); ret = ct_command(cmd, CS_LANG_CMD, select, CS_NULLTERM, CS_UNUSED); if (ret != CS_SUCCEED) { fprintf(stderr, "ct_command(%s) failed\n", select); 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: 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 != 2) { fprintf(stderr, "num_cols %d != 2", num_cols); return 1; } ret = ct_describe(cmd, 1, &datafmt); if (ret != CS_SUCCEED) { fprintf(stderr, "ct_describe() failed"); return 1; } datafmt.format = CS_FMT_UNUSED; if (datafmt.maxlength > 1024) { datafmt.maxlength = 1024; } datafmt.count = 2; ret = ct_bind(cmd, 1, &datafmt, &col1, &datalength, ind); if (ret != CS_SUCCEED) { fprintf(stderr, "ct_bind() failed\n"); return 1; } ret = ct_describe(cmd, 2, &datafmt); if (ret != CS_SUCCEED) { fprintf(stderr, "ct_describe() failed"); return 1; } datafmt.format = CS_FMT_NULLTERM; datafmt.maxlength = 5; datafmt.count = 4; ret = ct_bind(cmd, 2, &datafmt, col2[0], &datalength, ind); if (ret != CS_SUCCEED) { if (ct_diag(conn, CS_STATUS, CS_CLIENTMSG_TYPE, CS_UNUSED, &num_msgs) != CS_SUCCEED) { fprintf(stderr, "ct_diag(CS_STATUS) failed\n"); return 1; } fprintf(stdout, "Number of client messages returned: %d\n", num_msgs); for (i = 0; i < num_msgs; i++) { if (ct_diag(conn, CS_GET, CS_CLIENTMSG_TYPE, i + 1, &client_message) != CS_SUCCEED) { fprintf(stderr, "cs_diag(CS_GET) failed\n"); return 1; } clientmsg_cb(ctx, conn, &client_message); } if (ct_diag(conn, CS_CLEAR, CS_CLIENTMSG_TYPE, CS_UNUSED, NULL) != CS_SUCCEED) { fprintf(stderr, "cs_diag(CS_CLEAR) failed\n"); return 1; } if (ct_diag(conn, CS_STATUS, CS_CLIENTMSG_TYPE, CS_UNUSED, &num_msgs) != CS_SUCCEED) { fprintf(stderr, "cs_diag(CS_STATUS) failed\n"); return 1; } if (num_msgs != 0) { fprintf(stderr, "cs_diag(CS_CLEAR) failed there are still %d messages on queue\n", num_msgs); return 1; } /* we catch error, good */ result = 0; } else { fprintf(stderr, "ct_bind() succeeded while it shouldn't\n"); return 1; } datafmt.count = 2; ret = ct_bind(cmd, 2, &datafmt, col2[0], &datalength, ind); if (ret != CS_SUCCEED) { fprintf(stderr, "ct_bind() failed\n"); return 1; } count = 0; 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 { /* ret == CS_SUCCEED */ fprintf(stdout, "ct_fetch returned %d rows\n", count); for (cv = 0; cv < count; cv++) fprintf(stdout, "col1 = %d col2= '%s'\n", col1[cv], col2[cv]); } count = 0; } 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.\n"); return 1; } break; default: fprintf(stderr, "ct_results() unexpected result_type.\n"); 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"); } ret = try_ctlogout(ctx, conn, cmd, verbose); if (ret != CS_SUCCEED) { fprintf(stderr, "Logout failed\n"); return 1; } return result; }
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; }