mssqlclient 0.1.0

data/CHANGELOG

@@ -0,0 +1,2 @@
+-- 0.1.0:
+* Initial Gem Release

data/RAKEFILE

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'rake'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'pscp'
+
+PACKAGE_VERSION = '0.1.0'
+
+PACKAGE_FILES = FileList[
+  'README',
+  'CHANGELOG',
+  'RAKEFILE',
+  'lib/**/*.{rb,dll}',
+  'test/*.rb',
+  'src/*.{cpp,h,ico,rc,sln,vcproj}'
+].to_a
+
+PROJECT = 'mssqlclient'
+
+ENV['RUBYFORGE_USER'] = "ssmoot@rubyforge.org"
+ENV['RUBYFORGE_PROJECT'] = "/var/www/gforge-projects/#{PROJECT}"
+
+task :default => [:rdoc]
+
+desc 'Generate Documentation'
+rd = Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = "MsSqlClient -- A native Win32/ADO.NET ActiveRecord Adapter for Microsoft's SQL Server"
+  rdoc.options << '--line-numbers' << '--inline-source' << '--main' << 'README'
+  rdoc.rdoc_files.include(PACKAGE_FILES)
+end
+
+gem_spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = PROJECT
+  s.summary = "A native Win32/ADO.NET ActiveRecord Adapter for Microsoft's SQL Server"
+  s.description = "A faster, better way to integrate ActiveRecord with MS SQL Server"
+  s.version = PACKAGE_VERSION
+  
+  s.authors = 'Sam Smoot', 'Scott Bauer'
+  s.email = 'ssmoot@gmail.com; bauer.mail@gmail.com'
+  s.rubyforge_project = PROJECT
+  s.homepage = 'http://substantiality.net'
+  
+  s.files = PACKAGE_FILES
+  
+  s.require_path = 'lib'
+  s.requirements << 'active_record'
+  s.autorequire = 'mssqlclient_adapter'
+  
+  s.has_rdoc = true
+  s.rdoc_options << '--line-numbers' << '--inline-source' << '--main' << 'README'
+  s.extra_rdoc_files = rd.rdoc_files.reject { |fn| fn =~ /\.rb$/ }.to_a
+end
+
+Rake::GemPackageTask.new(gem_spec) do |p|
+  p.gem_spec = gem_spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+desc "Publish RDOC to RubyForge"
+task :rubyforge => [:rdoc, :gem] do
+  Rake::SshDirPublisher.new(ENV['RUBYFORGE_USER'], ENV['RUBYFORGE_PROJECT'], 'doc').upload
+end

data/README

@@ -0,0 +1 @@
+This is the README! Interesting!

data/lib/column_with_identity_and_ordinal.rb

@@ -0,0 +1,92 @@
+module ActiveRecord
+	module ConnectionAdapters
+		class ColumnWithIdentityAndOrdinal < Column# :nodoc:
+      attr_reader :identity, :is_special, :scale
+
+      def initialize(name, default, sql_type = nil, is_identity = false, null = true, scale_value = 0, ordinal = 0)
+        super(name, default, sql_type, null)
+        @identity = is_identity
+        @is_special = sql_type =~ /text|ntext|image/i ? true : false
+        @scale = scale_value
+        # SQL Server only supports limits on *char and float types
+        @limit = nil unless @type == :float or @type == :string
+				@ordinal = ordinal
+      end
+
+      def simplified_type(field_type)
+        case field_type
+          when /int|bigint|smallint|tinyint/i                        then :integer
+          when /float|double|decimal|money|numeric|real|smallmoney/i then @scale == 0 ? :integer : :float
+          when /datetime|smalldatetime/i                             then :datetime
+          when /timestamp/i                                          then :timestamp
+          when /time/i                                               then :time
+          when /text|ntext/i                                         then :text
+          when /binary|image|varbinary/i                             then :binary
+          when /char|nchar|nvarchar|string|varchar/i                 then :string
+          when /bit/i                                                then :boolean
+          when /uniqueidentifier/i                                   then :string
+        end
+      end
+
+      def type_cast(value)
+        return nil if value.nil? || value =~ /^\s*null\s*$/i
+        case type
+        when :string    then value
+        when :integer   then value == true || value == false ? value == true ? 1 : 0 : value.to_i
+        when :float     then value.to_f
+        when :datetime  then cast_to_datetime(value)
+        when :timestamp then cast_to_time(value)
+        when :time      then cast_to_time(value)
+        when :date      then cast_to_datetime(value)
+        when :boolean   then value == true or (value =~ /^t(rue)?$/i) == 0 or value.to_s == '1'
+        else value
+        end
+      end
+
+      def cast_to_time(value)
+        return value if value.is_a?(Time)
+        time_array = ParseDate.parsedate(value)
+        time_array[0] ||= 2000
+        time_array[1] ||= 1
+        time_array[2] ||= 1
+        Time.send(Base.default_timezone, *time_array) rescue nil
+      end
+
+      def cast_to_datetime(value)
+        if value.is_a?(Time)
+          if value.year != 0 and value.month != 0 and value.day != 0
+            return value
+          else
+            return Time.mktime(2000, 1, 1, value.hour, value.min, value.sec) rescue nil
+          end
+        end
+        return cast_to_time(value) if value.is_a?(Date) or value.is_a?(String) rescue nil
+        value
+      end
+
+      # These methods will only allow the adapter to insert binary data with a length of 7K or less
+      # because of a SQL Server statement length policy.
+      def self.string_to_binary(value)
+        value.gsub(/(\r|\n|\0|\x1a)/) do
+          case $1
+            when "\r"   then  "%00"
+            when "\n"   then  "%01"
+            when "\0"   then  "%02"
+            when "\x1a" then  "%03"
+          end
+        end
+      end
+
+      def self.binary_to_string(value)
+        value.gsub(/(%00|%01|%02|%03)/) do
+          case $1
+            when "%00"    then  "\r"
+            when "%01"    then  "\n"
+            when "%02\0"  then  "\0"
+            when "%03"    then  "\x1a"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mssqlclient.rb

@@ -0,0 +1 @@
+require 'mssqlclient_adapter'

data/lib/mssqlclient_adapter.rb

@@ -0,0 +1,391 @@
+require 'active_record' # 'active_record/connection_adapters/abstract_adapter'
+RAILS_CONNECTION_ADAPTERS << 'mssqlclient'
+
+require 'bigdecimal'
+require 'ms_sql_client'
+require 'column_with_identity_and_ordinal'
+
+module ActiveRecord
+  class Base
+    def self.mssqlclient_connection(config) #:nodoc:
+      ConnectionAdapters::MsSqlClientAdapter.new(logger, config.symbolize_keys)
+		end
+  end # class Base
+
+  module ConnectionAdapters
+    class MsSqlClientAdapter < AbstractAdapter
+    
+			include MsSqlClient
+
+      def initialize(logger, connection_options = nil)
+        @connection_options, @logger = connection_options, logger
+				@connection = self
+        @runtime = @last_verification = 0
+				@active = true
+				@connection_options[:schema] ||= 'dbo'				
+      end
+
+			def connection_string
+				if @connection_options[:trusted]
+					"Server=#{@connection_options[:host]};Database=#{@connection_options[:database]};Trusted_Connection=True;"
+				elsif @connection_options[:connection_string]
+					@connection_options[:connection_string]
+				else
+					"Data Source=#{@connection_options[:host]};Initial Catalog=#{@connection_options[:database]};User Id=#{@connection_options[:username]};Password=#{@connection_options[:password]};";
+				end
+			end
+
+      def native_database_types
+        {
+          :primary_key => "int NOT NULL IDENTITY(1, 1) PRIMARY KEY",
+          :string      => { :name => "varchar", :limit => 255  },
+          :text        => { :name => "text" },
+          :integer     => { :name => "int" },
+          :float       => { :name => "float", :limit => 8 },
+          :datetime    => { :name => "datetime" },
+          :timestamp   => { :name => "datetime" },
+          :time        => { :name => "datetime" },
+          :date        => { :name => "datetime" },
+          :binary      => { :name => "image"},
+          :boolean     => { :name => "bit"}
+        }
+      end
+
+      def adapter_name
+        'MsSqlClient'
+      end
+      
+      def supports_migrations? #:nodoc:
+        true				
+      end
+
+      # CONNECTION MANAGEMENT ====================================#
+
+			def verify!(timeout)
+        @last_verification = Time.now.to_i
+      end
+
+      # Returns true if the connection is active.
+      def active?
+        @active
+      end
+
+      # Reconnects to the database, returns false if no connection could be made.
+      def reconnect!
+				@active = true
+      end
+      
+      # Disconnects from the database
+      
+      def disconnect!
+				@active = false
+				true
+      end
+
+			def select_all(sql, name=nil)
+				select(sql)
+			end
+			
+			#alias_method :select_all, :select
+
+      def select_one(sql, name = nil)
+        add_limit!(sql, :limit => 1)
+        result = select(sql, name)
+        result.nil? ? nil : result.first
+      end
+
+      def columns(table_name, name = nil)
+        return [] if table_name.blank?
+        table_name = table_name.to_s if table_name.is_a?(Symbol)
+        table_name = table_name.split('.')[-1] unless table_name.nil?
+        sql = "SELECT COLUMN_NAME as ColName, COLUMN_DEFAULT as DefaultValue, DATA_TYPE as ColType, IS_NULLABLE as IsNullable, COL_LENGTH('#{table_name}', COLUMN_NAME) as Length, COLUMNPROPERTY(OBJECT_ID('#{table_name}'), COLUMN_NAME, 'IsIdentity') as IsIdentity, NUMERIC_SCALE as Scale FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = '#{table_name}' AND TABLE_SCHEMA = '#{@connection_options[:schema]}'"
+				# puts sql
+				# Comment out if you want to have the Columns select statment logged.
+        # Personnally, I think it adds unneccessary bloat to the log. 
+        # If you do comment it out, make sure to un-comment the "result" line that follows
+        result = log(sql, name) { _select(sql) }
+        #result = @connection.select_all(sql)
+        columns = []
+        result.each { |field| field.symbolize_keys!; columns << ColumnWithIdentityAndOrdinal.new(field[:ColName], field[:DefaultValue].to_s.gsub!(/[()\']/,"") =~ /null/ ? nil : field[:DefaultValue], "#{field[:ColType]}(#{field[:Length]})", field[:IsIdentity] == 1 ? true : false, field[:IsNullable] == 'YES', field[:Scale], field[:Ordinal]) }
+				# puts columns.inspect
+        columns
+      end
+
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+				table_name = get_table_name(sql)
+				col = get_identity_column(table_name)
+				ii_enabled = false
+
+				if col != nil
+					if query_contains_identity_column(sql, col)
+							sql = wrap_identity_insert(table_name, sql)
+					end
+				end
+
+				log(sql, name) do
+					new_id = _insert(sql)
+					id_value || new_id
+				end
+      end
+
+      def execute(sql, name = nil)
+        if sql =~ /^\s*INSERT/i
+          insert(sql, name)
+        else
+					# puts "About to execute"
+					# sleep 1
+          log(sql, name) { _execute(sql) }
+        end
+      end
+
+      def update(sql, name = nil)
+        execute(sql, name)
+      end
+      alias_method :delete, :update
+
+      def quote(value, column = nil)
+        case value
+          when String
+            if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
+              "'#{quote_string(column.class.string_to_binary(value))}'"
+            else
+              "N'#{quote_string(value)}'"
+            end
+          when NilClass              then "NULL"
+          when TrueClass             then '1'
+          when FalseClass            then '0'
+          when Float, Fixnum, Bignum then value.to_s
+          when Date                  then "'#{value.to_s}'" 
+          when Time, DateTime        then "'#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
+          else                            "'#{quote_string(value.to_yaml)}'"
+        end
+      end
+
+      def quote_string(string)
+        string.gsub(/\'/, "''")
+      end
+
+      def quoted_true
+        "1"
+      end
+      
+      def quoted_false
+        "0"
+      end
+
+      def quote_column_name(name)
+        "[#{name}]"
+      end
+
+      def add_limit_offset!(sql, options)
+				# STDOUT << "\n\nadd_limit_offset options = #{options.inspect}\n\n"
+				# STDOUT << "add_limit_offset sql = #{sql}\n\n"
+
+        if options[:limit] and options[:offset]
+					sub_query = sql.gsub /\bSELECT\b(\s*DISTINCT)?/i do
+						"SELECT #{$1} TOP 1000000000"
+					end
+
+          total_rows = select("SELECT count(*) as TotalRows from (#{sub_query}) tally")[0]['TotalRows'].to_i
+					
+          if (options[:limit] + options[:offset]) >= total_rows
+            options[:limit] = (total_rows - options[:offset] >= 0) ? (total_rows - options[:offset]) : 0
+          end
+          sql.sub!(/^\s*SELECT/i, "SELECT * FROM (SELECT TOP #{options[:limit]} * FROM (SELECT TOP #{options[:limit] + options[:offset]} ")
+          sql << ") AS tmp1"
+
+					# (SELECT TOP 0 * FROM (SELECT TOP 10  DISTINCT posts.id
+
+					sql.sub! /\(SELECT\sTOP\s(\d+)\s+DISTINCT/ do
+						"(SELECT DISTINCT TOP #{$1} "
+					end
+
+          if options[:order]
+            options[:order] = options[:order].split(',').map do |field|
+              parts = field.split(" ")
+              tc = parts[0]
+              if sql =~ /\.\[/ and tc =~ /\./ # if column quoting used in query
+                tc.gsub!(/\./, '\\.\\[')
+                tc << '\\]'
+              end
+              if sql =~ /#{tc} AS (t\d_r\d\d?)/
+                  parts[0] = $1
+              end
+              parts.join(' ')
+            end.join(', ')
+            sql << " ORDER BY #{change_order_direction(options[:order])}) AS tmp2 ORDER BY #{options[:order]}"
+          else
+            sql << " ) AS tmp2"
+          end
+        elsif sql !~ /^\s*SELECT (@@|COUNT\()/i
+          sql.sub!(/^\s*SELECT([\s]*distinct)?/i) do
+            "SELECT#{$1} TOP #{options[:limit]}"
+          end unless options[:limit].nil?
+        end
+      end
+
+      def recreate_database(name)
+        drop_database(name)
+        create_database(name)
+      end
+
+      def drop_database(name)
+        execute "DROP DATABASE #{name}"
+      end
+
+      def create_database(name)
+        execute "CREATE DATABASE #{name}"
+      end
+   
+      def current_database
+        @connection.select_one("select DB_NAME() as [Name]")['Name']
+      end
+
+      def tables(name = nil)
+				results = select("SELECT table_name from information_schema.tables WHERE table_type = 'BASE TABLE'", name)				
+
+        results.inject([]) do |tables, field|
+          table_name = field['table_name']
+          tables << table_name unless table_name == 'dtproperties'
+          tables
+        end
+      end
+
+      def indexes(table_name, name = nil)
+        indexes = []
+        select("EXEC sp_helpindex #{table_name}", name).each do |index| 
+          unique = index['index_description'] =~ /unique/
+          primary = index['index_description'] =~ /primary key/
+          if !primary
+            indexes << IndexDefinition.new(table_name, index['index_name'], unique, index['index_keys'].split(", "))
+          end
+        end
+        indexes
+      end
+            
+      def rename_table(name, new_name)
+        execute "EXEC sp_rename '#{name}', '#{new_name}'"
+      end
+      
+      def remove_column(table_name, column_name)
+        execute "ALTER TABLE #{table_name} DROP COLUMN #{column_name}"
+      end 
+      
+      def rename_column(table, column, new_column_name)
+        execute "EXEC sp_rename '#{table}.#{column}', '#{new_column_name}'"
+      end
+      
+      def change_column(table_name, column_name, type, options = {}) #:nodoc:
+        sql_commands = ["ALTER TABLE #{table_name} ALTER COLUMN #{column_name} #{type_to_sql(type, options[:limit])}"]
+        if options[:default]
+          remove_default_constraint(table_name, column_name)
+          sql_commands << "ALTER TABLE #{table_name} ADD CONSTRAINT DF_#{table_name}_#{column_name} DEFAULT #{options[:default]} FOR #{column_name}"
+        end
+        sql_commands.each {|c|
+          execute(c)
+        }
+      end
+      
+      def remove_column(table_name, column_name)
+        remove_default_constraint(table_name, column_name)
+        execute "ALTER TABLE #{table_name} DROP COLUMN #{column_name}"
+      end
+      
+      def remove_default_constraint(table_name, column_name)
+        defaults = select "select def.name from sysobjects def, syscolumns col, sysobjects tab where col.cdefault = def.id and col.name = '#{column_name}' and tab.name = '#{table_name}' and col.id = tab.id"
+        defaults.each {|constraint|
+          execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint["name"]}"
+        }
+      end
+      
+      def remove_index(table_name, options = {})
+        execute "DROP INDEX #{table_name}.[#{index_name(table_name, options)}]"
+      end
+
+      def type_to_sql(type, limit = nil) #:nodoc:
+        native = native_database_types[type]
+        # if there's no :limit in the default type definition, assume that type doesn't support limits
+        limit = limit || native[:limit]
+        column_type_sql = native[:name]
+        column_type_sql << "(#{limit})" if limit
+        column_type_sql
+      end
+
+      private
+        def select(sql, name = nil)
+          repair_special_columns(sql)					
+          log(sql, name) do						
+            _select(sql)
+					end
+        end
+
+        def wrap_identity_insert(table_name, sql)
+          if has_identity_column(table_name)
+						<<-SQL
+            SET IDENTITY_INSERT #{table_name} ON
+						#{sql}
+						SET IDENTITY_INSERT #{table_name} OFF
+						SQL
+          end
+        end
+
+        def get_table_name(sql)
+          if sql =~ /^\s*insert\s+into\s+([^\(\s]+)\s*|^\s*update\s+([^\(\s]+)\s*/i
+            $1
+          elsif sql =~ /from\s+([^\(\s]+)\s*/i
+            $1
+          else
+            nil
+          end
+        end
+
+        def has_identity_column(table_name)
+          !get_identity_column(table_name).nil?
+        end
+
+        def get_identity_column(table_name)
+          @table_columns = {} unless @table_columns
+          @table_columns[table_name] = columns(table_name) if @table_columns[table_name] == nil
+          @table_columns[table_name].each do |col|
+            return col.name if col.identity
+          end
+
+          return nil
+        end
+
+        def query_contains_identity_column(sql, col)
+          sql =~ /\[#{col}\]/
+        end
+
+        def change_order_direction(order)
+          order.split(",").collect {|fragment|
+            case fragment
+              when  /\bDESC\b/i     then fragment.gsub(/\bDESC\b/i, "ASC")
+              when  /\bASC\b/i      then fragment.gsub(/\bASC\b/i, "DESC")
+              else                  String.new(fragment).split(',').join(' DESC,') + ' DESC'
+            end
+          }.join(",")
+        end
+
+        def get_special_columns(table_name)
+          special = []
+          @table_columns ||= {}
+          @table_columns[table_name] ||= columns(table_name)
+          @table_columns[table_name].each do |col|
+            special << col.name if col.is_special
+          end
+          special
+        end
+
+        def repair_special_columns(sql)
+          special_cols = get_special_columns(get_table_name(sql))
+          for col in special_cols.to_a
+            sql.gsub!(Regexp.new(" #{col.to_s} = "), " #{col.to_s} LIKE ")
+            sql.gsub!(/ORDER BY #{col.to_s}/i, '')
+          end
+          sql
+        end
+
+    end #class MsSqlClientAdapter < AbstractAdapter
+  end #module ConnectionAdapters
+end #module ActiveRecord