MongoDB $ stdDevSamp

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

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.

$stdDevSamp tương tự như $stdDevPop . Sự khác biệt là $stdDevSamp tính toán mẫu độ lệch chuẩn, trong khi $stdDevPop tính toán dân số độ lệch chuẩn.

Do đó, hãy sử dụng $stdDevSamp 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 đó. Nếu các giá trị đại diện cho toàn bộ tập hợp dữ liệu hoặc bạn không muốn khái quát về một tập hợp lớn hơn, hãy sử dụng $stdDevPop thay vào đó.

Cú pháp

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

Cú pháp 1:

{ $stdDevSamp: <expression> }

Cú pháp 2:

{ $stdDevSamp: [ <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, $stdDevSamp trả về độ lệch chuẩn mẫu 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 $stdDevSamp kết hợp với $group để trả về độ lệch chuẩn mẫu 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 $stdDevSamp để trả về độ lệch chuẩn mẫu của price trường cho mỗi nhóm:

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

Kết quả:

{ "_id" : "gme", "result" : 131.24404748406687 }
{ "_id" : "jnj", "result" : 10.344080432788612 }

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

Mảng

Ví dụ này áp dụng $stdDevSamp 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 $stdDevSamp đến điểm scores trường trong mỗi tài liệu:

db.players.aggregate(
   [
     {
       $project:
          {
            result: { $stdDevSamp: "$scores" }
          }
     }
   ]
)

Kết quả:

{ "_id" : 1, "result" : 3.0783421635988546 }
{ "_id" : 2, "result" : 7.633260552782583 }
{ "_id" : 3, "result" : 5.988878581726855 }
{ "_id" : 4, "result" : null }
{ "_id" : 5, "result" : null }
{ "_id" : 6, "result" : null }

Trong trường hợp này, ba tài liệu đầu tiên trả về độ lệch chuẩn mẫu 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à null . Điều này là do chúng tôi chỉ cung cấp một số trong mảng. Nếu chúng tôi đã sử dụng $stdDevPop , điều này sẽ trả về 0 .

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 $stdDevSamp với nhiều hơn một đối số. $stdDevSamp 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 $stdDevSamp để trả về độ lệch chuẩn mẫu của a , b , c và d các trường của mỗi tài liệu:

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

Kết quả:

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

Kết quả của tài liệu đầu tiên dựa trên các giá trị đầu vào của 1 , 2 , 3 và 4 .

Tuy nhiên, hai tài liệu cuối cùng chỉ dẫn đến 1 , 2 và 3 Đang được đánh giá. $stdDevSamp toán tử đã bỏ qua d của họ lĩnh vực.

$stdDevSamp 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 mẫu 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, $stdDevSamp 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, $stdDevSamp 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ì $stdDevSamp trả về null .

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

Khi sử dụng cú pháp nhiều đối số, $stdDevSamp 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: { $stdDevSamp: [ "$a", "$b", "$c", "$d", "$e" ] }
          }
     }
   ]
)

Kết quả:

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

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. $stdDevSamp đã tính toán độ lệch chuẩn mẫu 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: { $stdDevSamp: [ "$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ố, một trường bị thiếu dẫn đến null .

Ví dụ:

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

Kết quả:

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

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

$stdDevSamp 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