Hướng dẫn mysql module provides which method to escape query values mcq - mô-đun mysql cung cấp phương thức nào để thoát các giá trị truy vấn mcq

Question

Chọn với bộ lọc

Khi chọn bản ghi từ bảng, bạn có thể lọc lựa chọn bằng cách sử dụng câu lệnh "WHERE":

Nội dung chính Show

Chọn với bộ lọc
Ký tự ký tự đại diện
Ký tự ký tự đại diện
10.5.4 & nbsp; mysqlcursor.execute () Phương thức
12.8.1 & NBSP; Chức năng so sánh chuỗi và toán tử
Làm thế nào để bạn trốn thoát trong mysql?
Làm cách nào để thoát khỏi các ký tự đặc biệt trong truy vấn chọn mysql?
Nhân vật nào là nhân vật thoát cho MySQL?
Phương thức Fetchall () con trỏ làm gì?

Thí dụ

Chọn (các) bản ghi trong đó địa chỉ là "Park Lane 38": Kết quả:

Nhập MySQL.Connector

myDB = mysql.connector.connect (& nbsp; host = "localhost", & nbsp; user = "yourusername", & nbsp; password = "yourPassword", & nbsp; cơ sở dữ liệu = "mydatabase")
host="localhost",
user="yourusername",
password="yourpassword",
database="mydatabase"
)

mycursor = mydb.cursor ()

SQL = "Chọn * Từ khách hàng trong đó địa chỉ = 'Park Lane 38'"

mycursor.execute(sql)

myResult = mycursor.fetchall ()

cho x trong myResult: & nbsp; in (x)
print(x)

Chạy ví dụ »

Ký tự ký tự đại diện

Bạn cũng có thể chọn các bản ghi bắt đầu, bao gồm hoặc kết thúc bằng một chữ cái hoặc cụm từ nhất định.

Sử dụng ________ 16 & nbsp; Để đại diện cho ký tự ký tự đại diện:

Thí dụ

Chọn (các) bản ghi trong đó địa chỉ là "Park Lane 38": Kết quả:

Nhập MySQL.Connector

myDB = mysql.connector.connect (& nbsp; host = "localhost", & nbsp; user = "yourusername", & nbsp; password = "yourPassword", & nbsp; cơ sở dữ liệu = "mydatabase")
host="localhost",
user="yourusername",
password="yourpassword",
database="mydatabase"
)

mycursor = mydb.cursor ()

SQL = "Chọn * Từ khách hàng trong đó địa chỉ = 'Park Lane 38'"

mycursor.execute(sql)

myResult = mycursor.fetchall ()

cho x trong myResult: & nbsp; in (x)
print(x)

Chạy ví dụ »

Ký tự ký tự đại diện

Bạn cũng có thể chọn các bản ghi bắt đầu, bao gồm hoặc kết thúc bằng một chữ cái hoặc cụm từ nhất định.

Sử dụng ________ 16 & nbsp; Để đại diện cho ký tự ký tự đại diện:

Chọn các bản ghi trong đó địa chỉ chứa từ "way":

Thí dụ

mycursor = mydb.cursor ()

Nhập MySQL.Connector

myDB = mysql.connector.connect (& nbsp; host = "localhost", & nbsp; user = "yourusername", & nbsp; password = "yourPassword", & nbsp; cơ sở dữ liệu = "mydatabase")
host="localhost",
user="yourusername",
password="yourpassword",
database="mydatabase"
)

mycursor = mydb.cursor ()

SQL = "Chọn * Từ khách hàng trong đó địa chỉ = 'Park Lane 38'"
adr = ("Yellow Garden 2", )

myResult = mycursor.fetchall ()

cho x trong myResult: & nbsp; in (x)
print(x)

Chạy ví dụ »

10.5.4 & nbsp; mysqlcursor.execute () Phương thức

Cú pháp:

cursor.execute(operation, params=None, multi=False)
iterator = cursor.execute(operation, params=None, multi=True)

Phương thức này thực thi cơ sở dữ liệu đã cho

insert_stmt = (
  "INSERT INTO employees (emp_no, first_name, last_name, hire_date) "
  "VALUES (%s, %s, %s, %s)"
)
data = (2, 'Jane', 'Doe', datetime.date(2012, 3, 23))
cursor.execute(insert_stmt, data)

select_stmt = "SELECT * FROM employees WHERE emp_no = %(emp_no)s"
cursor.execute(select_stmt, { 'emp_no': 2 })

8 (truy vấn hoặc lệnh). Các tham số được tìm thấy trong tuple hoặc từ điển

insert_stmt = (
  "INSERT INTO employees (emp_no, first_name, last_name, hire_date) "
  "VALUES (%s, %s, %s, %s)"
)
data = (2, 'Jane', 'Doe', datetime.date(2012, 3, 23))
cursor.execute(insert_stmt, data)

select_stmt = "SELECT * FROM employees WHERE emp_no = %(emp_no)s"
cursor.execute(select_stmt, { 'emp_no': 2 })

9 được liên kết với các biến trong hoạt động. Chỉ định các biến bằng cách sử dụng kiểu tham số

insert_stmt = (
  "INSERT INTO employees (emp_no, first_name, last_name, hire_date) "
  "VALUES (%s, %s, %s, %s)"
)
data = (2, 'Jane', 'Doe', datetime.date(2012, 3, 23))
cursor.execute(insert_stmt, data)

select_stmt = "SELECT * FROM employees WHERE emp_no = %(emp_no)s"
cursor.execute(select_stmt, { 'emp_no': 2 })

7 hoặc ____ 21) (nghĩa là sử dụng kiểu

operation = 'SELECT 1; INSERT INTO t1 VALUES (); SELECT 2'
for result in cursor.execute(operation, multi=True):
  if result.with_rows:
    print("Rows produced by statement '{}':".format(
      result.statement))
    print(result.fetchall())
  else:
    print("Number of rows affected by statement '{}': {}".format(
      result.statement, result.rowcount))

2 hoặc

operation = 'SELECT 1; INSERT INTO t1 VALUES (); SELECT 2'
for result in cursor.execute(operation, multi=True):
  if result.with_rows:
    print("Rows produced by statement '{}':".format(
      result.statement))
    print(result.fetchall())
  else:
    print("Number of rows affected by statement '{}': {}".format(
      result.statement, result.rowcount))

3).

operation = 'SELECT 1; INSERT INTO t1 VALUES (); SELECT 2'
for result in cursor.execute(operation, multi=True):
  if result.with_rows:
    print("Rows produced by statement '{}':".format(
      result.statement))
    print(result.fetchall())
  else:
    print("Number of rows affected by statement '{}': {}".format(
      result.statement, result.rowcount))

4 Trả về một trình lặp nếu

operation = 'SELECT 1; INSERT INTO t1 VALUES (); SELECT 2'
for result in cursor.execute(operation, multi=True):
  if result.with_rows:
    print("Rows produced by statement '{}':".format(
      result.statement))
    print(result.fetchall())
  else:
    print("Number of rows affected by statement '{}': {}".format(
      result.statement, result.rowcount))

5 là

operation = 'SELECT 1; INSERT INTO t1 VALUES (); SELECT 2'
for result in cursor.execute(operation, multi=True):
  if result.with_rows:
    print("Rows produced by statement '{}':".format(
      result.statement))
    print(result.fetchall())
  else:
    print("Number of rows affected by statement '{}': {}".format(
      result.statement, result.rowcount))

6.

Ghi chú

Trong Python, một tuple chứa một giá trị duy nhất phải bao gồm dấu phẩy. Ví dụ, ('ABC') được đánh giá là vô hướng trong khi ('ABC',) được đánh giá là một tuple.('abc') is evaluated as a scalar while ('abc',) is evaluated as a tuple.

Ví dụ này chèn thông tin về một nhân viên mới, sau đó chọn dữ liệu cho người đó. Các câu lệnh được thực thi dưới dạng các hoạt động

operation = 'SELECT 1; INSERT INTO t1 VALUES (); SELECT 2'
for result in cursor.execute(operation, multi=True):
  if result.with_rows:
    print("Rows produced by statement '{}':".format(
      result.statement))
    print(result.fetchall())
  else:
    print("Number of rows affected by statement '{}': {}".format(
      result.statement, result.rowcount))

4 riêng biệt:

insert_stmt = (
  "INSERT INTO employees (emp_no, first_name, last_name, hire_date) "
  "VALUES (%s, %s, %s, %s)"
)
data = (2, 'Jane', 'Doe', datetime.date(2012, 3, 23))
cursor.execute(insert_stmt, data)

select_stmt = "SELECT * FROM employees WHERE emp_no = %(emp_no)s"
cursor.execute(select_stmt, { 'emp_no': 2 })

Các giá trị dữ liệu được chuyển đổi khi cần thiết từ các đối tượng Python thành thứ mà MySQL hiểu. Trong ví dụ trước, ví dụ

operation = 'SELECT 1; INSERT INTO t1 VALUES (); SELECT 2'
for result in cursor.execute(operation, multi=True):
  if result.with_rows:
    print("Rows produced by statement '{}':".format(
      result.statement))
    print(result.fetchall())
  else:
    print("Number of rows affected by statement '{}': {}".format(
      result.statement, result.rowcount))

8 được chuyển đổi thành

operation = 'SELECT 1; INSERT INTO t1 VALUES (); SELECT 2'
for result in cursor.execute(operation, multi=True):
  if result.with_rows:
    print("Rows produced by statement '{}':".format(
      result.statement))
    print(result.fetchall())
  else:
    print("Number of rows affected by statement '{}': {}".format(
      result.statement, result.rowcount))

9.

Nếu

operation = 'SELECT 1; INSERT INTO t1 VALUES (); SELECT 2'
for result in cursor.execute(operation, multi=True):
  if result.with_rows:
    print("Rows produced by statement '{}':".format(
      result.statement))
    print(result.fetchall())
  else:
    print("Number of rows affected by statement '{}': {}".format(
      result.statement, result.rowcount))

5 được đặt thành

operation = 'SELECT 1; INSERT INTO t1 VALUES (); SELECT 2'
for result in cursor.execute(operation, multi=True):
  if result.with_rows:
    print("Rows produced by statement '{}':".format(
      result.statement))
    print(result.fetchall())
  else:
    print("Number of rows affected by statement '{}': {}".format(
      result.statement, result.rowcount))

6,

operation = 'SELECT 1; INSERT INTO t1 VALUES (); SELECT 2'
for result in cursor.execute(operation, multi=True):
  if result.with_rows:
    print("Rows produced by statement '{}':".format(
      result.statement))
    print(result.fetchall())
  else:
    print("Number of rows affected by statement '{}': {}".format(
      result.statement, result.rowcount))

4 có thể thực thi nhiều câu lệnh được chỉ định trong chuỗi

insert_stmt = (
  "INSERT INTO employees (emp_no, first_name, last_name, hire_date) "
  "VALUES (%s, %s, %s, %s)"
)
data = (2, 'Jane', 'Doe', datetime.date(2012, 3, 23))
cursor.execute(insert_stmt, data)

select_stmt = "SELECT * FROM employees WHERE emp_no = %(emp_no)s"
cursor.execute(select_stmt, { 'emp_no': 2 })

8. Nó trả về một trình lặp cho phép xử lý kết quả của mỗi câu lệnh. Tuy nhiên, sử dụng các tham số không hoạt động tốt trong trường hợp này và thường là một ý tưởng tốt để tự thực hiện từng câu lệnh.

Ví dụ sau chọn và chèn dữ liệu trong một thao tác

operation = 'SELECT 1; INSERT INTO t1 VALUES (); SELECT 2'
for result in cursor.execute(operation, multi=True):
  if result.with_rows:
    print("Rows produced by statement '{}':".format(
      result.statement))
    print(result.fetchall())
  else:
    print("Number of rows affected by statement '{}': {}".format(
      result.statement, result.rowcount))

4 duy nhất và hiển thị kết quả của mỗi câu lệnh:

operation = 'SELECT 1; INSERT INTO t1 VALUES (); SELECT 2'
for result in cursor.execute(operation, multi=True):
  if result.with_rows:
    print("Rows produced by statement '{}':".format(
      result.statement))
    print(result.fetchall())
  else:
    print("Number of rows affected by statement '{}': {}".format(
      result.statement, result.rowcount))

Nếu kết nối được cấu hình để tìm nạp các cảnh báo, các cảnh báo được tạo bởi hoạt động có sẵn thông qua phương thức mysqlcursor.fetchwarnings ().

12.8.1 & NBSP; Chức năng so sánh chuỗi và toán tử

Bảng & NBSP; 12.13 & NBSP; Chức năng so sánh chuỗi và toán tử

Tên Sự mô tả

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

5

Phù hợp với mô hình đơn giản

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

6

Sự phủ định của kết hợp mô hình đơn giản

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

7

So sánh hai chuỗi

Nếu một hàm chuỗi được cung cấp một chuỗi nhị phân như một đối số, chuỗi kết quả cũng là một chuỗi nhị phân. Một số được chuyển đổi thành một chuỗi được coi là một chuỗi nhị phân. Điều này chỉ ảnh hưởng đến so sánh.

Thông thường, nếu bất kỳ biểu thức nào trong so sánh chuỗi là nhạy cảm trường hợp, thì so sánh được thực hiện theo kiểu nhạy cảm trường hợp.

Nếu một hàm chuỗi được gọi từ bên trong máy khách MySQL, hiển thị chuỗi nhị phân bằng cách sử dụng ký hiệu thập lục phân, tùy thuộc vào giá trị của

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

8. Để biết thêm thông tin về tùy chọn đó, hãy xem Phần & NBSP; 4.5.1, MYSQL-Máy khách dòng lệnh MySQL.mysql client, binary strings display using hexadecimal notation, depending on the value of the

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

8. For more information about that option, see Section 4.5.1, “mysql — The MySQL Command-Line Client”.

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

9 như

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

0 [Escape '

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

1']]

Kết hợp mẫu bằng cách sử dụng mẫu SQL. Trả về

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

2 (

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

3) hoặc

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

4 (

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

5). Nếu

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

6 hoặc

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

0 là

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

8, kết quả là

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

8.

Các mẫu không cần phải là một chuỗi theo nghĩa đen. Ví dụ: nó có thể được chỉ định là một biểu thức chuỗi hoặc cột bảng. Trong trường hợp sau, cột phải được định nghĩa là một trong các loại chuỗi MySQL (xem Phần & NBSP; 11.3, các loại dữ liệu chuỗi chuỗi).

Theo tiêu chuẩn SQL,

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

5 thực hiện phù hợp trên cơ sở peracter, do đó nó có thể tạo ra kết quả khác với toán tử so sánh

mysql> SELECT 'David!' LIKE 'David\_';
        -> 0
mysql> SELECT 'David_' LIKE 'David\_';
        -> 1

1:

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

Đặc biệt, không gian theo dõi luôn luôn có ý nghĩa. Điều này khác với các so sánh được thực hiện với toán tử

mysql> SELECT 'David!' LIKE 'David\_';
        -> 0
mysql> SELECT 'David_' LIKE 'David\_';
        -> 1

1, trong đó tầm quan trọng của các không gian dấu vết trong các chuỗi không phải là (

mysql> SELECT 'David!' LIKE 'David\_';
        -> 0
mysql> SELECT 'David_' LIKE 'David\_';
        -> 1

3,

mysql> SELECT 'David!' LIKE 'David\_';
        -> 0
mysql> SELECT 'David_' LIKE 'David\_';
        -> 1

4 và

mysql> SELECT 'David!' LIKE 'David\_';
        -> 0
mysql> SELECT 'David_' LIKE 'David\_';
        -> 1

5) phụ thuộc vào thuộc tính PAD của đối chiếu được sử dụng để so sánh. Để biết thêm thông tin, xem xử lý không gian theo dõi trong so sánh.

Với

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

5, bạn có thể sử dụng hai ký tự ký tự đại diện sau trong mẫu:

insert_stmt = (
  "INSERT INTO employees (emp_no, first_name, last_name, hire_date) "
  "VALUES (%s, %s, %s, %s)"
)
data = (2, 'Jane', 'Doe', datetime.date(2012, 3, 23))
cursor.execute(insert_stmt, data)

select_stmt = "SELECT * FROM employees WHERE emp_no = %(emp_no)s"
cursor.execute(select_stmt, { 'emp_no': 2 })

6 khớp với bất kỳ số lượng ký tự nào, thậm chí không có ký tự.

mysql> SELECT 'David!' LIKE 'David\_';
        -> 0
mysql> SELECT 'David_' LIKE 'David\_';
        -> 1

8 khớp với chính xác một ký tự.

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

Để kiểm tra các trường hợp theo nghĩa đen của một nhân vật ký tự đại diện, đi trước nó bởi nhân vật thoát hiểm. Nếu bạn không chỉ định ký tự

mysql> SELECT 'David!' LIKE 'David\_';
        -> 0
mysql> SELECT 'David_' LIKE 'David\_';
        -> 1

9,

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1

0 sẽ được giả định, trừ khi chế độ

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1

1 SQL được bật. Trong trường hợp đó, không có ký tự thoát nào được sử dụng.

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1

2 khớp với một ký tự

insert_stmt = (
  "INSERT INTO employees (emp_no, first_name, last_name, hire_date) "
  "VALUES (%s, %s, %s, %s)"
)
data = (2, 'Jane', 'Doe', datetime.date(2012, 3, 23))
cursor.execute(insert_stmt, data)

select_stmt = "SELECT * FROM employees WHERE emp_no = %(emp_no)s"
cursor.execute(select_stmt, { 'emp_no': 2 })

6.

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1

4 khớp với một ký tự

mysql> SELECT 'David!' LIKE 'David\_';
        -> 0
mysql> SELECT 'David_' LIKE 'David\_';
        -> 1

8.

mysql> SELECT 'David!' LIKE 'David\_';
        -> 0
mysql> SELECT 'David_' LIKE 'David\_';
        -> 1

Để chỉ định một ký tự thoát khác nhau, hãy sử dụng mệnh đề

mysql> SELECT 'David!' LIKE 'David\_';
        -> 0
mysql> SELECT 'David_' LIKE 'David\_';
        -> 1

9:

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1

Trình tự thoát nên là một ký tự dài để chỉ định ký tự thoát hoặc trống để chỉ định rằng không có ký tự thoát nào được sử dụng. Biểu thức phải đánh giá như một hằng số tại thời điểm thực hiện. Nếu chế độ

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1

1 SQL được bật, chuỗi không thể trống.

Hai câu sau đây minh họa rằng các so sánh chuỗi không nhạy cảm với trường hợp trừ khi một trong các toán hạng nhạy cảm trường hợp (sử dụng đối chiếu nhạy cảm trường hợp hoặc là chuỗi nhị phân):

mysql> SELECT 'abc' LIKE 'ABC';
        -> 1
mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_0900_as_cs;
        -> 0
mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_bin;
        -> 0
mysql> SELECT 'abc' LIKE BINARY 'ABC';
        -> 0

Là một phần mở rộng cho SQL tiêu chuẩn, MySQL cho phép

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

5 trên các biểu thức số.

mysql> SELECT 10 LIKE '1%';
        -> 1

Ghi chú

MySQL sử dụng C Escape Cú pháp trong các chuỗi (ví dụ:

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1

9 để thể hiện ký tự dòng mới). Nếu bạn muốn một chuỗi

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

5 chứa một

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1

0 theo nghĩa đen, bạn phải nhân đôi nó. (Trừ khi chế độ

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1

1 SQL được bật, trong trường hợp đó không sử dụng ký tự thoát.) Để tìm kiếm

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1

0, chỉ định nó là

mysql> SELECT 'abc' LIKE 'ABC';
        -> 1
mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_0900_as_cs;
        -> 0
mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_bin;
        -> 0
mysql> SELECT 'abc' LIKE BINARY 'ABC';
        -> 0

6; Điều này là do các dấu gạch chéo ngược bị loại bỏ một lần bởi trình phân tích cú pháp và một lần nữa khi kết quả phù hợp với mẫu, để lại một dấu gạch chéo ngược để được khớp với.

Ngoại lệ: Ở cuối chuỗi mẫu, Backslash có thể được chỉ định là

mysql> SELECT 'abc' LIKE 'ABC';
        -> 1
mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_0900_as_cs;
        -> 0
mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_bin;
        -> 0
mysql> SELECT 'abc' LIKE BINARY 'ABC';
        -> 0

7. Ở cuối chuỗi, Backslash là tự đứng vì không có gì theo sau để trốn thoát. Giả sử rằng một bảng chứa các giá trị sau:

mysql> SELECT filename FROM t1;
+--------------+
| filename     |
+--------------+
| C:           |
| C:\          |
| C:\Programs  |
| C:\Programs\ |
+--------------+

Để kiểm tra các giá trị kết thúc bằng dấu gạch chéo ngược, bạn có thể khớp các giá trị bằng một trong các mẫu sau:

insert_stmt = (
  "INSERT INTO employees (emp_no, first_name, last_name, hire_date) "
  "VALUES (%s, %s, %s, %s)"
)
data = (2, 'Jane', 'Doe', datetime.date(2012, 3, 23))
cursor.execute(insert_stmt, data)

select_stmt = "SELECT * FROM employees WHERE emp_no = %(emp_no)s"
cursor.execute(select_stmt, { 'emp_no': 2 })

0

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

9 không thích

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

0 [Escape '

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

1']]

Điều này giống như không (

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

6 như

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

0 [Escape '

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

1']).

NOT
(mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1
6 LIKE mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1
0 [ESCAPE 'mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1
1'])

.

Ghi chú

MySQL sử dụng C Escape Cú pháp trong các chuỗi (ví dụ:

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1

9 để thể hiện ký tự dòng mới). Nếu bạn muốn một chuỗi

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

5 chứa một

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1

0 theo nghĩa đen, bạn phải nhân đôi nó. (Trừ khi chế độ

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1

1 SQL được bật, trong trường hợp đó không sử dụng ký tự thoát.) Để tìm kiếm

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1

0, chỉ định nó là

mysql> SELECT 'abc' LIKE 'ABC';
        -> 1
mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_0900_as_cs;
        -> 0
mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_bin;
        -> 0
mysql> SELECT 'abc' LIKE BINARY 'ABC';
        -> 0

6; Điều này là do các dấu gạch chéo ngược bị loại bỏ một lần bởi trình phân tích cú pháp và một lần nữa khi kết quả phù hợp với mẫu, để lại một dấu gạch chéo ngược để được khớp với.

insert_stmt = (
  "INSERT INTO employees (emp_no, first_name, last_name, hire_date) "
  "VALUES (%s, %s, %s, %s)"
)
data = (2, 'Jane', 'Doe', datetime.date(2012, 3, 23))
cursor.execute(insert_stmt, data)

select_stmt = "SELECT * FROM employees WHERE emp_no = %(emp_no)s"
cursor.execute(select_stmt, { 'emp_no': 2 })

1

Ngoại lệ: Ở cuối chuỗi mẫu, Backslash có thể được chỉ định là

mysql> SELECT 'abc' LIKE 'ABC';
        -> 1
mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_0900_as_cs;
        -> 0
mysql> SELECT 'abc' LIKE _utf8mb4 'ABC' COLLATE utf8mb4_bin;
        -> 0
mysql> SELECT 'abc' LIKE BINARY 'ABC';
        -> 0

7. Ở cuối chuỗi, Backslash là tự đứng vì không có gì theo sau để trốn thoát. Giả sử rằng một bảng chứa các giá trị sau:

NULL NOT LIKE
mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1
6

always returns

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

8, regardless of the value of

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

6. The same is true for aggregate queries involving

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

8 and comparisons using

mysql> SELECT filename FROM t1;
+--------------+
| filename     |
+--------------+
| C:           |
| C:\          |
| C:\Programs  |
| C:\Programs\ |
+--------------+

5 or

mysql> SELECT filename FROM t1;
+--------------+
| filename     |
+--------------+
| C:           |
| C:\          |
| C:\Programs  |
| C:\Programs\ |
+--------------+

6. In such cases, you must test explicitly for

mysql> SELECT filename FROM t1;
+--------------+
| filename     |
+--------------+
| C:           |
| C:\          |
| C:\Programs  |
| C:\Programs\ |
+--------------+

7 using

mysql> SELECT filename FROM t1;
+--------------+
| filename     |
+--------------+
| C:           |
| C:\          |
| C:\Programs  |
| C:\Programs\ |
+--------------+

8 (and not

mysql> SELECT filename FROM t1;
+--------------+
| filename     |
+--------------+
| C:           |
| C:\          |
| C:\Programs  |
| C:\Programs\ |
+--------------+

9), as shown here:

insert_stmt = (
  "INSERT INTO employees (emp_no, first_name, last_name, hire_date) "
  "VALUES (%s, %s, %s, %s)"
)
data = (2, 'Jane', 'Doe', datetime.date(2012, 3, 23))
cursor.execute(insert_stmt, data)

select_stmt = "SELECT * FROM employees WHERE emp_no = %(emp_no)s"
cursor.execute(select_stmt, { 'emp_no': 2 })

2

________ 100, ________ 101)

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

7 trả về

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

4 Nếu các chuỗi giống nhau,

insert_stmt = (
  "INSERT INTO employees (emp_no, first_name, last_name, hire_date) "
  "VALUES (%s, %s, %s, %s)"
)
data = (2, 'Jane', 'Doe', datetime.date(2012, 3, 23))
cursor.execute(insert_stmt, data)

select_stmt = "SELECT * FROM employees WHERE emp_no = %(emp_no)s"
cursor.execute(select_stmt, { 'emp_no': 2 })

04 nếu đối số đầu tiên nhỏ hơn thứ hai theo thứ tự sắp xếp hiện tại và

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

8 nếu một trong hai đối số là

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

8. Nó trả về

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

2 nếu không.

insert_stmt = (
  "INSERT INTO employees (emp_no, first_name, last_name, hire_date) "
  "VALUES (%s, %s, %s, %s)"
)
data = (2, 'Jane', 'Doe', datetime.date(2012, 3, 23))
cursor.execute(insert_stmt, data)

select_stmt = "SELECT * FROM employees WHERE emp_no = %(emp_no)s"
cursor.execute(select_stmt, { 'emp_no': 2 })

3

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

7 thực hiện so sánh bằng cách sử dụng đối chiếu các đối số.

insert_stmt = (
  "INSERT INTO employees (emp_no, first_name, last_name, hire_date) "
  "VALUES (%s, %s, %s, %s)"
)
data = (2, 'Jane', 'Doe', datetime.date(2012, 3, 23))
cursor.execute(insert_stmt, data)

select_stmt = "SELECT * FROM employees WHERE emp_no = %(emp_no)s"
cursor.execute(select_stmt, { 'emp_no': 2 })

4

Nếu các đối chiếu không tương thích, một trong những đối số phải được chuyển đổi để tương thích với các đối số khác. Xem phần & nbsp; 10.8.4, sự ép buộc đối chiếu trong các biểu thức.

insert_stmt = (
  "INSERT INTO employees (emp_no, first_name, last_name, hire_date) "
  "VALUES (%s, %s, %s, %s)"
)
data = (2, 'Jane', 'Doe', datetime.date(2012, 3, 23))
cursor.execute(insert_stmt, data)

select_stmt = "SELECT * FROM employees WHERE emp_no = %(emp_no)s"
cursor.execute(select_stmt, { 'emp_no': 2 })

5

Làm thế nào để bạn trốn thoát trong mysql?

Dữ liệu chuỗi được yêu cầu thoát trước khi sử dụng trong truy vấn chọn để trả về tập kết quả với một trích dẫn duy nhất (phạm), lùi (\), ascii null, v.v. Nó tạo ra một giá trị chuỗi thoát khỏi dữ liệu của truy vấn đúng cách.The MySQL QUOTE() function is used to do this task. It generates a string value that escapes the data of the query properly.

Làm cách nào để thoát khỏi các ký tự đặc biệt trong truy vấn chọn mysql?

MySQL nhận ra các chuỗi thoát được hiển thị trong Bảng 9.1, Trình tự thoát ký tự đặc biệt.... Bảng 9.1 Trình tự thoát ký tự đặc biệt ..

Nhân vật nào là nhân vật thoát cho MySQL?

MySQL nhận ra các chuỗi thoát sau đây.\ 0 Một ký tự ASCII nul (0x00).\ 'Một ký tự trích dẫn (' '').\ "Một nhân vật trích dẫn kép (" "").

Phương thức Fetchall () con trỏ làm gì?

Phương thức Fetchall ().Phương thức lấy tất cả (hoặc tất cả các hàng còn lại) của bộ kết quả truy vấn và trả về một danh sách các bộ dữ liệu.Nếu không có thêm hàng, nó sẽ trả về một danh sách trống.Bạn phải tìm nạp tất cả các hàng cho truy vấn hiện tại trước khi thực hiện các câu lệnh mới bằng cách sử dụng cùng một kết nối.fetches all (or all remaining) rows of a query result set and returns a list of tuples. If no more rows are available, it returns an empty list. You must fetch all rows for the current query before executing new statements using the same connection.

programming mysql MySQL Connector connect mysql connector-python Python MySQL Executemany Python UPDATE SQL Python Delete SQL Python

Hướng dẫn mysql module provides which method to escape query values mcq - mô-đun mysql cung cấp phương thức nào để thoát các giá trị truy vấn mcq

Chọn với bộ lọc

Thí dụ

Ký tự ký tự đại diện

Thí dụ

Ký tự ký tự đại diện

Thí dụ

10.5.4 & nbsp; mysqlcursor.execute () Phương thức

12.8.1 & NBSP; Chức năng so sánh chuỗi và toán tử

Làm thế nào để bạn trốn thoát trong mysql?

Làm cách nào để thoát khỏi các ký tự đặc biệt trong truy vấn chọn mysql?

Nhân vật nào là nhân vật thoát cho MySQL?

Phương thức Fetchall () con trỏ làm gì?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội