mkxms-mssql 1.0.0 → 1.1.0

data/lib/mkxms/mssql/primary_key_handler.rb

@@ -16,14 +16,11 @@ module Mkxms::Mssql
       a = node.attributes
       
       @pkey = PrimaryKey.new(a).tap do |c|
+        store_properties_on c
         constraints << c
       end
     end
     
-    def extended_properties
-      @pkey.extended_properties
-    end
-    
     def handle_column_element(parse)
       a = parse.node.attributes
       

data/lib/mkxms/mssql/property_handler.rb

@@ -54,6 +54,14 @@ module Mkxms::Mssql
       def handle_property_element(parse)
         parse.context = PropertyHandler.new(self, parse.node.attributes)
       end
+      
+      private
+      def store_properties_on(target)
+        define_singleton_method(:extended_properties) do
+          target.extended_properties
+        end
+        return target
+      end
     end
     
     def initialize(describable, attrs)

data/lib/mkxms/mssql/query_cursor.rb

@@ -4,9 +4,10 @@ module Mkxms::Mssql
   class QueryCursor
     def initialize(select_statement, variables, options = {})
       @select_statement = select_statement
-      @select_statement += ';' unless @select_statement.end_with? ';'
+      @select_statement += ';' unless @select_statement =~ /;\s*\Z/
       @cursor = options[:cursor_name] || self.class.generated_cursor_name
       @out = options[:output_to] || $stdout
+      @indented = @out.respond_to?(:indented) ? @out.method(:indented) : ->(&blk) {blk.call}
       @global = options[:global]
       @indent = options[:indent] || '  '
       
@@ -54,7 +55,7 @@ module Mkxms::Mssql
         fetch_next
         @out.puts "IF @@FETCH_STATUS = 0"
         @out.puts "BEGIN"
-        extra_action.call
+        indented {extra_action.call}
         @out.puts "END;"
       end
       
@@ -64,12 +65,15 @@ module Mkxms::Mssql
     def test_entry(opts = {})
       opts = {} unless opts.kind_of? Hash
       missing_action = expectation_failure_action(opts[:on_missing]) || proc {}
+      @out.puts
       fetch_next
       @out.puts "IF @@FETCH_STATUS <> 0"
       @out.puts "BEGIN"
-      missing_action.call
+      indented {missing_action.call}
       @out.puts "END ELSE BEGIN"
-      yield
+      indented {
+        yield
+      }
       @out.puts "END;"
     end
     
@@ -103,6 +107,10 @@ module Mkxms::Mssql
       @out.puts "CLOSE #{cursor_scope(false)} #@cursor; DEALLOCATE #{cursor_scope(false)} #@cursor;"
     end
     
+    def indented(&blk)
+      @indented.call(&blk)
+    end
+    
     def self.generated_cursor_name
       @gensym_number ||= 0
       "gensym_cursor_#{@gensym_number += 1}"

data/lib/mkxms/mssql/references_handler.rb

@@ -0,0 +1,24 @@
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  Reference = Struct.new(:schema, :name) do
+    include Utils::SchemaQualifiedName
+  end
+  
+  module Dependencies
+    def dependencies
+      @dependencies ||= []
+    end
+  end
+  
+  class ReferencesHandler
+    module ElementHandler
+      def handle_references_element(parse)
+        a = parse.node.attributes
+        referrer.dependencies << Reference.new(a['schema'], a['name'])
+      end
+    end
+  end
+end

data/lib/mkxms/mssql/role_handler.rb

@@ -40,14 +40,11 @@ module Mkxms::Mssql
     
     def initialize(roles, node)
       @role = Role.new(node.attributes['name'], owner: node.attributes['owner']).tap do |r|
+        store_properties_on 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

data/lib/mkxms/mssql/scalar_type_handler.rb

@@ -0,0 +1,108 @@
+require 'mkxms/mssql/property_handler'
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class ScalarType
+    include ExtendedProperties, Property::Hosting, Property::SchemaScoped
+    include Utils::SchemaQualifiedName
+    
+    SQL_OBJECT_TYPE = 'TYPE'
+    
+    def initialize(attrs)
+      a = attrs
+      @schema = a['schema']
+      @name = a['name']
+      @base_type = a['base-type']
+      @capacity = a['capacity']
+      @capacity = @capacity.to_i unless @capacity.nil? || @capacity == 'max'
+      @precision = a['precision']
+      @scale = a['scale']
+      @nullable = !!a['nullable']
+    end
+    
+    attr_accessor :schema, :name, :base_type, :capacity, :precision, :scale, :default
+    
+    def nullable?
+      @nullable
+    end
+    
+    def nullable=(val)
+      @nullable = !!val
+    end
+    
+    def type_spec
+      base_type.dup.tap do |ts|
+        case 
+        when capacity
+          ts << "(#{capacity})"
+        when precision
+          ts << "(#{[precision, scale].compact.join(", ")})"
+        end
+        ts << " NOT NULL" unless nullable?
+      end
+    end
+    
+    def to_sql
+      [].tap do |lines|
+        lines << "CREATE TYPE #{qualified_name}"
+        lines << "FROM #{type_spec};"
+        
+        if default
+          lines << default.to_sql
+          lines << "EXEC sp_bindefault #{default.qualified_name.sql_quoted}, #{qualified_name.sql_quoted};"
+        end
+      end.join("\n")
+    end
+    
+    def element_size
+      if %w[nchar nvarchar]
+        2
+      else
+        1
+      end
+    end
+  end
+  
+  class Default
+    include Utils::SchemaQualifiedName
+    
+    def initialize(attrs)
+      a = attrs
+      @schema = a['schema']
+      @name = a['name']
+      @definition = ""
+    end
+    
+    attr_accessor :schema, :name
+    attr_reader :definition
+    
+    def to_sql
+      "CREATE DEFAULT #{qualified_name} AS #{definition};"
+    end
+  end
+  
+  class ScalarTypeHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(user_types, node)
+      a = node.attributes
+      ScalarType.new(a).tap do |t|
+        store_properties_on t
+        user_types << (@type = t)
+      end
+    end
+    
+    def handle_default_element(parse)
+      @type.default = Default.new(parse.node.attributes)
+    end
+    
+    def handle_text(text, parent_element)
+      case [parent_element.namespace, parent_element.name]
+      when ['', 'default']
+        @type.default.definition << text
+      end
+    end
+  end
+end

data/lib/mkxms/mssql/schema_handler.rb

@@ -31,12 +31,9 @@ module Mkxms::Mssql
     
     def initialize(schemas, node)
       @schema = Schema.new(node.attributes['name'], owner: node.attributes['owner']).tap do |s|
+        store_properties_on s
         schemas << s
       end
     end
-    
-    def extended_properties
-      @schema.extended_properties
-    end
   end
 end

data/lib/mkxms/mssql/sql_string_manipulators.rb

@@ -13,13 +13,13 @@ module Mkxms::Mssql
         when margin.nil? && l =~ /^ *$/
           l
         when margin.nil?
-          margin = /^ */.match(l).length
-          l[margin..-1]
-        when s =~/^\s*$/
+          margin = /^ */.match(l)[0].length
           l[margin..-1]
         else
-          /^(?: *)(.*)/.match(l)[1]
+          /^(?: {0,#{margin}})(.*)/m.match(l)[1]
         end
+      end.tap do |lines|
+        lines.shift if lines.first == "\n"
       end.join('')
     end
     

data/lib/mkxms/mssql/statistics_handler.rb

@@ -44,14 +44,11 @@ module Mkxms::Mssql
       a = node.attributes
       
       @statistics = Statistics.new(a).tap do |s|
+        store_properties_on 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

data/lib/mkxms/mssql/stored_procedure_handler.rb

@@ -38,14 +38,11 @@ module Mkxms::Mssql
       a = node.attributes
       
       @procedure = StoredProcedure.new(a).tap do |sp|
+        store_properties_on sp
         procedures << sp
       end
     end
     
-    def extended_properties
-      @procedure.extended_properties
-    end
-    
     def handle_definition_element(parse); end
     
     def handle_references_element(parse); end

data/lib/mkxms/mssql/synonym_handler.rb

@@ -0,0 +1,40 @@
+require 'mkxms/mssql/property_handler'
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class Synonym
+    include ExtendedProperties, Property::Hosting, Property::SchemaScoped
+    include Utils::SchemaQualifiedName
+    
+    SQL_OBJECT_TYPE = 'SYNONYM'
+    
+    def initialize(schema, name, referent)
+      @schema = schema
+      @name = name
+      @referent = referent
+    end
+    
+    attr_accessor :schema, :name, :referent
+    
+    def to_sql
+      [].tap do |lines|
+        lines << "CREATE SYNONYM #{qualified_name} FOR #{referent};"
+        lines.concat extended_properties_sql
+      end.join("\n")
+    end
+  end
+  
+  class SynonymHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(synonyms, node)
+      a = node.attributes
+      Synonym.new(a['schema'], a['name'], a['for']).tap do |syn|
+        store_properties_on syn
+        synonyms << (@synonym = syn)
+      end
+    end
+  end
+end

data/lib/mkxms/mssql/table_handler.rb

@@ -128,16 +128,13 @@ module Mkxms::Mssql
           c.flags << :replicated if a['replicated']
           c.flags << :filestream if a['filestream']
           c.type_info.update(col_attrs)
+          store_properties_on c
           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
@@ -156,6 +153,7 @@ module Mkxms::Mssql
     def initialize(tables, node)
       a = node.attributes
       @table = Table.new(a['schema'], a['name']).tap do |t|
+        store_properties_on t
         tables << t
       end
       @table.owner = a['owner']
@@ -165,10 +163,6 @@ module Mkxms::Mssql
       @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

data/lib/mkxms/mssql/table_type_handler.rb

@@ -0,0 +1,254 @@
+require 'mkxms/mssql/property_handler'
+require 'mkxms/mssql/utils'
+
+module Mkxms; end
+
+module Mkxms::Mssql
+  class TableType
+    class Column
+      include ExtendedProperties
+      extend Utils::InitializedAttributes
+      
+      SQL_OBJECT_TYPE = 'COLUMN'
+      
+      def initialize(attrs)
+        a = attrs
+        @name = a['name']
+        @type_schema = a['type-schema']
+        @type_name = a['type']
+        @capacity = a['capacity']
+        @capacity = @capacity.to_i unless @capacity.nil? || @capacity == 'max'
+        @precision = a['precision']
+        @scale = a['scale']
+        @collation = a['collation']
+        @nullable = !!a['nullable']
+        @ansi_padded = !a['not-ansi-padded']
+        @full_xml_document = !!a['full-xml-document']
+        @xml_schema_collection = a['xml_collection_id']
+      end
+      
+      attr_accessor :name, :type_schema, :type_name, :capacity, :precision, :scale, :collation, :xml_schema_collection
+      attr_accessor :computed_expression
+      attr_init(:check_constraints) {[]}
+      
+      def nullable?; @nullable; end
+      def nullable=(val); @nullable = !!val; end
+      
+      def ansi_padded?; @ansi_padded; end
+      def ansi_padded=(val); @ansi_padded = !!val; end
+      
+      def full_xml_document?; @full_xml_document; end
+      def full_xml_document=(val); @full_xml_document = !!val; end
+      
+      def type_spec
+        [type_schema, type_name].compact.join('.').tap do |result|
+          result << "(#{capacity})" if capacity
+          result << " COLLATE #{collation}" if collation
+          result << "(#{[precision, scale].compact.join(', ')})" if precision
+          result << ' NOT NULL' unless nullable?
+          check_constraints.each do |c|
+            result << " #{c.to_sql}"
+          end
+        end
+      end
+      
+      def max_byte_consumption
+        if [nil, '[sys]'].include?(type_schema) && %w[[nchar] [nvarchar]].include?(type_name)
+          2 * capacity
+        else
+          capacity
+        end
+      end
+    end
+    
+    class ConstraintColumn
+      def initialize(attrs)
+        @name = attrs['name']
+        @ascending = !attrs['desc']
+      end
+      
+      attr_accessor :name
+      
+      def ascending?; @ascending; end
+      def descending?; !@ascending; end
+      def ascending=(val); @ascending = !!val; end
+      def descending=(val); @ascending = !val; end
+      
+      def spec
+        "#{name} #{ascending? ? "ASC" : "DESC"}"
+      end
+    end
+    
+    class KeyConstraint
+      include ExtendedProperties
+      extend Utils::InitializedAttributes
+      
+      SQL_OBJECT_TYPE = 'CONSTRAINT'
+      
+      def initialize(attrs)
+        @type = attrs['type']
+        @clustered = !!attrs['clustered']
+        @ignore_duplicates = !!attrs['ignore-duplicates']
+      end
+      
+      attr_accessor :type, :ignore_duplicates
+      attr_init(:columns) {[]}
+      
+      def clustered?; @clustered; end
+      def clustered=(val); @clustered = !!val; end
+      
+      def ignore_duplicates?; @ignore_duplicates; end
+      def ignore_duplicates=(val); @ignore_duplicates = !!val; end
+      
+      def to_sql
+        "#{type} #{clustered? ? "CLUSTERED" : "NONCLUSTERED"} (#{
+          columns.map(&:spec).join(', ')
+        })".tap do |result|
+          result << " WITH (IGNORE_DUP_KEY = ON)" if ignore_duplicates?
+        end
+      end
+    end
+    
+    class CheckConstraint
+      include ExtendedProperties
+      extend Utils::InitializedAttributes
+      
+      SQL_OBJECT_TYPE = 'CONSTRAINT'
+      
+      def initialize(attrs)
+      end
+      
+      attr_init(:expression) {''}
+      
+      def type
+        "CHECK"
+      end
+      
+      def to_sql
+        "CHECK #{expression}"
+      end
+    end
+    
+    include ExtendedProperties, Property::Hosting, Property::SchemaScoped
+    include Utils::SchemaQualifiedName
+    extend Utils::InitializedAttributes
+    
+    SQL_OBJECT_TYPE = 'TYPE'
+    
+    def initialize(attrs)
+      a = attrs
+      info_ver = (a['eyewkas_ver'] || 1.0).to_f
+      raise "mssql-eyewkas table-type ver. 1.1 or compatible required" if info_ver < 1.1 || info_ver >= 2
+      @schema = a['schema']
+      @name = a['name']
+    end
+    
+    attr_accessor :schema, :name
+    attr_init(:columns, :constraints) {[]}
+    
+    def to_sql
+      [].tap do |lines|
+        lines << "CREATE TYPE #{qualified_name} AS TABLE ("
+        columns.each_with_index do |col, i|
+          lines << "  #{i == 0 ? " " : ","} #{col.name} #{col.type_spec}"
+        end
+        constraints.each do |c|
+          lines << "  , #{c.to_sql}"
+        end
+        lines << ");"
+        lines << extended_properties_sql
+        columns.each do |col|
+          lines << subitem_extended_properties_sql(col)
+        end
+      end
+    end
+  end
+  
+  class TableTypeColumnHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(column)
+      store_properties_on(@column = column)
+    end
+    
+    def handle_computed_expression_element(parse)
+      # Do nothing
+    end
+    
+    def handle_check_constraint_element(parse)
+      parse.delegate_to TableTypeCheckConstraintHandler, @column.check_constraints
+    end
+    
+    def handle_text(text, parent_element)
+      case [parent_element.namespace, parent_element.name]
+      when ['', 'computed-expression']
+        (@column.computed_expression ||= '') << text
+      end
+    end
+  end
+  
+  class TableTypeCheckConstraintHandler
+    def initialize(constraints, node)
+      TableType::CheckConstraint.new(node.attributes).tap do |c|
+        constraints << (@constraint = c)
+      end
+    end
+    
+    def handle_expression_element(parse)
+      # do nothing
+    end
+    
+    def handle_text(text, parent_element)
+      case [parent_element.namespace, parent_element.name]
+      when ['', 'expression']
+        @constraint.expression << text
+      end
+    end
+    
+    def handle_property_element(parse)
+      raise "Properties on table type constraints are unsupported"
+    end
+  end
+  
+  class TableTypeKeyConstraintHandler
+    def initialize(constraints, node)
+      TableType::KeyConstraint.new(node.attributes).tap do |c|
+        constraints << (@constraint = c)
+      end
+    end
+    
+    def handle_column_element(parse)
+      @constraint.columns << TableType::ConstraintColumn.new(parse.node.attributes)
+    end
+    
+    def handle_property_element(parse)
+      raise "Properties on table type constraints are unsupported"
+    end
+  end
+  
+  class TableTypeHandler
+    include PropertyHandler::ElementHandler
+    
+    def initialize(user_types, node)
+      TableType.new(node.attributes).tap do |tt|
+        user_types << store_properties_on(@type = tt)
+      end
+    end
+    
+    def handle_column_element(parse)
+      a = parse.node.attributes
+      TableType::Column.new(parse.node.attributes).tap do |c|
+        @type.columns << c
+        parse.context = TableTypeColumnHandler.new(c)
+      end
+    end
+    
+    def handle_key_constraint_element(parse)
+      parse.delegate_to TableTypeKeyConstraintHandler, @type.constraints
+    end
+    
+    def handle_check_constraint_element(parse)
+      parse.delegate_to TableTypeCheckConstraintHandler, @type.constraints
+    end
+  end
+end