Using Caché Objects
Other Options for Persistent Classes
[Back] [Next]
   
Server:docs2
Instance:LATEST
User:UnknownUser
 
-
Go to:
Search:    

This chapter describes other options that are available for persistent classes. It discusses the following topics:

Also see the chapters Introduction to Persistent Objects, Working with Persistent Objects, and Defining Persistent Classes,” as well as the appendix Using the Object Synchronization Feature.”
When viewing this book online, use the preface of this book to quickly find other topics.
Defining a Read-Only Class
It is possible to define a persistent class whose objects can be opened but not saved or deleted. To do this, specify the READONLY parameter for the class as 1:
Parameter READONLY = 1;
This is only useful for cases where you have objects that are mapped to preexisting storage (such as existing globals or an external database). If you call the %Save() method on a read-only object, it will always return an error code.
Adding Indices
Indices provide a mechanism for optimizing searches across the instances of a persistent class; they define a specific sorted subset of commonly requested data associated with a class. They are very helpful in reducing overhead for performance-critical searches.
Indices automatically span the entire extent of the class in which they are defined. If a Person class has a subclass Student, all indices defined in Person contain both Person objects and Student objects. Indices defined in the Student class contain only Student objects.
Indices can be sorted on one or more properties belonging to their class. This allows you a great deal of specific control of the order in which results are returned.
In addition, indices can store additional data that is frequently requested by queries based on the sorted properties. By including additional data as part of an index, you can greatly enhance the performance of the query that uses the index; when the query uses the index to generate its result set, it can do so without accessing the main data storage facility. (See the Data keyword below.)
For additional information on indices, refer to the Defining and Building Indices chapter in Caché SQL Optimization Guide; of particular interest may be the section Properties That Can Be Indexed.” Also see Index Definitions in the Caché Class Definition Reference.
Adding Foreign Keys
To enforce referential integrity between tables you can define foreign keys in the corresponding persistent classes. When a table containing a foreign key constraint is modified, the foreign key constraints are checked. One way to add foreign keys is to add relationships between classes; see the chapter Defining and Using Relationships.” You can also add explicit foreign keys to classes. For information, see Using Foreign Keys in Using Caché SQL. Also see Foreign Key Definitions in the Caché Class Definition Reference.
Adding Triggers
Because Caché SQL supports the use of triggers, any trigger associated with a persistent class is included as part of the SQL projection of the class.
Triggers are code segments executed when specific events occur in Caché SQL. Caché supports triggers based on the execution of INSERT, UPDATE, and DELETE commands. The specified code will be executed either immediately before or immediately after the relevant command is executed, depending on the trigger definition. Each event can have multiple triggers as long as they are assigned an execution order.
If a trigger is defined with Foreach = row/object, then the trigger is also called at specific points during object access. See Triggers and Transactions in “Using Triggers” in Using Caché SQL.
Triggers are also fired by the persistence methods used by the legacy storage class, %CacheSQLStorage because it uses SQL statements internally to implement its persistent behavior.
For more information on triggers, see Triggers in Using Caché SQL. Also see Trigger Definitions in the Caché Class Definition Reference.
Referring to Fields from Caché ObjectScript
Within a class definition, there are several places that may include Caché ObjectScript code used in SQL. For example, SQL computed field code and trigger code is executed from within SQL. In these cases, there is no concept of a current object, so it is not possible to use dot syntax to access or set data within a specific instance. Instead, you can access the same data as fields within the current row using field syntax.
To reference a specific field of the current row, use the {fieldname} syntax where fieldname is the name of the field.
For example, the following code checks if the salary of an employee is less than 50000:
 If {Salary} < 50000 {
    // actions here...
 }
Note:
In UPDATE trigger code, {fieldname} denotes the updated field value. In DELETE trigger code, {fieldname} denotes the value of the field on disk.
To refer to the current field in a SQL computed field, use the {*} syntax.
For example, the following code might appear in the computed code for a Compensation field to compute its value based on the values of Salary and Commission fields:
 Set {*} = {Salary} + {Commission}
For trigger-specific syntax, see the Special Trigger Syntax section in the “Defining Triggers” chapter in Using Caché SQL.
Adding Row-Level Security
In addition to its general security, Caché offers SQL security with a granularity of a single row. This is called row-level security. With row-level security, each row holds a list of authorized viewers, which can be either users or roles. For more information on users and roles, see the Users and Roles chapters of the Caché Security Administration Guide.
Typically, SQL security is controlled by granting SELECT privilege on a table or view to a user or role. The use of roles simplifies access control when the number of security roles is substantially fewer than the number of users. In most cases, view-level security provides adequate control over which rows each user can select; however, when the number of views required to achieve the desired control becomes very large, another alternative for fine-grained access control is needed.
For example, a hospital may make patient-specific data available online to each patient. Creating a separate view for each patient is not a practical alternative; instead, fine-grained access control, in conjunction with the Caché role-based authentication model, enables this type of application to be created efficiently and securely through row-level security.
The following are constraints on the use of row-level security:
Setting Up Row-Level Security
To enable row-level security for a table, edit the definition of the class from which the table is projected. The procedure for this is:
  1. In Studio, on the Class menu, select Override. On the dialog that appears, go to the Parameters tab and select the ROWLEVELSECURITY parameter.
  2. In the class definition code, set the value of ROWLEVELSECURITY to 1, such as:
    ROWLEVELSECURITY = 1;
    This definition for the parameter means that row-level security is active and that the class uses the generated %READERLIST property to store information about users and roles with authorized access to the row.
    Alternatively, you can define the parameter as follows:
    ROWLEVELSECURITY = rlsprop;
    Where rlsprop is the name of a property in the same class. This alternative means that row-level security is active and that the class uses the given property to store information about users and roles with authorized access to the row. In this case, also add an index to the class as follows:
    Index %RLI On rlsprop;
  3. Define a %SecurityPolicy() class method, which determines and specifies the role and usernames that are permitted to select the row, subject to view and table SELECT privileges.
    The structure of the %SecurityPolicy() method is:
    ClassMethod %SecurityPolicy() As %String [ SqlProc ]
    {
        QUIT ""
    }
    Its characteristics are:
    Important:
    A user who is assigned to the %All role does not automatically have access to rows in a table that are protected with row-level security. If %All is to have access to such a row, the %SecurityPolicy() method must explicitly specify this.
  4. Compile the class and any dependent classes.
Adding Row-Level Security to a Table with Existing Data
To add row-level security to a table with existing data, first follow the procedure described in the previous section, Setting Up Row-Level Security.” Then:
  1. Rebuild the indices for the table.
  2. Update the value of the property that lists the users and roles who can view each row.
Rebuilding the Indices
Caution:
Do not rebuild indices while users are accessing the data for this table. Doing so may result in inaccurate query results.
The procedure to rebuild the indices for a table is:
  1. If the table has any views defined that have the WITH CHECK OPTION clause, remove these views with the DROP VIEW command. (You can re-create these views after updating who has access to each row).
  2. Go to the Management Portal SQL page ([Home] > [SQL]) and select the namespace that contains the table.
  3. Select Browse SQL Schemas, which displays the [Home] > [SQL] > [Schemas] page.
  4. On the Schemas page, in the row for the package containing the table that you just modified, select Tables to display the Tables page for it.
  5. On the Tables page, select the name of the table in the Name column to display the Table Properties page.
  6. On the Table Properties page, select Rebuild Indices to rebuild the indices.
Updating Who Can View Each Row
The procedure to do this is:
  1. From the Management Portal home page, go to the Execute SQL Query page ([Home] > [SQL] > [Execute SQL Query]) page.
  2. Select the namespace that contains the table.
  3. In the editable area on the Execute SQL Query page, issue a statement to update the table. It should have the following form:
    UPDATE MySchema.MyClass SET rlsprop = 
                    MySchema.SecurityPolicy(MySQLColumnName1, ...)
    where
  4. Click Execute Query.
  5. If desired, re-create any view that you initially removed.
Performance Tips and Information
The %READERLIST property is a calculated field and its value is determined by the %SecurityPolicy() method. Whenever an INSERT or UPDATE occurs, %SecurityPolicy() is invoked for that row and populates the value of %READERLIST.
A collection index on the %READERLIST property is defined, and can be exploited by the query optimizer to minimize the performance impact when row-level security is enabled.
By default, when you set ROWLEVELSECURITY equal to 1, a collection index is defined for the %READERLIST property (column) because the security policy can, in general, return more than one comma-separated role or username. If your security policy never returns more than one user or role name, then you can override the ROWLEVELSECURITY parameter and explicitly define the %RLI index as an ordinary (non-collection) bitmap index. This generally provides optimal performance.
Security Tips and Information
Keep in mind the following security factors when using row-level security: