MongoDB $ stdDevPop

Trong MongoDB, $stdDevPop nhà điều hành đường ống tổng hợp tính toán độ lệch chuẩn tổng thể của các giá trị đầu vào của nó.

Các giá trị đầu vào có thể từ một nhóm tài liệu (tức là các tài liệu được nhóm theo cùng một khóa) hoặc chúng có thể là nhiều trường trong một tài liệu.

Cú pháp

$stdDevPop toán tử hỗ trợ hai cú pháp.

Cú pháp 1:

{ $stdDevPop: <expression> }

Cú pháp 2:

{ $stdDevPop: [ <expression1>, <expression2> ... ]  }

Cú pháp đầu tiên chấp nhận một đối số và cú pháp thứ hai chấp nhận nhiều đối số.

Khi được sử dụng trong nhóm $group giai đoạn này, bạn chỉ có thể sử dụng cú pháp đầu tiên. Trong trường hợp này, $stdDevPop trả về độ lệch chuẩn tổng thể của biểu thức được chỉ định cho một nhóm tài liệu chia sẻ cùng một nhóm theo khóa.

Ví dụ về Cú pháp 1 (Đối số Đơn)

Dưới đây là một số ví dụ sử dụng cú pháp 1.

Tài liệu được Nhóm

Ví dụ này sử dụng $stdDevPop kết hợp với $group để trả về độ lệch chuẩn trên một nhóm tài liệu được nhóm theo khóa.

Giả sử chúng ta có một bộ sưu tập được gọi là stonks với các tài liệu sau:

{ "_id" : 1, "ticker" : "gme", "price" : 10 }
{ "_id" : 2, "ticker" : "gme", "price" : 40 }
{ "_id" : 3, "ticker" : "gme", "price" : 90 }
{ "_id" : 4, "ticker" : "gme", "price" : 180 }
{ "_id" : 5, "ticker" : "gme", "price" : 290 }
{ "_id" : 6, "ticker" : "gme", "price" : 390 }
{ "_id" : 7, "ticker" : "gme", "price" : 190 }
{ "_id" : 8, "ticker" : "gme", "price" : 90 }
{ "_id" : 9, "ticker" : "gme", "price" : 10 }
{ "_id" : 10, "ticker" : "jnj", "price" : 131 }
{ "_id" : 11, "ticker" : "jnj", "price" : 133 }
{ "_id" : 12, "ticker" : "jnj", "price" : 138 }
{ "_id" : 13, "ticker" : "jnj", "price" : 141 }
{ "_id" : 14, "ticker" : "jnj", "price" : 145 }
{ "_id" : 15, "ticker" : "jnj", "price" : 150 }
{ "_id" : 16, "ticker" : "jnj", "price" : 154 }
{ "_id" : 17, "ticker" : "jnj", "price" : 156 }
{ "_id" : 18, "ticker" : "jnj", "price" : 160 }

Chúng tôi có thể nhóm các tài liệu này theo ticker của chúng và sau đó sử dụng $stdDevPop để trả về độ lệch chuẩn tổng thể của price trường cho mỗi nhóm:

db.stonks.aggregate(
   [
     {
       $group:
          {
            _id: "$ticker",
            standardDeviation: { $stdDevPop: "$price" }
          }
     }
   ]
)

Kết quả:

{ "_id" : "gme", "standardDeviation" : 123.7380746218039 }
{ "_id" : "jnj", "standardDeviation" : 9.752492558885207 }

Chúng ta có thể thấy rằng gme có độ lệch chuẩn cao hơn nhiều so với jnj .

Mảng

Ví dụ này áp dụng $stdDevPop vào một tài liệu duy nhất có chứa một trường với một mảng giá trị.

Tùy chọn này chỉ khả dụng khi sử dụng cú pháp đối số duy nhất. Mảng bị bỏ qua khi sử dụng cú pháp nhiều đối số (thông tin thêm về điều này bên dưới).

Giả sử chúng ta có một bộ sưu tập có tên là players với các tài liệu sau:

{ "_id" : 1, "player" : "Homer", "scores" : [ 1, 7, 2, 3, 8, 7, 1 ] }
{ "_id" : 2, "player" : "Marge", "scores" : [ 0, 1, 8, 17, 18, 8 ] }
{ "_id" : 3, "player" : "Bart", "scores" : [ 15, 11, 8, 0, 1, 3 ] }
{ "_id" : 4, "player" : "Brian", "scores" : [ 7 ] }
{ "_id" : 5, "player" : "Farnsworth", "scores" : [ ] }
{ "_id" : 6, "player" : "Meg", "scores" : null }

Chúng tôi có thể áp dụng $stdDevPop đến điểm scores trường trong mỗi tài liệu:

db.players.aggregate(
   [
     {
       $project:
          {
            standardDeviation: { $stdDevPop: "$scores" }
          }
     }
   ]
)

Kết quả:

{ "_id" : 1, "standardDeviation" : 2.849991049037143 }
{ "_id" : 2, "standardDeviation" : 6.968181653455625 }
{ "_id" : 3, "standardDeviation" : 5.467073155618908 }
{ "_id" : 4, "standardDeviation" : 0 }
{ "_id" : 5, "standardDeviation" : null }
{ "_id" : 6, "standardDeviation" : null }

Trong trường hợp này, ba tài liệu đầu tiên trả về độ lệch chuẩn cho các số khác nhau trong các mảng tương ứng của chúng.

Tài liệu 4 dẫn đến độ lệch chuẩn là 0 . Điều này là do chúng tôi chỉ cung cấp một số trong mảng.

Tài liệu 5 được trả về null vì chúng tôi đã cung cấp một mảng trống.

Tài liệu 6 trả về null bởi vì chúng tôi đã cung cấp null như đối số.

Ví dụ về Cú pháp 2 (Nhiều đối số)

Cú pháp thứ hai liên quan đến việc cung cấp $stdDevPop với nhiều hơn một đối số. $stdDevPop sau đó tính toán độ lệch chuẩn dựa trên tất cả các đối số được cung cấp.

Giả sử chúng ta có một tập hợp được gọi là data với các tài liệu sau:

{ "_id" : 1, "a" : 1, "b" : 2, "c" : 3, "d" : 4 }
{ "_id" : 2, "a" : 1, "b" : 2, "c" : 3, "d" : [ 4 ] }
{ "_id" : 3, "a" : 1, "b" : 2, "c" : 3, "d" : "Hey" }

Chúng ta có thể sử dụng $stdDevPop để trả về độ lệch chuẩn tổng thể của a , b , c và d các trường của mỗi tài liệu:

db.data.aggregate(
   [
     {
       $project:
          {
            result: { $stdDevPop: [ "$a", "$b", "$c", "$d" ] }
          }
     }
   ]
)

Kết quả:

{ "_id" : 1, "result" : 1.118033988749895 }
{ "_id" : 2, "result" : 0.816496580927726 }
{ "_id" : 3, "result" : 0.816496580927726 }

Tài liệu 1 trả về độ lệch chuẩn dựa trên các giá trị đầu vào của nó là 1 , 2 , 3 và 4 .

Tuy nhiên, hai tài liệu cuối cùng chỉ trả về độ lệch chuẩn cho các giá trị đầu vào của 1 , 2 và 3 . $stdDevPop toán tử đã bỏ qua d của họ lĩnh vực.

Tại sao lại như vậy?

Cách nó hoạt động là $stdDevPop bỏ qua các giá trị không phải số. Vì vậy, trong trường hợp này, nó đã bỏ qua "Hey" trong tài liệu 3 và tính toán độ lệch chuẩn tổng thể từ các trường (số) còn lại.

Đối với tài liệu 2, d của nó trường chứa một mảng. Như đã đề cập, $stdDevPop toán tử bỏ qua mảng khi sử dụng cú pháp nhiều đối số. Chính xác hơn, nó coi các mảng là các giá trị không phải số khi được sử dụng trong ngữ cảnh này. Và như đã đề cập, $stdDevPop bỏ qua các giá trị không phải số.

Nếu tất cả các giá trị không phải là số, thì $stdDevPop trả về null .

Các trường bị thiếu

Khi sử dụng cú pháp nhiều đối số, $stdDevPop bỏ qua bất kỳ trường nào bị thiếu. Có nghĩa là, nếu bạn cung cấp một trường không tồn tại, nó sẽ bỏ qua nó. Nếu không có trường nào tồn tại, thì nó trả về null .

Ví dụ:

db.data.aggregate(
   [
     {
       $project:
          {
            result: { $stdDevPop: [ "$a", "$b", "$c", "$d", "$e" ] }
          }
     }
   ]
)

Kết quả:

{ "_id" : 1, "result" : 1.118033988749895 }
{ "_id" : 2, "result" : 0.816496580927726 }
{ "_id" : 3, "result" : 0.816496580927726 }

Trong trường hợp này, tôi đã cung cấp thêm một trường ($e ) không tồn tại trong tài liệu. $stdDevPop đã tính toán độ lệch chuẩn dựa trên các trường còn lại do tồn tại.

Tuy nhiên, đây là những gì sẽ xảy ra khi không có trong số các trường tồn tại:

db.data.aggregate(
   [
     {
       $project:
          {
            result: { $stdDevPop: [ "$x", "$y", "$z" ] }
          }
     }
   ]
)

Kết quả:

{ "_id" : 1, "result" : null }
{ "_id" : 2, "result" : null }
{ "_id" : 3, "result" : null }

Kết quả là null cho tất cả các tài liệu.

Khi sử dụng cú pháp một đối số, trường bị thiếu dẫn đến null .

Ví dụ:

db.stonks.aggregate(
   [
     {
       $group:
          {
            _id: "$ticker",
            standardDeviation: { $stdDevPop: "$oops!" }
          }
     }
   ]
)

Kết quả:

{ "_id" : "gme", "standardDeviation" : null }
{ "_id" : "jnj", "standardDeviation" : null }

Các giai đoạn có sẵn

$stdDevPop có sẵn trong các giai đoạn sau:

• $group
• $project
• $addFields
• $set
• $replaceRoot
• $replaceWith
• $match giai đoạn bao gồm $expr biểu hiện

Tính độ lệch chuẩn mẫu

Xem MongoDB $stdDevSamp nếu bạn cần lấy mẫu độ lệch chuẩn, trái ngược với dân số độ lệch chuẩn. Toán tử này hữu ích nếu các giá trị của bạn bao gồm một mẫu tập hợp dữ liệu để từ đó tổng quát hóa về tập hợp.