Next, we need to add our two fields, which can be done by right-clicking on the Fields node, but they are much quicker to create by dragging and dropping. To do this, follow these steps:

To aid the user interface design, we can place our fields in groups. This helps us provide a consistent interface for our users and also provides better and centralized control over the UI.

We only need one field group, as there is only a grid view of two fields. We will call this Overview. The following steps will create the field group:

There are two other key field groups, AutoLookup and AutoReport. The AutoLookup field group governs the fields that appear when the system constructs a drop-down list against the table. The AutoReport field group governs the fields that appear should the user choose to create a quick report for the table. For this table, add all the fields to these two groups.

The next part is to set up indexes. We set up indexes both for performance and to enforce unique constraints. There is another more fundamental reason. You may have noticed that the primary and clustered indexes were SurrogateKey. This is the default index, based on the record ID (RecId). Should we add a primary key relation, it will be based on that index and therefore on the RecId field. A record ID foreign key is of little use to us, as we intend the vehicle group ID to be placed on our vehicle table for grouping and reporting purposes.

So, we need to create a unique index based on the VehicleGroupId field, and tell the table to use this as its primary key. To create the primary index, follow these steps:

The final step before we hook up the user interface is to add a find and an exists method. These aren't used by the system, but it is a convention to create these methods on the tables we create. As the table's authors, we understand how to find records on this table and this saves time later as we avoid writing select statements to find the record.

These methods follow the same pattern for all tables we create, and are based on the primary key field, or fields. In our case, we have the VehicleGroupId key field, which is based on the ConFMSVehicleGroupId EDT (type).

The find method allows us to locate a record based (usually) on its primary key, and choose whether or not it should be selected for an update (locked). The method is a static method, which means we don't need to instantiate the table before calling it.

First, to create the find method, right-click on the Methods node and choose New Method. This will show a method template:

private void method1()
{
}

Methods marked as private are only visible for calls within this table. Our method is designed to be called from other objects and these methods are also declared as static, which is done as follows:

public static void method1()
{
}

The next part is the type of object the method returns. The method template assumes to be void. We want to return a record of the type ConFMSVehicleGroup, so replace void with the table name, but watch what happens as you type.

Replace void with the table name, but watch what happens as you type:

Use the arrow keys to choose the appropriate type from the pop-up list. In this case, it is highlighted, so just press Enter.

Rename the method to find, and specify the parameters that the method accepts: the primary key field and whether or not the record should be selected for update.

These are specified as follows:

public static ConFMSVehicleGroup find(
                               ConFMSVehicleGroupId _groupId, 
                               boolean _forUpdate = false)
{
}

We now have a vehicle group and know whether we should lock the record. We can now write the method's content.

The pattern for this method is similar each time we use it, and is done by:

To save making a needless select call, we can also make the call only if the vehicle group is not empty. The final code will be like this:

public static ConFMSVehicleGroup find(ConFMSVehicleGroupId _groupId, boolean _forUpdate = false)
{
    ConFMSVehicleGroup vehicleGroup;
    
    vehicleGroup.selectForUpdate(_forUpdate);
    if(_groupId != "")   
    {
        select firstonly vehicleGroup 
            where vehicleGroup.VehicleGroupId == _groupId;
    }
    return vehicleGroup;    
}

The exists method is similar but returns true or false, depending on whether the record was found. The way to determine whether a record was found is to check whether the record ID is zero or not.

To improve performance, we will select only the RecId column from the table. The method should look like this:

public static boolean exist(ConFMSVehicleGroupId _groupId)
{
    ConFMSVehicleGroup vehicleGroup;
    if(_groupId != "")   
{
     select RecId 
         from vehicleGroup 
         where vehicleGroup.VehicleGroupId == _groupId;
}
    return (vehicleGroup.RecId != 0);        
}

Close the code editor and press Save All.

Aside from some user interface elements, our table is complete. You can browse the data in it using the table browser by choosing Open from the table's context menu on the table.

You will notice some system-generated fields here, which are as follows: