ironruby-dbi 0.1.0

data/History.txt

@@ -0,0 +1,3 @@
+=== 0.1.0 / 2010-01-13
+
+* First gem

data/Manifest.txt

@@ -0,0 +1,34 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/dbd/mssql.rb
+lib/dbd/mssql/database.rb
+lib/dbd/mssql/driver.rb
+lib/dbd/mssql/statement.rb
+lib/dbd/mssql/types.rb
+lib/dbi.rb
+lib/dbi/base_classes.rb
+lib/dbi/base_classes/database.rb
+lib/dbi/base_classes/driver.rb
+lib/dbi/base_classes/statement.rb
+lib/dbi/binary.rb
+lib/dbi/columninfo.rb
+lib/dbi/exceptions.rb
+lib/dbi/handles.rb
+lib/dbi/handles/database.rb
+lib/dbi/handles/driver.rb
+lib/dbi/handles/statement.rb
+lib/dbi/row.rb
+lib/dbi/sql.rb
+lib/dbi/sql/preparedstatement.rb
+lib/dbi/sql_type_constants.rb
+lib/dbi/trace.rb
+lib/dbi/types.rb
+lib/dbi/typeutil.rb
+lib/dbi/utils.rb
+lib/dbi/utils/date.rb
+lib/dbi/utils/tableformatter.rb
+lib/dbi/utils/time.rb
+lib/dbi/utils/timestamp.rb
+lib/dbi/utils/xmlformatter.rb

data/README.txt

@@ -0,0 +1,21 @@
+= IronRuby DBI 
+
+* http://github.com/casualjim/jschementi
+
+== DESCRIPTION:
+
+ADO.NET compatible DBD extension to ruby-dbo
+
+== INSTALL:
+
+* gem install ironruby-dbi
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'hoe'
+
+$:.unshift 'lib'
+require 'dbd/mssql'
+
+Hoe.spec 'ironruby-dbi' do
+  developer 'Ivan Porto Carrero', 'ivan@flanders.co.nz'
+  self.version = DBI::DBD::MSSQL::VERSION
+  self.url = 'http://github.com/casualjim/ironruby-dbi'
+  extra_deps << ['deprecated', '>=2.0.1']
+end
+
+desc "Tests the dbd driver for adonet"
+task :test_dbd do
+    ruby("test/ts_dbd.rb")
+end
+
+task :test => [:test_dbd]
+
+task :default => :test
+

data/lib/dbd/mssql.rb

@@ -0,0 +1,191 @@
+require 'dbi'
+
+module DBI
+  module DBD
+
+
+
+    module MSSQL
+
+      VERSION          = "0.1.0"
+      USED_DBD_VERSION = "0.4.0"
+      DESCRIPTION      = "ADO.NET 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 ::DBI::Timestamp, ::Numeric, ::DBI::Binary
+                    obj.to_s
+                  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 ::String, System::String
+                    obj
+                  when ::TrueClass
+                    "1"
+                  when ::FalseClass
+                    "0"
+                  when ::BigDecimal
+                    obj.to_s("F")
+                  when ::Numeric
+                    obj.to_s
+                  else
+                    obj
+                end
+
+        if newobj.object_id == obj.object_id and not (obj.is_a?(::String) || obj.is_a?(System::String))
+          [newobj, true]
+        else
+          [newobj, false]
+        end
+      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,148 @@
+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)
+          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={})
+          st = prepare(stmt)
+          bindvars.each { |k, v| st.bind_param(k, v) }
+          res = st.execute
+          st.finish
+          return res
+        rescue RuntimeError, System::Data::SqlClient::SqlException => err
+          raise DBI::DatabaseError.new(err.message)
+        ensure
+          st.finish if st
+        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,31 @@
+module DBI
+  module DBD
+    module MSSQL
+
+      class Driver < DBI::BaseDriver
+                
+        PROVIDER_KEY = :mssql
+
+        def initialize
+          super(USED_DBD_VERSION, PROVIDER_KEY)
+        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