टाइमस्टैंप फ़ंक्शन

टाइमस्टैंप फ़ंक्शन

नाम ब्यौरा
CURRENT_TIMESTAMP अनुरोध के समय के हिसाब से TIMESTAMP जनरेट करता है.
TIMESTAMP_TRUNC यह फ़ंक्शन, TIMESTAMP को जानकारी के दिए गए स्तर के मुताबिक बदल देता है.
UNIX_MICROS_TO_TIMESTAMP 1970-01-01 00:00:00 UTC से अब तक के माइक्रोसेकंड की संख्या को TIMESTAMP में बदलता है
UNIX_MILLIS_TO_TIMESTAMP 1970-01-01 00:00:00 UTC से अब तक के मिलीसेकंड की संख्या को TIMESTAMP में बदलता है
UNIX_SECONDS_TO_TIMESTAMP 1970-01-01 00:00:00 UTC से लेकर अब तक के सेकंड की संख्या को TIMESTAMP में बदलता है
TIMESTAMP_ADD TIMESTAMP में समय का अंतराल जोड़ता है
TIMESTAMP_SUB यह फ़ंक्शन, TIMESTAMP से किसी समयावधि को घटाता है
TIMESTAMP_TO_UNIX_MICROS TIMESTAMP को 1970-01-01 00:00:00 UTC के बाद के माइक्रोसेकंड की संख्या में बदलता है
TIMESTAMP_TO_UNIX_MILLIS यह TIMESTAMP को 1970-01-01 00:00:00 UTC के बाद से अब तक के मिलीसेकंड की संख्या में बदलता है
TIMESTAMP_TO_UNIX_SECONDS TIMESTAMP को 1970-01-01 00:00:00 UTC के बाद से सेकंड की संख्या में बदलता है
TIMESTAMP_DIFF यह फ़ंक्शन, दो TIMESTAMP के बीच unit के अंतराल की कुल संख्या दिखाता है.
TIMESTAMP_EXTRACT किसी TIMESTAMP से कोई खास part (जैसे, साल, महीना, दिन) निकालता है.

CURRENT_TIMESTAMP

सिंटैक्स:

current_timestamp() -> TIMESTAMP

जानकारी:

अनुरोध के समय की शुरुआत में टाइमस्टैंप मिलता है input (1970-01-01 00:00:00 UTC के बाद से माइक्रोसेकंड की संख्या के तौर पर समझा जाता है).

यह किसी क्वेरी में स्थिर रहता है. साथ ही, कई बार कॉल किए जाने पर भी हमेशा एक ही वैल्यू पर रिज़ॉल्व होगा.

TIMESTAMP_TRUNC

सिंटैक्स:

timestamp_trunc(timestamp: TIMESTAMP | BSON_TIMESTAMP, granularity: STRING[, timezone: STRING]) -> TIMESTAMP

जानकारी:

जानकारी के बताए गए स्तर के मुताबिक टाइमस्टैंप को बदल देता है.

granularity आर्ग्युमेंट एक स्ट्रिंग होना चाहिए. साथ ही, इनमें से कोई एक होना चाहिए:

  • microsecond
  • millisecond
  • second
  • minute
  • hour
  • day
  • week
  • week([weekday])
  • month
  • quarter
  • year
  • isoyear

अगर timezone आर्ग्युमेंट दिया जाता है, तो ट्रंकेशन दिए गए टाइमज़ोन की कैलेंडर सीमाओं के आधार पर होगा. उदाहरण के लिए, दिन के ट्रंकेशन से दिए गए टाइमज़ोन में आधी रात तक ट्रंकेट किया जाएगा. ट्रंकेशन, डेलाइट सेविंग टाइम के हिसाब से होगा.

अगर timezone नहीं दिया गया है, तो ट्रंकेशन UTC कैलेंडर की सीमाओं पर आधारित होगा.

timezone आर्ग्युमेंट, tz डेटाबेस से टाइमज़ोन को दिखाने वाली स्ट्रिंग होनी चाहिए. उदाहरण के लिए, America/New_York. GMT से ऑफ़सेट तय करके, कस्टम टाइम ऑफ़सेट का भी इस्तेमाल किया जा सकता है.

प्रॉम्प्ट के उदाहरण:

timestamp granularity timezone timestamp_trunc(timestamp, granularity, timezone)
2000-01-01 10:20:30:123456 यूटीसी "दूसरा" नहीं दिया गया 2001-01-01 10:20:30 यूटीसी
1997-05-31 04:30:30 यूटीसी "दिन" नहीं दिया गया 1997-05-31 00:00:00 यूटीसी
1997-05-31 04:30:30 यूटीसी "दिन" "America/Los_Angeles" 1997-05-30 07:00:00 यूटीसी
2001-03-16 04:00:00 यूटीसी "week(friday) नहीं दिया गया 2001-03-16 00:00:00 यूटीसी
2001-03-23 04:00:00 यूटीसी "week(friday) "America/Los_Angeles" 2001-03-23 17:00:00 यूटीसी
24-01-2026 रात 08:00:00 बजे यूटीसी "महीना" "GMT+06:32:43" 2026-01-01T06:32:43 यूटीसी

UNIX_MICROS_TO_TIMESTAMP

सिंटैक्स:

unix_micros_to_timestamp(input: INT64) -> TIMESTAMP

जानकारी:

input को TIMESTAMP में बदलता है. को 1970-01-01 00:00:00 UTC के बाद के माइक्रोसेकंड की संख्या के तौर पर इंटरप्रेट किया जाता है. अगर input को मान्य TIMESTAMP में नहीं बदला जा सकता, तो error दिखाता है.

प्रॉम्प्ट के उदाहरण:

input unix_micros_to_timestamp(input)
0L 1970-01-01 00:00:00 यूटीसी
400123456L 1970-01-01 00:06:40.123456 यूटीसी
-1000000L 1969-12-31 23:59:59 यूटीसी
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("createdAtMicros").unixMicrosToTimestamp().as("createdAtString")
  )
  .execute();

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("createdAtMicros").unixMicrosToTimestamp().as("createdAtString")
  )
);
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("createdAtMicros").unixMicrosToTimestamp().as("createdAtString")
  ])
  .execute()

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtMicros").unixMicrosToTimestamp().alias("createdAtString")
    )
    .execute()

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtMicros").unixMicrosToTimestamp().alias("createdAtString")
    )
    .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("createdAtMicros")
        .unix_micros_to_timestamp()
        .as_("createdAtString")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(unixMicrosToTimestamp(field("createdAtMicros")).as("createdAtString"))
        .execute()
        .get();
जाएं
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.UnixMicrosToTimestamp(firestore.FieldOf("createdAtMicros")).As("createdAtString"),
	)).
	Execute(ctx)

UNIX_MILLIS_TO_TIMESTAMP

सिंटैक्स:

unix_millis_to_timestamp(input: INT64) -> TIMESTAMP

जानकारी:

यह input को TIMESTAMP में बदलता है. को 1970-01-01 00:00:00 UTC के बाद से मिलीसेकंड की संख्या के तौर पर इंटरप्रेट किया जाता है. अगर input को मान्य TIMESTAMP में नहीं बदला जा सकता, तो error दिखाता है.

प्रॉम्प्ट के उदाहरण:

input unix_millis_to_timestamp(input)
0L 1970-01-01 00:00:00 यूटीसी
4000123L 1970-01-01 01:06:40.123 यूटीसी
-1000000L 1969-12-31 23:43:20 यूटीसी
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("createdAtMillis").unixMillisToTimestamp().as("createdAtString")
  )
  .execute();

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("createdAtMillis").unixMillisToTimestamp().as("createdAtString")
  )
);
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("createdAtMillis").unixMillisToTimestamp().as("createdAtString")
  ])
  .execute()

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtMillis").unixMillisToTimestamp().alias("createdAtString")
    )
    .execute()

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtMillis").unixMillisToTimestamp().alias("createdAtString")
    )
    .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("createdAtMillis")
        .unix_millis_to_timestamp()
        .as_("createdAtString")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(unixMillisToTimestamp(field("createdAtMillis")).as("createdAtString"))
        .execute()
        .get();
जाएं
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.UnixMillisToTimestamp(firestore.FieldOf("createdAtMillis")).As("createdAtString"),
	)).
	Execute(ctx)

UNIX_SECONDS_TO_TIMESTAMP

सिंटैक्स:

unix_seconds_to_timestamp(input: INT64) -> TIMESTAMP

जानकारी:

यह फ़ंक्शन, input को TIMESTAMP में बदलता है. को 1970-01-01 00:00:00 UTC के बाद से सेकंड की संख्या के तौर पर समझा जाता है. अगर input को मान्य TIMESTAMP में नहीं बदला जा सकता, तो error दिखाता है.

प्रॉम्प्ट के उदाहरण:

input unix_seconds_to_timestamp(input)
0L 1970-01-01 00:00:00 यूटीसी
60L 1970-01-01 00:01:00 यूटीसी
-300L 1969-12-31 23:55:00 यूटीसी
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("createdAtSeconds").unixSecondsToTimestamp().as("createdAtString")
  )
  .execute();

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("createdAtSeconds").unixSecondsToTimestamp().as("createdAtString")
  )
);
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("createdAtSeconds").unixSecondsToTimestamp().as("createdAtString")
  ])
  .execute()

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtSeconds").unixSecondsToTimestamp().alias("createdAtString")
    )
    .execute()

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtSeconds").unixSecondsToTimestamp().alias("createdAtString")
    )
    .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("createdAtSeconds")
        .unix_seconds_to_timestamp()
        .as_("createdAtString")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(unixSecondsToTimestamp(field("createdAtSeconds")).as("createdAtString"))
        .execute()
        .get();
जाएं
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.UnixSecondsToTimestamp(firestore.FieldOf("createdAtSeconds")).As("createdAtString"),
	)).
	Execute(ctx)

TIMESTAMP_ADD

सिंटैक्स:

timestamp_add(timestamp: TIMESTAMP | BSON_TIMESTAMP, unit: STRING, amount: INT64) -> TIMESTAMP

जानकारी:

इससे timestamp से unit का amount जुड़ जाता है. amount आर्ग्युमेंट की वैल्यू नेगेटिव हो सकती है. ऐसे में, यह TIMESTAMP_SUB के बराबर होता है.

unit आर्ग्युमेंट एक स्ट्रिंग होना चाहिए. साथ ही, इनमें से कोई एक होना चाहिए:

  • microsecond
  • millisecond
  • second
  • minute
  • hour
  • day

अगर मिलने वाला टाइमस्टैंप TIMESTAMP रेंज में नहीं आता है, तो गड़बड़ी का मैसेज दिखता है.

प्रॉम्प्ट के उदाहरण:

timestamp unit amount timestamp_add(timestamp, unit, amount)
20-02-2025 00:00:00 यूटीसी "मिनट" 2L 2025-02-20 00:02:00 यूटीसी
20-02-2025 00:00:00 यूटीसी "घंटा" -4L 19-02-2025 रात 08:00:00 बजे यूटीसी
20-02-2025 00:00:00 यूटीसी "दिन" 5L 25-02-2025 00:00:00 यूटीसी
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("createdAt").timestampAdd("day", 3653).as("expiresAt")
  )
  .execute();

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("createdAt").timestampAdd("day", 3653).as("expiresAt")
  )
);
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("createdAt").timestampAdd(3653, .day).as("expiresAt")
  ])
  .execute()

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAt")
          .timestampAdd("day", 3653)
          .alias("expiresAt")
    )
    .execute()

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAt").timestampAdd("day", 3653).alias("expiresAt")
    )
    .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(Field.of("createdAt").timestamp_add("day", 3653).as_("expiresAt"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampAdd(field("createdAt"), "day", 3653).as("expiresAt"))
        .execute()
        .get();
जाएं
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.TimestampAdd(firestore.FieldOf("createdAt"), "day", 3653).As("expiresAt"),
	)).
	Execute(ctx)

TIMESTAMP_SUB

सिंटैक्स:

timestamp_sub(timestamp: TIMESTAMP | BSON_TIMESTAMP, unit: STRING, amount: INT64) -> TIMESTAMP

जानकारी:

timestamp से unit की amount को घटाता है. amount आर्ग्युमेंट की वैल्यू नेगेटिव हो सकती है. ऐसे में, यह TIMESTAMP_ADD के बराबर होता है.

unit आर्ग्युमेंट एक स्ट्रिंग होना चाहिए. साथ ही, इनमें से कोई एक होना चाहिए:

  • microsecond
  • millisecond
  • second
  • minute
  • hour
  • day

अगर मिलने वाला टाइमस्टैंप TIMESTAMP रेंज में नहीं आता है, तो गड़बड़ी का मैसेज दिखता है.

प्रॉम्प्ट के उदाहरण:

timestamp unit amount timestamp_sub(timestamp, unit, amount)
04-07-2026 00:00:00 यूटीसी "मिनट" 40L 2026-07-03 23:20:00 यूटीसी
04-07-2026 00:00:00 यूटीसी "घंटा" -24L 05-07-2026 00:00:00 यूटीसी
04-07-2026 00:00:00 यूटीसी "दिन" 3L 01-07-2026 00:00:00 यूटीसी
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("expiresAt").timestampSubtract("day", 14).as("sendWarningTimestamp")
  )
  .execute();

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("expiresAt").timestampSubtract("day", 14).as("sendWarningTimestamp")
  )
);
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("expiresAt").timestampSubtract(14, .day).as("sendWarningTimestamp")
  ])
  .execute()

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("expiresAt")
          .timestampSubtract("day", 14)
          .alias("sendWarningTimestamp")
    )
    .execute()

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("expiresAt").timestampSubtract("day", 14).alias("sendWarningTimestamp")
    )
    .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("expiresAt")
        .timestamp_subtract("day", 14)
        .as_("sendWarningTimestamp")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampSubtract(field("expiresAt"), "day", 14).as("sendWarningTimestamp"))
        .execute()
        .get();
जाएं
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.TimestampSubtract(firestore.FieldOf("expiresAt"), "day", 14).As("sendWarningTimestamp"),
	)).
	Execute(ctx)

TIMESTAMP_TO_UNIX_MICROS

सिंटैक्स:

timestamp_to_unix_micros(input: TIMESTAMP | BSON_TIMESTAMP) -> INT64

जानकारी:

input को 1970-01-01 00:00:00 UTC के बाद से अब तक के माइक्रोसेकंड की संख्या में बदलता है. यह सटीक होने के ज़्यादा लेवल को कम करके, माइक्रोसेकंड की शुरुआत तक राउंड डाउन करता है.

प्रॉम्प्ट के उदाहरण:

input timestamp_to_unix_micros(input)
1970-01-01 00:00:00 यूटीसी 0L
1970-01-01 00:06:40.123456 यूटीसी 400123456L
1969-12-31 23:59:59 यूटीसी -1000000L
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixMicros().as("unixMicros")
  )
  .execute();

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixMicros().as("unixMicros")
  )
);
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("dateString").timestampToUnixMicros().as("unixMicros")
  ])
  .execute()

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixMicros().alias("unixMicros")
    )
    .execute()

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixMicros().alias("unixMicros")
    )
    .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(Field.of("dateString").timestamp_to_unix_micros().as_("unixMicros"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampToUnixMicros(field("dateString")).as("unixMicros"))
        .execute()
        .get();
जाएं
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.TimestampToUnixMicros(firestore.FieldOf("dateString")).As("unixMicros"),
	)).
	Execute(ctx)

TIMESTAMP_TO_UNIX_MILLIS

सिंटैक्स:

timestamp_to_unix_millis(input: TIMESTAMP | BSON_TIMESTAMP) -> INT64

जानकारी:

input को 1970-01-01 00:00:00 UTC के बाद से मिलीसेकंड की संख्या में बदलता है. यह मिलीसेकंड की शुरुआत तक राउंड डाउन करके, सटीक होने के ज़्यादा लेवल को छोटा करता है.

प्रॉम्प्ट के उदाहरण:

input timestamp_to_unix_millis(input)
1970-01-01 00:00:00 यूटीसी 0L
1970-01-01 01:06:40.123 यूटीसी 4000123L
1969-12-31 23:43:20 -1000000L
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixMillis().as("unixMillis")
  )
  .execute();

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixMillis().as("unixMillis")
  )
);
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("dateString").timestampToUnixMillis().as("unixMillis")
  ])
  .execute()

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixMillis().alias("unixMillis")
    )
    .execute()

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixMillis().alias("unixMillis")
    )
    .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(Field.of("dateString").timestamp_to_unix_millis().as_("unixMillis"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampToUnixMillis(field("dateString")).as("unixMillis"))
        .execute()
        .get();
जाएं
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.TimestampToUnixMillis(firestore.FieldOf("dateString")).As("unixMillis"),
	)).
	Execute(ctx)

TIMESTAMP_TO_UNIX_SECONDS

सिंटैक्स:

timestamp_to_unix_seconds(input: TIMESTAMP | BSON_TIMESTAMP) -> INT64

जानकारी:

input को 1970-01-01 00:00:00 UTC के बाद से सेकंड की संख्या में बदलता है. यह सटीक होने के ज़्यादा लेवल को कम करके, सेकंड की शुरुआत तक राउंड डाउन करता है.

प्रॉम्प्ट के उदाहरण:

input timestamp_to_unix_seconds(input)
1970-01-01 00:00:00 यूटीसी 0L
1970-01-01 00:01:00 यूटीसी 60L
1969-12-31 23:55:00 यूटीसी -300L
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixSeconds().as("unixSeconds")
  )
  .execute();

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixSeconds().as("unixSeconds")
  )
);
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("dateString").timestampToUnixSeconds().as("unixSeconds")
  ])
  .execute()

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixSeconds().alias("unixSeconds")
    )
    .execute()

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixSeconds().alias("unixSeconds")
    )
    .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(Field.of("dateString").timestamp_to_unix_seconds().as_("unixSeconds"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampToUnixSeconds(field("dateString")).as("unixSeconds"))
        .execute()
        .get();
जाएं
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.TimestampToUnixSeconds(firestore.FieldOf("dateString")).As("unixSeconds"),
	)).
	Execute(ctx)

TIMESTAMP_DIFF

सिंटैक्स:

timestamp_diff(end: TIMESTAMP | BSON_TIMESTAMP, start: TIMESTAMP | BSON_TIMESTAMP, unit: STRING) -> INT64

जानकारी:

यह फ़ंक्शन, दो TIMESTAMP के बीच unit के अंतराल की कुल संख्या दिखाता है.

  • अगर end, start से पहले आता है, तो नेगेटिव वैल्यू दिखाता है.
  • यह किसी भी फ़्रैक्शनल यूनिट को ट्रंकेट करता है. उदाहरण के लिए, timestamp_diff("2021-01-01 00:00:01", "2021-01-01 00:00:00", "minute") से, नतीजे के तौर पर 0 मिलता है.

unit आर्ग्युमेंट एक स्ट्रिंग होना चाहिए. साथ ही, इनमें से कोई एक होना चाहिए:

  • microsecond
  • millisecond
  • second
  • minute
  • hour
  • day

प्रॉम्प्ट के उदाहरण:

end start unit timestamp_diff(end, start, unit)
04-07-2026 00:01:00 यूटीसी 04-07-2026 00:00:00 यूटीसी "दूसरा" 60L
04-07-2026 00:00:00 यूटीसी 05-07-2026 00:00:00 यूटीसी "दिन" -1L
04-07-2026 00:00:59 यूटीसी 04-07-2026 00:00:00 यूटीसी "मिनट" 0L

TIMESTAMP_EXTRACT

सिंटैक्स:

timestamp_extract(timestamp: TIMESTAMP | BSON_TIMESTAMP, part: STRING[, timezone: STRING]) -> INT64

जानकारी:

timestamp से कोई खास part (जैसे, साल, महीना, दिन) निकालता है.

part आर्ग्युमेंट एक स्ट्रिंग होना चाहिए. साथ ही, इनमें से कोई एक होना चाहिए:

  • microsecond
  • millisecond
  • second
  • minute
  • hour
  • day
  • dayofweek: यह 1 (रविवार) और 7 (शनिवार) के बीच की कोई वैल्यू दिखाता है.
  • dayofyear
  • week: यह साल के हफ़्ते का नंबर दिखाता है. साल के पहले रविवार के लिए, यह नंबर 1 से शुरू होता है.
  • week([weekday]): यह फ़ंक्शन, साल के हफ़्ते की संख्या दिखाता है. यह संख्या, तय किए गए weekday से शुरू होती है.
  • month
  • quarter
  • year
  • isoweek: यह ISO 8601 के हिसाब से हफ़्ते की संख्या बताता है.
  • isoyear: यह ISO 8601 के हिसाब से हफ़्ते की संख्या वाला साल बताता है.

अगर timezone आर्ग्युमेंट दिया गया है, तो दिए गए टाइमज़ोन के कैलेंडर के आधार पर जानकारी निकाली जाएगी. डेटा एक्सट्रैक्ट करने की प्रोसेस, डेलाइट सेविंग टाइम के मुताबिक होगी.

अगर timezone नहीं दिया गया है, तो डेटा UTC के आधार पर निकाला जाएगा.

timezone आर्ग्युमेंट, टाइमज़ोन डेटाबेस से टाइमज़ोन की स्ट्रिंग के तौर पर होना चाहिए. उदाहरण के लिए, America/New_York. GMT से ऑफ़सेट तय करके, कस्टम टाइम ऑफ़सेट का भी इस्तेमाल किया जा सकता है.

प्रॉम्प्ट के उदाहरण:

timestamp part timezone timestamp_extract(timestamp, part, timezone)
2025-02-20 10:20:30 यूटीसी "year" नहीं दिया गया 2025
2025-02-20 10:20:30 यूटीसी "दिन" नहीं दिया गया 20
31-12-2025 को रात 11:59:59 बजे यूटीसी "year" "Asia/Tokyo" 2026