1 | 'use strict';
|
2 |
|
3 | var testUtils = require('../test-utils');
|
4 | var sortById = testUtils.sortById;
|
5 |
|
6 | module.exports = function (dbType, context) {
|
7 |
|
8 | describe(dbType + ': fields', function () {
|
9 |
|
10 | it('does 2-field queries', function () {
|
11 | var db = context.db;
|
12 | var index = {
|
13 | "index": {
|
14 | "fields": ["foo", "bar"]
|
15 | },
|
16 | "name": "foo-index",
|
17 | "type": "json"
|
18 | };
|
19 | return db.createIndex(index).then(function () {
|
20 | return db.bulkDocs([
|
21 | { _id: '1', foo: 'a', bar: 'a'},
|
22 | { _id: '2', foo: 'b', bar: 'b'},
|
23 | { _id: '3', foo: 'a', bar: 'a'},
|
24 | { _id: '4', foo: 'c', bar: 'a'},
|
25 | { _id: '5', foo: 'b', bar: 'a'},
|
26 | { _id: '6', foo: 'a', bar: 'b'}
|
27 | ]);
|
28 | }).then(function () {
|
29 | return db.find({
|
30 | "selector": {
|
31 | "foo": {"$eq": "b"},
|
32 | "bar": {"$eq": "b"}
|
33 | },
|
34 | "fields": ["_id", "foo"]
|
35 | });
|
36 | }).then(function (resp) {
|
37 | resp.should.deep.equal({
|
38 | "docs": [
|
39 | { "_id": "2", "foo": "b"}
|
40 | ]
|
41 | });
|
42 | });
|
43 | });
|
44 |
|
45 | it('does 2-field queries eq/gte', function () {
|
46 | var db = context.db;
|
47 | var index = {
|
48 | "index": {
|
49 | "fields": ["foo", "bar"]
|
50 | },
|
51 | "name": "foo-index",
|
52 | "type": "json"
|
53 | };
|
54 | return db.createIndex(index).then(function () {
|
55 | return db.bulkDocs([
|
56 | { _id: '1', foo: 'a', bar: 'a'},
|
57 | { _id: '2', foo: 'a', bar: 'b'},
|
58 | { _id: '3', foo: 'a', bar: 'c'},
|
59 | { _id: '4', foo: 'b', bar: 'a'},
|
60 | { _id: '5', foo: 'b', bar: 'b'},
|
61 | { _id: '6', foo: 'c', bar: 'a'}
|
62 | ]);
|
63 | }).then(function () {
|
64 | return db.find({
|
65 | "selector": {
|
66 | "foo": {"$eq": "a"},
|
67 | "bar": {"$gte": "b"}
|
68 | },
|
69 | "fields": ["_id"]
|
70 | });
|
71 | }).then(function (resp) {
|
72 | resp.docs.sort(sortById);
|
73 | resp.docs.should.deep.equal([
|
74 | { _id: '2' },
|
75 | { _id: '3' }
|
76 | ]);
|
77 | });
|
78 | });
|
79 |
|
80 | it('does 2-field queries gte/gte', function () {
|
81 | var db = context.db;
|
82 | var index = {
|
83 | "index": {
|
84 | "fields": ["foo", "bar"]
|
85 | },
|
86 | "name": "foo-index",
|
87 | "type": "json"
|
88 | };
|
89 | return db.createIndex(index).then(function () {
|
90 | return db.bulkDocs([
|
91 | { _id: '1', foo: 'a', bar: 'a'},
|
92 | { _id: '2', foo: 'a', bar: 'b'},
|
93 | { _id: '3', foo: 'a', bar: 'c'},
|
94 | { _id: '4', foo: 'b', bar: 'a'},
|
95 | { _id: '5', foo: 'b', bar: 'b'},
|
96 | { _id: '6', foo: 'c', bar: 'a'}
|
97 | ]);
|
98 | }).then(function () {
|
99 | return db.find({
|
100 | "selector": {
|
101 | "foo": {"$gte": "b"},
|
102 | "bar": {"$gte": "a"}
|
103 | },
|
104 | "fields": ["_id"]
|
105 | });
|
106 | }).then(function (resp) {
|
107 | resp.docs.sort(sortById);
|
108 | resp.docs.should.deep.equal([
|
109 | { _id: '4' },
|
110 | { _id: '5' },
|
111 | { _id: '6' }
|
112 | ]);
|
113 | });
|
114 | });
|
115 |
|
116 | it('does 2-field queries gte/lte', function () {
|
117 | var db = context.db;
|
118 | var index = {
|
119 | "index": {
|
120 | "fields": ["foo", "bar"]
|
121 | },
|
122 | "name": "foo-index",
|
123 | "type": "json"
|
124 | };
|
125 | return db.createIndex(index).then(function () {
|
126 | return db.bulkDocs([
|
127 | { _id: '1', foo: 'a', bar: 'a'},
|
128 | { _id: '2', foo: 'a', bar: 'b'},
|
129 | { _id: '3', foo: 'a', bar: 'c'},
|
130 | { _id: '4', foo: 'b', bar: 'a'},
|
131 | { _id: '5', foo: 'b', bar: 'b'},
|
132 | { _id: '6', foo: 'c', bar: 'a'}
|
133 | ]);
|
134 | }).then(function () {
|
135 | return db.find({
|
136 | "selector": {
|
137 | "foo": {"$gte": "b"},
|
138 | "bar": {"$lte": "b"}
|
139 | },
|
140 | "fields": ["_id"]
|
141 | });
|
142 | }).then(function (resp) {
|
143 | resp.docs.sort(sortById);
|
144 | resp.docs.should.deep.equal([
|
145 | { _id: '4' },
|
146 | { _id: '5' },
|
147 | { _id: '6' }
|
148 | ]);
|
149 | });
|
150 | });
|
151 |
|
152 | it('does 3-field queries eq/eq/eq 3-field index', function () {
|
153 | var db = context.db;
|
154 | var index = {
|
155 | "index": {
|
156 | "fields": ["foo", "bar", "baz"]
|
157 | },
|
158 | "name": "foo-index",
|
159 | "type": "json"
|
160 | };
|
161 | return db.createIndex(index).then(function () {
|
162 | return db.bulkDocs([
|
163 | { _id: '1', foo: 'a', bar: 'a', baz: 'z'},
|
164 | { _id: '2', foo: 'a', bar: 'b', baz: 'z'},
|
165 | { _id: '3', foo: 'a', bar: 'c', baz: 'z'},
|
166 | { _id: '4', foo: 'b', bar: 'a', baz: 'z'},
|
167 | { _id: '5', foo: 'b', bar: 'b', baz: 'z'},
|
168 | { _id: '6', foo: 'c', bar: 'a', baz: 'z'}
|
169 | ]);
|
170 | }).then(function () {
|
171 | return db.find({
|
172 | "selector": {
|
173 | foo: 'b',
|
174 | bar: 'b',
|
175 | baz: 'z'
|
176 | },
|
177 | "fields": ["_id"]
|
178 | });
|
179 | }).then(function (resp) {
|
180 | resp.docs.sort(sortById);
|
181 | resp.docs.should.deep.equal([
|
182 | { _id: '5' }
|
183 | ]);
|
184 | });
|
185 | });
|
186 |
|
187 | it('does 1-field queries eq/eq 2-field index', function () {
|
188 | var db = context.db;
|
189 | var index = {
|
190 | "index": {
|
191 | "fields": ["foo", "bar"]
|
192 | },
|
193 | "name": "foo-index",
|
194 | "type": "json"
|
195 | };
|
196 | return db.createIndex(index).then(function () {
|
197 | return db.bulkDocs([
|
198 | { _id: '1', foo: 'a', bar: 'a', baz: 'z'},
|
199 | { _id: '2', foo: 'a', bar: 'b', baz: 'z'},
|
200 | { _id: '3', foo: 'a', bar: 'c', baz: 'z'},
|
201 | { _id: '4', foo: 'b', bar: 'a', baz: 'z'},
|
202 | { _id: '5', foo: 'b', bar: 'b', baz: 'z'},
|
203 | { _id: '6', foo: 'c', bar: 'a', baz: 'z'}
|
204 | ]);
|
205 | }).then(function () {
|
206 | return db.find({
|
207 | "selector": {
|
208 | foo: 'b'
|
209 | },
|
210 | "fields": ["_id"]
|
211 | });
|
212 | }).then(function (resp) {
|
213 | resp.docs.sort(sortById);
|
214 | resp.docs.should.deep.equal([
|
215 | { _id: '4' },
|
216 | { _id: '5' }
|
217 | ]);
|
218 | });
|
219 | });
|
220 |
|
221 | it('does 2-field queries eq/eq 3-field index', function () {
|
222 | var db = context.db;
|
223 | var index = {
|
224 | "index": {
|
225 | "fields": ["foo", "bar", "baz"]
|
226 | },
|
227 | "name": "foo-index",
|
228 | "type": "json"
|
229 | };
|
230 | return db.createIndex(index).then(function () {
|
231 | return db.bulkDocs([
|
232 | { _id: '1', foo: 'a', bar: 'a', baz: 'z'},
|
233 | { _id: '2', foo: 'a', bar: 'b', baz: 'z'},
|
234 | { _id: '3', foo: 'a', bar: 'c', baz: 'z'},
|
235 | { _id: '4', foo: 'b', bar: 'a', baz: 'z'},
|
236 | { _id: '5', foo: 'b', bar: 'b', baz: 'z'},
|
237 | { _id: '6', foo: 'c', bar: 'a', baz: 'z'}
|
238 | ]);
|
239 | }).then(function () {
|
240 | return db.find({
|
241 | "selector": {
|
242 | foo: 'b',
|
243 | bar: 'b'
|
244 | },
|
245 | "fields": ["_id"]
|
246 | });
|
247 | }).then(function (resp) {
|
248 | resp.docs.sort(sortById);
|
249 | resp.docs.should.deep.equal([
|
250 | { _id: '5' }
|
251 | ]);
|
252 | });
|
253 | });
|
254 | });
|
255 | }; |
\ | No newline at end of file |