[PYTHON] Utilisons MemSQL Vol.13: Practice 6

Cette fois, nous allons remettre en question la coopération entre Jupyter Notebook et MemSQL! !!

Dans la vérification précédente, j'ai essayé de lier MemSQL et R via Docker sur l'environnement Mac. Cette fois, je voudrais lier Jupyter Notebook, qui est célèbre pour Python, avec MemSQL. Il semble qu'il soit souvent utilisé comme environnement de développement pour Python, j'espère donc qu'il sera utile non seulement pour l'analyse, mais aussi pour l'apprentissage automatique et les approches de l'IA lorsque cela est fait dans le système Python.

Procédure d'installation

Cette fois, nous travaillerons dans l'environnement Mac comme avant.

(1) Présentez Xcode

Tout d'abord, nous présenterons le Xcode promis.

Dans mon environnement, j'ai tout entré, y compris le système de ligne de commande à ce stade, je vais donc passer à l'amélioration de l'environnement associé (dans les messages des seniors qui ont déjà posté sur le net, l'environnement de ligne de commande a été introduit ici Il y a des cas où il est présent, veuillez donc le vérifier au cas où.

(3) Installez Homebrew

Suivez les instructions de ** Homebrew Homepage ** pour installer. Vérifiez si Homebrew est installé

% brew update
% brew upgrade
% brew doctor

Au fait, l'environnement de travail cette fois-ci était comme ça (pour référence)

Enfin, installez Jupyter Notebook via pip3.

% pip3 install jupyter 

L'installation va démarrer, veuillez donc patienter un peu Une fois l'installation terminée, créez un répertoire de travail et déplacez-le. (Veuillez définir xxx selon le cas)

% mkdir xxx
% cd xxx

Cela semble être que le répertoire dans lequel jupyter notebook est exécuté devient automatiquement l'écran d'accueil, donc pour éviter de s'encombrer, créez un répertoire de travail avec mkdir à n'importe quel endroit et déplacez-vous vers ce répertoire Ensuite, démarrez le notebook jupyter.

% jupyter notebook

Le processus de démarrage va démarrer, veuillez donc patienter un peu.

Une fois l'installation exécutée pendant un certain temps, la page d'accueil de Jupyter Notebook s'affiche dans le navigateur. Je vérifierai l'opération promise.

print("Hello World")

Laissez cette description vide et sélectionnez Exécuter. Il semble qu'il a commencé à se déplacer en toute sécurité.

Enfin coopération avec MemSQL ...

Maintenant, nous allons enfin travailler avec MemSQL, mais avant cela, il y a un travail préparatoire très important qui doit être effacé. Comme beaucoup d'entre vous l'ont peut-être déjà remarqué, lorsque les deux utilisent des consoles basées sur l'interface graphique ... Le problème de collision 8080 devient évident, il est donc nécessaire de prendre des contre-mesures. Cette fois, je vais déplacer le port de distribution du côté Jupyter Notebook.

Pour travailler, suivez les étapes ci-dessous sur la console Mac.

% jupyter notebook --generate-config

Les fichiers suivants seront créés dans le répertoire supérieur de votre domicile, vérifiez donc le contenu et modifiez le numéro de port.

~/.jupyter/jupyter_notebook_config.py

Avec l'éditeur vi etc.

#c.NotebookApp.port = 8888

Recherchez et supprimez le # au début de la ligne (dans ce cas, 8888 sera le port après le redémarrage)

La console MemSQL et Jupyter Notebook peuvent désormais coexister en toute sécurité.

Ensuite, installez ** pymysql **.

% pip3 install pymysql

Je suis entré rapidement.

Cette fois également, nous exécuterons MemSQL dans l'environnement Docker sur Mac et travaillerons dans le sens de la liaison de cet environnement avec le Jupyter Notebook de cette saison.

Démarrez MemSQL sur Docker.

% docker start memsql-ciab

Enfin, la vérification de coopération est exécutée! !!

J'aimerais aller avec cette collaboration en me faisant passer pour MySQL, dans lequel je suis bon. Pour la base de données, essayez de lire la table au moment de la liaison R créée lors de la vérification précédente telle quelle.

Entrez le script suivant sur le bloc-notes Jupyter.

import pymysql

db = pymysql.connect(host='127.0.0.1',
                     user='root',
                     password='',
                     db='r_db',
                     charset='utf8',
                     cursorclass=pymysql.cursors.DictCursor)

db.commit()

S'il n'y a pas de problème avec les paramètres jusqu'à l'étape précédente, le dernier ** db.commit () ** se connectera à MemSQL.

Ensuite, essayez de lire les données de la table cible.

with db:
    cur=db.cursor()
    cur.execute("SELECT * FROM test99")
    rows=cur.fetchall()
    for row in rows:
        print (row)

J'ai pu lire les données en toute sécurité.

Écrivons maintenant les données de Jupyter Notebook vers MemSQL ...

Fondamentalement, si vous suivez la méthode ci-dessus, vous pouvez atteindre l'objectif sans aucun problème.

import pymysql

db = pymysql.connect(host=  '127.0.0.1',
                             user='root',
                             password='',
                             db='r_db',
                             charset='utf8',
                             cursorclass=pymysql.cursors.DictCursor)

db.commit()

with db:
   cur=db.cursor()
   cur.execute("CREATE TABLE IF NOT EXISTS p_test(id INT auto_increment primary key, data VARCHAR(25))")
   cur.execute("INSERT INTO p_test(data) VALUES('aaaaaaa')")
   cur.execute("INSERT INTO p_test(data) VALUES('bbbbbbb')")
   cur.execute("INSERT INTO p_test(data) VALUES('ccccccc')")

Vérifions le résultat dans la console MemSQL.

J'ai pu terminer avec succès la vérification d'écriture.

Ce résumé

Cette fois, j'ai brièvement vérifié la coopération entre Jupyter Notebook, célèbre dans le monde Python, et MemSQL. Si vous pouvez bien construire l'environnement de base, il n'y aura pas de difficulté particulière et vous pourrez développer la prochaine application. Il semble qu'il soit souvent utilisé dans le monde Python comme moteur d'apprentissage automatique, d'intelligence artificielle, d'analyse, etc., alors saisissez cette occasion pour envisager de créer un lien avec MemSQL.

Cet environnement est une combinaison de la version Docker de MemSQL et de l'installation normale de jupyter Notebook sur Mac. C'est un environnement qui peut être construit sur un bloc-notes puissant comme le précédent R, alors n'hésitez pas à utiliser SQL haute vitesse en mémoire.

** Utilisons MemSQL Vol.14: édition pratique 7 **

Merci

Les captures d'écran reproduites dans ce commentaire utilisent les images du site officiel actuellement publié par MemSQL, à l'exception de certaines, et sont publiées sur ce contenu et sur le site officiel de MemSQL. Veuillez comprendre que les informations fournies par MemSQL prévaudront si le contenu est différent.