数据库 API

本文展示了 aircode.db 下的所有 API 说明及其示例。

Table

`db.table(tableName)`

const PersonsTable = aircode.db.table('persons');

const PersonsTable = aircode.db.table('persons');

根据 tableName 获取到对应的 Table 对象。

参数

{string} tableName：要获取的数据表的名称

{Table}：数据表对象

`Table.save(record | arrayOfRecords)`

const PersonsTable = aircode.db.table('persons');
const record = await PersonsTable.save({
  name: 'Micheal',
  age: 28
});

const PersonsTable = aircode.db.table('persons');
const record = await PersonsTable.save({
  name: 'Micheal',
  age: 28
});

将传入的记录保存到数据库中。若参数中包含 _id 字段且在数据库中存在，则执行更新操作，否则执行插入操作。save 方法是异步操作，需要用 await 来等待其完成。

参数

{Object} record：要保存的记录，形式为 { field: value, ... }
{Array} arrayOfRecords：若传入的是一个对象数组，则会一次性保存多条记录

{Promise<Object | Array>}：保存后的对象或对象数组

参考教程

`Table.delete(record | arrayOfRecords)`

const PersonsTable = aircode.db.table('persons');
const record = await PersonsTable.where({ name: 'Micheal' }).findOne();
await PersonsTable.delete(record);

const PersonsTable = aircode.db.table('persons');
const record = await PersonsTable.where({ name: 'Micheal' }).findOne();
await PersonsTable.delete(record);

将传入的记录从数据库中删除，要删除的记录是根据传入参数中的 _id 字段来决定的。delete 方法是异步操作，需要用 await 来等待其完成。

参数

{Object} record：要删除的记录，必须包含 _id 字段
{Array} arrayOfRecords：若传入的是一个对象数组，则会根据每个对象的 _id 字段一次性删除多条记录

{Promise<Object>}：删除结果，包含 deletedCount 字段，代表被删除的记录数，例如：

{
  deletedCount: 15
}

{
  deletedCount: 15
}

参考教程

删除数据

`Table.where([conditions])`

const PersonsTable = aircode.db.table('persons');
const records = PersonsTable.where({ name: 'Micheal' }).find();

const PersonsTable = aircode.db.table('persons');
const records = PersonsTable.where({ name: 'Micheal' }).find();

通过 where 可以设置查询操作的条件。每个查询都必须以 Table.where 开始，这个方法会返回一个 Query 对象，后续可以通过链式操作附加其他条件。

where 中支持传递 0 到多个参数。传递多个条件时这些条件的关系为「与」，即查询时需要同时满足，例如：

// name = 'Micheal' and age = 20 and location = 'New York'
Table.where({ name: 'Micheal', age: 20 }, { location: 'New York' })

// name = 'Micheal' and age = 20 and location = 'New York'
Table.where({ name: 'Micheal', age: 20 }, { location: 'New York' })

参数

{...Object} [conditions]：查询条件，形式为 { field: value, ... }

{Query}：Query 对象，可以附加链式表达式来添加更多查询条件，也可以使用 Query 指令来执行操作

参考教程

查询数据

Query 指令

`Query.find()`

const PersonsTable = aircode.db.table('persons');
const records = await PersonsTable.where().find();

const PersonsTable = aircode.db.table('persons');
const records = await PersonsTable.where().find();

根据 Query 指定的查询条件获取所有匹配的记录。find 方法是异步操作，需要用 await 来等待其完成。

参数

无

{Promise<Array>}：查询结果的数组，若无匹配记录则为 []

参考教程

查询数据 - 获取所有记录

`Query.findOne()`

const PersonsTable = aircode.db.table('persons');
const record = await PersonsTable.where({ name: 'Micheal' }).findOne();

const PersonsTable = aircode.db.table('persons');
const record = await PersonsTable.where({ name: 'Micheal' }).findOne();

根据 Query 指定的查询条件获取第一条匹配的记录。findOne 方法是异步操作，需要用 await 来等待其完成。

参数

无

{Promise<Object | null>}：查询到的记录，若无匹配则返回 null

参考教程

查询数据 - 获取单条记录

`Query.count()`

const PersonsTable = aircode.db.table('persons');
const count = await PersonsTable.where().count();

const PersonsTable = aircode.db.table('persons');
const count = await PersonsTable.where().count();

根据 Query 指定的查询条件获取匹配的记录总条数，不会返回具体的记录值。count 方法是异步操作，需要用 await 来等待其完成。

参数

无

{Promise<number>}：查询到的记录总条数

参考教程

查询数据 - 返回查询结果总条数

`Query.save()`

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ score: db.lt(60) })
  .set({ pass: false })
  .save();

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ score: db.lt(60) })
  .set({ pass: false })
  .save();

根据 Query 指定的条件直接在数据库中执行更新，需要配合 set 等更新链式使用。整个操作是在数据库中一次性完成的，因此具有原子性，效率也较高。save 方法是异步操作，需要用 await 来等待其完成。

例如，上述示例会找到 persons 数据表中所有 score 小于 60 的记录，并将其 pass 字段设置为 false。

参数

无

{Promise<Object>}：更新结果，包含 updatedCount 字段，代表被更新的记录数，例如：

{
  updatedCount: 15
}

{
  updatedCount: 15
}

参考教程

更新数据 - 直接执行更新

`Query.delete()`

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ name: db.exists(false) })
  .delete();

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ name: db.exists(false) })
  .delete();

根据 Query 指定的条件直接在数据库将对应记录删除。整个操作是在数据库中一次性完成的，因此具有原子性，效率也较高。delete 方法是异步操作，需要用 await 来等待其完成。

例如，上述示例会将 persons 数据表中所有不包含 name 字段的记录删除。

参数

无

{Promise<Object>}：删除结果，包含 deletedCount 字段，代表被删除的记录数，例如：

{
  deletedCount: 5
}

{
  deletedCount: 5
}

排序和分页链式

`Query.sort(conditions)`

const PersonsTable = aircode.db.table('persons');
const records = await PersonsTable.where().sort({ age: 1 }).find();

const PersonsTable = aircode.db.table('persons');
const records = await PersonsTable.where().sort({ age: 1 }).find();

为查询添加按字段的排序条件。

参数

{Object} condtions：排序条件，形式为 { field: order, ... }，其中 order 可以为
- 1 或 asc，代表正序，即从小到大排序
- -1 或 desc，代表倒序，即从大到小排序

{Query}：Query 对象本身

参考教程

查询数据 - 排序和分页

`Query.skip(n)`

const PersonsTable = aircode.db.table('persons');
const curPage = 2;
const pageSize = 100;
const records = await PersonsTable
  .where({ location: 'Tokyo' })
  .sort({ age: 1 })
  .skip((curPage - 1) * pageSize)
  .limit(pageSize)
  .find();

const PersonsTable = aircode.db.table('persons');
const curPage = 2;
const pageSize = 100;
const records = await PersonsTable
  .where({ location: 'Tokyo' })
  .sort({ age: 1 })
  .skip((curPage - 1) * pageSize)
  .limit(pageSize)
  .find();

指定查询时跳过 n 条记录，一般与 sort 和 limit 配合使用实现分页查询。

参数

{number} n：要跳过的记录数

{Query}：Query 对象本身

参考教程

查询数据 - 排序和分页

`Query.limit(n)`

const PersonsTable = aircode.db.table('persons');
const curPage = 2;
const pageSize = 100;
const records = await PersonsTable
  .where({ location: 'Tokyo' })
  .sort({ age: 1 })
  .skip((curPage - 1) * pageSize)
  .limit(pageSize)
  .find();

const PersonsTable = aircode.db.table('persons');
const curPage = 2;
const pageSize = 100;
const records = await PersonsTable
  .where({ location: 'Tokyo' })
  .sort({ age: 1 })
  .skip((curPage - 1) * pageSize)
  .limit(pageSize)
  .find();

限制单次查询返回的记录总条数，一般与 sort 和 skip 配合使用实现分页查询。

重要提示

为了确保查询过程的稳定性，对于查询结果的最大条数有一定限制，即使 limit 设置超过这个最大值也不会生效，具体限制请参考：资源限制 - 数据库 - 查询限制。

参数

{number} n：限制的总条数

{Query}：Query 对象本身

参考教程

查询数据 - 排序和分页

字段筛选链式

`Query.projection(conditions)`

const PersonsTable = aircode.db.table('persons');
const records = await PersonsTable.where()
  .projection({ name: 1, age: 1 })
  .find();

const PersonsTable = aircode.db.table('persons');
const records = await PersonsTable.where()
  .projection({ name: 1, age: 1 })
  .find();

指定查询结果只包含特定的字段。

参数

{Object} conditions：字段筛选的条件，形式为 { field: value, ... }，其中 value 可以为：
- 1，代表结果只包含该字段，其余字段竣备忽略，_id 字段为特例，默认会返回
- 0，代表忽略该字段，返回其他字段

结果

{Query}：Query 对象本身

参考教程

查询数据 - 指定结果只包含特定字段

更新链式

`Query.set(conditions)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ score: db.lt(60) })
  .set({ pass: false, failTime: db.inc(1) })
  .save();

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ score: db.lt(60) })
  .set({ pass: false, failTime: db.inc(1) })
  .save();

用于指定更新时进行的操作，需要在最后使用指令 save 来执行更新。

在 set 的参数中，可以有两种方式指定要更新的数据：

直接指定要设置的值，例如示例中的 pass: false 代表将 pass 字段设置为 false
通过更新操作符指定操作，例如示例中的 failTime: db.inc(1) 代表将 failTime 字段的值增加 1

参数

{Object} conditions：更新操作，形式为 { field: value, ... }

{Query}：Query 对象本身

参考教程

更新数据 - 直接执行更新

`Query.upsert([boolean=true])`

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ name: 'Micheal', age: 28 })
  .set({ favorites: [ 'Ski', 'Hiking', 'Sushi' ] })
  .upsert(true)
  .save();

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ name: 'Micheal', age: 28 })
  .set({ favorites: [ 'Ski', 'Hiking', 'Sushi' ] })
  .upsert(true)
  .save();

用于指定 Upsert 操作，也就是当没有根据条件查询到记录时新创建一个。

例如，在上述示例中：

如果匹配到了 name 为 'Micheal'，age 为 28 的记录，则会将其 favorites 设置为 [ 'Ski', 'Hiking', 'Sushi' ]

如果没有匹配到，则会创建一个新记录

{
  name: 'Micheal',
  age: 28,
  favorites: [ 'Ski', 'Hiking', 'Sushi' ]
}

{
  name: 'Micheal',
  age: 28,
  favorites: [ 'Ski', 'Hiking', 'Sushi' ]
}

通过设置 upsert(true)，我们能确保更新操作执行完成后，数据库中至少会有一条满足我们条件的记录存在。

参数

{boolean} [boolean=true]：指定是否开启 Upsert 操作，默认为 true

{Query}：Query 对象本身

参考教程

更新数据 - 更新或插入数据（Upsert）

`Query.setOnInsert(object)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ name: 'Micheal', age: 28 })
  .set({ favorites: [ 'Ski', 'Hiking', 'Sushi' ] })
  .setOnInsert({ score: 0 })
  .upsert(true)
  .save();

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ name: 'Micheal', age: 28 })
  .set({ favorites: [ 'Ski', 'Hiking', 'Sushi' ] })
  .setOnInsert({ score: 0 })
  .upsert(true)
  .save();

用于指定 Upsert 在执行插入操作时要设置的值。setOnInsert 必须配合 upsert(true) 使用，否则将不生效。

例如，在上述示例中：

如果匹配到了 name 为 'Micheal'，age 为 28 的记录，则会将其 favorites 设置为 [ 'Ski', 'Hiking', 'Sushi' ]。此时因为没有触发插入操作，setOnInsert 不生效

如果没有匹配到，则会创建一个新记录

{
  name: 'Micheal',
  age: 28,
  favorites: [ 'Ski', 'Hiking', 'Sushi' ],
  score: 0
}

{
  name: 'Micheal',
  age: 28,
  favorites: [ 'Ski', 'Hiking', 'Sushi' ],
  score: 0
}

通过使用 setOnInsert，我们能在新创建对象时设置一些默认值，而在执行更新时则不会影响已经存在的值。

参数

{Object} object：执行插入操作时要设置的值，形式为 { field: value, ... }

{Query}：Query 对象本身

参考教程

更新数据 - 更新或插入数据（Upsert）

逻辑链式

`Query.and(...filters)`

// f1 && f2
Table.where(f1).and(f2);
// f1 && (f2 && f3)
Table.where(f1).and(f2, f3);

// f1 && f2
Table.where(f1).and(f2);
// f1 && (f2 && f3)
Table.where(f1).and(f2, f3);

通过链式的方式为多个查询条件添加「与」的关系。

参数

{Object} ...filters：查询条件，至少包含一个

{Query}：Query 对象本身

参考教程

查询数据 - 使用逻辑操作符组合多个查询条件

`Query.or(...filters)`

// f1 || f2
Table.where(f1).or(f2);
// f1 || (f2 || f3)
Table.where(f1).or(f2, f3);

// f1 || f2
Table.where(f1).or(f2);
// f1 || (f2 || f3)
Table.where(f1).or(f2, f3);

通过链式的方式为多个查询条件添加「或」的关系。

参数

{Object} ...filters：查询条件，至少包含一个

{Query}：Query 对象本身

参考教程

查询数据 - 使用逻辑操作符组合多个查询条件

`Query.nor(...filters)`

// !(f1 || f2)
Table.where(f1).nor(f2);
// !(f1 || !(f2 || f3))
Table.where(f1).nor(f2, f3);

// !(f1 || f2)
Table.where(f1).nor(f2);
// !(f1 || !(f2 || f3))
Table.where(f1).nor(f2, f3);

通过链式的方式为多个查询条件添加「或非」的关系，也就是所有条件都为 false。

参数

{Object} ...filters：查询条件，至少包含一个

{Query}：Query 对象本身

参考教程

查询数据 - 使用逻辑操作符组合多个查询条件

对比操作符

`db.gt(value)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable.where({ age: db.gt(20) }).find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable.where({ age: db.gt(20) }).find();

用于设置查询时某个字段的值大于（>）指定的 value。

参数

{*} value：查询时要大于的值

{Object}：查询条件，指定到具体字段上

参考教程

`db.gte(value)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable.where({ age: db.gte(20) }).find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable.where({ age: db.gte(20) }).find();

用于设置查询时某个字段的值大于或等于（>=）指定的 value。

参数

{*} value：查询时要大于或等于的值

{Object}：查询条件，指定到具体字段上

参考教程

`db.lt(value)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable.where({ age: db.lt(50) }).find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable.where({ age: db.lt(50) }).find();

用于设置查询时某个字段的值小于（<）指定的 value。

参数

{*} value：查询时要小于的值

{Object}：查询条件，指定到具体字段上

参考教程

`db.lte(value)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable.where({ age: db.lte(50) }).find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable.where({ age: db.lte(50) }).find();

用于设置查询时某个字段的值小于或等于（<=）指定的 value。

参数

{*} value：查询时要小于或等于的值

{Object}：查询条件，指定到具体字段上

参考教程

`db.ne(value)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable.where({ blocked: db.ne(true) }).find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable.where({ blocked: db.ne(true) }).find();

用于设置查询时某个字段的值不等于指定的 value。

另外如果某条记录不包含该字段，也会被查询到。例如对于记录：

{
  name: Micheal,
  location: 'New York'
}

{
  name: Micheal,
  location: 'New York'
}

使用如下条件查询：

where({
  blocked: db.ne(true)
})

where({
  blocked: db.ne(true)
})

由于该记录中不存在 blocked 字段，则也满足 db.ne 的条件，因此该记录会被查询到。

参数

{*} value：查询时字段不等于的值

{Object}：查询条件，指定到具体字段上

参考教程

查询数据 - 按大于、小于等比较条件查询

`db.in(array)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ name: db.in([ 'Micheal', 'Mary' ]) })
  .find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ name: db.in([ 'Micheal', 'Mary' ]) })
  .find();

用于设置查询时，某个字段的值与 array 中的任意元素相等。

如果被查询的字段本身的值也是数组，则只需要这个字段的数组中任意一个元素存在于 array 即可。例如，对于如下记录：

{
  name: 'Micheal',
  favorites: [ 'Ski', 'Hiking', 'Sushi' ]
}

{
  name: 'Micheal',
  favorites: [ 'Ski', 'Hiking', 'Sushi' ]
}

使用如下条件查询：

where({
  favorites: db.in([ 'Ski', 'Football' ])
})

where({
  favorites: db.in([ 'Ski', 'Football' ])
})

由于该记录 favorites 数组的 'Ski' 存在于 db.in 条件的数组中，因此该记录会被查询到。

参数

{Array} array：用于查询的数组条件

{Object}：查询条件，指定到具体字段上

参考教程

查询数据 - 按大于、小于等比较条件查询

`db.nin(array)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ location: db.nin([ 'Tokyo', 'London' ]) })
  .find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ location: db.nin([ 'Tokyo', 'London' ]) })
  .find();

用于设置查询时，某个字段的值满足以下条件之一：

该字段的值不在指定 array 中
该记录不包含此字段

如果被查询的字段本身的值也是数组，则需要满足这个字段的数组中没有一个元素存在于 array。例如，对于如下记录：

{
  name: 'Micheal',
  favorites: [ 'Ski', 'Hiking', 'Sushi' ]
}

{
  name: 'Micheal',
  favorites: [ 'Ski', 'Hiking', 'Sushi' ]
}

使用如下条件查询：

where({
  favorites: db.nin([ 'Ski', 'Football' ])
})

where({
  favorites: db.nin([ 'Ski', 'Football' ])
})

由于该记录 favorites 数组的 'Ski' 存在于 db.nin 条件的数组中，因此该记录不会被查询到。

参数

{Array} array：用于查询的数组条件

{Object}：查询条件，指定到具体字段上

参考教程

查询数据 - 按大于、小于等比较条件查询

元素操作符

`db.exists(boolean)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ name: db.exists(true) })
  .find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ name: db.exists(true) })
  .find();

用于设置查询时，某个字段在记录中是否存在：

若 boolean 为 true，则查询所有包含该字段的记录，包括字段值为 null 的记录
若 boolean 为 false，则查询所有不包含该字段的记录

参数

{boolean} boolean：指定是否包含该字段

{Object}：查询条件，指定到具体字段上

`db.type(typeString)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ tags: db.type('array') })
  .find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ tags: db.type('array') })
  .find();

用于设置查询时，某个字段的值类型是指定的 typeString。

参数

{string} typeString：类型字符串，可用的类型见下表

类型	`typeString`
Number	`'number'`
String	`'string'`
Object	`'object'`
Array	`'array'`
Binary data	`'binData'`
Boolean	`'bool'`
Date	`'date'`
Null	`'null'`
Regular Expression	`'regex'`
JavaScript	`'javascript'`
32-bit integer	`'int'`
64-bit integer	`'long'`
Double	`'double'`
Decimal128	`'decimal'`
Timestamp	`'timestamp'`

{Object}：查询条件，指定到具体字段上

评估操作符

`db.mod(divisor, remainder)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ age: db.mod(5, 0) })
  .find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ age: db.mod(5, 0) })
  .find();

用于设置查询时，某个字段的值除以 divisor 后余数为 remainder。其中 divisor 和 remainder 都必须是整数，否则会执行出错。

参数

{number} divisor：除数，必须是整数
{number} remainder：余数，必须是整数

{Object}：查询条件，指定到具体字段上

数组操作符

`db.all(array)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ favorites: db.all([ 'Ski', 'Hiking' ]) })
  .find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ favorites: db.all([ 'Ski', 'Hiking' ]) })
  .find();

用于设置查询时，某个字段的值是数组类型，且包含 array 中的所有元素。

例如在这个示例中：

若某个记录的 favorites 为 [ 'Ski', 'Hiking', 'Sushi' ]，则会被查询到
若某个记录的 favorites 为 [ 'Ski', 'Football' ]，则由于不包含 'Hiking' 而不会被查询到

提示

如果希望任意元素在条件中都能被查询到，可以使用 db.in 操作符。

参数

{Array} array：用于查询的数组条件

{Object}：查询条件，指定到具体字段上

`db.elemMatch(conditions)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ results: db.elemMatch(db.gt(60).lt(80)) })
  .find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ results: db.elemMatch(db.gt(60).lt(80)) })
  .find();

用于设置查询时，某个字段的值是数组类型，且数组里面至少有一个元素满足 conditions 指定的所有条件。

上述示例就是查询 results 数组中至少有一个值大于 60，小于 80 的记录。例如对于以下三条记录：

{ name: 'Micheal', results: [ 30, 50, 90 ] }
{ name: 'Mary', results: [ 20, 70, 100 ] }
{ name: 'Isabel', results: [ 50, 100, 120 ] }

{ name: 'Micheal', results: [ 30, 50, 90 ] }
{ name: 'Mary', results: [ 20, 70, 100 ] }
{ name: 'Isabel', results: [ 50, 100, 120 ] }

则会查询到如下记录，因为其 results 中包含一个 70 介于 60 和 80 之间：

{ name: 'Mary', results: [ 20, 70, 100 ] }

{ name: 'Mary', results: [ 20, 70, 100 ] }

设置子字段匹配

若数组中的元素是 Object，elemMatch 方法还可以指定其子字段的匹配条件。例如对于如下记录：

{
  item: 'iPhone',
  inventories: [
    { location: 'Beijing', qty: 100 },
    { location: 'New York', qty: 30 },
    { location: 'Tokyo', qty: 120 },
  ]
}
{
  item: 'MacBook',
  inventories: [
    { location: 'London', qty: 20 },
    { location: 'New York', qty: 200 },
    { location: 'Sidney', qty: 60 },
  ]
}
{
  item: 'iPad',
  inventories: [
    { location: 'Beijing', qty: 80 },
    { location: 'London', qty: 25 },
    { location: 'Tokyo', qty: 90 },
  ]
}

{
  item: 'iPhone',
  inventories: [
    { location: 'Beijing', qty: 100 },
    { location: 'New York', qty: 30 },
    { location: 'Tokyo', qty: 120 },
  ]
}
{
  item: 'MacBook',
  inventories: [
    { location: 'London', qty: 20 },
    { location: 'New York', qty: 200 },
    { location: 'Sidney', qty: 60 },
  ]
}
{
  item: 'iPad',
  inventories: [
    { location: 'Beijing', qty: 80 },
    { location: 'London', qty: 25 },
    { location: 'Tokyo', qty: 90 },
  ]
}

使用如下查询条件：

where({
  inventories: db.elemMatch({
    location: 'New York',
    qty: db.gt(100)
  })
})

where({
  inventories: db.elemMatch({
    location: 'New York',
    qty: db.gt(100)
  })
})

会返回如下记录，因为其 inventories 中包含一个元素，location 是 'New York' 且 qty 大于 100：

{
  item: 'MacBook',
  inventories: [
    { location: 'London', qty: 20 },
    { location: 'New York', qty: 200 },
    { location: 'Sidney', qty: 60 },
  ]
}

{
  item: 'MacBook',
  inventories: [
    { location: 'London', qty: 20 },
    { location: 'New York', qty: 200 },
    { location: 'Sidney', qty: 60 },
  ]
}

参数

{Object} conditions：指定数组中元素要匹配的条件

{Object}：查询条件，指定到具体字段上

`db.size(n)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ favorites: db.size(2) })
  .find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ favorites: db.size(2) })
  .find();

用于设置查询时，某个字段的值是数组类型，且数组元素的个数是 n。

参数

{number} n：指定数组的元素个数

{Object}：查询条件，指定到具体字段上

位操作符

`db.bitsAllClear(positions)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ age: db.bitsAllClear([ 1, 5 ]) })
  .find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ age: db.bitsAllClear([ 1, 5 ]) })
  .find();

用于设置查询时，某个字段的值是数字或二进制数据，且其二进制值中对应于 positions 指定的位置都是 0。

二进制数据的位置是如下确定的，注意最低位是第 0 位：

Bit Value	1	1	1	1	1	1	1	1
Position	7	6	5	4	3	2	1	0

对于示例中的查询条件，则要求第 1 位和第 5 位为 0。例如：

age 为 20 时，其二进制值为 00010100，满足条件
age 为 22 时，其二进制值为 00010110，不满足条件

参数

{Array} positions：指定二进制数据中要满足条件的位置

{Object}：查询条件，指定到具体字段上

`db.bitsAllSet(positions)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ age: db.bitsAllSet([ 1, 5 ]) })
  .find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ age: db.bitsAllSet([ 1, 5 ]) })
  .find();

用于设置查询时，某个字段的值是数字或二进制数据，且其二进制值中对应于 positions 指定的位置都是 1。

二进制数据的位置是如下确定的，注意最低位是第 0 位：

Bit Value	1	1	1	1	1	1	1	1
Position	7	6	5	4	3	2	1	0

对于示例中的查询条件，则要求第 1 位和第 5 位为 1。例如：

age 为 38 时，其二进制值为 00100110，满足条件
age 为 6 时，其二进制值为 00000110，不满足条件

参数

{Array} positions：指定二进制数据中要满足条件的位置

{Object}：查询条件，指定到具体字段上

`db.bitsAnyClear(positions)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ age: db.bitsAnyClear([ 1, 5 ]) })
  .find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ age: db.bitsAnyClear([ 1, 5 ]) })
  .find();

用于设置查询时，某个字段的值是数字或二进制数据，且其二进制值中对应于 positions 指定的位置有任意一个是 0。

二进制数据的位置是如下确定的，注意最低位是第 0 位：

Bit Value	1	1	1	1	1	1	1	1
Position	7	6	5	4	3	2	1	0

对于示例中的查询条件，则要求第 1 位和第 5 位中任意一位为 0。例如：

age 为 52 时，其二进制值为 00110100，满足条件
age 为 22 时，其二进制值为 00010110，满足条件
age 为 54 时，其二进制值为 00110110，不满足条件

参数

{Array} positions：指定二进制数据中要满足条件的位置

{Object}：查询条件，指定到具体字段上

`db.bitsAnySet(positions)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ age: db.bitsAnyClear([ 1, 5 ]) })
  .find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({ age: db.bitsAnyClear([ 1, 5 ]) })
  .find();

用于设置查询时，某个字段的值是数字或二进制数据，且其二进制值中对应于 positions 指定的位置有任意一个是 1。

二进制数据的位置是如下确定的，注意最低位是第 0 位：

Bit Value	1	1	1	1	1	1	1	1
Position	7	6	5	4	3	2	1	0

对于示例中的查询条件，则要求第 1 位和第 5 位中任意一位为 1。例如：

age 为 52 时，其二进制值为 00110100，满足条件
age 为 22 时，其二进制值为 00010110，满足条件
age 为 20 时，其二进制值为 00010100，不满足条件

参数

{Array} positions：指定二进制数据中要满足条件的位置

{Object}：查询条件，指定到具体字段上

地理位置对象

地理位置对象是符合一定格式的 JavaScript 对象，可以用于地理位置查询。

每个地理位置对象都包含以下两个字段：

type：指定这个对象的类型，具体支持的类型见下方文档
coordinates：指定这个对象的地理坐标

重要提示

当用经纬度来表示坐标时，经度在前，纬度在后。

经度值为 -180 到 180，正数代表东经，负数代表西经
纬度值为 -90 到 90，正数代表北纬，负数代表南纬

`Point`

代表地理位置中的一个点，例如：

{ type: 'Point', coordinates: [ 40, 5 ] }

{ type: 'Point', coordinates: [ 40, 5 ] }

`LineString`

代表由两个点确定的一条线段，例如：

{ type: 'LineString', coordinates: [ [ 40, 5 ], [ 41, 6 ] ] }

{ type: 'LineString', coordinates: [ [ 40, 5 ], [ 41, 6 ] ] }

`Polygon`

代表一个多边形，分为两种。

只有一个闭环的多边形对象：

{
  type: 'Polygon',
  coordinates: [ [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0  ] ] ]
}

{
  type: 'Polygon',
  coordinates: [ [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0  ] ] ]
}

包含多个闭环的多边形对象：

{
  type: 'Polygon',
  coordinates: [
    [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0 ] ],
    [ [ 2, 2 ], [ 3, 3 ], [ 4, 2 ], [ 2, 2 ] ]
  ]
}

{
  type: 'Polygon',
  coordinates: [
    [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0 ] ],
    [ [ 2, 2 ], [ 3, 3 ], [ 4, 2 ], [ 2, 2 ] ]
  ]
}

`MultiPoint`

代表多个点对象的集合，例如：

{
  type: 'MultiPoint',
  coordinates: [
    [ -73.9580, 40.8003 ],
    [ -73.9498, 40.7968 ],
    [ -73.9737, 40.7648 ],
    [ -73.9814, 40.7681 ]
  ]
}

{
  type: 'MultiPoint',
  coordinates: [
    [ -73.9580, 40.8003 ],
    [ -73.9498, 40.7968 ],
    [ -73.9737, 40.7648 ],
    [ -73.9814, 40.7681 ]
  ]
}

`MultiLineString`

代表多条线段的集合，例如：

{
  type: 'MultiLineString',
  coordinates: [
    [ [ -73.96943, 40.78519 ], [ -73.96082, 40.78095 ] ],
    [ [ -73.96415, 40.79229 ], [ -73.95544, 40.78854 ] ],
    [ [ -73.97162, 40.78205 ], [ -73.96374, 40.77715 ] ],
    [ [ -73.97880, 40.77247 ], [ -73.97036, 40.76811 ] ]
  ]
}

{
  type: 'MultiLineString',
  coordinates: [
    [ [ -73.96943, 40.78519 ], [ -73.96082, 40.78095 ] ],
    [ [ -73.96415, 40.79229 ], [ -73.95544, 40.78854 ] ],
    [ [ -73.97162, 40.78205 ], [ -73.96374, 40.77715 ] ],
    [ [ -73.97880, 40.77247 ], [ -73.97036, 40.76811 ] ]
  ]
}

`MultiPolygon`

代表多个多边形的集合，例如：

{
  type: 'MultiPolygon',
  coordinates: [
    [ [ [ -73.958, 40.8003 ], [ -73.9498, 40.7968 ], [ -73.9737, 40.7648 ], [ -73.9814, 40.7681 ], [ -73.958, 40.8003 ] ] ],
    [ [ [ -73.958, 40.8003 ], [ -73.9498, 40.7968 ], [ -73.9737, 40.7648 ], [ -73.958, 40.8003 ] ] ]
  ]
}

{
  type: 'MultiPolygon',
  coordinates: [
    [ [ [ -73.958, 40.8003 ], [ -73.9498, 40.7968 ], [ -73.9737, 40.7648 ], [ -73.9814, 40.7681 ], [ -73.958, 40.8003 ] ] ],
    [ [ [ -73.958, 40.8003 ], [ -73.9498, 40.7968 ], [ -73.9737, 40.7648 ], [ -73.958, 40.8003 ] ] ]
  ]
}

`GeometryCollection`

地理集合对象，包含了多个不同类型的地理对象的集合，例如：

{
  type: 'GeometryCollection',
  geometries: [
    {
      type: 'MultiPoint',
      coordinates: [
        [ -73.9580, 40.8003 ],
        [ -73.9498, 40.7968 ],
        [ -73.9737, 40.7648 ],
        [ -73.9814, 40.7681 ]
      ]
    },
    {
      type: 'MultiLineString',
      coordinates: [
        [ [ -73.96943, 40.78519 ], [ -73.96082, 40.78095 ] ],
        [ [ -73.96415, 40.79229 ], [ -73.95544, 40.78854 ] ],
        [ [ -73.97162, 40.78205 ], [ -73.96374, 40.77715 ] ],
        [ [ -73.97880, 40.77247 ], [ -73.97036, 40.76811 ] ]
      ]
    }
  ]
}

{
  type: 'GeometryCollection',
  geometries: [
    {
      type: 'MultiPoint',
      coordinates: [
        [ -73.9580, 40.8003 ],
        [ -73.9498, 40.7968 ],
        [ -73.9737, 40.7648 ],
        [ -73.9814, 40.7681 ]
      ]
    },
    {
      type: 'MultiLineString',
      coordinates: [
        [ [ -73.96943, 40.78519 ], [ -73.96082, 40.78095 ] ],
        [ [ -73.96415, 40.79229 ], [ -73.95544, 40.78854 ] ],
        [ [ -73.97162, 40.78205 ], [ -73.96374, 40.77715 ] ],
        [ [ -73.97880, 40.77247 ], [ -73.97036, 40.76811 ] ]
      ]
    }
  ]
}

地理操作符

`db.geoIntersects(conditions)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({
    position: db.geoIntersects({
      $geometry: {
        type: 'Polygon',
        coordinates: [ [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0  ] ] ]
      }
    })
  }).find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({
    position: db.geoIntersects({
      $geometry: {
        type: 'Polygon',
        coordinates: [ [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0  ] ] ]
      }
    })
  }).find();

用于设置查询时，某个字段的地理位置与 conditions 指定的地理对象有交集。

参数

{Object} conditions：地理查询条件，其中 $geometry 的值为地理位置对象

{Object}：查询条件，指定到具体字段上

参考教程

基于地理位置查询

`db.geoWithin(conditions)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({
    position: db.geoWithin({
      $geometry: {
        type: 'Polygon',
        coordinates: [ [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0  ] ] ]
      }
    })
  }).find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({
    position: db.geoWithin({
      $geometry: {
        type: 'Polygon',
        coordinates: [ [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0  ] ] ]
      }
    })
  }).find();

用于设置查询时，某个字段的地理位置完全位于 conditions 指定的地理对象内部。

参数

{Object} conditions：地理查询条件，其中 $geometry 的值为地理位置对象

{Object}：查询条件，指定到具体字段上

参考教程

基于地理位置查询

`db.near(conditions)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({
    position: db.near({
      $geometry: {
        type: 'Point',
        coordinates: [ -73.9855, 40.7580 ]
      },
      $maxDistance: 2000, // in meters
      $minDistance: 100   // in meters
    })
  }).find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({
    position: db.near({
      $geometry: {
        type: 'Point',
        coordinates: [ -73.9855, 40.7580 ]
      },
      $maxDistance: 2000, // in meters
      $minDistance: 100   // in meters
    })
  }).find();

用于设置查询时，某个字段的地理位置位于 conditions 指定的地理对象附近一定平面距离。

参数

{Object} conditions：地理查询条件，其中：
- $geometry 的值为地理位置对象
- $maxDistance 的值为最大距离，单位是米
- $minDistance 的值为最小距离，单位是米

{Object}：查询条件，指定到具体字段上

参考教程

基于地理位置查询

`db.nearSphere(conditions)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({
    position: db.nearSphere({
      $geometry: {
        type: 'Point',
        coordinates: [ -73.9855, 40.7580 ]
      },
      $maxDistance: 2000, // in meters
      $minDistance: 100   // in meters
    })
  }).find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({
    position: db.nearSphere({
      $geometry: {
        type: 'Point',
        coordinates: [ -73.9855, 40.7580 ]
      },
      $maxDistance: 2000, // in meters
      $minDistance: 100   // in meters
    })
  }).find();

用于设置查询时，某个字段的地理位置位于 conditions 指定的地理对象附近一定球面距离。与 near 最大的不同是 nearSphere 在计算距离时会使用球面几何的算法，从而更接近在地球上的真实表面距离。

参数

{Object} conditions：地理查询条件，其中：
- $geometry 的值为地理位置对象
- $maxDistance 的值为最大距离，单位是米
- $minDistance 的值为最小距离，单位是米

{Object}：查询条件，指定到具体字段上

参考教程

基于地理位置查询

更新操作符

`db.inc(value)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ name: 'Micheal' })
  .set({ score: db.inc(5) })
  .save();

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ name: 'Micheal' })
  .set({ score: db.inc(5) })
  .save();

用于 set 方法中，指定更新时将对应字段的值增加 value。如果对应字段不存在，则会创建这个字段并将其值设置为 value。

提示

如果 value 值为负数，则相当于减少对应字段的值。

参数

{number} value：指定要增加的值

{Object}：更新条件，指定到具体字段上

`db.mul(value)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ name: 'Micheal' })
  .set({ score: db.mul(2.5) })
  .save();

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ name: 'Micheal' })
  .set({ score: db.mul(2.5) })
  .save();

用于 set 方法中，指定更新时将对应字段的值乘以 value。如果对应字段不存在，则会创建这个字段并将其值设置为 0。

参数

{number} value：指定要乘以的值

{Object}：更新条件，指定到具体字段上

`db.min(value)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ name: 'Micheal' })
  .set({ score: db.min(60) })
  .save();

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ name: 'Micheal' })
  .set({ score: db.min(60) })
  .save();

用于 set 方法中，指定更新时选取当前字段值与 value 中较小的值。即：

当 value 小于当前字段值时，将当前字段设置为 value
否则，不变更

如果对应字段不存在，则会创建这个字段并将其值设置为 value。

参数

{any} value：指定用于对比的值

{Object}：更新条件，指定到具体字段上

`db.max(value)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ name: 'Micheal' })
  .set({ score: db.max(120) })
  .save();

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where({ name: 'Micheal' })
  .set({ score: db.max(120) })
  .save();

用于 set 方法中，指定更新时选取当前字段值与 value 中较大的值。即：

当 value 大于当前字段值时，将当前字段设置为 value
否则，不变更

如果对应字段不存在，则会创建这个字段并将其值设置为 value。

参数

{any} value：指定用于对比的值

{Object}：更新条件，指定到具体字段上

`db.rename(name)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where()
  .set({ cell: db.rename('mobile') })
  .save();

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where()
  .set({ cell: db.rename('mobile') })
  .save();

用于 set 方法中，指定将对应字段的名称更改为参数 name 指定的名称。

例如，上述示例就是将所有记录的 cell 字段重命名为 mobile。

参数

{string} name：要更改为的名称

{Object}：更新条件，指定到具体字段上

`db.unset()`

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where()
  .set({ position: db.unset() })
  .save();

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where()
  .set({ position: db.unset() })
  .save();

用于 set 方法中，指定将对应字段删除。

例如，上述示例就是将所有记录的 position 字段删除。

参数

无

{Object}：更新条件，指定到具体字段上

`db.currentDate()`

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where()
  .set({ lastModified: db.currentDate() })
  .save();

const { db } = aircode;
const PersonsTable = db.table('persons');
const result = await PersonsTable
  .where()
  .set({ lastModified: db.currentDate() })
  .save();

用于 set 方法中，指定更新时将对应字段的值设置为当前时间，类型是 Date。

参数

无

{Object}：更新条件，指定到具体字段上

逻辑操作符

`db.and(...filters)`

// f1 || (f2 && f3)
Table.where(f1).or(db.and(f2, f3));

// f1 || (f2 && f3)
Table.where(f1).or(db.and(f2, f3));

主要用于链式无法解决的复杂逻辑组合中，表示几个查询条件的「与」关系。

参数

{Object} ...filters：查询条件，至少包含两个

{Object}：逻辑条件，可以被用作其他逻辑操作符的条件参数

参考教程

查询数据 - 使用逻辑操作符组合多个查询条件

`db.or(...filters)`

// (f1 || f2) && (f3 && f4)
Table.where(db.or(f1, f2)).and(f3, f4);

// (f1 || f2) && (f3 && f4)
Table.where(db.or(f1, f2)).and(f3, f4);

主要用于链式无法解决的复杂逻辑组合中，表示几个查询条件的「或」关系。

参数

{Object} ...filters：查询条件，至少包含两个

{Object}：逻辑条件，可以被用作其他逻辑操作符的条件参数

参考教程

查询数据 - 使用逻辑操作符组合多个查询条件

`db.nor(...filters)`

// !(f1 || f2) && (f3 && f4)
Table.where(db.nor(f1, f2)).and(f3, f4);

// !(f1 || f2) && (f3 && f4)
Table.where(db.nor(f1, f2)).and(f3, f4);

主要用于链式无法解决的复杂逻辑组合中，表示几个查询条件的「或非」关系。

参数

{Object} ...filters：查询条件，至少包含两个

{Object}：逻辑条件，可以被用作其他逻辑操作符的条件参数

参考教程

查询数据 - 使用逻辑操作符组合多个查询条件

`db.not(condition)`

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({
    score: db.not(db.gt(2.5))
  })
  .find();

const { db } = aircode;
const PersonsTable = db.table('persons');
const records = await PersonsTable
  .where({
    score: db.not(db.gt(2.5))
  })
  .find();

用于设置查询时，某个字段的值不满足 condition 指定的条件，这也包含了这条记录没有该字段的情况。

例如上述示例会查询到：

score 小于等于 2.5 的记录
不包含 score 字段的记录

这也是与 db.lte(2.5) 的主要区别，因为 db.lte(2.5) 要求记录必须包含 score 字段。

参数

{any} condition：指定不满足的条件

{Object}：查询条件，指定到具体字段上

数据库 API ​

Table ​

db.table(tableName) ​

Table.save(record | arrayOfRecords) ​

Table.delete(record | arrayOfRecords) ​

Table.where([conditions]) ​

Query 指令 ​

Query.find() ​

Query.findOne() ​

Query.count() ​

Query.save() ​

Query.delete() ​

排序和分页链式 ​

Query.sort(conditions) ​

Query.skip(n) ​

Query.limit(n) ​

字段筛选链式 ​

Query.projection(conditions) ​

更新链式 ​

Query.set(conditions) ​

Query.upsert([boolean=true]) ​

Query.setOnInsert(object) ​

逻辑链式 ​

Query.and(...filters) ​

Query.or(...filters) ​

Query.nor(...filters) ​

对比操作符 ​

db.gt(value) ​

db.gte(value) ​

db.lt(value) ​

db.lte(value) ​

db.ne(value) ​

db.in(array) ​

db.nin(array) ​

元素操作符 ​

db.exists(boolean) ​

db.type(typeString) ​

评估操作符 ​

db.mod(divisor, remainder) ​

数组操作符 ​

db.all(array) ​

db.elemMatch(conditions) ​

db.size(n) ​

位操作符 ​

db.bitsAllClear(positions) ​

db.bitsAllSet(positions) ​

db.bitsAnyClear(positions) ​

db.bitsAnySet(positions) ​

地理位置对象 ​

Point ​

LineString ​

Polygon ​

MultiPoint ​

MultiLineString ​

MultiPolygon ​

GeometryCollection ​

地理操作符 ​

db.geoIntersects(conditions) ​

db.geoWithin(conditions) ​

db.near(conditions) ​

db.nearSphere(conditions) ​

更新操作符 ​

db.inc(value) ​

db.mul(value) ​

db.min(value) ​

db.max(value) ​

db.rename(name) ​

db.unset() ​

db.currentDate() ​

逻辑操作符 ​

db.and(...filters) ​

db.or(...filters) ​

db.nor(...filters) ​

db.not(condition) ​

数据库 API

Table

`db.table(tableName)`

`Table.save(record | arrayOfRecords)`

`Table.delete(record | arrayOfRecords)`

`Table.where([conditions])`

Query 指令

`Query.find()`

`Query.findOne()`

`Query.count()`

`Query.save()`

`Query.delete()`

排序和分页链式

`Query.sort(conditions)`

`Query.skip(n)`

`Query.limit(n)`

字段筛选链式

`Query.projection(conditions)`

更新链式

`Query.set(conditions)`

`Query.upsert([boolean=true])`

`Query.setOnInsert(object)`

逻辑链式

`Query.and(...filters)`

`Query.or(...filters)`

`Query.nor(...filters)`

对比操作符

`db.gt(value)`

`db.gte(value)`

`db.lt(value)`

`db.lte(value)`

`db.ne(value)`

`db.in(array)`

`db.nin(array)`

元素操作符

`db.exists(boolean)`

`db.type(typeString)`

评估操作符

`db.mod(divisor, remainder)`

数组操作符

`db.all(array)`

`db.elemMatch(conditions)`

`db.size(n)`

位操作符

`db.bitsAllClear(positions)`

`db.bitsAllSet(positions)`

`db.bitsAnyClear(positions)`

`db.bitsAnySet(positions)`

地理位置对象

`Point`

`LineString`

`Polygon`

`MultiPoint`

`MultiLineString`

`MultiPolygon`

`GeometryCollection`

地理操作符

`db.geoIntersects(conditions)`

`db.geoWithin(conditions)`

`db.near(conditions)`

`db.nearSphere(conditions)`

更新操作符

`db.inc(value)`

`db.mul(value)`

`db.min(value)`

`db.max(value)`

`db.rename(name)`

`db.unset()`

`db.currentDate()`

逻辑操作符

`db.and(...filters)`

`db.or(...filters)`

`db.nor(...filters)`

`db.not(condition)`