mkxms-mssql 1.0.0

data/lib/mkxms/mssql/role_handler.rb

@@ -0,0 +1,55 @@
+require 'mkxms/mssql/property_handler'
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class Role
+    include ExtendedProperties, Property::Hosting
+    
+    def initialize(name, owner: nil)
+      @name = name
+      @owner = owner
+      @encompassing_roles = []
+    end
+    
+    attr_accessor :name, :owner
+    attr_reader :encompassing_roles
+    
+    def definition_sql
+      "CREATE ROLE #{name};" + extended_properties_sql.joined_on_new_lines
+    end
+    
+    def authorization_sql
+      "ALTER AUTHORIZATION ON ROLE:: #{name} TO #{owner};" if owner
+    end
+    
+    def membership_sql
+      encompassing_roles.map do |encompassing_role|
+        "EXEC sp_addrolemember '#{Utils.unquoted_name encompassing_role}', '#{Utils.unquoted_name name}';\n"
+      end.join('')
+    end
+    
+    def property_subject_identifiers
+      ['USER', Utils.unquoted_name(name)]
+    end
+  end
+  
+  class RoleHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(roles, node)
+      @role = Role.new(node.attributes['name'], owner: node.attributes['owner']).tap do |r|
+        roles << r
+      end
+    end
+    
+    def extended_properties
+      @role.extended_properties
+    end
+    
+    def handle_member_of_element(parse)
+      @role.encompassing_roles << parse.node.attributes['name']
+    end
+  end
+end

data/lib/mkxms/mssql/schema_handler.rb

@@ -0,0 +1,42 @@
+require 'mkxms/mssql/property_handler'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class Schema
+    include ExtendedProperties, Property::Hosting
+    
+    def initialize(name, owner: nil)
+      @name = name
+      @owner = owner
+    end
+    
+    attr_accessor :name, :owner
+    
+    def to_sql
+      if owner
+        "CREATE SCHEMA #{name} AUTHORIZATION #{owner};"
+      else
+        "CREATE SCHEMA #{name};"
+      end + extended_properties_sql.joined_on_new_lines
+    end
+    
+    def property_subject_identifiers
+      ['SCHEMA', Utils.unquoted_name(name)]
+    end
+  end
+
+  class SchemaHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(schemas, node)
+      @schema = Schema.new(node.attributes['name'], owner: node.attributes['owner']).tap do |s|
+        schemas << s
+      end
+    end
+    
+    def extended_properties
+      @schema.extended_properties
+    end
+  end
+end

data/lib/mkxms/mssql/sql_string_manipulators.rb

@@ -0,0 +1,46 @@
+require 'xmigra'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  module SqlStringManipulators
+    MSSQL = XMigra::MSSQLSpecifics
+    
+    def dedent(s)
+      margin = nil
+      s.lines.map do |l|
+        case 
+        when margin.nil? && l =~ /^ *$/
+          l
+        when margin.nil?
+          margin = /^ */.match(l).length
+          l[margin..-1]
+        when s =~/^\s*$/
+          l[margin..-1]
+        else
+          /^(?: *)(.*)/.match(l)[1]
+        end
+      end.join('')
+    end
+    
+    def stresc(s)
+      s.gsub("'", "''")
+    end
+    
+    def strlit(s)
+      MSSQL.string_literal(s)
+    end
+    
+    def unquoted_identifier(s)
+      MSSQL.strip_identifier_quoting(s)
+    end
+    
+    def bit_test(expr, expected)
+      "#{expr} = #{expected ? 1 : 0}"
+    end
+    
+    def boolean_desc(_is, s)
+      (_is ? '' : 'not ') + s
+    end
+  end
+end

data/lib/mkxms/mssql/statistics_handler.rb

@@ -0,0 +1,59 @@
+require 'mkxms/mssql/property_handler'
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class Statistics
+    extend Utils::FlagsQueries
+    include ExtendedProperties
+    
+    def initialize(attrs)
+      @schema = attrs['in-schema']
+      @relation = attrs['on']
+      @name = attrs['name']
+      @columns = []
+      @flags = []
+      
+      @flags << :manual_recompute if attrs['no-recompute']
+    end
+    
+    attr_accessor :schema, :relation, :name
+    attr_reader :columns, :flags
+    flags_query :manual_recompute
+    
+    def xmigra_params
+      [qualified_relation, @columns.join(', ')].tap do |result|
+        result << {'with' => 'NORECOMPUTE'} if manual_recompute?
+      end
+    end
+    
+    def name_params_pair
+      [name, xmigra_params]
+    end
+    
+    def qualified_relation
+      "#@schema.#@relation"
+    end
+  end
+  
+  class StatisticsHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(statistics_objs, node)
+      a = node.attributes
+      
+      @statistics = Statistics.new(a).tap do |s|
+        statistics_objs << s
+      end
+    end
+    
+    def extended_properties
+      @statistics.extended_properties
+    end
+    
+    def handle_column_element(parse)
+      @statistics.columns << parse.node.attributes['name']
+    end
+  end
+end

data/lib/mkxms/mssql/stored_procedure_handler.rb

@@ -0,0 +1,65 @@
+require 'mkxms/mssql/access_object_definition'
+require 'mkxms/mssql/property_handler'
+require 'mkxms/mssql/utils'
+
+module Mkxms::Mssql
+  class StoredProcedure
+    include ExtendedProperties, Property::Hosting, Property::SchemaScoped
+    include Utils::SchemaQualifiedName
+    
+    SQL_OBJECT_TYPE = 'PROCEDURE'
+    
+    def initialize(attrs)
+      @schema = attrs['schema']
+      @name = attrs['name']
+      @definition = ''
+      @param_properties = Hash.new {|h, k| h[k] = ''}
+    end
+    
+    attr_accessor :schema, :name
+    attr_reader :definition, :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
+  end
+
+  class StoredProcedureHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(procedures, node)
+      a = node.attributes
+      
+      @procedure = StoredProcedure.new(a).tap do |sp|
+        procedures << sp
+      end
+    end
+    
+    def extended_properties
+      @procedure.extended_properties
+    end
+    
+    def handle_definition_element(parse); end
+    
+    def handle_references_element(parse); end
+    
+    def handle_param_property_element(parse); end
+    
+    def handle_text(text, parent_element)
+      case [parent_element.namespace, parent_element.name]
+      when ['', 'definition']
+        @procedure.definition << text
+      when ['', 'param-property']
+        a = parent_element.attributes
+        @procedure.param_properties[[a['param'], a['property']]] << text
+      end
+    end
+  end
+end

data/lib/mkxms/mssql/table_handler.rb

@@ -0,0 +1,180 @@
+require 'mkxms/mssql/exceptions'
+require 'mkxms/mssql/property_handler'
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class Table
+    SQL_OBJECT_TYPE = 'TABLE'
+    include ExtendedProperties, Property::Hosting, Property::SchemaScoped
+    
+    def initialize(schema, name)
+      @schema = schema
+      @name = name
+      @columns = []
+    end
+    
+    attr_accessor :schema, :name, :owner, :heap_storage, :lob_storage
+    attr_reader :columns
+    
+    def to_sql
+      lines = ["CREATE TABLE #{schema}.#{name} ("]
+      lines << columns.map{|c| "    " + c.to_sql}.join(",\n")
+      lines << ")"
+      
+      lines << "ON #{heap_storage}" if heap_storage
+      lines << "TEXTIMAGE_ON #{lob_storage}" if lob_storage
+      
+      lines << ";"
+      lines << ""
+      
+      if owner
+        lines << ["ALTER AUTHORIZATION ON OBJECT::#{schema}.#{name} TO #{owner};"]
+        lines << ""
+      end
+      
+      lines.concat extended_properties_sql
+      
+      columns.each do |col|
+        lines.concat subitem_extended_properties_sql(col)
+      end
+      
+      return lines.join("\n")
+    end
+  end
+
+  class Column
+    SQL_OBJECT_TYPE = 'COLUMN'
+    
+    include ExtendedProperties
+    extend Utils::FlagsQueries
+    
+    def initialize(name)
+      @name = name
+      @flags = []
+      @type_info = {}
+    end
+    
+    attr_accessor :name, :type, :collation, :computed_expression
+    attr_reader :flags, :type_info
+    
+    flags_query :filestream, :nullable, :identity, :replicated, :rowguid, :persisted
+    
+    def to_sql
+      parts = [name]
+      if computed_expression
+        parts << "AS " + computed_expression
+        parts << "PERSISTED" if persisted?
+      else
+        each_type_part {|part| parts << part}
+      end
+      
+      return parts.join(' ')
+    end
+    
+    def each_type_part
+      yield type
+      yield("COLLATE " + collation) if collation
+      yield(nullable? ? 'NULL' : 'NOT NULL')
+      if identity?
+        yield "IDENTITY"
+        yield("NOT FOR REPLICATION") unless replicated?
+      end
+      yield("ROWGUID") if rowguid?
+    end
+  end
+
+  class TableHandler
+    class ColumnHandler
+      include PropertyHandler::ElementHandler
+      
+      def initialize(columns, node)
+        a = node.attributes
+        
+        col_attrs = {}
+        use_attr = proc {|k| col_attrs[k.gsub('-', '_').to_sym] = node.attributes[k]}
+        col_type = %w[type-schema type].map {|k| use_attr[k]}.compact.join('.')
+        
+        if a.has_key?('capacity')
+          col_type << "(%s)" % [use_attr['capacity']]
+        end
+        
+        prec_scale = []
+        if a.has_key?('precision') || a.has_key?('scale')
+          prec_scale << use_attr['precision']
+        end
+        if a.has_key?('scale')
+          prec_scale << use_attr['scale']
+        end
+        unless prec_scale.empty?
+          col_type << "(%s)" % (prec_scale.join(', '))
+        end
+        
+        if a.has_key?('xml_collection_id')
+          col_type << "(%s %s)" % [
+            xml_structure = (a['full-xml-document'] ? 'DOCUMENT' : 'CONTENT'),
+            a['xml_collection_id']
+          ]
+          col_attrs[:xml_validation] = {xml_structure.downcase => a['xml_collection_id']}
+        end
+        
+        raise UnsupportedFeatureError.new("Column #{name} declared 'not-ansi-padded'") if a['not-ansi-padded']
+        
+        @column = Column.new(a['name']).tap do |c|
+          c.type = col_type
+          c.collation = a['collation']
+          c.flags << :nullable if a['nullable']
+          c.flags << :replicated if a['replicated']
+          c.flags << :filestream if a['filestream']
+          c.type_info.update(col_attrs)
+          columns << c
+        end
+      end
+      
+      attr_reader :column
+      
+      def extended_properties
+        @column.extended_properties
+      end
+      
+      def handle_computed_expression_element(parse)
+        column.flags << :persisted if parse.node.attributes['persisted']
+        # Handle expression in #handle_text
+      end
+      
+      def handle_text(text, parent_element)
+        case %i[namespace name].map {|m| parent_element.send(m)}
+        when ['', 'computed-expression']
+          (column.computed_expression ||= '') << text
+        end
+      end
+    end
+    
+    include PropertyHandler::ElementHandler
+    
+    def initialize(tables, node)
+      a = node.attributes
+      @table = Table.new(a['schema'], a['name']).tap do |t|
+        tables << t
+      end
+      @table.owner = a['owner']
+      @table.heap_storage = a['rows-on']
+      @table.lob_storage = a['textimage-on']
+      @identity_column = a['identity']
+      @rowguid_column = a['rowguidcol']
+    end
+    
+    def extended_properties
+      @table.extended_properties
+    end
+    
+    def handle_column_element(parse)
+      parse.context = ColumnHandler.new(@table.columns, parse.node)
+      column = parse.context.column
+      
+      column.flags << :identity if column.name.eql? @identity_column
+      column.flags << :rowguid if column.name.eql? @rowguid_column
+    end
+  end
+end