Source for file Database.php

Documentation is available at Database.php

  1. <?php
  2. /**
  3.  *    LAIKA FRAMEWORK Release Notes:
  4.  *
  5.  *    @filesource     Database.php
  6.  *
  7.  *    @version        0.1.0b
  8.  *    @package        Laika
  9.  *    @subpackage     core
  10.  *    @category       database
  11.  *    @date           2010-01-20 17:06:20 -0500 (Wed, 20 Jan 2010)
  12.  *
  13.  *    @author         Leonard M. Witzel <leonard_witzel@harvard.edu>
  14.  *    @copyright      Copyright (c) 2010  Harvard University <{@link http://lab.dce.harvard.edu}>
  15.  *
  16.  */
  17. /**
  18.  * Laika_Database class.
  19.  *
  20.  * Main wrapper class to abstract database transactions.
  21.  *
  22.  * @extends Laika_Abstract_Socket_Service
  23.  */
  24. class Laika_Database extends Laika_Abstract_Socket_Service{
  25.  
  26. //-------------------------------------------------------------------
  27. //    VARIABLES
  28. //-------------------------------------------------------------------
  29.     protected static $instance;
  30.     private   static $database;
  31.     private   static $driver;
  32.     
  33. //-------------------------------------------------------------------
  34. //    METHODS
  35. //-------------------------------------------------------------------    
  36.     
  37.     /**
  38.      * init function.
  39.      * 
  40.      * @access public
  41.      * @static
  42.      * @return void 
  43.      */
  44.     public static function init(){
  45.  
  46.         if( empty(self::$instance) )      
  47.             $index = Laika_Registry::get_record(__CLASS__);
  48.             if( isset($index) )                   
  49.                 self::$instance = Laika_Registry::get_record(__CLASS__);
  50.             else
  51.                 parent::init(); 
  52.         return self::$instance;    
  53.     }
  54.     
  55.     /**
  56.      * load_database_driver function.
  57.      * 
  58.      * @access public
  59.      * @param  string $driver 
  60.      * @return void 
  61.      */
  62.     public function load_database_driver($driver){
  63.         $this::$database = $driver::connect();
  64.     }
  65.     
  66.     /**
  67.      * connect function.
  68.      * 
  69.      * @access public
  70.      * @param  string $driver 
  71.      * @return void 
  72.      */
  73.     public function connect($driver){
  74.  
  75.         USE_PDO && extension_loaded('pdo') ? 
  76.             $this::$driver = NAME_SPACE.'Pdo_Driver' :
  77.             $this::$driver = NAME_SPACE.ucfirst($driver).'_Driver';
  78.         try{ 
  79.             $this->load_database_driver($this::$driver);
  80.             Laika_Registry::register(__CLASS__,$this);
  81.         }
  82.         catch(Laika_Exception $e){ 
  83.             throw new Laika_Exception('DATABASE_NO_CONNECT', 830); 
  84.         }
  85.     }
  86.     
  87.     /**
  88.      * disconnect function.
  89.      * 
  90.      * @access public
  91.      * @return void 
  92.      */
  93.     public function disconnect(){
  94.         $db = $this::$driver;
  95.         $this::$database = $db::disconnect();   
  96.     }
  97.  
  98.     /**
  99.      * select function.
  100.      * 
  101.      * @access public
  102.      * @static
  103.      * @param mixed $subject 
  104.      * @param mixed $table 
  105.      * @return void 
  106.      */
  107.     public static function select($subject,$table,$condition){
  108.         $db = self::init();
  109.         $driver = $db::$database;
  110.         return $driver->select($subject,$table,$condition);
  111.     }       
  112.     
  113.     /**
  114.      * select_column function.
  115.      * 
  116.      * @access public
  117.      * @static
  118.      * @param mixed $subject 
  119.      * @param mixed $table 
  120.      * @return void 
  121.      */
  122.     public static function select_column($subject,$table){
  123.         $db = self::init();
  124.         $driver = $db::$database;
  125.         return $driver->select_column($subject,$table);
  126.     }
  127.       
  128.     /**
  129.      * select_by function.
  130.      * 
  131.      * @access public
  132.      * @static
  133.      * @param mixed $id 
  134.      * @param mixed $table 
  135.      * @return void 
  136.      */
  137.     public static function select_by($id,$table){
  138.         $db = self::init();
  139.         $driver = $db::$database;
  140.         return $driver->select_by($id,$table);
  141.     }
  142.     /**
  143.      * select_all function.
  144.      * 
  145.      * @access public
  146.      * @static
  147.      * @param mixed $table 
  148.      * @return void 
  149.      */
  150.     public static function select_all($table){
  151.         $db = self::init();
  152.         $driver = $db::$database;
  153.         return $driver->select_all($table);
  154.     }       
  155.  
  156.     /**
  157.      * select_all_where function.
  158.      * 
  159.      * @access public
  160.      * @static
  161.      * @param mixed $subject 
  162.      * @param mixed $table 
  163.      * @param mixed $condition 
  164.      * @return void 
  165.      */
  166.     public static function select_all_where($table, $condition){
  167.         $db = self::init();
  168.         $driver = $db::$database;
  169.         return $driver->select_all_where($table, $condition);
  170.     }
  171.  
  172.     /**
  173.      * select_where function.
  174.      * 
  175.      * @access public
  176.      * @static
  177.      * @param mixed $column 
  178.      * @param mixed $table 
  179.      * @param mixed $condition 
  180.      * @return void 
  181.      */
  182.     public static function select_where($subject, $table, $condition){
  183.         $db = self::init();
  184.         $driver = $db::$database;
  185.         return $driver->select_where($subject, $table, $condition);
  186.     }
  187.     
  188.     /**
  189.      * query function.
  190.      * 
  191.      * @access public
  192.      * @static
  193.      * @param mixed $statement 
  194.      * @param mixed $return 
  195.      * @return void 
  196.      */
  197.     public static function query($statement,$return){
  198.         $db = self::init();
  199.         $driver = $db::$database;
  200.         return $driver->query($statement,$return);    
  201.     }
  202.     
  203.     /**
  204.      * insert function.
  205.      * 
  206.      * @access public
  207.      * @static
  208.      * @param mixed $table 
  209.      * @param array $columns 
  210.      * @param array $values 
  211.      * @return void 
  212.      */
  213.     public static function insert($table,$columns,$values){
  214.         $db = self::init();
  215.         $driver = $db::$database;
  216.         return $driver->insert($table,$columns,$values); 
  217.     }
  218.     
  219.     /**
  220.      * update function.
  221.      * 
  222.      * @access public
  223.      * @static
  224.      * @param mixed $table 
  225.      * @param mixed $record 
  226.      * @param mixed $data 
  227.      * @param mixed $condition 
  228.      * @return void 
  229.      */
  230.     public static function update($table, $record, $data, $condition){
  231.         $db = self::init();
  232.         $driver = $db::$database;
  233.         return $driver->update($table, $record, $data, $condition);     
  234.     }
  235.     
  236.     /**
  237.      * batch_update function.
  238.      * 
  239.      * @access public
  240.      * @static
  241.      * @param mixed $table 
  242.      * @param mixed $records 
  243.      * @param mixed $condition 
  244.      * @return void 
  245.      */
  246.     public static function batch_update($table,$records,$condition){
  247.         $db = self::init();
  248.         $driver = $db::$database;
  249.         return $driver->batch_update($table, $records, $condition);         
  250.     }
  251.     
  252.     /**
  253.      * add function.
  254.      * 
  255.      * @access public
  256.      * @static
  257.      * @param mixed $object 
  258.      * @return void 
  259.      */
  260.     public static function add($object){
  261.         $db = self::init();
  262.         $driver = $db::$database;        
  263.         return $driver->add($object);    
  264.     }
  265.     
  266.     /**
  267.      * delete function.
  268.      * 
  269.      * @access public
  270.      * @param mixed $table 
  271.      * @param mixed $id 
  272.      * @return void 
  273.      */
  274.     public static function delete($table,$id){
  275.         $db = self::init();
  276.         $driver = $db::$database;
  277.         $driver->delete($table,$id);  
  278.     }
  279.  
  280.     /**
  281.      * show function.
  282.      * 
  283.      * @access public
  284.      * @static
  285.      * @param mixed $table 
  286.      * @return void 
  287.      */
  288.     public static function show($table){
  289.         $db = self::init();
  290.         $driver = $db::$database;        
  291.         return $driver->show($table);        
  292.     }    
  293.     
  294.     /**
  295.      * reset_auto_increment function.
  296.      * 
  297.      * @access public
  298.      * @param mixed $table 
  299.      * @param mixed $id 
  300.      * @return void 
  301.      */
  302.     public static function reset_auto_increment($table,$id){
  303.         $db = self::init();
  304.         $driver = $db::$database;
  305.         $driver->reset_auto_increment($table,$id);
  306.     }
  307.     
  308.     /**
  309.      * alter function.
  310.      * 
  311.      * @access public
  312.      * @param mixed $table 
  313.      * @param mixed $condition 
  314.      * @return void 
  315.      */
  316.     public static function alter($table,$condition){
  317.         $db = self::init();
  318.         $driver = $db::$database;
  319.         $driver->alter($table,$condition);
  320.     }
  321.     
  322.     /**
  323.      * last function.
  324.      * 
  325.      * @access public
  326.      * @param mixed $table 
  327.      * @param mixed $limit 
  328.      * @return void 
  329.      */
  330.     public static function last($table,$limit,$conditions=NULL){
  331.         $db = self::init();
  332.         $driver = $db::$database;
  333.         return $driver->last($table,$limit,$conditions); 
  334.     }
  335.     
  336.     /**
  337.      * first function.
  338.      * 
  339.      * @access public
  340.      * @param mixed $table 
  341.      * @param mixed $limit 
  342.      * @return void 
  343.      */
  344.     public static function first($table,$limit,$conditions=NULL){
  345.         $db = self::init();
  346.         $driver = $db::$database;
  347.         return $driver->first($table,$limit,$conditions);     
  348.     }
  349.      
  350.     /**
  351.      * count function.
  352.      * 
  353.      * @access public
  354.      * @static
  355.      * @param mixed $table 
  356.      * @return void 
  357.      */
  358.     public static function count(){
  359.         $args  = func_get_args();
  360.         $db = self::init();
  361.         $driver = $db::$database;
  362.         
  363.         if(func_num_args()>1)
  364.             return $driver->count($args[0],$args[1]);
  365.         return $driver->count($args[0]);         
  366.     }
  367.     /**
  368.      * offset function.
  369.      * 
  370.      * @access public
  371.      * @static
  372.      * @param mixed $table 
  373.      * @param mixed $column 
  374.      * @param mixed $offset 
  375.      * @param mixed $limit 
  376.      * @return void 
  377.      */
  378.     public static function offset($table,$column,$limit,$offset){
  379.         $db = self::init();
  380.         $driver = $db::$database;
  381.         return $driver->offset($table,$column,$limit,$offset);    
  382.     }
  383.  
  384.     /**
  385.      * find_with_offset function.
  386.      * 
  387.      * @access public
  388.      * @static
  389.      * @param mixed $param 
  390.      * @param mixed $value 
  391.      * @param mixed $table 
  392.      * @param mixed $limit 
  393.      * @param mixed $offset 
  394.      * @return void 
  395.      */
  396.     public static function find_with_offset($conditions,$table,$limit,$offset){
  397.         $db = self::init();
  398.         $driver = $db::$database;
  399.         return $driver->find_with_offset($conditions,$table,$limit,$offset);     
  400.     }
  401.  
  402.  
  403.     /**
  404.      * find_with_offset_order_by function.
  405.      * 
  406.      * @access public
  407.      * @static
  408.      * @param mixed $conditions 
  409.      * @param mixed $table 
  410.      * @param mixed $limit 
  411.      * @param mixed $offset 
  412.      * @param mixed $by 
  413.      * @param mixed $order 
  414.      * @return void 
  415.      */
  416.     public static function find_with_offset_order_by($conditions,$table,$limit,$offset,$by,$order){
  417.         $db = self::init();
  418.         $driver = $db::$database;
  419.         return $driver->find_with_offset_order_by($conditions,$table,$limit,$offset,$by,$order);        
  420.     }
  421.     
  422.     /**
  423.      * create function.
  424.      * 
  425.      * @access public
  426.      * @static
  427.      * @param mixed $table 
  428.      * @param mixed $fields 
  429.      * @return void 
  430.      */
  431.     public static function create($table,$fields){
  432.         $db = self::init();
  433.         $driver = $db::$database;
  434.         $driver->create($table,$fields);              
  435.     }
  436.     
  437.     public static function drop(){}   
  438. }

Documentation generated on Sat, 19 May 2012 02:16:58 -0400 by phpDocumentor 1.4.4