Node.js
Biblioteca Mongoose

Connetti a MongoDB usando Mongoose

Innanzitutto, installa Mongoose con:

npm install mongoose

Quindi, aggiungilo a server.js come dipendenze:

var mongoose = require('mongoose');
var Schema = mongoose.Schema;

Successivamente, crea lo schema del database e il nome della raccolta:

var schemaName = new Schema({
    request: String,
    time: Number
}, {
    collection: 'collectionName'
});

Crea un modello e connettiti al database:

var Model = mongoose.model('Model', schemaName);
mongoose.connect('mongodb://localhost:27017/dbName');

Quindi, avviare MongoDB ed eseguire server.js utilizzando node server.js

Per verificare se ci siamo connessi con successo al database, possiamo usare gli eventi open , error dall'oggetto mongoose.connection .

var db = mongoose.connection;
db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', function() {
  // we're connected!
});

Salva i dati su MongoDB usando Mongoose e Express.js Routes

Impostare

Innanzitutto, installa i pacchetti necessari con:

npm install express cors mongoose

Codice

Quindi, aggiungi dipendenze al file server.js , crea lo schema del database e il nome della raccolta, crea un server Express.js e connettiti a MongoDB:

var express = require('express');
var cors = require('cors'); // We will use CORS to enable cross origin domain requests.
var mongoose = require('mongoose');
var Schema = mongoose.Schema;

var app = express();

var schemaName = new Schema({
    request: String,
    time: Number
}, {
    collection: 'collectionName'
});

var Model = mongoose.model('Model', schemaName);
mongoose.connect('mongodb://localhost:27017/dbName');

var port = process.env.PORT || 8080;
app.listen(port, function() {
    console.log('Node.js listening on port ' + port);
});

Ora aggiungi i percorsi Express.js che useremo per scrivere i dati:

app.get('/save/:query', cors(), function(req, res) {
    var query = req.params.query;

    var savedata = new Model({
        'request': query,
        'time': Math.floor(Date.now() / 1000) // Time of save the data in unix timestamp format
    }).save(function(err, result) {
        if (err) throw err;

        if(result) {
            res.json(result)
        }
    })
})

Qui la variabile di query sarà il parametro <query> della richiesta HTTP in entrata, che verrà salvata in MongoDB:

var savedata = new Model({
    'request': query,
    //...

Se si verifica un errore durante il tentativo di scrittura su MongoDB, riceverai un messaggio di errore sulla console. Se tutto è andato a buon fine, vedrai i dati salvati in formato JSON sulla pagina.

//...
}).save(function(err, result) {
    if (err) throw err;

    if(result) {
        res.json(result)
    }
})
//...

Ora, è necessario avviare MongoDB ed eseguire il file server.js utilizzando node server.js .

uso

Per utilizzare questo per salvare i dati, vai al seguente URL nel browser:

http://localhost:8080/save/<query>

Dove <query> è la nuova richiesta che desideri salvare.

Esempio:

http://localhost:8080/save/JavaScript%20is%20Awesome

Uscita in formato JSON:

{
    __v: 0,
    request: "JavaScript is Awesome",
    time: 1469411348,
    _id: "57957014b93bc8640f2c78c4"
}

Trova i dati in MongoDB usando i percorsi Mongoose e Express.js

Impostare

Innanzitutto, installa i pacchetti necessari con:

npm install express cors mongoose

Codice

Quindi, aggiungi dipendenze a server.js , crea lo schema del database e il nome della raccolta, crea un server Express.js e connettiti a MongoDB:

var express = require('express');
var cors = require('cors'); // We will use CORS to enable cross origin domain requests.
var mongoose = require('mongoose');
var Schema = mongoose.Schema;

var app = express();

var schemaName = new Schema({
    request: String,
    time: Number
}, {
    collection: 'collectionName'
});

var Model = mongoose.model('Model', schemaName);
mongoose.connect('mongodb://localhost:27017/dbName');

var port = process.env.PORT || 8080;
app.listen(port, function() {
    console.log('Node.js listening on port ' + port);
});

Ora aggiungi le rotte Express.js che useremo per interrogare i dati:

app.get('/find/:query', cors(), function(req, res) {
    var query = req.params.query;

    Model.find({
        'request': query
    }, function(err, result) {
        if (err) throw err;
        if (result) {
            res.json(result)
        } else {
            res.send(JSON.stringify({
                error : 'Error'
            }))
        }
    })
})

Supponiamo che i seguenti documenti siano presenti nella collezione nel modello:

{
        "_id" : ObjectId("578abe97522ad414b8eeb55a"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710551
}
{
        "_id" : ObjectId("578abe9b522ad414b8eeb55b"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710555
}
{
        "_id" : ObjectId("578abea0522ad414b8eeb55c"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710560
}

E l'obiettivo è trovare e visualizzare tutti i documenti contenenti "JavaScript is Awesome" sotto la chiave "request" .

Per fare ciò, avviare MongoDB ed eseguire server.js con node server.js :

uso

Per utilizzare questo per trovare i dati, vai al seguente URL in un browser:

http://localhost:8080/find/<query>

Dove <query> è la query di ricerca.

Esempio:

http://localhost:8080/find/JavaScript%20is%20Awesome

Produzione:

[{
    _id: "578abe97522ad414b8eeb55a",
    request: "JavaScript is Awesome",
    time: 1468710551,
    __v: 0
},
{
    _id: "578abe9b522ad414b8eeb55b",
    request: "JavaScript is Awesome",
    time: 1468710555,
    __v: 0
},
{
    _id: "578abea0522ad414b8eeb55c",
    request: "JavaScript is Awesome",
    time: 1468710560,
    __v: 0
}]

Trova i dati in MongoDB usando Mongoose, Express.js Routes e $ text Operator

Impostare

Innanzitutto, installa i pacchetti necessari con:

npm install express cors mongoose

Codice

Quindi, aggiungi dipendenze a server.js , crea lo schema del database e il nome della raccolta, crea un server Express.js e connettiti a MongoDB:

var express = require('express');
var cors = require('cors'); // We will use CORS to enable cross origin domain requests.
var mongoose = require('mongoose');
var Schema = mongoose.Schema;

var app = express();

var schemaName = new Schema({
    request: String,
    time: Number
}, {
    collection: 'collectionName'
});

var Model = mongoose.model('Model', schemaName);
mongoose.connect('mongodb://localhost:27017/dbName');

var port = process.env.PORT || 8080;
app.listen(port, function() {
    console.log('Node.js listening on port ' + port);
});

Ora aggiungi le rotte Express.js che useremo per interrogare i dati:

app.get('/find/:query', cors(), function(req, res) {
    var query = req.params.query;

    Model.find({
        'request': query
    }, function(err, result) {
        if (err) throw err;
        if (result) {
            res.json(result)
        } else {
            res.send(JSON.stringify({
                error : 'Error'
            }))
        }
    })
})

Supponiamo che i seguenti documenti siano presenti nella collezione nel modello:

{
        "_id" : ObjectId("578abe97522ad414b8eeb55a"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710551
}
{
        "_id" : ObjectId("578abe9b522ad414b8eeb55b"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710555
}
{
        "_id" : ObjectId("578abea0522ad414b8eeb55c"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710560
}

E che l'obiettivo è trovare e visualizzare tutti i documenti contenenti solo la parola "JavaScript" sotto la chiave "request" .

Per fare ciò, prima crea un indice di testo per "request" nella raccolta. Per questo, aggiungi il seguente codice a server.js :

schemaName.index({ request: 'text' });

E sostituire:

    Model.find({
        'request': query
    }, function(err, result) {

Con:

Model.find({
    $text: {
        $search: query
    }
}, function(err, result) {

Qui, stiamo usando $text e $search operatori MongoDB per trovare tutti i documenti nella collection collectionName che contiene almeno una parola dalla query di ricerca specificata.

uso

Per utilizzare questo per trovare i dati, vai al seguente URL in un browser:

http://localhost:8080/find/<query>

Dove <query> è la query di ricerca.

Esempio:

http://localhost:8080/find/JavaScript

Produzione:

[{
    _id: "578abe97522ad414b8eeb55a",
    request: "JavaScript is Awesome",
    time: 1468710551,
    __v: 0
},
{
    _id: "578abe9b522ad414b8eeb55b",
    request: "JavaScript is Awesome",
    time: 1468710555,
    __v: 0
},
{
    _id: "578abea0522ad414b8eeb55c",
    request: "JavaScript is Awesome",
    time: 1468710560,
    __v: 0
}]

Indici nei modelli.

MongoDB supporta indici secondari. In Mongoose, definiamo questi indici all'interno del nostro schema. La definizione di indici a livello di schema è necessaria quando è necessario creare indici composti.

Connessione Mongoose

var strConnection = 'mongodb://localhost:27017/dbName';
var db = mongoose.createConnection(strConnection)

Creazione di uno schema di base

var Schema = require('mongoose').Schema;
var usersSchema = new Schema({
    username: {
        type: String,
        required: true,
        unique: true
    },
    email: {
        type: String,
        required: true
    },
    password: {
        type: String,
        required: true
    },
    created: {
        type: Date,
        default: Date.now
    }
});

var usersModel = db.model('users', usersSchema);
module.exports = usersModel;

Per impostazione predefinita, mangusta aggiunge due nuovi campi nel nostro modello, anche quando quelli non sono definiti nel modello. Questi campi sono:

_ID

Mongoose assegna a ciascuno degli schemi un campo _id per impostazione predefinita se uno non viene passato al costruttore Schema. Il tipo assegnato è un ObjectId che coincide con il comportamento predefinito di MongoDB. Se non vuoi che un _id venga aggiunto al tuo schema, puoi disabilitarlo usando questa opzione.

var usersSchema = new Schema({
    username: {
        type: String,
        required: true,
        unique: true
    }, {
        _id: false 
});

__v o versionKey

VersionKey è una proprietà impostata su ciascun documento quando viene creata da Mongoose. Questo valore di chiavi contiene la revisione interna del documento. Il nome di questa proprietà del documento è configurabile.

Puoi disabilitare facilmente questo campo nella configurazione del modello:

var usersSchema = new Schema({
    username: {
        type: String,
        required: true,
        unique: true
    }, {
    versionKey: false 
});

Indici composti

Possiamo creare altri indici oltre a quelli creati da Mangusta.

usersSchema.index({username: 1 });
usersSchema.index({email: 1 });

In questo caso il nostro modello ha altri due indici, uno per il campo username e l'altro per il campo email. Ma possiamo creare indici composti.

usersSchema.index({username: 1, email: 1 });

Impatto sulle prestazioni dell'indice

Per impostazione predefinita, la mangusta chiama sempre il parametro sureIndex per ciascun indice in sequenza ed emette un evento 'index' sul modello quando tutte le chiamate sureIndex hanno avuto esito positivo o quando si è verificato un errore.

In MongoDB, sureIndex è deprecato dalla versione 3.0.0, ora è un alias per createIndex.

Si consiglia di disabilitare il comportamento impostando l'opzione autoIndex dello schema su false o globalmente sulla connessione impostando l'opzione config.autoIndex su false.

usersSchema.set('autoIndex', false);

Funzioni utili di Mongoose

Mongoose contiene alcune funzioni incorporate che si basano sul find() standard find() .

doc.find({'some.value':5},function(err,docs){
    //returns array docs
});

doc.findOne({'some.value':5},function(err,doc){
    //returns document doc
});

doc.findById(obj._id,function(err,doc){
    //returns document doc
});

trova i dati in mongodb usando le promesse

Impostare

Innanzitutto, installa i pacchetti necessari con:

npm install express cors mongoose

Codice

Quindi, aggiungi dipendenze a server.js , crea lo schema del database e il nome della raccolta, crea un server Express.js e connettiti a MongoDB:

var express = require('express');
var cors = require('cors'); // We will use CORS to enable cross origin domain requests.
var mongoose = require('mongoose');
var Schema = mongoose.Schema;

var app = express();

var schemaName = new Schema({
    request: String,
    time: Number
}, {
    collection: 'collectionName'
});

var Model = mongoose.model('Model', schemaName);
mongoose.connect('mongodb://localhost:27017/dbName');

var port = process.env.PORT || 8080;
app.listen(port, function() {
    console.log('Node.js listening on port ' + port);
});

app.use(function(err, req, res, next) {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

app.use(function(req, res, next) {
  res.status(404).send('Sorry cant find that!');
});

Ora aggiungi le rotte Express.js che useremo per interrogare i dati:

app.get('/find/:query', cors(), function(req, res, next) {
    var query = req.params.query;

    Model.find({
        'request': query
    })
    .exec() //remember to add exec, queries have a .then attribute but aren't promises
    .then(function(result) {
        if (result) {
            res.json(result)
        } else {
            next() //pass to 404 handler
        }
    })
    .catch(next) //pass to error handler
})

Supponiamo che i seguenti documenti siano presenti nella collezione nel modello:

{
        "_id" : ObjectId("578abe97522ad414b8eeb55a"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710551
}
{
        "_id" : ObjectId("578abe9b522ad414b8eeb55b"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710555
}
{
        "_id" : ObjectId("578abea0522ad414b8eeb55c"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710560
}

E l'obiettivo è trovare e visualizzare tutti i documenti contenenti "JavaScript is Awesome" sotto la chiave "request" .

Per fare ciò, avviare MongoDB ed eseguire server.js con node server.js :

uso

Per utilizzare questo per trovare i dati, vai al seguente URL in un browser:

http://localhost:8080/find/<query>

Dove <query> è la query di ricerca.

Esempio:

http://localhost:8080/find/JavaScript%20is%20Awesome

Produzione:

[{
    _id: "578abe97522ad414b8eeb55a",
    request: "JavaScript is Awesome",
    time: 1468710551,
    __v: 0
},
{
    _id: "578abe9b522ad414b8eeb55b",
    request: "JavaScript is Awesome",
    time: 1468710555,
    __v: 0
},
{
    _id: "578abea0522ad414b8eeb55c",
    request: "JavaScript is Awesome",
    time: 1468710560,
    __v: 0
}]