PHP : Extend mysqli - CodeS SourceS

Description

Voila mon premier code objet oriente
Ce code comporte 3 classes donc une principale : mysqli_access extends Mysqli et deux autres utilisees par la premiere Mysqli_access_stmt extends Mysqli_stmt, Mysqli_access_result extends Mysqli_results.
J'ai principalement cree cette classe car dans mes cripts je voulais avoir seulement get_data(), insert_data(), update_data() et delete_data() comme actions et acceder a certaines proprietes comme num_rows juste par $objet->num_rows.
Source / Exemple :

<?php
/**

  Msqli_exception
 *

  @version 1
  @author Julie.D
  @link http://www.phpclasses.org/browse/package/5770.html
 /

class Mysqli_exception extends Exception{
	
	public $_title;
	public $_class;
	public $_methode;
	public $_query;
	
	
		public function __construct($message,$code,$class='unknow',$methode='unknow',$title=null,$query=false){
		
			$this->_title   = $title;
			$this->_class   = $class;
			$this->_methode = $methode;
			$this->_query   = $query;
			
			$this->eLogPath['DIR']='logs';
			$this->eLogPath['FILE']='Mysqli_error';
			$this->eLogPath['EXTENSION']='.txt';
			
			parent::__construct($message,$code);
		}
		
		public function __tostring(){
			$str ='<p><b>' .$this->_title.'</b><br />';
			$str.='Class : ' .$this->_class. ' - Using Methode '.$this->_methode.'(). <br />';
			$str.='Error : ('.$this->getCode().') '.$this->getMessage().'. <br />';
			if($this->_query) {		
				$str.='Executing :' .$this->_query. '. <br />';
			}
	
			$str.='Script : '.$this->getFile().' - Line : '.$this->getLine().'. <br />';
			$str.= 'Trace :<br /> ';
			$str.=$this->Trace__tostring().' <br /></p>';
			
			return $str;
		}

		public function Trace__tostring(){
			
			$trace_array=$this->getTrace();
			$trace_str=null;
			foreach($trace_array as $trace) {
				$trace_str .=$trace['file']. ' - Line '.$trace['line'].'<br />';
				$trace_str .='Class ' .$trace['class'].'  - Using Methode ' .$trace['function'].'() <br />' ;
			}
			return $trace_str;
		}
}

class Mysqli_exception_connect extends Mysqli_exception {

	public function __construct($message,$code,$class='unknow',$methode='unknow',$title=null,$query=false) {
	
		if( is_null( $title ) ){
			$title='Connection error';
		}
		parent :: __construct($message,$code,$class,$methode,$title);
		

	}
}

Class Mysqli_Exception_config extends Mysqli_exception {

	
	public function __construct($message,$code,$class='unknow',$methode='unknow',$title=null,$query=false) {
	
		if( is_null( $title ) ){
			$title='Configuration Error [Mysqli_config.php]';
		}
		parent :: __construct($message,$code,$class,$methode,$title);
	}
}

Class Mysqli_exception_query extends Mysqli_exception {

	public function __construct($message,$code,$class='unknow',$methode='unknow',$title=null,$query=false) {
	
		if( is_null( $title ) ){
			$title='QUERY error';
		}
		if( preg_match('/prepare/',$message) ){
			$message=preg_replace('/prepare/','',$message);
			$message=$message. 'Could not prepare the query';
			$code=1;
		}
		if( preg_match('/bind_param/',$message) ){
			$message=preg_replace('/bind_param/','',$message);
			$message=$message. 'Could not bind parameter of the query';
			$code=2;
		}
		if( preg_match('/execute/',$message) ){
			$message=preg_replace('/execute/','',$message);
			$message=$message. 'Could not execute the query';
			$code=3;
		}
		if( preg_match('/store_result/',$message) ){
			$message=preg_replace('/store_result/','',$message);
			$message=$message. 'Could not store result of the statement';
			$code=5;
		}
		
		if( preg_match('/bind_result/',$message) ){
			$message=preg_replace('/bind_result/','',$message);
			$message=$message. 'Could not execute the query';
			$code=5;
		}
		
		parent :: __construct($message,$code,$class,$methode,$title,$query);
		

	}
}

class Mysqli_exception_param extends Mysqli_exception {

	public function __construct($message,$code,$class='unknow',$methode='unknow',$title=null,$query=false) {
	
		if( is_null( $title ) ){
			$title='Parametre error';
		}
		if( preg_match('/object/',$message) ){
			$message=preg_replace('/object/','',$message);
			$message=$message. 'must be an object';
			$code=1;
		}
		if( preg_match('/string/',$message) ){
			$message=preg_replace('/string/','',$message);
			$message=$message. 'must be a string';
			$code=2;
		}
		if( preg_match('/array/',$message) ){
			$message=preg_replace('/array/','',$message);
			$message=$message. 'must be a array';
			$code=3;
		}
		parent :: __construct($message,$code,$class,$methode,$title);
		

	}
}
?>

<?php
/*Mysqli_config*/

self::$option['SHOW_EXCEPTIONS']=true;																//will show exceptions if true
self::$option['SHOW_MESSAGE']='<p>An error as occur The Administrator has been informed</p>';		//will show this message if SHOW_EXCEPTION=false
self::$option['DIE_ON_EXCEPTION']=false;															// will make script die when an exception is caught

self::$option['AUTOCONNECT']=true;																	//will connect to database when create object		

//optional can be set when create object.
$this->login['HOST']='localhost';																	
$this->login['USER']='root';
$this->login['PASSWORD']='';
$this->login['DATABASE']='perso';
$this->login['TABLE']=false;																		//table name, optiona

?>

<?php 
/**

  Msqli_access
 *

  @version 1.1
  @author Julie.D
  @link http://www.phpclasses.org/browse/package/5770.html
 *

 	TODO: return affected_rows for inser, update, delete data;
 /

require '\mysqli_stmt_class.php';
require '\mysqli_result_class.php';
require '\build_query_string_class.php';
require '\mysqli_exception_class.php';

class mysqli_access extends mysqli{

	protected static $option=array();			//config options
	protected $login=array();			//config login

	public $table=null;					//to declare in script $object->table='tablename';
	public $fieldlist=array();			//list of field names of $this->table

	private $last_query;				//to hold the last query
	
	private $stmt; 						//new object of class msqli_access_stmt
	private $result;					//new object of class mysqli_access_result
	
	private $param_array=array(); 		//to create $param_array to bind parametre

	public $num_rows;
	
	public static $ErrorTrace=array();
	
	/*__construct

		 @	Set class properties  : $host
								  : $user
								  : $pass
	/	
	public function __construct($login=null,$option=null) {
		
		require '/mysqli_config.php';
		if( is_array( $login ) ) {
			foreach( $login as $key=>$value ) {
				$this->login[$key]=$value;
			}
		}
		if( is_array( $option ) ) {
			foreach( $option as $key=>$value ) {
				self::$option[$key]=$value;
			}
		}
		if( self::$option['AUTOCONNECT'] === true ) {
				$this->connect($this->login['DATABASE']);
		}
	}

	/* Connect to the database

		 @	Argument 	: $db : database name	
		 @ Connect 	: parent function __construct.
		/		
	public function connect($db=null){
		try{
			if( is_null($db) ){
				Throw new mysqli_exception_config('Database not set',null,get_class($this),__FUNCTION__ );
			} else {
					 parent::connect($this->login['HOST'], $this->login['USER'],$this->login['PASSWORD'], $db); 
				if( $this -> connect_error ) {
					Throw new Mysqli_exception_connect($this->connect_error, $this->connect_errno,__FUNCTION__);
				} else return true;
			} 
		}
		catch(Mysqli_exception_config $e) {
			self::handle_exception($e);
			return false;
		}catch(Mysqli_exception_connect $e) {
			self::handle_exception($e);
			return false;
		}
	}	
	
	/* handle exceptions : 

		 @Argument  : $e :object of exception class
		 if $this->option['SHOW_EXCEPTIONS'] = true 		it will display exceptions on screen
											  = false		it will keep trace of exception in an array
		 if $this->option['SHOW_EXCEPTIONS'] = true 		script will die when an exception is caught
		 trace of error when no
		/
	
	
	public function handle_exception($e){
		if( self::$option['SHOW_EXCEPTIONS'] === true ){
			if(  self::$option['DIE_ON_EXCEPTION'] === true ){
				die( $e->__tostring() );
			}
			else echo $e->__tostring();
		} else {
			$error_message=$this->option['ERROR_MESSAGE'];
			echo $error_message;
			self::$ErrorTrace[]=array	( 	'date'	=> date('d/m/y H:i:s'),
											'num'	=> $e->getCode(),
										 	'msg'	=> $e->getMessage(),
											'class'	=> $e->_class,
											'func'	=> $e->_methode
										);
										
			if(  self::$option['DIE_ON_EXCEPTION'] === true ){
				die();
			}
		}
	}
	
	/* set_table

		 if $this->table is null and $this->login['TABLE'] it will trigger an error.
		 if $this->table is null it will set teh table to select to $this->login['TABLE']
		 @ Return true if $this->table is set.									 
		/
	
	public function set_table(){
		try{
			if( ! is_null($this->table) ){
				return true;
			} elseif( ! $this->login['TABLE'] === false ) {
					$this->table=$this->login['TABLE'];
					return true;
				  
			}else {
				throw new Mysqli_exception_config('You did not set $table property',0,get_class($this),__FUNCTION__);
			}
		}catch(Mysqli_exception_config $e) {
			self::handle_exception($e);
			return false;
		}
	}
	
	/*Get_Data from $this->table

		 Has to have $line as get_data(__LINE__) to trigger error.
		 Arguments are optionals
				$fields   	: to build field clause 
				$wherearray : to build WHERE clause 
				$group 		: to build GROUP BY clause
				$sort 		: to build ORDER BY clause
				$limit		: to build LIMIT clause
		 @ BuildQueryString
		 @ Prepare, Bind_param, Execute
		 @ Use function fetch() of class mysql_access_stmt
		 @ Return data as an array
	/
	function get_data($fields=null,$wherearray=null,$group=null,$sort=null,$limit=null) {
	
		if( $this->set_table() === false){
			return false;	
		}
		BuildQueryString::$table=$this->table;
		$query=BuildQueryString::Get_select($fields,$wherearray,$group,$sort,$limit);
		$this->param_array=BuildQueryString::$param_array;
		
		if ( $query === false ) {
			return false;
		}
		if ( $this->prep_bind_execute($query,$this->param_array) === false ) {
			return false;
		} else {
			$data = $this->stmt->fetch();
			if(  $data === false ) {
				return false;
			} else {
					$this->num_rows=$this->stmt->num_rows;
					$this->stmt->close();
					unset($this->stmt);
					return $data;
			}
		}
	}
			
	/*Insert_data into $this->table

		 @ Arguments 	: $values :	string or array : values to insert into the table 
		 @ BuildQueryString
		 @ Prepare, Bind_param, Execute
	/	
	public function insert_data($values) {
		if( $this->set_table() === false){
			return false;	
		}
		BuildQueryString::$table=$this->table;
		$query=BuildQueryString::Get_insert($values);
		$this->param_array=BuildQueryString::$param_array;
		if ( $query === false ) { 
			return false;
		}
		if( $this->prep_bind_execute($query,$this->param_array) === false ) {
			return false;	
		} else {
			$this->stmt->close();
			unset($this->stmt);
			return true;
		}	
	}
	
	/*Update_data into $this->table

		 @ Arguments 	: $wherearray 	: array 
						: $values 		: string or array
		 		Optional: $fields 		: has to be as $values type if not null
		 @ BuildQueryString
		 @ Prepare, Bind_param, Execute
	/	
	public function update_data($wherearray,$values,$fields=null) {
		if( $this->set_table() === false){
			return false;	
		}
		BuildQueryString::$table=$this->table;
		$query=BuildQueryString::Get_update($values,$fields,$wherearray);
		$this->param_array=BuildQueryString::$param_array;
		
		if ( $query === false){
			return false;
		}
		if( ! $this->prep_bind_execute($query,$this->param_array) ) {
			return false;
		} else {
			$this->stmt->close();
			unset($this->stmt);
			return true;
		}	
	}
	
	/*Delete_data from $this->table

		 @ Arguments 	: $wherearray 	:  array
		 @ BuildQueryString
		 @ Prepare, Bind_param, Execute
	/	
	public function delete_data($wherearray) {
		if( $this->set_table() === false){
			return false;	
		}
		BuildQueryString::$table=$this->table;
		$query=BuildQueryString::Get_delete($wherearray);
		$this->param_array=BuildQueryString::$param_array;
		if( $query === false ){
			return false;
		}
		if( ! $this->prep_bind_execute($query,$this->param_array) ) {
			return false;
		}else{
			$this->stmt->close();
			unset($this->stmt);
			return true;
		}
	}
	
	/*get fields names from $this->table

		 @ BuildQueryString
		 @ Prepare, Bind_param, Execute
		 @ Get result_metadata
		 @ create new object $this->result from the class mysqli_access_result
		 @ Use fetch_list() from $this->result
		 @ Return $this->fieldlist populated with fields names of $this->table 
	/
	public function Get_table_fields($tablename=false){
		if( $tablename=== false ){
			$tablename=$this->table;
		}
		BuildQueryString::$table = $tablename;
		$query=BuildQueryString::Get_select();
		
		if( $query === false ) {
			return false;
		}
		if( ! $this->prep_bind_execute($query) ){
			return false;
		} 
		
		$metadata=$this->stmt->result_metadata();
		$this->stmt->close();
		unset($this->result);
			
		if( $metadata=== false) {
			return false;
		}
		$this->result=new mysqli_access_result($this);
		$this->fieldlist=$this->result->Fields_list($metadata);
		unset($this->result);
		if( $this->fieldlist === false){
			return false;
		}	else return $this->fieldlist;	
		
	}
	
	/*Prepare Bind execute statment

		 @ Arguments : $query : statement to be prepared.
					  : $param_array if got 1 argument or more bind_param()
		 @ Prepare, bind_param(), execute()
	/		
	private function prep_bind_execute($query,$param_array=array()){
		
			if( $this->prepare($query) ) {
				if( count($param_array)>0 ) {
					$this->bind_param($param_array); 	
				}
				 $this->execute();
				return true;
			} else return false;
	}
	/*Prepare statment 

		 @ Argument : $query : statement to be prepared.
		 @ Create 	new object $this->stmt from class mysqli_stmt_access
		 			Or Trigger Error 
		 @ return new object  $this->stmt
	/		
	public function prepare($query){
	
		$this->last_query=$query;
		$this->stmt=new mysqli_access_stmt($this, $this->last_query );
			
		if( $this->stmt->error ) {
				unset($this->stmt);	
				return false;
		} else  return $this->stmt;
	}
	
	/*Bind parametres

		  @ Argument : $param_array : array
			@ Use function bind_param of class mysqli_stmt_access 
	/
	public function bind_param($param_array){
	
		try{
			if( ! is_array($param_array) ){
				Throw new Mysqli_exception_param('1st parameter array',null,get_class($this),__FUNCTION__);
			}
			if( ! $this->stmt->bind_param($param_array) ){
				Throw new Mysqli_exception_query('bind_param',null,get_class($this),__FUNCTION__,null,$this->last_query);
			} else return true;
		} catch(Mysqli_exception_param $e) {
			$this->handle_exception($e);
			return false;
		} catch(Mysqli_exception_query $e) {
			$this->handle_exception($e);
			return false;
		}
	}
	
	/*Execute

			@ Use function Execute of class mysqli_stmt_access
	/
	public function execute(){
		Try {
			if( ! $this->stmt->execute() )	{
				Throw new Mysqli_exception_query('execute',null,get_class($this),__FUNCTION__,null,$this->last_query);
			} else return true;
		} catch(Mysqli_exception_query $e) {
			$this->handle_exception($e);
			return false;
		}
	}
}

?>

<?php
/**

  Msqli_access_stmt
 *

  @version 1.1
  @author Julie.D
  @link http://www.phpclasses.org/browse/package/5770.html
 *

  TODO 	: function affected_rows();
 /

class mysqli_access_stmt extends mysqli_stmt{

	protected static $option=array();			//config options
	protected $login=array();			//config login
	
	public static $ErrorTrace=array();
	private $last_stmt;					//to hold last statement
	
	protected $data=array();			//store data to be returned as an array
	
	
	
	
	public function __construct($link, $stmt) {
		require '\mysqli_config.php';
		$this->last_stmt=$stmt;
		try{
			if	( ! is_object($link) ) {
				Throw new Mysqli_exception_param('1st parameter object',0,get_class($this),__FUNCTION__);
			}
			if	( ! is_string( $stmt) ){
				Throw new Mysqli_exception_param('1st parameter string',0,get_class($this),__FUNCTION__);
			}
			parent::__construct($link, $stmt) ;
			
			 if( $this->error ) {
				Throw new Mysqli_exception_query($this->error,$this->errno,get_class($this),__FUNCTION__,null,$this->last_stmt);
			 } else return true;
		}catch(Mysqli_exception_param $e) {
			Mysqli_access::handle_exception($e);
			unset($this);
			return false;
		}catch(Mysqli_exception_query $e) {
			Mysqli_access::handle_exception($e);
			unset($this);
			return false;
		}
		
	}
  
  
	/* GET_PARAM TYPES set the type string i.d or s

		 @ Argument : $param : string, integer, double or otehr
		 @ Redurn the type of the param as a string
		/
		function Get_param_type($param){
			if( is_integer($param ) ){
				$type='i';
			} elseif( is_double($param) ){
				$type='d';
			} elseif( is_string($param) ){	
				$type='s'; 
			} else {
				$type='s';
			}
			return $type;
		}
	
	/* Get type string of param_array

		  @ Arguments :$param_array accepts array
		  @ Return a string with the type of each argument of the array
		 /
	
	function Get_type_string($param_array) {
		$type_str=NULL;
		try{
			if( ! is_array($param_array) ){
				Throw new Mysqli_exception_param('1st parameter array',null,get_class($this),__FUNCTION__);
			} else {
				foreach($param_array as $key=>$param){
					$type=self::Get_param_type($param);	
					if( is_null($type_str) ) {
						$type_str=$type;
					} else {
						$type_str .=$type;
					}
				}
				return $type_str;
		}
		}catch(Mysqli_exception_param $e) {
			Mysqli_access::handle_exception($e);
			return false;
		}
	}
  
	/* BIND_PARAM

		  @ Argument : $param_array :  array 
		  @ Bind_param()
		 /
	function bind_param($param_array){
		try{
			if( ! is_array($param_array) ){
				Throw new Mysqli_exception_param('1st parameter array',null,get_class($this),__FUNCTION__);
			} else {
				$bind_array=array();
				$type_str=self::Get_type_string($param_array);
				$bind_array[0]=$type_str;
					
				foreach($param_array as $key=>$param){
					$bind_array[]=&$param_array[$key];
				}
				if ( ! call_user_func_array('parent::bind_param',$bind_array)  )  {
				
					Throw new Mysqli_exception_query('bind_param',null,get_class($this),__FUNCTION__,null,$this->last_stmt);
				}
				return true;	
			}
		}catch(Mysqli_exception_param $e) {
			Mysqli_access::handle_exception($e);
			return false;
		}catch(Mysqli_exception_query $e) {
			Mysqli_access::handle_exception($e);
			return false;
		}
	}
	
	/* BIND RESULT

		 @ Argument :$field_array : array
		/	

	function bind_result($field_array){
		try{
			if( ! is_array($field_array) ){
				Throw new Mysqli_exception_param('1st parameter array',null,__FUNCTION__);
			} elseif( ! call_user_func_array('parent::bind_result',$field_array) ) {
				Throw new Mysqli_exception_query('bind_result',null,get_class($this),__FUNCTION__,null,$this->last_stmt);
			}else return true;
		}catch(Mysqli_exception_param $e) {
			Mysqli_access::handle_exception($e);
			return false;
		}catch(Mysqli_exception_query $e) {
			Mysqli_access::handle_exception($e);
			return false;
		}
	}
 
	function execute() {
		try{
			parent::execute();
			if(  $this->error ) {
				Throw new Mysqli_exception_query($this->error ,$this->errno,get_class($this),__FUNCTION__,null,$this->last_stmt);
			} else return true;
		}catch(Mysqli_exception_query $e) {
				Mysqli_access::handle_exception($e);
				return false;
		}
 
	}
	
	function store_result() {
		try{
			parent::store_result();
			if( $this->error ) {
				Throw new Mysqli_exception_query($this->error ,$this->errno,get_class($this),__FUNCTION__,null,$this->last_stmt);
			} else return true;
		}catch(Mysqli_exception_query $e) {
			Mysqli_access::handle_exception($e);
			return false;
		}
	}
  
	/*FETCH

		  Has to be use after 
		 	mysqli->prepare, mysqli->bind_param , mysqli ->execute
		   @ parent Store results
		   @ bind results depending num of field 
		   @ access to properties  $this->field_count, $this->num_rows
		   @ parent fetch()
		   @ Return data as an array
		 / 
	public function fetch(){
		
		if( ! $this->store_result() ) {
			return false;
		} 
		$result_set=array();
		for($i=0 ; $i<$this->field_count ;$i++  ) {
				$result_set[]=&$row[$i];
		}
		if( ! $this->bind_result($result_set) ) { 
				return false;
		} 
		for( $i=0 ; $i<$this->num_rows ; $i++) {
			parent::fetch() ;
			$temp=array();
			foreach( $result_set as $k=>$v ) {
				$temp[$k]=$v;
			}
			array_push($this->data,$temp);
		}
		return $this->data;
	}	
		
		
	public function result_metadata(){
		try{
			$metadata=parent::result_metadata();
			if( ! is_object($metadata) ){
				Throw new Mysqli_exception_query('Could not get metadata',null,get_class($this),__FUNCTION__);
			} else return $metadata;
		}catch(Mysqli_exception_query $e) {
			Mysqli_access::handle_exception($e);
			return false;
		}
	}
	
}
?>

<?php
/**

  Msqli_access_result
 *

  @version 1.1
  @author Julie.D
  @link http://www.phpclasses.org/browse/package/5770.html
 *

 /

 

class mysqli_access_result extends mysqli_result {

	public $fieldlist=array();
	protected static $option;
	public static $ErrorTrace=array();
	
	public function __construct($mysqli){
		try{
			require '\mysqli_config.php';
			if( ! is_object($mysqli) ){
				Throw new Mysqli_exception_param('1st parameter object',0,get_class($this),__FUNCTION__);
			}
			parent::__construct($mysqli);		
		} catch(Mysqli_exception_param $e) {
			Mysqli_access::handle_exception($e);
			return false;
		}
	}
	
	/*Field_list

		  @ Argument : $metadata : object.
		  @ Return fields name of the table as an array 
		 /
	public function Fields_list($metadata){
		try{
			if( !is_object($metadata) ){
				Throw new Mysqli_exception_param('1st argument object',0,get_class($this),__FUNCTION__);
			}
			$finfo=$metadata->fetch_fields();
			foreach ($finfo as $val) {
				$this->fieldlist[]=$val->name;	
			}
			return $this->fieldlist;
		} catch(Mysqli_exception_param $e) {
			Mysqli_access::handle_exception($e);
			return false;
		}
	}

}
?>

<?php
<?php
/**

  BuildQueryString
 *

  @version 1
  @author Julie.D
  @link http://www.phpclasses.org/browse/package/5770.html
 /
 
Class BuildQueryString{
	
	public static $table;			//tablename to create strings
	public static $param_array;		//param_array to return for bind_param
	public static $ErrorTrace=array();
	
	public function __construct($table_name){
		self::$table=$table_name;
		self::$param_array =array();
	}
	
	/*Build SELECT values_str

		 The string is build for the table this->table which has to be define.
			@Arguments : are all optional
				$fields   	: string or array
				$wherearray : array
				$group 		: string
				$sort 		: string or array
				$limit		: string
		 @ Return string 
				For exemple : 'SELECT * FROM table'
							: 'SELECT field1 FROM table WHERE field1=?' 
		/					
	 public static function Get_select($fields=null,$wherearray=null,$group=null,$sort=null,$limit=null) {
			$field_str = ( is_null($fields) ) ? '*' : self::Get_fields($fields);
			self::$param_array=array();																	
		
			if( !is_null($wherearray) ) {
				$where_str=self::Get_where($wherearray); 	
			}else $where_str=null;
			if( ! is_null($group) )	{																	
				$group_str=" GROUP BY $group ";
			} else $group_str=null;
			if( !is_null($sort) ) {																		
				$sort_str=self::Get_sort($sort);
			} else $sort_str=null;
			if (! is_null($limit) && is_numeric($limit) ) {												
				$limit= " LIMIT " . $limit;
			}	else $limit_str=null;
			if( $field_str === false || $where_str === false || $group_str=== false || $sort_str=== false || $limit_str=== false ){
				return false;
			} else {
				$query='SELECT '.$field_str.' FROM ' .self::$table.$where_str.$group_str.$sort_str.$limit_str;
				return $query;
			}
	}
	
	/*Build INSERT string

		 The string is build for the table this->table which has to be define.
		 @ Argument	:	$values	: array
		 @ Populate self::$param_array
		 @ Return string 
				For exemple : 'INSERT into table VALUES (?,?,?)
				
	/					
	public static function Get_insert($values) {
		
		try{
			if( ! is_array($values) ) {
				Throw new Mysqli_exception_param('1st parameter array',null,'BuildQueryString',__FUNCTION__);
				
			} else {
				$values_str=NULL;
				self::$param_array=array();	
				$values_str=self::Get_fields($values,false,true);
				$query='INSERT INTO '. self::$table.' VALUES ('.$values_str.')';
				return $query;	
			}
		} catch(Mysqli_exception_param $e) {
			Mysqli_access::handle_exception($e);
			return false;
		}
	}
	
	/*Build UPDATE string

		 The string is build for the table this->table which has to be define.
		 @ Arguments  	: $values 		: string or array 
						: $fields 		: string or array 
								  		: has to be as $values type,
							 	  		: if is null get_table_fields()
						: $wherearray 	: array
		 @ Populate self::$param_array
		 @ Return string 
				For exemple : 'UPDATE table SET $field1=?,$field2=? WHERE $field1=?
	/				
	public static function Get_update($values,$fields,$wherearray){
		try{
			self::$param_array=array();	
			if( is_null($fields) ){
				$sqli=new Mysqli_access();
				$fields=$sqli->Get_table_fields(self::$table);
				$sqli->close();
				unset($sqli);
			} 
			if ( is_array($fields) || is_array($values) ){
				if( ! is_array($fields) ) {
						Throw new Mysqli_exception_param('1st parameter array',null,'BuildQueryString',__FUNCTION__);
				}
				if( ! is_array($values) ) {
						Throw new Mysqli_exception_param('2nd parameter array',null,'BuildQueryString',__FUNCTION__);
				}
				if( count($values) != count($fields) ){
					Throw new Mysqli_exception_param('$values and $fields arguments count are different',6,get_class($this),__FUNCTION__);
				} else{
					$values_str=self::Get_fields($fields,$values,false);
				}
			} else{
				$values_str=$fields .'=?';
				self::$param_array[]=$values;
			}
			$where_str=self::Get_where($wherearray);
			$query= 'UPDATE '.self::$table.' SET '.$values_str.$where_str ;
			return $query;
		} catch(Mysqli_exception_param $e) {
			Mysqli_access::handle_exception($e);
			return false;
		}
	}
	
	
	/*Build DELETE string

		 The string is build for the table this->table which has to be define.
		 @ Arguments  	: $wherearray 	: array
		 @ Populate self::$param_array
		 @ Return string 
				For exemple : 'DELETE FROM table WHERE $field1=?'
	/	
	public static function Get_delete($wherearray) {
		self::$param_array=array();
		$where_str=self::Get_where($wherearray);
		$query='DELETE FROM '.self::$table. $where_str;
		
		return $query;
	}
	
	/*Build Field String (to use with get_select)

		 @ Arguments: $fields	 :	 string or array
						 	For Exemple	:	$fields=$field1
										:	$fields=array($filed1,$filed2, .......)
		   Optionals:	$values or $bind  Thus populate self::$param_array
					 : 	$values  :	array or string 	[ $bind has to be false ]
					 : 	$bind 	 : 	boleen true of false
		 @ Return field string as : '$field1,$field2,... '
									: if $values : '$field1=?','$field2=?' 
									: if $bind   :	'?,?'					
	/	
	public static function Get_fields($fields,$values=false,$bind=false) {
		$field_str=NULL;
		if( is_array($fields) )	{				
			foreach($fields as $key=>$field) {	
				if( is_null($field_str) ) {
					$field_str = ( $bind ) ? '?' :"$field"; 
				}else{
					$field_str .= ( $bind ) ? ', ?' :", $field"; 
				}
				if($values){
					$field_str .= '=?'; 
					self::$param_array[]=$values[$key];
				} else{
					self::$param_array[]=$field;
				}
			}
		} elseif( is_string($fields) ) {	
			$field_str = $fields; 		
			if( $values ){
				$field_str = $fields . '=?'; 
				self::$param_array[]=$values;
			}
		}	
		return $field_str;
	}
	
	
	
	/*Build WHERE string

		 @Argument : $wherearray :	 Array 
		 					For Exemple :	$wherearray[$field1]=$value1;
		  								:	$wherearray=array( $field1=>$value1, $field2=>$value2)
		 @ Populate self::$param_array	as 	: self::$param_array=($value1,$value2);		 
		 @ Return Where string as : 'Where $field1= ? AND $field1= ?'	
	 /	
	public static function Get_where($wherearray) {										
		try{
			if( ! is_array($wherearray) ) {	
				Throw new Mysqli_exception_param('1st parameter array',null,'BuildQueryString',__FUNCTION__);
				return false;		
			} else {
				$where_str=NULL;
				foreach($wherearray as $field=>$value) {
					if( is_null($where_str) ) {	
						$where_str =" WHERE $field=? ";
						self::$param_array[]=$value;
					} else {	
						$where_str .=" AND $field=? ";
						self::$param_array[]=$value;
					}
				}		
				return $where_str;
			}
		}catch(Mysqli_exception_param $e) {
			Mysqli_access::handle_exception($e);
			return false;
		}
	}
	
	/*Build SORT clause (to use with get_select)

		 @ Argument : $sort :	 string or array
							For Exemple :	$sort=$field;	
										:	$sort=array($filed1,$field2);
								->Can specify the order to sort as $order= 'DESC' or 'ASC'
		 								:	$sort[$field1]=$order1;  
		  								:	$sort=array( $field1=>$order1, $field2=>$order2)		
		 @ Return Sort string as 	: ' ORDER BY $field1'
									: ' ORDER BY $field1 $order1 ' 
	 /	
	public static function Get_sort($sort){
		$sort_str=NULL;
	
		if( is_array($sort) ) {												
			foreach($sort as $field=>$order) {	
				$field = ( is_numeric($field) ) ? NULL : $field;									
				if( is_null($sort_str) ) {															
					$sort_str= " ORDER BY $field $order "; 
				} else {
					$sort_str .= ", $field $order";
				}
			}
		} elseif( is_string($sort) ) {
			$sort_str = " ORDER BY $sort";
		}												
	return $sort_str;
	}
}

?>
Conclusion :

Je ne suis aps developpeur apres avoir lu et relu sur ce sujet je me suis lancee, peut etre je m y suis mal prise, les conseils seront les bienvenus.
Il reste a faire sur ces classes dont developper Mysqli_result et ameliorer ma gestion d erreur pourrait etre dans une classe a part plus generale (je reflechie la dessus).
->chose faite mais surement loin d etre parfaite toujous ouverte aux commentaures
Télécharger le projet
Codes Sources

A voir également

Extend mysqli
Extend java ✓ - Forum Java
Mysql_result mysqli ✓ - Forum PHP
Mysqli ✓ - Forum PHP
Moteur de recherche php mysqli - Forum PHP
Erreur Mysqli ✓ - Forum PHP
S'inscrire maintenant
Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.
Source / Exemple :

Conclusion :

A voir également

Vous n'êtes pas encore membre ? inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
