Python 데이터 액세스-빠른 가이드
데이터베이스 인터페이스의 Python 표준은 Python DB-API입니다. 대부분의 Python 데이터베이스 인터페이스는이 표준을 따릅니다.
애플리케이션에 적합한 데이터베이스를 선택할 수 있습니다. Python Database API는 다음과 같은 광범위한 데이터베이스 서버를 지원합니다.
- GadFly
- mSQL
- MySQL
- PostgreSQL
- 마이크로 소프트 SQL 서버 2000
- Informix
- Interbase
- Oracle
- Sybase
여기에 사용할 수 파이썬 데이터베이스 인터페이스의 목록입니다 : 파이썬 데이터베이스 인터페이스 및 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_MySQLPIP 확인
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.6mysql-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
Python Data Access
4
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 홈 페이지를 방문하십시오 .
클릭 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> 프롬프트에서 exit 명령을 사용하여 언제든지 MySQL 데이터베이스에서 연결을 끊을 수 있습니다.
mysql> exit
ByePython을 사용하여 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() 방법.
간단히 말해서 python 7minus를 사용하여 테이블을 생성하는 것입니다.
수입 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 insertedSELECT 쿼리를 사용하여 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)파이썬을 사용하는 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)파이썬을 사용하는 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)
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)파이썬을 사용하여 테이블의 레코드 제거
데이터베이스에서 일부 레코드를 삭제하려면 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를 추가하여 삭제하기 전에 테이블이 있는지 확인하여이 오류를 방지 할 수 있습니다.
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()산출
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)파이썬을 사용하는 제한 절
호출하면 execute() LIMIT 절과 함께 SELECT 쿼리를 전달하여 커서 개체에 메서드를 사용하면 필요한 레코드 수를 검색 할 수 있습니다.
Python을 사용하여 MYSQL 데이터베이스에서 테이블을 삭제하려면 execute() 커서 개체에 메서드를 추가하고 drop 문을 매개 변수로 전달합니다.
예
다음 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 번째 레코드 ( 1st가 아님) 에서 시작하는 레코드를 제한해야하는 경우 LIMIT와 함께 OFFSET을 사용하여 그렇게 할 수 있습니다.
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()산출
[('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 | etchwarnings() 이 메서드는 마지막으로 실행 된 쿼리에서 생성 된 경고를 반환합니다. |
속성
다음은 Cursor 클래스의 속성입니다-
| Sr. 아니요 | 속성 및 설명 |
|---|---|
| 1 | column_names 결과 집합의 열 이름이 포함 된 목록을 반환하는 읽기 전용 속성입니다. |
| 2 | description 결과 집합의 열 설명이 포함 된 목록을 반환하는 읽기 전용 속성입니다. |
| 삼 | lastrowid 이는 읽기 전용 속성입니다. 테이블에 자동 증가 된 열이있는 경우 마지막 INSERT 또는 UPDATE 작업에서 해당 열에 대해 생성 된 값을 반환합니다. |
| 4 | rowcount SELECT 및 UPDATE 작업의 경우 반환 / 업데이트 된 행 수를 반환합니다. |
| 5 | statement 이 속성은 마지막으로 실행 된 문을 반환합니다. |
설치
PostgreSQL은 강력한 오픈 소스 객체 관계형 데이터베이스 시스템입니다. 15 년 이상의 활발한 개발 단계와 신뢰성, 데이터 무결성 및 정확성에 대한 강력한 명성을 얻은 입증 된 아키텍처를 보유하고 있습니다.
Python을 사용하여 PostgreSQL과 통신하려면 Python 프로그래밍 용으로 제공되는 어댑터 인 psycopg를 설치해야합니다. 현재 버전은 다음과 같습니다. psycog2.
psycopg2는 매우 작고 빠르며 바위처럼 안정적이라는 목표로 작성되었습니다. PIP (python의 패키지 관리자)에서 사용할 수 있습니다.
PIP를 사용하여 Psycog2 설치
우선, 파이썬과 PIP가 시스템에 제대로 설치되어 있고 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그런 다음 관리자 모드에서 명령 프롬프트를 열고 pip install psycopg2-binary 아래와 같이 명령-
C:\WINDOWS\system32>pip install psycopg2-binary
Collecting psycopg2-binary
Using cached https://files.pythonhosted.org/packages/80/79/d0d13ce4c2f1addf4786f4a2ded802c2df66ddf3c1b1a982ed8d4cb9fc6d/psycopg2_binary-2.8.3-cp37-cp37m-win32.whl
Installing collected packages: psycopg2-binary
Successfully installed psycopg2-binary-2.8.3확인
설치를 확인하려면 다음 줄이 포함 된 샘플 Python 스크립트를 만듭니다.
import mysql.connector설치가 성공하면 실행하면 오류가 발생하지 않습니다.
D:\Python_PostgreSQL>import psycopg2
D:\Python_PostgreSQL>PostgreSQL은 쿼리를 실행하기위한 자체 셸을 제공합니다. PostgreSQL 데이터베이스와의 연결을 설정하려면 시스템에 올바르게 설치했는지 확인하십시오. PostgreSQL 셸 프롬프트를 열고 서버, 데이터베이스, 사용자 이름 및 암호와 같은 세부 정보를 전달합니다. 제공 한 모든 세부 정보가 적절하다면 PostgreSQL 데이터베이스와의 연결이 설정됩니다.
세부 정보를 전달하는 동안 기본 서버, 데이터베이스, 포트 및 셸에서 제안한 사용자 이름을 사용할 수 있습니다.
Python을 사용하여 연결 설정
연결 클래스 psycopg2연결 인스턴스를 나타내거나 처리합니다. 다음을 사용하여 새 연결을 만들 수 있습니다.connect()함수. 이것은 dbname, 사용자, 암호, 호스트, 포트와 같은 기본 연결 매개 변수를 받아들이고 연결 개체를 반환합니다. 이 기능을 사용하여 PostgreSQL과의 연결을 설정할 수 있습니다.
예
다음 Python 코드는 기존 데이터베이스에 연결하는 방법을 보여줍니다. 데이터베이스가 존재하지 않으면 생성되고 마지막으로 데이터베이스 개체가 반환됩니다. PostgreSQL의 기본 데이터베이스 이름은 postrgre 입니다. 따라서 데이터베이스 이름으로 제공합니다.
import psycopg2
#establishing the connection
conn = psycopg2.connect(
database="postgres", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Executing an MYSQL function using the execute() method
cursor.execute("select version()")
# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print("Connection established to: ",data)
#Closing the connection
conn.close()
Connection established to: (
'PostgreSQL 11.5, compiled by Visual C++ build 1914, 64-bit',
)산출
Connection established to: (
'PostgreSQL 11.5, compiled by Visual C++ build 1914, 64-bit',
)CREATE DATABASE 문을 사용하여 PostgreSQL에서 데이터베이스를 생성 할 수 있습니다. 명령 뒤에 생성 할 데이터베이스의 이름을 지정하여 PostgreSQL 셸 프롬프트에서이 문을 실행할 수 있습니다.
통사론
다음은 CREATE DATABASE 문의 구문입니다.
CREATE DATABASE dbname;예
다음 문은 PostgreSQL에서 testdb라는 데이터베이스를 생성합니다.
postgres=# CREATE DATABASE testdb;
CREATE DATABASE\ l 명령을 사용하여 PostgreSQL에서 데이터베이스를 나열 할 수 있습니다. 데이터베이스 목록을 확인하면 다음과 같이 새로 생성 된 데이터베이스를 찾을 수 있습니다.
postgres=# \l
List of databases
Name | Owner | Encoding | Collate | Ctype |
-----------+----------+----------+----------------------------+-------------+
mydb | postgres | UTF8 | English_United States.1252 | ........... |
postgres | postgres | UTF8 | English_United States.1252 | ........... |
template0 | postgres | UTF8 | English_United States.1252 | ........... |
template1 | postgres | UTF8 | English_United States.1252 | ........... |
testdb | postgres | UTF8 | English_United States.1252 | ........... |
(5 rows)또한 SQL 문 CREATE DATABASE를 둘러싼 래퍼 인 createdb 명령을 사용하여 명령 프롬프트에서 PostgreSQL에 데이터베이스를 생성 할 수 있습니다 .
C:\Program Files\PostgreSQL\11\bin> createdb -h localhost -p 5432 -U postgres sampledb
Password:Python을 사용하여 데이터베이스 만들기
psycopg2의 커서 클래스는 다양한 PostgreSQL 명령을 실행하고 레코드를 가져오고 데이터를 복사하는 다양한 방법을 제공합니다. Connection 클래스의 cursor () 메서드를 사용하여 커서 객체를 만들 수 있습니다.
이 클래스의 execute () 메소드는 PostgreSQL 쿼리를 매개 변수로 받아 실행합니다.
따라서 PostgreSQL에서 데이터베이스를 생성하려면이 방법을 사용하여 CREATE DATABASE 쿼리를 실행합니다.
예
다음 파이썬 예제는 PostgreSQL 데이터베이스에 mydb라는 데이터베이스를 생성합니다.
import psycopg2
#establishing the connection
conn = psycopg2.connect(
database="postgres", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
conn.autocommit = True
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Preparing query to create a database
sql = '''CREATE database mydb''';
#Creating a database
cursor.execute(sql)
print("Database created successfully........")
#Closing the connection
conn.close()산출
Database created successfully........CREATE TABLE 문을 사용하여 PostgreSQL의 데이터베이스에 새 테이블을 생성 할 수 있습니다. 이를 실행하는 동안 테이블 이름, 열 이름 및 해당 데이터 유형을 지정해야합니다.
통사론
다음은 PostgreSQL의 CREATE TABLE 문의 구문입니다.
CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
);예
다음 예제는 PostgreSQL에서 이름이 CRICKETERS 인 테이블을 생성합니다.
postgres=# CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age INT,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
CREATE TABLE
postgres=#\ dt 명령을 사용하여 PostgreSQL에서 데이터베이스의 테이블 목록을 가져올 수 있습니다. 테이블을 생성 한 후 테이블 목록을 확인할 수 있다면 새로 생성 된 테이블을 다음과 같이 관찰 할 수 있습니다.
postgres=# \dt
List of relations
Schema | Name | Type | Owner
--------+------------+-------+----------
public | cricketers | table | postgres
(1 row)
postgres=#같은 방법으로 아래와 같이 \ d를 사용하여 생성 된 테이블에 대한 설명을 얻을 수 있습니다.
postgres=# \d cricketers
Table "public.cricketers"
Column | Type | Collation | Nullable | Default
----------------+------------------------+-----------+----------+---------
first_name | character varying(255) | | |
last_name | character varying(255) | | |
age | integer | | |
place_of_birth | character varying(255) | | |
country | character varying(255) | | |
postgres=#Python을 사용하여 테이블 만들기
Python을 사용하여 테이블을 생성하려면 pyscopg2 Cursor의 execute () 메서드를 사용하여 CREATE TABLE 문을 실행해야합니다 .
예
다음 Python 예제에서는 이름이 employee 인 테이블을 만듭니다.
import psycopg2
#Establishing the connection
conn = psycopg2.connect(
database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Doping 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)
print("Table created successfully........")
#Closing the connection
conn.close()산출
Table created successfully........PostgreSQL의 기존 테이블에 레코드를 삽입 할 수 있습니다. INSERT INTO성명서. 이를 실행하는 동안 테이블의 이름과 테이블의 열 값을 지정해야합니다.
통사론
다음은 INSERT 문의 권장 구문입니다-
INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);여기서 column1, column2, column3, ..은 테이블의 열 이름이고 value1, value2, value3, ...은 테이블에 삽입해야하는 값입니다.
예
아래와 같이 CREATE TABLE 문을 사용하여 이름이 CRICKETERS 인 테이블을 생성했다고 가정합니다.
postgres=# CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age INT,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
CREATE TABLE
postgres=#다음 PostgreSQL 문은 위에서 생성 된 테이블에 행을 삽입합니다-
postgres=# insert into CRICKETERS (
First_Name, Last_Name, Age, Place_Of_Birth, Country)
values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=#INSERT INTO 문을 사용하여 레코드를 삽입하는 동안 열 이름을 건너 뛰면 레코드가 삽입되고 건너 뛴 열에 빈 공간이 남습니다.
postgres=# insert into CRICKETERS (First_Name, Last_Name, Country)
values('Jonathan', 'Trott', 'SouthAfrica');
INSERT 0 1전달하는 값의 순서가 테이블의 각 열 이름과 동일한 경우 열 이름을 지정하지 않고 테이블에 레코드를 삽입 할 수도 있습니다.
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1
postgres=#테이블에 레코드를 삽입 한 후 아래와 같이 SELECT 문을 사용하여 내용을 확인할 수 있습니다.
postgres=# SELECT * from CRICKETERS;
first_name | last_name | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Shikhar | Dhawan | 33 | Delhi | India
Jonathan | Trott | | | SouthAfrica
Kumara | Sangakkara | 41 | Matale | Srilanka
Virat | Kohli | 30 | Delhi | India
Rohit | Sharma | 32 | Nagpur | India
(5 rows)Python을 사용하여 데이터 삽입
psycopg2의 커서 클래스는 execute () 메서드라는 이름의 메서드를 제공합니다. 이 메서드는 쿼리를 매개 변수로 받아들이고 실행합니다.
따라서 Python을 사용하여 PostgreSQL의 테이블에 데이터를 삽입하려면-
수입 psycopg2 꾸러미.
다음을 사용하여 연결 개체를 만듭니다. connect() 사용자 이름, 암호, 호스트 (선택적 기본값 : localhost) 및 데이터베이스 (선택적)를 매개 변수로 전달하여 메소드를 사용합니다.
속성 값으로 false를 설정하여 자동 커밋 모드를 끕니다. autocommit.
그만큼 cursor() 의 방법 Connectionpsycopg2 라이브러리의 클래스는 커서 객체를 반환합니다. 이 메서드를 사용하여 커서 개체를 만듭니다.
그런 다음 INSERT 문을 매개 변수로 execute () 메서드에 전달하여 실행합니다.
예
다음 Python 프로그램은 PostgreSQL 데이터베이스에 EMPLOYEE라는 이름의 테이블을 생성하고 execute () 메서드를 사용하여 레코드를 삽입합니다.
import psycopg2
#Establishing the connection
conn = psycopg2.connect(
database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
# Preparing SQL queries to INSERT a record into the database.
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
INCOME) VALUES ('Ramya', 'Rama priya', 27, 'F', 9000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
INCOME) VALUES ('Vinay', 'Battacharya', 20, 'M', 6000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
INCOME) VALUES ('Sharukh', 'Sheik', 25, 'M', 8300)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
INCOME) VALUES ('Sarmista', 'Sharma', 26, 'F', 10000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
INCOME) VALUES ('Tripthi', 'Mishra', 24, 'F', 6000)''')
# Commit your changes in the database
conn.commit()
print("Records inserted........")
# Closing the connection
conn.close()산출
Records inserted........SELECT 문을 사용하여 PostgreSQL에서 기존 테이블의 내용을 검색 할 수 있습니다. 이 명령문에서 테이블의 이름을 지정해야하며 결과 세트로 알려진 테이블 형식으로 컨텐츠를 리턴합니다.
통사론
다음은 PostgreSQL의 SELECT 문의 구문입니다.
SELECT column1, column2, columnN FROM table_name;예
다음 쿼리를 사용하여 이름이 CRICKETERS 인 테이블을 생성했다고 가정합니다.
postgres=# CREATE TABLE CRICKETERS (
First_Name VARCHAR(255), Last_Name VARCHAR(255),
Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#그리고 INSERT 문을 사용하여 5 개의 레코드를 삽입했다면-
postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1다음 SELECT 쿼리는 CRICKETERS 테이블에서 FIRST_NAME, LAST_NAME 및 COUNTRY 열의 값을 검색합니다.
postgres=# SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
first_name | last_name | country
------------+------------+-------------
Shikhar | Dhawan | India
Jonathan | Trott | SouthAfrica
Kumara | Sangakkara | Srilanka
Virat | Kohli | India
Rohit | Sharma | India
(5 rows)각 레코드의 모든 열을 검색하려면 다음과 같이 열 이름을 "*"로 바꿔야합니다.
postgres=# SELECT * FROM CRICKETERS;
first_name | last_name | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Shikhar | Dhawan | 33 | Delhi | India
Jonathan | Trott | 38 | CapeTown | SouthAfrica
Kumara | Sangakkara | 41 | Matale | Srilanka
Virat | Kohli | 30 | Delhi | India
Rohit | Sharma | 32 | Nagpur | India
(5 rows)
postgres=#Python을 사용하여 데이터 검색
모든 데이터베이스에 대한 읽기 작업은 데이터베이스에서 유용한 정보를 가져 오는 것을 의미합니다. psycopg2에서 제공하는 fetch () 메서드를 사용하여 PostgreSQL에서 데이터를 가져올 수 있습니다.
Cursor 클래스는 fetchall (), fetchmany () 및 fetchone ()의 세 가지 메소드를 제공합니다.
fetchall () 메서드는 쿼리 결과 집합의 모든 행을 검색하여 튜플 목록으로 반환합니다. (몇 개의 행을 검색 한 후 이것을 실행하면 나머지 행을 반환합니다).
fetchone () 메서드는 쿼리 결과에서 다음 행을 가져 와서 튜플로 반환합니다.
fetchmany () 메소드는 fetchone ()과 유사하지만 단일 행 대신 쿼리 결과 세트에서 다음 행 세트를 검색합니다.
Note − 결과 집합은 커서 개체를 사용하여 테이블을 쿼리 할 때 반환되는 개체입니다.
예
다음 Python 프로그램은 PostgreSQL의 mydb라는 데이터베이스에 연결하고 EMPLOYEE라는 테이블에서 모든 레코드를 검색합니다.
import psycopg2
#establishing the connection
conn = psycopg2.connect(
database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Retrieving data
cursor.execute('''SELECT * from EMPLOYEE''')
#Fetching 1st row from the table
result = cursor.fetchone();
print(result)
#Fetching 1st row from the table
result = cursor.fetchall();
print(result)
#Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
('Ramya', 'Rama priya', 27, 'F', 9000.0)
[('Vinay', 'Battacharya', 20, 'M', 6000.0),
('Sharukh', 'Sheik', 25, 'M', 8300.0),
('Sarmista', 'Sharma', 26, 'F', 10000.0),
('Tripthi', 'Mishra', 24, 'F', 6000.0)]SELECT, UPDATE 또는 DELETE 작업을 수행하는 동안 WHERE 절을 사용하여 레코드를 필터링하는 조건을 지정할 수 있습니다. 작업은 주어진 조건을 만족하는 레코드에 대해 수행됩니다.
통사론
다음은 PostgreSQL의 WHERE 절 구문입니다.
SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]비교 또는 논리 연산자를 사용하여 search_condition을 지정할 수 있습니다. >, <, =, LIKE, NOT 등. 다음 예제는이 개념을 명확하게합니다.
예
다음 쿼리를 사용하여 이름이 CRICKETERS 인 테이블을 생성했다고 가정합니다.
postgres=# CREATE TABLE CRICKETERS (
First_Name VARCHAR(255), Last_Name VARCHAR(255),
Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#그리고 INSERT 문을 사용하여 5 개의 레코드를 삽입했다면-
postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1다음 SELECT 문은 나이가 35보다 큰 레코드를 검색합니다-
postgres=# SELECT * FROM CRICKETERS WHERE AGE > 35;
first_name | last_name | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Jonathan | Trott | 38 | CapeTown | SouthAfrica
Kumara | Sangakkara | 41 | Matale | Srilanka
(2 rows)
postgres=#파이썬을 사용하는 Where 절
Python 프로그램을 사용하여 테이블에서 특정 레코드를 가져 오려면 WHERE 절이있는 SELECT 문을 매개 변수로 전달하여 execute() 방법.
예
다음 python 예제는 python을 사용하는 WHERE 명령의 사용법을 보여줍니다.
import psycopg2
#establishing the connection
conn = psycopg2.connect(
database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True
#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, 'M', 5000),
('Mac', 'Mohan', 26, 'M', 2000)]
cursor.executemany(insert_stmt, data)
#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())
#Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]일반적으로 테이블에서 데이터를 검색하려고하면 삽입 한 순서와 동일한 순서로 레코드를 가져옵니다.
사용 ORDER BY 절, 테이블의 레코드를 검색하는 동안 원하는 열을 기준으로 결과 레코드를 오름차순 또는 내림차순으로 정렬 할 수 있습니다.
통사론
다음은 PostgreSQL의 ORDER BY 절 구문입니다.
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];예
다음 쿼리를 사용하여 이름이 CRICKETERS 인 테이블을 생성했다고 가정합니다.
postgres=# CREATE TABLE CRICKETERS (
First_Name VARCHAR(255), Last_Name VARCHAR(255),
Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#그리고 INSERT 문을 사용하여 5 개의 레코드를 삽입했다면-
postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1다음 SELECT 문은 연령의 오름차순으로 CRICKETERS 테이블의 행을 검색합니다-
postgres=# SELECT * FROM CRICKETERS ORDER BY AGE;
first_name | last_name | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Virat | Kohli | 30 | Delhi | India
Rohit | Sharma | 32 | Nagpur | India
Shikhar | Dhawan | 33 | Delhi | India
Jonathan | Trott | 38 | CapeTown | SouthAfrica
Kumara | Sangakkara | 41 | Matale | Srilanka
(5 rows)es:둘 이상의 열을 사용하여 테이블의 레코드를 정렬 할 수 있습니다. 다음 SELECT 문은 열 age 및 FIRST_NAME을 기준으로 CRICKETERS 테이블의 레코드를 정렬합니다.
postgres=# SELECT * FROM CRICKETERS ORDER BY AGE, FIRST_NAME;
first_name | last_name | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Virat | Kohli | 30 | Delhi | India
Rohit | Sharma | 32 | Nagpur | India
Shikhar | Dhawan | 33 | Delhi | India
Jonathan | Trott | 38 | CapeTown | SouthAfrica
Kumara | Sangakkara | 41 | Matale | Srilanka
(5 rows)기본적으로 ORDER BY절은 테이블의 레코드를 오름차순으로 정렬합니다. DESC를 사용하여 결과를 내림차순으로 정렬 할 수 있습니다.
postgres=# SELECT * FROM CRICKETERS ORDER BY AGE DESC;
first_name | last_name | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Kumara | Sangakkara | 41 | Matale | Srilanka
Jonathan | Trott | 38 | CapeTown | SouthAfrica
Shikhar | Dhawan | 33 | Delhi | India
Rohit | Sharma | 32 | Nagpur | India
Virat | Kohli | 30 | Delhi | India
(5 rows)파이썬을 사용하는 ORDER BY 절
특정 순서로 테이블의 내용을 검색하려면 커서 개체에서 execute () 메서드를 호출하고 ORDER BY 절과 함께 SELECT 문을 매개 변수로 전달합니다.
예
다음 예에서는 ORDER BY 절을 사용하여 이름과 직원이있는 테이블을 만들고, 채우고, 해당 레코드를 나이의 (오름차순) 순서로 다시 검색합니다.
import psycopg2
#establishing the connection
conn = psycopg2.connect(
database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
#Creating a table
sql = '''CREATE TABLE EMPLOYEE(
FIRST_NAME CHAR(20) NOT NULL,
LAST_NAME CHAR(20),
AGE INT, SEX CHAR(1),
INCOME INT,
CONTACT INT
)'''
cursor.execute(sql)
#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (
FIRST_NAME, LAST_NAME, AGE, SEX, INCOME, CONTACT) VALUES
(%s, %s, %s, %s, %s, %s)"
data = [('Krishna', 'Sharma', 26, 'M', 2000, 101),
('Raj', 'Kandukuri', 20, 'M', 7000, 102),
('Ramya', 'Ramapriya', 29, 'F', 5000, 103),
('Mac', 'Mohan', 26, 'M', 2000, 104)]
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())
#Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
[('Sharukh', 'Sheik', 25, 'M', 8300.0), ('Sarmista', 'Sharma', 26, 'F', 10000.0)]UPDATE 문을 사용하여 PostgreSQL에서 테이블의 기존 레코드 내용을 수정할 수 있습니다. 특정 행을 업데이트하려면 WHERE 절을 함께 사용해야합니다.
통사론
다음은 PostgreSQL의 UPDATE 문의 구문입니다.
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];예
다음 쿼리를 사용하여 이름이 CRICKETERS 인 테이블을 생성했다고 가정합니다.
postgres=# CREATE TABLE CRICKETERS (
First_Name VARCHAR(255), Last_Name VARCHAR(255),
Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#그리고 INSERT 문을 사용하여 5 개의 레코드를 삽입했다면-
postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1다음 문은 이름이 크리켓 선수의 나이를 수정합니다. Shikhar −
postgres=# UPDATE CRICKETERS SET AGE = 45 WHERE FIRST_NAME = 'Shikhar' ;
UPDATE 1
postgres=#FIRST_NAME이 Shikhar 인 레코드를 검색하면 나이 값이 45로 변경된 것을 볼 수 있습니다.
postgres=# SELECT * FROM CRICKETERS WHERE FIRST_NAME = 'Shikhar';
first_name | last_name | age | place_of_birth | country
------------+-----------+-----+----------------+---------
Shikhar | Dhawan | 45 | Delhi | India
(1 row)
postgres=#WHERE 절을 사용하지 않은 경우 모든 레코드의 값이 업데이트됩니다. 다음 UPDATE 문은 CRICKETERS 테이블에있는 모든 레코드의 나이를 1 씩 증가시킵니다.
postgres=# UPDATE CRICKETERS SET AGE = AGE+1;
UPDATE 5SELECT 명령을 사용하여 테이블의 내용을 검색하면 업데이트 된 값을 다음과 같이 볼 수 있습니다.
postgres=# SELECT * FROM CRICKETERS;
first_name | last_name | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Jonathan | Trott | 39 | CapeTown | SouthAfrica
Kumara | Sangakkara | 42 | Matale | Srilanka
Virat | Kohli | 31 | Delhi | India
Rohit | Sharma | 33 | Nagpur | India
Shikhar | Dhawan | 46 | Delhi | India
(5 rows)Python을 사용하여 레코드 업데이트
psycopg2의 커서 클래스는 execute () 메서드라는 이름의 메서드를 제공합니다. 이 메서드는 쿼리를 매개 변수로 받아들이고 실행합니다.
따라서 Python을 사용하여 PostgreSQL의 테이블에 데이터를 삽입하려면-
수입 psycopg2 꾸러미.
다음을 사용하여 연결 개체를 만듭니다. connect() 사용자 이름, 암호, 호스트 (선택적 기본값 : localhost) 및 데이터베이스 (선택적)를 매개 변수로 전달하여 메소드를 사용합니다.
속성 값으로 false를 설정하여 자동 커밋 모드를 끕니다. autocommit.
그만큼 cursor() 의 방법 Connectionpsycopg2 라이브러리의 클래스는 커서 객체를 반환합니다. 이 메서드를 사용하여 커서 개체를 만듭니다.
그런 다음 execute () 메서드에 매개 변수로 전달하여 UPDATE 문을 실행합니다.
예
다음 Python 코드는 Employee 테이블의 내용을 업데이트하고 결과를 검색합니다.
import psycopg2
#establishing the connection
conn = psycopg2.connect(
database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Fetching all the rows before the update
print("Contents of the Employee table: ")
sql = '''SELECT * from EMPLOYEE'''
cursor.execute(sql)
print(cursor.fetchall())
#Updating the records
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M'"
cursor.execute(sql)
print("Table updated...... ")
#Fetching all the rows after the update
print("Contents of the Employee table after the update operation: ")
sql = '''SELECT * from EMPLOYEE'''
cursor.execute(sql)
print(cursor.fetchall())
#Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
Contents of the Employee table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0),
('Vinay', 'Battacharya', 20, 'M', 6000.0),
('Sharukh', 'Sheik', 25, 'M', 8300.0),
('Sarmista', 'Sharma', 26, 'F', 10000.0),
('Tripthi', 'Mishra', 24, 'F', 6000.0)]
Table updated......
Contents of the Employee table after the update operation:
[('Ramya', 'Rama priya', 27, 'F', 9000.0),
('Sarmista', 'Sharma', 26, 'F', 10000.0),
('Tripthi', 'Mishra', 24, 'F', 6000.0),
('Vinay', 'Battacharya', 21, 'M', 6000.0),
('Sharukh', 'Sheik', 26, 'M', 8300.0)]다음을 사용하여 기존 테이블의 레코드를 삭제할 수 있습니다. DELETE FROMPostgreSQL 데이터베이스의 문. 특정 레코드를 제거하려면 WHERE 절을 함께 사용해야합니다.
통사론
다음은 PostgreSQL의 DELETE 쿼리 구문입니다.
DELETE FROM table_name [WHERE Clause]예
다음 쿼리를 사용하여 이름이 CRICKETERS 인 테이블을 생성했다고 가정합니다.
postgres=# CREATE TABLE CRICKETERS (
First_Name VARCHAR(255), Last_Name VARCHAR(255),
Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#그리고 INSERT 문을 사용하여 5 개의 레코드를 삽입했다면-
postgres=# insert into CRICKETERS values ('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1다음 문장은 성이 '상악 카라'인 크리켓 선수의 기록을 삭제합니다. −
postgres=# DELETE FROM CRICKETERS WHERE LAST_NAME = 'Sangakkara';
DELETE 1SELECT 문을 사용하여 테이블의 내용을 검색하면 하나를 삭제했기 때문에 4 개의 레코드 만 볼 수 있습니다.
postgres=# SELECT * FROM CRICKETERS;
first_name | last_name | age | place_of_birth | country
------------+-----------+-----+----------------+-------------
Jonathan | Trott | 39 | CapeTown | SouthAfrica
Virat | Kohli | 31 | Delhi | India
Rohit | Sharma | 33 | Nagpur | India
Shikhar | Dhawan | 46 | Delhi | India
(4 rows)WHERE 절없이 DELETE FROM 문을 실행하면 지정된 테이블의 모든 레코드가 삭제됩니다.
postgres=# DELETE FROM CRICKETERS;
DELETE 4모든 레코드를 삭제 했으므로 CRICKETERS 테이블의 내용을 검색하려고하면 SELECT 문을 사용하여 아래와 같이 빈 결과 집합을 얻게됩니다.
postgres=# SELECT * FROM CRICKETERS;
first_name | last_name | age | place_of_birth | country
------------+-----------+-----+----------------+---------
(0 rows)Python을 사용하여 데이터 삭제
psycopg2의 커서 클래스는 execute () 메서드라는 이름의 메서드를 제공합니다. 이 메서드는 쿼리를 매개 변수로 받아들이고 실행합니다.
따라서 Python을 사용하여 PostgreSQL의 테이블에 데이터를 삽입하려면-
수입 psycopg2 꾸러미.
다음을 사용하여 연결 개체를 만듭니다. connect() 사용자 이름, 암호, 호스트 (선택적 기본값 : localhost) 및 데이터베이스 (선택적)를 매개 변수로 전달하여 메소드를 사용합니다.
속성 값으로 false를 설정하여 자동 커밋 모드를 끕니다. autocommit.
그만큼 cursor()psycopg2 라이브러리의 Connection 클래스 메서드는 커서 개체를 반환합니다. 이 메서드를 사용하여 커서 개체를 만듭니다.
그런 다음 execute () 메서드에 매개 변수로 전달하여 UPDATE 문을 실행합니다.
예
다음 Python 코드는 25보다 큰 연령 값을 가진 EMPLOYEE 테이블의 레코드를 삭제합니다.
import psycopg2
#establishing the connection
conn = psycopg2.connect(
database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Retrieving contents of the table
print("Contents of the table: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())
#Deleting records
cursor.execute('''DELETE FROM EMPLOYEE WHERE AGE > 25''')
#Retrieving data after delete
print("Contents of the table after delete operation ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())
#Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
Contents of the table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0),
('Sarmista', 'Sharma', 26, 'F', 10000.0),
('Tripthi', 'Mishra', 24, 'F', 6000.0),
('Vinay', 'Battacharya', 21, 'M', 6000.0),
('Sharukh', 'Sheik', 26, 'M', 8300.0)]
Contents of the table after delete operation:
[('Tripthi', 'Mishra', 24, 'F', 6000.0),
('Vinay', 'Battacharya', 21, 'M', 6000.0)]DROP TABLE 문을 사용하여 PostgreSQL 데이터베이스에서 테이블을 삭제할 수 있습니다.
통사론
다음은 PostgreSQL의 DROP TABLE 문의 구문입니다.
DROP TABLE table_name;예
다음 쿼리를 사용하여 CRICKETERS와 EMPLOYEES라는 이름의 두 테이블을 만들었다 고 가정합니다.
postgres=# CREATE TABLE CRICKETERS (
First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int,
Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#
postgres=# CREATE TABLE EMPLOYEE(
FIRST_NAME CHAR(20) NOT NULL, LAST_NAME CHAR(20), AGE INT,
SEX CHAR(1), INCOME FLOAT
);
CREATE TABLE
postgres=#이제“\ dt”명령을 사용하여 테이블 목록을 확인하면 위에서 생성 된 테이블을 다음과 같이 볼 수 있습니다.
postgres=# \dt;
List of relations
Schema | Name | Type | Owner
--------+------------+-------+----------
public | cricketers | table | postgres
public | employee | table | postgres
(2 rows)
postgres=#다음 문은 데이터베이스에서 Employee라는 테이블을 삭제합니다-
postgres=# DROP table employee;
DROP TABLEEmployee 테이블을 삭제 했으므로 테이블 목록을 다시 검색하면 테이블 하나만 관찰 할 수 있습니다.
postgres=# \dt;
List of relations
Schema | Name | Type | Owner
--------+------------+-------+----------
public | cricketers | table | postgres
(1 row)
postgres=#Employee 테이블을 다시 삭제하려고하면 이미 삭제했기 때문에 아래와 같이 "테이블이 존재하지 않습니다"라는 오류 메시지가 표시됩니다.
postgres=# DROP table employee;
ERROR: table "employee" does not exist
postgres=#이를 해결하려면 DELTE 문과 함께 IF EXISTS 절을 사용할 수 있습니다. 테이블이있는 경우 테이블을 제거하고 DLETE 작업을 건너 뜁니다.
postgres=# DROP table IF EXISTS employee;
NOTICE: table "employee" does not exist, skipping
DROP TABLE
postgres=#Python을 사용하여 전체 테이블 제거
DROP 문을 사용하여 필요할 때마다 테이블을 삭제할 수 있습니다. 단, 테이블 삭제 후 손실 된 데이터는 복구되지 않으므로 기존 테이블 삭제시 매우주의해야합니다.
import psycopg2
#establishing the connection
conn = psycopg2.connect(
database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE emp")
print("Table dropped... ")
#Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
#Table dropped...PostgreSQL SELECT 문을 실행하는 동안 LIMIT 절을 사용하여 결과의 레코드 수를 제한 할 수 있습니다.
통사론
다음은 PostgreSQL의 LMIT 절 구문입니다.
SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]예
다음 쿼리를 사용하여 이름이 CRICKETERS 인 테이블을 생성했다고 가정합니다.
postgres=# CREATE TABLE CRICKETERS (
First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int,
Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#그리고 INSERT 문을 사용하여 5 개의 레코드를 삽입했다면-
postgres=# insert into CRICKETERS values ('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1다음 문은 LIMIT 절을 사용하여 Cricketers 테이블의 처음 3 개 레코드를 검색합니다.
postgres=# SELECT * FROM CRICKETERS LIMIT 3;
first_name | last_name | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Shikhar | Dhawan | 33 | Delhi | India
Jonathan | Trott | 38 | CapeTown | SouthAfrica
Kumara | Sangakkara | 41 | Matale | Srilanka
(3 rows)특정 레코드 (오프셋)에서 시작하는 레코드를 가져 오려면 LIMIT와 함께 OFFSET 절을 사용하면됩니다.
postgres=# SELECT * FROM CRICKETERS LIMIT 3 OFFSET 2;
first_name | last_name | age | place_of_birth | country
------------+------------+-----+----------------+----------
Kumara | Sangakkara | 41 | Matale | Srilanka
Virat | Kohli | 30 | Delhi | India
Rohit | Sharma | 32 | Nagpur | India
(3 rows)
postgres=#파이썬을 사용하는 제한 절
다음 파이썬 예제는 EMPLOYEE라는 테이블의 내용을 검색하여 결과의 레코드 수를 2로 제한합니다.
예
import psycopg2
#establishing the connection
conn = psycopg2.connect(
database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True
#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)
#Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
[('Sharukh', 'Sheik', 25, 'M', 8300.0), ('Sarmista', 'Sharma', 26, 'F', 10000.0)]데이터를 두 테이블로 나눈 경우 조인을 사용하여이 두 테이블에서 결합 된 레코드를 가져올 수 있습니다.
예
CRICKETERS라는 이름의 테이블을 만들고 아래와 같이 5 개의 레코드를 삽입했다고 가정합니다.
postgres=# CREATE TABLE CRICKETERS (
First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int,
Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
postgres=# insert into CRICKETERS values (
'Shikhar', 'Dhawan', 33, 'Delhi', 'India'
);
postgres=# insert into CRICKETERS values (
'Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica'
);
postgres=# insert into CRICKETERS values (
'Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka'
);
postgres=# insert into CRICKETERS values (
'Virat', 'Kohli', 30, 'Delhi', 'India'
);
postgres=# insert into CRICKETERS values (
'Rohit', 'Sharma', 32, 'Nagpur', 'India'
);그리고 OdiStats라는 이름으로 다른 테이블을 만들고 5 개의 레코드를 삽입했다면
postgres=# CREATE TABLE ODIStats (
First_Name VARCHAR(255), Matches INT, Runs INT, AVG FLOAT,
Centuries INT, HalfCenturies INT
);
postgres=# insert into OdiStats values ('Shikhar', 133, 5518, 44.5, 17, 27);
postgres=# insert into OdiStats values ('Jonathan', 68, 2819, 51.25, 4, 22);
postgres=# insert into OdiStats values ('Kumara', 404, 14234, 41.99, 25, 93);
postgres=# insert into OdiStats values ('Virat', 239, 11520, 60.31, 43, 54);
postgres=# insert into OdiStats values ('Rohit', 218, 8686, 48.53, 24, 42);다음 문은이 두 테이블의 값을 결합한 데이터를 검색합니다.
postgres=# SELECT
Cricketers.First_Name, Cricketers.Last_Name, Cricketers.Country,
OdiStats.matches, OdiStats.runs, OdiStats.centuries, OdiStats.halfcenturies
from Cricketers INNER JOIN OdiStats ON Cricketers.First_Name = OdiStats.First_Name;
first_name | last_name | country | matches | runs | centuries | halfcenturies
------------+------------+-------------+---------+-------+-----------+---------------
Shikhar | Dhawan | India | 133 | 5518 | 17 | 27
Jonathan | Trott | SouthAfrica | 68 | 2819 | 4 | 22
Kumara | Sangakkara | Srilanka | 404 | 14234 | 25 | 93
Virat | Kohli | India | 239 | 11520 | 43 | 54
Rohit | Sharma | India | 218 | 8686 | 24 | 42
(5 rows)
postgres=#Python을 사용하여 조인
데이터를 두 테이블로 나눈 경우 조인을 사용하여이 두 테이블에서 결합 된 레코드를 가져올 수 있습니다.
예
다음 파이썬 프로그램은 JOIN 절의 사용법을 보여줍니다-
import psycopg2
#establishing the connection
conn = psycopg2.connect(
database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Retrieving single row
sql = '''SELECT * from EMP INNER JOIN CONTACT ON EMP.CONTACT = CONTACT.ID'''
#Executing the query
cursor.execute(sql)
#Fetching 1st row from the table
result = cursor.fetchall();
print(result)
#Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
[('Ramya', 'Rama priya', 27, 'F', 9000.0, 101, 101, '[email protected]', 'Hyderabad'),
('Vinay', 'Battacharya', 20, 'M', 6000.0, 102, 102, '[email protected]', 'Vishakhapatnam'),
('Sharukh', 'Sheik', 25, 'M', 8300.0, 103, 103, '[email protected] ', 'Pune'),
('Sarmista', 'Sharma', 26, 'F', 10000.0, 104, 104, '[email protected]', 'Mumbai')]psycopg 라이브러리 의 Cursor 클래스는 Python 코드를 사용하여 데이터베이스에서 PostgreSQL 명령을 실행하는 방법을 제공합니다.
그것의 방법을 사용하여 SQL 문을 실행하고, 결과 집합에서 데이터를 가져오고, 프로 시저를 호출 할 수 있습니다.
당신은 만들 수 있습니다 Cursor Connection 객체 / 클래스의 cursor () 메서드를 사용하는 객체.
예
import psycopg2
#establishing the connection
conn = psycopg2.connect(
database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True
#Creating a cursor object using the cursor() method
cursor = conn.cursor()행동 양식
다음은 Cursor 클래스 / 객체에서 제공하는 다양한 메서드입니다.
| Sr. 아니요 | 방법 및 설명 |
|---|---|
| 1 | callproc() 이 메서드는 기존 프로 시저 PostgreSQL 데이터베이스를 호출하는 데 사용됩니다. |
| 2 | close() 이 메서드는 현재 커서 개체를 닫는 데 사용됩니다. |
| 삼 | executemany() 이 메소드는 일련의 매개 변수 목록을 허용합니다. MySQL 쿼리를 준비하고 모든 매개 변수를 사용하여 실행합니다. |
| 4 | execute() 이 메소드는 MySQL 쿼리를 매개 변수로 받아들이고 주어진 쿼리를 실행합니다. |
| 5 | fetchall() 이 메서드는 쿼리 결과 집합의 모든 행을 검색하여 튜플 목록으로 반환합니다. (몇 개의 행을 검색 한 후 이것을 실행하면 나머지 행을 반환합니다) |
| 6 | fetchone() 이 메서드는 쿼리 결과에서 다음 행을 가져 와서 튜플로 반환합니다. |
| 7 | fetchmany() 이 메소드는 fetchone ()과 유사하지만 단일 행 대신 쿼리 결과 세트에서 다음 행 세트를 검색합니다. |
속성
다음은 Cursor 클래스의 속성입니다-
| Sr. 아니요 | 속성 및 설명 |
|---|---|
| 1 | description 결과 집합의 열 설명이 포함 된 목록을 반환하는 읽기 전용 속성입니다. |
| 2 | astrowid 이는 읽기 전용 속성입니다. 테이블에 자동 증가 된 열이있는 경우 마지막 INSERT 또는 UPDATE 작업에서 해당 열에 대해 생성 된 값을 반환합니다. |
| 삼 | rowcount SELECT 및 UPDATE 작업의 경우 반환 / 업데이트 된 행 수를 반환합니다. |
| 4 | closed 이 속성은 커서가 닫혀 있는지 여부를 지정합니다. 그렇다면 true를 반환하고 그렇지 않으면 false를 반환합니다. |
| 5 | connection 이 커서가 생성 된 연결 개체에 대한 참조를 반환합니다. |
| 6 | name 이 속성은 커서의 이름을 반환합니다. |
| 7 | scrollable 이 속성은 특정 커서를 스크롤 할 수 있는지 여부를 지정합니다. |
설치
SQLite3는 Gerhard Haring이 작성한 sqlite3 모듈을 사용하여 Python과 통합 할 수 있습니다. PEP 249에 설명 된 DB-API 2.0 사양을 준수하는 SQL 인터페이스를 제공합니다.이 모듈은 기본적으로 Python 버전 2.5.x와 함께 제공되므로 별도로 설치할 필요가 없습니다.
sqlite3 모듈을 사용하려면 먼저 데이터베이스를 나타내는 연결 개체를 만든 다음 선택적으로 모든 SQL 문을 실행하는 데 도움이되는 커서 개체를 만들 수 있습니다.
Python sqlite3 모듈 API
다음은 중요한 sqlite3 모듈 루틴으로, Python 프로그램에서 SQLite 데이터베이스로 작업하기위한 요구 사항을 충족 할 수 있습니다. 더 정교한 애플리케이션을 찾고 있다면 Python sqlite3 모듈의 공식 문서를 살펴볼 수 있습니다.
| Sr. 아니. | API 및 설명 |
|---|---|
| 1 | sqlite3.connect(database [,timeout ,other optional arguments]) 이 API는 SQLite 데이터베이스 파일에 대한 연결을 엽니 다. ": memory :"를 사용하여 디스크 대신 RAM에있는 데이터베이스에 대한 데이터베이스 연결을 열 수 있습니다. 데이터베이스가 성공적으로 열리면 연결 개체를 반환합니다. |
| 2 | connection.cursor([cursorClass]) 이 루틴은 cursorPython으로 데이터베이스 프로그래밍 전반에 걸쳐 사용됩니다. 이 메소드는 단일 선택적 매개 변수 cursorClass를 허용합니다. 제공된 경우 sqlite3.Cursor를 확장하는 사용자 정의 커서 클래스 여야합니다. |
| 삼 | cursor.execute(sql [, optional parameters]) 이 루틴은 SQL 문을 실행합니다. SQL 문은 매개 변수화 될 수 있습니다 (즉, SQL 리터럴 대신 자리 표시 자). sqlite3 모듈은 물음표와 명명 된 플레이스 홀더 (스타일 명)라는 두 가지 종류의 플레이스 홀더를 지원합니다. For example − cursor.execute ( "사람 값에 삽입 (?,?)", (누가, 나이)) |
| 4 | connection.execute(sql [, optional parameters]) 이 루틴은 커서 개체가 제공하는 위의 실행 메서드의 바로 가기이며 커서 메서드를 호출하여 중간 커서 개체를 만든 다음 주어진 매개 변수로 커서의 실행 메서드를 호출합니다. |
| 5 | cursor.executemany(sql, seq_of_parameters) 이 루틴은 시퀀스 sql에서 찾은 모든 매개 변수 시퀀스 또는 매핑에 대해 SQL 명령을 실행합니다. |
| 6 | connection.executemany(sql[, parameters]) 이 루틴은 커서 메서드를 호출하여 중간 커서 개체를 만든 다음 주어진 매개 변수로 cursor.s executemany 메서드를 호출하는 바로 가기입니다. |
| 7 | cursor.executescript(sql_script) 이 루틴은 스크립트 형식으로 제공된 여러 SQL 문을 한 번에 실행합니다. 먼저 COMMIT 문을 발행 한 다음 매개 변수로 가져 오는 SQL 스크립트를 실행합니다. 모든 SQL 문은 세미콜론 (;)으로 구분해야합니다. |
| 8 | connection.executescript(sql_script) 이 루틴은 커서 메서드를 호출하여 중간 커서 개체를 만든 다음 지정된 매개 변수로 커서의 executescript 메서드를 호출하는 바로 가기입니다. |
| 9 | connection.total_changes() 이 루틴은 데이터베이스 연결이 열린 이후 수정, 삽입 또는 삭제 된 총 데이터베이스 행 수를 리턴합니다. |
| 10 | connection.commit() 이 메서드는 현재 트랜잭션을 커밋합니다. 이 메서드를 호출하지 않으면 마지막 commit () 호출 이후에 수행 한 작업이 다른 데이터베이스 연결에서 표시되지 않습니다. |
| 11 | connection.rollback() 이 메서드는 commit ()에 대한 마지막 호출 이후 데이터베이스에 대한 모든 변경 사항을 롤백합니다. |
| 12 | connection.close() 이 방법은 데이터베이스 연결을 닫습니다. 이것은 commit ()을 자동으로 호출하지 않습니다. commit ()을 먼저 호출하지 않고 데이터베이스 연결을 닫으면 변경 사항이 손실됩니다! |
| 13 | cursor.fetchone() 이 메서드는 쿼리 결과 집합의 다음 행을 가져 와서 단일 시퀀스를 반환하거나 더 이상 데이터를 사용할 수없는 경우 없음을 반환합니다. |
| 14 | cursor.fetchmany([size = cursor.arraysize]) 이 루틴은 쿼리 결과의 다음 행 집합을 가져와 목록을 반환합니다. 사용 가능한 행이 더 이상 없으면 빈 목록이 반환됩니다. 메소드는 size 매개 변수에 표시된만큼의 행을 가져 오려고합니다. |
| 15 | cursor.fetchall() 이 루틴은 쿼리 결과의 모든 (나머지) 행을 가져 와서 목록을 반환합니다. 사용 가능한 행이 없으면 빈 목록이 반환됩니다. |
SQLite Open 명령 프롬프트와 연결을 설정하려면 SQLite를 설치 한 위치를 검색하고 명령을 실행하기 만하면됩니다. sqlite3 아래와 같이-
Python을 사용하여 연결 설정
SQLite3 python 모듈을 사용하여 SQLite2 데이터베이스와 통신 할 수 있습니다. 이렇게하려면 먼저 연결을 설정해야합니다 (연결 개체 만들기).
파이썬을 사용하여 SQLite3 데이터베이스와 연결을 설정하려면 다음이 필요합니다.
import 문을 사용하여 sqlite3 모듈을 가져옵니다.
connect () 메서드는 연결해야하는 데이터베이스의 이름을 매개 변수로 받아들이고 Connection 객체를 반환합니다.
예
import sqlite3
conn = sqlite3.connect('example.db')산출
print("Connection established ..........")SQLite CREATE TABLE 문을 사용하여 데이터베이스에 테이블을 만들 수 있습니다.
통사론
다음은 SQLite 데이터베이스에서 테이블을 생성하는 구문입니다-
CREATE TABLE database_name.table_name(
column1 datatype PRIMARY KEY(one or more columns),
column2 datatype,
column3 datatype,
.....
columnN datatype
);예
다음 SQLite 쿼리 / 문은 이름이있는 테이블을 생성합니다. CRICKETERS SQLite 데이터베이스에서-
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>CRICKETERS 테이블에서 각 플레이어의 1 일 크리켓 통계를 설명하는 OdiStats 테이블을 하나 더 만들겠습니다.
sqlite> CREATE TABLE ODIStats (
First_Name VARCHAR(255),
Matches INT,
Runs INT,
AVG FLOAT,
Centuries INT,
HalfCenturies INT
);
sqlite다음을 사용하여 SQLite 데이터베이스의 데이터베이스에있는 테이블 목록을 가져올 수 있습니다. .tables명령. 테이블을 생성 한 후 테이블 목록을 확인할 수 있다면 새로 생성 된 테이블을 다음과 같이 관찰 할 수 있습니다.
sqlite> . tables
CRICKETERS ODIStats
sqlite>Python을 사용하여 테이블 만들기
Cursor 객체는 quire를 실행하고 데이터를 가져 오는 모든 메소드를 포함합니다. 연결 클래스의 cursor 메소드는 커서 객체를 반환합니다.
따라서 파이썬을 사용하여 SQLite 데이터베이스에 테이블을 생성하려면-
connect () 메서드를 사용하여 데이터베이스와의 연결을 설정합니다.
위에서 생성 한 연결 객체에 대해 cursor () 메서드를 호출하여 커서 객체를 생성합니다.
이제 Cursor 클래스의 execute () 메서드를 사용하여 CREATE TABLE 문을 실행합니다.
예
다음 Python 프로그램은 SQLite3에서 Employee라는 테이블을 생성합니다-
import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Doping 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)
print("Table created successfully........")
# Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
Table created successfully........INSERT INTO 문을 사용하여 기존 SQLite 테이블에 새 행을 추가 할 수 있습니다. 여기에서 테이블 이름, 열 이름 및 값을 지정해야합니다 (열 이름과 동일한 순서로).
통사론
다음은 INSERT 문의 권장 구문입니다-
INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);여기서 column1, column2, column3, ..은 테이블의 열 이름이고 value1, value2, value3, ...은 테이블에 삽입해야하는 값입니다.
예
아래와 같이 CREATE TABLE 문을 사용하여 이름이 CRICKETERS 인 테이블을 생성했다고 가정합니다.
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>다음 PostgreSQL 문은 위에서 생성 된 테이블에 행을 삽입합니다.
sqlite> insert into CRICKETERS
(First_Name, Last_Name, Age, Place_Of_Birth, Country) values
('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite>INSERT INTO 문을 사용하여 레코드를 삽입하는 동안 열 이름을 건너 뛰면이 레코드가 삽입되고 건너 뛴 열에 빈 공간이 남습니다.
sqlite> insert into CRICKETERS
(First_Name, Last_Name, Country) values
('Jonathan', 'Trott', 'SouthAfrica');
sqlite>전달하는 값의 순서가 테이블의 각 열 이름과 동일한 경우 열 이름을 지정하지 않고 테이블에 레코드를 삽입 할 수도 있습니다.
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>테이블에 레코드를 삽입 한 후 아래와 같이 SELECT 문을 사용하여 내용을 확인할 수 있습니다.
sqlite> select * from cricketers;
Shikhar | Dhawan | 33 | Delhi | India
Jonathan | Trott | | | SouthAfrica
Kumara | Sangakkara | 41 | Matale | Srilanka
Virat | Kohli | 30 | Delhi | India
Rohit | Sharma | 32 | Nagpur | India
sqlite>Python을 사용하여 데이터 삽입
SQLite 데이터베이스의 기존 테이블에 레코드를 추가하려면-
sqlite3 패키지를 가져옵니다.
데이터베이스 이름을 매개 변수로 전달하여 connect () 메서드를 사용하여 연결 객체를 만듭니다.
그만큼 cursor()메서드는 SQLite3와 통신 할 수있는 커서 객체를 반환합니다. (위에서 만든) Connection 객체에서 cursor () 객체를 호출하여 커서 객체를 만듭니다.
그런 다음 INSERT 문을 매개 변수로 전달하여 커서 개체에서 execute () 메서드를 호출합니다.
예
다음 파이썬 예제는 EMPLOYEE라는 테이블에 레코드를 삽입합니다-
import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
# Preparing SQL queries to INSERT a record into the database.
cursor.execute('''INSERT INTO EMPLOYEE(
FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
('Ramya', 'Rama Priya', 27, 'F', 9000)''')
cursor.execute('''INSERT INTO EMPLOYEE(
FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
('Vinay', 'Battacharya', 20, 'M', 6000)''')
cursor.execute('''INSERT INTO EMPLOYEE(
FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
('Sharukh', 'Sheik', 25, 'M', 8300)''')
cursor.execute('''INSERT INTO EMPLOYEE(
FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
('Sarmista', 'Sharma', 26, 'F', 10000)''')
cursor.execute('''INSERT INTO EMPLOYEE(
FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
('Tripthi', 'Mishra', 24, 'F', 6000)''')
# Commit your changes in the database
conn.commit()
print("Records inserted........")
# Closing the connection
conn.close()산출
Records inserted........SELCT 쿼리를 사용하여 SQLite 테이블에서 데이터를 검색 할 수 있습니다. 이 쿼리 / 문은 지정된 관계 (테이블)의 내용을 표 형식으로 반환하며 결과 집합이라고합니다.
통사론
다음은 SQLite에서 SELECT 문의 구문입니다-
SELECT column1, column2, columnN FROM table_name;예
다음 쿼리를 사용하여 이름이 CRICKETERS 인 테이블을 생성했다고 가정합니다.
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>그리고 INSERT 문을 사용하여 5 개의 레코드를 삽입했다면-
sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>다음 SELECT 쿼리는 CRICKETERS 테이블에서 FIRST_NAME, LAST_NAME 및 COUNTRY 열의 값을 검색합니다.
sqlite> SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
Shikhar |Dhawan |India
Jonathan |Trott |SouthAfrica
Kumara |Sangakkara |Srilanka
Virat |Kohli |India
Rohit |Sharma |India
sqlite>보시다시피 SQLite 데이터베이스의 SELECT 문은 지정된 테이블의 레코드 만 반환합니다. 형식화 된 출력을 얻으려면 다음을 설정해야합니다.header, 및 mode 아래와 같이 SELECT 문 앞에 각 명령을 사용하여-
sqlite> .header on
sqlite> .mode column
sqlite> SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
First_Name Last_Name Country
---------- -------------------- ----------
Shikhar Dhawan India
Jonathan Trott SouthAfric
Kumara Sangakkara Srilanka
Virat Kohli India
Rohit Sharma India
sqlite>각 레코드의 모든 열을 검색하려면 다음과 같이 열 이름을 "*"로 바꿔야합니다.
sqlite> .header on
sqlite> .mode column
sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name Age Place_Of_Birth Country
---------- ---------- ---------- -------------- ----------
Shikhar Dhawan 33 Delhi India
Jonathan Trott 38 CapeTown SouthAfric
Kumara Sangakkara 41 Matale Srilanka
Virat Kohli 30 Delhi India
Rohit Sharma 32 Nagpur India
sqlite>에서는 SQLite는 기본적으로 열 폭 다진 폭이 10 초과의 값 (2의 국가 열의 관측 인 ND 상기 표의 행). 다음을 사용하여 각 열의 너비를 필요한 값으로 설정할 수 있습니다..width 아래에 표시된 것처럼 테이블의 내용을 검색하기 전에 명령-
sqlite> .width 10, 10, 4, 10, 13
sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name Age Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar Dhawan 33 Delhi India
Jonathan Trott 38 CapeTown SouthAfrica
Kumara Sangakkara 41 Matale Srilanka
Virat Kohli 30 Delhi India
Rohit Sharma 32 Nagpur India
sqlite>Python을 사용하여 데이터 검색
모든 데이터베이스에 대한 읽기 작업은 데이터베이스에서 유용한 정보를 가져 오는 것을 의미합니다. sqlite python 모듈에서 제공하는 fetch () 메서드를 사용하여 MYSQL에서 데이터를 가져올 수 있습니다.
sqlite3.Cursor 클래스는 fetchall (), fetchmany () 및 fetchone ()의 세 가지 메소드를 제공합니다.
fetchall () 메서드는 쿼리 결과 집합의 모든 행을 검색하여 튜플 목록으로 반환합니다. (몇 개의 행을 검색 한 후 이것을 실행하면 나머지 행을 반환합니다).
fetchone () 메서드는 쿼리 결과에서 다음 행을 가져 와서 튜플로 반환합니다.
fetchmany () 메소드는 fetchone ()과 유사하지만 단일 행 대신 쿼리 결과 세트에서 다음 행 세트를 검색합니다.
Note − 결과 집합은 커서 개체를 사용하여 테이블을 쿼리 할 때 반환되는 개체입니다.
예
다음 예제는 SELECT 쿼리를 사용하여 EMPLOYEE 테이블의 모든 행을 가져오고 처음에 얻은 결과 집합에서 처음에는 fetchone () 메서드를 사용하여 첫 번째 행을 검색 한 다음 fetchall () 메서드를 사용하여 나머지 행을 가져옵니다.
다음 Python 프로그램은 위의 예에서 만든 COMPANY 테이블에서 레코드를 가져 와서 표시하는 방법을 보여줍니다.
import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Retrieving data
cursor.execute('''SELECT * from EMPLOYEE''')
#Fetching 1st row from the table
result = cursor.fetchone();
print(result)
#Fetching 1st row from the table
result = cursor.fetchall();
print(result)
#Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
('Ramya', 'Rama priya', 27, 'F', 9000.0)
[('Vinay', 'Battacharya', 20, 'M', 6000.0),
('Sharukh', 'Sheik', 25, 'M', 8300.0),
('Sarmista', 'Sharma', 26, 'F', 10000.0),
('Tripthi', 'Mishra', 24, 'F', 6000.0)
]SQLite에서 테이블의 특정 행을 가져 오거나 삭제하거나 업데이트하려면 where 절을 사용하여 작업을 위해 테이블의 행을 필터링하는 조건을 지정해야합니다.
예를 들어 where 절이있는 SELECT 문이있는 경우 지정된 조건을 충족하는 행만 검색됩니다.
통사론
다음은 SQLite에서 WHERE 절의 구문입니다-
SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]비교 또는 논리 연산자를 사용하여 search_condition을 지정할 수 있습니다. >, <, =, LIKE, NOT 등. 다음 예제는이 개념을 명확하게합니다.
예
다음 쿼리를 사용하여 이름이 CRICKETERS 인 테이블을 생성했다고 가정합니다.
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>그리고 INSERT 문을 사용하여 5 개의 레코드를 삽입했다면-
sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>다음 SELECT 문은 나이가 35보다 큰 레코드를 검색합니다-
sqlite> SELECT * FROM CRICKETERS WHERE AGE > 35;
First_Name Last_Name Age Place_Of_B Country
---------- ---------- ---- ---------- -------------
Jonathan Trott 38 CapeTown SouthAfrica
Kumara Sangakkara 41 Matale Srilanka
sqlite>파이썬을 사용하는 Where 절
Cursor 객체 / 클래스에는 쿼리를 실행하고 데이터를 가져 오는 등의 모든 메서드가 포함되어 있습니다. 연결 클래스의 커서 메서드는 커서 객체를 반환합니다.
따라서 파이썬을 사용하여 SQLite 데이터베이스에 테이블을 생성하려면-
connect () 메서드를 사용하여 데이터베이스와의 연결을 설정합니다.
위에서 생성 한 연결 객체에 대해 cursor () 메서드를 호출하여 커서 객체를 생성합니다.
이제 Cursor 클래스의 execute () 메서드를 사용하여 CREATE TABLE 문을 실행합니다.
예
다음 예에서는 Employee라는 테이블을 만들고 채 웁니다. 그런 다음 where 절을 사용하여 연령 값이 23 미만인 레코드를 검색합니다.
import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')
#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
cursor.execute('''INSERT INTO EMPLOYEE(
FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
('Ramya', 'Rama priya', 27, 'F', 9000)''')
cursor.execute('''INSERT INTO EMPLOYEE
(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
('Vinay', 'Battacharya', 20, 'M', 6000)''')
cursor.execute('''INSERT INTO EMPLOYEE(
FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
('Sharukh', 'Sheik', 25, 'M', 8300)''')
cursor.execute('''INSERT INTO EMPLOYEE(
FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
('Sarmista', 'Sharma', 26, 'F', 10000)''')
cursor.execute('''INSERT INTO EMPLOYEE(
FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
('Tripthi', 'Mishra', 24, 'F', 6000)''')
#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())
#Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
[('Vinay', 'Battacharya', 20, 'M', 6000.0)]SELECT 쿼리를 사용하여 데이터를 가져 오는 동안 삽입 한 순서와 동일한 순서로 레코드를 가져옵니다.
다음을 사용하여 원하는 순서 (오름차순 또는 내림차순)로 결과를 정렬 할 수 있습니다. Order By절. 기본적으로이 절은 결과를 오름차순으로 정렬합니다. 내림차순으로 정렬해야하는 경우 "DESC"를 명시 적으로 사용해야합니다.
통사론
다음은 SQLite의 ORDER BY 절 구문입니다.
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];예
다음 쿼리를 사용하여 이름이 CRICKETERS 인 테이블을 생성했다고 가정합니다.
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>그리고 INSERT 문을 사용하여 5 개의 레코드를 삽입했다면-
sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>다음 SELECT 문은 연령의 오름차순으로 CRICKETERS 테이블의 행을 검색합니다-
sqlite> SELECT * FROM CRICKETERS ORDER BY AGE;
First_Name Last_Name Age Place_Of_B Country
---------- ---------- ---- ---------- -------------
Virat Kohli 30 Delhi India
Rohit Sharma 32 Nagpur India
Shikhar Dhawan 33 Delhi India
Jonathan Trott 38 CapeTown SouthAfrica
Kumara Sangakkara 41 Matale Srilanka
sqlite>둘 이상의 열을 사용하여 테이블의 레코드를 정렬 할 수 있습니다. 다음 SELECT 문은 AGE 및 FIRST_NAME 열을 기준으로 CRICKETERS 테이블의 레코드를 정렬합니다 .
sqlite> SELECT * FROM CRICKETERS ORDER BY AGE, FIRST_NAME;
First_Name Last_Name Age Place_Of_B Country
---------- ---------- ---- ---------- -------------
Virat Kohli 30 Delhi India
Rohit Sharma 32 Nagpur India
Shikhar Dhawan 33 Delhi India
Jonathan Trott 38 CapeTown SouthAfrica
Kumara Sangakkara 41 Matale Srilanka
sqlite>기본적으로 ORDER BY 절은 테이블의 레코드를 오름차순으로 정렬합니다. DESC를 사용하여 결과를 내림차순으로 정렬 할 수 있습니다.
sqlite> SELECT * FROM CRICKETERS ORDER BY AGE DESC;
First_Name Last_Name Age Place_Of_B Country
---------- ---------- ---- ---------- -------------
Kumara Sangakkara 41 Matale Srilanka
Jonathan Trott 38 CapeTown SouthAfrica
Shikhar Dhawan 33 Delhi India
Rohit Sharma 32 Nagpur India
Virat Kohli 30 Delhi India
sqlite>파이썬을 사용하는 ORDER BY 절
특정 순서로 테이블의 내용을 검색하려면 커서 개체에서 execute () 메서드를 호출하고 ORDER BY 절과 함께 SELECT 문을 매개 변수로 전달합니다.
예
다음 예에서는 ORDER BY 절을 사용하여 이름과 Employee가있는 테이블을 만들고, 채우고, 해당 레코드를 연령의 (오름차순) 순서로 다시 검색합니다.
import psycopg2
#establishing the connection
conn = psycopg2.connect(
database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
#Creating a table
sql = '''CREATE TABLE EMPLOYEE(
FIRST_NAME CHAR(20) NOT NULL,
LAST_NAME CHAR(20),
AGE INT, SEX CHAR(1),
INCOME INT,
CONTACT INT
)'''
cursor.execute(sql)
#Populating the table
#Populating the table
cursor.execute('''INSERT INTO EMPLOYEE
(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
('Ramya', 'Rama priya', 27, 'F', 9000),
('Vinay', 'Battacharya', 20, 'M', 6000),
('Sharukh', 'Sheik', 25, 'M', 8300),
('Sarmista', 'Sharma', 26, 'F', 10000),
('Tripthi', 'Mishra', 24, 'F', 6000)''')
conn.commit()
#Retrieving specific records using the ORDER BY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY AGE")
print(cursor.fetchall())
#Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
[('Vinay', 'Battacharya', 20, 'M', 6000, None),
('Tripthi', 'Mishra', 24, 'F', 6000, None),
('Sharukh', 'Sheik', 25, 'M', 8300, None),
('Sarmista', 'Sharma', 26, 'F', 10000, None),
('Ramya', 'Rama priya', 27, 'F', 9000, None)]모든 데이터베이스에 대한 UPDATE 작업은 이미 데이터베이스에서 사용 가능한 테이블의 하나 이상의 레코드 값을 수정하는 것을 의미합니다. UPDATE 문을 사용하여 SQLite의 기존 레코드 값을 업데이트 할 수 있습니다.
특정 행을 업데이트하려면 WHERE 절을 함께 사용해야합니다.
통사론
다음은 SQLite에서 UPDATE 문의 구문입니다-
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];예
다음 쿼리를 사용하여 이름이 CRICKETERS 인 테이블을 생성했다고 가정합니다.
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>그리고 INSERT 문을 사용하여 5 개의 레코드를 삽입했다면-
sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>다음 진술은 이름이 크리켓 선수의 나이를 수정합니다. Shikhar −
sqlite> UPDATE CRICKETERS SET AGE = 45 WHERE FIRST_NAME = 'Shikhar' ;
sqlite>FIRST_NAME이 Shikhar 인 레코드를 검색하면 나이 값이 45로 변경된 것을 볼 수 있습니다.
sqlite> SELECT * FROM CRICKETERS WHERE FIRST_NAME = 'Shikhar';
First_Name Last_Name Age Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar Dhawan 45 Delhi India
sqlite>WHERE 절을 사용하지 않은 경우 모든 레코드의 값이 업데이트됩니다. 다음 UPDATE 문은 CRICKETERS 테이블에있는 모든 레코드의 나이를 1 씩 증가시킵니다.
sqlite> UPDATE CRICKETERS SET AGE = AGE+1;
sqlite>SELECT 명령을 사용하여 테이블의 내용을 검색하면 업데이트 된 값을 다음과 같이 볼 수 있습니다.
sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name Age Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar Dhawan 46 Delhi India
Jonathan Trott 39 CapeTown SouthAfrica
Kumara Sangakkara 42 Matale Srilanka
Virat Kohli 31 Delhi India
Rohit Sharma 33 Nagpur India
sqlite>Python을 사용하여 기존 레코드 업데이트
SQLite 데이터베이스의 기존 테이블에 레코드를 추가하려면-
sqlite3 패키지를 가져옵니다.
데이터베이스 이름을 매개 변수로 전달 하여 connect () 메서드를 사용하여 연결 객체를 만듭니다 .
그만큼 cursor()메서드는 SQLite3와 통신 할 수있는 커서 객체를 반환합니다. (위에서 만든) Connection 객체에서 cursor () 객체를 호출하여 커서 객체를 만듭니다.
그런 다음 UPDATE 문을 매개 변수로 전달하여 커서 개체에서 execute () 메서드를 호출합니다.
예
Python 예제에 따라 EMPLOYEE라는 이름의 테이블을 만들고 5 개의 레코드를 삽입 한 다음 모든 남성 직원의 나이를 1로 늘립니다.
import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Doping 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)
#Inserting data
cursor.execute('''INSERT INTO EMPLOYEE
(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES
('Ramya', 'Rama priya', 27, 'F', 9000),
('Vinay', 'Battacharya', 20, 'M', 6000),
('Sharukh', 'Sheik', 25, 'M', 8300),
('Sarmista', 'Sharma', 26, 'F', 10000),
('Tripthi', 'Mishra', 24, 'F', 6000)''')
conn.commit()
#Fetching all the rows before the update
print("Contents of the Employee table: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())
#Updating the records
sql = '''UPDATE EMPLOYEE SET AGE=AGE+1 WHERE SEX = 'M' '''
cursor.execute(sql)
print("Table updated...... ")
#Fetching all the rows after the update
print("Contents of the Employee table after the update operation: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())
#Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
Contents of the Employee table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0),
('Vinay', 'Battacharya', 20, 'M', 6000.0),
('Sharukh', 'Sheik', 25, 'M', 8300.0),
('Sarmista', 'Sharma', 26, 'F', 10000.0),
('Tripthi', 'Mishra', 24, 'F', 6000.0)]
Table updated......
Contents of the Employee table after the update operation:
[('Ramya', 'Rama priya', 27, 'F', 9000.0),
('Vinay', 'Battacharya', 21, 'M', 6000.0),
('Sharukh', 'Sheik', 26, 'M', 8300.0),
('Sarmista', 'Sharma', 26, 'F', 10000.0),
('Tripthi', 'Mishra', 24, 'F', 6000.0)]SQLite 테이블에서 레코드를 삭제하려면 DELETE FROM 문을 사용해야합니다. 특정 레코드를 제거하려면 WHERE 절을 함께 사용해야합니다.
특정 행을 업데이트하려면 WHERE 절을 함께 사용해야합니다.
통사론
다음은 SQLite의 DELETE 쿼리 구문입니다.
DELETE FROM table_name [WHERE Clause]예
다음 쿼리를 사용하여 이름이 CRICKETERS 인 테이블을 생성했다고 가정합니다.
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>그리고 INSERT 문을 사용하여 5 개의 레코드를 삽입했다면-
sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>다음 문장은 성이 '상악 카라'인 크리켓 선수의 기록을 삭제합니다.
sqlite> DELETE FROM CRICKETERS WHERE LAST_NAME = 'Sangakkara';
sqlite>SELECT 문을 사용하여 테이블의 내용을 검색하면 하나를 삭제했기 때문에 4 개의 레코드 만 볼 수 있습니다.
sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name Age Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar Dhawan 46 Delhi India
Jonathan Trott 39 CapeTown SouthAfrica
Virat Kohli 31 Delhi India
Rohit Sharma 33 Nagpur India
sqlite>WHERE 절없이 DELETE FROM 문을 실행하면 지정된 테이블의 모든 레코드가 삭제됩니다.
sqlite> DELETE FROM CRICKETERS;
sqlite>모든 레코드를 삭제 했으므로 CRICKETERS 테이블의 내용을 검색하려고하면 SELECT 문을 사용하여 아래와 같이 빈 결과 집합을 얻게됩니다.
sqlite> SELECT * FROM CRICKETERS;
sqlite>Python을 사용하여 데이터 삭제
SQLite 데이터베이스의 기존 테이블에 레코드를 추가하려면-
sqlite3 패키지를 가져옵니다.
데이터베이스 이름을 매개 변수로 전달 하여 connect () 메서드를 사용하여 연결 객체를 만듭니다 .
그만큼 cursor()메서드는 SQLite3와 통신 할 수있는 커서 객체를 반환합니다. (위에서 만든) Connection 객체에서 cursor () 객체를 호출하여 커서 객체를 만듭니다.
그런 다음 DELETE 문을 매개 변수로 전달하여 커서 개체에서 execute () 메서드를 호출합니다.
예
다음 python 예제는 나이 값이 25보다 큰 EMPLOYEE 테이블에서 레코드를 삭제합니다.
import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Retrieving contents of the table
print("Contents of the table: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())
#Deleting records
cursor.execute('''DELETE FROM EMPLOYEE WHERE AGE > 25''')
#Retrieving data after delete
print("Contents of the table after delete operation ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())
#Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
Contents of the table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0),
('Vinay', 'Battacharya', 21, 'M', 6000.0),
('Sharukh', 'Sheik', 26, 'M', 8300.0),
('Sarmista', 'Sharma', 26, 'F', 10000.0),
('Tripthi', 'Mishra', 24, 'F', 6000.0)]
Contents of the table after delete operation
[('Vinay', 'Battacharya', 21, 'M', 6000.0),
('Tripthi', 'Mishra', 24, 'F', 6000.0)]DROP TABLE 문을 사용하여 전체 테이블을 제거 할 수 있습니다. 삭제해야하는 테이블의 이름 만 지정하면됩니다.
통사론
다음은 PostgreSQL의 DROP TABLE 문의 구문입니다.
DROP TABLE table_name;예
다음 쿼리를 사용하여 CRICKETERS와 EMPLOYEES라는 이름의 두 테이블을 만들었다 고 가정합니다.
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int,
Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
sqlite> CREATE TABLE EMPLOYEE(
FIRST_NAME CHAR(20) NOT NULL, LAST_NAME CHAR(20), AGE INT,
SEX CHAR(1), INCOME FLOAT
);
sqlite>이제 다음을 사용하여 테이블 목록을 확인하면 .tables 명령을 사용하면 위의 생성 된 테이블을 볼 수 있습니다 (목록).
sqlite> .tables
CRICKETERS EMPLOYEE
sqlite>다음 문은 데이터베이스에서 Employee라는 테이블을 삭제합니다-
sqlite> DROP table employee;
sqlite>Employee 테이블을 삭제 했으므로 테이블 목록을 다시 검색하면 테이블 하나만 관찰 할 수 있습니다.
sqlite> .tables
CRICKETERS
sqlite>Employee 테이블을 다시 삭제하려고하면 이미 삭제했기 때문에 아래와 같이 "해당 테이블이 없습니다"라는 오류 메시지가 표시됩니다.
sqlite> DROP table employee;
Error: no such table: employee
sqlite>이를 해결하려면 DELTE 문과 함께 IF EXISTS 절을 사용할 수 있습니다. 테이블이있는 경우 테이블을 제거하고 DLETE 작업을 건너 뜁니다.
sqlite> DROP table IF EXISTS employee;
sqlite>Python을 사용하여 테이블 삭제
MYSQL의 DROP 문을 사용하여 필요할 때마다 테이블을 삭제할 수 있지만, 테이블 삭제 후 손실 된 데이터는 복구되지 않으므로 기존 테이블을 삭제할 때는 매우주의해야합니다.
예
파이썬을 사용하여 SQLite3 데이터베이스에서 테이블을 삭제하려면 execute() 커서 개체에 메서드를 추가하고 drop 문을 매개 변수로 전달합니다.
import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE emp")
print("Table dropped... ")
#Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
Table dropped...특정 수로 제한하려면 레코드를 가져 오는 동안 SQLite의 LIMIT 절을 사용하면됩니다.
통사론
다음은 SQLite의 LIMIT 절 구문입니다-
SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]예
다음 쿼리를 사용하여 이름이 CRICKETERS 인 테이블을 생성했다고 가정합니다.
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>그리고 INSERT 문을 사용하여 5 개의 레코드를 삽입했다면-
sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>다음 문은 LIMIT 절을 사용하여 Cricketers 테이블의 처음 3 개 레코드를 검색합니다.
sqlite> SELECT * FROM CRICKETERS LIMIT 3;
First_Name Last_Name Age Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar Dhawan 33 Delhi India
Jonathan Trott 38 CapeTown SouthAfrica
Kumara Sangakkara 41 Matale Srilanka
sqlite>첫 번째가 아닌 n 번째 레코드부터 시작하는 레코드를 제한해야하는 경우 LIMIT와 함께 OFFSET을 사용하여 그렇게 할 수 있습니다.
sqlite> SELECT * FROM CRICKETERS LIMIT 3 OFFSET 2;
First_Name Last_Name Age Place_Of_B Country
---------- ---------- ---- ---------- -------------
Kumara Sangakkara 41 Matale Srilanka
Virat Kohli 30 Delhi India
Rohit Sharma 32 Nagpur India
sqlite>Python을 사용하는 LIMIT 절
LIMIT 절과 함께 SELECT 쿼리를 전달하여 커서 개체에서 execute () 메서드를 호출하면 필요한 레코드 수를 검색 할 수 있습니다.
예
다음 파이썬 예제는 LIMIT 절을 사용하여 EMPLOYEE 테이블의 처음 두 레코드를 검색합니다.
import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 3'''
#Executing the query
cursor.execute(sql)
#Fetching the data
result = cursor.fetchall();
print(result)
#Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
[('Ramya', 'Rama priya', 27, 'F', 9000.0),
('Vinay', 'Battacharya', 20, 'M', 6000.0),
('Sharukh', 'Sheik', 25, 'M', 8300.0)]데이터를 두 테이블로 나눈 경우 조인을 사용하여이 두 테이블에서 결합 된 레코드를 가져올 수 있습니다.
예
다음 쿼리를 사용하여 이름이 CRICKETERS 인 테이블을 생성했다고 가정합니다.
sqlite> CREATE TABLE CRICKETERS (
First_Name VARCHAR(255),
Last_Name VARCHAR(255),
Age int,
Place_Of_Birth VARCHAR(255),
Country VARCHAR(255)
);
sqlite>CRICKETERS 테이블에서 각 플레이어의 1 일 크리켓 통계를 설명하는 OdiStats 테이블을 하나 더 만들겠습니다.
sqlite> CREATE TABLE ODIStats (
First_Name VARCHAR(255),
Matches INT,
Runs INT,
AVG FLOAT,
Centuries INT,
HalfCenturies INT
);
sqlite>다음 문은이 두 테이블의 값을 결합한 데이터를 검색합니다.
sqlite> SELECT
Cricketers.First_Name, Cricketers.Last_Name, Cricketers.Country,
OdiStats.matches, OdiStats.runs, OdiStats.centuries, OdiStats.halfcenturies
from Cricketers INNER JOIN OdiStats ON Cricketers.First_Name = OdiStats.First_Name;
First_Name Last_Name Country Matches Runs Centuries HalfCenturies
---------- ---------- ------- ---------- ------------- ---------- ----------
Shikhar Dhawan Indi 133 5518 17 27
Jonathan Trott Sout 68 2819 4 22
Kumara Sangakkara Sril 404 14234 25 93
Virat Kohli Indi 239 11520 43 54
Rohit Sharma Indi 218 8686 24 42
sqlite>파이썬을 사용하는 조인 절
다음 SQLite 예제는 파이썬을 사용하여 JOIN 절을 보여줍니다-
import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')
#Creating a cursor object using the cursor() method
cursor = conn.cursor()
#Retrieving data
sql = '''SELECT * from EMP INNER JOIN CONTACT ON EMP.CONTACT = CONTACT.ID'''
#Executing the query
cursor.execute(sql)
#Fetching 1st row from the table
result = cursor.fetchall();
print(result)
#Commit your changes in the database
conn.commit()
#Closing the connection
conn.close()산출
[('Ramya', 'Rama priya', 27, 'F', 9000.0, 101, 101, '[email protected]', 'Hyderabad'),
('Vinay', 'Battacharya', 20, 'M', 6000.0, 102, 102,'[email protected]', 'Vishakhapatnam'),
('Sharukh', 'Sheik', 25, 'M', 8300.0, 103, 103, '[email protected]', 'Pune'),
('Sarmista', 'Sharma', 26, 'F', 10000.0, 104, 104, '[email protected]', 'Mumbai')]sqlite3.Cursor 클래스는 SQLite 문을 실행하고 쿼리의 결과 집합에서 데이터를 가져 오는 메서드를 호출 할 수있는 인스턴스입니다. 당신은 만들 수 있습니다Cursor Connection 객체 / 클래스의 cursor () 메서드를 사용하는 객체.
예
import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')
#Creating a cursor object using the cursor() method
cursor = conn.cursor()행동 양식
다음은 Cursor 클래스 / 객체에서 제공하는 다양한 메서드입니다.
| Sr. 아니요 | 방법 및 설명 |
|---|---|
| 1 | execute() 이 루틴은 SQL 문을 실행합니다. SQL 문은 매개 변수화 될 수 있습니다 (즉, SQL 리터럴 대신 자리 표시 자). psycopg2 모듈은 % s 기호를 사용하여 자리 표시자를 지원합니다. 예 : cursor.execute ( "insert into people values (% s, % s)", (who, age)) |
| 2 | executemany() 이 루틴은 시퀀스 sql에서 찾은 모든 매개 변수 시퀀스 또는 매핑에 대해 SQL 명령을 실행합니다. |
| 삼 | fetchone() 이 메서드는 쿼리 결과 집합의 다음 행을 가져 와서 단일 시퀀스를 반환하거나 더 이상 데이터를 사용할 수없는 경우 없음을 반환합니다. |
| 4 | fetchmany() 이 루틴은 쿼리 결과의 다음 행 집합을 가져와 목록을 반환합니다. 사용 가능한 행이 더 이상 없으면 빈 목록이 반환됩니다. 메소드는 size 매개 변수에 표시된만큼의 행을 가져 오려고합니다. |
| 5 | fetchall() 이 루틴은 쿼리 결과의 모든 (나머지) 행을 가져 와서 목록을 반환합니다. 사용 가능한 행이 없으면 빈 목록이 반환됩니다. |
속성
다음은 Cursor 클래스의 속성입니다-
| Sr. 아니요 | 방법 및 설명 |
|---|---|
| 1 | arraySize 이것은 fetchmany () 메서드가 반환하는 행 수를 설정할 수있는 읽기 / 쓰기 속성입니다. |
| 2 | description 결과 집합의 열 설명이 포함 된 목록을 반환하는 읽기 전용 속성입니다. |
| 삼 | lastrowid 이는 읽기 전용 속성입니다. 테이블에 자동 증가 된 열이있는 경우 마지막 INSERT 또는 UPDATE 작업에서 해당 열에 대해 생성 된 값을 반환합니다. |
| 4 | rowcount SELECT 및 UPDATE 작업의 경우 반환 / 업데이트 된 행 수를 반환합니다. |
| 5 | connection 이 읽기 전용 속성은 Cursor 개체에서 사용하는 SQLite 데이터베이스 연결을 제공합니다. |
Pymongo는 MongoDB와 함께 작동하는 도구를 제공하는 Python 배포판으로, Python에서 MongoDB 데이터베이스와 통신하는 가장 선호되는 방법입니다.
설치
pymongo를 먼저 설치하려면 python3 (PIP와 함께) 및 MongoDB를 올바르게 설치했는지 확인하십시오. 그런 다음 다음 명령을 실행하십시오.
C:\WINDOWS\system32>pip install pymongo
Collecting pymongo
Using cached https://files.pythonhosted.org/packages/cb/a6/b0ae3781b0ad75825e00e29dc5489b53512625e02328d73556e1ecdf12f8/pymongo-3.9.0-cp37-cp37m-win32.whl
Installing collected packages: pymongo
Successfully installed pymongo-3.9.0확인
pymongo를 설치했으면 새 텍스트 문서를 열고 다음 행을 붙여넣고 test.py로 저장하십시오.
import pymongopymongo를 제대로 설치했다면 아래와 같이 test.py를 실행하면 아무런 문제가 없을 것입니다.
D:\Python_MongoDB>test.py
D:\Python_MongoDB>다른 데이터베이스와 달리 MongoDB는 데이터베이스를 생성하는 별도의 명령을 제공하지 않습니다.
일반적으로 use 명령은 특정 데이터베이스를 선택 / 전환하는 데 사용됩니다. 이 명령은 처음에 지정한 데이터베이스가 존재하는지 여부를 확인합니다. 존재하는 경우 연결합니다. 데이터베이스가 존재하지 않는 경우 use 명령으로 지정하면 새 데이터베이스가 생성됩니다.
따라서 MongoDB에서 다음을 사용하여 데이터베이스를 만들 수 있습니다. Use 명령.
통사론
기본 구문 use DATABASE 진술은 다음과 같습니다-
use DATABASE_NAME예
다음 명령은 mydb라는 이름의 데이터베이스를 생성합니다.
>use mydb
switched to db mydbdb 명령을 사용하여 생성을 확인할 수 있습니다. 그러면 현재 데이터베이스가 표시됩니다.
>db
mydbPython을 사용하여 데이터베이스 만들기
pymongo를 사용하여 MongoDB에 연결하려면 MongoClient를 가져 와서 생성 한 다음 속성 열정에서 생성해야하는 데이터베이스에 직접 액세스 할 수 있습니다.
예
다음 예제는 MangoDB에 데이터베이스를 만듭니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['mydb']
print("Database created........")
#Verification
print("List of databases after creating new one")
print(client.list_database_names())산출
Database created........
List of databases after creating new one:
['admin', 'config', 'local', 'mydb']MongoClient를 생성하는 동안 포트 및 호스트 이름을 지정할 수도 있으며 사전 스타일로 데이터베이스에 액세스 할 수 있습니다.
예
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['mydb']
print("Database created........")산출
Database created........MongoDB의 컬렉션은 일련의 문서를 보유하며 관계형 데이터베이스의 테이블과 유사합니다.
다음을 사용하여 컬렉션을 만들 수 있습니다. createCollection()방법. 이 메서드는 만들 컬렉션의 이름을 나타내는 문자열 값과 옵션 (선택 사항) 매개 변수를받습니다.
이것을 사용하여 다음을 지정할 수 있습니다-
- 컬렉션의 크기입니다.
- 제한 컬렉션에 허용되는 최대 문서 수입니다.
- 우리가 생성하는 컬렉션이 제한 컬렉션 (고정 크기 컬렉션)이어야하는지 여부.
- 우리가 생성하는 컬렉션이 자동 인덱싱되어야하는지 여부.
통사론
다음은 MongoDB에서 컬렉션을 만드는 구문입니다.
db.createCollection("CollectionName")예
다음 메서드는 ExampleCollection이라는 컬렉션을 만듭니다.
> use mydb
switched to db mydb
> db.createCollection("ExampleCollection")
{ "ok" : 1 }
>마찬가지로 다음은 createCollection () 메서드의 옵션을 사용하여 컬렉션을 만드는 쿼리입니다.
>db.createCollection("mycol", { capped : true, autoIndexId : true, size :
6142800, max : 10000 } )
{ "ok" : 1 }
>Python을 사용하여 컬렉션 만들기
다음 파이썬 예제는 MongoDB (mydb)의 데이터베이스에 연결하고 그 안에 컬렉션을 만듭니다.
예
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['mydb']
#Creating a collection
collection = db['example']
print("Collection created........")산출
Collection created........insert () 메서드를 사용하여 MongoDB에 문서를 저장할 수 있습니다 . 이 메소드는 JSON 문서를 매개 변수로 허용합니다.
통사론
다음은 삽입 메소드의 구문입니다.
>db.COLLECTION_NAME.insert(DOCUMENT_NAME)예
> use mydb
switched to db mydb
> db.createCollection("sample")
{ "ok" : 1 }
> doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
{ "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
> db.sample.insert(doc1)
WriteResult({ "nInserted" : 1 })
>마찬가지로 다음을 사용하여 여러 문서를 삽입 할 수도 있습니다. insert() 방법.
> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data =
[
{
"_id": "1001",
"name": "Ram",
"age": "26",
"city": "Hyderabad"
},
{
"_id": "1002",
"name" : "Rahim",
"age" : 27,
"city" : "Bangalore"
},
{
"_id": "1003",
"name" : "Robert",
"age" : 28,
"city" : "Mumbai"
}
]
[
{
"_id" : "1001",
"name" : "Ram",
"age" : "26",
"city" : "Hyderabad"
},
{
"_id" : "1002",
"name" : "Rahim",
"age" : 27,
"city" : "Bangalore"
},
{
"_id" : "1003",
"name" : "Robert",
"age" : 28,
"city" : "Mumbai"
}
]
> db.sample.insert(data)
BulkWriteResult
({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 3,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
>Python을 사용하여 컬렉션 만들기
Pymongo는 MangoDB에 문서를 삽입하기 위해 insert_one ()이라는 메서드를 제공합니다. 이 방법을 사용하려면 문서를 사전 형식으로 전달해야합니다.
예
다음 예제는 example이라는 컬렉션에 문서를 삽입합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['mydb']
#Creating a collection
coll = db['example']
#Inserting document into a collection
doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
coll.insert_one(doc1)
print(coll.find_one())산출
{
'_id': ObjectId('5d63ad6ce043e2a93885858b'),
'name': 'Ram',
'age': '26',
'city': 'Hyderabad'
}pymongo를 사용하여 MongoDB에 여러 문서를 삽입하려면 insert_many () 메서드를 호출해야합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['mydb']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data =
[
{
"_id": "101",
"name": "Ram",
"age": "26",
"city": "Hyderabad"
},
{
"_id": "102",
"name": "Rahim",
"age": "27",
"city": "Bangalore"
},
{
"_id": "103",
"name": "Robert",
"age": "28",
"city": "Mumbai"
}
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)산출
Data inserted ......
['101', '102', '103']MongoDB에서 저장된 문서를 읽고 검색 할 수 있습니다. find()방법. 이 메서드는 MongoDB의 모든 문서를 구조화되지 않은 방식으로 검색하고 표시합니다.
통사론
다음은 find() 방법.
>db.CollectionName.find()예
다음 쿼리를 사용하여 sample이라는 컬렉션의 testDB라는 데이터베이스에 3 개의 문서를 삽입했다고 가정합니다.
> use testDB
> db.createCollection("sample")
> data = [
{"_id": "1001", "name" : "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
{"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
> db.sample.insert(data)다음과 같이 find () 메소드를 사용하여 삽입 된 문서를 검색 할 수 있습니다.
> use testDB
switched to db testDB
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
>findOne () 메소드를 사용하여 컬렉션의 첫 번째 문서를 검색 할 수도 있습니다.
> db.sample.findOne()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }Python을 사용하여 데이터 검색 (찾기)
그만큼 find_One() pymongo의 메서드는 쿼리를 기반으로 단일 문서를 검색하는 데 사용됩니다. 일치하는 항목이없는 경우이 메서드는 아무것도 반환하지 않으며 쿼리를 사용하지 않으면 컬렉션의 첫 번째 문서를 반환합니다.
이 메서드는 결과의 문서를 하나만 검색해야하거나 쿼리가 하나의 문서 만 반환한다고 확신 할 때 유용합니다.
예
다음 파이썬 예제는 컬렉션의 첫 번째 문서를 검색합니다-
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['mydatabase']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)
#Retrieving the first record using the find_one() method
print("First record of the collection: ")
print(coll.find_one())
#Retrieving a record with is 103 using the find_one() method
print("Record whose id is 103: ")
print(coll.find_one({"_id": "103"}))산출
Data inserted ......
['101', '102', '103']
First record of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
Record whose id is 103:
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}단일 쿼리 (단일 호출 또는 찾기 방법)에서 여러 문서를 가져 오려면 다음을 사용할 수 있습니다. find()pymongo의 방법. 쿼리를 전달하지 않은 경우 컬렉션의 모든 문서를 반환하고이 메서드에 쿼리를 전달한 경우 일치하는 모든 문서를 반환합니다.
예
#Getting the database instance
db = client['myDB']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Retrieving all the records using the find() method
print("Records of the collection: ")
for doc1 in coll.find():
print(doc1)
#Retrieving records with age greater than 26 using the find() method
print("Record whose age is more than 26: ")
for doc2 in coll.find({"age":{"$gt":"26"}}):
print(doc2)산출
Data inserted ......
Records of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Record whose age is more than 26:
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}검색하는 동안 find()방법을 사용하면 쿼리 개체를 사용하여 문서를 필터링 할 수 있습니다. 필수 문서에 대한 조건을 지정하는 쿼리를이 메서드에 대한 매개 변수로 전달할 수 있습니다.
연산자
다음은 MongoDB의 쿼리에 사용되는 연산자 목록입니다.
| 조작 | 통사론 | 예 |
|---|---|---|
| 평등 | {"핵심 가치"} | db.mycol.find ({ "by": "튜토리얼 포인트"}) |
| 보다 작음 | { "키": {$ lt : "값"}} | db.mycol.find ({ "좋아요": {$ lt : 50}}) |
| 보다 작음 | { "key": {$ lte : "value"}} | db.mycol.find ({ "좋아요": {$ lte : 50}}) |
| 보다 큰 | { "키": {$ gt : "값"}} | db.mycol.find ({ "좋아요": {$ gt : 50}}) |
| 같음보다 큼 | { "키"{$ gte : "value"}} | db.mycol.find ({ "좋아요": {$ gte : 50}}) |
| 같지 않음 | { "key": {$ ne : "값"}} | db.mycol.find ({ "likes": {$ ne : 50}}) |
예 1
다음 예제는 이름이 sarmista 인 컬렉션에서 문서를 검색합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['sdsegf']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
{"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
{"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
{"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Retrieving data
print("Documents in the collection: ")
for doc1 in coll.find({"name":"Sarmista"}):
print(doc1)산출
Data inserted ......
Documents in the collection:
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}예 2
다음 예제는 컬렉션에서 연령 값이 26보다 큰 문서를 검색합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['ghhj']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
{"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
{"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
{"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Retrieving data
print("Documents in the collection: ")
for doc in coll.find({"age":{"$gt":"26"}}):
print(doc)산출
Data inserted ......
Documents in the collection:
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}컬렉션의 내용을 검색하는 동안 다음을 사용하여 오름차순 또는 내림차순으로 정렬하고 정렬 할 수 있습니다. sort() 방법.
이 방법으로 필드와 정렬 순서 (1 또는 -1)를 전달할 수 있습니다. 여기서 1은 오름차순이고 -1은 내림차순입니다.
통사론
다음은 sort () 메서드 의 구문입니다 .
>db.COLLECTION_NAME.find().sort({KEY:1})예
아래와 같이 컬렉션을 만들고 5 개의 문서를 삽입했다고 가정합니다.
> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 6,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})다음 줄은 연령을 기준으로 오름차순으로 정렬 된 컬렉션의 모든 문서를 검색합니다.
> db.sample.find().sort({age:1})
{ "_id" : "1005", "name" : "Sarmista", "age" : 23, "city" : "Delhi" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }파이썬을 사용하여 문서 정렬
쿼리 결과를 오름차순 또는 내림차순으로 정렬하기 위해 pymongo는 sort()방법. 이 메서드에는 결과에 필요한 문서 수를 나타내는 숫자 값을 전달합니다.
기본적으로이 방법은 지정된 필드를 기준으로 문서를 오름차순으로 정렬합니다. 내림차순으로 정렬해야하는 경우 필드 이름과 함께 -1을 전달합니다.
coll.find().sort("age",-1)예
다음 예제는 오름차순으로 연령 값에 따라 정렬 된 컬렉션의 모든 문서를 검색합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['b_mydb']
#Creating a collection
coll = db['myColl']
#Inserting document into a collection
data = [
{"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
{"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
{"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
{"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Retrieving first 3 documents using the find() and limit() methods
print("List of documents (sorted in ascending order based on age): ")
for doc1 in coll.find().sort("age"):
print(doc1)산출
Data inserted ......
List of documents (sorted in ascending order based on age):
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1006', 'name': 'Rasajna', 'age': 26, 'city': 'Chennai'}
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}컬렉션에서 문서를 삭제할 수 있습니다. remove()MongoDB의 방법. 이 방법은 두 개의 선택적 매개 변수를 허용합니다.
문서 삭제 조건을 지정하는 삭제 기준.
하나만, true 또는 1을 두 번째 매개 변수로 전달하면 하나의 문서 만 삭제됩니다.
통사론
다음은 remove () 메소드의 구문입니다.
>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)예
아래와 같이 컬렉션을 만들고 5 개의 문서를 삽입했다고 가정합니다.
> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 6,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})다음 쿼리는 이름 값이 Sarmista 인 컬렉션의 문서를 삭제합니다.
> db.sample.remove({"name": "Sarmista"})
WriteResult({ "nRemoved" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }호출하면 remove() 삭제 기준을 통과하지 않고 메서드를 사용하면 컬렉션의 모든 문서가 삭제됩니다.
> db.sample.remove({})
WriteResult({ "nRemoved" : 5 })
> db.sample.find()Python을 사용하여 문서 삭제
MangoDB 컬렉션에서 문서를 삭제하려면 메서드를 사용하여 컬렉션에서 문서를 삭제할 수 있습니다. delete_one() 과 delete_many() 행동 양식.
이러한 메서드는 문서 삭제 조건을 지정하는 쿼리 개체를받습니다.
detele_one () 메서드는 일치하는 경우 단일 문서를 삭제합니다. 쿼리를 지정하지 않으면이 메서드는 컬렉션의 첫 번째 문서를 삭제합니다.
예
다음 파이썬 예제는 ID 값이 1006 인 컬렉션에서 문서를 삭제합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['lpaksgf']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
{"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
{"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
{"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Deleting one document
coll.delete_one({"_id" : "1006"})
#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")
for doc2 in coll.find():
print(doc2)산출
Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}마찬가지로 delete_many() pymongo의 메소드는 지정된 조건을 만족하는 모든 문서를 삭제합니다.
예
다음 예제는 컬렉션에서 나이 값이 26보다 큰 모든 문서를 삭제합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['sampleDB']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
{"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
{"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
{"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Deleting multiple documents
coll.delete_many({"age":{"$gt":"26"}})
#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")
for doc2 in coll.find():
print(doc2)산출
Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1004', 'name': 'Romeo', 'age': '25', 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}
{'_id': '1006', 'name': 'Rasajna', 'age': '26', 'city': 'Chennai'}쿼리를 전달하지 않고 delete_many () 메서드를 호출하면이 메서드는 컬렉션의 모든 문서를 삭제합니다.
coll.delete_many({})다음을 사용하여 컬렉션을 삭제할 수 있습니다. drop() MongoDB의 방법.
통사론
다음은 drop () 메소드의 구문입니다.
db.COLLECTION_NAME.drop()예
다음 예제는 샘플 이름으로 컬렉션을 삭제합니다-
> show collections
myColl
sample
> db.sample.drop()
true
> show collections
myColl파이썬을 사용하여 컬렉션 삭제
drop () 메서드를 호출하여 현재 데이터베이스에서 컬렉션을 삭제 / 삭제할 수 있습니다.
예
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['example2']
#Creating a collection
col1 = db['collection']
col1.insert_one({"name": "Ram", "age": "26", "city": "Hyderabad"})
col2 = db['coll']
col2.insert_one({"name": "Rahim", "age": "27", "city": "Bangalore"})
col3 = db['myColl']
col3.insert_one({"name": "Robert", "age": "28", "city": "Mumbai"})
col4 = db['data']
col4.insert_one({"name": "Romeo", "age": "25", "city": "Pune"})
#List of collections
print("List of collections:")
collections = db.list_collection_names()
for coll in collections:
print(coll)
#Dropping a collection
col1.drop()
col4.drop()
print("List of collections after dropping two of them: ")
#List of collections
collections = db.list_collection_names()
for coll in collections:
print(coll)산출
List of collections:
coll
data
collection
myColl
List of collections after dropping two of them:
coll
myColl다음을 사용하여 기존 문서의 내용을 업데이트 할 수 있습니다. update() 방법 또는 save() 방법.
업데이트 방법은 기존 문서를 수정하는 반면 저장 방법은 기존 문서를 새 문서로 바꿉니다.
통사론
다음은 MangoDB의 update () 및 save () 메소드의 구문입니다.
>db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)
Or,
db.COLLECTION_NAME.save({_id:ObjectId(),NEW_DATA})예
데이터베이스에 컬렉션을 만들고 아래와 같이 3 개의 레코드를 삽입했다고 가정합니다.
> use testdatabase
switched to db testdatabase
> data = [
... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
... {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
... {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
[
{
"_id" : "1001",
"name" : "Ram",
"age" : "26",
"city" : "Hyderabad"
},
{
"_id" : "1002",
"name" : "Rahim",
"age" : 27,
"city" : "Bangalore"
},
{
"_id" : "1003",
"name" : "Robert",
"age" : 28,
"city" : "Mumbai"
}
]
> db.createCollection("sample")
{ "ok" : 1 }
> db.sample.insert(data)다음 메소드는 ID가 1002 인 문서의 도시 값을 업데이트합니다.
> db.sample.update({"_id":"1002"},{"$set":{"city":"Visakhapatnam"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }마찬가지로 save () 메서드를 사용하여 동일한 ID로 저장하여 문서를 새 데이터로 바꿀 수 있습니다.
> db.sample.save(
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" }
)
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }Python을 사용하여 문서 업데이트
단일 문서를 검색하는 find_one () 메소드와 유사하게, pymongo의 update_one () 메소드는 단일 문서를 업데이트합니다.
이 메서드는 업데이트 할 문서와 업데이트 작업을 지정하는 쿼리를받습니다.
예
다음 파이썬 예제는 컬렉션에있는 문서의 위치 값을 업데이트합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['myDB']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
print(doc1)
coll.update_one({"_id":"102"},{"$set":{"city":"Visakhapatnam"}})
#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")
for doc2 in coll.find():
print(doc2)산출
Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}마찬가지로 update_many() pymongo의 메소드는 지정된 조건을 충족하는 모든 문서를 업데이트합니다.
예
다음 예제는 컬렉션의 모든 문서에서 위치 값을 업데이트합니다 (빈 상태)-
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['myDB']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
print(doc1)
coll.update_many({},{"$set":{"city":"Visakhapatnam"}})
#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")
for doc2 in coll.find():
print(doc2)산출
Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Visakhapatnam'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Visakhapatnam'}컬렉션의 내용을 검색하는 동안 limit () 메서드를 사용하여 결과의 문서 수를 제한 할 수 있습니다. 이 메서드는 결과에서 원하는 문서 수를 나타내는 숫자 값을받습니다.
통사론
다음은 limit () 메서드의 구문입니다.
>db.COLLECTION_NAME.find().limit(NUMBER)예
아래와 같이 컬렉션을 만들고 5 개의 문서를 삽입했다고 가정합니다.
> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data = [
... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 6,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})다음 줄은 컬렉션의 처음 3 개 문서를 검색합니다.
> db.sample.find().limit(3)
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }파이썬을 사용하여 문서 제한
쿼리 결과를 특정 문서 수로 제한하기 위해 pymongo는 limit()방법. 이 메서드에는 결과에 필요한 문서 수를 나타내는 숫자 값을 전달합니다.
예
다음 예제는 컬렉션의 처음 세 문서를 검색합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['l']
#Creating a collection
coll = db['myColl']
#Inserting document into a collection
data = [
{"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
{"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
{"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
{"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Retrieving first 3 documents using the find() and limit() methods
print("First 3 documents in the collection: ")
for doc1 in coll.find().limit(3):
print(doc1)산출
Data inserted ......
First 3 documents in the collection:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}