Méthode d'optimisation des performances des procédures stockées Oracle PLSQL
1. Causes courantes affectant les performances
1. Essayez d'utiliser des procédures stockées et évitez d'utiliser des blocs anonymes PL/SQL
Une fois la procédure stockée créée, Oracle analysera sa syntaxe et sa syntaxe, et la stockera dans la base de données sous une forme compilée. Lorsque le client l'appelle, il lui suffit d'envoyer une instruction d'appel, ce qui évite la transmission d'une grande quantité de code source sur Internet par le bloc anonyme et réduit le coût du réseau. La charge de communication est réduite et les performances du programme sont améliorées car il n'est compilé qu'une seule fois lors de sa création.
2. Écrivez des instructions SQL partagées
Lorsqu'Oracle exécute une instruction SQL, après la première analyse, il placera l'instruction SQL dans le pool partagé situé dans la zone globale du système SGA. Cette zone mémoire peut être partagée par tous les utilisateurs de la base de données, donc lors de l'exécution d'une instruction SQL, par exemple , le curseur dans l'instruction PL/SQL exécute l'instruction SQL. Si Oracle détecte qu'il s'agit de la même instruction que l'instruction qui a été exécutée auparavant, il utilisera l'instruction qui a été analysée et utilisera le chemin d'exécution optimal.
Lorsqu'Oracle exécute une instruction SQL, il recherche toujours d'abord la même instruction SQL dans la zone de mémoire partagée. Cependant, comme Oracle ne met en cache que des tables simples, il ne convient pas aux requêtes de connexion multi-tables.
SÉLECTIONNER * DEPUIS EMP ;
SELECT * depuis EMP ;
Sélectionnez * dans Emp ;
SÉLECTIONNER * DEPUIS EMP ;
Afin d'éviter ce type d'instructions SQL, lors de l'écriture d'instructions SQL, vous devez veiller à adopter une convention de casse cohérente, les mots-clés et les mots réservés sont en majuscules et les identifiants déclarés par l'utilisateur sont en minuscules. En concevant vos propres conventions d'écriture et en suivant Ces conventions, les instructions sont cohérentes avec celles du pool partagé, ce qui contribue à améliorer les performances d'exécution.
3. Utilisez BINARY_INTEGER et PLS_INTEGER pour déclarer des entiers
Lorsque vous déclarez des types de variables dans la programmation PLSQL, vous devez toujours utiliser BINARY_INTEGER et PLS_INTEGER pour éviter de trop vous fier au type numérique, car le premier offre des performances plus rapides.
4. Utilisez l'invite de compilation NOCOPY lors de la transmission des paramètres Big Data dans le processus
Lors de la création d'une procédure ou d'une fonction, le mode IN transmet toujours un pointeur, tandis que OUT et IN OUT transmettent une copie de la valeur, également appelée transmission par valeur. Lorsque la transmission de paramètres de grande capacité est impliquée, les performances seront sérieusement réduites. À ce stade, vous devriez envisager d'utiliser l'astuce de compilation NOCOPY pour transmettre des paramètres par référence. Plus la taille du paramètre est grande, plus l'effet est évident. Par exemple : supposons qu'une procédure a un
type IN OUT Les paramètres sont passés par valeur par défaut. L'exemple suivant montre l'appel de ce processus plusieurs fois et la transmission d'un paramètre de table d'index volumineux. Si NOCOPY n'est pas utilisé, les performances seront sérieusement réduites.
Utilisez NOCOPY pour améliorer les performances
declare
type test_tb1 is table of pls_integer index by pls_integer; --定义索引表类型
test_tb1 test_tb1_type; --定义索引表类型的变量
--定义内嵌子程序，在IN OUT 参数中使用NOCOPY提示来按引用传递
procedure test (arg_cnt in pls_integer，arg_tb1 in out nocopy test_tb1_type)
is
begin
for cnt_test in test_tb1.first .. arg_tb1.last --依循环索引表
loop
arg_tb1 (cnt_test):=arg_tb1 (cnt_test) + arg_cnt;
end loop; --为形式参数表赋值
end;
begin
for cnt in 0 .. 10000
loop
test_tb1 (cnt) := cnt;
end loop;
for cnt in 0 .. 10000
loop
test (cnt,test_tb1);
end loop;
end;
5. Utilisez return pour obtenir la valeur de retour
Lorsque vous utilisez des instructions DML pour traiter les données d'une ligne d'objet, si vous souhaitez obtenir la valeur de retour de la ligne, vous devez toujours utiliser la clause return pour réduire le nombre d'exécutions SQL et améliorer l'efficacité de l'exécution :
insérer dans … valeur (…) renvoyant col1 dans :col1;
mettre à jour … définir … renvoyant col1 dans :col1;
supprimer … renvoyant col1 dans :col1;
En utilisant le retour, vous pouvez non seulement renvoyer des données multi-colonnes, mais également renvoyer des données et les enregistrer vers des tableaux et d'autres types de données. Moyen :
renvoyer col1, col2 dans :col1, :col2 ;
renvoyer col1 dans :col1_array ;
6. Évitez d'utiliser des instructions SQL dynamiques
Bien que les instructions SQL dynamiques facilitent la programmation, leur utilisation excessive réduira considérablement les performances des applications PLSQL. Par conséquent, si nécessaire, vous devez toujours envisager d'utiliser des instructions SQL statiques. Si vous devez utiliser des instructions SQL dynamiques, vous devez toujours choisir d'utiliser des instructions SQL dynamiques locales, c'est-à-dire exécuter immédiatement ou ouvrir pour au lieu d'utiliser dbms_sql, car dbms_sql est non seulement plus compliqué à écrire du code, mais a également des performances moins bonnes que instructions SQL dynamiques locales.
7. Essayez d'utiliser le traitement par lots en masse
Si l'opération implique une grande quantité de données, vous pouvez améliorer les performances en traitant une grande quantité de données à la fois. Par exemple, vous pouvez placer les données dans des tables d'index, des tables imbriquées et des tableaux de longueur variable, et utiliser des instructions de traitement par lots. comme forall ou group collect into. , traitant de grandes quantités de données en même temps et améliorant les performances.
Utilisez l'instruction Bulk Collect In pour insérer simultanément toutes les données de la table emp dans les variables de la table d'index. Lorsque la quantité de données est particulièrement importante, cela peut améliorer considérablement les performances.
Obtenez toutes les données en même temps grâce au traitement par lots
declare
type emp_tb1 is table of emp%ROWTYPE index by pls_integer; --定义索引表类型
emp_tb1 emp_tb1_type;
cursor emp_cur
is
select * from emp;
begin
open emp_cur;
fetch emp_cur
bulk collect into emp_tb1;
close emp_cur;
end;
En utilisant la clause de collecte groupée into, toutes les données du curseur sont extraites simultanément dans les variables de la table d'index, ce qui améliore les performances d'exécution du programme et économise la quantité d'écriture de code. Par conséquent, dans la mesure du possible, le traitement par lots doit être utilisé pour terminer le traitement des données.
Deuxièmement, utilisez le package DBMS_PROFILER
1.Installez le package DBMS_PROFILER
Avant d'utiliser DBMS_PROFILER, vous devez entrer dans le système de base de données en tant qu'administrateur pour l'installer.
conn system/manager en tant que sysdba ;
desc dbms_profiler ;
Si la commande desc indique que le package dbms_profiler n'existe pas, vous devez utiliser la commande suivante pour l'installer :
sql>@?/rdbms/admin/profload.sql
Exécutez à nouveau desc dbms_profiler , vous pouvez voir ce package Contient des informations sur les sous-programmes, deux fonctions principales sont utilisées :
start_profiler démarre le profileur
stop_profiler arrête le profil
2. Configurez la solution de profileur
Créez un utilisateur pour stocker les informations de suivi et les synonymes des tables liées au profileur :
créer un profileur utilisateur identifié par 123456 ;
accorder la connexion, la ressource au profileur ;
créer un synonyme public plsql_profiler_runs pour profiler.plsql_profiler_runs ;
créer un synonyme public plsql_profiler_units pour profiler.plsql_profiler_units ;
créer un synonyme public plsql_profiler_data pour profiler.plsql_profiler_data ;
créer un synonyme public plsql_profiler_runnumber pour profiler.plsql_profiler_runnumber ;
3. Configurez la table du profileur
profileur de conn/123456
@?/rdbms/admin/proftab.sql
accorder la sélection sur plsql_profile_runnumber au public ;
accorder la sélection, l'insertion, la mise à jour, la suppression sur plsql_profiler_data au public ; accorder la
sélection, l'insertion, la mise à jour, la suppression sur plsql_profiler_units au public ; accorder la sélection, l'insertion, la mise à jour, la suppression sur plsql_profiler_runs à public_profiler_runs
au public ; plsqlber plsql_profiler_data enregistre les informations du profileur de chaque unité plsql_profiler_units enregistre les données détaillées de chaque unité plsql_profiler_runs est utilisé pour générer la séquence de numéros d'exécution uniques du profileur
4. Exécutez le profileur pour obtenir les informations de configuration
Après avoir créé le processus, vous pouvez utiliser le profileur pour instrumenter le code du programme.
Créer un processus à tester
create table pro_tst_table (a int);
create or replace procedure sp_test
as
begin
for i in 1 .. 10000
loop
insert into pro_tst_table values(i);
end loop;
commit;
end;
Utilisez dbms_profiler pour tester le package
declare
v_run_number integer;
v_temp1 integer;
begin
--启动profiler
sys.DBMS_PROFILER.start_profiler(run_number => v_run_number);
--显示当前跟踪的运行序号(后面查询要用)
dbms_output.put_line('run_number:'||v_run_number);
--运行要跟踪的PLSQL
sp_test;
--停止profiler
sys.DBMS_PROFILER.stop_profiler;
end;
5. Interrogez le profileur pour obtenir le résultat
Pour utiliser des instructions SQL pour interroger les informations de cette exécution, vous pouvez d'abord interroger plsql_profiler_runs pour obtenir les informations de base de cette exécution : sélectionnez
runid, run_owner, run_date, run_total_time à partir de plsql_profiler_runs ;
L'auteur a exécuté le code deux fois, il y a donc deux enregistrements runid. , ID La valeur est générée via le numéro de série et la valeur d'ID maximale indique l'exécution la plus récente.
RUN_TOTAL_TIME indique l'heure d'exécution. Vous pouvez voir que l'heure des deux exécutions est significativement différente. Les
informations d'unité de ce profil peuvent être obtenu en interrogeant la table plsql_profiler_units.
En interrogeant la table plsql_profiler_data, vous pouvez obtenir des informations statistiques pour chaque ligne de la procédure stockée exécutée en fonction du numéro de ligne et du numéro d'unité.
3. Utilisez le package DBMS_TRACE
Par exemple, si vous voyez l'ordre d'exécution des sous-programmes, vous pouvez utiliser le package DBMS_TRACE. L'utilisation de ce package est similaire à celle de DBMS_PROFILER. Une différence majeure est que dbms_trace peut définir les événements qui doivent être suivis : appels, exceptions, SQL et même les événements possibles de chaque code PLSQL. Grâce à ces informations, les anomalies dans le processus du programme en arrière-plan peuvent être localisées très rapidement.
Il y a deux fonctions dans le package :
set_plsql_trace : permet la collecte de statistiques de traçage.
clear_plsql_trace : arrête la collecte des statistiques de trace
1. Configurer et utiliser DBMS_TRACE
Avant de l'utiliser, vous devez configurer les tables de données utilisées par dbms_trace et permettre à tous les utilisateurs d'écrire des données dans ces tables.
conn système/gestionnaire en tant que sysdba
@？/rdbms/admin/tracetab.sql
Le script crée deux tables et une séquence
Table plsql_trace_runs : utilisée pour enregistrer chaque information de trace.
Table plsql_trace_events : utilisée pour enregistrer les données détaillées de toutes les traces
séquence plsql_trace_runnumber : séquence utilisée pour générer des numéros d'exécution uniques.
2. Après avoir créé avec succès les tables requises, vous devez créer des synonymes pour les tables correspondantes et leur attribuer des autorisations d'accès afin que les utilisateurs dotés de rôles publics puissent opérer sur les tables correspondantes.
créer ou remplacer le synonyme public plsql_trace_runs pour sys.plsql_trace_runs ;
créer ou remplacer le synonyme public plsql_trace_events pour sys.plsql_trace_events ;
créer ou remplacer le synonyme public plsql_trace_runnumber pour sys.plsql_trace_runnumber ;
accorder la sélection, l'insertion, la mise à jour, la suppression sur plsql_trace_events au public ;
accorder la sélection, l'insertion, la mise à jour, la suppression sur plsql_trace_runs au public ;
accorder la sélection sur plsql_trace_runnumber au public ;
Créer un programme de test dbms_trace
create or replace procedure do_something (p_times in number)
as
1_dummy number;
begin
for i in 1 .. p_times
loop
select 1_dummy + 1 into 1_dummy from dual;
end loop;
end;
Programmes de traçage avec dbms_trace
declare
1_result binary_integer;
begin
--跟踪所有的调用
dbms_trace.set_plsql_trace(dbms_trace.trace_all_calls);
do_something(100);
--停止PLSQL跟踪
dbms_trace.clear_plsql_trace;
--跟踪所有的sql语句
dbms_trace.set_plsql_trace(dbms_trace.trace_all_sql);
do_something(100);
--停止跟踪
dbms_trace.clear_plsql_trace;
--跟踪所有行数据
dbms_trace.set_plsql_trace(dbms_trace.trace_all_lines);
do_something(100);
dbms_trace.clear_plsql_trace;
end;
Pour chaque appel, set_plsql_trace est d'abord utilisé pour démarrer le processus de traçage. Le paramètre DBMS_TRACE_trace_all_calls de ce processus est une constante spécifiée pour tracer l'appel ou renvoyer la valeur.
La spécification du package DBMS_TRACE contient une liste et une explication détaillée des constantes disponibles pour set_plsql_trace.
Obtenez des informations sur chaque trace en interrogeant la table plsql_trace_runs.
Quatrièmement, compétences en optimisation des performances PLSQL
Lorsque la base de données Oracle exécute une instruction SQL, l'optimiseur d'Oracle détermine le chemin d'exécution de l'instruction SQL selon certaines règles afin de garantir que l'instruction SQL peut être exécutée avec des performances optimales. Afin d'exécuter l'instruction SQL dans le système de base de données Oracle, Oracle peut avoir besoin d'implémenter plusieurs Chacune de ces étapes peut consister à récupérer physiquement des lignes de données de la base de données ou à préparer les lignes de données d'une manière ou d'une autre pour être utilisées par l'utilisateur qui écrit l'instruction SQL. La combinaison de ces étapes utilisée par Oracle pour exécuter l'instruction est appelée exécution.
Oracle passe par 4 étapes lors de l'exécution d'une instruction SQL :
Analyser l'instruction SQL : interrogez principalement la même instruction SQL dans le pool partagé, vérifiez la sécurité ainsi que la syntaxe et la sémantique SQL.
Création de plans d'exécution et exécution : y compris la création de plans d'exécution pour les instructions SQL et l'acquisition proprement dite des données des tables.
Afficher l'ensemble de résultats : effectue tous les tris, transformations et reformatages nécessaires des données de champ.
Convertir les données de champ : reformatez et convertissez les champs qui ont été convertis via des fonctions intégrées.
Vérifiez le plan d'exécution de l'instruction SQL. Par exemple, certains outils tiers doivent d'abord exécuter le script utlxplan.sql pour créer la table expliquer_plan.
@？/rdbms/admin/utlxplan.sql
définir l'autotrace sur expliquer : exécuter SQL et afficher uniquement le plan d'exécution
définir l'autotrace sur les statistiques : exécuter SQL et afficher uniquement les statistiques d'exécution
activer la trace automatique : exécuter SQL et afficher le plan d'exécution et les informations statistiques, aucun résultat d'exécution
définir l'autotrace traceonly : affiche uniquement le plan d'exécution et les informations statistiques, aucun résultat d'exécution
désactiver l'autotrace : désactiver le plan d'affichage des traces et les statistiques
définir la trace automatique sur expliquer
format de nom de colonne a20 ;
sélectionnez empno，ename depuis emp où empno=7369 ;
5. Comprendre le plan d'exécution
1. Analyse complète de la table : Cette méthode lira chaque enregistrement de la table et lira chaque bloc de données séquentiellement jusqu'à la marque de fin. Pour une table de données volumineuse, l'utilisation d'une analyse complète de la table réduira les performances, mais certains Parfois, par exemple, lorsque le La proportion des résultats de requête par rapport au volume de données de la table entière est relativement élevée, l'analyse de la table complète est une meilleure méthode que la sélection d'index.
2. Obtenir via la valeur ROWID : Le rowid de la ligne indique le fichier de données où se trouve la ligne, le bloc de données et la position de la ligne dans le bloc. Par conséquent, l'accès aux données via rowid peut localiser rapidement les données cibles, qui est une ligne unique accessible par Oracle. Le moyen le plus rapide d'accéder aux données.
3. Analyse d'index : recherchez d'abord la valeur rowid de l'objet via l'index, puis recherchez directement les données spécifiques de la table via la valeur rowid, ce qui peut considérablement améliorer l'efficacité de la recherche.
6. Ordre du tableau de la requête de connexion
Par défaut, l'optimiseur utilisera la méthode d'optimisation all_rows, c'est-à-dire que l'optimiseur basé sur les coûts CBO générera un plan d'exécution et la méthode CBO générera un plan d'exécution basé sur des informations statistiques.
Les informations statistiques donnent la taille du tableau, le nombre de lignes, la longueur de chaque ligne et d'autres informations. Ces informations statistiques ne sont pas initialement disponibles dans la bibliothèque. Elles ont été découvertes après avoir effectué une analyse. Plusieurs fois, des informations statistiques expirées entraîneront l'optimiseur de faire une erreur.plan de mise en œuvre, ces informations doivent donc être mises à jour en temps opportun.
En mode CBO, lors de l'exécution d'une requête de jointure sur plusieurs tables, l'analyseur Oracle traitera les noms de table dans la clause from dans l'ordre de droite à gauche. Par exemple:
sélectionnez a.empno，a.ename，c.deptno，c.dname，a.log_action depuis emp_log a,emp b,dept c
Pendant l'exécution, Oracle interrogera d'abord la table dept et utilisera les lignes interrogées dans la table dept comme source de données pour se connecter en série à la table emp afin de poursuivre l'exécution. Par conséquent, la table dept est également appelée table de base ou table de pilote. . Parce que l’ordre de connexion a un grand impact sur l’efficacité de la requête. Par conséquent, lorsque vous traitez des jointures multi-tables, vous devez sélectionner une table avec moins d'enregistrements comme table de base, et Oracle utilisera le tri et la fusion pour se connecter. Par exemple, analysez d'abord la table dept, puis triez la table dept, puis analysez la table emp et enfin fusionnez tous les enregistrements récupérés avec les enregistrements de la première table.
S'il y a plus de 3 tables connectées à la requête, vous devez sélectionner le tableau croisé comme table de base. Le tableau croisé fait référence à la table référencée par d'autres tables. Puisque emp_log est un tableau croisé entre les tables dept et emp, il contient le contenu de dept et emp.
sélectionnez a.empno，a.ename，c.deptno，c.dname，a.log_action depuis emp b,dept c,emp_log a ;
7. Spécifiez l'ordre des conditions où
Lors de l'interrogation d'une table, l'ordre des conditions dans la clause Where affecte souvent les performances d'exécution. Par défaut, Oracle analyse les clauses Where dans un ordre ascendant. Par conséquent, lors du traitement de requêtes multi-tables, les connexions entre les tables doivent être écrites avant les autres conditions Where, mais les conditions de filtrage des enregistrements de données doivent être écrites avant Where à la fin de la clause. afin que la connexion puisse être traitée après avoir filtré les données, ce qui peut améliorer les performances de l'instruction SQL.
Évitez d'utiliser le symbole *
8. Utilisez la fonction de décodage
Par exemple, pour compter le nombre et le récapitulatif des salaires des employés portant le numéro de service 20 et le numéro de service 30 dans la table emp, si vous n'utilisez pas de décodage, vous devez utiliser deux instructions SQL.
sélectionnez count( )，SUM(sal) depuis emp où deptno=20 ;
union
select count( )，SUM(sal) from emp où deptno=30 ;
Deux analyses de table complètes ont été effectuées ci-dessus
Grâce à l'instruction de décodage, les mêmes résultats peuvent être obtenus dans une requête SQL et les deux lignes de résultats sont affichées sur une seule ligne.
select count (decode (deptno，20，'X'，NULL)) dept20_count，
count (decode (deptno，30，'X'，NULL)) dept30_count，
SUM (decode (deptno，20，sal，NULL)) dept20_sal，
sum (decode (deptno，30，sal，NULL)) dept30_sal de emp ;
Une seule analyse complète de la table a été effectuée ci-dessus
En utilisant de manière flexible la fonction de décodage, vous pouvez obtenir de nombreux résultats inattendus, tels que l'utilisation de la fonction de décodage dans une clause group by ou order by, ou l'imbrication d'un autre bloc de décodage dans un bloc de décodage.
9. Utilisez où au lieu d'avoir
Les clauses Where et Have peuvent filtrer les données, mais la clause Where ne peut pas utiliser de fonctions d'agrégation, telles que count max min avg sum et d'autres fonctions.
exemple:
sélectionnez empno,deptno，sum(sal) dans le groupe emp par empno，deptno
ayant sum(sal) > 1000 et deptno dans (20，30) ;
Dans la clause have, les enregistrements portant les numéros de service 20 ou 30 sont filtrés. En fait, cela entraînera la requête à récupérer les enregistrements des employés de tous les départements, à effectuer des calculs de regroupement et enfin à filtrer les enregistrements des départements 20 et 30 en fonction sur les résultats du regroupement. C'est très inefficace. Un bon algorithme consiste d'abord à utiliser la clause Where pour récupérer les enregistrements portant les numéros de département 20 et 30, puis à les filtrer.
sélectionnez empno，deptno，sum(sal) depuis emp où deptno dans （20,30）
regrouper par empno，deptno ayant une somme (sal) > 1000 ;
10. Utilisez UNION au lieu de OR
Si les deux colonnes à effectuer par OU sont des colonnes d'index, envisagez d'utiliser l'union pour améliorer les performances.
Exemple : Par exemple, dans la table emp, empno et ename ont des colonnes d'index créées. Lorsque vous devez effectuer une requête d'opération OU entre empno et ename, vous pouvez envisager de remplacer ces deux requêtes par union pour améliorer les performances.
sélectionnez empno，ename，job，sal depuis emp où empno > 7500 OU ename LIKE 'S%' ;
11. Utilisez UNION
sélectionnez empno，ename，job，sal depuis emp où empno > 7500
UNION
sélectionnez empno，ename，job，sal depuis emp où ename LIKE 'S%' ;
Mais cette méthode garantit que les deux colonnes sont des colonnes d'index.
Si vous insistez pour utiliser l'instruction OR, n'oubliez pas d'écrire autant que possible la colonne d'index avec le moins d'enregistrements renvoyés au début, afin d'obtenir de meilleures performances. Par exemple, empno > 7500 renvoie moins d'enregistrements que la requête. pour ename, donc dans l'instruction OR, le mettre au premier plan vous donnera de meilleures performances. Une autre suggestion consiste à envisager d'utiliser IN à la place lors de l'exécution de calculs OR sur une seule valeur de champ.
Par exemple ce qui suit
sélectionnez empno，ename，job，sal depuis emp où deptno=20 OU deptno=30 ;
12. L'utilisation existe au lieu de IN
Par exemple, pour interroger la liste de tous les employés de Chicago, vous pouvez envisager d'utiliser IN
sélectionnez * depuis emp où deptno IN (
sélectionnez deptno depuis dept où loc='CHICAGO');
Remplacer par
sélectionnez * depuis emp où existe (
sélectionnez deptno depuis dept où loc='CHICAGO');
La même page de remplacement se produit entre not in et not exist. La clause not in effectuera un tri et une fusion internes. En fait, elle effectue une analyse complète de la table dans la sous-requête, donc l'efficacité est faible. Lorsque vous avez besoin de utilisation Dans le cas de NOT IN, Yingai envisage toujours de le changer en connexion externe ou NOT EXISTS
sélectionnez * depuis emp où deptno NOT IN (
sélectionnez deptno depuis dept où loc='CHICAGO');
Afin d'améliorer les performances, vous pouvez utiliser la requête de jointure
sélectionnez a.* dans emp a，dept b où a.deptno=b.deptno et b.loc <> 'CHICAGO' ;
le plus efficace
sélectionnez a.* dans emp a où N'EXISTE PAS (
sélectionnez 1 dans le département b où a.deptno =b.deptno et loc='CHICAGO');
13. Évitez les instructions de contrôle de processus PL/SQL inefficaces
PLSQL utilise la méthode de calcul de chemin court lors du traitement des valeurs d'expression logique.
declare
v_sal number:=&sal;
v_job varchar2(20):=&job;
begin
if (v_sal > 5000 ) OR (v_job = '销售')
then
dbms_output.put_line('符合匹配的OR条件');
end if;
end;
Tout d'abord, la première condition est évaluée. Si v_sal est supérieur à 5 000, la condition v_job ne sera pas jugée. L'utilisation flexible de cette méthode de calcul de court-circuit peut améliorer les performances. Vous devez toujours placer les instructions de jugement les moins coûteuses en premier, de sorte que lorsque le jugement précédent échoue, les instructions suivantes, plus coûteuses, ne soient pas exécutées, ce qui peut améliorer les performances des applications PL/SQL.
Par exemple, pour l’opérateur logique et, le résultat est vrai uniquement si les opérations sur les côtés gauche et droit sont vraies. Si la première opération du résultat précédent est fausse, la deuxième opération ne sera pas effectuée.
declare
v_sal number:=&sal;
v_job varchar2(20):=&job;
begin
if (check_sal(v_sal) > 5000) AND (v_job = '销售') --判断执行条件
then
dbms_output.put_line('符合匹配的and条件');
end if;
end;
Ce code présente un risque en termes de performances. check_sal implique certaines vérifications de logique métier. Si la fonction check_sal est appelée en premier, cette fonction sera toujours appelée. Par conséquent, pour des raisons de performances, le jugement de v_job doit toujours être placé dans et avant l'instruction.
declare
v_sal number:=&sal;
v_job varchar2(20):=&job;
begin
if (v_job='销售') and (check_sal(v_sal) > 5000)
then
dbms_output.put_line('符合匹配的and条件');
end if;
end;
Évitez les conversions de type implicites