ఎంటర్ప్రైజ్ రంగంలో Text-to-SQL ఎందుకు విఫలమవుతుంది
చాలా Text-to-SQL డెమోలు చాలా సరళంగా ఉంటాయి.
అవి సరళమైన స్కీమాలు మరియు స్పష్టమైన టేబుల్ పేర్లను ఉపయోగిస్తాయి. ఒకటి లేదా రెండు టేబుల్స్ ఖచ్చితంగా అనుసంధానించబడి ఉంటాయని అవి భావిస్తాయి. ఇది ఒక డెమోకు పని చేస్తుంది, కానీ నిజమైన కంపెనీలో విఫలమవుతుంది.
ఎంటర్ప్రైజ్ డేటాబేస్లలో, కష్టమైన భాగం SELECT క్లాజ్ కాదు. అసలైన సవాలు 'join path' (జాయిన్ పాత్).
ఒక మోడల్ కస్టమర్ వారీగా ఆదాయం (revenue) కోసం సరైన క్వెరీని వ్రాయవచ్చు. ఆ SQL రన్ అవుతుంది. డ్యాష్బోర్డ్ నంబర్లను చూపిస్తుంది. కానీ సమాధానం తప్పుగా ఉంటుంది.
ఇది ఎందుకు జరుగుతుంది?
- కస్టమర్ టేబుల్ అధికారిక మాస్టర్ లిస్ట్ కాదు.
- రెవెన్యూ ఫీల్డ్ ఫైనాన్స్ విభాగం ఆమోదించిన వెర్షన్ కాదు.
- వివిధ ప్రాంతాలలో రికార్డులు డూప్లికేట్ అయ్యాయి.
- జాయిన్ చేయడం వల్ల fanout ఎర్రర్స్ వస్తాయి.
- ఆర్థిక క్యాలెండర్లు (Fiscal calendars), సాధారణ క్యాలెండర్ సంవత్సరాల కంటే భిన్నంగా ఉంటాయి.
సింటాక్టికల్గా సరైన క్వెరీ అంటే అది నమ్మదగిన క్వెరీ అని కాదు.
నిజమైన ప్రొడక్షన్ సిస్టమ్స్ చాలా క్లిష్టంగా ఉంటాయి. మిస్సింగ్ ఫారిన్ కీలు (foreign keys), లెగసీ టేబుల్స్ మరియు నంబర్లను పెంచే (inflate చేసే) వన్-టు-మ్యానీ రిలేషన్షిప్స్ వంటి సమస్యలను మీరు ఎదుర్కోవాల్సి ఉంటుంది. మనుషులు కూడా ఒక జాయిన్ను నమ్మే ముందు పాత రిపోర్టులను తనిఖీ చేయాల్సి ఉంటుంది లేదా ఫైనాన్స్ టీమ్ను అడగాల్సి ఉంటుంది.
ఒక AI మోడల్ కేవలం పేర్లు మరియు కాలమ్స్ను మాత్రమే చూస్తుంది. అది ఊహించి (guess చేసి) సమాధానం చెబుతుంది. కొన్నిసార్లు ఆ ఊహ ప్రమాదకరంగా ఉండవచ్చు.
fanout గురించి ఆలోచించండి. మీరు ఆర్డర్లను ఆర్డర్ లైన్స్తో, ఆపై షిప్మెంట్లతో జాయిన్ చేస్తే, ఒకే ఆర్డర్ బహుళ సార్లు లెక్కించబడవచ్చు. SQL సరైనదే కావచ్చు, కానీ ఫలితం తప్పుగా ఉంటుంది.
మెటాడేటా సహాయపడుతుంది, కానీ అది సరిపోదు. ఒక రిలేషన్షిప్ ఫైనాన్షియల్ రిపోర్టింగ్ కోసం సురక్షితమైనదా కాదా అనేది కాలమ్ పేర్లు చెప్పలేవు. ఫారిన్ కీలు చారిత్రక మినహాయింపులను (historical exceptions) వివరించలేవు.
Text-to-SQL కి రిలేషన్షిప్ ఇంటెలిజెన్స్ (relationship intelligence) అవసరం.
ఒక నమ్మదగిన సిస్టమ్కు ఇవి తెలిసి ఉండాలి:
- నిర్దిష్ట వ్యాపార ప్రశ్నల కోసం ఆమోదించబడిన join paths.
- రిలేషన్షిప్ కార్డినాలిటీ (Relationship cardinality).
- తెలిసిన fanout రిస్క్లు.
- ఏ పాత్లు నిలిపివేయబడ్డాయి (deprecated).
కేవలం కోడ్ రాయడమే కాకుండా, సిస్టమ్ భద్రత (safety) గురించి ఆలోచించాలి. అది నమ్మదగిన మార్గాన్ని ఎంచుకోవాలి లేదా మార్గాలు స్పష్టంగా లేనప్పుడు సహాయం కోరాలి.
ప్రస్తుత సిస్టమ్స్లో ఉన్న లోపం ఏమిటంటే, పేర్లను మ్యాప్ చేయడం నుండి SQLని జనరేట్ చేయడం వరకు ఉన్న దూరం. మీరు రిలేషన్షిప్ కాంటెక్స్ట్ (relationship context) అనే ఒక పొరను జోడించాలి.
Text-to-SQL అనేది కేవలం భాషకు సంబంధించిన సమస్య మాత్రమే కాదు. ఇది కాంటెక్స్ట్కు సంబంధించిన సమస్య.
ఏ జాయిన్లు సురక్షితమైనవో మోడల్స్ అర్థం చేసుకునే వరకు, అవి డెమోలలో పని చేస్తాయి కానీ ప్రొడక్షన్లో విఫలమవుతాయి.
Source: https://dev.to/arisyndata/why-text-to-sql-breaks-when-the-join-path-is-not-obvious-3bk0
Optional learning community: https://t.me/GyaanSetuAi