
## Table of Contents

1. [Introduction](#introduction)
2. [Getting Started](#getting-started)
3. [Connect to MongoDB](#connect-to-mongodb)
4. [Define the MongoDB Schema](#define-the-mongodb-schema)
5. [Find Data from MongoDB](#find-data-from-mongodb)
6. [Conclusion](#conclusion)

## Introduction

This blog shows a tutorial on how to find data from MongoDB by using Node.js
with Mongoose. Mongoose is the Object Data Modeling library for MongoDB and
Node.js. It provides functions for schema, query building, and more. If you
don't use Mongoose to access MongoDB with Node.js, then you can use the
MongoDB package for Node.js directly.

## Getting Started

First, initialize a new npm package. We'll create a new package and a new
file, and add our code for how to find data from MongoDB.

```
npm init -y
```

Next, let's install the mongoose package. This will be the only package we'll
use for this tutorial.

```
npm install --save mongoose
```

Create an **index.js** file. We'll add our code to this file to
connect to MongoDB and query data from the database.

## Connect to MongoDB

Now, the following is a sample code to connect to MongoDB. Assume you already
have MongoDB set up locally and have a database called
**your-database**.

```
const {connect} = require('mongoose');

connect('mongodb://localhost:27017/your-database')
.then(() => {
    console.info('connect successfully')
})
.catch(() => {
    console.error('connection error');
});
```

## Define the MongoDB Schema

Here, we'll define our collection in MongoDB. The collection name will be
**my-collection-name**.

```
let localModel = new Schema({
    key: {
        type: String
    },
    value: {
        type: String
    },
    culture: {
        type: String
    }
})

let localSchema = model('localization', localModel, 'my-collection-name');
```

## Find Data from MongoDB

Now, this is the final step. We'll find data from this collection. After this
code runs, it should return a list of results matching the key `test-key`
from the collection **my-collection-name**.

```
const getDataAsync = async() => {

    let result = await localSchema.find({key: 'test-key'});

}

getDataAsync();
```

If you only expect to return one record, you can use the following query.

```
const getOneAsync = async() => {

    let result = await localSchema.findOne({key: 'test-key'});
    console.info(result);
}

getOneAsync();
```

If you want to find a record and then update it, you can try the following
code. It will find the record and then update it with the new value.

```
const getAndModifyAsync = async() => {

    let result = await localSchema.findOneAndUpdate({key: 'test-key'}, {
        value: "my new value"
    })
}

getAndModifyAsync();
```

## Conclusion

Above is how you can get data from MongoDB by using Node.js with Mongoose.


This blog shows a tutorial on how to find data from MongoDB by using Node.js with Mongoose.

How to Find Record from MongoDB with Node.js and Mongoose


## Table of Contents

1. [Introduction](#introduction)
2. [Getting Started](#getting-started)
3. [Connect to MongoDB](#connect-to-mongodb)
4. [Define the MongoDB Schema](#define-the-mongodb-schema)
5. [Insert Some Data into MongoDB](#insert-some-data-into-mongodb)
6. [Delete Records with Mongoose](#delete-records-with-mongoose)
7. [Conclusion](#conclusion)

## Introduction

This blog shows a tutorial on how to delete data from MongoDB by using Node.js
with Mongoose. Mongoose is the Object Data Modeling library for MongoDB and
Node.js. It provides functions for schema, query building, and more. If you
don't use Mongoose to access MongoDB with Node.js, then you can use the
MongoDB package for Node.js directly.

## Getting Started

First, initialize a new npm package. We'll create a new package and a new
file, and add our code for how to delete data from MongoDB.

```
npm init -y
```

Next, let's install the mongoose package. This will be the only package we'll
use for this tutorial.

```
npm install --save mongoose
```

Create an **index.js** file. We'll add our code to this file to
connect to MongoDB and delete data from the database.

## Connect to MongoDB

Now, the following is a sample code to connect to MongoDB. Assume you already
have MongoDB set up locally and have a database called
**your-database**.

```
const {connect} = require('mongoose');

connect('mongodb://localhost:27017/your-database')
.then(() => {
    console.info('connect successfully')
})
.catch(() => {
    console.error('connection error');
});
```

## Define the MongoDB Schema

Here, we'll define our collection in MongoDB. The collection name will be
**my-collection-name**.

```
let localModel = new Schema({
    key: {
        type: String
    },
    value: {
        type: String
    },
    culture: {
        type: String
    }
})

let localSchema = model('localization', localModel, 'my-collection-name');
```

## Insert Some Data into MongoDB

Before we can try the Mongoose delete function, let's add some test data. The
following code will add 100 different records into the collection.

```
const createTestMillionAsync = async(roopLimit) => {
    let timerName = `insert-timer-${roopLimit}`;
    console.time(timerName)
    let testTargetList = [];
    for (let index = 0; index < roopLimit; index++) {

        testTargetList.push({
            key: `test-key-${index}`,
            value: `my test value : ${index}`,
            culture: 'en-US'
        });

    }

    await localSchema.insertMany(testTargetList);

    console.timeEnd(timerName);
}

createTestMillionAsync(100);
```

## Delete Records with Mongoose

The following example shows how to delete a specific record. You just need to
call `deleteOne` and pass the `_id` value.

```
const removeDataAsync = async() => {

  let result = await localSchema.deleteOne({
        _id: '60a872a9d3ed022504e3aa01'
    });
    if (result) {
        console.info('update successfully', result);
    }
}

removeDataAsync();
```

In case you want to delete everything from the collection, you can try the
following code.

```
const removeDataAsync = async() => {

    let result = await localSchema.deleteMany({});
    if (result) {
        console.info('update successfully', result);
    }
}

removeDataAsync();
```

## Conclusion

Above is how you can use the delete function with Mongoose to remove data from
MongoDB by using Node.js.


This blog shows a tutorial on how to delete data from MongoDB by using Node.js with Mongoose.

How to Delete Data from MongoDB with Node.js and Mongoose


## Table of Contents

1. [Introduction](#introduction)
2. [Get Started](#get-started)
3. [Connect to MongoDB](#connect-to-mongodb)
4. [Define MongoDB Schema](#define-mongodb-schema)
5. [Update Data in MongoDB](#update-data-in-mongodb)
6. [Conclusion](#conclusion)

## Introduction

This blog will show a tutorial about how to update data in MongoDB by using
Node.js with Mongoose. Mongoose is the Object Data Modeling library for
MongoDB and Node.js. It provides functions for schema, query building, and
more. If you don't use Mongoose to access MongoDB with Node.js, then you can
use the MongoDB package for Node.js directly.

## Get Started

First, initialize a new npm package. We'll create a new package and a new file,
and add our code for how to update data in MongoDB.

```
npm init -y
```

Next, let's install the mongoose package. This will be the only package we'll
use for this tutorial.

```
npm install --save mongoose
```

Create an **index.js** file. We'll add our code to this file to
connect to MongoDB and update data in the database.

## Connect to MongoDB

Now, the following is sample code to connect to MongoDB. Assume you already
have MongoDB set up on your local machine and have a database named
**your-database**.

```
const {connect} = require('mongoose');

connect('mongodb://localhost:27017/your-database')
.then(() => {
    console.info('connect successfully')
})
.catch(() => {
    console.error('connection error');
});
```

## Define MongoDB Schema

Here, we'll define our collection in MongoDB. The collection name will be
**my-collection-name**.

```
let localModel = new Schema({
    key: {
        type: String
    },
    value: {
        type: String
    },
    culture: {
        type: String
    }
})

let localSchema = model('localization', localModel, 'my-collection-name');
```

## Update Data in MongoDB

Now, this is the final step. We'll find data from the collection, then update
the data. The following code will first find records by key 'test-key', then
update the value field.

```
const updateDataAsync = async() => {

    let result = await localSchema.find({key: 'test-key'});
    if (result) {
        let updateResult = await localSchema.updateOne({
            _id: result[0]._id
        }, {
            value: 'test3'
        });
        if (updateResult) {
            console.info('update successfully')
        }
    }
}

updateDataAsync();
```

## Conclusion

The above is how you can update data in MongoDB by using Node.js with
Mongoose.


This tutorial shows how to update data in MongoDB by using Node.js with Mongoose, including connecting to MongoDB, defining a schema, and performing update operations.

How to Update MongoDB Data with Node.js and Mongoose


## Table of Contents

1. [Introduction](#introduction)
2. [Getting Started](#getting-started)
3. [Connect to MongoDB](#connect-to-mongodb)
4. [Define the MongoDB Schema](#define-the-mongodb-schema)
5. [Insert New Data into MongoDB](#insert-new-data-into-mongodb)
6. [Insert Data into MongoDB by Using mongoose.create](#insert-data-into-mongodb-by-using-mongoosecreate)
7. [Conclusion](#conclusion)

## Introduction

This blog shows a tutorial on how to insert data into MongoDB by using Node.js
with Mongoose. Mongoose is the Object Data Modeling library for MongoDB and
Node.js. It provides functions for schema, query building, and more. If you
don't use Mongoose to access MongoDB with Node.js, then you can use the
MongoDB package for Node.js directly.

## Getting Started

First, initialize a new npm package. We'll create a new package and a new
file, and add our code for how to insert data into MongoDB.

```
npm init -y
```

Next, let's install the mongoose package. This will be the only package we'll
use for this tutorial.

```
npm install --save mongoose
```

Create an **index.js** file. We'll add our code to this file to
connect to MongoDB and insert data into the database.

## Connect to MongoDB

Now, the following is a sample code to connect to MongoDB. Assume you already
have MongoDB set up locally and have a database called
**your-database**.

```
const {connect} = require('mongoose');

connect('mongodb://localhost:27017/your-database')
.then(() => {
    console.info('connect successfully')
})
.catch(() => {
    console.error('connection error');
});
```

## Define the MongoDB Schema

Here, we'll define our collection in MongoDB. The collection name will be
**my-collection-name**.

```
let localModel = new Schema({
    key: {
        type: String
    },
    value: {
        type: String
    },
    culture: {
        type: String
    }
})

let localSchema = model('localization', localModel, 'my-collection-name');
```

## Insert New Data into MongoDB

Now, this is the final step. We'll insert new data into the collection using
**insertMany**. After this code runs, it should insert new data
into the collection **my-collection-name**.

```
localSchema.insertMany({
    key: 'test-key',
    value: 'key description',
    culture: 'en-US'
}).then(function() {
    console.info('insert new data successfully')
}).catch(function() {
    console.error('has error when insert new data');
})
```

## Insert Data into MongoDB by Using mongoose.create

Another way to insert data is the following, but which one is better? Should
you use insert or create?

```
const createAsync = async() => {
    await localSchema.create({
        key: 'test-key-2',
        value: 'key2 description',
        culture: 'en-US'
    });
}

createAsync();
```

It looks like it is better to use `insertMany` because it's faster and has
fewer issues. I did some research by inserting 100,000 records into MongoDB.

When I executed the following code on my macOS, the insert-timer time was
11922.764ms.

```
const createTestMillionAsync = async() => {
    console.time('insert-timer')
    let testTargetList = [];
    for (let index = 0; index < 100000; index++) {

        testTargetList.push({
            key: `test-key-${index}`,
            value: `my test value : ${index}`,
            culture: 'en-US'
        });

    }

    await localSchema.insertMany(testTargetList);

    console.timeEnd('insert-timer');
}

createTestMillionAsync();
```

However, when I tried inserting 100,000 records with `create`, I got a
timeout error. The default connection timeout is 10000ms.

```
const createTestMillionAsync = async(roopLimit) => {
    let timerName = `insert-timer-${roopLimit}`;
    console.time(timerName)
    let testTargetList = [];
    for (let index = 0; index < roopLimit; index++) {

        testTargetList.push({
            key: `test-key-${index}`,
            value: `my test value : ${index}`,
            culture: 'en-US'
        });

    }

    await localSchema.insertMany(testTargetList);

    console.timeEnd(timerName);
}

createTestMillionAsync(100000);
```

So I extended the connectionTimeout from 10000 to 50000 and re-ran the
following combinations. You can see that `insertMany` is 7 times faster than
`create`.

| **Records** | **mongoose.create**                  | **mongoose.insertMany** |
| ----------- | ------------------------------------ | ----------------------- |
| 100000      | 75261.921ms                          | 11869.793.ms            |
| 500000      | Error: Javascript heap out of memory | 61775.343ms             |

## Conclusion

Above is how you can insert new data into MongoDB with Node.js and Mongoose.
It looks like it's better to use `insertMany` for better performance.


This blog shows a tutorial on how to insert data into MongoDB by using Node.js with Mongoose.

How to Insert Data into MongoDB with Node.js and Mongoose


## Table of Contents

1. [Introduction](#introduction)
2. [How to Use MongoDB Text Search](#how-to-use-mongodb-text-search)
3. [Stop Words and Stemming in MongoDB Text Search](#stop-words-and-stemming-in-mongodb-text-search)
4. [Getting Started with MongoDB Text Search](#getting-started-with-mongodb-text-search)
5. [What's Going On, Doesn't Work!](#whats-going-on-doesnt-work)
6. [So, What Did I Do?](#so-what-did-i-do)
7. [How Does MongoDB Define Score for Text Search?](#how-does-mongodb-define-score-for-text-search)
8. [Conclusion](#conclusion)

## Introduction

MongoDB provides a text search function since version 2.4. This blog will show how to use MongoDB text search. All the examples below are run based on MongoDB version 3.0.5. I'm also using Robomongo (0.8.5) to run all the MongoDB commands.

I also have a code snippet about how to use Mongoose with text search, but I recommend using at least version 2.6, since 2.4 with Mongoose has some problems.

## How to Use MongoDB Text Search

### Stop Words and Stemming in MongoDB Text Search

Before jumping into how to use MongoDB text search, we need to understand how MongoDB handles stop words and stemming. **Stop words** in MongoDB means that if you have "I like apple", the indexed word will be **apple**. **Stemming** is like "cook, cooking, cooks" — MongoDB's text engine will index "cook".

> I like apple, also I enjoy cooking.

In the above example, MongoDB will index `apple` and `cook`. There is a very good blog about this topic: text-search-mongodb-stemming.

## Getting Started with MongoDB Text Search

### Get MongoDB's Version

This command will tell you what version of MongoDB you're using.

```
db.version()
// 3.0.5
```

### Get Current MongoDB Database Name

This will return your current database name. Before you run your query, you need to check that you're connected to the correct MongoDB database.

```
db.getName()
// the current database name.
```

### Check Index of Current Collection

You can run the following command if you want to check whether your collection has a text index or other indexes.

The following example shows how to check whether my collection `Posts` contains any indexes.

```
// You run this
db.posts.getIndexes()
```

```
// Then you will get some result like this, or if there's no index then just empty JSON. As you can see, the following example contains no text search index.
{
    "0" : {
        "v" : 1,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "dake-tech.posts"
    },
    "1" : {
        "v" : 1,
        "unique" : true,
        "key" : {
            "slug" : 1
        },
        "name" : "slug_1",
        "ns" : "dake-tech.posts",
        "background" : true,
        "safe" : null
    }
}
```

Now, we're going to add a text index to this collection. First, the collection `Posts` looks like the following. I'd like to create a text index on `content.brief`, `content.extended`, and `title`.

```
{
    "_id" : ObjectId("535cc04cd06eabf033ee36bc"),
    "__v" : 0,
    "author" : ObjectId("535c4fe25115d24c0c4cf84b"),
    "categories" : [],
    "content" : {
        "brief" : "Looks like http://embed.ly/ is a great site if I want to create something with a URL. It'll get the short version of the URL's detail.",
        "extended" : ""
    },
    "publishedDate" : ISODate("2014-04-01T07:00:00.000Z"),
    "slug" : "embedly-get-url-link-detail",
    "state" : "published",
    "title" : "embed.ly - Get url link detail"
}
```

### Add Text Index to Title

First, let's add a text index to the title:

```
db.posts.ensureIndex({title: "text"});
```

After I created the text index on the `title` field and ran `db.posts.getIndexes()` again to check my index, I got the following new entry. I had successfully added a text index to my Posts.Title.

```
"4" : {
        "v" : 1,
        "key" : {
            "_fts" : "text",
            "_ftsx" : 1
        },
        "name" : "title_text",
        "ns" : "dake-tech.posts",
        "weights" : {
            "title" : 1
        },
        "default_language" : "english",
        "language_override" : "language",
        "textIndexVersion" : 2
    }
```

### Validate the Index

Now, MongoDB also has `YourCollection.validate()` which will validate your index. When I ran `db.posts.validate()`, I got the following result about my title field's text index. The `"dake-tech.posts.$title_text" : 1464` tells you the post.title indexed `1464` key words.

```
{
    "ns" : "dake-tech.posts",
    "datasize" : 4.72926e+006,
    "nrecords" : 325,
    "lastExtentSize" : 1.67772e+007,
    "firstExtent" : "0:ef000 ns:dake-tech.posts",
    "lastExtent" : "0:351000 ns:dake-tech.posts",
    "extentCount" : 4,
    "firstExtentDetails" : {
        "loc" : "0:ef000",
        "xnext" : "0:111000",
        "xprev" : "null",
        "nsdiag" : "dake-tech.posts",
        "size" : 8192,
        "firstRecord" : "0:ef0b0",
        "lastRecord" : "0:f0eb0"
    },
    "lastExtentDetails" : {
        "loc" : "0:351000",
        "xnext" : "null",
        "xprev" : "0:151000",
        "nsdiag" : "dake-tech.posts",
        "size" : 1.67772e+007,
        "firstRecord" : "0:3510b0",
        "lastRecord" : "0:591230"
    },
    "deletedCount" : 5,
    "deletedSize" : 1.44095e+007,
    "nIndexes" : 5,
    "keysPerIndex" : {
        "dake-tech.posts.$_id_" : 325,
        "dake-tech.posts.$slug_1" : 325,
        "dake-tech.posts.$state_1" : 325,
        "dake-tech.posts.$publishedDate_1" : 325,
        "dake-tech.posts.$title_text" : 1464
    },
    "valid" : true,
    "errors" : [],
    "warning" : "Some checks omitted for speed. use {full:true} option to do more thorough scan.",
    "ok" : 1.0000000000000000
}
```

### Running a Text Search

When you type `db.posts.runCommand("text", {search: "mongodb"})`, you might get a result like the following:

```
{
    "ok" : 0.0000000000000000,
    "errmsg" : "no such command: text",
    "code" : 59,
    "bad cmd" : {
        "text" : "posts",
        "search" : "mongodb"
    }
}
```

## What's Going On, Doesn't Work!

You might try the following — go to admin and enable text search. However, you will still get the same result. The following command seems to work for older MongoDB versions, maybe 2.4 to 2.6. However, if you use the latest MongoDB (3.0 or above), text search is enabled by default, and `runCommand("text",` no longer exists.

```
use admin
db.runCommand({setParameter: 1, textSearchEnabled: true})

db.posts.runCommand("text", {search: "mongodb"})

{
    "was" : true,
    "ok" : 1.0000000000000000
}
```

## So, What Did I Do?

If your MongoDB version is 3.0 or above (like my current MongoDB 3.0.5), you can try the following:

```
db.posts.find( { $text: { $search: "javascript" } } )
```

Also, here is the result I got. Awesome, right? You get 12 results.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_0eg17u58c.png)

### Adding Text Index to Multiple Fields

Now, I'm going to add a text index to additional fields: `content.brief` and `content.extended`. So you type `db.posts.ensureIndex({'content.brief': 'text'});`. Then you get this error — what's going on? Can I only add one text index?

```
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 3,
    "errmsg" : "exception: Index with pattern: { _fts: \"text\", _ftsx: 1 } already exists with different options",
    "code" : 85,
    "ok" : 0
}
```

The answer is that in the current version (3.0.5), you can only have one text index per collection. If you want to add multiple fields for text search, you need to do the following. First, run `db.posts.dropIndex('title_text')` to drop the old text index.

This is the result you will get:

```
{
    "nIndexesWas" : 5,
    "ok" : 1.0000000000000000
}
```

Now, you can run the following command to add a text index to multiple fields:

```
db.posts.ensureIndex({title: 'text', 'content.brief': 'text', 'content.extended': 'text'});
```

Once it shows a result like the following, the new index is added.

If you run `db.posts.getIndexes()`, you can verify that your text index has been added:

```
"4" : {
        "v" : 1,
        "key" : {
            "_fts" : "text",
            "_ftsx" : 1
        },
        "name" : "title_text_content.brief_text_content.extended_text",
        "ns" : "dake-tech.posts",
        "weights" : {
            "content.brief" : 1,
            "content.extended" : 1,
            "title" : 1
        },
        "default_language" : "english",
        "language_override" : "language",
        "textIndexVersion" : 2
    }
```

Also, if you run the index validation `db.posts.validate()`, you can see that the new text index has `31429` key words indexed (`"dake-tech.posts.$title_text_content.brief_text_content.extended_text" : 31429`), compared to the previous title-only index which had `1464` keys indexed.

```
{
    "ns" : "dake-tech.posts",
    "datasize" : 4.72926e+006,
    "nrecords" : 325,
    "lastExtentSize" : 1.67772e+007,
    "firstExtent" : "0:ef000 ns:dake-tech.posts",
    "lastExtent" : "0:351000 ns:dake-tech.posts",
    "extentCount" : 4,
    "firstExtentDetails" : {
        "loc" : "0:ef000",
        "xnext" : "0:111000",
        "xprev" : "null",
        "nsdiag" : "dake-tech.posts",
        "size" : 8192,
        "firstRecord" : "0:ef0b0",
        "lastRecord" : "0:f0eb0"
    },
    "lastExtentDetails" : {
        "loc" : "0:351000",
        "xnext" : "null",
        "xprev" : "0:151000",
        "nsdiag" : "dake-tech.posts",
        "size" : 1.67772e+007,
        "firstRecord" : "0:3510b0",
        "lastRecord" : "0:591230"
    },
    "deletedCount" : 5,
    "deletedSize" : 1.44095e+007,
    "nIndexes" : 5,
    "keysPerIndex" : {
        "dake-tech.posts.$_id_" : 325,
        "dake-tech.posts.$slug_1" : 325,
        "dake-tech.posts.$state_1" : 325,
        "dake-tech.posts.$publishedDate_1" : 325,
        "dake-tech.posts.$title_text_content.brief_text_content.extended_text" : 31429
    },
    "valid" : true,
    "errors" : [],
    "warning" : "Some checks omitted for speed. use {full:true} option to do more thorough scan.",
    "ok" : 1.0000000000000000
}
```

Now let's run the same text search query again with the score:

```
db.posts.find( { $text: { $search: "javascript" } }, { score: { $meta: "textScore" }} )
```

![](https://d1p0mp3f1fx0hz.cloudfront.net/_uwqsh0ebl.png)

This is not what I expected — the first result's title is not related to JavaScript.

## How Does MongoDB Define Score for Text Search?

I don't have an answer for this yet; this is something I want to figure out. In the meantime, once your text search is enabled, you can try the following queries. You can also find documentation from MongoDB [here](https://docs.mongodb.org/manual/reference/operator/query/text/).

1. Search for a word:
`db.posts.find( { $text: { $search: "javascript" } } )`

2. Search for a phrase:
`db.posts.find( { $text: { $search: "javascript angular react" } } )`

3. Exclude documents that contain a term (search for "javascript" and exclude "angular"):
`db.posts.find( { $text: { $search: "javascript -angular" } } )`

4. Search in a different language:
`db.posts.find( { $text: { $search: "javascript", $language: "es" } } )`

5. Case-sensitive search:
`db.posts.find( { $text: { $search: "Javascript", $caseSensitive: true } } )`

6. Case-sensitive phrase search:
`db.posts.find( { $text: { $search: "\"Javascript React\"", $caseSensitive: true } } )`

7. Case-sensitive with excluded term (search "Javascript" but exclude lowercase "javascript"):
`db.posts.find( { $text: { $search: "Javascript -javascript", $caseSensitive: true } } )`

8. Diacritic-sensitive search for a term

9. Diacritic sensitivity with negated term

10. Return the text search score:
`db.posts.find( { $text: { $search: "javascript" } }, { score: { $meta: "textScore" }} )`

11. Sort by text search score

12. Return top 2 matching documents

13. Text search with additional query and sort expressions

## Conclusion

MongoDB text search is a powerful feature that allows you to perform full-text queries on string content. Key takeaways include: you can only have one text index per collection (but it can span multiple fields), text search uses stop words and stemming to index content, and starting from MongoDB 3.0, text search is enabled by default using the `$text` operator instead of the legacy `runCommand("text", ...)` syntax.


A guide on how to set up and use MongoDB text search with Node.js, including indexing, querying, and scoring.

How to Setup MongoDB Text Search with Node.js


## Table of Contents

1. [Introduction](#introduction)
2. [Upgrade Steps](#upgrade-steps)
3. [Conclusion](#conclusion)

## Introduction

I noticed that I had been using MongoDB 2.4, where text search was in beta. Some code like the following was not going to work — `outputDeal` was null.

```
mycollection.textSearch(req.body.searchBox, searchOpt, function (err, outputDeal) {
        var result = inspect(outputDeal, { depth: null });
        console.info(result);
    })
```

MongoDB 2.6 has more features. Key improvements include aggregation enhancements, text-search integration, query-engine improvements, a new write-operation protocol, and security enhancements.

## Upgrade Steps

This blog provides how to upgrade from 2.4 to 2.6 by following these steps:

1. Dump your MongoDB data.

2. Download the binary 2.6 files.

3. Stop all services and apps using MongoDB.

4. Go to the MongoDB bin folder and replace all the DLLs with the new 2.6 versions.

5. Restart all services and apps using MongoDB.

6. You should be able to verify version 2.6 by typing `db.version()`.

After completing the above steps, I could verify that my first text search query was working.

## Conclusion

Upgrading from MongoDB 2.4 to 2.6 is straightforward: dump your data, replace the binaries, and restart your services. The upgrade enables full text search support and many other improvements over the 2.4 beta features.


MongoDB 2.6 Upgrade


#### Table of Contents

1. How to use MongoDB text search with Mongoose
2. Mongodb need to be 2.4 or higher
3. Other References
4. Other Search Engine

This blog shows example code of how to use MongoDB's text search by use
Mongoose. You can also find What's
[Mongoose Text Search at here.

### How to use MongoDB text search with Mongoose

First, install following npm module.

mongoose-text-search

```
textSearch = require('mongoose-text-search')
```

set up your schema

```
// give schema text search capabilities
yourMongooseSchema.plugin(textSearch);
// add a text index
yourMongooseSchema.index(
{
    Title: 'text'
});
```

Following is example how to use text search.

```
var option = {
        // list of schema property you do not want to include
        project: '-DealId -DealSiteId -Title'
        // casts queries based on schema
        , filter: { likes: { $gt: 1000000 }}
        , limit: 10
        , language: 'spanish'
          , lean: true
    };

var keyWord = 'key word to search'
yourCollection.textSearch(keyWord , option, function (err, output)
{
}

More about Mongoose with MongoDB text search, check mongoose-text-search](../../blog/post/mongodb-text-search).
```

### Mongodb need to be 2.4 or higher

### Other References

[Blog -MongoDB Text Search Explained

Enable Text Search

MongoDB release note 3.0

MongoDB release note 3.2

$text

Text Searching with MongoDB

### Other Search Engine

Want to use other popular search engine?

Solr](https://blog.codecentric.de/en/2013/01/text-search-mongodb-stemming/)

    - [Solr.NET](https://github.com/mausch/SolrNet)

[elastic](https://www.elastic.co/)

    - Elasticsearch.NET


How to Use MongoDB TextSearch by Mongoose


## Table of Contents

1. [Introduction](#introduction)
2. [Sample Code](#sample-code)
3. [Conclusion](#conclusion)

## Introduction

This snippet shows how to get all records where the Ids contain a specific ObjectId using Mongoose.

## Sample Code

```
var q= yourCollection.find({ Ids: mongoose.Types.ObjectId('539ba44481973asdfe0c402bc6') });
    q.exec(function (err, items)
    {
        console.info(err);
        console.info(items.length);
    });
```

## Conclusion

Using `mongoose.Types.ObjectId()` inside a `find()` query allows you to search for documents where an array field contains a specific ObjectId. This is useful when working with referenced documents in MongoDB.


Get all records where the Ids contain a specific ObjectId with Mongoose.

Code Snippet - How to Find Items by ObjectId with Mongoose


## Table of Contents

1. [Introduction](#introduction)
2. [Add Mongoose Dependency to Node Package File](#add-mongoose-dependency-to-node-package-file)
3. [Run NPM Command to Install](#run-npm-command-to-install)
4. [Try It Out](#try-it-out)
5. [Best Practice](#best-practice)
6. [Conclusion](#conclusion)

## Introduction

This article provides information to help you get started with Mongoose. Before you start, you must have NPM and MongoDB installed.

## Add Mongoose Dependency to Node Package File

```
"dependencies": {
    "express": "~4.0.0",
    "mongoose": "3.8.12"
  },
```

## Run NPM Command to Install

```
npm install mongoose
```

## Try It Out

Try looking at the following examples to write code:

- NPM mongoose - NPM Package

- http://mongoosejs.com/ - Official Mongoose website

## Best Practice

After you have installed Mongoose and tried sample code, you'll wonder what the best practice is for implementation.

You could reference the following article (it has a file to download):

mongoose-connection-best-practice

## Conclusion

I think the best approach is to keep all the MongoDB connection logic in one place, which handles connecting to MongoDB, closing the MongoDB connection when Node.js shuts down, error handling for MongoDB, and defining all the collections.

These should all be in one place. Then your Node.js code just requires that file and uses its functions for CRUD operations.


This article provides information to help you get started with Mongoose.