JDBCలో డేటా రకం చర్చలు

డేటా రకాలు

పట్టికను పరిశీలిద్దాం:

మూడవ నిలువు వరుసలో మనకు రకాలు కనిపిస్తాయి: INT , VARCHAR , DATE . ఇవి SQL సర్వర్ రకాలు. సర్వర్ అంటే తనకు తెలిసిన వాటితో డేటాను ఇస్తుంది. ఈ రకాలు జావా రకాలుగా ఎలా మార్చబడతాయి?

JDBCతో ప్రమాణీకరించబడిన వాటిలో ఇది ఖచ్చితంగా ఒకటి. JDBC సృష్టికర్తలు SQL రకాల జాబితాను ఫిక్స్ చేయడం ద్వారా ప్రారంభించారు. స్థిరాంకాలతో ప్రత్యేక తరగతి ఉంది:

class java.sql.Types {
   public static final int CHAR         =   1;
   public static final int NUMERIC    	=   2;
   public static final int DECIMAL     	=   3;
   public static final int INTEGER      =   4;
   public static final int FLOAT        =   6;
   public static final int REAL         =   7;
  …
}

సంఖ్య తరగతిలోని క్రమ సంఖ్య కాదు, కానీ SQL స్పెసిఫికేషన్‌లోని SQL రకాల జాబితాలో ID రకం. ఉపన్యాసం ప్రారంభంలో ఉదాహరణలో మీరు చూసిన సంఖ్యలు ఇవి.

అలాగే ResultSet తరగతిలో ఒక డేటా రకాన్ని మరొకదానికి మార్చగల పద్ధతులు ఉన్నాయి. అన్ని రకాలు ఒకదానికొకటి మార్చబడవు, కానీ తర్కం తగినంత స్పష్టంగా ఉంది. మీ కోసం ఇక్కడ మంచి స్ప్రెడ్‌షీట్ ఉంది:

అన్ని SQL రకాల్లో, కొన్ని సమూహాలను స్పష్టంగా వేరు చేయవచ్చు:

• సంఖ్యలు
• సమయం
• పంక్తులు
• బైట్ వస్తువులు

మార్గం ద్వారా, మీరు getInt() పద్ధతిని గమనించారా ?

JDBC మరియు NULL

ResultSet తరగతి యొక్క getInt() పద్ధతిలో ఏమి తప్పు ఉందో మీరు గమనించారా ? దాని సంతకాన్ని మళ్ళీ చూద్దాం:

int getInt(column)

ఈ పద్ధతి పూర్ణాంకాన్ని కాకుండా పూర్ణాంకాన్ని అందిస్తుంది. ఎందుకంటే JDBC రకం పూర్ణాంకం సృష్టించబడిన సమయంలో, అది ఇంకా ఉనికిలో లేదు. సరే, చెప్పుకుందాం. అప్పుడు నాకు ఒక ప్రశ్న ఉంది:

INT NULL కాలమ్‌ని కలిగి ఉన్న డేటాబేస్‌లో నా దగ్గర పట్టిక ఉంది, అది INT కావచ్చు కానీ NULL కూడా కావచ్చు. నేను ఈ నిలువు వరుస నుండి శూన్య విలువను ఎలా పొందగలను?

చింతించకండి, ప్రతిదీ మీ కోసం ఆలోచించబడింది.

పరిష్కారం ఒకటి . జావాలోని SQL రకాన్ని తేదీ లేదా స్ట్రింగ్ వంటి రిఫరెన్స్ రకం ద్వారా సూచించినట్లయితే, సమస్య లేదు . ఈ రకమైన వేరియబుల్స్ శూన్య విలువలను తీసుకోవచ్చు.

పరిష్కారం రెండు . ఆదిమ రకాలు శూన్యం కావు, కాబట్టి getInt() వంటి పద్ధతులు కేవలం డిఫాల్ట్ విలువను అందిస్తాయి . Int కోసం ఇది 0, ఫ్లోట్ = 0.0f కోసం, డబుల్ = 0.0d మరియు ఇలాంటి వాటికి.

మరియు కాలమ్‌లో ఏమి ఉందో అర్థం చేసుకోవడం ఎలా: 0 లేదా NULL? మరి ఈ ప్రశ్నకు పార్టీ దగ్గర సమాధానం ఉంది.

పరిష్కారం మూడు . ResultSet క్లాస్ ప్రత్యేకమైన wasNull() పద్ధతిని కలిగి ఉంది , ఈ పద్ధతి NULLకి బదులుగా వేరే విలువను అందించినట్లయితే అది నిజం అని చూపుతుంది .

నేను ఇక్కడ వ్రాసినట్లు ప్రతిదీ సరిగ్గా పని చేస్తుంది. ఉదాహరణ:

ResultSet results = staatement.executeQuery("SELECT * FROM user");
    int level = results.getInt("level");

if (results.wasNull()) {
    System.out.println("Level is null");
} else {
   System.out.println("Level is " + level);
    }

getInt() పద్ధతికి కాల్ చేస్తున్నప్పుడు అది శూన్యతను తిరిగి ఇవ్వవలసి ఉంటే, అప్పుడు wasNull() పద్ధతి ఒప్పు అని తిరిగి వస్తుంది, లేకుంటే wasNull() పద్ధతి తప్పుగా తిరిగి వస్తుంది.

ఇది ఆదిమ రకాలకు మాత్రమే కాదు:

ResultSet results = staatement.executeQuery("SELECT * FROM user");
    String name = results.getString("name");

 	if (results.wasNull()) {
 	    System.out.println("Name is null");
 	} else {
 	   System.out.println("User name is " + name);
    }

ఇది కోర్సు యొక్క ఊతకర్ర. కానీ NullPointerException తో సమస్య లేదు . ప్రతిదానిలో సానుకూలతను చూడండి :)

JDBCలో డేటా రకాల్లో తప్పు ఏమిటి?

పరీక్షను కొనసాగిద్దాం. getDate(నిలువు వరుస) పద్ధతిని నిశితంగా పరిశీలించాలా ? అతని తప్పు ఏమిటి? ఈ పద్ధతి క్రింది రకమైన ఫలితాన్ని కలిగి ఉంది:

java.sql.Date

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

java.util.Date

వారికి వేర్వేరు ప్యాకేజీలు ఉన్నాయి! ఇవి సాధారణంగా వివిధ రకాల డేటా. మరి కారణం ఇదే...

20వ శతాబ్దపు 70ల నుండి డేటాబేస్‌లు సమయాన్ని నిల్వ చేయడానికి 3 రకాల డేటాకు మద్దతు ఇస్తున్నాయి:

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

జావా భాష ఉనికిలో ఉన్న మొదటి 10 సంవత్సరాలలో ఒకే ఒక డేటా రకం, java.util.Date , ఇది UNIX TIME ఆకృతిలో ఒక పాయింట్‌ను నిల్వ చేసింది: 1970 ప్రారంభం నుండి మిల్లీసెకన్ల సంఖ్య.

అందువల్ల, JDBC ప్రమాణం యొక్క సృష్టికర్తలు జావాకు మరో మూడు డేటా రకాలను జోడించారు - ప్రత్యేకంగా JDBC కోసం:

• java.sql.date
• java.sql.Time
• java.sqlTimestamp

కాబట్టి ResultSet ఇంటర్‌ఫేస్ యొక్క పద్ధతులు స్థిర డేటా రకాలను కలిగి ఉంటాయి:

మరియు మీరు ఇక్కడ చూసే రకం ఇది:

ఇక్కడ ఏమి లేదు అని ఊహించండి? Java DateTime APIలో కనిపించిన డేటా రకాలు:

• స్థానిక తేదీ
• స్థానిక సమయం
• స్థానిక తేదీ సమయం