More tests passing. Standardize SchemaCache in/out policy.

Author: metaskills

lib/active_record/connection_adapters/sqlserver/schema_cache.rb

@@ -3,8 +3,6 @@ module ConnectionAdapters
     module SQLServer
       class SchemaCache < ActiveRecord::ConnectionAdapters::SchemaCache
 
-        attr_reader :view_information
-
         def initialize(conn)
           super
           @views = {}
@@ -14,28 +12,32 @@ def initialize(conn)
         # Superclass Overrides
 
         def primary_keys(table_name)
-          super(table_name_key(table_name))
+          name = key(table_name)
+          @primary_keys[name] ||= table_exists?(table_name) ? connection.primary_key(table_name) : nil
         end
 
         def table_exists?(table_name)
-          name = table_name_key(table_name)
-          super(name) || view_exists?(name)
-        end
-
-        def add(table_name)
-          super(table_name_key(table_name))
+          name = key(table_name)
+          prepare_tables_and_views
+          return @tables[name] if @tables.key? name
+          table_exists = @tables[name] = connection.table_exists?(table_name)
+          table_exists || view_exists?(table_name)
         end
 
         def tables(name)
-          super(table_name_key(name))
+          super(key(name))
         end
 
         def columns(table_name)
-          super(table_name_key(table_name))
+          name = key(table_name)
+          @columns[name] ||= connection.columns(table_name)
         end
 
         def columns_hash(table_name)
-          super(table_name_key(table_name))
+          name = key(table_name)
+          @columns_hash[name] ||= Hash[columns(table_name).map { |col|
+            [col.name, col]
+          }]
         end
 
         def clear!
@@ -49,10 +51,13 @@ def size
         end
 
         def clear_table_cache!(table_name)
-          table_name = table_name_key(table_name)
-          super(table_name)
-          @views.delete table_name
-          @view_information.delete table_name
+          name = key(table_name)
+          @columns.delete name
+          @columns_hash.delete name
+          @primary_keys.delete name
+          @tables.delete name
+          @views.delete name
+          @view_information.delete name
         end
 
         def marshal_dump
@@ -66,32 +71,41 @@ def marshal_load(array)
 
         # SQL Server Specific
 
-        def view_names
-          @views.select{ |k,v| v }.keys
-        end
-
         def view_exists?(table_name)
-          name = table_name_key(table_name)
-          prepare_views if @views.empty?
+          name = key(table_name)
+          prepare_tables_and_views
           return @views[name] if @views.key? name
-          @views[name] = connection.views.include?(name)
+          @views[name] = connection.views.include?(table_name)
         end
 
         def view_information(table_name)
-          name = table_name_key(table_name)
+          name = key(table_name)
           return @view_information[name] if @view_information.key? name
           @view_information[name] = connection.send(:view_information, table_name)
         end
 
 
         private
 
-        def table_name_key(table_name)
-          SQLServer::Utils.extract_identifiers(table_name).quoted
+        def identifier(table_name)
+          SQLServer::Utils.extract_identifiers(table_name)
+        end
+
+        def key(table_name)
+          identifier(table_name).quoted
+        end
+
+        def prepare_tables_and_views
+          prepare_views if @views.empty?
+          prepare_tables if @tables.empty?
+        end
+
+        def prepare_tables
+          connection.tables.each { |table| @tables[key(table)] = true }
         end
 
         def prepare_views
-          connection.views.each { |view| @views[view] = true }
+          connection.views.each { |view| @views[key(view)] = true }
         end
 
       end

lib/active_record/connection_adapters/sqlserver/schema_statements.rb

@@ -187,10 +187,9 @@ def initialize_native_database_types
         end
 
         def column_definitions(table_name)
-          db_name = SQLServer::Utils.extract_identifiers(table_name).database
-          db_name_with_period = "#{db_name}." if db_name
-          table_schema = SQLServer::Utils.extract_identifiers(table_name).schema
-          table_name = SQLServer::Utils.extract_identifiers(table_name).object
+          identifier = SQLServer::Utils.extract_identifiers(table_name)
+          database   = "#{identifier.database_quoted}." if identifier.database_quoted
+          table_name = identifier.quoted
           sql = %{
             SELECT DISTINCT
             #{lowercase_schema_reflection_sql('columns.TABLE_NAME')} AS table_name,
@@ -203,7 +202,7 @@ def column_definitions(table_name)
             columns.ordinal_position,
             CASE
               WHEN columns.DATA_TYPE IN ('nchar','nvarchar') THEN columns.CHARACTER_MAXIMUM_LENGTH
-              ELSE COL_LENGTH('#{db_name_with_period}'+columns.TABLE_SCHEMA+'.'+columns.TABLE_NAME, columns.COLUMN_NAME)
+              ELSE COL_LENGTH('#{database}'+columns.TABLE_SCHEMA+'.'+columns.TABLE_NAME, columns.COLUMN_NAME)
             END AS [length],
             CASE
               WHEN columns.IS_NULLABLE = 'YES' THEN 1
@@ -214,32 +213,32 @@ def column_definitions(table_name)
               ELSE NULL
             END AS [is_primary],
             c.is_identity AS [is_identity]
-            FROM #{db_name_with_period}INFORMATION_SCHEMA.COLUMNS columns
-            LEFT OUTER JOIN #{db_name_with_period}INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC
+            FROM #{database}INFORMATION_SCHEMA.COLUMNS columns
+            LEFT OUTER JOIN #{database}INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC
               ON TC.TABLE_NAME = columns.TABLE_NAME
               AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY'
-            LEFT OUTER JOIN #{db_name_with_period}INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS KCU
+            LEFT OUTER JOIN #{database}INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS KCU
               ON KCU.COLUMN_NAME = columns.COLUMN_NAME
               AND KCU.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
               AND KCU.CONSTRAINT_CATALOG = TC.CONSTRAINT_CATALOG
               AND KCU.CONSTRAINT_SCHEMA = TC.CONSTRAINT_SCHEMA
-            INNER JOIN #{db_name}.sys.schemas AS s
+            INNER JOIN #{identifier.database_quoted}.sys.schemas AS s
               ON s.name = columns.TABLE_SCHEMA
               AND s.schema_id = s.schema_id
-            INNER JOIN #{db_name}.sys.objects AS o
+            INNER JOIN #{identifier.database_quoted}.sys.objects AS o
               ON s.schema_id = o.schema_id
               AND o.is_ms_shipped = 0
               AND o.type IN ('U', 'V')
               AND o.name = columns.TABLE_NAME
-            INNER JOIN #{db_name}.sys.columns AS c
+            INNER JOIN #{identifier.database_quoted}.sys.columns AS c
               ON o.object_id = c.object_id
               AND c.name = columns.COLUMN_NAME
             WHERE columns.TABLE_NAME = @0
-              AND columns.TABLE_SCHEMA = #{table_schema.blank? ? 'schema_name()' : '@1'}
+              AND columns.TABLE_SCHEMA = #{identifier.schema.blank? ? 'schema_name()' : '@1'}
             ORDER BY columns.ordinal_position
           }.gsub(/[ \t\r\n]+/, ' ')
-          binds = [['table_name', table_name]]
-          binds << ['table_schema', table_schema] unless table_schema.blank?
+          binds = [['table_name', identifier.object]]
+          binds << ['table_schema', identifier.schema] unless identifier.schema.blank?
           results = do_exec_query(sql, 'SCHEMA', binds)
           results.map do |ci|
             ci = ci.symbolize_keys
@@ -257,10 +256,10 @@ def column_definitions(table_name)
                         else
                           ci[:type]
                         end
-            if ci[:default_value].nil? && schema_cache.view_names.include?(table_name)
+            if ci[:default_value].nil? && schema_cache.view_exists?(table_name)
               real_table_name = table_name_or_views_table_name(table_name)
               real_column_name = views_real_column_name(table_name, ci[:name])
-              col_default_sql = "SELECT c.COLUMN_DEFAULT FROM #{db_name_with_period}INFORMATION_SCHEMA.COLUMNS c WHERE c.TABLE_NAME = '#{real_table_name}' AND c.COLUMN_NAME = '#{real_column_name}'"
+              col_default_sql = "SELECT c.COLUMN_DEFAULT FROM #{database}INFORMATION_SCHEMA.COLUMNS c WHERE c.TABLE_NAME = '#{real_table_name}' AND c.COLUMN_NAME = '#{real_column_name}'"
               ci[:default_value] = select_value col_default_sql, 'SCHEMA'
             end
             ci[:default_value] = case ci[:default_value]
@@ -306,13 +305,14 @@ def remove_indexes(table_name, column_name)
         # === SQLServer Specific (Misc Helpers) ========================= #
 
         def get_table_name(sql)
-          if sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)(\s+INTO)?\s+([^\(\s]+)\s*|^\s*update\s+([^\(\s]+)\s*/i
+          tn = if sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)(\s+INTO)?\s+([^\(\s]+)\s*|^\s*update\s+([^\(\s]+)\s*/i
             Regexp.last_match[3] || Regexp.last_match[4]
           elsif sql =~ /FROM\s+([^\(\s]+)\s*/i
             Regexp.last_match[1]
           else
             nil
           end
+          SQLServer::Utils.extract_identifiers(tn).object
         end
 
         def default_constraint_name(table_name, column_name)
@@ -344,19 +344,18 @@ def view_information(table_name)
             view_info = view_info.with_indifferent_access
             if view_info[:VIEW_DEFINITION].blank? || view_info[:VIEW_DEFINITION].length == 4000
               view_info[:VIEW_DEFINITION] = begin
-                                              select_values("EXEC sp_helptext #{quote_table_name(table_name)}", 'SCHEMA').join
-                                            rescue
-                                              warn "No view definition found, possible permissions problem.\nPlease run GRANT VIEW DEFINITION TO your_user;"
-                                              nil
-                                            end
+                select_values("EXEC sp_helptext #{quote_table_name(table_name)}", 'SCHEMA').join
+              rescue
+                warn "No view definition found, possible permissions problem.\nPlease run GRANT VIEW DEFINITION TO your_user;"
+                nil
+              end
             end
           end
           view_info
         end
 
         def table_name_or_views_table_name(table_name)
-          unquoted_table_name = SQLServer::Utils.extract_identifiers(table_name).object
-          schema_cache.view_names.include?(unquoted_table_name) ? view_table_name(unquoted_table_name) : unquoted_table_name
+          schema_cache.view_exists?(table_name) ? view_table_name(table_name) : table_name
         end
 
         def views_real_column_name(table_name, column_name)

lib/active_record/connection_adapters/sqlserver_column.rb

@@ -16,10 +16,6 @@ def sql_type_for_statement
         end
       end
 
-      def primary?
-        is_identity? || is_primary?
-      end
-
       def is_identity?
         @sqlserver_options[:is_identity]
       end

test/cases/adapter_test_sqlserver.rb

@@ -1,6 +1,7 @@
 require 'cases/helper_sqlserver'
 require 'models/topic'
 require 'models/task'
+require 'models/post'
 require 'models/subscriber'
 require 'models/minimalistic'
 
@@ -65,10 +66,10 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     assert !connection.send(:insert_sql?,'SELECT...')
   end
 
-  it 'return quoted table name from basic INSERT UPDATE and SELECT statements' do
-    assert_equal '[funny_jokes]', connection.send(:get_table_name, basic_insert_sql)
-    assert_equal '[customers]', connection.send(:get_table_name, basic_update_sql)
-    assert_equal '[customers]', connection.send(:get_table_name, basic_select_sql)
+  it 'return unquoted table name object from basic INSERT UPDATE and SELECT statements' do
+    assert_equal 'funny_jokes', connection.send(:get_table_name, basic_insert_sql)
+    assert_equal 'customers', connection.send(:get_table_name, basic_update_sql)
+    assert_equal 'customers', connection.send(:get_table_name, basic_select_sql)
   end
 
   describe 'with different language' do
@@ -413,10 +414,9 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
 
     it 'find identity column' do
-      pk_name = connection.primary_key(SSTestCustomersView.table_name)
-      pk_name.must_equal 'id'
-      pk_column = SSTestCustomersView.columns_hash[pk_name]
-      pk_column.must_be :primary?
+      SSTestCustomersView.primary_key.must_equal 'id'
+      connection.primary_key(SSTestCustomersView.table_name).must_equal 'id'
+      SSTestCustomersView.columns_hash['id'].must_be :is_identity?
     end
 
     it 'find default values' do
@@ -427,40 +427,32 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       assert SSTestCustomersView.table_exists?
     end
 
-    it 'have correct table name for all column objects' do
-      assert SSTestCustomersView.columns.all?{ |c| c.table_name == 'sst_customers_view' },
-        SSTestCustomersView.columns.map(&:table_name).inspect
-    end
-
     # With aliased column names
 
     it 'have matching column objects' do
       columns = ['id','pretend_null']
-      assert !StringDefaultsView.columns.blank?
-      assert_equal columns.size, StringDefaultsView.columns.size
+      assert !SSTestStringDefaultsView.columns.blank?
+      assert_equal columns.size, SSTestStringDefaultsView.columns.size
       columns.each do |colname|
         assert_instance_of ActiveRecord::ConnectionAdapters::SQLServerColumn,
-          StringDefaultsView.columns_hash[colname],
-          "Column name #{colname.inspect} was not found in these columns #{StringDefaultsView.columns.map(&:name).inspect}"
+          SSTestStringDefaultsView.columns_hash[colname],
+          "Column name #{colname.inspect} was not found in these columns #{SSTestStringDefaultsView.columns.map(&:name).inspect}"
       end
     end
 
     it 'find identity column' do
-      assert StringDefaultsView.columns_hash['id'].primary
+      SSTestStringDefaultsView.primary_key.must_equal 'id'
+      connection.primary_key(SSTestStringDefaultsView.table_name).must_equal 'id'
+      SSTestStringDefaultsView.columns_hash['id'].must_be :is_identity?
     end
 
     it 'find default values' do
-      assert_equal 'null', StringDefaultsView.new.pretend_null,
-        StringDefaultsView.columns_hash['pretend_null'].inspect
+      assert_equal 'null', SSTestStringDefaultsView.new.pretend_null,
+        SSTestStringDefaultsView.columns_hash['pretend_null'].inspect
     end
 
     it 'respond true to table_exists?' do
-      assert StringDefaultsView.table_exists?
-    end
-
-    it 'have correct table name for all column objects' do
-      assert StringDefaultsView.columns.all?{ |c| c.table_name == 'string_defaults_view' },
-        StringDefaultsView.columns.map(&:table_name).inspect
+      assert SSTestStringDefaultsView.table_exists?
     end
 
     # Doing identity inserts
@@ -479,31 +471,15 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     # That have more than 4000 chars for their defintion
 
     it 'cope with null returned for the defintion' do
-      assert_nothing_raised() { StringDefaultsBigView.columns }
+      assert_nothing_raised() { SSTestStringDefaultsBigView.columns }
     end
 
     it 'using alternate view defintion still be able to find real default' do
-      assert_equal 'null', StringDefaultsBigView.new.pretend_null,
-        StringDefaultsBigView.columns_hash['pretend_null'].inspect
+      assert_equal 'null', SSTestStringDefaultsBigView.new.pretend_null,
+        SSTestStringDefaultsBigView.columns_hash['pretend_null'].inspect
     end
 
   end
 
 end
 
-
-module ActiveRecord
-  class AdapterTest < ActiveRecord::TestCase
-
-    COERCED_TESTS = [:test_update_prepared_statement]
-    # Like PostgreSQL, SQL Server does not support null bytes in strings.
-    # DECLARE @mybin1 binary(5), @mybin2 binary(5)
-    # SET @mybin1 = 0x00
-    # SELECT 'a'+CONVERT(varchar(5), @mybin1) + 'aaaaa'
-    # This is not run for PostgreSQL at the rails level and the same should happen for SQL Server
-    # Until that patch is made to rails we are preventing this test from running in this gem.
-    include ARTest::SQLServer::CoercedTest
-
-    fixtures :authors
-  end
-end

test/cases/named_scoping_test_sqlserver.rb

@@ -12,7 +12,7 @@ class SchemaTestSQLServer < ActiveRecord::TestCase
 
     should 'find primary key for tables with odd schema' do
       assert_equal 'legacy_id', @connection.primary_key('natural_pk_data')
-      assert SqlServerNaturalPkData.columns_hash['legacy_id'].primary
+      assert SSTestNaturalPkData.columns_hash['legacy_id'].primary
     end
 
   end