tiny_tds 0.1.0

data/CHANGELOG

@@ -0,0 +1,3 @@
+
+* 0.1.0 Initial release!
+

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2010 Ken Collins, <ken@metaskills.net>
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,181 @@
+
+= 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 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:
+
+* TinyTds::Client - Your connection to the database.
+* TinyTds::Result - Returned from issuing an #execute on the connection. It includes Enumerable.
+* TinyTds::Error - A wrapper for all exceptions.
+
+
+
+== 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.
+
+    $ gem install tiny_tds
+
+Although we search for FreeTDS's libraries and headers, you may have to specify include and lib directories using "--with-freetds-include=/some/local/include/freetds" and "--with-freetds-lib=/some/local/lib"
+
+
+
+== 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".
+
+
+
+== Data Types
+
+Our goal is to support every SQL Server data type and covert it to a logical ruby object. When dates or times are returned, they are instantiated to either :utc or :local time depending on the query options. Under ruby 1.9, all strings are encoded to the connection's encoding and all binary data types are associated to ruby's ASCII-8BIT/BINARY encoding.
+
+Below is a list of the data types we plan to support using future versions of FreeTDS. They are associated with SQL Server 2008. All unsupported data types are returned as properly encoded strings.
+
+* [date]
+* [datetime2]
+* [datetimeoffset]
+* [time]
+
+
+
+== TinyTds::Client Usage
+
+Connect to a database.
+
+  client = TinyTds::Client.new(:user => 'sa', :password => 'secret', :dataserver => 'mytds_box')
+
+Creating a new client takes a hash of options. For valid iconv encoding options, see the output of "iconv -l". Only a few have been tested and highly recommended to leave blank for the UTF-8 default.
+
+* :username - The database server user.
+* :password - The user password.
+* :dataserver - The name for your server as defined in freetds.conf.
+* :database - The default database to use.
+* :appname - Short string seen in SQL Servers process/activity window.
+* :tds_version - TDS version. Defaults to 80, not recommended to change.
+* :login_timeout - Seconds to wait for login. Default to 60 seconds.
+* :timeout - Seconds to wait for a response to a SQL command. Default 5 seconds.
+* :encoding - Any valid iconv value like CP1251 or ISO-8859-1. Default UTF-8.
+
+Close and free a clients connection.
+
+  client.close
+  client.closed? # => true
+
+Escape strings.
+
+  client.escape("How's It Going'") # => "How''s It Going''"
+
+Send a SQL string to the database and return a TinyTds::Result object.
+
+  result = client.execute("SELECT * FROM [datatypes]")
+
+
+
+== TinyTds::Result Usage
+
+A result object is returned by the client's execute command. It is important that you either return the data from the query, most likely with the #each method, or that you cancel the results before asking the client to execute another SQL batch. Failing to do so will yield an error.
+
+Calling #each on the result will lazily load each row from the database.
+
+  result.each do |row|
+    # By default each row is a hash.
+    # The keys are the fields, as you'd expect.
+    # The values are pre-built ruby primitives mapped from their corresponding types.
+    # 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.
+
+  result.fields # => [ ... ]
+
+You can cancel a result object's data from being loading by the server.
+
+  result = client.execute("SELECT * FROM [super_big_table]")
+  result.cancel
+
+If the SQL executed by the client returns affected rows, you can easily find out how many.
+
+  result.each
+  result.affected_rows # => 24
+
+This pattern is so common for UPDATE and DELETE statements that the #do method cancels any need for loading the result data and returns the #affected_rows.
+
+  result = client.execute("DELETE FROM [datatypes]")
+  result.do # => 72
+
+Likewise for INSERT statements, the #insert method cancels any need for loading the result data and executes a SCOPE_IDENTITY() for the primary key.
+
+  result = client.execute("INSERT INTO [datatypes] ([xml]) VALUES ('<html><br/></html>')")
+  result.insert # => 420
+
+
+
+== Query Options
+
+Every TinyTds::Result object can pass query options to the #each method. The defaults are defined and configurable by setting options in the TinyTds::Client.default_query_options hash. The default values are:
+
+* :as => :hash - Object for each row yielded. Can be set to :array.
+* :symbolize_keys => false - Row hash keys. Defaults to shared/frozen string keys.
+* :cache_rows => true - Successive calls to #each returns the cached rows.
+* :timezone => :local - Local to the ruby client or :utc for UTC.
+
+Each result gets a copy of the default options you specify at the client level and can be overridden by passing an options hash to the #each method. For example
+  
+  result.each(:as => :array, :cache_rows => false) do |row|
+    # Each row is now an array of values ordered by #fields.
+    # Rows are yielded and forgotten about, freeing memory.
+  end
+
+Besides the standard query options, the result object can take one additional option. Using :first => true will only load the first row of data and cancel all remaining results.
+
+  result = client.execute("SELECT * FROM [super_big_table]")
+  result.each(:first => true) # => [{'id' => 24}]
+
+
+
+== 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.
+
+
+
+== Development & Testing
+
+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
+
+For help and support.
+
+* Github Source: http://github.com/rails-sqlserver/tiny_tds
+* Github Issues: http://github.com/rails-sqlserver/tiny_tds/issues
+* IRC Room: #rails-sqlserver on irc.freenode.net
+
+Current to do list.
+
+* Test 0.83 development of FreeTDS.
+* Handle multiple result sets.
+* Find someone brave enough to compile/test for Windows.
+* Install an interrupt handler.
+* Allow #escape to accept all ruby primitives.
+* Get bug reports!
+
+
+
+== About Me
+
+My name is Ken Collins and I have no love for Microsoft nor do I work on Windows or have I ever owned a PC. I currently maintain the SQL Server adapter for ActiveRecord and wrote this library as my first cut into learning ruby C extensions. Hopefully it will help promote the power of ruby and the rails framework to those that have not yet discovered it. My blog is http://metaskills.net and I can be found on twitter as @metaskills. Enjoy!
+
+
+
+== Special Thanks
+
+* Erik Bryn for joining the project and helping me thru a few tight spots. - http://github.com/ebryn
+* To the authors and contributors of the Mysql2 gem for inspiration. - http://github.com/brianmario/mysql2
+* Yehuda Katz for articulating ruby's need for proper encoding support. Especially in database drivers - http://yehudakatz.com/2010/05/05/ruby-1-9-encodings-a-primer-and-the-solution-for-rails/
+* Josh Clayton of Thoughtbot for writing about ruby C extensions. - http://robots.thoughtbot.com/post/1037240922/get-your-c-on
+

data/ext/tiny_tds/client.c

@@ -0,0 +1,225 @@
+
+#include <tiny_tds_ext.h>
+#include <client.h>
+#include <errno.h>
+
+VALUE cTinyTdsClient;
+extern VALUE mTinyTds, cTinyTdsError;
+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;
+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 REQUIRE_OPEN_CLIENT(cwrap) \
+  if(cwrap->closed) { \
+    rb_raise(cTinyTdsError, "closed connection"); \
+    return Qnil; \
+  }
+
+
+// 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); }
+  VALUE 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));  
+  rb_exc_raise(e);
+  return Qnil;
+}
+
+
+// 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_msg_handler(DBPROCESS *dbproc, DBINT msgno, int msgstate, int severity, char *msgtext, char *srvname, char *procname, int line) {
+  static char *source = "message";
+  if (severity)
+    rb_tinytds_raise_error(dbproc, 1, msgtext, source, severity, msgno, msgstate);
+  return 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->closed = 1;
+  }
+  xfree(ptr);
+}
+
+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);
+  cwrap->closed = 1;
+  cwrap->charset = Qnil;
+  return obj;
+}
+
+
+// TinyTds::Client (public) 
+
+static VALUE rb_tinytds_tds_version(VALUE self) {
+  GET_CLIENT_WRAPPER(self);
+  return INT2FIX(dbtds(cwrap->client));
+}
+
+static VALUE rb_tinytds_close(VALUE self) {
+  GET_CLIENT_WRAPPER(self);
+  if (cwrap->client && !cwrap->closed) {
+    dbclose(cwrap->client);
+    cwrap->closed = 1;
+  }
+  return Qtrue;
+}
+
+static VALUE rb_tinytds_closed(VALUE self) {
+  GET_CLIENT_WRAPPER(self);
+  return cwrap->closed ? Qtrue : Qfalse;
+}
+
+static VALUE rb_tinytds_execute(VALUE self, VALUE sql) {
+  GET_CLIENT_WRAPPER(self);
+  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");
+    return Qfalse;
+  }
+  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);
+  rwrap->local_offset = rb_funcall(cTinyTdsClient, intern_local_offset, 0);
+  #ifdef HAVE_RUBY_ENCODING_H
+    rwrap->encoding = cwrap->encoding;
+  #endif
+  return result;  
+}
+
+static VALUE rb_tinytds_charset(VALUE self) {
+  GET_CLIENT_WRAPPER(self);
+  return cwrap->charset;
+}
+
+static VALUE rb_tinytds_encoding(VALUE self) {
+  GET_CLIENT_WRAPPER(self);
+  #ifdef HAVE_RUBY_ENCODING_H
+    return rb_enc_from_encoding(cwrap->encoding);
+  #else
+    return Qnil;
+  #endif
+}
+
+static VALUE rb_tinytds_escape(VALUE self, VALUE string) {
+  Check_Type(string, T_STRING);
+  GET_CLIENT_WRAPPER(self);
+  VALUE new_string = rb_funcall(string, intern_gsub, 2, opt_escape_regex, opt_escape_dblquote);
+  #ifdef HAVE_RUBY_ENCODING_H
+    rb_enc_associate(new_string, cwrap->encoding);
+  #endif
+  return new_string;
+}
+
+
+// TinyTds::Client (protected) 
+
+static VALUE rb_tinytds_connect(VALUE self, VALUE user, VALUE pass, VALUE dataserver, VALUE database, VALUE app, VALUE version, VALUE ltimeout, VALUE timeout, VALUE charset) {
+  if (dbinit() == FAIL) {
+    rb_raise(cTinyTdsError, "failed dbinit() function");
+    return self;
+  }
+  dberrhandle(tinytds_err_handler);
+  dbmsghandle(tinytds_msg_handler);
+  GET_CLIENT_WRAPPER(self);
+  cwrap->login = dblogin();
+  if (!NIL_P(user))
+    dbsetluser(cwrap->login, StringValuePtr(user));
+  if (!NIL_P(pass))
+    dbsetlpwd(cwrap->login, StringValuePtr(pass));
+  if (!NIL_P(app))
+    dbsetlapp(cwrap->login, StringValuePtr(app));
+  if (!NIL_P(version))
+    dbsetlversion(cwrap->login, NUM2INT(version));
+  if (!NIL_P(ltimeout))
+    dbsetlogintime(NUM2INT(ltimeout));
+  if (!NIL_P(timeout))
+    dbsettime(NUM2INT(timeout));
+  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;
+    #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));
+    #endif
+  }
+  return self;
+}
+
+
+// Lib Init
+
+void init_tinytds_client() {
+  cTinyTdsClient = rb_define_class_under(mTinyTds, "Client", rb_cObject);
+  rb_define_alloc_func(cTinyTdsClient, allocate);
+  /* Define TinyTds::Client Public Methods */
+  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, "execute", rb_tinytds_execute, 1);
+  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);
+  /* Define TinyTds::Client Protected Methods */
+  rb_define_protected_method(cTinyTdsClient, "connect", rb_tinytds_connect, 9);
+  /* Intern TinyTds::Error Accessors */
+  intern_source_eql = rb_intern("source=");
+  intern_severity_eql = rb_intern("severity=");
+  intern_db_error_number_eql = rb_intern("db_error_number=");
+  intern_os_error_number_eql = rb_intern("os_error_number=");
+  /* Intern Misc */
+  intern_new = rb_intern("new");
+  intern_dup = rb_intern("dup");
+  intern_transpose_iconv_encoding = rb_intern("transpose_iconv_encoding");
+  intern_local_offset = rb_intern("local_offset");
+  intern_gsub = rb_intern("gsub");
+  /* Escape Regexp Global */
+  opt_escape_regex = rb_funcall(rb_cRegexp, intern_new, 1, rb_str_new2("\\\'"));
+  opt_escape_dblquote = rb_str_new2("''");
+  rb_global_variable(&opt_escape_regex);
+  rb_global_variable(&opt_escape_dblquote);
+}
+
+

data/ext/tiny_tds/client.h

@@ -0,0 +1,19 @@
+
+#ifndef TINYTDS_CLIENT_H
+#define TINYTDS_CLIENT_H
+
+void init_tinytds_client();
+
+typedef struct {
+  LOGINREC *login;
+  RETCODE return_code;
+  DBPROCESS *client;
+  short int closed;
+  VALUE charset;
+  #ifdef HAVE_RUBY_ENCODING_H
+    rb_encoding *encoding;
+  #endif
+} tinytds_client_wrapper;
+
+
+#endif

data/ext/tiny_tds/extconf.rb

@@ -0,0 +1,75 @@
+require 'mkmf'
+
+FREETDS_LIBRARIES = ['sybdb']
+FREETDS_HEADERS = ['sqlfront.h', 'sybdb.h', 'syberror.h']
+
+dir_config('freetds')
+
+def root_paths
+  eop_regexp = /#{File::SEPARATOR}bin$/
+  paths = ENV['PATH'].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
+
+def have_freetds_libraries?(*libraries)
+  libraries.all? { |l| have_library(l) }
+end
+
+def find_freetds_libraries_path
+  root_paths.detect do |path|
+    [['lib'],['lib','freetds']].detect do |lpaths|
+      dir = File.join path, *lpaths
+      message = "looking for library directory #{dir} ..."
+      if File.directory?(dir)
+        puts "#{message} yes"
+        if with_ldflags("#{$LDFLAGS} -L#{dir}".strip) { have_freetds_libraries?(*FREETDS_LIBRARIES) }
+          $LDFLAGS += "#{$LDFLAGS} -L#{dir}".strip
+          true
+        else
+          false
+        end
+      else
+        puts "#{message} no"
+        false
+      end
+    end
+  end
+end
+
+def have_freetds_headers?(*headers)
+  headers.all? { |h| have_header(h) }
+end
+
+def find_freetds_include_path
+  root_paths.detect do |path|
+    [['include'],['include','freetds']].detect do |ipaths|
+      dir = File.join path, *ipaths
+      message = "looking for include directory #{dir} ..."
+      if File.directory?(dir)
+        puts "#{message} yes"
+        if with_cppflags("#{$CPPFLAGS} -I#{dir}".strip) { have_freetds_headers?(*FREETDS_HEADERS) }
+          $CPPFLAGS += "#{$CPPFLAGS} -I#{dir}".strip
+          true
+        else
+          false
+        end
+      else
+        puts "#{message} no"
+        false
+      end
+    end
+  end
+end
+
+def have_freetds?
+  (have_freetds_libraries?(*FREETDS_LIBRARIES) || find_freetds_libraries_path) && 
+  (have_freetds_headers?(*FREETDS_HEADERS) || find_freetds_include_path)
+end
+
+unless have_freetds?
+  abort "-----\nCan not find FreeTDS's db-lib or include directory.\n-----"
+end
+
+create_makefile('tiny_tds/tiny_tds')
+

data/ext/tiny_tds/result.c

@@ -0,0 +1,390 @@
+
+#include <tiny_tds_ext.h>
+
+VALUE cTinyTdsResult;
+extern VALUE mTinyTds, cTinyTdsClient, cTinyTdsError;
+VALUE cBigDecimal, cDate, cDateTime, cRational;
+VALUE opt_decimal_zero, opt_float_zero, opt_one, opt_zero, opt_four, opt_19hdr, opt_tenk, opt_onemil;
+static ID intern_new, intern_utc, intern_local, intern_localtime, intern_merge, 
+          intern_civil, intern_new_offset, intern_plus, intern_divide;
+static ID sym_symbolize_keys, sym_as, sym_array, sym_cache_rows, sym_first, sym_timezone, sym_local, sym_utc;
+
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *binaryEncoding;
+  #define ENCODED_STR_NEW(_data, _len) ({ \
+    VALUE _val = rb_str_new((char *)_data, (long)_len); \
+    rb_enc_associate(_val, rwrap->encoding); \
+    _val; \
+  })
+  #define ENCODED_STR_NEW2(_data2) ({ \
+    VALUE _val = rb_str_new2((char *)_data2); \
+    rb_enc_associate(_val, rwrap->encoding); \
+    _val; \
+  })
+#else
+  #define ENCODED_STR_NEW(_data, _len) \
+    rb_str_new((char *)_data, (long)_len);
+  #define ENCODED_STR_NEW2(_data2) \
+    rb_str_new2((char *)_data2);
+#endif
+
+
+// Lib Backend (Memory Management)
+
+static void rb_tinytds_result_mark(void *ptr) {
+  tinytds_result_wrapper *rwrap = (tinytds_result_wrapper *)ptr;
+  if (rwrap) {
+    rb_gc_mark(rwrap->local_offset);
+    rb_gc_mark(rwrap->fields);
+    rb_gc_mark(rwrap->rows);
+  }
+}
+
+static void rb_tinytds_result_free(void *ptr) {
+  tinytds_result_wrapper *rwrap = (tinytds_result_wrapper *)ptr;
+  xfree(ptr);
+}
+
+VALUE rb_tinytds_new_result_obj(DBPROCESS *c) {
+  VALUE obj;
+  tinytds_result_wrapper *rwrap;
+  obj = Data_Make_Struct(cTinyTdsResult, tinytds_result_wrapper, rb_tinytds_result_mark, rb_tinytds_result_free, rwrap);
+  rwrap->client = c;
+  rwrap->return_code = 0;
+  rwrap->local_offset = Qnil;
+  rwrap->fields = Qnil;
+  rwrap->rows = Qnil;
+  rwrap->number_of_fields = 0;
+  rwrap->number_of_rows = 0;
+  rb_obj_call_init(obj, 0, NULL);
+  return obj;
+}
+
+
+// Lib Backend (Helpers)
+
+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);
+  VALUE row;
+  unsigned int i = 0;
+  /* One-Time Fields Info & Container */
+  if (NIL_P(rwrap->fields)) {
+    rwrap->number_of_fields = dbnumcols(rwrap->client);
+    rwrap->fields = rb_ary_new2(rwrap->number_of_fields);
+    for (i = 0; i < rwrap->number_of_fields; i++) {
+      char *colname = dbcolname(rwrap->client, i+1);
+      VALUE field = symbolize_keys ? ID2SYM(rb_intern(colname)) : rb_obj_freeze(rb_str_new2(colname));
+      rb_ary_store(rwrap->fields, i, field);
+    }
+  }
+  /* Create Empty Row */
+  if (as_array) {
+    row = rb_ary_new2(rwrap->number_of_fields);
+  } else {
+    row = rb_hash_new();
+  }
+  /* Storing Values */
+  for (i = 0; i < rwrap->number_of_fields; i++) {
+    VALUE val = Qnil;
+    int col = i+1;
+    int coltype = dbcoltype(rwrap->client, col);
+    BYTE *data = dbdata(rwrap->client, col);
+    DBINT data_len = dbdatlen(rwrap->client, col);
+    int null_val = ((data == NULL) && (data_len == 0));
+    if (!null_val) {
+      switch(coltype) {
+        case SYBINT1:
+          val = INT2FIX(*(DBTINYINT *)data);
+          break;
+        case SYBINT2:
+          val = INT2FIX(*(DBSMALLINT *)data);
+          break;
+        case SYBINT4:
+          val = INT2NUM(*(DBINT *)data);
+          break;
+        case SYBINT8:
+          val = LONG2NUM(*(long *)data);
+          break;
+        case SYBBIT:
+          val = *(int *)data ? Qtrue : Qfalse;
+          break;
+        case SYBNUMERIC:
+        case SYBDECIMAL: { 
+          DBTYPEINFO *data_info = dbcoltypeinfo(rwrap->client, col);
+          int data_slength = (int)data_info->precision + (int)data_info->scale + 1;
+          char converted_decimal[data_slength];
+          dbconvert(rwrap->client, coltype, data, data_len, SYBVARCHAR, (BYTE *)converted_decimal, -1);
+          val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new2((char *)converted_decimal));
+          break;
+        }
+        case SYBFLT8: {
+          double col_to_double = *(double *)data;
+          val = (col_to_double == 0.000000) ? opt_float_zero : rb_float_new(col_to_double);
+          break;
+        }
+        case SYBREAL: {
+          float col_to_float = *(float *)data;
+          val = (col_to_float == 0.0) ? opt_float_zero : rb_float_new(col_to_float);
+          break;
+        }
+        case SYBMONEY: {
+          DBMONEY *money = (DBMONEY *)data;
+          char converted_money[25];
+          long money_value = ((long)money->mnyhigh << 32) | money->mnylow;
+          sprintf(converted_money, "%ld", money_value);
+          val = rb_funcall(cBigDecimal, intern_new, 2, rb_str_new2(converted_money), opt_four);
+          val = rb_funcall(val, intern_divide, 1, opt_tenk);
+          break;
+        }
+        case SYBMONEY4: {
+          DBMONEY4 *money = (DBMONEY4 *)data;
+          char converted_money[20];
+          sprintf(converted_money, "%f", money->mny4 / 10000.0);
+          val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new2(converted_money));
+          break;
+        }
+        case SYBBINARY:
+        case SYBIMAGE:
+          val = rb_str_new((char *)data, (long)data_len);
+          #ifdef HAVE_RUBY_ENCODING_H
+            rb_enc_associate(val, binaryEncoding);
+          #endif
+          break;
+        case 36: { // SYBUNIQUE
+          char converted_unique[32];
+          dbconvert(rwrap->client, coltype, data, 32, SYBVARCHAR, (BYTE *)converted_unique, -1);
+          val = ENCODED_STR_NEW2(converted_unique);
+          break;
+        }
+        case SYBDATETIME4:
+          dbconvert(rwrap->client, coltype, data, data_len, SYBDATETIME, data, data_len);
+        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;
+          if (year+month+day+hour+min+sec+msec != 0) {
+            VALUE offset = (timezone == intern_local) ? rwrap->local_offset : opt_zero;
+            /* Use DateTime */
+            if (year < 1902 || year+month+day > 2058) {
+              VALUE datetime_sec = INT2NUM(sec);
+              if (msec != 0) {
+                #ifdef HAVE_RUBY_ENCODING_H
+                  VALUE rational_msec = rb_Rational2(INT2NUM(msec*1000), opt_onemil);
+                #else
+                  VALUE rational_msec = rb_funcall(cRational, intern_new, 2, INT2NUM(msec*1000), opt_onemil);
+                #endif
+                datetime_sec = rb_funcall(datetime_sec, intern_plus, 1, rational_msec);
+              }
+              val = rb_funcall(cDateTime, intern_civil, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), datetime_sec, offset);
+              val = rb_funcall(val, intern_new_offset, 1, offset);
+            /* Use Time */
+            } else {
+              val = rb_funcall(rb_cTime, timezone, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), INT2NUM(msec*1000));
+            }
+          }
+          break;
+        }
+        case SYBCHAR:
+        case SYBTEXT:
+          val = ENCODED_STR_NEW(data, data_len);
+          break;
+        default:
+          val = ENCODED_STR_NEW(data, data_len);
+          break;
+      }
+    }
+    if (as_array) {
+      rb_ary_store(row, i, val);
+    } else {
+      rb_hash_aset(row, rb_ary_entry(rwrap->fields, i), val);
+    }
+  }
+  return row;
+}
+
+
+// TinyTds::Client (public)
+
+static VALUE rb_tinytds_result_each(int argc, VALUE * argv, VALUE self) {
+  GET_RESULT_WRAPPER(self);
+  /* Local Vars */
+  VALUE defaults, 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;
+  }
+  /* Locals From Options */
+  if (rb_hash_aref(opts, sym_first) == Qtrue)
+    first = 1;
+  if (rb_hash_aref(opts, sym_symbolize_keys) == Qtrue)
+    symbolize_keys = 1;
+  if (rb_hash_aref(opts, sym_as) == sym_array)
+    as_array = 1;
+  if (rb_hash_aref(opts, sym_cache_rows) == Qtrue)
+    cache_rows = 1;
+  if (rb_hash_aref(opts, sym_timezone) == sym_local) {
+    timezone = intern_local;
+  } else if (rb_hash_aref(opts, sym_timezone) == sym_utc) {
+    timezone = intern_utc;
+  } else {
+    rb_warn(":timezone option must be :utc or :local - defaulting to :local");
+    timezone = intern_local;
+  }
+  /* Make The Rows Or Yield Existing */
+  if (NIL_P(rwrap->rows)) {
+    rwrap->rows = rb_ary_new();
+    RETCODE return_code;
+    while (return_code != NO_MORE_RESULTS) {
+      return_code = dbresults(rwrap->client);
+      if (return_code != FAIL) {
+        /* If no actual rows, return the empty array. */
+        if (DBROWS(rwrap->client) != SUCCEED)
+          return rwrap->rows;
+        unsigned long rowi = 0;
+        while (dbnextrow(rwrap->client) != NO_MORE_ROWS) {
+          VALUE row = rb_tinytds_result_fetch_row(self, timezone, symbolize_keys, as_array);
+          if (cache_rows)
+            rb_ary_store(rwrap->rows, rowi, row);
+          if (!NIL_P(block))
+            rb_yield(row);
+          if (first)
+            dbcanquery(rwrap->client);
+          rowi++;
+        }
+        rwrap->number_of_rows = rowi;
+      } else {
+        // TODO: Account for failed dbresults() must have returned FAIL.
+        rb_warn("TinyTds: dbresults() must have returned FAIL.\n");
+      }
+    }
+    if (return_code == 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");
+    }
+  } else if (!NIL_P(block)) {
+    unsigned long i;
+    for (i = 0; i < rwrap->number_of_rows; i++) {
+      rb_yield(rb_ary_entry(rwrap->rows, i));
+    }
+  }
+  return rwrap->rows;
+}
+
+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)
+    dbcancel(rwrap->client);
+  return Qtrue;
+}
+
+static VALUE rb_tinytds_result_do(VALUE self) {
+  GET_RESULT_WRAPPER(self);
+  if (rwrap->client) {
+    dbcancel(rwrap->client);
+    return LONG2NUM((long)dbcount(rwrap->client));
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE rb_tinytds_result_affected_rows(VALUE self) {
+  GET_RESULT_WRAPPER(self);
+  if (rwrap->client) {
+    return LONG2NUM((long)dbcount(rwrap->client));
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE rb_tinytds_result_insert(VALUE self) {
+  GET_RESULT_WRAPPER(self);
+  if (rwrap->client) {
+    dbcancel(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) {
+      while (dbnextrow(rwrap->client) != NO_MORE_ROWS) {
+        int col = 1;
+        BYTE *data = dbdata(rwrap->client, col);
+        DBINT data_len = dbdatlen(rwrap->client, col);
+        int null_val = ((data == NULL) && (data_len == 0));
+        if (!null_val)
+          identity = LONG2NUM(*(long *)data);
+      }
+    }
+    return identity;
+  } else {
+    return Qnil;
+  }
+}
+
+
+// Lib Init
+
+void init_tinytds_result() {
+  /* Data Classes */
+  cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
+  cDate = rb_const_get(rb_cObject, rb_intern("Date"));
+  cDateTime = rb_const_get(rb_cObject, rb_intern("DateTime"));
+  cRational = rb_const_get(rb_cObject, rb_intern("Rational"));
+  /* 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, "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, "insert", rb_tinytds_result_insert, 0);
+  /* Intern String Helpers */
+  intern_new = rb_intern("new");
+  intern_utc = rb_intern("utc");
+  intern_local = rb_intern("local");
+  intern_merge = rb_intern("merge");
+  intern_localtime = rb_intern("localtime");
+  intern_civil = rb_intern("civil");
+  intern_new_offset = rb_intern("new_offset");
+  intern_plus = rb_intern("+");
+  intern_divide = rb_intern("/");
+  /* Symbol Helpers */
+  sym_symbolize_keys = ID2SYM(rb_intern("symbolize_keys"));
+  sym_as = ID2SYM(rb_intern("as"));
+  sym_array = ID2SYM(rb_intern("array"));
+  sym_cache_rows = ID2SYM(rb_intern("cache_rows"));
+  sym_first = ID2SYM(rb_intern("first"));
+  sym_local = ID2SYM(intern_local);
+  sym_utc = ID2SYM(intern_utc);
+  sym_timezone = ID2SYM(rb_intern("timezone"));
+  /* Data Conversion Options */
+  opt_decimal_zero = rb_str_new2("0.0");
+  rb_global_variable(&opt_decimal_zero);
+  opt_float_zero = rb_float_new((double)0);
+  rb_global_variable(&opt_float_zero);
+  opt_one = INT2NUM(1);
+  opt_zero = INT2NUM(0);
+  opt_four = INT2NUM(4);
+  opt_19hdr = INT2NUM(1900);
+  opt_tenk = INT2NUM(10000);
+  opt_onemil = INT2NUM(1000000);
+  /* Encoding */
+  #ifdef HAVE_RUBY_ENCODING_H
+    binaryEncoding = rb_enc_find("binary");
+  #endif
+}

data/ext/tiny_tds/result.h

@@ -0,0 +1,29 @@
+
+#ifndef TINYTDS_RESULT_H
+#define TINYTDS_RESULT_H
+
+void init_tinytds_result();
+VALUE rb_tinytds_new_result_obj(DBPROCESS *c);
+
+typedef struct {
+  DBPROCESS *client;
+  RETCODE return_code;
+  VALUE local_offset;
+  VALUE fields;
+  VALUE rows;
+  #ifdef HAVE_RUBY_ENCODING_H
+    rb_encoding *encoding;
+  #endif
+  long number_of_fields;
+  unsigned long number_of_rows;
+} tinytds_result_wrapper;
+
+
+#define GET_RESULT_WRAPPER(self) \
+  tinytds_result_wrapper *rwrap; \
+  Data_Get_Struct(self, tinytds_result_wrapper, rwrap)
+
+
+
+
+#endif

data/ext/tiny_tds/tiny_tds_ext.c

@@ -0,0 +1,12 @@
+
+#include <tiny_tds_ext.h>
+
+VALUE mTinyTds, cTinyTdsError;
+
+void Init_tiny_tds() {
+  mTinyTds      = rb_define_module("TinyTds");
+  cTinyTdsError = rb_const_get(mTinyTds, rb_intern("Error"));
+  init_tinytds_client();
+  init_tinytds_result();
+}
+

data/ext/tiny_tds/tiny_tds_ext.h

@@ -0,0 +1,17 @@
+#ifndef TINYTDS_EXT
+#define TINYTDS_EXT
+#define MSDBLIB
+
+#include <ruby.h>
+#include <sqlfront.h>
+#include <sybdb.h>
+#include <syberror.h>
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/encoding.h>
+#endif
+
+#include <client.h>
+#include <result.h>
+
+#endif

data/lib/tiny_tds.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+require 'date'
+require 'bigdecimal'
+require 'rational' unless RUBY_VERSION >= '1.9.2'
+
+require 'tiny_tds/error'
+require 'tiny_tds/tiny_tds'
+require 'tiny_tds/client'
+require 'tiny_tds/result'
+
+require 'tiny_tds/tiny_tds'
+
+
+# = TinyTds
+#
+# Tiny Ruby Wrapper For FreeTDS Using DB-Library
+module TinyTds
+  VERSION = '0.1.0'
+end

data/lib/tiny_tds/client.rb

@@ -0,0 +1,77 @@
+module TinyTds
+  class Client
+    
+    TDS_VERSIONS_SETTERS = {
+      'unknown' => 0,
+      '46'      => 1,
+      '100'     => 2,
+      '42'      => 3,
+      '70'      => 4,
+      '80'      => 5,
+      '90'      => 6  # TODO: untested
+    }.freeze
+    
+    TDS_VERSIONS_GETTERS = {
+      0  => {:name => 'DBTDS_UNKNOWN', :description => 'Unknown'},
+      1  => {:name => 'DBTDS_2_0',     :description => 'Pre 4.0 SQL Server'},
+      2  => {:name => 'DBTDS_3_4',     :description => 'Microsoft SQL Server (3.0)'},
+      3  => {:name => 'DBTDS_4_0',     :description => '4.0 SQL Server'},
+      4  => {:name => 'DBTDS_4_2',     :description => '4.2 SQL Server'},
+      5  => {:name => 'DBTDS_4_6',     :description => '2.0 OpenServer and 4.6 SQL Server.'},
+      6  => {:name => 'DBTDS_4_9_5',   :description => '4.9.5 (NCR) SQL Server'},
+      7  => {:name => 'DBTDS_5_0',     :description => '5.0 SQL Server'},
+      8  => {:name => 'DBTDS_7_0',     :description => 'Microsoft SQL Server 7.0'},
+      9  => {:name => 'DBTDS_8_0',     :description => 'Microsoft SQL Server 2000'},
+      10 => {:name => 'DBTDS_9_0',     :description => 'Microsoft SQL Server 2005'}
+    }.freeze
+    
+    @@default_query_options = {
+      :as => :hash,
+      :symbolize_keys => false,
+      :cache_rows => true,
+      :timezone => :local
+    }
+    
+    attr_reader :query_options
+    
+    def self.default_query_options
+      @@default_query_options
+    end
+    
+    # Most, if not all, iconv encoding names can be found by ruby. Just in case, you can 
+    # overide this method to return a string name that Encoding.find would work with. Default 
+    # is to return the passed encoding.
+    def self.transpose_iconv_encoding(encoding)
+      encoding
+    end
+
+
+    def initialize(opts={})
+      @query_options = @@default_query_options.dup
+      user       = opts[:username]
+      pass       = opts[:password]
+      dataserver = opts[:dataserver]
+      database   = opts[:database]
+      appname    = opts[:appname] || 'TinyTds'
+      version    = TDS_VERSIONS_SETTERS[opts[:tds_version].to_s] || TDS_VERSIONS_SETTERS['80']
+      ltimeout   = opts[:login_timeout] || 60
+      timeout    = opts[:timeout] || 5
+      encoding   = (opts[:encoding].nil? || opts[:encoding].downcase == 'utf8') ? 'UTF-8' : opts[:encoding].upcase
+      raise ArgumentError, 'missing :username option' if user.nil? || user.empty?
+      connect(user, pass, dataserver, database, appname, version, ltimeout, timeout, encoding)
+    end
+    
+    def tds_version_info
+      info = TDS_VERSIONS_GETTERS[tds_version]
+      "#{info[:name]} - #{info[:description]}" if info
+    end
+
+
+    private
+    
+    def self.local_offset
+      ::Time.local(2010).utc_offset.to_r / 86400
+    end
+    
+  end
+end

data/lib/tiny_tds/error.rb

@@ -0,0 +1,29 @@
+module TinyTds  
+  class Error < StandardError
+    
+    SEVERITIES = [
+      {:number => 1,   :severity => 'EXINFO',         :explanation => 'Informational, non-error.'},
+      {:number => 2,   :severity => 'EXUSER',         :explanation => 'User error.'},
+      {:number => 3,   :severity => 'EXNONFATAL',     :explanation => 'Non-fatal error.'},
+      {:number => 4,   :severity => 'EXCONVERSION',   :explanation => 'Error in DB-Library data conversion.'},
+      {:number => 5,   :severity => 'EXSERVER',       :explanation => 'The Server has returned an error flag.'},
+      {:number => 6,   :severity => 'EXTIME',         :explanation => 'We have exceeded our timeout period while waiting for a response from the Server - the DBPROCESS is still alive.'},
+      {:number => 7,   :severity => 'EXPROGRAM',      :explanation => 'Coding error in user program.'},
+      {:number => 8,   :severity => 'EXRESOURCE',     :explanation => 'Running out of resources - the DBPROCESS may be dead.'},
+      {:number => 9,   :severity => 'EXCOMM',         :explanation => 'Failure in communication with Server - the DBPROCESS is dead.'},
+      {:number => 10,  :severity => 'EXFATAL',        :explanation => 'Fatal error - the DBPROCESS is dead.'},
+      {:number => 11,  :severity => 'EXCONSISTENCY',  :explanation => 'Internal software error - notify Sybase Technical Support.'}
+    ].freeze
+    
+    attr_accessor :source, :severity, :db_error_number, :os_error_number
+    
+    def initialize(message)
+      super
+      @severity = nil
+      @db_error_number = nil
+      @os_error_number = nil
+    end
+
+
+  end
+end

data/lib/tiny_tds/result.rb

@@ -0,0 +1,8 @@
+module TinyTds
+  class Result
+    
+    include Enumerable
+    
+    
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: tiny_tds
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ken Collins
+- Erik Bryn
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-17 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.
+email: ken@metaskills.net
+executables: []
+
+extensions: 
+- ext/tiny_tds/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- CHANGELOG
+- MIT-LICENSE
+- README.rdoc
+- ext/tiny_tds/client.c
+- ext/tiny_tds/client.h
+- ext/tiny_tds/extconf.rb
+- ext/tiny_tds/result.c
+- ext/tiny_tds/result.h
+- ext/tiny_tds/tiny_tds_ext.c
+- ext/tiny_tds/tiny_tds_ext.h
+- lib/tiny_tds/client.rb
+- lib/tiny_tds/error.rb
+- lib/tiny_tds/result.rb
+- lib/tiny_tds.rb
+has_rdoc: true
+homepage: http://github.com/rails-sqlserver/tiny_tds
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: TinyTds - A modern, simple and fast FreeTDS library for Ruby using DB-Library.
+test_files: []
+