piggly-nsd 2.3.3

data/lib/piggly/dumper/reified_procedure.rb

@@ -0,0 +1,172 @@
+module Piggly
+  module Dumper
+
+    #
+    # Differs from SkeletonProcedure in that the procedure source code is stored
+    # as an instance variable.
+    #
+    class ReifiedProcedure < SkeletonProcedure
+
+      def initialize(source, oid, name, strict, secdef, setof, type, volatility, arg_modes, arg_names, arg_types, arg_defaults, prokind = "f", language = "plpgsql")
+        # Ensure source is UTF-8 encoded
+        @source = source.to_s.force_encoding('UTF-8').strip
+
+        if type.name == "record" and type.schema == "pg_catalog" and arg_modes.include?("t")
+          prefix       = arg_modes.take_while{|m| m != "t" }.length
+          type         = RecordType.new(arg_types[prefix..-1], arg_names[prefix..-1], arg_modes[prefix..-1], arg_defaults[prefix..-1])
+          arg_modes    = arg_modes[0, prefix]
+          arg_types    = arg_types[0, prefix]
+          arg_names    = arg_names[0, prefix]
+          arg_defaults = arg_defaults[0, prefix]
+          setof        = false
+        end
+
+        super(oid, name, strict, secdef, setof, type, volatility, arg_modes, arg_names, arg_types, arg_defaults, prokind, language)
+      end
+
+      # @return [String]
+      def source(config)
+        @source
+      end
+
+      # @return [void]
+      def store_source(config)
+        if @source.include?("$PIGGLY$")
+          raise "Procedure `#{@name}' is already instrumented. " +
+                "This means the original source wasn't restored after the " +
+                "last coverage run. You must restore the source manually."
+        end
+
+        File.open(source_path(config), "wb:UTF-8"){|io| io.write(@source) }
+      end
+
+      # @return [SkeletonProcedure]
+      def skeleton
+        SkeletonProcedure.new(@oid, @name, @strict, @secdef, @setof, @type,
+                              @volatility, @arg_modes, @arg_names, @arg_types,
+                              @arg_defaults, @prokind, @language)
+      end
+
+      def skeleton?
+        false
+      end
+    end
+
+    class << ReifiedProcedure
+      # Rewrite "i", "o", and "b", otherwise pass-through
+      MODES = Hash.new{|h,k| k }.update \
+        "i" => "in",
+        "o" => "out",
+        "b" => "inout",
+        "v" => "variadic"
+
+      # Rewrite "i", "v", and "s", otherwise pass-through
+      VOLATILITY = Hash.new{|h,k| k }.update \
+         "i" => "immutable",
+         "v" => "volatile",
+         "s" => "stable"
+
+      def mode(mode)
+        MODES[mode]
+      end
+
+      def volatility(mode)
+        VOLATILITY[mode]
+      end
+
+      def defaults(exprs, count, total)
+        exprs = if exprs.nil? then [] else exprs.split(", ") end
+
+        nreqd = total - count
+
+        if nreqd >= 0 and exprs.length == count
+          Array.new(nreqd) + exprs
+        else
+          raise "Couldn't parse default arguments"
+        end
+      end
+
+      # Returns a list of all PL/pgSQL stored procedures in the current database
+      #
+      # @return [Array<ReifiedProcedure>]
+      def all(connection)
+        connection.query(<<-SQL).map{|x| from_hash(x) }
+          select
+            pro.oid,
+            nschema.nspname   as nschema,
+            pro.proname       as name,
+            pro.proisstrict   as strict,
+            pro.prosecdef     as secdef,
+            pro.provolatile   as volatility,
+            pro.proretset     as setof,
+            rschema.nspname   as tschema,
+            ret.typname       as type,
+            pro.prosrc        as source,
+            pro.pronargs      as arg_count,
+            lang.lanname	    as language,
+            array_to_string(pro.proargmodes, ',') as arg_modes,
+            array_to_string(pro.proargnames, ',') as arg_names,
+            case when proallargtypes is not null then
+                   -- use proalltypes array if its non-null
+                   array_to_string(array(select format_type(proallargtypes[k], null)
+                                         from generate_series(array_lower(proallargtypes, 1),
+                                                              array_upper(proallargtypes, 1)) as k), ',')
+                 else
+                   -- fallback to oidvector proargtypes
+                   oidvectortypes(pro.proargtypes)
+                 end as arg_types,
+            pro.pronargdefaults as arg_defaults_count,
+            coalesce(pg_get_expr(pro.proargdefaults, 0), '') as arg_defaults,
+            coalesce(pro.prokind, 'f') as prokind
+          from pg_proc as pro,
+               pg_type as ret,
+               pg_namespace as nschema,
+               pg_namespace as rschema,
+               pg_language	as lang
+          where pro.pronamespace = nschema.oid
+            and pro.prolang = lang.oid
+            and ret.typnamespace = rschema.oid
+            and pro.proname not like 'piggly_%'
+            and pro.prorettype = ret.oid
+            and pro.prolang = (select oid from pg_language where lanname = 'plpgsql')
+            and pro.pronamespace not in (select oid
+                                         from pg_namespace
+                                         where nspname like 'pg_%'
+                                            or nspname like 'information_schema')
+        SQL
+      end
+
+      # Construct a ReifiedProcedure from a result row (Hash)
+      #
+      # @return [ReifiedProcedure]
+      def from_hash(hash)
+        new(hash["source"],
+            hash["oid"],
+            QualifiedName.new(hash["nschema"].to_s, hash["name"].to_s),
+            hash["strict"] == "t",
+            hash["secdef"] == "t",
+            hash["setof"]  == "t",
+            QualifiedType.parse(hash["tschema"].to_s, hash["type"].to_s),
+            volatility(hash["volatility"]),
+            coalesce(hash["arg_modes"].to_s.split(",").map{|x| mode(x.strip) },
+                     ["in"]*hash["arg_count"].to_i),
+            hash["arg_names"].to_s.split(",").map{|x| QualifiedName.new(nil, x.strip) },
+            hash["arg_types"].to_s.split(",").map{|x| QualifiedType.parse(x.strip) },
+            defaults(hash["arg_defaults"],
+                     hash["arg_defaults_count"].to_i,
+                     hash["arg_count"].to_i),
+            hash["prokind"].to_s,
+            hash["language"].to_s)
+      end
+
+      def coalesce(value, default)
+        if [nil, "", []].include?(value)
+          default
+        else
+          value
+        end
+      end
+    end
+
+  end
+end

data/lib/piggly/dumper/skeleton_procedure.rb

@@ -0,0 +1,112 @@
+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, :setof, :volatility, :secdef, :identifier, :prokind, :language
+
+      def initialize(oid, name, strict, secdef, setof, type, volatility, arg_modes, arg_names, arg_types, arg_defaults, prokind = "f", language = "plpgsql")
+        @oid, @name, @strict, @secdef, @type, @volatility, @setof, @arg_modes, @arg_names, @arg_types, @arg_defaults, @prokind, @language =
+          oid, name, strict, secdef, type, volatility, setof, arg_modes, arg_names, arg_types, arg_defaults, prokind, language
+
+
+        @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 " : nil
+      end
+
+      # Returns source text for strictness
+      # @return [String]
+      def strictness
+        @strict ? "strict" : nil
+      end
+
+      # Returns source text for security
+      # @return [String]
+      def security
+        @secdef ? "security definer" : nil
+      end
+
+      # Returns source SQL function/procedure definition statement
+      # @return [String]
+      def definition(body)
+        if @prokind == 'p'
+          # PostgreSQL PROCEDURE (introduced in PG11)
+          [%[create or replace procedure #{name.quote} (#{arguments})],
+           %[ language plpgsql #{security} as $__PIGGLY__$],
+           body,
+           %[$__PIGGLY__$]].join("\n")
+        else
+          # PostgreSQL FUNCTION
+          [%[create or replace function #{name.quote} (#{arguments})],
+           %[ returns #{setof}#{type.quote} as $__PIGGLY__$],
+           body,
+           %[$__PIGGLY__$ language plpgsql #{strictness} #{security} #{@volatility}]].join("\n")
+        end
+      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), encoding: 'UTF-8')
+      end
+
+      # @return [String]
+      alias source load_source
+
+      # @return [void]
+      def purge_source(config)
+        path = source_path(config)
+
+        FileUtils.rm_r(path) if File.exist?(path)
+
+        file = Compiler::TraceCompiler.new(config).cache_path(path)
+        FileUtils.rm_r(file) if File.exist?(file)
+
+        file = Reporter::Base.new(config).report_path(path, ".html")
+        FileUtils.rm_r(file) if File.exist?(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/dumper.rb

@@ -0,0 +1,9 @@
+module Piggly
+  module Dumper
+    autoload :Index,              "piggly/dumper/index"
+    autoload :QualifiedName,      "piggly/dumper/qualified_name"
+    autoload :QualifiedType,      "piggly/dumper/qualified_type"
+    autoload :ReifiedProcedure,   "piggly/dumper/reified_procedure"
+    autoload :SkeletonProcedure,  "piggly/dumper/skeleton_procedure"
+  end
+end

data/lib/piggly/installer.rb

@@ -0,0 +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)
+
+      procedures.each do |p|
+        begin
+          trace(p, profile)
+        rescue Parser::Failure
+          $stdout.puts $!
+        end
+      end
+
+      @connection.exec("commit")
+    rescue
+      @connection.exec("rollback")
+      raise
+    end
+
+    # @return [void]
+    def uninstall(procedures)
+      @connection.exec("begin")
+
+      procedures.each{|p| untrace(p) }
+      uninstall_support
+
+      @connection.exec("commit")
+    rescue
+      @connection.exec("rollback")
+      raise
+    end
+
+    # @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 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
+        CREATE OR REPLACE FUNCTION piggly_cond(message varchar, value boolean)
+          RETURNS boolean AS $$
+        BEGIN
+          IF value THEN
+            RAISE WARNING '#{@config.trace_prefix} % t', message;
+          ELSE
+            RAISE WARNING '#{@config.trace_prefix} % f', message;
+          END IF;
+          RETURN value;
+        END $$ LANGUAGE 'plpgsql' VOLATILE;
+      SQL
+
+      @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;
+        END $$ LANGUAGE 'plpgsql' VOLATILE;
+      SQL
+
+      @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;
+          RETURN value;
+        END $$ LANGUAGE 'plpgsql' VOLATILE;
+      SQL
+
+      @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;
+          RETURN value;
+        END $$ LANGUAGE 'plpgsql' VOLATILE;
+      SQL
+
+      @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;
+        END $$ LANGUAGE 'plpgsql' VOLATILE;
+      SQL
+    end
+
+    # Uninstalls instrumentation support
+    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
+  end
+
+end