mkxms-mssql 1.0.0

data/lib/mkxms/mssql/check_constraint_handler.rb

@@ -0,0 +1,56 @@
+require 'mkxms/mssql/property_handler'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class CheckConstraint
+    include ExtendedProperties, Property::Hosting
+    
+    def initialize(schema, table, name, enabled: true, when_replicated: true)
+      @schema = schema
+      @table = table
+      @name = name
+      @enabled = enabled
+      @when_replicated = when_replicated
+      @expression = ''
+    end
+    
+    attr_accessor :schema, :table, :name, :enabled, :when_replicated
+    attr_reader :expression
+    
+    def to_sql
+      "ALTER TABLE #@schema.#@table ADD%s CHECK%s #@expression;%s" % [
+        @name ? " CONSTRAINT #@name" : '',
+        @when_replicated ? '' : ' NOT FOR REPLICATION',
+        @enabled ? '' : "\nALTER TABLE #@schema.#@table NOCHECK CONSTRAINT #@name;"
+      ] + (name ? extended_properties_sql.joined_on_new_lines : '')
+    end
+    
+    def qualified_table
+      "#@schema.#@table"
+    end
+    
+    def qualified_name
+      "#@schema.#@name" if @name
+    end
+    
+    def property_subject_identifiers
+      ['SCHEMA', schema, 'TABLE', table, 'CONSTRAINT', name].map {|s| Utils::unquoted_name(s)}
+    end
+  end
+
+  class CheckConstraintHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(constraints, node)
+      a = node.attributes
+      
+      @check = CheckConstraint.new(a['schema'], a['table'], a['name'],
+                                   enabled: !a['disabled'], when_replicated: !a['not-for-replication'])
+    end
+    
+    def handle_text(text, parent_element)
+      @check.expression << text
+    end
+  end
+end

data/lib/mkxms/mssql/database_handler.rb

@@ -0,0 +1,339 @@
+require 'pathname'
+require 'set'
+require 'xmigra'
+require 'yaml'
+
+%w[
+
+  adoption_script_writer
+  check_constraint_handler
+  default_constraint_handler
+  filegroup_handler
+  foreign_key_handler
+  function_handler
+  index_handler
+  permission_handler
+  primary_key_handler
+  property_handler
+  role_handler
+  schema_handler
+  statistics_handler
+  stored_procedure_handler
+  table_handler
+  unique_constraint_handler
+  utils
+  view_handler
+  
+].each {|f| require "mkxms/mssql/" + f}
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class Mkxms::Mssql::DatabaseHandler
+    extend Utils::InitializedAttributes
+    include ExtendedProperties, PropertyHandler::ElementHandler
+    
+    ADOPTION_SQL_FILE = "adopt.sql"
+    
+    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(:indexes, :statistics){[]}
+    attr_init(:views, :udfs, :procedures){[]}
+    attr_init(:permissions){[]}
+    
+    def handle_database_element(parse)
+    end
+    
+    def handle_filegroup_element(parse)
+      parse.delegate_to FilegroupHandler, filegroups
+    end
+    
+    def handle_fulltext_document_type_element(parse)
+      # TODO: Check that these types are registered in the target instance
+    end
+    
+    def handle_schema_element(parse)
+      parse.delegate_to SchemaHandler, schemas
+    end
+    
+    def handle_role_element(parse)
+      parse.delegate_to RoleHandler, roles
+    end
+    
+    def handle_table_element(parse)
+      parse.delegate_to TableHandler, tables
+    end
+    
+    def handle_default_constraint_element(parse)
+      parse.delegate_to DefaultConstraintHandler, column_defaults
+    end
+    
+    def handle_primary_key_element(parse)
+      parse.delegate_to PrimaryKeyHandler, pku_constraints
+    end
+    
+    def handle_foreign_key_element(parse)
+      parse.delegate_to ForeignKeyHandler, foreign_keys
+    end
+    
+    def handle_unique_constraint_element(parse)
+      parse.delegate_to UniqueConstraintHandler, pku_constraints
+    end
+    
+    def handle_check_constraint_element(parse)
+      parse.delegate_to CheckConstraintHandler, check_constraints
+    end
+    
+    def handle_index_element(parse)
+      parse.delegate_to IndexHandler, indexes
+    end
+    
+    def handle_statistics_element(parse)
+      parse.delegate_to StatisticsHandler, statistics
+    end
+    
+    def handle_view_element(parse)
+      parse.delegate_to ViewHandler, views
+    end
+    
+    def handle_stored_procedure_element(parse)
+      parse.delegate_to StoredProcedureHandler, procedures
+    end
+    
+    def handle_user_defined_function_element(parse)
+      parse.delegate_to FunctionHandler, udfs
+    end
+    
+    def handle_granted_element(parse)
+      parse.delegate_to PermissionHandler, permissions
+    end
+    
+    def handle_denied_element(parse)
+      parse.delegate_to PermissionHandler, permissions
+    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")
+      end
+      
+      # TODO: Sort dependencies of triggers, views, user defined functions, and
+      # stored procedures to determine which ones must be incorporated into a
+      # migration (all the ones depended on by any triggers).
+      
+      # Create schema_dir if it does not exist
+      @schema_dir.mkpath
+      
+      # Create and populate @schema_dir + XMigra::SchemaManipulator::DBINFO_FILE
+      dbinfo_path.open('w') do |dbi|
+        dbi.puts "system: #{XMigra::MSSQLSpecifics::SYSTEM_NAME}"
+      end
+      
+      # TODO: Create migration to check required filegroups and files
+      
+      # Migration: Create roles
+      create_migration(
+        "create-roles",
+        "Create roles for accessing the database.",
+        (roles.map(&:definition_sql) + roles.map(&:authorization_sql).compact + roles.map(&:membership_sql)).join("\n"),
+        roles.map(&:name).sort
+      )
+      
+      # Migration: Create schemas
+      create_migration(
+        "create-schemas",
+        "Create schemas for containing database objects and controlling access.",
+        joined_modobj_sql(schemas, sep: "\nGO\n"),
+        schemas.map(&:name).sort
+      )
+      
+      tables.each do |table|
+        # Migration: Create table
+        qual_name = [table.schema, table.name].join('.')
+        create_migration(
+          "create-table #{qual_name}",
+          "Create #{qual_name} table.",
+          table.to_sql,
+          [table.schema, qual_name]
+        )
+      end
+      
+      # Migration: Add column defaults
+      create_migration(
+        "add-column-defaults",
+        "Add default constraints to table columns.",
+        joined_modobj_sql(column_defaults),
+        column_defaults.map {|d| [d.schema, d.qualified_table, d.qualified_column, d.qualified_name].compact}.flatten.uniq.sort
+      )
+      
+      # Migration: Add primary key and unique constraints
+      create_migration(
+        "add-primary-key-and-unique-constraints",
+        "Add primary key and unique constraints.",
+        joined_modobj_sql(pku_constraints),
+        pku_constraints.map {|c| [c.schema, c.qualified_table, c.qualified_name].compact}.flatten.uniq.sort
+      )
+      
+      # Migration: Add foreign key constraints
+      create_migration(
+        "add-foreign-key-constraints",
+        "Add foreign key constraints.",
+        joined_modobj_sql(foreign_keys),
+        foreign_keys.map {|c| [c.schema, c.qualified_table, c.qualified_name].compact}.flatten.uniq.sort
+      )
+      
+      # Migration: Add check constraints
+      create_migration(
+        "add-check-constraints",
+        "Add check constraints.",
+        joined_modobj_sql(check_constraints),
+        check_constraints.map {|c| [c.schema, c.qualified_table, c.qualified_name].compact}.flatten.uniq.sort
+      )
+      
+      # 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|
+        access_object_names.include?(p.target)
+      end.group_by {|p| p.target}.tap do |problems|
+        raise UnsupportedFeatureError.new(
+          "#{problems[0].target} cannot be granted the required permission(s)."
+        ) if problems.length == 1
+        
+        raise UnsupportedFeatureError.new(
+          (
+            ["The required permissions cannot be granted on:"] +
+            problems.map {|p| '    ' + p.target}
+          ).join("\n")
+        ) unless problems.empty?
+      end
+      
+      # Write a migration with all super-permissions
+      super_permissions = permissions.map {|p| p.super_permissions_sql}.inject([], :concat)
+      create_migration(
+        "add-super-permissions",
+        "Add permissions that confound the normal GRANT model.",
+        super_permissions.join("\n"),
+        permissions.map {|p| p.super_permissions.map(&:unscoped_target)}.flatten.uniq.sort
+      ) unless super_permissions.empty?
+      
+      indexes.each do |index|
+        write_index_def(index)
+      end
+      
+      write_statistics
+      
+      views.each do |view|
+        write_access_def(view, 'view')
+      end
+      
+      udfs.each do |udf|
+        write_access_def(udf, 'function')
+      end
+      
+      procedures.each do |procedure|
+        write_access_def(procedure, 'stored procedure')
+      end
+      
+      @schema_dir.join(XMigra::SchemaManipulator::PERMISSIONS_FILE).open('w') do |p_file|
+        YAML.dump(
+          permissions.map do |p|
+            p.regular_permissions_graph.map do |k, v|
+              [k, {p.subject => v}]
+            end.to_h
+          end.inject({}) do |r, n|
+            r.update(n) {|k, lv, rv| lv.merge rv}
+          end,
+          p_file
+        )
+      end
+      
+      create_adoption_script
+    end
+    
+    def migration_chain
+      @migration_chain ||= XMigra::NewMigrationAdder.new(@schema_dir)
+    end
+    
+    def create_migration(summary, description, sql, change_targets)
+      migration_chain.add_migration(
+        summary,
+        description: description,
+        sql: sql,
+        changes: change_targets
+      )
+    end
+    
+    def joined_modobj_sql(ary, sep: "\n")
+      ary.map(&:to_sql).join(sep)
+    end
+    
+    def write_access_def(access_obj, obj_type)
+      # Use Psych mid-level emitting API to specify literal syntax for SQL
+      def_tree = Psych::Nodes::Mapping.new
+      ["define", obj_type, "sql"].each do |s|
+        def_tree.children << Psych::Nodes::Scalar.new(s)
+      end
+      def_tree.children << Psych::Nodes::Scalar.new(access_obj.to_sql, nil, nil, false, true,
+                                                    Psych::Nodes::Scalar::LITERAL)
+      unless (references = access_obj.respond_to?(:references) ? access_obj.references : []).empty?
+        def_tree.children << Psych::Nodes::Scalar.new('referencing')
+        def_tree.children << (ref_seq = Psych::Nodes::Sequence.new)
+        references.each do |r|
+          ref_seq.children << Psych::Nodes::Scalar.new(r)
+        end
+      end
+      
+      def_doc = Psych::Nodes::Document.new
+      def_doc.children << def_tree
+      def_stream = Psych::Nodes::Stream.new
+      def_stream.children << def_doc
+      
+      access_dir = @schema_dir.join(XMigra::SchemaManipulator::ACCESS_SUBDIR)
+      access_dir.mkpath
+      access_dir.join(access_obj.qualified_name + '.yaml').open('w') do |ao_file|
+        def_str = def_stream.to_yaml(nil, line_width: -1)
+        ao_file.puts(def_str)
+      end
+    end
+    
+    def write_index_def(index)
+      indexes_dir = @schema_dir.join(XMigra::SchemaManipulator::INDEXES_SUBDIR)
+      indexes_dir.mkpath
+      index_path = indexes_dir.join(index.name + '.yaml')
+      
+      raise UnsupportedFeatureError.new(
+        "Index file #{index_path} already exists."
+      ) if index_path.exist?
+      
+      index_path.open('w') do |index_file|
+        YAML.dump({'sql' => index.to_sql}, index_file, line_width: -1)
+      end
+    end
+    
+    def write_statistics
+      statistics_path = @schema_dir.join(XMigra::MSSQLSpecifics::STATISTICS_FILE)
+      
+      statistics_path.open('w') do |stats_file|
+        YAML.dump(
+          Hash[statistics.map(&:name_params_pair)],
+          stats_file,
+          line_width: -1
+        )
+      end
+    end
+    
+    def create_adoption_script
+      adoption_script_path = @schema_dir.join(ADOPTION_SQL_FILE)
+      
+      writer = AdoptionScriptWriter.new(self)
+      
+      writer.create_script adoption_script_path
+    end
+  end
+end

data/lib/mkxms/mssql/default_constraint_handler.rb

@@ -0,0 +1,46 @@
+module Mkxms; end
+
+module Mkxms::Mssql
+  class DefaultConstraint
+    def initialize(schema, table, column, name)
+      @schema, @table, @column, @name = schema, table, column, name
+      @expression = ''
+    end
+    
+    attr_accessor :schema, :table, :column, :name, :expression
+    
+    def to_sql
+      "ALTER TABLE #@schema.#@table ADD #{"CONSTRAINT #@name" if @name} DEFAULT #@expression FOR #@column;"
+    end
+    
+    def qualified_table
+      "#@schema.#@table"
+    end
+    
+    def qualified_column
+      "#@schema.#@table.#@column"
+    end
+    
+    def qualified_name
+      "#@schema.#@name" if @name
+    end
+  end
+
+  class DefaultConstraintHandler
+    def initialize(constraints, node)
+      a = node.attributes
+      @constraint = DefaultConstraint.new(
+        a['schema'],
+        a['table'],
+        a['column'],
+        a['name'],
+      ).tap do |c|
+        constraints << c
+      end
+    end
+    
+    def handle_text(text, parent_element)
+      @constraint.expression << text
+    end
+  end
+end

data/lib/mkxms/mssql/engine.rb

@@ -0,0 +1,88 @@
+require "rexml/document"
+require "rexml/element"
+require "mkxms/mssql/utils"
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class Mkxms::Mssql::Engine
+    ParseItem = Struct.new(:context, :node) do
+      def delegate_to(klass, *constructor_args)
+        args = constructor_args + [node]
+        self.context = klass.new(*args)
+      end
+    end
+    
+    MissingHandler = Struct.new(:context_class, :handler_name) do
+      def to_s
+        "#{self.context_class.name} does not define #{self.handler_name}"
+      end
+    end
+    
+    class ParseErrors < Exception
+      def initialize(errors)
+        @errors = errors
+        super(@errors.map(&:to_s).join("\n"))
+      end
+      
+      attr_reader :errors
+    end
+    
+    def initialize(document, initial_context)
+      @initial_context = initial_context
+      @parse_items = [ParseItem.new(initial_context, document.root)]
+      @missing_handlers = []
+    end
+    
+    attr_reader :missing_handlers
+    
+    def run
+      until @parse_items.empty?
+        parse_item
+      end
+      
+      errors = @missing_handlers
+      raise ParseErrors.new(errors) unless errors.empty?
+    end
+    
+    private
+    def parse_item
+      item = @parse_items.shift
+      case item.node
+      when REXML::Element
+        begin
+          handler = item.context.method(handler_name = element_handler_method_name(item.node))
+        rescue NameError
+          record_missing_handler(item.context.class, handler_name)
+          return
+        end
+        result = ParseItem.new(item.context, item.node)
+        handler[result]
+        @parse_items = item.node.children.select do |node|
+          [REXML::Element, REXML::Text].any? {|c| node.kind_of? c}
+        end.map do |node|
+          ParseItem.new(result.context, node)
+        end + @parse_items
+      when REXML::Text
+        begin
+          handler = item.context.method(:handle_text)
+        rescue
+          record_missing_handler(item.context.class, :handle_text) unless item.node.value =~ /^\s*$/
+          return
+        end
+        handler[item.node.value, item.node.parent]
+      end
+    end
+    
+    def element_handler_method_name(node)
+      case node
+      when REXML::Element
+        "handle_#{Utils.code_sym_for node.name}_element".to_sym
+      end
+    end
+    
+    def record_missing_handler(context_class, method_name)
+      @missing_handlers << MissingHandler.new(context_class, method_name)
+    end
+  end
+end