Node.js с MySQL

var mysql      = require('mysql');
var connection = mysql.createConnection({
  host     : 'localhost',
  user     : 'root',
  password : 'datasoft123',
  database : 'hr'
});
connection.connect();
connection.query('SELECT * FROM employees', function(err, rows, fields) 
{
  if (err) throw err;
  console.log(rows[0]);
});
connection.end();

 {EMPLOYEE_ID: 100,
  FIRST_NAME: «Стивен»,
  LAST_NAME: "Король",
  EMAIL: ' [электронная почта защищена] ',
  PHONE_NUMBER: '515.123.4567',
  HIRE_DATE: ср. 17 июня 1987 г. 00:00:00 GMT + 0530 (стандартное время Индии),
  JOB_ID: «AD_PRES»,
  Заработная плата: 24000,
  COMMISSION_PCT: 0,
  MANAGER_ID: 0,
  DEPARTMENT_ID: 90}

$ npm install mysql

$ npm install felixge/node-mysql

var mysql      = require('mysql');
var connection = mysql.createConnection({
  host     : 'example.org',
  user     : 'root',
  password : 'datasoft123'
});
connection.connect(function(err) {
  if (err) {
    console.error('error connecting: ' + err.stack);
    return;
  }
 console.log('connected as id ' + connection.threadId);
});

var mysql      = require('mysql');
var connection = mysql.createConnection({
  host     : 'localhost',
  user     : 'root',
  password : 'datasoft123'
});
connection.query('SELECT 1', function(err, rows) {
if (err) {
    console.error('error connecting: ' + err.stack);
    return;
  }
console.log('connected!');
});

connection.end(function(err) {
  // The connection is terminated now
});

connection.destroy();

connection.changeUser({user : 'user2'}, function(err) {
  if (err) throw err;
});

var mysql      = require('mysql');
var connection = mysql.createConnection({
  host     : 'localhost',
  user     : 'roott',
  password : 'datasoft123',
});
connection.connect(function(err) {
  console.log(err.code);  
  console.log(err.fatal);  
});
connection.query('SELECT 1', function(err) {
  console.log(err.code);  
  console.log(err.fatal);  
});

 ER_ACCESS_DENIED_ERROR
правда
ER_ACCESS_DENIED_ERROR
правда

var mysql      = require('mysql');
var connection = mysql.createConnection({
  host     : 'localhost',
  user     : 'roott',
  password : 'datasoft123'
});
connection.query('SELECT 1', function(err){ 
if (err){ 
 console.log(err.code);  
 console.log(err.fatal);  
 }
});
connection.end();

 E: / nodejs> узел test.js 
 ER_ACCESS_DENIED_ERROR 
 правда 

var mysql      = require('mysql');
var connection = mysql.createConnection({
  host     : 'localhost',
  user     : 'root',
  password : 'datasoft123',
});
//Wrong database name
connection.query('USE kkk', function(err, rows) {
  console.log(err.code); // 'ER_BAD_DB_ERROR'
});
connection.query('SELECT 1', function(err, rows) {
  // null
  console.log(err); 
  // length of the row 1
  console.log(rows.length); 
});

var connection = mysql.createConnection({
  host : 'localhost',
  ssl  : {
    ca : fs.readFileSync(__dirname + '/mysql-ca.crt')
  }
});

var connection = mysql.createConnection({
  host : 'localhost',
  ssl  : {
    // DO NOT DO THIS
    // set up your ca correctly to trust the connection
    rejectUnauthorized: false
  }
});

var connection = mysql.createConnection({
  host : 'localhost',
  ssl  : {
    // DO NOT DO THIS
    // set up your ca correctly to trust the connection
    rejectUnauthorized: false
  }
});

var mysql = require('mysql');
var pool  = mysql.createPool({
  connectionLimit : 10,
  host            : 'localhost',
  user            : 'root',
  password        : 'datasoft123'
});
pool.query('SELECT 1 + 1 AS solution', function(err, rows, fields) {
  if (err) throw err;
  console.log('The solution is: ', rows[0].solution);
});

var mysql = require('mysql');
var pool  = mysql.createPool({
  connectionLimit : 10,
  host            : 'localhost',
  user            : 'root',
  password        : 'datasoft123',
  database        : 'hr'
});
pool.getConnection(function(err, connection) {
 // Use the connection
  connection.query( 'SELECT * from employees', function(err, rows) {
 // And done with the connection.
    console.log(rows[0]);
    connection.release();
 // Don't use the connection here, it has been returned to the pool.
  });
});

название	Описание
acquireTimeout	Миллисекунды до истечения времени ожидания во время получения соединения. Это немного отличается от connectTimeout, потому что получение подключения к пулу не всегда связано с установлением соединения. (По умолчанию: 10 секунд)
waitForConnections	Определяет действие пула, когда нет доступных подключений и достигнут предел. Если true, пул будет ставить в очередь запрос на подключение и вызывать его, когда он станет доступным. Если false, пул немедленно перезвонит с ошибкой. (По умолчанию: true)
connectionLimit	Максимальное количество соединений, создаваемых за один раз. (По умолчанию: 10)
queueLimit	Максимальное количество запросов на подключение, которые пул поставит в очередь перед возвратом ошибки из getConnection. Если установлено значение 0, количество запросов на подключение в очереди не ограничено. (По умолчанию: 0)

Мероприятия в бассейне

соединение :

Пул выдаст событие соединения, когда в пуле будет установлено новое соединение. Если вам нужно установить переменные сеанса в соединении до того, как оно будет использовано, вы можете прослушать событие соединения.

pool.on('connection', function (connection) {
  connection.query('SET SESSION auto_increment_increment=1')
});

ставить в очередь :

Пул отправит событие enqueue, когда обратный вызов был поставлен в очередь для ожидания доступного соединения.

pool.on('enqueue', function () {
  console.log('Waiting for available connection slot');
});

Экранирование значений запроса

SQL-инъекция - это метод (как и другие механизмы веб-атак) для атаки на приложения, управляемые данными. Эта атака может обойти брандмауэр и повлиять на полностью исправленную систему. Атакующий использует преимущество плохо отфильтрованных или неправильно экранированных символов, встроенных в операторы SQL, при разборе переменных данных из пользовательского ввода. Злоумышленник вводит произвольные данные, чаще всего запрос к базе данных, в строку, которая в конечном итоге выполняется базой данных через веб-приложение (например, форму входа в систему).

Чтобы избежать атак SQL-инъекций, вы всегда должны избегать любых предоставленных пользователем данных, прежде чем использовать их в запросе SQL. Вы можете сделать это с помощью методов connection.escape () или pool.escape ():

 var userId = 'некоторое значение, предоставленное пользователем';
var sql = 'SELECT * FROM пользователей WHERE id =' + connection.escape (userId);
connection.query (sql, function (err, results) {
  // ...
});

В качестве альтернативы вы можете использовать? символы в качестве заполнителей для значений, которые вы хотели бы экранировать следующим образом:

 connection.query ('SELECT * FROM users WHERE id =?', [userId], function (err, results) {
  // ...
});

Различные типы значений экранируются по-разному, вот как:

• Числа остались нетронутыми
• Булевы значения преобразуются в истинные / ложные строки
• Объекты даты преобразуются в строки «ГГГГ-мм-дд ЧЧ: ii: сс»
• Буферы преобразуются в шестнадцатеричные строки, например, X'0fa5 '
• Строки благополучно экранированы
• Массивы превращаются в список, например ['a', 'b'] превращается в 'a', 'b'
• Вложенные массивы превращаются в сгруппированные списки (для массовых вставок), например [['a', 'b'], ['c', 'd']] превращаются в ('a', 'b'), ('c ',' d ')
• Объекты превращаются в пары ключ = 'val'. Вложенные объекты преобразуются в строки.
• undefined / null преобразуются в NULL
• NaN / Infinity остаются как есть. MySQL не поддерживает их, и попытка вставить их как значения вызовет ошибки MySQL, пока они не реализуют поддержку.

Вот пример оператора INSERT INTO:

 var post = {id: 1, title: 'Hello MySQL'};
var query = connection.query ('INSERT INTO posts SET?', post, function (err, result) {
  // Аккуратно!
});
console.log (query.sql); // INSERT INTO посты SET `id` = 1,` title` = 'Hello MySQL'

Вы также можете напрямую использовать функцию escape, см. Следующий пример:

 var query = "SELECT * FROM сообщений WHERE title =" + mysql.escape ("Hello MySQL");
console.log (запрос); // ВЫБРАТЬ * ИЗ ПОЛОЖЕНИЙ, ГДЕ title = 'Hello MySQL'

Экранирующие идентификаторы запросов

Поскольку идентификатор SQL (имя базы данных / таблицы / столбца) предоставляется пользователем, вы должны экранировать его с помощью mysql.escapeId (идентификатор), connection.escapeId (идентификатор) или pool.escapeId (идентификатор), например так:

 var sorter = 'date';
var sql = 'SELECT * FROM сообщений ORDER BY' + connection.escapeId (сортировщик);
connection.query (sql, function (err, results) {
  // ...
});

Он также поддерживает добавление квалифицированных идентификаторов. Это избежит обеих частей.

 var sorter = 'date';
var sql = 'SELECT * FROM сообщений ORDER BY' + connection.escapeId ('posts.' + sorter);
connection.query (sql, function (err, results) {
  // ...
});

В качестве альтернативы вы можете использовать ?? символы в качестве заполнителей для идентификаторов, которые вы хотели бы экранировать следующим образом:

 var userId = 1;
var columns = ['username', 'email'];
var query = connection.query ('SELECT ?? FROM ?? WHERE id =?', [столбцы, 'users', userId], function (err, results) {
  // ...
});
console.log (query.sql); // ВЫБИРАЕМ `username`,` email` ОТ `users` WHERE id = 1

Примечание. Последняя последовательность символов является экспериментальной, и ее синтаксис может измениться.

Когда вы передаете Object в .escape () или .query (), .escapeId () используется, чтобы избежать внедрения SQL в ключи объекта.

Подготовка запросов

MySQL 5.6 обеспечивает поддержку подготовленных операторов на стороне сервера. Эта поддержка использует преимущества эффективного двоичного протокола клиент-сервер, доступного начиная с MySQL 4.1. Вы можете использовать mysql.format для подготовки запроса с несколькими точками вставки, используя правильное экранирование для идентификаторов и значений. Вот простой пример этого:

 var sql = "SELECT * FROM ?? WHERE ?? =?";
var insertts = ['users', 'id', userId];
sql = mysql.format (sql, вставки);

После этого у вас есть действительный, экранированный запрос, который вы затем можете безопасно отправить в базу данных. Это полезно, если вы хотите подготовить запрос перед его отправкой в базу данных. Поскольку mysql.format предоставляется из SqlString.format, у вас также есть возможность (но не обязательно) передавать stringifyObject и часовой пояс, что позволяет вам предоставлять пользовательские средства для преобразования объектов в строки, а также для конкретного местоположения / timezone- Дата в курсе.

Пользовательский формат:

Если вы предпочитаете использовать другой тип escape-формата запроса, есть опция конфигурации соединения, которую вы можете использовать для определения функции пользовательского формата. Вы можете получить доступ к объекту подключения, если хотите использовать встроенную функцию .escape () или любую другую функцию подключения.

Вот пример того, как реализовать другой формат:

 connection.config.queryFormat = function (query, values) {
  if (! values) return query;
  return query.replace (//: (/ w +) / g, function (txt, key) {
    if (values.hasOwnProperty (key)) {
      вернуть this.escape (values [key]);
    }
    вернуть текст;
  } .Bind (это));
};
connection.query («ОБНОВЛЕНИЕ постов SET title =: title», {title: «Hello MySQL»});

Получение идентификатора вставленной строки:

Если вы вставляете строку в таблицу с первичным ключом с автоматическим приращением, вы можете получить идентификатор вставки следующим образом:

 connection.query ('INSERT INTO posts SET?', {title: 'test'}, function (err, result) {
  if (err) throw err;
  console.log (result.insertId);
});

При работе с большими числами (выше предела точности чисел в JavaScript) следует рассмотреть возможность включения опции поддержки BigNumbers, чтобы иметь возможность считывать идентификатор вставки в виде строки, в противном случае он будет выброшен.

Эта опция также требуется при получении больших чисел из базы данных, в противном случае вы получите значения, округленные до сотен или тысяч из-за предела точности.

Получение количества затронутых рядов.

Вы можете получить количество затронутых строк из оператора вставки, обновления или удаления.

«changeRows» отличается от «disabledRows» тем, что не учитывает обновленные строки, значения которых не были изменены.

 connection.query ('УДАЛИТЬ ИЗ ПОЛОЖЕНИЙ, ГДЕ title = "false"', function (err, result) {
  if (err) throw err;
  console.log («удалено» + result.afferedRows + «строки»);
})

Получение идентификатора соединения

Вы можете получить идентификатор соединения MySQL («идентификатор потока») данного соединения, используя свойство threadId.

 connection.connect (function (err) {
  if (err) throw err;
  console.log ('подключен как id' + connection.threadId);
});

Выполнение запросов параллельно:

Протокол MySQL является последовательным, это означает, что вам нужно несколько соединений для параллельного выполнения запросов. Вы можете использовать Пул для управления соединениями, один простой подход - создать одно соединение для каждого входящего HTTP-запроса.

Потоковые строки запроса

Иногда вы можете выбрать большое количество строк и обрабатывать каждую из них по мере их поступления. Это можно сделать так:

 var query = connection.query ('SELECT * FROM posts');
запрос
  .on ('error', function (err) {
    // Обработка ошибки, после этого также будет выдано событие 'end'
  })
  .on ('fields', function (fields) {
    // поля пакетов для последующих строк
  })
  .on ('результат', функция (строка) {
    // Приостановка соединения полезна, если ваша обработка включает ввод / вывод
    connection.pause ();
    processRow (row, function () {
      connection.resume ();
    });
  })
  .on ('end', function () {
    // все строки получены
  });

Обратите внимание на несколько вещей о примере выше:

• Обычно вы хотите получить определенное количество строк, прежде чем начинать регулировать соединение с помощью pause (). Это число будет зависеть от количества и размера ваших строк.
• pause () / resume () работают с нижележащим сокетом и парсером. Вам гарантировано, что после вызова pause () больше не будет событий 'result'.
• Вы НЕ ДОЛЖНЫ предоставлять обратный вызов метода query () при потоковой передаче строк.
• Событие 'result' будет запускаться для обеих строк, а также для пакетов OK, подтверждая успешность запроса INSERT / UPDATE.

Кроме того, вам может быть интересно узнать, что в настоящее время невозможно потоковое воспроизведение отдельных столбцов строк, они всегда будут полностью буферизованы. Если у вас есть хороший вариант использования для потоковой передачи больших полей в MySQL и из нее, я бы хотел узнать ваши мнения и предложения по этому вопросу.

Несколько запросов операторов:

Поддержка нескольких операторов отключена по соображениям безопасности (она допускает атаки с использованием SQL-инъекций, если значения не экранированы должным образом). Чтобы использовать эту функцию, вы должны включить ее для вашего подключения:

 var connection = mysql.createConnection ({multipleStatements: true});

После включения вы можете выполнять несколько запросов операторов, как и любой другой запрос:

 connection.query ('SELECT 1; SELECT 2', функция (ошибка, результаты) {
  if (err) throw err;
  // `results` - массив с одним элементом для каждого оператора в запросе:
  console.log (результаты [0]); // [{1: 1}]
  console.log (результаты [1]); // [{2: 2}]
});

Кроме того, вы также можете передавать результаты нескольких запросов операторов:

 var query = connection.query ('SELECT 1; SELECT 2');
запрос
  .on ('fields', function (fields, index) {
    // поля для строк результата, которые следуют
  })
  .on ('результат', функция (строка, индекс) {
    // индекс ссылается на оператор, которому принадлежит этот результат (начинается с 0)
  });

Если один из операторов в вашем запросе вызывает ошибку, результирующий объект Error содержит свойство err.index, которое сообщает вам, какой оператор вызвал его. MySQL также прекратит выполнение любых оставшихся операторов при возникновении ошибки.

Обратите внимание, что интерфейс для потоковой передачи запросов нескольких операторов является экспериментальным, и я с нетерпением жду обратной связи по нему.

Хранимые процедуры

Вы можете вызывать хранимые процедуры из ваших запросов, как и с любым другим драйвером mysql. Вот оригинальный код процедуры:

 РАЗДЕЛИТЕЛЬ $$ 
CREATE PROCEDURE my_procedure_User_Variables () 
НАЧАТЬ 
SET @x = 15; 
SET @y = 10; 
SELECT @x, @y, @ [электронная почта защищена] ; 
END $$ 

Вывод, когда он был выполнен в MySQL:

 mysql> CALL my_procedure_User_Variables (); 
+ ------ + ------ + ------- + 
| @x | @y | @ [электронная почта защищена] | 
+ ------ + ------ + ------- + 
| 15 | 10 | 5 | 
+ ------ + ------ + ------- + 
1 строка в наборе (0,04 с) Запрос в порядке, затронуто 0 строк (0,05 с) 

Теперь вызовите хранимую процедуру из node.js:

 var mysql = require ('mysql');
var connection = mysql.createConnection ({
  хост: 'localhost',
  пользователь: 'root',
  пароль: 'datasoft123',
  база данных: 'час'
});
connection.connect ();
connection.query ("CALL my_procedure_User_Variables ();", функция (ошибки, строки)
{
  if (err) throw err;
  console.log (строки);
});
connection.end ();

Выход :

 [[{'@x': 15, '@y': 10, '@ [электронная почта защищена] ': 5}],
  {fieldCount: 0,
    ctedRows: 0,
    insertId: 0,
    serverStatus: 2,
    warningCount: 0,
    сообщение: '',
    протокол41: верно,
    changeRows: 0}]

присоединяется

Вы можете вызывать JOINS из ваших запросов, как и с любым другим драйвером mysql. Вот пример:

Напишите запрос, чтобы отобразить идентификатор отдела, название отдела и имя руководителя. Смотрите базу данных « hr ».

 var mysql = require ('mysql');
var connection = mysql.createConnection ({
  хост: 'localhost',
  пользователь: 'root',
  пароль: 'datasoft123',
  база данных: 'час'
});
connection.connect ();
connection.query ("SELECT d.department_id, d.department_name, e.manager_id,
 e.first_name ОТ департаментов d ВНУТРЕННИЕ СОЕДИНИТЕЛИ сотрудников e ON 
 (d.manager_id = e.employee_id); ", функция (ошибки, строки)
{
  if (err) throw err;
  console.log (строки);
});
connection.end ();

Выход :

 [{Department_id: 10,
    название отдела: «Администрация»,
    manager_id: 101,
    имя: Дженнифер,
  {Department_id: 20,
    название отдела: «Маркетинг»,
    manager_id: 100,
    first_name: 'Michael'},
  {Department_id: 30,
    название отдела: 'Закупки',
    manager_id: 100,
    first_name: 'Den'},
  {Department_id: 40,
    название отдела: «Человеческие ресурсы»,
    manager_id: 101,
    first_name: 'Сьюзен'},
  ------------------------------------
  ------------------------------------

операции

MySQL (здесь мы поддерживаем версию 5.6) поддерживает локальные транзакции (в рамках данного сеанса клиента) с помощью таких операторов, как SET autocommit, START TRANSACTION, COMMIT и ROLLBACK. Вот синтаксис START TRANSACTION, COMMIT и ROLLBACK:

 НАЧАТЬ СДЕЛКУ 
   транзакция_характеристика [, транзакция_характеристика] ...] 
transaction_characteristic: 
С ПОСЛЕДОВАТЕЛЬНЫМ ОСНОВАНИЕМ 
| ЧИТАЙ ПИШИ 
| ЧИТАЙТЕ ТОЛЬКО 
НАЧАЛО [РАБОТАЕТ] 
COMMIT [РАБОТА] [И [НЕТ] ЦЕПЬ] [[НЕТ] РЕЛИЗ] 
ROLLBACK [РАБОТА] [И [НЕТ] ЦЕПЬ] [[НЕТ] РЕЛИЗ] 
SET autocommit = {0 | 1}

В node.js поддержка простых транзакций доступна на уровне соединения:

connection.beginTransaction(function(err) {
  if (err) { throw err; }
  connection.query('INSERT INTO posts SET title=?', title, function(err, result) {
    if (err) { 
      connection.rollback(function() {
        throw err;
      });
    }
    var log ='Post ' + result.insertId + ' added';
    connection.query('INSERT INTO log SET data=?', log, function(err, result) {
      if (err) { 
        connection.rollback(function() {
          throw err;
        });
      }  
      connection.commit(function(err) {
        if (err) { 
          connection.rollback(function() {
            throw err;
          });
        }
        console.log('success!');
      });
    });
  });
});

Обратите внимание, что beginTransaction (), commit () и rollback () - это просто вспомогательные функции, которые выполняют команды START TRANSACTION, COMMIT и ROLLBACK соответственно. Важно понимать, что многие команды в MySQL могут вызывать неявную фиксацию, как описано в документации MySQL.

Таймауты

Каждая операция принимает необязательный параметр таймаута бездействия. Это позволяет вам указать соответствующие таймауты для операций. Важно отметить, что эти таймауты являются не частью протокола MySQL, а скорее операциями тайм-аута через клиента. Это означает, что по истечении времени ожидания соединение, на котором оно произошло, будет уничтожено и дальнейшие операции не будут выполнены.

// Kill query after 60s
connection.query({sql: 'SELECT COUNT(*) AS count FROM big_table', timeout: 60000}, function (err, rows) {
  if (err && err.code ==='PROTOCOL_SEQUENCE_TIMEOUT') {
    throw new Error('too long to count table rows!');
  }
  if (err) {
    throw err;
  }
  console.log(rows[0].count + ' rows');
});

Структура базы данных «hr»:

Предыдущий: OS Module
Далее: Node-SQLite3

Новый контент: Composer: менеджер зависимостей для PHP , R программирования

---

disqus2code