సమయంతో పని చేయడం

కాలక్రమేణా ప్రస్తుత పరిస్థితి

JDBC కనుగొనబడినప్పటి నుండి మరియు దాని ఇంటర్‌ఫేస్‌లు ప్రామాణికం చేయబడినప్పటి నుండి, 20 సంవత్సరాలు గడిచాయి మరియు ఈ సమయంలో చాలా విషయాలు మారాయి.

ముందుగా, ప్రపంచం ప్రపంచవ్యాప్తంగా మారింది మరియు ఇప్పుడు ఒక సర్వర్ ప్రపంచం నలుమూలల నుండి వినియోగదారులకు సేవ చేయగలదు. ఇంటర్నెట్ వేగం పెరిగింది. కాబట్టి, సమయంతో పని చేయడానికి మరొక డేటా రకం SQLకి జోడించబడింది . ఇప్పుడు రకాలు ఇలా కనిపిస్తాయి:

• DATE - తేదీని నిల్వ చేస్తుంది: సంవత్సరం, నెల, రోజు.
• TIME - సమయాన్ని నిల్వ చేస్తుంది: గంటలు, నిమిషాలు, సెకన్లు.
• TIMESTAMP - సమయం లో ఒక నిర్దిష్ట పాయింట్ నిల్వ చేస్తుంది: తేదీ, సమయం మరియు మిల్లీసెకన్లు.
• టైమ్‌స్టాంప్‌తో టైమ్ జోన్ - టైమ్‌స్టాంప్ మరియు టైమ్ జోన్ (జోన్ పేరు లేదా ఆఫ్‌సెట్).

రెండవది, జావా గ్లోబల్ టైమ్ మేనేజ్‌మెంట్ కోసం డేట్‌టైమ్ APIని పరిచయం చేసింది. ఇది క్రింది తరగతులను కలిగి ఉంది:

• తేదీ మరియు సమయం :
  • స్థానిక తేదీ
  • స్థానిక సమయం
• ఖచ్చితమైన క్షణం :
  • java.time.Instant
  • java.time.LocalDateTime
  • java.time.OffsetDateTime
  • java.time.ZonedDateTime
• టైమ్ జోన్‌తో సమయం :
  • java.time.OffsetDateTime
  • java.time.ZonedDateTime

మూడవ ఆసక్తికరమైన విషయం ఏమిటంటే, చాలా మంది SQL క్లయింట్‌లు ఇప్పటికే తమ స్థానిక జోన్‌లో ఉన్న సర్వర్ నుండి సమయాన్ని పొందాలనుకుంటున్నారు . అయితే, మీరు ఫ్లైలో సమయాన్ని మార్చవచ్చు, కానీ ఇది అనుకూలమైనది కాదు మరియు తప్పులు ఉన్నాయి.

ఉదాహరణకు, నేను డేటాబేస్ నుండి ఈరోజు అన్ని టాస్క్‌లను పొందాలనుకుంటున్నాను. దీని కోసం SQL సర్వర్ CURDATE() ఫంక్షన్‌ని కలిగి ఉంది. ఇక్కడ మాత్రమే సర్వర్ USAలో ఉంది మరియు నేను జపాన్‌లో ఉన్నాను. మరియు అతను "నా ఈ రోజు" కోసం అన్ని రికార్డులను తిరిగి ఇవ్వాలని నేను కోరుకుంటున్నాను మరియు "అతని ఈరోజు" కాదు.

సాధారణంగా, SQL సర్వర్ తప్పనిసరిగా వేర్వేరు సమయ మండలాల్లోని క్లయింట్‌లతో తెలివిగా పని చేయగలగాలి.

ఆధునిక సమస్యలకు ఆధునిక పరిష్కారాలు అవసరం

సూత్రప్రాయంగా, Java DateTime API నుండి కొత్త రకాలు మరియు SQL నుండి రకాలను సౌకర్యవంతంగా మ్యాప్ చేయవచ్చు. జావాలో DATE రకాన్ని సూచించడానికి , మీరు JDK 8 DateTime API నుండి java.time.LocalDate తరగతిని ఉపయోగించాలి .

డేటాబేస్ నుండి TIME రకాన్ని జావా నుండి రెండు రకాలుగా సూచించవచ్చు: java.time.LocalTime మరియు java.time.OffsetTime . సంక్లిష్టంగా ఏమీ లేదు.

డేటాబేస్‌లోని TIMESTAMP రకం ద్వారా సూచించబడే నిర్దిష్ట సమయం , జావాలో 4 రకాలుగా సూచించబడుతుంది:

• java.time.Instant
• java.time.LocalDateTime
• java.time.OffsetDateTime
• java.time.ZonedDateTime

చివరగా, టైమ్‌స్టాంప్ విత్ టైమ్ జోన్‌ని రెండు రకాలుగా సూచించవచ్చు:

• java.time.OffsetDateTime
• java.time.ZonedDateTime

మీకు ఇప్పటికే DateTime API గురించి బాగా తెలుసు కాబట్టి, ఈ విషయాన్ని గుర్తుంచుకోవడం మీకు కష్టమేమీ కాదు :)

నేను దానిని పట్టిక రూపంలో వ్రాస్తాను, కనుక ఇది సులభం అవుతుంది:

తేదీని పొందడం

మీ కోసం నా దగ్గర ఒక శుభవార్త ఉంది. చాలా కాలం తర్వాత మొదటిది. java.sql తేదీ రకాన్ని అందించే getDate() పద్ధతి యొక్క పరిమితిని మనం అధిగమించవచ్చు .

విషయం ఏమిటంటే వస్తువుఫలితం సెట్మరొక ఆసక్తికరమైన పద్ధతి ఉంది - getObject() . ఈ పద్ధతి రెండు పారామితులను తీసుకుంటుంది: ఒక నిలువు వరుస మరియు ఒక రకం, మరియు ఇచ్చిన రకానికి మార్చబడిన నిలువు వరుస విలువను అందిస్తుంది. పద్ధతి యొక్క సాధారణ రూపం క్రింది విధంగా ఉంది:

ClassName Name = getObject(column, ClassName);

మరియు మీరు DATE రకాన్ని java.time.LocalDate రకానికి మార్చాలనుకుంటే , మీరు ఇలా వ్రాయాలి:

LocalDate localDate = results.getObject(4, LocalDate.class);

మరియు సాధారణంగా ఏదైనా TIMESTAMPని అనేక రకాల రకాలుగా మార్చవచ్చు:

java.time.Instant instant = results.getObject(9, java.time.Instant.class);
java.time.LocalDateTime local = results.getObject(9, java.time. LocalDateTime.class);
java.time.OffsetDateTime offset = results.getObject(9, java.time. OffsetDateTime.class);
java.time.ZonedDateTime zoned = results.getObject(9, java.time. ZonedDateTime.class);

ముఖ్యమైనది! మీరు పాత MySQL JDBC డ్రైవర్‌ని కలిగి ఉంటే ఈ కోడ్ పని చేయదు . మీ pom.xmlలో వ్రాసిన "mysql-connector-java" సంస్కరణకు శ్రద్ధ వహించండి లేదా ప్రాజెక్ట్ సెట్టింగ్‌లలో లైబ్రరీలకు జోడించబడింది.

మార్గం ద్వారా, అదే విధంగా, మీరు ఆదిమ రకాల కోసం శూన్య నిల్వ అసమర్థత చుట్టూ పొందవచ్చు. పట్టిక కాలమ్ INT రకంగా ఉంటే, దాని నుండి శూన్యతను పొందడానికి రెండు మార్గాలు ఉన్నాయి. దిగువ ఉదాహరణ చూడండి:

Integer id1 = results.getObject(8, Integer.class);    	 // this will work
Integer id2 = results.getObject(8, int.class);                 //this will also work
int id3 = results.getObject(8,  Integer.class);            	//method will return null, JVM will throw NPE
int id4 = results.getObject(8,  int.class);                    	//method will return null, JVM will throw NPE

MySQLలో టైమ్‌జోన్ సెట్టింగ్

mysql://localhost:3306/db_scheme?Name=meaning&Name=meaning

కాబట్టి, MySQLలో సమయ మండలాలతో పని చేయడానికి మూడు పారామితులు జోడించబడ్డాయి. మీరు సర్వర్‌కు కనెక్షన్‌ని ఏర్పాటు చేసినప్పుడు మీరు ఈ పారామితులను పాస్ చేయవచ్చు.

క్రింద నేను వారితో ఒక టేబుల్ ఇస్తాను:

connectionTimeZone పరామితిని ఉపయోగించి , మేము అన్ని అభ్యర్థనలు అమలు చేయబడే సమయ మండలి (టైమ్ జోన్)ని ఎంచుకుంటాము. క్లయింట్ యొక్క దృక్కోణం నుండి, సర్వర్ పేర్కొన్న టైమ్ జోన్‌లో నడుస్తోంది.

ForceConnectionTimeZoneToSession పరామితి సెషన్ టైమ్_జోన్ వేరియబుల్‌ని విస్మరించేలా చేస్తుంది మరియు కనెక్షన్‌టైమ్‌జోన్‌తో భర్తీ చేస్తుంది.

చివరగా, PreserveInstants పరామితి JVM యొక్క టైమ్‌జోన్ మరియు కనెక్షన్‌టైమ్‌జోన్ మధ్య ఖచ్చితమైన-సమయ-మార్పిడిని నియంత్రిస్తుంది.

అత్యంత సాధారణ కాన్ఫిగరేషన్‌లు:

• connectionTimeZone=LOCAL & forceConnectionTimeZoneToSession=false - useLegacyDatetimeCode=trueతో పాత MySQL JDBC డ్రైవర్ వెర్షన్ 5.1కి అనుగుణంగా ఉంటుంది.

• connectionTimeZone=LOCAL & forceConnectionTimeZoneToSession=true అనేది తేదీ మరియు సమయ విలువలను నిర్వహించడానికి అత్యంత సహజమైన మార్గాన్ని అందించే కొత్త మోడ్.

• connectionTimeZone=SERVER & preserveInstants=true - useLegacyDatetimeCode=falseతో పాత MySQL JDBC డ్రైవర్ వెర్షన్ 5.1కి అనుగుణంగా ఉంటుంది.

• connectionTimeZone=user_defined & preserveInstants=true - CET/CEST వంటి సాధారణ సంక్షిప్తీకరణగా సెట్ చేయబడినందున సర్వర్ టైమ్ జోన్‌ను కనెక్టర్ గుర్తించలేని పరిస్థితిని అధిగమించడంలో సహాయపడుతుంది.

అవును, తేదీలు ఆసక్తికరమైన అంశం మరియు వాటితో చాలా సమస్యలు ఉన్నాయి. సామెత చెప్పినట్లుగా: ఇది భయానకంగా ఉంది, అయితే నేను కూడా విసుగు చెందను! :)