[PYTHON] Vérification de la capacité de traitement MemSQL (application 2)
Cette fois·····
Dans l'application 1, nous nous sommes concentrés sur l'amélioration de l'environnement utilisé dans cette vérification. Le traitement final de la requête SQL a fonctionné comme prévu, donc dans cette vérification, nous vérifierons le traitement ultérieur. Le but ultime est ... (1) En même temps que le côté génération de données (travail de terrain) (2) Sans imposer une nouvelle charge sur le système de données existant qui a été dimensionné de manière serrée et s'est affaibli à l'environnement de fonctionnement. (3) Réaliser l'utilisation des données en temps réel au-delà des murs des silos ... C'est possible? Confirmer ...
Le mot clé est ** changer le présent et créer le futur **. Économisez et faites un don! Pour les choses qui ne pouvaient pas être vues par le traitement de type, les informations nécessaires sont automatiquement préparées en temps réel selon votre convenance, et l'utilisation créative des données est réalisée à la demande ... La gestion des données sera possible.
Tout d'abord, lancez simplement la requête SQL à plusieurs reprises
Je pense que c'est un système de base en termes de SQL, mais je vais d'abord essayer d'interroger la fonction d'agrégation pour les données qui remplissent certaines conditions. (1) Effectuer un traitement d'agrégation pour chaque catégorie à partir des "informations de vente Nanchatte" générées automatiquement. (2) Les préfectures cibles sont la préfecture d'Osaka, la région métropolitaine de Tokyo, la préfecture de Fukuoka, la préfecture d'Aichi et la préfecture de Hokkaido. (3) Émettez une requête à la table de base de données que le générateur insère continuellement et vérifiez le résultat. Je vais y aller.
Créez un processus urgent. L'instruction SQL est volontairement rendue facile à lire (en supposant que le modèle sera changé plus tard), mais je pense que nous pouvons concevoir un peu plus efficacement. De plus, aux moments suivants et suivants, nous prévoyons de sélectionner la colonne à extraire et de créer une autre nouvelle table (en supposant que la réponse interne sera utilisée pour l'analyse), veuillez donc écrire dans ce processus en gardant cette opération à l'esprit. Je l'ai pris.
coding: utf-8
# Exécuter des tâches à intervalles réguliers en Python (version Power Technique)
# Version 2.7
import sys
stdout = sys.stdout
reload(sys)
sys.setdefaultencoding('utf-8')
sys.stdout = stdout
# Module à importer
import schedule
import time
# Définissez ici le processus pour qu'il s'exécute à intervalles réguliers
def job():
# Définissez le SQL du système d'agrégation à utiliser cette fois.
# Je le divise intentionnellement pour pouvoir essayer différentes choses ...
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 Category IN ('alcool', 'biens divers', 'livres', 'électroménagers', 'DVD / CD')"
SQL5 = "AND Prefecture IN ('Osaka prefecture', 'Tokyo prefecture', 'Fukuoka prefecture', 'Aichi prefecture', 'Hokkaido')"
SQL6 = "GROUP BY Category"
SQL_Data = SQL1 + SQL2 + SQL3 + SQL4 + SQL5 + SQL6
# Lancer le traitement
from datetime import datetime
print ("Date et heure d'exécution du JOB:" + datetime.now (). Strftime ("% Y /% m /% d% H:% M:% S"))
print
#Connectez-vous avec 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:
#Initialiser le tampon de travail
Tmp_Data = []
# Envoyer la requête et valider
cursor.execute(SQL_Data)
db.commit()
# Obtenir les résultats de la requête
rows = cursor.fetchall()
#Le contenu de la requête augmentera à l'avenir, alors préparez-vous à cela ...
for Query_Data in rows:
for item in Query_Data.values():
Tmp_Data.append(item)
print
print ("Catégorie de produit:" + str (Tmp_Data [0]))
print ("Prix de vente minimum:" + str (Tmp_Data [1]))
print ("Prix de vente le plus élevé:" + str (Tmp_Data [2]))
print ("Prix de vente moyen:" + str (Tmp_Data [3]))
print ("Nombre total de ventes:" + str (Tmp_Data [4]))
print
Tmp_Data = []
#Close la connexion à la base de données
db.close()
# Partie principale d'ici
def main():
# Paramétrage des variables à utiliser
Loop_Count = 3
Count = 0
Interval_Time = 60
# Heure de début de l'ensemble du processus
from datetime import datetime
print ("Date et heure de début du programme:" + datetime.now (). Strftime ("% Y /% m /% d% H:% M:% S"))
print
# Toutes les 10 minutes
# schedule.every(10).minutes.do(job)
# Toutes les 2 heures
# schedule.every(2).hours.do(job)
# 10 heures tous les jours
# schedule.every().day.at("10:00").do(job)
# tous les lundis
# schedule.every().monday.do(job)
schedule.every(Interval_Time).seconds.do(job)
# Processus en boucle infinie
while True:
schedule.run_pending()
#Sortiment mystérieux ... ww
time.sleep(Interval_Time)
# Vérifiez le nombre de fois spécifié
if (Count >= Loop_Count):
break
else:
Count += 1
print (str (Count) + "times: Le nombre spécifié de travaux est terminé!")
print
from datetime import datetime
print ("Date et heure de fin du programme:" + datetime.now (). Strftime ("% Y /% m /% d% H:% M:% S"))
if __name__ == "__main__":
main()
Le résultat de l'exécution est ...
Ce qui suit est le résultat de l'exécution du script créé précédemment en démarrant automatiquement la génération / insertion continue de données aléatoires aléatoires pour MemSQL. Cette fois, je voulais traiter après avoir collecté une certaine quantité de données, j'ai donc défini l'intervalle d'exécution à 60 secondes et exécuté 3 fois. (En fait, il n'y a pas de problème même si c'est 30 secondes)
Date et heure de début du programme: 06/10/2020 16:46:54
Date et heure d'exécution du JOB: 06/10/2020 16:47:54
Catégorie de produit: Appareils ménagers
Prix de vente minimum: 35800
Prix de vente maximum: 88000
Prix de vente moyen: 51840.0000
Nombre total de ventes: 5
Catégorie de produit: Livres
Prix de vente minimum: 1710
Prix de vente maximum: 5940
Prix de vente moyen: 3825.0000
Nombre total de ventes: 6
Classification des produits: Produits divers
Prix de vente minimum: 1592
Prix de vente maximum: 3580
Prix de vente moyen: 2586.0000
Nombre total de ventes: 5
Catégorie de produit: Liqueur
Prix de vente minimum: 9000
Prix de vente maximum: 18000
Prix de vente moyen: 12750.0000
Ventes totales: 23
Catégorie de produit: DVD / CD
Prix de vente minimum: 4400
Prix de vente maximum: 5960
Prix de vente moyen: 5246,6667
Nombre total de ventes: 6
Date et heure d'exécution du JOB: 06/10/2020 16:48:54
Catégorie de produit: Appareils ménagers
Prix de vente minimum: 198
Prix de vente maximum: 88000
Prix de vente moyen: 38177.8000
Nombre total de ventes: 10
Catégorie de produit: Livres
Prix de vente minimum: 280
Prix de vente maximum: 5940
Prix de vente moyen: 2601,6667
Nombre total de ventes: 14
Classification des produits: Produits divers
Prix de vente minimum: 1592
Prix de vente maximum: 3580
Prix de vente moyen: 2254,6667
Nombre total de ventes: 9
Catégorie de produit: Liqueur
Prix de vente minimum: 3960
Prix de vente maximum: 50000
Prix de vente moyen: 16456.0000
Ventes totales: 64
Catégorie de produit: DVD / CD
Prix de vente minimum: 4400
Prix de vente maximum: 7600
Prix de vente moyen: 6188.0000
Nombre total de ventes: 10
Date et heure d'exécution du JOB: 06/10/2020 16:49:54
Catégorie de produit: Appareils ménagers
Prix de vente minimum: 198
Prix de vente maximum: 88000
Prix de vente moyen: 44548.1667
Ventes totales: 12
Catégorie de produit: Livres
Prix de vente minimum: 280
Prix de vente maximum: 5940
Prix de vente moyen: 2601,6667
Nombre total de ventes: 14
Classification des produits: Produits divers
Prix de vente minimum: 396
Prix de vente maximum: 3580
Prix de vente moyen: 1790.0000
Ventes totales: 11
Catégorie de produit: Liqueur
Prix de vente minimum: 2450
Prix de vente maximum: 50000
Prix de vente moyen: 13355.0000
Ventes totales: 79
Catégorie de produit: DVD / CD
Prix de vente minimum: 1980
Prix de vente maximum: 7600
Prix de vente moyen: 5633.3333
Ventes totales: 17
3 fois: le nombre de travaux spécifié a été terminé!
Date et heure de fin du programme: 06/10/2020 16:50:54
Au fait, c'est le résultat de la vérification de l'exécution de la même requête sur l'éditeur SQL de MemSQL tout en insérant des données de la même manière.
La requête a été exécutée en fonction de la transition temporelle (exécutée en regardant l'horloge approximativement), mais le temps d'exécution était stable dans la plage de plusieurs millisecondes. Auparavant, j'avais cette requête SQL (dans ce cas, exécutée pour un état de table statique) traitée pour 100000 lignes de données similaires, mais elle produisait toujours des résultats correctement dans la plage de 10 millisecondes. Par conséquent, en mettant à l'échelle la zone en mémoire en fonction de la quantité d'extension réelle et en utilisant le traitement de cluster distribué, on peut s'attendre à ce que le traitement avec des performances spectaculaires soit pris en charge même pour un traitement de données à plus grande échelle. Faisons le.
La prochaine fois ...
La prochaine fois, j'aimerais modifier un peu cette instruction SQL afin qu'elle puisse créer automatiquement des tables de type instantané à de courts intervalles de temps. En utilisant les performances en mémoire de MemSQL, tout en collectant des données en temps réel via Equalum, les performances explosives de MemSQL sont utilisées pour exécuter les traitements SQL nécessaires à la demande sans imposer une charge de transaction en amont. Je voudrais vérifier que je vais l'utiliser. De plus, si je peux me le permettre, je voudrais créer intentionnellement plusieurs tables (imaginez l'extraction d'un système de données en silo ...) et exécuter SQL sur ces tables pour voir les résultats. ..
Merci
Cette vérification est effectuée à l'aide de la version gratuite officielle (V6) de MemSQL.
** À propos de la version gratuite de MemSQL ... **
Nous tenons à remercier MemSQL d'avoir fourni cette précieuse opportunité, et si ce contenu diffère du contenu publié sur le site officiel de MemSQL, les informations de MemSQL prévaudront. Veuillez comprendre cela.