piggly 1.2.1 → 2.0.0

data/lib/piggly/dumper/skeleton_procedure.rb

@@ -0,0 +1,102 @@
+module Piggly
+  module Dumper
+
+    #
+    # Encapsulates all the information about a stored procedure, except the
+    # procedure's source code, which is assumed to be on disk, loaded as needed.
+    #
+    class SkeletonProcedure
+
+      attr_reader :oid, :name, :type, :arg_types, :arg_modes, :arg_names,
+        :strict, :type, :setof, :volatility, :secdef, :identifier
+
+      def initialize(oid, name, strict, secdef, setof, type, volatility, arg_modes, arg_names, arg_types, arg_defaults)
+        @oid, @name, @strict, @secdef, @type, @volatility, @setof, @arg_modes, @arg_names, @arg_types, @arg_defaults =
+          oid, name, strict, secdef, type, volatility, setof, arg_modes, arg_names, arg_types, arg_defaults
+
+        @identifier = Digest::MD5.hexdigest(signature)
+      end
+
+      # Returns source text for argument list
+      # @return [String]
+      def arguments
+        @arg_types.zip(@arg_names, @arg_modes, @arg_defaults).map do |type, name, mode, default|
+          "#{mode + " " if mode}#{name.quote + " " if name}#{type.quote}#{" DEFAULT " + default if default}"
+        end.join(", ")
+      end
+
+      # Returns source text for return type
+      # @return [String]
+      def setof
+        @setof ? "setof " : ""
+      end
+
+      # Returns source text for strictness
+      # @return [String]
+      def strictness
+        @strict ? "strict" : ""
+      end
+
+      # Returns source text for security
+      # @return [String]
+      def security
+        @secdef ? "security definer" : ""
+      end
+
+      # Returns source SQL function definition statement
+      # @return [String]
+      def definition(body)
+        [%[create or replace function #{name.quote} (#{arguments})],
+         %[ returns #{setof}#{type.quote} as $__PIGGLY__$],
+         body,
+         %[$__PIGGLY__$ language plpgsql #{strictness} #{security} #{@volatility}]].join("\n")
+      end
+
+      # @return [String]
+      def signature
+        "#{@name}(#{@arg_modes.zip(@arg_types).map{|m,t| "#{m} #{t}" }.join(", ")})"
+      end
+
+      # @return [String]
+      def source_path(config)
+        config.mkpath("#{config.cache_root}/Dumper", "#{@identifier}.plpgsql")
+      end
+
+      # @return [String]
+      def load_source(config)
+        File.read(source_path(config))
+      end
+
+      # @return [String]
+      alias source load_source
+
+      # @return [void]
+      def purge_source(config)
+        path = source_path(config)
+
+        FileUtils.rm_r(path) if File.exists?(path)
+
+        file = Compiler::TraceCompiler.new(config).cache_path(path)
+        FileUtils.rm_r(file) if File.exists?(file)
+
+        file = Reporter::Base.new(config).report_path(path, ".html")
+        FileUtils.rm_r(file) if File.exists?(file)
+      end
+
+      # @return [SkeletonProcedure]
+      def skeleton
+        self
+      end
+
+      def skeleton?
+        true
+      end
+
+      def ==(other)
+        other.is_a?(self.class) and 
+          other.identifier == identifier
+      end
+    end
+
+  end
+end

data/lib/piggly/installer.rb

@@ -1,95 +1,137 @@
 module Piggly
+
   class Installer
+    def initialize(config, connection)
+      @config, @connection = config, connection
+    end
+
+    # @return [void]
+    def install(procedures, profile)
+      @connection.exec("begin")
+
+      install_support(profile)
 
-    # Compiles the procedures in +file+ with instrumentation and installs them
-    def self.trace_proc(file)
-      # recompile with instrumentation if needed
-      cache = Piggly::TraceCompiler.cache(file)
+      procedures.each do |p|
+        begin
+          trace(p, profile)
+        rescue Parser::Failure
+          $stdout.puts $!
+        end
+      end
 
-      # install instrumented code
-      connection.exec cache['code.sql']
+      @connection.exec("commit")
+    rescue
+      @connection.exec("rollback")
+      raise
+    end
+
+    # @return [void]
+    def uninstall(procedures)
+      @connection.exec("begin")
 
-      # map tag messages to tag objects
-      Profile.add(file, cache['tags'], cache)
+      procedures.each{|p| untrace(p) }
+      uninstall_support
+
+      @connection.exec("commit")
+    rescue
+      @connection.exec("rollback")
+      raise
     end
 
-    # Reinstalls the original stored procedures in +file+
-    def self.untrace_proc(file)
-      connection.exec File.read(file)
+    # @return [void]
+    def trace(procedure, profile)
+      # recompile with instrumentation
+      compiler = Compiler::TraceCompiler.new(@config)
+      result   = compiler.compile(procedure)
+        # result[:tree] - tagged and rewritten parse tree
+        # result[:tags] - collection of Tag values in the tree
+        # result[:code] - instrumented
+
+      @connection.exec(procedure.definition(result[:code]))
+      
+      profile.add(procedure, result[:tags], result)
+    rescue
+      $!.message << "\nError installing traced procedure #{procedure.name} "
+      $!.message << "from #{procedure.source_path(@config)}"
+      raise
+    end
+
+    # @return [void]
+    def untrace(procedure)
+      @connection.exec(procedure.definition(procedure.source(@config)))
     end
 
     # Installs necessary instrumentation support
-    def self.install_trace
-      # record trace messages
-      connection.set_notice_processor(&Profile.notice_processor)
+    def install_support(profile)
+      @connection.set_notice_processor(&profile.notice_processor(@config))
+
+    # def connection.set_notice_processor
+    #   # do nothing: prevent the notice processor from being subverted
+    # end
 
       # install tracing functions
-      connection.exec <<-SQL
-        -- signals that a conditional expression was executed
+      @connection.exec <<-SQL
+        -- Signals that a conditional expression was executed
         CREATE OR REPLACE FUNCTION piggly_cond(message varchar, value boolean)
           RETURNS boolean AS $$
         BEGIN
           IF value THEN
-            RAISE WARNING '#{Config.trace_prefix} % t', message;
+            RAISE WARNING '#{@config.trace_prefix} % t', message;
           ELSE
-            RAISE WARNING '#{Config.trace_prefix} % f', message;
+            RAISE WARNING '#{@config.trace_prefix} % f', message;
           END IF;
           RETURN value;
         END $$ LANGUAGE 'plpgsql' VOLATILE;
       SQL
 
-      connection.exec <<-SQL
-        -- generic signal
+      @connection.exec <<-SQL
+        -- Generic signal
         CREATE OR REPLACE FUNCTION piggly_signal(message varchar, signal varchar)
           RETURNS void AS $$
         BEGIN
-          RAISE WARNING '#{Config.trace_prefix} % %', message, signal;
+          RAISE WARNING '#{@config.trace_prefix} % %', message, signal;
         END $$ LANGUAGE 'plpgsql' VOLATILE;
       SQL
 
-      connection.exec <<-SQL
-        -- signals that a (sub)expression was executed. handles '' and NULL value
+      @connection.exec <<-SQL
+        -- Signals that a (sub)expression was executed. handles '' and NULL value
         CREATE OR REPLACE FUNCTION piggly_expr(message varchar, value varchar)
           RETURNS varchar AS $$
         BEGIN
-          RAISE WARNING '#{Config.trace_prefix} %', message;
+          RAISE WARNING '#{@config.trace_prefix} %', message;
           RETURN value;
         END $$ LANGUAGE 'plpgsql' VOLATILE;
       SQL
 
-      connection.exec <<-SQL
-        -- signals that a (sub)expression was executed. handles all other types
+      @connection.exec <<-SQL
+        -- Signals that a (sub)expression was executed. handles all other types
         CREATE OR REPLACE FUNCTION piggly_expr(message varchar, value anyelement)
           RETURNS anyelement AS $$
         BEGIN
-          RAISE WARNING '#{Config.trace_prefix} %', message;
+          RAISE WARNING '#{@config.trace_prefix} %', message;
           RETURN value;
         END $$ LANGUAGE 'plpgsql' VOLATILE;
       SQL
 
-      connection.exec <<-SQL
-        -- signals that a branch was taken
+      @connection.exec <<-SQL
+        -- Signals that a branch was taken
         CREATE OR REPLACE FUNCTION piggly_branch(message varchar)
           RETURNS void AS $$
         BEGIN
-          RAISE WARNING '#{Config.trace_prefix} %', message;
+          RAISE WARNING '#{@config.trace_prefix} %', message;
         END $$ LANGUAGE 'plpgsql' VOLATILE;
       SQL
     end
 
     # Uninstalls instrumentation support
-    def self.uninstall_trace
-      connection.set_notice_processor
-      connection.exec "DROP FUNCTION IF EXISTS piggly_cond(varchar, boolean);"
-      connection.exec "DROP FUNCTION IF EXISTS piggly_expr(varchar, varchar);"
-      connection.exec "DROP FUNCTION IF EXISTS piggly_expr(varchar, anyelement);"
-      connection.exec "DROP FUNCTION IF EXISTS piggly_branch(varchar);"
+    def uninstall_support
+      @connection.set_notice_processor{|x| $stderr.puts x }
+      @connection.exec "DROP FUNCTION IF EXISTS piggly_cond(varchar, boolean)"
+      @connection.exec "DROP FUNCTION IF EXISTS piggly_expr(varchar, varchar)"
+      @connection.exec "DROP FUNCTION IF EXISTS piggly_expr(varchar, anyelement)"
+      @connection.exec "DROP FUNCTION IF EXISTS piggly_branch(varchar)"
+      @connection.exec "DROP FUNCTION IF EXISTS piggly_signal(varchar, varchar)"
     end
-
-    # Returns the active PGConn
-    def self.connection
-      ActiveRecord::Base.connection.raw_connection
-    end
-
   end
+
 end

data/lib/piggly/parser.rb

@@ -3,64 +3,58 @@ module Piggly
   #
   # Pl/pgSQL Parser, returns a tree of NodeClass values (see nodes.rb)
   #
-  class Parser
-    include FileCache
+  module Parser
 
-    class Failure < RuntimeError; end
-
-    # Returns parse tree
-    def self.parse(string)
-      p = parser
-
-      begin
-        # downcase input for case-insensitive parsing,
-        # then restore original string after parsing
-        input = string.downcase
-        tree = p.parse(input)
-        tree or raise Failure, "#{p.failure_reason}"
-      rescue Failure
-        $!.backtrace.clear
-        raise
-      ensure
-        input.replace string
-      end
-    end
-
-    def self.parser_path;  File.join(File.dirname(__FILE__), 'parser', 'parser.rb')  end
-    def self.grammar_path; File.join(File.dirname(__FILE__), 'parser', 'grammar.tt') end
-    def self.nodes_path;   File.join(File.dirname(__FILE__), 'parser', 'nodes.rb')   end
+    autoload :Nodes,      "piggly/parser/nodes"
+    autoload :Traversal,  "piggly/parser/traversal"
 
-    def self.stale?(source)
-      File.stale?(cache_path(source), source, grammar_path, parser_path, nodes_path)
-    end
-
-    def self.cache(source)
-      cache = cache_path(source)
+    class Failure < RuntimeError; end
 
-      if stale?(source)
-        tree = parse(File.read(source))
-        File.open(cache, 'w+') do |f|
-          Marshal.dump(tree, f)
-          tree
+    class << self
+      # Returns lazy parse tree (only parsed when the value is needed)
+      def parse(string)
+        Util::Thunk.new do
+          p = parser
+
+          begin
+            # Downcase input for case-insensitive parsing
+            input = string.downcase
+            tree = p.parse(input)
+            tree or raise Failure, "#{p.failure_reason}"
+          ensure
+            # Restore the original string after parsing
+            input.replace(string)
+          end
         end
-      else
-        _ = parser # ensure parser libraries, like nodes.rb, are loaded
-        Marshal.load(File.read(cache))
       end
-    end
 
-    # Returns treetop parser (recompiled as needed)
-    def self.parser
-      require 'treetop'
-      require 'piggly/parser/treetop_ruby19_patch'
-      require nodes_path
+      def parser_path;  "#{File.dirname(__FILE__)}/parser/parser.rb"  end
+      def grammar_path; "#{File.dirname(__FILE__)}/parser/grammar.tt" end
+      def nodes_path;   "#{File.dirname(__FILE__)}/parser/nodes.rb"   end
+
+      # Returns treetop parser (recompiled as needed)
+      def parser
+        load_support
+
+        # @todo: Compare with the version of treetop
+        if Util::File.stale?(parser_path, grammar_path)
+          # Regenerate the parser when the grammar is updated
+          Treetop::Compiler::GrammarCompiler.new.compile(grammar_path, parser_path)
+          load parser_path
+        else
+          require parser_path
+        end
 
-      if File.stale?(parser_path, grammar_path)
-        Treetop::Compiler::GrammarCompiler.new.compile(grammar_path, parser_path)
+        ::PigglyParser.new
       end
+    
+    private
 
-      require parser_path
-      ::PigglyParser.new
+      def load_support
+        require "treetop"
+        require "piggly/parser/treetop_ruby19_patch"
+        require "piggly/parser/nodes"
+      end
     end
 
   end

data/lib/piggly/parser/grammar.tt

@@ -1,44 +1,31 @@
 grammar Piggly
-  # include Keywords
-  # include Expressions
-  # include Statements
-  # include Tokens
 
   rule start
-    procedure+
-  end
-  
-  # elements[20] is procedure body
-  rule procedure
-    procedureHeader
-    name:tIdentifier tSpace?
-    parameters:parameterList tSpace
-    procedureReturn
-    return:tType tSpace kwAS tSpace
-    procedureBody
-    procedureFooter <Procedure>
-  end
-
-  rule procedureHeader
-    tSpace? 'create' tSpace 'or' tSpace 'replace' tSpace 'function' tSpace <TextNode>
-  end
-
-  rule procedureReturn
-    'returns' tSpace ( 'setof' tSpace )? <TextNode>
-  end
-
-  rule procedureBody
-    dollarQuoteMarker tSpace? body:block ';'? tSpace? dollarQuoteMarker 
-    / "'"             tSpace? body:block ';'? tSpace? "'"
+    tSpace?
+    block ';'?
+    tSpace?
   end
 
-  rule procedureFooter
-    expressionUntilSemiColon ';' tSpace?  <TextNode>
-  end
-  
-  rule parameterList
-    '(' ( tSpace? name:tIdentifier tSpace type:tType tSpace? ',' )*
-        ( tSpace? name:tIdentifier tSpace type:tType )? tSpace? ')'
+  rule block
+    label_open:tLabelDefinition tSpace
+    blockDeclarations:stmtDeclare*
+    kwBEGIN
+      bodySpace:tSpace
+      bodyStub:stubNode
+      body:statement*
+    blockExceptions?
+    kwEND
+      ( tSpace label_close:tLabel )?
+      tSpace? <Piggly::Parser::Nodes::Block>
+    /
+    blockDeclarations:stmtDeclare*
+    kwBEGIN
+      bodySpace:tSpace
+      bodyStub:stubNode
+      body:statement*
+    blockExceptions?
+    kwEND
+      tSpace? <Piggly::Parser::Nodes::Block>
   end
 
   rule statement
@@ -49,60 +36,37 @@ grammar Piggly
           / stmtLoop
           / stmtWhileLoop
           / stmtForLoop
+          / stmtForEachLoop
           / stmtExit
           / stmtContinue
           / stmtReturn
           / stmtRaise
           / stmtExecSql
           / stmtNull
-          / stmtPerform
-          / stmtDynamicExecute
-          / stmtGetDiag
-          / stmtOpen
-          / stmtFetch
-          / stmtMove
-          / stmtClose ) tail:tSpace? <Statement>
-  end
-  
-  rule block
-    label_open:tLabel tSpace
-    blockDeclarations:stmtDeclare*
-    kwBEGIN
-      bodySpace:tSpace
-      bodyStub:stubNode
-      body:statement*
-    blockExceptions?
-    kwEND
-    ( tSpace label_close:tLabel )?
-    tSpace? <Block>
-    / 
-    blockDeclarations:stmtDeclare*
-    kwBEGIN
-      bodySpace:tSpace
-      bodyStub:stubNode
-      body:statement*
-    blockExceptions?
-    kwEND
-    tSpace? <Block>
+          / stmtGetDiag )
+    tail:tSpace? <Piggly::Parser::Nodes::Statement>
   end
 
   rule stmtAssignment
-    lval:lValue tSpace? kwASSIGN ws? rval:expressionUntilSemiColon ';' <Assignment>
+    lval:lValue tSpace? kwASSIGN ws?
+    rval:expressionUntilSemiColon ';' <Piggly::Parser::Nodes::Assignment>
   end
 
   rule stmtCase
-    kwCASE tSpace 
+    kwCASE tSpace
     cases:condWhen+
     else:stmtElse?
-    kwEND tSpace kwCASE tSpace? ';' <Cond>
+    kwEND tSpace kwCASE
+      tSpace? ';' <Piggly::Parser::Nodes::Cond>
     /
     kwCASE tSpace
     expr:expressionUntilWhen
     cases:caseWhen+
     else:stmtElse?
-    kwEND tSpace kwCASE tSpace? ';' <Case>
+    kwEND tSpace kwCASE
+      tSpace? ';' <Piggly::Parser::Nodes::Case>
   end
-  
+
   rule stmtIf
     kwIF
       condSpace:tSpace?
@@ -113,9 +77,9 @@ grammar Piggly
       bodyStub:stubNode
       body:statement*
       else:stmtElse?
-    kwEND tSpace kwIF tSpace? ';' <If>
+    kwEND tSpace kwIF tSpace? ';' <Piggly::Parser::Nodes::If>
   end
-  
+
   rule stmtElse
     kwELSIF
       condSpace:tSpace?
@@ -125,34 +89,36 @@ grammar Piggly
       bodySpace:tSpace
       bodyStub:stubNode
       body:statement*
-      else:stmtElse? <If>
+      else:stmtElse? <Piggly::Parser::Nodes::If>
     /
     kwELSE
       bodySpace:tSpace
       bodyStub:stubNode
-      body:statement* <Else>
+      body:statement* <Piggly::Parser::Nodes::Else>
   end
-  
+
   rule stmtLoop
-    label_open:tLabel tSpace
+    label_open:tLabelDefinition tSpace
     cond:kwLOOP
       bodySpace:tSpace
       bodyStub:stubNode
       body:statement*
+      doneStub:stubNode
     kwEND tSpace kwLOOP
-    ( tSpace label_close:tIdentifier )?
-    tSpace? ';' exitStub:stubNode <Loop>
+      ( tSpace label_close:tLabel <Piggly::Parser::Nodes::TLabel> )?
+      tSpace? ';' exitStub:stubNode <Piggly::Parser::Nodes::Loop>
     /
     cond:kwLOOP
       bodySpace:tSpace
       bodyStub:stubNode
       body:statement*
+      doneStub:stubNode
     kwEND tSpace kwLOOP
-    tSpace? ';' exitStub:stubNode <Loop>
+      tSpace? ';' exitStub:stubNode <Piggly::Parser::Nodes::Loop>
   end
-  
+
   rule stmtWhileLoop
-    label_open:tLabel tSpace
+    label_open:tLabelDefinition tSpace
     kwWHILE
       condSpace:tSpace?
       condStub:stubNode
@@ -162,8 +128,8 @@ grammar Piggly
       bodyStub:stubNode
       body:statement*
     kwEND tSpace kwLOOP
-    ( tSpace label_close:tIdentifier )?
-    tSpace? ';' <WhileLoop>
+      ( tSpace label_close:tLabel <Piggly::Parser::Nodes::TLabel> )?
+      tSpace? ';' <Piggly::Parser::Nodes::WhileLoop>
     /
     kwWHILE
       condSpace:tSpace?
@@ -174,12 +140,39 @@ grammar Piggly
       bodyStub:stubNode
       body:statement*
     kwEND tSpace kwLOOP
-    tSpace? ';' <WhileLoop>
+      tSpace? ';' <Piggly::Parser::Nodes::WhileLoop>
+  end
+
+  rule stmtForEachLoop
+    label_open:tLabelDefinition tSpace
+    kwFOREACH tSpace tIdentifier tSpace
+    kwIN tSpace kwARRAY
+      condSpace:tSpace
+      cond:expressionUntilLoop
+    kwLOOP
+      bodySpace:tSpace
+      bodyStub:stubNode
+      body:statement*
+      doneStub:stubNode
+    kwEND tSpace kwLOOP
+      ( tSpace label_close:tLabel <Piggly::Parser::Nodes::TLabel> )?
+      tSpace? ';' exitStub:stubNode <Piggly::Parser::Nodes::ForEachLoop>
+    /
+    kwFOREACH tSpace tIdentifier tSpace
+    kwIN tSpace kwARRAY
+      condSpace:tSpace
+      cond:expressionUntilLoop
+    kwLOOP
+      bodySpace:tSpace
+      bodyStub:stubNode
+      body:statement*
+      doneStub:stubNode
+    kwEND tSpace kwLOOP
+      tSpace? ';' exitStub:stubNode <Piggly::Parser::Nodes::ForEachLoop>
   end
-  
-  # loop coverage calculated by using exitStub
+
   rule stmtForLoop
-    label_open:tLabel tSpace
+    label_open:tLabelDefinition tSpace
     kwFOR tSpace identifierList tSpace
     kwIN
       condSpace:tSpace
@@ -190,9 +183,8 @@ grammar Piggly
       body:statement*
       doneStub:stubNode
     kwEND tSpace kwLOOP
-    ( tSpace label_close:tIdentifier )?
-    tSpace? ';'
-    exitStub:stubNode <ForLoop>
+      ( tSpace label_close:tLabel <Piggly::Parser::Nodes::TLabel> )?
+      tSpace? ';' exitStub:stubNode <Piggly::Parser::Nodes::ForLoop>
     /
     kwFOR tSpace identifierList tSpace
     kwIN
@@ -203,36 +195,40 @@ grammar Piggly
       bodyStub:stubNode
       body:statement*
       doneStub:stubNode
-    kwEND tSpace kwLOOP tSpace? ';'
-    exitStub:stubNode <ForLoop>
+    kwEND tSpace kwLOOP
+      tSpace? ';' exitStub:stubNode <Piggly::Parser::Nodes::ForLoop>
   end
-  
+
   rule stmtForSql
-    sqlKeyword tSpace expressionUntilLoop <Sql>
+    sqlKeyword tSpace expressionUntilLoop <Piggly::Parser::Nodes::Sql>
   end
-  
+
   rule stmtExit
     bodyStub:stubNode
-    body:( kwEXIT (tSpace label:tIdentifier)? ) tSpace? ';' <Exit>
+    body:( kwEXIT (tSpace label:tLabel <Piggly::Parser::Nodes::TLabel> )? )
+    tSpace? ';' <Piggly::Parser::Nodes::Exit>
     /
-    body:( kwEXIT (tSpace label:tIdentifier)? ) tSpace
+    body:( kwEXIT (tSpace label:tLabel <Piggly::Parser::Nodes::TLabel> )? )
+    tSpace
     kwWHEN
       condSpace:tSpace
       condStub:stubNode
-      cond:expressionUntilSemiColon ';' <ExitWhen>
+      cond:expressionUntilSemiColon ';' <Piggly::Parser::Nodes::ExitWhen>
   end
 
   rule stmtContinue
     bodyStub:stubNode
-    body:( kwCONTINUE (tSpace label:tIdentifier)? ) tSpace? ';' <Continue>
+    body:( kwCONTINUE (tSpace label:tLabel <Piggly::Parser::Nodes::TLabel> )? )
+      tSpace? ';' <Piggly::Parser::Nodes::Continue>
     /
-    body:( kwCONTINUE (tSpace label:tIdentifier)? ) tSpace
+    body:( kwCONTINUE (tSpace label:tLabel <Piggly::Parser::Nodes::TLabel> )? )
+      tSpace
     kwWHEN
       condSpace:tSpace
       condStub:stubNode
-      cond:expressionUntilSemiColon ';' <ContinueWhen>
+      cond:expressionUntilSemiColon ';' <Piggly::Parser::Nodes::ContinueWhen>
   end
-  
+
   rule stmtReturn
     bodyStub:stubNode
     body:(kwRETURN ( tSpace? &';'
@@ -240,10 +236,10 @@ grammar Piggly
                    / tSpace kwQUERY tSpace expressionUntilSemiColon
                    / expressionUntilSemiColon )) ';'
   end
-  
+
   rule stmtRaise
     bodyStub:stubNode
-    body:(kwRAISE tSpace level:kwEXCEPTION tSpace expr:expressionUntilSemiColon) ';' <Throw>
+    body:(kwRAISE tSpace level:kwEXCEPTION tSpace expr:expressionUntilSemiColon) ';' <Piggly::Parser::Nodes::Throw>
     /
     kwRAISE tSpace
     level:( kwWARNING
@@ -252,58 +248,33 @@ grammar Piggly
           / kwLOG
           / kwDEBUG )
     tSpace
-    expr:expressionUntilSemiColon ';' <Raise>
+    expr:expressionUntilSemiColon ';' <Piggly::Parser::Nodes::Raise>
   end
-  
+
   rule stmtExecSql
-    sqlKeyword tSpace expressionUntilSemiColon ';' <Sql>
-  end
-  
-  rule stmtDynamicExecute
-    kwEXECUTE tSpace expressionUntilSemiColon ';'
-  end
-  
-  rule stmtPerform
-    kwPERFORM tSpace expressionUntilSemiColon ';'
-  end
-  
-  rule stmtOpen
-    kwOPEN notImplemented
-  end
-  
-  rule stmtFetch
-    kwFETCH notImplemented
+    sqlKeyword tSpace expressionUntilSemiColon ';' <Piggly::Parser::Nodes::Sql>
   end
-  
-  rule stmtMove
-    kwMOVE notImplemented
-  end
-  
-  rule stmtClose
-    kwCLOSE notImplemented
-  end
-  
+
   rule stmtGetDiag
     kwGET tSpace
     kwPERFORM tSpace
     notImplemented
   end
-  
+
   rule stmtNull
     kwNULL tSpace? ';'
   end
-  
-  ##
+
   #############################################################################
-  
+
   rule stmtDeclare
     kwDECLARE tSpace varDeclaration*
   end
 
   rule varDeclaration
     name:tIdentifier tSpace ( kwCONSTANT tSpace )?
-    type:tType ( tSpace kwNOT tSpace kwNULL )?
-               ( tSpace kwASSIGN tSpace? rval:expressionUntilSemiColon )?
+    type:tType ( tSpace  kwNOT tSpace kwNULL )?
+               ( tSpace? kwASSIGN tSpace? rval:expressionUntilSemiColon )?
     tSpace?
     ';' tSpace?
   end
@@ -315,7 +286,7 @@ grammar Piggly
   rule blockExceptions
     kwEXCEPTION tSpace cases:exceptionCase*
   end
-  
+
   rule exceptionCase
     # cannot provide branch-coverage on cond
     kwWHEN
@@ -324,7 +295,7 @@ grammar Piggly
     kwTHEN
       bodySpace:tSpace
       bodyStub:stubNode
-      body:statement* <Catch>
+      body:statement* <Piggly::Parser::Nodes::Catch>
   end
 
   rule caseWhen
@@ -335,7 +306,7 @@ grammar Piggly
     kwTHEN
       bodySpace:tSpace
       bodyStub:stubNode
-      body:statement* <Case>
+      body:statement* <Piggly::Parser::Nodes::CaseWhen>
   end
 
   rule condWhen
@@ -346,97 +317,103 @@ grammar Piggly
     kwTHEN
       bodySpace:tSpace
       bodyStub:stubNode
-      body:statement* <Cond>
+      body:statement* <Piggly::Parser::Nodes::CondWhen>
   end
-  
+
   ## EXPRESSIONS
   #############################################################################
-  
-  # it would be nice to match parens and brackets here, but we again assume there
-  # are no syntax errors in the proc and let the database worry about them
-  
+
   rule expressionUntilSemiColon
-    head:tSpace? expr:( tString / skipWords / tSpace !';' / !tSpace [^;] )* tail:tSpace? &';' <Expression>
+    head:tSpace? expr:( tString / skipWords / tSpace !';' / !tSpace [^;] )*
+    tail:tSpace? &';' <Piggly::Parser::Nodes::Expression>
   end
-  
+
   rule expressionUntilClosingBracket
-    head:tSpace? expr:( tString / skipWords / tSpace !']' / !tSpace [^\]] )+ tail:tSpace? &']' <Expression>
+    head:tSpace? expr:( tString / skipWords / tSpace !']' / !tSpace [^\]] )+
+    tail:tSpace? &']' <Piggly::Parser::Nodes::Expression>
   end
-  
+
   rule expressionUntilThen
-    head:tSpace? expr:( tString / skipWords / tSpace !kwTHEN / !tSpace !kwTHEN . )+ tail:tSpace &kwTHEN <Expression>
+    head:tSpace? expr:( tString / skipWords / tSpace !kwTHEN / !tSpace !kwTHEN . )+
+    tail:tSpace &kwTHEN <Piggly::Parser::Nodes::Expression>
   end
-  
+
   rule expressionUntilWhen
-    head:tSpace? expr:( tString / skipWords / tSpace !kwWHEN / !tSpace !kwWHEN . )+ tail:tSpace &kwWHEN <Expression>
+    head:tSpace? expr:( tString / skipWords / tSpace !kwWHEN / !tSpace !kwWHEN . )+
+    tail:tSpace &kwWHEN <Piggly::Parser::Nodes::Expression>
   end
-  
+
   rule expressionUntilLoop
-    head:tSpace? expr:( tString / skipWords / tSpace !kwLOOP / !tSpace !kwLOOP . )+ tail:tSpace &kwLOOP <Expression>
+    head:tSpace? expr:( tString / skipWords / tSpace !kwLOOP / !tSpace !kwLOOP . )+
+    tail:tSpace &kwLOOP <Piggly::Parser::Nodes::Expression>
   end
 
   rule skipWords
-    [a-z0-9_]+ <TextNode>
+    [a-z0-9_]+ <Piggly::Parser::Nodes::TextNode>
   end
 
-  ##
   #############################################################################
 
   rule ws
-    [ \t\n\v\f\r]+ <TextNode>
+    [ \t\n\v\f\r]+ <Piggly::Parser::Nodes::TextNode>
   end
-  
+
   rule dollarQuoteMarker
-    '$' tag:( [a-z\200-\377_] [a-z\200-\377_0-9]* )? '$' <TDollarQuoteMarker>
+    '$' tag:( [a-z\200-\377_] [a-z\200-\377_0-9]* )? '$' <Piggly::Parser::Nodes::TDollarQuoteMarker>
   end
-  
+
   rule stubNode
-    '' <StubNode>
+    '' <Piggly::Parser::Nodes::StubNode>
   end
 
   rule notImplemented
-    '' <NotImplemented>
+    '' <Piggly::Parser::Nodes::NotImplemented>
   end
-  
+
   rule lValue
-      tIdentifier sub:('[' expressionUntilClosingBracket ']')+ next:('.' lValue)+ <Assignable>
-    / tIdentifier sub:('[' expressionUntilClosingBracket ']')+ <Assignable>
-    / tIdentifier next:('.' lValue)+ <Assignable>
-    / tIdentifier x:'' <Assignable>
+    tIdentifier
+      ( '[' expressionUntilClosingBracket ']' )*
+      ( [.] lValue )*
+
+    <Piggly::Parser::Nodes::Assignable>
   end
-  
+
   ## BASIC TOKENS
   #############################################################################
 
   rule tEOF
     !.
   end
-  
+
+  rule tLabelDefinition
+    '<<' tSpace? tLabel tSpace? '>>' <Piggly::Parser::Nodes::TLabel>
+  end
+
   rule tLabel
-    '<<' tSpace? name:tIdentifier tSpace? '>>' <TLabel>
+    tIdentifier
   end
-  
+
   rule tIdentifier
-    ( '"' [^"]+ '"' )+ <TIdentifier>
-    / !keyword ( [a-z\200-\377_] [a-z\200-\377_0-9$]* ) <TIdentifier>
+    ( '"' [^"]+ '"' )+ <Piggly::Parser::Nodes::TIdentifier>
+    / !keyword ( [a-z\200-\377_] [a-z\200-\377_0-9$]* ) <Piggly::Parser::Nodes::TIdentifier>
   end
 
   # not context sensitive so opening and closing tag might not match
   rule tString
-    openTag:dollarQuoteMarker content:(!dollarQuoteMarker .)* closeTag:dollarQuoteMarker <TString> /
-    "E'" content:("''" / [^'])* "'" <TString> /
-    "'"  content:("''" / [^'])* "'" <TString>
+    openTag:dollarQuoteMarker content:(!dollarQuoteMarker .)* closeTag:dollarQuoteMarker <Piggly::Parser::Nodes::TString> /
+    "E'" content:("''" / [^'])* "'" <Piggly::Parser::Nodes::TString> /
+    "'"  content:("''" / [^'])* "'" <Piggly::Parser::Nodes::TString>
   end
-  
+
   # beware this is quite broad and might match things it shouldn't
   rule tType
     [a-z\200-\377_]
     ( '(' rType ')' /
       '[' rType ']' /
-      [a-z\200-\377_0-9$%]+ /
-      ws !( kwAS / kwNOT / kwASSIGN / kwDEFAULT ) )* <TDatatype>
+      [a-z\200-\377_0-9$%]+ '.'? /
+      ws !( kwAS / kwNOT / kwASSIGN / kwDEFAULT ) )* <Piggly::Parser::Nodes::TDatatype>
   end
-  
+
   rule rType
     ( '(' rType ')' /
       '[' rType ']' /
@@ -444,14 +421,14 @@ grammar Piggly
   end
 
   rule tSpace
-    ws !tComment <TextNode>
+    ws !tComment <Piggly::Parser::Nodes::TextNode>
     /
     ( ws / tComment )+
   end
-  
+
   rule tComment
-    '/*' content:(!'*/' .)* '*/' <TComment> /
-    '--' content:[^\n]* ("\n" / tEOF) <TComment>
+    '/*' content:(!'*/' .)* '*/' <Piggly::Parser::Nodes::TComment> /
+    '--' content:[^\n]* ("\n" / tEOF) <Piggly::Parser::Nodes::TComment>
   end
 
   ##
@@ -480,27 +457,34 @@ grammar Piggly
     'cast' tSpace? '(' tSpace? tString tSpace kwAS tSpace tType tSpace? ')' /
     'cast' tSpace? '(' tSpace? tNumber tSpace kwAS tSpace tType tSpace? ')'
   end
-  
+
   ## KEYWORDS
   #############################################################################
-  
+
   rule sqlKeyword
     ( 'insert'
     / 'select'
     / 'update'
     / 'delete'
+    / 'perform'
+    / 'execute'
+    / 'open'
+    / 'close'
+    / 'lock'
+    / 'fetch'
+    / 'move'
+    / 'truncate'
+    / 'create'
     / 'drop'
     / 'alter'
     / 'commit'
     / 'copy'
     / 'create'
-    / 'begin'
-    / 'rollback'
     / 'set'
     / 'start'
-    / 'vacuum' ) ![a-z0-9] <TextNode>
+    / 'notify' ) ![a-z0-9] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule keyword
     # WHEN is checked first as a minor optimization to distinguish
     #   CONTINUE tIdentifier WHEN cond;
@@ -509,239 +493,231 @@ grammar Piggly
     #   CONTINUE WHEN cond;
     #   EXIT WHEN cond;
 
-    kwWHEN / kwAS / kwASSIGN / kwALIAS / kwBEGIN / kwBY / kwCASE / kwCLOSE
+    kwWHEN / kwAS / kwASSIGN / kwALIAS / kwBEGIN / kwBY / kwCASE / kwARRAY
     / kwCONSTANT / kwCONTINUE / kwCURSOR / kwDEBUG / kwDECLARE / kwDEFAULT
     / kwDIAGNOSTICS / kwELSE / kwELSIF / kwEND / kwEXCEPTION / kwEXECUTE / kwEXIT
-    / kwFETCH / kwFOR / kwFROM / kwGET / kwIF / kwIN / kwINFO / kwINSERT / kwINTO
-    / kwIS / kwLOG / kwLOOP / kwMOVE / kwNOT / kwNOTICE / kwNULL / kwOPEN
-    / kwOR / kwPERFORM / kwRAISE / kwRENAME / kwRESULTOID / kwRETURN
+    / kwFOR / kwFROM / kwGET / kwIF / kwIN / kwINFO / kwINSERT / kwINTO
+    / kwIS / kwLOG / kwLOOP / kwNOT / kwNOTICE / kwNULL / kwFOREACH
+    / kwOR / kwRAISE / kwRENAME / kwRESULTOID / kwRETURN
     / kwREVERSE / kwROWCOUNT / kwSCROLL / kwSTRICT / kwTHEN / kwTO / kwTYPE
     / kwWARNING / kwWHILE
   end
-  
+
   # this terminates keywords
   rule x
     [^a-z0-9_]
   end
-  
+
   rule kwAS
-    'as' ![a-z0-9_] <TKeyword>
+    'as' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwASSIGN
-    ':=' <TKeyword> / '=' <TKeyword>
+    ':=' <Piggly::Parser::Nodes::TKeyword> / '=' <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwALIAS
-    'alias' ![a-z0-9_] <TKeyword>
+    'alias' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
+  end
+
+  rule kwARRAY
+    'array' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwBEGIN
-    'begin' ![a-z0-9_] <TKeyword>
+    'begin' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwBY
-    'by' ![a-z0-9_] <TKeyword>
+    'by' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
 
   rule kwCASE
-    'case' ![a-z0-9_] <TKeyword>
-  end
-  
-  rule kwCLOSE
-    'close' ![a-z0-9_] <TKeyword>
+    'case' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwCONSTANT
-    'constant' ![a-z0-9_] <TKeyword>
+    'constant' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwCONTINUE
-    'continue' ![a-z0-9_] <TKeyword>
+    'continue' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwCURSOR
-    'cursor' ![a-z0-9_] <TKeyword>
+    'cursor' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwDEBUG
-    'debug' ![a-z0-9_] <TKeyword>
+    'debug' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwDECLARE
-    'declare' ![a-z0-9_] <TKeyword>
+    'declare' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwDEFAULT
-    'default' ![a-z0-9_] <TKeyword>
+    'default' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwDIAGNOSTICS
-    'diagnostics' ![a-z0-9_] <TKeyword>
+    'diagnostics' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwELSE
-    'else' ![a-z0-9_] <TKeyword>
+    'else' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwELSIF
-    ('elsif'/'elseif') ![a-z0-9_] <TKeyword>
+    ('elsif'/'elseif') ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwEND
-    'end' ![a-z0-9_] <TKeyword>
+    'end' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwEXCEPTION
-    'exception' ![a-z0-9_] <TKeyword>
+    'exception' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwEXECUTE
-    'execute' ![a-z0-9_] <TKeyword>
+    'execute' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwEXIT
-    'exit' ![a-z0-9_] <TKeyword>
+    'exit' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
-  rule kwFETCH
-    'fetch' ![a-z0-9_] <TKeyword>
-  end
-  
+
   rule kwFOR
-    'for' ![a-z0-9_] <TKeyword>
+    'for' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
+  rule kwFOREACH
+    'foreach' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
+  end
+
   rule kwFROM
-    'from' ![a-z0-9_] <TKeyword>
+    'from' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwGET
-    'get' ![a-z0-9_] <TKeyword>
+    'get' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwIF
-    'if' ![a-z0-9_] <TKeyword>
+    'if' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwIN
-    'in' ![a-z0-9_] <TKeyword>
+    'in' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwINFO
-    'info' ![a-z0-9_] <TKeyword>
+    'info' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwINSERT
-    'insert' ![a-z0-9_] <TKeyword>
+    'insert' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwINTO
-    'into' ![a-z0-9_] <TKeyword>
+    'into' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwIS
-    'is' ![a-z0-9_] <TKeyword>
+    'is' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwLOG
-    'log' ![a-z0-9_] <TKeyword>
+    'log' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwLOOP
-    'loop' ![a-z0-9_] <TKeyword>
-  end
-  
-  rule kwMOVE
-    'move' ![a-z0-9_] <TKeyword>
+    'loop' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwNEXT
-    'next' ![a-z0-9_] <TKeyword>
+    'next' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwNOT
-    'not' ![a-z0-9_] <TKeyword>
+    'not' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwNOTICE
-    'notice' ![a-z0-9_] <TKeyword>
+    'notice' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwNULL
-    'null' ![a-z0-9_] <TKeyword>
-  end
-  
-  rule kwOPEN
-    'open' ![a-z0-9_] <TKeyword>
+    'null' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwOR
-    'or' ![a-z0-9_] <TKeyword>
+    'or' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwPERFORM
-    'perform' ![a-z0-9_] <TKeyword>
+    'perform' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
 
   rule kwQUERY
-    'query' ![a-z0-9_] <TKeyword>
+    'query' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwRAISE
-    'raise' ![a-z0-9_] <TKeyword>
+    'raise' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwRENAME
-    'rename' ![a-z0-9_] <TKeyword>
+    'rename' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwRESULTOID
-    'result_oid' ![a-z0-9_] <TKeyword>
+    'result_oid' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwRETURN
-    'return' ![a-z0-9_] <TKeyword>
+    'return' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwREVERSE
-    'reverse' ![a-z0-9_] <TKeyword>
+    'reverse' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwROWCOUNT
-    'row_count' ![a-z0-9_] <TKeyword>
+    'row_count' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwSCROLL
-    'scroll' ![a-z0-9_] <TKeyword>
+    'scroll' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwSTRICT
-    'strict' ![a-z0-9_] <TKeyword>
+    'strict' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwTHEN
-    'then' ![a-z0-9_] <TKeyword>
+    'then' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwTO
-    'to' ![a-z0-9_] <TKeyword>
+    'to' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwTYPE
-    'type' ![a-z0-9_] <TKeyword>
+    'type' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwWARNING
-    'warning' ![a-z0-9_] <TKeyword>
+    'warning' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
   rule kwWHEN
-    'when' ![a-z0-9_] <TKeyword>
+    'when' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
 
   rule kwWHILE
-    'while' ![a-z0-9_] <TKeyword>
+    'while' ![a-z0-9_] <Piggly::Parser::Nodes::TKeyword>
   end
-  
+
 end