sqlpp 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 24d6f928aab73c2d65cf5eefc714dfac7f441641
+  data.tar.gz: df2f51ed9d6aef74270f7dfb64322154d94dc0b3
+SHA512:
+  metadata.gz: dda5183a4e28c854494b164f6a725a2e35f788c1def25f256693f557cb9cdf2a95f49915d8ceb2d6c4a3491b81634f1253c30989cd913047b90597f42e39366a
+  data.tar.gz: 980e4630ec6de08556260f31ac361366b14a250f3ee8af89d77cbbc96c734e2a4d3426d3e0e283feb9f1e3f690d2d2e71898e6fb1e17545c142c45efd24cb6c1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Jamis Buck
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,55 @@
+# SQLPP
+
+SQLPP is a simplistic SQL parser and pretty-printer.
+
+## Usage
+
+```ruby
+require 'sqlpp'
+
+sql = "..."
+ast = SQLPP::Parser.parse(sql)
+
+puts SQLPP::Formatter.new.format(ast)
+```
+
+Or, you can use the included `bin/sqlpp` script to format SQL via STDIN:
+
+```sh
+$ sqlpp < query.sql
+```
+
+## Output
+
+The formatter is not particularly sophisticated, and is optimized primarily for displaying queries with deeply nested subselects. The major query components (`FROM`, `WHERE`, `GROUP BY`, and `ORDER BY`) are printed on separate lines, with subselects indented.
+
+```sql
+SELECT a, b, sum(c)
+FROM (
+  SELECT d, e, f
+  FROM (
+    SELECT g, h, i
+    FROM table
+    WHERE id IN (1, 2, 3)
+  ) a
+  WHERE a.e = 5
+  OR a.e = 7
+) b
+WHERE b.c > 5
+GROUP BY a, b
+ORDER BY a ASC, b DESC
+```
+
+## Caveats
+
+This implementation is far, far, far from complete. It currently accepts only `SELECT` statements, and even then will only recognize a subset of the valid SQL syntax. That said, it should be a pretty big subset. It's done well enough for what I've needed it for.
+
+If, however, you find that it doesn't recognize some syntax that you need, pull requests would be appreciated!
+
+## License
+
+MIT. See `MIT-LICENSE`.
+
+## Author
+
+Jamis Buck (jamis@jamisbuck.org)

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+task default: :test
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end

data/bin/sqlpp

@@ -0,0 +1,8 @@
+#!/bin/sh ruby
+
+require 'sqlpp'
+
+sql = STDIN.read
+
+ast = SQLPP::Parser.parse(sql)
+puts SQLPP::Formatter.new.format(ast)

data/lib/sqlpp/ast.rb

@@ -0,0 +1,30 @@
+module SQLPP
+  module AST
+    class Select < Struct.new(:projections, :froms, :wheres, :groups, :orders)
+    end
+
+    class Expr < Struct.new(:left, :op, :right)
+    end
+
+    class Unary < Struct.new(:op, :expr)
+    end
+
+    class Atom < Struct.new(:type, :left, :right)
+    end
+
+    class Parens < Struct.new(:value)
+    end
+
+    class As < Struct.new(:name, :expr)
+    end
+
+    class Alias < Struct.new(:name, :expr)
+    end
+
+    class Join < Struct.new(:type, :left, :right, :on)
+    end
+
+    class SortKey < Struct.new(:key, :options)
+    end
+  end
+end

data/lib/sqlpp/formatter.rb

@@ -0,0 +1,163 @@
+module SQLPP
+  class Formatter
+    def initialize
+      @indent = nil
+      @state = nil
+    end
+
+    def format(node)
+      name = node.class.to_s.split(/::/).last
+      send(:"_format_#{name}", node)
+    end
+
+    def _format_Select(node)
+      output = ""
+
+      if @indent.nil?
+        @indent = 0
+      else
+        @indent += 2
+        output << "\n"
+      end
+
+      output << "#{_indent}SELECT "
+      output << node.projections.map { |c| format(c) }.join(", ")
+      output << "\n"
+
+      if node.froms
+        output << "#{_indent}FROM "
+        output << node.froms.map { |c| format(c) }.join(", ")
+        output << "\n"
+      end
+
+      if node.wheres
+        save, @state = @state, :where
+        output << "#{_indent}WHERE "
+        output << format(node.wheres)
+        output << "\n"
+        @state = save
+      end
+
+      if node.groups
+        output << "#{_indent}GROUP BY "
+        output << node.groups.map { |c| format(c) }.join(", ")
+        output << "\n"
+      end
+
+      if node.orders
+        output << "#{_indent}ORDER BY "
+        output << node.orders.map { |c| format(c) }.join(", ")
+        output << "\n"
+      end
+
+      @indent -= 2
+      @indent = nil if @indent < 0
+
+      output << _indent
+    end
+
+    def _format_Expr(node)
+      output = format(node.left)
+      if node.op
+        op = node.op.to_s.upcase
+
+        if @state == :where && %w(AND OR).include?(op)
+          output << "\n#{_indent}"
+        else
+          output << " "
+        end
+
+        output << op << " "
+        output << format(node.right)
+      end
+      output
+    end
+
+    def _format_Unary(node)
+      op = node.op.to_s.upcase
+      output = op
+      output << " " if op =~ /\w/
+      output << format(node.expr)
+    end
+
+    def _format_Atom(node)
+      output = ""
+
+      case node.type
+        when :range
+          output << format(node.left) << " AND " << format(node.right)
+        when :list
+          output << "(" << node.left.map { |c| format(c) }.join(", ") << ")"
+        when :func
+          output << format(node.left) << "("
+          output << node.right.map { |c| format(c) }.join(", ")
+          output << ")"
+        when :lit
+          output << node.left
+        when :attr
+          output << node.left
+          output << "." << node.right if node.right
+        when :case
+          output << "CASE "
+          output << format(node.left) << " " if node.left
+          node.right.each do |child|
+            if child.is_a?(Array)
+              output << "WHEN " << format(child[0]) << " "
+              output << "THEN " << format(child[1]) << " "
+            else
+              output << "ELSE " << format(child) << " "
+            end
+          end
+          output << "END"
+        else
+          raise ArgumentError, "unknown atom type #{node.type.inspect}"
+      end
+
+      output
+    end
+
+    def _format_Parens(node)
+      "(" + format(node.value) + ")"
+    end
+
+    def _format_As(node)
+      format(node.expr) + " AS " + format(node.name)
+    end
+
+    def _format_Alias(node)
+      format(node.expr) + " " + format(node.name)
+    end
+
+    def _format_Join(node)
+      output = ""
+
+      output << format(node.left)
+      output << "\n#{_indent}"
+      output << node.type.upcase << " JOIN "
+      output << format(node.right)
+      output << "\n#{_indent}ON " << format(node.on) if node.on
+
+      output
+    end
+
+    def _format_SortKey(node)
+      output = ""
+      output << format(node.key)
+
+      if node.options.any?
+        output << " "
+        output << node.options.map { |opt| opt.upcase }.join(", ")
+      end
+
+      output
+    end
+
+    def _format_String(string)
+      string
+    end
+
+    def _indent
+      " " * (@indent || 0)
+    end
+  end
+end