seaquel 0.1

data/lib/seaquel/ast/order.rb

@@ -0,0 +1,16 @@
+
+
+module Seaquel::AST
+  class Order
+    attr_reader :order, :column
+
+    def initialize order, column
+      @order = order
+      @column = column
+    end
+
+    def visit visitor
+      visitor.visit_order(order, column)
+    end
+  end
+end

data/lib/seaquel/ast/table.rb

@@ -0,0 +1,36 @@
+module Seaquel::AST
+  class Table
+    attr_reader :name
+
+    def initialize name
+      @name = name
+    end
+
+    def visit visitor
+      visitor.visit_table(self)
+    end
+
+    def quote quoter
+      quoter.table(name)
+    end
+
+    # Returns a table column.
+    #
+    def [] col_name
+      Column.new(col_name, self)
+    end
+
+    # Returns a table alias. 
+    #
+    def as name
+      TableAlias.new(self, name)
+    end
+
+    # Returns the identifier that designates the table uniquely in the query
+    # as a prefix for column references. ("foo"."a")
+    #
+    def as_column_prefix quoter
+      quote(quoter)
+    end
+  end
+end

data/lib/seaquel/ast/table_alias.rb

@@ -0,0 +1,24 @@
+
+module Seaquel::AST
+  class TableAlias
+    attr_reader :table
+    attr_reader :name
+
+    def initialize table, name
+      @table = table
+      @name = name
+    end
+
+    def [] col_name
+      Column.new(col_name, self)
+    end
+
+    def visit visitor
+      visitor.visit_table_alias table, name
+    end
+
+    def as_column_prefix quoter
+      quoter.identifier(name)
+    end
+  end
+end

data/lib/seaquel/bit.rb

@@ -0,0 +1,34 @@
+
+
+module Seaquel
+
+  # Represents a small bit of an SQL expression. 
+  #
+  class Bit
+    attr_reader :str
+    attr_reader :precedence
+
+    def initialize str, precedence
+      @str = str
+      @precedence = precedence
+    end
+
+    # Returns a string at given target_precedence. If the precedence of this 
+    # bit is lower than target_precedence, it will not be put in parenthesis.
+    #
+    def at target_precedence
+      if precedence != :inf && target_precedence >= precedence
+        @str
+      else
+        "(#{@str})"
+      end
+    end
+
+    # Returns the SQL that you would insert toplevel, meaning at a level where
+    # parens aren't needed anymore. 
+    #
+    def toplevel
+      str
+    end
+  end
+end

data/lib/seaquel/expression_converter.rb

@@ -0,0 +1,181 @@
+require_relative 'bit'
+
+module Seaquel
+  class ExpressionConverter
+    extend Forwardable
+
+    attr_reader :quoter
+    attr_reader :symbols
+
+    def initialize quoter
+      @quoter = quoter
+      @symbols = {
+        :eq   => '=',
+        :gt   => '>', 
+        :gteq => '>=', 
+        :lt   => '<', 
+        :lteq => '<=', 
+        :is   => ' IS ', 
+        :isnot => ' IS NOT ', 
+        :noteq => '!='
+      }
+    end
+
+    # Gets called whenever the expression contains a statement-type AST::Node. 
+    #
+    def visit_node node
+      bit(node.to_sql, :inf)
+    end
+
+    def_delegator :@quoter, :string, :quote_string
+    def_delegator :@quoter, :number, :quote_number
+
+    def visit_assign left, right
+      if left.kind_of? AST::Column
+        bit(
+          [left.as_column_reference(quoter), '=', sql(right).at(0)].join)
+      else
+        bit(
+          [sql(left).at(0), '=', sql(right).at(0)].join)
+      end
+    end
+
+    def visit_immediate sql_val
+      bit(sql_val)
+    end
+
+    def visit_new_statement *args
+      ::Seaquel::Generator.new(self).compact_sql
+    end
+
+    def visit_literal literal
+      bit(literal)
+    end
+
+    def visit_list elements
+      bit(elements.map { |e| sql(e).at(0) }.join(', '))
+    end
+
+    def visit_column_list elements
+      # Column lists only contain columns.
+      bit(elements.map { |e| e.as_column_reference(quoter) }.join(', '))
+    end
+
+    def visit_table table
+      bit(table.quote(quoter))
+    end
+
+    def visit_table_alias table, name
+      bit([
+        sql(table).at(0), 
+        "AS", 
+        quoter.identifier(name)
+        ].join(' '))
+    end
+
+    def visit_alias name, to
+      prec = precedence(:as)
+      bit("#{sql(to).at(prec)} AS \"#{name}\"")
+    end
+
+    def visit_binop op, left, right
+      prec = precedence(op)
+
+      if right.nil?
+        op = :is if op==:eq
+        op = :isnot if op==:noteq
+      end
+
+      if symbols.has_key?(op)
+        symbol = symbols[op]
+        return bit(
+          [sql(left).at(prec), symbol, sql(right).at(prec)].join, 
+          prec)
+      end
+
+      raise "No such operation (#{op.inspect})."
+    end
+
+    def visit_joinop op, exps
+      # Shortcut if we join one element only. 
+      if exps.size == 1
+        el = exps.first
+        return sql(el)
+      end
+
+      prec = precedence(op)
+      parts = exps.map { |e| sql(e).at(prec) }
+
+      sql = case op
+        when :and
+          parts.join(' AND ')
+      end
+
+      bit(sql, prec)
+    end
+
+    def visit_column col
+      bit(col.as_full_reference(quoter))
+    end
+
+    def visit_binding pos
+      bit("$#{pos}")
+    end
+
+    def visit_funcall name, args
+      arglist = args.map { |arg| sql(arg).toplevel }.join(', ')
+      bit("#{name}(#{arglist})")
+    end
+
+    def visit_order order, expr
+      bit("#{sql(expr).at(0)} #{order.upcase}")
+    end
+
+    def sql node
+      # p [:sql, node]
+      case node
+        when nil
+          bit('NULL')
+        when String
+          bit(quote_string(node))
+        when Fixnum
+          bit(quote_number(node))
+        when true,false
+          node ? bit('TRUE') : bit('FALSE')
+      else
+        node.visit(self)
+      end
+    end
+
+  private
+    def bit str, precedence=0
+      Bit.new(str, precedence)
+    end
+
+    def precedence op
+      precedences[op]
+    end
+
+    def precedences
+      @precedences ||= begin
+        prec = 1 # 0 reserved for simple values
+        precs = Hash.new(0)
+
+        assign = -> (*list) {
+          list.map { |e| precs[e] = prec }
+          prec += 1
+        }
+        
+        # By listing something above something else, it gets a lower precedence
+        # assigned. List from lower to higher precedences. Equivalence classes
+        # by extending the argument list.
+        assign[:as, :is, :isnot]
+        assign[:or]
+        assign[:and]
+        assign[:eq, :gt, :gteq, :lt, :lteq]
+
+        precs
+      end
+    end
+  end
+end

data/lib/seaquel/generator.rb

@@ -0,0 +1,29 @@
+
+require 'forwardable'
+
+require 'seaquel/expression_converter'
+
+module Seaquel
+  class Generator
+    def initialize ast
+      @ast = ast
+    end
+
+    def compact_sql
+      quoter = Quoter.new
+     
+      # Construct a statement 
+      expression_converter = ExpressionConverter.new(quoter)
+      statement = Statement.new(expression_converter)
+
+      # And a visitor for the AST
+      visitor = StatementGatherer.new(statement, quoter)
+
+      # Gather statement details from the AST
+      @ast.visit(visitor)
+
+      # Turn the statement into SQL.
+      statement.to_s(:compact)
+    end
+  end
+end

data/lib/seaquel/module.rb

@@ -0,0 +1,39 @@
+
+
+module Seaquel
+  module_function
+
+  def select
+    AST::Node.new(:select)
+  end
+  def update table
+    AST::Node.new(:update, table)
+  end
+  def insert
+    AST::Node.new(:insert)
+  end
+  def delete
+    AST::Node.new(:delete)
+  end
+
+  def column name
+    AST::Column.new(name)
+  end
+
+  def table name
+    AST::Table.new(name)
+  end
+
+  def literal text
+    AST::Literal.new(text)
+  end
+  def immediate ruby_obj
+    AST::Immediate.new(ruby_obj)
+  end
+  def binding position
+    AST::Binding.new(position)
+  end
+  def funcall name, *args
+    AST::Funcall.new(name, args)
+  end
+end

data/lib/seaquel/quoter.rb

@@ -0,0 +1,23 @@
+module Seaquel
+  class Quoter
+    def table name
+      identifier(name)
+    end
+
+    def column name
+      %Q("#{name}")
+    end
+
+    def string str
+      "'" + str.gsub("'", "''") + "'"
+    end
+
+    def number num
+      num.to_s
+    end
+
+    def identifier name
+      %Q("#{name}")
+    end
+  end
+end

data/lib/seaquel/statement.rb

@@ -0,0 +1,245 @@
+
+require_relative 'statement/join'
+
+module Seaquel
+
+  # Gets raised when during the generation of SQL we discover that the statement
+  # has no valid form. 
+  #
+  class InvalidStatement < StandardError
+  end
+
+  # Root node for an sql statement. 
+  #
+  class Statement
+
+    attr_reader :expression_convertor
+
+    attr_reader :from
+    attr_reader :project
+    attr_reader :where
+    attr_reader :set
+    attr_reader :target
+    attr_reader :values
+    attr_reader :fields
+    attr_reader :joins
+    attr_reader :limit
+    attr_reader :offset
+    attr_reader :order_by
+
+    def initialize expression_convertor
+      @expression_convertor = expression_convertor
+
+      @from = list()
+      @project = list()
+      @order_by = list()
+      @where = AST::JoinOp.new(:and, [])
+      @set = list()
+      @values = list()
+      @fields = column_list()
+      @joins = []
+    end
+
+    def set_limit n
+      @limit = n
+    end
+    def set_offset n
+      @offset = n
+    end
+
+    # Allows to determine the type of statement generated. 
+    #
+    # @param type [{:update, :select, :delete}]
+    #
+    def set_type type
+      @type = type
+    end
+
+    def set_target table
+      @target = table
+    end
+
+    # Produces a join clause and adds it to the joins list. 
+    #
+    # @param tables [Array<Object>] a list of tables to join to
+    # @return [Join] Join subobject.
+    #
+    def join tables
+      join = Join.new(tables)
+      joins << join
+
+      join
+    end
+
+    def to_s variant=:compact
+      case @type 
+        when :update
+          generate_update(variant)
+        when :insert
+          generate_insert(variant)
+        when :delete
+          generate_delete(variant)
+      else
+        generate_select(variant)
+      end
+    end
+
+    # Turns an expression into SQL
+    #
+    def convert exp
+      expression_convertor.sql(exp).toplevel
+    end
+  private
+
+    # Produces an empty list. 
+    #
+    def list
+      AST::List.new
+    end
+    def column_list
+      AST::ColumnList.new
+    end
+
+    # Wraps str in parenthesises.
+    #
+    # Example: 
+    #   parens('foo') # => '(foo)'
+    def parens str
+      "(#{str})"
+    end
+
+    # Generates SQL for a DELETE statement. 
+    # 
+    def generate_delete variant
+      parts = []
+      parts << "DELETE"
+
+      unless from.empty?
+        parts << 'FROM'
+        parts << convert(from)
+      end
+
+      unless joins.empty?
+        joins.each do |join|
+          parts << join.convert(
+            self # as #convert
+          )
+        end
+      end
+
+      unless where.empty?
+        parts << 'WHERE'
+        parts << convert(where)
+      end
+
+      parts.join(' ')      
+    end
+
+    # Generates SQL for an INSERT statement. 
+    # 
+    def generate_insert variant
+      parts = []
+      parts << "INSERT"
+
+      if target
+        parts << "INTO"
+        parts << convert(target)
+      end
+
+      unless values.empty?
+        if fields.empty?
+          # If you are inserting data to all the columns, the column names can be
+          # omitted.
+          parts << 'VALUES'
+          parts << values.
+            map { |value_list| 
+              parens(convert(value_list)) }.
+            join(', ')
+        else
+          # A field list must be produced
+          # assert: !values.empty? && !fields.empty?
+
+          parts << parens(convert(fields))
+          parts << 'VALUES'
+          parts << values.
+              map { |value_list| 
+                raise InvalidStatement, "Field list in INSERT statement doesn't match value list (#{fields.size} fields and #{value_list.size} values)." \
+                  unless fields.size == value_list.size
+
+                parens(convert(value_list)) }.
+              join(', ')
+        end
+      end
+
+      parts.join(' ')
+    end
+
+    # Generates SQL for a SELECT statement. 
+    #
+    def generate_select variant
+      parts = []
+      parts << "SELECT"
+
+      if project.empty?
+        parts << '*'
+      else
+        parts << convert(project)
+      end
+
+      unless from.empty?
+        parts << 'FROM'
+        parts << convert(from) 
+      end
+
+      unless joins.empty?
+        joins.each do |join|
+          parts << join.convert(
+            self # as #convert
+          )
+        end
+      end
+
+      unless where.empty?
+        parts << 'WHERE'
+        parts << convert(where)
+      end
+
+      unless order_by.empty?
+        parts << 'ORDER BY'
+        parts << convert(order_by)
+      end
+
+      if offset
+        parts << 'OFFSET'
+        parts << convert(offset)
+      end
+
+      if limit 
+        parts << 'LIMIT'
+        parts << convert(limit)
+      end
+
+      parts.join(' ')
+    end
+
+    # Generates SQL for an UPDATE statement.
+    #
+    def generate_update variant 
+      parts = []
+      parts << 'UPDATE'
+      parts << convert(target)
+
+      unless set.empty?
+        parts << 'SET'
+        parts << convert(set)
+      end
+
+      unless where.empty?
+        parts << 'WHERE'
+        parts << convert(where)
+      end
+
+      parts.join(' ')
+    end
+  end
+end