tiny_tds 0.2.3 → 0.3.1

data/CHANGELOG

@@ -1,4 +1,18 @@
 
+* 0.3.1 *
+
+* Fix bad gem build.
+
+
+* 0.3.0 *
+
+* Access stored procedure return codes.
+
+* Make sure dead or not enabled connections are handled.
+
+* Fix bad client after timeout & read from server errors.
+
+
 * 0.2.3 *
 
 *  Do not use development ruby/version, but simple memoize an eval check on init to find out, for 1.8.6 reflection.

data/README.rdoc

@@ -136,6 +136,14 @@ The result object can handle multiple result sets form batched SQL or stored pro
     # 2nd: [{"bigint"=>-9223372036854775807}, {"bigint"=>9223372036854775806}]
   end
 
+It is possible to get the return code after executing a stored procedure from either the result or client object.
+
+  client.return_code  # => nil
+  
+  result = client.execute("EXEC tinytds_TestReturnCodes")
+  result.return_code  # => 420
+  client.return_code  # => 420
+
 
 == Query Options
 

data/ext/tiny_tds/client.c

@@ -15,8 +15,11 @@ VALUE opt_escape_regex, opt_escape_dblquote;
   tinytds_client_wrapper *cwrap; \
   Data_Get_Struct(self, tinytds_client_wrapper, cwrap)
 
+#define GET_CLIENT_USERDATA(dbproc) \
+  tinytds_client_userdata *userdata = (tinytds_client_userdata *)dbgetuserdata(dbproc);
+
 #define REQUIRE_OPEN_CLIENT(cwrap) \
-  if(cwrap->closed) { \
+  if (cwrap->closed || cwrap->userdata->closed) { \
     rb_raise(cTinyTdsError, "closed connection"); \
     return Qnil; \
   }
@@ -25,7 +28,13 @@ VALUE opt_escape_regex, opt_escape_dblquote;
 // Lib Backend (Helpers)
 
 static VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, int cancel, char *error, char *source, int severity, int dberr, int oserr) {
-  if (cancel) { dbsqlok(dbproc); dbcancel(dbproc); }
+  GET_CLIENT_USERDATA(dbproc);
+  if (cancel && !dbdead(dbproc) && userdata && !userdata->closed) { 
+    userdata->dbsqlok_sent = 1;
+    dbsqlok(dbproc);
+    userdata->dbcancel_sent = 1;
+    dbcancel(dbproc);
+  }
   VALUE e = rb_exc_new2(cTinyTdsError, error);
   rb_funcall(e, intern_source_eql, 1, rb_str_new2(source));
   if (severity)
@@ -33,7 +42,7 @@ static VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, int cancel, char *error,
   if (dberr)
     rb_funcall(e, intern_db_error_number_eql, 1, INT2FIX(dberr));
   if (oserr)
-    rb_funcall(e, intern_os_error_number_eql, 1, INT2FIX(oserr));  
+    rb_funcall(e, intern_os_error_number_eql, 1, INT2FIX(oserr));   
   rb_exc_raise(e);
   return Qnil;
 }
@@ -41,12 +50,40 @@ static VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, int cancel, char *error,
 
 // Lib Backend (Memory Management & Handlers)
 
-int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, char *dberrstr, char *oserrstr) {  
-  static char *source = "error";
-  if (dberr == SYBESMSG)
-    return INT_CONTINUE;
-  rb_tinytds_raise_error(dbproc, 0, dberrstr, source, severity, dberr, oserr);
-  return INT_CONTINUE;
+int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, char *dberrstr, char *oserrstr) { 
+ static char *source = "error";
+ GET_CLIENT_USERDATA(dbproc);
+ int return_value = INT_CONTINUE;
+ int cancel = 0;
+ switch(dberr) {
+   case SYBESMSG:
+     return return_value;
+   case SYBEFCON:
+   case SYBESOCK:
+   case SYBECONN:
+     return_value = INT_EXIT;
+     break;
+   case SYBESEOF: {
+     if (userdata && userdata->timing_out)
+       return_value = INT_TIMEOUT;
+   }
+   case SYBETIME: {
+     if (userdata) {
+       if (userdata->timing_out) {
+         return INT_CONTINUE;
+       } else {
+         userdata->timing_out = 1;
+       }
+     }
+     cancel = 1;
+     break;
+   }
+   case SYBEREAD:
+     cancel = 1;
+     break;
+ }
+ rb_tinytds_raise_error(dbproc, cancel, dberrstr, source, severity, dberr, oserr);
+ return return_value;
 }
 
 int tinytds_msg_handler(DBPROCESS *dbproc, DBINT msgno, int msgstate, int severity, char *msgtext, char *srvname, char *procname, int line) {
@@ -56,6 +93,12 @@ int tinytds_msg_handler(DBPROCESS *dbproc, DBINT msgno, int msgstate, int severi
   return 0;
 }
 
+static void rb_tinytds_client_reset_userdata(tinytds_client_userdata *userdata) {
+  userdata->timing_out = 0;
+  userdata->dbsqlok_sent = 0;
+  userdata->dbcancel_sent = 0;
+}
+
 static void rb_tinytds_client_mark(void *ptr) {
   tinytds_client_wrapper *cwrap = (tinytds_client_wrapper *)ptr;
   if (cwrap) {
@@ -70,7 +113,9 @@ static void rb_tinytds_client_free(void *ptr) {
   if (cwrap->client && !cwrap->closed) {
     dbclose(cwrap->client);
     cwrap->closed = 1;
+    cwrap->userdata->closed = 1;
   }
+  xfree(cwrap->userdata);
   xfree(ptr);
 }
 
@@ -80,6 +125,9 @@ static VALUE allocate(VALUE klass) {
   obj = Data_Make_Struct(klass, tinytds_client_wrapper, rb_tinytds_client_mark, rb_tinytds_client_free, cwrap);
   cwrap->closed = 1;
   cwrap->charset = Qnil;
+  cwrap->userdata = malloc(sizeof(tinytds_client_userdata));
+  cwrap->userdata->closed = 1;
+  rb_tinytds_client_reset_userdata(cwrap->userdata);  
   return obj;
 }
 
@@ -96,22 +144,23 @@ static VALUE rb_tinytds_close(VALUE self) {
   if (cwrap->client && !cwrap->closed) {
     dbclose(cwrap->client);
     cwrap->closed = 1;
+    cwrap->userdata->closed = 1;
   }
   return Qtrue;
 }
 
 static VALUE rb_tinytds_closed(VALUE self) {
   GET_CLIENT_WRAPPER(self);
-  return cwrap->closed ? Qtrue : Qfalse;
+  return (cwrap->closed || cwrap->userdata->closed) ? Qtrue : Qfalse;
 }
 
 static VALUE rb_tinytds_execute(VALUE self, VALUE sql) {
   GET_CLIENT_WRAPPER(self);
+  rb_tinytds_client_reset_userdata(cwrap->userdata);
   REQUIRE_OPEN_CLIENT(cwrap);
   dbcmd(cwrap->client, StringValuePtr(sql));
-  if (dbsqlexec(cwrap->client) == FAIL) {
-    // TODO: Account for dbsqlexec() returned FAIL.
-    rb_warn("TinyTds: dbsqlexec() returned FAIL.\n");
+  if (dbsqlsend(cwrap->client) == FAIL) {
+    rb_warn("TinyTds: dbsqlsend() returned FAIL.\n");
     return Qfalse;
   }
   VALUE result = rb_tinytds_new_result_obj(cwrap->client);
@@ -148,6 +197,16 @@ static VALUE rb_tinytds_escape(VALUE self, VALUE string) {
   return new_string;
 }
 
+/* Duplicated in result.c */
+static VALUE rb_tinytds_return_code(VALUE self) {
+  GET_CLIENT_WRAPPER(self);
+  if (cwrap->client && dbhasretstat(cwrap->client)) {
+    return LONG2NUM((long)dbretstatus(cwrap->client));
+  } else {
+    return Qnil;
+  }
+}
+
 
 // TinyTds::Client (protected) 
 
@@ -175,11 +234,13 @@ static VALUE rb_tinytds_connect(VALUE self, VALUE user, VALUE pass, VALUE datase
   if (!NIL_P(charset))
     DBSETLCHARSET(cwrap->login, StringValuePtr(charset));
   cwrap->client = dbopen(cwrap->login, StringValuePtr(dataserver));
-  if (!NIL_P(database))
-    dbuse(cwrap->client, StringValuePtr(database));
   if (cwrap->client) {
     cwrap->closed = 0;
     cwrap->charset = charset;
+    dbsetuserdata(cwrap->client, cwrap->userdata);
+    cwrap->userdata->closed = 0;
+    if (!NIL_P(database))
+      dbuse(cwrap->client, StringValuePtr(database));
     #ifdef HAVE_RUBY_ENCODING_H
       VALUE transposed_encoding = rb_funcall(cTinyTdsClient, intern_transpose_iconv_encoding, 1, charset);
       cwrap->encoding = rb_enc_find(StringValuePtr(transposed_encoding));
@@ -202,6 +263,7 @@ void init_tinytds_client() {
   rb_define_method(cTinyTdsClient, "charset", rb_tinytds_charset, 0);
   rb_define_method(cTinyTdsClient, "encoding", rb_tinytds_encoding, 0);
   rb_define_method(cTinyTdsClient, "escape", rb_tinytds_escape, 1);
+  rb_define_method(cTinyTdsClient, "return_code", rb_tinytds_return_code, 0);
   /* Define TinyTds::Client Protected Methods */
   rb_define_protected_method(cTinyTdsClient, "connect", rb_tinytds_connect, 9);
   /* Intern TinyTds::Error Accessors */

data/ext/tiny_tds/client.h

@@ -4,12 +4,20 @@
 
 void init_tinytds_client();
 
+typedef struct {
+  short int closed;
+  short int timing_out;
+  short int dbsqlok_sent;
+  short int dbcancel_sent;
+} tinytds_client_userdata;
+
 typedef struct {
   LOGINREC *login;
   RETCODE return_code;
   DBPROCESS *client;
   short int closed;
   VALUE charset;
+  tinytds_client_userdata *userdata;
   #ifdef HAVE_RUBY_ENCODING_H
     rb_encoding *encoding;
   #endif

data/ext/tiny_tds/result.c

@@ -243,9 +243,11 @@ static VALUE rb_tinytds_result_each(int argc, VALUE * argv, VALUE self) {
   /* Make The Results Or Yield Existing */
   if (NIL_P(rwrap->results)) {
     rwrap->results = rb_ary_new();
+    RETCODE dbsqlok_rc = 0;
     RETCODE dbresults_rc = 0;
+    dbsqlok_rc = dbsqlok(rwrap->client);
     dbresults_rc = dbresults(rwrap->client);
-    while (dbresults_rc == SUCCEED) {
+    while ((dbsqlok_rc == SUCCEED) && (dbresults_rc == SUCCEED)) {
       /* Only do field and row work if there are rows in this result set. */
       int has_rows = (DBROWS(rwrap->client) == SUCCEED) ? 1 : 0;
       int number_of_fields = has_rows ? dbnumcols(rwrap->client) : 0;
@@ -321,6 +323,7 @@ static VALUE rb_tinytds_result_fields(VALUE self) {
 static VALUE rb_tinytds_result_cancel(VALUE self) {
   GET_RESULT_WRAPPER(self);
   if (rwrap->client)
+    dbsqlok(rwrap->client);
     dbcancel(rwrap->client);
   return Qtrue;
 }
@@ -328,6 +331,7 @@ static VALUE rb_tinytds_result_cancel(VALUE self) {
 static VALUE rb_tinytds_result_do(VALUE self) {
   GET_RESULT_WRAPPER(self);
   if (rwrap->client) {
+    dbsqlok(rwrap->client);
     dbcancel(rwrap->client);
     return LONG2NUM((long)dbcount(rwrap->client));
   } else {
@@ -344,9 +348,20 @@ static VALUE rb_tinytds_result_affected_rows(VALUE self) {
   }
 }
 
+/* Duplicated in client.c */
+static VALUE rb_tinytds_result_return_code(VALUE self) {
+  GET_RESULT_WRAPPER(self);
+  if (rwrap->client && dbhasretstat(rwrap->client)) {
+    return LONG2NUM((long)dbretstatus(rwrap->client));
+  } else {
+    return Qnil;
+  }
+}
+
 static VALUE rb_tinytds_result_insert(VALUE self) {
   GET_RESULT_WRAPPER(self);
   if (rwrap->client) {
+    dbsqlok(rwrap->client);
     dbcancel(rwrap->client);
     VALUE identity = Qnil;
     dbcmd(rwrap->client, "SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident");
@@ -382,6 +397,7 @@ void init_tinytds_result() {
   rb_define_method(cTinyTdsResult, "cancel", rb_tinytds_result_cancel, 0);
   rb_define_method(cTinyTdsResult, "do", rb_tinytds_result_do, 0);
   rb_define_method(cTinyTdsResult, "affected_rows", rb_tinytds_result_affected_rows, 0);
+  rb_define_method(cTinyTdsResult, "return_code", rb_tinytds_result_return_code, 0);
   rb_define_method(cTinyTdsResult, "insert", rb_tinytds_result_insert, 0);
   /* Intern String Helpers */
   intern_new = rb_intern("new");

data/lib/tiny_tds.rb

@@ -15,5 +15,5 @@ require 'tiny_tds/tiny_tds'
 #
 # Tiny Ruby Wrapper For FreeTDS Using DB-Library
 module TinyTds
-  VERSION = '0.2.3'
+  VERSION = '0.3.1'
 end

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
   - 3
-  version: 0.2.3
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Ken Collins
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-13 00:00:00 -05:00
+date: 2011-01-13 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -42,7 +42,6 @@ files:
 - lib/tiny_tds/client.rb
 - lib/tiny_tds/error.rb
 - lib/tiny_tds/result.rb
-- lib/tiny_tds/tiny_tds.bundle
 - lib/tiny_tds.rb
 has_rdoc: true
 homepage: http://github.com/rails-sqlserver/tiny_tds