tiny_tds 3.2.1 → 3.3.0

data/ext/tiny_tds/client.c

@@ -8,12 +8,54 @@ static ID intern_source_eql, intern_severity_eql, intern_db_error_number_eql, in
 static ID intern_new, intern_dup, intern_transpose_iconv_encoding, intern_local_offset, intern_gsub, intern_call;
 VALUE opt_escape_regex, opt_escape_dblquote;
 
+static void rb_tinytds_client_mark(void *ptr)
+{
+  tinytds_client_wrapper *cwrap = (tinytds_client_wrapper *)ptr;
+
+  if (cwrap) {
+    rb_gc_mark(cwrap->charset);
+  }
+}
+
+static void rb_tinytds_client_free(void *ptr)
+{
+  tinytds_client_wrapper *cwrap = (tinytds_client_wrapper *)ptr;
+
+  if (cwrap->login) {
+    dbloginfree(cwrap->login);
+  }
+
+  if (cwrap->client && !cwrap->closed) {
+    dbclose(cwrap->client);
+    cwrap->client = NULL;
+    cwrap->closed = 1;
+    cwrap->userdata->closed = 1;
+  }
+
+  xfree(cwrap->userdata);
+  xfree(ptr);
+}
+
+static size_t tinytds_client_wrapper_size(const void* data)
+{
+  return sizeof(tinytds_client_wrapper);
+}
+
+static const rb_data_type_t tinytds_client_wrapper_type = {
+  .wrap_struct_name = "tinytds_client_wrapper",
+  .function = {
+    .dmark = rb_tinytds_client_mark,
+    .dfree = rb_tinytds_client_free,
+    .dsize = tinytds_client_wrapper_size,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
 
 // Lib Macros
 
 #define GET_CLIENT_WRAPPER(self) \
   tinytds_client_wrapper *cwrap; \
-  Data_Get_Struct(self, tinytds_client_wrapper, cwrap)
+  TypedData_Get_Struct(self, tinytds_client_wrapper, &tinytds_client_wrapper_type, cwrap)
 
 #define REQUIRE_OPEN_CLIENT(cwrap) \
   if (cwrap->closed || cwrap->userdata->closed) { \
@@ -24,26 +66,36 @@ VALUE opt_escape_regex, opt_escape_dblquote;
 
 // Lib Backend (Helpers)
 
-VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, tinytds_errordata error) {
+VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, tinytds_errordata error)
+{
   VALUE e;
   GET_CLIENT_USERDATA(dbproc);
+
   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.error);
   rb_funcall(e, intern_source_eql, 1, rb_str_new2(error.source));
-  if (error.severity)
+
+  if (error.severity) {
     rb_funcall(e, intern_severity_eql, 1, INT2FIX(error.severity));
-  if (error.dberr)
+  }
+
+  if (error.dberr) {
     rb_funcall(e, intern_db_error_number_eql, 1, INT2FIX(error.dberr));
-  if (error.oserr)
+  }
+
+  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);
     }
@@ -57,7 +109,8 @@ VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, tinytds_errordata error) {
 
 
 // Lib Backend (Memory Management & Handlers)
-static void push_userdata_error(tinytds_client_userdata *userdata, tinytds_errordata error) {
+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;
@@ -68,7 +121,8 @@ static void push_userdata_error(tinytds_client_userdata *userdata, tinytds_error
   userdata->nonblocking_errors_length++;
 }
 
-int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, char *dberrstr, char *oserrstr) {
+int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, char *dberrstr, char *oserrstr)
+{
   static const char *source = "error";
   /* Everything should cancel by default */
   int return_value = INT_CANCEL;
@@ -91,6 +145,7 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
       return return_value;
 
     case SYBETIME:
+
       /*
       SYBETIME is the only error that can send INT_TIMEOUT or INT_CONTINUE,
       but we don't ever want to automatically retry. Instead have the app
@@ -99,19 +154,23 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
       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;
 
     case SYBEWRIT:
+
       /* Write errors may happen after we abort a statement */
       if (userdata && (userdata->dbsqlok_sent || userdata->dbcancel_sent)) {
         return return_value;
       }
+
       cancel = 1;
       break;
   }
@@ -137,6 +196,7 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
       dbcancel(dbproc);
       userdata->dbcancel_sent = 1;
     }
+
     push_userdata_error(userdata, error_data);
   } else {
     rb_tinytds_raise_error(dbproc, error_data);
@@ -145,7 +205,8 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
   return return_value;
 }
 
-int tinytds_msg_handler(DBPROCESS *dbproc, DBINT msgno, int msgstate, int severity, char *msgtext, char *srvname, char *procname, int line) {
+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);
 
@@ -177,6 +238,7 @@ int tinytds_msg_handler(DBPROCESS *dbproc, DBINT msgno, int msgstate, int severi
   } else {
     rb_tinytds_raise_error(dbproc, error_data);
   }
+
   return 0;
 }
 
@@ -187,7 +249,8 @@ 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) {
+static int check_interrupt(void *ptr)
+{
   GET_CLIENT_USERDATA((DBPROCESS *)ptr);
   return userdata->timing_out;
 }
@@ -199,15 +262,19 @@ 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) {
+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) {
+static void rb_tinytds_client_reset_userdata(tinytds_client_userdata *userdata)
+{
   userdata->timing_out = 0;
   userdata->dbsql_sent = 0;
   userdata->dbsqlok_sent = 0;
@@ -219,31 +286,11 @@ static void rb_tinytds_client_reset_userdata(tinytds_client_userdata *userdata)
   userdata->nonblocking_errors_size = 0;
 }
 
-static void rb_tinytds_client_mark(void *ptr) {
-  tinytds_client_wrapper *cwrap = (tinytds_client_wrapper *)ptr;
-  if (cwrap) {
-    rb_gc_mark(cwrap->charset);
-  }
-}
-
-static void rb_tinytds_client_free(void *ptr) {
-  tinytds_client_wrapper *cwrap = (tinytds_client_wrapper *)ptr;
-  if (cwrap->login)
-    dbloginfree(cwrap->login);
-  if (cwrap->client && !cwrap->closed) {
-    dbclose(cwrap->client);
-    cwrap->client = NULL;
-    cwrap->closed = 1;
-    cwrap->userdata->closed = 1;
-  }
-  xfree(cwrap->userdata);
-  xfree(ptr);
-}
-
-static VALUE allocate(VALUE klass) {
+static VALUE allocate(VALUE klass)
+{
   VALUE obj;
   tinytds_client_wrapper *cwrap;
-  obj = Data_Make_Struct(klass, tinytds_client_wrapper, rb_tinytds_client_mark, rb_tinytds_client_free, cwrap);
+  obj = TypedData_Make_Struct(klass, tinytds_client_wrapper, &tinytds_client_wrapper_type, cwrap);
   cwrap->closed = 1;
   cwrap->charset = Qnil;
   cwrap->userdata = malloc(sizeof(tinytds_client_userdata));
@@ -255,52 +302,63 @@ static VALUE allocate(VALUE klass) {
 
 // TinyTds::Client (public)
 
-static VALUE rb_tinytds_tds_version(VALUE self) {
+static VALUE rb_tinytds_tds_version(VALUE self)
+{
   GET_CLIENT_WRAPPER(self);
   return INT2FIX(dbtds(cwrap->client));
 }
 
-static VALUE rb_tinytds_close(VALUE self) {
+static VALUE rb_tinytds_close(VALUE self)
+{
   GET_CLIENT_WRAPPER(self);
+
   if (cwrap->client && !cwrap->closed) {
     dbclose(cwrap->client);
     cwrap->client = NULL;
     cwrap->closed = 1;
     cwrap->userdata->closed = 1;
   }
+
   return Qtrue;
 }
 
-static VALUE rb_tinytds_dead(VALUE self) {
+static VALUE rb_tinytds_dead(VALUE self)
+{
   GET_CLIENT_WRAPPER(self);
   return dbdead(cwrap->client) ? Qtrue : Qfalse;
 }
 
-static VALUE rb_tinytds_closed(VALUE self) {
+static VALUE rb_tinytds_closed(VALUE self)
+{
   GET_CLIENT_WRAPPER(self);
   return (cwrap->closed || cwrap->userdata->closed) ? Qtrue : Qfalse;
 }
 
-static VALUE rb_tinytds_canceled(VALUE self) {
+static VALUE rb_tinytds_canceled(VALUE self)
+{
   GET_CLIENT_WRAPPER(self);
   return cwrap->userdata->dbcancel_sent ? Qtrue : Qfalse;
 }
 
-static VALUE rb_tinytds_sqlsent(VALUE self) {
+static VALUE rb_tinytds_sqlsent(VALUE self)
+{
   GET_CLIENT_WRAPPER(self);
   return cwrap->userdata->dbsql_sent ? Qtrue : Qfalse;
 }
 
-static VALUE rb_tinytds_execute(VALUE self, VALUE sql) {
+static VALUE rb_tinytds_execute(VALUE self, VALUE sql)
+{
   VALUE result;
 
   GET_CLIENT_WRAPPER(self);
   rb_tinytds_client_reset_userdata(cwrap->userdata);
   REQUIRE_OPEN_CLIENT(cwrap);
   dbcmd(cwrap->client, StringValueCStr(sql));
+
   if (dbsqlsend(cwrap->client) == FAIL) {
     rb_raise(cTinyTdsError, "failed dbsqlsend() function");
   }
+
   cwrap->userdata->dbsql_sent = 1;
   result = rb_tinytds_new_result_obj(cwrap);
   rb_iv_set(result, "@query_options", rb_funcall(rb_iv_get(self, "@query_options"), intern_dup, 0));
@@ -312,17 +370,20 @@ static VALUE rb_tinytds_execute(VALUE self, VALUE sql) {
   }
 }
 
-static VALUE rb_tinytds_charset(VALUE self) {
+static VALUE rb_tinytds_charset(VALUE self)
+{
   GET_CLIENT_WRAPPER(self);
   return cwrap->charset;
 }
 
-static VALUE rb_tinytds_encoding(VALUE self) {
+static VALUE rb_tinytds_encoding(VALUE self)
+{
   GET_CLIENT_WRAPPER(self);
   return rb_enc_from_encoding(cwrap->encoding);
 }
 
-static VALUE rb_tinytds_escape(VALUE self, VALUE string) {
+static VALUE rb_tinytds_escape(VALUE self, VALUE string)
+{
   VALUE new_string;
   GET_CLIENT_WRAPPER(self);
 
@@ -333,8 +394,10 @@ static VALUE rb_tinytds_escape(VALUE self, VALUE string) {
 }
 
 /* Duplicated in result.c */
-static VALUE rb_tinytds_return_code(VALUE self) {
+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 {
@@ -342,7 +405,8 @@ static VALUE rb_tinytds_return_code(VALUE self) {
   }
 }
 
-static VALUE rb_tinytds_identity_sql(VALUE self) {
+static VALUE rb_tinytds_identity_sql(VALUE self)
+{
   GET_CLIENT_WRAPPER(self);
   return rb_str_new2(cwrap->identity_insert_sql);
 }
@@ -351,7 +415,8 @@ static VALUE rb_tinytds_identity_sql(VALUE self) {
 
 // TinyTds::Client (protected)
 
-static VALUE rb_tinytds_connect(VALUE self, VALUE opts) {
+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, contained, use_utf16;
   GET_CLIENT_WRAPPER(self);
@@ -369,44 +434,69 @@ static VALUE rb_tinytds_connect(VALUE self, VALUE opts) {
   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");
     return self;
   }
+
   dberrhandle(tinytds_err_handler);
   dbmsghandle(tinytds_msg_handler);
   cwrap->login = dblogin();
-  if (!NIL_P(version))
+
+  if (!NIL_P(version)) {
     dbsetlversion(cwrap->login, NUM2INT(version));
-  if (!NIL_P(user))
+  }
+
+  if (!NIL_P(user)) {
     dbsetluser(cwrap->login, StringValueCStr(user));
-  if (!NIL_P(pass))
+  }
+
+  if (!NIL_P(pass)) {
     dbsetlpwd(cwrap->login, StringValueCStr(pass));
-  if (!NIL_P(app))
+  }
+
+  if (!NIL_P(app)) {
     dbsetlapp(cwrap->login, StringValueCStr(app));
-  if (!NIL_P(ltimeout))
+  }
+
+  if (!NIL_P(ltimeout)) {
     dbsetlogintime(NUM2INT(ltimeout));
-  if (!NIL_P(charset))
+  }
+
+  if (!NIL_P(charset)) {
     DBSETLCHARSET(cwrap->login, StringValueCStr(charset));
+  }
+
   if (!NIL_P(database)) {
     if (azure == Qtrue || contained == Qtrue) {
       #ifdef DBSETLDBNAME
-        DBSETLDBNAME(cwrap->login, StringValueCStr(database));
+      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");
-        }
+
+      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
     }
   }
-  if (use_utf16 == Qtrue)  { DBSETLUTF16(cwrap->login, 1); }
-  if (use_utf16 == Qfalse) { DBSETLUTF16(cwrap->login, 0); }
+
+  if (use_utf16 == Qtrue)  {
+    DBSETLUTF16(cwrap->login, 1);
+  }
+
+  if (use_utf16 == Qfalse) {
+    DBSETLUTF16(cwrap->login, 0);
+  }
 
   cwrap->client = dbopen(cwrap->login, StringValueCStr(dataserver));
+
   if (cwrap->client) {
     if (dbtds(cwrap->client) < 11) {
       rb_raise(cTinyTdsError, "connecting with a TDS version older than 7.3!");
@@ -416,31 +506,40 @@ static VALUE rb_tinytds_connect(VALUE self, VALUE opts) {
 
     cwrap->closed = 0;
     cwrap->charset = charset;
-    if (!NIL_P(version))
+
+    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));
     }
+
     transposed_encoding = rb_funcall(cTinyTdsClient, intern_transpose_iconv_encoding, 1, charset);
     cwrap->encoding = rb_enc_find(StringValueCStr(transposed_encoding));
     cwrap->identity_insert_sql = "SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident";
   }
+
   return self;
 }
 
 
 // Lib Init
 
-void init_tinytds_client() {
+void init_tinytds_client()
+{
   cTinyTdsClient = rb_define_class_under(mTinyTds, "Client", rb_cObject);
   rb_define_alloc_func(cTinyTdsClient, allocate);
   /* Define TinyTds::Client Public Methods */

data/ext/tiny_tds/extconsts.rb

@@ -1,8 +1,8 @@
 ICONV_VERSION = ENV["TINYTDS_ICONV_VERSION"] || "1.18"
 ICONV_SOURCE_URI = "http://ftp.gnu.org/pub/gnu/libiconv/libiconv-#{ICONV_VERSION}.tar.gz"
 
-OPENSSL_VERSION = ENV["TINYTDS_OPENSSL_VERSION"] || "3.4.1"
+OPENSSL_VERSION = ENV["TINYTDS_OPENSSL_VERSION"] || "3.5.2"
 OPENSSL_SOURCE_URI = "https://www.openssl.org/source/openssl-#{OPENSSL_VERSION}.tar.gz"
 
-FREETDS_VERSION = ENV["TINYTDS_FREETDS_VERSION"] || "1.4.26"
+FREETDS_VERSION = ENV["TINYTDS_FREETDS_VERSION"] || "1.5.4"
 FREETDS_SOURCE_URI = "http://www.freetds.org/files/stable/freetds-#{FREETDS_VERSION}.tar.bz2"