பைத்தான் டேட்டா வேர்ஹவுசிங்: OLAP சிஸ்டம் வடிவமைப்பிற்கான ஒரு விரிவான வழிகாட்டி

இன்றைய தரவு சார்ந்த உலகில், பெரும் அளவிலான தகவல்களை விரைவாகப் பகுப்பாய்வு செய்யும் திறன் ஒரு போட்டி நன்மை மட்டுமல்ல; அது ஒரு அத்தியாவசியம். உலகெங்கிலும் உள்ள வணிகங்கள் சந்தைப் போக்குகளைப் புரிந்துகொள்ளவும், செயல்பாடுகளை மேம்படுத்தவும், மற்றும் மூலோபாய முடிவுகளை எடுக்கவும் வலுவான பகுப்பாய்வுகளை நம்பியுள்ளன. இந்த பகுப்பாய்வு திறனின் மையத்தில் இரண்டு அடிப்படைக் கருத்துக்கள் உள்ளன: டேட்டா வேர்ஹவுஸ் (DWH) மற்றும் ஆன்லைன் அனலிட்டிகல் பிராசசிங் (OLAP) அமைப்புகள்.

பாரம்பரியமாக, இந்த அமைப்புகளை உருவாக்க சிறப்பு, பெரும்பாலும் தனியுரிம மற்றும் விலை உயர்ந்த, மென்பொருள் தேவைப்பட்டது. இருப்பினும், திறந்த மூல தொழில்நுட்பங்களின் எழுச்சி டேட்டா இன்ஜினியரிங்கை ஜனநாயகப்படுத்தியுள்ளது. இந்த மாற்றத்திற்கு முன்னணியில் இருப்பது பைத்தான், இது ஒரு பல்துறை மற்றும் சக்திவாய்ந்த மொழியாகும், இது முழுமையான தரவு தீர்வுகளை உருவாக்குவதற்கான ஒரு விதிவிலக்கான தேர்வாக அமைகிறது. இந்த வழிகாட்டி, பைத்தான் ஸ்டேக்கைப் பயன்படுத்தி டேட்டா வேர்ஹவுசிங் மற்றும் OLAP அமைப்புகளை வடிவமைத்து செயல்படுத்துவதற்கான ஒரு விரிவான வழிகாட்டலை வழங்குகிறது, இது உலகளாவிய டேட்டா இன்ஜினியர்கள், ஆர்க்கிடெக்ட்டுகள் மற்றும் டெவலப்பர்களுக்காக வடிவமைக்கப்பட்டுள்ளது.

பகுதி 1: பிசினஸ் இன்டலிஜென்ஸின் மூலைக்கற்கள் - DWH மற்றும் OLAP

பைத்தான் குறியீட்டிற்குள் நுழைவதற்கு முன், கட்டடக்கலை கொள்கைகளைப் புரிந்துகொள்வது முக்கியம். ஒரு பொதுவான தவறு, செயல்பாட்டு தரவுத்தளங்களில் நேரடியாக பகுப்பாய்வு செய்ய முயற்சிப்பதாகும், இது மோசமான செயல்திறன் மற்றும் தவறான நுண்ணறிவுகளுக்கு வழிவகுக்கும். இந்த சிக்கலைத் தீர்க்கவே டேட்டா வேர்ஹவுஸ்கள் மற்றும் OLAP வடிவமைக்கப்பட்டன.

டேட்டா வேர்ஹவுஸ் (DWH) என்றால் என்ன?

டேட்டா வேர்ஹவுஸ் என்பது ஒன்று அல்லது அதற்கு மேற்பட்ட வேறுபட்ட மூலங்களிலிருந்து ஒருங்கிணைக்கப்பட்ட தரவைச் சேமிக்கும் ஒரு மையப்படுத்தப்பட்ட களஞ்சியமாகும். இதன் முதன்மை நோக்கம், வணிக நுண்ணறிவு (BI) செயல்பாடுகளை, குறிப்பாக பகுப்பாய்வு மற்றும் அறிக்கையிடலை ஆதரிப்பதாகும். இதை ஒரு நிறுவனத்தின் வரலாற்றுத் தரவுகளுக்கான ஒரே உண்மையான ஆதாரமாக நினையுங்கள்.

இது ஆன்லைன் பரிவர்த்தனை செயலாக்க (OLTP) தரவுத்தளத்திலிருந்து முற்றிலும் மாறுபட்டது, இது அன்றாட பயன்பாடுகளை இயக்குகிறது (எ.கா., ஒரு இ-காமர்ஸ் செக்அவுட் அமைப்பு அல்லது ஒரு வங்கியின் பரிவர்த்தனைப் பதிவேடு). இதோ ஒரு விரைவான ஒப்பீடு:

• பணிச்சுமை: OLTP அமைப்புகள் அதிக எண்ணிக்கையிலான சிறிய, வேகமான பரிவர்த்தனைகளைக் (reads, inserts, updates) கையாளுகின்றன. DWHகள் மில்லியன் கணக்கான பதிவுகளை ஸ்கேன் செய்யும் குறைவான எண்ணிக்கையிலான சிக்கலான, நீண்ட நேரம் இயங்கும் வினவல்களுக்கு (read-heavy) உகந்ததாக வடிவமைக்கப்பட்டுள்ளன.
• தரவு கட்டமைப்பு: OLTP தரவுத்தளங்கள் தரவு ஒருமைப்பாட்டை உறுதி செய்வதற்கும், தேவையற்ற தரவுகளைத் தவிர்ப்பதற்கும் உயர் அளவில் நார்மலைஸ் செய்யப்பட்டுள்ளன. DWHகள் பெரும்பாலும் பகுப்பாய்வு வினவல்களை எளிதாக்கவும், வேகப்படுத்தவும் டிநார்மலைஸ் செய்யப்படுகின்றன.
• நோக்கம்: OLTP வணிகத்தை நடத்துவதற்காக. DWH வணிகத்தை பகுப்பாய்வு செய்வதற்காக.

ஒரு நன்கு வடிவமைக்கப்பட்ட DWH நான்கு முக்கிய பண்புகளால் வகைப்படுத்தப்படுகிறது, இது பெரும்பாலும் முன்னோடி பில் இன்மனுடன் தொடர்புடையது:

• பொருள் சார்ந்தவை (Subject-Oriented): தரவு, பயன்பாட்டு செயல்முறைகளை விட, வணிகத்தின் முக்கிய பாடங்களான 'வாடிக்கையாளர்', 'தயாரிப்பு' அல்லது 'விற்பனை' போன்றவற்றைச் சுற்றி ஒழுங்கமைக்கப்பட்டுள்ளது.
• ஒருங்கிணைந்தவை (Integrated): தரவு பல்வேறு மூலங்களிலிருந்து சேகரிக்கப்பட்டு ஒரு சீரான வடிவத்தில் ஒருங்கிணைக்கப்படுகிறது. எடுத்துக்காட்டாக, 'USA', 'United States', மற்றும் 'U.S.' அனைத்தும் ஒரு 'United States' என்ற ஒற்றைப் பதிவாக தரப்படுத்தப்படலாம்.
• காலம் சார்ந்தவை (Time-Variant): கிடங்கில் உள்ள தரவு நீண்ட கால क्षિતિजத்தில் (எ.கா., 5-10 ஆண்டுகள்) தகவல்களைக் குறிக்கிறது, இது வரலாற்று பகுப்பாய்வு மற்றும் போக்கு கண்டறிதலை அனுமதிக்கிறது.
• அழியாதவை (Non-Volatile): தரவு கிடங்கில் ஏற்றப்பட்டவுடன், அது அரிதாகவே, அல்லது ஒருபோதும், புதுப்பிக்கப்படவோ அல்லது நீக்கப்படவோ இல்லை. இது வரலாற்று நிகழ்வுகளின் நிரந்தர பதிவாகிறது.

OLAP (ஆன்லைன் அனலிட்டிகல் பிராசசிங்) என்றால் என்ன?

DWH என்பது வரலாற்றுத் தரவுகளின் நூலகம் என்றால், OLAP என்பது அதை ஆராய உதவும் சக்திவாய்ந்த தேடுபொறி மற்றும் பகுப்பாய்வுக் கருவியாகும். OLAP என்பது மென்பொருள் தொழில்நுட்பத்தின் ஒரு வகையாகும், இது பயனர்களை பல பரிமாணக் காட்சிகளில் சுருக்கப்பட்ட தகவல்களை விரைவாக பகுப்பாய்வு செய்ய உதவுகிறது, இவை OLAP க்யூப்கள் என அழைக்கப்படுகின்றன.

OLAP க்யூப் என்பது OLAP-இன் கருத்தியல் இதயமாகும். இது அவசியமாக ஒரு பௌதீக தரவு கட்டமைப்பு அல்ல, ஆனால் தரவை மாதிரியாக்கவும் மற்றும் காட்சிப்படுத்தவும் ஒரு வழியாகும். ஒரு க்யூப் பின்வருவனவற்றைக் கொண்டுள்ளது:

• அளவீடுகள் (Measures): இவை நீங்கள் பகுப்பாய்வு செய்ய விரும்பும் அளவு சார்ந்த, எண் தரவுப் புள்ளிகள், அதாவது 'வருவாய்', 'விற்கப்பட்ட அளவு', அல்லது 'லாபம்'.
• பரிமாணங்கள் (Dimensions): இவை அளவீடுகளை விவரிக்கும் வகைப்பட்ட பண்புக்கூறுகள், சூழலை வழங்குகின்றன. பொதுவான பரிமாணங்களில் 'நேரம்' (ஆண்டு, காலாண்டு, மாதம்), 'புவியியல்' (நாடு, பகுதி, நகரம்), மற்றும் 'தயாரிப்பு' (வகை, பிராண்ட், SKU) ஆகியவை அடங்கும்.

விற்பனைத் தரவுகளின் ஒரு க்யூபை கற்பனை செய்து பாருங்கள். நீங்கள் மொத்த வருவாயை (அளவீடு) வெவ்வேறு பரிமாணங்களில் பார்க்கலாம். OLAP உடன், இந்த க்யூபில் நம்பமுடியாத வேகத்தில் சக்திவாய்ந்த செயல்பாடுகளைச் செய்ய முடியும்:

• ஸ்லைஸ் (Slice): ஒரு பரிமாணத்திற்கு ஒரு மதிப்பைத் தேர்ந்தெடுப்பதன் மூலம் க்யூபின் பரிமாணத்தைக் குறைத்தல். எடுத்துக்காட்டு: 'Q4 2023'க்கான விற்பனைத் தரவை மட்டும் பார்ப்பது.
• டைஸ் (Dice): பல பரிமாணங்களுக்கு மதிப்புகளின் வரம்பைக் குறிப்பிடுவதன் மூலம் ஒரு துணைக் க்யூபைத் தேர்ந்தெடுத்தல். எடுத்துக்காட்டு: 'ஐரோப்பா' மற்றும் 'ஆசியா' (புவியியல் பரிமாணம்) இல் 'எலக்ட்ரானிக்ஸ்' மற்றும் 'ஆடை' (தயாரிப்பு பரிமாணம்) க்கான விற்பனையைப் பார்ப்பது.
• டிரில்-டவுன் / டிரில்-அப் (Drill-Down / Drill-Up): ஒரு பரிமாணத்திற்குள் உள்ள விவரங்களின் நிலைகள் வழியாகச் செல்லுதல். டிரில்-டவுன் செய்வது உயர் மட்ட சுருக்கங்களிலிருந்து கீழ் மட்ட விவரங்களுக்குச் செல்கிறது (எ.கா., 'ஆண்டு' முதல் 'காலாண்டு' முதல் 'மாதம்' வரை). டிரில்-அப் (அல்லது ரோலிங் அப்) செய்வது இதற்கு நேர்மாறானது.
• பிவட் (Pivot): தரவின் புதிய காட்சியைக் காண க்யூபின் அச்சுகளைச் சுழற்றுதல். எடுத்துக்காட்டு: எந்தப் பகுதிகளில் எந்தப் பொருட்கள் விற்கப்படுகின்றன என்பதற்குப் பதிலாக, எந்தப் பகுதிகள் எந்தப் பொருட்களை வாங்குகின்றன என்பதைப் பார்க்க 'தயாரிப்பு' மற்றும் 'புவியியல்' அச்சுகளை மாற்றுவது.

OLAP அமைப்புகளின் வகைகள்

OLAP அமைப்புகளுக்கு மூன்று முக்கிய கட்டடக்கலை மாதிரிகள் உள்ளன:

1. MOLAP (Multidimensional OLAP): இது "கிளாசிக்" க்யூப் மாடல். தரவு DWH-லிருந்து பிரித்தெடுக்கப்பட்டு, ஒரு தனியுரிம, பல பரிமாண தரவுத்தளத்தில் முன்கூட்டியே ஒருங்கிணைக்கப்படுகிறது. நன்மைகள்: அனைத்து பதில்களும் முன்கூட்டியே கணக்கிடப்படுவதால், வினவல் செயல்திறன் மிகவும் வேகமாக இருக்கும். பாதகங்கள்: முன்கூட்டியே ஒருங்கிணைக்கப்பட்ட செல்களின் எண்ணிக்கை மிகப்பெரியதாக மாறக்கூடும் என்பதால் "தரவு வெடிப்புக்கு" வழிவகுக்கும், மேலும் நீங்கள் எதிர்பார்க்காத ஒரு கேள்வியைக் கேட்க வேண்டியிருந்தால் இது நெகிழ்வுத்தன்மை குறைவாக இருக்கலாம்.
2. ROLAP (Relational OLAP): இந்த மாடல் தரவை ஒரு ரிலேஷனல் தரவுத்தளத்தில் (பொதுவாக DWH-லேயே) வைத்திருக்கிறது மற்றும் OLAP வினவல்களை நிலையான SQL ஆக மொழிபெயர்க்க ஒரு அதிநவீன மெட்டாடேட்டா லேயரைப் பயன்படுத்துகிறது. நன்மைகள்: நவீன ரிலேஷனல் தரவுத்தளங்களின் சக்தியைப் பயன்படுத்துவதால், இது மிகவும் அளவிடக்கூடியது, மேலும் விரிவான, நிகழ்நேரத் தரவை வினவ முடியும். பாதகங்கள்: ஒருங்கிணைப்புகள் உடனடியாக செய்யப்படுவதால், வினவல் செயல்திறன் MOLAP-ஐ விட மெதுவாக இருக்கலாம்.
3. HOLAP (Hybrid OLAP): இந்த அணுகுமுறை இரண்டு உலகங்களிலும் சிறந்ததை இணைக்க முயற்சிக்கிறது. இது வேகத்திற்காக உயர் மட்ட ஒருங்கிணைந்த தரவை ஒரு MOLAP-பாணி க்யூபில் சேமிக்கிறது மற்றும் டிரில்-டவுன் பகுப்பாய்விற்காக விரிவான தரவை ROLAP ரிலேஷனல் தரவுத்தளத்தில் வைத்திருக்கிறது.

பைத்தானுடன் உருவாக்கப்பட்ட நவீன தரவு அடுக்குகளுக்கு, இந்த கோடுகள் மங்கிவிட்டன. நம்பமுடியாத வேகமான நெடுவரிசை தரவுத்தளங்களின் எழுச்சியுடன், ROLAP மாடல் ஆதிக்கம் செலுத்தி மிகவும் பயனுள்ளதாக மாறியுள்ளது, இது பெரும்பாலும் பாரம்பரிய MOLAP அமைப்புகளுக்குப் போட்டியான செயல்திறனை விறைப்புத்தன்மை இல்லாமல் வழங்குகிறது.

பகுதி 2: டேட்டா வேர்ஹவுசிங்கிற்கான பைத்தான் சுற்றுச்சூழல் அமைப்பு

பாரம்பரியமாக நிறுவன BI தளங்களால் ஆதிக்கம் செலுத்தப்பட்ட ஒரு பணிக்கு பைத்தானை ஏன் தேர்வு செய்ய வேண்டும்? பதில் அதன் நெகிழ்வுத்தன்மை, சக்திவாய்ந்த சுற்றுச்சூழல் அமைப்பு, மற்றும் முழு தரவு வாழ்க்கைச் சுழற்சியையும் ஒன்றிணைக்கும் திறனில் உள்ளது.

பைத்தான் ஏன்?

• ஒருங்கிணைந்த மொழி: நீங்கள் தரவு பிரித்தெடுத்தல் (ETL), மாற்றம், ஏற்றுதல், ஒருங்கிணைப்பு, பகுப்பாய்வு, இயந்திர கற்றல், மற்றும் API மேம்பாட்டிற்கு பைத்தானைப் பயன்படுத்தலாம். இது சிக்கலைக் குறைக்கிறது மற்றும் வெவ்வேறு மொழிகள் மற்றும் கருவிகளுக்கு இடையில் சூழல் மாறுதலுக்கான தேவையைக் குறைக்கிறது.
• பரந்த நூலக சுற்றுச்சூழல் அமைப்பு: பைத்தானில் செயல்முறையின் ஒவ்வொரு படிக்கும், தரவு கையாளுதல் (பாண்டாஸ், டாஸ்க்) முதல் தரவுத்தள தொடர்பு (SQLAlchemy) மற்றும் பணிப்பாய்வு மேலாண்மை (Airflow, Prefect) வரை முதிர்ந்த, போரில் சோதிக்கப்பட்ட நூலகங்கள் உள்ளன.
• விற்பனையாளர்-சார்பற்றது: பைத்தான் திறந்த மூலமானது மற்றும் எல்லாவற்றுடனும் இணைகிறது. உங்கள் தரவு ஒரு PostgreSQL தரவுத்தளத்திலோ, ஒரு Snowflake வேர்ஹவுஸிலோ, ஒரு S3 டேட்டா லேக்கிலோ, அல்லது ஒரு Google Sheet-இலோ இருந்தாலும், அதை அணுக ஒரு பைத்தான் நூலகம் உள்ளது.
• அளவிடுதல் திறன்: பைத்தான் தீர்வுகள் ஒரு மடிக்கணினியில் இயங்கும் ஒரு எளிய ஸ்கிரிப்டிலிருந்து, டாஸ்க் அல்லது ஸ்பார்க் (PySpark வழியாக) போன்ற கருவிகளைப் பயன்படுத்தி ஒரு கிளவுட் கிளஸ்டரில் பெட்டாபைட் தரவைச் செயலாக்கும் ஒரு விநியோகிக்கப்பட்ட அமைப்பு வரை அளவிட முடியும்.

டேட்டா வேர்ஹவுஸ் ஸ்டேக்கிற்கான முக்கிய பைத்தான் நூலகங்கள்

ஒரு பொதுவான பைத்தான் அடிப்படையிலான டேட்டா வேர்ஹவுசிங் தீர்வு ஒரு ஒற்றைத் தயாரிப்பு அல்ல, ஆனால் சக்திவாய்ந்த நூலகங்களின் ஒரு தொகுப்பாகும். இதோ அத்தியாவசியமானவை:

ETL/ELT-க்கு (பிரித்தெடுத்தல், மாற்றுதல், ஏற்றுதல்)

• Pandas: பைத்தானில் நினைவகத்தில் தரவு கையாளுதலுக்கான நடைமுறைத் தரம். சிறிய மற்றும் நடுத்தர அளவிலான தரவுத்தொகுப்புகளை (சில ஜிகாபைட்கள் வரை) கையாளுவதற்கு ஏற்றது. அதன் DataFrame பொருள் தரவை சுத்தம் செய்வதற்கும், மாற்றுவதற்கும், பகுப்பாய்வு செய்வதற்கும் உள்ளுணர்வு மற்றும் சக்தி வாய்ந்தது.
• Dask: உங்கள் பைத்தான் பகுப்பாய்வுகளை அளவிடும் ஒரு இணை கணினி நூலகம். டாஸ்க் ஒரு இணை DataFrame பொருளை வழங்குகிறது, இது பாண்டாஸ் API-ஐப் போலவே செயல்படுகிறது, ஆனால் நினைவகத்தை விட பெரிய தரவுத்தொகுப்புகளில், அவற்றை துண்டுகளாக உடைத்து பல கோர்கள் அல்லது கணினிகளில் இணையாகச் செயலாக்குவதன் மூலம் செயல்பட முடியும்.
• SQLAlchemy: பைத்தானுக்கான முதன்மையான SQL கருவித்தொகுப்பு மற்றும் ஆப்ஜெக்ட் ரிலேஷனல் மேப்பர் (ORM). இது SQLite முதல் BigQuery அல்லது Redshift போன்ற நிறுவன தர கிடங்குகள் வரை கிட்டத்தட்ட எந்த SQL தரவுத்தளத்துடனும் இணைவதற்கு ஒரு சீரான, உயர் மட்ட API-ஐ வழங்குகிறது.
• பணிப்பாய்வு ஒருங்கிணைப்பாளர்கள் (Airflow, Prefect, Dagster): ஒரு டேட்டா வேர்ஹவுஸ் ஒரு ஒற்றை ஸ்கிரிப்டில் கட்டமைக்கப்படவில்லை. இது சார்ந்த பணிகளின் தொடர் (A-லிருந்து பிரித்தெடு, B-ஐ மாற்று, C-க்கு ஏற்று, D-ஐ சரிபார்). ஒருங்கிணைப்பாளர்கள் இந்த பணிப்பாய்வுகளை இயக்கப்பட்ட சுழற்சியற்ற வரைபடங்களாக (DAGs) வரையறுக்க, திட்டமிட, கண்காணிக்க மற்றும் வலுவுடன் மீண்டும் முயற்சிக்க அனுமதிக்கின்றன.

தரவு சேமிப்பு மற்றும் செயலாக்கத்திற்கு

• கிளவுட் DWH இணைப்பிகள்: snowflake-connector-python, google-cloud-bigquery, மற்றும் psycopg2 (Redshift மற்றும் PostgreSQL-க்கு) போன்ற நூலகங்கள் முக்கிய கிளவுட் டேட்டா வேர்ஹவுஸ்களுடன் தடையற்ற தொடர்பை அனுமதிக்கின்றன.
• PyArrow: நெடுவரிசை தரவு வடிவங்களுடன் பணிபுரிவதற்கான ஒரு முக்கியமான நூலகம். இது ஒரு தரப்படுத்தப்பட்ட நினைவக வடிவத்தை வழங்குகிறது மற்றும் அமைப்புகளுக்கு இடையில் அதிவேக தரவு பரிமாற்றத்தை செயல்படுத்துகிறது. இது Parquet போன்ற வடிவங்களுடன் திறமையான தொடர்புகளுக்குப் பின்னால் உள்ள இயந்திரம்.
• நவீன லேக்ஹவுஸ் நூலகங்கள்: மேம்பட்ட அமைப்புகளுக்கு, deltalake, py-iceberg போன்ற நூலகங்கள், மற்றும் - ஸ்பார்க் பயனர்களுக்கு - இந்த வடிவங்களுக்கான PySpark-இன் சொந்த ஆதரவு, பைத்தானை நம்பகமான, பரிவர்த்தனை தரவுக் குளங்களை உருவாக்க அனுமதிக்கிறது, இது ஒரு கிடங்கின் அடித்தளமாகச் செயல்படுகிறது.

பகுதி 3: பைத்தானுடன் ஒரு OLAP அமைப்பை வடிவமைத்தல்

இப்போது, கோட்பாட்டிலிருந்து நடைமுறைக்குச் செல்வோம். உங்கள் பகுப்பாய்வு அமைப்பை வடிவமைப்பதற்கான படிப்படியான வழிகாட்டி இங்கே.

படி 1: பகுப்பாய்விற்கான டேட்டா மாடலிங்

எந்தவொரு நல்ல OLAP அமைப்பின் அடித்தளமும் அதன் தரவு மாதிரியாகும். வேகமான, உள்ளுணர்வுடன் கூடிய வினவலுக்காக தரவை கட்டமைப்பதே இதன் குறிக்கோள். மிகவும் பொதுவான மற்றும் பயனுள்ள மாதிரிகள் ஸ்டார் ஸ்கீமா மற்றும் அதன் மாறுபாடான ஸ்னோஃப்ளேக் ஸ்கீமா ஆகும்.

ஸ்டார் ஸ்கீமா மற்றும் ஸ்னோஃப்ளேக் ஸ்கீமா

ஸ்டார் ஸ்கீமா என்பது டேட்டா வேர்ஹவுஸ்களுக்கு பரவலாகப் பயன்படுத்தப்படும் கட்டமைப்பாகும். இது பின்வருவனவற்றைக் கொண்டுள்ளது:

• ஒரு மைய ஃபேக்ட் டேபிள் (Fact Table): அளவீடுகளையும் (நீங்கள் பகுப்பாய்வு செய்ய விரும்பும் எண்கள்) மற்றும் பரிமாண அட்டவணைகளுக்கான வெளிநாட்டு விசைகளையும் (foreign keys) கொண்டுள்ளது.
• பல பரிமாண அட்டவணைகள் (Dimension Tables): ஒவ்வொரு பரிமாண அட்டவணையும் ஃபேக்ட் டேபிளுடன் ஒரு ஒற்றை விசை மூலம் இணைக்கப்பட்டுள்ளது மற்றும் விளக்கமான பண்புகளைக் கொண்டுள்ளது. இந்த அட்டவணைகள் எளிமை மற்றும் வேகத்திற்காக உயர்வாக டிநார்மலைஸ் செய்யப்பட்டுள்ளன.

எடுத்துக்காட்டு: `FactSales` என்ற அட்டவணையில் `DateKey`, `ProductKey`, `StoreKey`, `QuantitySold`, மற்றும் `TotalRevenue` போன்ற நெடுவரிசைகள் உள்ளன. அது `DimDate`, `DimProduct`, மற்றும் `DimStore` அட்டவணைகளால் சூழப்பட்டிருக்கும்.

ஸ்னோஃப்ளேக் ஸ்கீமா என்பது ஸ்டார் ஸ்கீமாவின் ஒரு நீட்டிப்பாகும், இதில் பரிமாண அட்டவணைகள் பல தொடர்புடைய அட்டவணைகளாக நார்மலைஸ் செய்யப்படுகின்றன. எடுத்துக்காட்டாக, `DimProduct` அட்டவணை `DimProduct`, `DimBrand`, மற்றும் `DimCategory` அட்டவணைகளாக பிரிக்கப்படலாம்.

பரிந்துரை: ஒரு ஸ்டார் ஸ்கீமாவுடன் தொடங்கவும். வினவல்கள் எளிமையானவை (குறைந்த இணைப்புகள்), மற்றும் நவீன நெடுவரிசை தரவுத்தளங்கள் அகலமான, டிநார்மலைஸ் செய்யப்பட்ட அட்டவணைகளைக் கையாள்வதில் மிகவும் திறமையானவை, இதனால் ஸ்னோஃப்ளேக் ஸ்கீமாக்களின் சேமிப்பக நன்மைகள் கூடுதல் இணைப்புகளின் செயல்திறன் செலவுடன் ஒப்பிடும்போது பெரும்பாலும் அற்பமானவை.

படி 2: பைத்தானில் ETL/ELT பைப்லைனை உருவாக்குதல்

ETL செயல்முறை உங்கள் டேட்டா வேர்ஹவுஸிற்கு உணவளிக்கும் முதுகெலும்பாகும். இது மூல அமைப்புகளிலிருந்து தரவைப் பிரித்தெடுத்தல், அதை ஒரு சுத்தமான மற்றும் சீரான வடிவமாக மாற்றுதல், மற்றும் உங்கள் பகுப்பாய்வு மாதிரியில் ஏற்றுதல் ஆகியவற்றை உள்ளடக்கியது.

பாண்டாஸைப் பயன்படுத்தி ஒரு எளிய பைத்தான் ஸ்கிரிப்ட் மூலம் இதை விளக்குவோம். நம்மிடம் மூல ஆர்டர்களின் ஒரு CSV கோப்பு இருப்பதாக கற்பனை செய்து கொள்ளுங்கள்.

# பைத்தான் மற்றும் பாண்டாஸ் பயன்படுத்தி ஒரு எளிமைப்படுத்தப்பட்ட ETL எடுத்துக்காட்டு

import pandas as pd

# --- பிரித்தெடுத்தல் (EXTRACT) ---
print("மூல ஆர்டர் தரவைப் பிரித்தெடுக்கிறது...")
source_df = pd.read_csv('raw_orders.csv')

# --- மாற்றுதல் (TRANSFORM) ---
print("தரவை மாற்றுகிறது...")

# 1. தரவை சுத்தம் செய்தல்
source_df['order_date'] = pd.to_datetime(source_df['order_date'])
source_df['product_price'] = pd.to_numeric(source_df['product_price'], errors='coerce')
source_df.dropna(inplace=True)

# 2. தரவை செறிவூட்டுதல் - ஒரு தனி தேதி பரிமாணத்தை உருவாக்குதல்
dim_date = pd.DataFrame({
    'DateKey': source_df['order_date'].dt.strftime('%Y%m%d').astype(int),
    'Date': source_df['order_date'].dt.date,
    'Year': source_df['order_date'].dt.year,
    'Quarter': source_df['order_date'].dt.quarter,
    'Month': source_df['order_date'].dt.month,
    'DayOfWeek': source_df['order_date'].dt.day_name()
}).drop_duplicates().reset_index(drop=True)

# 3. ஒரு தயாரிப்பு பரிமாணத்தை உருவாக்குதல்
dim_product = source_df[['product_id', 'product_name', 'category']].copy()
dim_product.rename(columns={'product_id': 'ProductKey'}, inplace=True)
dim_product.drop_duplicates(inplace=True).reset_index(drop=True)

# 4. ஃபேக்ட் டேபிளை உருவாக்குதல்
fact_sales = source_df.merge(dim_date, left_on=source_df['order_date'].dt.date, right_on='Date')\
                      .merge(dim_product, left_on='product_id', right_on='ProductKey')

fact_sales = fact_sales[['DateKey', 'ProductKey', 'order_id', 'quantity', 'product_price']]
fact_sales['TotalRevenue'] = fact_sales['quantity'] * fact_sales['product_price']
fact_sales.rename(columns={'order_id': 'OrderCount'}, inplace=True)

# விரும்பிய நிலைக்கு ஒருங்கிணைத்தல்
fact_sales = fact_sales.groupby(['DateKey', 'ProductKey']).agg(
    TotalRevenue=('TotalRevenue', 'sum'),
    TotalQuantity=('quantity', 'sum')
).reset_index()

# --- ஏற்றுதல் (LOAD) ---
print("இலக்கு சேமிப்பகத்தில் தரவை ஏற்றுகிறது...")
# இந்த எடுத்துக்காட்டிற்கு, நாம் பார்குவேட் கோப்புகளில் சேமிப்போம், இது ஒரு மிகவும் திறமையான நெடுவரிசை வடிவமாகும்
dim_date.to_parquet('warehouse/dim_date.parquet')
dim_product.to_parquet('warehouse/dim_product.parquet')
fact_sales.to_parquet('warehouse/fact_sales.parquet')

print("ETL செயல்முறை முடிந்தது!")

இந்த எளிய ஸ்கிரிப்ட் முக்கிய தர்க்கத்தை நிரூபிக்கிறது. ஒரு நிஜ உலக சூழ்நிலையில், நீங்கள் இந்த தர்க்கத்தை செயல்பாடுகளுக்குள் வைத்து, அதன் செயல்பாட்டை Airflow போன்ற ஒரு ஒருங்கிணைப்பாளர் மூலம் நிர்வகிப்பீர்கள்.

படி 3: OLAP இயந்திரத்தைத் தேர்ந்தெடுத்து செயல்படுத்துதல்

உங்கள் தரவு மாதிரியாக்கப்பட்டு ஏற்றப்பட்டவுடன், OLAP செயல்பாடுகளைச் செய்ய உங்களுக்கு ஒரு இயந்திரம் தேவை. பைத்தான் உலகில், உங்களிடம் பல சக்திவாய்ந்த விருப்பங்கள் உள்ளன, அவை முதன்மையாக ROLAP அணுகுமுறையைப் பின்பற்றுகின்றன.

அணுகுமுறை A: இலகுரக சக்திநிலையம் - DuckDB

DuckDB என்பது ஒரு இன்-பிராசஸ் பகுப்பாய்வு தரவுத்தளமாகும், இது நம்பமுடியாத அளவிற்கு வேகமானது மற்றும் பைத்தானுடன் பயன்படுத்த எளிதானது. இது பாண்டாஸ் டேட்டாஃபிரேம்கள் அல்லது பார்குவேட் கோப்புகளை SQL ஐப் பயன்படுத்தி நேரடியாக வினவ முடியும். இது சிறிய மற்றும் நடுத்தர அளவிலான OLAP அமைப்புகள், முன்மாதிரிகள் மற்றும் உள்ளூர் மேம்பாட்டிற்கு சரியான தேர்வாகும்.

இது ஒரு உயர்-செயல்திறன் ROLAP இயந்திரமாக செயல்படுகிறது. நீங்கள் நிலையான SQL எழுதுகிறீர்கள், மற்றும் DuckDB அதை உங்கள் தரவுக் கோப்புகளில் தீவிர வேகத்துடன் செயல்படுத்துகிறது.

import duckdb

# நினைவகத்தில் உள்ள தரவுத்தளத்துடன் அல்லது ஒரு கோப்புடன் இணைக்கவும்
con = duckdb.connect(database=':memory:', read_only=False)

# நாம் முன்பு உருவாக்கிய பார்குவேட் கோப்புகளை நேரடியாக வினவவும்
# DuckDB ஸ்கீமாவை தானாகவே புரிந்துகொள்கிறது
result = con.execute("""
SELECT
    p.category,
    d.Year,
    SUM(f.TotalRevenue) AS AnnualRevenue
FROM 'warehouse/fact_sales.parquet' AS f
JOIN 'warehouse/dim_product.parquet' AS p ON f.ProductKey = p.ProductKey
JOIN 'warehouse/dim_date.parquet' AS d ON f.DateKey = d.DateKey
WHERE p.category = 'Electronics'
GROUP BY p.category, d.Year
ORDER BY d.Year;
""").fetchdf() # fetchdf() ஒரு பாண்டாஸ் டேட்டாஃபிரேமை வழங்குகிறது

print(result)

அணுகுமுறை B: கிளவுட்-ஸ்கேல் டைட்டன்ஸ் - Snowflake, BigQuery, Redshift

பெரிய அளவிலான நிறுவன அமைப்புகளுக்கு, ஒரு கிளவுட் டேட்டா வேர்ஹவுஸ் நிலையான தேர்வாகும். பைத்தான் இந்த தளங்களுடன் தடையின்றி ஒருங்கிணைக்கிறது. உங்கள் ETL செயல்முறை கிளவுட் DWH-க்குள் தரவை ஏற்றும், மற்றும் உங்கள் பைத்தான் பயன்பாடு (எ.கா., ஒரு BI டாஷ்போர்டு அல்லது ஒரு ஜுபிடர் நோட்புக்) அதை வினவும்.

தர்க்கம் DuckDB-யுடன் போலவே உள்ளது, ஆனால் இணைப்பு மற்றும் அளவு வேறுபட்டவை.

import snowflake.connector

# ஸ்னோஃப்ளேக்குடன் இணைத்து ஒரு வினவலை இயக்குவதற்கான எடுத்துக்காட்டு
conn = snowflake.connector.connect(
    user='your_user',
    password='your_password',
    account='your_account_identifier'
)

cursor = conn.cursor()

try:
    cursor.execute("USE WAREHOUSE MY_WH;")
    cursor.execute("USE DATABASE MY_DB;")
    cursor.execute("""
        SELECT category, YEAR(date), SUM(total_revenue)
        FROM fact_sales 
        JOIN dim_product ON ...
        JOIN dim_date ON ...
        GROUP BY 1, 2;
    """)
    # தேவைக்கேற்ப முடிவுகளைப் பெறவும்
    for row in cursor:
        print(row)
finally:
    cursor.close()
    conn.close()

அணுகுமுறை C: நிகழ்நேர வல்லுநர்கள் - Apache Druid அல்லது ClickHouse

பெரிய, ஸ்ட்ரீமிங் தரவுத்தொகுப்புகளில் துணை-வினாடி வினவல் தாமதம் தேவைப்படும் பயன்பாட்டு நிகழ்வுகளுக்கு (நிகழ்நேர பயனர் பகுப்பாய்வு போன்றவை), Druid அல்லது ClickHouse போன்ற சிறப்பு தரவுத்தளங்கள் சிறந்த தேர்வுகளாகும். அவை OLAP பணிச்சுமைகளுக்காக வடிவமைக்கப்பட்ட நெடுவரிசை தரவுத்தளங்கள். பைத்தான் அவற்றுக்குள் தரவை ஸ்ட்ரீம் செய்வதற்கும், அவற்றின் தொடர்புடைய கிளையன்ட் நூலகங்கள் அல்லது HTTP APIகள் வழியாக வினவுவதற்கும் பயன்படுத்தப்படுகிறது.

பகுதி 4: ஒரு நடைமுறை எடுத்துக்காட்டு - ஒரு மினி OLAP அமைப்பை உருவாக்குதல்

இந்தக் கருத்துக்களை ஒரு மினி-திட்டத்தில் இணைப்போம்: ஒரு ஊடாடும் விற்பனை டாஷ்போர்டு. இது ஒரு முழுமையான, எளிமைப்படுத்தப்பட்டாலும், பைத்தான் அடிப்படையிலான OLAP அமைப்பை நிரூபிக்கிறது.

நமது ஸ்டாக்:

• ETL: பைத்தான் மற்றும் பாண்டாஸ்
• தரவு சேமிப்பு: பார்குவேட் கோப்புகள்
• OLAP இயந்திரம்: DuckDB
• டாஷ்போர்டு: Streamlit (டேட்டா சயின்ஸிற்காக அழகான, ஊடாடும் வலை பயன்பாடுகளை உருவாக்குவதற்கான ஒரு திறந்த மூல பைத்தான் நூலகம்)

முதலில், பகுதி 3-லிருந்து ETL ஸ்கிரிப்டை இயக்கி ஒரு `warehouse/` கோப்பகத்தில் பார்குவேட் கோப்புகளை உருவாக்கவும்.

அடுத்து, `app.py` என்ற டாஷ்போர்டு பயன்பாட்டுக் கோப்பை உருவாக்கவும்:

# app.py - ஒரு எளிய ஊடாடும் விற்பனை டாஷ்போர்டு

import streamlit as st
import duckdb
import pandas as pd
import plotly.express as px

# --- பக்க கட்டமைப்பு ---
st.set_page_config(layout="wide", page_title="Global Sales Dashboard")
st.title("Interactive Sales OLAP Dashboard")

# --- DuckDB உடன் இணைக்கவும் ---
# இது நமது பார்குவேட் கோப்புகளை நேரடியாக வினவும்
con = duckdb.connect(database=':memory:', read_only=True)

# --- வடிப்பான்களுக்கான பரிமாணத் தரவை ஏற்றவும் ---
@st.cache_data
def load_dimensions():
    products = con.execute("SELECT DISTINCT category FROM 'warehouse/dim_product.parquet'").fetchdf()
    years = con.execute("SELECT DISTINCT Year FROM 'warehouse/dim_date.parquet' ORDER BY Year").fetchdf()
    return products['category'].tolist(), years['Year'].tolist()

categories, years = load_dimensions()

# --- வடிப்பான்களுக்கான பக்கப்பட்டி (ஸ்லைசிங் மற்றும் டைசிங்!) ---
st.sidebar.header("OLAP Filters")

selected_categories = st.sidebar.multiselect(
    'Select Product Categories',
    options=categories,
    default=categories
)

selected_year = st.sidebar.selectbox(
    'Select Year',
    options=years,
    index=len(years)-1 # சமீபத்திய ஆண்டிற்கு இயல்பாக அமைக்கவும்
)

# --- OLAP வினவலை டைனமிக்காக உருவாக்கவும் ---
if not selected_categories:
    st.warning("Please select at least one category.")
    st.stop()

query = f"""
SELECT
    d.Month,
    d.MonthName, -- DimDate இல் MonthName இருப்பதாகக் கருதி
    p.category,
    SUM(f.TotalRevenue) AS Revenue
FROM 'warehouse/fact_sales.parquet' AS f
JOIN 'warehouse/dim_product.parquet' AS p ON f.ProductKey = p.ProductKey
JOIN 'warehouse/dim_date.parquet' AS d ON f.DateKey = d.DateKey
WHERE d.Year = {selected_year}
  AND p.category IN ({str(selected_categories)[1:-1]})
GROUP BY d.Month, d.MonthName, p.category
ORDER BY d.Month;
"""

# --- வினவலை இயக்கி முடிவுகளைக் காட்டவும் ---
@st.cache_data
def run_query(_query):
    return con.execute(_query).fetchdf()

results_df = run_query(query)

if results_df.empty:
    st.info(f"No data found for the selected filters in year {selected_year}.")
else:
    # --- முதன்மை டாஷ்போர்டு காட்சிகள் ---
    col1, col2 = st.columns(2)

    with col1:
        st.subheader(f"Monthly Revenue for {selected_year}")
        fig = px.line(
            results_df,
            x='MonthName',
            y='Revenue',
            color='category',
            title='Monthly Revenue by Category'
        )
        st.plotly_chart(fig, use_container_width=True)

    with col2:
        st.subheader("Revenue by Category")
        category_summary = results_df.groupby('category')['Revenue'].sum().reset_index()
        fig_pie = px.pie(
            category_summary,
            names='category',
            values='Revenue',
            title='Total Revenue Share by Category'
        )
        st.plotly_chart(fig_pie, use_container_width=True)

    st.subheader("Detailed Data")
    st.dataframe(results_df)

இதை இயக்க, குறியீட்டை `app.py` ஆக சேமித்து, உங்கள் டெர்மினலில் `streamlit run app.py` என இயக்கவும். இது உங்கள் ஊடாடும் டாஷ்போர்டுடன் ஒரு வலை உலாவியைத் தொடங்கும். பக்கப்பட்டியில் உள்ள வடிப்பான்கள் பயனர்களை OLAP 'ஸ்லைசிங்' மற்றும் 'டைசிங்' செயல்பாடுகளைச் செய்ய அனுமதிக்கின்றன, மேலும் டாஷ்போர்டு DuckDB-ஐ மீண்டும் வினவுவதன் மூலம் நிகழ்நேரத்தில் புதுப்பிக்கப்படுகிறது.

பகுதி 5: மேம்பட்ட தலைப்புகள் மற்றும் சிறந்த நடைமுறைகள்

நீங்கள் ஒரு மினி-திட்டத்திலிருந்து ஒரு உற்பத்தி அமைப்புக்குச் செல்லும்போது, இந்த மேம்பட்ட தலைப்புகளைக் கருத்தில் கொள்ளுங்கள்.

அளவிடுதல் மற்றும் செயல்திறன்

• பெரிய ETL-க்கு Dask-ஐப் பயன்படுத்தவும்: உங்கள் மூலத் தரவு உங்கள் கணினியின் RAM-ஐ விட அதிகமாக இருந்தால், உங்கள் ETL ஸ்கிரிப்டுகளில் பாண்டாஸை Dask உடன் மாற்றவும். API மிகவும் ஒத்திருக்கிறது, ஆனால் Dask கோர்-க்கு வெளியே மற்றும் இணை செயலாக்கத்தைக் கையாளும்.
• நெடுவரிசை சேமிப்பகம் முக்கியம்: உங்கள் கிடங்குத் தரவை எப்போதும் அப்பாச்சி பார்குவேட் அல்லது ORC போன்ற ஒரு நெடுவரிசை வடிவத்தில் சேமிக்கவும். இது பகுப்பாய்வு வினவல்களை வியத்தகு முறையில் வேகப்படுத்துகிறது, அவை பொதுவாக ஒரு பரந்த அட்டவணையில் இருந்து சில நெடுவரிசைகளை மட்டுமே படிக்க வேண்டும்.
• பிரித்தல் (Partitioning): ஒரு தரவுக் குளத்தில் (S3 அல்லது ஒரு உள்ளூர் கோப்பு முறைமை போன்றவை) தரவைச் சேமிக்கும்போது, உங்கள் தரவை தேதி போன்ற அடிக்கடி வடிகட்டப்படும் பரிமாணத்தின் அடிப்படையில் கோப்புறைகளாக பிரிக்கவும். எடுத்துக்காட்டாக: `warehouse/fact_sales/year=2023/month=12/`. இது வினவல் இயந்திரங்கள் பொருத்தமற்ற தரவைப் படிப்பதைத் தவிர்க்க அனுமதிக்கிறது, இந்த செயல்முறை 'பார்ட்டிஷன் புரூனிங்' என்று அழைக்கப்படுகிறது.

செமாண்டிக் லேயர்

உங்கள் அமைப்பு வளரும்போது, 'செயலில் உள்ள பயனர்' அல்லது 'மொத்த மார்ஜின்' போன்ற வணிக தர்க்கம் பல வினவல்கள் மற்றும் டாஷ்போர்டுகளில் மீண்டும் மீண்டும் வருவதைக் காண்பீர்கள். ஒரு செமாண்டிக் லேயர் உங்கள் வணிக அளவீடுகள் மற்றும் பரிமாணங்களின் மையப்படுத்தப்பட்ட, சீரான வரையறையை வழங்குவதன் மூலம் இதைத் தீர்க்கிறது. dbt (Data Build Tool) போன்ற கருவிகள் இதற்கு விதிவிலக்கானவை. இது ஒரு பைத்தான் கருவி இல்லையென்றாலும், dbt ஒரு பைத்தான்-ஒருங்கிணைக்கப்பட்ட பணிப்பாய்வுக்குள் hoàn hảoமாக ஒருங்கிணைக்கிறது. உங்கள் ஸ்டார் ஸ்கீமாவை மாதிரியாக்கவும், அளவீடுகளை வரையறுக்கவும் dbt-ஐப் பயன்படுத்துகிறீர்கள், பின்னர் dbt ரன்களை ஒருங்கிணைக்கவும், அதன் விளைவாக வரும் சுத்தமான அட்டவணைகளில் மேம்பட்ட பகுப்பாய்வு செய்யவும் பைத்தானைப் பயன்படுத்தலாம்.

தரவு ஆளுமை மற்றும் தரம்

ஒரு கிடங்கு அதனுள் இருக்கும் தரவைப் போலவே சிறந்தது. உங்கள் பைத்தான் ETL பைப்லைன்களில் நேரடியாக தரவுத் தர சோதனைகளை ஒருங்கிணைக்கவும். Great Expectations போன்ற நூலகங்கள் உங்கள் தரவைப் பற்றிய 'எதிர்பார்ப்புகளை' வரையறுக்க உங்களை அனுமதிக்கின்றன (எ.கா., `customer_id` ஒருபோதும் பூஜ்யமாக இருக்கக்கூடாது, `revenue` 0 மற்றும் 1,000,000 க்கு இடையில் இருக்க வேண்டும்). உங்கள் ETL வேலை பின்னர் இந்த ஒப்பந்தங்களை மீறும் உள்வரும் தரவு இருந்தால் தோல்வியடையலாம் அல்லது உங்களை எச்சரிக்கலாம், இது மோசமான தரவு உங்கள் கிடங்கை சிதைப்பதைத் தடுக்கிறது.

முடிவுரை: குறியீடு-முதல் அணுகுமுறையின் சக்தி

பைத்தான் டேட்டா வேர்ஹவுசிங் மற்றும் பிசினஸ் இன்டலிஜென்ஸ் ஆகியவற்றின் நிலப்பரப்பை அடிப்படையில் மாற்றியுள்ளது. இது அதிநவீன பகுப்பாய்வு அமைப்புகளை அடிமட்டத்திலிருந்து உருவாக்குவதற்கான ஒரு நெகிழ்வான, சக்திவாய்ந்த மற்றும் விற்பனையாளர்-நடுநிலை கருவித்தொகுப்பை வழங்குகிறது. பாண்டாஸ், டாஸ்க், SQLAlchemy, மற்றும் DuckDB போன்ற சிறந்த நூலகங்களை இணைப்பதன் மூலம், நீங்கள் அளவிடக்கூடிய மற்றும் பராமரிக்கக்கூடிய ஒரு முழுமையான OLAP அமைப்பை உருவாக்க முடியும்.

இந்தப் பயணம் ஸ்டார் ஸ்கீமா போன்ற தரவு மாடலிங் கொள்கைகளைப் பற்றிய உறுதியான புரிதலுடன் தொடங்குகிறது. அங்கிருந்து, உங்கள் தரவை வடிவமைக்க வலுவான ETL பைப்லைன்களை உருவாக்கலாம், உங்கள் அளவிற்கு சரியான வினவல் இயந்திரத்தைத் தேர்வு செய்யலாம், மேலும் ஊடாடும் பகுப்பாய்வு பயன்பாடுகளைக் கூட உருவாக்கலாம். இந்த குறியீடு-முதல் அணுகுமுறை, பெரும்பாலும் 'நவீன தரவு அடுக்கு' என்பதன் முக்கிய கோட்பாடாக உள்ளது, இது பகுப்பாய்வின் சக்தியை நேரடியாக டெவலப்பர்கள் மற்றும் தரவுக் குழுக்களின் கைகளில் வைக்கிறது, இது அவர்களின் நிறுவனத்தின் தேவைகளுக்கு ஏற்றவாறு அமைப்புகளை உருவாக்க உதவுகிறது.