pg_query 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e4626094955c34766049a41a21623847e80cb0d8
-  data.tar.gz: ea9c73a5e6e410f14dd3baa3971dbb87046efab3
+  metadata.gz: ff45e7cd81fcb9dfcf97a5d57f9cf6c2e4131f31
+  data.tar.gz: 6458e3ebc2b8500062fef38392ef2c64235dafe5
 SHA512:
-  metadata.gz: eb545f475347e8add8714fd95b9c5022d79c24296c16c73a7990e1742704de0778d713faa47ec0cb34de609ffa7e05a8a60e0fe3357910034e9d3ec633bc50b2
-  data.tar.gz: c4981b0e1107bf5ce207376207c8d7b90244536cc480b2d0a7a3c2f311938cb7bf95bfaf7eae171e4448993da335fbd65984dadc37af0543c2970b5178d98f9c
+  metadata.gz: 40ef7f21ea55cc3e45d3eb88f7c095df908998773f50080524aca6b7a08db83a1191c3a874c6a04252a580ee7fc1412a2a78c778939c5b61eab5b25f9630d911
+  data.tar.gz: 76602b4307347a01e9262ef9065d577a16d2b4951e7125a5a2910993517b85e7202050d2e31cda685f1eae0c8b36764497253c4319497fd2010c46da462d05d2

data/CHANGELOG.md

@@ -0,0 +1,48 @@
+# Changelog
+
+## 0.6.2    UNRELEASED
+
+* ...
+
+
+## 0.6.1    2015-08-06
+
+* Deparsing: Support WITH clauses in INSERT/UPDATE/DELETE [@JackDanger](https://github.com/JackDanger)
+* Make sure gemspec includes all necessary files
+
+
+## 0.6.0    2015-08-05
+
+* Deparsing (experimental)
+  * Turns parse trees into SQL again
+  * New truncate method to smartly truncate based on less important query parts
+  * Thanks to [@mme](https://github.com/mme) & [@JackDanger](https://github.com/JackDanger) for their contributions
+* Restructure extension C code
+* Add table/filter columns support for CTEs
+* Extract views as tables from CREATE/REFRESH VIEW
+* Refactor code using generic treewalker
+* fingerprint: Normalize IN lists
+* param_refs: Fix length attribute in result
+
+
+## 0.5.0    2015-03-26
+
+* Query fingerprinting
+* Filter columns (aka columns referenced in a query's WHERE clause)
+* Parameter references: Returns all $1/$2/etc like references in the query with their location
+* Remove dependency on active_support
+
+
+## 0.4.1    2014-12-18
+
+* Fix compilation of C extension
+* Fix gemspec
+
+
+## 0.4.0    2014-12-18
+
+* Speed up build time by only building necessary objects
+* PostgreSQL 9.4 parser
+
+
+See git commit log for previous releases.

data/README.md

@@ -0,0 +1,178 @@
+# pg_query [ ![](https://img.shields.io/gem/v/pg_query.svg)](https://rubygems.org/gems/pg_query) [ ![](https://img.shields.io/gem/dt/pg_query.svg)](https://rubygems.org/gems/pg_query) [ ![Codeship Status for lfittl/dblint](https://img.shields.io/codeship/584524e0-ed17-0131-838b-4216c01ccc74.svg)](https://codeship.com/projects/26651)
+
+This Ruby extension uses the actual PostgreSQL server source to parse SQL queries and return the internal PostgreSQL parsetree.
+
+In addition the extension allows you to normalize queries (replacing constant values with ?) and parse these normalized queries into a parsetree again.
+
+When you build this extension, it fetches a copy of the PostgreSQL server source and builds parts of it, and then statically links it into this extension.
+
+This is slightly crazy, but is the only reliable way of parsing all valid PostgreSQL queries.
+
+You can find further examples and a longer rationale here: https://pganalyze.com/blog/parse-postgresql-queries-in-ruby.html
+
+## Installation
+
+```
+gem install pg_query
+```
+
+Due to compiling parts of PostgreSQL, installation will take a while. Expect between 2 and 10 minutes.
+
+Note: On some Linux systems you'll have to install the ```flex``` package beforehand.
+
+## Usage
+
+### Parsing a query
+
+```ruby
+PgQuery.parse("SELECT 1")
+
+=> #<PgQuery:0x007fe92b27ea18
+ @parsetree=
+  [{"SELECT"=>
+     {"distinctClause"=>nil,
+      "intoClause"=>nil,
+      "targetList"=>
+       [{"RESTARGET"=>
+          {"name"=>nil,
+           "indirection"=>nil,
+           "val"=>{"A_CONST"=>{"val"=>1, "location"=>7}},
+           "location"=>7}}],
+      ...}}],
+ @query="SELECT 1",
+ @warnings=[]>
+```
+
+### Modifying a parsed query and turning it into SQL again
+
+```ruby
+parsed_query = PgQuery.parse("SELECT * FROM users")
+
+=> #<PgQuery:0x007ff3e956c8b0
+ @parsetree=
+  [{"SELECT"=>{"distinctClause"=>nil,
+               "intoClause"=>nil,
+               "targetList"=>
+               [{"RESTARGET"=>
+                 {"name"=>nil,
+                  "indirection"=>nil,
+                  "val"=>
+                  {"COLUMNREF"=>
+                    {"fields"=>[{"A_STAR"=>{}}],
+                     "location"=>7}},
+                  "location"=>7}}],
+               "fromClause"=>
+               [{"RANGEVAR"=>
+                 {"schemaname"=>nil,
+                  "relname"=>"users",
+                  "inhOpt"=>2,
+                  "relpersistence"=>"p",
+                  "alias"=>nil,
+                  "location"=>14}}],
+               ...}}],
+ @query="SELECT * FROM users",
+ @warnings=[]>
+
+# Modify the parse tree in some way
+parsed_query.parsetree[0]['SELECT']['fromClause'][0]['RANGEVAR']['relname'] = 'other_users'
+
+# Turn it into SQL again
+parsed_query.deparse
+=> "SELECT * FROM other_users"
+```
+
+Note: The deparsing feature is experimental and does not support outputting all SQL yet.
+
+### Parsing a normalized query
+
+```ruby
+# Normalizing a query (like pg_stat_statements)
+PgQuery.normalize("SELECT 1 FROM x WHERE y = 'foo'")
+
+=> "SELECT ? FROM x WHERE y = ?"
+
+# Parsing a normalized query
+PgQuery.parse("SELECT ? FROM x WHERE y = ?")
+
+=> #<PgQuery:0x007fb99455a438
+ @parsetree=
+  [{"SELECT"=>
+     {"distinctClause"=>nil,
+      "intoClause"=>nil,
+      "targetList"=>
+       [{"RESTARGET"=>
+          {"name"=>nil,
+           "indirection"=>nil,
+           "val"=>{"PARAMREF"=>{"number"=>0, "location"=>7}},
+           "location"=>7}}],
+      "fromClause"=>
+       [{"RANGEVAR"=>
+          {"schemaname"=>nil,
+           "relname"=>"x",
+           "inhOpt"=>2,
+           "relpersistence"=>"p",
+           "alias"=>nil,
+           "location"=>14}}],
+      "whereClause"=>
+       {"AEXPR"=>
+         {"name"=>["="],
+          "lexpr"=>{"COLUMNREF"=>{"fields"=>["y"], "location"=>22}},
+          "rexpr"=>{"PARAMREF"=>{"number"=>0, "location"=>26}},
+          "location"=>24}},
+      ...}}],
+ @query="SELECT ? FROM x WHERE y = ?",
+ @warnings=[]>
+```
+
+### Extracting tables from a query
+
+```ruby
+PgQuery.parse("SELECT ? FROM x JOIN y USING (id) WHERE z = ?").tables
+
+=> ["x", "y"]
+```
+
+### Extracting columns from a query
+
+```ruby
+PgQuery.parse("SELECT ? FROM x WHERE x.y = ? AND z = ?").filter_columns
+
+=> [["x", "y"], [nil, "z"]]
+```
+
+### Fingerprinting a query
+
+```ruby
+PgQuery.parse("SELECT 1").fingerprint
+
+=> "db76551255b7861b99bd384cf8096a3dd5162ab3"
+
+PgQuery.parse("SELECT 2; --- comment").fingerprint
+
+=> "db76551255b7861b99bd384cf8096a3dd5162ab3"
+```
+
+## Differences from Upstream PostgreSQL
+
+**This gem uses a [patched version of the latest PostgreSQL stable](https://github.com/pganalyze/postgres/compare/REL9_4_STABLE...pg_query).**
+
+Changes:
+* **scan.l/gram.y:** Modified to support parsing normalized queries
+ * Known regression: Removed support for custom operators containing "?" (doesn't affect hstore/JSON/geometric operators)
+* **outfuncs_json.c:** Auto-generated outfuncs that outputs a parsetree as JSON (called through nodeToJSONString)
+
+Unit tests for these patches are inside this library - the tests will break if run against upstream.
+
+
+## Authors
+
+- [Lukas Fittl](mailto:lukas@fittl.com)
+
+
+## License
+
+Copyright (c) 2015, pganalyze Team <team@pganalyze.com><br>
+pg_query is licensed under the 3-clause BSD license, see LICENSE file for details.
+
+Query normalization code:<br>
+Copyright (c) 2008-2015, PostgreSQL Global Development Group

data/lib/pg_query/deparse.rb

@@ -0,0 +1,481 @@
+class PgQuery
+  # Reconstruct all of the parsed queries into their original form
+  def deparse(tree = @parsetree)
+    tree.map do |item|
+      self.class.deparse(item)
+    end.join('; ')
+  end
+
+  class << self
+    # Given one element of the PgQuery#parsetree reconstruct it back into the
+    # original query.
+    def deparse(item)
+      deparse_item(item)
+    end
+
+    private
+
+    def deparse_item(item, context = nil) # rubocop:disable Metrics/CyclomaticComplexity
+      return if item.nil?
+
+      type = item.keys[0]
+      node = item.values[0]
+
+      case type
+      when 'RANGEVAR'
+        deparse_rangevar(node)
+      when 'AEXPR'
+        deparse_aexpr(node)
+      when 'COLUMNREF'
+        deparse_columnref(node)
+      when 'A_ARRAYEXPR'
+        deparse_a_arrayexp(node)
+      when 'A_CONST'
+        deparse_a_const(node)
+      when 'A_STAR'
+        deparse_a_star(node)
+      when 'A_INDIRECTION'
+        deparse_a_indirection(node)
+      when 'A_INDICES'
+        deparse_a_indices(node)
+      when 'ALIAS'
+        deparse_alias(node)
+      when 'PARAMREF'
+        deparse_paramref(node)
+      when 'RESTARGET'
+        deparse_restarget(node, context)
+      when 'FUNCCALL'
+        deparse_funccall(node)
+      when 'RANGEFUNCTION'
+        deparse_range_function(node)
+      when 'AEXPR AND'
+        deparse_aexpr_and(node)
+      when 'JOINEXPR'
+        deparse_joinexpr(node)
+      when 'SORTBY'
+        deparse_sortby(node)
+      when 'SELECT'
+        deparse_select(node)
+      when 'WITHCLAUSE'
+        deparse_with_clause(node)
+      when 'COMMONTABLEEXPR'
+        deparse_cte(node)
+      when 'INSERT INTO'
+        deparse_insert_into(node)
+      when 'UPDATE'
+        deparse_update(node)
+      when 'TYPECAST'
+        deparse_typecast(node)
+      when 'TYPENAME'
+        deparse_typename(node)
+      when 'CASE'
+        deparse_case(node)
+      when 'WHEN'
+        deparse_when(node)
+      when 'SUBLINK'
+        deparse_sublink(node)
+      when 'RANGESUBSELECT'
+        deparse_rangesubselect(node)
+      when 'ROW'
+        deparse_row(node)
+      when 'AEXPR IN'
+        deparse_aexpr_in(node)
+      when 'AEXPR NOT'
+        deparse_aexpr_not(node)
+      when 'AEXPR OR'
+        deparse_aexpr_or(node)
+      when 'AEXPR ANY'
+        deparse_aexpr_any(node)
+      when 'NULLTEST'
+        deparse_nulltest(node)
+      when 'TRANSACTION'
+        deparse_transaction(node)
+      when 'COALESCE'
+        deparse_coalesce(node)
+      when 'DELETE FROM'
+        deparse_delete_from(node)
+      when 'A_TRUNCATED'
+        '...' # pg_query internal
+      else
+        fail format("Can't deparse: %s: %s", type, node.inspect)
+      end
+    end
+
+    def deparse_rangevar(node)
+      output = []
+      output << 'ONLY' if node['inhOpt'] == 0
+      output << node['relname']
+      output << deparse_item(node['alias']) if node['alias']
+      output.join(' ')
+    end
+
+    def deparse_columnref(node)
+      node['fields'].map do |field|
+        field.is_a?(String) ? field : deparse_item(field)
+      end.join('.')
+    end
+
+    def deparse_a_arrayexp(node)
+      'ARRAY[' + node['elements'].map do |element|
+        deparse_item(element)
+      end.join(', ') + ']'
+    end
+
+    def deparse_a_const(node)
+      node['val'].inspect.gsub('"', '\'')
+    end
+
+    def deparse_a_star(_node)
+      '*'
+    end
+
+    def deparse_a_indirection(node)
+      output = [deparse_item(node['arg'])]
+      node['indirection'].each do |subnode|
+        output << deparse_item(subnode)
+      end
+      output.join
+    end
+
+    def deparse_a_indices(node)
+      format('[%s]', deparse_item(node['uidx']))
+    end
+
+    def deparse_alias(node)
+      node['aliasname']
+    end
+
+    def deparse_paramref(node)
+      if node['number'] == 0
+        '?'
+      else
+        format('$%d', node['number'])
+      end
+    end
+
+    def deparse_restarget(node, context)
+      if context == :select
+        [deparse_item(node['val']), node['name']].compact.join(' AS ')
+      elsif context == :update
+        [node['name'], deparse_item(node['val'])].compact.join(' = ')
+      elsif node['val'].nil?
+        node['name']
+      else
+        fail format("Can't deparse %s in context %s", node.inspect, context)
+      end
+    end
+
+    def deparse_funccall(node)
+      args = Array(node['args']).map { |arg| deparse_item(arg) }
+      format('%s(%s)', node['funcname'].join('.'), args.join(', '))
+    end
+
+    def deparse_aexpr_in(node)
+      rexpr = Array(node['rexpr']).map { |arg| deparse_item(arg) }
+      format('%s IN (%s)', deparse_item(node['lexpr']), rexpr.join(', '))
+    end
+
+    def deparse_aexpr_not(node)
+      format('NOT %s', deparse_item(node['rexpr']))
+    end
+
+    def deparse_range_function(node)
+      output = []
+      output << 'LATERAL' if node['lateral']
+      output << deparse_item(node['functions'][0][0]) # FIXME: Needs more test cases
+      output << deparse_item(node['alias']) if node['alias']
+      output.join(' ')
+    end
+
+    def deparse_aexpr(node)
+      output = []
+      output << deparse_item(node['lexpr'])
+      output << deparse_item(node['rexpr'])
+      output.join(' ' + node['name'][0] + ' ')
+    end
+
+    def deparse_aexpr_and(node)
+      # Only put parantheses around OR nodes that are inside this one
+      lexpr = format(['AEXPR OR'].include?(node['lexpr'].keys[0]) ? '(%s)' : '%s', deparse_item(node['lexpr']))
+      rexpr = format(['AEXPR OR'].include?(node['rexpr'].keys[0]) ? '(%s)' : '%s', deparse_item(node['rexpr']))
+      format('%s AND %s', lexpr, rexpr)
+    end
+
+    def deparse_aexpr_or(node)
+      # Put parantheses around AND + OR nodes that are inside
+      lexpr = format(['AEXPR AND', 'AEXPR OR'].include?(node['lexpr'].keys[0]) ? '(%s)' : '%s', deparse_item(node['lexpr']))
+      rexpr = format(['AEXPR AND', 'AEXPR OR'].include?(node['rexpr'].keys[0]) ? '(%s)' : '%s', deparse_item(node['rexpr']))
+      format('%s OR %s', lexpr, rexpr)
+    end
+
+    def deparse_aexpr_any(node)
+      output = []
+      output << deparse_item(node['lexpr'])
+      output << format('ANY(%s)', deparse_item(node['rexpr']))
+      output.join(' ' + node['name'][0] + ' ')
+    end
+
+    def deparse_joinexpr(node)
+      output = []
+      output << deparse_item(node['larg'])
+      output << 'LEFT' if node['jointype'] == 1
+      output << 'JOIN'
+      output << deparse_item(node['rarg'])
+
+      if node['quals']
+        output << 'ON'
+        output << deparse_item(node['quals'])
+      end
+
+      output.join(' ')
+    end
+
+    def deparse_sortby(node)
+      output = []
+      output << deparse_item(node['node'])
+      output << 'ASC' if node['sortby_dir'] == 1
+      output.join(' ')
+    end
+
+    def deparse_with_clause(node)
+      output = ['WITH']
+      output << 'RECURSIVE' if node['recursive']
+      output << node['ctes'].map do |cte|
+        deparse_item(cte)
+      end.join(', ')
+      output.join(' ')
+    end
+
+    def deparse_cte(node)
+      output = ''
+      output += node['ctename']
+      output += format('(%s)', node['aliascolnames'].join(', ')) if node['aliascolnames']
+      output += format(' AS (%s)', deparse_item(node['ctequery']))
+      output
+    end
+
+    def deparse_case(node)
+      output = ['CASE']
+      output += node['args'].map { |arg| deparse_item(arg) }
+      if node['defresult']
+        output << 'ELSE'
+        output << deparse_item(node['defresult'])
+      end
+      output << 'END'
+      output.join(' ')
+    end
+
+    def deparse_when(node)
+      output = ['WHEN']
+      output << deparse_item(node['expr'])
+      output << 'THEN'
+      output << deparse_item(node['result'])
+      output.join(' ')
+    end
+
+    def deparse_sublink(node)
+      if node['subLinkType'] == 2 && node['operName'] == ['=']
+        return format('%s IN (%s)', deparse_item(node['testexpr']), deparse_item(node['subselect']))
+      elsif node['subLinkType'] == 0
+        return format('EXISTS(%s)', deparse_item(node['subselect']))
+      else
+        return format('(%s)', deparse_item(node['subselect']))
+      end
+    end
+
+    def deparse_rangesubselect(node)
+      output = '('
+      output += deparse_item(node['subquery'])
+      output += ')'
+      output += ' ' + node['alias']['ALIAS']['aliasname'] if node['alias']
+      output
+    end
+
+    def deparse_row(node)
+      'ROW(' + node['args'].map { |arg| deparse_item(arg) }.join(', ') + ')'
+    end
+
+    def deparse_select(node) # rubocop:disable Metrics/CyclomaticComplexity
+      output = []
+
+      if node['op'] == 1
+        output << deparse_item(node['larg'])
+        output << 'UNION'
+        output << 'ALL' if node['all']
+        output << deparse_item(node['rarg'])
+        return output.join(' ')
+      end
+
+      output << deparse_item(node['withClause']) if node['withClause']
+
+      if node['targetList']
+        output << 'SELECT'
+        output << node['targetList'].map do |item|
+          deparse_item(item, :select)
+        end.join(', ')
+      end
+
+      if node['fromClause']
+        output << 'FROM'
+        output << node['fromClause'].map do |item|
+          deparse_item(item)
+        end.join(', ')
+      end
+
+      if node['whereClause']
+        output << 'WHERE'
+        output << deparse_item(node['whereClause'])
+      end
+
+      if node['valuesLists']
+        output << 'VALUES'
+        output << node['valuesLists'].map do |value_list|
+          '(' + value_list.map { |v| deparse_item(v) }.join(', ') + ')'
+        end.join(', ')
+      end
+
+      if node['groupClause']
+        output << 'GROUP BY'
+        output << node['groupClause'].map do |item|
+          deparse_item(item)
+        end.join(', ')
+      end
+
+      if node['sortClause']
+        output << 'ORDER BY'
+        output << node['sortClause'].map do |item|
+          deparse_item(item)
+        end.join(', ')
+      end
+
+      output.join(' ')
+    end
+
+    def deparse_insert_into(node)
+      output = []
+      output << deparse_item(node['withClause']) if node['withClause']
+
+      output << 'INSERT INTO'
+      output << deparse_item(node['relation'])
+
+      if node['cols']
+        output << '(' + node['cols'].map do |column|
+          deparse_item(column)
+        end.join(', ') + ')'
+      end
+
+      output << deparse_item(node['selectStmt'])
+
+      output.join(' ')
+    end
+
+    def deparse_update(node)
+      output = []
+      output << deparse_item(node['withClause']) if node['withClause']
+
+      output << 'UPDATE'
+      output << deparse_item(node['relation'])
+
+      if node['targetList']
+        output << 'SET'
+        node['targetList'].each do |item|
+          output << deparse_item(item, :update)
+        end
+      end
+
+      if node['whereClause']
+        output << 'WHERE'
+        output << deparse_item(node['whereClause'])
+      end
+
+      if node['returningList']
+        output << 'RETURNING'
+        output << node['returningList'].map do |item|
+          # RETURNING is formatted like a SELECT
+          deparse_item(item, :select)
+        end.join(', ')
+      end
+
+      output.join(' ')
+    end
+
+    def deparse_typecast(node)
+      if deparse_item(node['typeName']) == :boolean
+        deparse_item(node['arg']) == "'t'" ? 'true' : 'false'
+      else
+        deparse_item(node['arg']) + '::' + deparse_typename(node['typeName']['TYPENAME'])
+      end
+    end
+
+    def deparse_typename(node)
+      if node['names'] == %w(pg_catalog bool)
+        :boolean
+      else
+        node['names'].join('.')
+      end
+    end
+
+    def deparse_nulltest(node)
+      output = [deparse_item(node['arg'])]
+      if node['nulltesttype'] == 0
+        output << 'IS NULL'
+      elsif node['nulltesttype'] == 1
+        output << 'IS NOT NULL'
+      end
+      output.join(' ')
+    end
+
+    TRANSACTION_CMDS = {
+      0 => 'BEGIN',
+      2 => 'COMMIT',
+      3 => 'ROLLBACK',
+      4 => 'SAVEPOINT',
+      5 => 'RELEASE',
+      6 => 'ROLLBACK TO SAVEPOINT'
+    }
+    def deparse_transaction(node)
+      output = []
+      output << TRANSACTION_CMDS[node['kind']] || fail(format("Can't deparse TRANSACTION %s", node.inspect))
+
+      if node['options'] && node['options'][0]['DEFELEM']
+        output << node['options'][0]['DEFELEM']['arg']
+      end
+
+      output.join(' ')
+    end
+
+    def deparse_coalesce(node)
+      format('COALESCE(%s)', node['args'].map { |a| deparse_item(a) }.join(', '))
+    end
+
+    def deparse_delete_from(node)
+      output = []
+      output << deparse_item(node['withClause']) if node['withClause']
+
+      output << 'DELETE FROM'
+      output << deparse_item(node['relation'])
+
+      if node['usingClause']
+        output << 'USING'
+        output << node['usingClause'].map do |item|
+          deparse_item(item)
+        end.join(', ')
+      end
+
+      if node['whereClause']
+        output << 'WHERE'
+        output << deparse_item(node['whereClause'])
+      end
+
+      if node['returningList']
+        output << 'RETURNING'
+        output << node['returningList'].map do |item|
+          # RETURNING is formatted like a SELECT
+          deparse_item(item, :select)
+        end.join(', ')
+      end
+
+      output.join(' ')
+    end
+  end
+end

data/lib/pg_query/treewalker.rb

@@ -0,0 +1,47 @@
+class PgQuery
+  private
+
+  def treewalker!(normalized_parsetree, &block)
+    exprs = normalized_parsetree.dup.map { |e| [e, []] }
+
+    loop do
+      expr, parent_location = exprs.shift
+
+      if expr.is_a?(Hash)
+        expr.each do |k, v|
+          location = parent_location + [k]
+
+          block.call(expr, k, v, location)
+
+          exprs << [v, location] unless v.nil?
+        end
+      elsif expr.is_a?(Array)
+        exprs += expr.map.with_index { |e, idx| [e, parent_location + [idx]] }
+      end
+
+      break if exprs.empty?
+    end
+  end
+
+  def find_tree_location(normalized_parsetree, searched_location, &block)
+    treewalker! normalized_parsetree do |expr, k, v, location|
+      next unless location == searched_location
+      block.call(expr, k, v)
+    end
+  end
+
+  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/truncate.rb

@@ -0,0 +1,58 @@
+class PgQuery
+  PossibleTruncation = Struct.new(:location, :node_type, :length, :is_array)
+
+  # Truncates the query string to be below the specified length, first trying to
+  # omit less important parts of the query, and only then cutting off the end.
+  def truncate(max_length)
+    output = deparse(parsetree)
+
+    # Early exit if we're already below the max length
+    return output if output.size <= max_length
+
+    truncations = find_possible_truncations
+
+    # Truncate the deepest possible truncation that is the longest first
+    truncations.sort_by! { |t| [-t.location.size, -t.length] }
+
+    tree = deep_dup(parsetree)
+    truncations.each do |truncation|
+      next if truncation.length < 3
+
+      find_tree_location(tree, truncation.location) do |expr, k|
+        expr[k] = { 'A_TRUNCATED' => nil }
+        expr[k] = [expr[k]] if truncation.is_array
+      end
+
+      output = deparse(tree)
+      return output if output.size <= max_length
+    end
+
+    # We couldn't do a proper smart truncation, so we need a hard cut-off
+    output[0..max_length - 4] + '...'
+  end
+
+  private
+
+  def find_possible_truncations
+    truncations = []
+
+    treewalker! parsetree do |_expr, k, v, location|
+      case k
+      when 'targetList'
+        length = deparse([{ 'SELECT' => { k => v } }]).size - 'SELECT '.size
+
+        truncations << PossibleTruncation.new(location, 'targetList', length, true)
+      when 'whereClause'
+        length = deparse([{ 'SELECT' => { k => v } }]).size
+
+        truncations << PossibleTruncation.new(location, 'whereClause', length, false)
+      when 'ctequery'
+        truncations << PossibleTruncation.new(location, 'ctequery', deparse([v]).size, false)
+      when 'cols'
+        truncations << PossibleTruncation.new(location, 'cols', deparse(v).size, true)
+      end
+    end
+
+    truncations
+  end
+end

data/lib/pg_query/version.rb

@@ -1,3 +1,3 @@
 class PgQuery
-  VERSION = '0.6.0'
+  VERSION = '0.6.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_query
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Lukas Fittl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-05 00:00:00.000000000 Z
+date: 2015-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -87,7 +87,9 @@ extensions:
 - ext/pg_query/extconf.rb
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
+- README.md
 - Rakefile
 - ext/pg_query/extconf.rb
 - ext/pg_query/pg_polyfills.c
@@ -97,11 +99,14 @@ files:
 - ext/pg_query/pg_query_normalize.c
 - ext/pg_query/pg_query_parse.c
 - lib/pg_query.rb
+- lib/pg_query/deparse.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/treewalker.rb
+- lib/pg_query/truncate.rb
 - lib/pg_query/version.rb
 homepage: http://github.com/pganalyze/pg_query
 licenses: