mkxms-mssql 1.0.0

data/lib/mkxms/mssql/exceptions.rb

@@ -0,0 +1,10 @@
+
+module Mkxms
+  module Mssql
+    class UnsupportedFeatureError < Exception
+    end
+    
+    class ProgramArgumentError < Exception
+    end
+  end
+end

data/lib/mkxms/mssql/filegroup_handler.rb

@@ -0,0 +1,81 @@
+require 'mkxms/mssql/property_handler'
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class Filegroup
+    include ExtendedProperties
+    
+    def initialize(default: false, read_only: false)
+      @default = default
+      @read_only = read_only
+    end
+    
+    def default?
+      return @default
+    end
+    
+    def read_only?
+      return @read_only
+    end
+  end
+
+  class FilegroupHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(filegroups, node)
+      group_options = Hash[
+        %w[default read-only].map do |a|
+          [Utils.code_sym_for(a), node.attributes.has_key?(a)]
+        end
+      ]
+      @filegroup = Filegroup.new(**group_options).tap do |fg|
+        filegroups << fg
+      end
+      @files = []
+    end
+    
+    def extended_properties
+      @filegroup.extended_properties
+    end
+    
+    def handle_file_element(parse)
+      parse.context = DatabaseFile.new(@files, parse.node)
+    end
+  end
+
+  class DatabaseFile
+    include ExtendedProperties, PropertyHandler::ElementHandler
+    
+    def initialize(files, node)
+      @properties = Hash[
+        node.attributes.each_pair.map do |k, v|
+          [Utils.code_sym_for(k), (k == v ? true : v)]
+        end
+      ]
+    end
+    
+    def name
+      @properties[:name]
+    end
+    
+    def offline?
+      @properties[:offline]
+    end
+    
+    def max_size_kb
+      value = @properties[:max_size]
+      return :available_space if value == 'available'
+      return value.to_i
+    end
+    
+    def growth
+      @properties[:growth].to_i
+    end
+    
+    def grow_by_fraction?
+      @properties[:growth_units] == 'percent'
+    end
+  end
+end

data/lib/mkxms/mssql/foreign_key_handler.rb

@@ -0,0 +1,85 @@
+require 'mkxms/mssql/property_handler'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class ForeignKey
+    include ExtendedProperties, Property::Hosting
+    
+    def self.generated_name
+      "XMigra_unnamed_foreign_key_constraint_#{@anon_counter = (@anon_counter || 0) + 1}"
+    end
+    
+    def initialize(schema, table, name, on_delete: 'NO ACTION', on_update: 'NO ACTION', enabled: true)
+      @schema = schema
+      @table = table
+      @delete_reconciliation = on_delete
+      @update_reconciliation = on_update
+      @enabled = enabled
+      @name = name || self.class.generated_name
+      @is_unnamed = !name
+      @links = []
+    end
+    
+    attr_accessor :schema, :table, :name
+    attr_accessor :delete_reconciliation, :update_reconciliation, :enabled
+    attr_accessor :references
+    attr_reader :links # Array of elements like [column_in_referrer, column_in_referent]
+    
+    def to_sql
+      "ALTER TABLE #{qualified_table} ADD CONSTRAINT #@name FOREIGN KEY (%s) REFERENCES #{@references[0]}.#{@references[1]} (%s)%s%s;" % [
+        @links.map {|e| e[0]}.join(', '),
+        @links.map {|e| e[1]}.join(', '),
+        (" ON DELETE #@delete_reconciliation" if @delete_reconciliation),
+        (" ON UPDATE #@update_reconciliation" if @update_reconciliation),
+      ] + (
+        @enabled ? '' : "\nALTER TABLE #{qualified_table} NOCHECK CONSTRAINT #@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 {|n| Utils.unquoted_name(n)}
+    end
+    
+    def unnamed?
+      @is_unnamed
+    end
+  end
+  
+  class ForeignKeyHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(constraints, node)
+      a = node.attributes
+      
+      @relation = ForeignKey.new(
+        a['schema'], a['table'], a['name'], 
+        on_delete: a['on-delete'], 
+        on_update: a['on-update'], 
+        enabled: !a['disabled']
+      ).tap do |k|
+        constraints << k
+      end
+    end
+    
+    def handle_referent_element(parse)
+      a = parse.node.attributes
+      
+      @relation.references = [a['schema'], a['name']]
+    end
+    
+    def handle_link_element(parse)
+      a = parse.node.attributes
+      
+      @relation.links << [a['from'], a['to']]
+    end
+  end
+end

data/lib/mkxms/mssql/function_handler.rb

@@ -0,0 +1,74 @@
+require 'mkxms/mssql/access_object_definition'
+require 'mkxms/mssql/property_handler'
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class Function
+    include ExtendedProperties, Property::Hosting, Property::SchemaScoped
+    include Utils::SchemaQualifiedName
+    
+    SQL_OBJECT_TYPE = 'FUNCTION'
+    
+    def initialize(attrs)
+      @schema = attrs['schema']
+      @name = attrs['name']
+      @definition = ''
+      @references = []
+      @param_properties = Hash.new {|h, k| h[k] = ''}
+    end
+    
+    attr_accessor :schema, :name
+    attr_reader :definition, :references, :param_properties
+    
+    def to_sql
+      mvdef = AccessObjectDefinition.replace_object_name(definition, "[{filename}]")
+      ([mvdef] + extended_properties_sql + param_properties_sql).join("\n")
+    end
+    
+    def param_properties_sql
+      @param_properties.each_pair.map do |k, v|
+        Property.addition_sql(k[1], v, property_subject_identifiers + ['PARAMETER', Utils.unquoted_name(k[0])])
+      end
+    end
+    
+    def qualified_name
+      "#@schema.#@name"
+    end
+  end
+
+  class FunctionHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(functions, node)
+      a = node.attributes
+      
+      @function = Function.new(a).tap do |f|
+        functions << f
+      end
+    end
+    
+    def extended_properties
+      @function.extended_properties
+    end
+    
+    def handle_definition_element(parse); end
+    
+    def handle_references_element(parse)
+      @function.references << %w[schema name].map {|k| parse.node.attributes[k]}.join('.')
+    end
+    
+    def handle_param_property(parse); end
+    
+    def handle_text(text, parent_element)
+      case [parent_element.namespace, parent_element.name]
+      when ['', 'definition']
+        @function.definition << text
+      when ['', 'param-property']
+        a = parent_element.attributes
+        @function.param_properties[[a['param'], a['property']]] << text
+      end
+    end
+  end
+end

data/lib/mkxms/mssql/indented_string_builder.rb

@@ -0,0 +1,199 @@
+require 'forwardable'
+require 'stringio'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class IndentedStringBuilder
+    NAMED_SUBSTITUTIONS = /\{(?<name>\S+)\}/
+    
+    class LineAccumulator
+      def initialize(indent, &flush_to)
+        @indent = indent
+        @flush_to = flush_to
+        @value = @indent.dup
+      end
+      
+      def flush
+        @flush_to[@value]
+        @value = @indent.dup
+      end
+      
+      def any_acculumation?
+        @value != @indent
+      end
+      
+      def <<(v)
+        @value << v
+        return self
+      end
+    end
+    
+    class DSL
+      extend Forwardable
+      
+      def self.for(builder, block)
+        new(builder, block.binding).instance_eval(&block)
+      end
+      
+      def initialize(builder, outer_binding)
+        @builder = builder
+        while sb = surrounding_binding(outer_binding)
+          outer_binding = sb
+        end
+        @outer_binding = outer_binding
+      end
+      
+      def_delegators :@builder, :indented
+      
+      def puts(*args, &blk)
+        if blk
+          @builder.puts(*args) {IndentedStringBuilder.new.tap {|i| i.dsl(&blk)}}
+        else
+          @builder.puts(*args)
+        end
+      end
+      
+      private
+      def method_missing(sym, *args, &blk)
+        if args.empty? and blk.nil?
+          @outer_binding.eval sym.to_s
+        else
+          @outer_binding.eval("method(:#{sym})").call(*args, &blk)
+        end
+      end
+      
+      def surrounding_binding(b)
+        if (b_self = b.eval("self")).kind_of? DSL
+          b_self.instance_variable_get(:@outer_binding)
+        end
+      end
+    end
+    
+    def initialize(options = {})
+      @io = StringIO.new
+      @indent = 0
+      @each_indent = options.fetch(:each_indent, "  ")
+    end
+    
+    def to_s
+      @io.string
+    end
+    
+    def indented(n = 1)
+      prev_indent = @indent
+      @indent += n
+      begin
+        yield
+      ensure
+        @indent = prev_indent
+      end
+    end
+    
+    def puts(s = "", options = {})
+      sub_pattern = options.fetch(:sub, '%s')
+      sub_pattern = NAMED_SUBSTITUTIONS if sub_pattern == :named
+      if sub_pattern.nil?
+        @io.puts(s)
+        return s.each_line.lazy.map {|l| l.chomp}
+      end
+      
+      sub_pattern = Regexp.compile(Regexp.escape(sub_pattern)) unless sub_pattern.is_a? Regexp
+      sub_name_index = sub_pattern.named_captures.fetch('name', []).min
+      scan_pattern = Regexp.union(sub_pattern, /\n|$/)
+      current_indent = indent_string
+      
+      i = Enumerator.new {|y| v = 0; loop {y.yield(v); v += 1}}
+      completed = 0
+
+      lines = Enumerator.new do |e|
+        if s.is_a? Range
+          e.yield(current_indent + s.begin)
+          body = yield
+          hanging_indent = current_indent + @each_indent
+          if body.is_a?(String) || !body.respond_to?(:each)
+            body = body.to_s.each_line
+          end
+          body.each {|l| e.yield(hanging_indent + l.chomp)}
+          e.yield(current_indent + s.end)
+          next
+        end
+        
+        line = LineAccumulator.new(current_indent) {|v| e.yield v}
+        subbed_multiline = false
+        s.scan(scan_pattern) do |m|
+          chunk_range, completed = completed...$~.begin(0), $~.end(0)
+          chunk_empty = !chunk_range.cover?(chunk_range.begin)
+          
+          case
+          when m == "\n"
+            (line << s[chunk_range]).flush if line.any_acculumation? || !chunk_empty
+            next
+          when m == "" && !chunk_empty
+            (line << s[chunk_range]).flush
+            next
+          when m == ""
+            line.flush if line.any_acculumation?
+            next
+          end
+          
+          # Expect repl is a string or an enumerator of lines
+          prev_indent = @indent
+          @indent += 1
+          hanging_indent = indent_string
+          begin
+            yield_from_string = proc do |r|
+              s_chunk = s[chunk_range]
+              if r.include? "\n"
+                line << s_chunk if line.any_acculumation? || !s_chunk.match(/^\s*$/)
+                line.flush if line.any_acculumation?
+                r.each_line {|l| e.yield(hanging_indent + l.chomp)}
+              else
+                line << s_chunk << r
+              end
+            end
+            
+            yield_args = []
+            yield_args << m[sub_name_index - 1] if sub_name_index
+            yield_args << i.next
+            case repl = yield(*yield_args)
+            when String
+              yield_from_string[repl]
+            when ->(v){v.respond_to? :each}
+              (line << s[chunk_range]).flush
+              repl.each {|l| e.yield(
+                hanging_indent + 
+                l.chomp.gsub("\n", hanging_indent + "\n")
+              )}
+            else
+              yield_from_string[repl.to_s]
+            end
+          ensure
+            @indent = prev_indent
+          end
+        end
+      end
+      
+      lines.tap {|e| e.dup.each {|l| @io.puts l}}
+    end
+    
+    def dsl(&block)
+      DSL.for(self, block)
+      return self
+    end
+    
+    def self.dsl(&block)
+      new.dsl(&block).to_s
+    end
+    
+    def each
+      @io.string.each_line {|l| yield l.chomp}
+    end
+    include Enumerable
+    
+    protected
+    def indent_string
+      @each_indent * @indent
+    end
+  end
+end