3 PYTHON INTERACTION WITH SQLITE (concept of python)

PYTHON INTERACTION
WITH SQLITE
BY AMIT PATEL

IMPORTING MODULE
• “Import” statement imports the sqlite3 module in the program.
• Using the classes and methods defined in the sqlite3 module we can communicate with the
SQLite database.
• Import in python is similar to #include header_file in C/C++.
• Python modules can get access to code from another module by importing the file/function
using import.
• When the import is used, it searches for the module initially in the local scope by calling
__import__() function.
import module_name

IMPORTING MODULE
• For example:
import math
print(math.pi)
import module_name.member_name
• In the above code module, math is imported, and its variables can be accessed by considering
it to be a class and pi as its object.
• The value of pi is returned by __import__().
• pi as a whole can be imported into our initial code, rather than importing the whole module.

IMPORTING MODULE
• For example:
from math import pi
# Note that in the above example,
# we used math.pi. Here we have used
# pi directly.
print(pi)
from module_name import *
• In the above code module, math is not imported, rather just pi has been imported as a variable.
• All the functions and constants can be imported using *.

CONNECT() AND EXECUTE()
• Connecting to the SQLite Database can be established using the connect() method, passing the
name of the database to be accessed as a parameter.
• If that database does not exist, then it’ll be created.
sqliteConnection = sqlite3.connect('sql.db')
• But what if you want to execute some queries after the connection is being made.
• For that, a cursor has to be created using the cursor() method on the connection instance,
which will execute our SQL queries.
cursor = sqliteConnection.cursor()
print('DB Init')

CONNECT() AND EXECUTE()
• The SQL query to be executed can be written in form of a string, and then executed by calling
the execute() method on the cursor object.
• Then, the result can be fetched from the server by using the fetchall() method, which in this
case, is the SQLite Version Number.
query = 'SQL query;'
cursor.execute(query)
result = cursor.fetchall()
print('SQLite Version is {}'.format(result))

FETCHALL( ) & FETCHONE( )
• fetchall(), fetchmany(), and fetchone( ) to retrieve data from MySQL, PostgreSQL, SQLite
database.
• 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.

FETCHALL( )
To fetch all rows from a database table, you need to follow these simple steps: –
• Create a database Connection from Python.
• Define the SELECT query. Here you need to know the table and its column details.
• Execute the SELECT query using the cursor.execute() method.
• Get resultSet (all rows) from the cursor object using a cursor.fetchall().
• Iterate over the ResultSet using for loop and get column values of each row.
• Close the Python database connection.
• Catch any SQL exceptions that may come up during the process.

FETCHALL( )
import sqlite3
def getAllRows():
try:
connection = sqlite3.connect('SQLite_Python.db')
cursor = connection.cursor()
print("Connected to SQLite")
sqlite_select_query = """SELECT * from database_developers"""
cursor.execute(sqlite_select_query)
records = cursor.fetchall()

FETCHALL( )
print("Total rows are: ", len(records))
print("Printing each row")
for row in records:
print("Id: ", row[0])
print("Name: ", row[1])
print("Email: ", row[2])
print("Salary: ", row[3])
print("n")
cursor.close()
except sqlite3.Error as error:
print("Failed to read data from table", error)
finally:
if connection:
connection.close()
print("The Sqlite connection is closed")
getAllRows() //function call to get all row

FETCHMANY()
• Retrieve a few rows from a table.
• Here size is the number of rows to be retrieved.
• 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’s fetchmany() method returns the number of rows specified by size argument. Default
value is 1. If the specified size is 100, then it returns 100 rows.
• Let try to fetch 3 rows from table using a cursor.fetchmany(size)
rows = cursor.fetchmany([size=cursor.arraysize])

FETCHMANY( )
import sqlite3
def getlimitedRows(size):
try:
print("Connected to database")
records = cursor.fetchmany(size)

FETCHMANY( )
print("Fetching Total ", size," rows")
print("Printing each row")
for row in records:
print("Id: ", row[0])
print("Name: ", row[1])
print("Email: ", row[2])
print("Salary: ", row[3])
print("n")
cursor.close()
finally:
if (connection):
connection.close()
getlimitedRows(3) // function call to get 3 row

FETCHONE()
• Retrieve only single rows from a table.
• It can return a none if no rows are available in the result set.
• cursor.fetchone() increments the cursor position by one and return the next row.
rows = cursor.fetchone( )

FETCHONE( )
import sqlite3
def getSingleRows():
try:
print("Connected to database")
print("Fetching single row")

FETCHONE( )
record = cursor.fetchone()
print(record)
print("Fetching next row")
record = cursor.fetchone()
print(record)
cursor.close()
finally:
if connection:
connection.close()
getSingleRows() // get single row

CRUD OPERATION USING EXECUTE( )
• Retrieve only single rows from a table.
• It can return a none if no rows are available in the result set.
• cursor.fetchone() increments the cursor position by one and return the next row.
rows = cursor.fetchone( )

STEPS TO CONNECT WITH SQLITE DATABASE
• Import sqlite3 module.
• Use the connect( ) method.
• Use the cursor( ) method.
• Use the execute( ) method.
• Extract result using fetchall( ).
• Close cursor and connection objects.
• Catch database exception if any that may occur during connection process.

CREATE SQLITE TABLE FROM PYTHON
Steps for create a table in SQLite from Python: –
• Connect to SQLite using a sqlite3.connect().
• Prepare a create table query.
• Execute the query using a cursor.execute(query)

CREATE SQLITE TABLE FROM PYTHON
import sqlite3
try:
sqliteConnection = sqlite3.connect('SQLite_Python.db')
sqlite_create_table_query = '''CREATE TABLE SqliteDb_developers (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
email text NOT NULL UNIQUE,
joining_date datetime,
salary REAL NOT NULL);'''

FETCHONE( )
print("Successfully Connected to SQLite")
cursor.execute(sqlite_create_table_query)
sqliteConnection.commit()
print("SQLite table created")
cursor.close()
print("Error while creating a sqlite table", error)
finally:
if sqliteConnection:
sqliteConnection.close()
print("sqlite connection is closed")

INSERT OPERATION
• Connect to SQLite from Python
• Define a SQL Insert query
• Get Cursor Object from Connection
• Execute the insert query using execute() method
• Commit your changes
• Get the number of rows affected
• Verify result using the SQL SELECT query
• Close the cursor object and database connection object

INSERT
import sqlite3
try:
print("Successfully Connected to SQLite")
sqlite_insert_query = """INSERT INTO SqliteDb_developers
(id, name, email, joining_date, salary)
VALUES
(1,'James','james@pynative.com','2019-03-17',8000)"""

INSERT
count = cursor.execute(sqlite_insert_query)
print("Record inserted successfully into SqliteDb_developers table ", cursor.rowcount)
cursor.close()
print("Failed to insert data into sqlite table", error)
finally:
print("The SQLite connection is closed")

INSERT OPERATION USING PYTHON VARIABLE
• Sometimes we need to insert a Python variable value into a table’s column.
• This value can be anything, including integer, string, float, and DateTime.
• For example, in the registration form person enter his/her details. You can take those values
in Python variables and insert them into the SQLite table.
• We use a parameterized query to insert Python variables into the table.
• Using a parameterized query, we can pass python variables as a query parameter in which
placeholders (?)

import sqlite3
def insertVaribleIntoTable(id, name, email, joinDate, salary):
try:
sqlite_insert_with_param = """INSERT INTO SqliteDb_developers
VALUES (?, ?, ?, ?, ?);"""

data_tuple = (id, name, email, joinDate, salary)
cursor.execute(sqlite_insert_with_param, data_tuple)
print("Python Variables inserted successfully into SqliteDb_developers table")
cursor.close()
print("Failed to insert Python variable into sqlite table", error)

finally:
insertVaribleIntoTable(2, 'Joe', 'joe@pynative.com', '2019-05-19', 9000)
insertVaribleIntoTable(3, 'Ben', 'ben@pynative.com', '2019-02-23', 9500)

INSERT MULTIPLE ROW
• Sometimes we need to insert multiple rows into the table in a single insert query.
• For example, You wanted to add all records from the CSV file into the SQLite table.
• Instead of executing the INSERT query every time to add each record, you can perform a
bulk insert operation in a single query using a cursor’s executemany() function.
• The executemany() method takes two arguments SQL query and records to update.

INSERT MULTIPLE ROW
import sqlite3
def insertMultipleRecords(recordList):
try:
sqlite_insert_query = """INSERT INTO SqliteDb_developers
VALUES (?, ?, ?, ?, ?);"""

INSERT MULTIPLE ROW
cursor.executemany(sqlite_insert_query, recordList)
print("Total", cursor.rowcount, "Records inserted successfully into SqliteDb_developers table")
cursor.close()
print("Failed to insert multiple records into sqlite table", error)

INSERT MULTIPLE ROW
finally:
recordsToInsert = [(4, 'Jos', 'jos@gmail.com', '2019-01-14', 9500),
(5, 'Chris', 'chris@gmail.com', '2019-05-15', 7600),
(6, 'Jonny', 'jonny@gmail.com', '2019-03-27', 8400)]
insertMultipleRecords(recordsToInsert)

UPDATE
• Most of the time, we need to update a table with some runtime values.
• For example, when users update their profile or any other details through a user interface,
we need to update a table with those new values.
• In such cases, It is always best practice to use a parameterized query.
• The parameterized query uses placeholders (?) inside SQL statements that contain input
from users.
• It helps us to update runtime values and prevent SQL injection concerns.

UPDATE
import sqlite3
def updateSqliteTable(id, salary):
try:
sql_update_query = """Update SqliteDb_developers set salary = ? where id = ?"""
data = (salary, id)
cursor.execute(sql_update_query, data)

UPDATE
print("Record Updated successfully")
cursor.close()
print("Failed to update sqlite table", error)
finally:
print("The sqlite connection is
closed")
updateSqliteTable(3, 7500)

UPDATE
• We used two placeholders in the update query, one for the salary column and the other is
for the id column.
• Next, We prepared a data tuple by specifying two Python variables in sequential order.
• Next, we passed the SQL update query and data tuple to the cursor.execute() method.
Remember variables order in the tuple is sequential as per column placeholders order.

UPDATE MULTIPLE ROW USING CURSOR
• In the above example, we have used execute() method of cursor object to update a single
record. But sometimes, we need to update multiple rows of the SQLite table.
• For example, you want to increase the salary of developers by 20%.
• Instead of executing the UPDATE query every time to update each record, you can perform
bulk update operations in a single query using the cursor.executemany() method.
• The executemany(query, seq_param) method accepts the following two parameters
• SQL query
• list of records to be updated.

import sqlite3
def updateMultipleRecords(recordList):
try:
sqlite_update_query = """Update SqliteDb_developers set salary = ? where id = ?"""
cursor.executemany(sqlite_update_query, recordList)

print("Total", cursor.rowcount, "Records updated
successfully")
cursor.close()
print("Failed to update multiple records of sqlite table", error)

finally:
records_to_update = [(9700, 4), (7800, 5), (8400, 6)]
updateMultipleRecords(records_to_update)

• We prepared the SQLite update query with two placeholders (“salary” and “Id” column ) and
a list of records to update in tuple format.
• Each element of a list is nothing but a tuple for each row. Each tuple contains two values, i.e.,
salary and id of a developer.
• We passed SQLite update query and record list to executemany() as arguments.
• To get to know the number of records updated, we used a cursor.rowcount function.

DELETE
• In order to delete data in the SQLite database from a Python program, you use the following
steps:
• First, establish a connection the SQLite database by creating a Connection object using the
connect() function.
• Second, to execute a DELETE statement, you need to create a Cursor object using the
cursor() method of the Connection object.
• Third, execute the DELETE statement using the execute() method of the Cursor object. In
case you want to pass the arguments to the statement, you use a question mark (?) for each
argument.

EXAMPLE:
#import the module.
import sqlite3;
#Use the connect( ) method for open or create a database
con = sqlite3.connect("MyDB.db")
print("Database Created")
#Use the cursor( ) method using connection object
cur = con.cursor()
#create a table using execute() method
createtbl = "create table test(ID int primary key, name text not null, total int not null)"
con.execute(createtbl)
print("Table Created")

INSERT DATA
#insert the data using execute() method
insertquery = "insert into test values(1,'Nidhi',78);"
con.execute(insertquery)
print("data inserted", con.total_changes)
#take input from user to insert data into table.
id1 = input("Enter ID:")
name = input("Enter Name:")
total = input("Enter Total:")
con.execute("insert into test values(?,?,?)", (id1,name,total))

INSERT MULTIPLE DATA
#insert multiple data into table using executemany() method.
records = [(3,'mnp',33), (4,'pqr',67),(6,'wxy',88)]
con.executemany("insert into test values(?,?,?)", records)

UPDATE DATA
#update the data using execute() method
updatequery = "update test set total=90 where id=1"
con.execute(updatequery)
print("data updated", con.total_changes)
#take input from user to update data into table.
idtoupadte = input("Enter id:")
con.execute("update test set total=99 where id=?", idtoupadte)

UPDATE DATA
#take multiple input from user to update data.
updatename=input("enter update name:")
updateid = input("enter id:")
con.execute("update test set name=? where id=?",(updatename,updateid))
#update multiple data into table using executemany() method.
updatedata = [('priya',55,3),
('payal', 56,4),
('pritam',57,6)]
con.executemany("update test set name=?, total=? where id=?",updatedata)

DELETE DATA
#delete data from table using execute() method
deletequery = "delete from test where id=1"
con.execute(deletequery)
print("data deleted", con.total_changes)
#take input from user to delete data into table.
deleteid = input("Enter id:")
con.execute("delete from test where id=?",deleteid)
print("data deleted", con.total_changes)

SELECT DATA
#select data from table usinf cursor() object and print the data using for loop.
data = con.execute("SELECT * from test")
for row in data:
print ("ID = ", row[0])
print ("NAME = ", row[1])
print ("TOTAL = ", row[2])

SELECT DATA- FETCHALL()
#use the fetchall() method to get all data.
cur.execute("select * from test")
data1 = cur.fetchall()
for row in data1:
print ("ID = ", row[0])
print ("NAME = ", row[1])
print ("TOTAL = ", row[2])

SELECT DATA- FETCHONE() AND FECTHMANY()
#use fetchone() to get a single record
data2 =cur.fetchone()
print(data2)
#use fetchmany() method to get number of data record
data3 = cur.fetchmany(2)
print(data3)

EXAMPLE
#print the list of tables of database
print("List of tables:")
cur.execute("SELECT * FROM sqlite_master WHERE type='table';")
print(cur.fetchall())
#print the structure of a table.
a= con.execute("PRAGMA table_info('test')")
print("nTable structure of test:", a)
for i in a:
print(i)

EXAMPLE
#print the foreign keys in database
rows=cur.execute('pragma foreign_keys')
for r in rows:
print (r)
#use commit() method at last to save changes in your table
con.commit()
#use close() method to close the connection
con.close()

WHAT IS EXCEPTION?
• An exception is an event, which occurs during the execution of a program that disrupts the
normal flow of the program's instructions. In general, when a Python script encounters a
situation that it cannot cope with, it raises an exception. An exception is a Python object that
represents an error.
• When a Python script raises an exception, it must either handle the exception immediately
otherwise it terminates and quits.

HANDLING AN EXCEPTION?
• If you have some suspicious code that may raise an exception, you can defend your
program by placing the suspicious code in a try: block. After the try: block, include an
except: statement, followed by a block of code which handles the problem as elegantly as
possible.

HANDLING AN EXCEPTION?
• The try block lets you test a block of code for errors.
• The except block lets you handle the error.
• The else block lets you execute code when there is no error.
• The finally block lets you execute code, regardless of the result of the try- and except blocks.
• When an error occurs, or exception as we call it, Python will normally stop and generate an
error message.
• These exceptions can be handled using the try statement:

TRY EXCEPT
• This statement will raise an error, because x is not defined:
print(x)
• If we write below statement then it print a error statement rather than throw a error.
try:
print(x)
except:
print("An exception occurred")
Output:
An exception occurred

MANY EXCEPTION
• You can define as many exception blocks as you want, e.g. if you want to execute a special block
of code for a special kind of error:
try:
print(x)
except NameError:
print("Variable x is not defined")
except:
print("Something else went wrong")
Output:
Variable x is not defined
• Print one message if the try block raises a NameError and another for other errors:

ELSE
• You can use the else keyword to define a block of code to be executed if no errors were
raised:
try:
print("Hello")
except:
print("Something went wrong")
else:
print("Nothing went wrong")
Output:
Hello
Nothing went wrong

FINALLY
• The finally block, if specified, will be executed regardless if the try block raises an error or
not. try:
print(x)
except:
print("Something went wrong")
finally:
print("The 'try except' is finished")
Output:
Something went wrong
The 'try except' is finished

3 PYTHON INTERACTION WITH SQLITE (concept of python)

Recommended

More Related Content

Similar to 3 PYTHON INTERACTION WITH SQLITE (concept of python) (20)

Recently uploaded (20)

3 PYTHON INTERACTION WITH SQLITE (concept of python)