Previous		Next
UnitTests		RSDTable

RSDEngine - The Rapid and Secure Development Engine

aka The Rocket Science Development Engine

Lukas Feiler

lukas.feiler@chello.at

Introduction
What The RSDEngine Is Not
Input - Configuration Options

Output - The Implementation

Files Generated For Web Applications

Extending the generated Code

Introduction

The basic idea of the RSDEngine is to sepeate things that change from things that do not. What does change in every application is the data that is managed with it - the database design. But what does not change, is the way this data is created, updated, selected or deleted. Everything or let's say the most of the things that 'stay the same' can be therefore generated. The rest is analysis and cannot be performed by a computer but by an analyst - a database designer! The RSDEngine needs the result of the analysis - the database design - and a few other configuration options as input and outputs an implementation of this analysis based on a very modular and flexible design.

What The RSDEngine Is Not

The RSDEngine is not an all-purpose code generator. It only generates code for a specific type of application - database backended applications. It will not implement complex business logic for you. What it does, is to implement a powerful interface to your relational data. Note: it is possible to generate projects that are not database backended. This can be very useful as well but keep in mind that the power of the RSDEngine lies in generating code for accessing a database!

Input - Configuration Options

The RSDEngine needs an associative array of configuration options as input. This associative array must be passed to the method RSDEngine::generate. The RSDEngine understands the following configuration options:

General: $config['versioning']

Whether to create a project with versioning support. In fact this option is just stored in the config file - the RSDEngine has nothing else to with it. This configuration option is used by EVS. If $config['versioning'] is true the project will be created with versioning support.

General: $config['projectName']

The name of your project. This option is obligatory!

General: $config['projectDescription']

A short description of your project containing no newline characters. This field is optional.

General: $config['authors']

A list of authors in the following format:

   			Firstname Lastname <name@host.tld>

Multile authors are separated by newline characters ('\n').

General: $config['copyright']

A string containing copyright information. Must not contain newline characters.

General: $config['skel']

The path to the skel (skeleton directory). Set this option to an empty string if you do not want a skel to be used. This would be the case if you are regenerating a project. Please see Basic Directory Structure

General: $config['updateVersionAfterRelease']

Whether to update all @version tags in all files found in the version directory when making a new release. In fact this option is just stored in the config file - the RSDEngine has nothing else to with it. This configuration option is used by EVS. EVSVersion actually performs the update after making a new release.

General: $config['phpDocumentorDir']

The path to the directory where PHPDocumentor is installed. In fact this option is just stored in the config file - the RSDEngine has nothing else to with it. This configuration option is used by EVS. Example: /usr/share/php/phpDocumentor/. Use forward slashes and place one at the end of the path! You do not even have to specify an absolute path - just make sure a require_once statement as the following will not fail:


1     require_once("${phpDocumentorDir}phpdoc.php");

General: $config['install']

The contents of the obligatory INSTALL file.

General: $config['readme']

The contents of the obligatory README file.

Database Backend: $config['databaseBackend']

If the supplied value evaluates to the boolean value true support for a database backend will be implemented. Creating code for accassing a database is probably the most powerful feature of the RSDEngine. See Database Backend: $config['sql'].

Database Backend: $config['databaseHost']

The name of the host on which the database runs on - ignored if Database Backend: $config['databaseBackend'] is set to false.

Database Backend: $config['databaseName']

The name of the database - ignored if Database Backend: $config['databaseBackend'] is set to false.

Database Backend: $config['databaseUsername']

The username to use to connect to the database - ignored if Database Backend: $config['databaseBackend'] is set to false.

Database Backend: $config['databasePassword']

The password to use to connect to the database - ignored if Database Backend: $config['databaseBackend'] is set to false.

Database Backend: $config['databaseType']

The type of the database. Only databases supported by PEAR::DB are valid - ignored if Database Backend: $config['databaseBackend'] is set to false.

Database Backend: $config['databaseEnsureReferentialIntegrity']

Whether to ensure referential integrity. This has the advantage that errors will be catchted earlyer and it will be possible to tell which column violated which constraint. The disadvantage is the reduced speed. Note that this option cannot ensured referential integrity in you database. If you really need referential integrity use a relational database (which MySQL prior to 4.0 definitely is not). It only configures the isValid-Methods and the method checkUniqueConstraints. Ignored if Database Backend: $config['databaseBackend'] is set to false.

Database Backend: $config['tablePrefix']

The prefix used for all tables in Database Backend: $config['sql'] - ignored if Database Backend: $config['databaseBackend'] is set to false.

Database Backend: $config['columnPrefix']

The prefix used for all columns in Database Backend: $config['sql'] - ignored if Database Backend: $config['databaseBackend'] is set to false.

Database Backend: $config['validationClassName']

The name of the static class that provides the validation methods that can be used in the /**isValid:...**/ statements in in $config['sql']. Please see Column Modifier /**isValid:TYPE:ARG1:ARG2:ARG3...**/. The default is 'RSValidation' (RSValidation). This configuration option will be ignored if Database Backend: $config['databaseBackend'] is set to false.

Database Backend: $config['validationClassFile']

The name of the file in which the validation class is definded. Please see Database Backend: $config['validationClassName']. The default is 'RSValidation/RSValidation.php' (RSValidation). This configuration option will be ignored if Database Backend: $config['databaseBackend'] is set to false.

Database Backend: $config['fileStorageDirectory']

The default storage directory for uploaded files. Please see Column Modifier /**isValid:TYPE:ARG1:ARG2:ARG3...**/. This configuration option will be ignored if Database Backend: $config['databaseBackend'] is set to false.

Database Backend: $config['additionalConfig']

This can be a multiline string containing constant definitions (valid PHP code). For example:


1     /**This right is required to create new records in the table prj_document.
2     */
3     define('PRJ_LIVEUSER_RIGHT_DOCUMENT_CREATE', 1);
4     
5     /**This right is required to select records from the table prj_document.
6     */
7     define('PRJ_LIVEUSER_RIGHT_DOCUMENT_SELECT', 2);

This configuration option will be ignored if Database Backend: $config['databaseBackend'] is set to false.

Database Backend: $config['sql']

The SQL DDL of this project - ignored if Database Backend: $config['databaseBackend'] is set to false.

Formatting

The CREATE TABLE statements must be formatted as follows:

CREATE TABLE t_user(
    f_userid NUMBER PRIMARY KEY UNIQUE NOT NULL
        /**isValid:isInt**/
        /**sequence:t_user_userid**/
    ,
    f_group_id NUMBER /**isValid:isInt**/,
    f_firstname VARCHAR(100) /**isValid:isString:2:30**/,
    f_lastname VARCHAR(200) /**isValid:isString:2:30**/,
    f_activated CHAR(1)
        /**isValid:in:'0':'1'**/
        /**defaultInsert:'1'**/
    ,
    UNIQUE(f_firstname,f_lastname),
    FOREIGN KEY (f_group_id) REFERENCES(t_group.f_groupid)
);

Note that is is allowed (and somethimes even recommended) to put each configuration option on a separated line (as for f_activated). If Table Modifiers - General are used the formatting differs a bit:

CREATE TABLE t_user
    /**option1**/
    /**option2**/
(
    f_userid NUMBER PRIMARY KEY UNIQUE NOT NULL
        /**isValid:isInt**/
        /**sequence:t_user_userid**/,
    f_group_id NUMBER /**isValid:isInt**/,
    f_firstname VARCHAR(100) /**isValid:isString:2:30**/,
    f_lastname VARCHAR(200) /**isValid:isString:2:30**/,
    UNIQUE(f_firstname,f_lastname),
    FOREIGN KEY (f_group_id) REFERENCES(t_group.f_groupid)
);

The specification of a table type is valid as well:

CREATE TABLE t_user
    /**option1**/
    /**option2**/
(
    f_userid NUMBER PRIMARY KEY UNIQUE NOT NULL
        /**isValid:isInt**/
        /**sequence:t_user_userid**/,
    f_group_id NUMBER /**isValid:isInt**/,
    f_firstname VARCHAR(100) /**isValid:isString:2:30**/,
    f_lastname VARCHAR(200) /**isValid:isString:2:30**/,
    UNIQUE(f_firstname,f_lastname),
    FOREIGN KEY (f_group_id) REFERENCES(t_group.f_groupid)
) TYPE=MyISAM;

Note:

If possible use just one line for the definition of one column. If you use a lot of column modifyers (/**...**/) you can put each one on a separate line to increase readability. A comma (`,') must be the last character of the column definition! If fact a split(",\n") operation is used to separate the column definitions.
A column modifyer (e.g. /**isValid**/) must not go over multiple lines.
A table modifier (e.g. /**LiveUserRight**/) may go over multiple lines.
The opening parenthesis of the CREATE TABLE statement is the last character on the line.
The closing parenthesis followed by an optional table type definition and a semi-colon must be the only characters on the last line.
Primary keys are defined as column constraints. This is just a convention but you are on the save side doing it this way (and your code is compatible to the RSD Coding Conventions).
Foreign keys are defined as table constraints.
The unique constraint that involves only one column is defined as column constraint. This is just a convention but you are on the save side doing it this way (and your code is compatible to the RSD Coding Conventions).
The unique constraint that involves more than one column is defined as table constraint.

Table Modifiers - General

Table modifiers can be set beween the table name and the opening brace. The following format is strongly recommended.


1     CREATE TABLE t_user
2         /**modifier1**/
2     
3         /**modifier2**/
3     
4     (
5         f_userid NUMBER PRIMARY KEY UNIQUE NOT NULL,
6         f_group_id NUMBER,
7         f_firstname VARCHAR(100),
8         f_lastname VARCHAR(200),
9         UNIQUE(f_firstname,f_lastname),
10        FOREIGN KEY (f_group_id) REFERENCES(t_group.f_groupid)
11    );

It is recommended to wirte a table option on a single line if possible! It is possible though to write it over multiple lines. But realize that an opening brace on the end of a line is considered as the end of the table modifier section! Please follow the following coding conventions:

If table modifiers are used the opening brace must be placed on a single line!
The table modifiers are surrunded by '/**' and '**/'.
The table modifiers are (unlike columns!) NOT separated by commas.

Table Modifier /ignore/

If a table is defined with this table modifier it is completly ignored.


1     CREATE TABLE t_user
2         /**ignore**/
2     
3     (
4         f_userid NUMBER PRIMARY KEY UNIQUE NOT NULL,
5         f_group_id NUMBER,
6         f_firstname VARCHAR(100),
7         f_lastname VARCHAR(200),
8         UNIQUE(f_firstname,f_lastname),
9         FOREIGN KEY (f_group_id) REFERENCES(t_group.f_groupid)
10    );

Table Modifier /label/

This option defines which SQL expression will be used to define the lable of a record of the defined column. The label is used in all popup menues to represent a record. The default is to use the first column defined as VARCHAR.


1     CREATE TABLE t_user
2         /**label:CONCAT(CONCAT(f_lastname, ", "), f_firstname)**/
2     
3     (
4         f_userid NUMBER PRIMARY KEY UNIQUE NOT NULL,
5         f_group_id NUMBER,
6         f_firstname VARCHAR(100),
7         f_lastname VARCHAR(200),
8         UNIQUE(f_firstname,f_lastname),
9         FOREIGN KEY (f_group_id) REFERENCES(t_group.f_groupid)
10    );

Table Modifier /beforeInsert:PHP_CODE/

With this option you can define PHP code to get executed right before the insert operation.


1     CREATE TABLE t_user
2         /**beforeInsert:$registrationhistory =& $this->app->getTable('t_registrationhistory');
3         $error = $registrationhistory->insert(
4             array(
5                 'f_user_id' > $inserts['f_userid']
6             );
7         );
8         if (PEAR::isError($error)) {
9             return $error;
10        }
11        **/
11    
12    (
13        f_userid NUMBER PRIMARY KEY UNIQUE NOT NULL,
14        f_group_id NUMBER,
15        f_firstname VARCHAR(100),
16        f_lastname VARCHAR(200),
17        UNIQUE(f_firstname,f_lastname),
18        FOREIGN KEY (f_group_id) REFERENCES(t_group.f_groupid)
19    );
20    
21    CREATE TABLE t_registrationhistory (
22        f_user_id NUMBER,
23        f_registrationdate DATETIME NOT NULL 
24            /**defaultInsert:new RSDColumnValue('NOW()', '!')**/
24    
25            /**doNotUpdate**/
25    
26    );

Context: The code specified will be run before an insert operation. You will mostly use the variable $inserts which is an associative array containing column name and column value pairs (to be inserted). Not that a column value can be specifed as a string or as an instance of RSDColumnValue. Please see {@see RSDColumnValue}.

Table Modifier /afterInsert:PHP_CODE/

With this option you can define PHP code to get executed right after the insert operation.


1     CREATE TABLE t_user
2         /**afterInsert:$registrationhistory =& $this->app->getTable('t_registrationhistory');
3         $error = $registrationhistory->insert(
4             array(
5                 'f_user_id' > $inserts['f_userid']
6             );
7         );
8         **/
8     
9     (
10        f_userid NUMBER PRIMARY KEY UNIQUE NOT NULL,
11        f_group_id NUMBER,
12        f_firstname VARCHAR(100),
13        f_lastname VARCHAR(200),
14        UNIQUE(f_firstname,f_lastname),
15        FOREIGN KEY (f_group_id) REFERENCES(t_group.f_groupid)
16    );
17    
18    CREATE TABLE t_registrationhistory (
19        f_user_id NUMBER,
20        f_registrationdate DATETIME NOT NULL 
21            /**defaultInsert:new RSDColumnValue('NOW()', '!')**/
21    
22            /**doNotUpdate**/
22    
23    );

Context: The code specified will be run after a successful insert operation. If the insert failed for some reasons an instance of PEAR_Error will be returned before the spcecified code could be run. You will mostly use the variable $inserts which is an associative array containing column name and column value pairs. Not that a column value can be specifed as a string or as an instance of RSDColumnValue. Please see {@see RSDColumnValue}.

Table Modifier /beforeUpdate:PHP_CODE/

With this option you can define PHP code to get executed right before the update operation.


1     CREATE TABLE t_user
2         /**beforeUpdate:$changehistory =& $this->app->getTable('t_changehistory');
3         $error = $registrationhistory->insert(
4             array(
5                 'f_user_id' > $record['f_userid']
6             );
7         );
8         if (PEAR::isError($error)) {
9             return $error;
10        }
11        **/
11    
12    (
13        f_userid NUMBER PRIMARY KEY UNIQUE NOT NULL,
14        f_group_id NUMBER,
15        f_firstname VARCHAR(100),
16        f_lastname VARCHAR(200),
17        UNIQUE(f_firstname,f_lastname),
18        FOREIGN KEY (f_group_id) REFERENCES(t_group.f_groupid)
19    );
20    
21    CREATE TABLE t_changehistory (
22        f_user_id NUMBER,
23        f_changedate DATETIME NOT NULL 
24            /**defaultInsert:new RSDColumnValue('NOW()', '!')**/
24    
25            /**doNotUpdate**/
25    
26    );

Context: The code specified will be run before an update operation. The code is placed inside a while loop that loops over all records that will be affected by the update operation. You will mostly use the variable $record which represents (obviously) a record that will be updated. $record will always be an associative array with the column names as keys.

Table Modifier /afterUpdate:PHP_CODE/

With this option you can define PHP code to get executed right after the update operation.


1     CREATE TABLE t_user
2         /**afterUpdate:$changehistory =& $this->app->getTable('t_changehistory');
3         $error = $registrationhistory->insert(
4             array(
5                 'f_user_id' > $record['f_userid']
6             );
7         );
8         if (PEAR::isError($error)) {
9             return $error;
10        }
11        **/
11    
12    (
13        f_userid NUMBER PRIMARY KEY UNIQUE NOT NULL,
14        f_group_id NUMBER,
15        f_firstname VARCHAR(100),
16        f_lastname VARCHAR(200),
17        UNIQUE(f_firstname,f_lastname),
18        FOREIGN KEY (f_group_id) REFERENCES(t_group.f_groupid)
19    );
20    
21    CREATE TABLE t_changehistory (
22        f_user_id NUMBER,
23        f_changedate DATETIME NOT NULL 
24            /**defaultInsert:new RSDColumnValue('NOW()', '!')**/
24    
25            /**doNotUpdate**/
25    
26    );

Context: The code specified will be run after a successful update operation. If the update failed for some reasons an instance of PEAR_Error will be returned before the spcecified code could be run. The code is placed inside a while loop that loops over all records that where affected by the update operation. You will mostly use the variable $record which represents (obviously) a record that was updated. $record will always be an associative array with the column names as keys. NOTE: The records that you reference via $record are already updated!

Table Modifier /beforeDelete:PHP_CODE/

With this option you can define PHP code to get executed right before the delete operation.


1     CREATE TABLE t_user
2         /**beforeDelete:$deletehistory =& $this->app->getTable('t_deletehistory');
3         $error = $registrationhistory->insert(
4             array(
5                 'f_user_id' > $record['f_userid']
6             );
7         );
8         if (PEAR::isError($error)) {
9             return $error;
10        }
11        **/
11    
12    (
13        f_userid NUMBER PRIMARY KEY UNIQUE NOT NULL,
14        f_group_id NUMBER,
15        f_firstname VARCHAR(100),
16        f_lastname VARCHAR(200),
17        UNIQUE(f_firstname,f_lastname),
18        FOREIGN KEY (f_group_id) REFERENCES(t_group.f_groupid)
19    );
20    
21    CREATE TABLE t_deletehistory (
22        f_user_id NUMBER,
23        f_deletedate DATETIME NOT NULL 
24            /**defaultInsert:new RSDColumnValue('NOW()', '!')**/
24    
25            /**doNotUpdate**/
25    
26    );

Context: The code specified will be run before a delete operation. The code is placed inside a while loop that loops over all records that will be affected by the delete operation. You will mostly use the variable $record which represents (obviously) a record that will be deleted. $record will always be an associative array with the column names as keys.

Table Modifier /afterUpdate:PHP_CODE/

With this option you can define PHP code to get executed right after the delete operation.


1     CREATE TABLE t_user
2         /**afterDelete:$deletehistory =& $this->app->getTable('t_deletehistory');
3         $error = $registrationhistory->insert(
4             array(
5                 'f_user_id' > $record['f_userid']
6             );
7         );
8         if (PEAR::isError($error)) {
9             return $error;
10        }
11        **/
11    
12    (
13        f_userid NUMBER PRIMARY KEY UNIQUE NOT NULL,
14        f_group_id NUMBER,
15        f_firstname VARCHAR(100),
16        f_lastname VARCHAR(200),
17        UNIQUE(f_firstname,f_lastname),
18        FOREIGN KEY (f_group_id) REFERENCES(t_group.f_groupid)
19    );
20    
21    CREATE TABLE t_deletehistory (
22        f_user_id NUMBER,
23        f_deletedate DATETIME NOT NULL 
24            /**defaultInsert:new RSDColumnValue('NOW()', '!')**/
24    
25            /**doNotUpdate**/
25    
26    );

Context: The code specified will be run after a successful delete operation. If the delete failed for some reasons an instance of PEAR_Error will be returned before the spcecified code could be run. The code is placed inside a while loop that loops over all records that where affected by the delete operation. You will mostly use the variable $record which represents (obviously) a record that was updated. $record will always be an associative array with the column names as keys. NOTE: Do not forget that the records you access via $record actually do not exist any more (they have already been deleted).

Table Modifier /LiveUserRight[:$OPERATION]:rightId=$RIGHT_ID|condition=PHP_CODE|recordCondition=PHP_CODE/

This option must be in the following format:

/**LiveUserRight[:$OPERATION]:rightId=$RIGHT_ID|condition=PHP_CODE|recordCondition=PHP_CODE**/

Or a little more specific:

/**LiveUserRight[:select|insert|update|delete|all][:rightId=column|table.column|SQL_QUERY|PHP_CODE]|[condition=PHP_CODE|recordCondition=PHP_CODE]**/

$OPERATION can therefore be one of:

'insert': The types of $RIGHT_ID you can use for this operation are 'SQL_QUERY', 'PHP_CODE', 'table.column' and 'column' (even if using the last one does not really make sense). Additionally you can use condition=PHP_CODE but not recordCondition=PHP_CODE.
'select': If the type of $RIGHT_ID is 'column' or 'table.column' or recordCondition=PHP_CODE is used, the generated select method will only return those records the user has access to. If the user has access to no records an empty array of records will be returned and no error will be raised. If $RIGHT_ID is of the type 'SQL_QUERY' or 'PHP_CODE' or condition=PHP_CODE is used, the generated select method will return all requested records or raise a permission violation error. The selectIncluding* methods act the same with one important difference: if the type of $RIGHT_ID is 'table.column' the selectIncluding methods will only perform a permission check if the table that contains the right-IDs is included in the join the method performs.
'update': In contrast to 'select' the generated method 'update' will only update all requested records or none. If the permission for only one record is missing the whole update operation fails and a permission denied error is raised.
'delete': In contrast to 'select' the generated method 'delete' will only delete all requested records or none. If the permission for only one record is missing the whole delete operation fails and a permission denied error is raised.

'all': If $OPERATION is set to 'all' this LiveUserRight option will be internally duplicated for each possible operation. This means that using the $RIGHT_ID type 'column' does not really make sense. But be aware that it is possible to overwrite an 'all'-operation:


1     CREATE TABLE t_document
2         /**LiveUserRight:all:condition=false**/
2     
3         /**LiveUserRight:select:condition=true**/
3     
4     (
5         f_documentid INTEGER NOT NULL PRIMARY KEY
6             /**isValid:isInt**/
6     
7             /**sequence:prj_document_documentid**/
7     ,
8         f_folder_id INTEGER /**isValid:isInt**/
8     ,
9         f_selectdocumentright /**isValid:isInt**/
9     ,
10        f_lastmodified DATE
11            /**isValid:isDate**/
11    
12            /**defaultInsert:new RSDColumnValue('NOW()','!')**/
12    
13            /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
13    ,
14        f_title VARCHAR(100) /**isValid:isString:2:100**/
14    
15    );

This allows a select operation for everybody and forbids everything else. It is equivalent to the following:


1     CREATE TABLE t_document
2         /**LiveUserRight:insert:condition=false**/
2     
3         /**LiveUserRight:update:condition=false**/
3     
4         /**LiveUserRight:delete:condition=false**/
4     
5         /**LiveUserRight:select:condition=true**/
5     
6     (
7         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
7      /**sequence:prj_document_documentid**/
7     ,
8         f_folder_id INTEGER /**isValid:isInt**/
8     ,
9         f_selectdocumentright /**isValid:isInt**/
9     ,
10        f_lastmodified DATE /**isValid:isDate**/
10     /**defaultInsert:new RSDColumnValue('NOW()','!')**/
10     /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
10    ,
11        f_title VARCHAR(100) /**isValid:isString:2:100**/
11    
12    );

none: If $OPERATION is omitted 'all' is assumed. Therefore the following is valid:


1     CREATE TABLE t_document
2         /**LiveUserRight:condition=true**/
2     
3     (
4         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
4      /**sequence:prj_document_documentid**/
4     ,
5         f_folder_id INTEGER /**isValid:isInt**/
5     ,
6         f_selectdocumentright /**isValid:isInt**/
6     ,
7         f_lastmodified DATE /**isValid:isDate**/
7      /**defaultInsert:new RSDColumnValue('NOW()','!')**/
7      /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
7     ,
8         f_title VARCHAR(100) /**isValid:isString:2:100**/
8     
9     );

$RIGHT_ID: internally $RIGHT_ID can be one of the following types:

'column': If $RIGHT_ID consists only of lowercase alphanumeric characters and underscores ([a-z0-9_]*) it is treated as a column name of the current table. Choose this option if it must be possible to rescrict access to every record individually. For each record the referenced column will hold the corresponding rightId. NOTE: the name of a column that holds a rightId must be UNIQUE in the whole database design! This is becuase when joining multiple tables the result ends up in an associative array which cannot contain to fields named 'f_rightid'. RSD will warn you if two columns have the same name. Using this type does not make a lot of sense when the $OPERATION is 'insert' - but it is possible. Here is an example:


1     CREATE TABLE t_document
2         /**LiveUserRight:select:rightId=f_selectdocumentright**/
2     
3     (
4         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
4      /**sequence:prj_document_documentid**/
4     ,
5         f_folder_id INTEGER /**isValid:isInt**/
5     ,
6         f_selectdocumentright /**isValid:isInt**/
6     ,
7         f_lastmodified DATE /**isValid:isDate**/
7      /**defaultInsert:new RSDColumnValue('NOW()','!')**/
7      /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
7     ,
8         f_title VARCHAR(100) /**isValid:isString:2:100**/
8     
9     );

In the above example the generated select method will return only those records to which the user has access (has the right saved in f_selectdocumentright by id). If the the user has access to no records an empty array containing no records will be returned. Here is an other example with update:


1     CREATE TABLE t_document
2         /**LiveUserRight:select:rightId=f_selectdocumentright**/
2     
3         /**LiveUserRight:update:rightId=f_updatedocumentright**/
3     
4     (
5         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
5      /**sequence:prj_document_documentid**/
5     ,
6         f_folder_id INTEGER /**isValid:isInt**/
6     ,
7         f_selectdocumentright /**isValid:isInt**/
7     ,
8         f_updatedocumentright /**isValid:isInt**/
8     ,
9         f_lastmodified DATE /**isValid:isDate**/
9      /**defaultInsert:new RSDColumnValue('NOW()','!')**/
9      /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
9     ,
10        f_title VARCHAR(100) /**isValid:isString:2:100**/
10    
11    );

The generated method 'update' will raise an error if the user does not have the rights saved in f_updatedocumentright for all columns she is about to update. So there is no 'partial' update - the requested update operation is performed or not. The same is true for delete:


1     CREATE TABLE t_document
2         /**LiveUserRight:select:rightId=f_selectdocumentright**/
2     
3         /**LiveUserRight:update:rightId=f_updatedocumentright**/
3     
4         /**LiveUserRight:delete:rightId=f_deletedocumentright**/
4     
5     (
6         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
6      /**sequence:prj_document_documentid**/
6     ,
7         f_folder_id INTEGER /**isValid:isInt**/
7     ,
8         f_selectdocumentright /**isValid:isInt**/
8     ,
9         f_updatedocumentright /**isValid:isInt**/
9     ,
10        f_deletedocumentright /**isValid:isInt**/
10    ,
11        f_lastmodified DATE /**isValid:isDate**/
11     /**defaultInsert:new RSDColumnValue('NOW()','!')**/
11     /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
11    ,
12        f_title VARCHAR(100) /**isValid:isString:2:100**/
12    
13    );

'table.column': If $RIGHT_ID consists of two sets of lowercase alphanumeric characters and underscores separated by a dot ([a-z0-9_]*\.[a-z0-9_]*) the expression is treated as a reference to a column of an other table that stores right-IDs. The expression is only considered valid if any relations lead to this table. The scenario for this type is quite complex but imagine the following specification: There are documents and folders. Every document is assigned to one folder. The user should only be able to access those documents that are in folders he has access to. To prevent saving the same rightId in multiple document records we need to reference the rightId saved in the folder record:


1     CREATE TABLE t_document
2         /**LiveUserRight:select:rightId=t_folder.f_selectfolderright**/
2     
3     (
4         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
4      /**sequence:seq_prj_document_documentid**/
4     ,
5         f_folder_id INTEGER /**isValid:isInt**/
5     ,
6         f_lastmodified DATE /**isValid:isDate**/
6      /**defaultInsert:new RSDColumnValue('NOW()','!')**/
6      /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
6     ,
7         f_documentname VARCHAR(100) /**isValid:isString:2:100**/
7     ,
8         FOREIGN KEY (f_folder_id) REFERENCES t_folder (f_folderid)
9     );
10    
11    CREATE TABLE t_folder
12        /**LiveUserRight:select:rightId=f_selectfolderright**/
12    
13    (
14        f_folderid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
14     /**sequence:seq_prj_folder_folderid**/
14    ,
15        f_foldername VARCHAR(100) /**isValid:isString:2:100**/
15    ,
16        f_selectfolderright /**isValid:isInt**/
16    
17    );

This works because the method RSDEngineDBTable::_getSelectIncludingMethodName finds the selectIncluding* method that performs a join over both tables based on the foreign key t_document.f_folder_id referencing the primary key t_folder.f_folderid. The generated method select will only return those records the user has access to. Again the methods 'delete' and 'update' raise a permission denied error if the permission for a single records is missing. Since RSDEngine v0.1.10 the type 'table.column' can be used for the operation 'insert' as well. In this case the RSDEngine tries to find a table that is directly related to the current table and is as well related to the 'target' table specified by 'table.column'.

'SQL_QUERY': If $RIGHT_ID starts with the word 'SELECT' and conains as well the words 'FROM' and 'WHERE' in this order the expression is treated as an SQL SELECT query. The query will be surrounded by double quotes (") and passed to PEAR::DB's method getOne as argument. Think of it like this:


1     $rightId = $db->getOne("WHATEVER_YOU_TYPED");

The most important difference to 'column' and 'table.column' is that the right is checked only once - not for every record! Let's go back to the privous example of documents and folders. If we only want to allow a user to create documents in folders she has (read-) access to we would do it like this:


1     CREATE TABLE t_document
2         /**LiveUserRight:select:rightId=t_folder.f_selectfolderright**/
2     
3         /**LiveUserRight:insert:rightId=SELECT f_selectfolderright FROM efx_folder WHERE f_folderid=" . $this->db->quote($inserts['f_folder_id']) . "**/
3     
4     (
5         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
5      /**sequence:seq_prj_document_documentid**/
5     ,
6         f_folder_id INTEGER /**isValid:isInt**/
6     ,
7         f_lastmodified DATE /**isValid:isDate**/
7      /**defaultInsert:new RSDColumnValue('NOW()','!')**/
7      /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
7     ,
8         f_documentname VARCHAR(100) /**isValid:isString:2:100**/
8     ,
9         FOREIGN KEY (f_folder_id) REFERENCES t_folder (f_folderid)
10    );
11    
12    CREATE TABLE t_folder
13        /**LiveUserRight:select:rightId=f_selectfolderright**/
13    
14    (
15        f_folderid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
15     /**sequence:seq_prj_folder_folderid**/
15    ,
16        f_foldername VARCHAR(100) /**isValid:isString:2:100**/
16    ,
17        f_selectfolderright /**isValid:isInt**/
17    
18    );

Note that we need to close the string with a double quote (") and open it afterwards again if we want to interrupt the SQL query. Be aware that $inserts['f_folder_id'] is not quoted by that time. To prevent a SQL injection we need to call $this->db->quote.

'PHP_CODE': If $RIGHT_ID is not of the type 'column', 'table.column' or 'SQL_QUERY' the expression is treadted as PHP code. Think of it like this:


1     $rightId = WHATEVER_YOU_TYPED;

The most important difference to 'column' and 'table.column' is that the right is checked only once - not for every record! The most common usage will be the use of constants that are used to save certain right-IDs. Use Database Backend: $config['additionalConfig'] to define these constants. In the following example the user must have the right with the ID saved in PRJ_LIVEUSER_RIGHT_DOCUMENT_SELECT in order to select records from this table.


1     CREATE TABLE t_document
2         /**LiveUserRight:select:PRJ_LIVEUSER_RIGHT_DOCUMENT_SELECT**/
2     
3     (
4         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
4      /**sequence:prj_document_documentid**/
4     ,
5         f_folder_id INTEGER /**isValid:isInt**/
5     ,
6         f_selectdocumentright /**isValid:isInt**/
6     ,
7         f_lastmodified DATE /**isValid:isDate**/
7      /**defaultInsert:new RSDColumnValue('NOW()','!')**/
7      /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
7     ,
8         f_title VARCHAR(100) /**isValid:isString:2:100**/
8     
9     );

Now a little more complex example. It solves the same problem as the example of 'SQL_QUERY'.


1     CREATE TABLE t_document
2         /**LiveUserRight:select:rightId=t_folder.f_selectfolderright**/
2     
3         /**LiveUserRight:insert:rightId=$this->db->getOne("SELECT f_istemplatefolder FROM efx_folder WHERE f_folderid=" . $this->db->quote($inserts['f_folder_id']))**/
3     
4     (
5         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
5      /**sequence:seq_prj_document_documentid**/
5     ,
6         f_folder_id INTEGER /**isValid:isInt**/
6     ,
7         f_lastmodified DATE /**isValid:isDate**/
7      /**defaultInsert:new RSDColumnValue('NOW()','!')**/
7      /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
7     ,
8         f_documentname VARCHAR(100) /**isValid:isString:2:100**/
8     ,
9         FOREIGN KEY (f_folder_id) REFERENCES t_folder (f_folderid)
10    );
11    
12    CREATE TABLE t_folder
13        /**LiveUserRight:select:rightId=f_selectfolderright**/
13    
14    (
15        f_folderid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
15     /**sequence:seq_prj_folder_folderid**/
15    ,
16        f_foldername VARCHAR(100) /**isValid:isString:2:100**/
16    ,
17        f_selectfolderright /**isValid:isInt**/
17    
18    );

The object that represents the table t_document and contains the method 'insert' has a property named 'db' that holds a handle to an instance of PEAR::DB. This is why we need to call $this->db->getOne. Be aware that $inserts['f_folder_id'] is not quoted by that time. To prevent a SQL injection we need to call $this->db->quote.

The settings condition=PHP_CODE and recordCondition=PHP_CODE are completly defferent. As the left operand implies it is no more about fetching a right id (and checking if the current user has this right). These settings give you the ability to define any condition.

condition=PHP_CODE: The PHP code specified is only executed once. To save resources, use this setting whereever you can. To prevent the deletion by anybody but an administrator:


1     CREATE TABLE t_document
2         /**LiveUserRight:delete:condition=$this->app->isAdmin()**/
2     
3     (
4         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
4      /**sequence:prj_document_documentid**/
4     ,
5         f_folder_id INTEGER /**isValid:isInt**/
5     ,
6         f_selectdocumentright /**isValid:isInt**/
6     ,
7         f_lastmodified DATE /**isValid:isDate**/
7      /**defaultInsert:new RSDColumnValue('NOW()','!')**/
7      /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
7     ,
8         f_title VARCHAR(100) /**isValid:isString:2:100**/
8     
9     );

But be aware that this condition will be used as well in the generated method canDelete. As this method is not always called with an argument the following would cause NOTICES:


1     CREATE TABLE t_document
2         /**LiveUserRight:delete:condition=$this->app->isAdmin() && $record['f_folder_id'] != '666'**/
2     
3     (
4         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
4      /**sequence:prj_document_documentid**/
4     ,
5         f_folder_id INTEGER /**isValid:isInt**/
5     ,
6         f_selectdocumentright /**isValid:isInt**/
6     ,
7         f_lastmodified DATE /**isValid:isDate**/
7      /**defaultInsert:new RSDColumnValue('NOW()','!')**/
7      /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
7     ,
8         f_title VARCHAR(100) /**isValid:isString:2:100**/
8     
9     );

You should make sure the variables you use are initialised:


1     CREATE TABLE t_document
2         /**LiveUserRight:delete:condition=$this->app->isAdmin() && isset($record['f_folder_id']) && $record['f_folder_id'] != '666'**/
2     
3     (
4         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
4      /**sequence:prj_document_documentid**/
4     ,
5         f_folder_id INTEGER /**isValid:isInt**/
5     ,
6         f_selectdocumentright /**isValid:isInt**/
6     ,
7         f_lastmodified DATE /**isValid:isDate**/
7      /**defaultInsert:new RSDColumnValue('NOW()','!')**/
7      /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
7     ,
8         f_title VARCHAR(100) /**isValid:isString:2:100**/
8     
9     );

This would keep the notices away but our canDelete method would allways return false if called with no arguements. To fix this you could write:


1     CREATE TABLE t_document
2         /**LiveUserRight:delete:condition=(!isset($record['f_folder_id']) && $this->app->isAdmin()) || ($this->app->isAdmin() && isset($record['f_folder_id']) && $record['f_folder_id'] != '666')**/
2     
3     (
4         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
4      /**sequence:prj_document_documentid**/
4     ,
5         f_folder_id INTEGER /**isValid:isInt**/
5     ,
6         f_selectdocumentright /**isValid:isInt**/
6     ,
7         f_lastmodified DATE /**isValid:isDate**/
7      /**defaultInsert:new RSDColumnValue('NOW()','!')**/
7      /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
7     ,
8         f_title VARCHAR(100) /**isValid:isString:2:100**/
8     
9     );

This is only advisable if the isValid options for f_folder_id would prevent the insertion of a record with f_folder_id not set. One more thing: if you want to reference a column value in an insert operation you have to use $inserts (not $record!):


1     CREATE TABLE t_document
2         /**LiveUserRight:insert:condition=(!isset($inserts['f_folder_id']) && $this->app->isAdmin()) || ($this->app->isAdmin() && isset($inserts['f_folder_id']) && $inserts['f_folder_id'] != '666')**/
2     
3     (
4         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
4      /**sequence:prj_document_documentid**/
4     ,
5         f_folder_id INTEGER /**isValid:isInt**/
5     ,
6         f_selectdocumentright /**isValid:isInt**/
6     ,
7         f_lastmodified DATE /**isValid:isDate**/
7      /**defaultInsert:new RSDColumnValue('NOW()','!')**/
7      /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
7     ,
8         f_title VARCHAR(100) /**isValid:isString:2:100**/
8     
9     );

This is probably a bit confusing but results from the fact that we simply do not deal with a record!

recordCondition=PHP_CODE: The PHP code specified is executed for every record. PHP_CODE will be implemented inside of a while loop. The variable $record will allways point to the current record. This setting cannot be used for the $OPERATION 'insert'. To prevent the deletion of document of the folder ID 666 you would write:


1     CREATE TABLE t_document
2         /**LiveUserRight:delete:recordCondition=$record['f_folder_id'] != 666**/
2     
3     (
4         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
4      /**sequence:prj_document_documentid**/
4     ,
5         f_folder_id INTEGER /**isValid:isInt**/
5     ,
6         f_selectdocumentright /**isValid:isInt**/
6     ,
7         f_lastmodified DATE /**isValid:isDate**/
7      /**defaultInsert:new RSDColumnValue('NOW()','!')**/
7      /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
7     ,
8         f_title VARCHAR(100) /**isValid:isString:2:100**/
8     
9     );

Table Modifier /file:OPTIONS/

The following definition of file modifier is more specific (spread over multiple lines to increase readability):


1     /**file
2     [:type=controllers|templates|classes|get|getOne|search|delete|update|create|getController|getOneController|searchController|deleteController|updateController|createController|getTemplate|getOneTemplate|searchTemplate|deleteTemplate|updateTemplate|createTemplate|childClass|baseClass|all]
3     [:write=true|false|overwrite]
4     [:public=true|false]
5     [:header=true|false]
6     [:footer=true|false]
7     [:showKeyColumns=true|false]
8     [:orderBy=SQL_EXPRESSION]
9     [:allowUserOrderBy=true|false]
10    [:paging=true|false]
11    [:recordsPerPage=X
12    [:selectMethodName=methodName]
13    [:separateRecordTemplate=true|false]
14    **/

The file modifier knows the folling options:

type - this options defines for which file(s) the specified settings should be applied. type can be one of the following:
- controllers: this is a container for getController, getOneController, searchController, deleteController, updateController and createController.
- templates: this is a container for getTemplate, getTemplateRecord, getOneTemplate, searchTemplate, searchTemplateRecord, deleteTemplate, updateTemplate and createTemplate.
- classes: this is a container for childClass and baseClass.
- get: this is a container for getController, getTemplate and getTemplateRecord.
- getOne: this is a container for getOneController and getOneTemplate.
- search: this is a container for searchController, searchTemplate and searchTemplateRecord.
- delete: this is a container for deleteController and deleteTemplate.
- update: this is a container for updateController and updateTemplate.
- create: this is a container for createController and createTemplate.
- all: this is a container for all possible types.
- getController: the controller file for selecting records from a table.
- getOneController: the controller file for selecting a single record from a table. Please note that the getOneStored-controller will be affected as well by this setting (see {@see RSDEngineDBControllerFileGetStored}). (It was not considered worth introducting another type)
- searchController: the controller file for searching records in a table.
- deleteController: the controller file for deleting records from a table.
- updateController: the controller file for updating records in a table. This setting will affect as well the updateArea, updateGroup and updateRight controllers (see {@see RSDEngineDBControllerFileUpdateGroup}, {@see RSDEngineDBControllerFileUpdateArea}, {@see RSDEngineDBControllerFileUpdateRight}).
- createController: the controller file for inserting a record into a table.
- getTemplate: the template file for selecting records from a table.
- getTemplateRecord: the template file for displaying a record from within a getTemplate; please see Web Application: $config['separateRecordTemplate'] (Default).
- getOneTemplate: the template file for selecting a single record from a table.
- searchTemplate: the template file for searching records in a table.
- searchTemplateRecord: the template file for displaying a record from within a searchTemplate; please see Web Application: $config['separateRecordTemplate'] (Default).
- deleteTemplate: the template file for deleting records from a table.
- updateTemplate: the template file for updating records in a table. This setting will affect as well the updateArea, updateGroup and updateRight templates (see {@see RSDEngineDBTemplateFileUpdateGroup}, {@see RSDEngineDBTemplateFileUpdateArea}, {@see RSDEngineDBTemplateFileUpdateRight}).
- createTemplate: the template file for inserting a record into a table.
- childClass: the RSDTable child class.
- baseClass: the RSDTable base class.
write - this options defines under which conditions the file should be written. write can be one of the following:
- true: write the file if it does not already exist.
- false: do not write the file.
- overwrite: write the file, if it already exists, overwrite it.
If this option is not specified the defaults will be used:
- for the file type 'getController': Web Application: $config['writeControllerGet']
- for the file type 'getOneController': Web Application: $config['writeControllerGetOne']
- for the file type 'updateController': Web Application: $config['writeControllerUpdate']
- for the file type 'deleteController': Web Application: $config['writeControllerDelete']
- for the file type 'searchController': Web Application: $config['writeControllerSearch']
- for the file type 'createController': Web Application: $config['writeControllerCreate']
- for the file type 'getTemplate': Web Application: $config['writeTemplateGet']
- for the file type 'getOneTemplate': Web Application: $config['writeTemplateGetOne']
- for the file type 'updateTemplate': Web Application: $config['writeTemplateUpdate']
- for the file type 'deleteTemplate': Web Application: $config['writeTemplateDelete']
- for the file type 'searchTemplate': Web Application: $config['writeTemplateSearch']
- for the file type 'createTemplate': Web Application: $config['writeTemplateCreate']
public - this options defines whether the specified controller should be public (require no password authentication). Please note that the option only effects controller file types. public can be one of the following:
- true: the controller requires no password authentication
- false: the controller requires password authentication
If this option is not specified the defaults will be used:
- for the file type 'getController': Web Application: $config['getControllersArePublic'] (Default)
- for the file type 'getOneController': Web Application: $config['getOneControllersArePublic'] (Default)
- for the file type 'updateController': Web Application: $config['updateControllersArePublic'] (Default)
- for the file type 'deleteController': Web Application: $config['deleteControllersArePublic'] (Default)
- for the file type 'searchController': Web Application: $config['searchControllersArePublic'] (Default)
- for the file type 'createController': Web Application: $config['createControllersArePublic'] (Default)
header - this options defines whether the specified controller or template should include a header file. Please note that the option only effects controller and temlate file types. header can be one of the following:
- true: the generated controller will include header.php; the template header.tpl
- false: the generated controller and template will include no header file.
If this option is not specified the default defined in Web Application: $config['useHeader'] (Default) will be used.
footer - this options defines whether the specified controller or template should include a footer file. Please note that the option only effects controller and temlate file types. footer can be one of the following:
- true: the generated controller will include footer.php; the template footer.tpl
- false: the generated controller and template will include no footer file.
If this option is not specified the default defined in Web Application: $config['useFooter'] (Default) will be used.
showKeyColumns - this options defines whether to display the columns defined as primary or foreing key in the templates. Please note that the option only effects get, getRecord, getOne, select and selectRecord templates. showKeyColumns can be one of the following:
- true: the key columns will be displayed as well; This is usually not what you want. You should consider using the file option selectMethodName (see below).
- false: do not display the key columns.
If this option is not specified the default defined in Database Backend: $config['showKeyColumns'] (Default) will be used.
orderBy - this options defines the ORDER BY clause to be used by default for a getController or a searchController. Please note that the option only effects getController and searchController file types. orderBy can be any valid SQL ORDER BY clause (without the 'ORDER BY'). For example 'f_jobtitle DESC'. If this option is not specified no ORDER BY clause will be used by default.
allowUserOrderBy - this options defines whether the specified controller or template should implement a feature that lets the user define the sort order of the selected records. Please note that the option only effects getController, getTemlate, searchController and searchTemlate file types. allowUserOrderBy can be one of the following:
- true: the generated controller and template will allow the user to perfor a sort by each column
- false: the generated controller and template will not allow any sorting operation by the user
If this option is not specified the default defined in Web Application: $config['allowUserOrderBy'] (Default) will be used.
paging - this options defines whether the specified controller or template should implement the paging feature. Please note that the option only effects getController, getTemlate, searchController and searchTemlate file types. paging can be one of the following:
- true: the generated controller and template will implement the paging feature
- false: the generated controller and template will not implement the paging feature
If this option is not specified the defaults will be used:
- for the file type 'getController' and 'getTemplate': Database Backend: $config['getPaging']
- for the file type 'searchController' and 'searchTemplate': Database Backend: $config['searchPaging']
Please note that it does not make any sense to set paging to true for a template but not for the corresponding controller.
recordsPerPage - this options defines the the number of records to be displayed per page (if the paging feature is activated). Please note that the option only effects getController and searchController file types. If this option is not specified the default defined in Database Backend: $config['recordsPerPage'] will be used.
selectMethodName - this options defines the selectIncluding method to use to retrieve the records for the specified controller. Please note that the option only effects getController, getTemplate, getOneController, getOneTemplate, searchController and searchTemplate file types. If this option is not specified the defaults will be used:
- for the file type 'getController' and 'getTemplate': Database Backend: $config['getSelectMethodName']
- for the file type 'getOneController' and 'getOneTemplate': Database Backend: $config['getOneSelectMethodName']
- for the file type 'searchController' and 'searchTemplate': Database Backend: $config['searchSelectMethodName']
Please note that it does not make any sense to define to different selectIncluding methods for a controller and its corresponding template. The specifed selectIncluding method must be really generated by the RSDEngine.
separateRecordTemplate - this options defines whether the specified template should directly implement the way a record is displayed or should rather include an other file to perfor this operation. Please note that the option only effects getTemlate and searchTemlate file types. separateRecordTemplate can be one of the following:
- true: and other file will be included to do the display work
- false: implement it directly in the specified template
If this option is not specified the default defined in Web Application: $config['separateRecordTemplate'] (Default) will be used. This feature can come in handy if you duplicate the generated template and want to change the way a record is displayed only once.

To prevent the delete-controller from getting written to disk and to make the get-controller public you would define:

CREATE TABLE prj_user
    /**file:type=deleteController:write=false**/
    /**file:type=getController:public=true**/
(
    f_userid INT,
    f_firstname VARCHAR(100),
    f_lastname VARCHAR(100)
);

To prevent as well the delete-template from getting written you could write:

CREATE TABLE prj_user
    /**file:type=delete:write=false**/
    /**file:type=getController:public=true**/
(
    f_userid INT,
    f_firstname VARCHAR(100),
    f_lastname VARCHAR(100)
);

This works becuase delete is a "container". It is equivalent to writing

CREATE TABLE prj_user
    /**file:type=deleteController:write=false**/
    /**file:type=deleteTemplate:write=false**/
    /**file:type=getController:public=true**/
(
    f_userid INT,
    f_firstname VARCHAR(100),
    f_lastname VARCHAR(100)
);

If you want the get and the getOne controller to use the selectIncluding-method selectIncludingAll and the search controller to use selectIncludingDirectlyRelated you could write

CREATE TABLE prj_user
    /**file:type=get:selectMethodName=selectIncludingAll**/
    /**file:type=getOne:selectMethodName=selectIncludingAll**/
    /**file:type=search:selectMethodName=selectIncludingDirectlyRelated**/
(
    f_userid INT,
    f_firstname VARCHAR(100),
    f_lastname VARCHAR(100)
);

You could as well write

CREATE TABLE prj_user
    /**file:type=all:selectMethodName=selectIncludingAll**/
    /**file:type=search:selectMethodName=selectIncludingDirectlyRelated**/
(
    f_userid INT,
    f_firstname VARCHAR(100),
    f_lastname VARCHAR(100)
);

The first /**file**/ modifier is owerwritten by the second one for the type and options specified. This means that in the following example orderBy will be `f_firstname DESC' for all controllers:

CREATE TABLE prj_user
    /**file:type=all:selectMethodName=selectIncludingAll:orderBy=f_firstname DESC**/
    /**file:type=search:selectMethodName=selectIncludingDirectlyRelated**/
(
    f_userid INT,
    f_firstname VARCHAR(100),
    f_lastname VARCHAR(100)
);

Note: the second /**file**/ modifier only overwrites selectMethodName for the file type 'search' - nothing else.

Table Modifier /excludeSelectMethod:REG_EXPR[,REG_EXPR][,REG_EXPR][...]/

With this table modifier you can reduce the number of generated selectIncluding-methods. This is useful because the RSDEngine creates a selectIncluding-method for every possible combination of tables that are related to the current table. But you cannot exclude selectIncluding-methods that are required to produce ready-to-run code. This means that you cannot exclude selectIncludingAll, selectIncludingDirectlyRelated and all methods required to retrieve a LiveUser right or were explicitly specified with the selectMethodName option of the table modifier /**file**/.

Technically spoken selectIncludingAll, selectIncludingDirectlyRelated and all methods returned by {@see RSDEngineDBTable::_getSelectIncludingMethodName} or passed to {@see RSDEngineDBTable::getSelectMethodColumns} cannot be excluded.

The regular expressions you specify are used in the following way:


1     preg_match("/^$REG_EXPR\$/", $methodName)

This allows you to specify a comma separated list of method names you want to be excluded - without thinking about perl regular expressions:

CREATE TABLE pcs_message
    /**excludeSelectMethod:selectIncludingDiscussion,selectIncludingDiscussionAndProject**/
(
  f_messageid BIGINT UNSIGNED NOT NULL,
  f_messagetype_id BIGINT UNSIGNED NOT NULL,
  f_user_id BIGINT UNSIGNED NOT NULL /**defaultInsert:$this->app->getUserId()**/ /**doNotUpdate**/,
  f_discussion_id BIGINT UNSIGNED NOT NULL,
  f_messagecreationdate DATETIME NULL /**defaultInsert:new RSDColumnValue('NOW()', '!')**/,
  f_messagesubject VARCHAR(255) NOT NULL,
  f_content TEXT NOT NULL,
  PRIMARY KEY(f_messageid),
  INDEX idx_pcs_message_messagetype_id(f_messagetype_id),
  INDEX idx_pcs_message_user_id(f_user_id),
  INDEX idx_pcs_message_discussion_id(f_discussion_id),
  FOREIGN KEY(f_discussion_id)
    REFERENCES pcs_discussion(f_discussionid)
      ON DELETE NO ACTION
      ON UPDATE NO ACTION,
  FOREIGN KEY(f_user_id)
    REFERENCES pcs_user(f_userid)
      ON DELETE NO ACTION
      ON UPDATE NO ACTION,
  FOREIGN KEY(f_messagetype_id)
    REFERENCES pcs_messagetype(f_messagetypeid)
      ON DELETE NO ACTION
      ON UPDATE NO ACTION
);

To exclude all methods that perform a join over pcs_message, pcs_discussion and 3rd table you would write:

CREATE TABLE pcs_message
    /**excludeSelectMethod:selectIncludingDiscussionAnd[A-Z][a-z]***/
(
  f_messageid BIGINT UNSIGNED NOT NULL,
  f_messagetype_id BIGINT UNSIGNED NOT NULL,
  f_user_id BIGINT UNSIGNED NOT NULL /**defaultInsert:$this->app->getUserId()**/ /**doNotUpdate**/,
  f_discussion_id BIGINT UNSIGNED NOT NULL,
  f_messagecreationdate DATETIME NULL /**defaultInsert:new RSDColumnValue('NOW()', '!')**/,
  f_messagesubject VARCHAR(255) NOT NULL,
  f_content TEXT NOT NULL,
  PRIMARY KEY(f_messageid),
  INDEX idx_pcs_message_messagetype_id(f_messagetype_id),
  INDEX idx_pcs_message_user_id(f_user_id),
  INDEX idx_pcs_message_discussion_id(f_discussion_id),
  FOREIGN KEY(f_discussion_id)
    REFERENCES pcs_discussion(f_discussionid)
      ON DELETE NO ACTION
      ON UPDATE NO ACTION,
  FOREIGN KEY(f_user_id)
    REFERENCES pcs_user(f_userid)
      ON DELETE NO ACTION
      ON UPDATE NO ACTION,
  FOREIGN KEY(f_messagetype_id)
    REFERENCES pcs_messagetype(f_messagetypeid)
      ON DELETE NO ACTION
      ON UPDATE NO ACTION
);

But the most common use of this table modifier will be to exclude all methods that are not somehow required. A synonym for `.*' is `all' or `ALL':

CREATE TABLE pcs_message
    /**excludeSelectMethod:ALL**/
(
  f_messageid BIGINT UNSIGNED NOT NULL,
  f_messagetype_id BIGINT UNSIGNED NOT NULL,
  f_user_id BIGINT UNSIGNED NOT NULL /**defaultInsert:$this->app->getUserId()**/ /**doNotUpdate**/,
  f_discussion_id BIGINT UNSIGNED NOT NULL,
  f_messagecreationdate DATETIME NULL /**defaultInsert:new RSDColumnValue('NOW()', '!')**/,
  f_messagesubject VARCHAR(255) NOT NULL,
  f_content TEXT NOT NULL,
  PRIMARY KEY(f_messageid),
  INDEX idx_pcs_message_messagetype_id(f_messagetype_id),
  INDEX idx_pcs_message_user_id(f_user_id),
  INDEX idx_pcs_message_discussion_id(f_discussion_id),
  FOREIGN KEY(f_discussion_id)
    REFERENCES pcs_discussion(f_discussionid)
      ON DELETE NO ACTION
      ON UPDATE NO ACTION,
  FOREIGN KEY(f_user_id)
    REFERENCES pcs_user(f_userid)
      ON DELETE NO ACTION
      ON UPDATE NO ACTION,
  FOREIGN KEY(f_messagetype_id)
    REFERENCES pcs_messagetype(f_messagetypeid)
      ON DELETE NO ACTION
      ON UPDATE NO ACTION
);

Table Modifier /includeSelectMethod:REG_EXPR[,REG_EXPR][,REG_EXPR][...]/

With this table modifyer you can include methods excluded with Table Modifier /**excludeSelectMethod:REG_EXPR[,REG_EXPR][,REG_EXPR][...]**/. This can save you some typing:

CREATE TABLE pcs_message
    /**excludeSelectMethod:ALL**/
    /**includeSelectMethod:selectIncludingDiscussion**/
(
  f_messageid BIGINT UNSIGNED NOT NULL,
  f_messagetype_id BIGINT UNSIGNED NOT NULL,
  f_user_id BIGINT UNSIGNED NOT NULL /**defaultInsert:$this->app->getUserId()**/ /**doNotUpdate**/,
  f_discussion_id BIGINT UNSIGNED NOT NULL,
  f_messagecreationdate DATETIME NULL /**defaultInsert:new RSDColumnValue('NOW()', '!')**/,
  f_messagesubject VARCHAR(255) NOT NULL,
  f_content TEXT NOT NULL,
  PRIMARY KEY(f_messageid),
  INDEX idx_pcs_message_messagetype_id(f_messagetype_id),
  INDEX idx_pcs_message_user_id(f_user_id),
  INDEX idx_pcs_message_discussion_id(f_discussion_id),
  FOREIGN KEY(f_discussion_id)
    REFERENCES pcs_discussion(f_discussionid)
      ON DELETE NO ACTION
      ON UPDATE NO ACTION,
  FOREIGN KEY(f_user_id)
    REFERENCES pcs_user(f_userid)
      ON DELETE NO ACTION
      ON UPDATE NO ACTION,
  FOREIGN KEY(f_messagetype_id)
    REFERENCES pcs_messagetype(f_messagetypeid)
      ON DELETE NO ACTION
      ON UPDATE NO ACTION
);

Column Modifiers - General

All modifiers but 'PRIMARY KEY' and 'UNIQUE' are surrunded by /** and **/ to distinguish them from normal comments starting with /* and ending with */ which are ignored. It is allowed to place each column modifier on a separate line but be aware that it is strongly recommended no to break up one column modifier over multiple lines. (This is because the columns are sepereated by performing a split(',\n') operation.) The following column modifiers are supported:

Column Modifier /ignore/

The column will not be parsed and completely ignored by the RSDEngine. Example:

CREATE TABLE t_test(
    f_test VARCHAR(200),
    f_creationdate DATE /**ignore**/
);

Actually /**ignore**/ can also be used for table constraints (UNIQUE, FOREIGN KEY (..) REFERENCES (...)). In the following example the table constraint UNIQUE and the FOREIGN KEY definition would be complitly ignored by the RSDEngine:

CREATE TABLE prj_user(
	f_userid INTEGER PRIMARY KEY NOT NULL /**sequence:seq_prj_user_userid**/,
	f_group_id INTEGER,
    f_firstname VARCHAR(200),
    f_lastname VARCHAR(200),
    UNIQUE(f_firstname, f_lastname) /**ignore**/,
    FOREIGN KEY (f_group_id) REFERENCES(prj_group.f_groupid) /**ignore**/
);

Column Modifier /canBeNull/

As explained in Column Modifier /**isValid:TYPE:ARG1:ARG2:ARG3...**/ only values with a prepare string of `?' are validated. Thus NULL values are in fact always valid. What this column modifier really does is to leave the choice whether to insert/update a NULL value to the template designer. If the template designer defines that a select option with the value "userSubmittedNULL", NULL will be inserted/updated. This allows the controllers not to deal with this issue. Wheather the string "userSubmittedNULL" should be replace by a real NULL value (specified as as an instance of RSDColumnValue [new RSDColumnValue('NULL', '!')] is defined in the application logic through /**canBeNull**/. The result will be that the use will not be forced to select an option in a select menue. In the following example the user would not be forced to specify a group for the user to create/update.

CREATE TABLE prj_user(
	f_userid INTEGER PRIMARY KEY NOT NULL /**sequence:seq_prj_user_userid**/,
	f_group_id INTEGER /**canBeNull**/,
    f_firstname VARCHAR(200),
    f_lastname VARCHAR(200),
    UNIQUE(f_firstname, f_lastname),
    FOREIGN KEY (f_group_id) REFERENCES(prj_group.f_groupid)
);

Column Modifier /isValid:TYPE:ARG1:ARG2:ARG3.../

Values for this column must pass the specified validation. Note: Only values with a prepare string of `?' are validated! This is because these values are usually those that come from outside the Model (from outside the application logic; i.e. from the user himself). Besides that you whould have to validate SQL expressions like `NOW()' which is not very practicable. Please see {@see RSDTable::insert} and {@see RSDTable::update}. TYPE can be one of the follwoing:

in: /**isValid:in:PHP_EXPRESSION:PHP_EXPRESSION:PHP_EXPRESSION:...**/ The value is only valid if it is equal to one of the php expressions. Note that === is used for comparision because an expression such as ("" == 0) would evaluate to true. The following would only allow values for f_test that evaluate to '0' or '1'.

CREATE TABLE t_test(
    f_test VARCHAR(200) /**isValid:in:'0':'1'**/
);

NOTE: the following normally doesn't make a lot of sense because the values submitted by a user via an HTML-form are always interpreted as strings.

CREATE TABLE t_test(
    f_test VARCHAR(200) /**isValid:in:0:1**/
);

The following would only allow values for f_test that evaluate to 'y' or 'n'.

CREATE TABLE t_test(
    f_test VARCHAR(200) /**isValid:in:'y':'n'**/
);

Note that any php expression can be used:

CREATE TABLE t_test(
    f_test VARCHAR(200) /**isValid:in:$GLOBALS['object']->getId():CONSTANT_ID**/
);

would result in


1     if (!($test === $GLOBALS['object']->getId() || $test === CONSTANT_ID))

code: /**isValid:code:PHP_EXPRESSION**/ For a value to be valid for this column PHP_EXPRESSION must evaluate to the boolean value true. %s will be replaced in PHP_EXPRESSION with the variable that holds the value to validate. Example:

CREATE TABLE t_test(
    f_test VARCHAR(200) /**isValid:code:$GLOBALS['someObject']->validate(%s)**/
);

Or a little more complex:

CREATE TABLE t_test(
    f_test VARCHAR(200) /**isValid:code:%s === '0' || %s === '1' || %s === 'y' || %s === 'n'**/
);

which is by the way equivalent to

CREATE TABLE t_test(
    f_test VARCHAR(200) /**isValid:in:'0':'1':'y':'n'**/
);

would result in


1     if (!($test === '0' || $test === '1' || $test === 'y' || $test === 'n'))

Any method of the static class defined in Database Backend: $config['validationClassName']: /**isValid:METHOD_NAME:EXPRESSION_ARG1:EXPRESSION_ARG2:EXPRESSION_ARG3:...**/ The default validation class is RSValidation. The most useful methods of RSValidation are:


1     boolean RSValidation::isString($str, $minLength = null, $maxLength = null)
2     boolean RSValidation::isAlpha($str)
3     boolean RSValidation::isNumeric($str)
4     boolean RSValidation::isDate($str)
5     boolean RSValidation::isTime($str)
6     boolean RSValidation::isDateTime($str)
7     boolean RSValidation::isAlphanumeric($str)
8     boolean RSValidation::isEmail($str)

It is recommended to use RSValidate for validation. For a list of the methods provided by RSValidation and thier useage please see the {@see RSValidation} and RSValidation. PEAR::Validate would do the job as well but the methods of RSValidation have a more intuitive order of arguments. Note: RSValidate extends PEAR::Validate! Usage example:

CREATE TABLE t_test(
    f_test VARCHAR(200) /**isValid:isString:2:4**/
);

would result in the following code (if RSValidation was chosen for validation):


1     if(!RSValidation::isString(2, 4))

Note that any php expression can be used as argument:

CREATE TABLE t_test(
    f_test VARCHAR(200) /**isValid:isString:2 + $GLOBALS['someObject']->getId():4**/
);

would result in


1     if(!RSValidation::isString(2 + $GLOBALS['someObject']->getId(), 4))

file: /**isValid:file[:SIZE[KB|MB][:CONTENT_TYPE[:DEFAULT_FILE[;STORAGE_DIR]]]]**/ For a value to be valid for this column it must be the name of file that matches the specified criteria. DEFAULT_FILE and STORAGE_DIR can be specified by an absolute path: /my/path or C:/my/path on Windows (always use foreward slashes!). DEFAULT_FILE and STORAGE_DIR can be as well specified as a path relative to the code-directory (the root of your application). To let the RSDEngine know it's a relative path it MUST begin with './' or '../'.Note that DEFAULT_FILE and STORAGE_DIR are separated by a semi colon (';') and NOT a colon (':'). This is necassary to handle absolute windows paths that start with something like 'C:/'. Example:
```
CREATE TABLE t_test(
    f_file1 VARCHAR(200) /**isValid:file**/ /**sequence:seq_test_files**/,
    f_file2 VARCHAR(200) /**isValid:file:1024**/ /**sequence:seq_test_files**/,
    f_file3 VARCHAR(200) /**isValid:file:10KB**/ /**sequence:seq_test_files**/,
    f_file4 VARCHAR(200) /**isValid:file:5MB**/ /**sequence:seq_test_files**/,
    f_file5 VARCHAR(200) /**isValid:file:5MB:image/**/ /**sequence:seq_test_files**/,
    f_file6 VARCHAR(200) /**isValid:file:5MB:image/jpg**/ /**sequence:seq_test_files**/,
    f_file7 VARCHAR(200) /**isValid:file:5MB:image/jpg:./images/file7Default.jpg**/ /**sequence:seq_test_files**/,
    f_file8 VARCHAR(200) /**isValid:file:5MB:image/jpg:./images/file8Default.jpg;./file8Storage**/ /**sequence:seq_test_files**/,
    f_file9 VARCHAR(200) /**isValid:file:::./images/file8Default.jpg**/ /**sequence:seq_test_files**/
);
			   			
```
Note that every column defined with /**isValid:file...**/ needs to be defined with a sequence! This sequence will be used to generate the filenames. This allows all files to be stored in the same storage directory [recommened]. Note that you would not have to use the same sequence for all columns because the files are stored with a table and a column prefix. The following usage is recommended because it gives you the most security: /**isValid:file:size[KB|MB]:CONTENT_TYPE:DEFAULT_FILE**/.
- f_file1 has no restrictions on file size or content type. Files uploaded for f_file1 will be stored in the default storage directory Database Backend: $config['fileStorageDirectory'].
- f_file2 will only accept files smaller than 1024 bytes. Files uploaded for f_file2 will be stored in the default storage directory Database Backend: $config['fileStorageDirectory'].
- f_file3 will only accept files smaller than 10 kilo bytes. Files uploaded for f_file3 will be stored in the default storage directory Database Backend: $config['fileStorageDirectory'].
- f_file4 will only accept files smaller than 5 mega bytes. Files uploaded for f_file4 will be stored in the default storage directory Database Backend: $config['fileStorageDirectory'].
- f_file5 will only accept files that are smaller than 5 mega bytes and are of a content type that contais the string 'image/' [strpos($contentType, 'image/') !== false]. This will only allow image/jpg, image/gif and so on... Files uploaded for f_file5 will be stored in the default storage directory Database Backend: $config['fileStorageDirectory'].
- f_file6 will only accept files that are smaller than 5 mega bytes and are of the content type 'image/jpg'. Files uploaded for f_file6 will be stored in the default storage directory Database Backend: $config['fileStorageDirectory'].
- f_file7 will only accept files that are smaller than 5 mega bytes and are of the content type 'image/jpg'. If an error occurres while displaying the stored image ./images/file7Default.jpg will be displayed instead. Such an error could be that the user does not have the permission to view this image. Files uploaded for f_file7 will be stored in the default storage directory Database Backend: $config['fileStorageDirectory'].
- f_file8 will only accept files that are smaller than 5 mega bytes and are of the content type 'image/jpg'. If an error occurres while displaying the stored image ./images/file8Default.jpg will be displayed instead. Such an error could be that the user does not have the permission to view this image. Files uploaded for f_file8 will be stored in the directory ./file8Storage.
- f_file9 has no restrictions on file size or content type. Files uploaded for f_file9 will be stored in the default storage directory Database Backend: $config['fileStorageDirectory']. If an error occurres while displaying the stored image ./images/file8Default.jpg will be displayed instead. Such an error could be that the user does not have the permission to view this image.

Column Modifier /inputType:TYPE[:TYPE_DATA]/

Specifies the HTML input type to use in the template. TYPE can be one of the follwoing:

text: /**inputType:text**/ Use a standard text field. This is the default.

CREATE TABLE t_test(
    f_test VARCHAR(200) /**inputType:text**/
);

password: /**inputType:password**/ Use a password field.

CREATE TABLE t_test(
    f_password VARCHAR(200) /**inputType:password**/
);

select: /**inputType:select[:array(...)]**/ Use a select box for input. If the column is defined as a foreign key the records of the referenced table will be used as TYPE_DATA:

CREATE TABLE t_test(
    f_test VARCHAR(200) /**inputType:select**/,
    FOREIGN KEY(f_test) REFERENCES t_test2(f_test2)
);

Note that this is the default behaviour for all foreign key columns. In the following example we specify TYPE_DATA:

CREATE TABLE t_test(
    f_status CHAR(1)
      /**isValid:in:'0':'1':'2'**/
      /**inputType:select:array('0' => 'unknown', '1' => 'in work', '2' => 'done')**/
);

And now a little different (the status is saved by name not by ID):

CREATE TABLE t_test(
    f_status VARCHAR(7)
      /**isValid:in:'unknown':'in work':'done'**/
      /**inputType:select:array('unknown' => 'unknown', 'in work' => 'in work', 'done' => 'done')**/
);

Please note that using TYPE_DATA should be used with care! If the possible values are likely to chage, consider creating a new table for all possible values and link that with a foreign key. This increases maintainability.

radio: /**inputType:radio[:array(...)]**/ Use radio buttons for input. Everything said about /**inputType:select**/ is also true for this option. Please read above.
textarea: /**inputType:textarea**/ Use a textarea for input. Note: you cannot specify TYPE_DATA for /**inputType:textarea**/.
date: /**inputType:date**/ Use multiple select boxes (year, month, day) for input. Note: you cannot specify TYPE_DATA for /**inputType:textarea**/.
time: /**inputType:time**/ Use multiple select boxes (hour, minute) for input. Note: you cannot specify TYPE_DATA for /**inputType:time**/.
datetime: /**inputType:datetime**/ Use multiple select boxes (year, month, day, hour, minute) for input. Note: you cannot specify TYPE_DATA for /**inputType:datetime**/.

checkbox: /**inputType:checkbox[array('checked' => PHP_EXPR, 'unchecked' => PHP_EXPR)]**/ Use a checkbox. If you specify an array make sure it has elements for the keys 'checked' and 'unchecked'. If you do not specify an array '1' will be used if the checkbox was checked and '0' otherwise.

CREATE TABLE t_test(
    f_activated VARCHAR(200)
    /**isValid:in:'Y':'N'**/
    /**inputType:checkbox:array('checked' => 'Y', 'unchecked' => 'N')**/
);

Column Modifier /defaultInsert:PHP_EXPRESSION/

The generated method 'insert' will use PHP_EXPRESSION as default value for this column. This is useful if you want to insert the current date and time by default (for, let's say a f_creationdate column). Please read RSDTable::insert first. The array, that is passed to insert as argument, holds the inserts as key value pairs. The key is the column name while the value can be a string or again an array. Again, read RSDTable::insert if you do not understand this! The array element for this column will be constructed like this:


1     'f_columnname' => PHP_EXPRESSION

So if you want the integer 0 to be the default value you would write


1     /**defaultInsert:0**/

Note that you have to be careful if you additionaly defined this column as /**isValid:in:'0':'1'**/ as described in Column Modifier /**isValid:TYPE:ARG1:ARG2:ARG3...**/. Because /**isValid:in:'0':'1'**/ would result in the isValid condition %s === '0' || %s === '1' which would not be true for our default value. So if you defined your column as /**isValid:in:'0':'1'**/ use /**defaultInsert:'0'**/. For inserting the current date and time (in MySQL) you would write


1     /**defaultInsert:new RSDColumnValue('NOW()','!')**/

If you want to save the creation date of a record you would additionally define the column with Column Modifier /**doNotUpdate**/:

CREATE TABLE prj_test(
	f_testid INTEGER INTEGER PRIMARY KEY NOT NULL /**sequence:seq_prj_test_testid**/,
    f_test VARCHAR(200) /**isValid:isString:2:200**/,
    f_creationdate DATE /**defaultInsert:new RSDColumnValue('NOW()','!')**/ /**doNotUpdate**/
);

Please note that all columns defined with /**defaultInsert...**/ are treated as if defined as well with Column Modifier /**doNotInsert**/.

Column Modifier /defaultUpdate:PHP_EXPRESSION/

The generated method 'update' will use PHP_EXPRESSION as default value for this column. This is useful if you want to update a f_lastmodified column with the current date and time by default. Please read RSDTable::update first. The array, that is passed to update as argument, holds the updates as key value pairs. The key is the column name while the value can be a string or again an array. Again, read RSDTable::update if you do not understand this! The array element for this column will be constructed like this:


1     'f_columnname' => PHP_EXPRESSION

So if you want the integer 0 to be the default value you would write


1     /**defaultUpdate:0**/

Note that you have to be careful if you additionaly defined this column as /**isValid:in:'0':'1'**/ as described in Column Modifier /**isValid:TYPE:ARG1:ARG2:ARG3...**/. Because /**isValid:in:'0':'1'**/ would result in the isValid condition %s === '0' || %s === '1' which would not be true for our default value. So if you defined your column as /**isValid:in:'0':'1'**/ use /**defaultUpdate:'0'**/. For updating a column by default with the current date and time (in MySQL) you would write


1     /**defaultUpdate:new RSDColumnValue('NOW()','!')**/

If you want to save the date of the last modification of the record in a column named f_lastmodified you would use both /**defaultInsert...**/ and /**defaultUpdate...**/:

CREATE TABLE prj_test(
	f_testid INTEGER PRIMARY KEY NOT NULL /**sequence:seq_prj_test_testid**/,
    f_test VARCHAR(200) /**isValid:isString:2:200**/,
    f_lastmodified DATE /**defaultInsert:new RSDColumnValue('NOW()','!')**/ /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
);

Please note that all columns defined with /**defaultUpdate...**/ are treated as if defined as well with Column Modifier /**doNotUpdate**/.

Column Modifier /sequence:sequence_name/

If provided a method named getNextCOLUMNNAME will be created that returns the next id from the sequence specified. Note that sequences are emulated by PEAR::DB if not supported by the RDBMS. Please follow the naming conventions of RSD for naming sequences. Example:

CREATE TABLE prj_test(
    f_test VARCHAR(200),
    f_testid NUMBER /**sequence:seq_prj_test_testid**/
);

Note that if you define a primary key column with a sequence, the return value of the generated getNext-Method will be used as default value for this column in the method insert. Please see Column Modifier /**defaultInsert:PHP_EXPRESSION**/ for details on default values.

Column Modifier /doNotInsert/

The generated controllers and templates that handle the creation of a new record will not deal with this column. Example:

CREATE TABLE prj_test(
    f_test VARCHAR(200),
    f_creationdate DATE /**doNotInsert**/
    f_test2 VARCHAR(200) DEFAULT 'undefined' /**doNotInsert**/
);

This comes in handy when you have columns that a user should not edit directly (or not at all). Please note that all columns defined with Column Modifier /**defaultInsert:PHP_EXPRESSION**/ are treated as if defined with /**doNotInsert**/.

Column Modifier /doNotSelect/

The generated teplates will not display this column. Example:

CREATE TABLE prj_user(
    f_userid INTEGER PRIMARY KEY NOT NULL /**sequence:seq_prj_user_userid**
    f_username VARCHAR(200),
    f_password VARCHAR(200) /**doNotSelect**/
);

As in the example above it my be appropriate not to display certain columns.

Column Modifier /doNotUpdate/

The generated controllers and templates that handle an update operation of a record will not deal with this column. Example:

CREATE TABLE prj_test(
    f_test VARCHAR(200),
    f_creationdate DATE /**doNotUpdate**/
    f_test2 VARCHAR(200) DEFAULT 'undefined' /**doNotUpdate**/
);

This comes in handy when you have columns that a user should not edit directly (or not at all). Please note that all columns defined with Column Modifier /**defaultUpdate:PHP_EXPRESSION**/ are treated as if defined with /**doNotUpdate**/.

Column Modifier /deleteLiveUserRightOnDelete/

If this column modifier is used the LiveUser right stored in this column by ID is deleted when the containing record is deleted. In the following example a new LiveUser right will be created for each record - and deleted again when the record is deleted:


1     CREATE TABLE t_document
2         /**LiveUserRight:select:rightId=f_selectdocumentright**/
2     
3     (
4         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
4      /**sequence:prj_document_documentid**/
4     ,
5         f_folder_id INTEGER /**isValid:isInt**/
5     ,
6         f_selectdocumentright
7             /**isValid:isInt**/
7     
8             /**deleteLiveUserRightOnDelete**/
8     
9             /**doNotUpdate**/
9     
10            /**defaultInsert:$this->app->addLiveUserRight(1, 'EFX_LIVEUSER_RIGHT_DOCUMENT_SELECT', 'EFX_LIVEUSER_RIGHT_DOCUMENT_SELECT', array($this->app->liveUser->getProperty('permUserId')))**/
10    
11        ,
12        f_lastmodified DATE /**isValid:isDate**/
12     /**defaultInsert:new RSDColumnValue('NOW()','!')**/
12     /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
12    ,
13        f_title VARCHAR(100) /**isValid:isString:2:100**/
13    
14    );

In fact this is just a synonym for the table modifier Table Modifier /**afterUpdate:PHP_CODE**/ used in the following way:


1     /**afterDelete:$this->app->callLiveUserPermAdminMethod('removeRight', array($record['f_selectdocumentright']));**/

Column Modifier /deleteLiveUserGroupOnDelete/

If this column modifier is used the LiveUser group stored in this column by ID is deleted when the containing record is deleted. In the following example a new LiveUser group will be created for each record - and delete again when the record is deleted.


1     CREATE TABLE t_document
2         /**LiveUserRight:select:rightId=f_selectdocumentright**/
2     
3     (
4         f_documentid INTEGER NOT NULL PRIMARY KEY /**isValid:isInt**/
4      /**sequence:prj_document_documentid**/
4     ,
5         f_folder_id INTEGER /**isValid:isInt**/
5     ,
6         f_selectdocumentright
7             /**isValid:isInt**/
7     
8             /**deleteLiveUserRightOnDelete**/
8     
9             /**doNotUpdate**/
9     
10            /**defaultInsert:$this->app->addLiveUserRight(1, 'EFX_LIVEUSER_RIGHT_DOCUMENT_SELECT', 'EFX_LIVEUSER_RIGHT_DOCUMENT_SELECT', array($this->app->liveUser->getProperty('permUserId')))**/
10    
11        ,
12        f_lastmodified DATE /**isValid:isDate**/
12     /**defaultInsert:new RSDColumnValue('NOW()','!')**/
12     /**defaultUpdate:new RSDColumnValue('NOW()','!')**/
12    ,
13        f_title VARCHAR(100) /**isValid:isString:2:100**/
13    
14    );


1     /**afterDelete:$this->app->callLiveUserPermAdminMethod('removeGroup', array($record['f_selectdocumentright']));**/

Column Modifier /deleteLiveUserAreaOnDelete/

If this column modifier is used the LiveUser area stored in this column by ID is deleted when the containing record is deleted. In fact this is just a synonym for the table modifier Table Modifier /**afterUpdate:PHP_CODE**/ used in the following way:


1     /**afterDelete:$this->app->callLiveUserPermAdminMethod('removeArea', array($record['f_columnname']));**/

Column Modifier /editLiveUserRight[:$OPERATION][:[rightId=$RIGHT_ID]|[condition=PHP_CODE]]/

If this column modifier is used the LiveUser right stored in this column by ID is made editable. A more specific definition of this option is

/**editLiveUserRight[:userRight|groupRight|grantRight|revokeRight|grantUserRight|revokeUserRight|grantGroupRight|revokeGroupRight|all][[:rightId=column|table.column|SQL_QUERY|PHP_CODE]|condition=PHP_CODE**/

Therefore $OPERATION can be one of the following:

all: If $OPERATION is set to 'all' this editLiveUserRight option will be internally duplicated for the operations 'grantUserRight', 'revokeUserRight', 'grantGroupRight' and 'revokeGroupRight'.
userRight: If $OPERATION is set to 'userRight' this editLiveUserRight option will be internally duplicated for the operations 'grantUserRight' and 'revokeUserRight'.
groupRight: If $OPERATION is set to 'groupRight' this editLiveUserRight option will be internally duplicated for the operations 'grantGroupRight' and 'revokeGroupRight'.
grantRight: If $OPERATION is set to 'grantRight' this editLiveUserRight option will be internally duplicated for the operations 'grantUserRight' and 'grantGroupRight'.
revokeRight: If $OPERATION is set to 'revokeRight' this editLiveUserRight option will be internally duplicated for the operations 'revokeUserRight' and 'revokeGroupRight'.
grantUserRight: If $OPERATION is set to 'grantUserRight' the condition must evaluate to true/the specified right must be granted to the current user in order to be able to grant the right stored in this column by ID to a user.
revokeUserRight: If $OPERATION is set to 'revokeUserRight' the condition must evaluate to true/the specified right must be granted to the current user in order to be able to revoke the right stored in this column by ID from a user.
grantGroupRight: If $OPERATION is set to 'grantGroupRight' the condition must evaluate to true/the specified right must be granted to the current user in order to be able to grant the right stored in this column by ID to a group.
revokeGroupRight: If $OPERATION is set to 'revokeGroupRight' the condition must evaluate to true/the specified right must be granted to the current user in order to be able to revoke the right stored in this column by ID from a group.
none: If $OPERATION is omitted 'all' is assumed.

If no $RIGHT_ID or condition=PHP_CODE is specified the current user must have the right to edit. To allow every user that has the right stored in f_workgroupupdate to grant this right to other users; to allow only administrator to revoke the right from users and not to allow to revoke the right from groups at all you would write:


1     CREATE TABLE ehr_workgroup
2         /**LiveUserRight:update:rightId=f_workgroupupdate**/
2     
3     (
4       f_workgroupid INT UNSIGNED NOT NULL,
5       f_workgroupname VARCHAR(100) NULL,
6       f_workgroupupdate INT UNSIGNED NOT NULL
7         /**isValid:isInt**/
7     
8         /**deleteLiveUserRightOnDelete**/
8     
9         /**defaultInsert:$this->app->addLiveUserRight(1, 'EHR_WORKGROUP_UPDATE', 'EHR_WORKGROUP_UPDATE')**/
9     
10        /**doNotUpdate**/
10    
11        /**editLiveUserRight:grantRight**/
11    
12        /**editLiveUserRight:revokeUserRight:condition=$this->app->isAdmin()**/
12    
13        /**editLiveUserRight:revokeGroupRight:condition=false**/
13    
14    );

For more details on how to use the different $RIGHT_ID types or condition=PHP_CODE please see Table Modifier /**LiveUserRight[:$OPERATION]:rightId=$RIGHT_ID|condition=PHP_CODE|recordCondition=PHP_CODE**/.

Column Modifier /editLiveUserArea[:$OPERATION][[:rightId=$RIGHT_ID]|[condition=PHP_CODE]]/

If this column modifier is used the LiveUser area stored in this column by ID is made editable. A more specific definition of this option is

/**editLiveUserArea[:addAdmin|removeAdmin|updateNameAndComment|all][:[rightId=column|table.column|SQL_QUERY|PHP_CODE]|[condition=PHP_CODE]]**/

Therefore $OPERATION can be one of the following:

all: If $OPERATION is set to 'all' this editLiveUserArea option will be internally duplicated for the operations 'addAdmin', 'removeAdmin' and 'updateNameAndComment'.
addAdmin: If $OPERATION is set to 'addAdmin' the condition must evaluate to true/the specified right must be granted to the current user in order to add an admin to this area.
removeAdmin: If $OPERATION is set to 'removeAdmin' the condition must evaluate to true/the specified right must be granted to the current user in order to remove an admin from this area.
updateNameAndComment: If $OPERATION is set to 'updateNameAndComment' the condition must evaluate to true/the specified right must be granted to the current user in order to be able to update the name and comment of this area.
none: If $OPERATION is omitted 'all' is assumed.

If no $RIGHT_ID or condition=PHP_CODE is specified the current user must be admin of the area stored in this column by ID. To allow all users that have the right stored in f_workgroupupdate to add and remove area admins but to disallow themm to update the area name and comment you would write: groups at all you would write:


1     CREATE TABLE ehr_workgroup
2         /**LiveUserRight:update:rightId=f_workgroupupdate**/
2     
3     (
4       f_workgroupid INT UNSIGNED NOT NULL,
5       f_workgroupname VARCHAR(100) NULL,
6       f_workgroupupdate INT UNSIGNED NOT NULL
7         /**isValid:isInt**/
7     
8         /**deleteLiveUserRightOnDelete**/
8     
9         /**defaultInsert:$this->app->addLiveUserRight(1, 'EHR_WORKGROUP_UPDATE', 'EHR_WORKGROUP_UPDATE')**/
9     
10        /**doNotUpdate**/
10    
11        /**editLiveUserRight:grantRight**/
11    
12        /**editLiveUserRight:revokeUserRight:condition=$this->app->isAdmin()**/
12    
13        /**editLiveUserRight:revokeGroupRight:condition=false**/
13    
14      ,
15      f_workgrouparea INT UNSIGNED NOT NULL
16        /**isValid:isInt**/
16    
17        /**deleteLiveUserAreaOnDelete**/
17    
18        /**defaultInsert:$this->app->addLiveUserArea(EHR_LIVEUSER_APPLICATION_ID, 'EHR_WORKGROUP_AREA', 'EHR_WORKGROUP_AREA', array($this->app->getUserId()))**/
18    
19        /**doNotUpdate**/
19    
20        /**editLiveUserArea:all:rightId=f_workgroupupdate**/
20    
21        /**editLiveUserArea:updateNameAndComment:condition=false**/
21    
22    );

Note that the second editLiveUserArea option overwrites the first one for the operation updateNameAndComment. For more details on how to use the different $RIGHT_ID types or condition=PHP_CODE please see Table Modifier /**LiveUserRight[:$OPERATION]:rightId=$RIGHT_ID|condition=PHP_CODE|recordCondition=PHP_CODE**/.

Column Modifier /editLiveUserGroup[:$OPERATION][:[rightId=$RIGHT_ID]|[condition=PHP_CODE]]/

If this column modifier is used the LiveUser group stored in this column by ID is made editable. A more specific definition of this option is

/**editLiveUserGroup[:addUser|removeUser|activate|deactivate|updateNameAndComment|all][:[rightId=column|table.column|SQL|PHP]|[condition=PHP_CODE]]**/

Therefore $OPERATION can be one of the following:

all: If $OPERATION is set to 'all' this editLiveUserGroup option will be internally duplicated for the operations 'addUser', 'removeUser', 'activate', 'deactivate' and 'updateNameAndComment'.
addUser: If $OPERATION is set to 'addUser' the condition must evaluate to true/the specified right must be granted to the current user in order to add a user to this group.
removeUser: If $OPERATION is set to 'removeUser' the condition must evaluate to true/the specified right must be granted to the current user in order to remove a user from this group.
activate: If $OPERATION is set to 'activate' the condition must evaluate to true/the specified right must be granted to the current user in order to activate this group.
deactivate: If $OPERATION is set to 'deactivate' the condition must evaluate to true/the specified right must be granted to the current user in order to deactivate this group.
updateNameAndComment: If $OPERATION is set to 'updateNameAndComment' the condition must evaluate to true/the specified right must be granted to the current user in order to be able to update the name and comment of this group.
none: If $OPERATION is omitted 'all' is assumed.

If no $RIGHT_ID or condition=PHP_CODE is specified the current user must be in the group stored in this column by ID. Here is a rather complex example:


1     CREATE TABLE prj_workgroup
2        /**LiveUserRight:insert:condition=$this->app->isAdmin()**/
2     
3        /**LiveUserRight:update:rightId=f_workgroupupdate**/
3     
4        /**LiveUserRight:delete:condition=$this->app->isAdmin()**/
4     
5        /**LiveUserRight:select:rightId=f_workgroupmembership**/
5     
6     (
7       f_workgroupid INT UNSIGNED NOT NULL,
8       f_workgroupname VARCHAR(100) NULL,
9       f_workgroupdescription TEXT NULL,
10      f_workgroupcreationdate DATE NULL /**defaultInsert:new RSDColumnValue('NOW()','!')**/
10     /**doNotUpdate**/
10    ,
11      f_workgroupdeactivated CHAR(1) NULL DEFAULT '0' /**isValid:in:'0':'1'**/
11    ,
12      f_workgroupgroup INT UNSIGNED NOT NULL
13       /**isValid:isInt**/
13    
14       /**deleteLiveUserGroupOnDelete**/
14    
15       /**defaultInsert:$this->app->addLiveUserGroup('PRJ_WORKGROUP_GROUP', array($this->app->getUserId()), 'This is a workgroup.')**/
15    
16       /**doNotUpdate**/
16    
17       /**editLiveUserGroup:addUser:rightId=f_workgroupupdate**/
17    
18       /**editLiveUserGroup:removeUser:rightId=f_workgroupupdate**/
18    
19      ,
20      f_workgrouparea INT UNSIGNED NOT NULL
21       /**isValid:isInt**/
21    
22       /**deleteLiveUserAreaOnDelete**/
22    
23       /**defaultInsert:$this->app->addLiveUserArea(PRJ_LIVEUSER_APPLICATION_ID, 'PRJ_WORKGROUP_AREA', 'PRJ_WORKGROUP_AREA', array($this->app->getUserId()))**/
23    
24       /**doNotUpdate**/
24    
25       /**editLiveUserArea:condition=false**/
25    
26       ,
27      f_workgroupupdate INT UNSIGNED NOT NULL
28       /**isValid:isInt**/
28    
29       /**deleteLiveUserRightOnDelete**/
29    
30       /**defaultInsert:$this->app->addLiveUserRight($inserts['f_workgrouparea'], 'PRJ_WORKGROUP_UPDATE', 'PRJ_WORKGROUP_UPDATE')**/
30    
31       /**doNotUpdate**/
31    
32       /**editLiveUserRight:condition=false**/
32    
33      ,
34      f_workgroupmembership INT UNSIGNED NOT NULL
35       /**isValid:isInt**/
35    
36       /**deleteLiveUserRightOnDelete**/
36    
37       /**defaultInsert:$this->app->addLiveUserRight($inserts['f_workgrouparea'], 'PRJ_WORKGROUP_MEMBERSHIP', 'PRJ_WORKGROUP_MEMBERSHIP', array(), array($inserts['f_workgroupgroup']))**/
37    
38       /**doNotUpdate**/
38    
39       /**editLiveUserRight:condition=false**/
39    
40      ,
41      PRIMARY KEY(f_workgroupid),
42      UNIQUE INDEX idx_prj_workgroup_workgroupid(f_workgroupid)
43    );

Only administrators are allowed to create a new workgroup. When a new workgroup is created, a new group with the creator as the only member is created as well and its ID is assigned to the column f_workgroupgroup. It is only possible to add and to remove users from the group, not to change the name or comment. In order to do this the right stored in the column f_workgroupupdate is required. The ID of a newly created area with the creator as area admin is assigned to the column f_workgrouparea. The column f_workgroupupdate saves the right that is required to add or remove a user from the group saved in f_workgroupgroup or to perform a general update operation for this table. The right itself cannot be granted to any user or group. In the column f_workgroupmembership, the ID of another newly created right is stored. This right is granted to the group stored in f_workgroupgroup. It cannot be directly granted to any users or groups. Only administrators can delete workgroups. When a workgroup is deleted, the corresponding area, group and rights are deleted as well. A user must have the right stored in f_workgroupmembership in order to select a certain record from this table. This right can only be granted via adding the user to the group stored in f_workgroupgroup because the right cannot be directly granted (as already mentioned). The creator has the right stored in f_workgroupupdate because she is the admin of the area stored in f_workgrouparea and is member of the group stored in f_workgroupgroup. For more details on how to use the different $RIGHT_ID types or condition=PHP_CODE please see Table Modifier /**LiveUserRight[:$OPERATION]:rightId=$RIGHT_ID|condition=PHP_CODE|recordCondition=PHP_CODE**/.

Column Modifier /key/

If provided the methods getByCOLUMNNAME, updateByCOLUMNNAME and deleteByCOLUMNNAME will be generated for this column. Example:

CREATE TABLE prj_test(
    f_testid NUMBER PRIMARY KEY NOT NULL /**sequence:seq_prj_test_testid**/,
    f_name VARCHAR(200) /**key**/
);

This will not only generate the methods getByTestid, updateByTestid and deleteByTestid (f_testid was defined as a primary key) but as well getByName, updateByName and deleteByName.

Column Modifier PRIMARY KEY (Column Constraint)

If provided this column will be treated as a primary key. This means:

It is verified before updating or inserting a record that the value for this column is unique.
The methods getByCOLUMNNAME, updateByCOLUMNNAME and deleteByCOLUMNNAME will be generated for this column.

The use of the modifier PIMARY KEY is for the RSDEngine equivalent to the use of /**key**/ in combination of UNIQUE. Note that the modifier PIMARY KEY is not surrounded by /** and **/ because it is valid SQL. Example:

CREATE TABLE prj_test(
    f_testid NUMBER PRIMARY KEY,
    f_name VARCHAR(200)
);

Column Modifier UNIQUE (Column Constraint)

If provided, it is verified before updating or inserting a record that the value for this column is unique. Example:

CREATE TABLE prj_test(
    f_username VARCHAR(200) UNIQUE,
    f_password VARCHAR(200)
);

Column Modifier FOREIGN KEY (Table Constraint)

Defines column as a foreign key. Example:

CREATE TABLE prj_user(
    f_group_id NUMBER,
    f_username VARCHAR(200),
    f_password VARCHAR(200),
    FOREIGN KEY (f_group_id) REFERENCING(prj_group.f_groupid)
);

defines f_group_id as foreign key referencing prj_group.f_groupid. The foreign key definition does not have to fit on one line and 'ON DELETE' and 'ON UPDATE' sections area legal as well (but will get ignored):

CREATE TABLE prj_user(
    f_group_id NUMBER,
    f_username VARCHAR(200),
    f_password VARCHAR(200),
    FOREIGN KEY(f_group_id)
       REFERENCING(prj_group.f_groupid)
         ON DELETE NO ACTION
         ON UPDATE NO ACTION
);

Column Modifier /deleteReferencedRecordOnDelete/

If used along with a FOREIGN KEY definition the referenced record will be deleted as well when a record of this table is deleted:

CREATE TABLE prj_test(
    f_test VARCHAR(20),
	f_test2_id INTEGER,
    FOREIGN KEY (f_test2_id) REFERENCING(prj_test2.f_test2id)
        /**deleteReferencedRecordOnDelete**/
);

Column Modifier UNIQUE (Table Constraint)

Defines the combination of one ore columns as unique. Not that specifying only one column does work as well but is NOT recommended. Define the UNIQUE constraint as a column constraint if only one column is invloved! Example:

CREATE TABLE prj_user_group(
    f_user_id NUMBER,
    f_group_id NUMBER,
    UNIQUE(f_user_id,f_group_id)
);

Defines the combination of f_user_id and f_group_id as unique. In this case it is a N:N relationship between users and groups. Using unique in this way prevents one user becoming a member in the same group twice. An unique contraint can as well be defined as an UNIQUE INDEX:

CREATE TABLE prj_user_group(
    f_user_id NUMBER,
    f_group_id NUMBER,
    UNIQUE INDEX idx_prj_user_group_user_id_group_id (f_user_id,f_group_id)
);

Column Modifier PRIMARY KEY (Table Constraint)

Defines one column as a primary key. Specifying more than one column would be valid SQL DDL but the RSDEngine is not able to handle it. Example:

CREATE TABLE prj_country(
    f_countryid NUMBER,
    f_countryname VARCHAR(50),
    PRIMARY KEY(f_countryid)
);

This defines f_countryid as the primary key.

Ignored: INDEX

An index definition like the following will be ignored:

CREATE TABLE prj_country(
    f_countryid NUMBER,
    f_countryname VARCHAR(50),
    INDEX idx_prj_country_countryid(f_countryid)
);

IsValid Guessing

If Database Backend: $config['makeIsValidAssumption'] is set an isValid option is guessed from the column type for all columns that are not defined with an isValid option. The following mapping was implemented:

CHAR VARYING(x), BINARY(x), VARBINARY(x), VARCHAR(x) and VARCHAR(x) --> isString:1:x
CHAR(x)                --> isString:x:x
TINYBLOB, TINYTEXT     --> isString:0:pow(2,8)-1
BLOB, TEXT             --> isString:0:pow(2,16)-1
MEDIUMBLOB, MEDIUMTEXT --> isString:0:pow(2,24)-1
LONGBLOB, LONGTEXT     --> isString:0:pow(2,32)-1
TINYINT                --> isInt:-128:127
SMALLINT               --> isInt:-32768:32767
MEDIUMINT              --> isInt:-8388608:8388607
BIGINT                 --> isInt:-9223372036854775808:9223372036854775807
INT                    --> isInt:-2147483648:2147483647

Sequence Guessing

If Database Backend: $config['makeSequenceAssumption'] is set a Column Modifier /**sequence:sequence_name**/ is internally added for all primary key columns that were not difine with one.

Dynaminc Naming

You can as well write a CREATE TABLE statement as follows (note dollar signs!):

CREATE TABLE $t_user(
    $f_userid NUMBER PRIMARY KEY UNIQUE NOT NULL,
    $f_group_id NUMBER,
    $f_firstname VARCHAR(100),
    $f_lastname VARCHAR(200),
    UNIQUE($f_firstname,$f_lastname),
    FOREIGN KEY ($f_group_id) REFERENCES($t_group.$f_groupid)
);

This makes it possible to specify the names of the tables and columns at run time! This is done by passing an associative array as constructor argument. Example:


1     $options['t_user'] = 'prj_user';
2     $options['f_firstname'] = 'f_first';
3     $options['f_lastname'] = 'f_last';
4     $prjUser = new PRJUser(&$rsdApp, &$rsdApp->db, &$options);

This would make PRJUser using the table prj_user (instead of t_user), the column f_first (instead of f_firstname) and f_last (instead of f_lastname). Note that we did not specify a value for $f_group_id. Therefore the column will be named as in the SQL DDL (with the leading dollar sign removed). This means that you can specify the dynimically named columns and tables - but you do not have to! It is as well possible to define only specific columns and tables with dynamic naming:

CREATE TABLE t_user(
    f_userid NUMBER PRIMARY KEY UNIQUE NOT NULL,
    $f_group_id NUMBER,
    f_firstname VARCHAR(100),
    f_lastname VARCHAR(200),
    UNIQUE($f_firstname,$f_lastname),
    FOREIGN KEY ($f_group_id) REFERENCES($t_group.$f_groupid)
);

This makes it only possible to name $f_group_id, and its foreign key target dynamically.

Dynamic Naming is most useful if you want to write an application like an authentication system (please don't; use PEAR::Auth!) and want the user of your class (the programmer) to be able to specify what tables and columns to use without hacking around in your code.

Database Backend: $config['getOneSelectMethodName']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. The method to call to get the records for the getOne controller. Methods that are always valid are: select, selectIncludingAll (performs a join over all tables related to this table) and selectIncludingDirectlyRelated (performs a join over the tables directly refrenced by a foreign key defined in this table). This option will be ignored if Database Backend: $config['databaseBackend'] or Web Application: $config['webApplication'] is set to false.

Database Backend: $config['searchSelectMethodName']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. The method to call to get the records for the search controller. Methods that are always valid are: select, selectIncludingAll (performs a join over all tables related to this table) and selectIncludingDirectlyRelated (performs a join over the tables directly refrenced by a foreign key defined in this table). This option will be ignored if Database Backend: $config['databaseBackend'] or Web Application: $config['webApplication'] is set to false.

Database Backend: $config['getSelectMethodName']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. The method to call to get the records for the 'get' controller. Methods that are always valid are: select, selectIncludingAll (performs a join over all tables related to this table) and selectIncludingDirectlyRelated (performs a join over the tables directly refrenced by a foreign key defined in this table). This option will be ignored if Database Backend: $config['databaseBackend'] or Web Application: $config['webApplication'] is set to false.

Database Backend: $config['getPaging']

Whether to implement a paging feature in the get controllers and templates. paging means that not all records are diplayed at once but that you can browse them per page. This option will be ignored if Database Backend: $config['databaseBackend'] or Web Application: $config['webApplication'] is set to false.

Database Backend: $config['searchPaging']

Whether to implement a paging feature in the search controllers and templates. paging means that not all records are diplayed at once but that you can browse them per page. This option will be ignored if Database Backend: $config['databaseBackend'] or Web Application: $config['webApplication'] is set to false.

Database Backend: $config['recordsPerPage']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. How many records to display per page. This option will be ignored if Database Backend: $config['databaseBackend'] or Web Application: $config['webApplication'] is set to false.

Authentication: $config['auth']

If the supplied value evaluates to the boolean value true an authentication system based on PEAR::Auth will be implemented. NOTE: $config['auth'] and all other authentication options will be ignored if Database Backend: $config['databaseBackend'] is set to false.

Authentication: $config['authTable']

The name of the table that stores the login information - ignored if Authentication: $config['auth'] is set to false. This information is used to create a new instance of PEAR::Auth. Please see the documentation of PEAR::Auth for details.

Authentication: $config['authUsernameColumn']

The name of the column that stores the usernames - ignored if Authentication: $config['auth'] is set to false. This information is used to create a new instance of PEAR::Auth. Please see the documentation of PEAR::Auth for details.

Authentication: $config['authPasswordColumn']

The name of the column that stores the passwords - ignored if Authentication: $config['auth'] is set to false. This information is used to create a new instance of PEAR::Auth. Please see the documentation of PEAR::Auth for details.

Authentication: $config['authActivatedColumn']

The name of the column that stores the information if a user is activated (can log in). Pass an empty string if you do not need this feature. Ignored if Authentication: $config['auth'] is set to false. This information is used to create a new instance of PEAR::Auth. Please see the documentation of PEAR::Auth for details.

Authentication: $config['authCryptType']

The name of the cryptographic algorithm to use for storing passwords. Use 'md5', 'crypt' or 'none'. If you might need the feature of sending a user his password use 'none' - ignored if Authentication: $config['auth'] is set to false. This information is used to create a new instance of PEAR::Auth. Please see the documentation of PEAR::Auth for details.

Authentication: $config['authSessionName']

The name of the session cookie to set. IMPORTANT: If two applications on your system use the same cookie name a user who has once logged in at one of the applications can also use the other applications without logging in again! - ignored if Authentication: $config['auth'] is set to false. This information is used to create a new instance of PEAR::Auth. Please see the documentation of PEAR::Auth for details.

Authentication: $config['authSessionTimeout']

The maximum time a session can be idle (in seconds). From a security and performance standpoint of view it is highly recommended to set it to something smaller than 1800 (half an hour) - ignored if Authentication: $config['auth'] is set to false. This information is used to create a new instance of PEAR::Auth. Please see the documentation of PEAR::Auth for details.

Authentication: $config['authLogoutURL']

The URL the user should be redirected to after logout. If your application resides in http://domain.com/app/ and you set $logoutURL to an empty string the user will be redirected to http://domain.com/app/ - ignored if Authentication: $config['auth'] is set to false. AUTH::setLogoutCallback is called to register a callback function that does the redirect.

LiveUser: $config['liveUser']

Whether to implement the authentication and permission management system LiveUser. Please see http://pear.php.net/package-info.php?package=LiveUser and http://projects.21st-hq.de/liveuser for details. LiveUser is not stable yet but under very active development!

LiveUser: $config['liveUserSessionName']

The session name (cookie name) LiveUser uses for all sessions. IMPORTANT: If two applications on your system use the same cookie name a user who has once logged in at one of the applications can also use the other applications without logging in again! This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserLoginSubmitMethod']

The submit method used by the login form. Valid values are 'GET' and 'POST'. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserRememberMe']

Whether to allow the use of the remember-me feature. The name of the "remember me" checkbox on the HTML login form must be 'rememberMe'. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserRememberMeCookieName']

The name for the cookie to store auth information in (used for the "remember me" feature) This option is ignored if LiveUser: $config['liveUserRememberMe'] is set to false.

LiveUser: $config['liveUserRememberMeCookieLifetime']

The lifetime of the "remember me" cookie in days. Note that the cookie lifetime will be refreshed every time the user logs in. This option is ignored if LiveUser: $config['liveUserRememberMe'] is set to false.

LiveUser: $config['liveUserRememberMeCookieDomain']

The domain for the "remember me" cookie. To make the cookie available on all subdomains of example.com then you'd set it to '.example.com'. The . is not required but makes it compatible with more browsers. Setting it to www.example.com will make the cookie only available in the www subdomain. This option is ignored if LiveUser: $config['liveUserRememberMe'] is set to false.

LiveUser: $config['liveUserRememberMeCookiePath']

The path for the "remember me" cookie. If set to '/', the cookie will be available within the entire domain. If set to '/foo/', the cookie will only be available within the /foo/ directory and all sub-directories such as /foo/bar/ of domain. The default value is the current directory that the cookie is being set in. This option is ignored if LiveUser: $config['liveUserRememberMe'] is set to false.

LiveUser: $config['liveUserRememberMeCookieSecretKey']

This is the secret key used for remember-me cookie value encryption. This option is ignored if LiveUser: $config['liveUserRememberMe'] is set to false.

LiveUser: $config['liveUserLogoutRedirectURL']

The URL to redirect to when the user logs out. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserDestroySessionOnLogout']

Whether or not to destroy the entire session on logout. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserAuthIdleTime']

Maximum time of idleness in seconds. Idletime gets refreshed each time, LiveUser::init() is called. If this options is set to 0, idle time is never checked. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserAuthLoginTimeout']

Number of hours that must pass between two logins to be counted as a new login. If you want the auth container to count each login as new login, you've to set it to 0. It is recommended to set this option to 0. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserAuthExpireTime']

Auth lifetime or maximum login time in seconds. If you want the user to be automaticly logged out after one hour, you've to set it to 3600. Attention: If you want to use expire, you should set LiveUser: $config['liveUserAuthLoginTimeout'] to 0 ! It is recommended to set this option to 0. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserAuthAllowDuplicateHandles']

Whether to allow multiple users in the database to have the same login handle. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserAuthPasswordEncryptionMode']

The encryption mode the password is stored in the container. Possible values are 'plain' and 'md5'. You shouldn't use 'plain' for security reasons. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserRefreshRights']

Whether to refresh a user's rights on every request or not. This is neccessary if you deal with dynamic right creation but slows down everything a bit. If set to true $liveUser->_perm->readRights() is called on every request. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserAuthTable']

The name of the database table to be used by the authentication container. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserAuthTableColumnUserid']

The name of the user-ID column in LiveUser: $config['liveUserAuthTable']. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserAuthTableColumnHandle']

The name of the handle (username) column in LiveUser: $config['liveUserAuthTable']. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserAuthTableColumnPassword']

The name of the password column in LiveUser: $config['liveUserAuthTable']. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserAuthTableColumnLastLogin']

The name of the last-login column in LiveUser: $config['liveUserAuthTable']. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserAuthTableColumnIsActive']

The name of the is-active column in LiveUser: $config['liveUserAuthTable']. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserPermType']

The "name" of the container. LiveUser includes the container found in /LiveUser/Perm/Container/"type".php and creates a new object $_perm. For now available are 'DB_Simple', 'DB_Medium' and 'DB_Complex'. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserPermTablePrefix']

Prefix for all database tables used by the permission container. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserAuthAdminClass']

The class name of the auth admin class. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserAuthAdminFile']

The path to the file that contains LiveUser: $config['liveUserAuthAdminClass']. This is usually something like: 'LiveUser/Admin/Auth/Container/DB.php'. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserPermAdminClass']

The class name of the perm admin class. This option is ignored if LiveUser: $config['liveUser'] is set to false.

LiveUser: $config['liveUserPermAdminFile']

The path to the file that contains LiveUser: $config['liveUserAuthAdminClass']. This is usually something like: 'LiveUser/Admin/Perm/Container/DB_Complex.php'. This option is ignored if LiveUser: $config['liveUser'] is set to false.

Database Backend: $config['makeSequenceAssumption']

Whether to make an assumption about the /**sequence**/ setting if a primary key was not defined with one. Please see Sequence Guessing for details. This option is ignored if Database Backend: $config['databaseBackend'] is set to false.

Database Backend: $config['makeIsValidAssumption']

Whether to make an assumption about /**isValid**/ setting if a column was not define with one. Please see IsValid Guessing for details. This option is ignored if Database Backend: $config['databaseBackend'] is set to false.

Database Backend: $config['showKeyColumns'] (Default)

Whether to display the columns defined as primary or foreing key in the templates. With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This option is ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['webApplication']

If the supplied value evaluates to the boolean value true the design model MVC will be implemented. This is done by seperating the Model, the View and the Controller and storing its files in different directories. The template engine SMARTY is used to separate Controller and View. If this option is set to a value that evaluates to true and Web Application: $config['webApplicationSkel'] is set the Web Application Directory Structure is used.

Web Application: $config['smartyLeftDelimiter']

The left delemiter for Smarty-tags generated in the template files. Can be any string. Note that '{{' is recommended.

Web Application: $config['smartyRightDelimiter']

The right delemiter for Smarty-tags generated in the template files. Can be any string. Note that '}}' is recommended.

Web Application: $config['smartyDir']

The path to the directory where you installed Smarty. Example: /usr/share/php/smarty/ or C:/php/inc/smarty/. Note that this directory must not be in the webroot! Use forward slashes and place one at the end of the path! You do not even have to specify an absolute path - just make sure an require_once statement as the following will not fail:


1     require_once("${SMARTY_DIR}Smarty.class.php");

Web Application: $config['webApplicationSkel']

The path to the skel (skeleton directory) for web applications. Set this option to an empty string if you do not want a web application skel to be used. This would be the case if you are regenerating a project. Note: this option is ignored if Web Application: $config['webApplication'] is set to false. Please see Web Application Directory Structure

Web Application: $config['makeInputTypeAssumption']

If this configuration option is set to true, RSD will try to guess the HTML input type of all columns. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['separateRecordTemplate'] (Default)

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. If this configuration option is set to true, the search and get-controllers will not directly implement the way a record is displayed but will include an other file for this purpose. The included file will be be generated as well if this option is set to true. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['allowUserOrderBy'] (Default)

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. If this configuration option is set to true, the search and get-controllers will allow the user to sort the listed records by the column she chooses. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['useHeader'] (Default)

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. If this configuration option is set to true, the generated templates will include a file called header.tpl and the the controllers will include header.php. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['useFooter'] (Default)

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. If this configuration option is set to true, the generated templates will include a file called footer.tpl and the the controllers will include footer.php. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['getControllersArePublic'] (Default)

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. If this configuration option is set to true, the generated get-controllers will be public (require no authentication). This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['getOneControllersArePublic'] (Default)

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. If this configuration option is set to true, the generated getOne-controllers will be public (require no authentication). This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['searchControllersArePublic'] (Default)

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. If this configuration option is set to true, the generated search-controllers will be public (require no authentication). This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['deleteControllersArePublic'] (Default)

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. If this configuration option is set to true, the generated delete-controllers will be public (require no authentication). This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['updateControllersArePublic'] (Default)

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. If this configuration option is set to true, the generated update-controllers will be public (require no authentication). This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['createControllersArePublic'] (Default)

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. If this configuration option is set to true, the generated create-controllers will be public (require no authentication). This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

General: write options

All configuration options starting with `write' know three possible values:


1     `true'      ...create the file in question only if it does not already exist
2     		`false'     ...do not write the file
3     		`overwrite' ...write the file and overwrite an existing file if necessary

Web Application: $config['writePagingTemplate']

This configuration option defines if the paging template file (paging.tpl) should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeHeaderFiles']

This configuration option defines if the header files (header.php, header.tpl) should be written. So this option affects a template AND a controller! Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeFooterFiles']

This configuration option defines if the footer files (footer.php, footer.tpl) should be written. So this option affects a template AND a controller! Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeTemplateGet']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This configuration option defines if the get-template (get${TABLE_NAME}.tpl) files should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeTemplateGetOne']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This configuration option defines if the getOne-template files (getOne${TABLE_NAME}.tpl) should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeTemplateGetRecord']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This configuration option defines if the getRecord-template files should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false. Wheather the generated get-template should try to include a separate file for displaying a record can be defined with Web Application: $config['separateRecordTemplate'] (Default).

Web Application: $config['writeTemplateUpdate']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This configuration option defines if the update-template files (update${TABLE_NAME}.tpl) should be written. This option as well as the per-table setting will affect as well the updateArea, updateGroup and updateRight templates (see {@see RSDEngineDBTemplateFileUpdateGroup}, {@see RSDEngineDBTemplateFileUpdateArea}, {@see RSDEngineDBTemplateFileUpdateRight}). Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeTemplateDelete']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This configuration option defines if the delete-template files (delete${TABLE_NAME}.tpl) should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeTemplateSearch']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This configuration option defines if the search-template files (search${TABLE_NAME}.tpl) should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeTemplateSearchRecord']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This configuration option defines if the searchRecord-template files should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false. Wheather the generated search-template should try to include a separate file for displaying a record can be defined with Web Application: $config['separateRecordTemplate'] (Default).

Web Application: $config['writeTemplateCreate']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This configuration option defines if the create-template files (create${TABLE_NAME}.tpl) should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeFatalErrorTemplate']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This configuration option defines if the fatal error template (fatalError.tpl) should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writePermissionDeniedTemplate']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This configuration option defines if the permission denied template (permissionDenied.tpl) should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeControllerGet']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This configuration option defines if the get-controller (get${TABLE_NAME}.tpl) files should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeControllerGetOne']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This configuration option defines if the getOne-controller files (getOne${TABLE_NAME}.tpl) should be written. This option as well as the per-table setting will affect as well the getOneStored-controller (see {@see RSDEngineDBControllerFileGetStored}). Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeControllerUpdate']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This configuration option defines if the update-controller files (update${TABLE_NAME}.tpl) should be written. This option as well as the per-table setting will affect as well the updateArea, updateGroup and updateRight controllers (see {@see RSDEngineDBControllerFileUpdateGroup}, {@see RSDEngineDBControllerFileUpdateArea}, {@see RSDEngineDBControllerFileUpdateRight}). Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeControllerDelete']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This configuration option defines if the delete-controller files (delete${TABLE_NAME}.tpl) should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeControllerSearch']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This configuration option defines if the search-controller files (search${TABLE_NAME}.tpl) should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeControllerCreate']

With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. This configuration option defines if the create-controller files (create${TABLE_NAME}.tpl) should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeSmartyBaseClass']

This configuration option defines if the smarty base class file should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Web Application: $config['writeSmartyChildClass']

This configuration option defines if the smarty child class file should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Database Backend: $config['writeConfigFile']

This configuration option defines if the application config file should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Database Backend: $config['writeInitFile']

This configuration option defines if the application init file should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Database Backend: $config['writePublicInitFile']

This configuration option defines if the public application file should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Database Backend: $config['writePrivateInitFile']

This configuration option defines if the private application file should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Database Backend: $config['writeIndexFile']

This configuration option defines if the index file (index.php) should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Database Backend: $config['writeLogoutFile']

This configuration option defines if the logout file (logout.php) should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Database Backend: $config['writeApplicationBaseClass']

This configuration option defines if the application base class file should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Database Backend: $config['writeApplicationChildClass']

This configuration option defines if the application child class file should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Database Backend: $config['writeTableBaseClasses']

This configuration option defines if the table base class files should be written. With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Database Backend: $config['writeTableChildClasses']

This configuration option defines if the table child class files should be written. With this option you can define the default. A per-table setting is possible using Table Modifier /**file:OPTIONS**/. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Database Backend: $config['writeErrorManagerClass']

This configuration option defines if the error manager class class file should be written. Please see General: write options. This configuration option will be ignored if Web Application: $config['webApplication'] is set to false.

Mail: $config['mail']

Whether to implement a mail sending system. PEAR::Mail is used for this purpose. Please see its documentation for details.

Mail: $config['mailDefaultSender']

The default sender address to use. This option is ignored if Mail: $config['mail'] is set to false.

Mail: $config['mailType']

The mail sending mechanism to use. Valid values are 'mail', 'sendmail' and 'smtp'. Please see the documentation of PEAR::Mail for details.

If $config['mailType'] is set to 'sendmail' you have to specify the options Mail: $config['mailSendmailPath'] and Mail: $config['mailSendmailArgs'] as well.

If $config['mailType'] is set to 'smtp' you have to specify the options Mail: $config['mailSMTPHost'], Mail: $config['mailSMTPPort'], Mail: $config['mailSMTPAuth'] and evantually Mail: $config['mailSMTPUsername'] and Mail: $config['mailSMTPPassword'] This option is ignored if Mail: $config['mail'] is set to false.

If $config['mailType'] is set to 'mail' the builtin function mail is used and no more options are needed.

Mail: $config['mailSendmailPath']

The location of the sendmail program on the filesystem. This option is ignored if Mail: $config['mailType'] is not set to 'sendmail'.

Mail: $config['mailSendmailArgs']

Additional parameters to pass to the sendmail program. This option is ignored if Mail: $config['mailType'] is not set to 'sendmail'.

Mail: $config['mailSMTPHost']

The SMTP server to connect to. This option is ignored if Mail: $config['mailType'] is not set to 'smtp'.

Mail: $config['mailSMTPPort']

The port to connect to. This option is ignored if Mail: $config['mailType'] is not set to 'smtp'.

Mail: $config['mailSMTPAuth']

Whether or not to use SMTP authentication. This option is ignored if Mail: $config['mailType'] is not set to 'smtp'.

Mail: $config['mailSMTPUsername']

The username to use for SMTP authentication. This option is ignored if Mail: $config['mailSMTPAuth'] is set to false.

Mail: $config['mailSMTPPassword']

The password to use for SMTP authentication. This option is ignored if Mail: $config['mailSMTPAuth'] is set to false.

Output - The Implementation

The RSDEngine follows the coding standards of RSD - Rapid and Secure Development: RSD Coding Conventions. Please see it's documentation for details.

Directory Structures

A project will be created using a specific directory structure. Which one depends on the configuration options set. But all directory structures extend the Basic Directory Structure. Note that all occurences of PROJECT_NAME preceeded and followed by %% and PROJECT_DESCRIPTION preceeded and followed by %% in file or directory names will be replaced with General: $config['projectName'] and General: $config['projectDescription']. In all files all occurences of the string PROJECT_NAME preceeded by %% and followed by %% will be replaced with General: $config['projectName'], all occurences of PROJECT_DESCRIPTION preceeded and followed by %% will be replaced with General: $config['projectDescription'] and all occurences of DOCBOOOK_AUTHORS preceeded and followed by %% will be replaced with DocBook XML tags for the authors in General: $config['authors'].

Basic Directory Structure

The basic directory structure will be used if you set the configuration option Web Application: $config['webApplication'] to a value that evaluates to false. Where the basic directory structore resides must be specified by General: $config['skel']. The distributed skel looks like this:

ROOT                              - The project ROOT. Is renamed to
  ¦                                  $config['projectName'].
  +---code                        - The code of the application.
  +---design                      - Application design information.

Web Application Directory Structure

This directory structure extends the Basic Directory Structure. The project will be created using the web application directory structure if you set Web Application: $config['webApplication'] to a value that evaluates to true. Where the web application directory structore resides must be specified by Web Application: $config['webApplicationSkel']. The distributed web application directory structure looks like this:

    ROOT
      +---code
          +---model            - Application/business logic
          ¦                       should be implemented here.
          +---view             - The presentation logic resides here.
              +---cache        - Used by SMARTY to do some caching.
              +---configs      - SMARTY configuration files
              ¦                   can be stored here.
              +---templates    - Put your SMARTY templates
              ¦                   here.
              +---templates_c  - This is where SMARTY stores the
                                  compiled templates.

Files Generated For Database Backend Support

These files are only generated if Database Backend: $config['databaseBackend'] is set to true.

The Table Base Classes

For each table defined in Database Backend: $config['sql'] a base class is generated. Do not change the base class because these changes will get lost when regenerating your project! Each class is stored in a separate file named like the class itself (with .php appended). All Table Base Classes extend the class RSDTable. Please see its documentation for details. The Table Base Classes are generated by the classes RSDEngineDB and RSDEngineDBTable.

The name of a Table Base Class is generated like this:


1     ucfirst($projectName) . ucfirst($tableNameWithoutPrefix) . 'Base'

If Web Application: $config['webApplication'] is set to true it is stored in ROOT/code/model. If it's not, it is stored directly in the ROOT/code.

The following methods are created for all columns:

isValid$columnName: Returns true if the passed argument is valid for this column. Passing the boolean value true as second argument allows you to force a referential integrity check.

The following methods are created for all columns defined as a PRIMARY KEY, FOREIGN KEY or "undefined" key using /**key**/:

deleteBy$columnName: Deletes all records from the table where $columnName equals the value passed as argument.
updateBy$columnName: Updates all records in the table where $columnName equals the value passed as first argument. Which columns should be updated must be specified by an associative array, passed as second argument, that contains column-value pairs.
getBy$columnName: Returns an array containing all records from the table where $columnName equals the value passed as argument.

The following methos are created for all columns defined with /**sequence:sequence_name**/:

getNext$columnName: Returns a new id from the sequence specified for sequence_name. Note that PEAR::DB emulates sequences if not supported by your RDBMS.

The following methos are created for all columns defined with /**isValid:file**/:

storeUploaded$columnName: Stores a file uploaded for this column in the defined storage directory.
removeStored$columnName: Removes a file stored for this column.
getStored$columnName: Returns the contents of a file stored for this column.

The following methods are as well generated:

checkUniqueConstraints: Returns true if no unique constraints would be violated by using the array of assignments passed as argument for a INSERT or a UPDATE operation. Otherwise an instance of PEAR_Error is returned.
getSmartyHTMLOptionsArray: Returns an array for use with a SMARTY {html_options} statement. If you call this method without an argument the method getLabelColumn will be called to retrieve a literal representation for a record.
getLabelColumn: Returns an sql statement that can be used in a select query to retrieve a literal representation of this record. This method returns the name of the first column defined as VARCHAR. If no column was defined as VARCHAR the name of the first record is returned. You are encouraged to overwrite this method in the child class.
insert: Inserts one record into the table. Returns a new DB_Result (from PEAR::DB) on success or a DB_Error (from PEAR::DB) which extends PEAR_Error on failure. This method overwrites RSDTable::insert to assign the default values and to check LiveUser rights (if configured to do so).
update: Updates one or more records in the table. Returns a new DB_Result (from PEAR::DB) on success or a DB_Error (from PEAR::DB) which extends PEAR_Error on failure. This method overwrites RSDTable::update to assign the default values and to check LiveUser rights (if configured to do so).
delete: Deletes one or more records in the table. Returns a new DB_Result (from PEAR::DB) on success or a DB_Error (from PEAR::DB) which extends PEAR_Error on failure. This method overwrites RSDTable::delete to check LiveUser rights (if configured to do so).
select: Selects one or more records from the table. Returns an array of records on success or a DB_Error (from PEAR::DB) which extends PEAR_Error on failure. This method overwrites RSDTable::select and checks as well LiveUser rights (if configured to do so). This method tries as well to set the array fields '__canUpdate' and '__canDelete' as well.
canInsert: This method returns whether the currently logged in user has sufficient permissions to create a record. To define what permissions the user must have please see Table Modifier /**LiveUserRight[:$OPERATION]:rightId=$RIGHT_ID|condition=PHP_CODE|recordCondition=PHP_CODE**/.
canUpdate: This method returns whether the currently logged in user has sufficient permissions to perform an update operation. There are two ways of using this method. The first one is to find out if the user has the permission to perform an update at all - do this by passing no argument. The second one is to pass a record as an array. This tells you whether you can update the specific record passed as argument. This method does as well create a new element in the array passed as argument. The element key will be '__canUpdate' and the value is equal to the return value. This allows you to call canUpdate for multiple record arrays and handle the results later on easyly. Please not that the select(Including*) methods try to set this property as well. To define what permissions the user must have please see Table Modifier /**LiveUserRight[:$OPERATION]:rightId=$RIGHT_ID|condition=PHP_CODE|recordCondition=PHP_CODE**/.
canDelete: This method returns whether the currently logged in user has sufficient permissions to perform a delete operation. There are two ways of using this method. The first one is to find out if the user has the permission to perform a delete operation at all - do this by passing no argument. The second one is to pass a record as an array. This tells you whether you can delete the specific record passed as argument. This method does as well create a new element in the array passed as argument. The element key will be '__canDelete' and the value is equal to the return value. This allows you to call canUpdate for multiple record arrays and handle the results later on easyly. Please not that the select(Including*) methods try to set this property as well. To define what permissions the user must have please see Table Modifier /**LiveUserRight[:$OPERATION]:rightId=$RIGHT_ID|condition=PHP_CODE|recordCondition=PHP_CODE**/.
canSelect: This method returns whether the currently logged in user has sufficient permissions to perform a select operation. There are two ways of using this method. The first one is to find out if the user has the permission to perform a select operation at all - do this by passing no argument. The second one is to pass a record as an array. This tells you whether you can select the specific record passed as argument. This method does as well create a new element in the array passed as argument. The element key will be '__canSelect' and the value is equal to the return value. This allows you to call canUpdate for multiple record arrays and handle the results later on easyly. Please not that the select(Including*) methods try to set this property as well. To define what permissions the user must have please see Table Modifier /**LiveUserRight[:$OPERATION]:rightId=$RIGHT_ID|condition=PHP_CODE|recordCondition=PHP_CODE**/.
selectIncluding*: selectIncluding methods are created for all possible combinations of tables that are related to each other by foreign/primary keys. A method named 'selectIncludingFolder' of a class representing the table 'prj_document' would perform a join over both tables using the foreign key and primary key as WHERE condition. These methos return an array of records on success or a DB_Error (from PEAR::DB) which extends PEAR_Error on failure. These methods check as well LiveUser rights (if configured to do so). IMPORTANT: if the LiveUserRight table modifier is defined with a $RIGHT_ID of 'table.column' and this 'table' is not included in the specific join a permission denied error will be raised unless RSD_NO_LIVEUSER_RIGHT_CHECK was passed as argument. Please see Table Modifier /**LiveUserRight[:$OPERATION]:rightId=$RIGHT_ID|condition=PHP_CODE|recordCondition=PHP_CODE**/. This method tries as well to set the array fields '__canUpdate' and '__canDelete' as well.

The class has the following public properties:

TableBaseClass::db: A handle to an instance of PEAR::DB.
TableBaseClass::name: The name of the table.
TableBaseClass::app: A handle to the instance of the Application Child Class that created this instance.

For more information just create a documentation of your project and have a look at your Table Base Classes.

The Table Child Classes

For each table a Table Child Class is generated. This file is only generated if it does not already exit - so this is where you can do your implementation. Do not change the base class because these changes will get lost when regenerating your project! Each class is stored in a separate file named like the class itself (with .php appended). A Table Child Class extends the The Table Base Classes. A Table Child Class is generated by the classes RSDEngineDB and RSDEngineDBTable.

Its name is generated like this:


1     ucfirst($projectName) . ucfirst($tableNameWithoutPrefix)

If Web Application: $config['webApplication'] is set to true it is stored in ROOT/code/model. If it's not, it is stored directly in the ROOT/code.

This is where you can implement additional logic for this table. The file that contains this class is NOT overwritten when regenerating your porject. The child classes as they are generated do nothing but to inherit from the corresponding The Table Base Classes and to call the parent constructor inside its own constructor.

The Application Base Class

If LiveUser: $config['liveUser'] is set to false it extends the class RSDApplication. If LiveUser: $config['liveUser'] is set to true it extends RSDLiveUserApplication which extends RSDApplication. So you will be always - directly or not - inheriting from RSDApplication. This class is generated by the class RSDEngineDBApplicationBaseClass. Do not change the base class because these changes will get lost when regenerating your project!

The name of the class (and the file, just with '.php' appended) is generated like this:


1     ucfirst($config['projectName']) . 'Base'

If Web Application: $config['webApplication'] is set to true it is stored in ROOT/code/model. If it's not, it is stored directly in the ROOT/code.

The Application Class holds handles to all objects created:

ApplicationClass::getTable($tableName): Method that returns an instance of the Table Child Class (see The Table Child Classes) representing this table.
ApplicationClass::auth: Property that holds a handle to an instance of PEAR::Auth (if the project was created with support for PEAR::Auth).
ApplicationClass::liveUser: Property that holds a handle to an instance of PEAR::LiveUser (if the project was created with support for PEAR::LiveUser).
ApplicationClass::liveUser: Property that holds a handle to an instance of Smarty (if the project was created with support for Smarty).
ApplicationClass::errorManager: Property that holds a handle to an instance of RSErrorManager.
ApplicationClass::db: Property that holds a handle to an instance of PEAR::DB.

For more information just create a documentation of your project and have a look at your Application Base Class.

The Application Child Class

It extends the class The Application Base Class. This class is generated by the class RSDEngineDBApplicationClass. This file is only generated if it does not already exit - so this is where you can do your implementation. Do not change the base class because these changes will get lost when regenerating your project!

The name of the class (and the file, just with '.php' appended) is generated like this:


1     ucfirst($config['projectName'])

If Web Application: $config['webApplication'] is set to true it is stored in ROOT/code/model. If it's not, it is stored directly in the ROOT/code.

For more information just create a documentation of your project and have a look at your Application Child Class.

The Application Config File

It contains declarations of constants for your application. This file is generated by the class RSDEngineDBApplicationConfigFile. Do not change this file because these changes will get lost when regenerating your project! The Application Config File contains only constants configurable through the web interface of RSD. If you need additional constants use Database Backend: $config['additionalConfig']! If this is for whatever reason not possible create a new file and include it in the The Application Init File.

The name of the Application Config File is generated like this:


1     strtolower($this->config['projectName']) . "Config.php"

If Web Application: $config['webApplication'] is set to true it is stored in ROOT/code/model. If it's not, it is stored directly in the ROOT/code.

For more information just create a documentation of your project and have a look at your Application Config File.

The Index File

This file is primary for demonstration purpose. This file is generated by the class RSDEngineDBApplicationIndexFile. It will only be generated if it does not already exist.

The name of the file is index.php. It is stored in ROOT/code

For more information just create a documentation of your project and have a look at your index.php.

The Logout File

Requesting logout.php with a browser logs you out (and depending on the configuration destroys your session). This file is generated by the class RSDEngineDBApplicationLogoutFile. It will only be generated if it does not already exist.

The name of this file is logout.php. It is stored in ROOT/code

For more information just create a documentation of your project and have a look at your logout.php.

The Application Init File

This file creates instances of the The Application Child Class and initializes it. This file is generated by the class RSDEngineDBApplicationInitFile. It will only be generated if it does not already exist.

The name of the init file is generated like this:


1     strtolower($this->config['projectName']). "Init.php"

If Web Application: $config['webApplication'] is set to true it is stored in ROOT/code/model. If it's not, it is stored directly in the ROOT/code.

For more information just create a documentation of your project and have a look at your Application Init File.

The Public Application Init File

The generated file includes The Application Init File. It does not force authentication. Therefore including this file in a controller makes the controller 'public' - no authentication is needed to access it. This file is generated by the class RSDEngineDBApplicationPublicInitFile. It will only be generated if it does not already exist.

The name of the Public Application Init File is generated like this:


1     strtolower($this->config['projectName']) . "Init_public.php"

If Web Application: $config['webApplication'] is set to true it is stored in ROOT/code/model. If it's not, it is stored directly in the ROOT/code.

For more information just create a documentation of your project and have a look at your Public Application Init File.

The Private Application Init File

The generated file includes The Application Init File. It does force authentication. Therefore including this file in a controller makes the controller 'private' - authentication is required to access it. This file is generated by the class RSDEngineDBApplicationPrivateInitFile. It will only be generated if it does not already exist.

The name of the Private Application Init File is generated like this:


1     strtolower($this->config['projectName']) . "Init_private.php"

If Web Application: $config['webApplication'] is set to true it is stored in ROOT/code/model. If it's not, it is stored directly in the ROOT/code.

For more information just create a documentation of your project and have a look at your Private Application Init File.

The Error Manager Class

The generated class extends RSErrorManager. Most important it overwrites the methods 'onFatalError' and 'onPermissionDenied'. If Web Application: $config['webApplication'] is set to true these methods use the templates fatalError.tpl and permissionDenied.tpl to display the error information. This file is generated by the class RSDEngineErrorManagerClass. It will only be generated if it does not already exist.

The name of the Error Manager Class (and the name of the file, just with '.php' appended) is generated like this:


1     ucfirst($this->config['projectName']) . 'ErrorManager'

If Web Application: $config['webApplication'] is set to true it is stored in ROOT/code/model. If it's not, it is stored directly in the ROOT/code.

Files Generated For Web Applications

These files are only generated if Web Application: $config['webApplication'] is set to true.

The Smarty Class

This class extends Smarty.

The name of the Smarty Class (and the name of the file, just with '.php' appended) is generated like this:


1     ucfirst($this->config['projectName']) . 'Smarty'

It is stored in ROOT/code/model.

For more information just create a documentation of your project and have a look at your Smarty Class file.

Controller Files

For all tables the following controller files are created:

A file to create a new record. Its name is generated like this:


1     "create" . ucfirst($this->config['table']->getTableNameWithoutPrefix()) . ".php"

A file to delete a single record. It can only be generated if the table is defined with a primary key. Its name is generated like this:


1     "delete" . ucfirst($this->config['table']->getTableNameWithoutPrefix()) . ".php"

A file to update a single record. It can only be generated if the table is defined with a primary key. Its name is generated like this:


1     "update" . ucfirst($this->config['table']->getTableNameWithoutPrefix()) . ".php"

A file to list (get) all records. Its name is generated like this:


1     "get" . ucfirst($this->config['table']->getTableNameWithoutPrefix()) . ".php"

A file to view (get) a single record. It can only be generated if the table is defined with a primary key. Its name is generated like this.


1     "getOne" . ucfirst($this->config['table']->getTableNameWithoutPrefix()) . ".php"

For all columns defined as /**isValid:file**/ a file is created that diplays the contents of the uploaded file. Its name is generated like this.


1     "getStored" . ucfirst($this->config['table']->getTableNameWithoutPrefix()) . ucfirst($this->config['column']->getColumnNameForVariableName()) . ".php"

The controllers are stored in ROOT/code.

For more information just have a look at your generated controllers.

Template Files

For all tables the following template files are created:

A file to create a new record. Its name is generated like this.


1     "create" . ucfirst($this->config['table']->getTableNameWithoutPrefix()) . ".tpl"

A file to delete a single record. It can only be generated if the table is defined with a primary key. Its name is generated like this.


1     "delete" . ucfirst($this->config['table']->getTableNameWithoutPrefix()) . ".tpl"

A file to update a single record. It can only be generated if the table is defined with a primary key. Its name is generated like this.


1     "update" . ucfirst($this->config['table']->getTableNameWithoutPrefix()) . ".tpl"

A file to list (get) all records. Its name is generated like this.


1     "get" . ucfirst($this->config['table']->getTableNameWithoutPrefix()) . ".tpl"

A file to view (get) a single record. It can only be generated if the table is defined with a primary key. Its name is generated like this.


1     "getOne" . ucfirst($this->config['table']->getTableNameWithoutPrefix()) . ".tpl"

Additionally the following templates are created:

fatalError.tpl: The template used by The Error Manager Class for displaying fatal errors.
permissionDenied.tpl: The template used by The Error Manager Class for displaying permission denied errors.

The templates are stored in ROOT/code/view/templates.

For more information just have a look at the your generated templates.

Extending the generated Code

The RSDEngine does a lot of work for you - but not all of it. This section tries to help the programmer with his task.

Extending the Table Classes

Just modify one of the The Table Child Classes. Overwrite existing methods or add new ones - as you wish. The Table Child Class files are only generated if they do not already exit - so this is where you can do your implementation.

Crating Templates and Controllers

New Template: create a new file with the extention .tpl and save it in ROOT/code/view/templates/. For how to work with Smarty please see http://smarty.php.net. You best start by coping parts of an other template.

New Controller: create a new PHP file in ROOT/code. You best start by coping parts of an other controller.

Modify Templates

This should actually be done by the HTML-guy. Once the basic presentation logic is generated, building HTML around it is pretty easy. If you need to change the presentation logic, it would be very efficient if the HTML-guy learns how to use the SMARTY tags. Again, please see http://smarty.php.net.

Previous		Next
UnitTests		RSDTable

Documentation generated on Mon, 8 Dec 2003 13:10:23 +0100 by phpDocumentor 1.2.3

RSDEngine - The Rapid and Secure Development Engine

aka The Rocket Science Development Engine

Table of Contents

Introduction

What The RSDEngine Is Not

Input - Configuration Options

General: $config['versioning']

General: $config['projectName']

General: $config['projectDescription']

General: $config['authors']

General: $config['copyright']

General: $config['skel']

General: $config['updateVersionAfterRelease']

General: $config['phpDocumentorDir']

General: $config['install']

General: $config['readme']

Database Backend: $config['databaseBackend']

Database Backend: $config['databaseHost']

Database Backend: $config['databaseName']

Database Backend: $config['databaseUsername']

Database Backend: $config['databasePassword']

Database Backend: $config['databaseType']

Database Backend: $config['databaseEnsureReferentialIntegrity']

Database Backend: $config['tablePrefix']

Database Backend: $config['columnPrefix']

Database Backend: $config['validationClassName']

Database Backend: $config['validationClassFile']

Database Backend: $config['fileStorageDirectory']

Database Backend: $config['additionalConfig']

Database Backend: $config['sql']

Formatting

Table Modifiers - General

Table Modifier /**ignore**/

Table Modifier /**label**/

Table Modifier /**beforeInsert:PHP_CODE**/

Table Modifier /**afterInsert:PHP_CODE**/

Table Modifier /**beforeUpdate:PHP_CODE**/

Table Modifier /**afterUpdate:PHP_CODE**/

Table Modifier /**beforeDelete:PHP_CODE**/

Table Modifier /**afterUpdate:PHP_CODE**/

Table Modifier /**LiveUserRight[:$OPERATION]:rightId=$RIGHT_ID|condition=PHP_CODE|recordCondition=PHP_CODE**/

Table Modifier /**file:OPTIONS**/

Table Modifier /**excludeSelectMethod:REG_EXPR[,REG_EXPR][,REG_EXPR][...]**/

Table Modifier /**includeSelectMethod:REG_EXPR[,REG_EXPR][,REG_EXPR][...]**/

Column Modifiers - General

Column Modifier /**ignore**/

Column Modifier /**canBeNull**/

Column Modifier /**isValid:TYPE:ARG1:ARG2:ARG3...**/

Column Modifier /**inputType:TYPE[:TYPE_DATA]**/

Column Modifier /**defaultInsert:PHP_EXPRESSION**/

Column Modifier /**defaultUpdate:PHP_EXPRESSION**/

Column Modifier /**sequence:sequence_name**/

Column Modifier /**doNotInsert**/

Column Modifier /**doNotSelect**/

Column Modifier /**doNotUpdate**/

Column Modifier /**deleteLiveUserRightOnDelete**/

Column Modifier /**deleteLiveUserGroupOnDelete**/

Column Modifier /**deleteLiveUserAreaOnDelete**/

Column Modifier /**editLiveUserRight[:$OPERATION][:[rightId=$RIGHT_ID]|[condition=PHP_CODE]]**/

Column Modifier /**editLiveUserArea[:$OPERATION][[:rightId=$RIGHT_ID]|[condition=PHP_CODE]]**/

Column Modifier /**editLiveUserGroup[:$OPERATION][:[rightId=$RIGHT_ID]|[condition=PHP_CODE]]**/

Column Modifier /**key**/

Column Modifier PRIMARY KEY (Column Constraint)

Column Modifier UNIQUE (Column Constraint)

Column Modifier FOREIGN KEY (Table Constraint)

Column Modifier /**deleteReferencedRecordOnDelete**/

Column Modifier UNIQUE (Table Constraint)

Column Modifier PRIMARY KEY (Table Constraint)

Ignored: INDEX

IsValid Guessing

Sequence Guessing

Dynaminc Naming

Database Backend: $config['getOneSelectMethodName']

Database Backend: $config['searchSelectMethodName']

Database Backend: $config['getSelectMethodName']

Database Backend: $config['getPaging']

Database Backend: $config['searchPaging']

Database Backend: $config['recordsPerPage']

Authentication: $config['auth']

Authentication: $config['authTable']

Table Modifier /ignore/

Table Modifier /label/

Table Modifier /beforeInsert:PHP_CODE/

Table Modifier /afterInsert:PHP_CODE/

Table Modifier /beforeUpdate:PHP_CODE/

Table Modifier /afterUpdate:PHP_CODE/

Table Modifier /beforeDelete:PHP_CODE/

Table Modifier /afterUpdate:PHP_CODE/

Table Modifier /LiveUserRight[:$OPERATION]:rightId=$RIGHT_ID|condition=PHP_CODE|recordCondition=PHP_CODE/

Table Modifier /file:OPTIONS/

Table Modifier /excludeSelectMethod:REG_EXPR[,REG_EXPR][,REG_EXPR][...]/

Table Modifier /includeSelectMethod:REG_EXPR[,REG_EXPR][,REG_EXPR][...]/

Column Modifier /ignore/

Column Modifier /canBeNull/

Column Modifier /isValid:TYPE:ARG1:ARG2:ARG3.../

Column Modifier /inputType:TYPE[:TYPE_DATA]/

Column Modifier /defaultInsert:PHP_EXPRESSION/

Column Modifier /defaultUpdate:PHP_EXPRESSION/

Column Modifier /sequence:sequence_name/

Column Modifier /doNotInsert/

Column Modifier /doNotSelect/

Column Modifier /doNotUpdate/

Column Modifier /deleteLiveUserRightOnDelete/

Column Modifier /deleteLiveUserGroupOnDelete/

Column Modifier /deleteLiveUserAreaOnDelete/

Column Modifier /editLiveUserRight[:$OPERATION][:[rightId=$RIGHT_ID]|[condition=PHP_CODE]]/

Column Modifier /editLiveUserArea[:$OPERATION][[:rightId=$RIGHT_ID]|[condition=PHP_CODE]]/

Column Modifier /editLiveUserGroup[:$OPERATION][:[rightId=$RIGHT_ID]|[condition=PHP_CODE]]/

Column Modifier /key/

Column Modifier /deleteReferencedRecordOnDelete/