mkxms-mssql 1.0.0

data/lib/mkxms/mssql/index_column.rb

@@ -0,0 +1,11 @@
+module Mkxms; end
+module Mkxms::Mssql; end
+
+Mkxms::Mssql.const_set(
+  :IndexColumn,
+  Struct.new(:name, :direction) do
+    def to_sql
+      "#{name} #{direction == :descending ? 'DESC' : 'ASC'}"
+    end
+  end
+)

data/lib/mkxms/mssql/index_handler.rb

@@ -0,0 +1,98 @@
+require 'mkxms/mssql/property_handler'
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class Index
+    extend Utils::FlagsQueries
+    include ExtendedProperties, Property::Hosting
+    
+    def initialize(attrs)
+      @schema = attrs['schema']
+      @relation = attrs['relation']
+      @name = attrs['name']
+      @fill_factor = attrs['fill-factor']
+      @spatial_index_geometry = attrs['spatial-index-over']
+      @cells_per_object = attrs['cells-per-object']
+      @storage = attrs['stored-on']
+      @columns = []
+      @included_columns = []
+      
+      @flags = []
+      @flags << :unique if attrs['unique']
+      @flags << :padded if attrs['padded']
+      @flags << :disabled if attrs['disabled']
+      @flags << :ignore_duplicates if attrs['ignore-duplicates']
+      @flags << :row_locks_prohibited if attrs['no-row-locks']
+      @flags << :page_locks_prohibited if attrs['no-page-locks']
+    end
+    
+    attr_accessor :schema, :relation, :name, :fill_factor, :spatial_index_geometry, :cells_per_object, :storage
+    attr_reader :columns, :included_columns, :flags
+    
+    flags_query :unique, :padded, :ignore_duplicates, :row_locks_prohibited, :page_locks_prohibited
+    
+    def to_sql
+      if @spatial_index_geometry
+      else
+        [].tap do |parts|
+          parts << "CREATE #{'UNIQUE ' if unique?}INDEX #@name ON #{qualified_relation} (\n" +
+          @columns.map(&:to_sql).join(', ') +
+          "\n)"
+          
+          parts << "INCLUDE (\n" +
+          @included_columns.map(&:name).join(', ') +
+          "\n)" unless @included_columns.empty?
+          
+          # TODO: "WHERE" clause
+          
+          options = []
+          options << "PAD_INDEX = ON" if padded?
+          options << "FILLFACTOR = #@fill_factor" if @fill_factor
+          options << "IGNORE_DUP_KEY = ON" if ignore_duplicates?
+          options << "ALLOW_ROW_LOCKS = OFF" if row_locks_prohibited?
+          options << "ALLOW_PAGE_LOCKS = OFF" if page_locks_prohibited?
+          parts << "WITH (#{options.join(', ')})" unless options.empty?
+          
+          parts << "ON #@storage" if @storage
+          
+        end.join(' ') + ';' + extended_properties_sql.joined_on_new_lines
+      end
+    end
+    
+    def property_subject_identifiers
+      ['SCHEMA', @schema, 'TABLE', @relation, 'INDEX', @name].map {|n| Utils.unquoted_name(n)}
+    end
+    
+    def qualified_relation
+      [@schema, @relation].join '.'
+    end
+  end
+  
+  class IndexHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(indexes, node)
+      @index = Index.new(node.attributes).tap do |i|
+        indexes << i
+      end
+    end
+    
+    def extended_properties
+      @index.extended_properties
+    end
+    
+    def handle_column_element(parse)
+      a = parse.node.attributes
+      
+      if a['included']
+        @index.included_columns << IndexColumn.new(a['name'])
+      else
+        @index.columns << IndexColumn.new(a['name'], a['desc'] ? :descending : :ascending)
+      end
+    end
+    
+    # TODO: Handle partition columns
+  end
+end

data/lib/mkxms/mssql/keylike_constraint_helper.rb

@@ -0,0 +1,67 @@
+require 'mkxms/mssql/index_column'
+require 'mkxms/mssql/property_handler'
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class KeylikeConstraint
+    extend Utils::FlagsQueries
+    include ExtendedProperties, Property::Hosting
+    
+    def initialize(attrs)
+      @schema = attrs['schema']
+      @table = attrs['table']
+      @name = attrs['name']
+      @stored_on = attrs['stored-on']
+      @fill_factor = attrs['fill-factor']
+      
+      @flags = []
+      @flags << :clustered if attrs['clustered']
+      @flags << :paddedd if attrs['padded']
+      @flags << :row_locks_ok unless attrs['no-row-locks']
+      @flags << :page_locks_ok unless attrs['no-page-locks']
+      
+      @columns = []
+    end
+    
+    attr_accessor :schema, :table, :name, :stored_on, :fill_factor
+    attr_reader :columns, :flags
+    flags_query :clustered, :padded, :row_locks_ok, :page_locks_ok
+    
+    def to_sql
+      "ALTER TABLE #@schema.#@table ADD #{"CONSTRAINT #@name " if @name}" +
+      "#{self.sql_constraint_type} #{'NON' unless clustered?}CLUSTERED (\n" +
+      '    ' + columns.map {|c| c.to_sql}.join(", ") +
+      "\n)" +
+      with_clause_sql +
+      # TODO: Handle partitioned constraints
+      "#{" ON #@stored_on" if @stored_on}" +
+      ";" +
+      (name ? extended_properties_sql.joined_on_new_lines : '')
+    end
+    
+    def with_clause_sql
+      options = []
+      options << 'PAD_INDEX = ON' if padded?
+      options << "FILLFACTOR = #@fill_factor" if fill_factor
+      options << 'ALLOW_ROW_LOCKS = OFF' unless row_locks_ok?
+      options << 'ALLOW_PAGE_LOCKS = OFF' unless page_locks_ok?
+      
+      return '' if options.empty?
+      return " WITH (\n#{options.join ", "}\n)"
+    end
+    
+    def qualified_table
+      "#@schema.#@table"
+    end
+    
+    def qualified_name
+      "#@schema.#@name" if @name
+    end
+    
+    def property_subject_identifiers
+      @prop_subj_id ||= ['SCHEMA', schema, 'TABLE', table, 'CONSTRAINT', name].map {|s| Utils::unquoted_name(s)}
+    end
+  end
+end

data/lib/mkxms/mssql/permission_handler.rb

@@ -0,0 +1,115 @@
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class PermissionGroup
+    ACTION_STATEMENT_PROLOG_TEMPLATES = {
+      'granted' => 'GRANT %s ON %s TO %s',
+      'denied' => 'DENY %s ON %s TO %s',
+    }
+    
+    def initialize(action, subject)
+      @action = action
+      @subject = subject
+      @permissions = []
+    end
+    
+    attr_accessor :action, :subject
+    attr_reader :permissions
+    
+    def super_permissions_sql
+      super_permissions.map do |p|
+        ''.tap do |sql|
+          sql << ACTION_STATEMENT_PROLOG_TEMPLATES[action] % [p.name, p.target, subject]
+          sql << ' WITH GRANT OPTION' if p.grant_option?
+          sql << ';'
+        end
+      end
+    end
+    
+    def regular_permissions_graph
+      Hash.new.tap do |result|
+        regular_permissions.sort {|a, b| a.target <=> b.target}.group_by {|p| p.target}.each_pair do |target, perms|
+          result[target] = perms.map(&:name)
+        end
+      end
+    end
+    
+    def is_super_permission?(p)
+      action != 'granted' || p.grant_option?
+    end
+    
+    def super_permissions
+      permissions.select {|p| is_super_permission? p}
+    end
+    
+    def regular_permissions
+      permissions.select {|p| !is_super_permission? p}
+    end
+  end
+  
+  class Permission
+    def initialize(attrs)
+      @name = attrs['name']
+      @target_type = attrs['target-type']
+      @name_scope = attrs['name-scope']
+      @schema = attrs['in-schema']
+      @object = attrs['on']
+      @column = attrs['column']
+      @target = if @object
+        "".tap do |subject|
+          if @schema
+            subject << (@schema + '.')
+          end
+          subject << @object
+          subject << " (#@column)" if @column
+        end
+      else
+        'DATABASE'
+      end
+      @grant_option = attrs['with-grant-option']
+      @authority = attrs['by']
+    end
+    
+    attr_accessor :name, :target_type, :name_scope, :column, :authority
+    
+    def target(scoped: true)
+      if scoped && @name_scope
+        "#@name_scope :: #@target"
+      else
+        @target
+      end
+    end
+    
+    def unscoped_target
+      target(scoped: false)
+    end
+    
+    def grant_option?
+      @grant_option
+    end
+    def grant_option=(value)
+      @grant_option = value
+    end
+    
+    def object_id_parts
+      [@target_type, @schema, @object, @column]
+    end
+  end
+  
+  class PermissionHandler
+    def initialize(permissions, node)
+      a = node.attributes
+      
+      @action = PermissionGroup.new(node.name, a['to'] || a['from']).tap do |pg|
+        permissions << pg
+      end
+    end
+    
+    def handle_permission_element(parse)
+      a = parse.node.attributes
+      @action.permissions << Permission.new(a)
+    end
+  end
+end

data/lib/mkxms/mssql/primary_key_handler.rb

@@ -0,0 +1,36 @@
+require 'mkxms/mssql/keylike_constraint_helper'
+
+module Mkxms::Mssql
+  class PrimaryKey < Mkxms::Mssql::KeylikeConstraint
+    SQL_CONSTRAINT_TYPE = 'PRIMARY KEY'
+    
+    def sql_constraint_type
+      SQL_CONSTRAINT_TYPE
+    end
+  end
+
+  class PrimaryKeyHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(constraints, node)
+      a = node.attributes
+      
+      @pkey = PrimaryKey.new(a).tap do |c|
+        constraints << c
+      end
+    end
+    
+    def extended_properties
+      @pkey.extended_properties
+    end
+    
+    def handle_column_element(parse)
+      a = parse.node.attributes
+      
+      raise UnsupportedFeatureError.new("Primary keys may not specify included columns (#{@pkey.qualified_table})") if a['included']
+      @pkey.columns << IndexColumn.new(a['name'], a['desc'] ? :descending : :ascending)
+    end
+    
+    # TODO: Handle partitioned primary keys
+  end
+end

data/lib/mkxms/mssql/property_handler.rb

@@ -0,0 +1,87 @@
+require 'base64'
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  module ExtendedProperties
+    def extended_properties
+      @extended_properties ||= {}
+    end
+  end
+  
+  module Property
+    def self.addition_sql(name, value, subject_identification_parts)
+      "EXEC sp_addextendedproperty N'%s', %s, %s;" % [
+        name,
+        value,
+        subject_identification_parts.map {|part| "N'#{part}'"}.join(', ')
+      ]
+    end
+    
+    module Hosting
+      def extended_properties_sql
+        self.extended_properties.each_pair.map do |name, value|
+          Mkxms::Mssql::Property.addition_sql(name, value, self.property_subject_identifiers)
+        end.tap do |v|
+          class <<v
+            def joined_on_new_lines(indent: '    ')
+              map {|i| "\n" + indent + i}.join('')
+            end
+          end
+        end
+      end
+    end
+    
+    module SchemaScoped
+      def property_subject_identifiers
+        ['SCHEMA', Utils::unquoted_name(schema), self.class::SQL_OBJECT_TYPE.upcase, Utils.unquoted_name(name)]
+      end
+      
+      def subitem_extended_properties_sql(subitem)
+        subitem.extended_properties.each_pair.map do |name, value|
+          Mkxms::Mssql::Property.addition_sql(
+            name, value,
+            property_subject_identifiers + [subitem.class::SQL_OBJECT_TYPE.upcase, Utils.unquoted_name(subitem.name)]
+          )
+        end
+      end
+    end
+  end
+
+  class PropertyHandler
+    module ElementHandler
+      def handle_property_element(parse)
+        parse.context = PropertyHandler.new(self, parse.node.attributes)
+      end
+    end
+    
+    def initialize(describable, attrs)
+      @describable = describable
+      @name = attrs['name']
+      @value_type = attrs['type'].downcase
+    end
+    
+    def handle_text(property_value, node)
+      stored_value = property_value.dup
+      
+      stored_value = Base64.decode64(stored_value) if @value_type.include? 'binary'
+      
+      stored_value.define_singleton_method(
+        :to_sql_literal,
+        &(case @value_type
+        when 'char', 'varchar', 'uniqueidentifier', 'smalldatetime', 'datetime'
+          ->() {"'#{self}'"}
+        when 'nchar', 'nvarchar'
+          ->() {"N'#{self}'"}
+        when 'binary', 'varbinary'
+          ->() {"0x" + self.bytes.map {|b| "%02x" % b}.join}
+        else
+          ->() {self.to_s}
+        end)
+      )
+      
+      @describable.extended_properties[@name] = stored_value
+    end
+  end
+end

data/lib/mkxms/mssql/query_cursor.rb

@@ -0,0 +1,111 @@
+module Mkxms; end
+
+module Mkxms::Mssql
+  class QueryCursor
+    def initialize(select_statement, variables, options = {})
+      @select_statement = select_statement
+      @select_statement += ';' unless @select_statement.end_with? ';'
+      @cursor = options[:cursor_name] || self.class.generated_cursor_name
+      @out = options[:output_to] || $stdout
+      @global = options[:global]
+      @indent = options[:indent] || '  '
+      
+      @variable_decl = variables.gsub(/\s+/, ' ')
+      @variable_names = variables.split(',').map do |vardecl|
+        vardecl.chomp.split(nil, 2)[0]
+      end
+    end
+    
+    attr_reader :cursor_name
+    
+    def each_row
+      set_up_loop
+      fetch_next
+      @out.puts "WHILE @@FETCH_STATUS = 0"
+      @out.puts "BEGIN"
+      yield
+      fetch_next(@indent)
+      @out.puts "END;"
+    end
+    
+    class ExpectedRowTest
+      def initialize(test_proc)
+        @test_proc = test_proc
+      end
+      
+      def row(*args, &blk)
+        @test_proc.call(*args, &blk)
+      end
+    end
+    
+    def expectations(opts = {})
+      extra_action = expectation_failure_action(opts[:on_extra])
+      test_entry_proc = if missing_action = expectation_failure_action(opts[:on_missing])
+        proc {|&blk| test_entry(on_missing: missing_action, &blk)}
+      else
+        method(:test_entry)
+      end
+      
+      set_up_loop
+      
+      yield ExpectedRowTest.new(test_entry_proc)
+      
+      if extra_action
+        fetch_next
+        @out.puts "IF @@FETCH_STATUS = 0"
+        @out.puts "BEGIN"
+        extra_action.call
+        @out.puts "END;"
+      end
+      
+      tear_down_loop
+    end
+    
+    def test_entry(opts = {})
+      opts = {} unless opts.kind_of? Hash
+      missing_action = expectation_failure_action(opts[:on_missing]) || proc {}
+      fetch_next
+      @out.puts "IF @@FETCH_STATUS <> 0"
+      @out.puts "BEGIN"
+      missing_action.call
+      @out.puts "END ELSE BEGIN"
+      yield
+      @out.puts "END;"
+    end
+    
+    def expectation_failure_action(value)
+      case value
+      when Proc then value
+      when String then proc {@out.puts(@indent + value)}
+      end
+    end
+    
+    def cursor_scope(explicit_local = true)
+      case
+      when @global then 'GLOBAL'
+      when explicit_local then 'LOCAL'
+      else ''
+      end
+    end
+    
+    def set_up_loop
+      @out.puts "DECLARE #@variable_decl;"
+      @out.puts "DECLARE #@cursor CURSOR #{cursor_scope} FOR"
+      @out.puts @select_statement
+      @out.puts "OPEN #@cursor;"
+    end
+    
+    def fetch_next(indent = '')
+      @out.puts(indent + "FETCH NEXT FROM #@cursor INTO #{@variable_names.join(', ')};")
+    end
+    
+    def tear_down_loop
+      @out.puts "CLOSE #{cursor_scope(false)} #@cursor; DEALLOCATE #{cursor_scope(false)} #@cursor;"
+    end
+    
+    def self.generated_cursor_name
+      @gensym_number ||= 0
+      "gensym_cursor_#{@gensym_number += 1}"
+    end
+  end
+end