dbd-adonet-sqlserver 0.3.2

data/README.rdoc

@@ -0,0 +1,49 @@
+= IronRuby DBI - Easing data access for ironruby
+
+* http://github.com/casualjim/ironruby-dbi
+
+== DESCRIPTION:
+
+This project aims to provide adapters based on the .NET System.Data infrastructure.
+It does so to make using existing ruby OR/M solutions easier to integrate.
+
+== FEATURES/PROBLEMS:
+
+
+
+== SYNOPSIS:
+
+    
+
+
+== REQUIREMENTS:
+
+* To use the caricature library you need to have uuidtools installed
+(sudo) gem install uuidtools
+(sudo) igem install uuidtools
+
+== INSTALL:
+
+(sudo) igem install ironruby-dbi
+
+== LICENSE:
+
+Copyright (c) 2009 IronRuby-DBI team
+
+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/Rakefile

@@ -0,0 +1,88 @@
+require 'rubygems'
+require 'fileutils'
+require 'rake'
+require 'rake/rdoctask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ironnails"
+    gem.summary = %Q{IronNails brings rails like development to IronRuby and WPF}
+    gem.description = %Q{IronNails is a framework inspired by the Rails and rucola frameworks. It offers a rails-like way of developing
+applications with IronRuby and Windows Presentation Foundation (WPF).}
+    gem.email = "ivan@flanders.co.nz"
+    gem.homepage = "http://github.com/casualjim/ironnails"
+    gem.authors = ["Ivan Porto Carrero"]
+    gem.add_runtime_dependency     "thor",          ">= 0.11.8"
+    gem.add_runtime_dependency     "activesupport", ">= 2.3.5"
+    gem.add_runtime_dependency     "bundler",       ">= 0.9.2"
+    gem.add_development_dependency "rspec", ">= 0"
+    gem.files = FileList["[A-Z]*", "{lib}/**/*"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+##############################################################################
+# OPTIONS
+##############################################################################
+
+PKG_NAME      = 'ironruby-dbi'
+PKG_VERSION   = "0.2.5"
+AUTHORS       = ['Ivan Porto Carrero']
+EMAIL         = "ivan@flanders.co.nz"
+HOMEPAGE      = "http://casualjim.github.com/ironruby-dbi"
+SUMMARY       = "A DBI implementation for .NET based drivers."
+
+# These are the common rdoc options that are shared between generation of
+# rdoc files using BOTH 'rake rdoc' and the installation by users of a
+# RubyGem version which builds rdoc's along with its installation.  Any
+# rdoc options that are ONLY for developers running 'rake rdoc' should be
+# added in the 'Rake::RDocTask' block below.
+RDOC_OPTIONS  = [
+                "--quiet",
+                "--title", SUMMARY,
+                "--main", "README.rdoc"
+                ]
+
+# Extra files outside of the lib dir that should be included with the rdocs.
+RDOC_FILES    = (%w( README.rdoc)).sort
+
+# The full file list used for rdocs, tarballs, gems, and for generating the xmpp4r.gemspec.
+PKG_FILES     = (%w( Rakefile ironruby-dbi.gemspec ) + RDOC_FILES + Dir["{lib,spec}/**/*"]).sort
+
+# RDOC
+#######
+Rake::RDocTask.new do |rd|
+
+  # which dir should rdoc files be installed in?
+  rd.rdoc_dir = 'rdoc'
+
+  # the full list of files to be included
+  rd.rdoc_files.include(RDOC_FILES, "lib/**/*.rb")
+
+  # the full list of options that are common between gem build
+  # and 'rake rdoc' build of docs.
+  rd.options = RDOC_OPTIONS
+
+  # Devs Only : Uncomment to also document private methods in the rdocs
+  # Please don't check this change in to the source repo.
+  #rd.options << '--all'
+
+  # Devs Only : Uncomment to generate dot (graphviz) diagrams along with rdocs.
+  # This requires that graphiz (dot) be installed as a local binary and on your path.
+  # See : http://www.graphviz.org/
+  # Please don't check this change in to the source repo as it introduces a binary dependency.
+  #rd.options << '--diagram'
+  #rd.options << '--fileboxes'
+
+end
+
+
+
+
+task :test => [:test_dbd]
+
+task :default => :test

data/dbd-adonet-sqlserver.gemspec

@@ -0,0 +1,32 @@
+# WARNING : RAKE AUTO-GENERATED FILE.  DO NOT MANUALLY EDIT!
+# RUN : 'rake gem:update_gemspec'
+
+Gem::Specification.new do |s|
+  s.authors = ["Ivan Porto Carrero"]
+  s.description = "A DBD implementation for .NET access to sqlserver."
+  s.email = "ivan@flanders.co.nz"
+  s.extra_rdoc_files = ["README.rdoc"]
+  s.files = ["README.rdoc",
+ "Rakefile",
+ "dbd-adonet-sqlserver.gemspec",
+ "lib/dbd/mssql.rb",
+ "lib/dbd/mssql/database.rb",
+ "lib/dbd/mssql/driver.rb",
+ "lib/dbd/mssql/statement.rb",
+ "lib/dbd/mssql/types.rb"]
+  s.has_rdoc = true
+  s.homepage = "http://casualjim.github.com/ironruby-dbi"
+  s.loaded = false
+  s.name = "dbd-adonet-sqlserver"
+  s.platform = "ruby"
+  s.rdoc_options = ["--quiet", "--title", "A DBD implementation for .NET access to sqlserver.", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.required_ruby_version = ">= 1.8.4"
+  s.required_rubygems_version = ">= 0"
+  s.rubyforge_project = "dbd-adonet-sqlserver"
+  s.rubygems_version = "1.3.5"
+  s.add_runtime_dependency "dbd-adonet", "= 0.3.2"
+  s.specification_version = 3
+  s.summary = "A DBD implementation for .NET access to sqlserver."
+  s.version = "0.3.2"
+end

data/lib/dbd/mssql.rb

@@ -0,0 +1,185 @@
+require 'rubygems' unless defined? Gem
+
+require 'dbd/adonet'
+require 'dbd/adonet/prepared_statement'
+
+module DBI
+  module DBD
+
+
+
+    module MSSQL
+
+      VERSION          = "0.3"
+      DESCRIPTION      = "ADO.NET Microsoft SQL Server DBI DBD"
+
+      require File.dirname(__FILE__) + "/mssql/types"
+
+      # Hash to translate MS SQL Server type names to DBI SQL type constants
+      #
+      # Only used in #mssql_type_info.
+      #
+      MSSQL_TO_XOPEN = {
+              "TINYINT"          => [DBI::SQL_TINYINT, 1, nil],
+              "SMALLINT"         => [DBI::SQL_SMALLINT, 2, nil],
+              "INT"              => [DBI::SQL_INTEGER, 4, nil],
+              "INTEGER"          => [DBI::SQL_INTEGER, 4, nil],
+              "BIGINT"           => [DBI::SQL_BIGINT, 8, nil],
+              "REAL"             => [DBI::SQL_REAL, 24, nil],
+              "FLOAT"            => [DBI::SQL_FLOAT, 12, nil],
+              "DECIMAL"          => [DBI::SQL_DECIMAL, 18, nil],
+              "NUMERIC"          => [DBI::SQL_DECIMAL, 18, nil],
+              "MONEY"            => [DBI::SQL_DECIMAL, 8, 4],
+              "SMALLMONEY"       => [DBI::SQL_DECIMAL, 4, 4],
+              "DATE"             => [DBI::SQL_DATE, 10, nil],
+              "TIME"             => [DBI::SQL_TIME, 8, nil],
+              "DATETIME2"        => [DBI::SQL_TIMESTAMP, 19, nil],
+              "DATETIME"         => [DBI::SQL_TIMESTAMP, 19, nil],
+              "CHAR"             => [DBI::SQL_CHAR, 1, nil],
+              "VARCHAR"          => [DBI::SQL_VARCHAR, 255, nil],
+              "NCHAR"            => [DBI::SQL_CHAR, 1, nil],
+              "NVARCHAR"         => [DBI::SQL_VARCHAR, 255, nil],
+              "TEXT"             => [DBI::SQL_VARCHAR, 65535, nil],
+              "NTEXT"            => [DBI::SQL_VARCHAR, 131070, nil],
+              "BINARY"           => [DBI::SQL_VARBINARY, 65535, nil],
+              "VARBINARY"        => [DBI::SQL_VARBINARY, 16277215, nil],
+              "IMAGE"            => [DBI::SQL_LONGVARBINARY, 2147483657, nil],
+              "BIT"              => [DBI::SQL_BIT, 1, nil],
+              "UNIQUEIDENTIFIER" => [DBI::SQL_VARCHAR, 20, nil],
+              "XML"              => [DBI::SQL_VARCHAR, 65535, nil],
+              "TIMESTAMP"        => [DBI::SQL_VARCHAR, 18, nil],
+              nil                => [DBI::SQL_OTHER, nil, nil]
+      }
+
+      MSSQL_TYPEMAP = {
+              "TINYINT"          => DBI::Type::Integer,
+              "SMALLINT"         => DBI::Type::Integer,
+              "INT"              => DBI::Type::Integer,
+              "INTEGER"          => DBI::Type::Integer,
+              "BIGINT"           => DBI::Type::Integer,
+              "REAL"             => DBI::Type::Float,
+              "FLOAT"            => DBI::Type::Float,
+              "DECIMAL"          => DBI::DBD::MSSQL::Type::Decimal,
+              "NUMERIC"          => DBI::DBD::MSSQL::Type::Decimal,
+              "MONEY"            => DBI::DBD::MSSQL::Type::Decimal,
+              "SMALLMONEY"       => DBI::DBD::MSSQL::Type::Decimal,
+              "DATE"             => DBI::DBD::MSSQL::Type::Date,
+              "TIME"             => DBI::DBD::MSSQL::Type::Timestamp,
+              "DATETIME2"        => DBI::DBD::MSSQL::Type::Timestamp,
+              "DATETIME"         => DBI::DBD::MSSQL::Type::Timestamp,
+              "CHAR"             => DBI::Type::Varchar,
+              "VARCHAR"          => DBI::Type::Varchar,
+              "NCHAR"            => DBI::Type::Varchar,
+              "NVARCHAR"         => DBI::Type::Varchar,
+              "TEXT"             => DBI::Type::Varchar,
+              "NTEXT"            => DBI::Type::Varchar,
+              "BINARY"           => DBI::Type::Varchar,
+              "VARBINARY"        => DBI::Type::Varchar,
+              "IMAGE"            => DBI::Type::Varchar,
+              "BIT"              => DBI::Type::Boolean,
+              "UNIQUEIDENTIFIER" => DBI::Type::Varchar,
+              "XML"              => DBI::Type::Varchar,
+              "TIMESTAMP"        => DBI::Type::Varchar,
+              nil                => DBI::DBD::MSSQL::Type::Null,
+              System::DBNull     => DBI::DBD::MSSQL::Type::Null
+      }
+
+
+
+      def self.driver_name
+        "mssql"
+      end
+
+      DBI::TypeUtil.register_conversion(driver_name) do |obj|
+
+
+        newobj =
+                case obj
+                  when ::DateTime
+                    "#{obj.strftime("%Y-%m-%d %H:%M:%S")}"
+                  when ::Time
+                    "#{obj.strftime("%H:%M:%S")}"
+                  when ::Date
+                    "#{obj.strftime("%Y-%m-%d")}"
+                  when ::NilClass
+                    System::DBNull.value
+                  when ::TrueClass
+                    "1"
+                  when ::FalseClass
+                    "0"
+                  when ::BigDecimal
+                    obj.to_s("F")
+                  when ::Numeric, ::String, System::String, ::DBI::Timestamp, ::DBI::Binary
+                    obj.to_s
+                  else
+                    obj
+                end
+
+          [newobj, (newobj.object_id == obj.object_id and not (obj.is_a?(::String) || obj.is_a?(System::String)))]
+      end
+
+
+      CLR_TYPES = {
+              :TINYINT => "byte",
+              :SMALLINT => "short",
+              :BIGINT => "long",
+              :INT => "int",
+              :FLOAT => "double",
+              :REAL => "float",
+              :SMALLMONEY => "decimal",
+              :MONEY => "decimal",
+              :NUMERIC => "decimal",
+              :DECIMAL => "decimal",
+              :BIT => "bool",
+              :UNIQUEIDENTIFIER => "Guid",
+              :VARCHAR => "string",
+              :NVARCHAR => "string",
+              :TEXT => "string",
+              :NTEXT => "string",
+              :CHAR => "char",
+              :NCHAR => "char",
+              :VARBINARY => "byte[]",
+              :IMAGE => "byte[]",
+              :DATETIME => "DateTime"
+      }
+
+      SQL_TYPE_NAMES = {
+              :BIT => "BIT",
+              :TINYINT => "TINYINT",
+              :SMALLINT => "SMALLINT",
+              :INTEGER => "INTEGER",
+              :INT => "INTEGER",
+              :BIGINT => "BIGINT",
+              :FLOAT => "FLOAT",
+              :REAL => "REAL",
+              :DOUBLE => "DOUBLE",
+              :NUMERIC => "NUMERIC",
+              :DECIMAL => "DECIMAL",
+              :CHAR => "CHAR",
+              :NCHAR => "CHAR",
+              :VARCHAR => "VARCHAR",
+              :NVARCHAR => "VARCHAR",
+              :LONGVARCHAR => "LONG VARCHAR",
+              :TEXT => "LONG VARCHAR",
+              :NTEXT => "LONG VARCHAR",
+              :DATE => "DATE",
+              :DATETIME => "DATETIME",
+              :TIME => "TIME",
+              :TIMESTAMP => "TIMESTAMP",
+              :BINARY => "BINARY",
+              :VARBINARY => "VARBINARY",
+              :LONGVARBINARY => "LONG VARBINARY",
+              :IMAGE => "BLOB",
+              :BLOB => "BLOB",
+              :CLOB => "CLOB",
+              :OTHER => "",
+              :BOOLEAN => "BOOLEAN",
+              :UNIQUEIDENTIFIER => "VARCHAR"
+      }
+    end
+  end
+end
+
+require File.dirname(__FILE__) + "/mssql/driver"
+require File.dirname(__FILE__) + "/mssql/database"
+require File.dirname(__FILE__) + "/mssql/statement"

data/lib/dbd/mssql/database.rb

@@ -0,0 +1,142 @@
+module DBI
+  module DBD
+    module MSSQL
+       
+      class Database < DBI::BaseDatabase
+
+
+        def initialize(dbd_db, attr)
+          super
+          self['AutoCommit'] = true
+        end
+
+        def disconnect
+          unless @trans.nil?
+            @trans.rollback unless @attr['AutoCommit']
+            @trans = nil
+          end
+          @handle.close
+        rescue RuntimeError, System::Data::SqlClient::SqlException => err
+          raise DBI::DatabaseError.new(err.message)
+        end
+
+        def prepare(statement)
+          Statement.new(statement, self)
+        end
+
+        def ping
+          cmd = @handle.create_command
+          cmd.command_text = "Select 1"
+          begin
+            cmd.execute_non_query
+            return true
+          rescue
+            return false
+          end
+        rescue RuntimeError, System::Data::SqlClient::SqlException => err
+          raise DBI::DatabaseError.new(err.message)
+        end
+
+        def tables
+          @handle.get_schema("Tables").rows.collect { |row| row["TABLE_NAME"].to_s }
+        rescue RuntimeError, System::Data::SqlClient::SqlException => err
+          raise DBI::DatabaseError.new(err.message)
+        end
+
+        def current_transaction
+          @trans
+        end
+
+        def has_transaction?
+          !@trans.nil?
+        end
+
+        def columns(table)
+          sql = "select object_name(c.object_id) as table_name, c.column_id, c.name, type_name(system_type_id) as sql_type,
+              max_length, is_nullable, precision, scale, object_definition(c.default_object_id) as default_value,
+              convert(bit,(Select COUNT(*) from sys.indexes as i
+                inner join sys.index_columns as ic
+                  on ic.index_id = i.index_id and ic.object_id = i.object_id
+                inner join sys.columns as c2 on ic.column_id = c2.column_id and i.object_id = c2.object_id
+              WHERE i.is_primary_key = 1 and ic.column_id = c.column_id and i.object_id=c.object_id)) as is_primary_key,               
+              convert(bit,(Select COUNT(*) from sys.indexes as i
+                inner join sys.index_columns as ic
+                  on ic.index_id = i.index_id and ic.object_id = i.object_id
+                inner join sys.columns as c2 on ic.column_id = c2.column_id and i.object_id = c2.object_id
+              WHERE i.is_primary_key = 0
+                and i.is_unique_constraint = 0 and ic.column_id = c.column_id and i.object_id=c.object_id)) as is_index,
+              convert(bit,(Select Count(*) from sys.indexes as i inner join sys.index_columns as ic
+                  on ic.index_id = i.index_id and ic.object_id = i.object_id
+                inner join sys.columns as c2 on ic.column_id = c2.column_id and i.object_id = c2.object_id
+              WHERE (i.is_unique_constraint = 1) and ic.column_id = c.column_id and i.object_id=c.object_id)) as is_unique
+              from sys.columns as c
+              WHERE object_name(c.object_id) = @table_name
+              order by table_name"
+          stmt = prepare(sql)
+          stmt.bind_param("table_name", table.to_s.to_clr_string)
+          stmt.execute
+          ret = stmt.fetch_all.collect do |row|
+            dtn = row[3].upcase
+            ColumnInfo.new({
+                    'name' => row[2].to_s,
+                    'dbi_type' => MSSQL_TYPEMAP[dtn],
+                    'mssql_type_name' => dtn,
+                    'sql_type' =>MSSQL_TO_XOPEN[dtn][0],
+                    'type_name' => DBI::SQL_TYPE_NAMES[MSSQL_TO_XOPEN[dtn][0]],
+                    'precision' => row[6].zero? ? row[4] : row[6],
+                    'default' => row[8],
+                    'scale' => row[7],
+                    'nullable' => row[5],
+                    'primary' => row[9],
+                    'indexed' => row[10],
+                    'unique' => row[11]
+            })
+          end
+          stmt.finish
+          ret
+        end
+
+        def commit
+          unless @attr['AutoCommit']
+            @trans.commit if @trans
+            @trans = @handle.begin_transaction
+          end
+        rescue RuntimeError, System::Data::SqlClient::SqlException => err
+          raise DBI::DatabaseError.new(err.message)
+        end
+
+        def rollback
+          unless @attr['AutoCommit']
+            @trans.rollback if @trans
+            @trans = @handle.begin_transaction
+          end
+        rescue RuntimeError, System::Data::SqlClient::SqlException => err
+          raise DBI::DatabaseError.new(err.message)
+        end
+
+        def do(stmt, *bindvars)
+          super
+        rescue RuntimeError, System::Data::SqlClient::SqlException => err
+          raise DBI::DatabaseError.new(err.message)        
+        end
+
+        def current_connection
+          @handle
+        end
+
+        def []=(attr, value)
+          if attr == 'AutoCommit' and @attr[attr] != value
+            @trans.commit if @trans
+            unless value
+              @trans = @handle.begin_transaction unless @trans
+            else
+              @trans = nil
+            end
+          end
+          @attr[attr] = value
+        end
+
+      end # class Database
+    end
+  end
+end

data/lib/dbd/mssql/driver.rb

@@ -0,0 +1,41 @@
+module DBI
+  module DBD
+    module MSSQL
+
+      class Driver < DBI::DBD::BaseAdonetDriver
+                
+        PROVIDER_KEY = :mssql
+
+        def initialize
+          super(DBI::IRONRUBY::USES_DBD_VERSION, PROVIDER_KEY)
+        end
+
+        # Connect to the database. DBD Required.
+        def connect(db_args, user, auth, attr)
+          connection = factory.create_connection
+#          db_args = "#{db_args}; MultipleActiveResultSets=true;" unless db_args =~ /MultipleActiveResultSets/i
+          connection.connection_string = db_args
+          connection.open
+          return create_database(connection, attr);
+        rescue RuntimeError, System::Data::SqlClient::SqlException => err
+          raise DBI::DatabaseError.new(err.message)
+        end
+
+        def create_database(connection, attr)
+          Database.new(connection, attr)
+        end
+
+        private
+
+        def data_sources
+          conn = factory.create_connection
+          conn.open
+          ret = conn.get_schema("Databases").rows.collect { |db| db.to_s unless %w(master tempdb model msdb).include? db.to_s  }
+          conn.close
+          ret
+        end
+      end
+
+    end
+  end
+end

data/lib/dbd/mssql/statement.rb

@@ -0,0 +1,149 @@
+module DBI
+  module DBD
+    module MSSQL
+
+      class Statement < DBI::BaseStatement
+
+        def initialize(statement, db)
+          @connection = db.current_connection;
+          @command = @connection.create_command
+          @previous_statement = @connection.instance_variable_get :@current_statement
+          @connection.instance_variable_set :@current_statement, self
+          @statement = DBI::Adonet::PreparedStatement.new(db, statement.to_s).bind
+          @command.command_text = @statement.to_clr_string
+          @command.transaction = db.current_transaction if db.has_transaction?
+          @current_index = 0
+          @db = db
+        end
+
+        def bind_param(name, value, attribs={})
+          unless name.to_s.empty?
+            name = "p#{name}" if name.is_a? Numeric
+            parameter = @command.create_parameter
+            parm_name = name.to_s.to_clr_string
+            parameter.ParameterName = parm_name
+            val =  value.is_a?(String) ? value.to_clr_string : value #(value || System::DBNull.value)
+            parameter.Value = val
+            if @command.parameters.contains(parm_name)
+              @command.parameters[parm_name] = parameter
+            else
+              @command.parameters.add parameter
+            end                                            
+          end
+        end
+
+        def execute
+          @previous_statement.finish if @previous_statement
+          
+          @current_index = 0
+          @rows = []
+          @schema = nil
+          finish
+          @reader = @command.execute_reader
+          schema
+          unless SQL.query?(@statement.to_s)
+            do_finish true
+          end
+          @reader.records_affected
+        rescue RuntimeError, System::Data::SqlClient::SqlException => err
+          raise DBI::DatabaseError.new(err.message)
+        end
+
+        def fetch
+          if @reader and @reader.is_closed
+            if @pending_fetches
+              return @pending_fetches.shift
+            else
+              return nil
+            end
+          end
+          res = nil
+          if  @reader.read
+            res = read_row(@reader)
+          end
+          puts "result: #{res}, \nclass: #{res.class}" if $quoting_test
+          
+          res
+        rescue RuntimeError, System::Data::SqlClient::SqlException => err
+          raise DBI::DatabaseError.new(err.message)
+        end
+
+        def finish
+          do_finish false
+        end
+        
+        def do_finish(check_pending_fetches)
+          if @reader and not @reader.is_closed
+            if check_pending_fetches
+              @pending_fetches = []
+              while (res = fetch) != nil
+                @pending_fetches << res
+              end
+            else
+              @pending_fetches = nil
+            end
+          @reader.close
+        end
+          
+        rescue RuntimeError, System::Data::SqlClient::SqlException => err
+          raise DBI::DatabaseError.new(err.message)
+        end
+
+        def cancel
+          finish
+          @command.cancel
+        end
+
+        def schema
+          @schema ||= @reader.get_schema_table || System::Data::DataTable.new
+        end
+
+        def column_info
+          infos = schema.rows.collect do |row|
+            name = row["ColumnName"]
+            def_val_col = row.table.columns[name]
+            def_val = def_val_col.nil? ? nil : def_val_col.default_value
+            dtn = row["DataTypeName"].to_s.upcase
+            {
+
+                'name' => name.to_s,
+                'dbi_type' => MSSQL_TYPEMAP[dtn],
+                'mssql_type_name' => dtn,
+                'sql_type' =>MSSQL_TO_XOPEN[dtn][0],
+                'type_name' => DBI::SQL_TYPE_NAMES[MSSQL_TO_XOPEN[dtn][0]],
+                'precision' => %w(varchar nvarchar char nchar text ntext).include?(dtn.downcase) ? row["ColumnSize"] : row["NumericPrecision"],
+                'default' => def_val,
+                'scale' => %w(varchar nvarchar char nchar text ntext).include?(dtn.downcase) ? nil : row["NumericScale"]  ,
+                'nullable' => row["AllowDBNull"],
+                'primary' => schema.primary_key.select { |pk| pk.column_name == name }.size > 0,
+                'unique' => row["IsUnique"]
+            }
+          end 
+          infos
+        rescue RuntimeError, System::Data::SqlClient::SqlException => err
+          raise DBI::DatabaseError.new(err.message)
+        end
+
+        def rows
+          return 0 if @reader.nil?
+          res = @reader.records_affected
+          res == -1 ? 0 : res
+        end
+
+        private
+
+        def read_row(record)
+          (0...record.visible_field_count).collect do |i|
+            res = record.get_value(i)
+            if res.is_a?(System::String)
+              res.to_s
+            else
+               res.is_a?(System::DBNull) ? nil : res
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/dbd/mssql/types.rb

@@ -0,0 +1,70 @@
+module DBI::DBD::MSSQL::Type
+
+    #
+    # Represents a Decimal with real precision (BigDecimal). Falls back to
+    # Float.
+    #
+    class Decimal < DBI::Type::Float
+        def self.parse(obj)
+            BigDecimal.new(obj.to_s) rescue super
+        end
+    end
+
+    #
+    # Represents a SQL NULL.
+    #
+    class Null
+        def self.parse(obj)
+            return nil if obj.is_a?(System::DBNull) or obj.to_s.match(/^null$/i)
+            return obj
+        end
+    end
+
+    #
+    # Custom handling for TIMESTAMP and DATETIME types in MySQL. See DBI::Type
+    # for more information.
+    #
+    class Timestamp < DBI::Type::Timestamp
+
+            def self.parse(obj)
+                case obj
+                when ::DateTime
+                    return obj
+                when ::Date
+                    return create(obj.year, obj.month, obj.day, 0, 0, 0)
+                when ::Time
+                    return create(obj.year, obj.month, obj.day, obj.hour, obj.min, obj.sec, obj.usec, obj.utc_offset / 86400.0)
+                when ::System::DateTime
+                    return create(obj.year, obj.month, obj.day, obj.hour, obj.minute, obj.second, obj.millisecond)
+                else
+                    obj = super
+                    return obj unless obj
+                    return create(*parse_string(obj.to_s))   if obj.respond_to? :to_s
+                    return create(*parse_string(obj.to_str)) if obj.respond_to? :to_str
+                    return obj
+                end
+            end
+    end
+
+    #
+    # Custom handling for DATE types in MySQL. See DBI::Type for more
+    # information.
+    #
+    class Date < DBI::Type::Null
+        def self.parse(obj)
+            obj = super
+            return obj unless obj
+
+            case obj.class
+            when ::Date
+                return obj
+            when ::String
+                return ::Date.strptime(obj, "%Y-%m-%d")
+            else
+                return ::Date.parse(obj.to_s)   if obj.respond_to? :to_s
+                return ::Date.parse(obj.to_str) if obj.respond_to? :to_str
+                return obj
+            end
+        end
+    end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: dbd-adonet-sqlserver
+version: !ruby/object:Gem::Version 
+  version: 0.3.2
+platform: ruby
+authors: 
+- Ivan Porto Carrero
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-02 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dbd-adonet
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.3.2
+    version: 
+description: A DBD implementation for .NET access to sqlserver.
+email: ivan@flanders.co.nz
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- dbd-adonet-sqlserver.gemspec
+- lib/dbd/mssql.rb
+- lib/dbd/mssql/database.rb
+- lib/dbd/mssql/driver.rb
+- lib/dbd/mssql/statement.rb
+- lib/dbd/mssql/types.rb
+has_rdoc: true
+homepage: http://casualjim.github.com/ironruby-dbi
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --quiet
+- --title
+- A DBD implementation for .NET access to sqlserver.
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.4
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: dbd-adonet-sqlserver
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A DBD implementation for .NET access to sqlserver.
+test_files: []
+