Modularizing Queries (Groovy)

Modularization (breaking code into loosely coupled, self-contained pieces) is a common practice in software development. It should be used to improve the organization and readability of Deephaven queries in both Python and Groovy. This guide covers best practices for importing Deephaven scripts into Core+ queries from both notebooks and Git repositories. In Groovy, you can import scripts that belong to a package whose name matches their file location.

In order to import Deephaven notebooks found in the File Explorer, the scripts must meet the following requirements:

Belong to a package.
The package name must match its file location. For instance, scripts in the com.example.compute package must be located in com/example/compute.

Note

It's possible for identically named scripts to be available when Git is integrated as a source for notebooks. When this is the case, the script in the filesystem is imported, as it's not under version control.

Copy the following script into a new notebook:

package test.notebook

return "Notebook"

String notebookVar() {
  return "Notebook Level Var"
}

String notebookPassedVar(String passedVar) {
  return passedVar
}

String notebookMethod() {
  return "Called method"
}

static String notebookStaticMethod() {
    return "Called static method"
}

class NotebookClass {
    final String value = "Called class method"
    String getValue() {
        return value
    }
}

static String notebookStaticMethodUsingClass() {
  new NotebookClass().getValue()
}

Then, save the notebook as test/notebook/MyNotebook.groovy. It can then be imported as test.notebook.MyNotebook. The following example imports test/notebook/MyNotebook.groovy and calls its methods:

import io.deephaven.engine.context.ExecutionContext
import io.deephaven.engine.util.TableTools
import test.notebook.MyNotebook

ExecutionContext.getContext().getQueryLibrary().importClass(MyNotebook.class)

MyNotebook.main()

localVar = "Top Level Var"

println new MyNotebook().run()
println new MyNotebook().notebookVar()
println new MyNotebook().notebookPassedVar(localVar)
println new MyNotebook().notebookMethod()
println MyNotebook.notebookStaticMethod()
println MyNotebook.notebookStaticMethodUsingClass()

testTable = TableTools.emptyTable(1).updateView(
        "RunResult = new MyNotebook().run()",
        "NotebookVar = new MyNotebook().notebookVar()",
        "NotebookPassedVar = new MyNotebook().notebookPassedVar(`$localVar`)",
        "NotebookMethod = new MyNotebook().notebookMethod()",
        "NotebookStaticMethod = MyNotebook.notebookStaticMethod()",
        "NotebookClassMethod = MyNotebook.notebookStaticMethodUsingClass()"
)

Note

Per Groovy rules, you can run the script's top-level statements via main() or run(). You can also use its defined methods like a typical Java class.

Note

Each notebook is considered a different module. As such, global or field variables defined in one notebook are not accessible in another. Use the "Var" methods as shown above for passing and retrieving variables.

Import from Git repositories

Importing scripts from an integrated Git repository works the same way as notebooks with one exception: the script package names don't necessarily need to match every directory. For example, if the iris.scripts.repo.<repo>.paths property is set:

iris.scripts.repo.<repo>.paths=module/deephaven

The package found at module/deephaven/com/example/compute will be imported as com.example.compute, leaving out the module/deephaven prefix:

import com.example.compute

Modularizing Queries (Groovy)

Import from Git repositories

Related documentation