Trouble getting a response from cursor.toArray() in Mongo/Node - node.js

node 0.10.24 + mongo node driver 1.3.23 on 32 bit linux
My callback here is never getting executed.
console.log(record_collection);
record_collection.find({}, function (error, cursor) {
console.log("record_collection.find() returned");
if (error) {
console.log(error);
callback(error);
}
else {
console.log("calling toArray with cursor");
cursor.toArray(function(error, docs){
console.log("cursor.toArray() returned");
if (error) {
console.log(error);
callback(error);
}
else {
callback(null, docs);
}
});
}
});
The output from this section goes like this:
{ db:
{ domain: null,
_events: {},
_maxListeners: 10,
databaseName: 'dbname',
serverConfig:
{ domain: null,
_events: {},
_maxListeners: 10,
_callBackStore: [Object],
_commandsStore: [Object],
auth: [Object],
_dbStore: [Object],
host: 'localhost',
port: 27017,
options: [Object],
internalMaster: false,
connected: false,
poolSize: 5,
disableDriverBSONSizeCheck: false,
_used: true,
replicasetInstance: null,
emitOpen: true,
ssl: false,
sslValidate: false,
sslCA: null,
sslCert: undefined,
sslKey: undefined,
sslPass: undefined,
serverCapabilities: null,
name: 'localhost:27017',
_readPreference: null,
socketOptions: [Object],
logger: [Object],
eventHandlers: [Object],
_serverState: 'connecting',
_state: [Object],
recordQueryStats: false,
socketTimeoutMS: [Getter/Setter],
db: [Circular],
dbInstances: [Object],
connectionPool: [Object] },
options: {},
_applicationClosed: false,
slaveOk: false,
bufferMaxEntries: -1,
native_parser: undefined,
bsonLib:
{ Code: [Function: Code],
Symbol: [Function: Symbol],
BSON: [Object],
DBRef: [Function: DBRef],
Binary: [Object],
ObjectID: [Object],
Long: [Object],
Timestamp: [Object],
Double: [Function: Double],
MinKey: [Function: MinKey],
MaxKey: [Function: MaxKey],
promoteLongs: true },
bson: { promoteLongs: true },
bson_deserializer:
{ Code: [Function: Code],
Symbol: [Function: Symbol],
BSON: [Object],
DBRef: [Function: DBRef],
Binary: [Object],
ObjectID: [Object],
Long: [Object],
Timestamp: [Object],
Double: [Function: Double],
MinKey: [Function: MinKey],
MaxKey: [Function: MaxKey],
promoteLongs: true },
bson_serializer:
{ Code: [Function: Code],
Symbol: [Function: Symbol],
BSON: [Object],
DBRef: [Function: DBRef],
Binary: [Object],
ObjectID: [Object],
Long: [Object],
Timestamp: [Object],
Double: [Function: Double],
MinKey: [Function: MinKey],
MaxKey: [Function: MaxKey],
promoteLongs: true },
_state: 'connecting',
pkFactory:
{ [Function: ObjectID]
index: 14382708,
createPk: [Function: createPk],
createFromTime: [Function: createFromTime],
createFromHexString: [Function: createFromHexString] },
forceServerObjectId: false,
safe: false,
notReplied: {},
isInitializing: true,
openCalled: true,
commands: [],
logger: { error: [Function], log: [Function], debug: [Function] },
tag: 1390462362041,
eventHandlers:
{ error: [],
parseError: [],
poolReady: [],
message: [],
close: [] },
serializeFunctions: false,
raw: false,
recordQueryStats: false,
retryMiliSeconds: 1000,
numberOfRetries: 60,
readPreference: undefined },
collectionName: 'gis_stops',
internalHint: null,
opts: {},
slaveOk: false,
serializeFunctions: false,
raw: false,
readPreference: 'primary',
pkFactory:
{ [Function: ObjectID]
index: 14382708,
createPk: [Function: createPk],
createFromTime: [Function: createFromTime],
createFromHexString: [Function: createFromHexString] },
serverCapabilities: undefined }
record_collection.find() returned
calling toArray with cursor
It looks like the first console.log() of the collection doesn't finish. But the other traces appear. Why isn't the callback being executed? Why don't I see "cursor.toArray() returned"?
This stopped working when I moved to a new server. The old server was running node 0.10.13 and mongodb 1.2.13.

From the record_collection trace:
db.serverConfig.connected = false;
The database was not connected.

Related

Mongoose Difficulty in displaying time stamps

I have been Recently Working on Mongoose To connect with the MongoDB with Node application.
I have Used Schemas to build the model and set the timestamps to true.
But When i try to run the node application it displays a very long message and the time stamps are empty in the terminal but displays when copied and pasted in text editor.
I want the output to be short to only display the documents available in my collection.
Here is My code
index.js file
const mongoose = require('mongoose');
const Dishes = require('./models/dishes')
const url = 'mongodb://localhost:27017/conFusion';
const connect = mongoose.connect(url);
connect.then((db) => {
console.log('Connected correctly to server');
Dishes.create({
name: 'Uthapizzas',
description: 'Test'
})
.then((dish) => {
console.log(dish);
return Dishes.findByIdAndUpdate(dish._id,{
$set: { description: 'Updated Test'}
},{
new: true//return the updated dish
}).exec();
})
.then((dish) => {
console.log(dish);
dish.comments.push({
rating: 5,
comment: 'I\'m getting a sinking feeling!',
author: 'Leonardo di Carpaccio'
});
return dish.save();
})
.then((dish) => {
console.log(dish);
return Dishes.remove({});
})
.then(() => {
return mongoose.connection.close();
})
.catch((err) => {
console.log(err);
});
dishes.js file
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const commentSchema = new Schema({
rating: {
type: Number,
min: 1,
max: 5,
required: true
},
comment: {
type: String,
required: true
},
author:{
type: String,
required: true
}
}, {
timestamps: true
});
const dishSchema = new Schema({
name: {
type: String,
required: true,
unique: true
},
description: {
type: String,
required: true
},
comments:[commentSchema]
},
{
timestamps: true
}
);
var Dishes = mongoose.model('Dish', dishSchema);
module.exports = Dishes;
Here is My output
<ref *1> model {
'$__': InternalCache {
strictMode: true,
selected: undefined,
shardval: undefined,
saveError: undefined,
validationError: undefined,
adhocPaths: undefined,
removing: undefined,
inserting: true,
saving: undefined,
version: undefined,
getters: {},
_id: 63563fab8405ad299448f321,
populate: undefined,
populated: undefined,
wasPopulated: false,
scope: undefined,
activePaths: StateMachine {
paths: [Object],
states: [Object],
stateNames: [Array],
map: [Function (anonymous)]
},
pathsToScopes: {},
session: null,
ownerDocument: undefined,
fullPath: undefined,
emitter: EventEmitter {
_events: [Object: null prototype],
_eventsCount: 2,
_maxListeners: 0,
[Symbol(kCapture)]: false
},
'$options': {}
},
isNew: false,
errors: undefined,
_doc: {
_id: 63563fab8405ad299448f321,
name: 'Uthapizzas',
description: 'Test',
comments: CoreMongooseArray(0) [
_path: 'comments',
toBSON: [Function: toBSON],
_atomics: {},
_parent: [Circular *1],
_cast: [Function: _cast],
_markModified: [Function: _markModified],
_registerAtomic: [Function: _registerAtomic],
'$__getAtomics': [Function: $__getAtomics],
hasAtomics: [Function: hasAtomics],
_mapCast: [Function: _mapCast],
push: [Function: push],
nonAtomicPush: [Function: nonAtomicPush],
'$pop': [Function: $pop],
pop: [Function: pop],
'$shift': [Function: $shift],
shift: [Function: shift],
pull: [Function: pull],
splice: [Function: splice],
unshift: [Function: unshift],
sort: [Function: sort],
addToSet: [Function: addToSet],
set: [Function: set],
toObject: [Function: toObject],
inspect: [Function: inspect],
indexOf: [Function: indexOf],
remove: [Function: pull],
id: [Function: id],
create: [Function: create],
notify: [Function: notify],
isMongooseDocumentArray: true,
validators: [],
_schema: [DocumentArray],
_handlers: [Object]
],
createdAt: 2022-10-24T07:32:59.266Z,
updatedAt: 2022-10-24T07:32:59.266Z,
__v: 0
}
}
<ref *1> model {
'$__': InternalCache {
strictMode: true,
selected: {},
shardval: undefined,
saveError: undefined,
validationError: undefined,
adhocPaths: undefined,
removing: undefined,
inserting: undefined,
saving: undefined,
version: undefined,
getters: {},
_id: 63563fab8405ad299448f321,
populate: undefined,
populated: undefined,
wasPopulated: false,
scope: undefined,
activePaths: StateMachine {
paths: [Object],
states: [Object],
stateNames: [Array]
},
pathsToScopes: {},
session: undefined,
ownerDocument: undefined,
fullPath: undefined,
emitter: EventEmitter {
_events: [Object: null prototype],
_eventsCount: 2,
_maxListeners: 0,
[Symbol(kCapture)]: false
},
'$options': { skipId: true, isNew: false, skipDefaults: [Object] }
},
isNew: false,
errors: undefined,
_doc: {
_id: 63563fab8405ad299448f321,
name: 'Uthapizzas',
description: 'Updated Test',
comments: CoreMongooseArray(0) [
_path: 'comments',
toBSON: [Function: toBSON],
_atomics: {},
_parent: [Circular *1],
_cast: [Function: _cast],
_markModified: [Function: _markModified],
_registerAtomic: [Function: _registerAtomic],
'$__getAtomics': [Function: $__getAtomics],
hasAtomics: [Function: hasAtomics],
_mapCast: [Function: _mapCast],
push: [Function: push],
nonAtomicPush: [Function: nonAtomicPush],
'$pop': [Function: $pop],
pop: [Function: pop],
'$shift': [Function: $shift],
shift: [Function: shift],
pull: [Function: pull],
splice: [Function: splice],
unshift: [Function: unshift],
sort: [Function: sort],
addToSet: [Function: addToSet],
set: [Function: set],
toObject: [Function: toObject],
inspect: [Function: inspect],
indexOf: [Function: indexOf],
remove: [Function: pull],
id: [Function: id],
create: [Function: create],
notify: [Function: notify],
isMongooseDocumentArray: true,
validators: [],
_schema: [DocumentArray],
_handlers: [Object]
],
createdAt: 2022-10-24T07:32:59.266Z,
updatedAt: 2022-10-24T07:32:59.287Z,
__v: 0
},
'$init': true
}
<ref *1> model {
'$__': InternalCache {
strictMode: true,
selected: {},
shardval: undefined,
saveError: undefined,
validationError: undefined,
adhocPaths: undefined,
removing: undefined,
inserting: false,
saving: undefined,
version: undefined,
getters: {},
_id: 63563fab8405ad299448f321,
populate: undefined,
populated: undefined,
wasPopulated: false,
scope: undefined,
activePaths: StateMachine {
paths: [Object],
states: [Object],
stateNames: [Array],
map: [Function (anonymous)]
},
pathsToScopes: { comments: [Circular *1] },
session: undefined,
ownerDocument: undefined,
fullPath: undefined,
emitter: EventEmitter {
_events: [Object: null prototype],
_eventsCount: 2,
_maxListeners: 0,
[Symbol(kCapture)]: false
},
'$options': { skipId: true, isNew: false, skipDefaults: [Object] }
},
isNew: false,
errors: undefined,
_doc: {
_id: 63563fab8405ad299448f321,
name: 'Uthapizzas',
description: 'Updated Test',
comments: CoreMongooseArray(1) [
[EmbeddedDocument],
_path: 'comments',
toBSON: [Function: toBSON],
_atomics: {},
_parent: [Circular *1],
_cast: [Function: _cast],
_markModified: [Function: _markModified],
_registerAtomic: [Function: _registerAtomic],
'$__getAtomics': [Function: $__getAtomics],
hasAtomics: [Function: hasAtomics],
_mapCast: [Function: _mapCast],
push: [Function: push],
nonAtomicPush: [Function: nonAtomicPush],
'$pop': [Function: $pop],
pop: [Function: pop],
'$shift': [Function: $shift],
shift: [Function: shift],
pull: [Function: pull],
splice: [Function: splice],
unshift: [Function: unshift],
sort: [Function: sort],
addToSet: [Function: addToSet],
set: [Function: set],
toObject: [Function: toObject],
inspect: [Function: inspect],
indexOf: [Function: indexOf],
remove: [Function: pull],
id: [Function: id],
create: [Function: create],
notify: [Function: notify],
isMongooseDocumentArray: true,
validators: [],
_schema: [DocumentArray],
_handlers: [Object]
],
createdAt: 2022-10-24T07:32:59.266Z,
updatedAt: 2022-10-24T07:32:59.308Z,
__v: 1
},
'$init': true
}
Can You Please Help me in resolving this issue.
Why i am getting this much lines of output and why my time stamps are not displaying in the output(They are Displaying when copied) and the output looks very clumsy.
I only need the output which document i have inserted into the database and need the time stamps.
I am not able to access the time stamps also.
I am using mongo v5
Thank you in advance!!
You should log your plaing javascript object, not the document. In order to do this, you should call console.log(dish.toJSON()).

How to get values from a mongodb cursor from a collection with elements

I'm trying to build a live chart out of a simple mongo colection, using Raspberry Pi 2 with dietPi (DietPi v6.22.3), mongodb and nodejs.
What I'm trying to do is to get data from the db using something like:
var express = require('express');
var app = express();
var MongoClient = require('mongodb').MongoClient;
var url = 'mongodb://localhost:27017/DB_A';
var str = "";
app.route('/PAGE_A').get(function (req, res) {
MongoClient.connect(url, function (err, db) {
if (err) {
console.log(err);
} else {
console.log("Connected to db");
var cursor = db.collection('COL_A').find();
console.log(cursor);
//noinspection JSDeprecatedSymbols
cursor.each(function (err, item) {
if (item != null) {
str = str + " DateTime " + item.dt + " - Users: " + item.users + " </br>";
}
});
res.send(str);
db.close();
}
});
});
var server = app.listen(8080, function () {});
Running node app.js and accessing the designated IP:8080/page_A I get the "Connected to db" message but no expected data from the cursor is being printed, except for its parameters I used for this question.
The collection is not empty. I can use DB_A and get elements from db.COL_A.find()...
This is what I get printed in the console when I "npm start" and access IP/PAGE_A:
Connected to db
Cursor {
db:
Db {
_events: [Object: null prototype] {},
_eventsCount: 0,
_maxListeners: undefined,
databaseName: 'DB_A',
serverConfig:
Server {
_events: [Object: null prototype] {},
_eventsCount: 0,
_maxListeners: undefined,
_callBackStore: [CallbackStore],
host: 'localhost',
port: 27017,
options: [Object],
internalMaster: true,
connected: true,
poolSize: 5,
disableDriverBSONSizeCheck: false,
slaveOk: undefined,
_used: true,
replicasetInstance: null,
ssl: false,
sslValidate: false,
sslCA: null,
sslCert: undefined,
sslKey: undefined,
sslPass: undefined,
_readPreference: null,
socketOptions: [Object],
logger: [Object],
eventHandlers: [Object],
_serverState: 'connected',
_state: [Object],
recordQueryStats: false,
db: [Circular],
dbInstances: [Array],
connectionPool: [EventEmitter],
isMasterDoc: [Object] },
options:
{ read_preference_tags: null,
read_preference: 'primary',
native_parser: false,
readPreference: [ReadPreference],
safe: false,
w: 1 },
_applicationClosed: false,
native_parser: false,
bsonLib:
{ Code: [Function: Code],
Symbol: [Function: Symbol],
BSON: [Function],
DBRef: [Function: DBRef],
Binary: [Function],
ObjectID: [Function],
Long: [Function],
Timestamp: [Function],
Double: [Function: Double],
MinKey: [Function: MinKey],
MaxKey: [Function: MaxKey] },
bson: BSON {},
bson_deserializer:
{ Code: [Function: Code],
Symbol: [Function: Symbol],
BSON: [Function],
DBRef: [Function: DBRef],
Binary: [Function],
ObjectID: [Function],
Long: [Function],
Timestamp: [Function],
Double: [Function: Double],
MinKey: [Function: MinKey],
MaxKey: [Function: MaxKey] },
bson_serializer:
{ Code: [Function: Code],
Symbol: [Function: Symbol],
BSON: [Function],
DBRef: [Function: DBRef],
Binary: [Function],
ObjectID: [Function],
Long: [Function],
Timestamp: [Function],
Double: [Function: Double],
MinKey: [Function: MinKey],
MaxKey: [Function: MaxKey] },
_state: 'connected',
pkFactory:
{ [Function: ObjectID]
index: 0,
createPk: [Function: createPk],
createFromTime: [Function: createFromTime],
createFromHexString: [Function: createFromHexString] },
forceServerObjectId: false,
safe: false,
notReplied: {},
isInitializing: true,
auths: [],
openCalled: true,
commands: [],
logger:
{ error: [Function: error],
log: [Function: log],
debug: [Function: debug] },
slaveOk: false,
tag: 1554299599878,
eventHandlers:
{ error: [],
parseError: [],
poolReady: [],
message: [],
close: [] },
serializeFunctions: false,
raw: false,
recordQueryStats: false,
retryMiliSeconds: 1000,
numberOfRetries: 60,
readPreference:
ReadPreference { _type: 'ReadPreference', mode: 'primary', tags: undefined } },
collection:
Collection {
db:
Db {
_events: [Object: null prototype] {},
_eventsCount: 0,
_maxListeners: undefined,
databaseName: 'DB_A',
serverConfig: [Server],
options: [Object],
_applicationClosed: false,
native_parser: false,
bsonLib: [Object],
bson: BSON {},
bson_deserializer: [Object],
bson_serializer: [Object],
_state: 'connected',
pkFactory: [Function],
forceServerObjectId: false,
safe: false,
notReplied: {},
isInitializing: true,
auths: [],
openCalled: true,
commands: [],
logger: [Object],
slaveOk: false,
tag: 1554299599878,
eventHandlers: [Object],
serializeFunctions: false,
raw: false,
recordQueryStats: false,
retryMiliSeconds: 1000,
numberOfRetries: 60,
readPreference: [ReadPreference] },
collectionName: 'COL_A',
internalHint: null,
opts: {},
slaveOk: false,
serializeFunctions: false,
raw: false,
readPreference: 'primary',
pkFactory:
{ [Function: ObjectID]
index: 0,
createPk: [Function: createPk],
createFromTime: [Function: createFromTime],
createFromHexString: [Function: createFromHexString] } },
selector: {},
fields: undefined,
skipValue: 0,
limitValue: 0,
sortValue: undefined,
hint: null,
explainValue: undefined,
snapshot: undefined,
timeout: true,
tailable: undefined,
awaitdata: undefined,
numberOfRetries: 5,
currentNumberOfRetries: 5,
batchSizeValue: 0,
slaveOk: false,
raw: false,
read: 'primary',
returnKey: undefined,
maxScan: undefined,
min: undefined,
max: undefined,
showDiskLoc: undefined,
comment: undefined,
tailableRetryInterval: 100,
exhaust: false,
partial: false,
totalNumberOfRecords: 0,
items: [],
cursorId: Long { _bsontype: 'Long', low_: 0, high_: 0 },
dbName: undefined,
state: 0,
queryRun: false,
getMoreTimer: false,
collectionName: 'DB_A.COL_A' }
Here are some details on my setup:
mongod --version
db version v2.4.14
node --version
v10.15.3
NodeJS mongo driver -> 1.2.13
cat /etc/os-release
PRETTY_NAME="Raspbian GNU/Linux 9 (stretch)"
NAME="Raspbian GNU/Linux"
VERSION_ID="9"
VERSION="9 (stretch)"
ID=raspbian
ID_LIKE=debian
HOME_URL="http://www.raspbian.org/"
SUPPORT_URL="http://www.raspbian.org/RaspbianForums"
BUG_REPORT_URL="http://www.raspbian.org/RaspbianBugs"
cat /etc/debian_version
9.8
uname -a
Linux DietPi 4.14.98+ #1200 Tue Feb 12 20:11:02 GMT 2019 armv6l GNU/Linux
cat /proc/cpuinfo
processor : 0
model name : ARMv6-compatible processor rev 7 (v6l)
BogoMIPS : 697.95
Features : half thumb fastmult vfp edsp java tls
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x0
CPU part : 0xb76
CPU revision : 7
Hardware : BCM2835
Revision : 000e
Serial : 00000000ce0ee037
Thank you.
if you want desire result you can get it using async await
MongoClient.connect(url, async (err, db) => {
if (err) {
console.log(err);
} else {
console.log("Connected to db");
var cursor = await db.collection("comments").find().toArray();
console.log({ cursor });
db.close();
}
});
But if you want to use cursor type with each method of cursor not sure why not working
also change mongodb version "^3.2.2" to "^2.2.33" no luck

the nodejs and mongo db find

I use this code to connect to my mongo db localhost and find the "names" but i have a problem in consol.log:
url = require("url"),
emitter = require("events").EventEmitter,
assert = require("assert"),
mongo = require("mongodb"),
Cursor = mongo.Cursor;
var uristring = "mongodb://localhost:27017/test";
var mongoUrl = url.parse (uristring);
mongo.MongoClient.connect (uristring, function (err, db) {
var test = db.collection ("test")
console.log ("Success connecting to " + mongoUrl.protocol + "//" + mongoUrl.hostname + ".");
console.log (test.find({},{name:1,_id:0}));
db.close();
});
when i use db.test.find({},{name:1,_id:0}) in my terminal in mongo its returning { "name" : "pooya" }
but in nodjs code it return:
Success connecting to mongodb://localhost.
{ db:
{ domain: null,
_events: {},
_maxListeners: 10,
databaseName: 'test',
serverConfig:
{ domain: null,
_events: {},
_maxListeners: 10,
_callBackStore: [Object],
_commandsStore: [Object],
auth: [Object],
_dbStore: [Object],
host: 'localhost',
port: 27017,
options: [Object],
internalMaster: true,
connected: true,
poolSize: 5,
disableDriverBSONSizeCheck: false,
_used: true,
replicasetInstance: null,
emitOpen: false,
ssl: false,
sslValidate: false,
sslCA: null,
sslCert: undefined,
sslKey: undefined,
sslPass: undefined,
serverCapabilities: [Object],
name: 'localhost:27017',
socketOptions: [Object],
logger: [Object],
eventHandlers: [Object],
_serverState: 'connected',
_state: [Object],
recordQueryStats: false,
socketTimeoutMS: [Getter/Setter],
_readPreference: [Object],
db: [Circular],
dbInstances: [Object],
connectionPool: [Object],
isMasterDoc: [Object] },
options:
{ read_preference_tags: null,
read_preference: 'primary',
url: 'mongodb://localhost:27017/test',
native_parser: true,
readPreference: [Object],
safe: false,
w: 1 },
_applicationClosed: false,
slaveOk: false,
bufferMaxEntries: -1,
native_parser: true,
bsonLib:
{ BSON: [Object],
Long: [Object],
ObjectID: [Object],
DBRef: [Function: DBRef],
Code: [Function: Code],
Timestamp: [Object],
Binary: [Object],
Double: [Function: Double],
MaxKey: [Function: MaxKey],
MinKey: [Function: MinKey],
Symbol: [Function: Symbol] },
bson: { promoteLongs: true },
bson_deserializer:
{ Code: [Function: Code],
Symbol: [Function: Symbol],
BSON: [Object],
DBRef: [Function: DBRef],
Binary: [Object],
ObjectID: [Object],
Long: [Object],
Timestamp: [Object],
Double: [Function: Double],
MinKey: [Function: MinKey],
MaxKey: [Function: MaxKey],
promoteLongs: true },
bson_serializer:
{ Code: [Function: Code],
Symbol: [Function: Symbol],
BSON: [Object],
DBRef: [Function: DBRef],
Binary: [Object],
ObjectID: [Object],
Long: [Object],
Timestamp: [Object],
Double: [Function: Double],
MinKey: [Function: MinKey],
MaxKey: [Function: MaxKey],
promoteLongs: true },
_state: 'connected',
pkFactory:
{ [Function: ObjectID]
index: 2954887,
createPk: [Function: createPk],
createFromTime: [Function: createFromTime],
createFromHexString: [Function: createFromHexString],
isValid: [Function: isValid] },
forceServerObjectId: false,
safe: false,
notReplied: {},
isInitializing: true,
openCalled: true,
commands: [],
logger: { error: [Function], log: [Function], debug: [Function] },
tag: 1416152062206,
eventHandlers:
{ error: [],
parseError: [],
poolReady: [],
message: [],
close: [] },
serializeFunctions: false,
raw: false,
recordQueryStats: false,
retryMiliSeconds: 1000,
numberOfRetries: 60,
readPreference: { _type: 'ReadPreference', mode: 'primary', tags: undefined } },
collection:
{ db:
{ domain: null,
_events: {},
_maxListeners: 10,
databaseName: 'test',
serverConfig: [Object],
options: [Object],
_applicationClosed: false,
slaveOk: false,
bufferMaxEntries: -1,
native_parser: true,
bsonLib: [Object],
bson: [Object],
bson_deserializer: [Object],
bson_serializer: [Object],
_state: 'connected',
pkFactory: [Object],
forceServerObjectId: false,
safe: false,
notReplied: {},
isInitializing: true,
openCalled: true,
commands: [],
logger: [Object],
tag: 1416152062206,
eventHandlers: [Object],
serializeFunctions: false,
raw: false,
recordQueryStats: false,
retryMiliSeconds: 1000,
numberOfRetries: 60,
readPreference: [Object] },
collectionName: 'test',
internalHint: null,
opts: {},
slaveOk: false,
serializeFunctions: false,
raw: false,
readPreference: { _type: 'ReadPreference', mode: 'primary', tags: undefined },
pkFactory:
{ [Function: ObjectID]
index: 2954887,
createPk: [Function: createPk],
createFromTime: [Function: createFromTime],
createFromHexString: [Function: createFromHexString],
isValid: [Function: isValid] },
serverCapabilities: undefined },
selector: {},
fields: { name: 1, _id: 0 },
skipValue: 0,
limitValue: 0,
sortValue: undefined,
hint: null,
explainValue: undefined,
snapshot: undefined,
timeout: true,
tailable: undefined,
awaitdata: undefined,
oplogReplay: undefined,
numberOfRetries: 5,
currentNumberOfRetries: 5,
batchSizeValue: 0,
raw: false,
readPreference: { _type: 'ReadPreference', mode: 'primary', tags: undefined },
returnKey: undefined,
maxScan: undefined,
min: undefined,
max: undefined,
showDiskLoc: undefined,
comment: undefined,
tailableRetryInterval: 100,
exhaust: false,
partial: false,
slaveOk: false,
maxTimeMSValue: undefined,
connection: undefined,
totalNumberOfRecords: 0,
items: [],
cursorId: { _bsontype: 'Long', low_: 0, high_: 0 },
dbName: undefined,
state: 0,
queryRun: false,
getMoreTimer: false,
collectionName: 'test.test' }
why its happening?how to solve it?
Welcome to StackOverflow.
You are using the API wrongly. The MongoDB driver returns the query results asynchronously, via callback, not synchronously like in most languages you probably met so far, if you are new to node.js.
So, basically you are doing this
var results = test.find({},{name:1,_id:0})
console.log (results);
But what you really want to do is:
test.find({name:1,_id:0}, new function(error, results)
{
if(error! = null) console.log(error);
else //do whatever you want with the results
});
Keep in mind that the code after test.find() will keep running independently of the query and its results. The results processing will be called when the query is finished.
Btw. I also think parameters passed to your find() method are somehow wrong. The query should be the first parameter, and in your example it's second, if I'm not mistaken. The method looks like this: find(query[, options], callback).
You can find the documentation of the MongoDB driver here, including the find method.
You should more or less do the same with the find() method as you did with the connect() method in which callback you are writing the query.
If you are not comfortable with the notion of asynchronous, event driven or non-blocking programming please consider reading these links:
http://book.mixu.net/node/ch7.html
http://justinklemm.com/node-js-async-tutorial/
EDIT:
Sorry, I must edit myself. The callback has two parameters, the FIRST one is the error, the SECOND are the results. Haven't used this for a while.

MongoDB (Node.js) find not returning expected result

I am trying to make a find from node to a mongodb server. Here is the code:
var mongo = require('mongodb'),
Server = mongo.Server,
Db = mongo.Db;
var mongoServer = new Server(10.141.74.74, 28019,{auto_reconnect: true, safe:true});
var db = new Db("statusReport", mongoServer, {safe:true});
db.open(function(err,db){
if(!err){
db.collection("status",function(err,collection){
if(!err){
collection.find({}, function(a,b){
console.log(a);
console.log(b);
});
}else{
console.log("ERROR: could not open collection");
}
});
db.close();
}else{
console.log("ERROR: could not open database");
}
});
However, instead of returning data it is returning this:
{ db:
{ domain: null,
_events: { open: [] },
_maxListeners: 10,
databaseName: 'statusReport',
serverConfig:
{ domain: null,
_events: null,
_maxListeners: 10,
host: '10.141.74.74',
port: 28019,
options: [Object],
internalMaster: true,
connected: true,
poolSize: 5,
disableDriverBSONSizeCheck: false,
ssl: false,
slaveOk: undefined,
_used: true,
_readPreference: null,
socketOptions: [Object],
logger: [Object],
eventHandlers: [Object],
_serverState: 'connected',
_state: [Object],
recordQueryStats: false,
dbInstance: [Circular],
dbInstances: [Object],
connectionPool: [Object],
isMasterDoc: [Object] },
options: { safe: true },
_applicationClosed: false,
native_parser: undefined,
bsonLib:
{ Code: [Function: Code],
Symbol: [Function: Symbol],
BSON: [Object],
DBRef: [Function: DBRef],
Binary: [Object],
ObjectID: [Object],
Long: [Object],
Timestamp: [Object],
Double: [Function: Double],
MinKey: [Function: MinKey],
MaxKey: [Function: MaxKey] },
bson: {},
bson_deserializer:
{ Code: [Function: Code],
Symbol: [Function: Symbol],
BSON: [Object],
DBRef: [Function: DBRef],
Binary: [Object],
ObjectID: [Object],
Long: [Object],
Timestamp: [Object],
Double: [Function: Double],
MinKey: [Function: MinKey],
MaxKey: [Function: MaxKey] },
bson_serializer:
{ Code: [Function: Code],
Symbol: [Function: Symbol],
BSON: [Object],
DBRef: [Function: DBRef],
Binary: [Object],
ObjectID: [Object],
Long: [Object],
Timestamp: [Object],
Double: [Function: Double],
MinKey: [Function: MinKey],
MaxKey: [Function: MaxKey] },
_state: 'connected',
pkFactory:
{ [Function: ObjectID]
index: 0,
createPk: [Function: createPk],
createFromTime: [Function: createFromTime],
createFromHexString: [Function: createFromHexString] },
forceServerObjectId: false,
safe: true,
notReplied: {},
isInitializing: true,
auths: [],
openCalled: true,
commands: [],
_callBackStore: { domain: null, _events: {}, _maxListeners: 10, _notReplied: {} },
logger: { error: [Function], log: [Function], debug: [Function] },
slaveOk: false,
tag: 1363118044637,
eventHandlers:
{ error: [],
parseError: [],
poolReady: [],
message: [],
close: [] },
serializeFunctions: false,
raw: false,
recordQueryStats: false,
reaperEnabled: false,
_lastReaperTimestamp: 1363118044637,
retryMiliSeconds: 1000,
numberOfRetries: 60,
reaperInterval: 10000,
reaperTimeout: 30000,
readPreference: undefined },
collection:
{ db:
{ domain: null,
_events: [Object],
_maxListeners: 10,
databaseName: 'statusReport',
serverConfig: [Object],
options: [Object],
_applicationClosed: false,
native_parser: undefined,
bsonLib: [Object],
bson: {},
bson_deserializer: [Object],
bson_serializer: [Object],
_state: 'connected',
pkFactory: [Object],
forceServerObjectId: false,
safe: true,
notReplied: {},
isInitializing: true,
auths: [],
openCalled: true,
commands: [],
_callBackStore: [Object],
logger: [Object],
slaveOk: false,
tag: 1363118044637,
eventHandlers: [Object],
serializeFunctions: false,
raw: false,
recordQueryStats: false,
reaperEnabled: false,
_lastReaperTimestamp: 1363118044637,
retryMiliSeconds: 1000,
numberOfRetries: 60,
reaperInterval: 10000,
reaperTimeout: 30000,
readPreference: undefined },
collectionName: 'status',
internalHint: null,
opts: {},
slaveOk: false,
serializeFunctions: false,
raw: false,
readPreference: 'primary',
pkFactory:
{ [Function: ObjectID]
index: 0,
createPk: [Function: createPk],
createFromTime: [Function: createFromTime],
createFromHexString: [Function: createFromHexString] } },
selector: {},
fields: undefined,
skipValue: 0,
limitValue: 0,
sortValue: undefined,
hint: null,
explainValue: undefined,
snapshot: undefined,
timeout: true,
tailable: undefined,
awaitdata: undefined,
numberOfRetries: 5,
currentNumberOfRetries: 5,
batchSizeValue: 0,
slaveOk: false,
raw: false,
read: 'primary',
returnKey: undefined,
maxScan: undefined,
min: undefined,
max: undefined,
showDiskLoc: undefined,
comment: undefined,
tailableRetryInterval: 100,
exhaust: false,
partial: false,
totalNumberOfRecords: 0,
items: [],
cursorId: { _bsontype: 'Long', low_: 0, high_: 0 },
dbName: undefined,
state: 0,
queryRun: false,
getMoreTimer: false,
collectionName: 'statusReport.status' }
I know there is stuff in there because I can see it using MongoHub. I can also query it there too. What is wrong here?
I also tried doing collection.insert(some data here) and the insert works. Just the find does not.
collection.find(callback) returns the cursor, not the documents. you want to do:
collection.find().toArray(callback)

Can't return a string properly with mongoskin

So I have this script:
var db = require('mongoskin').db('localhost:27017/titles', {safe:true});
var titles = db.collection('titles');
title = titles.findOne(function(err, result){
if (err) throw err;
return result.title;
});
console.log(title)
And this BSON object in the collection:
{"title": "Hello World", "postNumber": 0, "_id": ObjectId("509eeffbf8f11e8813000001")}
My goal is got get the string "Hello World" to output to the console, but instead I get this:
{ emitter: { _events: { open: [Object] }, _maxListeners: 50 },
state: 1,
options: undefined,
skinDb:
{ emitter: { _events: [Object], _maxListeners: 100 },
state: 1,
_dbconn:
{ databaseName: 'titles',
serverConfig: [Object],
options: [Object],
_applicationClosed: false,
native_parser: true,
bsonLib: [Object],
bson: {},
bson_deserializer: [Object],
bson_serializer: [Object],
_state: 'connecting',
pkFactory: [Object],
forceServerObjectId: false,
safe: true,
notReplied: {},
isInitializing: true,
auths: [],
openCalled: true,
commands: [],
_callBackStore: [Object],
logger: [Object],
slaveOk: false,
tag: 1352682584657,
eventHandlers: [Object],
serializeFunctions: false,
raw: false,
recordQueryStats: false,
reaperEnabled: false,
_lastReaperTimestamp: 1352682584657,
retryMiliSeconds: 1000,
numberOfRetries: 60,
reaperInterval: 10000,
reaperTimeout: 30000,
readPreference: undefined },
db: null,
username: '',
password: undefined,
admin: { emitter: {}, state: 0, skinDb: [Circular], admin: null },
_collections: { titles: [Circular] },
bson_serializer:
{ BSON: [Object],
Long: [Object],
ObjectID: [Object],
DBRef: [Function: DBRef],
Code: [Function: Code],
Timestamp: [Object],
Binary: [Object],
Double: [Function: Double],
MaxKey: [Function: MaxKey],
MinKey: [Function: MinKey],
Symbol: [Function: Symbol] },
ObjectID:
{ [Function: ObjectID]
index: 0,
createPk: [Function: createPk],
createFromTime: [Function: createFromTime],
createFromHexString: [Function: createFromHexString] } },
ObjectID:
{ [Function: ObjectID]
index: 0,
createPk: [Function: createPk],
createFromTime: [Function: createFromTime],
createFromHexString: [Function: createFromHexString] },
collectionName: 'titles',
collection: null,
internalHint: null,
hint: [Getter/Setter] }
It works just fine when I put the console.log() inside the function, I just can't return the string for some reason.
Solved:
read = function(callback){
titles.findOne(function(err, result){
if (err) throw err;
callback(result.title);
});
};
read(function(title){
console.log(title);
});
you need to understand javascript callback.
1 - findOne will return a db object not the result of your string. I never read the mongoskin doco but I think it will be a db collection or some sort which is what you see in the console.log print out.
2 - in the callback your do return result.title; will never return the title back as you would expect. so that is why I suggest to do some reading on how callback work.
The correct way to print the title will be putting the console.log inside the callback function as you mention.

Resources