RethinkDB 2.3 - Dates and times

RethinkDB में दिनांक और समय




rethinkdb

RethinkDB में दिनांक और समय

RethinkDB समय क्षेत्रों के साथ मिलीसेकंड-सटीक समय के लिए मूल समर्थन है। कुछ मुख्य बातें:

  • टाइम्स आधिकारिक ड्राइवरों के साथ एकीकृत है , जो स्वचालित रूप से आपकी भाषा के मूल समय प्रकार से और उससे परिवर्तित हो जाएगा।
  • क्वेरीज़ टाइम -अवगत हैं , इसलिए आप इस तरह के प्रश्न पूछ सकते हैं "क्या यह घटना सोमवार को उस समय क्षेत्र में हुई थी जहां इसे रिकॉर्ड किया गया था?"
  • टाइम्स इंडेक्स के रूप में काम करता है , इसलिए जब आप घटित होते हैं, तो आप उनके आधार पर घटनाओं को कुशलता से प्राप्त कर सकते हैं।
  • समय संचालन शुद्ध रेक्लीन हैं , जिसका अर्थ है कि जटिल तिथि-समय के प्रश्नों को क्लस्टर भर में कुशलतापूर्वक वितरित किया जा सकता है।

डेट्स और टाइम्स इलस्ट्रेशन

एक त्वरित उदाहरण

सबसे पहले, एक टेबल बनाएं और कुछ ईवेंट डालें। हम पहली घटना को एक मूल ऑफसेटसेटेट ऑब्जेक्ट का उपयोग करके सम्मिलित करेंगे, और दूसरा epochTime निर्माता के साथ:

import java.time.OffsetDateTime;
import java.util.List;

r.tableCreate("events").run(conn);

OffsetDateTime nowDateTime = OffsetDateTime.now();

r.table("events").insert(r.array(
    r.hashMap("id", 0).with("timestamp", nowDateTime),
    r.hashMap("id", 1).with("timestamp", r.epochTime(1376436769.923))
)).run(conn);

अब, चलो उन वापस जाओ:

Cursor cursor = r.table("events").run(conn);
List events = cursor.toList();
System.out.println(events);

परिणाम:

[{id=0, timestamp=2016-01-05T10:41:45.100-08:00}, {id=1, timestamp=2013-08-13T23:32:49.923Z}]

दोनों बार मूल जावा 8 OffsetDateTime ऑब्जेक्ट के रूप में लौटाए OffsetDateTime हैं।

अब हम इन समयों के आधार पर फ़िल्टर कर सकते हैं:

cursor = r.table("events").filter(
    row -> row.g("timestamp").hours().gt(20)
).run(conn);
events = cursor.toList();
System.out.println(events);
[{id=1, timestamp=2013-08-13T23:32:49.923Z}]

या उन पर एक द्वितीयक सूचकांक बनाएँ:

r.table("events").indexCreate("timestamp").run(conn);

cursor = r.table("events").between(
    r.epochTime(1376436769.913), r.epochTime(1376436769.933)
).optArg("index", "timestamp").run(conn);
events = cursor.toList();
System.out.println(events);
[{id=1, timestamp=2013-08-13T23:32:49.923Z}]

तकनीकी जानकारी

टाइम्स सर्वर पर सेकंड (यूटीसी) के बाद से सेकंड के रूप में मिलीसेकंड सटीक और एक समय क्षेत्र के साथ संग्रहीत किया जाता है। वर्तमान में केवल उपलब्ध समय क्षेत्र UTC से मिनट-सटीक समय ऑफसेट हैं, लेकिन हम भविष्य में DST- अवगत समय क्षेत्रों के लिए समर्थन जोड़ सकते हैं। समय क्षेत्र आईएसओ 8601 द्वारा निर्दिष्ट तार हैं।

जब उनके युग (UTC) समय मान समान होते हैं, तो टाइम्स को समान माना जाता है । यह तुलना और अनुक्रमित संचालन दोनों के लिए सही है। टाइम्स की तुलना मिलीसेकंड सटीक के साथ फ्लोटिंग पॉइंट में की जाती है।

अधिकांश दिनांक परिचालनों को केवल वर्ष [1400, 10000] में परिभाषित किया गया है (लेकिन ध्यान दें कि वर्ष में 10000 को आईएसओ 8601 तिथियों के रूप में मुद्रित नहीं किया जा सकता है)।

लीप-सेकंड अभी अच्छी तरह से समर्थित नहीं हैं: 2012-06-30T23:59:60 और 2012-07-01T00:00:00 बराबर।

डालने का समय

आप केवल एक मूल OffsetDateTime ऑब्जेक्ट पास करके बार सम्मिलित कर सकते हैं।

OffsetDateTime myDateTime = OffsetDateTime.now();

r.table("events").insert(
    r.hashMap("id", 2).with("timestamp", myDateTime),
).run(conn);
{unchanged=0, skipped=0, replaced=0, inserted=1, errors=0, deleted=0}

आप r.now (जो UTC में क्वेरी प्राप्त होने के समय सर्वर की व्याख्या करता है) का उपयोग कर r.epochTime , या r.ISO8601 , r.epochTime , या r.ISO8601 का उपयोग करके समय का निर्माण कर r.ISO8601

r.now().toISO8601().run(conn, callback);
// returns "2013-08-09T18:53:15.012+00:00"

r.time(2013, r.august(), 9, 18, 53, 15.012, "-07:00").toIso8601().run(conn);
// returns "2013-08-09T18:53:15.012-07:00"

r.epochTime(1376074395.012).toIso8601().run(conn);
// returns "2013-08-09T18:53:15.012+00:00"

r.iso8601("2013-08-09T18:53:15.012-07:00").toIso8601().run(conn);
// returns "2013-08-09T18:53:15.012-07:00"

एक मेज के लिए प्राथमिक कुंजी के रूप में टाइम्स का उपयोग किया जा सकता है। दो बार के बराबर माना जाता है यदि उनके पास समय क्षेत्र की परवाह किए बिना युग (यूटीसी) के बाद से मिलीसेकंड की समान संख्या है।

r.table("t").insert(
    r.hashMap("id", r.iso8601("2013-08-09T11:58:00.1111-07:00"))
).run(conn);

// returns:
// {deleted=0, errors=0, inserted=1, replaced=0, skipped=0, unchanged=0}

r.table("t").insert(
    r.hashMap("id", r.iso8601("2013-08-09T10:58:00.1112-08:00"))
).run(conn);

// returns: 
// {deleted=0, errors=1, inserted=0, replaced: 0, skipped=0, unchanged=0, first_error="Duplicate primary key `id`=..."}

आप शाब्दिक छद्म रूप वस्तु डालकर एक समय भी लगा सकते हैं। यह उपयोगी है, उदाहरण के लिए, आपने { timeFormat : 'raw' } का उपयोग करके एक पंक्ति निर्यात की है (नीचे पुनर्प्राप्त समय देखें)।

नोट: अपनी वस्तुओं में नियमित अभिव्यक्ति ^\$reql_.+\$$ से मेल खाते कुंजियों के उपयोग से बचें। RethinkDB उन लोगों को आरक्षित कीवर्ड मानता है।

r.expr(
    r.hashMap("$reql_type$", "TIME")
     .with("epoch_time", 1376075362.662)
     .with("timezone", "+00:00")
).toIso8601().run(conn);

पुनः प्राप्त करने का समय

डिफ़ॉल्ट रूप से, समय सर्वर से पुनर्प्राप्त होने पर देशी वस्तुओं में परिवर्तित हो जाते हैं। इसे run लिए optArg timeFormat पास करके इसे ओवरराइड किया जा सकता है। अभी केवल विकल्प native , डिफ़ॉल्ट और raw

r.now().run(conn);
// returns "2016-01-06T00:34:13.623Z"

r.now().inTimezone("-07:00").run(conn);
// returns "2016-01-05T17:34:13.623Z-07:00"

import com.rethinkdb.model.OptArgs;
r.now().run(conn, OptArgs.of("time_format", "raw"));
// returns:
// {"timezone":"+00:00","$reql_type$":"TIME","epoch_time":1.452040701881E9}

r.now().inTimezone("-07:00").run(conn, OptArgs.of("time_format", "raw"));
// returns:
// {"timezone":"-07:00","$reql_type$":"TIME","epoch_time":1.452040701881E9}

आप या तो toEpochTime या toIso8601 का उपयोग करके सर्वर पर टाइम ऑब्जेक्ट को भी रूपांतरित कर सकते हैं।

r.now().toEpochTime().run(conn);
// returns 1376075986.574

r.now().toISO8601().run(conn);
// returns "2013-08-09T19:19:46.574+00:00"

समय के साथ काम करना

केवल तीन उपयोगी चीजें हैं जो आप एक समय के साथ कर सकते हैं: इसे संशोधित करें, इसे किसी अन्य समय से तुलना करें, या इसके एक हिस्से को पुनः प्राप्त करें।

संशोधित समय

आप किसी अवधि को (सेकंड में) जोड़ या घटा सकते हैं:

r.time(2015, 1, 1, "Z").add(86400).run(conn);
// returns "2015-01-02T00:00Z"

यदि आप दो बार घटाते हैं, तो आपको एक अवधि मिलती है:

r.time(2015, 1, 2, "Z").sub(r.time(2015, 1, 1, "Z")).run(conn);
// returns 86400

तुलना के समय

सभी सामान्य तुलना ऑपरेटरों को समय पर परिभाषित किया जाता है:

r.epochTime(1376081287.982).lt(new Date()).run(conn, callback);
// true

टाइम्स केवल मिलीसेकंड परिशुद्धता के साथ तुलना में हैं:

r.epochTime(1376081287.9821).eq(r.epochTime(1376081287.9822)).run(conn);
// true

कमांड के during भी होता है, जो यह जांच सकता है कि कोई समय किसी विशेष श्रेणी में है या नहीं।

समय के कुछ हिस्सों को पुनः प्राप्त करना

यदि आपके पास समय है, तो आप वर्तमान समय क्षेत्र के सापेक्ष किसी विशेष भाग (जैसे महीने, या घंटे) को पुनः प्राप्त कर सकते हैं। ( एपीआई संदर्भ में पूरी सूची देखें।)

OffsetDateTime nowDateTime = OffsetDateTime.now();

r.expr(nowDateTime).run(conn);
// returns "2013-08-13T23:32:49.923Z"

r.expr(nowDateTime).month().run(conn);
// returns 8

r.expr(nowDateTime).hours().run(conn);
// returns 23

r.expr(nowDateTime).inTimezone("-06:00").hours()run(conn);
// returns 17

हम एक सप्ताह की आईएसओ 8601 परिभाषा का उपयोग करते हैं, जो सोमवार से शुरू होती है, जिसे 1 रूप में दर्शाया गया है।

r.expr(nowDateTime).dayOfWeek().run(conn);
// returns 2 for Tuesday

हम r.monday...r.sunday और r.january...r.december को परिभाषित r.monday...r.sunday सुविधा के लिए r.january...r.december :

r.expr(nowDateTime).dayOfWeek().eq(r.tuesday).run(conn);
// returns true

हम आपको तारीख और दिन के वर्तमान समय (क्रमशः एक समय और एक अवधि) में समय का टुकड़ा करने देते हैं:

r.now().toEpochTime().run(conn);
// returns 1376351312.744

r.now().date().toEpochTime().run(conn);
// returns 1376265600

r.now().timeOfDay().run(conn);
// returns 85712.744

यह सब एक साथ डालें

इन ऑपरेशनों को मिलाकर, आप शुद्ध रूप से ReQL में उपयोगी उपयोगी प्रश्न लिख सकते हैं। उदाहरण के लिए, मान लें कि आपके पास अपनी कंपनी द्वारा बनाई गई बिक्री की एक तालिका है, और आप यह जानना चाहते हैं कि उन लोगों से कितना सकल आता है जो ओवरटाइम काम कर रहे थे:

r.table("sales").filter(sale ->
    // Weekends are overtime
    sale.g("time").dayOfWeek().eq(r.saturday())
    .or(sale.g("time").dayOfWeek().eq(r.sunday()))
    // Weekdays outside 9-5 are overtime
    .or(sale.g("time").hours().lt(9))
    .or(sale.g("time").hours().ge(17))
).sum("dollars").run(conn);

यदि आपके टाइमस्टैम्प को समय क्षेत्र के साथ संग्रहीत किया जाता है, तो यह क्वेरी तब भी काम करेगी जब आपके पास विभिन्न देशों के विभिन्न कार्यालयों से बिक्री होगी (यह मानते हुए कि वे सभी 9-5 स्थानीय समय पर काम करते हैं)।

चूँकि यह क्वेरी शुद्ध ReQL है, क्लाइंट पर कोई संगणना किए बिना पूरी क्वेरी को क्लस्टर पर कुशलतापूर्वक वितरित किया जाएगा।

इसके अलावा, क्योंकि यह ReQL है, क्वेरी के अलग-अलग टुकड़े आसानी से मिल रहे हैं। यदि आप तय करते हैं कि आप प्रति माह के आधार पर उन संख्याओं को चाहते हैं, तो आप केवल एक group को वहां फेंक सकते हैं:

r.table("sales").filter(sale ->
    // Weekends are overtime
    sale.g("time").dayOfWeek().eq(r.saturday())
    .or(sale.g("time").dayOfWeek().eq(r.sunday()))
    // Weekdays outside 9-5 are overtime
    .or(sale.g("time").hours().lt(9))
    .or(sale.g("time").hours().ge(17))
).group(sale -> sale.g("time").month()).sum("dollars").run(conn);