Tài liệu về nhà → Hướng dẫn sử dụng MongoDB → MongoDB Manual
db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
3Syntax: db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
4Syntax:
db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
4
db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ] db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ] db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ] db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
3 thực hiện hoạt động logic
6 trên một mảng gồm một hoặc nhiều biểu thức [
7,
8, v.v.] và chọn các tài liệu đáp ứng tất cả các biểu thức. performs a logical
db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
6 operation on an array of one or more expressions [db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
7, db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
8, and so on] and selects the documents that satisfy all the expressions.Ghi chú
MongoDB cung cấp một hoạt động
db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
6 ngầm khi chỉ định danh sách các biểu thức phân tách bằng dấu phẩy.
Để cho phép công cụ truy vấn tối ưu hóa các truy vấn,
db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
3 xử lý các lỗi như sau:Nếu bất kỳ biểu thức nào được cung cấp cho
3 sẽ gây ra lỗi khi được đánh giá một mình,db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
3 chứa biểu thức có thể gây ra lỗi nhưng không được đảm bảo lỗi.db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
Một biểu thức được cung cấp sau biểu thức đầu tiên được cung cấp cho
3 có thể gây ra lỗi ngay cả khi biểu thức đầu tiên đánh giá làdb.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
4.db.inventory.find[ { price: { $ne: 1.99, $exists: true } } ]
Ví dụ: truy vấn sau luôn tạo ra lỗi nếu
db.inventory.find[ { price: { $ne: 1.99, $exists: true } } ]
5 là db.inventory.find[ { price: { $ne: 1.99, $exists: true } } ]
6:db.example.find[ { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ]
Truy vấn sau, chứa nhiều biểu thức được cung cấp cho
db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
3, có thể gây ra lỗi nếu có bất kỳ tài liệu nào trong đó db.inventory.find[ { price: { $ne: 1.99, $exists: true } } ]
5 là db.inventory.find[ { price: { $ne: 1.99, $exists: true } } ]
6:db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
Xem xét truy vấn này:
db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
Truy vấn chọn tất cả các tài liệu trong bộ sưu tập
db.inventory.find[ { $and: [ { $or: [ { qty: { $lt : 10 } }, { qty : { $gt: 50 } } ] }, { $or: [ { sale: true }, { price : { $lt : 5 } } ] } ] } ]
0 trong đó:Giá trị trường
1 không bằngdb.inventory.find[ { $and: [ { $or: [ { qty: { $lt : 10 } }, { qty : { $gt: 50 } } ] }, { $or: [ { sale: true }, { price : { $lt : 5 } } ] } ] } ]
2 vàanddb.inventory.find[ { $and: [ { $or: [ { qty: { $lt : 10 } }, { qty : { $gt: 50 } } ] }, { $or: [ { sale: true }, { price : { $lt : 5 } } ] } ] } ] Trường
1 tồn tại.db.inventory.find[ { $and: [ { $or: [ { qty: { $lt : 10 } }, { qty : { $gt: 50 } } ] }, { $or: [ { sale: true }, { price : { $lt : 5 } } ] } ] } ]
Truy vấn có thể được viết lại với thao tác
db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
6 ngầm kết hợp các biểu thức toán tử cho trường db.inventory.find[ { $and: [ { $or: [ { qty: { $lt : 10 } }, { qty : { $gt: 50 } } ] }, { $or: [ { sale: true }, { price : { $lt : 5 } } ] } ] } ]
1:db.inventory.find[ { price: { $ne: 1.99, $exists: true } } ]
Xem xét truy vấn này:
db.inventory.find[ { $and: [ { $or: [ { qty: { $lt : 10 } }, { qty : { $gt: 50 } } ] }, { $or: [ { sale: true }, { price : { $lt : 5 } } ] } ] } ]
Truy vấn chọn tất cả các tài liệu trong bộ sưu tập
db.inventory.find[ { $and: [ { $or: [ { qty: { $lt : 10 } }, { qty : { $gt: 50 } } ] }, { $or: [ { sale: true }, { price : { $lt : 5 } } ] } ] } ]
0 trong đó:Giá trị trường
1 không bằngdb.inventory.find[ { $and: [ { $or: [ { qty: { $lt : 10 } }, { qty : { $gt: 50 } } ] }, { $or: [ { sale: true }, { price : { $lt : 5 } } ] } ] } ]
2 vàanddb.inventory.find[ { $and: [ { $or: [ { qty: { $lt : 10 } }, { qty : { $gt: 50 } } ] }, { $or: [ { sale: true }, { price : { $lt : 5 } } ] } ] } ] Trường
1 tồn tại.or thedb.inventory.find[ { $and: [ { $or: [ { qty: { $lt : 10 } }, { qty : { $gt: 50 } } ] }, { $or: [ { sale: true }, { price : { $lt : 5 } } ] } ] } ]
1 field value is less thandb.inventory.find[ { $and: [ { $or: [ { qty: { $lt : 10 } }, { qty : { $gt: 50 } } ] }, { $or: [ { sale: true }, { price : { $lt : 5 } } ] } ] } ]
2.var myDateString = Date[];
Truy vấn có thể được viết lại với thao tác
db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
6 ngầm kết hợp các biểu thức toán tử cho trường db.inventory.find[ { $and: [ { $or: [ { qty: { $lt : 10 } }, { qty : { $gt: 50 } } ] }, { $or: [ { sale: true }, { price : { $lt : 5 } } ] } ] } ]
1:Truy vấn chọn tất cả các tài liệu trong đó:
Tài liệu về nhà → Hướng dẫn sử dụng MongoDB → MongoDB Manual
Ghi chú
MongoDB BSON cung cấp hỗ trợ cho các loại dữ liệu bổ sung so với JSON. Trình điều khiển cung cấp hỗ trợ gốc cho các loại dữ liệu này bằng ngôn ngữ máy chủ và shell
var myDateString = Date[];
5 cũng cung cấp một số lớp trợ giúp để hỗ trợ việc sử dụng các loại dữ liệu này trong vỏ JavaScript var myDateString = Date[];
5. Xem tài liệu tham khảo JSON mở rộng để biết thêm thông tin.Drivers provide native support for these data types in host languages and the var myDateString = Date[];
5 shell also provides several helper classes to support the use of these data types in the
var myDateString = Date[];
5 JavaScript shell. See the Extended JSON reference for additional information.Shell
var myDateString = Date[];
5 cung cấp các phương thức khác nhau để trả về ngày, dưới dạng chuỗi hoặc dưới dạng đối tượng var myDateString = Date[];
8:Phương thức
9 trả về ngày hiện tại dưới dạng chuỗi.var myDateString = Date[];
Trình xây dựng
0 trả về một đối tượngWed Dec 19 2012 01:03:25 GMT-0500 [EST]
8 bằng cách sử dụng trình bao bọcvar myDateString = Date[];
2.Wed Dec 19 2012 01:03:25 GMT-0500 [EST]
Trình xây dựng
2 trả về một đối tượngWed Dec 19 2012 01:03:25 GMT-0500 [EST]
8 bằng cách sử dụng trình bao bọcvar myDateString = Date[];
2.Wed Dec 19 2012 01:03:25 GMT-0500 [EST]
Trong nội bộ, các đối tượng ngày được lưu trữ dưới dạng số nguyên 64 bit có chữ ký đại diện cho số mili giây kể từ kỷ nguyên Unix [ngày 1 tháng 1 năm 1970].
Không phải tất cả các hoạt động và trình điều khiển cơ sở dữ liệu đều hỗ trợ phạm vi 64 bit đầy đủ. Bạn có thể làm việc một cách an toàn với ngày với nhiều năm trong phạm vi bao gồm
db.inventory.find[ { price: { $ne: 1.99, $exists: true } } ]
6 đến Wed Dec 19 2012 01:03:25 GMT-0500 [EST]
7.Để trả về ngày làm chuỗi, hãy sử dụng phương thức
var myDateString = Date[];
9, như trong ví dụ sau:var myDateString = Date[];
Để in giá trị của biến, hãy nhập tên biến trong shell, như trong phần sau:
Kết quả là giá trị của
Wed Dec 19 2012 01:03:25 GMT-0500 [EST]
9:Wed Dec 19 2012 01:03:25 GMT-0500 [EST]
Để xác minh loại, hãy sử dụng toán tử
var myDate = new Date[]; var myDateInitUsingISODateWrapper = ISODate[];
0, như sau:Hoạt động trả về
var myDate = new Date[]; var myDateInitUsingISODateWrapper = ISODate[];
1.Các vỏ
var myDateString = Date[];
5 kết thúc các đối tượng của loại var myDateString = Date[];
8 với người trợ giúp var myDate = new Date[]; var myDateInitUsingISODateWrapper = ISODate[];
4; Tuy nhiên, các đối tượng vẫn còn thuộc loại var myDateString = Date[];
8.Ví dụ sau đây sử dụng cả hàm tạo
Wed Dec 19 2012 01:03:25 GMT-0500 [EST]
0 và hàm tạo Wed Dec 19 2012 01:03:25 GMT-0500 [EST]
2 để trả về các đối tượng var myDateString = Date[];
8.var myDate = new Date[]; var myDateInitUsingISODateWrapper = ISODate[];
Bạn cũng có thể sử dụng toán tử
var myDate = new Date[]; var myDateInitUsingISODateWrapper = ISODate[];
9 với hàm tạo Wed Dec 19 2012 01:03:25 GMT-0500 [EST]
2.Để in giá trị của biến, hãy nhập tên biến trong shell, như trong phần sau:
Kết quả là giá trị của
Wed Dec 19 2012 01:03:25 GMT-0500 [EST]
9:ISODate["2012-12-19T06:01:17.171Z"]
Để xác minh loại, hãy sử dụng toán tử
var myDate = new Date[]; var myDateInitUsingISODateWrapper = ISODate[];
0, như sau:myDate instanceof Date myDateInitUsingISODateWrapper instanceof Date
Hoạt động trả về
var myDate = new Date[]; var myDateInitUsingISODateWrapper = ISODate[];
1.Các vỏ
var myDateString = Date[];
5 kết thúc các đối tượng của loại var myDateString = Date[];
8 với người trợ giúp var myDate = new Date[]; var myDateInitUsingISODateWrapper = ISODate[];
4; Tuy nhiên, các đối tượng vẫn còn thuộc loại var myDateString = Date[];
8.Ví dụ sau đây sử dụng cả hàm tạo Wed Dec 19 2012 01:03:25 GMT-0500 [EST]
0 và hàm tạo Wed Dec 19 2012 01:03:25 GMT-0500 [EST]
2 để trả về các đối tượng var myDateString = Date[];
8.
Wed Dec 19 2012 01:03:25 GMT-0500 [EST]
Wed Dec 19 2012 01:03:25 GMT-0500 [EST]
var myDateString = Date[];
Bạn cũng có thể sử dụng toán tử var myDate = new Date[]; var myDateInitUsingISODateWrapper = ISODate[];
9 với hàm tạo Wed Dec 19 2012 01:03:25 GMT-0500 [EST]
2.
var myDate = new Date[]; var myDateInitUsingISODateWrapper = ISODate[];
Wed Dec 19 2012 01:03:25 GMT-0500 [EST]
Kết quả là giá trị
var myDateString = Date[];
8 của ISODate["2012-12-19T06:01:17.171Z"]
2 được bọc trong trình trợ giúp Wed Dec 19 2012 01:03:25 GMT-0500 [EST]
2:Để xác minh loại, hãy sử dụng toán tử
ISODate["2012-12-19T06:01:17.171Z"]
4, như sau:db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
0Hoạt động trả về
var myDateString = Date[];
0 cho cả hai.db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
1Shell
var myDateString = Date[];
5 cung cấp lớp trình bao bọc ISODate["2012-12-19T06:01:17.171Z"]
7 xung quanh kiểu dữ liệu ObjectID. Để tạo một ObjectID mới, hãy sử dụng thao tác sau trong shell var myDateString = Date[];
5:db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
2Mẹo
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
3Nhìn thấy:float, the data type changes to a floating point value, as in the following example:
Shell
5 coi tất cả các số là các giá trị dấu phẩy động theo mặc định. Vỏvar myDateString = Date[];
5 cung cấp trình bao bọcvar myDateString = Date[];
1 để xử lý các số nguyên 64 bit.myDate instanceof Date myDateInitUsingISODateWrapper instanceof Date
4db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ] Trình bao bọc
1 chấp nhận dài như một chuỗi:myDate instanceof Date myDateInitUsingISODateWrapper instanceof Date
2db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ] Các ví dụ sau sử dụng trình bao bọc
1 để ghi vào bộ sưu tập:myDate instanceof Date myDateInitUsingISODateWrapper instanceof Date
6db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
Ghi chú
MongoDB BSON cung cấp hỗ trợ cho các loại dữ liệu bổ sung so với JSON. Trình điều khiển cung cấp hỗ trợ gốc cho các loại dữ liệu này bằng ngôn ngữ máy chủ và shell
var myDateString = Date[];
5 cũng cung cấp một số lớp trợ giúp để hỗ trợ việc sử dụng các loại dữ liệu này trong vỏ JavaScript var myDateString = Date[];
5. Xem tài liệu tham khảo JSON mở rộng để biết thêm thông tin.Shell
var myDateString = Date[];
5 coi tất cả các số là các giá trị dấu phẩy động theo mặc định. Vỏ var myDateString = Date[];
5 cung cấp hàm tạo db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
10 để chỉ định rõ ràng các số nguyên 32 bit.Mới trong phiên bản 3.4.
Shell
var myDateString = Date[];
5 coi tất cả các số là các giá trị nổi 64 bit db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
12 theo mặc định. Vỏ var myDateString = Date[];
5 cung cấp hàm tạo db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
14 để chỉ định rõ ràng các giá trị dấu phẩy động dựa trên thập phân 128 bit có khả năng mô phỏng số thập phân với độ chính xác chính xác. Chức năng này được dành cho các ứng dụng xử lý dữ liệu tiền tệ, chẳng hạn như tính toán tài chính, thuế và khoa học.Loại
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
15 BSON sử dụng định dạng đánh số điểm nổi của IEEE 754 Decimal128 hỗ trợ 34 chữ số thập phân [tức là các chữ số quan trọng] và phạm vi số mũ từ −6143 đến +6144.Chất xây dựng
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
14 chấp nhận giá trị db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
15 dưới dạng chuỗi:Giá trị được lưu trữ trong cơ sở dữ liệu như sau:
Chất xây dựng
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
14 cũng chấp nhận các giá trị db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
12 từ vỏ var myDateString = Date[];
5 [tức là không có báo giá], mặc dù điều này không được khuyến nghị do nguy cơ mất độ chính xác. Hàm tạo tạo biểu diễn độ chính xác db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
12 dựa trên nhị phân của tham số dựa trên thập phân [có khả năng mất độ chính xác], sau đó chuyển đổi giá trị đó thành giá trị db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
15 với độ chính xác là 15 chữ số. Ví dụ sau đây truyền giá trị ngầm dưới dạng db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
12 và cho thấy cách nó được tạo với độ chính xác là 15 chữ số:Giá trị được lưu trữ trong cơ sở dữ liệu như sau:
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
7Chất xây dựng
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
14 cũng chấp nhận các giá trị db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
12 từ vỏ var myDateString = Date[];
5 [tức là không có báo giá], mặc dù điều này không được khuyến nghị do nguy cơ mất độ chính xác. Hàm tạo tạo biểu diễn độ chính xác db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
12 dựa trên nhị phân của tham số dựa trên thập phân [có khả năng mất độ chính xác], sau đó chuyển đổi giá trị đó thành giá trị db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
15 với độ chính xác là 15 chữ số. Ví dụ sau đây truyền giá trị ngầm dưới dạng db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
12 và cho thấy cách nó được tạo với độ chính xác là 15 chữ số:db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
8Giá trị được lưu trữ trong cơ sở dữ liệu như sau:
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
9Chất xây dựng db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
14 cũng chấp nhận các giá trị db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
12 từ vỏ var myDateString = Date[];
5 [tức là không có báo giá], mặc dù điều này không được khuyến nghị do nguy cơ mất độ chính xác. Hàm tạo tạo biểu diễn độ chính xác db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
12 dựa trên nhị phân của tham số dựa trên thập phân [có khả năng mất độ chính xác], sau đó chuyển đổi giá trị đó thành giá trị db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
15 với độ chính xác là 15 chữ số. Ví dụ sau đây truyền giá trị ngầm dưới dạng db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
12 và cho thấy cách nó được tạo với độ chính xác là 15 chữ số:
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
var myDateString = Date[];
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
Ví dụ sau đây vượt qua giá trị ngầm là
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
12 và cho thấy mức độ mất độ chính xác có thể xảy ra:MongoDB driver, be sure to use a driver version that supports it.Ghi chú
db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
0Để sử dụng kiểu dữ liệu
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
15 với trình điều khiển MongoDB, hãy chắc chắn sử dụng phiên bản trình điều khiển hỗ trợ nó.
db.example.find[ { |
$and: [ |
{ x: { $ne: 0 } }, |
{ $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } |
] |
} ] |
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
12 dựa trên nhị phân thường có các biểu diễn gần đúng của các giá trị dựa trên thập phân và có thể không chính xác bằng các biểu diễn db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
15 của chúng, vì vậy hãy sử dụng hàm tạo db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
14 khi kiểm tra tính bình đẳng của các giá trị db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
15. Xem xét các ví dụ sau với các tài liệu sau trong bộ sưu tập db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
31:Khi các truy vấn từ bảng bên dưới được cắm vào phương thức
32, các kết quả sau được trả về:db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
Truy vấn
Kết quả
{"Val": 9,99}
{"_id": 2, "Val": 9,99, "Mô tả": "Double"}
{"Val": numberDecimal ["9,99"]}
{"_id": 1, "val": numberdecimal ["9,99"], "mô tả": "thập phân"}
{val: 10}
{"_id": 3, "Val": 10, "Mô tả": "Double"}
{"_id": 4, "val": numberLong [10], "mô tả": "dài"}
{"_id": 1, "val": numberdecimal ["9,99"], "mô tả": "thập phân"}
{val: 10}
{"_id": 3, "Val": 10, "Mô tả": "Double"}
{"_id": 4, "val": numberLong [10], "mô tả": "dài"}
{"_id": 5, "val": numberdecimal ["10.0"], "mô tả": "thập phân"}
{val: numberdecimal ["10"]}
Truy vấn đầu tiên,
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
33, ngầm tìm kiếm biểu diễn db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
12 của db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
35 không bằng biểu diễn db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
15 của giá trị.db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
1Chất xây dựng
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
14 được sử dụng để truy vấn cho tài liệu với biểu diễn db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
15 của db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
35. Các giá trị của loại db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
12 được loại trừ vì chúng không khớp với giá trị chính xác của biểu diễn db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
15 của db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
35.Giá trị phù hợp của tất cả các loại số được trả về khi truy vấn cho toàn bộ số. Ví dụ: truy vấn cho biểu diễn
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
12 của db.inventory.find[ { $and: [ { $or: [ { qty: { $lt : 10 } }, { qty : { $gt: 50 } } ] }, { $or: [ { sale: true }, { price : { $lt : 5 } } ] } ] } ]
7 sẽ bao gồm biểu diễn db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
15 của db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
46 trong kết quả và ngược lại.Để kiểm tra loại
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
15, hãy sử dụng toán tử db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
48 với bí danh chuỗi db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
49 hoặc db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
50, mã số cho loại db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
15.db.inventory.find[ { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] } ]
2Để xác định loại trường, vỏ
var myDateString = Date[];
5 cung cấp các toán tử ISODate["2012-12-19T06:01:17.171Z"]
4 và var myDate = new Date[]; var myDateInitUsingISODateWrapper = ISODate[];
0.ISODate["2012-12-19T06:01:17.171Z"]
4 Trả về Boolean để kiểm tra xem giá trị là một thể hiện của một số loại.Ví dụ: hoạt động sau kiểm tra xem trường
db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
56 có phải là một thể hiện của loại db.example.find[ { $and: [ { x: { $ne: 0 } }, { $expr: { $eq: [ { $divide: [ 1, "$x" ] }, 3 ] } } ] } ]
57:Hoạt động trả về
var myDateString = Date[];
0.