MongoDB $dateFromParts

W MongoDB $dateFromParts Operator potoku agregacji konstruuje i zwraca obiekt Date z części składowych daty.

Każdą część daty podajesz jako osobne pole.

W razie potrzeby można określić pola daty składowej w formacie daty tygodnia ISO.

Przykład

Załóżmy, że mamy kolekcję o nazwie dateParts z następującym dokumentem:

{
	"_id" : 1,
	"year" : 2020,
	"month" : 12,
	"day" : 31,
	"hour" : 23,
	"minute" : 30,
	"second" : 25,
	"millisecond" : 123
}

Dokument zawiera inne pole dla każdej części daty.

Możemy uruchomić następujący kod, aby zwrócić obiekt daty z pól w tych dokumentach.

db.dateParts.aggregate([
{
   $project: {
      date: {
         $dateFromParts: {
            "year": "$year", 
            "month": "$month", 
            "day": "$day", 
            "hour": "$hour", 
            "minute": "$minute", 
            "second": "$second", 
            "millisecond": "$millisecond"
         }
      }
   }
}])

Wynik:

{ "_id" : 1, "date" : ISODate("2020-12-31T23:30:25.123Z") }

Wszystkie części daty/czasu zostały przekonwertowane na pojedynczy obiekt daty.

Strefy czasowe

Możesz użyć timezone pole, aby określić strefę czasową.

Strefę czasową można określić za pomocą identyfikatora strefy czasowej Olson (np. "Europe/London" , "GMT" ) lub przesunięcie UTC (np. "+02:30" , "-1030" ).

Identyfikator strefy czasowej Olsona

Oto przykład, który używa identyfikatorów stref czasowych Olson do wyprowadzania trzech różnych dat z jednego dokumentu, w oparciu o trzy różne strefy czasowe.

db.dateParts.aggregate([
{
   $project: {
      dateUTC: {
         $dateFromParts: {
            "year": "$year", 
            "month": "$month", 
            "day": "$day", 
            "hour": "$hour", 
            "minute": "$minute", 
            "second": "$second", 
            "millisecond": "$millisecond",
            "timezone": "Pacific/Auckland"
         }
      },
      dateHonolulu: {
         $dateFromParts: {
            "year": "$year", 
            "month": "$month", 
            "day": "$day", 
            "hour": "$hour", 
            "minute": "$minute", 
            "second": "$second", 
            "millisecond": "$millisecond",
            "timezone": "Pacific/Honolulu"
         }
      },
      dateAuckland: {
         $dateFromParts: {
            "year": "$year", 
            "month": "$month", 
            "day": "$day", 
            "hour": "$hour", 
            "minute": "$minute", 
            "second": "$second", 
            "millisecond": "$millisecond",
            "timezone": "Pacific/Auckland"
         }
      }
   }
}]).pretty()

Wynik:

{
	"_id" : 1,
	"dateUTC" : ISODate("2020-12-31T10:30:25.123Z"),
	"dateHonolulu" : ISODate("2021-01-01T09:30:25.123Z"),
	"dateAuckland" : ISODate("2020-12-31T10:30:25.123Z")
}

Przesunięcie UTC

Oto przykład, który używa przesunięcia UTC.

db.dateParts.aggregate([
{
   $project: {
      "date+00:00": {
         $dateFromParts: {
            "year": "$year", 
            "month": "$month", 
            "day": "$day", 
            "hour": "$hour", 
            "minute": "$minute", 
            "second": "$second", 
            "millisecond": "$millisecond",
            "timezone": "+00:00"
         }
      },
      "date-10:00": {
         $dateFromParts: {
            "year": "$year", 
            "month": "$month", 
            "day": "$day", 
            "hour": "$hour", 
            "minute": "$minute", 
            "second": "$second", 
            "millisecond": "$millisecond",
            "timezone": "-10:00"
         }
      },
      "date+12:00": {
         $dateFromParts: {
            "year": "$year", 
            "month": "$month", 
            "day": "$day", 
            "hour": "$hour", 
            "minute": "$minute", 
            "second": "$second", 
            "millisecond": "$millisecond",
            "timezone": "+12:00"
         }
      }
   }
}]).pretty()

Wynik:

{
	"_id" : 1,
	"date+00:00" : ISODate("2020-12-31T23:30:25.123Z"),
	"date-10:00" : ISODate("2021-01-01T09:30:25.123Z"),
	"date+12:00" : ISODate("2020-12-31T11:30:25.123Z")
}

Format daty tygodnia ISO

W razie potrzeby części daty można określić przy użyciu formatu ISO 8601.

W szczególności możesz użyć:

Specyfikator formatu	Wyjście
`isoWeekYear`	Rok w formacie ISO 8601. To pole jest wymagane, jeśli nie używasz `year` (i `year` jest wymagane, jeśli nie używasz `isoWeekYear` ).
`isoWeek`	Tydzień roku w formacie ISO 8601. Można używać tylko z `isoWeekYear` .
`isoDayOfWeek`	Dzień tygodnia (1-poniedziałek, 7-niedziela). Można używać tylko z `isoWeekYear` .

Załóżmy, że wstawiamy drugi dokument, który wygląda tak:

{
	"_id" : 2,
	"isoWeekYear" : 2021,
	"isoWeek" : 32,
	"isoDayOfWeek" : 7,
	"hour" : 23,
	"minute" : 30,
	"second" : 25,
	"millisecond" : 123,
	"timezone" : "UTC"
}

Widzimy, że używa isoWeekYear , isoWeek i isoDayOfWeek zamiast year , month i day (którego używa pierwszy dokument).

Możemy użyć następującego kodu do skonstruowania obiektu Date z tego dokumentu:

db.dateParts.aggregate([
  { $match: { _id: 2} },
  {
    $project: {
        date: {
          $dateFromParts: {
              "isoWeekYear": "$isoWeekYear", 
              "isoWeek": "$isoWeek", 
              "isoDayOfWeek": "$isoDayOfWeek", 
              "hour": "$hour", 
              "minute": "$minute", 
              "second": "$second", 
              "millisecond": "$millisecond", 
              "timezone": "$timezone"
          }
        }
    }
  }
])

Wynik:

{ "_id" : 2, "date" : ISODate("2021-08-15T23:30:25.123Z") }

Pola poza zakresem

Począwszy od MongoDB 4.4, obsługiwany zakres wartości dla year i isoWeekYear to 1-9999 . We wcześniejszych wersjach dolna granica dla tych wartości wynosiła 0 a obsługiwany zakres wartości to 0-9999 .

Począwszy od MongoDB 4.0, jeśli wartość określona dla pól innych niż year , isoWeekYear i timezone jest poza prawidłowym zakresem, $dateFromParts operator przenosi lub odejmuje różnicę od innych części daty, aby obliczyć datę.

Wartości wyższe niż zakres

Załóżmy, że do naszej kolekcji dodamy następujący dokument:

{
	"_id" : 3,
	"year" : 2020,
	"month" : 14,
	"day" : 65,
	"hour" : 48,
	"minute" : 130,
	"second" : 625,
	"millisecond" : 123
}

Wiele pól daty i godziny w tym dokumencie jest wyższych niż ich odpowiednie prawidłowe zakresy.

Uruchommy następujące polecenie, aby przekonwertować go na obiekt Date:

db.dateParts.aggregate([
  { $match: { _id: 3} },
  {
    $project: {
        date: {
          $dateFromParts: {
              "year": "$year", 
              "month": "$month", 
              "day": "$day", 
              "hour": "$hour", 
              "minute": "$minute", 
              "second": "$second", 
              "millisecond": "$millisecond"
          }
        }
    }
  }
])

Wynik:

{ "_id" : 3, "date" : ISODate("2021-04-08T02:20:25.123Z") }

Widzimy, że części daty w wynikowym obiekcie Date różnią się od odpowiednich części daty w dokumencie. Dzieje się tak, ponieważ $dateFromParts ponownie obliczył datę, aby uwzględnić wartości części daty, które przekroczyły ich normalny zakres.

Wartości niższe niż zakres

Załóżmy, że do naszej kolekcji dodamy następujący dokument:

{
	"_id" : 4,
	"year" : 2020,
	"month" : 0,
	"day" : 0,
	"hour" : 0,
	"minute" : 0,
	"second" : 0,
	"millisecond" : 0
}

Wiele pól daty i godziny w tym dokumencie jest niższych niż ich odpowiednie prawidłowe zakresy.

Uruchommy następujące polecenie, aby przekonwertować go na obiekt Date:

db.dateParts.aggregate([
  { $match: { _id: 4} },
  {
    $project: {
        date: {
          $dateFromParts: {
              "year": "$year", 
              "month": "$month", 
              "day": "$day", 
              "hour": "$hour", 
              "minute": "$minute", 
              "second": "$second", 
              "millisecond": "$millisecond"
          }
        }
    }
  }
])

Wynik:

{ "_id" : 4, "date" : ISODate("2019-11-30T00:00:00Z") }