qdsl 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b17f51187e9228065276df1168b773eb30edad75
-  data.tar.gz: cd4bdee9e1610bd6cbaba37f2d8d123d75e99804
+  metadata.gz: 3cfa45077d918ab12b58525ffdc20fda82587730
+  data.tar.gz: f52f010312f89176572fbfb903353a005a830254
 SHA512:
-  metadata.gz: 49da8e1de1dd71759acc1b66324b823c262ced79fe1a0d8de3b7cfc2c656d811445a559bed4de5f7cf4c2cc29af7b52b1724f0871934b6d657cbb0a13c5e8497
-  data.tar.gz: 742fc9b2c3ef627f1205b3a0baa2fb0e04ece7ad40a77880a2b1c2afa54dff92c7ca14a96b971892632077e70daf872eddcb1cde693ff5296fa2a53908b113c7
+  metadata.gz: e85a49678f55f66921aad11e26f73e259674befb8fa970b9734429fdf4b90f7dfef524791181190ecfa05b0b0a15f104a5ea0b4c1778653c42a338b211f64edc
+  data.tar.gz: 338110b7b6397848979cdd07323b0b28fbaa3ce86d4da6667276fe621bd12c7a5cbbe82871a06fee87dbfa377a08f6cdbc670caefeb1c53dc062d2b08eb4b1c1

data/lib/and.rb

@@ -4,12 +4,16 @@ module Qdsl
       super 'AND', exprs
     end
 
+    def to_expression
+      self
+    end
+
     def and(expr)
       And.new(@exprs + [expr])
     end
 
-    def or(expr)
-      Or.new([self, expr])
+    def true?
+      IsTrue.new(self)
     end
   end
 end

data/lib/boolean.rb

@@ -1,3 +1,5 @@
+require_relative 'expression'
+
 module Qdsl
   class Boolean < Expression
     def initialize(operator, exprs)
@@ -5,9 +7,10 @@ module Qdsl
       @exprs = exprs
     end
 
-    def render(context, ids)
+    def render_sql(context, ids)
       expr_results = @exprs.collect { |x| render_operand(context, ids, x) }
-      expr_results.collect { |x| "(#{x})" }.join(" #{@operator} ")
+      parameters = expr_results.inject({}) { |acc, x| acc.merge(x.parameters) }
+      SimpleRenderResult.new(expr_results.collect { |x| "(#{x.sql})" }.join(" #{@operator} "), parameters)
     end
   end
 end

data/lib/call.rb

@@ -0,0 +1,28 @@
+module Qdsl
+  class Call
+    attr_reader :source, :name
+
+    def initialize(source, function_name, parameters, name = nil)
+      @source = source
+      @function_name = function_name
+      @parameters = parameters
+      @name = name ? name.to_s : nil
+    end
+
+    def as(name)
+      Call.new(@source, @function_name, @parameters, name)
+    end
+
+    def exists?
+      @parameters.all? { |x| x.exists? }
+    end
+
+    def render_sql(context, id)
+      parameter_results = @parameters.collect { |x| x.render_sql(context, id) }
+      query_parameters = parameter_results.collect(&:parameters).inject({}) { |acc, x| acc.merge!(x) }
+      call = "#{@function_name}(#{parameter_results.collect(&:sql).join(', ')})"
+      SimpleRenderResult.new(@name ? "#{call} AS #{@name}" : call, query_parameters)
+    end
+  end
+end
+

data/lib/column.rb

@@ -31,8 +31,20 @@ module Qdsl
       Column.new(@name, @alias_name, source)
     end
 
-    def render(context, id)
-      @alias_name ? "#{id}.#{@name} AS #{@alias_name}" : "#{id}.#{@name}"
+    def exists?
+      @source.column_names.include?(@name)
+    end
+
+    def to_expression
+      true?
+    end
+
+    def true?
+      IsTrue.new(self)
+    end
+
+    def render_sql(context, ids)
+      SimpleRenderResult.new(@alias_name ? "#{@source.id}.#{@name} AS #{@alias_name}" : "#{@source.id}.#{@name}", {})
     end
 
     def equals(column)

data/lib/{funky_proxy.rb → column_proxy.rb}

@@ -1,5 +1,5 @@
 module Qdsl
-  class FunkyProxy
+  class ColumnProxy
     def initialize(source)
       @source = source
       source.column_names.each do |column|
@@ -12,9 +12,17 @@ module Qdsl
     end
 
     def [](name)
-      raise unless @source.column_names.include?(name.to_s)
+      raise "Unknown column \"#{name}\"" unless @source.column_names.include?(name.to_s)
       Column.new(name.to_s, nil, @source)
     end
+
+    def _call(function_name, *parameters)
+      Call.new(@source, function_name, parameters)
+    end
+
+    def _formatcall(format, *parameters)
+      FormatCall.new(@source, format, parameters)
+    end
   end
 end
 

data/lib/column_set.rb

@@ -0,0 +1,25 @@
+module Qdsl
+  class ColumnSet
+    attr_reader :columns, :block
+
+    def initialize(columns, block)
+      @columns = columns.collect { |x| Column[x] }
+      @block = block
+    end
+
+    def capture(source, join_sources)
+      sources = [source] + join_sources
+      columns = @columns.collect { |x| x.with_source(source) } + if @block
+        proxies = sources.collect { |x| ColumnProxy.new(x) }
+        [*@block.call(Util::fix_block_params(proxies))]
+      else
+        []
+      end
+
+      undefined_columns = columns.select { |x| !x.exists? }
+      raise "One or more undefined columns: #{undefined_columns.collect(&:name).join(', ')}" unless undefined_columns.empty?
+      columns
+    end
+  end
+end
+

data/lib/context.rb

@@ -1,22 +1,20 @@
 module Qdsl
   class Context
-    attr_reader :parameters
-
     def initialize
       @id_base = 0
-      @parameters = {}
+      @parameter_id_base = 0
     end
 
-    def id
+    def create_id
       result = "_#{@id_base.to_s.rjust(2, '0')}"
       @id_base += 1
       result
     end
 
-    def add_parameter(value)
-      parameter_id = "_param#{@parameters.size.to_s.rjust(2, '0')}"
-      @parameters[parameter_id] = value
-      parameter_id
+    def create_parameter_id
+      result = "_param#{@parameter_id_base.to_s.rjust(2, '0')}"
+      @parameter_id_base += 1
+      result
     end
   end
 end

data/lib/equals.rb

@@ -5,18 +5,15 @@ module Qdsl
       @column1 = column1
     end
 
-    def and(expr)
-      And.new([self, expr])
+    def to_expression
+      self
     end
 
-    def or(expr)
-      Or.new([self, expr])
-    end
-
-    def render(context, ids)
+    def render_sql(context, ids)
       column0_result = render_operand(context, ids, @column0)
       column1_result = render_operand(context, ids, @column1)
-      "#{column0_result} = #{column1_result}"
+      parameters = column0_result.parameters.merge(column1_result.parameters)
+      SimpleRenderResult.new("#{column0_result.sql} = #{column1_result.sql}", parameters)
     end
   end
 end

data/lib/expression.rb

@@ -1,19 +1,27 @@
 module Qdsl
   class Expression
+    def and(expr)
+      And.new([self, expr])
+    end
+
+    def or(expr)
+      Or.new([self, expr])
+    end
+
     protected
 
     def render_operand(context, ids, operand)
       if operand.is_a?(String)
-        parameter_id = context.add_parameter(operand)
-        ":#{parameter_id}"
+        parameter_id = context.create_parameter_id
+        SimpleRenderResult.new(":#{parameter_id}", {parameter_id => operand})
       elsif operand.is_a?(TrueClass)
-        'TRUE'
+        SimpleRenderResult.new('TRUE', {})
       elsif operand.is_a?(FalseClass)
-        'FALSE'
+        SimpleRenderResult.new('FALSE', {})
       elsif operand.is_a?(Expression)
-        operand.render(context, ids)
+        operand.render_sql(context, ids)
       else
-        operand.render(context, ids[operand.source])
+        operand.render_sql(context, ids[operand.source])
       end
     end
   end

data/lib/format_call.rb

@@ -0,0 +1,37 @@
+module Qdsl
+  class FormatCall
+    attr_reader :source, :name
+
+    def initialize(source, format, parameters, name = nil)
+      @source = source
+      @format = format
+      @parameters = parameters
+      @name = name.to_s
+    end
+
+    def as(name)
+      FormatCall.new(@source, @format, @parameters, name)
+    end
+
+    def exists?
+      @parameters.all? { |x| x.exists? }
+    end
+
+    def render_sql(context, id)
+      parameter_results = @parameters.collect { |x| x.render_sql(context, id) }
+      query_parameters = parameter_results.collect(&:parameters).inject({}) { |acc, x| acc.merge!(x) }
+      call = do_format(@format, parameter_results.collect(&:sql))
+      SimpleRenderResult.new(@name ? "#{call} AS #{@name}" : call, query_parameters)
+    end
+
+    private
+
+    def do_format(format, parameters)
+      format.gsub /%(\d+)/ do |m, x|
+        index = Integer(Regexp.last_match[1]) - 1
+        parameters[index]
+      end
+    end
+  end
+end
+

data/lib/inner_join.rb

@@ -1,10 +1,10 @@
 module Qdsl
   class InnerJoin
-    attr_reader :source, :predicate
+    attr_reader :source, :predicate_block
 
-    def initialize(source, predicate)
+    def initialize(source, predicate_block)
       @source = source
-      @predicate = predicate
+      @predicate_block = predicate_block
     end
   end
 end

data/lib/inner_join_builder.rb

@@ -1,13 +1,12 @@
 module Qdsl
   class InnerJoinBuilder
-    def initialize(query_builder, source)
-      @query_builder = query_builder
+    def initialize(select, source)
+      @select = select
       @source = source
     end
 
-    def on
-      predicate = yield(FunkyProxy.new(@query_builder.source), FunkyProxy.new(@source))
-      @query_builder.add_inner_join(@source, predicate)
+    def on(&predicate_block)
+      @select.add_inner_join(@source, predicate_block)
     end
   end
 end

data/lib/is_true.rb

@@ -0,0 +1,17 @@
+module Qdsl
+  class IsTrue < Expression
+    def initialize(column)
+      @column = column
+    end
+
+    def to_expression
+      self
+    end
+
+    def render_sql(context, ids)
+      column_result = render_operand(context, ids, @column)
+      column_result
+    end
+  end
+end
+

data/lib/or.rb

@@ -1,16 +1,22 @@
+require_relative 'boolean'
+
 module Qdsl
   class Or < Boolean
     def initialize(exprs)
       super 'OR', exprs
     end
 
-    def and(expr)
-      And.new([self, expr])
+    def to_expression
+      self
     end
 
     def or(expr)
       Or.new(@exprs + [expr])
     end
+
+    def true?
+      IsTrue.new(self)
+    end
   end
 end
 

data/lib/qdsl/version.rb

@@ -1,4 +1,4 @@
 module Qdsl
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end
 

data/lib/qdsl.rb

@@ -1,27 +1,13 @@
 require 'qdsl/version'
+require 'byebug'
 
-%w{
-  expression
-  boolean
-  and
-  column
-  context
-  equals
-  funky_proxy
-  inner_join
-  inner_join_builder
-  or
-  qdsl
-  select
-  table
-  table_query
-}.each do |file_name|
-  require_relative file_name
+Dir.glob("#{File.dirname(__FILE__)}/*.rb").each do |file_name|
+  require file_name
 end
 
 module Qdsl
   def self.select(*columns, &block)
-    Select.new(columns.collect { |x| Column[x] }, &block)
+    Select.new(ColumnSet.new(columns, block))
   end
 end
 

data/lib/render_result.rb

@@ -0,0 +1,13 @@
+module Qdsl
+  class RenderResult < SimpleRenderResult
+    attr_reader :id, :column_names, :parameters
+
+    def initialize(id, sql, column_names, parameters)
+      super sql, parameters
+      @id = id
+      @column_names = column_names
+      @parameters = parameters
+    end
+  end
+end
+

data/lib/select.rb

@@ -1,94 +1,127 @@
 module Qdsl
-  class SelectQuery
-    attr_reader :column_names
-
-    def initialize(select, column_names)
-      @select = select
-      @column_names = column_names
-    end
-
-    def render(context, depth, id)
-      select_result = @select.render(context, depth)
-      "(\n#{select_result}) AS #{id}"
-    end
-  end
-
   class Select
     attr_reader :source
 
-    def initialize(columns, &block)
-      @columns = columns
-      @block = block
+    def initialize(column_set)
+      @column_set = column_set
       @inner_joins = []
     end
 
     def from(source)
-      @source = source.create_query
+      @source = source
       self
     end
 
-def create_query
-  # Clone columns?
-  column_names = @columns.collect(&:name)
-  SelectQuery.new(self, column_names)
-end
+    def where(&predicate_block)
+      @where_predicate_block = predicate_block
+      self
+    end
+
+    def order_by(*columns, &block)
+      @order_by_column_set = ColumnSet.new(columns, block)
+      self
+    end
 
-    def where
-      sources = [@source] + @inner_joins.collect(&:source)
-      proxies = sources.collect { |x| FunkyProxy.new(x) }
-      @where = yield(proxies.size == 1 ? proxies.first : proxies)
+    def limit(count)
+      @count = count
       self
     end
 
     def inner_join(source)
-      InnerJoinBuilder.new(self, source.create_query)
+      InnerJoinBuilder.new(self, source)
+    end
+
+    def create_query
+      SelectQuery.new(self, @column_set)
     end
 
-    def add_inner_join(source, predicate)
-      @inner_joins << InnerJoin.new(source, predicate)
+    def add_inner_join(source, predicate_block)
+      @inner_joins << InnerJoin.new(source, predicate_block)
       self
     end
 
-    def render(context = nil, depth = 0)
-      context ||= Context.new
+    def render(context = nil, depth = 0, id = nil)
+      raise 'No FROM clause was specified' unless @source
 
       indent = '  ' * depth
 
-      unknown_columns = @columns.select { |x| !@source.column_names.include?(x.name) }
-      raise "One or more unknown columns: #{unknown_columns.collect(&:name).join(', ')}" unless unknown_columns.empty?
+      context ||= Context.new
 
-      columns = @columns.collect { |x| x.with_source(@source) }
+      parameters = {}
 
-      sources = [@source] + @inner_joins.collect(&:source)
+      source_query = @source.create_query
+      source_query_id = context.create_id
+      source_result = source_query.render(context, depth + 1, source_query_id)
 
-      extra_columns = if @block
-        proxies = sources.collect { |x| FunkyProxy.new(x) }
-        [*@block.call(proxies.size == 1 ? proxies.first : proxies)]
-      else
-        []
+      inner_join_fragments = []
+      inner_join_results = []
+      @inner_joins.each do |inner_join|
+        inner_join_query = inner_join.source.create_query
+        inner_join_query_id = context.create_id
+        inner_join_result = inner_join_query.render(context, depth + 1, inner_join_query_id)
+        inner_join_results << inner_join_result
+        x = ColumnProxy.new(source_result)
+        y = ColumnProxy.new(inner_join_result)
+        predicate = inner_join.predicate_block.call(x, y)
+
+        # Should just use id attribute instead of passing dictionary!
+        bah = {
+          source_result => source_result.id,
+          inner_join_result => inner_join_result.id,
+        }
+
+        predicate_result = predicate.render_sql(context, bah)
+
+        inner_join_fragments << "#{indent}INNER JOIN #{inner_join_result.sql}"
+        inner_join_fragments << "#{indent}ON #{predicate_result.sql}\n"
       end
 
-      ids = sources.inject({}) { |acc, x| acc[x] = context.id; acc }
+      columns = @column_set.capture(source_result, inner_join_results)
 
-      column_results = (columns + extra_columns).collect { |x| x.render(context, ids[x.source]) }
+      column_results = columns.collect { |x| x.render_sql(context, x.source.id) }
 
       fragments = []
 
-      fragments << "#{indent}SELECT #{column_results.join(', ')}\n"
-      fragments << "#{indent}FROM #{@source.render(context, depth + 1, ids[@source])}\n"
+      fragments << "#{indent}SELECT\n"
+      column_results.each_with_index do |column_result, index|
+        fragments << "#{indent}  #{column_result.sql}#{index < column_results.size - 1 ? ',' : ''}\n"
+      end
 
-      @inner_joins.each do |inner_join|
-        predicate_result = inner_join.predicate.render(context, ids)
-        fragments << "#{indent}INNER JOIN #{inner_join.source.render(context, depth + 1, ids[inner_join.source])}\n"
-        fragments << "#{indent}ON #{predicate_result}\n"
+      fragments << "#{indent}FROM #{source_result.sql}"
+
+      fragments += inner_join_fragments
+
+      if @where_predicate_block
+        blah = [source_result] + inner_join_results
+        proxies = blah.collect { |x| ColumnProxy.new(x) }
+        where_predicate = @where_predicate_block.call(Util::fix_block_params(proxies))
+
+        # Should just use id attribute instead of passing dictionary!
+        bah = blah.inject({}) { |acc, x| acc[x] = x.id; acc }
+
+        where_predicate_result = where_predicate.render_sql(context, bah)
+        parameters.merge!(where_predicate_result.parameters)
+
+        fragments << "#{indent}WHERE #{where_predicate_result.sql}\n"
+      end
+
+      if @order_by_column_set
+        order_by_columns = @order_by_column_set.capture(source_result, inner_join_results)
+        order_by_column_results = order_by_columns.collect { |x| x.render_sql(context, x.source.id) }
+        fragments << "#{indent}ORDER BY #{order_by_column_results.collect(&:sql).join(', ')}\n"
       end
 
-      if @where
-        predicate_result = @where.render(context, ids)
-        fragments << "#{indent}WHERE #{predicate_result}"
+      if @count
+        fragments << "LIMIT #{@count}"
       end
 
-      fragments.join
+      sql = fragments.join
+      RenderResult.new(
+        id,
+        sql,
+        columns.collect(&:name),
+        parameters
+      )
     end
   end
 end

data/lib/select_query.rb

@@ -0,0 +1,30 @@
+module Qdsl
+  class SelectQuery
+    def initialize(select, column_set)
+      @select = select
+      @column_set = column_set
+    end
+
+    def render(context, depth, id)
+      indent = '  ' * depth
+
+      columns = @column_set.capture(@select.source, [])
+
+      select_result = @select.render(context, depth)
+
+      fragments = []
+      fragments << "(\n"
+      fragments << select_result.sql
+      fragments << ") AS #{id}\n"
+
+      sql = fragments.join
+      RenderResult.new(
+        id,
+        sql,
+        columns.collect(&:name),
+        {}
+      )
+    end
+  end
+end
+

data/lib/simple_render_result.rb

@@ -0,0 +1,11 @@
+module Qdsl
+  class SimpleRenderResult
+    attr_reader :sql, :parameters
+
+    def initialize(sql, parameters)
+      @sql = sql
+      @parameters = parameters
+    end
+  end
+end
+

data/lib/table_query.rb

@@ -8,7 +8,7 @@ module Qdsl
     end
 
     def render(context, depth, id)
-      "#{@name} AS #{id}"
+      RenderResult.new(id, "#{@name} AS #{id}\n", @column_names, {})
     end
   end
 end

data/lib/util.rb

@@ -0,0 +1,8 @@
+module Qdsl
+  module Util
+    def self.fix_block_params(params)
+      params.size == 1 ? params.first : params
+    end
+  end
+end
+