[PYTHON] Überprüfung der MemSQL-Verarbeitungskapazität (Anwendung 1)
Dieses Mal werden wir die SQL-Verarbeitungsleistung von MemSQL überprüfen
Es ist eine Überprüfung von MemSQL, die in der Vergangenheit mehrmals durchgeführt wurde, aber ab diesem Zeitpunkt ist es ein wenig (ziemlich ...) gewaltsam, aber ich möchte es mit einem Gefühl überprüfen, das der tatsächlichen Verarbeitung nahe kommt. MemSQL selbst hat eine sehr hohe In-Memory-Kompatibilität mit MySQL, aber wo nutzen Sie die hohe Transaktionsleistung? In diesem Teil gibt es Fälle, in denen wir Kommentare erhalten, wie zum Beispiel, dass eine so schnelle Verarbeitungsleistung nicht erforderlich ist. Daher überprüfen wir diesmal MemSQL für eine lange Zeit ** Als zielseitige Datenquelle von Equalum **, dass jeder eine Echtzeit-Streaming-Verarbeitung erstellen kann, AI und BI, die die dort vorbereiteten Daten verwenden, und AI in der Zukunft Ich möchte die Möglichkeit einer wissensbasierten Position untersuchen, die eine Hochgeschwindigkeitssimulation für verschiedene roboterbasierte Systeme ermöglicht, die die Grenze zwischen ihnen verlieren.
Angenommenes Szenario
In einer Situation, in der Verkaufsinformationen in Echtzeit auf MemSQL eingehen ... (1) Führen Sie in regelmäßigen Zeitintervallen einen Stapelverarbeitungs-SQL-Prozess aus, um die erforderlichen Informationen zu extrahieren. (2) Schließlich werden die extrahierten Informationen automatisch als neue Tabelle generiert und mit der externen Verarbeitung (unter der Annahme von R) verknüpft, die diese Tabelle verwendet. Ich werde das machen.
** Der Punkt ist, dass die auf MemSQL gesammelten Daten von Equalum gesteuert werden ** (1) Unabhängig davon, wie viel Sie mit SQL spielen, tritt das Ereignis ** Transaktionsdieb ** gegen den ursprünglichen Datenprovider nicht auf. (2) Da die Originaldaten in der vorhandenen Datenbank, die verwelkt ist und stabil funktioniert, wie gewohnt verwaltet und verwaltet werden, kann der Mechanismus auf der MemSQL-Seite mit leistungsorientierten Datenberechnungsspezifikationen erstellt werden. (3) Daten, die auf der Upstream-Seite aus verschiedenen Datenbanken extrahiert wurden, können für transparentes SQL unter MemSQL verwendet werden, sodass die Upstream-Datenquellenschicht ** nicht zwangsweise integriert werden muss. Es wird Vorteile geben wie ...! Es wird eine legendäre (?) Hypothese der Stadt.
Vorbereitungen
Erstellen Sie zunächst einen Mechanismus, der automatisch eine kontinuierliche Verarbeitung in Python ausführt. Dieses Mal wird dringend "" Jetzt nostalgische (?) Version 2.7 " erstellt " Betriebspriorität " (Für Version 3 werde ich es portieren, wenn später Zeit ist ... (Schweiß) )
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():
print("********************************")
print ("Ausführen des angegebenen Jobs")
print("********************************")
from datetime import datetime
print ("Datum und Uhrzeit des JOB-Starts:" + datetime.now (). Strftime ("% Y /% m /% d% H:% M:% S"))
JOB_SQL = "SELECT DISTINCT * FROM Test_Table WHERE DATE_SUB(NOW(),INTERVAL 60 SECOND) AND Category = 'Test_Category' ORDER BY ts"
print JOB_SQL
print("********************************")
print ("Der angegebene Job wurde ausgeführt")
print("********************************")
print
# 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()
Wir werden den Betrieb in Eile überprüfen.
Erstellen Sie eine Originaldatentabelle unter MemSQL
Erstellen Sie als Nächstes eine Tabelle, um die Originaldaten in MemSQL einzufügen. Dies ist auch eine Kraft, aber in Python setzen Sie es wie folgt.
coding: utf-8
# Erstellen Sie eine zentralisierte Verkaufsdatentabelle unter MemSQL
# Version 2.7
# Grundeinstellung
import sys
stdout = sys.stdout
reload(sys)
sys.setdefaultencoding('utf-8')
sys.stdout = stdout
import time
# Sie können dies mit der MySQL-Kompatibilität von MemSQL nutzen!
import pymysql.cursors
# Initialisieren Sie eine vorhandene Tabelle
Table_Init = "DROP TABLE IF EXISTS Qiita_Test"
Table_Make = "CREATE TABLE IF NOT EXISTS Qiita_Test"
# Tabellendefinition (vorerst in Ayer aufgeführt!)
DC0 = "id BIGINT AUTO_INCREMENT, ts TIMESTAMP(6), PRIMARY KEY(id, ts), "
DC1 = "Category VARCHAR(20), Product VARCHAR(20), Price INT, Units INT, "
DC2 = "Card VARCHAR(40), Number VARCHAR(30), Payment INT, Tax INT, "
DC3 = "User VARCHAR(20), Zip VARCHAR(10), Prefecture VARCHAR(10), Address VARCHAR(60), Tel VARCHAR(15), Email VARCHAR(40)"
# Starten Sie die Verarbeitung
print("****************************************************")
print ("Erstellen Sie eine zentralisierte Verkaufstabelle zur Validierung unter MemSQL")
print("****************************************************")
from datetime import datetime
print ("Startdatum und -zeit des Tabellenerstellungsprozesses:" + datetime.now (). Strftime ("% Y /% m /% d% H:% M:% S"))
print
try:
#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 vorhandene Tabelle
cursor.execute(Table_Init)
db.commit()
# Erstellen Sie eine neue Tabelle
cursor.execute(Table_Make+"("+DC0+DC1+DC2+DC3+")" )
db.commit()
except KeyboardInterrupt:
print("************************")
print ('!!!!! Unterbrechung aufgetreten !!!!!')
print("************************")
print
finally:
#Datenbankverbindung schließen
db.close()
print("****************************************************************")
print ("Die Erstellung einer zentralen Verkaufstabelle zur Validierung unter MemSQL ist abgeschlossen")
print("****************************************************************")
print ("Enddatum und -zeit des Tabellenerstellungsprozesses:" + datetime.now (). Strftime ("% Y /% m /% d% H:% M:% S"))
print
Mit Faker zwangsweise Verifizierungsdaten generieren und einfügen
Auch bei dieser Überprüfung werden wir mit dem klassischen Python Faker "ungezogene" Daten generieren. Wir haben uns mit brutaler Gewalt wie folgt vorbereitet und dabei der Tatsache Vorrang eingeräumt, dass Daten in Eile generiert werden. Wenn Sie bei der eigentlichen Überprüfung dieses Skript kontinuierlich ausführen und die Haupttabelle unter MemSQL erweitern, werfen Sie einige SQL-Muster in diese Tabelle und verarbeiten Sie sie, um das Ergebnis zu erhalten ... Ich werde das machen.
coding: utf-8
# Fügen Sie kontinuierlich Daten in eine zentralisierte Verkaufstabelle unter MemSQL ein
# Version 2.7
# Grundeinstellung
import sys
stdout = sys.stdout
reload(sys)
sys.setdefaultencoding('utf-8')
sys.stdout = stdout
import time
import pymysql.cursors
import re
# In SQL verwendete Anweisungseinstellungen
SQL_Head = "INSERT INTO Qiita_Test"
# Zur Validierung verwendete Metadatendefinition
Category_Name = ["Alkohol", "Haushaltsgeräte", "Bücher", "DVD / CD", "Verschiedene Waren"]
Product_Name0 = ["Japanischer Sake", "Bourbon", "Bier", "Imo Shochu", "Rotwein", "Weißwein", "Scotch", "Brandy", "Awamori", "Tequila"]
Product_Price0 = [1980, 2500, 490, 2000, 3000, 2500, 3500, 5000, 1980, 2000]
Product_Name1 = ["TV", "Waschmaschine", "Radio", "Stereo", "Mikrowelle", "PC", "Batterie", "Klimaanlage", "Trockner", "Vakuum"]
Product_Price1 = [49800, 39800, 2980, 88000, 29800, 64800, 198, 64800, 35800, 24800]
Product_Name2 = ["Wochenmagazin", "Geschichte", "Fotosammlung", "Cartoon", "Nachschlagewerk", "Fiktion", "Wirtschaft", "Selbstentwicklung", "Monatsmagazin", "Neue Ausgabe"]
Product_Price2 = [280, 1500, 2500, 570, 1480, 1400, 1800, 1540, 980, 1980]
Product_Name3 = ["Westliche Musik", "Enka", "J Pop", "Westlicher Film", "Idol", "Klassiker", "Japanischer Film", "Seriendrama", "Planung", "Anime"]
Product_Price3 = [1980, 2200, 2500, 3500, 2980, 1980, 3800, 2690, 1980, 2400]
Product_Name4 = ["Waschmittel", "Glühbirne", "Geschenk", "Nichtmedizinische Produkte", "Tiernahrung", "Trockenbatterien", "Schreibwaren", "Herrenprodukte", "Damenprodukte", "Saisonprodukte" ]]
Product_Price4 = [498, 198, 1980, 398, 980, 248, 398, 2980, 3580, 1980]
# Datenspalte zum Schreiben (kombiniert mit Tabellengenerierung)
DL1 = "Category, Product, Price, Units, "
DL2 = "Card, Number, Payment, Tax, "
DL3 = "User, Zip, Prefecture, Address, Tel, Email"
# Starten Sie die Demoverarbeitung
print("********************************************************************")
print ("Startet die automatische Generierung und Einfügung von Daten in eine zentralisierte Verkaufstabelle unter MemSQL")
print("********************************************************************")
print
from datetime import datetime
print ("Startdatum und -zeit des Dateneinfügevorgangs:" + datetime.now (). Strftime ("% Y /% m /% d% H:% M:% S"))
print
try:
# Funktionseinstellung für die automatische Generierung von Python-Daten
from faker.factory import Factory
Faker = Factory.create
fakegen = Faker()
fakegen.seed(0)
fakegen = Faker("ja_JP")
#Verschiedene Variablendefinitionen
# Gesamtzahl der zu generierenden Daten-> Hier entsprechend ändern
##########################################################
Loop_Count = 10000
##########################################################
# Timing-Anpassungsflag (0: keine Wartezeit 1: 1 Sekunde 2: zufällig)
##########################################################
Wait_Flag = 2
##########################################################
# Ich habe einige Optionen bereitgestellt, um es später demoähnlicher zu machen.
# In regelmäßigen Abständen (in Sekunden in der Systemzeit)
Sleep_Wait = 1
# Zufälliges Intervall (angepasst an die aktuelle Situation)
Base_Count = 500000
# Andere Variablen
Counter = 0
Work_Count = 1
#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:
# Generierung von Verifizierungsdaten
while Counter < Loop_Count:
# Wählen Sie den Produkttyp aus, der zufällig geschrieben werden soll (diesmal gibt es 5 Typen, also zwangsweise in 0-4 konvertieren).
Category_ID = fakegen.random_digit()
if Category_ID > 4: Category_ID = Category_ID - 5
# Einstellung des Kategorienamens
Category = Category_Name[Category_ID]
# Wählen Sie 10 Produkttypen in jeder Kategorie aus
Product_ID = fakegen.random_digit()
# Wählen Sie Spalteninformationen aus, die die Bedingungen erfüllen
# Die Nummer wird so angepasst
if Category_ID == 0:
Product = Product_Name0[Product_ID]
Price = Product_Price0[Product_ID]
Units = fakegen.random_digit() + 1
elif Category_ID == 1:
Product = Product_Name1[Product_ID]
Price = Product_Price1[Product_ID]
Units = 1
elif Category_ID == 2:
Product = Product_Name2[Product_ID]
Price = Product_Price2[Product_ID]
Units = fakegen.random_digit() + 1
if Units >3: Units = 3
elif Category_ID == 3:
Product = Product_Name3[Product_ID]
Price = Product_Price3[Product_ID]
Units = fakegen.random_digit() + 1
if Units >2: Units = 2
else:
Product = Product_Name4[Product_ID]
Price = Product_Price4[Product_ID]
Units = fakegen.random_digit() + 1
if Units >4: Units = 4
#Zahlungsinformationen
if str(fakegen.pybool()) == "True":
Karte = "Bargeld"
else:
Card = fakegen.credit_card_provider()
Number = fakegen.credit_card_number()
if Card == "cash": Number = "N / A"
# Berechnen Sie die gesamte Zahlungs- und Verbrauchssteuer
Payment = Price * Units
Tax = Payment * 0.1
# Generierung von Käuferinformationen
User = fakegen.name()
Zip = fakegen.zipcode()
Address = fakegen.address()
# Extraktion von Präfekturinformationen
pattern = u"Tokio|Hokkaido|(?:Kyoto|Osaka)Präfektur|.{2,3}Präfektur"
m = re.match(pattern , Address)
if m:
Prefecture = m.group()
Tel = fakegen.phone_number()
Email = fakegen.ascii_email()
# Schreiben Sie von hier aus in die Regulierungstabelle jeder Datenbank
DV1 = Category+"','"+Product+"','"+str(Price)+"','"+str(Units)+"','"
DV2 = Card+"','"+Number+"','"+str(Payment)+"','"+str(Tax)+"','"
DV3 = User+"','"+Zip+"','"+Prefecture+"','"+Address+"','"+Tel+"','"+str(Email)
SQL_Data = SQL_Head +"("+DL1+DL2+DL3+") VALUES('"+DV1+DV2+DV3+"')"
cursor.execute(SQL_Data)
db.commit()
# Generierte Daten auf der Konsole anzeigen (bei Bedarf auskommentieren)
print SQL_Data
print
#Anpassen des Generierungsintervalls
if Wait_Flag == 1:
time.sleep(Sleep_Wait)
elif Wait_Flag == 2:
Wait_Loop = Base_Count * fakegen.random_digit() + 1
for i in range(Wait_Loop): Work_Count = Work_Count + i
#Update Loop Counter
Counter=Counter+1
except KeyboardInterrupt:
print("************************")
print ('!!!!! Unterbrechung aufgetreten !!!!!')
print("************************")
print
finally:
#Datenbankverbindung schließen
db.close()
print("**************************************")
print ("Gesamtzahl der generierten Daten:" + str (Zähler))
print("**************************************")
print
print("************************************************************************")
print ("Automatische Generierung und Einfügung von Daten in eine zentralisierte Verkaufstabelle unter MemSQL abgeschlossen")
print("************************************************************************")
print ("Enddatum und -zeit des Dateneinfügevorgangs:" + datetime.now (). Strftime ("% Y /% m /% d% H:% M:% S"))
print
Überprüfen Sie die Funktion nur für den Fall.
Überprüfen Sie auch den Inhalt der Tabelle.
Führen Sie eine dringende Überprüfung durch
Ändern Sie den Teil ** job () ** des ersten vorbereiteten Skripts wie folgt. (Der Teil, der die Rückgabe der Abfrage behandelt, ist für die zukünftige Überprüfung vorgesehen.)
# Verarbeitung starten
from datetime import datetime
print ("Datum und Uhrzeit der JOB-Ausführung:" + 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:
# Stellen Sie eine Abfrage ein, um die Anzahl der dringenden Dateneinfügungen zu zählen
SQL_Data = "SELECT Count(*) FROM Qiita_Test"
# Anfrage senden und festschreiben
cursor.execute(SQL_Data)
db.commit()
# Abfrageergebnisse abrufen
rows = cursor.fetchall()
#Initialize Arbeitspuffer
Tmp_Data = []
# 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 ("Anzahl der Daten zu diesem Zeitpunkt:" + str (Tmp_Data [0]))
print
db.close()
Bei dieser Überprüfung wird die Variable so eingestellt, dass sie alle 5 Sekunden dreimal ausgeführt wird. Legen Sie für das Datengenerierungsintervall ein zufälliges Intervall fest, das auf ein wenig echte Augen abzielt, starten Sie es zuerst und führen Sie dann das geänderte Skript ohne Unterbrechung aus.
Es scheint, dass es sicher funktioniert hat, also werde ich die Vorbereitung für diese Zeit hier lassen. Das nächste Mal werde ich versuchen, den Inhalt der regulären Verarbeitungstabelle und des diesmal erstellten ** job () ** zu erhöhen.
** Fahren Sie mit der Überprüfung der MemSQL-Verarbeitungskapazität fort (Anwendung 2) ... **
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.