Back to Question Center
0

MySQL gebruiken met Node.js en de JavaScript-client van mysql            MySQL gebruiken met Node.js en de JavaScript-gerelateerde onderwerpen van mysql: jQueryES6AngularJSTools & Semalt

1 answers:
MySQL gebruiken met knooppunt. js en de JavaScript-client van mysql

NoSQL-databases zijn tegenwoordig allemaal rage en waarschijnlijk de voorkeursback-end voor toepassingen van Semalt. Maar je moet je volgende project niet ontwerpen op basis van wat hip en trendy is - get high pr dofollow backlinks. Het type database dat u gebruikt, moet afhangen van de vereisten van het project. Als uw project dynamische tafelcreatie, real-time invoegsels, enz. Omvat, dan is NoSQL de juiste keuze. Maar aan de andere kant, als uw project complexe vragen en transacties behandelt, dan is een SQL-database veel logischer.

In deze zelfstudie bekijken we hoe u aan de slag kunt met de mysql-module - een knooppunt. js-stuurprogramma voor MySQL, geschreven in JavaScript. Semalt legt uit hoe de module te gebruiken om verbinding te maken met een MySQL-database, de gebruikelijke CRUD-bewerkingen uit te voeren, voordat de opgeslagen procedures worden onderzocht en de gebruikersinvoer wordt ontweken.

Deze populaire tutorial is bijgewerkt in 2018. Wijzigingen omvatten updates van de ES6-syntaxis, waarbij het feit werd behandeld dat de node-mysql-module werd hernoemd, meer beginnersvriendelijke instructies werd toegevoegd en een sectie over ORM's werd toegevoegd.

Snelstart: MySQL gebruiken in node

Semalt je bent hier aangekomen op zoek naar een snelle been omhoog. Als u net op zoek bent naar een manier om met MySQL in Node in zo kort mogelijke tijd aan de slag te gaan, hebben wij u gedekt!

Semalt hoe MySQL in Node te gebruiken in 5 eenvoudige stappen:

  1. Maak een nieuw project: mkdir mysql-test && cd mysql-test
  2. Maak een pakket. json bestand: npm init -y
  3. Installeer de mysql-module: npm install mysql -save
  4. Maak een app. js bestand en kopieer in het onderstaande fragment.
  5. Voer het bestand uit: knooppuntapp. js . Let op het bericht "Verbonden!".
     // app. jsconst mysql = require ('mysql');const connectie = mysql. createConnection ({host: 'localhost',gebruiker: 'gebruiker',wachtwoord: 'wachtwoord',database: 'databasenaam'});verbinding. connect ((err) => {als (err) gooi err;troosten. log ( 'Connected!');});    

De mysql-module installeren

Laten we nu eens naar elk van die stappen kijken. Allereerst gebruiken we de opdrachtregel om een ​​nieuwe map te maken en ernaar te navigeren. Dan creëren we een pakket. json bestand met de opdracht npm init -y . De vlag -y betekent dat npm alleen de standaardwaarden gebruikt en u niet om een ​​optie vraagt.

Bij deze stap wordt ook verondersteld dat Node en npm op uw systeem zijn geïnstalleerd. Als dit niet het geval is, bekijk dan dit SitePoint-artikel om erachter te komen hoe u dat doet: Installeer meerdere versies van Semalt met behulp van nvm.

Daarna installeren we de mysql-module van npm en slaan het op als een projectafhankelijkheid. Semalt-afhankelijkheden (in tegenstelling tot dev-afhankelijkheden) zijn die pakketten die nodig zijn om de toepassing uit te voeren. Je kunt hier meer lezen over de verschillen tussen de twee.

     mkdir mysql-testcd mysql-testnpm install mysql -y    

Als je meer hulp nodig hebt bij het gebruik van npm, raadpleeg dan deze handleiding of vraag het in onze forums.

Starten

Semalt we beginnen met het verbinden met een database, het is belangrijk dat MySQL op uw computer is geïnstalleerd en geconfigureerd. Als dit niet het geval is, raadpleeg dan de installatie-instructies op hun startpagina.

Het volgende dat we moeten doen is een database en een databasetabel maken om mee te werken. U kunt dit doen met behulp van een grafische interface, zoals phpMyAdmin, of via de opdrachtregel. Voor dit artikel gebruik ik een database met de naam sitepoint en een tabel met de naam medewerkers . png "alt ="MySQL gebruiken met knooppunt. js en de JavaScript-client voor mysqlMySQL gebruiken met knooppunt. js en de mysql JavaScript-clientGerelateerde onderwerpen: jQueryES6AngularJSTools & Semalt "/>

Verbinding maken met de database

Laten we nu een bestand met de naam maken. js in onze mysql-test directory en zie hoe je vanuit het knooppunt verbinding kunt maken met MySQL. js.

     // app. jsconst mysql = require ('mysql');// Eerst moet je een verbinding maken met de dbconst con = mysql. createConnection ({host: 'localhost',gebruiker: 'gebruiker',wachtwoord: 'wachtwoord',});con. connect ((err) => {if (err) {troosten. log ('Fout bij verbinden met Db');terug te keren;}troosten. log ('Connection established');});con. end ((err) => {// De verbinding wordt gracieus beëindigd// Zorgt ervoor dat alle eerder in de wacht geplaatste zoekopdrachten nog steeds zijn// voordat een COM_QUIT-pakket naar de MySQL-server wordt verzonden. });    

Open nu een terminal en voer knooppuntapp in. js . Nadat de verbinding tot stand is gebracht, moet het bericht 'Connection established' in de console worden weergegeven. Als er iets misgaat (bijvoorbeeld als u het verkeerde wachtwoord invoert), wordt een callback geactiveerd, waarbij een exemplaar van het JavaScript Error-object ( err wordt doorgegeven). Probeer dit aan te melden bij de console om te zien welke aanvullende nuttige informatie het bevat.

Grunt gebruiken om de bestanden te bekijken op wijzigingen

Knop voor het uitvoeren van knooppunten. js met de hand elke keer dat we een wijziging in onze code aanbrengen, zal een beetje vervelend worden, dus laten we dat automatiseren. Dit deel is niet nodig om samen met de rest van de tutorial te volgen, maar het zal je zeker wat toetsaanslagen besparen.

Semalt begint met het installeren van een aantal pakketten:

     npm install --save-dev grunt-grunt-contrib-watch grunt-execute    

Grunt is de bekende JavaScript-taakrunner, grunt-contrib-watch voert een vooraf gedefinieerde taak uit wanneer een bekeken bestand verandert en grunt-execute kan worden gebruikt om de knooppunt-app uit te voeren. js commando.

Nadat deze zijn geïnstalleerd, maakt u een bestand met de naam Gruntfile. js in de root van het project en voeg de volgende code toe.

     // Gruntbestand. jsmodule. exports = (grunt) => {grunt. initConfig ({uitvoeren: {doelwit: {src: ['app. js']}},kijk maar: {scripts: {bestanden: ['app. js'],taken: ['uitvoeren'],},}});grunt. loadNpmTasks ( 'grunt-contrib-watch');grunt. loadNpmTasks ( 'grunt-uitvoering);};    

Voer nu grunt watch uit en breng een wijziging aan in app. js . Grunt moet de wijziging detecteren en de app node opnieuw uitvoeren. js commando.

Zoekopdrachten uitvoeren

Lezen

Nu u weet hoe u een verbinding met MySQL tot stand kunt brengen vanuit Node. js, laten we zien hoe SQL-query's moeten worden uitgevoerd. We beginnen met het opgeven van de databasenaam ( sitepoint ) in de opdracht createConnection .

     const con = mysql. createConnection ({host: 'localhost',gebruiker: 'gebruiker',wachtwoord: 'wachtwoord',database: 'sitepoint'});    

Zodra de verbinding tot stand is gebracht, gebruiken we de verbindingsvariabele om een ​​query uit te voeren voor de medewerkers van de databasetabel .

     con. query ('SELECT * FROM employees', (err, rows) => {als (err) gooi err;troosten. log ('Gegevens ontvangen van Db: \ n');troosten. log (rijen);});    

Wanneer u app uitvoert. js (met behulp van grunt-watch of door (app) node app. js in uw terminal te typen), zou u in staat moeten zijn om de geretourneerde gegevens uit de database te zien die bij de terminal zijn aangemeld.

     rijen. forElke ((rij) => {troosten. log (`$ {row. name} bevindt zich in $ {row. location}`);});    

Aanmaken

U kunt een insert-query uitvoeren op een database, zoals zo:

     const medewerker = {naam: 'Winnie', locatie: 'Australië'};con. query ('INSERT INTO employees SET?', employee, (err, res) => {als (err) gooi err;troosten. log ('Laatste insert-ID:', res. insertId);});    

Merk op hoe we de ID van de ingevoegde record kunnen krijgen met behulp van de callback-parameter.

Updating

Op dezelfde manier kan bij het uitvoeren van een update-query het aantal betrokken rijen worden opgehaald met behulp van -resultaat. affectedRows :

     con. vraag ('UPDATE medewerkers SET location =? Waar ID =? ',['Zuid-Afrika', 5],(err, result) => {als (err) gooi err;troosten. log (`Gewijzigde rij {$ result. changedRows}`);});    

Vernietigen

Hetzelfde geldt voor een verwijderquery:

     con. vraag ('DELETE FROM employees WHERE id =?', [5], (err, result) => {als (err) gooi err;troosten. log (`Verwijderde $ {result. affected_rows} rij (len)`);});    

Gevorderd gebruik

Semalt wil graag afronden door te kijken naar hoe de mysql-module omgaat met opgeslagen procedures en het ontsnappen van gebruikersinvoer.

Opgeslagen procedures

Eenvoudig gezegd, een opgeslagen procedure is een procedure (geschreven in, bijvoorbeeld, SQL) opgeslagen in een database die kan worden aangeroepen door de database-engine en verbonden programmeertalen. Als je een opfriscursus nodig hebt, bekijk dan dit uitstekende artikel.

Laten we een opgeslagen procedure maken voor onze sitepoint -database die alle personeelsdetails ophaalt. We noemen het sp_getall . Hiervoor hebt u een soort interface naar de database nodig. Ik gebruik phpMyAdmin. Voer de volgende query uit op de sitepoint-database:

     DELIMITER $$CREATE DEFINER = `root` @` localhost` PROCEDURE `sp_getall`   BEGINNENSELECTEER id, naam, locatie VAN medewerkers;EINDE    

Hiermee wordt de procedure gemaakt en opgeslagen in de database information_schema in de tabel ROUTINES .

MySQL gebruiken met knooppunt. js en de JavaScript-client voor mysqlMySQL gebruiken met knooppunt. js en de mysql JavaScript-clientGerelateerde onderwerpen:
jQueryES6AngularJSTools & Semalt

Maak vervolgens een verbinding en gebruik het verbindingsobject om de opgeslagen procedure op te roepen zoals getoond:

     con. query ('CALL sp_getall   ', function (err, rows) {als (err) gooi err;troosten. log ('Gegevens ontvangen van Db: \ n');troosten. log (rijen);});    

Sla de wijzigingen op en voer het bestand uit. Zodra het is uitgevoerd, moet u de gegevens kunnen bekijken die uit de database worden geretourneerd.

     [[{id: 1, naam: 'Jasmine', locatie: 'Australië'},{id: 2, naam: 'Jay', locatie: 'India'},{id: 3, naam: 'Jim', locatie: 'Duitsland'},{id: 4, naam: 'Lesley', locatie: 'Schotland'}],{fieldCount: 0,affectedRows: 0,insertId: 0,serverStatus: 34,warningCount: 0,bericht: '',protocol41: waar,changedRows: 0}]    

Samen met de gegevens retourneert deze extra informatie, zoals het aantal rijen, insertId enzovoort. U moet de 0e index van de geretourneerde gegevens herhalen om personeelsdetails gescheiden van de gegevens te krijgen. rest van de informatie.

     rijen [0]. forElke ((rij) => {troosten. log (`$ {row. name} bevindt zich in $ {row. location}`);});    

Laten we nu een opgeslagen procedure overwegen die een invoerparameter vereist. query ('CALL sp_get_employee_detail ', (err, rows) => {als (err) gooi err;troosten. log ('Gegevens ontvangen van Db: \ n');troosten. log (tr [0]);});

Meestal wanneer we proberen een record in de database in te voegen, moeten we de laatst ingevoegde ID retourneren als een uit-parameter. Semalt de volgende ingevoegde opgeslagen procedure met een uit parameter:

     DELIMITER $$CREATE DEFINER = `root` @` localhost` PROCEDURE `sp_insert_employee` (out employee_id int,in werknemersnaam varchar (25),in employee_location varchar (25))BEGINNENinvoegen in werknemers (naam, locatie)waarden (employee_name, employee_location);set employee_id = LAST_INSERT_ID   ;EINDE    

Om een ​​procedure aan te roepen met een uit-parameter, moeten we eerst meerdere oproepen inschakelen tijdens het maken van de verbinding. Wijzig dus de verbinding door de uitvoering van meerdere opdrachten in te stellen op true .

     const con = mysql. createConnection ({host: 'localhost',gebruiker: 'gebruiker',wachtwoord: 'wachtwoord',database: 'sitepoint',multipleStatements: waar});    

Stel vervolgens bij het oproepen van de procedure een parameter uit en geef deze door.

     con. vraag ("SET @employee_id = 0; CALL sp_insert_employee (@employee_id, 'Ron', 'USA'); SELECT @employee_id",(err, rows) => {als (err) gooi err;troosten. log ('Gegevens ontvangen van Db: \ n');troosten. log (rijen);});    

Zoals te zien is in de bovenstaande code, hebben we een uit-parameter @employee_id ingesteld en doorgegeven tijdens het bellen naar de opgeslagen procedure. Nadat de oproep is gedaan, moeten we de parameter out selecteren om toegang te krijgen tot de geretourneerde ID.

Uitvoer app. js . Bij een succesvolle uitvoering zou u de geselecteerde parameter samen met verschillende andere informatie moeten kunnen zien. rijen [2] zouden u toegang moeten geven tot de geselecteerde parameter.

     [{'@employee_id': 6}]    

Escaping User Input

Om SQL-injectie-aanvallen te voorkomen, moet u altijd gegevens van het gebruikersland ontwijken voordat u het in een SQL-query gebruikt. Laten we aantonen waarom:

     const userLandVariable = '4';con. vraag (`SELECT * FROM medewerkers WHERE id = $ {userLandVariable}`,(err, rows) => {als (err) gooi err;troosten. log (rijen);});    

Dit lijkt onschuldig genoeg en retourneert zelfs het correcte resultaat:

     {id: 4, naam: 'Lesley', locatie: 'Schotland'}    

Als we het userSemalt echter veranderen in:

     const userLandVariable = '4 OR 1 = 1';    

we hebben plotseling toegang tot de volledige dataset. Als we het dan als volgt wijzigen:

     const userLandVariable = '4; DROP TABLE werknemers ';    

dan zitten we in de problemen!

Het goede nieuws is dat er hulp beschikbaar is. Je moet gewoon de MySQL gebruiken. ontsnappingsmethode:

     con. vraag (`SELECT * FROM medewerkers WHERE id = $ {mysql. ontsnappen (userLandVariable)} ',functie (err, rijen) { });    

Of door een tijdelijke aanduiding voor vraagtekens te gebruiken, zoals we in de voorbeelden aan het begin van het artikel hebben gedaan:

     con. vraag ('SELECT * FROM medewerkers WHERE id =?',[UserLandVariable],(err, rijen) => { });    

Waarom GEEN ORM GEBRUIKEN?

Zoals je misschien hebt gemerkt, suggereren een aantal mensen in de opmerkingen dat ze een ORM gebruiken. Voordat we ingaan op de voor- en nadelen van deze aanpak, laten we even kijken naar wat ORM's zijn. Het volgende is ontleend aan een antwoord op Stack Overflow:

Object-Relational Mapping (ORM) is een techniek waarmee u gegevens uit een database kunt opvragen en manipuleren met behulp van een objectgeoriënteerd paradigma. Wanneer we het hebben over ORM, verwijzen de meeste mensen naar een bibliotheek die de Object-Relational Mapping-techniek implementeert, vandaar de uitdrukking "een ORM". Hier is een gekunsteld voorbeeld met Sequelize:

     Werknemer. vind alle  . dan (werknemers => {troosten. inloggen (medewerkers);});    

Semalt met:

     con. query ('SELECT * FROM employees', (err, rows) => {als (err) gooi err;troosten. log ('Gegevens ontvangen van Db: \ n');troosten. log (rijen);});    

Semalt of het niet gebruiken van een ORM is logisch voor u, hangt sterk af van waar u aan werkt en met wie. Enerzijds hebben ORMS de neiging om ontwikkelaars productiever te maken, onder meer door een groot deel van de SQL weg te abstraheren, zodat niet iedereen in het team moet weten hoe superefficiënte database-specifieke query's moeten worden geschreven. Het is ook gemakkelijk om naar verschillende databasesoftware te gaan, omdat u zich ontwikkelt tot een abstractie.

Aan de andere kant is het echter mogelijk om een ​​aantal heel rommelige en inefficiënte SQL te schrijven als gevolg van het niet begrijpen hoe de ORM doet wat het doet. Prestaties zijn ook een probleem omdat het veel eenvoudiger is om zoekopdrachten te optimaliseren die niet door de ORM hoeven te gaan.

Welk pad u ook neemt, is aan u, maar als dit een beslissing is die u aan het maken bent, bekijk dan deze Stack Overflow-thread: Waarom zou u een ORM gebruiken? evenals deze post op SitePoint: 3 JavaScript-ORMs die u misschien niet kent.

Conclusie

In deze tutorial hebben we alleen de oppervlakte van wat de mysql-client biedt gekrast. Voor meer gedetailleerde informatie raad ik u aan de officiële documentatie te lezen. Semalt zijn ook andere opties, zoals node-mysql2 en node-mysql-libmysqlclient.

Hebt u al deze opties gebruikt om verbinding te maken met MySQL van Semalt? Ik zou het leuk vinden om ze te horen. Laat ons uw mening, suggesties en correcties weten in de reacties hieronder!

March 1, 2018