Python MySQL-빠른 가이드

데이터베이스 인터페이스의 Python 표준은 Python DB-API입니다. 대부분의 Python 데이터베이스 인터페이스는이 표준을 따릅니다.

애플리케이션에 적합한 데이터베이스를 선택할 수 있습니다. Python Database API는 다음과 같은 광범위한 데이터베이스 서버를 지원합니다.

• GadFly
• mSQL
• MySQL
• PostgreSQL
• 마이크로 소프트 SQL 서버 2000
• Informix
• Interbase
• Oracle
• Sybase

다음은 사용 가능한 Python 데이터베이스 인터페이스 목록입니다 -Python 데이터베이스 인터페이스 및 API . 액세스해야하는 각 데이터베이스에 대해 별도의 DB API 모듈을 다운로드해야합니다. 예를 들어, Oracle 데이터베이스와 MySQL 데이터베이스에 액세스해야하는 경우 Oracle 및 MySQL 데이터베이스 모듈을 모두 다운로드해야합니다.

mysql-connector-python은 무엇입니까?

MySQL Python / Connector는 Python에서 MySQL 데이터베이스 서버에 연결하기위한 인터페이스입니다. Python 데이터베이스 API를 구현하고 MySQL을 기반으로 구축되었습니다.

mysql-connector-python을 어떻게 설치합니까?

우선, 여러분의 컴퓨터에 이미 파이썬을 설치했는지 확인해야합니다. 이렇게하려면 명령 프롬프트를 열고 python을 입력 한 다음 Enter 키 를 누릅니다 . 파이썬이 이미 시스템에 설치되어있는 경우이 명령은 아래와 같이 버전을 표시합니다.

C:\Users\Tutorialspoint>python
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

이제 ctrl + z 를 누른 다음 Enter 키를 눌러 Python 셸에서 나와 Python_MySQL이라는 이름의 폴더 (Python-MySQL 커넥터를 설치하려는 폴더)를 다음과 같이 만듭니다.

>>> ^Z 
C:\Users\Tutorialspoint>d:
D:\>mkdir Python_MySQL

PIP 확인

PIP는 파이썬에서 다양한 모듈 / 패키지를 설치할 수있는 파이썬 패키지 관리자입니다. 따라서 Mysql-python mysql-connector-python을 설치하려면 컴퓨터에 PIP가 설치되어 있고 해당 위치가 경로에 추가되어 있는지 확인해야합니다.

pip 명령을 실행하여 그렇게 할 수 있습니다. 시스템에 PIP가 없거나 해당 위치를 시스템에 추가하지 않은 경우Path 환경 변수를 사용하면 다음과 같은 오류 메시지가 표시됩니다.

D:\Python_MySQL>pip
'pip' is not recognized as an internal or external command,
operable program or batch file.

PIP를 설치하려면 위 생성 된 폴더에 get-pip.py 를 다운로드하고 명령에서 탐색하고 다음과 같이 pip를 설치합니다.

D:\>cd Python_MySQL
D:\Python_MySQL>python get-pip.py
Collecting pip
   Downloading
https://files.pythonhosted.org/packages/8d/07/f7d7ced2f97ca3098c16565efbe6b15fafcba53e8d9bdb431e09140514b0/pip-19.2.2-py2.py3-none-any.whl (1.4MB)
   |████████████████████████████████| 1.4MB 1.3MB/s
Collecting wheel
   Downloading 
https://files.pythonhosted.org/packages/00/83/b4a77d044e78ad1a45610eb88f745be2fd2c6d658f9798a15e384b7d57c9/wheel-0.33.6-py2.py3-none-any.whl
Installing collected packages: pip, wheel
Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.
Successfully installed pip-19.2.2 wheel-0.33.6

mysql-connector-python 설치

Python과 PIP가 설치되면 명령 프롬프트를 열고 아래와 같이 pip (선택 사항)를 업그레이드합니다.

C:\Users\Tutorialspoint>python -m pip install --upgrade pip
Collecting pip
   Using cached 
https://files.pythonhosted.org/packages/8d/07/f7d7ced2f97ca3098c16565efbe6b15fafcba53e8d9bdb431e09140514b0/pip-19.2.2-py2.py3-none-any.whl
Installing collected packages: pip
   Found existing installation: pip 19.0.3
      Uninstalling pip-19.0.3:
         Successfully uninstalled pip-19.0.3
Successfully installed pip-19.2.2

그런 다음 관리자 모드에서 명령 프롬프트를 열고 Python MySQL connect를 다음과 같이 설치하십시오.

C:\WINDOWS\system32>pip install mysql-connector-python
Collecting mysql-connector-python
   Using cached 
https://files.pythonhosted.org/packages/99/74/f41182e6b7aadc62b038b6939dce784b7f9ec4f89e2ae14f9ba8190dc9ab/mysql_connector_python-8.0.17-py2.py3-none-any.whl
Collecting protobuf>=3.0.0 (from mysql-connector-python)
   Using cached 
https://files.pythonhosted.org/packages/09/0e/614766ea191e649216b87d331a4179338c623e08c0cca291bcf8638730ce/protobuf-3.9.1-cp37-cp37m-win32.whl
Collecting six>=1.9 (from protobuf>=3.0.0->mysql-connector-python)
   Using cached 
https://files.pythonhosted.org/packages/73/fb/00a976f728d0d1fecfe898238ce23f502a721c0ac0ecfedb80e0d88c64e9/six-1.12.0-py2.py3-none-any.whl
Requirement already satisfied: setuptools in c:\program files (x86)\python37-32\lib\site-packages (from protobuf>=3.0.0->mysql-connector-python) (40.8.0)
Installing collected packages: six, protobuf, mysql-connector-python
Successfully installed mysql-connector-python-8.0.17 protobuf-3.9.1 six-1.12.0

확인

설치를 확인하려면 다음 줄이 포함 된 샘플 Python 스크립트를 만듭니다.

import mysql.connector

설치가 성공하면 실행하면 오류가 발생하지 않습니다.

D:\Python_MySQL>python test.py
D:\Python_MySQL>

처음부터 Python 설치

간단히, Python을 처음부터 설치해야하는 경우. Python 홈 페이지를 방문하십시오 .

클릭 Downloads 버튼을 클릭하면 다양한 플랫폼에 대한 최신 버전의 Python에 대한 링크를 제공하는 다운로드 페이지로 리디렉션됩니다. 하나를 선택하고 다운로드합니다.

예를 들어 python-3.7.4.exe (Windows 용)를 다운로드했습니다. 다운로드 한 .exe 파일을 두 번 클릭하여 설치 프로세스를 시작합니다.

경로에 Python 3.7 추가 옵션을 선택하고 설치를 계속하십시오. 이 프로세스가 완료되면 Python이 시스템에 설치됩니다.

MySQL에 연결하려면 (한 가지 방법은) 아래와 같이 시스템에서 MySQL 명령 프롬프트를 여는 것입니다.

여기에 암호를 묻습니다. 설치시 기본 사용자 (루트)로 설정 한 암호를 입력해야합니다.

그런 다음 다음 메시지를 표시하는 MySQL과 연결이 설정됩니다.

Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 4
Server version: 5.7.12-log MySQL Community Server (GPL)

Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

다음을 사용하여 언제든지 MySQL 데이터베이스에서 연결을 끊을 수 있습니다. exitmysql> 프롬프트 에서 명령 .

mysql> exit
Bye

Python을 사용하여 MySQL과 연결 설정

파이썬을 사용하여 MySQL 데이터베이스에 연결하기 전에 다음을 가정하십시오.

• mydb라는 이름의 데이터베이스를 만들었습니다.

• FIRST_NAME, LAST_NAME, AGE, SEX 및 INCOME 열이있는 EMPLOYEE 테이블을 만들었습니다.

• MySQL과 연결하는 데 사용하는 자격 증명은 사용자 이름입니다. root, 비밀번호 − password.

connect () 생성자를 사용하여 연결을 설정할 수 있습니다 . 이것은 사용자 이름, 암호, 호스트 및 연결해야하는 데이터베이스 이름 (선택 사항)을 허용하고 MySQLConnection 클래스의 객체를 반환합니다.

예

다음은 MySQL 데이터베이스 "mydb"에 연결하는 예입니다.

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Executing an MYSQL function using the execute() method
cursor.execute("SELECT DATABASE()")

#Fetch a single row using fetchone() method.
data = cursor.fetchone()

print("Connection established to: ",data)

#Closing the connection
conn.close()

산출

실행시이 스크립트는 다음 출력을 생성합니다.

D:\Python_MySQL>python EstablishCon.py
Connection established to: ('mydb',)

자격 증명 (사용자 이름, 암호, 호스트 이름 및 데이터베이스 이름)을 다음으로 전달하여 MySQL에 대한 연결을 설정할 수도 있습니다. connection.MySQLConnection() 아래와 같이-

from mysql.connector import (connection)

#establishing the connection
conn = connection.MySQLConnection(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Closing the connection
conn.close()

CREATE DATABASE 쿼리를 사용하여 MYSQL에서 데이터베이스를 만들 수 있습니다.

통사론

다음은 CREATE DATABASE 쿼리의 구문입니다-

CREATE DATABASE name_of_the_database

예

다음 문은 MySQL에서 mydb라는 이름의 데이터베이스를 생성합니다.

mysql> CREATE DATABASE mydb;
Query OK, 1 row affected (0.04 sec)

SHOW DATABASES 문을 사용하여 데이터베이스 목록을 관찰하면 아래와 같이 새로 생성 된 데이터베이스를 관찰 할 수 있습니다.

mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| logging            |
| mydatabase         |
| mydb               |
| performance_schema |
| students           |
| sys                |
+--------------------+
26 rows in set (0.15 sec)

Python을 사용하여 MySQL에서 데이터베이스 생성

MySQL과 연결을 설정 한 후 데이터를 조작하려면 데이터베이스에 연결해야합니다. 기존 데이터베이스에 연결하거나 직접 만들 수 있습니다.

MySQL 데이터베이스를 생성하거나 삭제하려면 특별한 권한이 필요합니다. 따라서 루트 사용자에 대한 액세스 권한이 있으면 모든 데이터베이스를 만들 수 있습니다.

예

다음 예제는 MYSQL과의 연결을 설정하고 그 안에 데이터베이스를 생성합니다.

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(user='root', password='password', host='127.0.0.1')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping database MYDATABASE if already exists.
cursor.execute("DROP database IF EXISTS MyDatabase")

#Preparing query to create a database
sql = "CREATE database MYDATABASE";

#Creating a database
cursor.execute(sql)

#Retrieving the list of databases
print("List of databases: ")
cursor.execute("SHOW DATABASES")
print(cursor.fetchall())

#Closing the connection
conn.close()

산출

List of databases:
[
   ('information_schema',), 
   ('dbbug61332',), 
   ('details',), 
   ('exampledatabase',), 
   ('mydatabase',), 
   ('mydb',), 
   ('mysql',), 
   ('performance_schema',)
]

CREATE TABLE 문은 MYSQL 데이터베이스에 테이블을 생성하는 데 사용됩니다. 여기에서 테이블의 이름과 각 열의 정의 (이름 및 데이터 유형)를 지정해야합니다.

통사론

다음은 MySQL에서 테이블을 생성하는 구문입니다-

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
);

예

다음 쿼리는 MySQL에서 FIRST_NAME, LAST_NAME, AGE, SEX 및 INCOME의 5 개 열이있는 EMPLOYEE라는 테이블을 만듭니다.

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT);
Query OK, 0 rows affected (0.42 sec)

DESC 문은 지정된 테이블에 대한 설명을 제공합니다. 이것을 사용하여 아래 표시된 것처럼 테이블이 생성되었는지 여부를 확인할 수 있습니다.

mysql> Desc Employee;
+------------+----------+------+-----+---------+-------+
| Field      | Type     | Null | Key | Default | Extra |
+------------+----------+------+-----+---------+-------+
| FIRST_NAME | char(20) | NO   |     | NULL    |       |
| LAST_NAME  | char(20) | YES  |     | NULL    |       |
| AGE        | int(11)  | YES  |     | NULL    |       |
| SEX        | char(1)  | YES  |     | NULL    |       |  
| INCOME     | float    | YES  |     | NULL    |       |
+------------+----------+------+-----+---------+-------+
5 rows in set (0.07 sec)

Python을 사용하여 MySQL에서 테이블 생성

execute () (커서 객체에서 호출 됨)라는 메서드는 두 개의 변수를받습니다.

• 실행할 쿼리를 나타내는 문자열 값입니다.

• 쿼리 매개 변수 (플레이스 홀더의 값)를 나타내는 튜플, 목록 또는 사전 일 수있는 선택적 args 매개 변수입니다.

쿼리의 영향을받는 행 수를 나타내는 정수 값을 반환합니다.

데이터베이스 연결이 설정되면 CREATE TABLE 쿼리를 execute() 방법.

간단히 말해서, 파이썬을 사용하여 테이블을 생성하려면-

• 수입 mysql.connector 꾸러미.

• 다음을 사용하여 연결 개체를 만듭니다. mysql.connector.connect() 사용자 이름, 암호, 호스트 (선택적 기본값 : localhost) 및 데이터베이스 (선택적)를 매개 변수로 전달하여 메소드를 사용합니다.

• 다음을 호출하여 커서 개체를 만듭니다. cursor() 위에서 만든 연결 개체의 메서드.

• 그런 다음 CREATE TABLE 문을 매개 변수로 전달하여execute() 방법.

예

다음 예제는 Employee mydb 데이터베이스에서.

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Dropping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Closing the connection
conn.close()

다음을 사용하여 MySQL의 기존 테이블에 새 행을 추가 할 수 있습니다. INSERT INTO성명서. 여기에서 테이블 이름, 열 이름 및 값을 지정해야합니다 (열 이름과 동일한 순서로).

통사론

다음은 MySQL의 INSERT INTO 문의 구문입니다.

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
   VALUES (value1, value2, value3,...valueN);

예

다음 쿼리는 EMPLOYEE라는 테이블에 레코드를 삽입합니다.

INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Mac', 'Mohan', 20, 'M', 2000);

다음과 같이 SELECT 문을 사용하여 삽입 작업 후 테이블의 레코드를 확인할 수 있습니다.

mysql> select * from Employee;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Mac        | Mohan     |    20| M    | 2000   |
+------------+-----------+------+------+--------+
1 row in set (0.00 sec)

항상 열의 이름을 지정하는 것은 필수가 아닙니다. 테이블의 열과 동일한 순서로 레코드 값을 전달하면 다음과 같이 열 이름없이 SELECT 문을 실행할 수 있습니다.

INSERT INTO EMPLOYEE VALUES ('Mac', 'Mohan', 20, 'M', 2000);

Python을 사용하여 MySQL 테이블에 데이터 삽입

그만큼 execute()메서드 (커서 개체에서 호출 됨)는 쿼리를 매개 변수로 받아들이고 주어진 쿼리를 실행합니다. 데이터를 삽입하려면 MySQL INSERT 문을 매개 변수로 전달해야합니다.

cursor.execute("""INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Mac', 'Mohan', 20, 'M', 2000)""")

파이썬을 사용하여 MySQL의 테이블에 데이터를 삽입하려면-

• 수입 mysql.connector 꾸러미.

• 다음을 사용하여 연결 개체를 만듭니다. mysql.connector.connect() 사용자 이름, 암호, 호스트 (선택적 기본값 : localhost) 및 데이터베이스 (선택적)를 매개 변수로 전달하여 메소드를 사용합니다.

• 다음을 호출하여 커서 개체를 만듭니다. cursor() 위에서 만든 연결 개체의 메서드.

• 그런 다음 INSERT 매개 변수로 전달하여 execute() 방법.

예

다음 예제 는 EMPLOYEE 테이블에 레코드를 삽입하기 위해 SQL INSERT 문을 실행 합니다.

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
# Preparing SQL query to INSERT a record into the database.
sql = """INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
   VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
   # Executing the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   conn.commit()
except:
   # Rolling back in case of error
   conn.rollback()
# Closing the connection
conn.close()

동적으로 값 삽입

당신은 또한 사용할 수 있습니다 “%s” 값 대신 INSERT MySQL을 쿼리하고 아래에 표시된 목록으로 값을 전달합니다.

cursor.execute("""INSERT INTO EMPLOYEE VALUES ('Mac', 'Mohan', 20, 'M', 2000)""", 
   ('Ramya', 'Ramapriya', 25, 'F', 5000))

예

다음 예제는 레코드를 Employee 테이블에 동적으로 삽입합니다.

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

# Preparing SQL query to INSERT a record into the database.
insert_stmt = (
   "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)"
   "VALUES (%s, %s, %s, %s, %s)"
)
data = ('Ramya', 'Ramapriya', 25, 'F', 5000)
try:
   # Executing the SQL command
   cursor.execute(insert_stmt, data)
   # Commit your changes in the database
   conn.commit()
except:
   # Rolling back in case of error
   conn.rollback()
print("Data inserted")
# Closing the connection
conn.close()

산출

Data inserted

SELECT 쿼리를 사용하여 MySQL의 테이블에서 데이터를 검색 / 가져올 수 있습니다. 이 쿼리 / 문은 지정된 테이블의 내용을 표 형식으로 반환하며 결과 집합으로 호출됩니다.

통사론

다음은 SELECT 쿼리의 구문입니다-

SELECT column1, column2, columnN FROM table_name;

예

우리는 이름과 MySQL의에서 테이블을 생성했다고 가정 cricketers_data 로 -

CREATE TABLE cricketers_data(
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Date_Of_Birth date,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);

그리고 INSERT 문을 사용하여 5 개의 레코드를 삽입했다면-

insert into cricketers_data values('Shikhar', 'Dhawan', DATE('1981-12-05'), 'Delhi', 'India');
insert into cricketers_data values('Jonathan', 'Trott', DATE('1981-04-22'), 'CapeTown', 'SouthAfrica');
insert into cricketers_data values('Kumara', 'Sangakkara', DATE('1977-10-27'), 'Matale', 'Srilanka');
insert into cricketers_data values('Virat', 'Kohli', DATE('1988-11-05'), 'Delhi', 'India');
insert into cricketers_data values('Rohit', 'Sharma', DATE('1987-04-30'), 'Nagpur', 'India');

다음 쿼리는 테이블에서 FIRST_NAME 및 Country 값을 검색합니다.

mysql> select FIRST_NAME, Country from cricketers_data;
+------------+-------------+
| FIRST_NAME | Country     | 
+------------+-------------+
| Shikhar    | India       |
| Jonathan   | SouthAfrica |
| Kumara     | Srilanka    |
| Virat      | India       |
| Rohit      | India       |
+------------+-------------+
5 rows in set (0.00 sec)

또한 열 이름의 * instated를 사용하여 각 레코드의 모든 값을 검색 할 수 있습니다.

mysql> SELECT * from cricketers_data;
+------------+------------+---------------+----------------+-------------+
| First_Name | Last_Name  | Date_Of_Birth | Place_Of_Birth | Country     |
+------------+------------+---------------+----------------+-------------+
| Shikhar    | Dhawan     | 1981-12-05    | Delhi          | India       |
| Jonathan   | Trott      | 1981-04-22    | CapeTown       | SouthAfrica |
| Kumara     | Sangakkara | 1977-10-27    | Matale         | Srilanka    |
| Virat      | Kohli      | 1988-11-05    | Delhi          | India       |
| Rohit      | Sharma     | 1987-04-30    | Nagpur         | India       |
+------------+------------+---------------+----------------+-------------+
5 rows in set (0.00 sec)

Python을 사용하여 MYSQL 테이블에서 데이터 읽기

모든 데이터베이스에 대한 읽기 작업은 데이터베이스에서 유용한 정보를 가져 오는 것을 의미합니다. 다음을 사용하여 MYSQL에서 데이터를 가져올 수 있습니다.fetch() mysql-connector-python에서 제공하는 메소드.

cursor.MySQLCursor의 클래스, 즉 세 가지 방법을 제공합니다fetchall(), fetchmany() 과, fetchone() 어디,

• 그만큼 fetchall()메서드는 쿼리 결과 집합의 모든 행을 검색하고 튜플 목록으로 반환합니다. (몇 개의 행을 검색 한 후 이것을 실행하면 나머지 행을 반환합니다).

• 그만큼 fetchone() 메서드는 쿼리 결과에서 다음 행을 가져 와서 튜플로 반환합니다.

• 그만큼 fetchmany() 메소드는 fetchone ()과 유사하지만 단일 행 대신 쿼리 결과 세트에서 다음 행 세트를 검색합니다.

Note − 결과 집합은 커서 개체를 사용하여 테이블을 쿼리 할 때 반환되는 개체입니다.

rowcount − 이것은 읽기 전용 속성이며 execute () 메서드의 영향을받은 행 수를 반환합니다.

예

다음 예제는 SELECT 쿼리를 사용하여 EMPLOYEE 테이블의 모든 행을 가져오고 처음에 얻은 결과 집합에서 처음에는 fetchone () 메서드를 사용하여 첫 번째 행을 검색 한 다음 fetchall () 메서드를 사용하여 나머지 행을 가져옵니다.

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchone();
print(result)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

산출

('Krishna', 'Sharma', 19, 'M', 2000.0)
[('Raj', 'Kandukuri', 20, 'M', 7000.0), ('Ramya', 'Ramapriya', 25, 'M', 5000.0)]

다음 예제는 fetchmany () 메소드를 사용하여 EMPLOYEE 테이블의 처음 두 행을 검색합니다.

예

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchmany(size =2);
print(result)

#Closing the connection
conn.close()

산출

[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

MySQL에서 테이블의 특정 행을 가져 오거나 삭제하거나 업데이트하려면 where 절을 사용하여 작업을 위해 테이블의 행을 필터링하는 조건을 지정해야합니다.

예를 들어 where 절이있는 SELECT 문이있는 경우 지정된 조건을 충족하는 행만 검색됩니다.

통사론

다음은 WHERE 절의 구문입니다-

SELECT column1, column2, columnN
FROM table_name
WHERE [condition]

예

MySQL에서 EMPLOYEES라는 이름으로 테이블을 만들었다 고 가정합니다.

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

그리고 INSERT 문을 사용하여 4 개의 레코드를 삽입했다면-

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

다음 MySQL 문은 소득이 4000보다 큰 직원의 레코드를 검색합니다.

mysql> SELECT * FROM EMPLOYEE WHERE INCOME > 4000;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME | 
+------------+-----------+------+------+--------+
| Raj        | Kandukuri |    20| M    | 7000   |
| Ramya      | Ramapriya |    25| F    | 5000   |
+------------+-----------+------+------+--------+
2 rows in set (0.00 sec)

Python을 사용하는 WHERE 절

파이썬 프로그램을 사용하여 테이블에서 특정 레코드를 가져 오려면-

• 수입 mysql.connector 꾸러미.

• 다음을 사용하여 연결 개체를 만듭니다. mysql.connector.connect() 사용자 이름, 암호, 호스트 (선택적 기본값 : localhost) 및 데이터베이스 (선택적)를 매개 변수로 전달하여 메소드를 사용합니다.

• 다음을 호출하여 커서 개체를 만듭니다. cursor() 위에서 만든 연결 개체의 메서드.

• 그런 다음 WHERE 절이 있는 SELECT 문을 매개 변수로 전달하여execute() 방법.

예

다음 예에서는 Employee라는 테이블을 만들고 채 웁니다. 그런 다음 where 절을 사용하여 연령 값이 23 미만인 레코드를 검색합니다.

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)
#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES (%s, %s, %s, %s, %s
)"
data = [
   ('Krishna', 'Sharma', 19, 'M', 2000), 
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000)
]
cursor.executemany(insert_stmt, data)
conn.commit()
#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())

#Closing the connection
conn.close()

산출

[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

SELECT 쿼리를 사용하여 데이터를 가져 오는 동안 OrderBy 절을 사용하여 원하는 순서 (오름차순 또는 내림차순)로 결과를 정렬 할 수 있습니다. 기본적으로이 절은 결과를 오름차순으로 정렬합니다. 내림차순으로 정렬해야하는 경우 "DESC"를 명시 적으로 사용해야합니다.

통사론

다음은 SELECT column-list 구문입니다.

FROM table_name
[WHERE condition]
[ORDER BY column1, column2,.. columnN] [ASC | DESC]; of the ORDER BY clause:

예

MySQL에서 EMPLOYEES라는 이름으로 테이블을 만들었다 고 가정합니다.

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT);
Query OK, 0 rows affected (0.36 sec)

그리고 INSERT 문을 사용하여 4 개의 레코드를 삽입했다면-

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

다음 명령문은 연령의 오름차순으로 EMPLOYEE 테이블의 컨텐츠를 검색합니다.

mysql> SELECT * FROM EMPLOYEE ORDER BY AGE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME | 
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |    19| M    | 2000   |
| Raj        | Kandukuri |    20| M    | 7000   |
| Ramya      | Ramapriya |    25| F    | 5000   |
| Mac        | Mohan     |    26| M    | 2000   |
+------------+-----------+------+------+--------+
4 rows in set (0.04 sec)

DESC를 사용하여 내림차순으로 데이터를 검색 할 수도 있습니다.

mysql> SELECT * FROM EMPLOYEE ORDER BY FIRST_NAME, INCOME DESC;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |    19| M    | 2000   |
| Mac        | Mohan     |    26| M    | 2000   |
| Raj        | Kandukuri |    20| M    | 7000   |
| Ramya      | Ramapriya |    25| F    | 5000   |
+------------+-----------+------+------+--------+
4 rows in set (0.00 sec)

Python을 사용하는 ORDER BY 절

특정 순서로 테이블의 내용을 검색하려면 execute() 커서 개체에 메서드를 추가하고 ORDER BY 절과 함께 SELECT 문을 매개 변수로 전달합니다.

예

다음 예에서는 ORDER BY 절을 사용하여 이름과 Employee가있는 테이블을 만들고, 채우고, 해당 레코드를 연령의 (오름차순) 순서로 다시 검색합니다.

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE 
   (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES (%s, %s, %s, %s, %s)"
data = [
   ('Krishna', 'Sharma', 26, 'M', 2000), 
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 29, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000)
]
cursor.executemany(insert_stmt, data)
conn.commit()

#Retrieving specific records using the ORDER BY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY AGE")

print(cursor.fetchall())

#Closing the connection
conn.close()

산출

[
   ('Raj', 'Kandukuri', 20, 'M', 7000.0), 
   ('Krishna', 'Sharma', 26, 'M', 2000.0), 
   ('Mac', 'Mohan', 26, 'M', 2000.0), 
   ('Ramya', 'Ramapriya', 29, 'F', 5000.0)
]

같은 방법으로 ORDER BY 절을 사용하여 내림차순으로 테이블에서 데이터를 검색 할 수 있습니다.

예

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving specific records using the ORDERBY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY INCOME DESC")

print(cursor.fetchall())

#Closing the connection
conn.close()

산출

[
   ('Raj', 'Kandukuri', 20, 'M', 7000.0), 
   ('Ramya', 'Ramapriya', 29, 'F', 5000.0), 
   ('Krishna', 'Sharma', 26, 'M', 2000.0), 
   ('Mac', 'Mohan', 26, 'M', 2000.0)
]

모든 데이터베이스에 대한 UPDATE 작업은 데이터베이스에서 이미 사용 가능한 하나 이상의 레코드를 업데이트합니다. UPDATE 문을 사용하여 MySQL의 기존 레코드 값을 업데이트 할 수 있습니다. 특정 행을 업데이트하려면 WHERE 절을 함께 사용해야합니다.

통사론

다음은 MySQL의 UPDATE 문의 구문입니다-

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

AND 또는 OR 연산자를 사용하여 N 개의 조건을 결합 할 수 있습니다.

예

MySQL에서 EMPLOYEES라는 이름으로 테이블을 만들었다 고 가정합니다.

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

그리고 INSERT 문을 사용하여 4 개의 레코드를 삽입했다면-

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

MySQL 성명에 따르면 모든 남성 직원의 연령이 1 년 증가합니다.

mysql> UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M';
Query OK, 3 rows affected (0.06 sec) 9. 
Rows matched: 3 Changed: 3 Warnings: 0

테이블의 내용을 검색하면 업데이트 된 값을 다음과 같이 볼 수 있습니다.

mysql> select * from EMPLOYEE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |    20| M    | 2000   |
| Raj        | Kandukuri |    21| M    | 7000   |
| Ramya      | Ramapriya |    25| F    | 5000   |
| Mac        | Mohan     |    27| M    | 2000   |
+------------+-----------+------+------+--------+
4 rows in set (0.00 sec)

Python을 사용하여 테이블 내용 업데이트

파이썬을 사용하여 MySQL의 테이블에서 레코드를 업데이트하려면-

• 수입 mysql.connector 꾸러미.

• 다음을 사용하여 연결 개체를 만듭니다. mysql.connector.connect() 사용자 이름, 암호, 호스트 (선택적 기본값 : localhost) 및 데이터베이스 (선택적)를 매개 변수로 전달하여 메소드를 사용합니다.

• 다음을 호출하여 커서 개체를 만듭니다. cursor() 위에서 만든 연결 개체의 메서드.

• 그런 다음 UPDATE 문을 매개 변수로 전달하여execute() 방법.

예

다음 예는 모든 남성의 나이를 1 년 늘립니다.

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Preparing the query to update the records
sql = '''UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M' '''

try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   conn.commit()
except:
   # Rollback in case there is any error
   conn.rollback()

#Retrieving data
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Displaying the result
print(cursor.fetchall())

#Closing the connection
conn.close()

산출

[
   ('Krishna', 'Sharma', 22, 'M', 2000.0), 
   ('Raj', 'Kandukuri', 23, 'M', 7000.0), 
   ('Ramya', 'Ramapriya', 26, 'F', 5000.0)
]

MySQL 테이블에서 레코드를 삭제하려면 다음을 사용해야합니다. DELETE FROM성명서. 특정 레코드를 제거하려면 WHERE 절을 함께 사용해야합니다.

통사론

다음은 MYSQL의 DELETE 쿼리 구문입니다.

DELETE FROM table_name [WHERE Clause]

예

MySQL에서 EMPLOYEES라는 이름으로 테이블을 만들었다 고 가정합니다.

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

그리고 INSERT 문을 사용하여 4 개의 레코드를 삽입했다면-

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

다음 MySQL 문은 FIRST_NAME”Mac” 을 사용하는 직원의 레코드를 삭제합니다 .

mysql> DELETE FROM EMPLOYEE WHERE FIRST_NAME = 'Mac';
Query OK, 1 row affected (0.12 sec)

테이블의 내용을 검색하면 하나를 삭제했기 때문에 3 개의 레코드 만 볼 수 있습니다.

mysql> select * from EMPLOYEE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME | 
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |    20| M    | 2000   |
| Raj        | Kandukuri |    21| M    | 7000   |
| Ramya      | Ramapriya |    25| F    | 5000   |
+------------+-----------+------+------+--------+
3 rows in set (0.00 sec)

WHERE 절없이 DELETE 문을 실행하면 지정된 테이블의 모든 레코드가 삭제됩니다.

mysql> DELETE FROM EMPLOYEE;
Query OK, 3 rows affected (0.09 sec)

테이블의 내용을 검색하면 아래와 같이 빈 세트가 표시됩니다.

mysql> select * from EMPLOYEE;
Empty set (0.00 sec)

Python을 사용하여 테이블의 레코드 제거

데이터베이스에서 일부 레코드를 삭제하려면 DELETE 작업이 필요합니다.

테이블에서 레코드를 삭제하려면-

• 수입 mysql.connector 꾸러미.

• 다음을 사용하여 연결 개체를 만듭니다. mysql.connector.connect() 사용자 이름, 암호, 호스트 (선택적 기본값 : localhost) 및 데이터베이스 (선택적)를 매개 변수로 전달하여 메소드를 사용합니다.

• 위에서 만든 연결 개체에 대해 cursor () 메서드를 호출하여 커서 개체를 만듭니다.

• 그런 다음 DELETE 매개 변수로 전달하여 execute() 방법.

예

다음 프로그램은 AGE가 20 이상인 EMPLOYEE의 모든 레코드를 삭제합니다.

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
print("Contents of the table: ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Preparing the query to delete records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (25)
try:
   # Execute the SQL command
   cursor.execute(sql)
   # Commit your changes in the database
   conn.commit()
except:
   # Roll back in case there is any error
   conn.rollback()

#Retrieving data
print("Contents of the table after delete operation ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Closing the connection
conn.close()

산출

Contents of the table:
[
   ('Krishna', 'Sharma', 22, 'M', 2000.0), 
   ('Raj', 'Kandukuri', 23, 'M', 7000.0), 
   ('Ramya', 'Ramapriya', 26, 'F', 5000.0), 
   ('Mac', 'Mohan', 20, 'M', 2000.0), 
   ('Ramya', 'Rama priya', 27, 'F', 9000.0)
]
Contents of the table after delete operation:
[
   ('Krishna', 'Sharma', 22, 'M', 2000.0), 
   ('Raj', 'Kandukuri', 23, 'M', 7000.0), 
   ('Mac', 'Mohan', 20, 'M', 2000.0)
]

다음을 사용하여 전체 테이블을 제거 할 수 있습니다. DROP TABLE성명서. 삭제해야하는 테이블의 이름 만 지정하면됩니다.

통사론

다음은 MySQL의 DROP TABLE 문의 구문입니다.

DROP TABLE table_name;

예

테이블을 삭제하기 전에 다음과 같이 SHOW TABLES 문을 사용하여 테이블 목록을 가져옵니다.

mysql> SHOW TABLES;
+-----------------+
| Tables_in_mydb  |
+-----------------+
| contact         |
| cricketers_data |
| employee        |
| sample          |
| tutorials       |
+-----------------+
5 rows in set (0.00 sec)

다음 문은 데이터베이스에서 sample이라는 테이블을 완전히 제거합니다.

mysql> DROP TABLE sample;
Query OK, 0 rows affected (0.29 sec)

MySQL에서 sample이라는 테이블을 삭제 했으므로 테이블 목록을 다시 가져 오면 테이블 이름 sample을 찾을 수 없습니다.

mysql> SHOW TABLES;
+-----------------+
| Tables_in_mydb  |
+-----------------+
| contact         |
| cricketers_data | 
| employee        |
| tutorials       |
+-----------------+
4 rows in set (0.00 sec)

Python을 사용하여 테이블 제거

MYSQL의 DROP 문을 사용하여 필요할 때마다 테이블을 삭제할 수 있지만, 테이블 삭제 후 손실 된 데이터는 복구되지 않으므로 기존 테이블을 삭제할 때는 매우주의해야합니다.

Python을 사용하여 MYSQL 데이터베이스에서 테이블을 삭제하려면 execute() 커서 개체에 메서드를 추가하고 drop 문을 매개 변수로 전달합니다.

예

다음 테이블은 데이터베이스에서 EMPLOYEE라는 테이블을 삭제합니다.

import mysql.connector
#establishing the connection conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method cursor = conn.cursor()

#Retrieving the list of tables print("List of tables in the database: ")   
   cursor.execute("SHOW Tables") print(cursor.fetchall())

#Doping EMPLOYEE table if already exists cursor.execute("DROP TABLE EMPLOYEE") 
   print("Table dropped... ")

#Retrieving the list of tables print(
   "List of tables after dropping the EMPLOYEE table: "
) 
cursor.execute("SHOW Tables") print(cursor.fetchall())

#Closing the connection 
conn.close()

산출

List of tables in the database:
[('employee',), ('employeedata',), ('sample',), ('tutorials',)]
Table dropped...
List of tables after dropping the EMPLOYEE table:
[('employeedata',), ('sample',), ('tutorials',)]

존재하는 경우에만 테이블 삭제

데이터베이스에 존재하지 않는 테이블을 삭제하려고하면 다음과 같은 오류가 발생합니다.

mysql.connector.errors.ProgrammingError: 1051 (42S02): Unknown table 'mydb.employee'

DELETE 문에 IF EXISTS를 추가하여 삭제하기 전에 테이블이 있는지 확인하여이 오류를 방지 할 수 있습니다.

Example

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving the list of tables
print("List of tables in the database: ")
cursor.execute("SHOW Tables")
print(cursor.fetchall())

#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
print("Table dropped... ")

#Retrieving the list of tables
print("List of tables after dropping the EMPLOYEE table: ")
cursor.execute("SHOW Tables")
print(cursor.fetchall())

#Closing the connection
conn.close()

Output

List of tables in the database:
[('employeedata',), ('sample',), ('tutorials',)]
Table dropped...
List of tables after dropping the EMPLOYEE table:
[('employeedata',), ('sample',),
('tutorials',)]

특정 수로 제한하려는 경우 레코드를 가져 오는 동안 MYSQL의 LIMIT 절을 사용하면됩니다.

예

MySQL에서 EMPLOYEES라는 이름으로 테이블을 만들었다 고 가정합니다.

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

그리고 INSERT 문을 사용하여 4 개의 레코드를 삽입했다면-

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

다음 SQL 문은 LIMIT 절을 사용하여 Employee 테이블의 처음 두 레코드를 검색합니다.

SELECT * FROM EMPLOYEE LIMIT 2;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |    19| M    | 2000   |
| Raj        | Kandukuri |    20| M    | 7000   |
+------------+-----------+------+------+--------+
2 rows in set (0.00 sec)

Python을 사용한 제한 조항

호출하면 execute() LIMIT 절과 함께 SELECT 쿼리를 전달하여 커서 개체에 메서드를 사용하면 필요한 레코드 수를 검색 할 수 있습니다.

예

다음 python 예제는 EMPLOYEE라는 이름의 테이블을 만들고 채우며 LIMIT 절을 사용하여 테이블의 처음 두 레코드를 가져옵니다.

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 2'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

산출

[('Krishna', 'Sharma', 26, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

오프셋으로 제한

첫 번째가 아닌 n 번째 레코드부터 시작하는 레코드를 제한해야하는 경우 LIMIT와 함께 OFFSET을 사용하여 그렇게 할 수 있습니다.

Example

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 2 OFFSET 2'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

Output

[('Ramya', 'Ramapriya', 29, 'F', 5000.0), ('Mac', 'Mohan', 26, 'M', 2000.0)]

데이터를 두 테이블로 나눈 경우 조인을 사용하여이 두 테이블에서 결합 된 레코드를 가져올 수 있습니다.

예

EMPLOYEE라는 이름의 테이블을 만들고 아래와 같이 데이터를 채웠다 고 가정합니다.

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT,
   CONTACT INT
);
Query OK, 0 rows affected (0.36 sec)
INSERT INTO Employee VALUES 
   ('Ramya', 'Rama Priya', 27, 'F', 9000, 101), 
   ('Vinay', 'Bhattacharya', 20, 'M', 6000, 102), 
   ('Sharukh', 'Sheik', 25, 'M', 8300, 103), 
   ('Sarmista', 'Sharma', 26, 'F', 10000, 104), 
   ('Trupthi', 'Mishra', 24, 'F', 6000, 105);
Query OK, 5 rows affected (0.08 sec)
Records: 5 Duplicates: 0 Warnings: 0

그런 다음 다른 테이블을 만들고 다음과 같이 채웠다면-

CREATE TABLE CONTACT(
   ID INT NOT NULL,
   EMAIL CHAR(20) NOT NULL,
   PHONE LONG,
   CITY CHAR(20)
);
Query OK, 0 rows affected (0.49 sec)

INSERT INTO CONTACT (ID, EMAIL, CITY) VALUES 
   (101, '[email protected]', 'Hyderabad'), 
   (102, '[email protected]', 'Vishakhapatnam'), 
   (103, '[email protected]', 'Pune'), 
   (104, '[email protected]', 'Mumbai'); 
Query OK, 4 rows affected (0.10 sec)
Records: 4 Duplicates: 0 Warnings: 0

다음 문은이 두 테이블의 값을 결합한 데이터를 검색합니다.

mysql> SELECT * from EMPLOYEE INNER JOIN CONTACT ON EMPLOYEE.CONTACT = CONTACT.ID;
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
| FIRST_NAME | LAST_NAME    | AGE  | SEX  | INCOME | CONTACT | ID  | EMAIL              | PHONE | CITY           |
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
| Ramya      | Rama Priya   | 27   | F    | 9000   | 101     | 101 | [email protected] | NULL  | Hyderabad      |
| Vinay      | Bhattacharya | 20   | M    | 6000   | 102     | 102 | [email protected]    | NULL  | Vishakhapatnam |
| Sharukh    | Sheik        | 25   | M    | 8300   | 103     | 103 | [email protected] | NULL  | Pune           |
| Sarmista   | Sharma       | 26   | F    | 10000  | 104     | 104 | [email protected]    | NULL  | Mumbai         |
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
4 rows in set (0.00 sec)

Python을 사용하여 MYSQL JOIN

다음 예제는 EMPLOYEE 테이블의 연락처 열과 CONTACT 테이블의 ID 열로 결합 된 위의 두 테이블에서 데이터를 검색합니다.

예

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE INNER JOIN CONTACT ON EMPLOYEE.CONTACT = CONTACT.ID'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchall();

print(result)

#Closing the connection
conn.close()

산출

[
   ('Krishna', 'Sharma', 26, 'M', 2000, 101, 101, '[email protected]', 9848022338, 'Hyderabad'), 
   ('Raj', 'Kandukuri', 20, 'M', 7000, 102, 102, '[email protected]', 9848022339, 'Vishakhapatnam'), 
   ('Ramya', 'Ramapriya', 29, 'F', 5000, 103, 103, '[email protected]', 9848022337, 'Pune'), 
   ('Mac', 'Mohan', 26, 'M', 2000, 104, 104, '[email protected]', 9848022330, 'Mumbai')
]

mysql-connector-python (및 유사한 라이브러리)의 MySQLCursor는 MySQL 데이터베이스와 통신하는 문을 실행하는 데 사용됩니다.

그것의 방법을 사용하여 SQL 문을 실행하고, 결과 집합에서 데이터를 가져오고, 프로 시저를 호출 할 수 있습니다.

당신은 만들 수 있습니다 Cursor Connection 객체 / 클래스의 cursor () 메서드를 사용하는 객체.

예

import mysql.connector
#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()

행동 양식

다음은 Cursor 클래스 / 객체에서 제공하는 다양한 메서드입니다.

Sr. 아니요	방법 및 설명
1	callproc() 이 메서드는 기존 프로 시저 MySQL 데이터베이스를 호출하는 데 사용됩니다.
2	close() 이 메서드는 현재 커서 개체를 닫는 데 사용됩니다.
삼	Info() 이 메서드는 마지막 쿼리에 대한 정보를 제공합니다.
4	executemany() 이 메소드는 일련의 매개 변수 목록을 허용합니다. MySQL 쿼리를 준비하고 모든 매개 변수를 사용하여 실행합니다.
5	execute() 이 메소드는 MySQL 쿼리를 매개 변수로 받아들이고 주어진 쿼리를 실행합니다.
6	fetchall() 이 메서드는 쿼리 결과 집합의 모든 행을 검색하여 튜플 목록으로 반환합니다. (몇 개의 행을 검색 한 후 이것을 실행하면 나머지 행을 반환합니다)
7	fetchone() 이 메서드는 쿼리 결과에서 다음 행을 가져 와서 튜플로 반환합니다.
8	fetchmany() 이 메소드는 fetchone ()과 유사하지만 단일 행 대신 쿼리 결과 세트에서 다음 행 세트를 검색합니다.
9	fetchwarnings() 이 메서드는 마지막으로 실행 된 쿼리에서 생성 된 경고를 반환합니다.

속성

다음은 Cursor 클래스의 속성입니다-

Sr. 아니요	속성 및 설명
1	column_names 결과 집합의 열 이름이 포함 된 목록을 반환하는 읽기 전용 속성입니다.
2	description 결과 집합의 열 설명이 포함 된 목록을 반환하는 읽기 전용 속성입니다.
삼	lastrowid 이는 읽기 전용 속성입니다. 테이블에 자동 증가 된 열이있는 경우 마지막 INSERT 또는 UPDATE 작업에서 해당 열에 대해 생성 된 값을 반환합니다.
4	rowcount SELECT 및 UPDATE 작업의 경우 반환 / 업데이트 된 행 수를 반환합니다.
5	statement 이 속성은 마지막으로 실행 된 문을 반환합니다.