[Introduction à cx_Oracle] (Partie 11) Bases de l'exécution PL / SQL

Table de sérialisation

Série: Introduction à cx_Oracle Contents

Environnement de vérification

--Utilisation d'Oracle Cloud

• Oracle Linux 7.7 (VM.Standard2.1)
• Python 3.6
• cx_Oracle 8.0
• Oracle Database 19.5 (ATP, 1OCPU)
• Oracle Instant Client 18.5

Exécuter PL / SQL anonyme

Le PL / SQL anonyme peut être exécuté avec la méthode execute () de l'objet Cursor comme toute autre instruction SQL. Voici un exemple. Comme l'exemple, des variables de liaison sont également disponibles.

sample11a.py

import cx_Oracle

USERID = "admin"
PASSWORD = "FooBar"
DESTINATION = "atp1_low"
SQL = """
begin
  :out_value := :in_value * 2;
end;
"""

with cx_Oracle.connect(USERID, PASSWORD, DESTINATION) as connection:
        with connection.cursor() as cursor:
                outValue = cursor.var(int)
                cursor.execute(SQL, [outValue, 111])
                print(outValue.getvalue())

Exécution de la procédure stockée

Il existe deux types de méthodes d'exécution pour stocker les procédures stockées.

Utilisez la méthode Cursor.callproc ()

sample11b.py

import cx_Oracle

USERID = "admin"
PASSWORD = "FooBar"
DESTINATION = "atp1_low"
SQL = """
create or replace procedure sample11b(in_value in number, out_value out number) is
begin
  out_value := in_value * 2;
end;
"""

with cx_Oracle.connect(USERID, PASSWORD, DESTINATION) as connection:
        with connection.cursor() as cursor:
                outValue = cursor.var(int)
                cursor.execute(SQL)
                cursor.callproc("sample11b", [222, outValue])
                print(outValue.getvalue())

Comme indiqué sur la deuxième ligne à partir du bas, spécifiez le nom de la procédure stockée que vous souhaitez appeler dans le premier argument avec le type str. Pour le deuxième argument, spécifiez l'argument de la procédure stockée en fonction des spécifications d'argument de la procédure.

Exécuter l'instruction SQL CALL à l'aide de la méthode Cursor.execute ()

sample11c.py

import cx_Oracle

USERID = "admin"
PASSWORD = "FooBar"
DESTINATION = "atp1_low"
SQL = """
create or replace procedure sample11b(in_value in number, out_value out number) is
begin
  out_value := in_value * 2;
end;
"""

with cx_Oracle.connect(USERID, PASSWORD, DESTINATION) as connection:
        with connection.cursor() as cursor:
                outValue = cursor.var(int)
                cursor.execute(SQL)
                cursor.execute("call sample11b(:a, :b)", [333, outValue])
                print(outValue.getvalue())

Vous devez spécifier les arguments de procédure en tant que variables de liaison.

Ce qui est mieux, callproc () ou execute () + CALL, dans le cas de callproc (), la DB API callproc () ne prend pas en charge la spécification de l'argument avec le nom de l'argument. Cependant, cx_Oracle étend l'API DB pour la prendre en charge. Si vous souhaitez coder strictement correspondant à l'API DB, utilisez execute () + CALL. Cependant, cx_Oracle a un certain nombre d'extensions propriétaires que l'API DB n'a pas, il semble donc difficile de les respecter strictement. Au contraire, je pense que la clarté du codage est callproc (). En outre, il semble que les spécifications pour appeler les procédures stockées et les fonctions stockées dans l'instruction CALL peuvent différer légèrement par rapport à callproc (). Si vous êtes préoccupé par ces points, nous vous recommandons d'utiliser callproc ().

Exécution des fonctions stockées

Il existe deux types de méthodes d'exécution pour stocker les procédures stockées.

Utilisez la méthode Cursor.callfunc ()

sample11d.py

import cx_Oracle

USERID = "admin"
PASSWORD = "FooBar"
DESTINATION = "atp1_low"
SQL = """
create or replace function sample11d(in_value in number)
  return number is
begin
  return in_value * 2;
end;
"""

with cx_Oracle.connect(USERID, PASSWORD, DESTINATION) as connection:
        with connection.cursor() as cursor:
                cursor.execute(SQL)
                returnValue = cursor.callfunc("sample11d", int, [111])
                print(returnValue)

Comme indiqué dans la deuxième ligne à partir du bas, la fonction renvoie le résultat de l'opération, il est donc reçu sous forme de variable (returnValue dans l'exemple de cas). Le premier argument de la méthode callfunc () est le nom de la fonction, qui doit être passé en type str. Le second spécifie le type de données de la valeur de retour de la fonction. Le troisième est l'argument de la fonction.

Exécuter l'instruction SQL CALL à l'aide de la méthode Cursor.execute ()

sample11e.py

import cx_Oracle

USERID = "admin"
PASSWORD = "FooBar"
DESTINATION = "atp1_low"
SQL = """
create or replace function sample11d(in_value in number)
  return number is
begin
  return in_value * 2;
end;
"""

with cx_Oracle.connect(USERID, PASSWORD, DESTINATION) as connection:
        with connection.cursor() as cursor:
                outValue = cursor.var(int)
                cursor.execute(SQL)
                cursor.execute("call sample11d(:inValue) into :outValue", [222, outValue])
                print(outValue.getvalue())

C'est fondamentalement la même chose que l'exécution d'une procédure stockée. Notez que pour les fonctions stockées, une clause INTO est requise pour recevoir la valeur de retour.

Laquelle des deux méthodes d'exécution ci-dessus est la meilleure est fondamentalement la même idée qu'une fonction stockée. La différence est qu'il n'y a pas de callfunc () dans l'API DB.