_find`¶

POST /{db}/_find

使用声明式 JSON 查询语法查找文档。如果可用，查询将使用自定义索引，该索引使用 _index 端点指定。否则，它们使用内置 _all_docs 索引，该索引可能会非常慢。

参数:

db – 数据库名称

请求标头:

Content-Type –
- application/json

请求 JSON 对象:

selector (json) – 描述用于选择文档的条件的 JSON 对象。有关选择器语法部分提供了更多信息。必需
limit (number) – 返回的最大结果数。默认值为 25。可选
skip (number) – 跳过前“n”个结果，其中“n”是指定的值。可选
sort (json) – 遵循排序语法的 JSON 数组。可选
fields (array) – 指定应返回每个对象的哪些字段的 JSON 数组。如果省略，则返回整个对象。有关过滤字段部分提供了更多信息。可选
use_index (string|array) – 指示查询使用特定索引。指定为 "<design_document>" 或 ["<design_document>", "<index_name>"]。可选
conflicts (boolean) – 如果 true，则包括冲突文档。预期用途是轻松查找冲突文档，而无需索引或视图。默认值为 false。可选
r (number) – 结果所需的读取法定人数。这默认为 1，在这种情况下，将返回在索引中找到的文档。如果设置为较高的值，则在结果中返回每个文档之前，至少从该数量的副本中读取该文档。这可能比仅使用与索引一起本地存储的文档花费更多时间。可选，默认值：1
bookmark (string) – 一个字符串，使您能够指定所需的哪个结果页面。用于对结果集进行分页。每个查询都在 bookmark 键下返回一个不透明字符串，然后可以将其传递回查询以获取下一页结果。如果选择器查询的任何部分在请求之间发生更改，则结果未定义。可选，默认值：null
update (boolean) – 是否在返回结果之前更新索引。默认值为 true。可选
stable (boolean) – 视图结果是否应从“稳定”的分片集中返回。可选
stale (字符串) – update=false 和 stable=true 选项的组合。可能的选项："ok"、false（默认）。可选请注意，此参数已弃用。请改用 stable 和 update。有关更多详细信息，请参阅视图生成。
execution_stats (布尔值) – 在查询响应中包含执行统计信息。可选，默认： false

响应标头:

Content-Type – application/json
Transfer-Encoding – chunked

响应 JSON 对象:

docs (对象) – 与搜索匹配的文档数组。在每个匹配的文档中，都会列出请求正文的 fields 部分中指定字段及其值。
warning (字符串) – 执行警告
execution_stats (对象) – 执行统计信息
bookmark (字符串) – 用于分页的不透明字符串。有关用法详细信息，请参阅请求中的 bookmark 字段（以上）。

状态代码:

200 OK – 请求已成功完成
400 Bad Request – 无效请求
401 Unauthorized – 需要读取权限
404 Not Found – 未找到请求的数据库
500 Internal Server Error – 查询执行错误

limit 和 skip 值与您的预期完全一致。虽然存在 skip，但它不适用于分页。原因是 bookmark 功能更有效。

请求:

使用索引查找文档的示例请求正文

POST /movies/_find HTTP/1.1
Accept: application/json
Content-Type: application/json
Content-Length: 168
Host: localhost:5984

{
    "selector": {
        "year": {"$gt": 2010}
    },
    "fields": ["_id", "_rev", "year", "title"],
    "sort": [{"year": "asc"}],
    "limit": 2,
    "skip": 0,
    "execution_stats": true
}

响应:

使用索引查找文档时的示例响应

HTTP/1.1 200 OK
Cache-Control: must-revalidate
Content-Type: application/json
Date: Thu, 01 Sep 2016 15:41:53 GMT
Server: CouchDB (Erlang OTP)
Transfer-Encoding: chunked

{
    "docs": [
        {
            "_id": "176694",
            "_rev": "1-54f8e950cc338d2385d9b0cda2fd918e",
            "year": 2011,
            "title": "The Tragedy of Man"
        },
        {
            "_id": "780504",
            "_rev": "1-5f14bab1a1e9ac3ebdf85905f47fb084",
            "year": 2011,
            "title": "Drive"
        }
    ],
    "execution_stats": {
        "total_keys_examined": 0,
        "total_docs_examined": 200,
        "total_quorum_docs_examined": 0,
        "results_returned": 2,
        "execution_time_ms": 5.52
    }
}

1.3.6.1. 选择器语法¶

选择器表示为描述目标文档的 JSON 对象。在此结构中，您可以使用特殊命名的字段应用条件逻辑。

虽然选择器与 MongoDB 查询文档有一些相似之处，但这些相似之处源于目的相似，并不一定扩展到函数或结果的通用性。

1.3.6.1.1. 选择器基础¶

基本选择器语法要求您指定一个或多个字段，以及这些字段所需的相应值。此选择器匹配“director”字段值为“Lars von Trier”的所有文档。

{
    "director": "Lars von Trier"
}

A simple selector, inspecting specific fields

"selector": {
  "title": "Live And Let Die"
},
"fields": [
  "title",
  "cast"
]

您可以通过组合运算符来创建更复杂的选择器表达式。为了获得最佳性能，最好将“组合”或“数组逻辑”运算符（例如 $regex）与相等运算符（例如 $eq、$gt、$gte、$lt 和 $lte）组合（但不能与 $ne 组合）。有关创建复杂选择器表达式的更多信息，请参阅创建选择器表达式。

1.3.6.1.2. 包含 2 个字段的选择器¶

此选择器匹配任何包含 "Paul" 的 name 字段且 location 字段值为 "Boston" 的文档。

{
    "name": "Paul",
    "location": "Boston"
}

1.3.6.1.3. 子字段¶

更复杂的选择器使您能够指定嵌套对象或子字段的字段值。例如，您可以使用标准 JSON 结构来指定字段和子字段。

使用标准 JSON 结构的字段和子字段选择器的示例

{
    "imdb": {
        "rating": 8
    }
}

缩写等价项使用点符号将字段和子字段名称组合成一个名称。

{
    "imdb.rating": 8
}

1.3.6.1.4. 运算符¶

运算符通过在名称字段中使用美元符号 ($) 前缀来标识。

选择器语法中有两种核心类型的运算符

组合运算符
条件运算符

通常，组合运算符应用于选择的最顶层。它们用于组合条件，或将条件组合成一个选择器。

每个显式运算符的格式为

{"$operator": argument}

没有显式运算符的选择器被认为具有隐式运算符。确切的隐式运算符由选择器表达式的结构决定。

1.3.6.1.5. 隐式运算符¶

有两种隐式运算符

相等
且

在选择器中，任何包含 JSON 值但没有运算符的字段都被视为相等条件。隐式相等测试也适用于字段和子字段。

任何不是条件运算符参数的 JSON 对象都是对每个字段的隐式 $and 运算符。

在下面的示例中，我们使用运算符来匹配任何文档，其中 "year" 字段的值大于 2010

{
    "year": {
        "$gt": 2010
    }
}

在下一个示例中，匹配的文档中必须有 "director" 字段，并且该字段的值必须完全等于 "Lars von Trier"。

{
    "director": "Lars von Trier"
}

您还可以使相等运算符显式化。

{
    "director": {
        "$eq": "Lars von Trier"
    }
}

在下一个使用子字段的示例中，匹配文档中必需的字段 "imdb" 也必须具有子字段 "rating"，并且子字段必须具有等于 8 的值。

应用于子字段测试的隐式运算符示例

{
    "imdb": {
        "rating": 8
    }
}

同样，您可以使等式运算符显式化。

{
    "imdb": {
        "rating": { "$eq": 8 }
    }
}

与全文索引一起使用的 $eq 运算符示例

{
  "selector": {
    "year": {
      "$eq": 2001
    }
  },
  "sort": [
    "title:string"
  ],
  "fields": [
    "title"
  ]
}

在字段 "year" 上建立数据库索引时使用的 $eq 运算符示例

{
  "selector": {
    "year": {
      "$eq": 2001
    }
  },
  "sort": [
    "year"
  ],
  "fields": [
    "year"
  ]
}

在此示例中，字段 "director" 必须存在并包含值 "Lars von Trier"，并且字段 "year" 必须存在并具有值 2003。

{
    "director": "Lars von Trier",
    "year": 2003
}

您可以使 $and 运算符和等式运算符都显式化。

使用显式 $and 和 $eq 运算符的示例

{
    "$and": [
        {
            "director": {
                "$eq": "Lars von Trier"
            }
        },
        {
            "year": {
                "$eq": 2003
            }
        }
    ]
}

1.3.6.1.6. 显式运算符¶

除了“等式”和“与”之外，所有运算符都必须明确说明。

1.3.6.1.7. 组合运算符¶

组合运算符用于组合选择器。除了大多数编程语言中常见的布尔运算符之外，还有三个组合运算符（$all、$elemMatch 和 $allMatch），它们可帮助您处理 JSON 数组，而一个则可处理 JSON 映射（$keyMapMatch）。

组合运算符采用单个参数。参数可以是另一个选择器，也可以是选择器数组。

组合运算符列表

运算符	参数	目的
`$and`	数组	如果数组中的所有选择器都匹配，则匹配。
`$or`	数组	如果数组中的任何选择器匹配，则匹配。所有选择器都必须使用相同的索引。
`$not`	选择器	如果给定的选择器不匹配，则匹配。
`$nor`	数组	如果数组中的任何选择器都不匹配，则匹配。
`$all`	数组	如果数组值包含参数数组的所有元素，则匹配。
`$elemMatch`	选择器	匹配并返回包含数组字段的所有文档，该数组字段至少包含一个与所有指定查询条件匹配的元素。
`$allMatch`	选择器	匹配并返回包含数组字段的所有文档，该数组字段的所有元素都匹配所有指定的查询条件。
`$keyMapMatch`	选择器	匹配并返回包含至少一个键匹配所有指定查询条件的地图的所有文档。

$and 运算符: 与两个字段一起使用的 $and 运算符

{
  "selector": {
    "$and": [
      {
        "title": "Total Recall"
      },
      {
        "year": {
          "$in": [1984, 1991]
        }
      }
    ]
  },
  "fields": [
    "year",
    "title",
    "cast"
  ]
}

$and 运算符在数组中的所有选择器匹配时匹配。下面是使用主索引 (_all_docs) 的示例

{
    "$and": [
        {
            "_id": { "$gt": null }
        },
        {
            "year": {
                "$in": [2014, 2015]
            }
        }
    ]
}

$or 运算符

$or 运算符在数组中的任何选择器匹配时匹配。下面是与字段 "year" 上的索引一起使用的示例

{
    "year": 1977,
    "$or": [
        { "director": "George Lucas" },
        { "director": "Steven Spielberg" }
    ]
}

$not 运算符

$not 运算符在给定选择器不匹配时匹配。下面是与字段 "year" 上的索引一起使用的示例

{
    "year": {
        "$gte": 1900
    },
    "year": {
        "$lte": 1903
    },
    "$not": {
        "year": 1901
    }
}

$nor 运算符

$nor 运算符在给定选择器不匹配时匹配。下面是与字段 "year" 上的索引一起使用的示例

{
    "year": {
        "$gte": 1900
    },
    "year": {
        "$lte": 1910
    },
    "$nor": [
        { "year": 1901 },
        { "year": 1905 },
        {  "year": 1907 }
    ]
}

$all 运算符

$all 运算符匹配数组值，如果它包含参数数组的所有元素。下面是与主索引 (_all_docs) 一起使用的示例

{
    "_id": {
        "$gt": null
    },
    "genre": {
        "$all": ["Comedy","Short"]
    }
}

$elemMatch 运算符

$elemMatch 运算符匹配并返回包含数组字段的所有文档，该数组字段至少有一个元素匹配提供的查询条件。下面是与主索引 (_all_docs) 一起使用的示例

{
    "_id": { "$gt": null },
    "genre": {
        "$elemMatch": {
            "$eq": "Horror"
        }
    }
}

$allMatch 运算符

$allMatch 运算符匹配并返回包含数组字段的所有文档，该数组字段的所有元素都匹配提供的查询条件。下面是与主索引 (_all_docs) 一起使用的示例

{
    "_id": { "$gt": null },
    "genre": {
        "$allMatch": {
            "$eq": "Horror"
        }
    }
}

$keyMapMatch 运算符

$keyMapMatch 运算符匹配并返回包含至少一个键匹配所有指定查询条件的地图的所有文档。下面是与主索引 (_all_docs) 一起使用的示例

{
    "_id": { "$gt": null },
    "cameras": {
        "$keyMapMatch": {
            "$eq": "secondary"
        }
    }
}

1.3.6.1.8. 条件运算符¶

条件运算符特定于某个字段，用于评估存储在该字段中的值。例如，基本 $eq 运算符在指定字段包含等于所提供参数的值时匹配。

注意

为了让条件运算符正确运行，该字段必须存在于文档中，选择器才能匹配。例如，$ne 表示指定字段必须存在，且不等于参数的值。

支持大多数编程语言中常见的基本相等和不等运算符。使用严格类型匹配。

此外，还提供了一些“元”条件运算符。一些条件运算符接受任何有效的 JSON 内容作为参数。其他条件运算符要求参数采用特定的 JSON 格式。

运算符类型	运算符	参数	目的
(不)相等	`$lt`	任何 JSON	字段小于参数
	`$lte`	任何 JSON	字段小于或等于参数。
	`$eq`	任何 JSON	字段等于参数
	`$ne`	任何 JSON	字段不等于参数。
	`$gte`	任何 JSON	字段大于或等于参数。
	`$gt`	任何 JSON	字段大于参数。
对象	`$exists`	布尔	检查字段是否存在，而不管其值如何。
	`$type`	字符串	检查文档字段的类型。有效值包括 `"null"`、`"boolean"`、`"number"`、`"string"`、`"array"` 和 `"object"`。
数组	`$in`	JSON 值数组	文档字段必须存在于所提供的列表中。
	`$nin`	JSON 值数组	文档字段不得存在于所提供的列表中。
	`$size`	整数	匹配文档中数组字段长度的特殊条件。非数组字段无法匹配此条件。
其他	`$mod`	[除数、余数]	除数是非零整数，余数是任意整数。非整数值会导致 404。匹配 `field % Divisor == Remainder` 为 true 的文档，并且仅在文档字段为整数时匹配。
	`$regex`	字符串	与文档字段匹配的正则表达式模式。仅在字段为字符串值且与所提供的正则表达式匹配时匹配。匹配算法基于 Perl 兼容正则表达式 (PCRE) 库。有关已实现内容的更多信息，请参阅 Erlang 正则表达式

警告

正则表达式不适用于索引，因此不应将其用于过滤大型数据集。但是，它们可用于限制部分索引。

1.3.6.1.9. 创建选择器表达式¶

我们已经看到了组合选择器表达式的示例，例如使用显式 $and 和 $eq 运算符。

一般来说，每当你有一个接受参数的操作符时，该参数本身可以是另一个带有其自身参数的操作符。这使我们能够构建更复杂的选取器表达式。

但是，只有等式操作符（例如 $eq、$gt、$gte、$lt 和 $lte（但不是 $ne）才能用作查询的基础。你应该在选取器中至少包含其中一个。

例如，如果你尝试执行一个查询，试图匹配所有具有名为 afieldname 的字段的文档，该字段包含以字母 A 开头的值，这将触发一个警告，因为无法使用索引，并且数据库对主索引执行完全扫描

请求

POST /movies/_find HTTP/1.1
Accept: application/json
Content-Type: application/json
Content-Length: 112
Host: localhost:5984

{
    "selector": {
        "afieldname": {"$regex": "^A"}
    }
}

响应:

HTTP/1.1 200 OK
Cache-Control: must-revalidate
Content-Type: application/json
Date: Thu, 01 Sep 2016 17:25:51 GMT
Server: CouchDB (Erlang OTP)
Transfer-Encoding: chunked

{
    "warning":"no matching index found, create an index to optimize
    query time",
    "docs":[
    ]
}

警告

始终建议你在生产环境中部署时创建一个适当的索引。

大多数选取器表达式的工作方式与你对给定操作符的期望完全一致。但并非总是如此：例如，字符串比较使用 ICU 完成，如果你期望 ASCII 排序，可能会产生令人惊讶的结果。有关更多详细信息，请参阅视图排序。

1.3.6.2. 排序语法¶

sort 字段包含一个字段名称和方向对列表，表示为一个基本数组。第一个字段名称和方向对是排序的最顶层。如果提供了第二个对，则它是排序的下一层。

该字段可以是任何字段，如果需要，可以使用点号表示法表示子文档字段。

方向值对于升序为 "asc"，对于降序为 "desc"。如果你省略方向值，则使用默认的 "asc"。

示例，按 2 个字段排序

[{"fieldName1": "desc"}, {"fieldName2": "desc" }]

示例，按 2 个字段排序，假设两个字段的方向都为默认值

["fieldNameA", "fieldNameB"]

一个典型的要求是使用选取器搜索一些内容，然后根据指定字段按所需方向对结果进行排序。

要使用排序，请确保

选取器中至少包含一个排序字段。
已经定义了一个索引，其中所有排序字段都按相同
顺序排列。
排序数组中的每个对象都有一个键。

如果排序数组中的一个对象没有单个键，则产生的排序顺序与实现有关，并且可能会更改。

Find 不支持具有不同排序顺序的多个字段，因此方向必须全部为升序或全部为降序。

对于文本搜索排序中的字段名称，有时需要指定字段类型，例如

{ "<fieldname>:string": "asc"}

如果可能，会尝试根据选取器发现字段类型。在模棱两可的情况下，必须显式提供字段类型。

当字段包含不同的数据类型时，排序顺序是不确定的。这是文本索引和视图索引之间的一个重要区别。对于具有不同数据类型的字段，排序行为在将来的版本中可能会发生变化。

一个使用排序的简单查询

{
    "selector": {"Actor_name": "Robert De Niro"},
    "sort": [{"Actor_name": "asc"}, {"Movie_runtime": "asc"}]
}

1.3.6.3. 过滤字段¶

从数据库中选择时，可以指定要为文档返回哪些字段。其优点有

你的结果仅限于文档中应用程序
所需的那些部分。
响应大小减小。

返回的字段指定为一个数组。

在响应中仅包含指定的过滤器字段。当包含字段列表时，不会自动包含 _id 或其他元数据字段。

从匹配文档中选择性检索字段的示例

{
    "selector": { "Actor_name": "Robert De Niro" },
    "fields": ["Actor_name", "Movie_year", "_id", "_rev"]
}

1.3.6.4. 分页¶

Mango 查询通过书签字段支持分页。每个 _find 响应都包含一个书签，CouchDB 使用该书签来确定在进行后续查询时从何处恢复。要获取下一组查询结果，将前一个响应中收到的书签添加到下一个请求中。请记住保持 selector 相同，否则您将收到意外的结果。要向后分页，可以使用前一个书签返回前一组结果。

请注意，书签的存在并不能保证有更多结果。您可以通过将返回的结果数与请求的页面大小进行比较来测试是否已达到结果集的末尾，如果返回的结果 < limit，则没有更多结果。

1.3.6.5. 执行统计¶

Find 可以为特定请求返回基本执行统计。结合 _explain 端点，这应提供一些见解，了解索引是否被有效使用。

执行统计目前包括

字段	说明
`total_keys_examined`	检查的索引键数。当前始终为 0。
`total_docs_examined`	从数据库/索引中获取的文档数，相当于在视图中使用 `include_docs=true`。然后，可以在内存中对这些文档进行筛选，以根据选择器进一步缩小结果集。
`total_quorum_docs_examined`	使用带外文档获取从数据库获取的文档数。仅当在查询参数中指定读入法定人数 > 1 时，此值才非零。
`results_returned`	从查询返回的结果数。理想情况下，此值不应明显低于检查的总文档/键数。
`execution_time_ms`	数据库测量的总执行时间（以毫秒为单位）。

1.3.7. `/db/_index`¶

Mango 是一种用于 CouchDB 数据库的声明式 JSON 查询语言。Mango 封装了多种索引类型，首先是开箱即用的主索引。使用 MapReduce 视图构建索引类型为 json 的 Mango 索引。

POST /{db}/_index¶

在数据库上创建新索引

参数:

db – 数据库名称

请求标头:

Content-Type –
- application/json

查询参数:

index (json) – 描述要创建的索引的 JSON 对象。
ddoc (字符串) – 将创建索引的设计文档的名称。默认情况下，每个索引都将在其自己的设计文档中创建。可以将索引分组到设计文档中以提高效率。但是，设计文档中一个索引的更改将使同一文档中的所有其他索引失效（类似于视图）。可选
name (字符串) – 索引的名称。如果没有提供名称，则将自动生成一个名称。可选
type (字符串) – 可以是 "json" 或 "text"。默认为 json。未来将支持地理空间索引。可选文本索引通过第三方库支持可选
partitioned (布尔值) – 确定 JSON 索引是分区索引还是全局索引。 partitioned 的默认值为数据库的 partitioned 属性。要在分区数据库上创建全局索引，请为 "partitioned" 字段指定 false。如果在未分区数据库上为 "partitioned" 字段指定 true，则会发生错误。

响应标头:

Content-Type – application/json
Transfer-Encoding – chunked

响应 JSON 对象:

result (字符串) – 显示索引是创建的还是已经存在的标志。可以是 "created" 或 "exists"。
id (字符串) – 创建索引的设计文档的 ID。
name (字符串) – 创建的索引的名称。

状态代码:

200 OK – 索引创建成功或已存在
400 Bad Request – 无效请求
401 未授权 – 需要管理员权限
404 未找到 – 数据库未找到
500 内部服务器错误 – 执行错误

Index 对象是一个 JSON 对象，具有以下字段

JSON 参数:

fields (数组) – 遵循排序语法的字段名称数组。还允许嵌套字段，例如 “person.name”。
partial_filter_selector (json) – 在索引时应用于文档的选择器，创建部分索引。可选

为名为 foo 的字段创建新索引的示例

请求:

POST /db/_index HTTP/1.1
Content-Type: application/json
Content-Length: 116
Host: localhost:5984

{
    "index": {
        "fields": ["foo"]
    },
    "name" : "foo-index",
    "type" : "json"
}

返回的 JSON 确认已创建索引

响应:

HTTP/1.1 200 OK
Cache-Control: must-revalidate
Content-Length: 96
Content-Type: application/json
Date: Thu, 01 Sep 2016 18:17:48 GMT
Server: CouchDB (Erlang OTP/18)

{
    "result":"created",
    "id":"_design/a5f4711fc9448864a13c81dc71e660b524d7410c",
    "name":"foo-index"
}

使用所有可用查询参数创建索引的示例

请求:

POST /db/_index HTTP/1.1
Content-Type: application/json
Content-Length: 396
Host: localhost:5984

{
    "index": {
        "partial_filter_selector": {
            "year": {
                "$gt": 2010
            },
            "limit": 10,
            "skip": 0
        },
        "fields": [
            "_id",
            "_rev",
            "year",
            "title"
        ]
    },
    "ddoc": "example-ddoc",
    "name": "example-index",
    "type": "json",
    "partitioned": false
}

默认情况下，JSON 索引将包括具有已存在索引字段的所有文档，包括具有空值文档。

1.3.7.1. 部分索引¶

部分索引允许在索引时对文档进行筛选，从而可能为无法明确映射到索引上范围查询的查询选择器提供显著的性能改进。

我们来看一个示例查询

{
  "selector": {
    "status": {
      "$ne": "archived"
    },
    "type": "user"
  }
}

如果没有部分索引，则需要进行完全索引扫描才能找到所有 "type":"user" 但没有 "archived" 状态的文档。这是因为普通索引只能用于匹配连续行，而 "$ne" 运算符无法保证这一点。

为了改善响应时间，我们可以创建一个索引，在索引时间使用 "partial_filter_selector" 字段排除 "status": { "$ne": "archived" } 的文档

POST /db/_index HTTP/1.1
Content-Type: application/json
Content-Length: 144
Host: localhost:5984

{
  "index": {
    "partial_filter_selector": {
      "status": {
        "$ne": "archived"
      }
    },
    "fields": ["type"]
  },
  "ddoc" : "type-not-archived",
  "type" : "json"
}

除非由 "use_index" 字段指定，否则查询规划器目前不使用部分索引，因此我们需要修改原始查询

{
  "selector": {
    "status": {
      "$ne": "archived"
    },
    "type": "user"
  },
  "use_index": "type-not-archived"
}

从技术上讲，我们不需要在查询选择器中包含 "status" 字段的过滤器 - 部分索引确保始终为真 - 但包含它可以使选择器的意图更加清晰，并且可以更轻松地利用查询规划的未来改进（例如，自动选择部分索引）。

注意

仅当选择器包含所有已编入索引的字段时，才使用具有字段的索引。例如，如果索引包含 ["a". "b"] 但选择器仅要求字段 ["a"] 存在于匹配的文档中，则该索引对查询无效。但是，所有索引都可以被视为包含特殊字段 _id 和 _rev。它们永远不需要在查询选择器中指定。

GET /{db}/_index¶

当您向 /db/_index 发出 GET 请求时，您将获得数据库中所有索引的列表。除了通过此 API 可用的信息外，索引还存储在设计文档 <index-functions> 中。设计文档是 ID 以 _design/ 开头的常规文档。设计文档可以与任何其他文档一样检索和修改，尽管在使用 Mango 时没有必要这样做。

参数:

db – 数据库名称。

响应标头:

Content-Type – application/json
Transfer-Encoding – chunked

响应 JSON 对象:

total_rows (数字) – 索引数
indexes (对象) – 索引定义数组

状态代码:

200 OK – 成功
400 Bad Request – 无效请求
401 Unauthorized – 需要读取权限
500 内部服务器错误 – 执行错误

索引对象的格式

ddoc：索引所属设计文档的 ID。此 ID
可用于通过向 /db/ddoc 发出 GET 请求来检索包含索引的设计文档，其中 ddoc 是此字段的值。
name：索引名称。
type：索引类型。目前“json”是唯一
支持的类型。
def：索引的定义，包含已编入索引的字段
以及排序顺序：升序或降序。

请求:

GET /db/_index HTTP/1.1
Accept: application/json
Host: localhost:5984

响应:

HTTP/1.1 200 OK
Cache-Control: must-revalidate
Content-Length: 238
Content-Type: application/json
Date: Thu, 01 Sep 2016 18:17:48 GMT
Server: CouchDB (Erlang OTP/18)

{
    "total_rows": 2,
    "indexes": [
    {
        "ddoc": null,
        "name": "_all_docs",
        "type": "special",
        "def": {
            "fields": [
                {
                    "_id": "asc"
                }
            ]
        }
    },
    {
        "ddoc": "_design/a5f4711fc9448864a13c81dc71e660b524d7410c",
        "name": "foo-index",
        "type": "json",
        "def": {
            "fields": [
                {
                    "foo": "asc"
                }
            ]
        }
    }
  ]
}

DELETE /{db}/_index/{designdoc}/json/{name}¶

参数:

db – 数据库名称。
designdoc – 设计文档名称。
name – 索引名称。

响应标头:

Content-Type – application/json

响应 JSON 对象:

ok (字符串) – 如果成功，则为 “true”。

状态代码:

200 OK – 成功
400 Bad Request – 无效请求
401 Unauthorized – 需要写入权限
404 Not Found – 找不到索引
500 内部服务器错误 – 执行错误

请求:

DELETE /db/_index/_design/a5f4711fc9448864a13c81dc71e660b524d7410c/json/foo-index HTTP/1.1
Accept: */*
Host: localhost:5984

响应:

HTTP/1.1 200 OK
Cache-Control: must-revalidate
Content-Length: 12
Content-Type: application/json
Date: Thu, 01 Sep 2016 19:21:40 GMT
Server: CouchDB (Erlang OTP/18)

{
    "ok": true
}

1.3.8. `/db/_explain`¶

POST /{db}/_explain¶

显示查询使用的索引。参数与 _find 相同

参数:

db – 数据库名称

请求标头:

Content-Type – application/json

响应标头:

Content-Type – application/json
Transfer-Encoding – chunked

响应 JSON 对象:

dbname (string) – 数据库名称
index (object) – 用于满足查询的索引
selector (object) – 使用的查询选择器
opts (object) – 使用的查询选项
limit (number) – 使用的限制参数
skip (number) – 使用的跳过参数
fields (array) – 查询返回的字段
range (object) – 传递给底层视图的范围参数

状态代码:

200 OK – 请求已成功完成
400 Bad Request – 无效请求
401 Unauthorized – 需要读取权限
500 内部服务器错误 – 执行错误

请求:

POST /movies/_explain HTTP/1.1
Accept: application/json
Content-Type: application/json
Content-Length: 168
Host: localhost:5984

{
    "selector": {
        "year": {"$gt": 2010}
    },
    "fields": ["_id", "_rev", "year", "title"],
    "sort": [{"year": "asc"}],
    "limit": 2,
    "skip": 0
}

响应:

HTTP/1.1 200 OK
Cache-Control: must-revalidate
Content-Type: application/json
Date: Thu, 01 Sep 2016 15:41:53 GMT
Server: CouchDB (Erlang OTP)
Transfer-Encoding: chunked

{
    "dbname": "movies",
    "index": {
        "ddoc": "_design/0d61d9177426b1e2aa8d0fe732ec6e506f5d443c",
        "name": "0d61d9177426b1e2aa8d0fe732ec6e506f5d443c",
        "type": "json",
        "def": {
            "fields": [
                {
                    "year": "asc"
                }
            ]
        }
    },
    "selector": {
        "year": {
            "$gt": 2010
        }
    },
    "opts": {
        "bookmark": "nil",
        "limit": 2,
        "skip": 0,
        "sort": {},
        "fields": [
            "_id",
            "_rev",
            "year",
            "title"
        ],
        "r": [
            49
        ],
        "conflicts": false
    },
    "limit": 2,
    "skip": 0,
    "fields": [
        "_id",
        "_rev",
        "year",
        "title"
    ],
    "range": {
        "start_key": [
            2010
        ],
        "end_key": [
            {}
        ]
    }
}

1.3.8.1. 索引选择¶

_find 选择用于响应查询的索引，除非你在查询时指定了索引。

查询计划程序查看选择器部分并找到与查询中使用的运算符和字段最匹配的索引。如果匹配两个或更多 json 类型索引，则优先选择索引中字段数量最少的索引。如果仍然有两个或更多候选索引，则选择第一个按字母顺序排列的索引。

注意

在查询中明确指定索引是一种好习惯。这可以防止现有查询受到生产环境中可能添加的新索引的影响。

1.3.6. /db/_find¶

1.3.6.1. 选择器语法¶

1.3.6.1.1. 选择器基础¶

1.3.6.1.2. 包含 2 个字段的选择器¶

1.3.6.1.3. 子字段¶

1.3.6.1.4. 运算符¶

1.3.6.1.5. 隐式运算符¶

1.3.6.1.6. 显式运算符¶

1.3.6.1.7. 组合运算符¶

1.3.6.1.8. 条件运算符¶

1.3.6.1.9. 创建选择器表达式¶

1.3.6.2. 排序语法¶

1.3.6.3. 过滤字段¶

1.3.6.4. 分页¶

1.3.6.5. 执行统计¶

1.3.7. /db/_index¶

1.3.7.1. 部分索引¶

1.3.8. /db/_explain¶

1.3.8.1. 索引选择¶

1.3.6. `/db/_find`¶

1.3.7. `/db/_index`¶

1.3.8. `/db/_explain`¶