This is how I currently query to find a non empty array

collection
        .findAll({
            theArray: {$exists: true},
            $not: {theArray: $length: 0}
        })

It would be great if there was another way to do this or atleast some syntactic sugar that would let me do something like:

collection
        .findAll({
            theArray: $gt: 0
        })

or maybe

collection
        .findAll({
            theArray: $length: $gt: 0
        })

https://github.com/bevry/query-engine/wiki/Using

Add support for dot notation like in mongo: http://docs.mongodb.org/manual/tutorial/query-documents/#subdocuments

• Currently it is linking to Contributing.md.
• Should link to CONTRIBUTING.md.

The demo URL (http://bevry.github.com/query-engine/demo/) promoted in Query Engine guide (https://bevry.me/queryengine/guide) is incorrect, greeting with 404.

This url http://bevry.github.io/query-engine/out/demo/ is no longer valid

Ref #16

Hi Ben,

Is it possible to add project documentation? The wiki documentation is missing: https://github.com/bevry/query-engine/wiki/Using

Best,

Nikolay

Calling collection.reset() without arguments causes a wrong behaviour due to line 588 of query-engine.js. (QueryCollection.prototype.add). It looks the problem is the condition that forces the creation of an array when models argument is not one (:[models]). It creates an array even in the case the models argument of add method is undefined. This causes the array to have 1 phantom element ({}).
Fortunately there is an easy workaround, to call reset method with an an empty array (collection.reset([])). This way the condition that gets evaluated is ?models.slice() and that returns an empty array which is the expected behaviour.

Are you accepting pull requests? I see many issues open.

Now that query-engine requires backbone, it starts to get to heavy for simple use-cases with simple arrays. I understand the reason why backbone is now required is because of the live collections. This make sense, but if you remove the live collections feature from query-engine, does that trim it down enough to not warrant backbone? I personally don't need the concept of live collections.

Thoughts?

I'm using docpad 6.59 and node 0.10.12

If I define this collection

pages: (database) ->
    database.findAllLive({relativeOutDirPath:/de[\/\\]\w+/, pageOrder: $exists: true})

it works, but when I change the order, it fails:

pages: (database) ->
    database.findAllLive({pageOrder: $exists: true, relativeOutDirPath:/de[\/\\]\w+/})

Error:

error: An error occured: 
Error: Couldn't find the selector relativeOutDirPath
    at Query.compileSelector (./node_modules/docpad/node_modules/query-engine/out/lib/query-engine.js:1492:15)

Unless I'm mistaken, QueryEngine doesn't implement the limit cursor method of MongoDB. S o it's not natively possible to extract only a few results. MongoDB docs says that it's a very good performance enhancement, since more objects than necessary may be returned otherwise.

Is there already a way to limit results ? If not, is this feature planned ?

https://trello.com/c/TYrXZc4T

When I call:

childCollection = parentCollection.createChildCollection()

url property is not passed through from the parentCollection.

The useful logicalOperator only exists in examples (http://bevry.github.io/query-engine/demo/search.html) at moment - while it serves to be mentioned in documentation, too.

If i use query-engine as a common module and convert them with browserify, then i got an error in line 5 of query-engine.js. This is the extend function of coffeescript, but it themes that the Backbone variable is the problem.

If i change

(function() {
  var Backbone, Criteria, Hash, Pill, Query, QueryCollection, queryEngine, util, _ref,
    __hasProp = {}.hasOwnProperty,
    __slice = [].slice,
    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; },
    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };

  Backbone = this.Backbone || (typeof window !== "undefined" && window !== null ? window.Backbone : void 0) || ((function() {
    try {
      return typeof require === "function" ? require('backbone') : void 0;
    } catch (_error) {}
  })()) || ((function() {
    try {
      return typeof require === "function" ? require('exoskeleton') : void 0;
    } catch (_error) {}
  })()) || null;

  util = { [...]

to

(function() {
  var Backbone, Criteria, Hash, Pill, Query, QueryCollection, queryEngine, util, _ref,
    __hasProp = {}.hasOwnProperty,
    __slice = [].slice,
    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; },
    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };

  Backbone = null;

  util = { [...]

it works fine. So i tested what i got back at the Backbone declaration. It themes that i will got an object instead of null. So the following parts act as i loaded Backbone an will extend functionallity from an undefined object. I hope it is not so confusing.

Thomas

Issue #41 is a result of $hasAll not having a test - I'd like to suggest that a "meta-test" be added simply to make sure all query selectors have an associated test. This would assert a certain level test coverage.

I imagine it would look something like looping over Query.selectors and making sure a key for the selector exists in queryTests:

https://github.com/bevry/query-engine/blob/master/src/documents/test/queries-test.js.coffee#L71

The selectors are defined here:

https://github.com/bevry/query-engine/blob/master/src/documents/lib/query-engine.js.coffee#L1214-L1470

It could even be as simple/naive as:

Object.keys(queryTests).length is Object.keys(Query.selectors).length

PS: If you want to get even more meta - test just $hasAll and then use that to test that queryTests has all of the keys of Query.selectors. WE CAN GO DEEPER

Clicked the link on README and found dead link.
Enderjs is nolonger at http://ender.jit.su/ found at http://enderjs.com/

http://lucene.apache.org/core/

Awesome project, thanks!

When writing a query using the syntax as mentioned here:
http://docs.mongodb.org/manual/reference/operator/regex/

query-engine throws an error. To be more specific: the query:

{ field: { $regex: 'acme.*corp', $options: 'i' } }

results in:

Error: Couldn't find the selector $regexp

Hello,

When using the 'AMD' versions of Underscore and Backbone libraries, QueryEngine fails to load the proper dependencies using require("backbone"), etc.

As per this discussion require sync version needs to be used within a require or define callback, like so:

define(['foo-dep', function () {
  var foo = require('foo-dep');
});

The issue can be seen here

Patched version can be seen here

I apologize, I don't yet know coffeescript well enough to submit a pull request, but I have provided a diff of the javascript files if that helps. The main difference is a define wrapper at the top, and returning the global at the bottom. (code borrowed from knockout.js):

http://www.diffnow.com/?report=ignzq

Regards,
Aaron

I did a npm install query-engine and it installed with version 1.5.5. However when I do a require("query-engine").Backbone it's always a null.

Hello,

I use your lib for a project that does'nt use Backbone and it fails with this line :

else if (selectorValue instanceof Backbone.Model) {

cause the Backbone is not defined, you cannot get something on it.

KR

Mongo NoSQL Spec: https://docs.mongodb.org/manual/reference/operator/query/

Any query-engine specific selectors should either be removed, or prefixed with $qe

The current $in should be changed to mongo spec'd $in and a new $qeContains, or the like

There should also be a $qeWithin.

Details: https://bevry.slack.com/archives/maintenance/p1456474718000276

@blitmap is in charge for this

Has anyone been able to get this working with Webpack? I tried shimming it but I'm not sure what is going wrong. It was complaining about not being able to find the parent. In fact, none of the require calls were working inside of it.

• http://jsperf.com/queryengine-or
• http://jsperf.com/queryengine-and
• http://jsperf.com/queryengine-and-one
• http://jsperf.com/queryengine/7
• http://jsperf.com/scope-vs-args

It would be great if query-engine could be added to http://jamjs.org/

I want to make a query, something like that: (foo && bar) || (qux && baz)
I wrote it in this style (coffee script)

@getDatabase().findAllLive
  $or:
    $and:
      foo: {$exists: true}
      bar: {$exists: true}
    $and:
      qux: {$exists: true}
      baz: {$exists: true}

But the result is always the part with qux && baz

Here is the real query:
https://gist.github.com/timaschew/0f53f48a8e82431dccf6