db_meta 0.1.1 → 0.1.3

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

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

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

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

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

@@ -0,0 +1,30 @@
+module DbMeta
+  module Oracle
+    class Procedure < Base
+      register_type('PROCEDURE')
+
+      attr_reader :source
+
+      def fetch
+        @source = ""
+        connection = Connection.instance.get
+        cursor = connection.exec("select text from user_source where type = 'PROCEDURE' 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/sequence.rb

@@ -0,0 +1,41 @@
+module DbMeta
+  module Oracle
+    class Sequence < Base
+      register_type('SEQUENCE')
+
+      attr_reader :min_value, :max_value, :increment_by, :cycle_flag, :order_flag, :cache_size, :last_number
+
+      def fetch
+        connection = Connection.instance.get
+        cursor = connection.exec("select to_char(min_value), to_char(max_value), to_char(increment_by), cycle_flag, order_flag, to_char(cache_size), to_char(last_number) from user_sequences where sequence_name = '#{@name}'")
+        while row = cursor.fetch()
+          @min_value = row[0].to_i
+          @max_value = row[1].to_i
+          @increment_by = row[2].to_i
+          @cycle_flag = row[3].to_s
+          @order_flag = row[4].to_s
+          @cache_size = row[5].to_i
+          @last_number = row[6].to_i
+        end
+        cursor.close
+      ensure
+        connection.logoff
+      end
+
+      def extract(args={})
+        buffer = [block(@name)]
+        buffer << "CREATE SEQUENCE #{@name}"
+        buffer << "  START WITH #{@last_number}"
+        buffer << "  MAXVALUE #{@max_value}"
+        buffer << "  MINVALUE #{@min_value}"
+        buffer << (@cycle_flag == 'N' ? '  NOCYCLE' : '  CYCLE')
+        buffer << (@cache_size == 0 ? '  NOCACHE' : "  CACHE #{@cache_size}")
+        buffer << (@order_flag == 'N' ? '  NOORDER' : '  ORDER')
+        buffer << ';'
+        buffer << nil
+        buffer.join("\n")
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module DbMeta
+  module Oracle
+    class Synonym < Base
+      register_type('SYNONYM')
+
+      attr_reader :table_owner, :table_name, :db_link
+
+      def initialize(args={})
+        super(args)
+
+        @extract_type = :merged
+      end
+
+      def fetch(args={})
+        connection = Connection.instance.get
+        cursor = connection.exec("select table_owner, table_name, db_link from user_synonyms where synonym_name = '#{@name}'")
+        while row = cursor.fetch()
+          @table_owner = row[0].to_s
+          @table_name = row[1].to_s
+          @db_link = row[2].to_s
+        end
+        cursor.close
+      ensure
+        connection.logoff
+      end
+
+      def extract(args={})
+        line = ""
+        line << "CREATE OR REPALCE SYNONYM #{@name} FOR "
+        line << "#{@table_owner}." if @table_owner.size > 0
+        line << "#{@table_name}"
+        line << "@#{@db_link}" if @db_link.size > 0
+        line << ";"
+
+        buffer = []
+        buffer << line
+        buffer.join("\n")
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module DbMeta
+  module Oracle
+    class SynonymCollection
+      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/table.rb

@@ -0,0 +1,164 @@
+module DbMeta
+  module Oracle
+    class Table < Base
+      register_type('TABLE')
+
+      attr_reader :columns, :temporary, :cache, :iot_type, :duration
+
+      def initialize(args={})
+        super(args)
+
+        @comment = nil # table level comment
+
+        @comment = nil
+        @columns = []
+        @indexes = []
+        @constraints = []
+        @triggers = []
+      end
+
+      def add_object(object)
+        @indexes << object if object.type == 'INDEX'
+        @constraints << object if object.type == 'CONSTRAINT'
+        @triggers << object if object.type == 'TRIGGER'
+      end
+
+      def fetch
+        @comment = Comment.find(type: 'TABLE', name: @name)
+        @columns = Column.all(object_name: @name)
+
+        connection = Connection.instance.get
+        cursor = connection.exec("select temporary, cache, iot_type, duration from user_tables where table_name = '#{@name}'")
+        while row = cursor.fetch()
+          @temporary = row[0].to_s.strip == 'Y' ? 'GLOBAL TEMPORARY' : nil
+          @cache = row[1].to_s.strip == 'Y' ? 'CACHE' : 'NOCACHE'
+          @iot_type = row[2].to_s
+          @duration = row[3].to_s
+        end
+        cursor.close
+
+      rescue
+        connection.logoff
+      end
+
+
+      def extract(args={})
+        buffer = [block(@name)]
+        buffer << "CREATE#{" #{@temporary}" if @temporary} TABLE #{@name}"
+        buffer << '('
+
+        # add columns
+        @columns.each_with_index do |c, index|
+          buffer << "  #{c.extract}#{',' if index+1 < @columns.size}"
+        end
+
+        # Primary key definition must be here for IOT tables
+        if @iot_type == 'IOT'
+          constraint = @constraints.select{ |c| c.constraint_type == 'PRIMARY KEY'}[0]
+          buffer[-1] += ','
+          buffer << "  CONSTRAINT #{constraint.name}"
+          buffer << "  PRIMARY KEY (#{constraint.columns.join(', ')})"
+          buffer << "  ENABLE VALIDATE"
+        end
+
+        buffer << ')'
+        buffer << translate_duration if @duration.size > 0
+        buffer << @cache if @temporary
+        buffer << "ORGANIZATION INDEX" if @iot_type == "IOT"
+        buffer[-1] += ';'
+        buffer << nil
+
+        # table comments
+        if @comment
+          buffer << "COMMENT ON TABLE #{@name} IS '#{@comment.text("'","''")}';"
+        end
+
+        # table column comments
+        @columns.each do |column|
+          next if column.comment.size == 0
+          buffer << "COMMENT ON COLUMN #{@name}.#{column.name} IS '#{column.comment.gsub("'","''")}';"
+        end
+
+        # indexes
+        if @indexes.size > 0
+          buffer << block("Indexes", 40)
+          @indexes.each do |index|
+            line = ""
+            line << "-- System Index: " if index.system_object? || @iot_type == "IOT"
+            line << index.extract(args)
+            buffer << line
+          end
+          buffer << nil
+        end
+
+        # constaints
+        if @constraints.size > 0
+          buffer << block("Constraints", 40)
+          @constraints.sort_by{ |c| [ Constraint.sort_value(c.constraint_type), c.name] }.each do |constraint|
+            buffer << constraint.extract(args.merge({comment: (constraint.constraint_type == 'FOREIGN KEY')}))
+          end
+        end
+
+        # triggers
+        if @triggers.size > 0
+          buffer << block("Triggers", 40)
+          buffer << @triggers.map{ |o| o.extract(args) }.join("\n")
+          buffer << nil
+        end
+
+        buffer.join("\n")
+      end
+
+      def ddl_drop
+        "DROP #{@type} #{@name} CASCADE CONSTRAINTS PURGE;"
+      end
+
+      def system_object?
+        is_system_object = super
+        return is_system_object if is_system_object
+
+       # check for tables created based on materialized views
+        n = 0
+        connection = Connection.instance.get
+        cursor = connection.exec("select count(*) as n from user_mviews where mview_name = '#{@name}'")
+        cursor.fetch_hash do |item|
+          n = item['N']
+        end
+        cursor.close
+
+        return n == 1
+      ensure
+        connection.logoff if connection
+      end
+
+      def get_core_data_where_clause(id=1000000)
+        buffer = []
+        @constraints.each do |constraint|
+          if constraint.constraint_type == 'PRIMARY KEY'
+            constraint.columns.each do |column|
+              buffer << "#{column} < #{id}"
+            end
+          end
+        end
+
+        return '' if buffer.size == 0
+        buffer.insert(0, 'where')
+        buffer.join(' ')
+      end
+
+      private
+
+      def translate_duration
+        case @duration
+          when "SYS$TRANSACTION"
+            return "ON COMMIT DELETE ROWS"
+          when "SYS$SESSION"
+            return "ON COMMIT PRESERVE ROWS"
+        else
+          return "-- table duration definition [#{@duration}] is unknown and may need code adaptations"
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+module DbMeta
+  module Oracle
+    class TableDataCollection
+      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
+        @tables = args[:tables]
+      end
+
+      def extract(args={})
+        buffer = [block(@name)]
+        buffer << nil
+
+        connection = Connection.instance.get
+
+        @tables.each do |table|
+          buffer << block(table.name, 40)
+
+          name_type_map = {}
+          table.columns.each do |column|
+            name_type_map[column.name] = column.type
+          end
+
+          cursor = connection.exec("select * from #{table.name} #{table.get_core_data_where_clause}")
+          cursor.fetch_hash do |item|
+            buffer << "insert into #{table.name}(#{item.keys.join(', ')}) values(#{format_values(name_type_map, item)});"
+          end
+          cursor.close
+          buffer << nil
+        end
+
+        buffer << 'commit;'
+        buffer << nil
+
+        buffer.join("\n")
+      ensure
+        connection.logoff
+      end
+
+      def ddl_drop
+        '-- will automatically be dropped with table object'
+      end
+
+      def system_object?
+        false
+      end
+
+      private
+
+      def format_values(name_type_map, item)
+        buffer = []
+
+        item.each_pair do |key, value|
+          if value == nil
+            buffer << 'NULL'
+            next
+          end
+
+          case name_type_map[key]
+            when /varchar|char/i
+              buffer << "'#{value.gsub("'","''")}'"
+            when /clob/i
+              buffer << "'#{item.read}'"
+            when /date/i
+              buffer << "to_date('#{value.strftime("%Y-%m-%d %H:%M:%S")}','YYYY-MM-DD HH24:MI:SS')"
+            when /timestamp/i
+             buffer << "to_timezone('#{value.strftime("%Y-%m-%d %H:%M:%S %Z")}','YYYY-MM-DD HH24:MI:SS.FF TZD')"
+          else
+            buffer << value.to_s
+          end
+        end
+
+        buffer.join(', ')
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,64 @@
+module DbMeta
+  module Oracle
+    class Trigger < Base
+      register_type('TRIGGER')
+
+      attr_accessor :trigger_type, :trigger_event, :for_each, :table_name, :referencing_names, :description, :tigger_body
+
+      def initialize(args={})
+        super(args)
+
+        @extract_type = :embedded
+      end
+
+      def fetch
+        connection = Connection.instance.get
+        cursor = connection.exec("select trigger_type, triggering_event, table_name, referencing_names, description, trigger_body from user_triggers where trigger_name = '#{@name}'")
+        while row = cursor.fetch()
+          @trigger_type = row[0].to_s
+          @triggering_event = row[1].to_s
+          @table_name = row[2].to_s
+          @referencing_names = row[3].to_s
+          @description = row[4].to_s
+          @trigger_body = row[5].to_s
+        end
+
+        parse_trigger_type
+
+        cursor.close
+      ensure
+        connection.logoff
+      end
+
+      def extract(args={})
+        buffer = []
+        buffer << "CREATE OR REPLACE TRIGGER #{@name}"
+        buffer << "#{@trigger_type} #{@triggering_event}"
+        buffer << "ON #{@table_name}"
+        buffer << "#{@referencing_names}"
+        buffer << "#{@for_each}" if @for_each
+        buffer << "#{@trigger_body.strip}"
+        buffer << '/'
+        buffer << nil
+        buffer.join("\n")
+      end
+
+      private
+
+      def parse_trigger_type
+        @for_each = 'FOR EACH ROW' if @trigger_type =~ /each row/i
+
+        case @trigger_type
+          when /before/i
+            @trigger_type = 'BEFORE'
+          when /after/i
+            @trigger_type = 'AFTER'
+          when /instead of/i
+            @for_each = 'FOR EACH ROW'
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module DbMeta
+  module Oracle
+    class Type < Base
+      register_type('TYPE')
+
+      def fetch
+        @source = ""
+        @body = ""
+        connection = Connection.instance.get
+        cursor = connection.exec("select text from user_source where type = 'TYPE' and name = '#{@name}' order by line")
+        while row = cursor.fetch()
+          @source << row[0].to_s
+        end
+        cursor.close
+
+        # check for type body
+        cursor = connection.exec("select text from user_source where type = 'TYPE BODY' and name = '#{@name}' order by line")
+        while row = cursor.fetch()
+          @body << row[0].to_s
+        end
+        cursor.close
+      ensure
+        connection.logoff
+      end
+
+      def extract(args={})
+        buffer = [block(@name)]
+        buffer << "CREATE OR REPLACE #{@source.strip}"
+        buffer << '/'
+        buffer << nil
+        if @body.size > 0
+          buffer << "CREATE OR REPLACE #{@body.strip}"
+          buffer << '/'
+          buffer << nil
+        end
+        buffer.join("\n")
+      end
+
+    end
+  end
+end

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

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

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

@@ -0,0 +1,60 @@
+module DbMeta
+  module Oracle
+    class View < Base
+      register_type('VIEW')
+
+      def initialize(args={})
+        super(args)
+
+        @comment = nil # view level comment
+      end
+
+      def fetch(args={})
+        @comment = Comment.find(type: 'TABLE', name: @name)
+        @columns = Column.all(object_name: @name)
+
+        @source = ""
+        connection = Connection.instance.get
+        cursor = Connection.instance.get.exec("select text from user_views where view_name = '#{@name}'")
+        while row = cursor.fetch()
+          @source << row[0].to_s
+        end
+        cursor.close
+      ensure
+        connection.logoff
+      end
+
+
+      def extract(args={})
+        buffer = [block(@name)]
+        buffer << "CREATE OR REPLACE VIEW #{@name}"
+        buffer << '('
+
+        # add columns
+        @columns.each_with_index do |c, index|
+          buffer << "  #{c.name}#{',' if index+1 < @columns.size}"
+        end
+
+        buffer << ')'
+        buffer << "AS"
+        buffer << @source.strip
+        buffer[-1] += ';'
+        buffer << nil
+
+        # view comments
+        if @comment
+          buffer << "COMMENT ON VIEW #{@name} IS '#{@comment.text("'","''")}';"
+        end
+
+        # view column comments
+        @columns.each do |column|
+          next if column.comment.size == 0
+          buffer << "COMMENT ON COLUMN #{@name}.#{column.name} IS '#{column.comment.gsub("'","''")}';"
+        end
+
+        buffer.join("\n")
+      end
+
+    end
+  end
+end

data/lib/db_meta/version.rb

@@ -1,3 +1,3 @@
 module DbMeta
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/db_meta.rb

@@ -1,26 +1,38 @@
 require_relative 'db_meta/version'
-require_relative 'db_meta/abstract'
+require_relative 'db_meta/constant'
+require_relative 'db_meta/logger'
 
+require_relative 'db_meta/abstract'
 require_relative 'db_meta/oracle/oracle'
 
+Log = Logger.new(STDOUT)
+
 module DbMeta
 
   DATABASE_TYPES = [:oracle]
 
   class DbMeta
 
-    def initialize(**args)
+    def initialize(args={})
       @database_type = args[:database_type] || DATABASE_TYPES[0]
       raise "allowed database types are [#{DATABASE_TYPES.join(', ')}], but provided was [#{@database_type}]" unless DATABASE_TYPES.include?(@database_type)
       @abstract = Abstract.from_type(@database_type, args)
     end
 
-    def fetch(**args)
-      abstract.fetch(args)
+    def fetch(args={})
+      Log.info("Fetching...")
+      @abstract.fetch(args)
+      Log.info("Fetch completed")
+    # rescue => e
+    #   Log.error(e.to_s)
     end
 
-    def extract(**args)
-      abstract.extract(args)
+    def extract(args={})
+      Log.info("Extracting...")
+      @abstract.extract(args)
+      Log.info("Extraction completed")
+    # rescue => e
+    #   Log.error(e.to_s)
     end
 
   end