Hướng dẫn how to keep mysql connection alive in node js - cách giữ kết nối mysql tồn tại trong nút js

Tôi đang sử dụng các nhóm kết nối MySQL trong Node JS. Sau một thời gian nhàn rỗi, các kết nối hết hạn và lần tiếp theo tôi thực hiện truy vấn, một kết nối mới cần được tạo. Điều này có thể gây ra sự chậm trễ vài giây. Không thể chấp nhận được!

Tôi muốn thực hiện chức năng giữ cho định kỳ cơ sở dữ liệu và đảm bảo sức khỏe nhất quán của các kết nối với phụ trợ. Tôi đang tìm kiếm đầu vào từ những người khác đã cố gắng tương tự, hoặc phản hồi về cách tiếp cận của tôi.

const mysql = require['mysql'];
const pool = createConnectionPool[];

setInterval[keepalive, 180000]; // 30 mins

function keepalive[] {
  pool._freeConnections.forEach[[connection] => pool.acquireConnection[connection,function [] {
    connection.query['SELECT 1 + 1 AS solution', function [err] {
      if [err] {
        console.log[err.code]; // 'ER_BAD_DB_ERROR'
      }
      console.log['Keepalive RDS connection pool using connection id', connection.threadId];
    }]
  }]];
}

Điều này đã thành công một chút: - Một khi kết nối được mở, nó vẫn mở - các kết nối không bao giờ hết thời gian - nếu một kết nối bị mất, nó sẽ được tái tạo trong khoảng thời gian tiếp theo
- once a connection is opened, it stays open
- connections never time out
- if a connection is lost, it is recreated on the next interval

Điều này là không lý tưởng: - Nhóm kết nối MySQL lười biếng, chỉ tạo và khôi phục các kết nối khi cần thiết. Với thứ này, hồ bơi không còn lười biếng nữa. Khi một kết nối được mở, Keepalive sẽ giữ cho nó mở. Các hồ bơi không còn quy mô tùy thuộc vào giao thông. - Tôi không tự tin rằng phương pháp lặp lại của tôi thông qua danh sách các kết nối miễn phí và thực hiện truy vấn sẽ là một cách tiếp cận khôn ngoan. Ứng dụng có thể kiểm tra cùng một kết nối từ nhóm trong khi cùng một kết nối đang được Keepalive sử dụng không?
- the mysql connection pool is lazy, only creating and restoring connections as needed. with this keepalive, the pool is no longer lazy. once a connection is opened, the keepalive will keep it open. the pool no longer scales depending on traffic.
- i'm not confident that my method of iterating through the list of free connections and performing a query will be a wise approach. is it possible for the application to check out the same connection from the pool while the same connection is being used by keepalive?

Một cách tiếp cận có thể khác là bỏ chức năng giữ trong ứng dụng và dựa vào lưu lượng trái tim để giữ cho tối thiểu các kết nối tồn tại.

Có ai đã cố gắng thực hiện chức năng Keepalive, sử dụng gói hoặc công cụ cung cấp tính năng này hoặc kết thúc bằng cách sử dụng một cách tiếp cận khác không?

Kết nối với máy chủ MySQL có thể được thiết lập bằng cách tạo

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    host: 'localhost',
    port: 33060,
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

4 thông qua phương thức

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    host: 'localhost',
    port: 33060,
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

5 có sẵn trong API mô -đun chính. Phiên sẽ được thiết lập thông qua plugin X, theo mặc định, lắng nghe trên cổng TCP

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    host: 'localhost',
    port: 33060,
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

6. Ngoài ra, theo mặc định, các phiên giao thức X được thiết lập bằng TLS và phương thức xác thực

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    host: 'localhost',
    port: 33060,
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

7 [chi tiết có sẵn ở đây].

Sử dụng URI:

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Sử dụng chuỗi kết nối "hợp nhất", về cơ bản là phiên bản giảm của định dạng URI [không có sơ đồ]:

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Sử dụng đối tượng cấu hình phiên:

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    host: 'localhost',
    port: 33060,
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Nếu máy chủ đang chạy trong cùng một máy với máy khách và bị ràng buộc với ổ cắm unix cục bộ [chưa hỗ trợ cho các ống Windows], các ví dụ trước đó sẽ hoạt động, với một số khác biệt ký hiệu nhỏ.

Sử dụng URI với đường dẫn ổ cắm được mã hóa PCT:

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

Sử dụng URI với đường dẫn ổ cắm không được mã hóa:

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@[/path/to/socket]/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

Sử dụng chuỗi kết nối "hợp nhất" với đường dẫn ổ cắm được mã hóa PCT:

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

Sử dụng chuỗi kết nối "hợp nhất" với đường dẫn ổ cắm không được mã hóa:

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@[/path/to/socket]/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

Sử dụng đối tượng cấu hình phiên:

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    socket: '/path/to/socket',
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

Nếu máy chủ đang chạy trong cùng một máy với máy khách và bị ràng buộc với ổ cắm unix cục bộ [chưa hỗ trợ cho các ống Windows], các ví dụ trước đó sẽ hoạt động, với một số khác biệt ký hiệu nhỏ.

Sử dụng URI với đường dẫn ổ cắm được mã hóa PCT:

Sử dụng URI với đường dẫn ổ cắm không được mã hóa:

Sử dụng chuỗi kết nối "hợp nhất" với đường dẫn ổ cắm được mã hóa PCT:
Sử dụng chuỗi kết nối "hợp nhất" với đường dẫn ổ cắm không được mã hóa:

Nhiều máy chủ và chuyển đổi dự phòng

const mysqlx = require['@mysql/xdevapi'];

const uri = 'mysqlx://root:passwd@[127.0.0.1:33060, 127.0.0.1:33061, 127.0.0.1:33062]';
// or
const options = {
    endpoints: [{
        host: '127.0.0.1',
        port: 33060
    }, {
        host: '127.0.0.1',
        port: 33061
    }, {
        host: '127.0.0.1',
        port: 33062
    }],
    user: 'root',
    password: 'passwd'
};

// if neither 33060 nor 33061 are available
mysqlx.getSession[uri]
    .then[session => {
        console.log[session.inspect[].port]; // 33062
    }];

// if neither 33060 nor 33062 are available
mysqlx.getSession[uri]
    .then[session => {
        console.log[session.inspect[].port]; // 33061
    }];

// if neither 33061 nor 33062 are available
mysqlx.getSession[options]
    .then[session => {
        console.log[session.inspect[].port]; // 33060
    }];

// if only 33060 is not available, any of the other two can be picked
mysqlx.getSession[options]
    .then[session => {
        console.log[session.inspect[].port]; // 33061 or 33062
    }]

Nhiều điểm cuối của bộ định tuyến hoặc máy chủ MYSQL [máy chủ và/hoặc cổng hoặc unix] có thể được cung cấp khi tạo phiên. Điều này cho phép đầu nối thực hiện lựa chọn chuyển đổi dự phòng tự động khi các điểm cuối không có sẵn. Lựa chọn được thực hiện dựa trên mức độ ưu tiên được chỉ định cho mỗi điểm cuối hoặc ngẫu nhiên nếu mức độ ưu tiên không được coi là.

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Các ưu tiên rõ ràng nên bắt đầu ở

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    host: 'localhost',
    port: 33060,
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

8 [ưu tiên thấp nhất] và kết thúc ở

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    host: 'localhost',
    port: 33060,
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

9 [ưu tiên cao nhất]. Khi hai điểm cuối có cùng mức độ ưu tiên, một trong số chúng sẽ được chọn ngẫu nhiên.

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

CẢNH BÁO

Trong các phiên bản trước của Trình kết nối/Node.js, các điểm cuối sẽ được gán một ưu tiên giảm dần ngầm theo vị trí của chúng trong danh sách. Đây không còn là trường hợp.

Khi thiết lập các điểm cuối chuyển đổi dự phòng đa

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Thiết lập các máy chủ chuyển đổi dự phòng với mức độ ưu tiên rõ ràng:

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Trộn các điểm cuối có và không có ưu tiên là không thể với chuỗi kết nối. Có thể làm điều đó bằng cách sử dụng một đối tượng cấu hình nhưng nó không được bảo vệ. Trong trường hợp nó xảy ra, các điểm cuối không có ưu tiên sẽ chỉ được chọn ngẫu nhiên và nếu chỉ có các điểm cuối với một ưu tiên cụ thể có sẵn tại thời điểm này.

Thời gian chờ kết nối

Theo mặc định, kết nối máy chủ ban đầu sẽ hết thời gian chờ sau 10 giây trong một kịch bản duy nhất và sau 10 giây cho mỗi lần thử kết nối trong một kịch bản đa lưu trữ. Hành vi này có thể được ghi đè bằng cách cung cấp giá trị thời gian chờ tùy chỉnh, đó là một số nguyên đại diện cho số lượng

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

0 để chờ kết nối hợp lệ.

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Trong một kịch bản duy nhất, khi một kết nối không được thiết lập trong khoảng thời gian xác định, điều sau đây sẽ xảy ra:

Giá trị tùy chỉnh cũng có thể được xác định bằng cách sử dụng đối tượng JavaScript đơn giản, có tên thuộc tính đối tác, trong trường hợp này là

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

Trong một kịch bản nhiều máy chủ, thông báo lỗi sẽ hơi khác một chút:

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Để vô hiệu hóa rõ ràng thời gian chờ, người ta có thể sử dụng

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Làm việc với các lược đồ

Như thường lệ trong MySQL, tất cả các bảng, chế độ xem và bộ sưu tập sống trong một không gian tên nhất định được gọi là lược đồ chính thức. Một thể hiện

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    host: 'localhost',
    port: 33060,
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

4 cung cấp các cấu trúc để quản lý các lược đồ cơ sở dữ liệu trong phạm vi của một phiên nhất định.

Quyền muaNghĩaMặc định

Đã bật	Bật/tắt gộp	thật
Tối đa	Số lượng kết nối tối đa được hỗ trợ bởi nhóm	25
Maxidletime	Số mili giây tối đa để cho phép kết nối không hoạt động [0 = vô hạn]	0
Queuetimeout	Số mili giây tối đa để chờ kết nối có sẵn [0 = Infinite]	0

Lưu ý: Tùy chọn gộp

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

6 khác với tùy chọn Connection

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

1. Trong một kịch bản gộp, đã có các kết nối trong nhóm, vì vậy

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

6 kiểm soát thời gian chờ đợi để có được kết nối từ nhóm, chứ không phải chờ đợi kết nối đó được thiết lập.

Tạo một nhóm với các tùy chọn mặc định

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Tạo một nhóm với các tùy chọn cấu hình tùy chỉnh

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Mỗi phiên được tạo từ nhóm kết nối bao gồm phương thức

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

9, trong trường hợp này, sẽ phát hành kết nối từ nhóm và cung cấp nó trong các yêu cầu kết nối tiếp theo.

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Mặt khác, ví dụ của khách hàng bao gồm một phương thức

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

9 phá hủy hiệu quả nhóm và làm sạch mọi tham chiếu kết nối không sử dụng.

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Nhìn chung, khi gộp kết nối được bật, các tình huống sau đây có thể sẽ xảy ra khi kết nối được yêu cầu từ một nhóm chứa các kết nối

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@[/path/to/socket]/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

Một kết nối sẽ có sẵn khi một phiên hiện có trước đó được đóng rõ ràng.

Không có kết nối nào có sẵn và máy khách sẽ bị treo, khi không có phiên nào trước đó được đóng rõ ràng, nếu cả

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

6 và

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@[/path/to/socket]/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

3 được đặt thành giá trị mặc định của chúng là

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    host: 'localhost',
    port: 33060,
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

8 ms.

Một lỗi thời gian chờ sẽ được ném nếu vượt quá thời gian được chỉ định bởi

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

Mỗi kết nối giao thức X khớp với phiên X DevAPI thông thường của riêng mình, có nghĩa là mỗi khi phương thức

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@[/path/to/socket]/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

6 được gọi, một phiên máy chủ mới cũng được tạo từ một bảng xếp hạng sạch.

Thuộc tính kết nối

Chi tiết hoạt động tùy chỉnh về ứng dụng có thể bị lỗi và được gửi đến máy chủ MySQL bằng các thuộc tính kết nối, cung cấp thông tin đó trong cơ sở dữ liệu, trong các bảng

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@[/path/to/socket]/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

7 sau:

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@[/path/to/socket]/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

8, thuộc tính cho phiên hiện tại và các phiên khác được liên kết với phiên

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@[/path/to/socket]/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

9, thuộc tính cho tất cả các phiên

Các thuộc tính này được xác định khi tạo phiên X Devapi mới và sẽ bất biến trong suốt thời gian sống của phiên đó. Điều đó có nghĩa là không thể sử dụng chúng để lưu trữ thông tin thoáng qua, chẳng hạn như số lượng hàng đã được xử lý đến một điểm cho hay liệu kết nối có giao dịch hoạt động hay không, dòng mã ứng dụng nào được thực thi, v.v. Tuy nhiên, chúng rất hữu ích cho mục đích khắc phục sự cố.

Có hai loại thuộc tính khác nhau. Các thuộc tính do khách hàng xác định, được ánh xạ giá trị khóa được bảo lưu ngầm được mã hóa bởi trình kết nối. Các thuộc tính do người dùng xác định là ánh xạ giá trị khóa được cung cấp bởi người dùng/ứng dụng thông qua API công khai.

Trình kết nối/Node.js sử dụng, theo mặc định, danh sách các thuộc tính do khách hàng xác định sau:

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

0, bộ định danh quy trình trên máy nơi ứng dụng đang chạy

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

1, kiến trúc nền tảng nơi ứng dụng đang chạy

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

2, tên và phiên bản nền tảng trong đó ứng dụng đang chạy [ví dụ:

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

4, tên máy chủ của máy nơi ứng dụng đang chạy

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

5 [

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

7, phiên bản của Trình kết nối/Node.js được sử dụng bởi ứng dụng

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

8 [

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@%2Fpath%2Fto%2Fsocket/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

Theo mặc định, trong các kịch bản sau, khi không có thuộc tính nào được xác định rõ ràng, các thuộc tính do máy khách xác định sẽ được gửi đến máy chủ bất kể.

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Gửi các thuộc tính do người dùng xác định có thể được thực hiện như sau:

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Tên thuộc tính trùng lặp không được phép khi sử dụng chuỗi kết nối. Khi sử dụng đối tượng JavaScript hoặc JSON đơn giản, định nghĩa giá trị thuộc tính cuối cùng sẽ đứng. Tên thuộc tính do khách hàng xác định bắt đầu bằng

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@[/path/to/socket]/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

0, điều đó có nghĩa là quy ước này không được phép cho các thuộc tính do người dùng xác định. Ngoài ra, do các bảng hạn chế lược đồ của các bảng

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['mysqlx://root:passwd@[/path/to/socket]/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

7, giao thức X chỉ cho phép ánh xạ giá trị khóa dựa trên chuỗi, có nghĩa là các giá trị không định hướng và/hoặc lồng nhau không có hỗ trợ hạng nhất và được "chuỗi" theo mặc định theo mặc định .

Cũng lưu ý rằng các chuỗi trống,

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@[/path/to/socket]/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

2 hoặc

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@[/path/to/socket]/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

3 Các giá trị thuộc tính sẽ bị ép buộc với giá trị

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@[/path/to/socket]/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

4 của MySQL.

Tính năng này có thể bị vô hiệu hóa và không có thuộc tính kết nối nào sẽ được gửi bất cứ điều gì [do khách hàng xác định hoặc do người dùng xác định].

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Giải quyết các bản ghi SRV cho một máy chủ nhất định

Khi sử dụng máy chủ DNS hoặc bất kỳ tiện ích khám phá dịch vụ hoặc loại nào hỗ trợ ánh xạ SRV Record .

Chẳng hạn, với máy chủ DNS ở điểm cuối ____776, với ánh xạ dịch vụ sau:

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Máy khách sẽ kết nối với máy chủ đích tốt nhất, được ưu tiên và trọng lượng.

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Nếu máy chủ đích ưu tiên cao nhất không có sẵn, thì sự thay thế phù hợp nhất sẽ được chọn:

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Hành vi cũng nên áp dụng cho các kết nối gộp, sử dụng giao diện

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@[/path/to/socket]/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

7. Một kịch bản có liên quan trong một thiết lập gộp là khi kết nối được phát hành trở lại nhóm và máy chủ mục tiêu ban đầu không khả dụng vì nó bị hỏng hoặc nó đã bị xóa khỏi danh sách bản ghi SRV. Trong trường hợp đó, các cuộc gọi tiếp theo đến

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    host: 'localhost',
    port: 33060,
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

5 sẽ mang lại kết nối với máy chủ có sẵn tiếp theo, theo các quy tắc tương tự được thiết lập bởi ưu tiên và trọng lượng.

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@localhost:33060/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Lưu ý: Cố gắng tạo kết nối với ổ cắm UNIX, cổng máy chủ hoặc nhiều tên máy chủ trong khi cho phép độ phân giải SRV sẽ dẫn đến lỗi.

Kết nối được đóng bởi máy chủ

Một kết nối máy chủ có thể bị đóng vì nhiều lý do, do lỗi không mong muốn hoặc đơn giản là vì máy chủ quyết định đóng kết nối đã đưa ra một trong những lý do sau:

Kết nối không hoạt động [một hoặc cả

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@[/path/to/socket]/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

9 và

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    socket: '/path/to/socket',
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

0 đã bị vượt quá]

Kết nối đã bị giết trong một phiên khác [sử dụng lệnh API quản trị

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    socket: '/path/to/socket',
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

1 hoặc câu lệnh SQL

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    socket: '/path/to/socket',
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

Bản thân máy chủ đang tắt

Trong tất cả các kịch bản này, khi kết nối được đóng, nó không thể được sử dụng lại bởi một phiên hiện có. Tuy nhiên, trong hai kịch bản đầu tiên, máy chủ có thể vẫn có sẵn, điều đó có nghĩa là chúng ta có thể cố gắng kết nối lại. Đây cũng là trường hợp khi có các máy chủ khác có sẵn trong cài đặt nhiều máy chủ.

Điều này giới thiệu một hành vi nhóm kết nối tùy chỉnh, trong đó tất cả các kết nối đã được máy chủ đóng lại được giải phóng một cách hiệu quả khỏi nhóm bất cứ khi nào kết nối mới cố gắng có được, bất kể giá trị của

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    socket: '/path/to/socket',
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

3 đã bị vượt quá.

Vì vậy, ví dụ, khi

const mysqlx = require['@mysql/xdevapi'];

mysqlx.getSession['root:passwd@[/path/to/socket]/mySchema']
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', socket: '/path/to/socket' }
    }];

9 được đặt thành 10 giây:

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    host: 'localhost',
    port: 33060,
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Khi kết nối bị giết từ một phiên khác:

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    host: 'localhost',
    port: 33060,
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Khi máy chủ đang tắt và không có máy chủ nào khác:

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    host: 'localhost',
    port: 33060,
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Khi máy chủ đang tắt nhưng có sẵn các máy chủ khác:

const mysqlx = require['@mysql/xdevapi'];

const config = {
    password: 'passwd',
    user: 'root',
    host: 'localhost',
    port: 33060,
    schema: 'mySchema'
};

mysqlx.getSession[config]
    .then[session => {
        console.log[session.inspect[]]; // { user: 'root', host: 'localhost', port: 33060 }
    }];

Làm cách nào để giữ kết nối MySQL còn sống?

Để ngăn chặn các kết nối này được tự động đóng, đầu nối có thể được cấu hình để giữ cho kết nối tồn tại bằng cách gửi một câu lệnh Chọn đơn giản [thực sự chọn 'keep_alive';] định kỳ để đảm bảo rằng thời gian chờ MySQL không đạt được và kết nối đóng.submitting a simple SELECT statement [actually SELECT 'KEEP_ALIVE';] periodically to ensure that the MySQL timeout is not reached and the connection closed.

Node JS xử lý kết nối MySQL như thế nào?

Để tải xuống và cài đặt mô -đun "MySQL", hãy mở thiết bị đầu cuối lệnh và thực hiện các mục sau:..

C: \ Users \ Your Name> NPM Cài đặt MySQL ..

var mysql = yêu cầu ['mysql'] ;.

Chạy "demo_db_connection.js" C: \ users \ tên của bạn> node demo_db_connection.js ..

Connected!.

con.Kết nối [hàm [err] {if [err] ném err; bảng điều khiển ..

Tôi có nên đóng kết nối MySQL sau mỗi truy vấn không?

Đóng rõ ràng các kết nối mở và bộ kết quả miễn phí là tùy chọn.Tuy nhiên, bạn nên đóng kết nối ngay khi tập lệnh kết thúc thực hiện tất cả các hoạt động cơ sở dữ liệu của nó, nếu nó vẫn còn nhiều việc phải thực hiện sau khi nhận được kết quả.it's a good idea to close the connection as soon as the script finishes performing all of its database operations, if it still has a lot of processing to do after getting the results.

Có tốt không khi sử dụng MySQL với Node JS?

JS được kết hợp với MongoDB và các cơ sở dữ liệu NoQuery khác, nhưng Node.js cũng hoạt động tốt với các cơ sở dữ liệu quan hệ như MySQL.Nếu bạn muốn viết một microservice mới với nút.JS cho một cơ sở dữ liệu hiện có, rất có khả năng bạn sẽ sử dụng MySQL, một trong những cơ sở dữ liệu nguồn mở phổ biến nhất thế giới.Node. js performs well with relational databases like MySQL, too. If you want to write a new microservice with Node. js for an existing database, it's highly likely that you'll use MySQL, one of the world's most popular open-source databases.

Nếu máy chủ đang chạy trong cùng một máy với máy khách và bị ràng buộc với ổ cắm unix cục bộ [chưa hỗ trợ cho các ống Windows], các ví dụ trước đó sẽ hoạt động, với một số khác biệt ký hiệu nhỏ.

CẢNH BÁO

Trong một kịch bản duy nhất, khi một kết nối không được thiết lập trong khoảng thời gian xác định, điều sau đây sẽ xảy ra:

Làm việc với các lược đồ

Tạo một nhóm với các tùy chọn mặc định

Tạo một nhóm với các tùy chọn cấu hình tùy chỉnh

Thuộc tính kết nối

Giải quyết các bản ghi SRV cho một máy chủ nhất định

Kết nối được đóng bởi máy chủ

Làm cách nào để giữ kết nối MySQL còn sống?

Node JS xử lý kết nối MySQL như thế nào?

Tôi có nên đóng kết nối MySQL sau mỗi truy vấn không?

Có tốt không khi sử dụng MySQL với Node JS?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề