oraora 0.1.0

data/lib/oraora/meta/object.rb

@@ -0,0 +1,46 @@
+module Oraora
+  class Meta
+    class Object
+      attr_reader :type
+
+      def initialize(schema, name, type = nil)
+        @schema = schema
+        @name = name
+        @type = type
+      end
+
+      def load_from_oci(oci)
+        if !@type
+          @id, @type = oci.select_one("SELECT object_id, object_type FROM all_objects
+                                        WHERE owner = :schema AND object_name = :name
+                                        ORDER BY decode(namespace,  19, 0,  99)", @schema, @name) if !@type
+          raise NotExists if !@id
+          @id = @id.to_i
+        end
+        case @type
+          when 'TABLE'              then Table.from_oci(oci, @schema, @name)
+          when 'VIEW'               then View.from_oci(oci, @schema, @name)
+          when 'MATERIALIZED VIEW'  then MaterializedView.from_oci(oci, @schema, @name)
+          when 'SEQUENCE'           then Sequence.from_oci(oci, @schema, @name)
+          else self
+        end
+      end
+
+      def self.from_oci(oci, schema, name, type = nil)
+        new(schema, name, type).load_from_oci(oci)
+      end
+
+      def describe(options = {})
+        <<-HERE.reset_indentation
+          Object #{@schema}.#{@name}
+          Id:           #{@id}
+          Type:         #{@type}
+        HERE
+      end
+
+      def list(options = {}, filter = nil)
+        raise NotApplicable, "Cannot list for this object"
+      end
+    end
+  end
+end

data/lib/oraora/meta/schema.rb

@@ -0,0 +1,40 @@
+module Oraora
+  class Meta
+    class Schema
+      def initialize(name)
+        @name = name
+      end
+
+      def load_from_oci(oci)
+        @id, @created = oci.select_one("SELECT user_id, created FROM all_users WHERE username = :name", @name)
+        raise NotExists if !@id
+        @id = @id.to_i
+        @objects = oci.pluck("SELECT object_name, min(object_type) object_type FROM all_objects
+                               WHERE owner = :name
+                                 AND object_type IN ('TABLE', 'VIEW', 'MATERIALIZED VIEW', 'SEQUENCE')
+                               GROUP BY object_name
+                               ORDER BY object_name", @name)
+        self
+      end
+
+      def self.from_oci(oci, name)
+        new(name).load_from_oci(oci)
+      end
+
+      def describe(options = {})
+        <<-HERE.reset_indentation
+          Schema #{@name}
+          Id:           #{@id}
+          Created:      #{@created}
+        HERE
+      end
+
+      def list(options = {}, filter = nil)
+        objects = @objects.collect(&:first)
+        objects.reject! { |o| o =~ /^ISEQ\$\$/ || o =~ /^SYS_/ || o =~ /^ORA_/ } unless options['a']
+        objects.select! { |o| o =~ /^#{Regexp.escape(filter).gsub('\*', '.*').gsub('\?', '.')}$/ } if filter
+        objects
+      end
+    end
+  end
+end

data/lib/oraora/meta/sequence.rb

@@ -0,0 +1,33 @@
+require_relative './object.rb'
+
+module Oraora
+  class Meta
+    class Sequence < Object
+      def type
+        'SEQUENCE'
+      end
+
+      def load_from_oci(oci)
+        @min, @max, @inc, @last = oci.select_one("SELECT min_value, max_value, increment_by, last_number
+                                                    FROM all_sequences
+                                                   WHERE sequence_owner = :schema AND sequence_name = :name", @schema, @name)
+        raise NotExists if !@min
+        self
+      end
+
+      def describe(options = {})
+        <<-HERE.reset_indentation
+          Sequence #{@schema}.#{@name}
+          Min value:    #{@min.to_i}
+          Max value:    #{@max.to_i}
+          Increment by: #{@inc.to_i}
+          Last value:   #{@last.to_i}
+        HERE
+      end
+
+      def list(options = {}, filter = nil)
+        raise NotApplicable, "Nothing to list for sequence"
+      end
+    end
+  end
+end

data/lib/oraora/meta/subprogram.rb

@@ -0,0 +1,36 @@
+module Oraora
+  class Meta
+    class Subprogram
+      attr_reader :id, :schema, :package, :name
+
+      def initialize(schema, package, name)
+        @schema = schema
+        @package = package
+        @name = name
+      end
+
+      def load_from_oci(oci)
+        @id =
+            oci.select_one("SELECT subprogram_id FROM all_procedues WHERE owner = :schema AND object_name = :package AND procedure_name = :name", @schema, @package, @name)
+        self
+      end
+
+      def self.from_oci(oci, schema, package, name)
+        new(schema, package, name).load_from_oci(oci)
+      end
+
+      def describe(options = {})
+        <<-HERE.reset_indentation
+          Schema:       #{@schema}
+          Package:      #{@package}
+          Name:         #{@name}
+          Id:           #{@id}
+        HERE
+      end
+
+      def list(options = {}, filter = nil)
+        raise NotApplicable, "Nothing to list for subprogram"
+      end
+    end
+  end
+end

data/lib/oraora/meta/table.rb

@@ -0,0 +1,42 @@
+require_relative './object.rb'
+
+module Oraora
+  class Meta
+    class Table < Object
+      def type
+        'TABLE'
+      end
+
+      def load_from_oci(oci)
+        @partitioned = oci.select_one("SELECT partitioned FROM all_tables WHERE owner = :schema AND table_name = :name", @schema, @name).first
+        raise NotExists if !@partitioned
+        @columns = oci.pluck("SELECT column_name, column_id, data_type, data_length, data_precision, data_scale, char_used, char_length " +
+                             "FROM all_tab_columns WHERE owner = :schema AND table_name = :name ORDER BY column_id", @schema, @name).collect do |col|
+          Column.new(@schema, @name, col[0], id: col[1].to_i, type: col[2], length: col[3] && col[3].to_i,
+                                             precision: col[4] && col[4].to_i, scale: col[5] && col[5].to_i, char_used: col[6],
+                                             char_length: col[7] && col[7].to_i)
+        end
+        @columns_hash = Hash[@columns.collect { |col| [col.name, col] }]
+        self
+      end
+
+      def describe(options = {})
+        <<-HERE.reset_indentation
+          Table #{@schema}.#{@name}
+          Partitioned:  #{@partitioned}
+        HERE
+      end
+
+      def list(options = {}, filter = nil)
+        columns = @columns_hash.keys
+        columns.select! { |c| c =~ /^#{Regexp.escape(filter).gsub('\*', '.*').gsub('\?', '.')}$/ } if filter
+        columns
+      end
+
+      def columns(column)
+        raise NotExists if !@columns_hash[column]
+        @columns_hash[column]
+      end
+    end
+  end
+end

data/lib/oraora/meta/view.rb

@@ -0,0 +1,41 @@
+require_relative './object.rb'
+
+module Oraora
+  class Meta
+    class View < Object
+      def type
+        'VIEW'
+      end
+
+      def load_from_oci(oci)
+        x = oci.select_one("SELECT 1 FROM all_views WHERE owner = :schema AND view_name = :name", @schema, @name).first
+        raise NotExists if !x
+        @columns = oci.pluck("SELECT column_name, column_id, data_type, data_length, data_precision, data_scale, char_used, char_length " +
+                                 "FROM all_tab_columns WHERE owner = :schema AND table_name = :name ORDER BY column_id", @schema, @name).collect do |col|
+          Column.new(@schema, @name, col[0], id: col[1].to_i, type: col[2], length: col[3] && col[3].to_i,
+                     precision: col[4] && col[4].to_i, scale: col[5] && col[5].to_i, char_used: col[6],
+                     char_length: col[7] && col[7].to_i)
+        end
+        @columns_hash = Hash[@columns.collect { |col| [col.name, col] }]
+        self
+      end
+
+      def describe(options = {})
+        <<-HERE.reset_indentation
+          View #{@schema}.#{@name}
+        HERE
+      end
+
+      def list(options = {}, filter = nil)
+        columns = @columns_hash.keys
+        columns.select! { |c| c =~ /^#{Regexp.escape(filter).gsub('\*', '.*').gsub('\?', '.')}$/ } if filter
+        columns
+      end
+
+      def columns(column)
+        raise NotExists if !@columns_hash[column]
+        @columns_hash[column]
+      end
+    end
+  end
+end

data/lib/oraora/oci.rb

@@ -0,0 +1,56 @@
+module Oraora
+  # Wrapper around OCI8 to add some extra stuff
+  class OCI < OCI8
+    # Wrapped in a separate thread as OCI8 seems to ignore interrupts
+    def initialize(*args)
+      ret = nil
+      thread = Thread.new { ret = super }
+      thread.join
+      ret
+    end
+
+    # Wrapped in a separate thread as OCI8 seems to ignore interrupts
+    def logoff
+      ret = nil
+      thread = Thread.new { ret = super }
+      thread.join
+      ret
+    end
+
+    # Wrapped in a separate thread with Interrupt handling
+    def exec(sql, *bindvars, &block)
+      ret = nil
+      thread = Thread.new { ret = super }
+      thread.join
+      ret
+    rescue Interrupt
+      self.break
+      raise
+    end
+
+    # Wrapped in a separate thread with Interrupt handling
+    def select_one(sql, *bindvars)
+      ret = nil
+      thread = Thread.new { ret = super }
+      thread.join
+      ret
+    rescue Interrupt
+      self.break
+      raise
+    end
+
+    # Returns the query result as an array of arrays
+    def pluck(sql, *bindvars)
+      result = []
+      exec(sql, *bindvars) { |row| result << row }
+      result
+    end
+
+    # Returns first column of a query as an array
+    def pluck_one(sql, *bindvars)
+      result = []
+      exec(sql, *bindvars) { |row| result << row.first }
+      result
+    end
+  end
+end

data/lib/oraora/terminal.rb

@@ -0,0 +1,55 @@
+module Oraora
+  module Terminal
+    def self.width
+      HighLine::SystemExtensions.terminal_size[0]
+    end
+
+    def self.height
+      HighLine::SystemExtensions.terminal_size[1]
+    end
+
+    def self.puts_grid(items)
+      # TODO: Disable terminal size check when not reading from terminal
+      terminal_cols = [width || 0, 32].max
+      object_cols = terminal_cols / 32
+      # TODO: Determine optimal object_cols
+      num_rows = (items.length + object_cols - 1) / object_cols
+      #@logger.debug "Determined #{num_rows} rows of #{object_cols} objects for #{items.count} objects and #{terminal_cols} terminal width"
+      (0...num_rows).each do |row|
+        line = ''
+        (0...object_cols).each do |col|
+          index = num_rows * col + row
+          line += items[index].ljust(32) if items[index]
+        end
+        puts line
+      end
+    end
+
+    def self.puts_cursor(cursor)
+      # Column metadata
+      column_names = cursor.get_col_names
+
+      cursor.prefetch_rows = 1000
+      begin
+        # Fetch 1000 rows
+        output = []
+        column_lengths = Array.new(column_names.length, 1)
+        while output.length < 1000 && record = cursor.fetch
+          record.collect! { |val| val.is_a?(BigDecimal) ? val.to_s('F').gsub(/\.0+$/, '') : val.to_s }
+          output << record
+          column_lengths = column_lengths.zip(record.collect { |v| v.length}).collect(&:max)
+        end
+
+        # Output
+        if !output.empty?
+          puts "%-*.*s  " * column_names.length % column_lengths.zip(column_lengths, column_names).flatten
+          puts "%-*s  " * column_names.length % column_lengths.zip(column_lengths.collect { |c| '-' * c }).flatten
+          output.each do |row|
+            puts "%-*s  " * row.length % column_lengths.zip(row).flatten
+          end
+          puts
+        end
+      end while record
+    end
+  end
+end

data/oraora.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |s|
+  s.name        = 'oraora'
+  s.version     = '0.1.0'
+  s.summary     = "Interactive command-line utility for Oracle"
+  s.description = "Interactive command-line utility for Oracle"
+
+  s.author      = "kmehkeri"
+  s.email       = 'kmehkeri@gmail.com'
+  s.homepage    = 'http://rubygems.org/gems/oraora'
+  s.license     = 'MIT'
+
+  s.files       = `git ls-files`.split($/)
+  s.executables = `git ls-files -- bin`.split($/).map { |f| File.basename(f)  }
+
+  s.add_runtime_dependency 'highline'
+  s.add_runtime_dependency 'ruby-oci8'
+  s.add_runtime_dependency 'indentation'
+  s.add_runtime_dependency 'colorize'
+  s.add_runtime_dependency 'bigdecimal'
+
+  s.add_development_dependency 'rspec'
+end

data/spec/context_spec.rb

@@ -0,0 +1,132 @@
+require 'oraora/context'
+
+describe Oraora::Context do
+
+  describe '.initialize' do
+    it "should initialize from hash" do
+      context = Oraora::Context.new('V', schema: 'X', object: 'Y', object_type: 'TABLE')
+      expect( context.level ).to eql :object
+      expect( context.user ).to eql 'V'
+      expect( context.schema ).to eql 'X'
+      expect( context.object ).to eql 'Y'
+      expect( context.object_type ).to eql 'TABLE'
+    end
+  end
+
+  describe '.su' do
+    it "should return a different context object" do
+      context = Oraora::Context.new('V', schema: 'X', object: 'Y', object_type: 'TABLE')
+      expect( context.su('Z') ).not_to eql context
+    end
+
+    it "should store specified user" do
+      context = Oraora::Context.new('V', schema: 'X', object: 'Y', object_type: 'TABLE').su('Z')
+      expect( context.user ).to eql 'Z'
+    end
+
+    it "should store original context's data" do
+      context = Oraora::Context.new('V', schema: 'X', object: 'Y', object_type: 'TABLE').su('Z')
+      expect( context.schema ).to eql 'X'
+      expect( context.object ).to eql 'Y'
+    end
+  end
+
+  describe '.dup' do
+    it "should return equal context" do
+      context = Oraora::Context.new('V', schema: 'X', object: 'Y', object_type: 'TABLE').dup
+      expect( context.user ).to eql 'V'
+      expect( context.schema ).to eql 'X'
+      expect( context.object ).to eql 'Y'
+      expect( context.object_type ).to eql 'TABLE'
+    end
+  end
+
+  describe '#set & #traverse' do
+    it "should set root context correctly" do
+      context = Oraora::Context.new.set({})
+      expect( context.level ).to be_nil
+      expect( context.schema ).to be_nil
+    end
+
+    it "should set schema context correctly" do
+      context = Oraora::Context.new.set(schema: 'A')
+      expect( context.level ).to eql :schema
+      expect( context.schema ).to eql 'A'
+    end
+
+    it "should set column context correctly" do
+      context = Oraora::Context.new.set(schema: 'A', object: 'B', object_type: 'TABLE', column: 'C')
+      expect( context.level ).to eql :column
+      expect( context.schema ).to eql 'A'
+      expect( context.object ).to eql 'B'
+      expect( context.column ).to eql 'C'
+    end
+
+    it "should set user correctly on the context" do
+      context = Oraora::Context.new('AA').set(schema: 'A')
+      expect( context.level ).to eql :schema
+      expect( context.user ).to eql 'AA'
+      expect( context.schema ).to eql 'A'
+    end
+
+    it "should save user when switching context" do
+      context = Oraora::Context.new('AA').set(schema: 'A')
+      context.set(schema: 'B')
+      expect( context.level ).to eql :schema
+      expect( context.user ).to eql 'AA'
+      expect( context.schema ).to eql 'B'
+    end
+
+    it "should raise error on invalid key" do
+      expect { Oraora::Context.new.set(foo: 'A') }.to raise_exception(Oraora::Context::InvalidKey)
+    end
+
+    it "should raise error on missing object_type when object is present" do
+      expect { Oraora::Context.new.set(schema: 'A', object: 'B') }.to raise_exception(Oraora::Context::InvalidKey)
+    end
+
+    it "should raise error on invalid combination of keys" do
+      expect { Oraora::Context.new.set(schema: 'A', column: 'B', subprogram: 'C') }.to raise_exception(Oraora::Context::InvalidKey)
+    end
+  end
+
+  describe "#up" do
+    it "should do nothing when already at root" do
+      context = Oraora::Context.new.up
+      expect( context.level ).to be_nil
+    end
+
+    it "should go up from object to schema level" do
+      context = Oraora::Context.new(nil, schema: 'A', object: 'B', object_type: 'TABLE').up
+      expect( context.level ).to eql :schema
+      expect( context.schema ).to eql 'A'
+      expect( context.object ).to be_nil
+    end
+
+    it "should go up from column to object level" do
+      context = Oraora::Context.new(nil, schema: 'X', object: 'Y', object_type: 'TABLE', column: 'Z').up
+      expect( context.level ).to eql :object
+      expect( context.schema ).to eql 'X'
+      expect( context.object ).to be_eql 'Y'
+      expect( context.column ).to be_nil
+    end
+  end
+
+  describe '#prompt' do
+    it "should display correct prompt for context" do
+      {
+        {}                                                                      => '/',
+        { schema: 'Q' }                                                         => 'Q',
+        { schema: 'U' }                                                         => '~',
+        { schema: 'A', object: 'B', object_type: 'TABLE' }                      => 'A.B',
+        { schema: 'U', object: 'B', object_type: 'PACKAGE' }                    => '~.B',
+        { schema: 'U', object: 'Y', object_type: 'TABLE', column: 'Z' }         => '~.Y.Z',
+        { schema: 'MMM', object: 'NNN', object_type: 'VIEW', column: 'TEST' }   => 'MMM.NNN.TEST'
+      }.each do |hash, prompt|
+        expect( Oraora::Context.new('U', hash).prompt ).to eql prompt
+      end
+    end
+  end
+end
+
+