SQL*Plus en PL/SQL staan al jaren op gespannen voet - er zijn talloze gevallen waarin de manier waarop een taak wordt uitgevoerd met SQL*Plus verschilt van de manier waarop diezelfde of vergelijkbare taak wordt voltooid in PL/SQL. Daarnaast zijn er datatypes beschikbaar in PL/SQL die niet beschikbaar waren in SQL*Plus. Oracle versie 21c biedt een manier om enkele van de PL/SQL-gegevenstypen in SQL*Plus-typedefinities te gebruiken, met het voorbehoud dat de PL/SQL-typen niet persistent zullen zijn. Wat betekent dit en hoe ga je om met het gebruik van deze nieuw gevonden schat aan soorten? Laten we verder onderzoeken en kijken wat we vinden.
Het creëren van bepaalde typen in zowel PL/SQL als SQL*Plus bracht al een tijdje een wijziging in de syntaxis met zich mee - een type met twee elementen in PL?SQL is een record, en diezelfde typeconstructie in SQL*Plus wordt een objecttype. Dit is iets waar ontwikkelaars aan gewend zijn geraakt. Als die typen echter PL/SQL-typen (boolean, pls_integer, binary_integer, enz.) moeten bevatten, was er helaas geen gemakkelijke manier in SQL*Plus om aan die vereiste te voldoen. Tot 21c. Laten we eens kijken naar een voorbeeld van hoe dergelijke typen kunnen worden gebruikt in SQL*Plus-typedefinities. Laten we zeggen dat als argument een type nodig is met een BOOLEAN-gegevenstype in SQL*Plus. Vóór 21c zou het nodig zijn om VEEL te coderen om het BOOLEAN-gegevenstype na te bootsen - met 21c kunnen we BOOLEAN als een type gebruiken, zolang de database niet probeert de gegevens op schijf te bewaren:
SQL> create or replace 2 type EMP_SAL_APPROVAL_FOR_PL as object 3 ( e_num number, 4 e_nme varchar2(35), 5 new_sal number, 6 mgr_approve boolean 7 ) not persistable ; 8 / Type created.
Een dergelijk object kan tijdens runtime worden doorgegeven aan een PL/SQL-programma-eenheid met de BOOLEAN-waarde en Oracle weet dat de BOOLEAN-waarde niet mag blijven bestaan buiten de huidige context. Zoals eerder vermeld is dit niet beperkt tot BOOLEAN-waarden; laten we zowel een PLS_INTEGER als een BINARY_INTEGER proberen:
SQL> create or replace 2 type EMP_SAL_APPROVAL_FOR_PL as object 3 ( e_num number, 4 e_nme varchar2(35), 5 new_sal number, 6 mgr_approve boolean, 6 old_sal pls_integer, 7 yrly_sal binary_integer 8 ) not persistable ; 9 / Type created.
Elk gegevenstype dat niet kan worden bewaard in SQL*Plus, is niet vanwege de instructie "niet persistent", hoewel ze tijdens runtime kunnen worden doorgegeven aan een PL/SQL-eenheid.
Als je je afvraagt of dit ook beschikbaar is voor gebruik in geneste tabellen en varrays, dan is het antwoord ja:
SQL> create or replace 2 type i_array as 3 varray(40) of (binary_integer) 4 not persistable; 5 / Type created.
Helaas staat dit het gebruik van een %TYPE-referentie niet toe (een bekende en vaak gebruikte snelkoppeling met PL/SQL-codering om ervoor te zorgen dat de PL/SQL-code en de gebruikte tabellen overeenkomen) in elk type met de "not persistable"-richtlijn:
SQL> create or replace 2 type EMP_SAL_APPROVAL_FOR_PL as object 3 ( e_num emp.empno%type, 4 e_nme varchar2(35), 5 new_sal number, 6 mgr_approve boolean, 6 old_sal pls_integer, 7 yrly_sal binary_integer 8 ) not persistable ; 9 / Warning: Type created with compilation errors. SQL> SQL> show errors Errors for TYPE EMP_SAL_APPROVAL_FOR_PL LINE/COL ERROR -------- ----------------------------------------------------- 0/0 PL/SQL: Compilation unit analysis terminated 3/12 PLS-00201: identifier 'EMP.EMPNO' must be declared
Oracle heeft een belangrijke stap gezet met de "not persistable"-richtlijn, waardoor programmeurs PL/SQL-gegevenstypen kunnen gebruiken in SQL*Plus-typedefinities; dit heeft hoogstwaarschijnlijk een beperkt nut of aantrekkingskracht, wetende dat de gegevens die door dergelijke constructies worden vertegenwoordigd niet in de database worden opgeslagen, maar bij het doorgeven van BOOLEAN-, PL:S_INTEGER- of BINARY_INTEGER-waarden van SQL*Plus naar PL/SQL-programma-eenheden kan het elimineer eventuele problemen met het type mismatch die worden veroorzaakt door het niet hebben van dergelijke typen in SQL*Plus. En dit is waarschijnlijk de eerste stap in het uitbreiden van de functionele compatibiliteit van SQL*Plus met PL/SQL.