oraora 0.1.0

data/lib/oraora/awareness.rb

@@ -0,0 +1,78 @@
+module Oraora
+  module Awareness
+    Entry = Struct.new(:key, :object_types, :map, :sql)
+
+    ENRICH_MAP = [
+      # Column
+      Entry.new(:column, nil,                                     %w(SELECT ;),         'SELECT $column FROM $object'),
+      *%w(PARTITION WHERE CONNECT GROUP MODEL UNION INTERSECT MINUS ORDER).collect do |keyword|
+        Entry.new(:column, nil,                                     [keyword],            "SELECT $column FROM $object #{keyword}")
+      end,
+      Entry.new(:column, nil,                                     %w(SET),              'UPDATE $object SET $column ='),
+      Entry.new(:column, 'TABLE',                                 %w(DROP),             'ALTER TABLE $object DROP COLUMN $column'),
+      Entry.new(:column, 'TABLE',                                 %w(RENAME),           'ALTER TABLE $table RENAME COLUMN $column TO'),
+
+      # Table
+      Entry.new(:object, 'TABLE',                                 %w(DROP ;),           'DROP TABLE $object'),
+      Entry.new(:object, 'TABLE',                                 %w(DROP CASCADE),     'DROP TABLE $object CASCADE'),
+      Entry.new(:object, 'TABLE',                                 %w(DROP PURGE),       'DROP TABLE $object PURGE'),
+      Entry.new(:object, 'TABLE',                                 %w(TRUNCATE),         'TRUNCATE TABLE $object'),
+      Entry.new(:object, 'TABLE',                                 %w(DROP PARTITION),   'ALTER TABLE $object DROP PARTITION'),
+      *%w(ADD MODIFY RENAME PARALLEL NOPARALLEL ENABLE DISABLE CACHE NOCACHE READ REKEY PCTFREE PCTUSED INITRANS COMPRESS NOCOMPRESS SHRINK MERGE SPLIT).collect do |keyword|
+        Entry.new(:object, 'TABLE',                                 [keyword],            "ALTER TABLE $object #{keyword}")
+      end,
+
+      # View
+      Entry.new(:object, 'VIEW',                                  %w(DROP),             'DROP VIEW $object'),
+      Entry.new(:object, 'VIEW',                                  %w(RENAME),           'RENAME $object'),
+      Entry.new(:object, 'VIEW',                                  %w(COMPILE),          'ALTER VIEW $object COMPILE'),
+
+      # Mview
+      Entry.new(:object, 'MATERIALIZED VIEW',                     %w(DROP),             'DROP MATERIALIZED VIEW $object'),
+
+      # Relation
+      Entry.new(:object, ['TABLE', 'VIEW', 'MATERIALIZED VIEW'],  %w(SELECT ;),         'SELECT * FROM $object'),
+      Entry.new(:object, ['TABLE', 'VIEW', 'MATERIALIZED VIEW'],  %w(COUNT ),           'SELECT count(*) FROM $object'),
+      *%w(PARTITION WHERE CONNECT GROUP MODEL UNION INTERSECT MINUS ORDER).collect do |keyword|
+        Entry.new(:object, ['TABLE', 'VIEW', 'MATERIALIZED VIEW'],  [keyword],            "SELECT * FROM $object #{keyword}")
+      end,
+      Entry.new(:object, ['TABLE', 'VIEW', 'MATERIALIZED VIEW'],  %w(SET),              'UPDATE  $object SET'),
+      Entry.new(:object, ['TABLE', 'VIEW', 'MATERIALIZED VIEW'],  %w(DELETE ;),         'DELETE FROM $object'),
+      Entry.new(:object, ['TABLE', 'VIEW', 'MATERIALIZED VIEW'],  %w(DELETE WHERE),     'DELETE FROM $object WHERE'),
+      Entry.new(:object, ['TABLE', 'VIEW', 'MATERIALIZED VIEW'],  %w(INSERT VALUES),    'INSERT INTO $object VALUES'),
+      Entry.new(:object, ['TABLE', 'VIEW', 'MATERIALIZED VIEW'],  %w(INSERT SELECT),    'INSERT INTO $object SELECT'),
+
+      # Schema
+      *%w(IDENTIFIED PROFILE ACCOUNT QUOTA DEFAULT TEMPORARY).collect do |keyword|
+        Entry.new(:schema, nil,                                     [keyword],            "ALTER USER $schema #{keyword}")
+      end
+    ]
+
+    def self.enrich(sql, context)
+      tokens = []
+      map = []
+      (sql + ';').scan(/(?:\w+|\/\*.*?\*\/|--.*?\n|;|\s+)/mi) do |token|
+        tokens << token
+        if token =~ /^(\/\*.*?\*\/|--.*?\n|\s+)$/mi
+          next
+        end
+        map << token.upcase
+        #puts "[AWARENESS] #{token}, map: #{map}"
+        match = ENRICH_MAP.detect do |entry|
+          context.send(entry.key) && (!entry.object_types || [*entry.object_types].include?(context.object_type)) && map == entry.map
+        end
+
+        if match
+          #puts "[AWARENESS] Map match: #{match.sql}"
+          sql =~ /^#{tokens.join.chomp(';')}(.*)$/mi
+          last_part = $1
+          first_part = eval '"' + match.sql.gsub(/\$(\w+)+/, '#{context.send(:\1)}') + '"'
+          return first_part + last_part
+        end
+
+        break if tokens.length >= 2
+      end
+      sql
+    end
+  end
+end

data/lib/oraora/completion.rb

@@ -0,0 +1,56 @@
+module Oraora
+  class Completion
+    TEMPLATES = {
+        's'  => 'SELECT ',
+        's*' => 'SELECT * FROM ',
+        'c*' => 'SELECT COUNT(*) FROM ',
+        'i'  => 'INSERT ',
+        'u'  => 'UPDATE ',
+        'd'  => 'DELETE ',
+        'a'  => 'ALTER ',
+        'c'  => 'CREATE ',
+        'cr' => 'CREATE OR REPLACE '
+    }
+
+    def initialize(app)
+      @app = app
+    end
+
+    def comp_proc
+      Proc.new do |s|
+        # Complete with template alone if matched
+        if TEMPLATES[Readline.line_buffer.downcase]
+          TEMPLATES[Readline.line_buffer.downcase]
+
+        else
+          # Complete for SQL keywords
+          comp = App::SQL_KEYWORDS
+
+          # Complete for current context
+          if s !~ /[\.\/]/
+            comp += @app.meta.find(@app.context).list rescue []
+            context = @app.context.dup
+            comp += @app.meta.find(context.up).list while context.level
+
+          # Complete for input
+          else
+            context = @app.context.dup
+            path = s.split(/(?<=[\.\/])/, -1)
+            last = path.pop
+            loop do
+              comp_context = @app.context_for(context, path.join) rescue nil
+              if comp_context
+                comp += @app.meta.find(comp_context).list.collect { |n| path.join + n } rescue []
+              end
+              break if context.level == nil
+              context.up
+            end
+          end
+
+          comp.sort.uniq.grep(/^#{Regexp.escape(s)}/i)
+        end
+      end
+    end
+
+  end
+end

data/lib/oraora/context.rb

@@ -0,0 +1,90 @@
+module Oraora
+  class Context
+    class InvalidKey < StandardError; end
+
+    HIERARCHY = {
+      nil =>       [:schema],
+      schema:      [:object],
+      object:      [:column, :subprogram],
+      column:      [],
+      subprogram:  [],
+    }
+    KEYS = HIERARCHY.keys.compact + [:object_type, :subprogram_type]
+    RELATION_OBJECT_TYPES = ['TABLE', 'VIEW', 'MATERIALIZED VIEW']
+
+    attr_reader :level, :user, *KEYS
+
+    def initialize(user = nil, hash = {})
+      @user = user
+      set(hash)
+    end
+
+    def su(user)
+      self.class.new(user, key_hash)
+    end
+
+    def dup
+      su(@user)
+    end
+
+    def set(hash = {})
+      KEYS.each { |key| instance_variable_set("@#{key}", nil) }
+      @level = nil
+      traverse(hash)
+    end
+
+    def traverse(hash)
+      while(!hash.empty?) do
+        key = HIERARCHY[@level].detect { |k| hash[k] } or raise InvalidKey
+        case key
+          when :column then raise InvalidKey unless RELATION_OBJECT_TYPES.include?(@object_type)
+          when :object then raise InvalidKey unless @object_type = hash.delete(:object_type)
+          when :subprogram then raise InvalidKey unless @object_type == :package && @subprogram_type = hash.delete(:subprogram_type)
+        end
+        @level = key
+        instance_variable_set("@#{key}", hash.delete(key))
+      end
+      self
+    end
+
+    def root
+      set
+    end
+
+    def up
+      case @level
+        when nil then return self
+        when :subprogram then @subprogram_type = nil
+        when :object then @object_type = nil
+      end
+      instance_variable_set("@#{level}", nil)
+      @level = HIERARCHY.invert.detect { |k, v| k.include? @level }.last
+      self
+    end
+
+    def prompt
+      if @schema
+        p = @user == @schema ? '~' : @schema
+        level_2 = @object
+        p += ".#{level_2}" if level_2
+        level_3 = @column || @subprogram
+        p += ".#{level_3}" if level_3
+      else
+        p = '/'
+      end
+      p
+    end
+
+    def key_hash
+      Hash[ KEYS.collect { |key| [key, instance_variable_get("@#{key}")] } ].delete_if { |k, v| v.nil? }
+    end
+
+    def hash
+      key_hash.hash
+    end
+
+    def eql?(other)
+      key_hash == other.key_hash
+    end
+  end
+end

data/lib/oraora/credentials.rb

@@ -0,0 +1,64 @@
+module Oraora
+  class Credentials
+    class ParseError < StandardError; end
+
+    attr_accessor :user, :password, :database
+    @@vault = []
+
+    def initialize(user = nil, password = nil, database = nil)
+      @user = user
+      @password = password
+      @database = database
+    end
+
+    def self.read_passfile(filename)
+      @@vault = []
+      ok = true
+      File.open(filename, "r") do |infile|
+        while (line = infile.gets)
+          begin
+            @@vault << parse(line.chomp)
+          rescue ParseError
+            ok = false
+          end
+        end
+      end
+      ok
+    end
+
+    def self.parse(str)
+      if str
+        match = str.match /^([^\/@]+)?\/?([^\/@]+)?@?([^\/@]+)?$/
+        raise ParseError, "invalid format (use login/pass@DB)" if !match
+        user, password, database = match[1..3]
+        raise ParseError, "user can only contain alphanumeric characters" if user && !user.match(/^\w+$/)
+        raise ParseError, "database name can only contain alphanumeric characters" if database && !database.match(/^\w+$/)
+        return new(user, password, database)
+      else
+        return new
+      end
+    end
+
+    def fill_password_from_vault
+      entry = @@vault.detect { |e| match?(e) }
+      @password = entry.password if entry && !@password
+      self
+    end
+
+    def to_s
+      s = @user || ''
+      s += '/' + @password if @password
+      s = '/' if s == ''
+      s += '@' + @database if @database
+      s
+    end
+
+    def eql?(c)
+      user == c.user && password == c.password && database == c.database
+    end
+
+    def match?(c)
+      user == c.user && database == c.database
+    end
+  end
+end

data/lib/oraora/logger.rb

@@ -0,0 +1,19 @@
+require 'logger'
+require 'colorize'
+
+module Oraora
+  class Logger < ::Logger
+    SEVERITY_COLORS = {
+        'WARN' => :yellow,
+        'ERROR' => :red,
+        'INFO' => :light_black,
+        'DEBUG' => :light_black
+    }
+
+    def initialize(name, log_level = ::Logger::WARN)
+      super
+      self.level = log_level
+      self.formatter = proc { |severity, datetime, progname, msg| "[#{severity}] #{msg}\n".send(SEVERITY_COLORS[severity]) }
+    end
+  end
+end

data/lib/oraora/meta.rb

@@ -0,0 +1,39 @@
+module Oraora
+  # Helper class wrapping OCI methods for querying metadata
+  class Meta
+    class NotExists < StandardError; end
+    class NotApplicable < StandardError; end
+
+    # Initializes with OCI
+    def initialize(oci)
+      @oci = oci
+      @cache = {}
+    end
+
+    # Returns a node identified by context
+    def find(context)
+      node = case context.level
+               when nil
+                 @cache[context] || Meta::Database.from_oci(@oci)
+               when :schema
+                 @cache[context] || Meta::Schema.from_oci(@oci, context.schema)
+               when :object
+                 @cache[context] || Meta::Object.from_oci(@oci, context.schema, context.object, context.object_type)
+               when :column
+                 find(context.dup.up).columns(context.column)
+             end
+      @cache[context] = node if node && context.level != :column
+      node
+    end
+
+    # Returns an object node identified by name
+    def find_object(schema, name)
+      Meta::Object.from_oci(@oci, schema, name)
+    end
+
+    # Removes all cached metadata
+    def purge_cache
+      @cache = {}
+    end
+  end
+end

data/lib/oraora/meta/column.rb

@@ -0,0 +1,45 @@
+module Oraora
+  class Meta
+    class Column
+      CHAR_USED_MAP = { 'B' => 'BYTE', 'C' => 'CHAR' }
+      attr_reader :name, :id
+
+      def initialize(schema, relation, name, attributes = {})
+        @schema = schema
+        @relation = relation
+        @name = name
+        attributes.each { |k, v| instance_variable_set("@#{k}".to_sym, v) }
+      end
+
+      def describe(options = {})
+        <<-HERE.reset_indentation
+          Column #{@schema}.#{@relation}.#{@name}
+          Id:           #{@id}
+          Type:         #{display_type}
+        HERE
+      end
+
+      def list(options = {}, filter = nil)
+        raise NotApplicable, "Nothing to list for column"
+      end
+
+      def display_type
+        case @type
+          when 'NUMBER'
+            case
+              when !@precision && !@scale then "NUMBER"
+              when !@precision && @scale == 0 then "INTEGER"
+              when @scale == 0 then "NUMBER(#{@precision})"
+              else "NUMBER(#{@precision},#{@scale})"
+            end
+          when 'CHAR', 'NCHAR'
+            @char_length == 1 ? 'CHAR' : "CHAR(#{@char_length} #{@char_used})"
+          when 'VARCHAR', 'VARCHAR2', 'NVARCHAR2'
+            "#{@type}(#{@char_length} #{CHAR_USED_MAP[@char_used]})"
+          else
+            @type
+        end
+      end
+    end
+  end
+end

data/lib/oraora/meta/database.rb

@@ -0,0 +1,27 @@
+module Oraora
+  class Meta
+    class Database
+      def load_from_oci(oci)
+        @name, @created = oci.select_one("SELECT name, created FROM v$database")
+        @schemas = oci.pluck_one("SELECT username FROM all_users ORDER BY username")
+        self
+      end
+
+      def self.from_oci(oci)
+        new.load_from_oci(oci)
+      end
+
+      def describe(options = {})
+        <<-HERE.reset_indentation
+          Database #{@name}
+          Created:      #{@created}
+        HERE
+      end
+
+      def list(options = {}, filter = nil)
+        schemas = @schemas.select! { |o| o =~ /^#{Regexp.escape(filter).gsub('\*', '.*').gsub('\?', '.')}$/ } if filter
+        schemas || @schemas
+      end
+    end
+  end
+end

data/lib/oraora/meta/materialized_view.rb

@@ -0,0 +1,48 @@
+require_relative './object.rb'
+
+module Oraora
+  class Meta
+    class MaterializedView < Object
+      def type
+        'MATERIALIZED VIEW'
+      end
+
+      def load_from_oci(oci)
+        @updatable, @refresh_mode, @fast_refreshable, @staleness =
+            oci.select_one("SELECT updatable, refresh_mode, fast_refreshable, staleness
+                              FROM all_mviews
+                             WHERE owner = :schema AND mview_name = :name", @schema, @name)
+        raise NotExists if !@updatable
+        @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
+          Materialized view #{@schema}.#{@name}
+          Updatable:        #{@updatable}
+          Refresh mode:     #{@refresh_mode}
+          Fast refreshable: #{@fast_refreshable}
+          Staleness:        #{@staleness}
+        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