mongo_ql 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54ebbab82b00ce95966996491caf76cea95683f8f88be3676f15655c836ffa6b
-  data.tar.gz: 4e9bd70e840f6f2c118fcba06e8d086ceca67d42bfa8ecd82d3cf8412dd9191e
+  metadata.gz: 39d6acd8e471a93e4b6598473110d45935c2f17a1bae9ac2c65435669cd054fb
+  data.tar.gz: 0b1efe2e91c015963e9cd0f90b291d14b2b2d0cff55f0c02a3a646327b349ca2
 SHA512:
-  metadata.gz: 591efcb215b9769e6be3e4cdbf0d493a6c3800042fec75a649852afd0901b25916ad063516a3f46af05b9a44bdb62eb5cd719f754624d7b15135e85177e3e7d3
-  data.tar.gz: 586002d366b3d6f264ee8e6621297679febed34b869e6a9c94d4e9698d64a58a07d663b275d313682bef6d7ef16edf1187bd535503312e67acc53abdaea17264
+  metadata.gz: ae59e895897c0c23d05b1ad1d2063b0b5f543712876abdd1bb2edd1c75b28dc69686d0dfc1a49c049e61a983920a3e879964a1bf927327a19454377ebcc180c8
+  data.tar.gz: 47d606ac87f2c577cd2ea0cb16915f883cafa393b32bd44ccc6a54969fd14404703fff0a5ecfd1928c439d123c58a5dc2966f2553ce73e1ce91f638876a3d5da

data/.gitignore

@@ -6,4 +6,5 @@
 /doc/
 /pkg/
 /spec/reports/
-/tmp/
+/tmp/
+/*.gem

data/bin/console

@@ -3,5 +3,15 @@
 require "bundler/setup"
 require "./lib/mongo_ql"
 
+include MongoQL
+
+define_singleton_method(:method_missing) do |m, *_args, &_block|
+  MongoQL::Expression::FieldNode.new(m)
+end
+
+define_singleton_method(:aggregate) do |*variables, &block|
+  MongoQL.compose(*variables, &block)
+end
+
 require "irb"
 IRB.start

data/design_specs.md

@@ -16,9 +16,9 @@ Order.where { total  >= If(currency == "CAD", 100, 80) }
 # Aggregation Pipeline DSL
 ```ruby
 Order.all.mongo_ql do
-  join    Customer, 
-          :customer_id => _id,
-          :as          => customers
+  join    Customer,
+          on: customer_id == _id.to_id, 
+          as: customers
 
   join    Shipping, :as => shippings do
     match  order_id == doc._id, 
@@ -26,7 +26,7 @@ Order.all.mongo_ql do
   end
 
   match   province == "ON"
-
+  
   project :_id, 
           :total, 
           :customer  => customers.name,
@@ -35,6 +35,11 @@ Order.all.mongo_ql do
   group   customer, 
           :total     => total.sum,
           :total_tax => tax.sum * 5
+
+  sort_by age.desc
+
+  page 1
+  per  10
 end
 
 # The above aggregation is equivalent to the following mognodb pipeline

data/lib/mongo_ql/binary_operators.rb

@@ -8,11 +8,17 @@ module MongoQL
       "*":  "$multiply",
       "/":  "$divide",
       ">":  "$gt",
+      "gt?":  "$gt",
       "<":  "$lt",
+      "lt?":  "$lt",
       ">=": "$gte",
+      "gte?":  "$gte",
       "<=": "$lte",
+      "lte?":  "$lte",
       "!=": "$ne",
+      "neq?":  "$ne",
       "==": "$eq",
+      "eq?":  "$eq",
       "&":  "$and",
       "|":  "$or",
       "%":  "$mod",

data/lib/mongo_ql/expression/ascend.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module MongoQL
+  class Expression::Ascend < Expression
+    attr_accessor :field
+
+    def initialize(field)
+      @field = field
+    end
+
+    def to_ast
+      { field.to_s => 1 }
+    end
+  end
+end

data/lib/mongo_ql/expression/descend.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module MongoQL
+  class Expression::Descend < Expression
+    attr_accessor :field
+
+    def initialize(field)
+      @field = field
+    end
+
+    def to_ast
+      { field.to_s => -1 }
+    end
+  end
+end

data/lib/mongo_ql/expression/field_node.rb

@@ -19,5 +19,21 @@ module MongoQL
     def to_ast
       "$#{field_name}"
     end
+
+    def to_s
+      field_name.to_s
+    end
+
+    def name
+      field_name.to_s
+    end
+
+    def dsc
+      Expression::Descend.new(self)
+    end
+
+    def asc
+      Expression::Ascend.new(self)
+    end
   end
 end

data/lib/mongo_ql/expression/projection.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module MongoQL
+  class Expression::Projection < Expression
+    attr_accessor :field, :expression
+
+    def initialize(field, expression = 1)
+      @expression = case expression
+                    when 0, 1
+                      expression
+                    when Expression::FieldNode
+                      expression
+                    else
+                      raise ArgumentError, "#{expression&.inspect} is not a valid project expression"
+                    end
+
+      @field = case field
+               when String, Symbol
+                 Expression::FieldNode.new(field)
+               when Expression::FieldNode
+                 field
+               else
+                 raise ArgumentError, "#{field&.inspect} is not a valid project field"
+               end
+    end
+
+    def to_ast
+      { field.to_s => expression }
+    end
+  end
+end

data/lib/mongo_ql/stage/group.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module MongoQL
+  class Stage::Group < Stage
+    EXPRESSION_TO_AST_MAPPER = proc { |v| v.is_a?(Expression) ? v.to_ast : v  }
+
+    attr_accessor :by, :fields
+
+    def initialize(by, arrow_fields = {}, **fields)
+      @by     = by
+      @fields = fields.transform_keys(&:to_s).merge(arrow_fields.transform_keys(&:to_s))
+    end
+
+    def to_ast
+      {
+        "$group" => {
+          "_id" => by.to_ast,
+        }.merge(fields.transform_values(&EXPRESSION_TO_AST_MAPPER))
+      }
+    end
+  end
+end

data/lib/mongo_ql/stage/lookup.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module MongoQL
+  class Stage::Lookup < Stage
+    class NestedPipelineVars
+      attr_accessor :vars
+
+      def initialize
+        @vars = {}
+      end
+
+      def method_missing(m, *args, &block)
+        if is_setter?(m)
+          set(m, args.first)
+        else
+          get(m)
+        end
+      end
+
+      def get(name)
+        vars["var_#{name}"] ||= Expression::FieldNode.new(name)
+        Expression::FieldNode.new("$var_#{name}")
+      end
+
+      def set(name, val)
+        vars["var_#{name.to_s[0..-2]}"] = val
+      end
+
+      private
+        def is_setter?(method_name)
+          method_name.to_s.end_with?("=")
+        end
+    end
+
+    attr_accessor :from, :condition, :as, :nested_pipeline_block, :let_vars
+
+    def initialize(from, condition = nil, on: nil, as: nil, &block)
+      @from      = collection_name(from)
+      @as        = new_array_name(as)
+      @nested_pipeline_block = block
+
+      if has_nested_pipeline?
+        @let_vars = NestedPipelineVars.new
+      else
+        @condition = condition_ast(condition || on)
+      end
+    end
+
+    def to_ast
+      lookup_expr = { "from" => from, "as" => as }
+      if has_nested_pipeline?
+        lookup_expr["pipeline"] = nested_pipeline.to_ast
+        lookup_expr["let"]      = let_vars.vars
+      else
+        lookup_expr = lookup_expr.merge(condition)
+      end
+      { "$lookup" => lookup_expr }
+    end
+
+    private
+      def has_nested_pipeline?
+        condition.nil? && !nested_pipeline_block.nil?
+      end
+
+      def nested_pipeline
+        sub_ctx = StageContext.new
+        sub_ctx.instance_exec(let_vars, &nested_pipeline_block)
+        sub_ctx
+      end
+
+      def collection_name(from)
+        case from
+        when String, Symbol
+          from
+        when Expression::FieldNode
+          from.to_s
+        else
+          if from&.respond_to?(:collection)
+            from&.collection&.name
+          elsif  from&.respond_to?(:name)
+            from.name
+          else
+            raise ArgumentError, "#{from} is not a valid collection"
+          end
+        end
+      end
+
+      def condition_ast(cond)
+        raise ArgumentError, "#{cond.inspect} must be a valid Expression::Binary, example: _id == user_id" unless cond.is_a?(Expression::Binary)
+        raise ArgumentError, "#{cond.inspect} must be an 'equal' expression, example: _id == user_id" unless cond.operator == "$eq"
+        {
+          "localField"   => cond&.left_node&.to_s,
+          "foreignField" => cond&.right_node&.to_s
+        }
+      end
+
+      def new_array_name(as)
+        as&.to_s
+      end
+  end
+end

data/lib/mongo_ql/stage/match.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module MongoQL
+  class Stage::Match < Stage
+    attr_accessor :conditions, :field_filters
+
+    def initialize(*conds, **field_filters)
+      conds.each do |c|
+        raise ArgumentError, "#{c.inspect} is not a MongoQL::Expression" unless c.is_a?(MongoQL::Expression)
+      end
+      @conditions    = conds
+      @field_filters = field_filters
+    end
+
+    def to_ast
+      conds = {}
+      if conditions_ast
+        conds["$expr"] = conditions_ast
+      end
+      { "$match" => conds.merge(field_filters) }
+    end
+
+    private
+      def conditions_ast
+        if conditions.size > 1
+          { "$and" => conditions.map(&:to_ast) }
+        elsif conditions.size == 1
+          conditions[0].to_ast
+        else
+          nil
+        end
+      end
+  end
+end

data/lib/mongo_ql/stage/project.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module MongoQL
+  class Stage::Project < Stage
+    attr_accessor :field_projections
+
+    def initialize(*fields)
+      @field_projections = fields.map do |field|
+                              case field
+                              when String, Symbol, Expression::FieldNode
+                                { field.to_s => 1 }
+                              when Hash
+                                field.map { |k, v| [k.to_s, to_expression(v).to_ast] }.to_h
+                              else
+                                raise ArgumentError, "#{field} is not a valid field mapping option"
+                              end
+                            end.inject({}) { |p, c| p.merge(c) }
+    end
+
+    def to_ast
+      { "$project" => field_projections }
+    end
+
+    protected
+      def to_expression(val)
+        if val.is_a?(Expression)
+          val
+        else
+          Expression::ValueNode.new(val)
+        end
+      end
+  end
+end

data/lib/mongo_ql/stage/sort.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module MongoQL
+  class Stage::Sort < Stage
+    attr_accessor :fields
+
+    def initialize(*fields)
+      @fields = fields.map do |field|
+        case field
+        when Expression::FieldNode
+          field.asc
+        when String, Symbol
+          Expression::FieldNode.new(field).asc
+        when Expression::Ascend, Expression::Descend
+          field
+        else
+          raise ArgumentError, "#{field.inspect} must be in type [String, Symbol, Expression::FieldNode, Expression::Ascend, Expression::Descend]"
+        end
+      end
+    end
+
+    def to_ast
+      {
+        "$sort" => fields.inject({}) { |p, c| p.merge(c.to_ast) }
+      }
+    end
+  end
+end

data/lib/mongo_ql/stage/unwind.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module MongoQL
+  class Stage::Unwind < Stage
+    attr_accessor :path, :allow_null
+
+    def initialize(path, allow_null: false)
+      @path       = path.is_a?(Expression) ? path.to_ast : path
+      @allow_null = allow_null
+    end
+
+    def to_ast
+      {
+        "$unwind" => {
+          "path" => path,
+          "preserveNullAndEmptyArrays" => allow_null
+        }
+      }
+    end
+  end
+end

data/lib/mongo_ql/stage.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module MongoQL
+  class Stage
+    
+    def to_ast
+      raise NotImplementedError, "stage #{self.class} must implement to_ast"
+    end
+  end
+end

data/lib/mongo_ql/stage_context.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module MongoQL
+  class StageContext
+    attr_accessor :pipeline
+
+    def initialize
+      @pipeline = []
+    end
+
+    def where(*args)
+      pipeline << Stage::Match.new(*args)
+    end
+    alias_method :match, :where
+
+    def add_fields(*args)
+      raise NotImplementedError, "add_fields is not implemented"
+    end
+
+    def project(*fields)
+      pipeline << Stage::Project.new(*fields)
+    end
+    alias_method :select, :project
+
+    def lookup(*args, &block)
+      pipeline << Stage::Lookup.new(*args, &block)
+    end
+    alias_method :join, :lookup
+
+    def group(*args)
+      pipeline << Stage::Group.new(*args)
+    end
+
+    def unwind(*args)
+      pipeline << Stage::Unwind.new(*args)
+    end
+    alias_method :flatten, :unwind
+
+    def sort(*args)
+      pipeline << Stage::Sort.new(*args)
+    end
+    alias_method :sort_by, :sort
+
+    def method_missing(m, *args, &block)
+      Expression::FieldNode.new(m)
+    end
+
+    def first_of(*field_expressions)
+      field_expressions.map do |expr|
+        [expr, expr.first]
+      end.to_h
+    end
+
+    def f(name)
+      Expression::FieldNode.new(name)
+    end
+
+    def v(val)
+      Expression::ValueNode.new(val)
+    end
+
+    def to_ast
+      stages = pipeline.map(&:to_ast)
+      stages.map do |stage|
+        stage.deep_transform_values do |v|
+          v.is_a?(Expression) ? v.to_ast : v
+        end
+      end
+    end
+
+    %w(where match project select sort flatten unwind lookup join).each do |m|
+      alias_method :"#{m.capitalize}", m
+    end
+  end
+end

data/lib/mongo_ql/string_operators.rb

@@ -16,5 +16,11 @@ module MongoQL
         }
       }
     end
+
+    def concat(*expressions)
+      Expression::MethodCall.new "$concat", self, ast_template: -> (target, **_args) {
+        [target, *expressions.map { |e| to_expression(e) }.map(&:to_ast)]
+      }
+    end
   end
 end

data/lib/mongo_ql/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MongoQL
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/mongo_ql.rb

@@ -1,6 +1,36 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/hash"
+require "logger"
 module MongoQL
+  class InvalidVariableAccess < StandardError; end
+
+  def self.compose(*variable_names, &block)
+    block_binding = block.binding
+    ctx = MongoQL::StageContext.new
+
+    variables = variable_names.map do |name|
+      [name, block_binding.local_variable_get(name)]
+    end.to_h
+
+    # Update injected local variables to ValueNode expressions
+    variable_names.each do |name|
+      block_binding.local_variable_set(name, Expression::ValueNode.new(variables[name]))
+    end
+
+    ctx.instance_exec(*variables, &block)
+
+    # Restore local variables
+    variable_names.each do |name|
+      block_binding.local_variable_set(name, variables[name])
+    end
+
+    ctx
+  end
+
+  def self.logger
+    @logger ||= Logger.new($stdout)
+  end
 end
 
 require_relative "mongo_ql/version"
@@ -10,4 +40,18 @@ require_relative "mongo_ql/expression/field_node"
 require_relative "mongo_ql/expression/value_node"
 require_relative "mongo_ql/expression/method_call"
 require_relative "mongo_ql/expression/binary"
-require_relative "mongo_ql/expression/unary"
+require_relative "mongo_ql/expression/unary"
+
+require_relative "mongo_ql/expression/descend"
+require_relative "mongo_ql/expression/ascend"
+require_relative "mongo_ql/expression/projection"
+
+require_relative "mongo_ql/stage"
+require_relative "mongo_ql/stage/project"
+require_relative "mongo_ql/stage/lookup"
+require_relative "mongo_ql/stage/match"
+require_relative "mongo_ql/stage/group"
+require_relative "mongo_ql/stage/unwind"
+require_relative "mongo_ql/stage/sort"
+
+require_relative "mongo_ql/stage_context"

data/mongo_ql.gemspec

@@ -18,4 +18,6 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "activesupport" 
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: mongo_ql
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Xizheng Ding
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-09 00:00:00.000000000 Z
-dependencies: []
+date: 2019-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - dingxizheng@gamil.com
@@ -30,12 +44,23 @@ files:
 - lib/mongo_ql/collection_operators.rb
 - lib/mongo_ql/date_operators.rb
 - lib/mongo_ql/expression.rb
+- lib/mongo_ql/expression/ascend.rb
 - lib/mongo_ql/expression/binary.rb
 - lib/mongo_ql/expression/date_note.rb
+- lib/mongo_ql/expression/descend.rb
 - lib/mongo_ql/expression/field_node.rb
 - lib/mongo_ql/expression/method_call.rb
+- lib/mongo_ql/expression/projection.rb
 - lib/mongo_ql/expression/unary.rb
 - lib/mongo_ql/expression/value_node.rb
+- lib/mongo_ql/stage.rb
+- lib/mongo_ql/stage/group.rb
+- lib/mongo_ql/stage/lookup.rb
+- lib/mongo_ql/stage/match.rb
+- lib/mongo_ql/stage/project.rb
+- lib/mongo_ql/stage/sort.rb
+- lib/mongo_ql/stage/unwind.rb
+- lib/mongo_ql/stage_context.rb
 - lib/mongo_ql/string_operators.rb
 - lib/mongo_ql/unary_operators.rb
 - lib/mongo_ql/version.rb