With DBStudio we can have script code acting like database stored procedures or functions running on server side. But where do we store this code ?

• We can load scripts from remote http reposirories but this makes no sense for high speed database processing.
• We can load script code from local files but what if you have multiple dbstudio running as application servers ?
• Or we can use the scripts catalog tables that can server as code repository for a specific sccript language.

Each script language is stored in an specific table named dbscripts_[lang]. You can create the scripts table catalog for the appropriate language using DBStudio explorer.

1. Select a database where you plan to store scripts.
2. Select the scripts node and expand it. Click on the selected language.
3. Right click on the desired language and confirm to create the scripts table.
4. Right click again on the selected language to create your first script.
5. Enter the script name and the code (or leave code blank as you can edit it later)
6. Select the new script created to review the code. You have successfully stored your first script in a database table. Not we can try to run our first script.

Let's see how to call the previously stored javascript sum function. We can do it by using two different methods.

1. Using the load function to eval the code inline. The code should return the object or function it wishes to expose to the calling script. Then from declared function in the current context.

   This is the common method in JavaScript programming. You first import (load) the code you need and run with functions declared in a single context.

2. Using a direct call to function using a new context.

   This option is more time expensive but provide better isolation.

Let's see the two examples using a simple sum function that we store with name sum in our database scripts library.

Now, you can run a script in SQL editor and import the library using the Nashorn load command. To resolve the script we will use the database script resolver function that will load the named script from current database instance.

For instance, let suppose we want to a library with formatting utils

return {
    
    
    mask: function(value, pattern) {
        var i = 0,
            v = value.toString();
            
        return pattern.replace(/#/g, _ => v[i++]);
    },
    
    formatNumber: function(value) {
        if (value) 
            return value.toFixed(2).replace(/\d(?=(\d{3})+\.)/g, '$&,');
        return "";    
    }
    
    
}

Then we could use the library

<script>
var formLib = Ax.db.load("format_lib");
console.log("MASK" ,  formLib.mask("746298", "###-##/#"))
console.log("NUMBER", formLib.formatNumber(746298.12))
</script>

"MASK", "746-29/8"
"NUMBER", "746,298.12"

You have successfully executed a script using a library stored in database library.

<script>
load(db.script("db1", "sum"));
return sum(1,2,3);
</script>

6

An optional way to invoke a script is to use the call function.

Let's suppose we have sum function defined in our library:

function sum(a,b) {
    return a + b;
}

The function can be invoked using the call command:

<script>
   return Ax.db.call("sum", 1,2,3);
</script>

6

Or using apply and passing an object array with arguments.

<script>
   return Ax.db.appply("sum", [1,2,3]);
</script>

6

Both methods load the function from database table and executes it. Only difference between call and apply function is how arguments is passed to the function. Using call, arguments are appended after the function name to load and execute. Using apply, all arguments are passed as a single array argument to the function.

Call and Apply are interchangeable. You can decide whether it’s easier to send in an array or a comma separated list of arguments.