How to Index Numeric Values

1
{
2
  "name": "default",
3
  "collectionName": "accounts",
4
  "database": "sample_analytics",
5
  "mappings": {
6
    "dynamic": false,
7
    "fields": {
8
      "account_id": {
9
        "type": "number",
10
        "representation": "int64"
11
      }
12
    }
13
  }
14
}

1
{
2
  "name": "default",
3
  "collectionName": "accounts",
4
  "database": "sample_analytics",
5
  "mappings": {
6
    "dynamic": false,
7
    "fields": {
8
      "account_id": {
9
        "type": "number",
10
        "representation": "int64",
11
        "indexDoubles": false
12
      }
13
    }
14
  }
15
}

1
{
2
  "name": "default",
3
  "collectionName": "listingsAndReviews",
4
  "database": "sample_airbnb",
5
  "mappings": {
6
    "dynamic": false,
7
    "fields": {
8
      "bathrooms": {
9
        "type": "number",
10
        "indexIntegers": false
11
      }
12
    }
13
  }
14
}

1
{
2
  "mappings": { 
3
    "dynamic": false, 
4
    "fields": { 
5
        "title": {
6
            "type": "number",
7
            "representation": "int64"
8
        }
9
    } 
10
  }
11
}

1
{
2
  "mappings": { 
3
    "dynamic": false, 
4
    "fields": { 
5
        "title": {
6
            "type": "number",
7
            "representation": "int64",
8
            "indexDoubles": false
9
        }
10
    } 
11
  }
12
}

1
{
2
  "mappings": { 
3
    "dynamic": false, 
4
    "fields": { 
5
        "title": {
6
            "type": "number",
7
            "indexIntegers": false
8
        }
9
    } 
10
  }
11
}

{
  "mappings": {
    "dynamic": true|false,
    "fields": {
      "<field-name>": {
        "type": "number",
        "representation": "int64|double",
        "indexIntegers": true|false,
        "indexDoubles": true|false
      }
    }
  }
}

1
#include <mongoc/mongoc.h>
2
#include <stdlib.h>
3
4
int main (void)
5
{
6
    mongoc_client_t *client = NULL;
7
    mongoc_collection_t *collection = NULL;
8
    mongoc_database_t *database = NULL;
9
    bson_error_t error;
10
    bson_t cmd = BSON_INITIALIZER;
11
    bool ok = true;
12
13
    mongoc_init();
14
15
    // Connect to your Atlas deployment
16
    client = mongoc_client_new("<connectionString>");
17
    if (!client) {
18
        fprintf(stderr, "Failed to create a MongoDB client.\n");
19
        ok = false;
20
        goto cleanup;
21
    }
22
23
    // Access your database and collection
24
    database = mongoc_client_get_database(client, "sample_analytics");
25
    collection = mongoc_database_get_collection(database, "accounts");
26
27
    // Specify the command and the new index
28
    const char *cmd_str = BSON_STR({
29
        "createSearchIndexes" : "<collectionName>",
30
        "indexes" : [ {
31
            "name" : "default",
32
            "definition" : {
33
                "mappings": { 
34
                    "dynamic": true|false, 
35
                    "fields": { 
36
                        "account_id" : {
37
                            "type": "number",
38
                            "representation": "int64"
39
                        }
40
                    } 
41
                },
42
            }
43
	    } ]
44
	});
45
46
    // Convert your command to BSON
47
    if (!bson_init_from_json(&cmd, cmd_str, -1, &error)) {
48
        fprintf(stderr, "Failed to parse command: %s\n", error.message);
49
        ok = false;
50
        goto cleanup;
51
    }
52
53
    // Create the MongoDB Search index by running the command
54
    if (!mongoc_collection_command_simple (collection, &cmd, NULL, NULL, &error)) {
55
        fprintf(stderr, "Failed to run createSearchIndexes: %s\n", error.message);
56
        ok = false;
57
        goto cleanup;
58
    }
59
    printf ("Index created!\n");
60
61
cleanup:
62
   mongoc_collection_destroy (collection);
63
   mongoc_client_destroy (client);
64
   mongoc_database_destroy (database);
65
   bson_destroy (&cmd);
66
   mongoc_cleanup ();
67
   return ok ? EXIT_SUCCESS : EXIT_FAILURE;
68
}

1
#include <mongoc/mongoc.h>
2
#include <stdlib.h>
3
4
int main (void)
5
{
6
    mongoc_client_t *client = NULL;
7
    mongoc_collection_t *collection = NULL;
8
    mongoc_database_t *database = NULL;
9
    bson_error_t error;
10
    bson_t cmd = BSON_INITIALIZER;
11
    bool ok = true;
12
13
    mongoc_init();
14
15
    // Connect to your Atlas deployment
16
    client = mongoc_client_new("<connectionString>");
17
    if (!client) {
18
        fprintf(stderr, "Failed to create a MongoDB client.\n");
19
        ok = false;
20
        goto cleanup;
21
    }
22
23
    // Access your database and collection
24
    database = mongoc_client_get_database(client, "sample_analytics");
25
    collection = mongoc_database_get_collection(database, "accounts");
26
27
    // Specify the command and the new index
28
    const char *cmd_str = BSON_STR({
29
        "createSearchIndexes" : "<collectionName>",
30
        "indexes" : [ {
31
            "name" : "default",
32
            "definition" : {
33
                "mappings": { 
34
                    "dynamic": true|false, 
35
                    "fields": { 
36
                        "account_id" : {
37
                            "type": "number",
38
                            "representation": "int64",
39
                            "indexDoubles": false
40
                        }
41
                    } 
42
                },
43
            }
44
	    } ]
45
	});
46
47
    // Convert your command to BSON
48
    if (!bson_init_from_json(&cmd, cmd_str, -1, &error)) {
49
        fprintf(stderr, "Failed to parse command: %s\n", error.message);
50
        ok = false;
51
        goto cleanup;
52
    }
53
54
    // Create the MongoDB Search index by running the command
55
    if (!mongoc_collection_command_simple (collection, &cmd, NULL, NULL, &error)) {
56
        fprintf(stderr, "Failed to run createSearchIndexes: %s\n", error.message);
57
        ok = false;
58
        goto cleanup;
59
    }
60
    printf ("Index created!\n");
61
62
cleanup:
63
   mongoc_collection_destroy (collection);
64
   mongoc_client_destroy (client);
65
   mongoc_database_destroy (database);
66
   bson_destroy (&cmd);
67
   mongoc_cleanup ();
68
   return ok ? EXIT_SUCCESS : EXIT_FAILURE;
69
}

1
#include <mongoc/mongoc.h>
2
#include <stdlib.h>
3
4
int main (void)
5
{
6
    mongoc_client_t *client = NULL;
7
    mongoc_collection_t *collection = NULL;
8
    mongoc_database_t *database = NULL;
9
    bson_error_t error;
10
    bson_t cmd = BSON_INITIALIZER;
11
    bool ok = true;
12
13
    mongoc_init();
14
15
    // Connect to your Atlas deployment
16
    client = mongoc_client_new("<connectionString>");
17
    if (!client) {
18
        fprintf(stderr, "Failed to create a MongoDB client.\n");
19
        ok = false;
20
        goto cleanup;
21
    }
22
23
    // Access your database and collection
24
    database = mongoc_client_get_database(client, "sample_airbnb");
25
    collection = mongoc_database_get_collection(database, "listingsAndReviews");
26
27
    // Specify the command and the new index
28
    const char *cmd_str = BSON_STR({
29
        "createSearchIndexes" : "<collectionName>",
30
        "indexes" : [ {
31
            "name" : "default",
32
            "definition" : {
33
                "mappings": { 
34
                    "dynamic": true|false, 
35
                    "fields": { 
36
                        "account_id" : {
37
                            "type": "number",
38
                            "indexIntegers": false
39
                        }
40
                    } 
41
                },
42
            }
43
	    } ]
44
	});
45
46
    // Convert your command to BSON
47
    if (!bson_init_from_json(&cmd, cmd_str, -1, &error)) {
48
        fprintf(stderr, "Failed to parse command: %s\n", error.message);
49
        ok = false;
50
        goto cleanup;
51
    }
52
53
    // Create the MongoDB Search index by running the command
54
    if (!mongoc_collection_command_simple (collection, &cmd, NULL, NULL, &error)) {
55
        fprintf(stderr, "Failed to run createSearchIndexes: %s\n", error.message);
56
        ok = false;
57
        goto cleanup;
58
    }
59
    printf ("Index created!\n");
60
61
cleanup:
62
   mongoc_collection_destroy (collection);
63
   mongoc_client_destroy (client);
64
   mongoc_database_destroy (database);
65
   bson_destroy (&cmd);
66
   mongoc_cleanup ();
67
   return ok ? EXIT_SUCCESS : EXIT_FAILURE;
68
}

1
using MongoDB.Bson;
2
using MongoDB.Driver;
3
4
// connect to your Atlas deployment
5
var uri = "<connection-string>";
6
7
var client = new MongoClient(uri);
8
9
var db = client.GetDatabase("sample_analytics");
10
var collection = db.GetCollection<BsonDocument>("accounts");
11
12
// define your MongoDB Search index
13
var index =  new CreateSearchIndexModel(
14
  "default", new BsonDocument
15
  {
16
    { "mappings", new BsonDocument
17
      {
18
        { "dynamic", false },
19
        { "fields", new BsonDocument
20
          {
21
            { "account_id", new BsonDocument
22
              {
23
                { "type", "number" },
24
                { "representation", "int64" }
25
              }
26
            }
27
          }
28
        }
29
      }
30
    }
31
  });
32
33
var result = collection.SearchIndexes.CreateOne(index);
34
Console.WriteLine($"New index name: {result}");

1
using MongoDB.Bson;
2
using MongoDB.Driver;
3
4
// connect to your Atlas deployment
5
var uri = "<connection-string>";
6
7
var client = new MongoClient(uri);
8
9
var db = client.GetDatabase("sample_analytics");
10
var collection = db.GetCollection<BsonDocument>("accounts");
11
12
// define your MongoDB Search index
13
var index =  new CreateSearchIndexModel(
14
  "default", new BsonDocument
15
  {
16
    { "mappings", new BsonDocument
17
      {
18
        { "dynamic", false },
19
        { "fields", new BsonDocument
20
          {
21
            { "account_id", new BsonDocument
22
              {
23
                { "type", "number" },
24
                { "representation", "int64" },
25
                { "indexDoubles", false }
26
              }
27
            }
28
          }
29
        }
30
      }
31
    }
32
  });
33
34
var result = collection.SearchIndexes.CreateOne(index);
35
Console.WriteLine($"New index name: {result}");

1
using MongoDB.Bson;
2
using MongoDB.Driver;
3
4
// connect to your Atlas deployment
5
var uri = "<connection-string>";
6
7
var client = new MongoClient(uri);
8
9
var db = client.GetDatabase("sample_airbnb");
10
var collection = db.GetCollection<BsonDocument>("listingsAndReviews");
11
12
// define your MongoDB Search index
13
var index =  new CreateSearchIndexModel(
14
  "default", new BsonDocument
15
  {
16
    { "mappings", new BsonDocument
17
      {
18
        { "dynamic", false },
19
        { "fields", new BsonDocument
20
          {
21
            { "bathrooms", new BsonDocument
22
              {
23
                { "type", "number" },
24
                { "indexIntegers", false }
25
              }
26
            }
27
          }
28
        }
29
      }
30
    }
31
  });
32
33
var result = collection.SearchIndexes.CreateOne(index);
34
Console.WriteLine($"New index name: {result}");

1
#include <iostream>
2
3
#include <bsoncxx/builder/basic/document.hpp>
4
#include <bsoncxx/json.hpp>
5
#include <mongocxx/client.hpp>
6
#include <mongocxx/instance.hpp>
7
#include <mongocxx/uri.hpp>
8
9
using bsoncxx::builder::basic::kvp;
10
using bsoncxx::builder::basic::make_document;
11
12
int main(){
13
14
    mongocxx::instance instance;
15
    mongocxx::uri uri("<connection-string>");
16
    mongocxx::client client(uri);
17
18
    auto db = client["sample_analytics"];
19
    auto collection = db["accounts"];
20
21
    // instantiate a ``mongocxx::search_index_view`` on your collection
22
    auto siv = collection.search_indexes();
23
24
    {
25
        auto name = "default";
26
        auto definition = make_document(
27
            kvp("mappings", make_document(
28
                kvp("dynamic", false),
29
                kvp("fields", make_document(
30
                    kvp("account_id", make_document(
31
                        kvp("type", "number"),
32
                        kvp("representation", "int64")
33
                    ))
34
                ))
35
            ))
36
        );
37
38
        auto model = mongocxx::search_index_model(name, definition.view());
39
40
        // Create the search index
41
        auto result = siv.create_one(model);
42
        std::cout << "New index name: " << result << std::endl;
43
    }
44
}

1
#include <iostream>
2
3
#include <bsoncxx/builder/basic/document.hpp>
4
#include <bsoncxx/json.hpp>
5
#include <mongocxx/client.hpp>
6
#include <mongocxx/instance.hpp>
7
#include <mongocxx/uri.hpp>
8
9
using bsoncxx::builder::basic::kvp;
10
using bsoncxx::builder::basic::make_document;
11
12
int main(){
13
14
    mongocxx::instance instance;
15
    mongocxx::uri uri("<connection-string>");
16
    mongocxx::client client(uri);
17
18
    auto db = client["sample_analytics"];
19
    auto collection = db["accounts"];
20
21
    // instantiate a ``mongocxx::search_index_view`` on your collection
22
    auto siv = collection.search_indexes();
23
24
    {
25
        auto name = "default";
26
        auto definition = make_document(
27
            kvp("mappings", make_document(
28
                kvp("dynamic", false),
29
                kvp("fields", make_document(
30
                    kvp("account_id", make_document(
31
                        kvp("type", "number"),
32
                        kvp("representation", "int64"),
33
                        kvp("indexDoubles": false)
34
                    ))
35
                ))
36
            ))
37
        );
38
39
        auto model = mongocxx::search_index_model(name, definition.view());
40
41
        // Create the search index
42
        auto result = siv.create_one(model);
43
        std::cout << "New index name: " << result << std::endl;
44
    }
45
}

1
#include <iostream>
2
3
#include <bsoncxx/builder/basic/document.hpp>
4
#include <bsoncxx/json.hpp>
5
#include <mongocxx/client.hpp>
6
#include <mongocxx/instance.hpp>
7
#include <mongocxx/uri.hpp>
8
9
using bsoncxx::builder::basic::kvp;
10
using bsoncxx::builder::basic::make_document;
11
12
int main(){
13
14
    mongocxx::instance instance;
15
    mongocxx::uri uri("<connection-string>");
16
    mongocxx::client client(uri);
17
18
    auto db = client["sample_airbnb"];
19
    auto collection = db["listingsAndReviews"];
20
21
    // instantiate a ``mongocxx::search_index_view`` on your collection
22
    auto siv = collection.search_indexes();
23
24
    {
25
        auto name = "default";
26
        auto definition = make_document(
27
            kvp("mappings", make_document(
28
                kvp("dynamic", false),
29
                kvp("fields", make_document(
30
                    kvp("bathrooms", make_document(
31
                        kvp("type", "number"),
32
                        kvp("indexIntegers", false)
33
                    ))
34
                ))
35
            ))
36
        );
37
38
        auto model = mongocxx::search_index_model(name, definition.view());
39
40
        // Create the search index
41
        auto result = siv.create_one(model);
42
        std::cout << "New index name: " << result << std::endl;
43
    }
44
}