seaquel 0.1

data/lib/seaquel/statement/join.rb

@@ -0,0 +1,36 @@
+
+
+module Seaquel
+  class Statement
+    # A join clause inside an SQL statement. 
+    class Join
+      attr_reader :tables
+      attr_reader :ons
+
+      def initialize tables
+        @tables = AST::List.new(tables)
+
+        @ons = AST::JoinOp.new(:and, [])
+      end
+
+      def on exps
+        ons.concat(*exps)
+      end
+
+      # Turns a join statement into SQL by invoking conversion_helper on the
+      # right parts.
+      #
+      # @param conversion_helper [#convert] instance of a class that implements
+      #   a #convert method that turns expressions into SQL. 
+      # @return [String] SQL string for this join
+      #
+      def convert conversion_helper
+        parts = []
+        parts << 'INNER JOIN'
+        parts << conversion_helper.convert(tables)
+        parts << 'ON'
+        parts << conversion_helper.convert(ons)
+      end
+    end
+  end
+end

data/lib/seaquel/statement_gatherer.rb

@@ -0,0 +1,119 @@
+
+module Seaquel
+  # Visits a statement AST and issues a statement. 
+  class StatementGatherer
+    extend Forwardable
+
+    attr_reader :current_join
+
+    def initialize statement, quoter
+      @statement = statement
+      @quoter = quoter
+      @current_join = nil
+    end
+
+    def_delegator :@quoter, :table, :quote_table
+
+    def visit_from parent, *args
+      s.from.concat(args)
+
+      continue(parent)
+    end
+    def visit_select parent
+      continue(parent)
+    end
+    def visit_project parent, fields
+      continue(parent)
+
+      # Since the tree is processed in lifo order, we need to only apply the
+      # very last project. 
+      s.project.replace(fields)
+    end
+    def visit_order_by parent, list
+      continue(parent)
+
+      s.order_by.replace(list)
+    end
+    def visit_where parent, expression
+      continue(parent)
+
+      s.where.concat(expression)
+    end
+
+    def visit_update parent, table
+      continue(parent)
+
+      s.set_type(:update)
+      s.set_target(table)
+    end
+    def visit_set parent, assign_list
+      continue(parent)
+
+      s.set.concat(assign_list)
+    end
+
+    def visit_join parent, tables
+      continue(parent)
+
+      @current_join = s.join(tables)
+    end
+    def visit_on(parent, exps)
+      continue(parent)
+
+      raise InvalidExpression, ".on without a .join encoutered" \
+        unless current_join
+      
+      current_join.on(exps)
+    end
+
+    def visit_insert parent
+      continue(parent)
+
+      s.set_type(:insert)
+    end
+    def visit_into parent, table
+      continue(parent)
+
+      s.set_target(table)
+    end
+    def visit_values parent, values
+      continue(parent)
+
+      s.values << AST::List.new(values)
+    end
+    def visit_fields parent, fields
+      continue(parent)
+
+      s.fields.concat(fields)
+    end
+
+    def visit_delete parent
+      continue(parent)
+
+      s.set_type(:delete)
+    end
+
+    def visit_offset parent, n
+      continue(parent)
+
+      s.set_offset(n)
+    end
+    def visit_limit parent, n
+      continue(parent)
+
+      s.set_limit(n)
+    end
+
+  private
+    # A shorthand for saying that node needs to be visited.
+    #
+    def continue node
+      node.visit(self) if node
+    end
+
+    # A short-cut for the code in here.
+    def s
+      @statement
+    end
+  end
+end

data/qed/applique/ae.rb

@@ -0,0 +1 @@
+require 'ae'

data/qed/applique/sql.rb

@@ -0,0 +1,2 @@
+
+require 'seaquel'

data/qed/generation.md

@@ -0,0 +1,103 @@
+
+# Overview
+
+This library deals with generation of valid SQL. What one would like to have is
+a programmatic interface to SQL that allows to create a query and turn it into
+SQL.
+
+~~~ruby
+  include Seaquel # to avoid having to write Seaquel.select - optional
+
+  select.from(table('foobar')).where(column('name').eq('baz')).
+    to_sql # => %Q(SELECT * FROM "foobar" WHERE "name"='baz')
+~~~
+
+As can be seen from the above snippet, SQL construction uses a DSL that is functional in nature. The DSL needs to support all kinds of constructs and cover a broad range of SQL syntax. 
+
+~~~ruby
+  update(table('bar')).set(literal('a=1'), column('b').to(2)).
+    to_sql # => %Q(UPDATE "bar" SET a=1, "b"=2)
+~~~
+
+~~~ruby
+  insert.fields(column('a'), column('b')).values('1', 2).
+    into(table('baz')).
+    to_sql # => %Q(INSERT INTO "baz" ("a", "b") VALUES ('1', 2))
+~~~
+
+~~~ruby
+  delete.from(table('baz')).
+    where(column('a').eq(1)).
+    join(table('bar')).on(column('b').eq(column('c'))).
+    to_sql # => %Q(DELETE FROM "baz" INNER JOIN "bar" ON "b"="c" WHERE "a"=1)
+~~~
+
+As you can see, method invocation can be in any order and the generator figures out what you mean.
+
+# Different Types of JOINs
+
+# Positional (Binding) Parameters
+
+To bind a value in your client, use the `binding(position)` macro. The returned object can be treated as part of an expression. 
+
+~~~ruby
+  select.where(column('a').eq(binding(1))).
+    to_sql # => %Q(SELECT * WHERE "a"=$1)
+~~~
+
+# SQL Function Calls
+
+To formulate something like `SELECT string_agg(a) FROM table`, you need to be able to generate function calls. 
+
+~~~ruby
+  select.project(funcall('string_agg', column(:a))).from(table(:table)).
+    to_sql # => %Q(SELECT string_agg("a") FROM "table")
+~~~
+
+The funcall method call can be wrapped inside a Ruby function, yielding a quite natural interface: 
+
+~~~ruby
+  def string_agg col
+    funcall('string_agg', column(col))
+  end
+  
+  select.project(string_agg(:a)).from(table(:table)).
+    to_sql # => %Q(SELECT string_agg("a") FROM "table")
+~~~
+
+# SELECT
+
+Here's how you access columns from a given table. 
+
+~~~ruby
+  users = table('users')
+  select.project(users['id'], users['name']).from(users).
+    to_sql # => %Q(SELECT "users"."id", "users"."name" FROM "users")
+~~~
+
+Also, table aliases are possible and can shorten the issued statements quite a bit.
+
+~~~ruby
+  users = table('users').as('u')
+  select.project(users['id'], users['name']).from(users).
+    to_sql # => %Q(SELECT "u"."id", "u"."name" FROM "users" AS "u")
+~~~
+
+Here's how you set an offset and a limit.
+
+~~~ruby
+  select.limit(5).offset(3).
+    to_sql # => %Q(SELECT * OFFSET 3 LIMIT 5)
+~~~
+
+
+# INSERT
+
+PostgreSQL allows inserting multiple rows at once:
+
+~~~ruby
+  insert.into(table('foo')).fields(column('a'), column('b')).
+    values(1, 2).
+    values(2, 3).
+    to_sql # => %Q(INSERT INTO "foo" ("a", "b") VALUES (1, 2), (2, 3))
+~~~

data/spec/functional/delete_spec.rb

@@ -0,0 +1,19 @@
+
+require 'spec_helper'
+
+describe 'DELETE statements' do
+  include Seaquel
+
+  it 'basic' do
+    delete.from(table('bar')).generates <<-SQL
+      DELETE FROM "bar"
+    SQL
+  end
+  it 'initial example from QED' do
+    delete.
+      from(table('baz')).where(column('a').eq(1)).
+      join(table('bar')).on(column('b').eq(column('c'))).generates <<-SQL
+        DELETE FROM "baz" INNER JOIN "bar" ON "b"="c" WHERE "a"=1 
+      SQL
+  end
+end

data/spec/functional/insert_spec.rb

@@ -0,0 +1,31 @@
+
+require 'spec_helper'
+
+describe 'INSERT statements' do
+  include Seaquel
+
+  it 'basic functionality' do
+    insert.into(table('foo')).generates <<-SQL
+      INSERT INTO "foo"
+    SQL
+  end
+  it 'an actual statement' do
+    insert.
+      fields(column('a'), column('b')).
+      values('1', 2).into(table('baz')).
+      generates <<-SQL
+        INSERT INTO "baz" ("a", "b") VALUES ('1', 2)
+      SQL
+  end
+  it 'omitting the fields part' do
+    insert.values(1, 2).into(table('bar')).generates <<-SQL
+      INSERT INTO "bar" VALUES (1, 2)
+    SQL
+  end
+  it 'allows usage of columns linked to a table' do
+    foo = table('foo')
+    insert.into(foo).fields(foo['bar']).values(1).generates <<-SQL
+      INSERT INTO "foo" ("bar") VALUES (1)
+    SQL
+  end
+end

data/spec/functional/select_spec.rb

@@ -0,0 +1,99 @@
+
+require 'spec_helper'
+
+describe 'SELECT statements' do
+  include Seaquel
+
+  it 'allows FROM clause' do
+    select.from(table('foo')).generates <<-SQL
+      SELECT * FROM "foo"
+    SQL
+  end
+  it 'allows bare selection' do
+    select.project(1).generates <<-SQL
+      SELECT 1
+    SQL
+  end
+  it 'allows bare selection list' do
+    select.project(1, 2, 3).generates <<-SQL
+      SELECT 1, 2, 3
+    SQL
+  end
+
+  describe '#join' do
+    it 'allows joining tables (INNER JOIN being the default)' do
+      foo = table(:foo)
+      bar = table(:bar)
+      select.from(foo).join(bar).on(foo[:id].eq(bar[:foo_id])).generates <<-SQL
+        SELECT * FROM "foo" INNER JOIN "bar" ON "foo"."id"="bar"."foo_id"
+      SQL
+    end
+  end
+  describe '#order_by' do
+    it 'allows ordering the query' do
+      select.order_by(column(:a)).generates <<-SQL
+        SELECT * ORDER BY "a"
+        SQL
+    end
+    it 'overrides previous order_bys' do
+      select.order_by(column(:a)).order_by(column(:b)).generates <<-SQL
+        SELECT * ORDER BY "b"
+      SQL
+    end
+  end
+  describe '#project' do
+    it 'allows expressions in project' do
+      select.project(literal(1).as('one')).generates <<-SQL
+        SELECT 1 AS "one"
+      SQL
+    end
+    it 'overwrites any earlier projects (for flexibility)' do
+      select.project(column('a')).project(column('b')).generates <<-SQL
+        SELECT "b"
+      SQL
+    end
+  end
+  describe '#where' do
+    it 'allows simple literal WHERE clause' do
+      select.where(literal('1=2')).generates <<-SQL
+        SELECT * WHERE 1=2
+      SQL
+    end
+    it 'joins literals with correct precedence' do
+      select.where(literal('1=2'), literal('2=3')).generates <<-SQL
+        SELECT * WHERE 1=2 AND 2=3
+      SQL
+    end
+    it 'allows more complex WHERE clause' do
+      select.where(column('name').eq('baz')).generates <<-SQL
+        SELECT * WHERE "name"='baz'
+      SQL
+    end
+
+    describe 'subselects' do
+      it 'are allowed' do
+        sub = select.
+          from(table('foo')).
+          project(column('id')).
+          where(column('count').gt(10))
+
+        select.from(table("bar")).where(column('id').eq(sub)).generates <<-SQL
+          SELECT * FROM "bar" WHERE "id"=(SELECT "id" FROM "foo" WHERE "count">10) 
+        SQL
+      end
+    end
+
+    describe 'multiple where() calls' do
+      it 'are joined using AND' do
+        select.where(true).where(false).generates <<-SQL
+          SELECT * WHERE TRUE AND FALSE
+        SQL
+      end
+      it 'are joined using AND (arglist)' do
+        select.where(true, false).generates <<-SQL
+          SELECT * WHERE TRUE AND FALSE
+        SQL
+      end
+    end
+  end
+end

data/spec/functional/update_spec.rb

@@ -0,0 +1,30 @@
+
+require 'spec_helper'
+
+describe 'UPDATE statements' do
+  include Seaquel
+
+  it 'can be used' do
+    update(table('bar')).set(column('foo').to(immediate(1))).generates <<-SQL
+      UPDATE "bar" SET "foo"=1
+    SQL
+  end
+  it 'set statements can be chained' do
+    update(table('bar')).
+      set(column('foo').to(immediate(1))).
+      set(column('bar').to(immediate(2))).generates <<-SQL
+      UPDATE "bar" SET "foo"=1, "bar"=2
+    SQL
+  end
+  it 'works using the table[column] syntax' do
+    foo = table('foo')
+    update(foo).set(foo['bar'].to(1)).generates <<-SQL
+      UPDATE "foo" SET "bar"=1
+    SQL
+  end
+  it 'allows WHERE clauses' do
+    update(table('foo')).where(column('id').eq(1)).generates <<-SQL
+      UPDATE "foo" WHERE "id"=1
+    SQL
+  end
+end