ઉકેલી: પોસ્ટગ્રેસ માટે pandas Timedelta

ડેટા વિશ્લેષણની દુનિયામાં, સમય શ્રેણીના ડેટાને હેન્ડલ કરવું એ એક નિર્ણાયક પાસું છે. આ હેતુ માટે સૌથી વધુ ઉપયોગમાં લેવાતી લાઇબ્રેરીઓમાંની એક પાયથોન પ્રોગ્રામિંગ ભાષામાં **પાંડા** છે. સમય શ્રેણીના ડેટા સાથે કામ કરતી વખતે એક સામાન્ય કાર્ય એ વિવિધ ઇવેન્ટ્સ વચ્ચેના સમયના તફાવતોને પ્રમાણભૂત ફોર્મેટમાં રૂપાંતરિત કરવાનું છે. આ તે છે જ્યાં પાંડા ટાઇમડેલ્ટા હાથમાં આવે છે. જો કે, પોસ્ટગ્રેએસક્યુએલ જેવા ડેટાબેઝ સાથે કામ કરતી વખતે, આ ટાઇમડેલ્ટાને સંગ્રહિત કરવું થોડું મુશ્કેલ હોઈ શકે છે. આ લેખમાં, અમે પંડા ટાઇમડેલ્ટાને પોસ્ટગ્રેએસક્યુએલમાં સંગ્રહિત કરી શકાય તેવા ફોર્મેટમાં કેવી રીતે રૂપાંતરિત કરવું તેની ચર્ચા કરીશું અને તેની સાચી રજૂઆત જાળવી રાખીને તેને પુનઃપ્રાપ્ત કરીશું.

સમસ્યાનો ઉકેલ

આ સમસ્યાના ઉકેલમાં pandas અને psycopg2 પુસ્તકાલયોનો ઉપયોગ સામેલ છે, જે અનુક્રમે ડેટા મેનીપ્યુલેશન અને PostgreSQL ડેટાબેઝ મેનેજમેન્ટ માટે વ્યાપકપણે ઉપયોગમાં લેવાય છે. psycopg2 લાઇબ્રેરીમાં PostgreSQL માં `ઇન્ટરવલ` ડેટા પ્રકારનો ઉપયોગ કરીને ટાઇમડેલ્ટાને હેન્ડલ કરવા માટે સપોર્ટ છે. અમે અમારા પંડા ટાઇમડેલ્ટાને PostgreSQL માં સ્ટોર કરવા માટે આ સુવિધાનો લાભ લઈશું અને તેને તેના યોગ્ય ફોર્મેટમાં પાછું મેળવીશું.

પ્રથમ, ચાલો જરૂરી લાઈબ્રેરીઓ આયાત કરીએ અને અમારા PostgreSQL ડેટાબેઝ સાથે જોડાણ સ્થાપિત કરીએ.

import pandas as pd
import psycopg2

conn = psycopg2.connect(database="your_database",
                        user="your_user",
                        password="your_password",
                        host="your_host",
                        port="your_port")

pandas Timedelta અને PostgreSQL અંતરાલ

pandas Timedelta એ સમયના તફાવતોને સુસંગત અને વાંચી શકાય તેવી રીતે વ્યક્ત કરવા માટેનું એક શક્તિશાળી સાધન છે. પાંડામાં ટાઇમડેલ્ટા ઑબ્જેક્ટ્સ બનાવવાનું અને તેની હેરફેર કરવી સરળ છે, પરંતુ જ્યારે તેને PostgreSQL ડેટાબેઝમાં સ્ટોર કરવાની વાત આવે છે, ત્યારે આપણે તેને યોગ્ય ફોર્મેટમાં કન્વર્ટ કરવાની જરૂર છે.

PostgreSQL સમય અંતરાલોને સંગ્રહિત કરવા માટે `અંતરાલ` ડેટા પ્રકાર ઓફર કરે છે. આ ડેટા પ્રકાર દિવસો, કલાકો, મિનિટો અને સેકંડ જેવા વિવિધ ગ્રેન્યુલારિટીમાં સમયગાળો રજૂ કરી શકે છે. પોસ્ટગ્રેએસક્યુએલ ડેટાબેઝમાં પાંડા ટાઇમડેલ્ટાને સ્ટોર કરવા માટે, આપણે તેને પોસ્ટગ્રેએસક્યુએલ અંતરાલમાં રૂપાંતરિત કરવાની જરૂર છે.

ચાલો ટાઈમડેલ્ટા કૉલમ સાથે નમૂના પાંડા ડેટાફ્રેમ બનાવીએ:

data = {'event_name': ['start', 'end'],
        'time': [pd.Timestamp('2021-01-01'), pd.Timestamp('2021-01-03')]}
df = pd.DataFrame(data)
df['difference'] = df['time'].diff()
print(df)

હવે આ ડેટાને અમારા PostgreSQL ડેટાબેઝમાં દાખલ કરવા માટે એક ફંક્શન બનાવીએ અને Timedelta ડેટાને PostgreSQL-સુસંગત અંતરાલમાં કન્વર્ટ કરીએ.

def insert_data(event_name, time, difference, conn):
    query = """
    INSERT INTO timedeltas (event_name, time, difference)
    VALUES (%s, %s, %s)
    """
    with conn.cursor() as cur:
        cur.execute(query, (event_name, time, difference))
    conn.commit()

આ ફંક્શનનો ઉપયોગ કરીને, અમે પોસ્ટગ્રેએસક્યુએલ ડેટાબેઝમાં અમારા પાંડા ડેટાફ્રેમ ડેટા દાખલ કરી શકીએ છીએ:

for _, row in df.iterrows():
    event_name, time, difference = row['event_name'], row['time'], row['difference']
    insert_data(event_name, time, difference, conn)

PostgreSQL માંથી Timedeltas પુનઃપ્રાપ્ત કરી રહ્યા છીએ

એકવાર pandas Timedelta ડેટા અંતરાલો તરીકે PostgreSQL માં સંગ્રહિત થઈ જાય, અમે તેને સરળતાથી પુનઃપ્રાપ્ત કરી શકીએ છીએ અને ડેટા વાંચતી વખતે તેને પાંડા Timedeltas માં રૂપાંતરિત કરી શકીએ છીએ.

ચાલો આપણા PostgreSQL ટેબલમાંથી ડેટા મેળવવા માટે એક ફંક્શન બનાવીએ:

def fetch_data(conn):
    query = "SELECT event_name, time, difference FROM timedeltas"
    data = pd.read_sql(query, conn)
    data['difference'] = pd.to_timedelta(data['difference'])
    return data

આ ફંક્શન સાથે, અમે અમારા PostgreSQL ડેટાબેઝમાંથી ડેટા મેળવી અને પ્રિન્ટ કરી શકીએ છીએ:

result = fetch_data(conn)
print(result)

PostgreSQL માંથી મેળવેલ ડેટા હવે તેના Timedeltas ને યોગ્ય રીતે pandas Timedeltas તરીકે રજૂ કરે છે.

નિષ્કર્ષમાં, pandas Timedelta ને PostgreSQL સ્ટોરેજ માટે યોગ્ય ફોર્મેટમાં રૂપાંતરિત કરવું અને તેને તેના મૂળ સ્વરૂપમાં પુનઃપ્રાપ્ત કરવું એ એક સીધી પ્રક્રિયા છે. શક્તિશાળી પાંડા અને સાયકોપજી2 લાઇબ્રેરીઓનો લાભ લઈને, અમે સમય શ્રેણીના ડેટાને સરળતાથી હેન્ડલ કરી શકીએ છીએ અને અમારા ડેટા વિશ્લેષણ અને અમારા ડેટાબેઝ સ્ટોરેજ બંનેમાં તેની યોગ્ય રજૂઆત જાળવી શકીએ છીએ.