pg_query 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b2251b16a127ee476a1aed7b7f1a8742345ffd51
-  data.tar.gz: 3ca4be0ecefd3404dc2dad263e9d027ada55ee0f
+  metadata.gz: 31d33e3f025beef9defb3beb7c471774873ca41c
+  data.tar.gz: 6d2bf5bf6fda9dcd91bf9ecadc4d9a4c3d4af230
 SHA512:
-  metadata.gz: c021937633296ed32789f625008c9bece2711f10ed41e4804e998fa8114e403414b2a191d60c7c937089daac4661d79ce670124f3e4b0653dde62d5b1420ae38
-  data.tar.gz: 5b9fcbc430526ad159ca5aa46a16094462eb5b8de956d377be9d740146e7166348364774efca904b32a975b765df70f937c85730653874ca2bbd768045ecdfd5
+  metadata.gz: 8d1053da24fa8ec75b06797d44578ea9d438ce71a00d9626d1b0f2c2ad7e3b4fe993e6c5d0cb6e1264c87c607ec31640abba0013690b113d097350a4fdee606c
+  data.tar.gz: 0302e42540073577d6e8e02f21c65c2ca71c15621555be41c7dee50432b57374573b695696260ff2c91ab422c54511e8cbf5d8fed3dc072faaf9f0bd46cd0494

data/ext/pg_query/extconf.rb

@@ -28,14 +28,14 @@ PG_OBJS = {
 #
 # Note: We intentionally use a patched version that fixes bugs in outfuncs.c
 if !Dir.exists?(pgdir)
-  unless File.exists?("#{workdir}/postgres.zip")
-    File.open("#{workdir}/postgres.zip", "wb") do |target_file|
-      open("https://codeload.github.com/pganalyze/postgres/zip/pg_query", "rb") do |read_file|
+  unless File.exists?("#{workdir}/postgres.tar.gz")
+    File.open("#{workdir}/postgres.tar.gz", "wb") do |target_file|
+      open("https://codeload.github.com/pganalyze/postgres/tar.gz/pg_query", "rb") do |read_file|
         target_file.write(read_file.read)
       end
     end
   end
-  system("unzip -q #{workdir}/postgres.zip -d #{workdir}") || raise("ERROR")
+  system("tar -xf #{workdir}/postgres.tar.gz") || raise("ERROR")
   system("mv #{workdir}/postgres-pg_query #{pgdir}") || raise("ERROR")
   system("cd #{pgdir}; CFLAGS=-fPIC ./configure -q") || raise("ERROR")
   system("cd #{pgdir}; make -C src/backend lib-recursive") # Ensures headers are generated

data/ext/pg_query/pg_polyfills.c

@@ -31,3 +31,11 @@ bool proc_exit_inprogress = false;
 /* src/backend/tcop/postgres.c */
 #include "miscadmin.h"
 void check_stack_depth(void) { /* Do nothing */ }
+
+/* src/backends/commands/define.c */
+#include "commands/defrem.h"
+#include "nodes/makefuncs.h"
+DefElem * defWithOids(bool value)
+{
+  return makeDefElem("oids", (Node *) makeInteger(value));
+}

data/lib/pg_query.rb

@@ -2,4 +2,7 @@ require 'pg_query/version'
 require 'pg_query/parse_error'
 
 require 'pg_query/pg_query'
-require 'pg_query/parse'
+require 'pg_query/parse'
+require 'pg_query/filter_columns'
+require 'pg_query/fingerprint'
+require 'pg_query/param_refs'

data/lib/pg_query/filter_columns.rb

@@ -0,0 +1,87 @@
+class PgQuery
+  # Returns a list of columns that the query filters by - this excludes the
+  # target list, but includes things like JOIN condition and WHERE clause.
+  #
+  # Note: This also traverses into sub-selects.
+  def filter_columns
+    load_tables_and_aliases! if @aliases.nil?
+
+    # Get condition items from the parsetree
+    statements = @parsetree.dup
+    condition_items = []
+    filter_columns = []
+    loop do
+      if statement = statements.shift
+        if statement["SELECT"]
+          if statement["SELECT"]["op"] == 0
+            if statement["SELECT"]["fromClause"]
+              # FROM subselects
+              statement["SELECT"]["fromClause"].each do |item|
+                statements << item["RANGESUBSELECT"]["subquery"] if item["RANGESUBSELECT"]
+              end
+
+              # JOIN ON conditions
+              condition_items += conditions_from_join_clauses(statement["SELECT"]["fromClause"])
+            end
+
+            # WHERE clause
+            condition_items << statement["SELECT"]["whereClause"] if statement["SELECT"]["whereClause"]
+          elsif statement["SELECT"]["op"] == 1
+            statements << statement["SELECT"]["larg"] if statement["SELECT"]["larg"]
+            statements << statement["SELECT"]["rarg"] if statement["SELECT"]["rarg"]
+          end
+        elsif statement["UPDATE"]
+          condition_items << statement["UPDATE"]["whereClause"] if statement["UPDATE"]["whereClause"]
+        elsif statement["DELETE FROM"]
+          condition_items << statement["DELETE FROM"]["whereClause"] if statement["DELETE FROM"]["whereClause"]
+        end
+      end
+
+      # Process both JOIN and WHERE conditions here
+      if next_item = condition_items.shift
+        if next_item.keys[0].start_with?("AEXPR") || next_item["ANY"]
+          ["lexpr", "rexpr"].each do |side|
+            next unless expr = next_item.values[0][side]
+            next unless expr.is_a?(Hash)
+            condition_items << expr
+          end
+        elsif next_item["ROW"]
+          condition_items += next_item["ROW"]["args"]
+        elsif next_item["COLUMNREF"]
+          column, table = next_item["COLUMNREF"]["fields"].reverse
+          filter_columns << [@aliases[table] || table, column]
+        elsif next_item["NULLTEST"]
+          condition_items << next_item["NULLTEST"]["arg"]
+        elsif next_item["FUNCCALL"]
+          # FIXME: This should actually be extracted as a funccall and be compared with those indices
+          condition_items += next_item["FUNCCALL"]["args"] if next_item["FUNCCALL"]["args"]
+        elsif next_item["SUBLINK"]
+          condition_items << next_item["SUBLINK"]["testexpr"]
+          statements << next_item["SUBLINK"]["subselect"]
+        end
+      end
+
+      break if statements.empty? && condition_items.empty?
+    end
+
+    filter_columns.uniq
+  end
+
+protected
+  def conditions_from_join_clauses(from_clause)
+    condition_items = []
+    from_clause.each do |item|
+      next unless item["JOINEXPR"]
+
+      joinexpr_items = [item["JOINEXPR"]]
+      loop do
+        break unless next_item = joinexpr_items.shift
+        condition_items << next_item["quals"] if next_item["quals"]
+        ["larg", "rarg"].each do |side|
+          joinexpr_items << next_item[side]["JOINEXPR"] if next_item[side]["JOINEXPR"]
+        end
+      end
+    end
+    condition_items
+  end
+end

data/lib/pg_query/fingerprint.rb

@@ -0,0 +1,62 @@
+require 'digest'
+
+class PgQuery
+  def fingerprint
+    normalized_parsetree = deep_dup(parsetree)
+    exprs = normalized_parsetree.dup
+    loop do
+      expr = exprs.shift
+
+      if expr.is_a?(Hash)
+        expr.each do |k,v|
+          if v.is_a?(Hash) && ["A_CONST", "ALIAS", "PARAMREF"].include?(v.keys[0])
+            # Remove constants, aliases and param references from tree
+            expr[k] = nil
+          elsif k == "location"
+            # Remove location info in order to ignore whitespace and target list ordering
+            expr.delete(k)
+          elsif !v.nil?
+            # Remove SELECT target list names & ignore order
+            if k == "targetList" && v.is_a?(Array)
+              v.each {|v| v["RESTARGET"]["name"] = nil if v["RESTARGET"] } # Remove names
+              v.sort_by! {|v| v.to_s }
+              expr[k] = v
+            end
+
+            # Ignore INSERT cols order
+            if k == "cols" && v.is_a?(Array)
+              v.sort_by! {|v| v.to_s }
+              expr[k] = v
+            end
+
+            # Process sub-expressions
+            exprs << v
+          end
+        end
+      elsif expr.is_a?(Array)
+        exprs += expr
+      end
+
+      break if exprs.empty?
+    end
+
+    Digest::SHA1.hexdigest(normalized_parsetree.to_s)
+  end
+
+  private
+
+  def deep_dup(obj)
+    case obj
+    when Hash
+      obj.each_with_object(obj.dup) do |(key, value), hash|
+        hash[deep_dup(key)] = deep_dup(value)
+      end
+    when Array
+      obj.map { |it| deep_dup(it) }
+    when NilClass, FalseClass, TrueClass, Symbol, Numeric
+      obj # Can't be duplicated
+    else
+      obj.dup
+    end
+  end
+end

data/lib/pg_query/param_refs.rb

@@ -0,0 +1,40 @@
+class PgQuery
+  def param_refs
+    results = []
+    exprs = parsetree.dup
+    loop do
+      expr = exprs.shift
+
+      if expr.is_a?(Hash)
+        expr.each do |k,v|
+          if v.is_a?(Hash)
+            if v["PARAMREF"]
+              length = 1 # FIXME: Not true when we have actual paramrefs
+              results << {"location" => v["PARAMREF"]["location"], "length" => length}
+              next
+            elsif (p = v["TYPECAST"]["arg"]["PARAMREF"] rescue false) && (t = v["TYPECAST"]["typeName"]["TYPENAME"] rescue false)
+              location = p["location"]
+              typeloc = t["location"]
+              typename = t["names"].join(".")
+              length = 1 # FIXME: Not true when we have actual paramrefs
+              if typeloc < location
+                length += location - typeloc
+                location = typeloc
+              end
+              results << {"location" => location, "length" => length, "typename" => typename}
+              next
+            end
+          end
+
+          exprs << v if !v.nil?
+        end
+      elsif expr.is_a?(Array)
+        exprs += expr
+      end
+
+      break if exprs.empty?
+    end
+    results.sort_by! {|r| r["location"] }
+    results
+  end
+end

data/lib/pg_query/version.rb

@@ -1,3 +1,3 @@
 class PgQuery
-  VERSION = '0.4.1'
+  VERSION = '0.5.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_query
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Lukas Fittl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-18 00:00:00.000000000 Z
+date: 2015-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -66,6 +66,9 @@ files:
 - ext/pg_query/pg_query.c
 - ext/pg_query/pg_query.sym
 - lib/pg_query.rb
+- lib/pg_query/filter_columns.rb
+- lib/pg_query/fingerprint.rb
+- lib/pg_query/param_refs.rb
 - lib/pg_query/parse.rb
 - lib/pg_query/parse_error.rb
 - lib/pg_query/version.rb
@@ -89,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: PostgreSQL query parsing and normalization library