db_meta 0.1.1 → 0.1.3

data/lib/db_meta/oracle/oracle.rb

@@ -1,7 +1,176 @@
+require 'oci8'
+require 'fileutils'
+
+require_relative 'connection'
+require_relative 'helper'
+require_relative 'base'
+require_relative 'objects'
+
+Dir[File.dirname(__FILE__) + '/types/*.rb'].each {|file| require file }
+
 module DbMeta
+  module Oracle
+    class Oracle < DbMeta::Abstract
+      include Helper
 
-  class Oracle < DbMeta::Abstract
-    register_type(:oracle)
-  end
+      register_type(:oracle)
+
+      def initialize(args={})
+        super(args)
+
+        Connection.instance.set(@username, @password, @instance, @worker)
+
+        @objects = Objects.new
+      end
+
+      def fetch(args={})
+        @include_pattern = args[:include]
+        @exclude_pattern = args[:exclude]
+
+        Objects.all.each do |object|
+          next if @exclude_pattern =~ object.name if @exclude_pattern
+          next unless @include_pattern =~ object.name if @include_pattern
+          @objects << object
+        end
+
+        # parallel fetching of object details
+        @objects.fetch
+      ensure
+        Connection.instance.disconnect
+      end
+
+      def extract(args={})
+        format = args[:format] || :sql
+
+        # validate args
+        raise "Format [#{format}] is not supported" unless EXTRACT_FORMATS.include?(format)
+
+        remove_folder(@base_folder)
+        create_folder(@base_folder)
+
+        @objects.merge_synonyms
+        @objects.merge_grants
+        @objects.embed_indexes
+        @objects.embed_constraints
+        @objects.merge_constraints
+        @objects.embed_triggers
+        @objects.handle_table_data(args)
+
+        extract_summary
+        extract_create_all(args)
+        extract_drop_all(args)
+
+        # extract all default objects
+        @objects.default_each do |object|
+          folder = File.join(@base_folder, "#{"%02d" % type_sequence(object.type)}_#{object.type}")
+          create_folder(folder)
+
+          filename = File.join(folder, "#{object.name}.#{format.to_s}")
+          write_buffer_to_file(object.extract(args), filename)
+        end
+      end
+
+      private
+
+      def extract_summary
+        Log.info("Summarizing...")
 
+        buffer = [block("Summary of #{@username}"), nil]
+
+        total = 0
+        @objects.summary_each do |type, count|
+          total += count
+          buffer << "#{SUMMARY_COLUMN_FORMAT_NAME % type.upcase.to_s}#{"%5d" % count} #{"(#{@objects.summary_system_object[type]} system #{pluralize(@objects.summary_system_object[type], 'object')})" if @objects.summary_system_object[type] > 0}"
+        end
+        buffer << nil
+
+        buffer << "#{SUMMARY_COLUMN_FORMAT_NAME % 'Total Objects'}#{"%5d" % total}"
+        buffer << nil
+        buffer << nil
+
+        # invalid objects
+        if @objects.invalids?
+          buffer << 'Invalid/Disabled Objects'
+          @objects.invalid_each do |type, objects|
+            buffer << "#{SUMMARY_COLUMN_FORMAT_NAME % type.upcase.to_s}#{"%5d" % objects.size}"
+            objects.each do |object|
+              buffer << "#{SUMMARY_COLUMN_FORMAT_NAME_RIGHT % object.name}"
+            end
+            buffer << nil
+          end
+        else
+          buffer << 'No invalid/disabled objects'
+        end
+        buffer << nil
+
+        filename = File.join(@base_folder, "#{"%02d" % type_sequence('SUMMARY')}_summary.txt")
+        write_buffer_to_file(buffer, filename)
+      end
+
+      def extract_create_all(args={})
+        Log.info("Extracting create all script...")
+
+        buffer = [block("#{@username} - CREATE ALL")]
+
+        current_type = nil
+        @objects.default_each do |object|
+          if current_type != object.type
+            buffer << nil;
+            buffer << block(object.type, 40)
+          end
+
+          folder = "#{'%02d' % type_sequence(object.type)}_#{object.type}"
+          file = "#{object.name}.sql"
+          buffer << "@#{File.join(folder,file).downcase.gsub(' ', '_')}"
+          current_type = object.type
+        end
+        buffer << nil
+        buffer << compile_invalid_script
+        buffer << nil
+
+        filename = File.join(@base_folder,"#{'%02d' % type_sequence('CREATE')}_create_all.sql")
+        write_buffer_to_file(buffer, filename)
+      end
+
+      def extract_drop_all(args={})
+        Log.info("Extracting drop all script...")
+
+        buffer = [block("#{@username} - DROP ALL")]
+
+        current_type = nil
+        @objects.reverse_default_each do |object|
+
+          if current_type != object.type
+            buffer << nil;
+            buffer << block(object.type, 40)
+          end
+
+          buffer << object.ddl_drop
+          current_type = object.type
+        end
+        buffer << nil
+
+        filename = File.join(@base_folder,"#{'%02d' % type_sequence('DROP')}_drop_all.sql")
+        write_buffer_to_file(buffer, filename)
+      end
+
+      def compile_invalid_script
+        buffer = [block('Compile invalid objects if needed', 40)]
+        buffer << "declare"
+        buffer << "begin"
+        buffer << "  for rec in (select object_name, object_type from user_objects where status = 'INVALID') loop"
+        buffer << "    if rec.object_type = 'PACKAGE' or rec.object_type = 'PACKAGE BODY' then"
+        buffer << "      execute immediate 'alter PACKAGE ' || rec.object_name || ' compile';"
+        buffer << "      execute immediate 'alter PACKAGE ' || rec.object_name || ' compile body';"
+        buffer << "    else"
+        buffer << "      execute immediate 'alter ' || rec.object_type || ' ' || rec.object_name || ' compile';"
+        buffer << "    end if;"
+        buffer << "  end loop;"
+        buffer << "end;"
+        buffer << "/"
+        buffer.join("\n")
+      end
+
+    end
+  end
 end

data/lib/db_meta/oracle/types/column.rb

@@ -0,0 +1,70 @@
+module DbMeta
+  module Oracle
+    class Column
+
+      attr_accessor :name, :type, :data_length, :data_precision, :data_scale, :nullable, :data_default, :comment
+
+      def initialize(args={})
+      end
+
+      def extract
+        buffer = "#{'%-30s' % @name}"
+        buffer << " #{convert_type}"
+        buffer << " DEFAULT #{@data_default}".strip if @data_default.size > 0
+        return buffer
+      end
+
+      def self.all(args={})
+        columns = []
+        connection = Connection.instance.get
+        cursor = connection.exec("select column_name, data_type, data_length, data_precision, data_scale, nullable, data_default from user_tab_columns where table_name = '#{args[:object_name]}' order by column_id")
+        while row = cursor.fetch()
+          column = Column.new(row)
+          column.name = row[0].to_s
+          column.type = row[1].to_s
+          column.data_length = row[2].to_i
+          column.data_precision = row[3].to_i
+          column.data_scale = row[4].to_i
+          column.nullable = row[5].to_s
+          column.data_default = row[6].to_s
+
+          # column comments
+          cursor2 = connection.exec("select comments from user_col_comments where table_name = '#{args[:object_name]}' and column_name = '#{column.name}'")
+          while row2 = cursor2.fetch()
+            column.comment = row2[0].to_s
+          end
+          cursor2.close
+          columns << column
+
+        end
+        cursor.close
+
+        columns
+      rescue
+        connection.loggoff
+      end
+
+      private
+
+      def convert_type
+        case @type
+          when 'FLOAT'
+            buffer = "#{@type}"
+            buffer << "(#{@data_precision})" unless @data_precision == 0
+            return buffer
+          when 'NUMBER'
+            buffer = "#{@type}"
+            buffer << "(#{@data_precision}" unless @data_precision == 0
+            buffer << ",#{@data_scale}" unless @data_scale == 0
+            buffer << ")" if buffer.include?("(")
+            return buffer
+          when /CHAR|RAW/
+            return "#{@type}(#{@data_length} BYTE)"
+        else
+          return @type
+        end
+      end
+
+    end
+  end
+end

data/lib/db_meta/oracle/types/comment.rb

@@ -0,0 +1,20 @@
+module DbMeta
+  module Oracle
+    class Comment
+      attr_reader :text
+
+      def self.find(args={})
+
+        connection = Connection.instance.get
+        cursor = connection.exec("select comments from user_tab_comments where table_type = '#{args[:type]}' and table_name = '#{args[:name]}'")
+        while row = cursor.fetch()
+          @text = row[0]
+        end
+
+      ensure
+        connection.logoff
+      end
+
+    end
+  end
+end

data/lib/db_meta/oracle/types/constraint.rb

@@ -0,0 +1,91 @@
+module DbMeta
+  module Oracle
+    class Constraint < Base
+      register_type('CONSTRAINT')
+
+      attr_reader :constraint_type, :table_name, :search_condition, :referential_constraint, :delete_rule, :columns
+
+      def initialize(args={})
+        super(args)
+
+        @extract_type = :embedded
+        @columns = []
+      end
+
+      def fetch(args={})
+        connection = Connection.instance.get
+        cursor = connection.exec("select * from user_constraints where constraint_name = '#{@name}'")
+        cursor.fetch_hash do |item|
+          @constraint_type = translate_constraint_type(item['CONSTRAINT_TYPE'])
+          @extract_type = :merged if @constraint_type == 'FOREIGN KEY'
+          @table_name = item['TABLE_NAME']
+          @search_condition = item['SEARCH_CONDITION']
+          @delete_rule = item['DELETE_RULE']
+
+          if @constraint_type == 'FOREIGN KEY'
+            constraint = Constraint.new('OBJECT_TYPE' => 'CONSTRAINT', 'OBJECT_NAME' => item['R_CONSTRAINT_NAME'])
+            constraint.fetch
+            @referential_constraint = constraint
+          end
+        end
+        cursor.close
+
+        # get affected columns
+        cursor = connection.exec("select * from user_cons_columns where constraint_name = '#{@name}' order by position")
+        cursor.fetch_hash do |item|
+          @columns << item['COLUMN_NAME']
+        end
+        cursor.close
+
+      ensure
+        connection.logoff
+      end
+
+
+      def extract(args={})
+        buffer = []
+        buffer << "ALTER TABLE #{@table_name} ADD ("
+        buffer << "  CONSTRAINT #{@name}"
+
+        case @constraint_type
+          when 'CHECK'
+            buffer << "  #{@constraint_type} (#{@search_condition})"
+          when 'FOREIGN KEY'
+            buffer << "  #{@constraint_type} (#{@columns.join(', ')})"
+            buffer << "  REFERENCES #{@referential_constraint.table_name} (#{@referential_constraint.columns.join(', ')})"
+          else
+            buffer << "  #{@constraint_type} (#{@columns.join(', ')})"
+        end
+
+        buffer << "  ON DELETE CASCADE" if @delete_rule == 'CASCADE'
+        buffer << "  ENABLE VALIDATE"
+        buffer << ");"
+
+        (0..buffer.size-1).each { |n|  buffer[n] = ('-- ' + buffer[n])}  if args[:comment] == true
+
+        buffer << nil
+        buffer.join("\n")
+      end
+
+      def self.sort_value(type)
+        ['PRIMARY KEY', 'FOREIGN KEY', 'UNIQUE', 'CHECK'].index(type)
+      end
+
+      private
+
+      def translate_constraint_type(type)
+        case type
+          when 'P'
+            return 'PRIMARY KEY'
+          when 'U'
+            return 'UNIQUE'
+          when 'C'
+            return 'CHECK'
+          when 'R'
+            return 'FOREIGN KEY'
+        end
+      end
+
+    end
+  end
+end

data/lib/db_meta/oracle/types/constraint_collection.rb

@@ -0,0 +1,46 @@
+module DbMeta
+  module Oracle
+    class ConstraintCollection
+      include DbMeta::Oracle::Helper
+
+      attr_reader :name, :type, :status, :extract_type, :collection
+
+      def initialize(args={})
+        @name = args[:name]
+        @type = args[:type]
+        @status = :valid
+        @extract_type = :default
+        @collection = []
+      end
+
+      def empty?
+        @collection.size == 0
+      end
+
+      def <<(object)
+        @collection << object
+      end
+
+      def extract(args={})
+        buffer = [block(@name)]
+        title = nil
+        @collection.sort_by{ |o| [o.table_name, o.name]}.each do |object|
+          buffer << block(object.table_name, 40) if title != object.table_name
+          buffer << object.extract(args)
+          title = object.table_name
+        end
+        buffer.join("\n")
+      end
+
+      def ddl_drop
+        '-- will automatically be dropped with table object'
+      end
+
+      def system_object?
+        false
+      end
+
+    end
+
+  end
+end

data/lib/db_meta/oracle/types/database_link.rb

@@ -0,0 +1,33 @@
+module DbMeta
+  module Oracle
+    class DatabaseLink < Base
+      register_type('DATABASE LINK')
+
+      attr_reader :username, :password, :host
+
+      def fetch(args={})
+        connection = Connection.instance.get
+        cursor = connection.exec("select username, password, host from user_db_links where db_link = '#{@name}'")
+        while row = cursor.fetch()
+          @username = row[0].to_s
+          @password = row[1].to_s
+          @host = row[2].to_s
+        end
+        cursor.close
+      ensure
+        connection.logoff
+      end
+
+      def extract(args={})
+        buffer = []
+        buffer << "CREATE DATABASE LINK #{@name}"
+        buffer << " CONNECT TO #{@username}"
+        buffer << " IDENTIFIED BY :1"
+        buffer << " USING '#{@host}';"
+        buffer << nil
+        buffer.join("\n")
+      end
+
+    end
+  end
+end

data/lib/db_meta/oracle/types/function.rb

@@ -0,0 +1,30 @@
+module DbMeta
+  module Oracle
+    class Function < Base
+      register_type('FUNCTION')
+
+      attr_reader :source
+
+      def fetch
+        @source = ""
+        connection = Connection.instance.get
+        cursor = connection.exec("select text from user_source where type = 'FUNCTION' and name = '#{@name}' order by line")
+        while row = cursor.fetch()
+          @source << row[0].to_s
+        end
+        cursor.close
+      ensure
+        connection.logoff
+      end
+
+      def extract(args={})
+        buffer = [block(@name)]
+        buffer << @source.strip
+        buffer << '/'
+        buffer << nil
+        buffer.join("\n")
+      end
+
+    end
+  end
+end

data/lib/db_meta/oracle/types/grant.rb

@@ -0,0 +1,46 @@
+module DbMeta
+  module Oracle
+    class Grant < Base
+      register_type('GRANT')
+
+      attr_reader :grantee, :owner, :table_name, :grantor, :privilege, :grantable
+
+      def initialize(args={})
+        super(args)
+        @extract_type = :merged
+      end
+
+      def fetch(args={})
+        # definition is comma seperated in the name to prevent re-fetching table for every grant
+        @grantee, @owner, @table_name, @grantor, @privilege, @grantable = @name.split(',')
+      end
+
+      def extract(args={})
+        buffer = ""
+        buffer << ( '%-30s' % "-- granted via #{@grantor}: ") if external_grant?
+        buffer << "GRANT #{"%-18s" % @privilege} ON #{"%-32s" % @table_name} TO #{@grantee}"
+        buffer << " WITH GRANT OPTION" if @grantable == 'YES'
+        buffer << ";"
+        buffer
+      end
+
+      def ddl_drop
+        buffer = ""
+
+        buffer << ( '%-30s' % "-- granted via #{@grantor}: ") if external_grant?
+        buffer << "REVOKE #{"%-18s" % @privilege} ON #{"%-32s" % @table_name} FROM #{@grantee};"
+        buffer
+      end
+
+      def external_grant?
+        @grantee == Connection.instance.username.upcase
+      end
+
+      def sort_value
+        return ["2", @grantor, @privilege, @table_name] if external_grant?
+        return ["1", @grantee, @privilege, @table_name]
+      end
+
+    end
+  end
+end

data/lib/db_meta/oracle/types/grant_collection.rb

@@ -0,0 +1,42 @@
+module DbMeta
+  module Oracle
+    class GrantCollection
+      include DbMeta::Oracle::Helper
+
+      attr_reader :name, :type, :status, :extract_type, :collection
+
+      def initialize(args={})
+        @name = args[:name]
+        @type = args[:type]
+        @status = :valid
+        @extract_type = :default
+        @collection = []
+      end
+
+      def empty?
+        @collection.size == 0
+      end
+
+      def <<(object)
+        @collection << object
+      end
+
+      def extract(args={})
+        buffer = [block(@name)]
+        buffer << @collection.map{ |o| o.extract(args) }
+        buffer << nil
+        buffer.join("\n")
+      end
+
+      def ddl_drop
+        @collection.reverse_each.map{ |o| o.ddl_drop }.join("\n")
+      end
+
+      def system_object?
+        false
+      end
+
+    end
+
+  end
+end

data/lib/db_meta/oracle/types/index.rb

@@ -0,0 +1,43 @@
+module DbMeta
+  module Oracle
+    class Index < Base
+      register_type('INDEX')
+
+      attr_reader :index_type, :table_name, :uniqueness, :tablespace
+
+      def initialize(args={})
+        super(args)
+
+        @extract_type = :embedded
+        @columns = []
+      end
+
+      def fetch(args={})
+        connection = Connection.instance.get
+        cursor = connection.exec("select index_type, table_name, uniqueness, tablespace_name from user_indexes where index_name = '#{@name}'")
+        while row = cursor.fetch()
+          @index_type = row[0].to_s
+          @table_name = row[1].to_s
+          @uniqueness = row[2].to_s
+          @tablespace = row[3].to_s
+        end
+        cursor.close
+
+        # involved columns
+        cursor = connection.exec("select column_name from user_ind_columns where index_name = '#{@name}' order by column_position")
+        while row = cursor.fetch()
+          @columns << row[0].to_s
+        end
+        cursor.close
+
+      ensure
+        connection.logoff
+      end
+
+      def extract(args={})
+        "CREATE#{ @uniqueness == 'UNIQUE' ? ' UNIQUE' : nil } INDEX #{@name} ON #{@table_name}(#{@columns.join(', ')});"
+      end
+
+    end
+  end
+end

data/lib/db_meta/oracle/types/lob.rb

@@ -0,0 +1,13 @@
+module DbMeta
+  module Oracle
+    class Lob < Base
+      register_type('LOB')
+
+      def initialize(args={})
+        super(args)
+        @extract_type = :embedded
+      end
+
+    end
+  end
+end

data/lib/db_meta/oracle/types/materialized_view.rb

@@ -0,0 +1,65 @@
+module DbMeta
+  module Oracle
+    class MaterializedView < Base
+      register_type('MATERIALIZED VIEW')
+
+      attr_reader :query, :build_mode, :refresh_mode, :refresh_method, :interval, :next_date, :rewrite_enabled, :columns
+
+      def fetch(args={})
+        connection = Connection.instance.get
+
+        cursor = connection.exec("select * from user_mviews where mview_name = '#{@name}'")
+        cursor.fetch_hash do |item|
+          @query = item['QUERY']
+          @build_mode = item['BUILD_MODE']
+          @refresh_mode = item['REFRESH_MODE']
+          @refresh_method = item['REFRESH_METHOD']
+          @rewrite_enabled = item['REWRITE_ENABLED'] == 'Y' ? 'ENABLE' : 'DISABLE'
+        end
+        cursor.close
+
+        cursor = connection.exec("select * from user_refresh where rname = '#{@name}'")
+        cursor.fetch_hash do |item|
+          @interval = item['INTERVAL']
+          @next_date = item['NEXT_DATE']
+        end
+        cursor.close
+
+        @columns = Column.all(object_name: @name)
+
+        # comments on materialized views
+        cursor = connection.exec("select * from user_mview_comments where mview_name = '#{@name}'")
+        cursor.fetch_hash do |item|
+          @comment = item['COMMENTS']
+        end
+        cursor.close
+
+      ensure
+        connection.logoff
+      end
+
+
+      def extract(args={})
+        buffer = [block(@name)]
+        buffer << "CREATE MATERIALIZED VIEW #{@name}(#{@columns.map{ |c| c.name}.join(', ')})"
+        buffer << "BUILD #{@build_mode}"
+        buffer << "REFRESH #{@refresh_method} ON #{@refresh_mode}"
+        buffer << "START WITH TO_DATE('#{@next_date}') NEXT #{@interval}" if @interval
+        buffer << "#{@rewrite_enabled} QUERY REWRITE"
+        buffer << 'AS'
+        buffer << @query
+        buffer << '/'
+        buffer << nil
+
+        # materialized view comments
+        if @comment
+          buffer << "COMMENT ON MATERIALIZED VIEW #{@name} IS '#{@comment.gsub("'","''")}';"
+          buffer << nil
+        end
+
+        buffer.join("\n")
+      end
+
+    end
+  end
+end