Python MySQL Connectivity
1
Here we are using mysql as back end database because it is open
source,free and portable. Any one of the modules either mysql
- connector or MySQLdb can be used for database programming.
1. Mysql-connector enables Python programs to access MySQL databases,
using an API that is compliant with the Python Database API
Specification v2.0.
2. MySQLdb is an interface for connecting to a MySQL database server
from Python. It implements the Python Database API v2.0 and is built
on top of the MySQL C API.
2
We must download a separate DB API (database application programming
interface) module for each database we need to access. Suppose we need to
access an Oracle database as well as a MySQL database, we must download
both the Oracle and the MySQL database modules. The DB API provides a
minimal standard for working with databases using Python structures and
syntax wherever possible. This API includes the following −
● Importing the API module.
● Acquiring a connection with the database.
● Issuing SQL statements and stored procedures.
● Closing the connection
3
To download MySQL Python Connector
MySQL Python Connector is used to access the MySQL
database from Python, you need a database driver. MySQL
Connector/Python is a standardized database driver provided
by MySQL.
Step 1: Open Command window
Step2 : type pip install mysql-connector
4
Now, to check whether mysql-connector is installed/ working properly -
1. Open Python IDLE
2. Type import mysql
3. If no error occurs, it means mysql-connector is working properly
5
Steps to connect a python application to our MySQL database
1. Import mysql.connector module
2. Create the connection object.
3. Create the cursor object
4. Execute the query
6
Some important points are as follows:
• To connect to a database from within a programming
application, you need a framework that facilitates
communication between two different genres of software
(programming application and DBMS).
• To connect from Python to MYSQL, you need a library called
MySQL connector.
• You must import mysql.connector in the Python
program/script before writing code of connectivity.
• Steps to create a database connectivity Python application are:
• Step 1. Start Python: start Python's editor where you can
create your python scripts, i.e; IDE or IDLE. 7
• Step 2. Import the package required for database programming.
• Here you need to import mysql.connector package in your python
scripts.
• Step 3. Open a connection: Here we need to establish a
connection to MYSQL database using connect(). This requires 4
parameters, the syntax for this is as follows:
<Connection_object> = mysql.connector.connect(host=
<host_name>, user=<username>, passwd =<password> , [database
= <database>])
• where user is the user name
• password is the password of the user
• host_name is IP address. database is the database name of mysql
for example:
## import mysql.connector as sqltor
mycon = sqltor.connect(host ="localhost" , user ="root", passwd
= "mypass", database ="test")
• Step 4. Create a cursor instance.
• Here we have to create an instance of cursor by using cursor(),
the syntax for the following is as follows:
• <cursorobject> =<connectionobject>.cursor()
• i.e; in the above connection we can create cursor() by writing:
• cursor = mycon.cursor()
9
• Step 5. Execute a query: here we use the execute() with
following syntax.
• < cursorobject>.execute(<sql query string>)
• cursor.execute("select*from data)
• Step 6. Extract data from result set. Here you can fetch the
data from the resultset by using fetch( ) functions. [fetchall(),
fetchmany(<n>), fetchone()]
• Step 7. Clean up the environment.
• A database Connection object controls the connection to the
database. It represents a unique session with a database
connected from within a script/program.
10
• A Database Cursor is a special control structure that facilitates
the row by row processing of records in the resultset, i.e., the
set of records retrieved as per query.
• The resultset refers to a logical set of records that are fetched
from the database by executing an SQL query and made
available to the application program.
• You can use connect() method for establishing database
connection, cursor() to create a cursor and execute() to
execute an SQL query.
• For INSERT, UPDATE and DELETE queries, you must run
commit() with the connection object.
11
Creating the connection : connect () method
Pass the database details like HostName, username, and the database password in the
method call. The method returns the connection object.
Syntax :
ConnObject = mysql.connector.connect
(host = <hostname>, user = <username> , passwd = <password> )
import mysql.connector
# Open database connection
conn = mysql.connector.connect(host="localhost",user="root",password="DPS@123",
database='test')
#print connector
print (conn)
RESTART: G:\Ritu Data\Class XII Notes(2019-20)\Ritu python \DBC with Mysql 01.py
<mysql.connector.connection_cext.CMySQLConnection object at 0x0000026A758D5F60>
12
Cursor in Python
Cursors are created by the connection.cursor() method. They are bound to
the connection for the entire lifetime of the program and all the commands
are executed in the context of the database session wrapped by the
connection.
<cur_obj> = conn.cursor()
Note : We need cursor to execute our MySQL Queries
13
To display list of available tables in MySQL
With the help of
execute () one can
run any MySQL
query
('bank',)
('dishes',)
('doctors',)
Showing list of tables ('employee',)
('flights',)
('gadget_details',)
14
We can also create our database through python
Creating
Database
See a new
database
('employees',)
employees is
('information_schema',)
('mt1',) created
output ('mysql',)
('performance_schema',)
('sys',)
15
('test',)
Now , let us create a table ‘Employee’
Creating
table
16
Use of desc <table> to view table structure
output
17
Inserting data into table Employee
Inserting
a record
output
18
In the same way, we can insert multiple records
Inserting many
records by creating
list of tuples
Note that here we have to use executemany() instead of
execute()
output
19
Inserting records by taking its input by user
With INSERT INTO statement, we can
mention the format specifier (%s) in
place of values.
20
Deleting record
Employee Name
whose details
needs be deleted
output
21
Functions used with cursor object
• cursor.fetchall() fetches all the rows of a query result. It returns all
the rows as a list of tuples. An empty list is returned if there is no
record to fetch.
• cursor.fetchmany(size) returns the number of rows specified by
size argument. When called repeatedly this method fetches the
next set of rows of a query result and returns a list of tuples. If no
more rows are available, it returns an empty list.
• cursor.fetchone() method returns a single record or None if no
more rows are available.
22
Selecting Records
The resultset refers to a logical set of records that are fetched. Fetchall will return all the
records retrieved as per the query in a tuple form. RowCount will tell display no. of records
fetched after running the query.
Printing no. of records
23
Use of Fetchone
24
Use of Fetchmany
output
25
Updating Records
26
Updating Records based on Dynamic Column names
Set {} and where {}
format substitutes
the values
27
Rules for parameter insertion
"parameter insertion" is meant for only for values, it will not
work for table names, column names, etc. - for those, the Python
string substitution works fine in the sql syntax defintion
28
