eno 0.4 → 0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb697b829ee2858e69995a4485607463b4b2c0740cb78f2c984bd25ffa188108
-  data.tar.gz: 40850710021d688e6a916e0f8c21ee5511990012f015c8c9541e9e700f815b59
+  metadata.gz: f38441c60755b6d8a052a675725904ef2d7694955b81908790c31a1f33a314fd
+  data.tar.gz: f7a0cb8679e3c0798f626781daac68c17c5de0aca907323628e26a1b73645d73
 SHA512:
-  metadata.gz: cf6d28da3a66cc2db0121914f2ae29c578ec67f9d5ea72bc9acb9fc0d0c85215145f424092095b73abc6d68b094661ef5a73a318f84d3a70d2dba91c1f75a4b7
-  data.tar.gz: dec76ece5872f0f4688d1654ff2894809680e870f728165269516167101828be9e8379f77ef643f137604f4cf082a73d03c88ce0a05be34248350f32b40081b7
+  metadata.gz: 94a69f5cdd6e83f504d2bf3536e5616b1cce54589a450dc25440ead3576b93def237be2e51e74cdffb9671775bd22b5f695c7f0db92fd5d8cde482744442b84e
+  data.tar.gz: 1e3859cfb9f114e90b8748862a30db06e41c57c54754bb1c0d6c768c11cab065dd2d75fcc013494490ec0f44defda21e4e5d52fbb2920baebb1ca32b548b5962

data/.gitignore

@@ -0,0 +1,50 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+* Rename `#_q` to `#_l` (for literal)
+* Add `#_i` method for creating identifier
+
+0.5 2019-01-25
+--------------
+
+* Implement query combination: `union`, `intersect`, `except`
+* Implement `#not_in` method
+* Implement case expression (using `#cond`)
+* Implement not in expression
+* Implement in operator
+* Implement cast operator (using either `#cast` or `#^`)
+
 0.4 2019-01-21
 --------------
 

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,23 @@
+PATH
+  remote: .
+  specs:
+    eno (0.5)
+      modulation (= 0.18)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    modulation (0.18)
+    pg (1.1.3)
+    sqlite3 (1.3.13)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  eno!
+  pg (= 1.1.3)
+  sqlite3 (= 1.3.13)
+
+BUNDLED WITH
+   2.1.4

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 digital-fabric
+
+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.md

@@ -30,7 +30,7 @@ like ActiveRecord's `where`:
 Client.where(order_count: [1, 3, 5])
 ```
 
-And Sequel is a bit more flexible:
+And Sequel is (quite) a bit more flexible:
 
 ```ruby
 Client.where { order_count > 10 }
@@ -98,15 +98,90 @@ Q {
 }.to_sql #=> "select a, b from c"
 ```
 
-## Using expressions
+## Expressions
 
-Once inside the query block, you can build arbitrarily complex expressions. You
-can mix logical and arithmetic operators:
+Eno lets you build arbitrarily complex expressions once inside the query block.
+You can freely mix identifiers and literals, use most operators (with certain
+caveats) and make function calls.
+
+### Identifiers
+
+An identifier is referenced simply using its name:
+
+```ruby
+Q {
+  select foo
+} #=> select foo
+```
+
+Identifiers can be qualified by using dot-notation:
+
+```ruby
+Q {
+  select foo.bar
+} #=> select foo.bar
+```
+
+### Literals
+
+Literals can be specified as literals
+
+```ruby
+Q {
+  select x * 10
+} #=> select x * 10
+```
+
+However, if the first argument of an expression is a literal, it will need to be
+wrapped in a call to `#_q`:
+
+```ruby
+Q {
+  select _q(2) + 2
+} #=> select 2 + 2
+```
+
+### Operators
+
+Eno supports the following mathematical operators:
+
+operator | description
+---------|------------
+`+`      | addition
+`-`      | subtraction
+`*`      | multiplication
+`/`      | division
+`%`      | modulo (remainder)
+
+Logical operators are supported using the following operators:
+
+operator | description
+---------|------------
+`&`      | logical and
+`\|`      | logical or       
+`!`      | logical not
+
+The following comparison operators are supported:
+
+operator | description
+---------|------------
+`==`     | equal
+`!=`     | not equal
+`<`      | less than
+`>`      | greater than
+`<=`     | less than or equal
+`>=`     | greater than or equal      
+
+An example involving multiple operators:
 
 ```ruby
-Q { select (a + b) & (c * d) }.to_sql #=> select (a + b) and (c * d)
+Q {
+  select (a + b) & (c * d), e >= f
+} #=> select (a + b) and (c * d), e >= f
 ```
 
+### functions
+
 You can also use SQL functions:
 
 ```ruby
@@ -117,6 +192,80 @@ Q {
 }
 ```
 
+## SQL clauses
+
+Eno supports the following clauses:
+
+### Select
+
+The `#select` method is used to specify the list of selected expressions for a
+`select` statement. The `select` method accepts a list of expressions:
+
+```ruby
+Q { select a, b + c, d.as(e) } #=> select a, b + c, d as e
+```
+
+The `#select` method can also accept a hash mapping aliases to expressions:
+
+```ruby
+Q { select c: a + b, f: d(e) } #=> select a + b as c, d(e) as f
+```
+
+Columns can be qualified using dot-notation:
+
+```ruby
+Q { select a.b, c.d.e } #=> select a.b, c.d.e
+```
+
+Note: if `#select` is not called within a query block, a `select *` is assumed:
+
+```ruby
+Q { from mytable } #=> select * from mytable
+```
+
+### From
+
+The `#from` method is used to specify one or more sources for the query. Usually
+this would be a table name, a subquery, a CTE name (specified using `#with`):
+
+```ruby
+Q { from a, b, c } #=> select * from a, b, c
+Q { from a.as b } #=> select * from a as b
+```
+
+Subqueries can also be used in `#from`:
+
+```ruby
+Q {
+  select sum(foo.score)
+  from Q { select * from scores }.as(foo)
+} #=> select sum(foo.score) from (select score from scores) as foo
+```
+
+### Where
+
+The `#where` method is used to specify a record filter:
+
+```ruby
+Q {
+  from users
+  where name == 'John Doe' & age > 30
+} #=> select * from users where (name = 'John Doe') and (age > 30)
+```
+
+Where clauses can be of arbitrary complexity (as shown [above](#expressions)),
+and can also be chained in order to mutate and further filter query:
+
+```ruby
+query = Q {
+  from users
+  where state == 'CA'
+}
+query.where { age >= 25 } #=> select * from users where (state = 'CA') and (age >= 25)
+```
+
+
+
 ## Hooking up Eno to your database
 
 In and of itself, Eno is just an engine for building SQL queries. To actually

data/eno.gemspec

@@ -0,0 +1,22 @@
+require_relative './lib/eno/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'eno'
+  s.version     = Eno::VERSION
+  s.licenses    = ['MIT']
+  s.summary     = 'Eno: Eno is Not an ORM'
+  s.author      = 'Sharon Rosner'
+  s.email       = 'ciconia@gmail.com'
+  s.files       = `git ls-files`.split
+  s.homepage    = 'http://github.com/digital-fabric/eno'
+  s.metadata    = {
+    "source_code_uri" => "https://github.com/digital-fabric/eno"
+  }
+  s.rdoc_options = ["--title", "eno", "--main", "README.md"]
+  s.extra_rdoc_files = ["README.md"]
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency      'modulation', '0.18'
+  s.add_development_dependency  'pg',         '1.1.3'
+  s.add_development_dependency  'sqlite3',    '1.3.13'
+end

data/lib/eno.rb

@@ -2,485 +2,16 @@
 
 require 'modulation/gem'
 
-export :Query, :SQL, :Expression, :Identifier, :Alias
+export_default :Eno
 
 module ::Kernel
   def Q(**ctx, &block)
-    Query.new(**ctx, &block)
+    Eno::Query.new(**ctx, &block)
   end
 end
 
-class Expression
-  def self.quote(expr)
-    case expr
-    when Query
-      "(#{expr.to_sql.strip})"
-    when Expression
-      expr.to_sql
-    when Symbol
-      expr.to_s
-    when String
-      "'#{expr}'"
-    else
-      expr.inspect
-    end
-  end
-
-  attr_reader :members, :props
-
-  def initialize(*members, **props)
-    @members = members
-    @props = props
-  end
-
-  def as(sym = nil, &block)
-    if sym
-      Alias.new(self, sym)
-    else
-      Alias.new(self, Query.new(&block))
-    end
-  end
-
-  def desc
-    Desc.new(self)
-  end
-
-  def over(sym = nil, &block)
-    Over.new(self, sym || WindowExpression.new(&block))
-  end
-
-  def ==(expr2)
-    Operator.new('=', self, expr2)
-  end
-
-  def !=(expr2)
-    Operator.new('<>', self, expr2)
-  end
-
-  def <(expr2)
-    Operator.new('<', self, expr2)
-  end
-
-  def >(expr2)
-    Operator.new('>', self, expr2)
-  end
-
-  def <=(expr2)
-    Operator.new('<=', self, expr2)
-  end
-
-  def >=(expr2)
-    Operator.new('>=', self, expr2)
-  end
-
-  def &(expr2)
-    Operator.new('and', self, expr2)
-  end
-
-  def |(expr2)
-    Operator.new('or', self, expr2)
-  end
-
-  def +(expr2)
-    Operator.new('+', self, expr2)
-  end
-
-  def -(expr2)
-    Operator.new('-', self, expr2)
-  end
-
-  def *(expr2)
-    Operator.new('*', self, expr2)
-  end
-
-  def /(expr2)
-    Operator.new('/', self, expr2)
-  end
-
-  def %(expr2)
-    Operator.new('%', self, expr2)
-  end
-
-  # not
-  def !@
-    Not.new(self)
-  end
-  
-  def null?
-    IsNull.new(self)
-  end
-
-  def not_null?
-    IsNotNull.new(self)
-  end
-
-  def join(sym, **props)
-    Join.new(self, sym, **props)
-  end
-
-  def inner_join(sym, **props)
-    join(sym, props.merge(type: :inner))
-  end
-end
-
-class Operator < Expression
-  def initialize(*members, **props)
-    op = members[0]
-    if Operator === members[1] && op == members[1].op
-      members = [op] + members[1].members[1..-1] + members[2..-1]
-    end
-    if Operator === members[2] && op == members[2].op
-      members = members[0..1] + members[2].members[1..-1]
-    end
-
-    super(*members, **props)
-  end
-
-  def op
-    @members[0]
-  end
-
-  def to_sql
-    op = " #{@members[0]} "
-    "(%s)" % @members[1..-1].map { |m| Expression.quote(m) }.join(op)
-  end
-end
-
-class Desc < Expression
-  def to_sql
-    "#{Expression.quote(@members[0])} desc"
-  end
-end
-
-class Over < Expression
-  def to_sql
-    "#{Expression.quote(@members[0])} over #{Expression.quote(@members[1])}"
-  end
-end
-
-class Not < Expression
-  def to_sql
-    "(not #{Expression.quote(@members[0])})"
-  end
-end
-
-class IsNull < Expression
-  def to_sql
-    "(#{Expression.quote(@members[0])} is null)"
-  end
-
-  def !@
-    IsNotNull.new(members[0])
-  end
-end
-
-class IsNotNull < Expression
-  def to_sql
-    "(#{Expression.quote(@members[0])} is not null)"
-  end
-end
-
-class WindowExpression < Expression
-  def initialize(&block)
-    instance_eval(&block)
-  end
-
-  def partition_by(*args)
-    @partition_by = args
-  end
-
-  def order_by(*args)
-    @order_by = args
-  end
-
-  def range_unbounded
-    @range = 'between unbounded preceding and unbounded following'
-  end
-
-  def to_sql
-    "(%s)" % [
-      _partition_by_clause,
-      _order_by_clause,
-      _range_clause
-    ].join.strip
-  end
-
-  def _partition_by_clause
-    return nil unless @partition_by
-    "partition by %s " % @partition_by.map { |e| Expression.quote(e) }.join(', ')
-  end
-
-  def _order_by_clause
-    return nil unless @order_by
-    "order by %s " % @order_by.map { |e| Expression.quote(e) }.join(', ')
-  end
-
-  def _range_clause
-    return nil unless @range
-    "range #{@range} "
-  end
-
-  def method_missing(sym)
-    super if sym == :to_hash
-    Identifier.new(sym)
-  end
-end
-
-class QuotedExpression < Expression
-  def to_sql
-    Expression.quote(@members[0])
-  end
-end
-
-class Identifier < Expression
-  def to_sql
-    @members[0].to_s
-  end
-
-  def method_missing(sym)
-    super if sym == :to_hash
-    Identifier.new("#{@members[0]}.#{sym}")
-  end
-
-  def _empty_placeholder?
-    m = @members[0]
-    Symbol === m && m == :_
-  end
-end
-
-class Alias < Expression
-  def to_sql
-    "#{Expression.quote(@members[0])} as #{Expression.quote(@members[1])}"
-  end
-end
-
-class FunctionCall < Expression
-  def to_sql
-    fun = @members[0]
-    if @members.size == 2 && Identifier === @members.last && @members.last._empty_placeholder?
-      "#{fun}()"
-    else
-      "#{fun}(#{@members[1..-1].map { |a| Expression.quote(a) }.join(', ')})"
-    end
-  end
-end
-
-class Join < Expression
-  H_JOIN_TYPES = {
-    nil:    'join',
-    inner:  'inner join',
-    outer:  'outer join'
-  }
-
-  def to_sql
-    ("%s %s %s %s" % [
-      Expression.quote(@members[0]),
-      H_JOIN_TYPES[@props[:type]],
-      Expression.quote(@members[1]),
-      condition_sql
-    ]).strip
-  end
-
-  def condition_sql
-    if @props[:on]
-      'on %s' % Expression.quote(@props[:on])
-    elsif using_fields = @props[:using]
-      fields = using_fields.is_a?(Array) ? using_fields : [using_fields]
-      'using (%s)' % fields.map { |f| Expression.quote(f) }.join(', ')
-    else
-      nil
-    end
-  end
-end
-
-class From < Expression
-  def to_sql
-    "from %s" % @members.map { |m| member_sql(m) }.join(', ')
-  end
-
-  def member_sql(member)
-    if Query === member
-      "%s t1" % Expression.quote(member)
-    elsif Alias === member && Query === member.members[0]
-      "%s %s" % [Expression.quote(member.members[0]), Expression.quote(member.members[1])]
-    else
-      Expression.quote(member)
-    end
-  end
-end
-
-class With < Expression
-  def to_sql
-    "with %s" % @members.map { |e| Expression.quote(e) }.join(', ')
-  end
-end
-
-class Select < Expression
-  def to_sql
-    "select %s%s" % [distinct_clause, @members.map { |e| Expression.quote(e) }.join(', ')]
-  end
-
-  def distinct_clause
-    case (on = @props[:distinct])
-    when nil
-      nil
-    when true
-      "distinct "
-    when Array
-      "distinct on (%s) "  % on.map { |e| Expression.quote(e) }.join(', ')
-    else
-      "distinct on %s "  % Expression.quote(on)
-    end
-  end
-end
-
-class Where < Expression
-  def to_sql
-    "where %s" % @members.map { |e| Expression.quote(e) }.join(' and ')
-  end
-end
-
-class Window < Expression
-  def initialize(sym, &block)
-    super(sym)
-    @block = block
-  end
-
-  def to_sql
-    "window %s as %s" % [
-      Expression.quote(@members.first),
-      WindowExpression.new(&@block).to_sql
-    ]
-  end
-end
-
-class OrderBy < Expression
-  def to_sql
-    "order by %s" % @members.map { |e| Expression.quote(e) }.join(', ')
-  end
-end
-
-class Limit < Expression
-  def to_sql
-    "limit %d" % @members[0]
-  end
-end
-
-class Query
-  def initialize(**ctx, &block)
-    @ctx = ctx
-    @block = block
-  end
-
-  def to_sql(**ctx)
-    r = SQL.new(@ctx.merge(ctx))
-    r.to_sql(&@block)
-  end
-
-  def as(sym)
-    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
-end
-
-class SQL
-  def initialize(ctx)
-    @ctx = ctx
-  end
-
-  def to_sql(&block)
-    instance_eval(&block)
-    [
-      @with,
-      @select || default_select,
-      @from,
-      @where,
-      @window,
-      @order_by,
-      @limit
-    ].compact.map { |c| c.to_sql }.join(' ')
-  end
-
-  def _q(expr)
-    QuotedExpression.new(expr)
-  end
-
-  def default_select
-    Select.new(:*)
-  end
-
-  def method_missing(sym, *args)
-    if @ctx.has_key?(sym)
-      value = @ctx[sym]
-      return Symbol === value ? Identifier.new(value) : value
-    end
-    
-    super if sym == :to_hash
-    if args.empty?
-      Identifier.new(sym)
-    else
-      FunctionCall.new(sym, *args)
-    end
-  end
-
-  def with(*members, **props)
-    @with = With.new(*members, **props)
-  end
-
-  H_EMPTY = {}.freeze
-
-  def select(*members, **props)
-    if members.empty? && !props.empty?
-      members = props.map { |k, v| Alias.new(v, k) }
-      props = {}
-    end
-    @select = Select.new(*members, **props)
-  end
-
-  def from(*members, **props)
-    @from = From.new(*members, **props)
-  end
-
-  def where(expr)
-    if @where
-      @where.members << expr
-    else
-      @where = Where.new(expr)
-    end
-  end
-
-  def window(sym, &block)
-    @window = Window.new(sym, &block)
-  end
-
-  def order_by(*members, **props)
-    @order_by = OrderBy.new(*members, **props)
-  end
-
-  def limit(*members)
-    @limit = Limit.new(*members)
-  end
-
-  def all(sym = nil)
-    if sym
-      Identifier.new("#{sym}.*")
-    else
-      Identifier.new('*')
-    end
-  end
-end
+module Eno
+  include_from('./eno/expressions')
+  SQL   = import('./eno/sql')::SQL
+  Query = import('./eno/query')::Query
+end