tiny_tds 0.3.2 → 0.4.0

data/CHANGELOG

@@ -1,4 +1,19 @@
 
+* 0.4.0 *
+
+* Allow SYBEICONVI errors to pass thru so that bad data is converted to ? marks.
+
+* Build native deps using MiniPortile [Luis Lavena]
+
+* Allow Result#fields to be called before iterating over the results.
+
+* Two new client helper methods, #sqlsent? and #canceled?. Possible to use these to determine current 
+  state of the client and the need to use Result#cancel to stop processing active results. It is also 
+  safe to call Result#cancel over and over again.
+
+* Look for the syb headers only.
+
+
 * 0.3.2 *
 
 * Small changes while testing JRuby. Using options hash for connect vs many args.
@@ -25,7 +40,8 @@
 
 * 0.2.2 *
 
-* Fixed failing test in Ruby 1.8.6. DateTime doesn't support fractional seconds greater than 59. See: http://redmine.ruby-lang.org/issues/show/1490 [Erik Bryn]
+* Fixed failing test in Ruby 1.8.6. DateTime doesn't support fractional seconds greater than 59. 
+  See: http://redmine.ruby-lang.org/issues/show/1490 [Erik Bryn]
 
 
 * 0.2.1 *

data/README.rdoc

@@ -1,9 +1,9 @@
 
-= TinyTds - A modern, simple and fast FreeTDS library for Ruby using DB-Library.
+= TinyTDS - A modern, simple and fast FreeTDS library for Ruby using DB-Library.
 
-The TinyTds gem is meant to serve the extremely common use-case of connecting, querying and iterating over results to Microsoft SQL Server databases from ruby. Even though it uses FreeTDS's DB-Library, it is NOT meant to serve as direct 1:1 mapping of that complex C API.
+The TinyTDS gem is meant to serve the extremely common use-case of connecting, querying and iterating over results to Microsoft SQL Server databases from ruby. Even though it uses FreeTDS's DB-Library, it is NOT meant to serve as direct 1:1 mapping of that complex C API.
 
-The benefits are speed, automatic casting to ruby primitives, and proper encoding support. It converts all SQL Server datatypes to native ruby objects supporting :utc or :local time zones for time-like types. To date it is the only ruby client library that allows client encoding options, defaulting to UTF-8, while connecting to SQL Server. It also  properly encodes all string and binary data. The motivation for TinyTds is to become the de-facto low level connection mode for the SQL Server adapter for ActiveRecord. For further details see the special thanks section at the bottom
+The benefits are speed, automatic casting to ruby primitives, and proper encoding support. It converts all SQL Server datatypes to native ruby objects supporting :utc or :local time zones for time-like types. To date it is the only ruby client library that allows client encoding options, defaulting to UTF-8, while connecting to SQL Server. It also  properly encodes all string and binary data. The motivation for TinyTDS is to become the de-facto low level connection mode for the SQL Server adapter for ActiveRecord. For further details see the special thanks section at the bottom
 
 The API is simple and consists of these classes:
 
@@ -12,10 +12,15 @@ The API is simple and consists of these classes:
 * TinyTds::Error - A wrapper for all exceptions.
 
 
+== New & Noteworthy
+
+* Works with FreeTDS 0.83.dev
+* Tested on Windows using MiniPortile & RailsInstaller.
+
 
 == Install
 
-Installing with rubygems should just work. TinyTds is tested on ruby version 1.8.6, 1.8.7, 1.9.1, 1.9.2 as well as REE & JRuby.
+Installing with rubygems should just work. TinyTDS is tested on ruby version 1.8.6, 1.8.7, 1.9.1, 1.9.2 as well as REE & JRuby.
 
     $ gem install tiny_tds
 
@@ -25,7 +30,7 @@ Although we search for FreeTDS's libraries and headers, you may have to specify
 
 == FreeTDS Compatibility
 
-TinyTds is developed primarily for FreeTDS 0.82 and tested with SQL Server 2000, 2005, and 2008 using TDS Version 8.0. We utilize FreeTDS's db-lib client library. We compile against sybdb.h and define MSDBLIB which means that our client enables Microsoft behavior in the db-lib API where it diverges from Sybase's. You do NOT need to compile FreeTDS with the "--enable-msdblib" option for our client to work properly. However, please make sure to compile FreeTDS with libiconv support for encodings to work at their best. Run "tsql -C" in your console and check for "iconv library: yes".
+TinyTDS is developed for FreeTDS 0.82 & 0.83.dev. It is tested with SQL Server 2000, 2005, and 2008 using TDS Version 8.0. We utilize FreeTDS's db-lib client library. We compile against sybdb.h and define MSDBLIB which means that our client enables Microsoft behavior in the db-lib API where it diverges from Sybase's. You do NOT need to compile FreeTDS with the "--enable-msdblib" option for our client to work properly. However, please make sure to compile FreeTDS with libiconv support for encodings to work at their best. Run "tsql -C" in your console and check for "iconv library: yes".
 
 
 
@@ -88,9 +93,18 @@ Calling #each on the result will lazily load each row from the database.
     # Here's an leemer: http://is.gd/g61xo
   end
 
-Once a result returns its rows, you can access the fields. Returns nil if the data has not yet been loaded or there are no rows returned.
+A result object has a #fields accessor. It can be called before the result rows are iterated over. Even if no rows are returned, #fields will still return the column names you expected. Any SQL that does not return columned data will always return an empty array for #fields. It is important to remember that if you access the #fields before iterating over the results, the columns will always follow the default query option's :symbolize_keys setting at the client's level and will ignore the query options passed to each.
 
-  result.fields # => [ ... ]
+  result = client.execute("USE [tinytds_test]")
+  result.fields # => []
+  result.do
+  
+  result = client.execute("SELECT [id] FROM [datatypes]")
+  result.fields # => ["id"]
+  result.cancel
+  result = client.execute("SELECT [id] FROM [datatypes]")
+  result.each(:symbolize_keys => true)
+  result.fields # => [:id]
 
 You can cancel a result object's data from being loading by the server.
 
@@ -136,6 +150,29 @@ The result object can handle multiple result sets form batched SQL or stored pro
     # 2nd: [{"bigint"=>-9223372036854775807}, {"bigint"=>9223372036854775806}]
   end
 
+Use the #sqlsent? and #canceled? query methods on the client to determine if an active SQL batch still needs to be processed and or if data results were canceled from the last result object. These values reset to true and false respectively for the client at the start of each #execute and new result object. Or if all rows are processed normally, #sqlsent? will return false. To demonstrate, lets assume we have 100 rows in the result object.
+  
+  client.sqlsent?   # = false
+  client.canceled?  # = false
+  
+  result = client.execute("SELECT * FROM [super_big_table]")
+  
+  client.sqlsent?   # = true
+  client.canceled?  # = false
+  
+  result.each do |row|
+    # Assume we break after 20 rows with 80 still pending.
+    break if row["id"] > 20
+  end
+  
+  client.sqlsent?   # = true
+  client.canceled?  # = false
+  
+  result.cancel
+  
+  client.sqlsent?   # = false
+  client.canceled?  # = true
+
 It is possible to get the return code after executing a stored procedure from either the result or client object.
 
   client.return_code  # => nil
@@ -170,15 +207,14 @@ Besides the standard query options, the result object can take one additional op
 
 == Row Caching
 
-By default row caching is turned on because the SQL Server adapter for ActiveRecord would not work without it. I hope to find some time to create some performance patches for ActiveRecord that would allow it to take advantages of lazily created yielded rows from result objects. Currently only TinyTds and the Mysql2 gem allow such a performance gain.
+By default row caching is turned on because the SQL Server adapter for ActiveRecord would not work without it. I hope to find some time to create some performance patches for ActiveRecord that would allow it to take advantages of lazily created yielded rows from result objects. Currently only TinyTDS and the Mysql2 gem allow such a performance gain.
 
 
 
-== Using TinyTds With Rails & The ActiveRecord SQL Server adapter.
+== Using TinyTDS With Rails & The ActiveRecord SQL Server adapter.
 
-As of version 2.3.11 & 3.0.3 of the adapter, you can specify a :dblib mode in database.yml and use TinyTds as the low level connection mode. Make sure to add a :dataserver option to that matches the name in your freetds.conf file. The SQL Server adapter can be found using the link below. Also included is a direct link to the wiki article covering common questions when using TinyTds as the low level connection mode for the adapter.
+As of version 2.3.11 & 3.0.3 of the adapter, you can specify a :dblib mode in database.yml and use TinyTDS as the low level connection mode. Make sure to add a :dataserver option to that matches the name in your freetds.conf file. The SQL Server adapter can be found using the link below. Also included is a direct link to the wiki article covering common questions when using TinyTDS as the low level connection mode for the adapter.
 
-http://github.com/rails-sqlserver/activerecord-sqlserver-adapter
 http://github.com/rails-sqlserver/activerecord-sqlserver-adapter/wiki/Using-TinyTds
 
 
@@ -187,7 +223,9 @@ http://github.com/rails-sqlserver/activerecord-sqlserver-adapter/wiki/Using-Tiny
 
 We use bundler for development. Simply run "bundle install" then "rake" to build the gem and run the unit tests. The tests assume you have created a database named "tinytds_test" accessible by a database owner named "tinytds". Before running the test rake task, you may need to define a pair of environment variables that help the client connect to your specific FreeTDS database server name and which schema (2000, 2005 or 2008) to use. For example:
 
-  $ env TINYTDS_UNIT_DATASERVER=mydbserver TINYTDS_SCHEMA=sqlserver_2008 rake
+  $ rake TINYTDS_UNIT_DATASERVER=mydbserver TINYTDS_SCHEMA=sqlserver_2008
+
+If you are compiling locally using MiniPortile (the default dev setup) and you do not have a user based freetds.conf file with your dataservers, you may have to configure the locally compiled freetds.conf file. You can find it at the ports/<platform>/freetds/<version>/etc/freetds.conf path locally to your repo. In this situation you may have to set the FREETDS environment variable too this full path.
 
 For help and support.
 
@@ -198,8 +236,6 @@ For help and support.
 
 Current to do list.
 
-* Test 0.83 development of FreeTDS.
-* Find someone brave enough to compile/test for Windows.
 * Install an interrupt handler.
 * Allow #escape to accept all ruby primitives.
 * Get bug reports!

data/ext/tiny_tds/client.c

@@ -1,6 +1,5 @@
 
 #include <tiny_tds_ext.h>
-#include <client.h>
 #include <errno.h>
 
 VALUE cTinyTdsClient;
@@ -10,15 +9,13 @@ 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;
 VALUE opt_escape_regex, opt_escape_dblquote;
 
+
 // Lib Macros
 
 #define GET_CLIENT_WRAPPER(self) \
   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 || cwrap->userdata->closed) { \
     rb_raise(cTinyTdsError, "closed connection"); \
@@ -59,6 +56,8 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
  switch(dberr) {
    case SYBESMSG:
      return return_value;
+   case SYBEICONVI:
+     return INT_CANCEL;
    case SYBEFCON:
    case SYBESOCK:
    case SYBECONN:
@@ -96,6 +95,7 @@ int tinytds_msg_handler(DBPROCESS *dbproc, DBINT msgno, int msgstate, int severi
 
 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;
 }
@@ -155,6 +155,16 @@ static VALUE rb_tinytds_closed(VALUE self) {
   return (cwrap->closed || cwrap->userdata->closed) ? Qtrue : Qfalse;
 }
 
+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) {
+  GET_CLIENT_WRAPPER(self);
+  return cwrap->userdata->dbsql_sent ? Qtrue : Qfalse;
+}
+
 static VALUE rb_tinytds_execute(VALUE self, VALUE sql) {
   GET_CLIENT_WRAPPER(self);
   rb_tinytds_client_reset_userdata(cwrap->userdata);
@@ -164,6 +174,7 @@ static VALUE rb_tinytds_execute(VALUE self, VALUE sql) {
     rb_warn("TinyTds: dbsqlsend() returned FAIL.\n");
     return Qfalse;
   }
+  cwrap->userdata->dbsql_sent = 1;
   VALUE result = rb_tinytds_new_result_obj(cwrap->client);
   rb_iv_set(result, "@query_options", rb_funcall(rb_iv_get(self, "@query_options"), intern_dup, 0));
   GET_RESULT_WRAPPER(result);
@@ -250,7 +261,7 @@ static VALUE rb_tinytds_connect(VALUE self, VALUE opts) {
   if (cwrap->client) {
     cwrap->closed = 0;
     cwrap->charset = charset;
-    dbsetuserdata(cwrap->client, cwrap->userdata);
+    dbsetuserdata(cwrap->client, (BYTE*)cwrap->userdata);
     cwrap->userdata->closed = 0;
     if (!NIL_P(database))
       dbuse(cwrap->client, StringValuePtr(database));
@@ -272,6 +283,8 @@ void init_tinytds_client() {
   rb_define_method(cTinyTdsClient, "tds_version", rb_tinytds_tds_version, 0);
   rb_define_method(cTinyTdsClient, "close", rb_tinytds_close, 0);
   rb_define_method(cTinyTdsClient, "closed?", rb_tinytds_closed, 0);
+  rb_define_method(cTinyTdsClient, "canceled?", rb_tinytds_canceled, 0);
+  rb_define_method(cTinyTdsClient, "sqlsent?", rb_tinytds_sqlsent, 0);
   rb_define_method(cTinyTdsClient, "execute", rb_tinytds_execute, 1);
   rb_define_method(cTinyTdsClient, "charset", rb_tinytds_charset, 0);
   rb_define_method(cTinyTdsClient, "encoding", rb_tinytds_encoding, 0);

data/ext/tiny_tds/client.h

@@ -7,7 +7,9 @@ void init_tinytds_client();
 typedef struct {
   short int closed;
   short int timing_out;
+  short int dbsql_sent;
   short int dbsqlok_sent;
+  RETCODE dbsqlok_retcode;
   short int dbcancel_sent;
 } tinytds_client_userdata;
 
@@ -24,4 +26,10 @@ typedef struct {
 } tinytds_client_wrapper;
 
 
+// Lib Macros
+
+#define GET_CLIENT_USERDATA(dbproc) \
+  tinytds_client_userdata *userdata = (tinytds_client_userdata *)dbgetuserdata(dbproc);
+
+
 #endif

data/ext/tiny_tds/extconf.rb

@@ -1,13 +1,16 @@
 require 'mkmf'
 
-FREETDS_LIBRARIES = ['sybdb']
-FREETDS_HEADERS = ['sqlfront.h', 'sybdb.h', 'syberror.h']
+FREETDS_LIBRARIES = ['iconv','sybdb']
+FREETDS_HEADERS = ['sybfront.h', 'sybdb.h']
 
+dir_config('iconv')
 dir_config('freetds')
 
 def root_paths
   eop_regexp = /#{File::SEPARATOR}bin$/
-  paths = ENV['PATH'].split(File::PATH_SEPARATOR)
+  paths = ENV['PATH']
+  paths = paths.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
+  paths = paths.split(File::PATH_SEPARATOR)
   bin_paths = paths.select{ |p| p =~ eop_regexp }
   bin_paths.map{ |p| p.sub(eop_regexp,'') }.compact.reject{ |p| p.empty? }.uniq
 end
@@ -24,7 +27,7 @@ def find_freetds_libraries_path
       if File.directory?(dir)
         puts "#{message} yes"
         if with_ldflags("#{$LDFLAGS} -L#{dir}".strip) { have_freetds_libraries?(*FREETDS_LIBRARIES) }
-          $LDFLAGS += "#{$LDFLAGS} -L#{dir}".strip
+          $LDFLAGS = "-L#{dir} #{$LDFLAGS}".strip
           true
         else
           false
@@ -49,7 +52,7 @@ def find_freetds_include_path
       if File.directory?(dir)
         puts "#{message} yes"
         if with_cppflags("#{$CPPFLAGS} -I#{dir}".strip) { have_freetds_headers?(*FREETDS_HEADERS) }
-          $CPPFLAGS += "#{$CPPFLAGS} -I#{dir}".strip
+          $CPPFLAGS = "-I#{dir} #{$CPPFLAGS}".strip
           true
         else
           false
@@ -63,8 +66,7 @@ def find_freetds_include_path
 end
 
 def have_freetds?
-  (have_freetds_libraries?(*FREETDS_LIBRARIES) || find_freetds_libraries_path) && 
-  (have_freetds_headers?(*FREETDS_HEADERS) || find_freetds_include_path)
+  find_freetds_libraries_path && find_freetds_include_path
 end
 
 unless have_freetds?

data/ext/tiny_tds/result.c

@@ -10,6 +10,9 @@ static ID intern_new, intern_utc, intern_local, intern_localtime, intern_merge,
           intern_civil, intern_new_offset, intern_plus, intern_divide, intern_Rational;
 static ID sym_symbolize_keys, sym_as, sym_array, sym_cache_rows, sym_first, sym_timezone, sym_local, sym_utc;
 
+
+// Lib Macros
+
 #ifdef HAVE_RUBY_ENCODING_H
   rb_encoding *binaryEncoding;
   #define ENCODED_STR_NEW(_data, _len) ({ \
@@ -37,7 +40,9 @@ static void rb_tinytds_result_mark(void *ptr) {
   if (rwrap) {
     rb_gc_mark(rwrap->local_offset);
     rb_gc_mark(rwrap->fields);
+    rb_gc_mark(rwrap->fields_processed);
     rb_gc_mark(rwrap->results);
+    rb_gc_mark(rwrap->dbresults_retcodes);
   }
 }
 
@@ -52,8 +57,10 @@ VALUE rb_tinytds_new_result_obj(DBPROCESS *c) {
   obj = Data_Make_Struct(cTinyTdsResult, tinytds_result_wrapper, rb_tinytds_result_mark, rb_tinytds_result_free, rwrap);
   rwrap->client = c;
   rwrap->local_offset = Qnil;
-  rwrap->fields = Qnil;
+  rwrap->fields = rb_ary_new();
+  rwrap->fields_processed = rb_ary_new();
   rwrap->results = Qnil;
+  rwrap->dbresults_retcodes = rb_ary_new();
   rwrap->number_of_results = 0;
   rwrap->number_of_fields = 0;
   rwrap->number_of_rows = 0;
@@ -64,6 +71,38 @@ VALUE rb_tinytds_new_result_obj(DBPROCESS *c) {
 
 // Lib Backend (Helpers)
 
+static RETCODE rb_tinytds_result_dbresults_retcode(VALUE self) {
+  GET_RESULT_WRAPPER(self);
+  VALUE ruby_rc;
+  RETCODE db_rc;
+  ruby_rc = rb_ary_entry(rwrap->dbresults_retcodes, rwrap->number_of_results);
+  if (NIL_P(ruby_rc)) {
+    db_rc = dbresults(rwrap->client);
+    ruby_rc = INT2FIX(db_rc);
+    rb_ary_store(rwrap->dbresults_retcodes, rwrap->number_of_results, ruby_rc);
+  } else {
+    db_rc = FIX2INT(ruby_rc);
+  }
+  return db_rc;
+}
+
+static RETCODE rb_tinytds_result_ok_helper(DBPROCESS *client) {
+  GET_CLIENT_USERDATA(client);
+  if (userdata->dbsqlok_sent == 0) {
+    userdata->dbsqlok_retcode = dbsqlok(client);
+    userdata->dbsqlok_sent = 1;
+  }
+  return userdata->dbsqlok_retcode;
+}
+
+static void rb_tinytds_result_cancel_helper(DBPROCESS *client) {
+  GET_CLIENT_USERDATA(client);
+  rb_tinytds_result_ok_helper(client);
+  dbcancel(client);
+  userdata->dbcancel_sent = 1;
+  userdata->dbsql_sent = 0;
+}
+
 static VALUE rb_tinytds_result_fetch_row(VALUE self, ID timezone, int symbolize_keys, int as_array) {
   /* Wrapper And Local Vars */
   GET_RESULT_WRAPPER(self);
@@ -152,13 +191,13 @@ static VALUE rb_tinytds_result_fetch_row(VALUE self, ID timezone, int symbolize_
         case SYBDATETIME: {
           DBDATEREC date_rec;
           dbdatecrack(rwrap->client, &date_rec, (DBDATETIME *)data);
-          int year  = date_rec.year,
-              month = date_rec.month,
-              day   = date_rec.day,
-              hour  = date_rec.hour,
-              min   = date_rec.minute,
-              sec   = date_rec.second,
-              msec  = date_rec.millisecond;
+          int year  = date_rec.dateyear,
+              month = date_rec.datemonth+1,
+              day   = date_rec.datedmonth,
+              hour  = date_rec.datehour,
+              min   = date_rec.dateminute,
+              sec   = date_rec.datesecond,
+              msec  = date_rec.datemsecond;
           if (year+month+day+hour+min+sec+msec != 0) {
             VALUE offset = (timezone == intern_local) ? rwrap->local_offset : opt_zero;
             /* Use DateTime */
@@ -210,31 +249,67 @@ static VALUE rb_tinytds_result_fetch_row(VALUE self, ID timezone, int symbolize_
 
 // TinyTds::Client (public)
 
+static VALUE rb_tinytds_result_fields(VALUE self) {
+  GET_RESULT_WRAPPER(self);
+  RETCODE dbsqlok_rc = rb_tinytds_result_ok_helper(rwrap->client);
+  RETCODE dbresults_rc = rb_tinytds_result_dbresults_retcode(self);
+  VALUE fields_processed = rb_ary_entry(rwrap->fields_processed, rwrap->number_of_results);
+  if ((dbsqlok_rc == SUCCEED) && (dbresults_rc == SUCCEED) && (fields_processed == Qnil)) {
+    /* Default query options. */
+    VALUE qopts = rb_iv_get(self, "@query_options");
+    int symbolize_keys = (rb_hash_aref(qopts, sym_symbolize_keys) == Qtrue) ? 1 : 0;
+    /* Set number_of_fields count for this result set. */
+    rwrap->number_of_fields = dbnumcols(rwrap->client);
+    if (rwrap->number_of_fields > 0) {
+      /* Create fields for this result set. */
+      unsigned int fldi = 0;
+      VALUE fields = rb_ary_new2(rwrap->number_of_fields);
+      for (fldi = 0; fldi < rwrap->number_of_fields; fldi++) {
+        char *colname = dbcolname(rwrap->client, fldi+1);
+        VALUE field = symbolize_keys ? ID2SYM(rb_intern(colname)) : rb_obj_freeze(ENCODED_STR_NEW2(colname));
+        rb_ary_store(fields, fldi, field);
+      }
+      /* Store the fields. */
+      if (rwrap->number_of_results == 0) {
+        rwrap->fields = fields;
+      } else if (rwrap->number_of_results == 1) {
+        VALUE multi_rs_fields = rb_ary_new();
+        rb_ary_store(multi_rs_fields, 0, rwrap->fields);
+        rb_ary_store(multi_rs_fields, 1, fields);
+        rwrap->fields = multi_rs_fields;
+      } else {
+        rb_ary_store(rwrap->fields, rwrap->number_of_results, fields);
+      }
+    }
+    rb_ary_store(rwrap->fields_processed, rwrap->number_of_results, Qtrue);
+  }
+  return rwrap->fields;
+}
+
 static VALUE rb_tinytds_result_each(int argc, VALUE * argv, VALUE self) {
   GET_RESULT_WRAPPER(self);
+  GET_CLIENT_USERDATA(rwrap->client);
   /* Local Vars */
-  VALUE defaults, opts, block;
+  VALUE qopts, opts, block;
   ID timezone;
   int symbolize_keys = 0, as_array = 0, cache_rows = 0, first = 0;
-  /* Merge Options Hash, Populate Opts & Block Var */
-  defaults = rb_iv_get(self, "@query_options");
-  if (rb_scan_args(argc, argv, "01&", &opts, &block) == 1) {
-    opts = rb_funcall(defaults, intern_merge, 1, opts);
-  } else {
-    opts = defaults;
-  }
+  /* Merge Options Hash To Query Options. Populate Opts & Block Var. */
+  qopts = rb_iv_get(self, "@query_options");
+  if (rb_scan_args(argc, argv, "01&", &opts, &block) == 1)
+    qopts = rb_funcall(qopts, intern_merge, 1, opts);
+  rb_iv_set(self, "@query_options", qopts);
   /* Locals From Options */
-  if (rb_hash_aref(opts, sym_first) == Qtrue)
+  if (rb_hash_aref(qopts, sym_first) == Qtrue)
     first = 1;
-  if (rb_hash_aref(opts, sym_symbolize_keys) == Qtrue)
+  if (rb_hash_aref(qopts, sym_symbolize_keys) == Qtrue)
     symbolize_keys = 1;
-  if (rb_hash_aref(opts, sym_as) == sym_array)
+  if (rb_hash_aref(qopts, sym_as) == sym_array)
     as_array = 1;
-  if (rb_hash_aref(opts, sym_cache_rows) == Qtrue)
+  if (rb_hash_aref(qopts, sym_cache_rows) == Qtrue)
     cache_rows = 1;
-  if (rb_hash_aref(opts, sym_timezone) == sym_local) {
+  if (rb_hash_aref(qopts, sym_timezone) == sym_local) {
     timezone = intern_local;
-  } else if (rb_hash_aref(opts, sym_timezone) == sym_utc) {
+  } else if (rb_hash_aref(qopts, sym_timezone) == sym_utc) {
     timezone = intern_utc;
   } else {
     rb_warn(":timezone option must be :utc or :local - defaulting to :local");
@@ -243,35 +318,12 @@ 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);
+    RETCODE dbsqlok_rc = rb_tinytds_result_ok_helper(rwrap->client);
+    RETCODE dbresults_rc = rb_tinytds_result_dbresults_retcode(self);
     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;
-      if (has_rows && (number_of_fields > 0)) {
-        /* Create fields for this result set. */
-        unsigned int fldi = 0;
-        rwrap->number_of_fields = number_of_fields;
-        VALUE fields = rb_ary_new2(rwrap->number_of_fields);
-        for (fldi = 0; fldi < rwrap->number_of_fields; fldi++) {
-          char *colname = dbcolname(rwrap->client, fldi+1);
-          VALUE field = symbolize_keys ? ID2SYM(rb_intern(colname)) : rb_obj_freeze(ENCODED_STR_NEW2(colname));
-          rb_ary_store(fields, fldi, field);
-        }
-        /* Store the fields. */
-        if (rwrap->number_of_results == 0) {
-          rwrap->fields = fields;
-        } else if (rwrap->number_of_results == 1) {
-          VALUE multi_rs_fields = rb_ary_new();
-          rb_ary_store(multi_rs_fields, 0, rwrap->fields);
-          rb_ary_store(multi_rs_fields, 1, fields);
-          rwrap->fields = multi_rs_fields;
-        } else {
-          rb_ary_store(rwrap->fields, rwrap->number_of_results, fields);
-        }
+      rb_tinytds_result_fields(self);
+      if (has_rows && rwrap->number_of_fields > 0) {
         /* Create rows for this result set. */
         unsigned long rowi = 0;
         VALUE result = rb_ary_new();
@@ -281,31 +333,40 @@ static VALUE rb_tinytds_result_each(int argc, VALUE * argv, VALUE self) {
             rb_ary_store(result, rowi, row);
           if (!NIL_P(block))
             rb_yield(row);
-          if (first)
+          if (first) {
             dbcanquery(rwrap->client);
+            userdata->dbcancel_sent = 1;
+          }
           rowi++;
         }
         rwrap->number_of_rows = rowi;
         /* Store the result. */
-        if (rwrap->number_of_results == 0) {
-          rwrap->results = result;
-        } else if (rwrap->number_of_results == 1) {
-          VALUE multi_resultsets = rb_ary_new();
-          rb_ary_store(multi_resultsets, 0, rwrap->results);
-          rb_ary_store(multi_resultsets, 1, result);
-          rwrap->results = multi_resultsets;
-        } else {
-          rb_ary_store(rwrap->results, rwrap->number_of_results, result);
+        if (cache_rows) {
+          if (rwrap->number_of_results == 0) {
+            rwrap->results = result;
+          } else if (rwrap->number_of_results == 1) {
+            VALUE multi_resultsets = rb_ary_new();
+            rb_ary_store(multi_resultsets, 0, rwrap->results);
+            rb_ary_store(multi_resultsets, 1, result);
+            rwrap->results = multi_resultsets;
+          } else {
+            rb_ary_store(rwrap->results, rwrap->number_of_results, result);
+          }
         }
-        /* Record the result set */
+        // If we find results increment the counter that helpers use and setup the next loop.
         rwrap->number_of_results = rwrap->number_of_results + 1;
+        dbresults_rc = rb_tinytds_result_dbresults_retcode(self);
+      } else {
+        // If we do not find results, side step the rb_tinytds_result_dbresults_retcode helper and 
+        // manually populate its memoized array while nullifing any memoized fields too before loop.
+        dbresults_rc = dbresults(rwrap->client);
+        rb_ary_store(rwrap->dbresults_retcodes, rwrap->number_of_results, INT2FIX(dbresults_rc));
+        rb_ary_store(rwrap->fields_processed, rwrap->number_of_results, Qnil);
       }
-      dbresults_rc = dbresults(rwrap->client);
-    }
-    if (dbresults_rc == FAIL) {
-      // TODO: Account for something in the dbresults() while loop set the return code to FAIL.
-      rb_warn("TinyTds: Something in the dbresults() while loop set the return code to FAIL.\n");
     }
+    if (dbresults_rc == FAIL)
+      rb_warn("TinyTDS: Something in the dbresults() while loop set the return code to FAIL.\n");
+    userdata->dbsql_sent = 0;
   } else if (!NIL_P(block)) {
     unsigned long i;
     for (i = 0; i < rwrap->number_of_rows; i++) {
@@ -315,24 +376,18 @@ static VALUE rb_tinytds_result_each(int argc, VALUE * argv, VALUE self) {
   return rwrap->results;
 }
 
-static VALUE rb_tinytds_result_fields(VALUE self) {
-  GET_RESULT_WRAPPER(self);
-  return rwrap->fields;
-}
-
 static VALUE rb_tinytds_result_cancel(VALUE self) {
   GET_RESULT_WRAPPER(self);
-  if (rwrap->client)
-    dbsqlok(rwrap->client);
-    dbcancel(rwrap->client);
+  GET_CLIENT_USERDATA(rwrap->client);
+  if (rwrap->client && !userdata->dbcancel_sent)
+    rb_tinytds_result_cancel_helper(rwrap->client);
   return Qtrue;
 }
 
 static VALUE rb_tinytds_result_do(VALUE self) {
   GET_RESULT_WRAPPER(self);
   if (rwrap->client) {
-    dbsqlok(rwrap->client);
-    dbcancel(rwrap->client);
+    rb_tinytds_result_cancel_helper(rwrap->client);
     return LONG2NUM((long)dbcount(rwrap->client));
   } else {
     return Qnil;
@@ -361,8 +416,7 @@ static VALUE rb_tinytds_result_return_code(VALUE self) {
 static VALUE rb_tinytds_result_insert(VALUE self) {
   GET_RESULT_WRAPPER(self);
   if (rwrap->client) {
-    dbsqlok(rwrap->client);
-    dbcancel(rwrap->client);
+    rb_tinytds_result_cancel_helper(rwrap->client);
     VALUE identity = Qnil;
     dbcmd(rwrap->client, "SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident");
     if (dbsqlexec(rwrap->client) != FAIL && dbresults(rwrap->client) != FAIL && DBROWS(rwrap->client) != FAIL) {
@@ -392,8 +446,8 @@ void init_tinytds_result() {
   /* Define TinyTds::Result */
   cTinyTdsResult = rb_define_class_under(mTinyTds, "Result", rb_cObject);
   /* Define TinyTds::Result Public Methods */
-  rb_define_method(cTinyTdsResult, "each", rb_tinytds_result_each, -1);
   rb_define_method(cTinyTdsResult, "fields", rb_tinytds_result_fields, 0);
+  rb_define_method(cTinyTdsResult, "each", rb_tinytds_result_each, -1);
   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);

data/ext/tiny_tds/result.h

@@ -2,6 +2,7 @@
 #ifndef TINYTDS_RESULT_H
 #define TINYTDS_RESULT_H
 
+// TODO: Is this needed?
 typedef tds_sysdep_int64_type DBBIGINT;  /* Missing in sybdb.h ?!?! */
 
 void init_tinytds_result();
@@ -11,16 +12,20 @@ typedef struct {
   DBPROCESS *client;
   VALUE local_offset;
   VALUE fields;
+  VALUE fields_processed;
   VALUE results;
   #ifdef HAVE_RUBY_ENCODING_H
     rb_encoding *encoding;
   #endif
+  VALUE dbresults_retcodes;
   unsigned int number_of_results;
   unsigned int number_of_fields;
   unsigned long number_of_rows;
 } tinytds_result_wrapper;
 
 
+// Lib Macros
+
 #define GET_RESULT_WRAPPER(self) \
   tinytds_result_wrapper *rwrap; \
   Data_Get_Struct(self, tinytds_result_wrapper, rwrap)

data/ext/tiny_tds/tiny_tds_ext.h

@@ -1,11 +1,9 @@
 #ifndef TINYTDS_EXT
 #define TINYTDS_EXT
-#define MSDBLIB
 
 #include <ruby.h>
-#include <sqlfront.h>
+#include <sybfront.h>
 #include <sybdb.h>
-#include <syberror.h>
 
 #ifdef HAVE_RUBY_ENCODING_H
 #include <ruby/encoding.h>

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.3.2'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: tiny_tds
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 15
   prerelease: 
   segments: 
   - 0
-  - 3
-  - 2
-  version: 0.3.2
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Ken Collins
@@ -16,11 +16,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-17 00:00:00 -05:00
+date: 2011-03-23 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
-description: TinyTds - A modern, simple and fast FreeTDS library for Ruby using DB-Library. Developed for the ActiveRecord SQL Server adapter.
+description: TinyTDS - A modern, simple and fast FreeTDS library for Ruby using DB-Library. Developed for the ActiveRecord SQL Server adapter.
 email: ken@metaskills.net
 executables: []
 
@@ -73,9 +73,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.4.1
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: TinyTds - A modern, simple and fast FreeTDS library for Ruby using DB-Library.
+summary: TinyTDS - A modern, simple and fast FreeTDS library for Ruby using DB-Library.
 test_files: []