Added support for computed columns

Author: aidanharan

CHANGELOG.md

@@ -4,11 +4,12 @@
 
 - [#1301](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1301) Add support for `INDEX INCLUDE`.
 - [#1312](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1312) Add support for `insert_all` and `upsert_all`.
-- [#1317](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1317) Reverse order of values when upserting.
+- [#](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/) Added support for computed columns.
 
 #### Changed
 
 - [#1273](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1273) TinyTDS v3+ is now required.
+- [#1317](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1317) Reverse order of values when upserting.
 - [#1343](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1343) Support more Azure services by changing language source.
 
 #### Fixed

lib/active_record/connection_adapters/sqlserver/schema_creation.rb

@@ -12,6 +12,12 @@ def supports_index_using?
           false
         end
 
+        def visit_ColumnDefinition(o)
+          column_sql = super
+          column_sql = column_sql.sub(" #{o.sql_type}", "") if o.options[:as].present?
+          column_sql
+        end
+
         def visit_TableDefinition(o)
           if_not_exists = o.if_not_exists
 
@@ -58,18 +64,17 @@ def quoted_include_columns(o)
 
         def add_column_options!(sql, options)
           sql << " DEFAULT #{quote_default_expression_for_column_definition(options[:default], options[:column])}" if options_include_default?(options)
-          if options[:collation].present?
-            sql << " COLLATE #{options[:collation]}"
-          end
-          if options[:null] == false
-            sql << " NOT NULL"
-          end
-          if options[:is_identity] == true
-            sql << " IDENTITY(1,1)"
-          end
-          if options[:primary_key] == true
-            sql << " PRIMARY KEY"
+
+          sql << " COLLATE #{options[:collation]}" if options[:collation].present?
+          sql << " NOT NULL"                       if options[:null] == false
+          sql << " IDENTITY(1,1)"                  if options[:is_identity] == true
+          sql << " PRIMARY KEY"                    if options[:primary_key] == true
+
+          if as = options[:as]
+            sql << " AS #{as}"
+            sql << " PERSISTED" if options[:stored]
           end
+
           sql
         end
 

lib/active_record/connection_adapters/sqlserver/schema_dumper.rb

@@ -4,22 +4,32 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       class SchemaDumper < ConnectionAdapters::SchemaDumper
-        SQLSEVER_NO_LIMIT_TYPES = [
-          "text",
-          "ntext",
-          "varchar(max)",
-          "nvarchar(max)",
-          "varbinary(max)"
-        ].freeze
+        SQLSERVER_NO_LIMIT_TYPES = %w[text ntext varchar(max) nvarchar(max) varbinary(max)].freeze
 
         private
 
+        def prepare_column_options(column)
+          spec = super
+
+          if @connection.supports_virtual_columns? && column.virtual?
+            spec[:as] = extract_expression_for_virtual_column(column)
+            spec[:stored] = column.virtual_stored?
+            spec = { type: schema_type(column).inspect }.merge!(spec)
+          end
+
+          spec
+        end
+
+        def extract_expression_for_virtual_column(column)
+          column.default_function.inspect
+        end
+
         def explicit_primary_key_default?(column)
           column.type == :integer && !column.is_identity?
         end
 
         def schema_limit(column)
-          return if SQLSEVER_NO_LIMIT_TYPES.include?(column.sql_type)
+          return if SQLSERVER_NO_LIMIT_TYPES.include?(column.sql_type)
 
           super
         end

lib/active_record/connection_adapters/sqlserver/schema_statements.rb

@@ -85,41 +85,58 @@ def index_include_columns(table_name, index_name)
           select_all(sql, "SCHEMA").map { |row| row["column_name"] }
         end
 
-        def columns(table_name)
-          return [] if table_name.blank?
-
-          column_definitions(table_name).map do |ci|
-            sqlserver_options = ci.slice :ordinal_position, :is_primary, :is_identity, :table_name
-            sql_type_metadata = fetch_type_metadata ci[:type], sqlserver_options
-
-            new_column(
-              ci[:name],
-              lookup_cast_type(ci[:type]),
-              ci[:default_value],
-              sql_type_metadata,
-              ci[:null],
-              ci[:default_function],
-              ci[:collation],
-              nil,
-              sqlserver_options
-            )
+
+        # def columns(table_name)
+        #   return [] if table_name.blank?
+        #
+        #   definitions = column_definitions(table_name)
+        #   definitions.map do |field|
+        #     new_column_from_field(table_name, field, definitions)
+        #   end
+        # end
+
+        def new_column_from_field(table_name, field, definitions)
+          sqlserver_options = field.slice(:ordinal_position, :is_primary, :is_identity, :table_name)
+          sql_type_metadata = fetch_type_metadata(field[:type], sqlserver_options)
+          generated_type = extract_generated_type(field)
+
+
+
+
+          if generated_type.present?
+            # binding.pry if field[:name] == "mutated_name"
+
+
+            default_function = field[:computed_formula]
+          else
+            default_function = field[:default_function]
           end
-        end
 
-        def new_column(name, cast_type, default, sql_type_metadata, null, default_function = nil, collation = nil, comment = nil, sqlserver_options = {})
+
           SQLServer::Column.new(
-            name,
-            cast_type,
-            default,
+            field[:name],
+            lookup_cast_type(field[:type]),
+            field[:default_value],
             sql_type_metadata,
-            null,
+            field[:null],
             default_function,
-            collation: collation,
-            comment: comment,
+            collation: field[:collation],
+            comment: nil,
+            generated_type: generated_type,
             **sqlserver_options
           )
         end
 
+        def extract_generated_type(field)
+          if field[:is_computed]
+            if field[:is_persisted]
+              :stored
+            else
+              :virtual
+            end
+          end
+        end
+
         def primary_keys(table_name)
           primaries = primary_keys_select(table_name)
           primaries.present? ? primaries : identity_columns(table_name).map(&:name)
@@ -512,15 +529,19 @@ def column_definitions(table_name)
           raise ActiveRecord::StatementInvalid, "Table '#{table_name}' doesn't exist" if results.empty?
 
           results.map do |ci|
-            col = {
-              name: ci["name"],
-              numeric_scale: ci["numeric_scale"],
-              numeric_precision: ci["numeric_precision"],
-              datetime_precision: ci["datetime_precision"],
-              collation: ci["collation"],
-              ordinal_position: ci["ordinal_position"],
-              length: ci["length"]
-            }
+            # col = {
+            #   name:               ci["name"],
+            #   numeric_scale:      ci["numeric_scale"],
+            #   numeric_precision:  ci["numeric_precision"],
+            #   datetime_precision: ci["datetime_precision"],
+            #   collation:          ci["collation"],
+            #   ordinal_position:   ci["ordinal_position"],
+            #   length:             ci["length"],
+            #   is_computed:        ci["is_computed"],
+            #   is_persisted:       ci["is_persisted"]
+            # }
+
+            col = ci.slice("name", "numeric_scale", "numeric_precision", "datetime_precision", "collation", "ordinal_position", "length", "is_computed", "is_persisted", "computed_formula").symbolize_keys
 
             col[:table_name] = view_exists ? view_table_name(table_name) : table_name
             col[:type] = column_type(ci: ci)
@@ -640,7 +661,10 @@ def column_definitions_sql(database, identifier)
                 WHEN ic.object_id IS NOT NULL
                 THEN 1
               END AS [is_primary],
-              c.is_identity AS [is_identity]
+              c.is_identity AS [is_identity],
+              c.is_computed AS [is_computed],
+              cc.is_persisted AS [is_persisted],
+              cc.definition AS [computed_formula]
             FROM #{database}.sys.columns c
             INNER JOIN #{database}.sys.objects o
               ON c.object_id = o.object_id
@@ -659,6 +683,9 @@ def column_definitions_sql(database, identifier)
               ON k.parent_object_id = ic.object_id
               AND k.unique_index_id = ic.index_id
               AND c.column_id = ic.column_id
+            LEFT OUTER JOIN #{database}.sys.computed_columns cc
+              ON c.object_id = cc.object_id
+              AND c.column_id = cc.column_id
             WHERE
               o.Object_ID = Object_ID(#{object_id_arg})
               AND s.name = #{schema_name}

lib/active_record/connection_adapters/sqlserver/table_definition.rb

@@ -109,6 +109,8 @@ def new_column_definition(name, type, **options)
             type = :datetime2 unless options[:precision].nil?
           when :primary_key
             options[:is_identity] = true
+          when :virtual
+            type = options[:type]
           end
 
           super
@@ -117,7 +119,7 @@ def new_column_definition(name, type, **options)
         private
 
         def valid_column_definition_options
-          super + [:is_identity]
+          super + [:is_identity, :as, :type, :stored]
         end
       end
 

lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -265,6 +265,10 @@ def supports_insert_conflict_target?
         false
       end
 
+      def supports_virtual_columns?
+        true
+      end
+
       def return_value_after_insert?(column) # :nodoc:
         column.is_primary? || column.is_identity?
       end

lib/active_record/connection_adapters/sqlserver_column.rb

@@ -6,12 +6,13 @@ module SQLServer
       class Column < ConnectionAdapters::Column
         delegate :is_identity, :is_primary, :table_name, :ordinal_position, to: :sql_type_metadata
 
-        def initialize(*, is_identity: nil, is_primary: nil, table_name: nil, ordinal_position: nil, **)
+        def initialize(*, is_identity: nil, is_primary: nil, table_name: nil, ordinal_position: nil, generated_type: nil, **)
           super
           @is_identity = is_identity
           @is_primary = is_primary
           @table_name = table_name
           @ordinal_position = ordinal_position
+          @generated_type = generated_type
         end
 
         def is_identity?
@@ -31,6 +32,21 @@ def case_sensitive?
           collation&.match(/_CS/)
         end
 
+        def virtual?
+
+          # binding.pry
+
+          @generated_type.present?
+        end
+
+        def virtual_stored?
+          @generated_type == :stored
+        end
+
+        def has_default?
+          super && !virtual?
+        end
+
         def init_with(coder)
           @is_identity = coder["is_identity"]
           @is_primary = coder["is_primary"]