An instance of PEAR::DB

Constructor that calls the base class constructor PEAR().

Must be overwritten. Should return 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 false should be returned.

• Array $assignments: An array of key-value pairs.

Deletes records from this table.

• return: True on success, an instance of PEAR_Error on failure.
• see: RSDTable::generateWhereClause()

• String $whereConditions: A SQL-WHERE clause like 'WHERE table.filed=1' or any other argument valid for generateWhereClause.

Returns a WHERE clause generated from the array passed as argument.

• see: RSDTable::_generateAssignment()

• mixed $conditions: An array from which to generate the WHERE clause. The first way is to construct $conditions from column-value assignments as in the following example:

  
  1     $table->generateWhereClause(
  2            array(
  3                "f_title" => "Peters's",
  4                "f_date" => new RSDColumnValue("NOW()", "!"),
  5                "f_file" => RSDColumnValue("test.txt", "&"),
  6                "f_description" => RSDColumnValue("This is a test.", "?"),
  7                "f_data" => RSDColumnValue("test", "%")
  8            )
  9        );

  The element key represents the column name. The value that should be 'assigned' to the column can either be specified directly as the element value or as an instance of RSDColumnValue. Note that "f_title" => "My Title" is equal to "f_title" => RSDColumnValue('My Title', '?') because '?' is the default. The column name, the column value and the 'prepareString' ('!','&','?' or '%') are passed to the method $this->_generateAssignment. The example above would result in the following where clause (if oracle is used; ' is escaped with ''):

  
  1     WHERE
  2           f_title='Peters''s'
  3           AND
  4           f_date=NOW()
  5           AND
  6           f_file='The contents of the file test.txt with quotes('') escaped.'
  7           AND
  8           f_data LIKE '%test%'

  If you wish to connect the conditions differently than by AND, use the following format:

  
  1     $table->generateWhereClause(
  2            array(
  3                array(
  4                    "f_title" => "Peters's",
  5                    "f_date" => RSDColumnValue("NOW()", "!"),
  6                    "f_file" => RSDColumnValue("test.txt", "&"),
  7                    "f_description" => RSDColumnValue("This is a test.", "?"),
  8                    "f_data" => RSDColumnValue("test", "%")
  9                ),
  10               "%s1 AND %s2 AND (%s3 OR %s4 OR %s5)"
  11           )
  12       );

  Note that the the conditions-array from the previous example is now itself placed in an array (as the first element. The second element is a string that defines the format. %s1 is replaced with the first condition, %s2 with the second condition, and so on... If $conditions is a string this string will be returned without modifications. If $conditions is an array and has has a length of 0 or is (===) the boolean value false, an empty string will be returned. NOTE: this might be dangerous if the where clause is used in a DELETE or UPDATE statement! If $conditions is not an array and not a string the string "WHERE 1=2" will be returned. This is because if it's not a string nor an array something must have gone wrong; and in in that case we do not want to risk to cause unexpected results.

Fetch all the rows returned from a query.

This method is just like the method DB::getAll. But it adds the possibility to limit the result by specifying the arguments $from and $to.

• return: an nested array, or a DB error
• access: public

• string $query: the SQL query
• array $params: array if supplied, prepare/execute will be used with this array as execute parameters
• integer $fetchmode: the fetch mode to use

Returns the name of the method that checks if a value is valid for the column supplied as argument.

• return: The name of the isValid-Method.

• String $columnName: The column name.

Returns just one field of one record from this table.

This method uses getRow to get one record from this table. array_shift is used to extract the first column.

• return: A string holding value of the first field of the retrieved column or an instance of PEAR_Error on failure.
• see: RSDTable::getRow()

• boolean $checkRight: Whether to check if the current user has the right to perform this operation. The default is true.
• conditions $conditions: mixed Any argument valid vor generatedWhereClause.
• selectMethod $selectMethod: String Valid values are the names of all methods stating with "selectIncluding..." and "select". This argument is optional. The default is 'select'.
• columns $columns: String The columns to select. The default is "*" (all).

Returns just one record from this table.

• return: An array holding the first record retrieved from the database or an instance of PEAR_Error on failure.
• see: RSDTable::get()

• mixed $conditions: Any argument valid vor generatedWhereClause.
• String $selectMethod: Valid values are the names of all methods stating with "selectIncluding..." and "select". This argument is optional. The default is 'select'.
• String $columns: The columns to select. The default is "*" (all).
• boolean $checkRight: Whether to check if the current user has the right to perform this operation. The default is true.

Inserts a record into the table.

The argument $inserts contains a variable number of values assigned to fields. The key is always the clumn name. The value can be just a string as it is the case for f_title in the following example. But it is as well possible to specify the value as an instance of RSDColumnValue containing two properties. These properties are set by the contructor of RSDColumnValue. The first constructor argument specifies the value, the second specifies the prepare string (i.e. the way this value should be treated). You can set the second field to the string '!' as it is the case for f_date to prevent the value to be quoted. You can as well set it to '&' which means the value is a filename and its contents should be inserted. Note that the assignment for f_title is equivalent to the assignment for f_description because '?' is assumed if the value is not specified as an instance of RSDColumnValue.

1     $table->insert(
2          array(
3              "f_title" => "My Title",
4              "f_date" => new RSDColumnValue("NOW()", "!"),
5              "f_file" => new RSDColumnValue("test.text", "&"),
6              "f_description" => new RSDColumnValue("This is a test.", "?")
7          )
8      );

• return: True on success or an instance of PEAR_Error on failure.

• Array $inserts: Contains the columns and the values as key-value pairs.
• boolean $hypothetical: If set to true this method will return true if the user has the right to perform this operation. Otherwise an instance of RSError will be returned. This argument is optional. The default is false.* @return mixed True on success, an instance of PEAR_Error on failure.

Returns true if such a primary key exists in the specified table otherwise a new PEAR_Error.

• return: True if the value is a valid foreign key.

• $foreignKey $foreignKey: String The value of the foreign key.
• $primaryKey $primaryKey: String The column that holds the primary keys in ablsolute notation ("table.column").

Returns a two-demensional Array of records. One record is hold by one array.

All arguments are optional.

• return: An array of records.
• see: RSDTable::generateWhereClause()

• String $whereClause: Any value valid for generateWhereClause.
• String $orderByClause: A SQL-ORDER BY clause like 'ORDER BY table.column1 AND table.column2'
• int $from: If $from and $to are specified only the records from $from to $to are fechted and returened.
• int $to: See $from

This method should be overwritten in a child class. It should perform a join over all tables that referenced by a foreign key define in this table.

• return: An array of records.

• String $whereClause: Any value valid for generateWhereClause.
• String $orderByClause: A SQL-ORDER BY clause like 'ORDER BY table.column1 AND table.column2'
• int $from: If $from and $to are specified only the records from $from to $to are fechted and returened.
• int $to: See $from