mongery 0.0.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1124d4cc8a8887a26daf6cd0167b395692eb2b80
-  data.tar.gz: e0cc0961e38626e40cc26f079471e0e0c52186c2
+  metadata.gz: f07b3b2676098909d2b127f75970b95b4e4be027
+  data.tar.gz: 9d5c86b70c843e233ebeb5d101c44e6f9ddef6ae
 SHA512:
-  metadata.gz: e4de70968015998d26f1bd15e15e8e08c24a67356ae1ba3351f1be7ca6baed823a8c7688bab266b3fddb7dd9a31cbdfbb5540b1e81d06235bea504ab5e294409
-  data.tar.gz: 8861688d905bb127308cde48cd9797903d00620f500c15d89413527a20fce2bca18262af44761ee237611eb4923576f0c7dbf0abc33a414c8b21a096cf13454b
+  metadata.gz: 0442d0f7cf0f20fbf742fb5ece86d0bbed8f68642141742bcf2ef071c5bc78880d3bdef67e80a3f9b3eda7986695cdff66abe3baa308387746fb2cbb12f7bc35
+  data.tar.gz: 258eb17e770f85b4ae08e1700429b77c9a6867dfd3137b002eba77caaeb774e6815bce2b3cfdde6307403f960c6dd70cdf7db03dbf912143b7e6029c07f2e88c

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 1.0.0 (2014/12/9)
+- This is a MAJOR update and is incompatible to the previous version
+- All JSON fields are now represented with JSON path (`data#>>{path}`)
+- $in query is now translated to SQL IN
+- More accurate comparison with nil or numeric values
+- operators such as $lt, $gt can be used at the same time to chain them with AND
+- Supports partial JSON value match when you don't use $- operators
+- Supports casting JSON value based on JSON Schema rather than based on the bound values.
+
 ## 0.0.5 (2014/11/10)
 - Use JSON path expression for nested data to avoid errors like "cannot extract element from a scalar"
 

data/README.md

@@ -6,7 +6,7 @@ This could be useful in situations where you migrate off of MongoDB backend to P
 
 ## Limitation
 
-Currently, Mongery supports the limited set of queries to use with PostgreSQL 9.3. Most query on JSON data will end up with the full table scan. Index using hstore columns and/or 9.4 `jsonb` types are planned but not implemented.
+Currently, Mongery supports the limited set of queries to use with PostgreSQL 9.3. Most query on JSON data will end up with the full table scan, unless you manually create expression index for the JSON path you want to query on.
 
 See the spec file in `spec` directory for the supported conversion.
 
@@ -31,18 +31,47 @@ builder.find({ _id: 'abcd' }).limit(1).to_sql
 # => SELECT data FROM objects WHERE id = 'abcd' LIMIT 1
 
 builder.find({ age: {"$gte" => 21 } }).sort({ name: -1 }).to_sql
-# => SELECT data FROM objects WHERE (data->>'age')::integer >= 21 ORDER BY data->>'name' DESC
+# => SELECT data FROM objects WHERE (data#>>'{age}')::integer >= 21 ORDER BY data#>>'{name}' DESC
+
+builder.find({ "address.city": {"$in" => ["San Francisco", "Tokyo"] } })
+# => SELECT data FROM objects WHERE data#>>'{address,city}' IN ("San Francisco", "Tokyo")
 
 builder.insert({ _id: 'foobar' }).to_sql
 # => INSERT INTO "objects" ("id", "data") VALUES ('foobar', '{"_id":"foobar"}')
 
 builder.find({ age: {"$gte" => 21 } }).update({ name: "John" }).to_sql
-# => UPDATE "objects" SET "data" = '{"name":"John"}' WHERE (data->>'age')::integer >= 21
+# => UPDATE "objects" SET "data" = '{"name":"John"}' WHERE (data#>>'{age}')::integer >= 21
 
 builder.find({ age: {"$eq" => 55 } }).delete.to_sql
-# => DELETE FROM "objects" WHERE (data->>'age')::integer = 21
+# => DELETE FROM "objects" WHERE (data#>>'{age}')::integer = 21
+```
+
+### Type Casting
+
+By default, types are dynamically casted depending on the query values.
+
+```ruby
+builder.find({ age: {"$eq" => 55 } }).to_sql
+# => SELECT FROM "objects" WHERE (data#>>'{age}')::integer = 21
 ```
 
+Mongery has an **experimental support** for JSON Schema. You can pass JsonSchema::Schema object created with [json_schema gem](https://github.com/brandur/json_schema) to the Mongery::Builder constructor, to make it cast the query type based on the schema rather than the bound value.
+
+```ruby
+schema_data = {
+  "type" => "object",
+  "properties" => {
+    "name" => {
+      "type" => "string"
+    },
+  },
+}
+schema = JsonSchema.parse!(schema_data)
+
+builder = Mongery::Builder.new(:objects, ActiveRecord::Base, schema)
+```
+
+
 ## See Also
 
 * [mosql](https://github.com/stripe/mosql)

data/lib/mongery.rb

@@ -1,29 +1,32 @@
 require "mongery/version"
+require "mongery/schema"
 require "arel"
 
 module Mongery
   class Builder
-    attr_reader :model, :table
+    attr_reader :model, :table, :schema
 
-    def initialize(model, engine = ActiveRecord::Base)
+    def initialize(model, engine = ActiveRecord::Base, schema = nil)
       @model = model
       @table = Arel::Table.new(model, engine)
+      @schema = Schema.new(schema) if schema
     end
 
     def find(*args)
-      Query.new(table).where(*args)
+      Query.new(table, schema).where(*args)
     end
 
     def insert(*args)
-      Query.new(table).insert(*args)
+      Query.new(table, schema).insert(*args)
     end
   end
 
   class Query
-    attr_reader :table
+    attr_reader :table, :schema
 
-    def initialize(table)
+    def initialize(table, schema)
       @table = table
+      @schema = schema
       @condition = nil
     end
 
@@ -102,102 +105,183 @@ module Mongery
     end
 
     def translate(query)
-      chain(:and, query.map { |col, value| translate_cv(col, value) })
+      chain(:and, query.map {|col, value| translate_cv(col, value) })
     end
 
     def translate_cv(col, value)
       case col.to_s
-      when "_id"
-        translate_value(table[:id], value)
       when "$or"
         chain(:or, value.map {|q| translate(q) })
       when "$and"
-        chain(:and, value.map { |q| translate(q) })
+        chain(:and, value.map {|q| translate(q) })
       when /^\$/
         raise UnsupportedQuery, "Unsupported operator #{col}"
+      when "_id"
+        translate_value(table[:id], value)
       else
-        translate_value_json(sql_json_path(col), value)
+        if schema
+          translate_value_schema(col, sql_json_path(col), value)
+        else
+          translate_value_dynamic(sql_json_path(col), value)
+        end
       end
     end
 
-    def translate_value(col, value, json = false)
+    OPERATOR_MAP = {
+      "$in" => :in, "$eq" => :eq, "$ne" => :not_eq,
+      "$gt" => :gt, "$gte" => :gteq, "$lt" => :lt, "$lte" => :lteq,
+    }
+
+    def translate_value(col, value)
       case value
       when Hash
-        ops = value.keys
-        if ops.size > 1
-          raise UnsupportedQuery, "Multiple operator supported: #{ops.join(", ")}"
-        end
-
-        val = value[ops.first]
-        case ops.first
-        when "$in"
-          col.in(val)
-        when "$gt", "$gte", "$lt", "$lte"
-          col.send(COMPARE_MAPS[ops.first], val)
-        when "$eq"
-          col.eq(val)
-        when "$ne"
-          col.not_eq(val)
-        when /^\$/
-          raise UnsupportedQuery, "Unknown operator #{ops.first}"
+        if has_operator?(value)
+          chain(:and, value.map {|op, val|
+                  if OPERATOR_MAP.key?(op)
+                    col.send(OPERATOR_MAP[op], val)
+                  else
+                    raise UnsupportedQuery, "Unknown operator #{op}"
+                  end
+                })
+        else
+          col.eq(value.to_json)
         end
       else
         col.eq(value)
       end
     end
 
-    COMPARE_MAPS = { "$gt" => :gt, "$gte" => :gteq, "$lt" => :lt, "$lte" => :lteq }
+    def translate_value_dynamic(col, value)
+      case value
+      when String, TrueClass, FalseClass
+        compare(col, value.to_s, :eq)
+      when Numeric, NilClass
+        compare(col, value, :eq)
+      when Hash
+        if has_operator?(value)
+          chain(:and, value.map {|op, val|
+                  case op
+                  when "$in"
+                    if val.all? {|v| v.is_a? Numeric }
+                      wrap(col, val.first).in(val)
+                    else
+                      col.in(val.map(&:to_s))
+                    end
+                  when "$eq", "$ne", "$gt", "$gte", "$lt", "$lte"
+                    compare(col, val, OPERATOR_MAP[op])
+                  else
+                    raise UnsupportedQuery, "Unknown operator #{op}"
+                  end
+                })
+        else
+          col.eq(value.to_json)
+        end
+      else
+        col.eq(value.to_json)
+      end
+    end
 
-    def translate_value_json(col, value, json = false)
+    def translate_value_schema(column, col, value)
+      type = schema.column_type(column.to_s)
       case value
-      when String, Numeric, TrueClass, FalseClass
-        # in Postgres 9.3, you can't compare numeric
-        col.eq(value.to_s)
-      when NilClass
-        # You can't use IS NULL
-        col.eq('')
       when Hash
-        ops = value.keys
-        if ops.size > 1
-          raise UnsupportedQuery, "Multiple operator supported: #{ops.join(", ")}"
+        if has_operator?(value)
+          chain(:and, value.map {|op, val|
+                  case op
+                  when "$in"
+                    case type
+                    when "array"
+                      chain(:or, val.map { |v| col.matches(%Q[%"#{v}"%]) })
+                    else
+                      compare_schema(col, val, type, :in)
+                    end
+                  when "$eq", "$ne", "$gt", "$gte", "$lt", "$lte"
+                     compare_schema(col, val, type, OPERATOR_MAP[op])
+                  else
+                    raise UnsupportedQuery, "Unknown operator #{op}"
+                  end
+                })
+        else
+          col.eq(value.to_json)
         end
+      when String, Numeric, NilClass
+        compare_schema(col, value, type, :eq)
+      else
+        compare_schema(col, value.to_json, type, :eq)
+      end
+    end
 
-        val = value[ops.first]
-        case ops.first
-        when "$in"
-          chain(:or, val.map { |val| col.matches(%Q[%"#{val}"%]) })
-        when "$gt", "$gte", "$lt", "$lte"
-          wrap_numeric(col, val).send(COMPARE_MAPS[ops.first], val)
-        when "$eq"
-          wrap_numeric(col, val).eq(val)
-        when "$ne"
-          wrap_numeric(col, val).not_eq(val)
-        when /^\$/
-          raise UnsupportedQuery, "Unknown operator #{ops.first}"
+    def translate_value_dynamic(col, value)
+      case value
+      when String, TrueClass, FalseClass
+        col.eq(value.to_s)
+      when Numeric, NilClass
+        compare(col, value, :eq)
+      when Hash
+        if has_operator?(value)
+          chain(:and, value.map {|op, val|
+                  case op
+                  when "$in"
+                    if val.all? {|v| v.is_a? Numeric }
+                      wrap(col, val.first).in(val)
+                    else
+                      col.in(val.map(&:to_s))
+                    end
+                  when "$eq", "$ne", "$gt", "$gte", "$lt", "$lte"
+                    compare(col, val, OPERATOR_MAP[op])
+                  else
+                    raise UnsupportedQuery, "Unknown operator #{op}"
+                  end
+                })
+        else
+          col.eq(value.to_json)
         end
+      else
+        col.eq(value.to_json)
       end
     end
 
-    def wrap_numeric(col, val)
+    def has_operator?(value)
+      value.keys.any? {|key| key =~ /^\$/ }
+    end
+
+    def compare(col, val, op)
+      wrap(col, val).send(op, val)
+    end
+
+    def wrap(col, val)
       case val
-      when Float
-        Arel.sql("(#{col})::float")
-      when Integer
-        Arel.sql("(#{col})::integer")
+      when NilClass
+        # data#>>'{foo}' IS NULL    is invalid
+        # (data#>>'{foo}') IS NULL  is valid
+        Arel.sql("(#{col})")
+      when Numeric
+        Arel.sql("(#{col})::numeric")
       else
         col
       end
     end
 
-    def sql_json_path(col)
-      paths = col.to_s.split('.')
-      if paths.size > 1
-        Arel.sql("data#>>#{json_pathize(paths)}")
+    def compare_schema(col, val, type, op)
+      wrap_schema(col, type).send(op, val)
+    end
+
+    def wrap_schema(col, type)
+      case type
+      when "string"
+        Arel.sql("(#{col})")
+      when "number", "integer"
+        Arel.sql("(#{col})::numeric")
       else
-        Arel.sql("data->>#{quote(paths.first)}")
+        col
       end
     end
 
+    def sql_json_path(col)
+      paths = col.to_s.split('.')
+      Arel.sql("data#>>#{json_pathize(paths)}")
+    end
+
     def json_pathize(paths)
       quote("{#{paths.join(',')}}")
     end

data/lib/mongery/schema.rb

@@ -0,0 +1,32 @@
+module Mongery
+  class Schema
+    VALID_TYPES = ["array", "boolean", "integer", "number", "null", "object", "string"]
+
+    def initialize(schema)
+      @schema = schema
+    end
+
+    def property(col)
+      @schema.properties[col]
+    end
+
+    def column_type(col)
+      value = type_value(col)
+      if VALID_TYPES.include?(value)
+        value
+      else
+        nil
+      end
+    end
+
+    def type_value(col)
+      type = property(col).try(:type)
+      case type
+      when Array
+        (type - ["null"]).first
+      else
+        type
+      end
+    end
+  end
+end

data/lib/mongery/version.rb

@@ -1,3 +1,3 @@
 module Mongery
-  VERSION = "0.0.5"
+  VERSION = "1.0.0"
 end

data/mongery.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "activerecord", ">= 4.0.0"
   spec.add_development_dependency "pg"
+  spec.add_development_dependency "json_schema"
 end

data/spec/mongery/builder_schema_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'json_schema'
+
+describe Mongery::Builder do
+  queries = [
+    [ { name: "foo" },
+      /WHERE \(data#>>'{name}'\) = 'foo'$/ ],
+    [ { weight: { "$gt" => 66 } },
+      /WHERE \(data#>>'{weight}'\)::numeric > 66$/ ],
+    [ { weight: { "$gt" => 66.0 } },
+      /WHERE \(data#>>'{weight}'\)::numeric > 66\.0$/ ],
+    [ { name: { "$in" => ["John", "Bob"] } },
+      /WHERE \(data#>>'{name}'\) IN \('John', 'Bob'\)$/ ],
+    [ { age: { '$ne' => 10 }},
+      /WHERE \(data#>>'{age}'\)::numeric != 10/ ],
+    [ { tag: {"$in" => [ "food", "recipe" ]} },
+      /WHERE \(data#>>'{tag}' ILIKE '%"food"%' OR data#>>'{tag}' ILIKE '%"recipe"%'\)$/ ],
+    [ { active: true },
+      /WHERE data#>>'{active}' = 'true'$/ ],
+  ]
+
+  schema = JsonSchema.parse!(JSON.parse(<<-EOF))
+  {
+   "type": "object",
+   "properties": {
+    "name": {
+     "type": ["string", "null"]
+    },
+    "weight":{
+     "type": "number"
+    },
+    "age":{
+     "type": ["integer", "null"]
+    },
+    "tag":{
+     "type": "array"
+    },
+    "active":{
+     "type": "boolean"
+    }
+   }
+  }
+  EOF
+
+  builder = Mongery::Builder.new(:test, ActiveRecord::Base, schema)
+
+  queries.each do |query, sql|
+    context "with query #{query}" do
+      subject do
+        builder.find(query).to_sql
+      end
+      it { should match sql }
+    end
+  end
+end

data/spec/mongery/builder_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Mongery::Builder do
-  tests = [
+  queries = [
     [ { }, { },
       /^SELECT "test"\."data" FROM "test"$/ ],
     [ { _id: "foo" }, { },
@@ -15,56 +15,73 @@ describe Mongery::Builder do
     [ { _id: "foo" }, { skip: 10, sort: { _id: 1 } },
       /WHERE "test"\."id" = 'foo'  ORDER BY "test"\."id" ASC OFFSET 10$/ ],
     [ { _id: "foo" }, { sort: { name: -1, email: 1 } },
-      /WHERE "test"\."id" = 'foo'  ORDER BY data->>'name' DESC, data->>'email' ASC$/ ],
+      /WHERE "test"\."id" = 'foo'  ORDER BY data#>>'{name}' DESC, data#>>'{email}' ASC$/ ],
     [ { "_id" => "foo" }, { },
       /WHERE "test"\."id" = 'foo'$/ ],
     [ { name: "foo" }, { },
-      /WHERE data->>'name' = 'foo'$/ ],
+      /WHERE data#>>'{name}' = 'foo'$/ ],
+    [ { name: "" }, { },
+      /WHERE data#>>'{name}' = ''$/ ],
     [ { name: nil }, { },
-      /WHERE data->>'name' = ''$/ ],
+      /WHERE \(data#>>'{name}'\) IS NULL$/ ],
     [ { name: "foo", other: "bar" }, { },
-      /WHERE data->>'name' = 'foo' AND data->>'other' = 'bar'/ ],
+      /WHERE data#>>'{name}' = 'foo' AND data#>>'{other}' = 'bar'/ ],
     [ { "x'y" => "foo" }, { },
-      /WHERE data->>'x''y' = 'foo'/ ],
+      /WHERE data#>>'{x''y}' = 'foo'/ ],
     [ { weight: 66 }, { },
-      /WHERE data->>'weight' = '66'$/ ],
+      /WHERE \(data#>>'{weight}'\)::numeric = 66$/ ],
     [ { weight: { "$gt" => 66 } }, { },
-      /WHERE \(data->>'weight'\)::integer > 66$/ ],
+      /WHERE \(data#>>'{weight}'\)::numeric > 66$/ ],
     [ { weight: { "$gt" => 66.0 } }, { },
-      /WHERE \(data->>'weight'\)::float > 66\.0$/ ],
+      /WHERE \(data#>>'{weight}'\)::numeric > 66\.0$/ ],
     [ { weight: { "$lte" => 66 } }, { },
-      /WHERE \(data->>'weight'\)::integer <= 66$/ ],
+      /WHERE \(data#>>'{weight}'\)::numeric <= 66$/ ],
     [ { age: { '$eq' => 10 }}, { },
-      /WHERE \(data->>'age'\)::integer = 10/ ],
+      /WHERE \(data#>>'{age}'\)::numeric = 10/ ],
     [ { age: { '$ne' => 10 }}, { },
-      /WHERE \(data->>'age'\)::integer != 10/ ],
+      /WHERE \(data#>>'{age}'\)::numeric != 10/ ],
     [ { bool: true }, { },
-      /WHERE data->>'bool' = 'true'$/ ],
+      /WHERE data#>>'{bool}' = 'true'$/ ],
     [ { 'email.address' => 'john@example.com' }, { },
       /WHERE data#>>'{email,address}' = 'john@example.com'$/ ],
     [ { "x'y.z" => 'john' }, { },
       /WHERE data#>>'{x''y,z}' = 'john'$/ ],
     [ { type: "food", "$or" => [{name: "miso"}, {name: "tofu"}]}, { },
-      /WHERE data->>'type' = 'food' AND \(data->>'name' = 'miso' OR data->>'name' = 'tofu'\)$/ ],
+      /WHERE data#>>'{type}' = 'food' AND \(data#>>'{name}' = 'miso' OR data#>>'{name}' = 'tofu'\)$/ ],
     [ { "$or" => [{ _id: "foo" }, { _id: "bar" }] }, { },
       /WHERE \("test"\."id" = 'foo' OR "test"\."id" = 'bar'\)$/ ],
     [ { "$or" => [{ name: "John" }, { weight: 120 }] }, { },
-      /WHERE \(data->>'name' = 'John' OR data->>'weight' = '120'\)$/ ],
+      /WHERE \(data#>>'{name}' = 'John' OR \(data#>>'{weight}'\)::numeric = 120\)$/ ],
     [ { "$and" => [{ _id: "foo" }, { name: "bar" }] }, { },
-      /WHERE "test"\."id" = 'foo' AND data->>'name' = 'bar'$/ ],
+      /WHERE "test"\."id" = 'foo' AND data#>>'{name}' = 'bar'$/ ],
     [ { "$and" => [{ name: "John" }, { weight: 120 }] }, { },
-      /WHERE data->>'name' = 'John' AND data->>'weight' = '120'$/ ],
+      /WHERE data#>>'{name}' = 'John' AND \(data#>>'{weight}'\)::numeric = 120$/ ],
     [ { "$and" => [{ "$or" => [{name: "John"}, {email: "john"}] }, {_id: "Bob"}] }, { },
-      /WHERE \(data->>'name' = 'John' OR data->>'email' = 'john'\) AND "test"\."id" = 'Bob'$/ ],
-    [ { ids: {"$in" => [ "foo" ]} }, { },
-      /WHERE data->>'ids' ILIKE '%"foo"%'$/ ],
-    [ { ids: {"$in" => [ "foo", "bar" ]} }, { },
-      /WHERE \(data->>'ids' ILIKE '%"foo"%' OR data->>'ids' ILIKE '%"bar"%'\)$/ ],
+      /WHERE \(data#>>'{name}' = 'John' OR data#>>'{email}' = 'john'\) AND "test"\."id" = 'Bob'$/ ],
+    [ { bar: {"$in" => [ "foo" ]} }, { },
+      /WHERE data#>>'{bar}' IN \('foo'\)$/ ],
+    [ { tag: {"$in" => [ 1, 2 ]} }, { },
+      /WHERE \(data#>>'{tag}'\)::numeric IN \(1, 2\)$/ ],
+    [ { bar: {"$in" => [ "foo", "bar" ]} }, { },
+      /WHERE data#>>'{bar}' IN \('foo', 'bar'\)$/ ],
+    [ { bar: {"$in" => [ "foo", 1.2 ]} }, { },
+      /WHERE data#>>'{bar}' IN \('foo', '1\.2'\)$/ ],
+    [ { bar: { foo: "bar", baz: [1,2,3]} }, { },
+      /WHERE data#>>'{bar}' = '{"foo":"bar","baz":\[1,2,3\]}'$/ ],
+    [ { "foo.bar" => true }, { },
+      /WHERE data#>>'{foo,bar}' = 'true'$/ ],
+  ]
+
+  bad_queries = [
+    { "$bar" => "foo" },
+    { "_id" => { "$bar" => 1 } },
+    { "foo" => { "$bar" => 1 } },
+    { "foo" => { "$lt" => 1, "gt" => 2 } },
   ]
 
   builder = Mongery::Builder.new(:test)
 
-  tests.each do |query, condition, sql|
+  queries.each do |query, condition, sql|
     context "with query #{query}" do
       subject do
         builder.find(query).tap { |q|
@@ -76,4 +93,13 @@ describe Mongery::Builder do
       it { should match sql }
     end
   end
+
+  bad_queries.each do |query|
+    context "with query #{query}" do
+      it "should throw UnsupportedQuery exception" do
+        expect { builder.find(query).to_sql }
+          .to raise_error(Mongery::UnsupportedQuery)
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongery
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 1.0.0
 platform: ruby
 authors:
 - Tatsuhiko Miyagawa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-11 00:00:00.000000000 Z
+date: 2014-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: arel
@@ -68,6 +68,20 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -81,7 +95,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pg
+  name: json_schema
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -108,8 +122,10 @@ files:
 - README.md
 - Rakefile
 - lib/mongery.rb
+- lib/mongery/schema.rb
 - lib/mongery/version.rb
 - mongery.gemspec
+- spec/mongery/builder_schema_spec.rb
 - spec/mongery/builder_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/miyagawa/mongery
@@ -132,11 +148,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: Convert MongoDB query to Arel for PostgreSQL + JSON
 test_files:
+- spec/mongery/builder_schema_spec.rb
 - spec/mongery/builder_spec.rb
 - spec/spec_helper.rb
 has_rdoc: