
<p>
  This blog will show a tutorial about how to find 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.&nbsp;
</p>
<h2>Get Start</h2>
<p>
  First, initialize a new npm package, we'll create a new package and new file,
  and add our code for how to insert data to MongoDB.
</p>
<pre class="language-markup"><code>npm init -y</code></pre>
<p>
  Next, let's install the mongoose package, this will be the only package we'll
  use for this tutorial.&nbsp;
</p>
<pre class="language-javascript"><code>npm install --save mongoose</code></pre>
<p>
  Create an <strong>index.js</strong>, we'll add our code to this file to
  connect to MongoDB and insert data to the Database.
</p>
<h2>Connect to the MongoDB</h2>
<p>
  Now, the following is a sample code to connect to MongoDB. Assume you already
  set up MongoDB at your local and has a database as
  <strong>your-database</strong>.
</p>
<pre class="language-javascript"><code>const {connect} = require('mongoose');

connect('mongodb://localhost:27017/your-database')
.then(() =&gt; {
    console.info('connect successfully')
})
.catch(() =&gt; {
    console.error('connection error');
});</code></pre>
<h2>Defined MongoDB Schema</h2>
<p>
  Here, we'll define our collection in MongoDB, the collection name will be
  <strong>my-collection-name</strong>.
</p>
<pre class="language-javascript"><code>let localModel = new Schema({
    key: {
        type: String
    },
    value: {
        type: String
    },
    culture: {
        type: String
    }
})

let localSchema = model('localization', localModel, 'my-collection-name');</code></pre>
<h2>Find data from MongoDB</h2>
<p>
  Now, this is the final step we'll find data from this collection after this
  code had run it should return a list of result match the key is 'test-key'
  from collection <strong>my-collection-name</strong>.
</p>
<pre class="language-javascript"><code>const getDataAsync = async() =&gt; {
    
    let result = await localSchema.find({key: 'test-key'});

}

getDataAsync();</code></pre>
<p>If you only expect to return one record, you can do the following query.</p>
<pre class="language-javascript"><code>const getOneAsync = async() =&gt; {

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

getOneAsync();</code></pre>
<p>
  If you want to find the one then update it, you can try the following code.
  It'll find then update with the new value.
</p>
<pre class="language-javascript"><code>const getAndModifyAsync = async() =&gt; {

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

getAndModifyAsync();</code></pre>
<h3>Conclusion</h3>
<p>
  Above is how you can get data from MongoDB by using Node.js with Mongoose.
</p>


This blog will show a tutorial about how to find data into MongoDB by using Node.js with Mongoose.

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


<p>
  This blog will show a tutorial about 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.&nbsp;
</p>
<h2>Get Start</h2>
<p>
  First, initialize a new npm package, we'll create a new package and new file,
  and add our code for how to insert data to MongoDB.
</p>
<pre class="language-markup"><code>npm init -y</code></pre>
<p>
  Next, let's install the mongoose package, this will be the only package we'll
  use for this tutorial.&nbsp;
</p>
<pre class="language-javascript"><code>npm install --save mongoose</code></pre>
<p>
  Create an <strong>index.js</strong>, we'll add our code to this file to
  connect to MongoDB and insert data to the Database.
</p>
<h2>Connect to the MongoDB</h2>
<p>
  Now, the following is a sample code to connect to MongoDB. Assume you already
  set up MongoDB at your local and has a database as
  <strong>your-database</strong>.
</p>
<pre class="language-javascript"><code>const {connect} = require('mongoose');

connect('mongodb://localhost:27017/your-database')
.then(() =&gt; {
    console.info('connect successfully')
})
.catch(() =&gt; {
    console.error('connection error');
});</code></pre>
<h2>Defined MongoDB Schema</h2>
<p>
  Here, we'll define our collection in MongoDB, the collection name will be
  <strong>my-collection-name</strong>.
</p>
<pre class="language-javascript"><code>let localModel = new Schema({
    key: {
        type: String
    },
    value: {
        type: String
    },
    culture: {
        type: String
    }
})

let localSchema = model('localization', localModel, 'my-collection-name');</code></pre>
<h2>Insert some data to MongoDB</h2>
<p>
  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.
</p>
<pre
  class="language-javascript"
><code>const createTestMillionAsync = async(roopLimit) =&gt; {
    let timerName = `insert-timer-${roopLimit}`;
    console.time(timerName)
    let testTargetList = [];
    for (let index = 0; index &lt; 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);</code></pre>
<h2>Try delete Records with Mongoose</h2>
<p>
  The following is example is for deleting the specific record, so you just need
  to call the deleted one and pass the _id value.
</p>
<pre class="language-javascript"><code>const removeDataAsync = async() =&gt; {
    
  let result = await localSchema.deleteOne({
        _id: '60a872a9d3ed022504e3aa01'
    });
    if (result) {
        console.info('update successfully', result);
    }
}

removeDataAsync();</code></pre>
<p>
  In case you want to delete everything from the collection, you can try the
  following code.&nbsp;
</p>
<pre class="language-javascript"><code>const removeDataAsync = async() =&gt; {
    
    let result = await localSchema.deleteMany({});
    if (result) {
        console.info('update successfully', result);
    }
}

removeDataAsync();</code></pre>
<p></p>
<h3>Conclusion</h3>
<p>
  Above is how you can use the delete function with Mongoose to MongoDB by using
  Node.js.
</p>


This blog will show a tutorial about how to delete data from MongoDB by using Node.js with Mongoose.

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


<p>
  This blog will show a tutorial about how to update 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.&nbsp;
</p>
<h2>Get Start</h2>
<p>
  First, initialize a new npm package, we'll create a new package and new file,
  and add our code for how to insert data to MongoDB.
</p>
<pre class="language-markup"><code>npm init -y</code></pre>
<p>
  Next, let's install the mongoose package, this will be the only package we'll
  use for this tutorial.&nbsp;
</p>
<pre class="language-javascript"><code>npm install --save mongoose</code></pre>
<p>
  Create an <strong>index.js</strong>, we'll add our code to this file to
  connect to MongoDB and insert data to the Database.
</p>
<h2>Connect to the MongoDB</h2>
<p>
  Now, the following is a sample code to connect to MongoDB. Assume you already
  set up MongoDB at your local and has a database as
  <strong>your-database</strong>.
</p>
<pre class="language-javascript"><code>const {connect} = require('mongoose');

connect('mongodb://localhost:27017/your-database')
.then(() =&gt; {
    console.info('connect successfully')
})
.catch(() =&gt; {
    console.error('connection error');
});</code></pre>
<h2>Defined MongoDB Schema</h2>
<p>
  Here, we'll define our collection in MongoDB, the collection name will be
  <strong>my-collection-name</strong>.
</p>
<pre class="language-javascript"><code>let localModel = new Schema({
    key: {
        type: String
    },
    value: {
        type: String
    },
    culture: {
        type: String
    }
})

let localSchema = model('localization', localModel, 'my-collection-name');</code></pre>
<h2>Update data from MongoDB</h2>
<p>
  Now, this is the final step we'll find data from the collection, then update
  the data. Following code will first find records by key 'test-key', then
  update the value field.&nbsp;
</p>
<pre class="language-javascript"><code>const updateDataAsync = async() =&gt; {
    
    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();</code></pre>
<h3>Conclusion</h3>
<p>
  Now, above is how you can update data from MongoDB by using Node.js with
  Mongoose.
</p>


How to Update MongoDB Data with Node.js and Mongoose


<p>
  This blog will show a tutorial about 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.&nbsp;
</p>
<h2>Get Start</h2>
<p>
  First, initialize a new npm package, we'll create a new package and new file,
  and add our code for how to insert data to MongoDB.
</p>
<pre class="language-markup"><code>npm init -y</code></pre>
<p>
  Next, let's install the mongoose package, this will be the only package we'll
  use for this tutorial.&nbsp;
</p>
<pre class="language-javascript"><code>npm install --save mongoose</code></pre>
<p>
  Create an <strong>index.js</strong>, we'll add our code to this file to
  connect to MongoDB and insert data to the Database.
</p>
<h2>Connect to the MongoDB</h2>
<p>
  Now, the following is a sample code to connect to MongoDB. Assume you already
  set up MongoDB at your local and has a database as
  <strong>your-database</strong>.
</p>
<pre class="language-javascript"><code>const {connect} = require('mongoose');

connect('mongodb://localhost:27017/your-database')
.then(() =&gt; {
    console.info('connect successfully')
})
.catch(() =&gt; {
    console.error('connection error');
});</code></pre>
<h2>Defined MongoDB Schema</h2>
<p>
  Here, we'll define our collection in MongoDB, the collection name will be
  <strong>my-collection-name</strong>.
</p>
<pre class="language-javascript"><code>let localModel = new Schema({
    key: {
        type: String
    },
    value: {
        type: String
    },
    culture: {
        type: String
    }
})

let localSchema = model('localization', localModel, 'my-collection-name');</code></pre>
<h2>Insert new data into MongoDB</h2>
<p>
  Now, this is the final step we'll insert new data into the collection, we'll
  use <strong>insertMany.</strong> after this code it should insert new data
  into the collection <strong>my-collection-name</strong>.
</p>
<pre class="language-javascript"><code>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');
})</code></pre>
<h3>Insert Data to MongoDB by using mongoose.create</h3>
<p>
  Another way to insert into data is following, but then which one is better?
  Should I use insert or create.&nbsp;
</p>
<pre class="language-javascript"><code>const createAsync = async() =&gt; {
    await localSchema.create({
        key: 'test-key-2',
        value: 'key2 description',
        culture: 'en-US'
    });    
}

createAsync();</code></pre>
<p>
  So, looks like it is better to use mongoose.insert because it's faster and
  less issue. So I did some research by insert 100,000 records into MongoDB.
</p>
<p>
  When I execute the following record on my macOS, the insert-timer's time was
  11922.764ms.&nbsp;
</p>
<pre
  class="language-javascript"
><code>const createTestMillionAsync = async() =&gt; {
    console.time('insert-timer')
    let testTargetList = [];
    for (let index = 0; index &lt; 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();</code></pre>
<p>
  However, when I tried following 100,000 records with creating I was getting
  timed out error, the default connection time out is 10000ms.
</p>
<pre
  class="language-javascript"
><code>const createTestMillionAsync = async(roopLimit) =&gt; {
    let timerName = `insert-timer-${roopLimit}`;
    console.time(timerName)
    let testTargetList = [];
    for (let index = 0; index &lt; 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);</code></pre>
<p>
  So I extend the connectionTimeout from 10000 to 50000, re-run as following
  combination, you can see that insertMany are 7 times faster than create.&nbsp;
</p>
<table border="1" style="border-collapse: collapse; width: 100%">
  <tbody>
    <tr>
      <td style="width: 48.0302%"><strong>Records</strong></td>
      <td style="width: 24.0151%"><strong>mongoose.create</strong></td>
      <td style="width: 24.0151%">
        <strong>mongoose.insertMany</strong>
      </td>
    </tr>
    <tr>
      <td style="width: 48.0302%">100000</td>
      <td style="width: 24.0151%">75261.921ms&nbsp;</td>
      <td style="width: 24.0151%">11869.793.ms</td>
    </tr>
    <tr>
      <td style="width: 48.0302%">500000</td>
      <td style="width: 24.0151%">Error: Javascript heap out of memory</td>
      <td style="width: 24.0151%">61775.343ms</td>
    </tr>
  </tbody>
</table>
<h3>Conclusion</h3>
<p>
  Above is how you can insert new data into MongoDB with Node.js with Mongoose.
  Looks like it's better to use InsertMany for better performance.
</p>


This blog will show a tutorial about how to insert data into MongoDB by using Node.js with Mongoose.

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


<p>Get all records where the Ids contains specfic object Id.</p>
<pre
  class="language-javascript"
><code>  var q= yourCollection.find({ Ids: mongoose.Types.ObjectId('539ba44481973asdfe0c402bc6') });
    q.exec(function (err, items)
    {
        console.info(err);
        console.info(items.length);
    });
</code></pre>


Get all records where the Ids contain specific object Id with Mongoose.

Code Snippet - How to Find Items by ObjectId with Mongoose


<h2>How to use MongoDB text search</h2>
<p>
  MongoDB provide text search function since 2.4, this blog will show how to use
  mongodb text search.
</p>
<p>
  All the example at following is run based on MongoDB version, 3.0.5. Also, I'm
  using Robomongo (0.8.5) to run all the MongoDB command.
</p>
<p>
  I also have code snippet about how to use Mongoose with text search, but I
  recommend at least use 2.6, seems like 2.4 with Mongoose has some problem.
</p>
<h3>Stop Words, Stemming in MongoDB text search</h3>
<p>
  Before jump into how to use MongoDB text search, we need to understand how
  MongoDB do stop words and stemming. <strong>Stop</strong> in MongoDB is, let's
  say you have "I like apple", stop wold will be <strong>apple</strong>.
  <strong>Stemming</strong> is like "cook cooking cooks", so MongoDB text engine
  will index cook.
</p>
<blockquote>I like apple, also I enjoy cooking.</blockquote>
<p>
  Above example, MongoDB will index <code>apple</code> and <code>cook</code>,
  There is very good blog about this topic,&nbsp;<a
    href="https://blog.codecentric.de/en/2013/01/text-search-mongodb-stemming/"
    target="_blank"
    >text-search-mongodb-stemming</a
  >.
</p>
<p>&nbsp;</p>
<h3>Now, let's get started how to use MongoDB text search</h3>
<h6>Get MongoDB's version</h6>
<p>This command will tell you what version of MongoDB you're using.</p>
<pre class="language-javascript">
db.version()
// 3.0.5
</pre>
<h6>Get Current MongoDB database name</h6>
<p>
  This will return your current db name. Before you run you query you need to
  check you're running to the correct mongodb or not right?
</p>
<pre class="language-javascript">
db.getName()
// the current database name.
</pre>
<h6>Check Index of current collection</h6>
<p>
  You can run following command, if you want to check your collection had add
  text index or other index or not.
</p>
<p>
  Following example is how I check my collection
  <code>Posts&nbsp;</code>contains any index or not.
</p>
<pre class="language-javascript">
// You run this
db.posts.getIndexes()
</pre>
<pre
  class="language-javascript"
><code>// Then will some result like this or if there's no index then just empty json. Now as you can see 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
    }
}
</code>
</pre>
<p>
  Now, we're going to add text index to this collection.First the collection
  <code>Posts</code> looks like following. I'd like to add create text index to
  <code>content.brief &amp; content.extended &amp; title</code>
</p>
<pre class="language-javascript"><code>
{
    "_id" : ObjectId("535cc04cd06eabf033ee36bc"),
    "__v" : 0,
    "author" : ObjectId("535c4fe25115d24c0c4cf84b"),
    "categories" : [],
    "content" : {
        "brief" : "&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Looks like&amp;nbsp;http://embed.ly/ is greate site, if I want to create something with URL. It'll get the short version of the url's detail. I have thought about imprement these kind of stuff, but since somebody already create this, why not just use it.&amp;nbsp;&lt;/p&gt;
&lt;pre class="language-javascript"&gt;&lt;code&gt;\r\n&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;nbsp;&lt;/p&gt;
&lt;pre class="language-javascript"&gt;&lt;code&gt;\r\n&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Nextime, i'll post some detail when I use it.&lt;/p&gt;
&lt;pre class="language-javascript"&gt;&lt;code&gt;",
        "extended" : ""
    },
    "publishedDate" : ISODate("2014-04-01T07:00:00.000Z"),
    "slug" : "embedly-get-url-link-detail",
    "state" : "published",
    "title" : "embed.ly - Get url link detail"
}
</code>
</pre>
<p>First, let's add text index to <code>title</code></p>
<pre class="language-javascript">
db.posts.ensureIndex({title: "text"});
</pre>
<p>
  After I create text index to the <code>title</code>field, and run
  <code>db.posts.getIndexes()</code> again to check my index, I got following
  new added index. Cool, I had added text index to my Posts.Title.
</p>
<pre class="language-javascript">
    "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
    }
</pre>
<p>
  Now, mongodb also has YouCollection.validate() which will validate your
  index.So when I run <code>db.posts.validate()</code> I got following result
  about my title field's text index. So cool right, the
  <code>"dake-tech.posts.$title_text" : 1464</code> is telling you the
  post.title indexed <code>1464</code>keys words.
</p>
<pre class="language-javascript"><code>
{
    "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
}
</code>
</pre>
<h6>Now, let's do text search</h6>
<p>
  When you type <code>db.posts.runCommand("text", {search: "mongodb"})</code>,
  you might get result as following.
</p>
<pre class="language-javascript"><code>
{
    "ok" : 0.0000000000000000,
    "errmsg" : "no such command: text",
    "code" : 59,
    "bad cmd" : {
        "text" : "posts",
        "search" : "mongodb"
    }
}
</code>
</pre>
<h3>What's going on, doesn't work!</h3>
<p>
  You might able to try following, go to admin enable the text search. However
  you will still get the same result. What happening is following command looks
  like works for the old MongoDB, maybe 2.4 to 2.6. However, if you use latest
  MongoDB (3.0 or above), text search is enable by default, and
  <code>runCommand("text", </code> is no longer exist.
</p>
<pre class="language-javascript">
use admin
db.runCommand({setParameter: 1, textSearchEnabled: true})

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

{
    "was" : true,
    "ok" : 1.0000000000000000
}
</pre>
<h3>So, what's I do?</h3>
<p>
  If you mongodb version is 3.0 or above like my current MongoDB, 3.0.5. You can
  try following.
</p>
<pre class="language-javascript"><code>
db.posts.find( { $text: { $search: "javascript" } } )
</code>
</pre>
<p>Also, following is the result I got. Awesome, right!? you got 12 results.</p>
<p>
  <img
    class="img-responsive"
    src="https://d1p0mp3f1fx0hz.cloudfront.net/_0eg17u58c.png"
    alt=""
  />
</p>
<p>
  Now, I'm going to add text index to my result of fields,
  <code>content.brief</code> and <code>content.extended</code>, So you type...
  <code>db.posts.ensureIndex({'content.brief': 'text'});</code>. Then you got
  this error, what's going on!!? I can only add once!?
</p>
<pre class="language-javascript"><code>
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 3,
    "errmsg" : "exception: Index with pattern: { _fts: \"text\", _ftsx: 1 } already exists with different options",
    "code" : 85,
    "ok" : 0
}
</code>
</pre>
<p>
  The result is, at current version 3.0.5, you can only add one text index, if
  you want to add multi fields for text search, you could do as following.
  First, you run <code>db.posts.dropIndex('title_text')</code>, so you can drop
  the old text index.
</p>
<p>This is the result you will get.</p>
<pre class="language-javascript"><code>
{
    "nIndexesWas" : 5,
    "ok" : 1.0000000000000000
}
</code>
</pre>
<h6>Add text index to multi fields</h6>
<p>Now, you can run following command.</p>
<p>
  <code
    >db.posts.ensureIndex({title: 'text', 'content.brief': 'text',
    'content.extended': 'text'});</code
  >
</p>
<p>Once shows result as following, the new index is added.</p>
<p><code>Inserted 1 record(s) in 27ms</code></p>
<p>
  If you run <code>db.posts.getIndexes()</code>, you can verify you text index
  is added.
</p>
<pre class="language-javascript"><code>
    "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
    }
</code>
</pre>
<p>
  Also, if you the index validation <code>db.posts.validate()</code>, you can
  see that new text index has index <code>31429</code>key words.<code>
    "dake-tech.posts.$title_text_content.brief_text_content.extended_text" :
    31429</code
  >Compare before just title only <code>1464</code> was indexed. Now, I'd like
  to run the same text search query again, it's the fun time!!
</p>
<pre class="language-javascript"><code>
{
    "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
}
</code>
</pre>
<p>
  You run
  <code
    >db.posts.find( { $text: { $search: "javascript" } }, { score: { $meta:
    "textScore" }} )</code
  >
</p>
<p>
  <img
    class="img-responsive"
    src="https://d1p0mp3f1fx0hz.cloudfront.net/_uwqsh0ebl.png"
    alt=""
  />
</p>
<p>
  Mmmm, this is not what I expected, the first result's title is not relative
  with Javascript.
</p>
<h3>How does Mongodb define score for text search?</h3>
<p>
  I don't have an answer for this yet, this is something I want to figure out.
  In the mean time, once your text search is enable, you can try something as
  following. You can also find document from MongoDB at
  <a
    href="https://docs.mongodb.org/manual/reference/operator/query/text/#text-operator-text-score"
    >Here</a
  >.
</p>
<ol>
  <li>
    search word
    <code> db.post.find( { $text: { $search: "javascript" } } ) </code>
  </li>
  <li>
    search phrase
    <code>
      db.post.find( { $text: { $search: "javascript angular react" } } )
    </code>
  </li>
  <li>
    Exclude Documents that contains term, following will search javascript and
    exclude angular from the document
    <code> db.post.find( { $text: { $search: "javascript -angular" } } ) </code>
  </li>
  <li>
    You can search for different language
    <code>
      db.post.find( { $text: { $search: "javascript", $language: "es" } } )
    </code>
  </li>
  <li>
    You can search Case Sensitive
    <code>
      db.post.find( { $text: { $search: "Javascript", $caseSensitive: true } } )
    </code>
  </li>
  <li>
    Case Sensitive for Phrase
    <code>
      db.post.find( { $text: { $search: "\"Javascript React\"", $caseSensitive:
      true } } )
    </code>
  </li>
  <li>
    Case Sensitive with exclude term, search Javascript but exclude lower-case
    javascript
    <code>
      db.post.find( { $text: { $search: "Javascript -javascript",
      $caseSensitive: true } } )
    </code>
  </li>
  <li>Diacritic Sensitive Search for a Term</li>
  <li>Diacritic Sensitivity with Negated Term</li>
  <li>
    Return the Text Search Score
    <code>
      db.posts.find( { $text: { $search: "javascript" } }, { score: { $meta:
      "textScore" }} )
    </code>
  </li>
  <li>Sort by Text Search Score</li>
  <li>Return Top 2 Matching Documents</li>
  <li>Text Search with Additional Query and Sort Expressions</li>
</ol>


How to Setup MongoDB Text Search with Node.js


<p>
  I have noticed that I've been using Mongodb 2.4, text-search is beta. Some
  code like following is not going to work. outputDeal is null.
</p>
<pre
  class="language-javascript"
><code>  mycollection.textSearch(req.body.searchBox, searchOpt, function (err, outputDeal) {
        var result = inspect(outputDeal, { depth: null });
        console.info(result);
    })<br /><br /><span style="color: #494747; font-family: 'PT Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 16px; line-height: 24px; white-space: normal;">MongoDB 2.6 has more feature, see following for reference.<br />MongoDB 2.6 is now available. Key features include aggregation enhancements, text-search integration, query-engine improvements, a new write-operation protocol, and security enhancements.<br /></span></code></pre>
<p>SO this blog provide how to upgrade from 2.4 to 2.6 by following steps.</p>
<ol>
  <li>dump your mongodb data</li>
  <li>download binary 2.6 file.</li>
  <li>stop all service, app using the mongodb</li>
  <li>
    go to mongo bin folder and replace all the dll by using the new 2.6 dll.
  </li>
  <li>restart all service, app using the mongodb.</li>
  <li>you should be able to verify 2.6 by type db.version()</li>
</ol>
<p>
  after I change in above steps, I could verify my first text search query is
  working now.
</p>


Mongodb 2.6 upgrade


<p>
  This blog shows example code of how to use MongoDB's text search by use
  Mongoose. You can also find What's
  <a href="../../blog/post/mongodb-text-search" target="_blank"
    >Mongoose Text Search</a
  >&nbsp;at here.
</p>
<h3>How to use MongoDB text search with Mongoose</h3>
<p>First, install following npm module.</p>
<p>
  <code
    ><a
      href="https://www.npmjs.org/package/mongoose-text-search"
      target="_blank"
      >mongoose-text-search</a
    ></code
  >
</p>
<pre
  class="language-javascript"
><code>textSearch = require('mongoose-text-search')
</code></pre>
<p>set up your schema</p>
<pre class="language-javascript"><code>// give schema text search capabilities
yourMongooseSchema.plugin(textSearch);
// add a text index
yourMongooseSchema.index(
{
    Title: 'text'
});
</code></pre>
<p>Following is example how to use text search.</p>
<pre class="language-javascript"><code>
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)
{
}<br /><br />More about Mongoose with MongoDB text search, check <a href="https://www.npmjs.com/package/mongoose-text-search" target="_blank">mongoose-text-search</a>.
</code></pre>
<h3>Mongodb need to be 2.4 or higher</h3>
<h3>Other References</h3>
<ol>
  <li>
    <a
      href="https://blog.codecentric.de/en/2013/01/text-search-mongodb-stemming/"
      target="_blank"
      >Blog -MongoDB Text Search Explained</a
    >
  </li>
  <li>
    <a
      href="https://docs.mongodb.org/v2.4/tutorial/enable-text-search/"
      target="_blank"
      >Enable Text Search</a
    >
  </li>
  <li>
    <a href="https://docs.mongodb.org/manual/release-notes/3.0/" target="_blank"
      >MongoDB release note 3.0</a
    >
  </li>
  <li>
    <a href="https://docs.mongodb.org/manual/release-notes/3.2/" target="_blank"
      >MongoDB release note 3.2</a
    >
  </li>
  <li>
    <a
      href="https://docs.mongodb.org/manual/reference/operator/query/text/#examples"
      target="_blank"
      >$text</a
    >
  </li>
  <li>
    <a
      href="http://willowtreeapps.com/blog/text-searching-with-mongodb/"
      target="_blank"
      >Text Searching with MongoDB</a
    >
  </li>
</ol>
<h3>Other Search Engine</h3>
<p>Want to use other popular search engine?</p>
<ul>
  <li><a href="http://lucene.apache.org/solr/" target="_blank">Solr</a></li>
  <ul>
    <li>
      <a href="https://github.com/mausch/SolrNet" target="_blank">Solr.NET </a>
    </li>
  </ul>
  <li><a href="https://www.elastic.co/" target="_blank">elastic</a></li>
  <ul>
    <li>
      <a
        href="https://www.elastic.co/guide/en/elasticsearch/client/net-api/current/_elasticsearch_net.html"
        target="_blank"
        >Elasticsearch.NET</a
      >
    </li>
  </ul>
</ul>


Category Mongoose