Data Warehouse mit PostgreSQL in Python für Data Scientists

Dieser Beitrag wurde im Rahmen der . veröffentlicht Data Science Blogathon

Einführung

Datawarehouse verallgemeinert und mischt Daten in einem mehrdimensionalen Raum. Der Aufbau oder die Struktur eines Data Warehouse beinhaltet eine Datenbereinigung, Datenintegration und Datentransformation, und kann als angesehen werden “Vorverarbeitungsschritt wichtig für Data Mining”.

Zur selben Zeit, Data Warehouses bieten analytische Online-Verarbeitung (namens OLAP) Tools zur interaktiven Analyse mehrdimensionaler Daten unterschiedlicher Granularität, Ermöglichung eines effektiven Data Mining und der Generalisierung. Es gibt viele andere Data-Mining-Funktionen, als Verein,
Einstufung, Vorhersage und Clustering, die in OLAP-Operationen integriert werden können, um die interaktive Wissensextraktion zu fördern.

Aus diesem Grund ist das Data Warehouse zu einer wichtigen skalierten Plattform für Datenanalyse und OLAP geworden.. Das Data Warehouse wird eine konstruktive Plattform für Data Mining bieten. Deswegen, Data Warehousing und OLAP bilden einen wesentlichen Schritt im Knowledge Discovery-Verfahren (KDD). Dies ist der Überblick, der für das Verständnis der allgemeinen Vorgehensweise von Data Mining und Knowledge Discovery unerlässlich ist.

Lassen Sie uns nun das Grundkonzept des Data Warehouse verstehen.

Grundkonzept des Data Warehouse:

Data Warehousing bietet Architekturen und Tools, die Geschäftsleute organisieren können, diese Daten systematisch verstehen und nutzen, um strategische Entscheidungen zu treffen. Data-Warehousing-Systeme sind nützliche Werkzeuge in der heutigen wettbewerbsorientierten und sich schnell entwickelnden Welt.. Seit den letzten Jahren, viele Unternehmen und Branchen haben viele Millionen Dollar für den Aufbau unternehmensweiter Data Warehouses ausgegeben.

“Dann, Was genau ist ein Data Warehouse??” Allgemein gesagt, Ein Data Warehouse bezieht sich auf ein Datenarchiv, das getrennt von den operativen Datenbanken einer Organisation verwaltet wird. Data Warehouses ermöglichen die Integration verschiedener Anwendungssysteme. Die vier Stichworte (fokussiert auf das Thema, integriert, zeitvariabel und nichtflüchtig) Data Warehouses von anderen Datenspeichersystemen unterscheiden, Was
relationale DatenbanksystemeRDBMS), Transaktionsverarbeitungssysteme und andere Dateisysteme.

Es gibt drei Schlüssel zur Implementierung eines Data Warehouse:

– Server

– Planke

– Indizierung

Lassen Sie uns all diese Punkte im Detail analysieren: –

1) Server:

Postgre-SQL

“Postgre-SQL” ist ein relationales Open-Source-Datenbanksystem (RDMS). Obwohl es sich um ein strukturiertes Datenbankverwaltungssystem handelt (DBMS), speichert auch unstrukturierte Daten. Am wichtigsten ist, dass die Postgre SQL-GUI die Bereitstellung und Verwaltung von Datenbanken beim Einhängen sehr einfach macht..

vor dem Fortfahren, Sie müssen Postgres über den Link herunterladen und installieren PostgreSQL.

Nach Abschluss der Installation, Sie können sich beim Server anmelden, indem Sie die Anwendung ausführen, die ein Portal in Ihrem pgadmin-Browser öffnet.

Es gibt eine Standarddatenbank mit der Bezeichnung Postgre, trotz dieses, Sie können Ihre eigene Datenbank erstellen, indem Sie mit der rechten Maustaste auf das “Datenbanken" Menü und wählen Sie dann “Erschaffen” um eine neue Datenbank zu erstellen.

2) Python-Implementierung

Jetzt haben wir unseren Server und unsere Datenbank erstellt, Sie müssen zuerst das Paket namens . installieren “sqlalchemie ” um über Python eine Verbindung zur Datenbank herzustellen. Zusätzlich können Sie dieses Paket herunterladen und installieren, indem Sie den folgenden Befehl an der Anaconda-Eingabeaufforderung verwenden, z-

pip installieren sqlalchemy

Lassen Sie uns andere unverzichtbare Bibliotheken im Python-Skript wie folgt installieren und importieren:

from sqlalchemy import create_engine
import psycopg2
import pandas as pd
import streamlit as st

Jetzt, Wir müssen einen Zusammenhang zwischen unseren “records_db " Datenbank und erstellen Sie eine neue Tabelle, in der wir unsere Datensätze speichern können. Zur selben Zeit, Wir müssen eine weitere Verbindung mit der “datasets_db ” Datenbank, in der wir unsere Datensätze speichern können.

p_engine = create_engine("PostgreSQL://<Nutzername>:<Passwort>@localhost:5432/records_db")
p_engine_dataset = create_engine("PostgreSQL://<Nutzername>:<Passwort>@localhost:5432/datasets_db")
p_engine.execute("CREATE TABLE IF NOT EXISTS Datensätze (Namenstext PRIMÄRSCHLÜSSEL, Detailtext[])")

Wie wir die Postegre-Namenskonvention kennen, Tabellennamen müssen mit Unterstrichen beginnen (_) oder Liedtexte ("bis, B, c" und keine Zahlen), darf keine Bindestriche enthalten (-) und haben weniger als 64 Figuren. Betrachten Sie unsere “Aufzeichnungen” Tisch, Wir werden eine “Name” Feld mit einem “Text” Art der Daten deklariert als PRIMÄRSCHLÜSSEL und ein Details Feld als Text[](Ausbildung) das ist die Postgres-Notation für eine eindimensionale Matrix. Zur selben Zeit, Wenn Sie Ihre Datenbankanmeldeinformationen sicher speichern möchten, Speichern Sie sie in einer Konfigurationsdatei, und rufen Sie sie dann als Parameter in Ihrem Code entsprechend Ihren Anforderungen auf.

Deswegen, Lassen Sie uns die folgenden fünf Funktionen erstellen, die zum Lesen gedacht sind, schreiben, aktualisieren, unsere Daten aufzulisten / aus unserer Datenbank. Wir werden sehen:-

def write_record(Name,Details,p_engine):
    p_engine.execute("IN DATENSÄTZE EINFÜGEN (Name,Details) WERTE ('%s','%s')" % (Name,Details))

def read_record(Feld,Name,p_engine):
    Ergebnis = p_engine.execute("WÄHLEN SIE %S AUS DATENSÄTZEN AUS, WOBEI NAME="%S"" % (Feld,Name))
    return result.first()[0]
    
def update_record(Feld,Name,neuer Wert,p_engine):
    p_engine.execute("AKTUALISIEREN VON DATENSÄTZEN SATZ %S="%S" WOBEI Name="%S"" % (Feld,neuer Wert,Name))

def write_dataset(Name,Datensatz,p_engine):
    dataset.to_sql('%s' % (Name),p_engine,index=Falsch,if_exists="ersetzen",chunksize=1000)

read_dataset def(Name,p_engine):
    Versuchen:
        Datensatz = pd.read_sql_table(Name,p_engine)
    außer:
        Datensatz = PD. DataFrame([])
    return dataset

def list_datasets(p_engine):
    Datensätze = p_engine.execute("SELECT table_name FROM information_schema.tables WHERE table_schema="öffentlich" BESTELLEN NACH tabellenname;")
    Datensätze zurückgeben.fetchall()

3) Armaturenbrett:

Stromlit

“Stromlit” ist ein reines Python-Webframework, mit dem wir Benutzeroberflächen entwickeln und implementieren können (Benutzeroberfläche) und Echtzeitanwendungen. Hier verwenden wir Streamlit, um das Dashboard so zu rendern, dass es mit der Datenbank interagiert.

Im unten gezeigten Code, Wir verwenden verschiedene Texteingaben, um die Werte in unsere Datensätze einzufügen, Arrays und Namen für unsere Datensätze. Dann, Wir verwenden Streamlit-Funktionen, um unseren Datensatz interaktiv als Graph und auch als Datenrahmen zu visualisieren.

st.titel('Armaturenbrett')
Spalte_1, Spalte_2 = st.beta_Spalten(2)

mit Spalte_1:
    st.header('Datensätze speichern')
    name = st.text_input('Bitte Namen eingeben')
    details = st.text_input('Bitte geben Sie Ihre Daten ein (durch Komma getrennt ",")')
    Details = ('{%S}' % (Details))
    wenn st.taste('Datensatz in Datenbank speichern'):
        write_record(Name,Details,p_engine)
        st.info('Name: **%s** und Details: **%s** in Datenbank gespeichert' % (Name,Details[1:-1]))

    st.header('Datensätze aktualisieren')
    field = st.selectbox('Bitte Feld zum Aktualisieren auswählen',('Name','Einzelheiten'))
    name_key = st.text_input('Bitte geben Sie den Namen des zu aktualisierenden Datensatzes ein')    
    if Feld == 'Name':
        aktualisierter_name = st.text_input('Bitte geben Sie Ihren aktualisierten Namen ein')
        wenn st.taste('Datensätze aktualisieren'):
            update_record(Feld,name_key,aktualisierter_name,p_engine)
            st.info('Name im Datensatz **%s** auf **%s** aktualisiert' % (aktualisierter_name,name_key))                
    elif-Feld == 'Details':
        aktualisierte_details = st.text_input('Bitte aktualisierte Daten eingeben (durch Komma getrennt)')
        aktualisierte_details = ('{%S}' % (aktualisierte_details))  
        wenn st.taste('Datensätze aktualisieren'):
            update_record(Feld,name_key,aktualisierte_details,p_engine)
            st.info('Details zu **%s** im Datensatz **%s** aktualisiert' % (aktualisierte_details[1:-1],name_key))
            
    st.header('Datensätze lesen')
    record_to_read = st.text_input('Bitte geben Sie den Namen des zu lesenden Datensatzes ein')
    wenn st.taste('Suche'):
        read_name = read_record('Name',record_to_read,p_engine)
        read_details = read_record('Einzelheiten',record_to_read,p_engine)
        st.info('Datensatzname ist **%s**, Datensatzdetails sind **%s**' % (read_name,str(read_details)[1:-1]))

mit Spalte_2:
    st.header('Datensätze speichern')
    Datensatz = st.file_uploader('Bitte Datensatz hochladen')
    wenn Datensatz nicht None ist:
        Datensatz = pd.read_csv(Datensatz)
        dataset_name = st.text_input('Bitte Namen für Datensatz eingeben')
        wenn st.taste('Datensatz in Datenbank speichern'):
            write_dataset('%s' % (dataset_name),Datensatz,p_engine_dataset)
            st.info('**%s** in Datenbank gespeichert' % (dataset_name))

    Versuchen:
        read_title = st.leer()
        dataset_to_read = st.selectbox('Bitte Datensatz zum Lesen auswählen',([x[0] für x in list_datasets(p_engine_dataset)]))
        read_title.header('Datensätze lesen')
        wenn st.taste('Datensatz lesen'):
            df = read_dataset(dataset_to_read,p_engine_dataset)
            st.subheader('Diagramm')
            st.line_chart(df['Wert'])
            st.subheader('Datenrahmen')
            st.schreiben(df)    
    außer:
        passieren

Sie können Ihr Panel in einem lokalen Browser von Ihrem Computer aus ausführen, indem Sie die folgenden Befehle in eingeben Anakonda-Hinweis. Dann, erste, Sie sollten Ihr Stammverzeichnis an den Ort ändern, an dem Ihr Quellcode gespeichert wurde.

CDC:BenutzerIhr Verzeichnispfad...

Jetzt führen wir den folgenden Code aus, um unsere Anwendung auszuführen …

Streamlit-Lauf file_name.py

Endergebnis

Beenden, Wir haben eine Tafel, die zum Schreiben verwendet werden kann, lesen, tokenizar, aktualisieren, Laden Sie unsere Daten in Echtzeit hoch und sehen Sie sie an. Wir sehen die Schönheit unseres Data Warehouse, das für den Benutzer erweitert werden kann / host haben so viele Daten, wie Sie innerhalb derselben Struktur benötigen.