Source for file SqlRecord.php

Documentation is available at SqlRecord.php

  1. <?php
  2.     /**
  3.      * SQL Record Class
  4.      *
  5.      * @copyright Copyright (c) 2003-2006 Mirchev Ideas Ltd. All rights reserved.
  6.      * @package MIPHPF
  7.      */
  8.     
  9.     /**
  10.      */
  11.     if (class_exists('miStaticDBUtil', false) == false) {
  12.         require_once(dirname(__FILE__) . '/../database/StaticDBUtil.php');
  13.     }
  14.     
  15.     /**
  16.      * Handle and manage the inserting, updating, deleting and reading of data from the
  17.      * database. This class works only with one record row specified by a table primary key or
  18.      * unique field.
  19.      *
  20.      * @copyright Copyright (c) 2003-2006 Mirchev Ideas Ltd. All rights reserved.
  21.      * @package MIPHPF
  22.      */
  23.     class miSqlRecord {
  24.         
  25.         
  26.         /**
  27.          * @access protected
  28.          */
  29.         protected $_row = array();
  30.         
  31.         
  32.         /**
  33.          * @access protected
  34.          */
  35.         protected $_table = '';
  36.         
  37.         
  38.         /**
  39.          * @access protected
  40.          */
  41.         protected $_primaryKey = '';
  42.         
  43.         
  44.         /**
  45.          * miSqlRecord constructor. It takes two parameters table name and
  46.          * table primary key
  47.          * 
  48.          * Example:
  49.          * <code>
  50.          * <?php
  51.          * $record = new miSqlRecord('tableName', 'tablePrimaryKey');
  52.          * ?>
  53.          * </code>
  54.          * 
  55.          * @access public
  56.          * @param string $table database table name
  57.          * @param string $primaryKey database table primary key
  58.          */
  59.         public function __construct($table, $primaryKey)
  60.         {
  61.             $this->_table = $table;
  62.             $this->_primaryKey = $primaryKey;
  63.         }
  64.         
  65.         
  66.         /**
  67.          * Gets the primary key column of the table that this SQLRecord uses
  68.          * 
  69.          * @access public
  70.          * @return string the primary key column name
  71.          */
  72.         public function getPrimaryKeyColumn()
  73.         {
  74.             return $this->_primaryKey;
  75.         }
  76.         
  77.         
  78.         /**
  79.          * Gets the table name of this SQLRecord
  80.          * 
  81.          * @access public
  82.          * @return string the table name
  83.          */
  84.         public function getTableName()
  85.         {
  86.             return $this->_table;
  87.         }
  88.         
  89.         
  90.         /**
  91.          * Gets the value of a field
  92.          * 
  93.          * Example:
  94.          * <code>
  95.          * <?php
  96.          * $record = new miSqlRecord('tableName', 'tablePrimaryKey');
  97.          * $record->readPK($value);
  98.          * $value = $record->get($someField);
  99.          * ?>
  100.          * </code>
  101.          * @access public
  102.          * @param string $field field name
  103.          * @return mixed the field value
  104.          */
  105.         public function get($field) {
  106.             return $this->_row[$field];
  107.         }
  108.         
  109.         /**
  110.          * Gets the value of the primary key
  111.          * 
  112.          * @access public
  113.          * @return mixed the primary key value
  114.          */
  115.         public function getPK()
  116.         {
  117.             return $this->_row[$this->_primaryKey];
  118.         }
  119.         
  120.         /**
  121.          * Sets the value of a field
  122.          * 
  123.          * Example:
  124.          * <code>
  125.          * <?php
  126.          * $record = new miSqlRecord('tableName', 'tablePrimaryKey');
  127.          * $record->set($field, $value);
  128.          * ?>
  129.          * </code>
  130.          * @access public
  131.          * @param string $field the name of the field
  132.          * @param mixed $value value of the field
  133.          */
  134.         public function set($field, $value)
  135.         {
  136.             $this->_row[$field] = $value;
  137.         }
  138.         
  139.         
  140.         /**
  141.          * Return the data row as array
  142.          * 
  143.          * Example:
  144.          * <code>
  145.          * <?php
  146.          * $record = new miSqlRecord('tableName', 'tablePrimaryKey');
  147.          * $record->readPK($value);
  148.          * $row = $record->getRow();
  149.          * ?>
  150.          * </code>
  151.          * @access public
  152.          * @return array the data row
  153.          */
  154.         public function getRow()
  155.         {
  156.             return $this->_row;
  157.         }
  158.         
  159.         
  160.         /**
  161.          * Directly set the data row
  162.          * 
  163.          * Example:
  164.          * <code>
  165.          * <?php
  166.          * $record = new miSqlRecord('tableName', 'tablePrimaryKey');
  167.          * $record->setRow($row);
  168.          * ?>
  169.          * </code>
  170.          * @access public
  171.          * @param array $dataRow the data row
  172.          */
  173.         public function setRow($dataRow)
  174.         {
  175.             $this->_row = $dataRow;
  176.         }
  177.         
  178.         
  179.         /**
  180.          * Read a record where the specified field represented by $key
  181.          * is equal to the value represented by $value
  182.          * If there are is than one record matching the first one will be read in
  183.          *
  184.          * Example:
  185.          * <code>
  186.          * <?php
  187.          * $record = new miSqlRecord('tableName', 'tablePrimaryKey');
  188.          * $record->read('uniqueField', $uniqueFieldValue);
  189.          * ?>
  190.          * </code>
  191.          * @param string $key the name of the field
  192.          * @param string $value the value
  193.          * @return void 
  194.          * @throws miDBException
  195.          */
  196.         public function read($key, $value)
  197.         {
  198.             $query = 'SELECT * FROM ' . $this->_table . ' WHERE ' . $key . '="' . sql_escape_string($value) . '"';
  199.             $rows = miStaticDBUtil::execSelect($query);
  200.             if (count($rows)<1) {
  201.                 throw new miDBException('Record not found', miDBException::EXCEPTION_RECORD_NOT_FOUND);
  202.             }
  203.             
  204.             $this->_row = $rows[0];
  205.         }
  206.         
  207.         
  208.         /**
  209.          * Read a record using the specified primary key value
  210.          *
  211.          * Example:
  212.          * <code>
  213.          * <?php
  214.          * $record = new miSqlRecord('tableName', 'tablePrimaryKey');
  215.          * $record->readPK($value);
  216.          * ?>
  217.          * </code>
  218.          * @param mixed $value primary key value
  219.          * @return void 
  220.          * @throws miDBException
  221.          */
  222.         public function readPK($value)
  223.         {
  224.             $this->read($this->_primaryKey, $value);
  225.         }
  226.         
  227.         
  228.         /**
  229.          * Insert a record in the db table
  230.          * It also updates the the PK value of the inserted row
  231.          *
  232.          * @access public
  233.          * @return PK the primary key of the newly created record
  234.          * @throws miDBException
  235.          */
  236.         public function insert()
  237.         {
  238.             return $this->_row[$this->_primaryKey] = miStaticDBUtil::execInsert($this->_table, $this->_row);
  239.         }
  240.         
  241.         
  242.         /**
  243.          * Update a record in the db table
  244.          *
  245.          * @access public
  246.          * @return PK the primary key of the updated record
  247.          * @throws miDBException
  248.          */
  249.         public function update()
  250.         {
  251.             miStaticDBUtil::execUpdate($this->_table, $this->_row, $this->_primaryKey, $this->_row[$this->_primaryKey]);
  252.             return $this->_row[$this->_primaryKey];
  253.         }
  254.         
  255.         
  256.         /**
  257.          * Delete a record in the db table
  258.          *
  259.          * @access public
  260.          * @return PK the primary key of the deleted record
  261.          * @throws miDBException
  262.          */
  263.         public function delete()
  264.         {
  265.             if ($this->_row[$this->_primaryKey] === null)
  266.                 throw new miDBException('Cannot delete: primary key not set');
  267.             miStaticDBUtil::execDelete($this->_table, $this->_primaryKey, $this->_row[$this->_primaryKey]);
  268.             return $this->_row[$this->_primaryKey];
  269.         }
  270.     }
  271. ?>

Documentation generated on Thu, 08 May 2008 16:57:35 +0300 by phpDocumentor 1.4.1