mkxms-mssql 1.0.0 → 1.1.0

data/lib/mkxms/mssql/clr_type_handler.rb

@@ -0,0 +1,92 @@
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class ClrType
+    include Utils::SchemaQualifiedName
+    include ExtendedProperties, Property::Hosting, Property::SchemaScoped
+    
+    RaiserrorSource = Utils::RaiserrorWriter.new("%s: Missing or misconfigured CLR type %s")
+    
+    def initialize(schema, name, assembly, clr_class)
+      @schema = schema
+      @name = name
+      @assembly = assembly
+      @clr_class = clr_class
+      @warning_stmt = RaiserrorSource.next_statement("WARNING".sql_quoted, qualified_name.sql_quoted, severity: :warning)
+    end
+    
+    attr_reader :schema, :name, :warning_stmt
+    attr_accessor :assembly, :clr_class
+    
+    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_types'))"
+        s << "    CREATE TABLE xmigra.ignored_clr_types ([schema] SYSNAME, name SYSNAME, CONSTRAINT PK_ignored_clr_types PRIMARY KEY ([schema], name));"
+        
+        s << "" # Give a newline at the end
+      end.join("\n")
+    end
+    
+    def to_sql
+      [].tap do |s|
+        s << "IF NOT EXISTS ("
+        s << "  SELECT t.assembly_qualified_name"
+        s << "  FROM sys.assembly_types t"
+        s << "  JOIN sys.schemas s ON t.schema_id = s.schema_id"
+        s << "  WHERE QUOTENAME(s.name) = #{schema.sql_quoted}"
+        s << "  AND QUOTENAME(t.name) = #{name.sql_quoted}"
+        s << "  UNION ALL"
+        s << "  SELECT N''"
+        s << "  FROM xmigra.ignored_clr_types t"
+        s << "  WHERE t.[schema] = #{schema.sql_quoted}"
+        s << "  AND t.name = #{name.sql_quoted}"
+        s << ") BEGIN"
+        s << "  CREATE TYPE #{schema}.#{name} EXTERNAL NAME #{assembly}.#{clr_class};"
+        s.concat(extended_properties_sql.map {|s| "  " + s})
+        s << "END"
+        
+        s << "IF NOT EXISTS ("
+        s << "  SELECT CONCAT(s.name, N'.', t.name) as clr_type, QUOTENAME(asm.name) as assembly, QUOTENAME(t.assembly_class) as clr_class"
+        s << "  FROM sys.assembly_types t"
+        s << "  JOIN sys.schemas s ON t.schema_id = s.schema_id"
+        s << "  JOIN sys.assemblies asm ON t.assembly_id = asm.assembly_id"
+        s << "  WHERE QUOTENAME(s.name) = #{schema.sql_quoted}"
+        s << "  AND QUOTENAME(t.name) = #{name.sql_quoted}"
+        s << "  -- #{warning_stmt.error_marker} Run the query up to this point for CLR type configuration --"
+        cols = [
+          ["assembly", assembly],
+          ["clr_class", clr_class],
+        ].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(asm.name) = #{assembly.sql_quoted}"
+        s << "  AND QUOTENAME(t.assembly_class) = #{clr_class.sql_quoted}"
+        s << "  UNION ALL"
+        s << "  SELECT CONCAT(t.[schema], N'.', t.name), NULL, NULL"
+        s << "  FROM xmigra.ignored_clr_types t"
+        s << "  WHERE t.[schema] = #{schema.sql_quoted}"
+        s << "  AND t.name = #{name.sql_quoted}"
+        s << ") #{warning_stmt};"
+        
+        s << "" # Give a newline at the end
+      end
+    end
+  end
+  
+  class ClrTypeHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(types, node)
+      a = node.attributes
+      
+      @type_info = ClrType.new(
+        a['schema'],
+        a['name'],
+        a['assembly'],
+        a['class']
+      ).tap {|t| types << store_properties_on(t)}
+    end
+  end
+end

data/lib/mkxms/mssql/database_handler.rb

@@ -7,7 +7,13 @@ require 'yaml'
 
   adoption_script_writer
   check_constraint_handler
+  clr_aggregate_handler
+  clr_assembly_handler
+  clr_function_handler
+  clr_stored_procedure_handler
+  clr_type_handler
   default_constraint_handler
+  dml_trigger_handler
   filegroup_handler
   foreign_key_handler
   function_handler
@@ -16,10 +22,13 @@ require 'yaml'
   primary_key_handler
   property_handler
   role_handler
+  scalar_type_handler
   schema_handler
   statistics_handler
   stored_procedure_handler
+  synonym_handler
   table_handler
+  table_type_handler
   unique_constraint_handler
   utils
   view_handler
@@ -34,15 +43,32 @@ module Mkxms::Mssql
     include ExtendedProperties, PropertyHandler::ElementHandler
     
     ADOPTION_SQL_FILE = "adopt.sql"
+    DRY_RUN_MARKER = "for dry run"
+    
+    class IgnoreText
+      def initialize(node)
+      end
+      
+      def handle_text(t, node)
+      end
+    end
     
     def initialize(**kwargs)
       @schema_dir = kwargs[:schema_dir] || Pathname.pwd
     end
     
     attr_reader :schema_dir
-    attr_init(:filegroups, :schemas, :roles, :tables, :column_defaults, :pku_constraints, :foreign_keys, :check_constraints){[]}
+    attr_init(
+      :filegroups, :schemas, :roles,
+      :types,
+      :clr_assemblies, :clr_types,
+      :tables,
+      :column_defaults, :pku_constraints, :foreign_keys,
+      :check_constraints, :dml_triggers,
+      :synonyms,
+    ){[]}
     attr_init(:indexes, :statistics){[]}
-    attr_init(:views, :udfs, :procedures){[]}
+    attr_init(:views, :udfs, :procedures, :aggregates){[]}
     attr_init(:permissions){[]}
     
     def handle_database_element(parse)
@@ -60,6 +86,14 @@ module Mkxms::Mssql
       parse.delegate_to SchemaHandler, schemas
     end
     
+    def handle_type_element(parse)
+      parse.delegate_to ScalarTypeHandler, types
+    end
+    
+    def handle_table_type_element(parse)
+      parse.delegate_to TableTypeHandler, types
+    end
+    
     def handle_role_element(parse)
       parse.delegate_to RoleHandler, roles
     end
@@ -104,10 +138,22 @@ module Mkxms::Mssql
       parse.delegate_to StoredProcedureHandler, procedures
     end
     
+    def handle_clr_stored_procedure_element(parse)
+      parse.delegate_to ClrStoredProcedureHandler, procedures
+    end
+    
     def handle_user_defined_function_element(parse)
       parse.delegate_to FunctionHandler, udfs
     end
     
+    def handle_clr_function_element(parse)
+      parse.delegate_to ClrFunctionHandler, udfs
+    end
+    
+    def handle_clr_aggregate_element(parse)
+      parse.delegate_to ClrArggregateHandler, aggregates
+    end
+    
     def handle_granted_element(parse)
       parse.delegate_to PermissionHandler, permissions
     end
@@ -116,11 +162,32 @@ module Mkxms::Mssql
       parse.delegate_to PermissionHandler, permissions
     end
     
+    def handle_clr_assembly_element(parse)
+      parse.delegate_to ClrAssemblyHandler, clr_assemblies
+    end
+    
+    def handle_clr_type_element(parse)
+      parse.delegate_to ClrTypeHandler, clr_types
+    end
+    
+    def handle_dml_trigger_element(parse)
+      parse.delegate_to DmlTriggerHandler, dml_triggers
+    end
+    
+    def handle_synonym_element(parse)
+      parse.delegate_to SynonymHandler, synonyms
+    end
+    
     def create_source_files
       dbinfo_path = @schema_dir.join(XMigra::SchemaManipulator::DBINFO_FILE)
       
       if dbinfo_path.exist?
-        raise ProgramArgumentError.new("#{@schema_dir} already contains an XMigra schema")
+        if dbinfo_path.open {|f| YAML.load(f)[DRY_RUN_MARKER]}
+          # Delete everything in the source files, so we can do a dry run over
+          @schema_dir.each_child {|e| e.rmtree}
+        else
+          raise ProgramArgumentError.new("#{@schema_dir} already contains an XMigra schema")
+        end
       end
       
       # TODO: Sort dependencies of triggers, views, user defined functions, and
@@ -133,10 +200,21 @@ module Mkxms::Mssql
       # Create and populate @schema_dir + XMigra::SchemaManipulator::DBINFO_FILE
       dbinfo_path.open('w') do |dbi|
         dbi.puts "system: #{XMigra::MSSQLSpecifics::SYSTEM_NAME}"
+        if Utils.dry_run?
+          dbi.puts "#{DRY_RUN_MARKER}: true"
+        end
       end
       
       # TODO: Create migration to check required filegroups and files
       
+      # Migration: Check CLR assemblies
+      create_migration(
+        "check-clr-assemblies",
+        "Check expected CLR assemblies have been created.",
+        ClrAssembly.setup_sql + "\n" + joined_modobj_sql(clr_assemblies),
+        clr_assemblies.map(&:name).sort
+      )
+      
       # Migration: Create roles
       create_migration(
         "create-roles",
@@ -153,6 +231,30 @@ module Mkxms::Mssql
         schemas.map(&:name).sort
       )
       
+      # Migration: Create scalar types
+      create_migration(
+        "create-scalar-types",
+        "Create user-defined scalar types.",
+        joined_modobj_sql(types),
+        types.map {|t| [t.schema, t.qualified_name]}.flatten.uniq.sort
+      )
+      
+      # Migration: Create synonyms
+      create_migration(
+        "create-synonyms",
+        "Create synonyms for other objects in the database.",
+        joined_modobj_sql(synonyms),
+        synonyms.map {|s| [s.schema, s.qualified_name]}.flatten
+      )
+      
+      # Migration: Create CLR types that don't exist
+      create_migration(
+        "create-clr-types",
+        "Create CLR types (unless already existing).",
+        ClrType.setup_sql + "\n" + joined_modobj_sql(clr_types),
+        clr_types.map(&:qualified_name).sort
+      )
+      
       tables.each do |table|
         # Migration: Create table
         qual_name = [table.schema, table.name].join('.')
@@ -196,6 +298,16 @@ module Mkxms::Mssql
         check_constraints.map {|c| [c.schema, c.qualified_table, c.qualified_name].compact}.flatten.uniq.sort
       )
       
+      # Migration: Add DML triggers
+      create_migration(
+        "add-triggers",
+        "Add triggers.",
+        joined_modobj_sql(dml_triggers, sep: DmlTriggerHandler.ddl_block_separator) + "\n",
+        dml_triggers.map do |t|
+          [t.schema, t.table.qualified_name, t.qualified_name].compact
+        end.flatten.uniq.sort
+      ) unless dml_triggers.empty?
+      
       # Check that no super-permissions reference a view, user-defined function, or stored procedure
       access_object_names = (views + udfs + procedures).map {|ao| ao.qualified_name}
       permissions.map {|p| p.super_permissions}.flatten.select do |p|
@@ -228,6 +340,15 @@ module Mkxms::Mssql
       
       write_statistics
       
+      aggregates.each do |agg|
+        create_migration(
+          "register-#{agg.qualified_name}-aggregate",
+          "Register the CLR aggregate function #{agg.qualified_name}",
+          agg.to_sql.join("\nGO\n"),
+          [agg.schema, agg.qualified_name]
+        )
+      end
+      
       views.each do |view|
         write_access_def(view, 'view')
       end

data/lib/mkxms/mssql/declaratives_creator.rb

@@ -0,0 +1,206 @@
+require 'pathname'
+require 'psych' # YAML support
+require 'xmigra'
+require 'mkxms/mssql/keywords'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class DeclarativesCreator
+    def initialize(document, schema_dir)
+      @document = document
+      @schema_dir = schema_dir || Pathname.pwd
+    end
+    
+    def decls_dir
+      @schema_dir.join(
+        XMigra::SchemaManipulator::STRUCTURE_SUBDIR,
+        XMigra::DeclarativeMigration::SUBDIR,
+      )
+    end
+    
+    def create_artifacts
+      index_constraints
+      
+      # Loop through all tables
+      decl_paths = []
+      @document.elements.each('/database/table') do |table|
+        schema, name = %w[schema name].map {|a| table.attributes[a]}
+        tdecl_path = decls_dir.join([schema, name, 'yaml'].join('.'))
+        doc = build_declarative(table)
+        decls_dir.mkpath
+        tdecl_path.open('w') {|f| f.write(doc.to_yaml)}
+        decl_paths << tdecl_path
+      end
+      
+      # Loop through the created paths creating an adoption migration for each
+      decl_paths.each do |fpath|
+        tool = XMigra::ImpdeclMigrationAdder.new(@schema_dir)
+        tool.add_migration_implementing_changes(fpath, {adopt: true})
+      end
+    end
+    
+    def build_declarative(table)
+      doc, tdecl = create_blank_table_decl
+      
+      columns_decl = Psych::Nodes::Sequence.new.tap do |s|
+        tdecl.children << node_from('columns') << s
+      end
+      
+      table_key = %w[schema name].map {|a| table.attributes[a]}
+      
+      # Columns (including single-column default constraints)
+      table.elements.each('column') do |column|
+        entry = Psych::Nodes::Mapping.new.tap {|e| columns_decl.children << e}
+        col_name = column.attributes['name']
+        if col_name =~ /^\[[a-zA-Z_][a-zA-Z0-9_]*\]$/ && !KEYWORDS_SET.include?(col_name[1..-2].upcase)
+          col_name = col_name[1..-2]
+        end
+        entry.children.concat(
+          ['name', col_name].map {|v| node_from(v)}
+        )
+        col_type = column.attributes['type']
+        if KEYWORDS_SET.include?(basic_type = col_type[1..-2].upcase)
+          col_type = basic_type
+        end
+        if capacity = column.attributes['capacity']
+          col_type = "#{col_type}(#{capacity})"
+        end
+        entry.children.concat(
+          ['type', col_type].map {|v| node_from(v)}
+        )
+        unless column.attributes['nullable']
+          entry.children.concat(
+            ['nullable', false].map {|v| node_from(v)}
+          )
+        end
+        
+        if cstr = cstr_on_column(@default_constraints, table_key, column)
+          entry.children.concat(['default', cstr.text].map {|v| node_from(v)})
+        end
+        if cexpr = column.elements['computed-expression']
+          entry.children.concat(['X-computed-as', cexpr.text].map {|v| node_from(v)})
+        end
+      end
+      
+      # Everything but default constraints
+      cstrs_decl = Psych::Nodes::Mapping.new
+      constraint_default_name_part = mashable_name(table.attributes['name'])
+      @primary_key_constraints.fetch(table_key, []).each do |cstr|
+        cstr_name = cstr.attributes['name'] || "PK_#{constraint_default_name_part}"
+        cstrs_decl.children << node_from(cstr_name) << node_from({
+          'type' => 'primary key',
+          'columns' => cstr.elements.enum_for(:each, 'column').map {|c| c.attributes['name']},
+        })
+      end
+      @uniqueness_constraints.fetch(table_key, []).each do |cstr|
+        cstr_name = cstr.attributes['name'] || (
+          "UQ_#{constraint_default_name_part}_" +
+          mashable_name(
+            cstr.elements.enum_for(:each, 'column').map {|c| c.attributes['name']}.join('_')
+          )
+        )
+        cstrs_decl.children << node_from(cstr_name) << node_from({
+          'type' => 'unique',
+          'columns' => cstr.elements.enum_for(:each, 'column').map {|c| c.attributes['name']},
+        })
+      end
+      @foreign_key_constraints.fetch(table_key, []).each do |cstr|
+        cstr_name = cstr.attributes['name'] || :generated
+        if cstr_name == :generated
+          from_cols, to_cols = [], []
+          cstr.elements.each('link') do |link|
+            from_cols << link.attributes['from']
+            to_cols << link.attributes['to']
+          end
+          cstr_name = (
+            "FK_#{constraint_default_name_part}_" + 
+            mashable_name(from_cols.join('_')) + '_' +
+            mashable_name(%w[schema name].map {|a| cstr.elements['referent'].attributes[a]}.join('_')) + '_' +
+            mashable_name(to_cols.join('_'))
+          )
+        end
+        cstrs_decl.children << node_from(cstr_name) << node_from({
+          'link to' => cstr.elements['referent'].tap do |r|
+            break [r.attributes['schema'], r.attributes['name']].join('.')
+          end,
+          'columns' => Hash[
+            cstr.elements.enum_for(:each, 'link').map do |link|
+              %w[from to].map {|a| link.attributes[a]}
+            end
+          ],
+        })
+      end
+      existing_check_names = nil
+      @check_constraints.fetch(table_key, []).each_with_index do |cstr, i|
+        cstr_name = cstr.attributes['name'] || :generated
+        if cstr_name == :generated
+          existing_check_names ||= @check_constraints[table_key].map {|c| c.attributes['name']}.compact
+          cstr_name = "CK_#{constraint_default_name_part}_#{i+1}"
+          while existing_check_names.include?(cstr_name)
+            cstr_name << '_' unless cstr_name.end_with?('_')
+            cstr_name << 'X'
+          end
+          existing_check_names << cstr_name
+        end
+        cstrs_decl.children << node_from(cstr_name) << node_from({
+          'verify' => cstr.text,
+        })
+      end
+      
+      unless cstrs_decl.children.empty?
+        tdecl.children << node_from("constraints") << cstrs_decl
+      end
+      
+      return doc
+    end
+    
+    def index_constraints
+      @primary_key_constraints = read_constraints('primary-key')
+      @uniqueness_constraints = read_constraints('unique-constraint')
+      @foreign_key_constraints = read_constraints('foreign-key')
+      @check_constraints = read_constraints('check-constraint')
+      @default_constraints = read_constraints('default-constraint')
+    end
+    
+    def read_constraints(ctype, inline: false)
+      @document.elements.enum_for(:each, "/database/#{ctype}").each_with_object({}) do |cstr, result|
+        key = [cstr.attributes['schema'], cstr.attributes['table']]
+        (result[key] ||= []) << cstr
+      end
+    end
+    
+    def create_blank_table_decl
+      stream = Psych::Nodes::Stream.new
+      doc = Psych::Nodes::Document.new.tap {|d| stream.children << d}
+      decl = Psych::Nodes::Mapping.new.tap {|m| doc.children << m}
+      decl.implicit = false
+      decl.tag = '!table'
+      return [stream, decl]
+    end
+    
+    def node_from(val)
+      ast_stream = Psych.parse_stream(Psych.dump(val))
+      return ast_stream.children[0].children[0]
+    end
+    
+    def attr_eq?(a, o1=nil, *objs)
+      return true if o1.nil? || objs.length == 0
+      val = o1.attributes[a]
+      return objs.all? {|o| o.attributes[a] == val}
+    end
+    
+    def cstr_on_column(group, key, column)
+      cstrs = group[key]
+      return nil unless cstrs
+      cstrs.find do |cstr|
+        cstr.attributes['column'] == column.attributes['name'] || \
+          cstr.elements.enum_for(:each, 'column').select {|c| attr_eq?('name', c, column)}.count > 0
+      end
+    end
+    
+    def mashable_name(s)
+      s.gsub(/[\]\[]/, '').gsub(/[^a-zA-Z_]/, '_')
+    end
+  end
+end