Node.js - MySQL 插入資料

Hello there, future coding superstars! Today, we're going to embark on an exciting journey into the world of Node.js and MySQL. Specifically, we'll be focusing on how to insert data into a MySQL database using Node.js. Don't worry if you're new to programming - I'll be your friendly guide, explaining everything step by step. So, let's dive in!

Node.js - MySQL Insert Into

What is Node.js and MySQL?

Before we start, let's quickly understand what Node.js and MySQL are:

Node.js: It's a powerful JavaScript runtime that allows you to run JavaScript on your computer, not just in a web browser.
MySQL: It's a popular database system that helps store and manage data.

Think of Node.js as a chef and MySQL as a big, organized refrigerator. We'll use Node.js to cook up some code that puts data into our MySQL refrigerator!

Setting Up Our Environment

First things first, we need to set up our kitchen (I mean, our development environment). Here's what you need to do:

Install Node.js from the official website (nodejs.org)
Install MySQL from mysql.com
Install the MySQL module for Node.js by running this command in your terminal:

npm install mysql

Great! Now we have all our ingredients ready. Let's start cooking... I mean, coding!

Insert with Node.js

Establishing a Connection

Before we can insert data, we need to connect to our MySQL database. Here's how we do it:

const mysql = require('mysql');

const connection = mysql.createConnection({
host: 'localhost',
user: 'your_username',
password: 'your_password',
database: 'your_database_name'
});

connection.connect((err) => {
if (err) {
console.error('Error connecting to the database: ' + err.stack);
return;
}
console.log('Connected to database.');
});

Let's break this down:

We require the MySQL module we installed earlier.
We create a connection using mysql.createConnection(), providing our database details.
We use connection.connect() to actually connect to the database.
If there's an error, we log it. Otherwise, we confirm we're connected.

Simple INSERT Query

Now that we're connected, let's insert some data! Imagine we have a table called users with columns id, name, and email. Here's how we can insert a new user:

const newUser = { name: 'John Doe', email: '[email protected]' };

connection.query('INSERT INTO users SET ?', newUser, (error, results) => {
if (error) throw error;
console.log('New user added with ID: ' + results.insertId);
});

What's happening here?

We create an object newUser with the data we want to insert.
We use connection.query() to send an SQL query to the database.
The ? in the query is a placeholder. MySQL replaces it with our newUser object.
If successful, MySQL returns some results, including the ID of the new record.

Inserting Multiple Records

What if we want to add several users at once? We can do that too!

const users = [
{ name: 'Alice', email: '[email protected]' },
{ name: 'Bob', email: '[email protected]' },
{ name: 'Charlie', email: '[email protected]' }
];

connection.query('INSERT INTO users (name, email) VALUES ?', [users.map(user => [user.name, user.email])], (error, results) => {
if (error) throw error;
console.log('Number of records inserted: ' + results.affectedRows);
});

Here's what's new:

We create an array of user objects.
We use users.map() to transform our array into the format MySQL expects.
The ? placeholder now represents multiple sets of values.
results.affectedRows tells us how many records were inserted.

INSERT with Prepared Statement

Now, let's level up our game with prepared statements. These are like recipes that we can use over and over, just changing the ingredients (data) each time.

const sql = "INSERT INTO users (name, email) VALUES (?, ?)";
const values = ['David', '[email protected]'];

connection.query(sql, values, (error, results) => {
if (error) throw error;
console.log('New user added with ID: ' + results.insertId);
});

What's special here?

We separate our SQL query and our data.
The ? placeholders in the SQL represent where our data will go.
We pass the values array as a separate argument to query().

This method is safer and can protect against SQL injection attacks. It's like using a trusted recipe instead of just throwing ingredients together!

Reusing Prepared Statements

The real power of prepared statements shines when we reuse them:

const sql = "INSERT INTO users (name, email) VALUES (?, ?)";
const users = [
['Eva', '[email protected]'],
['Frank', '[email protected]'],
['Grace', '[email protected]']
];

users.forEach(user => {
connection.query(sql, user, (error, results) => {
if (error) throw error;
console.log('New user added with ID: ' + results.insertId);
});
});

Here, we're using the same SQL "recipe" for each user, just changing the "ingredients" (values) each time.

Closing the Connection

Don't forget to close the kitchen when you're done cooking! I mean, close the database connection when you're done querying:

connection.end((err) => {
if (err) {
console.error('Error closing the database connection: ' + err.stack);
return;
}
console.log('Database connection closed.');
});

This ensures we're not leaving any connections open, which could slow down our application or the database server.

Summary of Methods

Here's a quick reference table of the methods we've learned:

Method	Description
`mysql.createConnection()`	Creates a connection to the MySQL database
`connection.connect()`	Establishes the database connection
`connection.query()`	Executes an SQL query
`connection.end()`	Closes the database connection

Conclusion

Congratulations! You've just learned how to insert data into a MySQL database using Node.js. We've covered simple inserts, multiple inserts, and even prepared statements. Remember, practice makes perfect, so don't be afraid to experiment with these concepts.

In my years of teaching, I've found that the best way to learn is by doing. So, why not create a small project? Maybe a simple app that stores your favorite recipes in a database? That way, you can practice your new skills and never lose Grandma's secret cookie recipe again!

Happy coding, and may your databases always be properly normalized!

Credits: Image by storyset