Seminar 2 – Prelucrarea datelor în Python.

Connexiunea cu Oracle Database

Conectarea la baze de date Oracle – pachetul cx_Oracle

Pachetul cx_Oracle conține metode pentru realizarea unei conexiuni cu o bază de date
Oracle, pentru gestiunea interogărilor și a tranzacțiilor (comenzile
SELECT/INSERT/UPDATE/DELETE/MERGE și COMMIT/ROLLBACK).

Configurarea pachetului cx_Oracle. În sălile de seminar mediul de lucru este configurat

corespunzător.

Pachetul se instalează utilizând utilitarul pip:

python -m pip install cx_Oracle --upgrade

Pentru realizarea conexiunii este necesară instalarea clientului Oracle Client 12c
(https://www.oracle.com/database/technologies/instant-client/downloads.html). Versiunea de
Oracle Client trebuie să corespundă versiunii de Oracle Database (a se vedea lista de
compatibilități pe site-ul Oracle) dar și versiunii de Python instalată (32 sau 64 biți).
Instrucțiunile sunt detaliate aici:
https://cx-oracle.readthedocs.io/en/latest/user_guide/installation.html

Pentru realizarea conexiunii cu o bază de date Oracle se precizează userul, parola,

serverul (host/ip) și denumirea bazei de date (service name/SID). De exemplu, pentru
realizarea conexiunii cu serverul oracle care rulează pe IP-ul 37.120.250.20 cu
SERVICE_NAME oracle, nume utilizator student_ps și parola oracle se inițializează
conexiunea următoare:

connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")

Pentru gestiunea interogărilor sau a tranzacțiilor este necesară utilizarea unui cursor:
cursor = connection.cursor()

Obiectul de tip cursor dispune de toate metodele necesare gestiunii tranzacțiilor și procesării
interogărilor.
Metoda Explicații
cursor.execute(comand Execută comanda SQL specificată împreună cu lista de
a SQL, parametri) parametrii. Ca rezultat, în cazul SELECT cursorul este
încărcat cu înregistrările returnate
cursor.close() Închide cursorul și eliberează zona de memorie alocată
cursor.fetchone() Încarcă înregistrările din cursor în variabile locale Python
cursor.fetchmany(n) (de obicei în liste de tupluri)

cursor.fetchall()
cursor.prepare(comanda SQL) Transmite comanda SQL către cursor fără a o executa
cursor.rowcount Returnează numărul de înregistrări parcurse din cursor,
inițial este 0, iar pe măsură ce se utilizează comanda fetch(),

1
Seminar 2 – Prelucrarea datelor în Python. Connexiunea cu Oracle Database

numărul crește.
cursor.bindarraysize Precizează dimensiunea cursorului, utilizată în special la
comanda INSERT
cursor.setinputsizes() Precizează tipurile de date ale parametrilor, utilizată în
special la comanda INSERT
Lista completă a metodelor acestuia este disponibilă aici:
https://cx-oracle.readthedocs.io/en/latest/

Realizarea interogărilor
Pentru exemplificare se utilizează tabelele T_CLIENTI_DAUNE și T_CLIENTI_LEASING
din schema utilizatorului STUDENT_PS.
Vă conectați în SQL Developer utilizând următoarele informații:
Connection Name: Seminar 2

Username: student_ps

Parola: oracle

Server

Host: 37.120.250.20

Port 1521

Service_name: oracle

Vizualizați tabelele T_CLIENTI_DAUNE și T_CLIENTI_LEASING.

Instrucțiunile SELECT sunt executate în cadrul cursorului astfel:

cursor.execute("""SELECT * FROM t_clienti_leasing""")

Cursorul este încărcat cu tuplurile returnate de interogare, parcurgerea putând fi realizată

astfel:

for rec in cursor:

print("Values:", rec)

După prelucrarea cursorului se recomandă închiderea sa, iar la final închiderea conexiunii cu
baza de date:
cursor.close()
connection.close()

Pentru prelucrarea unui cursor se pot utiliza listele de tupluri, înregistrările putând fi încărcate
cu ajutorul metodelor cursorului:
- fetchone() – încarcă o singură înregistrare;
- fetchmany(n) – încarcă n înregistrări;
- fetchall() - încarcă toate înregistrările din cursor.

2
Seminar 2 – Prelucrarea datelor în Python. Connexiunea cu Oracle Database

Exemplul 1. Să se returneze numele, profesia și venitul anual al clientilor care au solicitat

pentru creditare mai mult de 5000 lei.
import cx_Oracle
from pprint import pprint

# Realizarea conexiunii cu serverul Oracle

#Conexiunea - user student_ps, parola oracle, host:37.120.250.20, service_name
oracle
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")
cursor = connection.cursor()
cursor.execute("""SELECT nume_client, profesia, venit_anual FROM
t_clienti_leasing where suma_solicitata>5000""")
lista_clienti=cursor.fetchall()
#inchidere cursor si conexiune
cursor.close()
connection.close()
#afisare lista clienti
pprint (lista_clienti)

Interogări cu parametrii
Parametrii se pot specifica direct în
cadrul metodei execute() sub forma
cursor.execute(comanda SQL, parametri). În cadrul interogării, parametrii se specifica
sub forma :param.
Exemplul 2. Să se returneze valoarea totală a daunelor înregistrate pentru o anumită marcă
auto introdusă de utilizator de la tastatură.
import cx_Oracle
from pprint import pprint

# Realizarea conexiunii cu serverul Oracle

#Conexiunea - user student_ps, parola oracle, hostȘ37.120.250.20, service_name
oracle
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")
cursor = connection.cursor()
v_marca = input("Introduceti marca: ");
cursor.execute("""SELECT marca, sum(valoare_dauna) Total_daune FROM
t_clienti_daune where lower(marca) like :p_marca group by marca""",
p_marca='%'+v_marca.lower()+'%')
lista_daune=cursor.fetchall()
#inchidere cursor si conexiune
cursor.close()
connection.close()
#afisare lista marci cu daune
pprint (lista_daune)

O altă variantă presupune utilizarea metodei prepare () pentru realizarea interogărilor cu

parametri. Aceasta permite realizarea apelurilor multiple folosind valori diferite pentru
parametrii actuali.

Exemplul 3. Să se returneze valoarea totală a daunelor pe fiecare marcă auto, dacă această
valoare este mai mare decât o anumită valoare prag. De la tastatură se va introduce
valoarea prag pentru 2 apeluri succesive.
import cx_Oracle
from pprint import pprint

# Realizarea conexiunii cu serverul Oracle

3
Seminar 2 – Prelucrarea datelor în Python. Connexiunea cu Oracle Database

#Conexiunea - user student_ps, parola oracle, host:37.120.250.20, service_name

oracle
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")
cursor = connection.cursor()

#pregatirea interogarii cu parametru

cursor.prepare("""SELECT marca, sum(valoare_dauna) Total_daune FROM
t_clienti_daune group by marca having sum(valoare_dauna)>:p_val""")

#primul apel
v_val = input("Introduceti valoarea: ")
cursor.execute(None, {'p_val': v_val})
lista_daune=cursor.fetchall()
#afisare lista marci cu daune
pprint (lista_daune)

#al doilea apel

v_val = input("Introduceti valoarea: ")
cursor.execute(None, {'p_val': v_val})
lista_daune=cursor.fetchall()
#afisare lista marci cu daune
pprint (lista_daune)

#inchidere cursor si conexiune

cursor.close()
connection.close()

Gestiunea tranzacțiilor
Operațiile DML (INSERT, UPDATE și DELETE) sunt realizate tot prin intermediul unui
cursor cu ajutorul metodei execute() sub forma cursor.execute(comanda SQL
INSERT/UPDATE/DELETE, parametri).

În cazul INSERT, se pot transmite mai multe înregistrări prin metoda executemany(). În acest
caz se recomandă să se precizeze numărul de înregistrări prin proprietatea bindarraysize și
tipul parametrilor prin metoda setinputsizes.
Tranzacțiile se pot finaliza sau anula prin precizarea opțiunilor COMMIT sau ROLLBACK
ale conexiunii: connection.commit() sau connection.rollback()
Exemplul 4. Să se adauge o listă de tupluri în tabela CLIENTI_NOI care are următoarea
structură: id_client number, nume_client varchar2(150), profesia varchar2(150), sex
varchar2(3), varsta number, stare_civila varchar2(1),suma_solicitata number.

Să se finalizeze tranzacția și apoi să se returneze înregistrările noi adăugate.

Modificați secvența de cod și anulați tranzacția.

import cx_Oracle
from pprint import pprint

# Realizarea conexiunii cu serverul Oracle

#Conexiunea - user student_ps, parola oracle, host 37.120.250.20, service_name
oracle
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")

lista_clienti_noi = [(100, "Popa Marcel", "Inginer", "m", 34, "C", 230),

(101, "Popa Vasilica", "Coafeza", "f", 32, "C", 200),
(102, "Popa Ion", "Instalator", "m", 64, "C", 120)]

cursor = connection.cursor()
#adaugarea listei de clienti noi in tabela

4
Seminar 2 – Prelucrarea datelor în Python. Connexiunea cu Oracle Database

cursor.bindarraysize = 3
cursor.setinputsizes(int, 150, 150, 3, int, 1, float)
cursor.executemany("insert into clienti_noi(id_client, nume_client, profesia,
sex, varsta, stare_civila,suma_solicitata) values (:1, :2, :3, :4, :5, :6, :7)",
lista_clienti_noi)
cursor.close()
#finalizarea tranzactiei
connection.commit()

#interogarea bazei de date pentru vizualizarea inregistrarilor noi adaugate

cursor2 = connection.cursor()
cursor2.execute("""SELECT * from clienti_noi where nume_client like 'Popa%'""")
lista_clienti=cursor2.fetchall()
pprint(lista_clienti)
cursor2.close()
connection.close()

Actualizarea înregistrărilor se realizează cu comanda SQL UPDATE precizată în sub forma

cursor.execute(comanda SQL UPDATE, parametri).
Exemplul 5. Să se majoreze cu 10% suma solicitată de clienții al căror nume este introdus
de utilizator de la tastatură. Actualizările se vor realiza pe tabela tabela CLIENTI_NOI.
Să se finalizeze/anuleze tranzacția și să se re-deschidă un cursor pentru verificarea
rezultatelor tranzacției.
import cx_Oracle
from pprint import pprint
# Realizarea conexiunii cu serverul Oracle
#Conexiunea - user student_ps, parola oracle, host 37.120.250.20, service_name
oracle
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")

cursor = connection.cursor()
#precizarea instructiunii update cu parametru
statement="update clienti_noi set suma_solicitata=suma_solicitata*1.10 where
lower(nume_client) like :p_nume"

v_nume=input("Introduceti numele clientului:")

cursor.execute(statement,p_nume='%'+v_nume.lower()+'%')
cursor.close()

#finalizarea tranzactiei
connection.commit()

#interogarea bazei de date pentru vizualizarea inregistrarilor noi adaugate

cursor2 = connection.cursor()
cursor2.execute("""SELECT * from clienti_noi where lower(nume_client)
like :p_nume""", p_nume='%'+v_nume.lower()+'%')
lista_clienti=cursor2.fetchall()
pprint(lista_clienti)
cursor2.close()
connection.close()

Ștergerea înregistrărilor se realizează cu comanda SQL DELETE precizată sub forma

cursor.execute(comanda SQL DELETE, parametri).

Exemplul 6. Să se șteargă din tabela CLIENTI_NOI clienții cu numele de familie Popa.

Să se finalizeze tranzacția.
import cx_Oracle
# Realizarea conexiunii cu serverul Oracle
#Conexiunea - user student_ps, parola oracle, host 37.120.250.20, service_name
oracle
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")

5
Seminar 2 – Prelucrarea datelor în Python. Connexiunea cu Oracle Database

cursor = connection.cursor()
#stergerea clientilor cu numele Popa
statement="delete from clienti_noi where nume_client like 'Popa%'"
cursor.execute(statement)
cursor.close()
#finalizarea tranzactiei
connection.commit()
connection.close()

In mod implicit, fără specificarea instrucțiunii COMMIT tranzacțiile nu sunt finalizate la

închiderea conexiunii. Pentru finalizarea tranzacțiilor după fiecare instrucțiune DML se poate
seta conexiunea în modul autocommit = true:
connection.autocommit = True

Exemplul 7.
1. În SQL Developer selectați clientul cu numele ‘Hosu%’ din tabela CLIENTI_NOI.
Observați valoarea solicitată.
2. În Python, deschideți conexiunea cu baza de date și vizualizați informațiile referitoare la
clientul cu numele ‘Hosu%’.
import cx_Oracle
from pprint import pprint
# Realizarea conexiunii cu serverul Oracle
#Conexiunea - user student_ps, parola oracle, host 37.120.250.20, service_name
oracle
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")

#interogarea bazei de date pentru vizualizarea inregistrarilor inainte de

actualizare
cursor2 = connection.cursor()
cursor2.execute("""SELECT * from clienti_noi where nume_client like 'Hosu%'""")
lista_clienti=cursor2.fetchall()
pprint(lista_clienti)
cursor2.close()

3. Actualizați suma solicitată cu o valoare introdusă de la tastatură:

cursor = connection.cursor()
#precizarea instructiunii update cu parametru
statement="update clienti_noi set suma_solicitata=:p_suma where nume_client like
'Hosu%'"
v_suma=input("Introduceti suma :")
cursor.execute(statement,p_suma=v_suma)
cursor.close()

4. Vizualizați informațiile despre client:

#interogarea bazei de date pentru vizualizarea inregistrarilor actualizate
cursor2 = connection.cursor()
cursor2.execute("""SELECT * from clienti_noi where nume_client like 'Hosu%'""")
lista_clienti=cursor2.fetchall()
pprint(lista_clienti)
cursor2.close()

5. Închideți conexiunea:
connection.close()

6. În SQL Developer rulați din nou interogarea pentru vizualizarea clientului cu numele
‘Hosu%’ . Observați că valoarea sumei este nemodificată, chiar dacă ultima interogare din
Python a afișat valoarea actualizată. În concluzie, instrucțiunile DML nu sunt finalizate

6
Seminar 2 – Prelucrarea datelor în Python. Connexiunea cu Oracle Database

automat la închiderea conexiunii, însă pe durata acesteia, actualizările realizate sunt

vizibile până la final pentru utilizatorul conectat.
Rulați din nou codul Python și observați că initial valoarea sumei este nemodificată.

7. Finalizați tranzacția înainte de închiderea conexiunii.

#finalizarea tranzactiei
connection.commit()

Exemplul 8:
1.Deschideți conexiunea cu baza de date Oracle și adăugați un nou client în tabela
CLIENTI_NOI, introducând id-ul de la tastatură:
import cx_Oracle
from pprint import pprint

# Realizarea conexiunii cu serverul Oracle

#Conexiunea - user student_ps, parola oracle, host 37.120.250.20, service_name
oracle
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")

#adaugarea listei de clienti noi in tabela

lista_info_client = [ "Popa Marcel", "Inginer", "m", 34, "C", 230]
v_id=input("Introduceti id-ul noului angajat :")
lista_info_client.insert(0,v_id)

statement="insert into clienti_noi(id_client, nume_client, profesia, sex, varsta,

stare_civila,suma_solicitata) values ( :1, :2, :3, :4, :5, :6, :7)"
cursor = connection.cursor()
cursor.execute(statement, lista_info_client)
cursor.close()

2. Setați autocommit pe valoarea True:

#schimbarea modului de finalizare a tranzactiei
connection.autocommit=True

3. Majorați suma solicitată cu 10 lei pentru clientul nou introdus:

#actualizarea sumei solicitate pentru clientul nou introdus
cursor2 = connection.cursor()
statement2="update clienti_noi set suma_solicitata=suma_solicitata+10 where
id_client =:p_id"
cursor2.execute(statement2,p_id=v_id)
cursor2.close()

4. Folosind o interogare SQL vizualizați printr-o listă datele referitoare la clientul nou
introdus:
#interogarea bazei de date pentru vizualizarea inregistrarilor noi adaugate
cursor3 = connection.cursor()
cursor3.execute("""SELECT * from clienti_noi where id_client =:p_id""",
p_id=v_id)
lista_clienti=cursor3.fetchall()
pprint(lista_clienti)
cursor3.close()
connection.close()

5. In SQL Developer vizualizați înregistrarea nou introdusă și observați modificările

realizate. În concluzie, setarea modului autocommit pe valoare True finalizează ambele
operații DML.

6. Modificați codul de mai sus folosind opțiunile pentru connection.autocommit astfel

încât doar prima instrucțiune DML să fie salvată automat în baza de date:

7
Seminar 2 – Prelucrarea datelor în Python. Connexiunea cu Oracle Database

import cx_Oracle
from pprint import pprint
# Realizarea conexiunii cu serverul Oracle
#Conexiunea - user student_ps, parola oracle, host 37.120.250.20, service_name
oracle
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")

#adaugarea listei de clienti noi in tabela

lista_info_client = [ "Popa Marcel", "Inginer", "m", 34, "C", 230]
v_id=input("Introduceti id-ul noului angajat :")
lista_info_client.insert(0,v_id)

statement="insert into clienti_noi(id_client, nume_client, profesia, sex, varsta,

stare_civila,suma_solicitata) values ( :1, :2, :3, :4, :5, :6, :7)"
#schimbarea modului de finalizare a tranzactiei
connection.autocommit=True
cursor = connection.cursor()
cursor.execute(statement, lista_info_client)
cursor.close()

#schimbarea modului de finalizare a tranzactiei

connection.autocommit=False
#actualizarea sumei solicitate pentru clientul nou introdus
cursor2 = connection.cursor()
statement2="update clienti_noi set suma_solicitata=suma_solicitata+10 where
id_client =:p_id"
cursor2.execute(statement2,p_id=v_id)
cursor2.close()

#interogarea bazei de date pentru vizualizarea inregistrarilor noi adaugate

cursor3 = connection.cursor()
cursor3.execute("""SELECT * from clienti_noi where id_client =:p_id""",
p_id=v_id)
lista_clienti=cursor3.fetchall()
pprint(lista_clienti)
cursor3.close()
connection.close()

Apelul procedurilor și funcțiilor PL/SQL din Python

Pentru apelul procedurilor PL/SQL stocate în baza de date se utilizează instrucțiunea
cursor.callproc("nume_procedura PL/SQL", lista_parametrii), iar pentru apelul
funcțiilor PL/SQL se utilizează instrucțiunea:
cursor.callfunc("nume functie PL/SQL", tip_returnat, lista_parametrii)

Exemplul 9: Se consideră funcția PL/SQL f_calcul_prescoring (p_id_client

t_clienti_leasing.id_client%type) stocată în baza de date pentru calculul
prescoringului unui client în funcție de venitul anual, valoarea creditelor, vârstă și suma din
depozite. Funcția este creată în schema student_ps și poate fi vizualizată în SQL Developer
din Object Browser->Functions:
create or replace function f_calcul_prescoring (p_id_client
t_clienti_leasing.id_client%type)
return number
is
v_prescoring number(2);
r t_clienti_leasing%rowtype;
begin
select * into r from t_clienti_leasing where id_client=p_id_client;
case

8
Seminar 2 – Prelucrarea datelor în Python. Connexiunea cu Oracle Database

when r.venit_anual between 0 and 5000 and r.val_credite_ron<-10000 and

r.varsta>50 and r.suma_depozit=0 then v_prescoring:=1;
when r.venit_anual between 5000 and 10000 and r.val_credite_ron between -
10000 and -5000 and r.varsta between 40 and 50 and r.suma_depozit=0 then
v_prescoring:=2;
when r.venit_anual between 10000 and 15000 and r.val_credite_ron between -
5000 and 0 and r.varsta between 30 and 40 and r.suma_depozit>0 then
v_prescoring:=3;
when r.venit_anual > 15000 and r.val_credite_ron = 0 and r.varsta between 25
and 50 and r.suma_depozit>0 then v_prescoring:=4;
else v_prescoring:=0;
end case;
return v_prescoring;
end f_calcul_prescoring;

1. În Python deschideți conexiunea cu baza de date și vizualizați datele referitoare la

clientul cu numele Hartig Paula din tabela T_CLIENTI_LEASING:
import cx_Oracle
# Realizarea conexiunii cu serverul Oracle
#Conexiunea - user student_ps, parola oracle, host 37.120.250.20, service_name
oracle
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")

#interogarea bazei de date pentru vizualizarea clientului

cursor = connection.cursor()
cursor.execute("""SELECT * from t_clienti_leasing where nume_client ='Hartig
Paula'""")
lista_clienti=cursor.fetchall()
print(lista_clienti)
cursor.close()

2. Obțineți id-ul clientului și apelați funcția PL/SQL pentru a calcula prescoringul:

#afisare id client
print ("ID-ul este ", list(lista_clienti[0])[0])
v_id=list(lista_clienti[0])[0]
#apel functie PL/SQL
cursor2 = connection.cursor()
returnVal = cursor2.callfunc("f_calcul_prescoring ", int, [v_id])
print("Prescoringul este " + str(returnVal))
cursor2.close()
connection.close()

Exemplul 10: Se consideră funcția PL/SQL f_grad_indatorare (p_venit_anual_ron

number, p_val_credite_ron number, p_suma_depozit number,
p_suma_solicitata number) stocată în baza de date pentru calculul gradului de
îndatorare al unui client în funcție de venitul anual, valoarea creditelor, suma solicitată și
suma din depozite. Funcția este creată în schema student_ps și poate fi vizualizată în SQL
Developer din Object Browser->Functions:
create or replace function f_grad_indatorare (p_venit_anual_ron number,
p_val_credite_ron number, p_suma_depozit number, p_suma_solicitata number)
return number
is
v_grad_indatorare number;

begin
return p_suma_solicitata/ (p_venit_anual_ron-abs(p_val_credite_ron)
+p_suma_depozit);
end f_grad_indatorare;

În Python deschideți conexiunea și folosind o interogare SQL afișați gradul de îndatorare

pentru clienții cu venitul anual mai mare decât 100000. Observați faptul că apelul funcției

9
Seminar 2 – Prelucrarea datelor în Python. Connexiunea cu Oracle Database

f_grad_indatorare este inclus în instrucțiunea SELECT:

import cx_Oracle
from pprint import pprint
# Realizarea conexiunii cu serverul Oracle
#Conexiunea - user student_ps, parola oracle, host 37.120.250.20, service_name
oracle
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")

#interogarea bazei de date pentru vizualizarea clientului

cursor = connection.cursor()
cursor.execute("""select id_client, nume_client, venit_anual, val_credite_ron,
suma_depozit, varsta, round(f_grad_indatorare (venit_anual_ron ,
val_credite_ron , suma_depozit , suma_solicitata),2) grad_indatorare from
t_clienti_leasing
where venit_anual>100000""")
lista_clienti=cursor.fetchall()
pprint(lista_clienti)
cursor.close()
connection.close()

Utilizarea pachetului Pandas pentru interacțiunea cu baza de date Oracle

Înregistrările returnate de o interogare SQL se pot încărca direct într-un DataFrame Pandas
prin metoda pandas.read_sql(comanda SQL, conexiunea, lista de parametrii).
În acest caz nu mai este necesară încărcarea înregistrărilor în cursor, acestea fiind gestionate
automat de către DataFrame.
Exemplul 11. Să se selecteze din tabela T_CLIENTI_DAUNE marca, modelul, anul de
fabricație, componenta, prețul manoperei și valoarea daunei pentru autoturismele mai noi
de 2010.
import pandas as pd
import cx_Oracle
from pprint import pprint

# Connect to oracle.
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")

#incarcam in DataFrame inregistrarile returnate de SELECT

an=2010
query ="""Select marca, model, an_fabricatie, componenta, pret_manopera,
valoare_dauna
from t_clienti_daune
where an_fabricatie>:an"""
df = pd.read_sql(query, con=connection, params={'an': an})
pprint(df)

connection.close()

Exemplul 12. În exemplul de mai sus să se adauge o nouă coloană în df pentru a calcula
ponderea manoperei din valoarea totală a daunei. Să se afișeze marca și componentele
înlocuite în cazul în care ponderea manoperei depășește 30% din valoarea daunei.
import pandas as pd
import cx_Oracle
from pprint import pprint

# Connect to oracle.
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")

#incarcam in DataFrame inregistrarile returnate de SELECT

an=2010
query ="""Select marca, model, an_fabricatie, componenta, pret_manopera,
valoare_dauna
from t_clienti_daune

10
Seminar 2 – Prelucrarea datelor în Python. Connexiunea cu Oracle Database

where an_fabricatie>:an"""
df = pd.read_sql(query, con=connection, params={'an': an})
connection.close()

df["PROCENT"]= df["PRET_MANOPERA"]/ df["VALOARE_DAUNA"]*100

pprint(df.loc[(df["PROCENT"]>30), ["MARCA","COMPONENTA"]])

Determinarea timpului de execuție

Exemplul 13. Determinăm timpul de execuție pentru 2 variante de prelucrare a datelor:
varianta 1 – utilizând pandas pentru calculul gradului de îndatorare
varianta 2 – apelăm funcția PL/SQL f_grad_indatorare

Deschideți conexiunea cu baza de date

import pandas as pd
import cx_Oracle
from pprint import pprint
import time
# Connect to oracle.
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")

Varianta 1:
Rețineți într-o variabilă timpul curent (se va importa pachetul time).
Încărcați într-un df numele, venitul anual, valoarea creditelor, suma din depozite și suma
solicitată pentru clienții cu venitul anual mai mare decât 150000.
În df adăugați o nouă coloană pentru a calcula gradul de îndatorare.
Afișați setul de date din df.
Calculați timpul de execuție
#varianta 1
start = time.time()
#incarcam in DataFrame inregistrarile returnate de SELECT
venit=150000
query ="""select nume_client, suma_solicitata,venit_anual_ron, val_credite_ron,
suma_depozit, varsta from t_clienti_leasing
where venit_anual>:venit"""
df = pd.read_sql(query, con=connection, params={'venit': venit})
df["GRAD_INDATORARE"]=round(df["SUMA_SOLICITATA"]/ (df["VENIT_ANUAL_RON"]-
abs(df["VAL_CREDITE_RON"])+df["SUMA_DEPOZIT"]),2)
pprint(df)
timp_executie = (time.time() - start)
print (timp_executie, " seconds")

Varianta 2:
Rețineți într-o variabilă timpul curent
Încărcați într-un df numele, venitul anual, valoarea creditelor, suma din depozite, suma
solicitată și gradul de îndatorare calculat cu funcția PL/SQL f_grad_indatorare pentru
clienții cu venitul anual mai mare decât 150000.
Afișați setul de date din df.
Calculați timpul de execuție.
#varianta 2
start = time.time()
#incarcam in DataFrame inregistrarile returnate de SELECT
venit=150000
query ="""select nume_client, suma_solicitata, venit_anual_ron, val_credite_ron,
suma_depozit, varsta, round(f_grad_indatorare (venit_anual_ron ,
val_credite_ron , suma_depozit , suma_solicitata),2) grad_indatorare from
t_clienti_leasing
where venit_anual>:venit"""

11
Seminar 2 – Prelucrarea datelor în Python. Connexiunea cu Oracle Database

df = pd.read_sql(query, con=connection, params={'venit': venit})

pprint(df)
timp_executie = (time.time() - start)
print (timp_executie, " seconds")

Închideți conexiunea.
connection.close()

Varianta 2 se execută mai repede dacă funcția PL/SQL este deja încărcată în SGA (System
Global Area - memoria internă a SGBD). Încărcarea funcției în SGA se realizează automat
la primul apel al acesteia.

Exemplul 14. Determinăm timpul de execuție pentru 2 variante de prelucrare a datelor.

Deschideți conexiunea cu baza de date
import pandas as pd
import cx_Oracle
from pprint import pprint
import time
# Connect to oracle.
connection = cx_Oracle.connect("student_ps", "oracle", "37.120.250.20/oracle")

Varianta 1:
Rețineți într-o variabilă timpul curent
Încărcăm într-un df numele, vârsta, profesia, venitul anual, suma solicitată și prescoringul
din tabela T_CLIENTI_LEASING..
Folosind metoda loc din pandas afișați numele, suma solicitată și prescoringul doar pentru
clienții cu vârsta < 40 ani, au venitul anual > 10000 și profesia Inginer sau Profesor.
Calculați timpul de execuție.
#varianta 1
start = time.time()
#incarcam in DataFrame inregistrarile returnate de SELECT

query ="""select nume_client, varsta , profesia, venit_anual_ron,

suma_solicitata, prescoring from t_clienti_leasing"""
df = pd.read_sql(query, con=connection)

print(df.loc[(df['VARSTA'] < 40)&(df['VENIT_ANUAL_RON'] > 10000)&

(df['PROFESIA'].isin(['Inginer', 'Profesor'])), ['NUME_CLIENT',
'SUMA_SOLICITATA','PRESCORING']])
timp_executie = (time.time() - start)
print (timp_executie, " seconds")

Varianta 2:
Rețineți într-o variabilă timpul curent
Folosind clauza WHERE din instrucțiunea SELECT încărcăm într-un df numele, vârsta,
profesia, venitul anual, suma solicitată și prescoringul doar pentru clienții cu vârsta < 40
ani, au venitul anual > 10000 și profesia Inginer sau Profesor.
Folosind metoda loc din pandas afișați numele, suma solicitată și prescoringul pentru setul
de date.
Calculați timpul de execuție.
#varianta 2
start = time.time()
#incarcam in DataFrame inregistrarile returnate de SELECT
query ="""select nume_client, varsta , profesia, venit_anual_ron,
suma_solicitata, prescoring from t_clienti_leasing
where varsta<40 and venit_anual_ron>10000 and profesia in ('Inginer',
'Profesor')"""
df = pd.read_sql(query, con=connection)

12
Seminar 2 – Prelucrarea datelor în Python. Connexiunea cu Oracle Database

pprint(df.loc[:, ['NUME_CLIENT', 'SUMA_SOLICITATA','PRESCORING']])

timp_executie = (time.time() - start)
print (timp_executie, " seconds")

Închideți conexiunea:
connection.close()

Pentru a reduce timpul de execuție, se recomandă limitarea setului de date adus din baza de
date prin utilizarea instrucțiunilor specifice SQL.

Exerciții propuse:
1. Să se returneze într-un df componenta, anul de fabricatie și pretul manoperei pentru
autoturismele Ford și Jeep. Pe setul din df, majorați cu 10% pretul manoperei pentru
autoturismele fabricate inainte de 2010 și care au componenta BATTERY defectă.
Salvați modificările într-un fișier .csv.
2. Încărcați într-un df marca, modelul, valoarea medie și numărul de daune pe fiecare
model și marcă. Afișați numărul de autoturisme pentru care valoarea medie depășește
400 lei. Reprezentați grafic modelele care au înregistrat mai mult de 200 de daune.
3. Încărcați într-un df numele, suma solicitată, suma din depozite și fidelitatea clienților
cu vârsta > 30 de ani care au solicitat un credit mai mare de 10.000 lei. Verificați în df
dacă suma din depozit este mai mare decât suma solicitată și pentru acești clienți
modificați fidelitatea în 5 (doar în df).
4. Încărcați într-un df profesia, venitul anual, suma din depozite și suma solicitată pe
fiecare profesie. În df adăugați o nouă coloană pentru a calcula gradul de îndatorare
pe fiecare profesie (suma_solicitata/(venit_anual+suma_depozit)*100).
5. Încărcați într-un df starea civilă, profesia și suma totală solicitată grupată în funcție de
aceste atribute. Introduceți de la tastatură profesia și pentru aceasta reprezentați grafic
suma solicitată în funcție de starea civilă.

13
Seminar 2 – Prelucrarea datelor în Python. Connexiunea cu Oracle Database

Referințe
1 Using Python with Oracle Database 11g

- https://www.oracle.com/technetwork/articles/dsl/python-091105.html
2 Developing a Python Web Application with Oracle Database 11g

https://www.oracle.com/webfolder/technetwork/tutorials/obe/db/OOW11/
python_django/python_django.htm
3 https://learncodeshare.net/2015/06/26/insert-crud-using-cx_oracle/
4 https://cx-oracle.readthedocs.io/en/latest/user_guide/sql_execution.html

14