MongoDB2.4发行说明 (2.3 发展系列)

Create Text Indexes¶

To create a text index, use the following syntax of ensureIndex():

db.collection.ensureIndex( { <field>: "text" } )

Consider the following example:

db.collection.ensureIndex( { content: "text" } )

This text index catalogs all string data in the content field where the content field contains a string or an array of string elements. To index fields in sub-documents, you need to specify the individual fields from the sub-documents using the dot notation. A text index can include multiple fields, as in the following:

db.collection.ensureIndex( { content: "text",
                             "users.comments": "text",
                             "users.profiles": "text" } )

The default name for the index consists of the <field name> concatenated with _text for the indexed fields, as in the following:

"content_text_users.comments_text_users.profiles_text"

These indexes may run into the Index Name Length limit. To avoid creating an index with a too-long name, you can specify a name in the options parameter, as in the following:

db.collection.ensureIndex( { content: "text",
                             "users.profiles": "text" },
                           { name: "TextIndex" } )

When creating text indexes you may specify weights for specific fields. Weights are factored into the relevant score for each document. The score for a given word in a document is the weighted sum of the frequency for each of the indexed fields in that document. Consider the following:

db.collection.ensureIndex( { content: "text",
                             "users.profiles": "text" },
                           { name: "TextIndex",
                             weights: { content: 1,
                                        "users.profiles": 2 } } )

This example creates a text index on the top-level field named content and the profiles field in the users sub-documents. Furthermore, the content field has a weight of 1 and the users.profiles field has a weight of 2.

You can add a conventional ascending or descending index field(s) as a prefix or suffix of the index. You cannot include multi-key index field nor geospatial index field.

If you create an ascending or descending index as a prefix of a text index:

• MongoDB will only index documents that have the prefix field (i.e. username) and
• The text query can limit the number of index entries to review in order to perform the query.
• All text queries using this index must include the filter option that specifies an equality condition for the prefix field or fields.

Create this index with the following operation:

db.collection.ensureIndex( { username: 1,
                             "users.profiles": "text" } )

Alternatively you create an ascending or descending index as a suffix to a text index. Then the text index can support covered queries if the text command specifies a project option.

Create this index with the following operation:

db.collection.ensureIndex( { "users.profiles": "text",
                             username: 1 } )

Finally, you may use the special wild card field specifier (i.e. $**) to specify index weights and fields. Consider the following example that indexes any string value in the data of every field of every document in a collection and names it TextIndex:

db.collection.ensureIndex( { "$**": "text",
                             username: 1 },
                           { name: "TextIndex" } )

By default, an index field has a weight of 1. You may specify weights for a text index with compound fields, as in the following:

db.collection.ensureIndex( { content: "text",
                             "users.profiles": "text",
                             comments: "text",
                             keywords: "text",
                             about: "text" },
                           { name: "TextIndex",
                             weights:
                             { content: 10,
                               "user.profiles": 2,
                               keywords: 5,
                               about: 5 } } )

This index, named TextIndex, includes a number of fields, with the following weights:

• content field that has a weight of 10,
• users.profiles that has a weight of 2,
• comments that has a weight of 1,
• keywords that has a weight of 5, and
• about that has a weight of 5.

This means that documents that match words in the content field will appear in the result set more than all other fields in the index, and that the user.profiles and comments fields will be less likely to appear in responses than words from other fields.

Specify Languages for Text Index¶

The default language associated with the indexed data determines the list of stop words and the rules for the stemmer and tokenizer. The default language for the indexed data is english.

Use the default_language option when creating the text index to specify a different language. See Languages Supported in Text Search.

The following example creates a text index on the content field and sets the default_language to spanish:

db.collection.ensureIndex( { content : "text" },
                           { default_language: "spanish" } )

If a collection contains documents that are in different languages, the individual documents can specify the language to use.

• By default, if the documents in the collection contain a field named language, the value of the language field overrides the default language.

  For example, the following document overrides the default language spanish with portuguese, the value in its language field.

  { content: "A sorte protege os audazes", language: "portuguese" }
  

• To use a different field to override the default language, specify the field with the language_override option when creating the index.

  For example, if the documents contain the field named myLanguage instead of language, create the text index with the language_override option.

  db.collection.ensureIndex( { content : "text" },
                             { language_override: "myLanguage" } )
  

Text Queries¶

MongoDB 2.3.2 introduces the text command to provide query support for text indexes. Unlike normal MongoDB queries, text returns a document rather than a cursor.

text¶

The text provides an interface to search text context stored in the text index. Consider the following prototype: text:

db.collection.runCommand( "text", { search: <string>,
                                    filter: <document>,
                                    project: <document>,
                                    limit: <number>,
                                    language: <string> } )

The text command has the following parameters:

参数:

search (string) – A text string that MongoDB stems and uses to query the text index. In the mongo shell, to specify a phrase to match, you can either: enclose the phrase in escaped double quotes and use double quotes to specify the search string, as in ""coffee table"", or enclose the phrase in double quotes and use single quotes to specify the search string, as in '"coffee table"' filter (document) – Optional. A query document to further limit the results of the query using another database field. You can use any valid MongoDB query in the filter document, except if the index includes an ascending or descending index field as a prefix. If the index includes an ascending or descending index field as a prefix, the filter is required and the filter query must be an equality match. project (document) – Optional. Allows you to limit the fields returned by the query to only those specified. limit (number) – Optional. Specify the maximum number of documents to include in the response. The text sorts the results before applying the limit. The default limit is 100. language (string) – Optional. Specify, for the search, the language that determines the list of stop words and the rules for the stemmer and tokenizer. The default language is the value of the default_language field specified during the index creation. See Languages Supported in Text Search for the supported languages.

返回:

text returns results, in descending order by score, in the form of a document. Results must fit within the BSON Document Size. Use the limit and the project parameters to limit the size of the result set.

The implicit connector between the terms of a multi-term search is a disjunction (OR). Search for "first second" searches for "first" or "second". The scoring system will prefer documents that contain all terms.

However, consider the following behaviors of text queries:

• With phrases (i.e. terms enclosed in escaped quotes), the search performs an AND with any other terms in the search string; e.g. search for ""twinkle twinkle" little star" searches for "twinkle twinkle" and ("little" or "star").
• text adds all negations to the query with the logical AND operator.

Languages Supported in Text Search¶

The text index and the text command support the following languages:

• danish
• dutch
• english
• finnish
• french
• german
• hungarian
• italian
• norwegian
• portuguese
• romanian
• russian
• spanish
• swedish
• turkish

E4X Extensions¶

V8 does not support the non-standard E4X extensions. E4X provides a native XML object to the JavaScript language and adds the syntax for embedding literal XML documents in JavaScript code.

You need to use alternative XML processing if you used any of the following constructors/methods:

• XML()
• Namespace()
• QName()
• XMLList()
• isXMLName()

Destructuring Assignment¶

V8 does not support the non-standard destructuring assignments. Destructuring assignment “extract[s] data from arrays or objects using a syntax that mirrors the construction of array and object literals.” - Mozilla docs

original = [4, 8, 15];
var [b, ,c] = a;  // <== destructuring assignment
print(b) // 4
print(c) // 15

Iterator(), StopIteration(), and Generators¶

V8 does not support Iterator(), StopIteration(), and generators.

InternalError()¶

V8 does not support InternalError(). Use Error() instead.

for each...in Construct¶

V8 does not support the use of for each...in construct. Use for (var x in y) construct instead.

var o = { name: 'MongoDB', version: 2.4 };

for each (var value in o) {
  print(value);
}

var o = { name: 'MongoDB', version: 2.4 };

for (var prop in o) {
  var value = o[prop];
  print(value);
}

Object.keys(o).forEach(function (key) {
  var value = o[key];
  print(value);
});

Array Comprehension¶

V8 does not support Array comprehensions.

Use other methods such as the Array instance methods map(), filter(), or forEach().

var a = { w: 1, x: 2, y: 3, z: 4 }

var arr = [i * i for each (i in a) if (i > 2)]
printjson(arr)

var a = { w: 1, x: 2, y: 3, z: 4 }

var arr = [];
Object.keys(a).forEach(function (key) {
  var val = a[key];
  if (val > 2) arr.push(val * val);
})
printjson(arr)

Multiple Catch Blocks¶

V8 does not support multiple catch blocks and will throw a SyntaxError.

try {
  something()
} catch (err if err instanceof SomeError) {
  print('some error')
} catch (err) {
  print('standard error')
}

Conditional Function Definition¶

V8 will produce different outcomes than SpiderMonkey with conditional function definitions.

function test () {
   if (false) {
      function go () {};
   }
   print(typeof go)
}

function test () {
  var go;
  if (false) {
    go = function () {}
  }
  print(typeof go)
}

function test () {
  'use strict';

  if (false) {
    function go () {}
  }
}

SyntaxError: In strict mode code, functions can only be declared at top level or immediately within another function.

String Generic Methods¶

V8 does not support String generics. String generics are a set of methods on the String class that mirror instance methods.

var name = 'MongoDB';

var lower = String.toLowerCase(name);

var name = 'MongoDB';

var lower = name.toLowerCase();
print(name + ' becomes ' + lower);

With V8, use the String instance methods instead of following generic methods:

Array Generic Methods¶

V8 does not support Array generic methods. Array generics are a set of methods on the Array class that mirror instance methods.

var arr = [4, 8, 15, 16, 23, 42];

function isEven (val) {
   return 0 === val % 2;
}

var allEven = Array.every(arr, isEven);
print(allEven);

var allEven = arr.every(isEven);
print(allEven);

With V8, use the Array instance methods instead of the following generic methods:

Array Instance Method toSource()¶

V8 does not support the Array instance method toSource(). Use the Array instance method toString() instead.

uneval()¶

V8 does not support the non-standard method uneval(). Use the standardized JSON.stringify() method instead.