vorax 0.4.2 → 5.0

data/lib/vorax/parser/plsql_walker.rb

@@ -1,143 +0,0 @@
-# encoding: utf-8
-
-require 'strscan'
-
-module Vorax
-
-  module Parser
-
-    # A PLSQL string scanner which is looking for interesting points within
-    # the provided source code. This is used instead of a fully fledged parser
-    # for speed considerations.
-    class PLSQLWalker
-
-      BEGIN_ML_COMMENT = /\/\*/ unless defined?(BEGIN_ML_COMMENT)
-      END_ML_COMMENT = /\*\// unless defined?(END_ML_COMMENT)
-      BEGIN_SL_COMMENT = /--/ unless defined?(BEGIN_SL_COMMENT)
-      END_SL_COMMENT = Parser::END_LINE unless defined?(END_SL_COMMENT)
-      BEGIN_PLSQL_SPECIAL_QUOTING = /q'[!\[{(<]/ unless defined?(BEGIN_PLSQL_SPECIAL_QUOTING)
-      BEGIN_DOUBLE_QUOTING = /[\"]/ unless defined?(BEGIN_DOUBLE_QUOTING)
-      BEGIN_SINGLE_QUOTING = /[']/ unless defined?(BEGIN_SINGLE_QUOTING)
-
-      # Create a new parse walker.
-      #
-      # @param text [String] the text to be walked/parsed
-      # @param create_default_spots [boolean] whenever or not to create default 
-      #  detection spots: multiline comments, singleline comments and quoted literals
-      def initialize(text, create_default_spots=true)
-        @text = text
-        @matchers = []
-        @ss = StringScanner.new(text)
-        create_default_spots() if create_default_spots
-      end
-
-      # Returns the string scanner used for walking the string.
-      #
-      # @return [StringScanner] the string scanner
-      def scanner
-        @ss
-      end
-
-      # Register a new detection spot. The order of specifying these spots is important.
-      #
-      # @param pattern [Regexp] the spot regular expression
-      # @param callback [Procedure] what to do when this spot is detected. The registered
-      #   block is always called with the string scanner object. Please do not use "return"
-      #   to exit from the defined block.
-      def register_spot(pattern, &callback)
-        @matchers << {:pattern => pattern, :callback => callback}
-      end
-
-      # Walk the text and trigger the registered callbacks. It returns the text which was
-      # successfully walked.
-      def walk
-        global_matcher = Regexp.new(@matchers.map { |e| e[:pattern].to_s }.join('|'), 
-                                    Regexp::IGNORECASE)
-        while !@ss.eos?
-          if match = @ss.scan_until(global_matcher)
-            current_pos = @ss.pos
-            @matchers.each do |matcher|
-              if @ss.matched =~ matcher[:pattern]
-                matcher[:callback].call(@ss)
-              end
-            end
-          else
-            @ss.terminate
-          end
-        end
-      end
-
-      # Register a spot to walk a multiline comment.
-      def register_default_ml_comment_spot
-        register_spot(BEGIN_ML_COMMENT) do |scanner|
-          scanner.scan_until(END_ML_COMMENT)
-        end
-      end
-
-      # Register a spot to walk a single line comment.
-      def register_default_sl_comment_spot
-        register_spot(BEGIN_SL_COMMENT) do |scanner|
-          scanner.scan_until(END_SL_COMMENT)
-        end
-      end
-
-      # Register a spot to walk a plsql special quoting liternal.
-      def register_default_plsql_quoting_spot
-        register_spot(BEGIN_PLSQL_SPECIAL_QUOTING) do |scanner|
-          scanner.scan_until(END_SL_COMMENT)
-          if scanner.matched =~ /q'\[/
-            scanner.scan_until(/\]'/) 
-          elsif scanner.matched =~ /q'[{]/
-            scanner.scan_until(/[}]'/) 
-          elsif scanner.matched =~ /q'[(]/
-            scanner.scan_until(/[)]'/) 
-          elsif scanner.matched =~ /q'[<]/
-            scanner.scan_until(/[>]'/) 
-          end
-        end
-      end
-
-      # Register a spot to walk a double quoted literal.
-      def register_default_double_quoting_spot
-        register_spot(BEGIN_DOUBLE_QUOTING) do |scanner|
-          scanner.scan_until(/"/)
-        end
-      end
-
-      # Register a spot to walk a single quoted literal.
-      def register_default_single_quoting_spot
-        register_spot(BEGIN_SINGLE_QUOTING) do |scanner|
-          collector = ''
-          begin
-            if match = scanner.scan_until(/\'+/) 
-              collector << match
-            end
-          end while (scanner.matched != "'" && !scanner.eos?)
-          collector
-        end
-      end
-
-      private
-
-      def create_default_spots
-        # define a multiline comment spot
-        register_default_ml_comment_spot()
-
-        # define a single line comment spot
-        register_default_sl_comment_spot()
-
-        # define special PLSQL quotes spot
-        register_default_plsql_quoting_spot()
-
-        # register a double quoted string spot
-        register_default_double_quoting_spot()
-        
-        # register a single quoted string spot
-        register_default_single_quoting_spot()
-      end
-
-    end
-
-  end
-
-end

data/lib/vorax/parser/statement_inspector.rb~

@@ -1,52 +0,0 @@
-# encoding: utf-8
-
-module Vorax
-
-  module Parser
-
-    class StatementInspector
-
-      def initialize(statement)
-        @statement = statement
-      end
-
-      def type
-        @type ||= Statement.new.type(statement)
-      end
-
-      def data_source
-        descriptor.refs
-      end
-
-      def recursive_data_source(refs, collect, position)
-        inner = refs.find { |r| r.respond_to?(:range) && r.range.include?(position) }
-        collect.unshift(refs).flatten!
-        if inner
-          desc = Parser::Alias.new
-          desc.walk(inner.base)
-          data_source(desc.refs, collect, position - inner_expr.range.first)
-        else
-          return collect
-        end
-      end
-
-      def query_fields
-        @query_fields ||= Column.new.walk(descriptor.query_fields)
-      end
-
-      private
-
-      def descriptor
-        unless @desc
-          @desc = Parser::Alias.new
-          @desc.walk(@statement)
-        end
-        @desc
-      end
-      
-    end
-
-  end
-  
-end
-

data/lib/vorax/parser/stmt_inspector.rb

@@ -1,78 +0,0 @@
-# encoding: utf-8
-
-module Vorax
-
-  module Parser
-
-    # A class used to gather metadata information for an SQL statement. This is needed
-    # especially for implementing VoraX code completion.
-    class StmtInspector
-
-      # Creates a new statement inspector.
-      #
-      # @param statement [String] the statement to be inspected
-      def initialize(statement)
-        @statement = statement
-      end
-
-      # Get the type of the statement
-      #
-      # (see Parser.statement_type)
-      def type
-        @type ||= Parser.statement_type(statement)
-      end
-
-      # Get all tableref/exprref for this statement, taking into account
-      # the current position within that statement.
-      #
-      # @param position [int] the current position.
-      # @return an array of TableRef/ExprRef objects
-      def data_source(position=0)
-        recursive_data_source(descriptor.refs, position)
-      end
-
-      # If it's a query, the corresponding columns are returned.
-      #
-      # @return an array of columns
-      def query_fields
-        @query_fields ||= Column.new.walk(descriptor.query_fields)
-      end
-
-      # Find the provided alias for the statement, taking into account the
-      # current position.
-      #
-      # @param name [String] the alias name
-      # @param position [int] the current position
-      def find_alias(name, position=0)
-        data_source(position).find { |r| r.pointer && r.pointer.upcase == name.upcase }
-      end
-
-      private
-
-      def descriptor
-        unless @desc
-          @desc = Parser::Alias.new
-          @desc.walk(@statement)
-        end
-        @desc
-      end
-
-      def recursive_data_source(refs, position, collect = [])
-        inner = refs.find { |r| r.respond_to?(:range) && r.range.include?(position) }
-        collect.unshift(refs).flatten!
-        if inner
-          desc = Parser::Alias.new
-          desc.walk(inner.base)
-          recursive_data_source(desc.refs, position - inner.range.first, collect)
-        else
-          return collect
-        end
-      end
-
-      
-    end
-
-  end
-  
-end
-

data/lib/vorax/parser/target_ref.rb

@@ -1,110 +0,0 @@
-# encoding: UTF-8
-
-module Vorax
-
-  module Parser
-
-    # An abstraction for a table reference within an SQL statement. This class is used
-    # by the StmtInspector to model the FROM clause of a query or the target table of
-    # an INSERT or UPDATE.
-    class TableRef
-
-      attr_reader :base, :pointer
-
-      # Creates a new TableRef object.
-      #
-      # @param base [String] is the actual table/view name from the SQL statement.
-      # @param pointer [String] is the alias of the table, if there's any
-      def initialize(base, pointer = nil)
-        @base = base
-        @pointer = pointer
-      end
-
-      # Return the columns of this table ref.
-      #
-      # @return the columns of the table, in an unexpanded form (e.g. tbl.*)
-      def columns
-        ["#{@base}.*"]
-      end
-
-      # Compare too table ref objects.
-      #
-      # param obj [TableRef] the other tableref used for comparison.
-      def ==(obj)
-        self.base == obj.base && self.pointer == obj.pointer
-      end
-
-    end
-
-    # This class is used to model a reference within a SQL statement, given as an
-    # expression (e.g. "select * from (select * from dual);")
-    class ExprRef
-
-      attr_reader :base, :range, :pointer
-
-      # Creates a new ExprRef object.
-      #
-      # @param base [String] the actual expresion
-      # @param range [Range] the bounderies of this expression within the parent statement
-      # @param pointer [String] the alias of the expresion, if there is any
-      def initialize(base, range, pointer = nil)
-        @base = base
-        @range = range
-        @pointer = pointer
-      end
-
-      # Get all columns for this expression.
-      #
-      # @return all columns of the query expression
-      def columns
-        collect = []
-        recursive_columns(@base, collect)
-      end
-      
-      # Compare too table ref objects.
-      #
-      # param obj [TableRef] the other tableref used for comparison.
-      def ==(obj)
-        self.base == obj.base && self.range == obj.range && self.pointer == obj.pointer
-      end
-
-      private
-
-      def recursive_columns(statement, collect)
-        inspector = StmtInspector.new(statement)
-        columns_data = inspector.query_fields
-        columns_data.each do |column|
-          if column =~ /([a-z0-9#$\_]+\.)?\*/i
-            #might be an alias
-            alias_name = column[/[a-z0-9#$\_]+/i]
-            ds = []
-            if alias_name
-              src = inspector.data_source.find do |r| 
-                (r.pointer && r.pointer.upcase == alias_name.upcase) || (r.base.upcase == alias_name.upcase)
-              end
-              ds << src if src
-            elsif column == '*'
-              ds = inspector.data_source
-            end
-            if ds.size > 0
-              ds.each do |source|
-                if source.respond_to?(:range)
-                  recursive_columns(source.base, collect)
-                else
-                  collect << "#{source.base}.*"
-                end
-              end
-            end
-          else
-            collect << column
-          end
-        end
-        return collect
-      end
-
-    end
-
-  end
-
-end
-

data/lib/vorax/sqlplus.rb

@@ -1,273 +0,0 @@
-# encoding: UTF-8
-
-module Vorax
-
-  # Provides integration with Oracle SqlPlus CLI tool.
-  class Sqlplus
-
-    attr_reader :bin_file, :default_funnel_name, :process
-    
-    # Creates a new sqlplus instance.
-    #
-    # @param bin_file [String] the path to the SqlPlus executable. By
-    #   default is "sqlplus", which requires that the executable to be
-    #   in $PATH.
-    def initialize(bin_file = "sqlplus")
-      @bin_file = bin_file
-      @busy = false
-      @start_marker, @end_marker, @cancel_marker = [2.chr, 3.chr, 4.chr]
-      @process = ChildProcess.build(@bin_file, "/nolog")
-      # On Unix we may abort the currently executing query by sending a
-      # INT signal to the Sqlplus process, but we need access to the 
-      # send_term private method.
-      class << @process; public :send_signal; end if ChildProcess.unix?
-      @process.duplex = true
-      @process.detach = true
-      @process.io.inherit!
-      @io_read, @io_write = VoraxIO.pipe
-      @process.io.stdout = @io_write
-      @process.start
-      @process.io.stdin.sync = true
-      @current_funnel = nil
-      @default_convertor_name = nil
-      @registered_convertors = {:vertical => Output::VerticalConvertor,
-                                :pagezip => Output::PagezipConvertor,
-                                :tablezip => Output::TablezipConvertor}
-      # warm up
-      sleep 0.2
-			# set the blockterm as the end_marker. The blockterm should
-			# not be touch by the Vorax user, otherwise nasty things
-			# may happen. This is also a workaround to mark the end of
-			# output when the "echo" setting of sqlplus is "on". See the
-			# implementation of pack().
-      send_text("set blockterm \"#@end_marker\"\n")
-    end
-
-    # Set the default convertor for the output returned by sqlplus.
-    #
-    # @param convertor_name [Symbol] the default funnel name. The
-    #   valid values are: :vertical, :pagezip and :tablezip
-    def default_convertor=(convertor_name)
-      Vorax.debug("default_convertor=#{convertor_name.inspect}")
-      @default_convertor_name = convertor_name
-    end
-
-    # Register a new convertor for the sqlplus output.
-    # 
-    # @param convertor_name [Symbol] the name of the convertor (key)
-    # @param convertor_class [Class] the class which implements the
-    #   convertor. It must be a subclass of BaseConvertor.
-    def register_convertor(convertor_name, convertor_class)
-      @registered_convertors[convertor_name] = convertor_class
-    end
-
-    # Execute an sqlplus command.
-    #
-    # @param command [String] the command to be executed.
-    # @param params [Hash] additional parameters. You may use
-    #   the following options:
-    #     :prep => a string with commands to be executed just before
-    #              running the provided command. For example, you may
-    #              choose to set some sqlplus options.
-    #     :post => a string with commands to be executed after the
-    #              provided command was run. Here it's a good place
-    #              to put commands that restores some options affected
-    #              by the executed command.
-    #     :convertor => the convertor used to convert the output received
-    #                from Sqlplus. By default it's the convertor set with
-    #                "default_convertor=" method.
-    #     :pack_file => the file name into which the command(s) to be
-    #                   executed are wrapped into and then sent for
-    #                   execution to sqlplus using '@<file_name>'. 
-    #                   Providing this option may prove to be a good
-    #                   thing for big commands. If this parameter is
-    #                   not provided then the command is sent directly
-    #                   to the input IO of the sqlplus process.
-    def exec(command, params = {})
-      Vorax.debug("exec: command=#{command.inspect} params=#{params.inspect}")
-      raise AnotherExecRunning if busy?
-      opts = {
-        :prep => nil,
-        :post => nil,
-        :convertor => @default_convertor_name,
-        :pack_file => nil,
-      }.merge(params)
-      @busy = true
-      @look_for = @start_marker
-      prepare_funnel(opts[:convertor])
-      if @current_funnel && @current_funnel.is_a?(Output::HTMLFunnel)
-        # all HTML funnels expects html format
-        send_text("set markup html on\n")
-      else
-        send_text("set markup html off\n")
-      end
-      if opts[:pack_file]
-        send_text("@#{pack(command, opts)}\n")
-      else
-        send_text("#{opts[:prep]}\n") if opts[:prep]
-        capture { send_text("#{command}\n") }
-        send_text("#{opts[:post]}\n") if opts[:post]
-      end
-    end
-
-    # Send a text directly to the stdin of the sqlplus process.
-    #
-    # @param text [String] the text to be sent to sqlplus
-    def send_text(text)
-      @process.io.stdin.print(text)
-    end
-
-    # Check if the sqlplus process is busy executing something.
-    #
-    # @return true if the sqlplus is busy executing something, 
-    #   false otherwise
-    def busy?
-      @busy
-    end
-
-    # Check if the output of a previous executed sqlpus command
-    # was completely fetched out.
-    #
-    # @return true if the whole output was fetched, false otherwise
-    def eof?
-      not busy?
-    end
-
-    # Read the output spit by sqlplus process. If there is any default
-    # convertor, the returned output will be formatted according to
-    # that convertor.
-    #
-    # @param bytes [int] the maximum output chunk size
-    # @return the output chunk
-    def read_output(bytes=4086)
-      output = ""
-      raw_output = nil
-      begin
-        raw_output = @io_read.read_nonblock(bytes)
-      rescue Errno::EAGAIN
-      end
-      if raw_output
-        raw_output.gsub!(/\r/, '')
-        scanner = StringScanner.new(raw_output)
-        while not scanner.eos?
-          if @look_for == @start_marker
-            if text = scanner.scan_until(/#{@look_for}/)
-              if text !~ /pro #{@look_for}/
-                # Only if it's not part of a PROMPT sqlplus command.
-                # This might happen when the "echo" sqlplus option
-                # is ON and the begin marker is included into the
-                # sql pack file. Because we are using big chunks to
-                # read data it's very unlikely that the echoing of the
-                # prompt command to be split in the middle.
-                @look_for = @end_marker
-              end
-            else
-              scanner.terminate
-            end
-          end
-          if @look_for == @end_marker
-            output = scanner.scan(/[^#{@look_for}]*/)
-            if scanner.scan(/#{@look_for}/)
-              # end of output reached
-              scanner.terminate
-              @busy = false
-            end
-          end
-        end
-      end
-      chunk = output.force_encoding('UTF-8')
-      if @current_funnel && !chunk.empty?
-        # nokogiri may be confused about those unclosed <p> tags
-        # sqlplus emits, so it's better to get rid of them and use
-        # <br> instead. 
-        @current_funnel.write(br_only(chunk))
-        chunk = @current_funnel.read
-      end
-      return chunk
-    end
-
-    # Cancel the currently executing statement. This is supported on Unix
-    # only. On Windows there's no way to send a CTRL+C signal to Sqlplus
-    # without aborting the process. There's an old enhancement request on 
-    # Oracle support: 
-    #
-    # Bug 8890996: ENH: CONTROL-C SHOULD NOT EXIT WINDOWS CONSOLE SQLPLUS
-    #
-    # So, as soon as we have some fixes from the Oracle guys I will come
-    # back to this method.
-    def cancel
-      raise PlatformNotSupported if ChildProcess.windows?
-      if busy?
-        @process.send_signal 'INT'
-        mark_cancel
-        # read until the cancel marker
-        raw_output = ""
-        until raw_output =~ /#{@cancel_marker}/
-          begin
-            raw_output = @io_read.read_nonblock(1024)
-            yield if block_given?
-          rescue Errno::EAGAIN
-            sleep 0.1
-          end
-        end
-        @busy = false
-      end
-    end
-
-    # Kill the sqlplus process.
-    def terminate
-      @process.stop
-    end
-
-    private
-
-    def br_only(chunk)
-      # be prepared for chunks with <p> tag broken in the middle
-      chunk.gsub(/<p>/, "<br>").gsub(/<p\z/, "<br").gsub(/\Ap>/, "br>")
-    end
-
-    def prepare_funnel(convertor_name)
-      convertor = @registered_convertors[convertor_name]
-      if convertor
-        @current_funnel = Output::HTMLFunnel.new(convertor.new)
-      else
-        @current_funnel = nil
-      end
-    end
-
-    def capture
-      @process.io.stdin.puts("#pro #{@start_marker}")
-      yield
-      @process.io.stdin.puts("#pro #{@end_marker}")
-      @process.io.stdin.puts(".")
-    end
-
-    def mark_cancel
-      @process.io.stdin.puts
-      @process.io.stdin.puts("pro #{@cancel_marker}")
-    end
-
-    def pack(command, opts)
-      pack_file = opts[:pack_file]
-      if pack_file
-        File.open(pack_file, 'w') do |f|
-          f.puts opts[:prep]
-          f.puts "#pro #@start_marker"
-          f.puts command.strip
-					# we assume that the @end_marker is also
-					# set as a block terminator. If "set echo on"
-					# the output region will end here since the
-					# block terminator command will be echoed. Otherwise,
-					# the next prompt statement will do the job.
-					f.puts "#{@end_marker}"
-          f.puts "#pro #@end_marker"
-          f.puts opts[:post]
-        end
-      end
-      pack_file
-    end
-
-
-  end
-
-end