eno 0.4 → 0.5

data/lib/eno/pg.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'pg'
+
+class PG::Connection
+  ESCAPER = ->(expr) {
+    case expr
+    when Symbol
+      quote_ident(expr.to_s)
+    when String
+      "'#{escape(expr)}'"
+    else
+      nil # use default quoting
+    end
+  }
+
+  def q(query = nil, **ctx, &block)
+    query ||= Eno::Query.new(&block)
+    exec(query_to_sql(query, **ctx))
+  end
+
+  def query_to_sql(query, **ctx)
+    query.to_sql(escape_proc: ESCAPER, **ctx)
+  end
+end

data/lib/eno/query.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+export :Query
+
+Expressions = import('./expressions')
+SQL         = import('./sql')
+
+class Query
+  def initialize(**ctx, &block)
+    @ctx = ctx
+    @block = block
+  end
+
+  def to_sql(escape_proc: nil, **ctx)
+    r = SQL::SQL.new(escape_proc: escape_proc, **@ctx.merge(ctx))
+    r.to_sql(&@block)
+  end
+
+  def as(sym)
+    Expressions::Alias.new(self, sym)
+  end
+
+  def where(&block)
+    old_block = @block
+    Query.new(@ctx) {
+      instance_eval(&old_block)
+      where instance_eval(&block)
+    }
+  end
+
+  def mutate(&block)
+    old_block = @block
+    Query.new(@ctx) {
+      instance_eval(&old_block)
+      instance_eval(&block)
+    }
+  end
+
+  def union(*queries, **props, &block)
+    q1 = self
+    queries << Query.new(&block) if queries.empty?
+    Query.new(@ctx) { union q1, *queries, **props }
+  end
+  alias_method :|, :union
+
+  def union_all(*queries, &block)
+    union(*queries, all: true, &block)
+  end
+
+  def intersect(*queries, **props, &block)
+    q1 = self
+    queries << Query.new(&block) if queries.empty?
+    Query.new(@ctx) { intersect q1, *queries, **props }
+  end
+  alias_method :&, :intersect
+
+  def intersect_all(*queries, &block)
+    intersect(*queries, all: true, &block)
+  end
+
+  def except(*queries, **props, &block)
+    q1 = self
+    queries << Query.new(&block) if queries.empty?
+    Query.new(@ctx) { except q1, *queries, **props }
+  end
+  alias_method :"^", :except
+
+  def except_all(*queries, &block)
+    except(*queries, all: true, &block)
+  end
+end
+ 

data/lib/eno/sql.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+Expressions = import('./expressions')
+Query = import('./query')
+
+export :SQL
+
+S_SPACE         = ' '
+S_PARENS        = '(%s)'
+S_QUOTES        = "'%s'"
+S_ALL           = '*'
+S_QUALIFIED_ALL = '%s.*'
+
+class SQL
+  def initialize(escape_proc: nil, **ctx)
+    @escape_proc = escape_proc
+    @ctx = ctx
+  end
+
+  def to_sql(&block)
+    instance_eval(&block)
+
+    return @combination.to_sql(self) if @combination
+
+    [
+      @with,
+      @select || default_select,
+      @from,
+      @where,
+      @window,
+      @order_by,
+      @limit
+    ].compact.map { |c| c.to_sql(self) }.join(S_SPACE)
+  end
+
+  def quote(expr)
+    if @escape_proc
+      value = @escape_proc.(expr)
+      return value if value
+    end
+
+    case expr
+    when Query::Query
+      S_PARENS % expr.to_sql(@ctx).strip
+    when Expressions::Expression
+      expr.to_sql(self)
+    when Symbol
+      expr.to_s
+    when String
+      S_QUOTES % expr
+    else
+      expr.inspect
+    end
+  end
+
+  def context
+    @ctx
+  end
+
+  def _l(value)
+    Expressions::Literal.new(value)
+  end
+
+  def _i(value)
+    Expressions::Identifier.new(value)
+  end
+
+  def default_select
+    Expressions::Select.new(:*)
+  end
+
+  def method_missing(sym, *args)
+    if @ctx.has_key?(sym)
+      value = @ctx[sym]
+      return Symbol === value ? Expressions::Identifier.new(value) : value
+    end
+    
+    super if sym == :to_hash
+    if args.empty?
+      Expressions::Identifier.new(sym)
+    else
+      Expressions::FunctionCall.new(sym, *args)
+    end
+  end
+
+  def with(*members, **props)
+    @with = Expressions::With.new(*members, **props)
+  end
+
+  H_EMPTY = {}.freeze
+
+  def select(*members, **props)
+    if members.empty? && !props.empty?
+      members = props.map { |k, v| Expressions::Alias.new(v, k) }
+      props = {}
+    end
+    @select = Expressions::Select.new(*members, **props)
+  end
+
+  def from(*members, **props)
+    @from = Expressions::From.new(*members, **props)
+  end
+
+  def where(expr)
+    if @where
+      @where.members << expr
+    else
+      @where = Expressions::Where.new(expr)
+    end
+  end
+
+  def window(sym, &block)
+    @window = Expressions::Window.new(sym, &block)
+  end
+
+  def order_by(*members, **props)
+    @order_by = Expressions::OrderBy.new(*members, **props)
+  end
+
+  def limit(*members)
+    @limit = Expressions::Limit.new(*members)
+  end
+
+  def all(sym = nil)
+    if sym
+      Expressions::Identifier.new(S_QUALIFIED_ALL % sym)
+    else
+      Expressions::Identifier.new(S_ALL)
+    end
+  end
+
+  def cond(props)
+    Expressions::Case.new(props)
+  end
+
+  def default
+    :default
+  end
+
+  def union(*queries, **props)
+    @combination = Expressions::Combination.new(*queries, kind: :union, **props)
+  end
+
+  def intersect(*queries, **props)
+    @combination = Expressions::Combination.new(*queries, kind: :intersect, **props)
+  end
+
+  def except(*queries, **props)
+    @combination = Expressions::Combination.new(*queries, kind: :except, **props)
+  end
+end

data/lib/eno/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Eno
-  VERSION = '0.4'
+  VERSION = '0.5'
 end

data/test/adapters/test_pg.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../ext'
+import('../../lib/eno/pg')
+
+require 'pp'
+
+class PostgresTest < T
+  DB = PG.connect(
+    host:     '/tmp',
+    user:     'reality',
+    password: nil,
+    dbname:   'reality',
+    sslmode:  'require'
+  )
+
+  def test_correct_escaping
+    results = DB.q {
+      select _l("abc def 'ghi'\n").as(:"jkl mno")
+    }.to_a
+    assert_equal(1, results.size)
+    assert_equal(['jkl mno'], results.first.keys)
+    assert_equal(["abc def 'ghi'\n"], results.first.values)
+  end
+
+  def test_identifier_escaping
+    query = Q {
+      select _i("abc'def\"ghi")
+    }
+    assert_equal("select \"abc'def\"\"ghi\"", DB.query_to_sql(query))
+  end
+end

data/test/ext.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'modulation'
+require 'minitest/autorun'
+
+Eno = import '../lib/eno'
+
+T = MiniTest::Test
+class T
+  def assert_sql(sql, &block); assert_equal(sql, Q(&block).to_sql); end
+end

data/test/test.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+Dir["#{__dir__}/**/test_*.rb"].each { |fn| require fn }

data/test/test_clauses.rb

@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+require_relative './ext'
+
+class SelectTest < T
+  def test_that_no_from_select_is_supported
+    assert_sql('select 1') { select 1 }
+    assert_sql('select pg_sleep(1)') { select pg_sleep(1) }
+  end
+
+  def test_default_select
+    assert_sql('select *') { }
+    assert_sql('select * from t') { from t}
+  end
+
+  def test_that_select_with_hash_is_supported
+    assert_sql('select 1 as a, 2 as b') { select a: 1, b: 2 }
+    assert_sql('select pg_sleep(1) as s, pg_sleep(2) as s2') {
+      select s: pg_sleep(1), s2: pg_sleep(2)
+    }
+  end
+
+  def test_select_distinct
+    assert_sql('select distinct a, b') {
+      select a, b, distinct: true
+    }
+
+    assert_sql('select distinct on (a + b) a, b') {
+      select a, b, distinct: a + b
+    }
+  end
+end
+
+class FromTest < T
+  def test_that_from_accepts_table_name
+    assert_sql('select * from abc') {
+      from abc
+    }
+  end
+
+  def test_that_expression_can_be_aliased
+    assert_sql('select * from abc as a') {
+      from abc.as(a)
+    }
+  end
+
+  def test_that_from_accepts_sub_query
+    query = Q { select _l(1).as a }
+    assert_sql('select a from (select 1 as a) t1') {
+      select a
+      from query
+    }
+
+    assert_sql('select a from (select 1 as a) t3') {
+      select a
+      from query.as t3
+    }
+  end
+end
+
+class WithTest < T
+  def test_that_with_accepts_sub_queries
+    assert_sql('with t1 as (select 1 as a), t2 as (select 2 as b) select * from b') {
+      with t1.as { select _l(1).as a }, t2.as { select _l(2).as b }
+      select all
+      from b
+    }
+  end
+end
+
+class WhereTest < T
+  def test_that_where_accepts_boolean_const
+    assert_sql('select * from a where true') {
+      from a
+      where true
+    }
+  end
+
+  def test_that_where_accepts_comparison_expression
+    assert_sql('select * from a where (b = 1)') {
+      from a
+      where b == 1
+    }
+
+    assert_sql('select * from a where ((b = 1) and (c = 2))') {
+      from a
+      where (b == 1) & (c == 2)
+    }
+
+    assert_sql('select * from a where ((b > 1) and (c < 2))') {
+      from a
+      where (b > 1) & (c < 2)
+    }
+
+    assert_sql('select * from a where ((b <= 1) and (c <> 2))') {
+      from a
+      where (b <= 1) & (c != 2)
+    }
+  end
+
+  def test_that_where_accepts_logical_expression
+    assert_sql('select * from a where (b and c)') {
+      from a
+      where b & c
+    }
+
+    assert_sql('select * from a where (b or c)') {
+      from a
+      where b | c
+    }
+
+    assert_sql('select * from a where (b and (not c))') {
+      from a
+      where b & !c
+    }
+
+    assert_sql('select * from a where (not (b or c))') {
+      from a
+      where !(b | c)
+    }
+  end
+
+  def test_that_where_accepts_nil
+    assert_sql('select * from a where (b is null)') {
+      from a
+      where b.null?
+    }
+
+    assert_sql('select * from a where (b is not null)') {
+      from a
+      where !b.null?
+    }
+
+    assert_sql('select * from a where (b is not null)') {
+      from a
+      where !b.null?
+    }
+  end
+
+  def test_that_where_accepts_arithmetic_operators
+    assert_sql('select * from a where ((b + c) = 42)') {
+      from a
+      where b + c == 42
+    }
+  end
+end
+
+class DSLTest < T
+  class Eno::Identifier
+    def [](sym)
+      case sym
+      when Symbol
+        Eno::Alias.new(JSONBExpression.new(self, sym), sym)
+      else
+        JSONBExpression.new(self, sym)
+      end
+    end
+  end
+  
+  class JSONBExpression < Eno::Expression
+    def to_sql(sql)
+      "#{sql.quote(@members[0])}->>'#{sql.quote(@members[1])}'"
+    end
+  end
+    
+  def test_that_dsl_can_be_extended
+    assert_sql("select attributes->>'path'") {
+      select attributes[path]
+    }
+
+    assert_sql("select attributes->>'path' as path") {
+      select attributes[:path]
+    }
+  end
+end
+
+class WindowTest < T
+  def test_that_over_is_supported
+    assert_sql('select last_value(q) over w as q_last, last_value(v) over w as v_last') {
+      select last_value(q).over(w).as(q_last),
+             last_value(v).over(w).as(v_last)
+    }
+  end
+
+  def test_that_over_supports_inline_window
+    assert_sql('select group_name, avg(price) over (partition by group_name) from products') {
+      select group_name, (avg(price).over { partition_by group_name })
+      from products
+    }
+  end
+
+  def test_named_windows
+    assert_sql('select last_value(q) over w as q_last, last_value(v) over w as v_last from t1 window w as (partition by stamp_aligned order by stamp range between unbounded preceding and unbounded following)') {
+      select last_value(q).over(w).as(q_last),
+             last_value(v).over(w).as(v_last)
+      from t1
+      window(w) {
+        partition_by stamp_aligned
+        order_by stamp
+        range_unbounded
+      }
+    }
+  end
+end
+
+class ContextTest < T
+  def test_that_context_passed_can_be_used_in_query
+    query = Q(tbl: :nodes, field: :sample_rate, value: 42) {
+      select a, b
+      from tbl
+      where field < value
+    }
+    assert_equal(
+      'select a, b from nodes where (sample_rate < 42)',
+      query.to_sql
+    )
+  end
+
+  def test_that_context_can_be_passed_in_to_sql_method
+    query = Q {
+      select a, b
+      from tbl
+      where field < value
+    }
+    assert_equal(
+      'select a, b from nodes where (sample_rate < 43)',
+      query.to_sql(tbl: :nodes, field: :sample_rate, value: 43)
+    )
+  end
+
+  def test_that_to_sql_overrides_initial_context
+    query = Q(tbl: :nodes, field: :deadband) {
+      select a, b
+      from tbl
+      where field < value
+    }
+    assert_equal(
+      'select a, b from nodes where (sample_rate < 42)',
+      query.to_sql(field: :sample_rate, value: 42)
+    )
+  
+    assert_equal(
+      'select a, b from nodes where (deadband < 42)',
+      query.to_sql(value: 42)
+    )
+  end
+end
+
+class MutationTest < T
+  def test_that_query_can_further_refined_with_where_clause
+    q = Q {
+      select a, b
+    }
+    assert_equal('select a, b', q.to_sql)
+
+    q2 = q.where { c < d}
+    assert(q != q2)
+    assert_equal('select a, b', q.to_sql)
+    assert_equal('select a, b where (c < d)', q2.to_sql)
+
+    q = Q {
+      where _l(2) + _l(2) == _l(5)
+    }
+    assert_equal('select * where ((2 + 2) = 5)', q.to_sql)
+
+    q2 = q.where { _l('up') == _l('down') }
+    assert_equal("select * where ((2 + 2) = 5) and ('up' = 'down')", q2.to_sql)
+  end
+
+  def test_that_mutated_query_can_change_arbitrary_clauses
+    q = Q { select a; from b }
+    assert_equal('select a from b', q.to_sql)
+
+    q2 = q.mutate { from c }
+    assert_equal('select a from b', q.to_sql)
+    assert_equal('select a from c', q2.to_sql)
+  end
+end
+
+class CastTest < T
+  def test_that_cast_is_correctly_formatted
+    assert_sql('select cast (a as b)') { select a.cast(b) }
+    assert_sql('select cast (123 as float)') { select _l(123).cast(float) }
+    assert_sql("select cast ('123' as integer)") { select _l('123').cast(integer) }
+  end
+
+  def test_that_cast_shorthand_is_correctly_formatted
+    assert_sql('select a::b') { select a^b }
+    assert_sql('select 123::float') { select _l(123)^float }
+    assert_sql("select '2019-01-01 00:00+00'::timestamptz") {
+      select _l('2019-01-01 00:00+00')^timestamptz
+    }
+  end
+
+  def test_that_cast_works_wih_symbols
+    assert_sql('select cast (a as b)') { select a.cast(:b) }
+  end
+end
+
+class InTest < T
+  def test_that_in_is_correctly_formatted
+    assert_sql('select * where a in (1, 2, 3)') { where a.in 1, 2, 3 }
+    assert_sql('select * where a not in (1, 2, 3)') { where !a.in(1, 2, 3) }
+  end
+
+  def test_that_not_in_is_correcly_formatted
+    assert_sql('select * where a not in (1, 2, 3)') { where a.not_in 1, 2, 3 }
+  end
+end
+
+class LiteralTest < T
+  def test_that_numbers_are_correctly_quoted
+    assert_sql('select 123') { select 123 }
+    assert_sql('select 123') { select _l(123) }
+    assert_sql('select (2 + 2)') { select _l(2) + _l(2) }
+  end
+
+  def test_that_strings_are_correctly_quoted
+    assert_sql("select 'abc'") { select 'abc' }
+  end
+
+  def test_that_null_literal_is_correctly_quoted
+    assert_sql('select null') { select null }
+  end
+end
+
+class ConvenienceVariablesTest < T
+  def test_that_convenience_variables_do_not_change_query
+    assert_sql('select unformatted_value::boolean, unformatted_value::float') {
+      uv = unformatted_value
+      select uv^boolean, uv^float
+    }
+  end
+end
+
+class ExtractEpoch < Eno::Expression
+  class Eno::SQL
+    def extract_epoch_from(sym)
+      ExtractEpoch.new(sym)
+    end
+  end
+    
+  def to_sql(sql)
+    "extract (epoch from #{sql.quote(@members[0])})::integer"
+  end
+end