{"id":13635,"date":"2024-10-16T04:22:28","date_gmt":"2024-10-16T02:22:28","guid":{"rendered":"https:\/\/www.salvis.com\/blog\/?p=13635"},"modified":"2025-03-12T10:22:04","modified_gmt":"2025-03-12T09:22:04","slug":"pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday","status":"publish","type":"post","link":"https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/","title":{"rendered":"PL\/SQL vs. JavaScript in the Oracle Database 23ai #JoelKallmanDay"},"content":{"rendered":"\n

JavaScript is the first language supported by the Multilingual Engine (MLE) in Oracle Database 23ai. Having additional languages in the Oracle Database allows us to use existing libraries within the database. Also, it makes it easier for those without PL\/SQL skills to get started with database development. Wasn’t that also the argument for Java in the database? What is easier and better in JavaScript than in Java? How performant are JavaScript modules? When is JavaScript a good alternative to PL\/SQL and when is it not?<\/p>\n\n\n\n

This is a translation of my German article “PL\/SQL oder JavaScript in der Oracle Datenbank 23ai?” published in the Red Stack Magazine<\/a> No. 6\/2024 on 11 October 2024.<\/p>\n\n\n\n

Why Do We Need Code in the Database?<\/h2>\n\n\n\n

<\/p>\n\n\n\n

I see the following reasons for this.<\/p>\n\n\n\n

    \n
  1. We bring the code to the data rather than the data to the code. This allows us to process the data efficiently on the database server and deliver the result to the client in just a few network round trips. This uses fewer resources, is more cost-effective and faster than if we had to transport the data to the client and process it there.<\/li>\n\n\n\n
  2. We take responsibility for the quality of the data stored in the database. Typically, we write data once and read it often. Therefore, we should store data correctly so that consumers can rely on the data when they read it. In this sense, the logic for validating the data belongs in the database. This logic is often more extensive than what today’s database constraints provide. In other words, we need code in the database as part of an API to keep our data consistent and correct.<\/li>\n<\/ol>\n\n\n\n

    Even if your database applications do not follow the principles of SmartDB or PinkDB<\/a>, there are benefits to selectively using code in the database. And if your company policy categorically forbids code in the database, it is probably time to reconsider.<\/p>\n\n\n\n

    PL\/SQL Without SQL<\/h2>\n\n\n\n

    Let’s pretend we need a function to convert a timestamp to Unix time. Wikipedia defines the Unix time<\/a> as follows.<\/p>\n\n\n\n

    \n

    Unix time is a date and time representation widely used in computing. It measures time by the number of non-leap seconds that have elapsed since 00:00:00 UTC on 1 January 1970, the Unix epoch.<\/p>\n<\/blockquote>\n\n\n\n

    Listing 1 shows how we can implement this in PL\/SQL.<\/p>\n\n\n\n

    Listing 1: to_epoch_plsql<\/span><\/path><\/path><\/svg><\/span>
    create or replace<\/span> function to_epoch_plsql(<\/span><\/span>\n   in_ts <\/span>in<\/span> <\/span>timestamp<\/span><\/span>\n) <\/span>return<\/span> <\/span>number<\/span> <\/span>is<\/span><\/span>\n   co_epoch_date <\/span>constant<\/span> <\/span>timestamp with time zone<\/span> := <\/span><\/span>\n      <\/span>timestamp<\/span> <\/span>'1970-01-01 00:00:00 UTC'<\/span>;<\/span><\/span>\n   <\/span>l_interval<\/span>    interval day(<\/span>9<\/span>) to second (<\/span>3<\/span>);<\/span><\/span>\nbegin<\/span><\/span>\n   <\/span>l_interval<\/span> := in_ts - co_epoch_date;<\/span><\/span>\n   <\/span>return<\/span> <\/span>1000<\/span> * (<\/span>extract<\/span>(second <\/span>from<\/span> <\/span>l_interval<\/span>)<\/span><\/span>\n         + <\/span>extract<\/span>(minute <\/span>from<\/span> <\/span>l_interval<\/span>) * <\/span>60<\/span><\/span>\n         + <\/span>extract<\/span>(hour <\/span>from<\/span> <\/span>l_interval<\/span>) * <\/span>60<\/span> * <\/span>60<\/span><\/span>\n         + <\/span>extract<\/span>(day <\/span>from<\/span> <\/span>l_interval<\/span>) * <\/span>60<\/span> * <\/span>60<\/span> * <\/span>24<\/span>);<\/span><\/span>\nend<\/span>;<\/span><\/span>\n\/<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    The to_epoch_plsql<\/code> function expects a timestamp<\/code>, a timestamp with timezone<\/code> would be better. We have omitted this to keep the example as simple as possible. Although the solution may seem simple, we are reimplementing existing functionality. We had to find out how Unix time works, what role time zones play, what leap seconds are for, and that Unix time is used in milliseconds, not seconds.<\/p>\n\n\n\n
    Wouldn’t it be nice to be able to use an existing, tested function in the database to keep our application’s code to a minimum? Even though there is no to_epoch<\/code> function in SQL, the Java Development Kit (JDK) offers such functionality. The Oracle Java Virtual Machine (OJVM) is an embedded component of the Oracle Database 23.5. It’s a JDK version 11.<\/p>\n\n\n\n
    Java Without SQL<\/h2>\n\n\n\n
    The Oracle Database has supported Java stored procedures since version 8i Release 1. This means that we can provide a to_epoch_java<\/code> function as shown in Listing 2.<\/p>\n\n\n\n
    Listing 2: to_epoch_java<\/span><\/path><\/path><\/svg><\/span>
    create or replace<\/span> <\/span>and<\/span> compile <\/span>java<\/span> source named <\/span>"Util"<\/span> <\/span>as<\/span><\/span>\npublic class Util {<\/span><\/span>\n   public static <\/span>long<\/span> toEpoch(<\/span>java<\/span>.<\/span>sql<\/span>.<\/span>Timestamp<\/span> ts) {<\/span><\/span>\n      <\/span>return<\/span> ts.getTime();<\/span><\/span>\n   }<\/span><\/span>\n}<\/span><\/span>\n\/<\/span><\/span>\ncreate or replace<\/span> function to_epoch_java(in_ts <\/span>in<\/span> <\/span>timestamp<\/span>) <\/span><\/span>\n  <\/span>return<\/span> <\/span>number<\/span> <\/span>is<\/span> <\/span>language<\/span> <\/span>java<\/span> <\/span>name<\/span> <\/span><\/span>\n    <\/span>'Util.toEpoch(java.sql.Timestamp) return java.lang.long'<\/span>;<\/span><\/span>\n\/<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    For Java, we need to create a class and a call specification. The purpose of the call specification is, among other things, to map the types of input and output data between SQL and Java. For example, to map the return value of java.lang.long<\/code> to number<\/code>.<\/p>\n\n\n\n
    The code no longer contains the formula for converting a timestamp to Unix time, but it is quite extensive. Is there an easy way in JavaScript?<\/p>\n\n\n\n
    JavaScript Without SQL<\/h2>\n\n\n\n
    With Oracle Database 23ai, we can create JavaScript modules.<\/p>\n\n\n\n
    Listing 3: to_epoch_js<\/span><\/path><\/path><\/svg><\/span>
    create or replace<\/span> mle module util_mod <\/span>language<\/span> javascript <\/span>as<\/span>   <\/span><\/span>\nexport function toEpoch(ts) {<\/span><\/span>\n   <\/span>return<\/span> ts.valueOf();<\/span><\/span>\n}<\/span><\/span>\n\/<\/span><\/span>\ncreate or replace<\/span> function to_epoch_js(in_ts <\/span>in<\/span> <\/span>timestamp<\/span>) <\/span><\/span>\n   <\/span>return<\/span> <\/span>number<\/span> <\/span>is<\/span> <\/span><\/span>\n      mle module util_mod <\/span><\/span>\n      signature <\/span>'toEpoch(Date)'<\/span>;<\/span><\/span>\n\/<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    The implementation of to_epoch_js<\/code> in Listing 3 is similar to to_epoch_java<\/code>. A module in JavaScript and then an MLE call specification. However, it is no longer necessary to fully map the input data types in JavaScript. The Oracle Database defines default values. These can be overridden, but do not need to be explicitly defined as in Java. It is not possible to map the output data type. In this case, it must be possible to convert the return value to a number<\/code>, otherwise, a runtime error will occur.<\/p>\n\n\n\n
    However, the implementation for this simple case is quite extensive. Oracle has probably realised this and provided an alternative.<\/p>\n\n\n\n
    Listing 4: to_epoch_js2 \u2013 inline MLE call specification<\/span><\/path><\/path><\/svg><\/span>
    create or replace<\/span> function to_epoch_js2(<\/span>"in_ts"<\/span> <\/span>in<\/span> <\/span>timestamp<\/span>)<\/span><\/span>\n   <\/span>return<\/span> <\/span>number<\/span> <\/span>is<\/span><\/span>\n      mle <\/span>language<\/span> javascript <\/span>' return in_ts.valueOf();'<\/span>;<\/span><\/span>\n\/<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    The to_epoch_js2<\/code> function in Listing 4 is equivalent to to_epoch_js<\/code> but significantly simpler than any of the other variants. However, an inline MLE call specification is only applicable to JavaScript code without dependencies on other modules, this means for JavaScript code without an import command.<\/p>\n\n\n\n
    Performance of to_epoch_...<\/code><\/h2>\n\n\n\n
    Anyone who has worked with Java stored procedures in the database knows that the initialisation of the OJVM in a new database session slows down the response time considerably. This is not the case with MLE because it uses a GraalVM native image. Simply put, it reads only the memory contents of a file, similar to waking your laptop from hibernation. This makes it possible to start a Java program within a millisecond. The native image is integrated into the database as a shared library $ORACLE_HOME\/lib\/libmle.so<\/code>. This means that the MLE provides JavaScript via Java, but is completely independent of the OJVM.<\/p>\n\n\n\n
    In Figure 1 we compare the runtimes of 100,000 function calls. Instead of seconds, we use a normalised unit of time, which makes comparing easier and results less dependent on the hardware stack used.<\/p>\n\n\n\n
    All experiments were performed using the Oracle Database 23.5 Free Edition on an AMD Ryzen R1600 processor-based system. The shortest time of five repetitions was taken into account. You can reproduce these experiments using the scripts in this GitHub repository<\/a>.<\/p>\n\n\n\n
    \"Figure<\/a>
    Figure 1: Runtime of 100K calls of to_epoch_…<\/em><\/figcaption><\/figure>\n\n\n\n
    The to_epoch_plsql<\/code>, to_epoch_java<\/code> and to_epoch_js<\/code> variants are called from a PL\/SQL loop. This means 100,000 context switches between PL\/SQL and Java or JavaScript. The fourth variant, to_epoch_jsloop<\/code>, calls toEpoch<\/code> from a JavaScript loop. In this case, the context switching between PL\/SQL and JavaScript makes processing about 50 times slower.<\/p>\n\n\n\n
    Based on these results, we should avoid context switching between PL\/SQL and JavaScript if possible. The performance of JavaScript in the database is impressive in this case. Quite different from the OJVM.<\/p>\n\n\n\n
    Memory Usage of to_epoch_...<\/code><\/h2>\n\n\n\n
    Figure 2 shows the maximum memory used at the end of a to_epoch_\u2026<\/code> function call. The call was made in a new database session and contains the memory requirements of the measuring instruments.<\/p>\n\n\n\n
    \"Max.<\/a>
    Figure 2: Max. memory usage after a single call<\/em><\/figcaption><\/figure>\n\n\n\n
    JavaScript uses significantly more memory than PL\/SQL. If you take this into account when sizing the database server and connection pools, this should not be a problem nowadays.<\/p>\n\n\n\n
    Using a 3rd Party JavaScript Library<\/h2>\n\n\n\n
    Let’s say we want to validate email addresses in our database without actually sending a test email. The rules for a valid email address<\/a> are quite extensive. In the JavaScript ecosystem, we can find open-source libraries for such requirements that can be used in the database without modification. For this example, we use validator.js<\/a>, which can validate not only email addresses but also credit card numbers, EAN, IBAN and much more. Using SQLcl’s script command, we can load npm modules<\/a> directly into the database.<\/p>\n\n\n\n
    Listing 5: Load validator.js from npm as validator_mod into the database<\/span><\/path><\/path><\/svg><\/span>
    script https:\/\/<\/span>raw<\/span>.githubusercontent.com\/PhilippSalvisberg\/mle-sqlcl\/main\/mle.js install validator_mod https:\/\/esm.run\/validator@<\/span>13.12<\/span>.<\/span>0<\/span> <\/span>13.12<\/span>.<\/span>0<\/span><\/span>\n<\/span>\nselect<\/span> version, language_name, <\/span>length<\/span>(module)<\/span><\/span>\n  <\/span>from<\/span> user_mle_modules<\/span><\/span>\n <\/span>where<\/span> module_name = <\/span>'VALIDATOR_MOD'<\/span>;<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    VERSION    LANGUAGE_NAME       LENGTH(MODULE)<\/span><\/span>\n---------- ---------------- ----------------- <\/span><\/span>\n13.12.0    JAVASCRIPT                  123260<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    In Listing 6, we create the MLE call specification in a PL\/SQL package. The is_mail<\/code> function accepts only a string as a parameter. The validator options are defined in the package body. This simplifies uniform use in the database application.<\/p>\n\n\n\n
    Listing 6: PL\/SQL package validator_api <\/span><\/path><\/path><\/svg><\/span>
    create or replace<\/span> <\/span>package<\/span> <\/span>validator_api<\/span> <\/span>is<\/span><\/span>\n   <\/span>function<\/span> <\/span>is_email<\/span>(<\/span><\/span>\n      in_email <\/span>in<\/span> <\/span>varchar2<\/span><\/span>\n   ) <\/span>return<\/span> <\/span>boolean<\/span> <\/span>deterministic<\/span>;<\/span><\/span>\nend<\/span> validator_api;<\/span><\/span>\n\/<\/span><\/span>\ncreate or replace<\/span> <\/span>package body<\/span> <\/span>validator_api<\/span> <\/span>is<\/span><\/span>\n   <\/span>function<\/span> <\/span>is_email_internal<\/span>(<\/span><\/span>\n      in_email   <\/span>in<\/span> <\/span>varchar2<\/span>,<\/span><\/span>\n      in_options <\/span>in<\/span> json<\/span><\/span>\n   ) <\/span>return<\/span> <\/span>boolean<\/span> <\/span>deterministic<\/span> <\/span>as<\/span> mle module validator_mod <\/span><\/span>\n   signature <\/span>'default.isEmail(string, any)'<\/span>;<\/span><\/span>\n<\/span>\n   <\/span>function<\/span> <\/span>is_email<\/span>(<\/span><\/span>\n      in_email <\/span>in<\/span> <\/span>varchar2<\/span><\/span>\n   ) <\/span>return<\/span> <\/span>boolean<\/span> <\/span>deterministic<\/span> <\/span>is<\/span><\/span>\n   <\/span>begin<\/span><\/span>\n      <\/span>return<\/span> is_email_internal(<\/span><\/span>\n                in_email   => in_email,<\/span><\/span>\n                in_options => json(<\/span>'<\/span><\/span>\n                   {<\/span><\/span>\n                      "allow_display_name": false,<\/span><\/span>\n                      "allow_undescores": false,<\/span><\/span>\n                      "require_display_name": false,<\/span><\/span>\n                      "allow_utf8_local_part": true,<\/span><\/span>\n                      "require_tld": true,<\/span><\/span>\n                      "allow_ip_domain": false,<\/span><\/span>\n                      "domain_specific_validation": false,<\/span><\/span>\n                      "blacklisted_chars": "",<\/span><\/span>\n                      "ignore_max_length": false,<\/span><\/span>\n                      "host_blacklist": ["dubious.com"],<\/span><\/span>\n                      "host_whitelist": []<\/span><\/span>\n                   }<\/span><\/span>\n                '<\/span>)<\/span><\/span>\n             );<\/span><\/span>\n   <\/span>end<\/span> is_email;<\/span><\/span>\nend<\/span> validator_api;<\/span><\/span>\n\/<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    Listing 7 shows the use of the validator in SQL. The second email address is invalid because of the allow_display_name<\/code> option. The third e-mail address is formally correct, but it uses a domain listed under host_blacklist<\/code>.<\/p>\n\n\n\n
    Listing 7: Validate email addresses<\/span><\/path><\/path><\/svg><\/span>
    select<\/span> e_mail, validator_api.is_email(e_mail) <\/span>as<\/span> is_valid<\/span><\/span>\n  <\/span>from<\/span> (<\/span>values<\/span><\/span>\n          (<\/span>'esther.muster@example.com'<\/span>),<\/span><\/span>\n          (<\/span>'Esther Muster <esther.muster@example.com>'<\/span>),<\/span><\/span>\n          (<\/span>'esther.muster@dubious.com'<\/span>)<\/span><\/span>\n       ) test_data (e_mail);<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    E_MAIL                                      IS_VALID<\/span><\/span>\n----------------------------------------- ----------<\/span><\/span>\nesther.muster@example.com                          1<\/span><\/span>\nEsther Muster <esther.muster@example.com>          0<\/span><\/span>\nesther.muster@dubious.com                          0<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    JavaScript With SQL<\/h2>\n\n\n\n
    The MLE provides a global variable session<\/code> of type IConnection<\/a> to communicate with the current database session. Listing 8 shows an example of a simple update statement using bind variables.<\/p>\n\n\n\n
    Listing 8: increase_salary_js <\/span><\/path><\/path><\/svg><\/span>
    create<\/span> <\/span>or<\/span> <\/span>replace<\/span> <\/span>mle<\/span> <\/span>module<\/span> <\/span>increase_salary_mod<\/span> <\/span><\/span>\nlanguage<\/span> <\/span>javascript<\/span> <\/span>as<\/span><\/span>\nexport<\/span> <\/span>function<\/span> <\/span>increase_salary<\/span>(<\/span>deptno<\/span>, <\/span>by_percent<\/span>) {<\/span><\/span>\n   <\/span>session<\/span>.<\/span>execute<\/span>(<\/span>`<\/span><\/span>\n      update emp<\/span><\/span>\n         set sal = sal + sal * :by_percent \/ 100<\/span><\/span>\n         where deptno = :deptno`<\/span>, [<\/span>by_percent<\/span>, <\/span>deptno<\/span>]);<\/span><\/span>\n}<\/span><\/span>\n\/<\/span><\/span>\ncreate<\/span> <\/span>or<\/span> <\/span>replace<\/span> <\/span>procedure<\/span> <\/span>increase_salary_js<\/span>(<\/span><\/span>\n   <\/span>in_deptno<\/span>     <\/span>in<\/span> <\/span>number<\/span>,<\/span><\/span>\n   <\/span>in_by_percent<\/span> <\/span>in<\/span> <\/span>number<\/span><\/span>\n) <\/span>as<\/span> <\/span>mle<\/span> <\/span>module<\/span> <\/span>increase_salary_mod<\/span><\/span>\nsignature<\/span> <\/span>'increase_salary(number, number)'<\/span>;<\/span><\/span>\n\/<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    PL\/SQL With SQL<\/h2>\n\n\n\n
    Listing 9 shows the PL\/SQL counterpart to the JavaScript code in Listing 8, using dynamic SQL with bind variables.<\/p>\n\n\n\n
    Listing 9: increase_salary_dplsql<\/span><\/path><\/path><\/svg><\/span>
    create or replace<\/span> procedure increase_salary_dplsql(<\/span><\/span>\n   in_deptno     <\/span>in<\/span> <\/span>number<\/span>,<\/span><\/span>\n   in_by_percent <\/span>in<\/span> <\/span>number<\/span><\/span>\n) <\/span>is<\/span><\/span>\nbegin<\/span><\/span>\n   <\/span>execute immediate<\/span> <\/span>'<\/span><\/span>\n      update emp<\/span><\/span>\n         set sal = sal + sal * :by_percent \/ 100<\/span><\/span>\n      where deptno = :deptno'<\/span> <\/span>using<\/span> in_by_percent, in_deptno;<\/span><\/span>\nend<\/span> increase_salary_dplsql;<\/span><\/span>\n\/<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    Experienced PL\/SQL developers would not write it this way, as syntax and semantic errors are only thrown at runtime. In addition, it is more expensive for the Oracle Database to execute dynamic SQL, and the use of database objects is not stored in the Oracle Data Dictionary. Instead, experienced PL\/SQL developers use static SQL whenever possible and sensible. The code is shorter and SQL injection is impossible. Listing 10 shows the static SQL variant.<\/p>\n\n\n\n
    Listing 10: increase_salary_plsql<\/span><\/path><\/path><\/svg><\/span>
    create or replace<\/span> procedure increase_salary_plsql(<\/span><\/span>\n   in_deptno     <\/span>in<\/span> <\/span>number<\/span>,<\/span><\/span>\n   in_by_percent <\/span>in<\/span> <\/span>number<\/span><\/span>\n) <\/span>is<\/span><\/span>\nbegin<\/span><\/span>\n   <\/span>update<\/span> emp<\/span><\/span>\n      <\/span>set<\/span> sal = sal + sal * in_by_percent \/ <\/span>100<\/span><\/span>\n    <\/span>where<\/span> deptno = in_deptno;<\/span><\/span>\nend<\/span> increase_salary_plsql;<\/span><\/span>\n\/<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    Performance of increase_salary_...<\/code><\/h2>\n\n\n\n
    Figure 3 compares the runtimes of 100,000 procedure calls in a PL\/SQL loop. Only increase_salary_jsloop<\/code> uses a JavaScript loop. This avoids 100,000 context switches between PL\/SQL and JavaScript. In other words, the difference between increase_salary_js<\/code> and increase_salary_jsloop<\/code> is the cost of 100,000 context switches.<\/p>\n\n\n\n
    \"Runtime<\/a>
    Figure 3: Runtime of 100,000 procedure calls<\/em><\/figcaption><\/figure>\n\n\n\n
    In the Oracle Database version 23.5, JavaScript is about 5 to 6 times slower than PL\/SQL in this example when we use dynamic SQL. In the Oracle Database version 23.3, the difference was a factor of 7, which makes me optimistic that we can expect further performance improvements in future versions.<\/p>\n\n\n\n
    Based on these experiments, it is difficult to make general statements about the performance differences between PL\/SQL and JavaScript. However, it appears that PL\/SQL code with SQL statements has an advantage over JavaScript.<\/p>\n\n\n\n
    MLE Environment<\/h2>\n\n\n\n
    Accessing the network using the JavaScript Fetch API<\/a> is possible, If the appropriate permissions have been granted using the PL\/SQL package dbms_network_acl_admin<\/a><\/code>. However, for security reasons, JavaScript cannot access the database server’s file system.<\/p>\n\n\n\n
    JavaScript runtime environments such as Node.js, Deno, Bun or web browsers, access the file system to import other JavaScript modules. For that, you need an MLE environment in the Oracle Database. Listing 11 shows how to create and use it.<\/p>\n\n\n\n
    Listing 11: Using an MLE environment<\/span><\/path><\/path><\/svg><\/span>
    create or replace<\/span> mle env demo_env<\/span><\/span>\n    imports(<\/span><\/span>\n        <\/span>'increase_salary'<\/span> module increase_salary_mod,<\/span><\/span>\n        <\/span>'validator'<\/span>       module validator_mod,<\/span><\/span>\n        <\/span>'util'<\/span>            module util_mod<\/span><\/span>\n    )<\/span><\/span>\n    <\/span>language<\/span> options  <\/span>'js.strict=true, js.console=false,<\/span><\/span>\n                       js.polyglot-builtin=true'<\/span><\/span>\n;<\/span><\/span>\ncreate or replace<\/span> mle module increase_salary_loop_mod <\/span><\/span>\nlanguage<\/span> javascript <\/span>as<\/span>   <\/span><\/span>\nimport {increase_salary} <\/span>from<\/span> <\/span>"increase_salary"<\/span>;<\/span><\/span>\nexport function increase_salary_loop(deptno,by_percent,times){<\/span><\/span>\n   <\/span>for<\/span> (let i=<\/span>0<\/span>; i<times; i++) {<\/span><\/span>\n      increase_salary(deptno, by_percent);<\/span><\/span>\n   }<\/span><\/span>\n}<\/span><\/span>\n\/<\/span><\/span>\ncreate or replace<\/span> procedure increase_salary_jsloop(<\/span><\/span>\n   in_deptno     <\/span>in<\/span> <\/span>number<\/span>,<\/span><\/span>\n   in_by_percent <\/span>in<\/span> <\/span>number<\/span>,<\/span><\/span>\n   in_times      <\/span>in<\/span> <\/span>number<\/span><\/span>\n) <\/span>as<\/span> mle module increase_salary_loop_mod<\/span><\/span>\nenv demo_env<\/span><\/span>\nsignature <\/span>'increase_salary_loop(number, number, number)'<\/span>;<\/span><\/span>\n\/<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
    The MLE environment demo_env<\/code> maps the import name increase_salary<\/code> to the MLE module increase_salary_mod<\/code>. This import is used in the MLE module increase_salary_loop_mod<\/code>. However, the MLE environment is not assigned there. This is only done in the MLE call specification increase_salary_jsloop<\/code>.<\/p>\n\n\n\n
    MLE environments allow JavaScript code to be structured in the same way inside and outside the database. In most cases, a single MLE environment will be sufficient for an application. Multiple MLE environments are required if different language options are used per module, or if different versions of a module are to be loaded with the same import name.<\/p>\n\n\n\n
    Is Tom Kyte\u2019s Mantra Still Valid?<\/h2>\n\n\n\n
    One of the things Tom Kyte is famous for is his mantra. There are several variations, but all have the same message. This variant is from Expert Oracle Database Architecture, Third Edition, 2014. On page 3 he writes:<\/p>\n\n\n\n
    \n
    I have a pretty simple mantra when it comes to developing database software, one that has been consistent for many years:<\/p>\n\n\n\n
      \n
    • You should do it in a single SQL statement if at all possible. And believe it or not, it is almost always possible. This statement is even truer as time goes on. SQL is an extremely powerful language.<\/li>\n\n\n\n
    • If you can\u2019t do it in a single SQL Statement, do it in PL\/SQL\u2014as little PL\/SQL as possible! Follow the saying that goes “more code = more bugs, less code = less bugs.”<\/li>\n\n\n\n
    • If you can\u2019t do it in PL\/SQL, try a Java stored procedure. The times this is necessary are extremely rare nowadays with Oracle9i and above. PL\/SQL is an extremely competent, fully featured 3GL.<\/li>\n\n\n\n
    • If you can\u2019t do it in Java, do it in a C external procedure. This is most frequently the approach when raw speed or using a third-party API written in C is needed.<\/li>\n\n\n\n
    • If you can\u2019t do it in a C external routine, you might want to seriously think about why it is you need to do it.<\/li>\n<\/ul>\n<\/blockquote>\n\n\n\n
      With Oracle Database 23ai, I would put JavaScript on the same level as PL\/SQL. Before Java, definitely. Furthermore, it is not just a question of whether something can be done in SQL or PL\/SQL. If we need a functionality that already exists in the JavaScript ecosystem, we should consider using it rather than reimplementing it in SQL or PL\/SQL just because it’s possible. Ultimately, it is also about the maintainability of the application and the technical debt we are incurring.<\/p>\n\n\n\n
      Conclusion<\/h2>\n\n\n\n
      MLE was introduced as an experimental feature at Oracle Open World 2017. Since then, MLE and the underlying GraalVM technology have been continuously improved and have reached a good, production-ready state in Oracle Database 23ai. It is ideally suited for integrating existing, tested functionality from the JavaScript ecosystem into the Oracle Database.<\/p>\n\n\n\n
      We still need to figure out how to develop, test, debug and deploy JavaScript with SQL. In any case, JavaScript is a real alternative to PL\/SQL, even if PL\/SQL scores with static SQL and better performance.<\/p>\n\n\n\n
      <\/p>\n","protected":false},"excerpt":{"rendered":"
      JavaScript is the first language supported by the Multilingual Engine (MLE) in Oracle Database 23ai. Having additional languages in the Oracle Database allows us to use existing libraries within the database. Also, it makes it easier for those without PL\/SQL skills to get started with database development. Wasn’t that also the argument [\u2026]<\/span><\/p>\n","protected":false},"author":1,"featured_media":13695,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[5],"tags":[135,140,109,13,103],"class_list":["post-13635","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oracle","tag-javascript","tag-oracle-26ai","tag-pinkdb","tag-plsql","tag-smartdb"],"yoast_head":"\nPL\/SQL vs. JavaScript in the Oracle Database 23ai #JoelKallmanDay - Philipp Salvisberg's Blog<\/title>\n<meta name=\"description\" content=\"What is easier and better in JavaScript than in Java? When is JavaScript a good alternative to PL\/SQL and when is it not?\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"PL\/SQL vs. JavaScript in the Oracle Database 23ai #JoelKallmanDay - Philipp Salvisberg's Blog\" \/>\n<meta property=\"og:description\" content=\"What is easier and better in JavaScript than in Java? When is JavaScript a good alternative to PL\/SQL and when is it not?\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/\" \/>\n<meta property=\"og:site_name\" content=\"Philipp Salvisberg's Blog\" \/>\n<meta property=\"article:published_time\" content=\"2024-10-16T02:22:28+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-03-12T09:22:04+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2024\/10\/plsql_vs_javscript4.webp\" \/>\n\t<meta property=\"og:image:width\" content=\"1024\" \/>\n\t<meta property=\"og:image:height\" content=\"1024\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/webp\" \/>\n<meta name=\"author\" content=\"Philipp Salvisberg\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@phsalvisberg\" \/>\n<meta name=\"twitter:site\" content=\"@phsalvisberg\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Philipp Salvisberg\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"10 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2024\\\/10\\\/16\\\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2024\\\/10\\\/16\\\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\\\/\"},\"author\":{\"name\":\"Philipp Salvisberg\",\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/#\\\/schema\\\/person\\\/34352245c48678b1a5a05d4bc1339515\"},\"headline\":\"PL\\\/SQL vs. JavaScript in the Oracle Database 23ai #JoelKallmanDay\",\"datePublished\":\"2024-10-16T02:22:28+00:00\",\"dateModified\":\"2025-03-12T09:22:04+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2024\\\/10\\\/16\\\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\\\/\"},\"wordCount\":2232,\"commentCount\":2,\"publisher\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/#\\\/schema\\\/person\\\/34352245c48678b1a5a05d4bc1339515\"},\"image\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2024\\\/10\\\/16\\\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/wp-content\\\/uploads\\\/2024\\\/10\\\/plsql_vs_javscript4.webp\",\"keywords\":[\"JavaScript\",\"Oracle 26ai\",\"PinkDB\",\"PL\\\/SQL\",\"SmartDB\"],\"articleSection\":[\"Oracle\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2024\\\/10\\\/16\\\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2024\\\/10\\\/16\\\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\\\/\",\"url\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2024\\\/10\\\/16\\\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\\\/\",\"name\":\"PL\\\/SQL vs. JavaScript in the Oracle Database 23ai #JoelKallmanDay - Philipp Salvisberg's Blog\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2024\\\/10\\\/16\\\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2024\\\/10\\\/16\\\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/wp-content\\\/uploads\\\/2024\\\/10\\\/plsql_vs_javscript4.webp\",\"datePublished\":\"2024-10-16T02:22:28+00:00\",\"dateModified\":\"2025-03-12T09:22:04+00:00\",\"description\":\"What is easier and better in JavaScript than in Java? When is JavaScript a good alternative to PL\\\/SQL and when is it not?\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2024\\\/10\\\/16\\\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2024\\\/10\\\/16\\\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2024\\\/10\\\/16\\\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\\\/#primaryimage\",\"url\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/wp-content\\\/uploads\\\/2024\\\/10\\\/plsql_vs_javscript4.webp\",\"contentUrl\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/wp-content\\\/uploads\\\/2024\\\/10\\\/plsql_vs_javscript4.webp\",\"width\":1024,\"height\":1024,\"caption\":\"PL\\\/SQL vs. JavaScrit in the Oracle Database 23ai\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/2024\\\/10\\\/16\\\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"PL\\\/SQL vs. JavaScript in the Oracle Database 23ai #JoelKallmanDay\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/\",\"name\":\"Philipp Salvisberg's Blog\",\"description\":\"Database-centric development\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/#\\\/schema\\\/person\\\/34352245c48678b1a5a05d4bc1339515\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":[\"Person\",\"Organization\"],\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/#\\\/schema\\\/person\\\/34352245c48678b1a5a05d4bc1339515\",\"name\":\"Philipp Salvisberg\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/wp-content\\\/uploads\\\/2010\\\/11\\\/phs_trivadis4.jpg\",\"url\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/wp-content\\\/uploads\\\/2010\\\/11\\\/phs_trivadis4.jpg\",\"contentUrl\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/wp-content\\\/uploads\\\/2010\\\/11\\\/phs_trivadis4.jpg\",\"width\":400,\"height\":400,\"caption\":\"Philipp Salvisberg\"},\"logo\":{\"@id\":\"https:\\\/\\\/www.salvis.com\\\/blog\\\/wp-content\\\/uploads\\\/2010\\\/11\\\/phs_trivadis4.jpg\"},\"sameAs\":[\"http:\\\/\\\/www.salvis.com\\\/\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"PL\/SQL vs. JavaScript in the Oracle Database 23ai #JoelKallmanDay - Philipp Salvisberg's Blog","description":"What is easier and better in JavaScript than in Java? When is JavaScript a good alternative to PL\/SQL and when is it not?","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/","og_locale":"en_US","og_type":"article","og_title":"PL\/SQL vs. JavaScript in the Oracle Database 23ai #JoelKallmanDay - Philipp Salvisberg's Blog","og_description":"What is easier and better in JavaScript than in Java? When is JavaScript a good alternative to PL\/SQL and when is it not?","og_url":"https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/","og_site_name":"Philipp Salvisberg's Blog","article_published_time":"2024-10-16T02:22:28+00:00","article_modified_time":"2025-03-12T09:22:04+00:00","og_image":[{"width":1024,"height":1024,"url":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2024\/10\/plsql_vs_javscript4.webp","type":"image\/webp"}],"author":"Philipp Salvisberg","twitter_card":"summary_large_image","twitter_creator":"@phsalvisberg","twitter_site":"@phsalvisberg","twitter_misc":{"Written by":"Philipp Salvisberg","Est. reading time":"10 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/#article","isPartOf":{"@id":"https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/"},"author":{"name":"Philipp Salvisberg","@id":"https:\/\/www.salvis.com\/blog\/#\/schema\/person\/34352245c48678b1a5a05d4bc1339515"},"headline":"PL\/SQL vs. JavaScript in the Oracle Database 23ai #JoelKallmanDay","datePublished":"2024-10-16T02:22:28+00:00","dateModified":"2025-03-12T09:22:04+00:00","mainEntityOfPage":{"@id":"https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/"},"wordCount":2232,"commentCount":2,"publisher":{"@id":"https:\/\/www.salvis.com\/blog\/#\/schema\/person\/34352245c48678b1a5a05d4bc1339515"},"image":{"@id":"https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/#primaryimage"},"thumbnailUrl":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2024\/10\/plsql_vs_javscript4.webp","keywords":["JavaScript","Oracle 26ai","PinkDB","PL\/SQL","SmartDB"],"articleSection":["Oracle"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/","url":"https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/","name":"PL\/SQL vs. JavaScript in the Oracle Database 23ai #JoelKallmanDay - Philipp Salvisberg's Blog","isPartOf":{"@id":"https:\/\/www.salvis.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/#primaryimage"},"image":{"@id":"https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/#primaryimage"},"thumbnailUrl":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2024\/10\/plsql_vs_javscript4.webp","datePublished":"2024-10-16T02:22:28+00:00","dateModified":"2025-03-12T09:22:04+00:00","description":"What is easier and better in JavaScript than in Java? When is JavaScript a good alternative to PL\/SQL and when is it not?","breadcrumb":{"@id":"https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/#primaryimage","url":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2024\/10\/plsql_vs_javscript4.webp","contentUrl":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2024\/10\/plsql_vs_javscript4.webp","width":1024,"height":1024,"caption":"PL\/SQL vs. JavaScrit in the Oracle Database 23ai"},{"@type":"BreadcrumbList","@id":"https:\/\/www.salvis.com\/blog\/2024\/10\/16\/pl-sql-vs-javascript-in-the-oracle-database-23ai-joelkallmanday\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.salvis.com\/blog\/"},{"@type":"ListItem","position":2,"name":"PL\/SQL vs. JavaScript in the Oracle Database 23ai #JoelKallmanDay"}]},{"@type":"WebSite","@id":"https:\/\/www.salvis.com\/blog\/#website","url":"https:\/\/www.salvis.com\/blog\/","name":"Philipp Salvisberg's Blog","description":"Database-centric development","publisher":{"@id":"https:\/\/www.salvis.com\/blog\/#\/schema\/person\/34352245c48678b1a5a05d4bc1339515"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.salvis.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":["Person","Organization"],"@id":"https:\/\/www.salvis.com\/blog\/#\/schema\/person\/34352245c48678b1a5a05d4bc1339515","name":"Philipp Salvisberg","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2010\/11\/phs_trivadis4.jpg","url":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2010\/11\/phs_trivadis4.jpg","contentUrl":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2010\/11\/phs_trivadis4.jpg","width":400,"height":400,"caption":"Philipp Salvisberg"},"logo":{"@id":"https:\/\/www.salvis.com\/blog\/wp-content\/uploads\/2010\/11\/phs_trivadis4.jpg"},"sameAs":["http:\/\/www.salvis.com\/"]}]}},"_links":{"self":[{"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/posts\/13635","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/comments?post=13635"}],"version-history":[{"count":55,"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/posts\/13635\/revisions"}],"predecessor-version":[{"id":13854,"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/posts\/13635\/revisions\/13854"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/media\/13695"}],"wp:attachment":[{"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/media?parent=13635"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/categories?post=13635"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.salvis.com\/blog\/wp-json\/wp\/v2\/tags?post=13635"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
    The script mle.js<\/code> in Listing 5 is not read from the local file system as usual but via a URL from GitHub. The script creates a JavaScript module validator_mod<\/code> with the contents of the URL https:\/\/esm.run\/validator@13.12.0<\/a>, which is a minimised, browser-optimised version of the validator.js module in the npm<\/a> software registry. The last parameter 13.12.0<\/code> is the version of the module stored in the Oracle Data Dictionary.<\/p>\n\n\n\n