EXÉCUTER DES REQUETE STYLE SQL SUR UN ARRAY

<?
/**
*	class facilitant la manipulation de tableau
*	@author: p418
*	@version: 0.9b
* 
**/
class myArray
{


	/**
	* ranger un tableau associatif par rapport a un champs 
	* ne marche que sur un array de type
	* 
	*	toto {
	*		[x] => Array(
	*				champ1 => x1,
	*				champ2 => x2,
	*				champ3 => x3
	*			),
	*		[y] => Array(
	*				champ1 => y1,
	*				champ2 => y2,
	*				champ3 => y3
	*			),
	*		[z] => Array(
	*				champ1 => z1,
	*				champ2 => z2,
	*				champ3 => z3
	*			)
	*	}
	* @access private
	* <code>
	* 	myArray::orderby($toto,"champ1")
	*	retournera un tableau avec x,y,z ordonnés par champs1
	* </code>
	* @param (array) $arrayToOrder
	* @param (string) $orderBy
	* @return (array)
	*/
	public static	function orderBy($arrayToOrder,$orderBy)
	{

		$result = array();

		if(!is_array($arrayToOrder) || count($arrayToOrder) == 0)
			return $result ;
		$tmp = $arrayToOrder;
		$sorting = $tmp[0][$orderBy];
		for($i=0;$i<count($arrayToOrder);$i++)
		{
			if($tmp[$i][$orderBy]==$sorting)
			{
				$result[]=$tmp[$i];
				array_splice($tmp,$i,1);
			}
		}
		return array_merge($result,self::orderBy($tmp,$orderBy));	
	}
	
	/**
	 *	semblable a array_unique mais basé sur un champs donné.
	 *	le tableau en entrée doit avoir la meme structure que pour la fontion orderby
	 * 
	 * @access private
	 * @param (array) $arrayToOrder
	 * @param (string) $orderBy
	 * @param (bool) $distinct
	 * @return array
	 */
	public static function groupBy($arrayToOrder,$orderBy,$distinct=false)
	{
		$exists = self::fieldExists($orderBy,$arrayToOrder);
		if($exists !== true)
			throw new Exception("Champs '$orderBy' inconnu dans la clause 'group by' $idx");				
		$res = array();
		while(list($k,$v) = each($arrayToOrder))
			$res[$v[$orderBy]][]=$v;
		return $res;
	}	

	/**
	 * Interprete la requete donnée en parametre sur le tableau $myArray
	 * @access private
	 * @param (Array) $myArray
	 * @param (string) $query
	 * @return (array)
	 */
	public static function query($myArray,$query)
	{

		try
		{
			if(eregi("(select|delete) *([\*a-zA-Z,_\(\)]*) *(where)? *(.*)",$query,$reg))
			{
				$todo	 	= array();
				$res		= array();			
				$columns	= explode(",",str_replace(" ","",$reg[2]));

				if(empty($reg[4]))
					$reg[4]="";
				else
				{
					$groupBy 	= preg_split("/group by/i",$reg[4]);
					$reg[4]		= empty($groupBy[0])?"":$groupBy[0];

				}

				//on exécute, la reqquete
				while(list($idx,$champs) = each($columns))
				{
					if(eregi("([0-9a-z_]*)\((.*)\)",$champs,$func))
					{
						$todo[$func[1]]=$func[2];
						continue;
					}
					
					if($champs=='*')
						foreach( self::getFields($myArray) as $field )
							$res=array_merge($res,self::select($myArray,$field,$reg[4]));
					else
					{
						$exists=self::fieldExists($champs,$myArray);
						if($exists!==true)
							throw new Exception("Champs '$champs' inexistant à l'index '$exists'\n".print_r($myArray,true));		
						$res=array_merge($res,self::select($myArray,$champs,$reg[4]));
					}
				}	
				$tmp	= array();
				$size 	= self::getMaxSize($res);
				for($i=0;$i<$size;$i++)
					foreach($res as $nom => $tab)
						$tmp[$i][$nom]=isset($tab[$i])?$tab[$i]:'';
				
				/**
				*
				*	action spécifique
				*
				**/

				// si on veut grouper
				if(!empty($groupBy[1]))
					$tmp=self::groupBy($tmp,trim($groupBy[1]));

				//autre actions
				if(count($todo))
				{
					foreach($todo as $func => &$do)
						if(!self::functionExists($func))
							throw new Exception("Fonction '$func()' inconnue");
				}		
				//*****
				return $tmp;
			}
			else
				throw new Exception("requete incomprise");


		}
		catch(Exception $e)
		{
			throw new Exception("[myArrayError] une erreur dans la requete : '$query'\n\t{$e->getMessage()}\n");	
		}
	}


	/**
	 *	retourne un array contenant les valeurs du champs $fieldName dans le tableau $myArray
	 *	une condition peut etre définie pour la récupération.
	 *	cette condition est évaluée par la fonction eval() de php
	 *	
	 *	pour faire appel a la valeur d'un champs donné, il suffit dencadrer ce nom de champs par des %%
	 *	ainsi %mon_champs% fera référence à la valeur de $row['mon_champs']
	 * 
	 * @access private
	 * @param (array) $myArray
	 * @param (string) $fieldName
	 * @param (string) $condition
	 * @return (array)
	 */
	public static function getField($myArray,$fieldName,$condition=true)
	{
		try
		{
			
			$res = array();
			
			//préparation de la condition
			if(is_string($condition) && trim($condition)!="")
			{
				$patterns=array("/^(.*)$/","/\s*([\*<>=+-]{1,2})\s*/");
				$condition=preg_replace($patterns," \$1 ",$condition);
				$condition=preg_replace("/\s+=\s+/"," == ",$condition);
	
				if(preg_match_all("/[\s]?%?([a-z_]+[\w]+)%?[\s]+/i",$condition,$reg))
				{
					while(list($idx,$field) = each($reg[0]))
					{
						$cleanned_field = $reg[1][$idx];
						if(in_array(strtolower($cleanned_field),array("and","or","between")) or self::functionExists($cleanned_field))
							continue;
						
						$fieldExists = self::fieldExists($cleanned_field,$myArray);
						if($fieldExists===true)
							$condition = str_ireplace($field,' $row["'.$cleanned_field.'"] ',$condition);
						else
							throw new Exception("Champs '{$cleanned_field}' à l'index '$fieldExists' inconnu dans la clause 'where'");
					}
			
				}
			}
			else
				$condition = "1";
			
			//global $row;
			while( list($row_idx,$row) = each($myArray))
				if(isset($row[$fieldName])  && self::where($condition,array("row" => $row)))
					 $res[$fieldName][]=$row[$fieldName];
			return $res;
		}
		catch(Exception $e)
		{
			throw $e;
		}
	}
	
	/**
	* Alias de la méthode getField
	* 
	* @see getField
	*/
	public static function select($myArray,$fieldName,$condition){	return self::getField($myArray,$fieldName,$condition);}
	
	
	/**
	*	
	*/
	private static function where($condition,$scope=null)
	{
		//on défini le scope par défaut
		$myScope = $GLOBALS;
		//si un scope a été spécifié
		if(is_array($scope))
			$myScope = $scope;
		//on charge les variables du scope pour pourvoir faire lévaluation
		extract($myScope,EXTR_OVERWRITE);
		
		// on utilise les saut de lignes pour pouvoir se repérer si une erreur est générée
		// car eval ne spécifie qu'un numéro de ligne pour une erreur.  
		$condition		= str_replace(" ","\n",$condition);
		
		//inhibition du mess d'erreur
		//j'ai pas trouvé de vraie méthode pour ca :( cest crade
		ob_start();
			$evaluation 	= eval("return $condition;");
		$errorMsg 		= ob_get_clean();
				
		if(!empty($errorMsg))
			$error = error_get_last();
		$error_msg 		= "Erreur de syntaxe dans la clause 'where': ";
		$arrow_pad 		= strlen($error_msg); 
		
		// si une erreur à été généré lors de l'eval, on va préciser où se trouve l'erreur
		if(!empty($error['line']))
		{
			$error_line = $error['line'];
			
			for($i=1,$pos = strpos($condition,"\n");$i<$error_line-1;$pos=strpos($condition,"\n",$pos+1),$i++ ){}
			$condition 	= str_replace("\n"," ",$condition);		
			
			$arrow_pad += ($pos-2);
			$arrow_pad += strlen($condition);

			$arrow 		= str_repeat(' ',$arrow_pad).'^';
			throw new Exception("$error_msg$condition \n\t $arrow ({$error['message']})");
		}
		
		return $evaluation;      
	}
	

	/**
	 * retourne la taille la plus grande parmis les array contenu dans $myArray
	 *
	 * @param (array) $myArray
	 * @return (int)
	 */
	public static function getMaxSize($myArray)
	{
		$sizes	= self::count($myArray);
		if(!count($sizes))
			return 0;
		return max($sizes);
	}

	
	/**
	* retourne l'existence d'une clé dans l'ensemble des sous tableau de $myArray
	*
	* @param (string) $aColumnName
	* @param (array)  $myArray
	* @return (bool) 
	*/
	public static function fieldExists($aColumnName,Array $myArray)
	{
		if(empty($myArray))
		{
			//print_r(debug_backtrace());
			throw new Exception("Erreur test d'existence");
		}
		while(list($idx,$row)=each($myArray))
			if(!array_key_exists($aColumnName,$row))
				return $idx;
		return (bool)true;
	}


	public static 	function functionExists($funcName)
	{
		return method_exists(get_class(),$funcName);
	}
	/**
	* retourne les champs 
	* si le parametre optionel $all est définie à true (false par défaut),
	* alors ce sont tous les champs qui sont retournés
	* sans se soucier si ils sont tous commun aux sous-tableaux
	*
	* @param (array) $myArray
	* @param (bool) [$all]
	* @return (array)
	**/
	public static function getFields($myArray,$all=false)
	{	
		$res= array();
		while(list($idx,$row)=each($myArray))
			$res = ($all)?$res+array_keys($row):(count($res)?array_intersect($res,array_keys($row)):array_keys($row));
		return $res;
	
	}
	
	
	/**
	* 		Fonctions type msyql
	*/
	
	
	/**
	* retourne pour chaque ligne du tableau la taille
	*
	* @param (array) $myArray
	* @return (array)
	*/
	public static function count($myArray)
	{
		$res = array();
		while(list($idx,$row) = each($myArray))
			$res[$idx] = count($row);
		return $res;
	}
	
}

?>