Python MySQL - Hızlı Kılavuz

Veritabanı arayüzleri için Python standardı, Python DB-API'dir. Çoğu Python veritabanı arayüzü bu standarda uymaktadır.

Uygulamanız için doğru veritabanını seçebilirsiniz. Python Veritabanı API, aşağıdakiler gibi çok çeşitli veritabanı sunucularını destekler:

GadFly
mSQL
MySQL
PostgreSQL
Microsoft SQL Server 2000
Informix
Interbase
Oracle
Sybase

Kullanılabilir Python veritabanı arayüzlerinin listesi - Python Veritabanı Arayüzleri ve API'ler . Erişmeniz gereken her veritabanı için ayrı bir DB API modülü indirmelisiniz. Örneğin, bir Oracle veritabanına ve ayrıca bir MySQL veritabanına erişmeniz gerekiyorsa, hem Oracle hem de MySQL veritabanı modüllerini indirmeniz gerekir.

Mysql-connector-python nedir?

MySQL Python / Connector, Python'dan bir MySQL veritabanı sunucusuna bağlanmak için bir arayüzdür. Python Veritabanı API'sini uygular ve MySQL'in üzerine inşa edilmiştir.

Mysql-connector-python'u nasıl kurarım?

Öncelikle, makinenize python kurduğunuzdan emin olmanız gerekir. Bunu yapmak için komut istemini açın ve içine python yazın ve Enter tuşuna basın . Python sisteminize zaten yüklüyse, bu komut sürümünü aşağıda gösterildiği gibi gösterecektir -

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.
>>>

Python kabuğundan çıkmak ve Python_MySQL adlı bir klasör oluşturmak için (Python-MySQL bağlayıcısını kurmayı düşündüğünüz) ctrl + z ve ardından Enter tuşlarına basın -

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

PIP'yi doğrulayın

PIP, Python'da çeşitli modülleri / paketleri kurabileceğiniz python paket yöneticisidir. Bu nedenle, Mysql-python mysql-connector-python'u kurmak için bilgisayarınızda PIP'in kurulu olduğundan ve konumunun yola eklendiğinden emin olmanız gerekir.

Bunu pip komutunu çalıştırarak yapabilirsiniz. Sisteminizde PIP yoksa veya konumunuPath ortam değişkeni, şu şekilde bir hata mesajı alacaksınız -

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

PIP'yi kurmak için get-pip.py dosyasını yukarıda oluşturulan klasöre indirin ve komuttan gezinin ve aşağıdaki gibi pip'i kurun -

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

Mysql-connector-python'u yükleme

Python ve PIP'i yükledikten sonra, komut istemini açın ve pip'i (isteğe bağlı) aşağıda gösterildiği gibi yükseltin -

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

Ardından yönetici modunda komut istemini açın ve python MySQL connect'i kurun -

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

Doğrulama

Kurulumunu doğrulamak için aşağıdaki satırı içeren örnek bir python betiği oluşturun.

import mysql.connector

Kurulum başarılı olursa, çalıştırdığınızda herhangi bir hata almamalısınız -

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

Python'u Sıfırdan Yükleme

Basitçe, Python'u sıfırdan yüklemeniz gerekiyorsa. Python Ana Sayfasını ziyaret edin .

Tıkla Downloads düğmesi, çeşitli platformlar için python'un en son sürümünün bağlantılarını sağlayan indirilenler sayfasına yönlendirileceksiniz birini seçin ve indirin.

Örneğin, python-3.7.4.exe'yi (Windows için) indirdik. İndirilen .exe dosyasına çift tıklayarak kurulum sürecini başlatın.

Python 3.7'yi Yola Ekle seçeneğini işaretleyin ve kuruluma devam edin. Bu işlem tamamlandıktan sonra python sisteminize yüklenecektir.

MySQL ile bağlanmak için (bir yolu) sisteminizde MySQL komut istemini aşağıda gösterildiği gibi açın -

Burada şifre ister; kurulum sırasında varsayılan kullanıcı (root) olarak belirlediğiniz parolayı yazmanız gerekir.

Ardından MySQL ile aşağıdaki mesajı görüntüleyen bir bağlantı kurulur -

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 veritabanından istediğiniz zaman bağlantıyı kesebilirsiniz. exitEn komut mysql> istemi.

mysql> exit
Bye

Python Kullanarak MySQL ile Bağlantı Kurmak

Python kullanarak MySQL veritabanına bağlantı kurmadan önce, varsayalım -

Mydb adıyla bir veritabanı oluşturduğumuzu.
FIRST_NAME, LAST_NAME, AGE, SEX ve INCOME sütunlarını içeren bir EMPLOYEE tablosu oluşturduk.
MySQL ile bağlantı kurmak için kullandığımız kimlik bilgileri kullanıcı adıdır - root, şifre - password.

Connect () yapıcısını kullanarak bir bağlantı kurabilirsiniz . Bu, bağlanmanız gereken (isteğe bağlı) kullanıcı adını, parolayı, ana bilgisayarı ve veritabanının adını kabul eder ve MySQLConnection sınıfının bir nesnesini döndürür.

Misal

Aşağıda MySQL veritabanı "mydb" ile bağlanma örneği verilmiştir.

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()

Çıktı

Yürütüldüğünde, bu komut dosyası aşağıdaki çıktıyı üretir -

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

Ayrıca kimlik bilgilerini (kullanıcı adı, parola, ana bilgisayar adı ve veritabanı adı) şuraya ileterek de MySQL ile bağlantı kurabilirsiniz. connection.MySQLConnection() aşağıda gösterildiği gibi -

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 sorgusunu kullanarak MYSQL'de bir veritabanı oluşturabilirsiniz.

Sözdizimi

CREATE DATABASE sorgusunun sözdizimi aşağıdadır -

CREATE DATABASE name_of_the_database

Misal

Aşağıdaki ifade MySQL'de mydb adlı bir veritabanı oluşturur -

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

SHOW DATABASES deyimini kullanarak veritabanları listesini gözlemlerseniz, yeni oluşturulan veritabanını aşağıda gösterildiği gibi gözlemleyebilirsiniz -

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

Python Kullanarak MySQL'de Veritabanı Oluşturma

MySQL ile bağlantı kurduktan sonra, içindeki verileri işlemek için bir veritabanına bağlanmanız gerekir. Mevcut bir veritabanına bağlanabilir veya kendi veritabanınızı oluşturabilirsiniz.

Bir MySQL veritabanı oluşturmak veya silmek için özel ayrıcalıklara ihtiyacınız olacaktır. Dolayısıyla, kök kullanıcıya erişiminiz varsa, herhangi bir veritabanı oluşturabilirsiniz.

Misal

Aşağıdaki örnek MYSQL ile bağlantı kurar ve içinde bir veritabanı oluşturur.

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()

Çıktı

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

CREATE TABLE deyimi, MYSQL veritabanında tablolar oluşturmak için kullanılır. Burada tablonun adını ve her bir sütunun tanımını (adı ve veri türü) belirtmeniz gerekir.

Sözdizimi

MySQL'de bir tablo oluşturmak için sözdizimi aşağıdadır -

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

Misal

Aşağıdaki sorgu MySQL'de FIRST_NAME, LAST_NAME, AGE, SEX ve INCOME olmak üzere beş sütunlu EMPLOYEE adlı bir tablo oluşturur.

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 ifadesi size belirtilen tablonun açıklamasını verir. Bunu kullanarak, tablonun aşağıda gösterildiği gibi oluşturulup oluşturulmadığını doğrulayabilirsiniz -

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 Kullanarak MySQL'de Tablo Oluşturma

Execute () adlı yöntem (imleç nesnesinde çağrılır) iki değişkeni kabul eder−

Yürütülecek sorguyu temsil eden bir String değeri.
Sorgunun parametrelerini (yer sahiplerinin değerleri) temsil eden bir demet veya liste veya sözlük olabilen isteğe bağlı bir args parametresi.

Sorgudan etkilenen satır sayısını temsil eden bir tamsayı değeri döndürür.

Bir veritabanı bağlantısı kurulduktan sonra, CREATE TABLE sorgusunu execute() yöntem.

Kısacası python kullanarak bir tablo oluşturmak için -

İthalat mysql.connector paketi.
Kullanarak bir bağlantı nesnesi oluşturun mysql.connector.connect() yöntem, kullanıcı adını, parolayı, ana bilgisayarı (isteğe bağlı varsayılan: localhost) ve veritabanını (isteğe bağlı) parametre olarak ona ileterek.
İmleç nesnesini çağırarak cursor() Yukarıda oluşturulan bağlantı nesnesinde yöntem.
Ardından, CREATE TABLE deyimini parametre olarak ileterek yürütün .execute() yöntem.

Misal

Aşağıdaki örnek, adında bir tablo oluşturur Employee mydb veritabanında.

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()

Mevcut bir MySQL tablosuna yeni satırlar ekleyebilirsiniz. INSERT INTOBeyan. Bunda, tablonun adını, sütun adlarını ve değerleri (sütun adlarıyla aynı sırada) belirtmeniz gerekir.

Sözdizimi

MySQL'in INSERT INTO ifadesinin sözdizimi aşağıdadır.

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

Misal

Aşağıdaki sorgu EMPLOYEE adlı tabloya bir kayıt ekler.

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

SELECT deyimini kullanarak ekledikten sonra tablonun kayıtlarını doğrulayabilirsiniz -

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

Sütunların adlarını her zaman belirtmek zorunlu değildir, bir kaydın değerlerini tablonun sütunlarıyla aynı sırada geçirirseniz, SELECT deyimini sütun adları olmadan aşağıdaki gibi çalıştırabilirsiniz -

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

Python Kullanarak MySQL Tablosuna Veri Ekleme

execute()yöntem (imleç nesnesinde çağrılan) bir sorguyu parametre olarak kabul eder ve verilen sorguyu yürütür. Veri eklemek için, MySQL INSERT ifadesini parametre olarak ona iletmeniz gerekir.

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

Python kullanarak MySQL'de bir tabloya veri eklemek için -

ithalat mysql.connector paketi.
Kullanarak bir bağlantı nesnesi oluşturun mysql.connector.connect() yöntem, kullanıcı adını, parolayı, ana bilgisayarı (isteğe bağlı varsayılan: localhost) ve veritabanını (isteğe bağlı) parametre olarak ona ileterek.
İmleç nesnesini çağırarak cursor() Yukarıda oluşturulan bağlantı nesnesinde yöntem.
Ardından, INSERT ifadesini parametre olarak ileterek execute() yöntem.

Misal

Aşağıdaki örnek , EMPLOYEE tablosuna bir kayıt eklemek için SQL INSERT deyimini çalıştırır -

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()

Değerleri Dinamik Olarak Ekleme

Ayrıca kullanabilirsin “%s” içindeki değerler yerine INSERT MySQL sorgusu ve değerleri aşağıda gösterildiği gibi listeler halinde onlara iletin -

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

Misal

Aşağıdaki örnek, Employee tablosuna dinamik olarak bir kayıt ekler.

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()

Çıktı

Data inserted

SELECT sorgusunu kullanarak MySQL'deki bir tablodan veri alabilir / getirebilirsiniz. Bu sorgu / ifade, belirtilen tablonun içeriğini tablo biçiminde döndürür ve sonuç kümesi olarak adlandırılır.

Sözdizimi

SELECT sorgusunun sözdizimi aşağıdadır -

SELECT column1, column2, columnN FROM table_name;

Misal

MySQL'de cricketers_data adıyla bir tablo oluşturduğumuzu varsayalım -

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

Ve INSERT ifadelerini kullanarak 5 kayıt eklediysek -

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');

Aşağıdaki sorgu, tablodan FIRST_NAME ve Ülke değerlerini alır.

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)

Ayrıca her kaydın tüm değerlerini, sütunların adının * örneğini kullanarak alabilirsiniz: -

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 Kullanarak MYSQL Tablosundan Veri Okuma

Herhangi bir veritabanı üzerinde OKUMA İşlemi, veritabanından bazı yararlı bilgileri almak anlamına gelir. Şunları kullanarak MYSQL'den veri alabilirsiniz.fetch() mysql-connector-python tarafından sağlanan yöntem.

Cursor.MySQLCursor sınıfı yani üç yöntem sağlarfetchall(), fetchmany() ve, fetchone() nerede,

fetchall()yöntem, bir sorgunun sonuç kümesindeki tüm satırları alır ve bunları tuple listesi olarak döndürür. (Bunu birkaç satırı aldıktan sonra yürütürsek, kalanları döndürür).
fetchone() yöntem, bir sorgunun sonucundaki sonraki satırı alır ve bir demet olarak döndürür.
fetchmany() yöntem fetchone () yöntemine benzer, ancak tek bir satır yerine bir sorgunun sonuç kümesindeki sonraki satır kümesini alır.

Note - Sonuç kümesi, bir tabloyu sorgulamak için bir imleç nesnesi kullanıldığında döndürülen bir nesnedir.

rowcount - Bu salt okunur bir özelliktir ve bir execute () yönteminden etkilenen satırların sayısını döndürür.

Misal

Aşağıdaki örnek, EMPLOYEE tablosunun tüm satırlarını SELECT sorgusunu kullanarak ve başlangıçta elde edilen sonuç kümesinden getirmektedir, ilk satırı fetchone () yöntemini kullanarak alıyoruz ve ardından fetchall () yöntemini kullanarak kalan satırları alıyoruz.

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()

Çıktı

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

Aşağıdaki örnek, EMPLOYEE tablosunun ilk iki satırını fetchmany () yöntemini kullanarak alır.

Misal

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()

Çıktı

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

MySQL'de bir tablonun belirli satırlarını getirmek, silmek veya güncellemek istiyorsanız, işlem için tablonun satırlarını filtrelemek için koşul belirtmek üzere where cümlesini kullanmanız gerekir.

Örneğin, where cümlesine sahip bir SELECT deyiminiz varsa, yalnızca belirtilen koşulu karşılayan satırlar alınacaktır.

Sözdizimi

WHERE cümlesinin sözdizimi aşağıdadır -

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

Misal

MySQL'de EMPLOYEES adıyla bir tablo oluşturduğumuzu varsayalım -

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)

Ve INSERT ifadelerini kullanarak 4 kayıt eklediysek -

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 ifadesinin ardından, geliri 4000'den fazla olan çalışanların kayıtları alınır.

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

Python Kullanan WHERE Cümlesi

Python programını kullanarak bir tablodan belirli kayıtları getirmek için -

ithalat mysql.connector paketi.
Kullanarak bir bağlantı nesnesi oluşturun mysql.connector.connect() yöntem, kullanıcı adını, parolayı, ana bilgisayarı (isteğe bağlı varsayılan: localhost) ve veritabanını (isteğe bağlı) parametre olarak ona ileterek.
İmleç nesnesini çağırarak cursor() Yukarıda oluşturulan bağlantı nesnesinde yöntem.
Ardından, SELECT deyimini WHERE yan tümcesine bir parametre olarak ileterek yürütün .execute() yöntem.

Misal

Aşağıdaki örnek, Employee adında bir tablo oluşturur ve onu doldurur. Daha sonra where cümlesini kullanarak yaş değeri 23'ten küçük olan kayıtları alır.

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()

Çıktı

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

SELECT sorgusunu kullanarak verileri alırken, OrderBy yan tümcesini kullanarak sonuçları istediğiniz sırada (artan veya azalan) sıralayabilirsiniz. Varsayılan olarak, bu cümle, sonuçları artan sırada sıralar, eğer onları azalan sırada düzenlemeniz gerekiyorsa, açıkça "DESC" kullanmanız gerekir.

Sözdizimi

Aşağıdaki sözdizimi SELECT sütun listesidir

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

Misal

MySQL'de EMPLOYEES adıyla bir tablo oluşturduğumuzu varsayalım -

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)

Ve INSERT ifadelerini kullanarak 4 kayıt eklediysek -

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);

Aşağıdaki ifade ÇALIŞAN tablosunun içeriğini çağın artan sırasına göre alır.

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)

Ayrıca DESC'i şu şekilde kullanarak azalan sırada da alabilirsiniz -

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

Python Kullanarak Maddeye Göre SİPARİŞ

Bir tablonun içeriğini belirli bir sırayla almak için, execute() yöntemini imleç nesnesinde ve SELECT deyimini ORDER BY yan tümcesi ile birlikte parametre olarak iletin.

Misal

Aşağıdaki örnekte, ad ve Çalışan ile bir tablo oluşturuyoruz, onu dolduruyoruz ve ORDER BY cümlesini kullanarak kayıtlarını yaşlarının (artan) sırasına göre geri alıyoruz.

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()

Çıktı

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

Aynı şekilde, ORDER BY yan tümcesini kullanarak bir tablodan verileri azalan sırada alabilirsiniz.

Misal

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()

Çıktı

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

GÜNCELLEME Herhangi bir veritabanı üzerinde yapılan işlem, veritabanında zaten mevcut olan bir veya daha fazla kaydı günceller. UPDATE deyimini kullanarak MySQL'deki mevcut kayıtların değerlerini güncelleyebilirsiniz. Belirli satırları güncellemek için, onunla birlikte WHERE yan tümcesini kullanmanız gerekir.

Sözdizimi

Aşağıda MySQL'deki UPDATE ifadesinin sözdizimi verilmiştir -

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

AND veya OR operatörlerini kullanarak N sayıda koşulu birleştirebilirsiniz.

Misal

MySQL'de EMPLOYEES adıyla bir tablo oluşturduğumuzu varsayalım -

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)

Ve INSERT ifadelerini kullanarak 4 kayıt eklediysek -

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 ifadesinin ardından tüm erkek çalışanların yaşı bir yıl artar -

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

Tablonun içeriğini alırsanız, güncellenmiş değerleri şu şekilde görebilirsiniz:

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 Kullanarak Bir Tablonun İçeriğini Güncelleme

Python kullanarak MySQL'deki bir tablodaki kayıtları güncellemek için -

ithalat mysql.connector paketi.
Kullanarak bir bağlantı nesnesi oluşturun mysql.connector.connect() yöntem, kullanıcı adını, parolayı, ana bilgisayarı (isteğe bağlı varsayılan: localhost) ve veritabanını (isteğe bağlı) parametre olarak ona ileterek.
İmleç nesnesini çağırarak cursor() Yukarıda oluşturulan bağlantı nesnesinde yöntem.
Ardından, UPDATE deyimini parametre olarak ileterek yürütün .execute() yöntem.

Misal

Aşağıdaki örnek tüm erkeklerin yaşını bir yıl artırmaktadır.

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()

Çıktı

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

Bir MySQL tablosundaki kayıtları silmek için, DELETE FROMBeyan. Belirli kayıtları kaldırmak için, onunla birlikte WHERE cümlesini kullanmanız gerekir.

Sözdizimi

MYSQL'de DELETE sorgusunun sözdizimi aşağıdadır -

DELETE FROM table_name [WHERE Clause]

Misal

MySQL'de EMPLOYEES adıyla bir tablo oluşturduğumuzu varsayalım -

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)

Ve INSERT ifadelerini kullanarak 4 kayıt eklediysek -

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 ifadesinin ardından, çalışanın FIRST_NAME ”Mac” ile kaydını siler .

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

Tablonun içeriğini geri alırsanız, birini sildiğimiz için sadece 3 kayıt görebilirsiniz.

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)

DELETE deyimini WHERE yan tümcesi olmadan yürütürseniz, belirtilen tablodaki tüm kayıtlar silinecektir.

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

Tablonun içeriğini geri alırsanız, aşağıda gösterildiği gibi boş bir set alacaksınız -

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

Python Kullanarak Bir Tablonun Kayıtlarını Kaldırma

Veritabanınızdan bazı kayıtları silmek istediğinizde DELETE işlemi gereklidir.

Bir tablodaki kayıtları silmek için -

ithalat mysql.connector paketi.
Kullanarak bir bağlantı nesnesi oluşturun mysql.connector.connect() yöntem, kullanıcı adını, parolayı, ana bilgisayarı (isteğe bağlı varsayılan: localhost) ve veritabanını (isteğe bağlı) parametre olarak ona ileterek.
Yukarıda oluşturulan bağlantı nesnesinde cursor () yöntemini çağırarak bir imleç nesnesi oluşturun.
Ardından, DELETE ifadesini parametre olarak ileterek execute() yöntem.

Misal

Aşağıdaki program, yaşı 20'den büyük olan ÇALIŞAN'dan tüm kayıtları siler -

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()

Çıktı

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)
]

Kullanarak tüm tabloyu kaldırabilirsiniz. DROP TABLEBeyan. Silmeniz gereken tablonun adını belirtmeniz yeterlidir.

Sözdizimi

Aşağıda MySQL'deki DROP TABLE ifadesinin sözdizimi verilmiştir -

DROP TABLE table_name;

Misal

Bir tabloyu silmeden önce SHOW TABLES deyimini kullanarak aşağıdaki gibi tabloların listesini alın -

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

Aşağıdaki ifade, sample adındaki tabloyu veritabanından tamamen kaldırır -

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

MySQL'den sample adındaki tabloyu sildiğimiz için, tabloların listesini tekrar alırsanız, içinde tablo adı örneğini bulamazsınız.

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

Python Kullanarak Bir Tabloyu Kaldırma

MYSQL'in DROP ifadesini kullanarak istediğiniz zaman bir tabloyu bırakabilirsiniz, ancak mevcut tabloyu silerken çok dikkatli olmalısınız çünkü bir tablo silindikten sonra kaybolan veriler kurtarılmayacaktır.

Python kullanarak bir MYSQL veritabanından bir tablo bırakmak için execute() yöntemini imleç nesnesine yerleştirin ve drop deyimini bir parametre olarak ona iletin.

Misal

Aşağıdaki tablo, veri tabanından EMPLOYEE adlı bir tablo bırakmaktadır.

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()

Çıktı

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

Yalnızca Varsa Tabloyu Bırak

Veritabanında olmayan bir tabloyu düşürmeye çalışırsanız, şu şekilde bir hata oluşur:

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

Bu hatayı, tablonun silinmeden önce var olup olmadığını doğrulayarak, DELETE deyimine IF EXISTS'i ekleyerek önleyebilirsiniz.

Example

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

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

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

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

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

#Closing the connection
conn.close()

Output

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

Kayıtları alırken belirli bir sayı ile sınırlandırmak istiyorsanız, bunu MYSQL'in LIMIT cümlesini kullanarak yapabilirsiniz.

Misal

MySQL'de EMPLOYEES adıyla bir tablo oluşturduğumuzu varsayalım -

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)

Ve INSERT ifadelerini kullanarak 4 kayıt eklediysek -

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);

Aşağıdaki SQL ifadesi, LIMIT deyimini kullanarak Employee tablosunun ilk iki kaydını alır.

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

Python Kullanarak Sınırlama Maddesi

Eğer çağırırsanız execute() SELECT sorgusunu LIMIT yan tümcesi ile birlikte geçirerek imleç nesnesi üzerinde yöntem, gerekli sayıda kaydı alabilirsiniz.

Misal

Aşağıdaki python örneği EMPLOYEE adıyla bir tablo oluşturur ve doldurur ve LIMIT cümlesini kullanarak ilk iki kaydını getirir.

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()

Çıktı

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

OFFSET ile LIMIT

Kayıtları n'inci kayıttan (1. değil) başlayarak sınırlamanız gerekiyorsa, OFFSET'i LIMIT ile birlikte kullanarak yapabilirsiniz.

Example

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

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

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

#Executing the query
cursor.execute(sql)

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

#Closing the connection
conn.close()

Output

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

Verileri iki tabloya böldüğünüzde, Birleşimler'i kullanarak bu iki tablodan birleşik kayıtları getirebilirsiniz.

Misal

EMPLOYEE adında bir tablo oluşturduğumuzu ve verileri bu tabloya aşağıda gösterildiği gibi doldurduğumuzu varsayalım -

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

Sonra, başka bir tablo oluşturup bunu şu şekilde doldurduysak -

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

Aşağıdaki ifade, bu iki tablodaki değerleri birleştiren verileri alır -

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 Kullanarak MYSQL JOIN

Aşağıdaki örnek, EMPLOYEE tablosunun kontak sütunu ve CONTACT tablosunun ID sütunu ile birleştirilen yukarıdaki iki tablodan verileri alır.

Misal

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()

Çıktı

[
   ('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'un (ve benzer kitaplıkların) MySQLCursoru, MySQL veritabanıyla iletişim kurmak için ifadeleri yürütmek için kullanılır.

Yöntemlerini kullanarak SQL deyimlerini çalıştırabilir, sonuç kümelerinden veri alabilir, prosedürleri çağırabilirsiniz.

Yaratabilirsin Cursor Connection nesnesinin / sınıfının cursor () yöntemini kullanan nesne.

Misal

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()

Yöntemler

Aşağıdakiler, Cursor sınıfı / nesnesi tarafından sağlanan çeşitli yöntemlerdir.

Sr.No	Yöntemler ve Açıklama
1	callproc() Bu yöntem, mevcut prosedürler MySQL veritabanını çağırmak için kullanılır.
2	close() Bu yöntem, mevcut imleç nesnesini kapatmak için kullanılır.
3	Info() Bu yöntem, son sorgu hakkında bilgi verir.
4	executemany() Bu yöntem, bir dizi parametre listesini kabul eder. Bir MySQL sorgusu hazırlar ve onu tüm parametrelerle yürütür.
5	execute() Bu yöntem, bir MySQL sorgusunu parametre olarak kabul eder ve verilen sorguyu yürütür.
6	fetchall() Bu yöntem, bir sorgunun sonuç kümesindeki tüm satırları alır ve bunları tuple listesi olarak döndürür. (Bunu birkaç satırı aldıktan sonra yürütürsek, kalanları döndürür)
7	fetchone() Bu yöntem, bir sorgunun sonucundaki sonraki satırı getirir ve bir demet olarak döndürür.
8	fetchmany() Bu yöntem fetchone () yöntemine benzer, ancak tek bir satır yerine bir sorgunun sonuç kümesindeki sonraki satır kümesini alır.
9	fetchwarnings() Bu yöntem, son yürütülen sorgu tarafından oluşturulan uyarıları döndürür.

Özellikleri

Cursor sınıfının özellikleri aşağıdadır -

Sr.No	Özellik ve Açıklama
1	column_names Bu, bir sonuç kümesinin sütun adlarını içeren listeyi döndüren salt okunur bir özelliktir.
2	description Bu, bir sonuç kümesindeki sütunların açıklamasını içeren listeyi döndüren salt okunur bir özelliktir.
3	lastrowid Bu salt okunur bir özelliktir, tabloda otomatik olarak artan sütunlar varsa, bu son INSERT veya UPDATE işleminde o sütun için oluşturulan değeri döndürür.
4	rowcount Bu, SELECT ve UPDATE işlemleri durumunda döndürülen / güncellenen satır sayısını döndürür.
5	statement Bu özellik, son çalıştırılan ifadeyi döndürür.