tiny_tds 1.0.4 → 2.1.5

data/ext/tiny_tds/client.c

@@ -3,9 +3,9 @@
 
 VALUE cTinyTdsClient;
 extern VALUE mTinyTds, cTinyTdsError;
-static ID sym_username, sym_password, sym_dataserver, sym_database, sym_appname, sym_tds_version, sym_login_timeout, sym_timeout, sym_encoding, sym_azure;
+static ID sym_username, sym_password, sym_dataserver, sym_database, sym_appname, sym_tds_version, sym_login_timeout, sym_timeout, sym_encoding, sym_azure, sym_contained, sym_use_utf16, sym_message_handler;
 static ID intern_source_eql, intern_severity_eql, intern_db_error_number_eql, intern_os_error_number_eql;
-static ID intern_new, intern_dup, intern_transpose_iconv_encoding, intern_local_offset, intern_gsub;
+static ID intern_new, intern_dup, intern_transpose_iconv_encoding, intern_local_offset, intern_gsub, intern_call;
 VALUE opt_escape_regex, opt_escape_dblquote;
 
 
@@ -24,29 +24,49 @@ VALUE opt_escape_regex, opt_escape_dblquote;
 
 // Lib Backend (Helpers)
 
-VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, int cancel, const char *error, const char *source, int severity, int dberr, int oserr) {
+VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, tinytds_errordata error) {
   VALUE e;
   GET_CLIENT_USERDATA(dbproc);
-  if (cancel && !dbdead(dbproc) && userdata && !userdata->closed) {
+  if (error.cancel && !dbdead(dbproc) && userdata && !userdata->closed) {
     userdata->dbsqlok_sent = 1;
     dbsqlok(dbproc);
     userdata->dbcancel_sent = 1;
     dbcancel(dbproc);
   }
-  e = rb_exc_new2(cTinyTdsError, error);
-  rb_funcall(e, intern_source_eql, 1, rb_str_new2(source));
-  if (severity)
-    rb_funcall(e, intern_severity_eql, 1, INT2FIX(severity));
-  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));
+  e = rb_exc_new2(cTinyTdsError, error.error);
+  rb_funcall(e, intern_source_eql, 1, rb_str_new2(error.source));
+  if (error.severity)
+    rb_funcall(e, intern_severity_eql, 1, INT2FIX(error.severity));
+  if (error.dberr)
+    rb_funcall(e, intern_db_error_number_eql, 1, INT2FIX(error.dberr));
+  if (error.oserr)
+    rb_funcall(e, intern_os_error_number_eql, 1, INT2FIX(error.oserr));
+
+  if (error.severity <= 10 && error.is_message) {
+    VALUE message_handler = userdata && userdata->message_handler ? userdata->message_handler : Qnil;
+    if (message_handler && message_handler != Qnil && rb_respond_to(message_handler, intern_call) != 0) {
+      rb_funcall(message_handler, intern_call, 1, e);
+    }
+
+    return Qnil;
+  }
+
   rb_exc_raise(e);
   return Qnil;
 }
 
 
 // Lib Backend (Memory Management & Handlers)
+static void push_userdata_error(tinytds_client_userdata *userdata, tinytds_errordata error) {
+  // reallocate memory for the array as needed
+  if (userdata->nonblocking_errors_size == userdata->nonblocking_errors_length) {
+    userdata->nonblocking_errors_size *= 2;
+    userdata->nonblocking_errors = realloc(userdata->nonblocking_errors, userdata->nonblocking_errors_size * sizeof(tinytds_errordata));
+  }
+
+  userdata->nonblocking_errors[userdata->nonblocking_errors_length] = error;
+  userdata->nonblocking_errors_length++;
+}
 
 int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, char *dberrstr, char *oserrstr) {
   static const char *source = "error";
@@ -76,6 +96,13 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
       but we don't ever want to automatically retry. Instead have the app
       decide what to do.
       */
+      if (userdata && userdata->timing_out) {
+        return INT_CANCEL;
+      }
+      // userdata will not be set if hitting timeout during login so check for it first
+      if (userdata) {
+        userdata->timing_out = 1;
+      }
       return_value = INT_TIMEOUT;
       cancel = 1;
       break;
@@ -89,6 +116,16 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
       break;
   }
 
+  tinytds_errordata error_data = {
+    .is_message = 0,
+    .cancel = cancel,
+    .severity = severity,
+    .dberr = dberr,
+    .oserr = oserr
+  };
+  strncpy(error_data.error, dberrstr, ERROR_MSG_SIZE);
+  strncpy(error_data.source, source, ERROR_MSG_SIZE);
+
   /*
   When in non-blocking mode we need to store the exception data to throw it
   once the blocking call returns, otherwise we will segfault ruby since part
@@ -100,26 +137,9 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
       dbcancel(dbproc);
       userdata->dbcancel_sent = 1;
     }
-
-    /*
-    If we've already captured an error message, don't overwrite it. This is
-    here because FreeTDS sends a generic "General SQL Server error" message
-    that will overwrite the real message. This is not normally a problem
-    because a ruby exception is normally thrown and we bail before the
-    generic message can be sent.
-    */
-    if (!userdata->nonblocking_error.is_set) {
-      userdata->nonblocking_error.cancel = cancel;
-      strcpy(userdata->nonblocking_error.error, dberrstr);
-      strcpy(userdata->nonblocking_error.source, source);
-      userdata->nonblocking_error.severity = severity;
-      userdata->nonblocking_error.dberr = dberr;
-      userdata->nonblocking_error.oserr = oserr;
-      userdata->nonblocking_error.is_set = 1;
-    }
-
+    push_userdata_error(userdata, error_data);
   } else {
-    rb_tinytds_raise_error(dbproc, cancel, dberrstr, source, severity, dberr, oserr);
+    rb_tinytds_raise_error(dbproc, error_data);
   }
 
   return return_value;
@@ -128,36 +148,75 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
 int tinytds_msg_handler(DBPROCESS *dbproc, DBINT msgno, int msgstate, int severity, char *msgtext, char *srvname, char *procname, int line) {
   static const char *source = "message";
   GET_CLIENT_USERDATA(dbproc);
-  if (severity > 10) {
-    // See tinytds_err_handler() for info about why we do this
-    if (userdata && userdata->nonblocking) {
-      if (!userdata->nonblocking_error.is_set) {
-        userdata->nonblocking_error.cancel = 1;
-        strcpy(userdata->nonblocking_error.error, msgtext);
-        strcpy(userdata->nonblocking_error.source, source);
-        userdata->nonblocking_error.severity = severity;
-        userdata->nonblocking_error.dberr = msgno;
-        userdata->nonblocking_error.oserr = msgstate;
-        userdata->nonblocking_error.is_set = 1;
-      }
-      if (!dbdead(dbproc) && !userdata->closed) {
-        dbcancel(dbproc);
-        userdata->dbcancel_sent = 1;
-      }
-    } else {
-      rb_tinytds_raise_error(dbproc, 1, msgtext, source, severity, msgno, msgstate);
+
+  int is_message_an_error = severity > 10 ? 1 : 0;
+
+  tinytds_errordata error_data = {
+    .is_message = !is_message_an_error,
+    .cancel = is_message_an_error,
+    .severity = severity,
+    .dberr = msgno,
+    .oserr = msgstate
+  };
+  strncpy(error_data.error, msgtext, ERROR_MSG_SIZE);
+  strncpy(error_data.source, source, ERROR_MSG_SIZE);
+
+  // See tinytds_err_handler() for info about why we do this
+  if (userdata && userdata->nonblocking) {
+    /*
+    In the case of non-blocking command batch execution we can receive multiple messages
+    (including errors). We keep track of those here so they can be processed once the
+    non-blocking call returns.
+    */
+    push_userdata_error(userdata, error_data);
+
+    if (is_message_an_error && !dbdead(dbproc) && !userdata->closed) {
+      dbcancel(dbproc);
+      userdata->dbcancel_sent = 1;
     }
+  } else {
+    rb_tinytds_raise_error(dbproc, error_data);
   }
   return 0;
 }
 
+/*
+Used by dbsetinterrupt -
+This gets called periodically while waiting on a read from the server
+Right now, we only care about cases where a read from the server is
+taking longer than the specified timeout and dbcancel is not working.
+In these cases we decide that we actually want to handle the interrupt
+*/
+static int check_interrupt(void *ptr) {
+  GET_CLIENT_USERDATA((DBPROCESS *)ptr);
+  return userdata->timing_out;
+}
+
+/*
+Used by dbsetinterrupt -
+This gets called if check_interrupt returns TRUE.
+Right now, this is only used in cases where a read from the server is
+taking longer than the specified timeout and dbcancel is not working.
+Return INT_CANCEL to abort the current command batch.
+*/
+static int handle_interrupt(void *ptr) {
+  GET_CLIENT_USERDATA((DBPROCESS *)ptr);
+  if (userdata->timing_out) {
+    return INT_CANCEL;
+  }
+  return INT_CONTINUE;
+}
+
 static void rb_tinytds_client_reset_userdata(tinytds_client_userdata *userdata) {
   userdata->timing_out = 0;
   userdata->dbsql_sent = 0;
   userdata->dbsqlok_sent = 0;
   userdata->dbcancel_sent = 0;
   userdata->nonblocking = 0;
-  userdata->nonblocking_error.is_set = 0;
+  // the following is mainly done for consistency since the values are reset accordingly in nogvl_setup/cleanup.
+  // the nonblocking_errors array does not need to be freed here. That is done as part of nogvl_cleanup.
+  userdata->nonblocking_errors_length = 0;
+  userdata->nonblocking_errors_size = 0;
 }
 
 static void rb_tinytds_client_mark(void *ptr) {
@@ -293,7 +352,7 @@ static VALUE rb_tinytds_identity_sql(VALUE self) {
 
 static VALUE rb_tinytds_connect(VALUE self, VALUE opts) {
   /* Parsing options hash to local vars. */
-  VALUE user, pass, dataserver, database, app, version, ltimeout, timeout, charset, azure;
+  VALUE user, pass, dataserver, database, app, version, ltimeout, timeout, charset, azure, contained, use_utf16;
   GET_CLIENT_WRAPPER(self);
 
   user = rb_hash_aref(opts, sym_username);
@@ -306,6 +365,9 @@ static VALUE rb_tinytds_connect(VALUE self, VALUE opts) {
   timeout = rb_hash_aref(opts, sym_timeout);
   charset = rb_hash_aref(opts, sym_encoding);
   azure = rb_hash_aref(opts, sym_azure);
+  contained = rb_hash_aref(opts, sym_contained);
+  use_utf16 = rb_hash_aref(opts, sym_use_utf16);
+  cwrap->userdata->message_handler = rb_hash_aref(opts, sym_message_handler);
   /* Dealing with options. */
   if (dbinit() == FAIL) {
     rb_raise(cTinyTdsError, "failed dbinit() function");
@@ -324,26 +386,47 @@ static VALUE rb_tinytds_connect(VALUE self, VALUE opts) {
     dbsetlapp(cwrap->login, StringValueCStr(app));
   if (!NIL_P(ltimeout))
     dbsetlogintime(NUM2INT(ltimeout));
-  if (!NIL_P(timeout))
-    dbsettime(NUM2INT(timeout));
   if (!NIL_P(charset))
     DBSETLCHARSET(cwrap->login, StringValueCStr(charset));
-  if (!NIL_P(database) && (azure == Qtrue)) {
-    #ifdef DBSETLDBNAME
-      DBSETLDBNAME(cwrap->login, StringValueCStr(database));
-    #else
-      rb_warn("TinyTds: Azure connections not supported in this version of FreeTDS.\n");
-    #endif
+  if (!NIL_P(database)) {
+    if (azure == Qtrue || contained == Qtrue) {
+      #ifdef DBSETLDBNAME
+        DBSETLDBNAME(cwrap->login, StringValueCStr(database));
+      #else
+        if (azure == Qtrue) {
+          rb_warn("TinyTds: :azure option is not supported in this version of FreeTDS.\n");
+        }
+        if (contained == Qtrue) {
+          rb_warn("TinyTds: :contained option is not supported in this version of FreeTDS.\n");
+        }
+      #endif
+    }
   }
+  #ifdef DBSETUTF16
+    if (use_utf16 == Qtrue)  { DBSETLUTF16(cwrap->login, 1); }
+    if (use_utf16 == Qfalse) { DBSETLUTF16(cwrap->login, 0); }
+  #else
+    if (use_utf16 == Qtrue || use_utf16 == Qfalse) {
+      rb_warning("TinyTds: Please consider upgrading to FreeTDS 0.99 or higher for better unicode support.\n");
+    }
+  #endif
+
   cwrap->client = dbopen(cwrap->login, StringValueCStr(dataserver));
   if (cwrap->client) {
-    VALUE transposed_encoding;
+    VALUE transposed_encoding, timeout_string;
 
     cwrap->closed = 0;
     cwrap->charset = charset;
     if (!NIL_P(version))
       dbsetversion(NUM2INT(version));
+    if (!NIL_P(timeout)) {
+      timeout_string = rb_sprintf("%"PRIsVALUE"", timeout);
+      if (dbsetopt(cwrap->client, DBSETTIME, StringValueCStr(timeout_string), 0) == FAIL) {
+        dbsettime(NUM2INT(timeout));
+      }
+    }
     dbsetuserdata(cwrap->client, (BYTE*)cwrap->userdata);
+    dbsetinterrupt(cwrap->client, check_interrupt, handle_interrupt);
     cwrap->userdata->closed = 0;
     if (!NIL_P(database) && (azure != Qtrue)) {
       dbuse(cwrap->client, StringValueCStr(database));
@@ -391,6 +474,9 @@ void init_tinytds_client() {
   sym_timeout = ID2SYM(rb_intern("timeout"));
   sym_encoding = ID2SYM(rb_intern("encoding"));
   sym_azure = ID2SYM(rb_intern("azure"));
+  sym_contained = ID2SYM(rb_intern("contained"));
+  sym_use_utf16 = ID2SYM(rb_intern("use_utf16"));
+  sym_message_handler = ID2SYM(rb_intern("message_handler"));
   /* Intern TinyTds::Error Accessors */
   intern_source_eql = rb_intern("source=");
   intern_severity_eql = rb_intern("severity=");
@@ -402,6 +488,7 @@ void init_tinytds_client() {
   intern_transpose_iconv_encoding = rb_intern("transpose_iconv_encoding");
   intern_local_offset = rb_intern("local_offset");
   intern_gsub = rb_intern("gsub");
+  intern_call = rb_intern("call");
   /* Escape Regexp Global */
   opt_escape_regex = rb_funcall(rb_cRegexp, intern_new, 1, rb_str_new2("\\\'"));
   opt_escape_dblquote = rb_str_new2("''");

data/ext/tiny_tds/client.h

@@ -4,11 +4,14 @@
 
 void init_tinytds_client();
 
+#define ERROR_MSG_SIZE 1024
+#define ERRORS_STACK_INIT_SIZE 2
+
 typedef struct {
-  short int is_set;
+  int is_message;
   int cancel;
-  char error[1024];
-  char source[1024];
+  char error[ERROR_MSG_SIZE];
+  char source[ERROR_MSG_SIZE];
   int severity;
   int dberr;
   int oserr;
@@ -22,7 +25,10 @@ typedef struct {
   RETCODE dbsqlok_retcode;
   short int dbcancel_sent;
   short int nonblocking;
-  tinytds_errordata nonblocking_error;
+  short int nonblocking_errors_length;
+  short int nonblocking_errors_size;
+  tinytds_errordata *nonblocking_errors;
+  VALUE message_handler;
 } tinytds_client_userdata;
 
 typedef struct {
@@ -36,7 +42,7 @@ typedef struct {
   rb_encoding *encoding;
 } tinytds_client_wrapper;
 
-VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, int cancel, const char *error, const char *source, int severity, int dberr, int oserr);
+VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, tinytds_errordata error);
 
 // Lib Macros