rails-sqlserver-2000-2005-adapter 2.2.6 → 2.2.7

data/CHANGELOG

@@ -4,7 +4,19 @@ MASTER
 * 
 
 
-* 2.2.6 (January 8th, 2008)
+* 2.2.7 (January 9th, 2009)
+
+* Created a connection#execute_procedure method that takes can take any number of ruby objects as variables 
+  and quotes them according to the connection's rules. Also added an ActiveRecord::Base class level core 
+  extension that hooks into this. It also checks if the connection responds to #execute_procedure and if 
+  not returns an empty array. [Ken Collins]
+
+* Added a #enable_default_unicode_types class attribute access to make all new added or changed string types 
+  like :string/:text default to unicode/national data types. See the README for full details. Added a rake 
+  task that assists setting this to true when running tests.  [Ken Collins]
+
+
+* 2.2.6 (January 8th, 2009)
 
 * Introduced a bug in 2.2.5 in the #add_order! core ext for ActiveRecord. Fixed [Ken Collins]
 

data/README.rdoc

@@ -6,13 +6,14 @@ The SQL Server adapter for rails is back for ActiveRecord 2.2 and up! We are cur
 
 == What's New
 
+* An ActiveRecord::Base.execute_procedure method that can be used by classes.
 * Enabled support for DDL transactions.
 * Micro second support. Time#usec is automatically converted to SQL Server's 3.33 millisecond limitation.
 * Datetime data types before type casting are represented correctly. For example: 1998-01-01 23:59:59.997
 * Implementation for #disable_referential_integrity used by ActiveRecord's Fixtures class.
 * Pessimistic locking suppot. See the #add_lock! method for details.
 * Enabled #case_sensitive_equality_operator used by unique validations.
-* Unicode character support for nchar, nvarchar and ntext data types.
+* Unicode character support for nchar, nvarchar and ntext data types. Configuration option for defaulting all string data types to the unicode safe types.
 * View support for table names, identity inserts, and column defaults.
 
 ==== Date/Time Data Type Hinting
@@ -26,6 +27,12 @@ Both SQL Server 2000 and 2005 do not have native data types for just 'date' or '
 
 This implementation has some limitations. To date we can only coerce date/time types for models that conform to the expected ActiveRecord class to table naming convention. So a table of 'foo_bar_widgets' will look for coerced types in the FooBarWidget class if it exists.
 
+==== Executing Stored Procedures
+
+Every class that sub classes ActiveRecord::Base will now have an execute_procedure class method to use. This method takes the name of the stored procedure which can be a string or symbol and any number of variables to pass to the procedure. Arguments will automatically be quoted per the connection's standards as normal. For example.
+
+  Account.execute_procedure :update_totals, 'admin', nil, true
+
 ==== Native Data Type Support
 
 Currently the following custom data types have been tested for schema definitions.
@@ -51,16 +58,20 @@ For example:
 Manually creating a varchar(max) on SQL Server 2005 is not necessary since this is the default type created when specifying a :text field. As time goes on we will be testing other SQL Server specific data types are handled correctly when created in a migration.
 
 
-==== Native Text/Binary Data Type Accessor
+==== Native Text/String/Binary Data Type Accessor
 
 To pass the ActiveRecord tests we had to implement an class accessor for the native type created for :text columns. By default any :text column created by migrations will create these native types.
 
 * SQL Server 2000 is 'text'
 * SQL Server 2005 is 'varchar(max)'
 
-During testing this type is set to 'varchar(8000)' for both versions. The reason is that rails expects to be able to use SQL = operators on text data types and this is not possible with a native 'text' data type in SQL Server. The default 'varchar(max)' for SQL Server 2005 can be queried using the SQL = operator and has plenty of storage space which is why we made it the default for 2005. If for some reason you want to change the data type created during migrations for any SQL Server version, you can configure this line to your liking in a config/initializers file.
+During testing this type is set to 'varchar(8000)' for SQL Server 2000. The reason is that rails expects to be able to use SQL = operators on text data types and this is not possible with a native 'text' data type in SQL Server. The default 'varchar(max)' for SQL Server 2005 can be queried using the SQL = operator and has plenty of storage space which is why we made it the default for 2005. If for some reason you want to change the data type created during migrations for any SQL Server version, you can configure this line to your liking in a config/initializers file.
 
   ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type = 'varchar(8000)'
+  
+Also, there is a class attribute setter for the native string database type. This is the same for both SQL Server 2000 and 2005, 'varchar'. However in can be used instead of the #enable_default_unicode_types below for finer grain control over which types you want unicode safe when adding or changing the schema.
+
+  ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_string_database_type = 'nvarchar'
 
 By default any :binary column created by migrations will create these native types
 
@@ -68,6 +79,23 @@ By default any :binary column created by migrations will create these native typ
 * SQL Server 2005 is 'varbinary(max)'
 
 
+====  Setting Unicode Types As Default
+
+By default the adapter will use non-unicode safe data types for :string and :text types when DEFINING or CHANGING the schema. If you choose, you can set the following class attribute in a config/initializers file that will change this behavior. When set to true it has the equivalent meaning as the two lower items. These examples show detail level alternatives to achieve similar effects.
+  
+  ActiveRecord::ConnectionAdapters::SQLServerAdapter.enable_default_unicode_types = true
+  
+  # SQL Server 2000
+  ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type = 'ntext'
+  ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_string_database_type = 'nvarchar'
+  
+  # SQL Server 2005
+  ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type = 'nvarchar(max)'
+  ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_string_database_type = 'nvarchar'
+
+It is important to remember that unicode types in SQL Server have approximately half the storage capacity as their counter parts. So where a normal string would max out at (8000) a unicode string will top off at (4000).
+
+
 ====  Schema Information Logging
 
 By default all queries to the INFORMATION_SCHEMA table is silenced. If you think logging these queries are useful, you can enable it by adding this like to a config/initializers file.

data/Rakefile

@@ -27,6 +27,7 @@ task :recreate_databases => [:drop_databases, :create_databases]
 
 
 for adapter in %w( sqlserver sqlserver_odbc )
+  
   Rake::TestTask.new("test_#{adapter}") { |t|
     t.libs << "test" 
     t.libs << "test/connections/native_#{adapter}"
@@ -40,5 +41,12 @@ for adapter in %w( sqlserver sqlserver_odbc )
   namespace adapter do
     task :test => "test_#{adapter}"
   end
+  
 end
 
+desc 'Test with unicode types enabled.'
+Rake::TestTask.new(:test_unicode_types) do |t|
+  ENV['ENABLE_DEFAULT_UNICODE_TYPES'] = 'true'
+  test = Rake::Task['test_sqlserver_odbc']
+  test.invoke
+end

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -150,12 +150,13 @@ module ActiveRecord
     class SQLServerAdapter < AbstractAdapter
       
       ADAPTER_NAME            = 'SQLServer'.freeze
-      VERSION                 = '2.2.6'.freeze
+      VERSION                 = '2.2.7'.freeze
       DATABASE_VERSION_REGEXP = /Microsoft SQL Server\s+(\d{4})/
       SUPPORTED_VERSIONS      = [2000,2005].freeze
       LIMITABLE_TYPES         = ['string','integer','float','char','nchar','varchar','nvarchar'].freeze
       
-      cattr_accessor :native_text_database_type, :native_binary_database_type, :log_info_schema_queries
+      cattr_accessor :native_text_database_type, :native_binary_database_type, :native_string_database_type,
+                     :log_info_schema_queries, :enable_default_unicode_types
       
       class << self
         
@@ -216,12 +217,21 @@ module ActiveRecord
         "#<#{self.class} version: #{version}, year: #{database_year}, connection_options: #{@connection_options.inspect}>"
       end
       
+      def native_string_database_type
+        @@native_string_database_type || (enable_default_unicode_types ? 'nvarchar' : 'varchar') 
+      end
+      
       def native_text_database_type
-        self.class.native_text_database_type || (sqlserver_2005? ? 'varchar(max)' : 'text')
+        @@native_text_database_type || 
+        if sqlserver_2005?
+          enable_default_unicode_types ? 'nvarchar(max)' : 'varchar(max)'
+        else
+          enable_default_unicode_types ? 'ntext' : 'text'
+        end
       end
       
       def native_binary_database_type
-        self.class.native_binary_database_type || (sqlserver_2005? ? 'varbinary(max)' : 'image')
+        @@native_binary_database_type || (sqlserver_2005? ? 'varbinary(max)' : 'image')
       end
       
       # QUOTING ==================================================#
@@ -324,6 +334,15 @@ module ActiveRecord
         finish_statement_handle(handle)
       end
       
+      def execute_procedure(proc_name, *variables)
+        holders = (1..variables.size).to_a.map{|n|'?'}.join(', ')
+        statement = "EXEC #{proc_name} #{holders}".strip
+        sql = statement.gsub('?') { quote(variables.shift) }
+        select(sql,'PROCEDURE',true).inject([]) do |results,row|
+          results << row.with_indifferent_access
+        end
+      end
+      
       def begin_db_transaction
         do_execute "BEGIN TRANSACTION"
       end
@@ -426,8 +445,8 @@ module ActiveRecord
       def native_database_types
         {
           :primary_key  => "int NOT NULL IDENTITY(1, 1) PRIMARY KEY",
-          :string       => { :name => "varchar", :limit => 255  },
-          :text         => { :name =>  native_text_database_type },
+          :string       => { :name => native_string_database_type, :limit => 255  },
+          :text         => { :name => native_text_database_type },
           :integer      => { :name => "int", :limit => 4 },
           :float        => { :name => "float", :limit => 8 },
           :decimal      => { :name => "decimal" },
@@ -435,7 +454,7 @@ module ActiveRecord
           :timestamp    => { :name => "datetime" },
           :time         => { :name => "datetime" },
           :date         => { :name => "datetime" },
-          :binary       => { :name =>  native_binary_database_type },
+          :binary       => { :name => native_binary_database_type },
           :boolean      => { :name => "bit"},
           # These are custom types that may move somewhere else for good schema_dumper.rb hacking to output them.
           :char         => { :name => 'char' },

data/lib/core_ext/active_record.rb

@@ -12,6 +12,14 @@ module ActiveRecord
       
       module ClassMethods
         
+        def execute_procedure(proc_name, *variables)
+          if connection.respond_to?(:execute_procedure)
+            connection.execute_procedure(proc_name,*variables)
+          else
+            []
+          end
+        end
+        
         def coerce_sqlserver_date(*attributes)
           write_inheritable_attribute :coerced_sqlserver_date_columns, Set.new(attributes.map(&:to_s))
         end

data/test/cases/adapter_test_sqlserver.rb

@@ -194,6 +194,35 @@ class AdapterTestSqlserver < ActiveRecord::TestCase
 
     end
     
+    context 'testing #enable_default_unicode_types configuration' do
+
+      should 'use non-unicode types when set to false' do
+        with_enable_default_unicode_types(false) do
+          if sqlserver_2000?
+            assert_equal 'varchar', @connection.native_string_database_type
+            assert_equal 'text', @connection.native_text_database_type
+          elsif sqlserver_2005?
+            assert_equal 'varchar', @connection.native_string_database_type
+            assert_equal 'varchar(max)', @connection.native_text_database_type
+          end
+        end
+      end
+      
+      should 'use unicode types when set to true' do
+        with_enable_default_unicode_types(true) do
+          if sqlserver_2000?
+            assert_equal 'nvarchar', @connection.native_string_database_type
+            assert_equal 'ntext', @connection.native_text_database_type
+          elsif sqlserver_2005?
+            assert_equal 'nvarchar', @connection.native_string_database_type
+            assert_equal 'nvarchar(max)', @connection.native_text_database_type
+          end
+        end
+      end
+
+    end
+    
+    
   end
   
   context 'For chronic data types' do
@@ -530,6 +559,20 @@ class AdapterTestSqlserver < ActiveRecord::TestCase
     @connection.send :order_to_min_set, order
   end
   
+  def with_enable_default_unicode_types(setting)
+    old_setting = ActiveRecord::ConnectionAdapters::SQLServerAdapter.enable_default_unicode_types
+    old_text = ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type
+    old_string = ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_string_database_type
+    ActiveRecord::ConnectionAdapters::SQLServerAdapter.enable_default_unicode_types = setting
+    ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type = nil
+    ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_string_database_type = nil
+    yield
+  ensure
+    ActiveRecord::ConnectionAdapters::SQLServerAdapter.enable_default_unicode_types = old_setting
+    ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type = old_text
+    ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_string_database_type = old_string
+  end
+  
 end
 
 

data/test/cases/execute_procedure_test_sqlserver.rb

@@ -0,0 +1,33 @@
+require 'cases/sqlserver_helper'
+
+class ExecuteProcedureTestSqlserver < ActiveRecord::TestCase
+  
+  def setup
+    @klass = ActiveRecord::Base
+  end
+  
+  should 'execute a simple procedure' do
+    tables = @klass.execute_procedure :sp_tables
+    assert_instance_of Array, tables
+    assert_instance_of HashWithIndifferentAccess, tables.first
+  end
+  
+  should 'take parameter arguments' do
+    tables = @klass.execute_procedure :sp_tables, 'sql_server_chronics'
+    table_info = tables.first
+    assert_equal 1, tables.size
+    assert_equal 'activerecord_unittest', table_info[:TABLE_QUALIFIER], "Table Info: #{table_info.inspect}"
+    assert_equal 'TABLE', table_info[:TABLE_TYPE], "Table Info: #{table_info.inspect}"
+  end
+  
+  should 'quote bind vars correctly' do
+    assert_sql(/EXEC sp_tables '%sql_server%', NULL, NULL, NULL, 1/) do
+      @klass.execute_procedure :sp_tables, '%sql_server%', nil, nil, nil, true
+    end if sqlserver_2005?
+    assert_sql(/EXEC sp_tables '%sql_server%', NULL, NULL, NULL/) do
+      @klass.execute_procedure :sp_tables, '%sql_server%', nil, nil, nil
+    end if sqlserver_2000?
+  end
+  
+  
+end

data/test/cases/migration_test_sqlserver.rb

@@ -40,7 +40,6 @@ class MigrationTest < ActiveRecord::TestCase
   
   include SqlserverCoercedTest
   
-  
   def test_coerced_test_add_column_not_null_without_default
     Person.connection.create_table :testings do |t| 
       t.column :foo, :string
@@ -53,5 +52,42 @@ class MigrationTest < ActiveRecord::TestCase
     Person.connection.drop_table :testings rescue nil
   end
   
+end
+
+class ChangeTableMigrationsTest < ActiveRecord::TestCase
+  
+  COERCED_TESTS = [:test_string_creates_string_column]
+
+  include SqlserverCoercedTest
+  
+  def setup
+    @connection = Person.connection
+    @connection.create_table :delete_me, :force => true do |t|
+    end
+  end
+
+  def teardown
+    @connection.drop_table :delete_me rescue nil
+  end
+  
+  def test_coerced_string_creates_string_column
+    with_sqlserver_change_table do |t|
+      @connection.expects(:add_column).with(:delete_me, :foo, sqlserver_string_column, {})
+      @connection.expects(:add_column).with(:delete_me, :bar, sqlserver_string_column, {})
+      t.string :foo, :bar
+    end
+  end
+  
+  protected
+
+  def with_sqlserver_change_table
+    @connection.change_table :delete_me do |t|
+      yield t
+    end
+  end
+  
+  def sqlserver_string_column
+    "#{@connection.native_string_database_type}(255)"
+  end
   
 end

data/test/cases/sqlserver_helper.rb

@@ -47,16 +47,30 @@ module SqlserverCoercedTest
       self.const_get(:COERCED_TESTS) rescue nil
     end
     def method_added(method)
-      undef_method(method) if coerced_tests && coerced_tests.include?(method)
+      if coerced_tests && coerced_tests.include?(method)
+        undef_method(method)
+        STDOUT.puts("Undefined coerced test: #{self.name}##{method}")
+      end
     end
   end
 end
 
+# Set weather to test unicode string defaults or not. Used from rake task.
+
+if ENV['ENABLE_DEFAULT_UNICODE_TYPES'] == 'true'
+  puts "With enabled unicode string types"
+  ActiveRecord::ConnectionAdapters::SQLServerAdapter.enable_default_unicode_types = true
+end
+
 # Change the text database type to support ActiveRecord's tests for = on text columns which 
 # is not supported in SQL Server text columns, so use varchar(8000) instead.
 
 if ActiveRecord::Base.connection.sqlserver_2000?
-  ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type = 'varchar(8000)'
+  if ActiveRecord::ConnectionAdapters::SQLServerAdapter.enable_default_unicode_types
+    ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type = 'nvarchar(4000)'
+  else
+    ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type = 'varchar(8000)'
+  end
 end
 
 # Our changes/additions to ActiveRecord test helpers specific for SQL Server.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rails-sqlserver-2000-2005-adapter
 version: !ruby/object:Gem::Version 
-  version: 2.2.6
+  version: 2.2.7
 platform: ruby
 authors: 
 - Ken Collins
@@ -75,6 +75,7 @@ test_files:
 - test/cases/column_test_sqlserver.rb
 - test/cases/connection_test_sqlserver.rb
 - test/cases/eager_association_test_sqlserver.rb
+- test/cases/execute_procedure_test_sqlserver.rb
 - test/cases/inheritance_test_sqlserver.rb
 - test/cases/migration_test_sqlserver.rb
 - test/cases/offset_and_limit_test_sqlserver.rb