[PYTHON] Überprüfung der MemSQL-Verarbeitungskapazität (Anwendung 2)

Diesmal·····

In Anwendung 1 haben wir uns auf die Verbesserung der bei dieser Überprüfung verwendeten Umgebung konzentriert. Die endgültige SQL-Abfrageverarbeitung hat wie erwartet funktioniert, daher werden wir bei dieser Überprüfung die nachfolgende Verarbeitung überprüfen. Das ultimative Ziel ist ... (1) Zur gleichen Zeit wie die Datenerzeugungsseite (Feldarbeit) (2) Ohne das bestehende Datensystem neu zu belasten, das eng dimensioniert und an die Betriebsumgebung verwelkt ist. (3) Realisieren Sie die Nutzung von Echtzeitdaten über die Wände von Silos hinaus ... Ist es möglich? Bestätigen ...

Das Schlüsselwort lautet ** Gegenwart ändern und Zukunft schaffen **. Speichern und anziehen! Für Dinge, die von der Typverarbeitung nicht erkannt werden konnten, werden die erforderlichen Informationen automatisch in Echtzeit nach Ihren Wünschen vorbereitet und die kreative Datennutzung wird bei Bedarf realisiert ... Möglicherweise ein neues Formular Datengesteuert werden möglich sein.

Werfen Sie zunächst einfach nur die SQL-Abfrage wiederholt

Ich denke, dass es ein Basissystem in Bezug auf SQL ist, aber zuerst werde ich versuchen, die Aggregatfunktion nach Daten abzufragen, die einige Bedingungen erfüllen. (1) Führen Sie für jede Kategorie eine Aggregationsverarbeitung aus den automatisch generierten "Nanchatte-Verkaufsinformationen" durch. (2) Die Zielpräfekturen sind die Präfektur Osaka, die Metropolregion Tokio, die Präfektur Fukuoka, die Präfektur Aichi und die Präfektur Hokkaido. (3) Stellen Sie eine Abfrage an die Datenbanktabelle, die der Generator kontinuierlich einfügt, und überprüfen Sie das Ergebnis. Ich werde dorthin gehen.

Erstellen Sie einen Eilprozess. Die SQL-Anweisung ist absichtlich leicht lesbar (vorausgesetzt, das Muster wird später geändert), aber ich denke, wir können etwas effizienter entwickeln. Außerdem planen wir, zum nächsten und nachfolgenden Zeitpunkt die zu extrahierende Spalte auszuwählen und eine weitere neue Tabelle zu erstellen (vorausgesetzt, die interne Antwort wird für die Analyse verwendet). Schreiben Sie daher in diesem Prozess unter Berücksichtigung dieser Operation. Ich habe es aufgenommen.

 coding: utf-8

# Führen Sie Aufgaben in regelmäßigen Abständen in Python aus (Power-Technik-Version).
# Version 2.7


import sys
stdout = sys.stdout
reload(sys)
sys.setdefaultencoding('utf-8')
sys.stdout = stdout

# Modul zum Importieren
import schedule
import time


# Stellen Sie hier den Prozess so ein, dass er in regelmäßigen Abständen ausgeführt wird


def job():

 # Stellen Sie das diesmal zu verwendende Aggregationssystem SQL ein.
 # Ich teile es absichtlich, damit ich verschiedene Dinge ausprobieren kann ...
    SQL1 = "SELECT SUM(Units) AS Sum_of_Units, AVG(Payment) AS Avarage_of_Payment, "
    SQL2 = "MAX(Payment) AS Max_of_Payment, MIN(Payment) AS Min_of_Payment, Category "
    SQL3 = "FROM Qiita_Test "
 SQL4 = "WHERE Kategorie IN ('Schnaps', 'verschiedene Waren', 'Bücher', 'Haushaltsgeräte', 'DVD / CD')"
 SQL5 = "UND Präfektur IN ('Präfektur Osaka', 'Präfektur Tokio', 'Präfektur Fukuoka', 'Präfektur Aichi', 'Hokkaido')"
    SQL6 = "GROUP BY Category"
    SQL_Data = SQL1 + SQL2 + SQL3 + SQL4 + SQL5 + SQL6
       
 # Verarbeitung starten
    from datetime import datetime
 print ("Datum und Uhrzeit der Ausführung des Auftrags:" + datetime.now (). Strftime ("% Y /% m /% d% H:% M:% S"))
    print
           
 #Verbinden Sie sich mit MemSQL
    db = pymysql.connect(host = 'xxx.xxx.xxx.xxx',
                         port=3306,
                         user='qiita',
                         password='adminqiita',
                         db='Test',
                         charset='utf8',
                         cursorclass=pymysql.cursors.DictCursor)
    
    with db.cursor() as cursor:
        
 #Initialize Arbeitspuffer
        Tmp_Data = []
           
 # Anfrage senden und festschreiben
        cursor.execute(SQL_Data)                    
        db.commit()
               
 # Abfrageergebnisse abrufen
        rows = cursor.fetchall()
          
 # Der Inhalt der Abfrage wird in Zukunft zunehmen. Seien Sie also darauf vorbereitet ...
        for Query_Data in rows:
                    
            for item in Query_Data.values():
                
                Tmp_Data.append(item)
                
            print
                
 print ("Produktkategorie:" + str (Tmp_Data [0]))
 print ("Mindestverkaufspreis:" + str (Tmp_Data [1]))
 print ("Höchster Verkaufspreis:" + str (Tmp_Data [2]))
 print ("Durchschnittlicher Verkaufspreis:" + str (Tmp_Data [3]))
 print ("Gesamtzahl der Verkäufe:" + str (Tmp_Data [4]))

            print
            
            Tmp_Data = []

 #Schließen Sie die Datenbankverbindung
    db.close()


# Hauptteil von hier


def main():

 # Einstellung der zu verwendenden Variablen
    Loop_Count = 3
    Count = 0

    Interval_Time = 60

 # Startzeit des gesamten Prozesses
    from datetime import datetime
 print ("Datum und Uhrzeit des Programmstarts:" + datetime.now (). Strftime ("% Y /% m /% d% H:% M:% S"))
    print

 # Alle 10 Minuten
    #　schedule.every(10).minutes.do(job)
 # Alle 2 Stunden
    #　schedule.every(2).hours.do(job)
 # 10 Uhr jeden Tag
    #　schedule.every().day.at("10:00").do(job)
 # jeden Montag
    #　schedule.every().monday.do(job)

    schedule.every(Interval_Time).seconds.do(job)

 # In einer Endlosschleife verarbeiten
    while True:

        schedule.run_pending()

 #Mysterischer Zauber ... ww
        time.sleep(Interval_Time)

 # Überprüfen Sie die angegebene Anzahl von Malen
        if (Count >= Loop_Count):

            break

        else:

            Count += 1

 print (str (Count) + "times: Die angegebene Anzahl von Jobs wurde abgeschlossen!")
    print
    from datetime import datetime
 print ("Programmenddatum und -zeit:" + datetime.now (). Strftime ("% Y /% m /% d% H:% M:% S"))

if __name__ == "__main__":
    main()

Das Ausführungsergebnis ist ...

Das Folgende ist das Ergebnis der Ausführung des zuvor erstellten Skripts, indem automatisch die kontinuierliche Generierung / Einfügung von zufälligen Zufallsdaten für MemSQL gestartet wird. Dieses Mal wollte ich nach dem Sammeln einer bestimmten Datenmenge verarbeiten, also habe ich das Ausführungsintervall auf 60 Sekunden festgelegt und dreimal ausgeführt. (Eigentlich gibt es kein Problem, auch wenn es 30 Sekunden sind)

 Datum und Uhrzeit des Programmstarts: 2020/10/06 16:46:54

 Datum und Uhrzeit der Ausführung des Jobs: 2020/10/06 16:47:54


 Produktkategorie: Haushaltsgeräte
 Mindestverkaufspreis: 35800
 Maximaler Verkaufspreis: 88000
 Durchschnittlicher Verkaufspreis: 51840.0000
 Gesamtzahl der Verkäufe: 5


 Produktkategorie: Bücher
 Mindestverkaufspreis: 1710
 Maximaler Verkaufspreis: 5940
 Durchschnittlicher Verkaufspreis: 3825.0000
 Gesamtzahl der Verkäufe: 6


 Produktklassifizierung: Verschiedene Waren
 Mindestverkaufspreis: 1592
 Maximaler Verkaufspreis: 3580
 Durchschnittlicher Verkaufspreis: 2586.0000
 Gesamtzahl der Verkäufe: 5


 Produktkategorie: Alkohol
 Mindestverkaufspreis: 9000
 Maximaler Verkaufspreis: 18000
 Durchschnittlicher Verkaufspreis: 12750.0000
 Gesamtumsatz: 23


 Produktkategorie: DVD / CD
 Mindestverkaufspreis: 4400
 Maximaler Verkaufspreis: 5960
 Durchschnittlicher Verkaufspreis: 5246.6667
 Gesamtzahl der Verkäufe: 6

 Datum und Uhrzeit der Ausführung des Jobs: 2020/10/06 16:48:54


 Produktkategorie: Haushaltsgeräte
 Mindestverkaufspreis: 198
 Maximaler Verkaufspreis: 88000
 Durchschnittlicher Verkaufspreis: 38177.8000
 Gesamtzahl der Verkäufe: 10


 Produktkategorie: Bücher
 Mindestverkaufspreis: 280
 Maximaler Verkaufspreis: 5940
 Durchschnittlicher Verkaufspreis: 2601.6667
 Gesamtzahl der Verkäufe: 14


 Produktklassifizierung: Verschiedene Waren
 Mindestverkaufspreis: 1592
 Maximaler Verkaufspreis: 3580
 Durchschnittlicher Verkaufspreis: 2254.6667
 Gesamtzahl der Verkäufe: 9


 Produktkategorie: Alkohol
 Mindestverkaufspreis: 3960
 Maximaler Verkaufspreis: 50000
 Durchschnittlicher Verkaufspreis: 16456.0000
 Gesamtzahl der Verkäufe: 64


 Produktkategorie: DVD / CD
 Mindestverkaufspreis: 4400
 Maximaler Verkaufspreis: 7600
 Durchschnittlicher Verkaufspreis: 6188.0000
 Gesamtzahl der Verkäufe: 10

 Datum und Uhrzeit der Ausführung des Jobs: 2020/10/06 16:49:54


 Produktkategorie: Haushaltsgeräte
 Mindestverkaufspreis: 198
 Maximaler Verkaufspreis: 88000
 Durchschnittlicher Verkaufspreis: 44548.1667
 Gesamtumsatz: 12


 Produktkategorie: Bücher
 Mindestverkaufspreis: 280
 Maximaler Verkaufspreis: 5940
 Durchschnittlicher Verkaufspreis: 2601.6667
 Gesamtzahl der Verkäufe: 14


 Produktklassifizierung: Verschiedene Waren
 Mindestverkaufspreis: 396
 Maximaler Verkaufspreis: 3580
 Durchschnittlicher Verkaufspreis: 1790.0000
 Gesamtzahl der Verkäufe: 11


 Produktkategorie: Alkohol
 Mindestverkaufspreis: 2450
 Maximaler Verkaufspreis: 50000
 Durchschnittlicher Verkaufspreis: 13355.0000
 Gesamtumsatz: 79


 Produktkategorie: DVD / CD
 Mindestverkaufspreis: 1980
 Maximaler Verkaufspreis: 7600
 Durchschnittlicher Verkaufspreis: 5633.3333
 Gesamtumsatz: 17

 3 mal: Die angegebene Anzahl von Jobs wurde abgeschlossen!

 Datum und Uhrzeit des Programmendes: 2020/10/06 16:50:54

Übrigens ist es das Überprüfungsergebnis, wenn dieselbe Abfrage im SQL-Editor von MemSQL ausgeführt wird, während Daten auf dieselbe Weise eingefügt werden.

Die Abfrage wurde gemäß dem Zeitübergang ausgeführt (ausgeführt, während ungefähr auf die Uhr geschaut wurde), aber die Ausführungszeit war im Bereich von mehreren Millisekunden stabil. Zuvor hatte ich diese SQL-Abfrage (in diesem Fall für einen statischen Tabellenstatus ausgeführt) für ähnliche Daten von 100.000 Zeilen verarbeitet, aber sie ergab immer noch ein korrektes Ergebnis im Bereich von 10 Millisekunden. Daher kann durch Skalieren des In-Memory-Bereichs entsprechend dem tatsächlichen Umfang der Erweiterung und Verwenden der verteilten Clusterverarbeitung erwartet werden, dass eine Verarbeitung mit dramatischer Leistung auch für eine Datenverarbeitung in größerem Maßstab unterstützt wird. Machen wir das.

Nächstes Mal ...

Beim nächsten Mal möchte ich diese SQL-Anweisung ein wenig ändern, damit in kurzen Zeitintervallen automatisch Snapshot-ähnliche Tabellen erstellt werden können. Durch die Nutzung der In-Memory-Leistung von MemSQL und die Erfassung von Daten in Echtzeit über Equalum wird die explosive Leistung von MemSQL genutzt, um die erforderliche SQL-Verarbeitung bei Bedarf auszuführen, ohne dass die Upstream-Seite eine Transaktionslast auferlegt. Ich möchte überprüfen, ob ich es verwenden werde. Wenn ich es mir leisten kann, möchte ich absichtlich mehrere Tabellen erstellen (Stellen Sie sich vor, Sie extrahieren aus einem isolierten Datensystem ...) und SQL über diese Tabellen ausführen, um die Ergebnisse anzuzeigen. ..

Vielen Dank

Diese Überprüfung wird mit der offiziellen kostenlosen Version (V6) von MemSQL durchgeführt.

** Über die kostenlose Version von MemSQL ... **

Wir möchten MemSQL für die Bereitstellung dieser wertvollen Gelegenheit danken. Wenn sich dieser Inhalt von dem auf der offiziellen Website von MemSQL veröffentlichten Inhalt unterscheidet, haben die Informationen von MemSQL Vorrang. Bitte haben Sie Verständnis dafür.