mkxms-mssql 1.0.0 → 1.1.0

data/lib/mkxms/mssql/clr_aggregate_handler.rb

@@ -0,0 +1,98 @@
+require 'mkxms/mssql/property_handler'
+require 'mkxms/mssql/clr_impl'
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class ClrAggregate
+    include ExtendedProperties, Property::Hosting, Property::SchemaScoped
+    include Utils::SchemaQualifiedName
+    extend Utils::InitializedAttributes
+    
+    SQL_OBJECT_TYPE = 'AGGREGATE'
+    
+    def initialize(attrs)
+      @schema = attrs['schema']
+      @name = attrs['name']
+      @execute_as = attrs['execute-as']
+    end
+    
+    attr_accessor :schema, :name, :execute_as, :clr_impl, :returns
+    attr_init(:params) {[]}
+    
+    def to_sql
+      (procedure_def_sql + extended_properties_sql + param_properties_sql)
+    end
+    
+    def procedure_def_sql
+      [[].tap do |lines|
+        lines << "IF NOT EXISTS ("
+        lines << "  SELECT * FROM xmigra.ignored_clr_assemblies asm"
+        lines << "  WHERE asm.name = #{clr_impl.assembly.sql_quoted}"
+        lines << ")"
+        lines << "CREATE AGGREGATE [{filename}] ("
+        lines << params.map do |param|
+          "  #{param.name} #{param.type_spec}".tap do |param_spec|
+            param_spec << " = #{param.default_value}" if param.default_value
+          end
+        end.join(",\n")
+        lines << ")"
+        lines << "RETURNS #{returns.type_spec}" if returns
+        lines << "EXTERNAL NAME #{clr_impl.full_specifier};"
+      end.join("\n")]
+    end
+    
+    def param_properties_sql
+      params.map do |param|
+        subitem_extended_properties_sql(param)
+      end
+    end
+  end
+  
+  class ClrArggregateHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(aggregates, node)
+      a = node.attributes
+      
+      @aggregate = ClrAggregate.new(a).tap do |agg|
+        store_properties_on agg
+        aggregates << agg
+      end
+    end
+    
+    def handle_implementation_element(parse)
+      a = parse.node.attributes
+      @aggregate.clr_impl = ClrClass.new(a['assembly'], a['class'])
+    end
+    
+    def handle_parameter_element(parse)
+      a = parse.node.attributes
+      Parameter.new(
+        a['name'],
+        a['type-schema'],
+        a['type'],
+        a['capacity'],
+        a['precision'],
+        a['scale'],
+        a['default'],
+        a['output'],
+      ).tap do |param|
+        @aggregate.params << param
+        parse.context = ParameterHandler.new(param)
+      end
+    end
+    
+    def handle_returns_element(parse)
+      a = parse.node.attributes
+      @aggregate.returns = ResultType.new(
+        a['type-schema'],
+        a['type'],
+        a['capacity'],
+        a['precision'],
+        a['scale'],
+      )
+    end
+  end
+end

data/lib/mkxms/mssql/clr_assembly_handler.rb

@@ -0,0 +1,92 @@
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class ClrAssembly
+    include ExtendedProperties
+    
+    RaiserrorSource = Utils::RaiserrorWriter.new("%s: Missing or misconfigured assembly %s")
+    
+    def initialize(name, lib_name = "", access:, owner: nil)
+      @name = name
+      @error_stmt = RaiserrorSource.next_statement("ERROR".sql_quoted, name.sql_quoted, severity: :error)
+      @warning_stmt = RaiserrorSource.next_statement("WARNING".sql_quoted, name.sql_quoted, severity: :warning)
+      @lib_name = lib_name
+      @access = access
+      @owner = owner
+    end
+    
+    attr_reader :name, :error_stmt, :warning_stmt
+    attr_accessor :lib_name, :owner, :access
+    
+    def self.setup_sql
+      [].tap do |s|
+        s << "IF NOT EXISTS (SELECT * FROM sys.tables t WHERE t.object_id = OBJECT_ID(N'xmigra.ignored_clr_assemblies'))"
+        s << "    CREATE TABLE xmigra.ignored_clr_assemblies (name SYSNAME PRIMARY KEY);"
+        
+        s << "" # Give a newline at the end
+      end.join("\n")
+    end
+    
+    def to_sql
+      [].tap do |s|
+        s << "IF NOT EXISTS ("
+        s << "  SELECT asm.name"
+        s << "  FROM sys.assemblies asm"
+        s << "  WHERE asm.is_visible = 1"
+        s << "  AND QUOTENAME(asm.name) = #{name.sql_quoted}"
+        s << "  UNION ALL"
+        s << "  SELECT asm.name"
+        s << "  FROM xmigra.ignored_clr_assemblies asm"
+        s << "  WHERE asm.name = #{name.sql_quoted}"
+        s << ") #{error_stmt};"
+        
+        s << "IF NOT EXISTS ("
+        s << "  SELECT asm.name, QUOTENAME(owner.name) as owner, REPLACE(LOWER(asm.permission_set_desc), '_', '-') as permission_set, asm.clr_name as library"
+        s << "  FROM sys.assemblies asm"
+        s << "  JOIN sys.database_principals owner ON asm.principal_id = owner.principal_id" if owner
+        s << "  WHERE asm.is_visible = 1"
+        s << "  AND QUOTENAME(asm.name) = #{name.sql_quoted}"
+        s << "  -- #{warning_stmt.error_marker} Run the query up to this point for assembly configuration --"
+        cols = [
+          ["owner", owner],
+          ["permission_set", access],
+          ["library", lib_name],
+        ].map {|t, v| [t.ljust(v.length), v.ljust(t.length)]}
+        s << ("  --                  " + cols.map {|e| e[0]}.join('   ') + ' --')
+        s << ("  -- Expected values: " + cols.map {|e| e[1]}.join('   ') + ' --')
+        s << "  AND QUOTENAME(owner.name) = #{owner.sql_quoted}" if owner
+        s << "  AND REPLACE(LOWER(asm.permission_set_desc), '_', '-') = #{access.sql_quoted}"
+        s << "  AND asm.clr_name = #{lib_name.sql_quoted}"
+        s << "  UNION ALL"
+        s << "  SELECT asm.name, NULL, NULL, NULL"
+        s << "  FROM xmigra.ignored_clr_assemblies asm"
+        s << "  WHERE asm.name = #{name.sql_quoted}"
+        s << ") #{warning_stmt};"
+        
+        s << "" # Gives a newline at the end
+      end.join("\n")
+    end
+  end
+  
+  class ClrAssemblyHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(assemblies, node)
+      a = node.attributes
+      
+      @assembly = ClrAssembly.new(
+        a['name'],
+        owner: a['owner'],
+        access: a['permission-set']
+      ).tap do |asm|
+        assemblies << asm
+      end
+    end
+    
+    def handle_text(content, parent_node)
+      @assembly.lib_name << content
+    end
+  end
+end

data/lib/mkxms/mssql/clr_function_handler.rb

@@ -0,0 +1,172 @@
+require 'mkxms/mssql/property_handler'
+require 'mkxms/mssql/clr_impl'
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class ClrFunction
+    include ExtendedProperties, Property::Hosting, Property::SchemaScoped
+    include Utils::SchemaQualifiedName
+    extend Utils::InitializedAttributes
+    
+    SQL_OBJECT_TYPE = 'FUNCTION'
+    
+    class ResultTable
+      extend Utils::InitializedAttributes
+      
+      attr_init(:columns) {[]}
+      
+      class Column
+        include ExtendedProperties
+        
+        SQL_OBJECT_TYPE = 'COLUMN'
+        
+        def initialize(name, result_type)
+          @name = name
+          @result_type = result_type
+        end
+        
+        attr_accessor :name, :result_type
+        
+        def type_spec
+          result_type.type_spec
+        end
+      end
+    end
+    
+    def initialize(attrs)
+      @schema = attrs['schema']
+      @name = attrs['name']
+      @execute_as = attrs['execute-as']
+    end
+    
+    attr_accessor :schema, :name, :execute_as, :clr_impl, :returns, :result_table
+    attr_init(:params) {[]}
+    
+    def to_sql
+      (procedure_def_sql + extended_properties_sql + param_properties_sql + result_column_properties_sql).join("\n")
+    end
+    
+    def procedure_def_sql
+      [[].tap do |lines|
+        lines << "CREATE FUNCTION [{filename}] ("
+        lines << params.map do |param|
+          "  #{param.name} #{param.type_spec}".tap do |param_spec|
+            param_spec << " = #{param.default_value}" if param.default_value
+          end
+        end.join(",\n")
+        lines << ")"
+        case 
+        when returns
+          lines << "RETURNS #{returns.type_spec}"
+        when result_table
+          lines << "RETURNS TABLE ("
+          lines << result_table.columns.map do |col|
+            "  #{col.name} #{col.type_spec}"
+          end.join(",\n")
+          lines << ")"
+        else
+          raise RuntimeError.new("Function return not defined")
+        end
+        case execute_as
+        when "OWNER"
+          lines << "WITH EXECUTE AS OWNER"
+        when String
+          lines << "WITH EXECUTE AS '#{Utils.unquoted_name execute_as}'"
+        end
+        lines << "AS EXTERNAL NAME #{clr_impl.full_specifier};"
+      end.join("\n")]
+    end
+    
+    def param_properties_sql
+      params.map do |param|
+        subitem_extended_properties_sql(param)
+      end
+    end
+    
+    def result_column_properties_sql
+      return [] unless result_table
+      result_table.columns.map do |col|
+        subitem_extended_properties_sql(col)
+      end
+    end
+  end
+  
+  class ClrFunctionHandler
+    include PropertyHandler::ElementHandler
+    
+    class ResultTableColumnHandler
+      include PropertyHandler::ElementHandler
+      
+      def initialize(column)
+        @column = store_properties_on(column)
+      end
+    end
+    
+    def initialize(functions, node)
+      a = node.attributes
+      
+      @function = ClrFunction.new(a).tap do |f|
+        store_properties_on f
+        functions << f
+      end
+    end
+    
+    def handle_implementation_element(parse)
+      a = parse.node.attributes
+      @function.clr_impl = ClrMethod.new(a['assembly'], a['class'], a['method'])
+    end
+    
+    def handle_parameter_element(parse)
+      a = parse.node.attributes
+      Parameter.new(
+        a['name'],
+        a['type-schema'],
+        a['type'],
+        a['capacity'],
+        a['precision'],
+        a['scale'],
+        a['default'],
+        a['output'],
+      ).tap do |param|
+        @function.params << param
+        parse.context = ParameterHandler.new(param)
+      end
+    end
+    
+    def handle_returns_element(parse)
+      a = parse.node.attributes
+      @function.returns = ResultType.new(
+        a['type-schema'],
+        a['type'],
+        a['capacity'],
+        a['precision'],
+        a['scale'],
+      )
+    end
+    
+    def handle_result_table_element(parse)
+      @function.result_table = @result_table = ClrFunction::ResultTable.new
+    end
+    
+    def handle_column_element(parse)
+      a = parse.node.attributes
+      ClrFunction::ResultTable::Column.new(
+        a['name'],
+        ResultType.new(
+          a['type-schema'],
+          a['type'],
+          a['capacity'],
+          a['precision'],
+          a['scale'],
+          a['collation'],
+        )
+      ).tap do |col|
+        @result_table.columns << col
+        # Dispatch parse for column properties
+        parse.context = ResultTableColumnHandler.new(col)
+      end
+    end
+  end
+end

data/lib/mkxms/mssql/clr_impl.rb

@@ -0,0 +1,58 @@
+require 'mkxms/mssql/property_handler'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  ClrMethod = Struct.new(:assembly, :asm_class, :method) do
+    def full_specifier
+      to_a.join('.')
+    end
+  end
+  
+  ClrClass = Struct.new(:assembly, :asm_class) do
+    def full_specifier
+      to_a.join('.')
+    end
+  end
+  
+  # The Parameter class(es) are defined here because they are only important
+  # for CLR-linked objects
+  Parameter = Struct.new(
+    :name,
+    :type_schema, :type, :capacity, :precision, :scale,
+    :default_value,
+    :output
+  ) do
+    include ExtendedProperties
+    
+    SQL_OBJECT_TYPE = 'PARAMETER'
+    
+    def type_spec
+      [type_schema, type].compact.join(".").tap do |result|
+        result << "(#{capacity})" if capacity
+        result << "(#{[precision, scale].compact.join(', ')})" if precision
+      end
+    end
+  end
+  
+  class ParameterHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(parameter)
+      @parameter = parameter
+    end
+    
+    attr_reader :parameter
+  end
+  
+  # Used for scalar and result table column type specification
+  ResultType = Struct.new(:schema, :name, :capacity, :precision, :scale, :collation) do
+    def type_spec
+      [schema, name].compact.join('.').tap do |result|
+        result << "(#{capacity})" if capacity
+        result << "(#{[precision, scale].compact.join(', ')})"
+        result << " COLLATE #{collation}" if collation
+      end
+    end
+  end
+end

data/lib/mkxms/mssql/clr_stored_procedure_handler.rb

@@ -0,0 +1,88 @@
+require 'mkxms/mssql/property_handler'
+require 'mkxms/mssql/clr_impl'
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class ClrStoredProcedure
+    include ExtendedProperties, Property::Hosting, Property::SchemaScoped
+    include Utils::SchemaQualifiedName
+    extend Utils::InitializedAttributes
+    
+    SQL_OBJECT_TYPE = 'PROCEDURE'
+    
+    def initialize(attrs)
+      @schema = attrs['schema']
+      @name = attrs['name']
+      @execute_as = attrs['execute-as']
+    end
+    
+    attr_accessor :schema, :name, :clr_impl, :execute_as
+    attr_init(:params) {[]}
+    
+    def to_sql
+      (procedure_def_sql + extended_properties_sql + param_properties_sql).join("\n")
+    end
+    
+    def procedure_def_sql
+      [[].tap do |lines|
+        lines << "CREATE PROCEDURE [{filename}]"
+        lines << params.map do |param|
+          "  #{param.name} #{param.type_spec}".tap do |param_spec|
+            param_spec << " = #{param.default_value}" if param.default_value
+            param_spec << " OUT" if param.output
+          end
+        end.join(",\n")
+        case execute_as
+        when "OWNER"
+          lines << "WITH EXECUTE AS OWNER"
+        when String
+          lines << "WITH EXECUTE AS '#{Utils.unquoted_name execute_as}'"
+        end
+        lines << "AS EXTERNAL NAME #{clr_impl.full_specifier};"
+      end.join("\n")]
+    end
+    
+    def param_properties_sql
+      params.map do |param|
+        subitem_extended_properties_sql(param)
+      end.flatten
+    end
+  end
+  
+  class ClrStoredProcedureHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(procedures, node)
+      a = node.attributes
+      
+      @procedure = ClrStoredProcedure.new(a).tap do |sp|
+        store_properties_on sp
+        procedures << sp
+      end
+    end
+    
+    def handle_implementation_element(parse)
+      a = parse.node.attributes
+      @procedure.clr_impl = ClrMethod.new(a['assembly'], a['class'], a['method'])
+    end
+    
+    def handle_parameter_element(parse)
+      a = parse.node.attributes
+      Parameter.new(
+        a['name'],
+        a['type-schema'],
+        a['type'],
+        a['capacity'],
+        a['precision'],
+        a['scale'],
+        a['default'],
+        a['output'],
+      ).tap do |param|
+        @procedure.params << param
+        parse.context = ParameterHandler.new(param)
+      end
+    end
+  end
+end