ObjectScript QuickStart

ObjectScript QuickStart

15 minutes

Page Contents

Introduction
Try it: Storing and retrieving data using ObjectScript
Try ObjectScript and globals
Try ObjectScript and objects
Try ObjectScript and SQL
Supporting Resources

This QuickStart introduces you to the ObjectScript programming language and gives several examples of how you can use it to store and retrieve data from the InterSystems IRIS® data platform. This QuickStart does not attempt to provide a thorough overview of the language or its capabilities. Use the sources listed at the end of this guide to continue your exploration.

What is ObjectScript?

ObjectScript is a programming language designed for rapidly developing complex business applications on the InterSystems IRIS data platform. ObjectScript source code is compiled into object code that is highly optimized for operations typically found within business applications, including string manipulations and database access.

One of the unique aspects of ObjectScript is its underlying storage structure, known as globals. Globals can be thought of as persistent multidimensional sparse arrays. ObjectScript allows you to access your data directly from globals, but also allows you to access that data through its native object and SQL support.

While you can write an application on the InterSystems IRIS platform using Java, .NET, node.js, or other languages, by using the platform’s many APIs, you can use ObjectScript to write efficient, server-based code that gives you finer control over your data.

Try it: Storing and retrieving data using ObjectScript

In this QuickStart, you will learn how to use ObjectScript to:

Store and retrieve data in globals.
Define a class and instantiate, use, and store objects of that class.
Access the data stored for that class using an SQL query and work with the result set.

As you will see, ObjectScript gives you the ability to store and access your data in multiple ways, for both power and flexibility.

First, make sure you have an instance of InterSystems IRIS and a multi-language IDE ready to go. Sandbox settings will appear below after you log in and launch a sandbox.

Need InterSystems IRIS?
Get a free, online development sandbox here. Log in with your InterSystems universal account, or register for one below.
Login Register
Please launch the sandbox before continuing!.
Clone the FirstLook-ObjectScript repo into the /home/project/shared directory. In the IDE’s terminal window, type:
```
cd /home/project/shared
git clone -b try-iris http://github.com/intersystems/FirstLook-ObjectScript
```

Importing the sample ObjectScript code

Start by importing the sample ObjectScript code into InterSystems IRIS.

There are two ways to open the Management Portal. From the Cloud IDE you can use the menu bar. Navigate to InterSystems > Management Portal. You can also Please launch the sandbox before continuing!.
From within the Management Portal, navigate to System Explorer > Classes.
On the Classes page, look at the left column to make sure you are in the USER namespace. You can think of a namespace as a work space or a directory.
Click Import.
In the Import Classes dialog box:
1. Under Import from a File or a Directory, click File.
2. Browse for the file /home/project/shared/FirstLook-ObjectScript/FirstLookObjectScript.xml.
3. Select Compile Imported Items.
4. For Compile Flags, specify cuk
5. Click Next.
6. Click Import.
7. When a message saying that the load finished successfully appears, click Done.

Now, on the Classes page, you should see FirstLook.ObjectScript.cls and FirstLook.Person.cls in the list of classes. In InterSystems IRIS, the name of the package — FirstLook — is appended with the name of the class (ObjectScript or Person). The extension .cls is used to denote class files.

Note:

If your namespace contains a lot of classes, filter the list by entering F*.cls in the Class Name box in the left column of the page.

Try ObjectScript and globals

If you want to play with a few ObjectScript commands, a good way to do this is to use the InterSystems IRIS Web Terminal.

Back in the Cloud IDE, use the menubar to navigate to InterSystems > Web Terminal. The prompt indicates which namespace you are in. If you are not in the USER namespace, execute the following command:

set $namespace ="USER"

In ObjectScript, you assign a value to a variable by using the set command:

set x = "Welcome to ObjectScript!"

To display the contents of a variable, use the write command:

write x
// Welcome to ObjectScript!

The variable you just created exists only in this Terminal session’s working memory. If you want to store a value in the database, you can use a global, which looks like a variable preceded by a caret (^):

set ^Settings("Color") = "Red"

Globals provide persistent storage, meaning that ^Settings will live on after you close your Terminal session.

This particular global is also an array, with one subscript. Unlike arrays in many other languages, globals can have subscripts that are integers, decimal numbers, or strings. Globals are also sparse, meaning subscripts may or may not be contiguous.

You can take advantage of the multidimensional nature of globals to define a more complex structure:

set ^Settings("Auto1", "Properties", "Color") = "Red"
set ^Settings("Auto1", "Properties", "Model") = "SUV"
set ^Settings("Auto2", "Owner") = "Mo"
set ^Settings("Auto2", "Properties", "Color") = "Green"

To display the all of the nodes in a global, you can use the zwrite command:

zwrite ^Settings
^Settings("Auto1","Properties","Color")="Red"
^Settings("Auto1","Properties","Model")="SUV"
^Settings("Auto2","Owner")="Mo"
^Settings("Auto2","Properties","Color")="Green"
^Settings("Color")="Red"

To retrieve the value stored at a particular node of a global, you can use the $get() function. This function returns the empty string if you try to retrieve a value from a global node that does not exist, avoiding potential undefined errors.

Try the following in the Terminal:

set ^testglobal(1) = 8888

set ^testglobal(2) = 9999

set globalValue = $get(^testglobal(1))

write "The value of ^testglobal(1) is ", globalValue
The value of ^testglobal(1) is 8888

To iterate over the nodes in a global, you can use the $order() function, which returns the next subscript in a global. Passing in a global node with a subscript equal to the empty string causes $order() to return the first subscript. A return value equal to the empty string indicates that $order() has reached the last subscript.

You can write the value returned by a function the same way you wrote the value of a variable or a global:

write $order(^testglobal(""))
// 1
write $order(^testglobal(1))
// 2
write $order(^testglobal(2))

In practice, you would usually create a $order() loop within a class method in an ObjectScript class file. The following method has been provided for you in FirstLook.ObjectScript.cls.

/// Iterate over global ^testglobal
ClassMethod Iterate() {
  // Start by setting subscript to ""
  set subscript = ""
  // "Argumentless" for loop
  for {
    // Get the next subscript
    set subscript = $order(^testglobal(subscript))
    // When we get to the end, quit the for loop
    quit:(subscript = "")
    // Otherwise, write the subscript and the value
    // stored at ^testglobal(subscript)
    write !, "subscript=", subscript, ", value=", ^testglobal(subscript)
  }
}

Note that the “argumentless” for loop specifies no terminating condition and would loop forever, if we did not explicitly quit the loop. The exclamation point in the write statement tells ObjectScript to move to the next line before writing the subscript and value of each node in the global.

To run the method in the Terminal, type:

do ##class(FirstLook.ObjectScript).Iterate()

This yields the output:

subscript=1, value=8888
subscript=2, value=9999

Try ObjectScript and objects

You can use ObjectScript to create classes that have methods and properties. You can then instantiate objects of that class. The sample class FirstLook.Person.cls defines a class Person and then lets you create instances of that class, such as the person John Smith or the person Jane Doe.

The basic class definition looks like this:

Class FirstLook.Person Extends %Persistent
{

Property FirstName As %String [ Required ];

Property LastName As %String [ Required ];

}

The Person class extends the built-in InterSystems IRIS class %Persistent, which gives you access to some helpful methods, such as %New() and %Save(). Then the properties of the class are listed. In this case, you are simply storing a person’s first and last name.

Go ahead and create a new person using the Terminal. If you are not in the USER namespace, execute the following command:

set $namespace = "USER"

To create a new Person object, use the %New() method, which returns a “handle” to the new person, more formally known as an object reference, or OREF. Then set the new person’s properties and call the %Save() method to store the new person in the database.

set person = ##class(FirstLook.Person).%New()

set person.FirstName = "Sarah"
 
set person.LastName = "Aarons"
 
set status = person.%Save()

write status
1

The %Save() method returns a status, which has the value 1 if it succeeds.

When you save an object, InterSystems IRIS stores it in a global for you automatically. The default global name is the class name with a D appended to the end, in this case ^FirstLook.PersonD.

If you display the contents of the global, you can see that the root node (the node without a subscript) holds an ID that is incremented for each new object that is stored. The remainder of the global is subscripted by ID. Each Person node contains a list of property values, where the list is denoted by $lb , for “list build.”

zwrite ^FirstLook.PersonD
^FirstLook.PersonD=1
^FirstLook.PersonD(1)=$lb("","Sarah","Aarons")

You can also define instance methods, which operate on a specific instance, as opposed to class methods, which are generic to a class. For example, FirstLook.Person.cls contains a WriteName() method, which writes a person’s name.

/// Given an instance of a person, write person's name
Method WriteName() {
  write "The name of this person is:"
  write !, ..FirstName
  write !, ..LastName
}

An extra dot in front of a property or method name indicates the current object or class.

Since the variable person currently refers to Sarah Aarons, you can write her name like so:

do person.WriteName()
The name of this person is:
Sarah
Aarons

As an exercise, create, store, and write a few new objects of the Person class.

Try ObjectScript and SQL

You’ve just seen how each person you create is stored as a node in a global. As you will see in this section, each person is also a row in a table, accessible using SQL.

InterSystems offers several ways to use SQL from within ObjectScript. For example, you can use a class query, which is basically an SQL query inside a class file.

The following class query, in FirstLook.Person.cls, does a SELECT command on all objects in the class:

/// Query for all stored names
Query Select() As %SQLQuery [SqlProc]
{
  SELECT %ID, FirstName, LastName 
  FROM Person
  ORDER By LastName, FirstName
}

To test the query, you can run it from the Terminal:

do ##class(%ResultSet).RunQuery("FirstLook.Person", "Select")
 
ID:FirstName:LastName:
4:Kate:Aarons:
1:Sarah:Aarons:
2:Andrew:Shaw:
3:Peter:Shaw:

In real life, you might write a class method, such as the one provided for you in FirstLook.Person.cls, to place the results of the query in a result set and then iterate through each row in the set:

/// Run select query and write all names in result set
ClassMethod WriteAllNames() {
  // Create a new ResultSet object
  set resultSet = ##class(%ResultSet).%New()
  // Specify the class query to execute by setting 
  // the ClassName and QueryName properties.  
  set resultSet.ClassName = "FirstLook.Person"
  set resultSet.QueryName = "Select"
  // Execute the query
  set status = resultSet.%Execute()
  // If status = $$$OK, query is successful
  if (status = $$$OK) {
    // Iterate over results
    while (resultSet.%Next()) {
      // Write person's first and last name
      write !, resultSet.FirstName, " ", resultSet.LastName
    }
  }
}

In this class method, resultSet.%Execute() returns a status of 1 if it is successful. This is often written in code using the $$$OK macro for easier readability. The code loops through the result set using resultSet.%Next(), which returns true if another row exists.

To run the method in the Terminal, type:

do ##class(FirstLook.Person).WriteAllNames()
 
// Kate Aarons
// Sarah Aarons
// Andrew Shaw
// Peter Shaw

As you have seen, ObjectScript gives you several options for working with your data. Using globals gives you the most control over how your data is stored, using objects makes it easy to work with single instances of a class, and SQL gives you the power to operate across the rows of a table. How you choose to think about your data is entirely up to you.