seaquel 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f51aa6cb26dbabeed5e62e1544877377b44090bc
+  data.tar.gz: 982a28e72454c041dd21129416c7def66b95ff32
+SHA512:
+  metadata.gz: d50b0346f4288a0974d2b0364b3f6596cde261fbcb126662a3aaf9f92fcd5c0255d688c5707afcf2b0d6d4639861427172aac652c20ed5347667175904c97290
+  data.tar.gz: cb41ddc3e7e14f77ab0f0774660fc66a414c5c6c4a4f02e7d42ad205a5ac1a5c6e32d08f48a88ea2c2a8189d6eaa1e9e12d338365a11ed6870791962ac1cef2f

data/FEATURES

@@ -0,0 +1,5 @@
+
+# SELECT
+
+SELECT * FROM table WHERE 1=2
+SELECT 1, 2, 3

data/LICENSE

@@ -0,0 +1,23 @@
+
+ Copyright (c) 2015 Kaspar Schiess
+
+ 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

@@ -0,0 +1,25 @@
+A simple SQL generation DSL. 
+
+SYNOPSIS
+
+    include Seaquel
+    select.from(table('foobar')).where(column('name').equal('baz')).to_sql
+      # => %Q(SELECT * FROM "foobar" WHERE "name"='baz')
+
+DESCRIPTION
+
+Allows generating SQL from a Ruby DSL. Geared towards the rich possibilities of
+PostgreSQL, this library can generate standard SQL as well. 
+
+Please also have a look at flounder, Seaquels friendly companion - located one
+layer higher up our SQL stack, it automates much of the work you'll be doing
+when you use Seaquel. 
+
+STATUS
+
+Early alpha
+
+WHY
+
+Because nothing really worked at the time we wrote this. Really. We looked. 
+

data/lib/seaquel.rb

@@ -0,0 +1,13 @@
+
+module Seaquel
+end
+
+require 'seaquel/quoter'
+require 'seaquel/ast'
+
+require 'seaquel/statement'
+require 'seaquel/statement_gatherer'
+require 'seaquel/generator'
+
+require 'seaquel/module'
+

data/lib/seaquel/ast.rb

@@ -0,0 +1,19 @@
+
+module Seaquel::AST
+end
+
+require 'seaquel/ast/node'
+require 'seaquel/ast/bin_op'
+require 'seaquel/ast/join_op'
+require 'seaquel/ast/assign'
+require 'seaquel/ast/alias'
+require 'seaquel/ast/list'
+require 'seaquel/ast/column_list'
+require 'seaquel/ast/column'
+require 'seaquel/ast/table'
+require 'seaquel/ast/literal'
+require 'seaquel/ast/immediate'
+require 'seaquel/ast/binding'
+require 'seaquel/ast/funcall'
+require 'seaquel/ast/table_alias'
+require 'seaquel/ast/order'

data/lib/seaquel/ast/alias.rb

@@ -0,0 +1,15 @@
+
+module Seaquel::AST
+  class Alias
+    attr_reader :name, :expression
+
+    def initialize name, expression
+      @name = name
+      @expression = expression
+    end
+
+    def visit visitor
+      visitor.visit_alias(name, expression)
+    end
+  end
+end

data/lib/seaquel/ast/assign.rb

@@ -0,0 +1,17 @@
+module Seaquel::AST
+  # Assignment of right to left. 
+  # This class can be visited.
+  #
+  class Assign
+    attr_reader :left, :right
+
+    def initialize left, right
+      @left, @right = left, right
+    end
+
+    def visit visitor
+      visitor.visit_assign(left, right)
+    end
+  end
+end
+

data/lib/seaquel/ast/bin_op.rb

@@ -0,0 +1,21 @@
+
+module Seaquel::AST
+  # A binary statement as in left=right. 
+  # This class can be visited.
+  #
+  class BinOp
+    attr_reader :op, :left, :right
+    
+    def initialize op, left, right
+      @op, @left, @right = op, left, right
+    end
+
+    def visit visitor
+      visitor.visit_binop(op, left, right)
+    end
+
+    def inspect 
+      "(" + ['bin_op', op.inspect, left.inspect, right.inspect].join(' ') + ")"
+    end
+  end
+end

data/lib/seaquel/ast/binding.rb

@@ -0,0 +1,20 @@
+
+require_relative 'expression'
+
+module Seaquel::AST
+  class Binding < Expression
+    attr_reader :pos
+
+    def initialize pos
+      @pos = pos
+    end
+
+    def visit visitor
+      visitor.visit_binding pos.to_s
+    end
+
+    def inspect
+      "(bind #{pos})"
+    end
+  end
+end

data/lib/seaquel/ast/column.rb

@@ -0,0 +1,50 @@
+
+require_relative 'expression'
+
+module Seaquel::AST
+  class Column < Expression
+    attr_reader :name
+    attr_reader :table
+
+    def initialize name, table=nil
+      @name = name
+      @table = table
+    end
+
+    # Set the column to value. 
+    #
+    def to value
+      Assign.new(self, value)
+    end
+
+    # Visits the column as part of sql generation. 
+    #
+    def visit visitor
+      visitor.visit_column self
+    end
+
+    # Returns an SQL column reference, including the table name. 
+    #
+    def as_full_reference quoter
+      parts = []
+
+      if table
+        parts << table.as_column_prefix(quoter)
+      end
+
+      parts << as_column_reference(quoter)
+
+      parts.join('.')
+    end
+
+    # Returns an SQL column reference, excluding table name. 
+    #
+    def as_column_reference quoter
+      quoter.column(name)
+    end
+
+    def inspect
+      "(column #{name})"
+    end
+  end
+end

data/lib/seaquel/ast/column_list.rb

@@ -0,0 +1,11 @@
+
+module Seaquel::AST
+  # Special case of a column list that needs to be formatted without table
+  # references.
+  #
+  class ColumnList < List
+    def visit visitor
+      visitor.visit_column_list(list)
+    end
+  end
+end

data/lib/seaquel/ast/expression.rb

@@ -0,0 +1,35 @@
+
+module Seaquel::AST
+  # Base class for all expression-type AST nodes. 
+  #
+  class Expression
+    def self.binop op
+      define_method(op) do |exp|
+        BinOp.new(op, self, exp)
+      end
+    end
+
+    binop :eq
+    binop :noteq
+    
+    binop :lt
+    binop :lteq
+
+    binop :gt
+    binop :gteq
+
+    binop :is
+    binop :isnot
+
+    def as name
+      Alias.new(name, self)
+    end
+
+    def asc
+      Order.new(:asc, self)
+    end
+    def desc
+      Order.new(:desc, self)
+    end
+  end
+end

data/lib/seaquel/ast/funcall.rb

@@ -0,0 +1,17 @@
+
+require_relative 'expression'
+
+module Seaquel::AST
+  class Funcall < Expression
+    attr_reader :name, :args
+
+    def initialize name, args
+      @name = name
+      @args = args
+    end
+
+    def visit visitor
+      visitor.visit_funcall(name, args)
+    end
+  end
+end

data/lib/seaquel/ast/immediate.rb

@@ -0,0 +1,16 @@
+
+require_relative 'expression'
+
+module Seaquel::AST
+  class Immediate < Expression
+    attr_reader :val
+
+    def initialize ruby_val
+      @val = ruby_val
+    end
+
+    def visit visitor
+      visitor.visit_immediate val.to_s
+    end
+  end
+end

data/lib/seaquel/ast/join_op.rb

@@ -0,0 +1,29 @@
+module Seaquel::AST
+  # A binary operation that can be used to join things together,  like 'AND' or
+  # 'OR'.
+  #
+  class JoinOp
+    attr_reader :op
+    attr_reader :elements
+
+    def initialize op, elements=[]
+      @op, @elements = op, elements
+    end
+
+    def concat element
+      elements << element
+    end
+
+    def empty?
+      elements.empty?
+    end
+
+    def visit visitor
+      visitor.visit_joinop(op, elements)
+    end
+
+    def inspect
+      [:join_op, op, *elements].inspect
+    end
+  end
+end

data/lib/seaquel/ast/list.rb

@@ -0,0 +1,25 @@
+
+require 'forwardable'
+
+module Seaquel::AST
+  class List
+    extend Forwardable
+
+    attr_reader :list
+
+    def initialize initial=[]
+      @list = initial
+    end
+
+    # Behaves array-like in many respects
+    def_delegators :@list, :empty?, :concat, :size, :<<, :map, :replace
+
+    def visit visitor
+      visitor.visit_list(list)
+    end
+
+    def inspect
+      '[' + list.map { |e| e.inspect }.join(', ') + ']'
+    end
+  end
+end

data/lib/seaquel/ast/literal.rb

@@ -0,0 +1,16 @@
+
+require_relative 'expression'
+
+module Seaquel::AST
+  class Literal < Expression
+    attr_reader :text
+
+    def initialize text
+      @text = text
+    end
+
+    def visit visitor
+      visitor.visit_literal(text)
+    end
+  end
+end

data/lib/seaquel/ast/node.rb

@@ -0,0 +1,109 @@
+module Seaquel::AST
+  # A general purpose node containing a node type and a list of arguments. 
+  # The node stores a link to its parent or nil if no such parent exists. 
+  # This class can be visited.
+  #
+  class Node
+    attr_reader :type
+    attr_reader :parent
+    attr_reader :args
+
+    def initialize *args
+      if args.first.kind_of?(Symbol)
+        @type, *@args = args
+      else
+        @parent, @type, *@args = args
+      end
+    end
+
+    # Replaces previous projection list with this one. 
+    #
+    # @param list [Array<Column>]
+    # @return [Node] node for chaining
+    #
+    def project *fields
+      node(:project, fields)
+    end
+
+    def from *tables
+      node(:from, *tables)
+    end
+
+    def where *exps
+      node(:where, JoinOp.new(:and, exps))
+    end
+
+    def set *assign_list
+      node(:set, assign_list)
+    end
+
+    def join *tables
+      node(:join, tables)
+    end
+    def on *exps
+      node(:on, exps)
+    end
+
+    def limit n
+      node(:limit, n)
+    end
+    def offset n
+      node(:offset, n)
+    end
+
+    # Replaces previous ORDER BY specification with this one. 
+    #
+    # @param list [Array<Column>]
+    # @return [Node] node for chaining
+    #
+    def order_by *list
+      node(:order_by, list)
+    end
+
+    # INSERT INTO ... (FIELDS) VALUES (...)
+    def fields *list
+      node(:fields, list)
+    end
+    
+    # Adds a values list to an INSERT statement. You have to pass all the columns
+    # at once; repeating this method call will create an INSERT statement that
+    # inserts multiple rows at once (a Postgres extension).
+    #
+    # Example: 
+    #   include Seaquel
+    #   insert.into(table('foo')).values(immediate(1), immediate(2))
+    #   # => INSERT INTO "foo" VALUES (1, 2)
+    #
+    # @param list [Array<AST::Expression>] values to insert
+    # @return [AST::Node] query you are building
+    # 
+    def values *list
+      node(:values, list)
+    end
+
+    def into table
+      node(:into, table)
+    end
+
+    def node *args
+      self.class.new(self, *args)
+    end
+
+    def visit visitor
+      method_name = "visit_#{type}"
+      if visitor.respond_to?(:visit_node)
+        visitor.visit_node(self)
+      else
+        visitor.send(method_name, parent, *args)
+      end
+    end
+
+    def to_sql
+      ::Seaquel::Generator.new(self).compact_sql
+    end
+
+    def inspect
+      [type, args, parent].inspect
+    end
+  end
+end