Source for file jDaoGenerator.class.php

Documentation is available at jDaoGenerator.class.php

  1. <?php
  2. /**
  3. @package    jelix
  4. @subpackage dao
  5. @author     GĂ©rald Croes, Laurent Jouanneau
  6. @contributor Laurent Jouanneau
  7. @contributor Bastien Jaillot (bug fix)
  8. @contributor Julien Issler
  9. @copyright  2001-2005 CopixTeam, 2005-2011 Laurent Jouanneau
  10. @copyright  2007-2008 Julien Issler
  11. *  This class was get originally from the Copix project (CopixDAOGeneratorV1, Copix 2.3dev20050901, http://www.copix.org)
  12. *  Few lines of code are still copyrighted 2001-2005 CopixTeam (LGPL licence).
  13. *  Initial authors of this Copix class are Gerald Croes and Laurent Jouanneau,
  14. *  and this class was rewrited for Jelix by Laurent Jouanneau
  15. *
  16. @link        http://www.jelix.org
  17. @licence  http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public Licence, see LICENCE file
  18. */
  19.  
  20. /**
  21. * This is a generator which creates php class from dao xml file.
  22. *
  23. * It is called by jDaoCompiler
  24. @package  jelix
  25. @subpackage dao
  26. @see jDaoCompiler
  27. */
  28. class jDaoGenerator {
  29.  
  30.     /**
  31.     * the dao definition.
  32.     * @var jDaoParser 
  33.     */
  34.     protected $_dataParser = null;
  35.  
  36.     /**
  37.     * The DaoRecord ClassName
  38.     * @var string 
  39.     */
  40.     protected $_DaoRecordClassName = null;
  41.  
  42.     /**
  43.     * the DAO classname
  44.     * @var string 
  45.     */
  46.     protected $_DaoClassName = null;
  47.  
  48.     protected $propertiesListForInsert = 'PrimaryTable';
  49.  
  50.     protected $aliasWord = ' AS ';
  51.  
  52.     /**
  53.      * @var jDbTools 
  54.     */
  55.     protected $tools;
  56.  
  57.     protected $_daoId;
  58.     protected $_daoPath;
  59.     protected $_dbType;
  60.  
  61.     /**
  62.      * the real name of the main table
  63.      */
  64.     protected $tableRealName = '';
  65.  
  66.     /**
  67.      * the real name of the main table, escaped in SQL
  68.      * so it is ready to include into a SQL query.
  69.      */
  70.     protected $tableRealNameEsc = '';
  71.     
  72.     protected $sqlWhereClause = '';
  73.     
  74.     protected $sqlFromClause = '';
  75.     
  76.     protected $sqlSelectClause = '';
  77.  
  78.     /**
  79.     * constructor
  80.     * @param jDaoParser $daoDefinition 
  81.     */
  82.     function __construct($selector$tools$daoParser){
  83.         $this->_daoId = $selector->toString();
  84.         $this->_daoPath = $selector->getPath();
  85.         $this->_dbType = $selector->driver;
  86.         $this->_dataParser = $daoParser;
  87.         $this->_DaoClassName = $selector->getDaoClass();
  88.         $this->_DaoRecordClassName = $selector->getDaoRecordClass();
  89.         $this->tools = $tools;
  90.     }
  91.  
  92.     /**
  93.     * build all classes
  94.     */
  95.     public function buildClasses ({
  96.  
  97.         $src array();
  98.         $src[' require_once ( JELIX_LIB_PATH .\'dao/jDaoRecordBase.class.php\');';
  99.         $src[' require_once ( JELIX_LIB_PATH .\'dao/jDaoFactoryBase.class.php\');';
  100.  
  101.         // prepare some values to generate properties and methods
  102.  
  103.         $this->buildFromWhereClause();
  104.         $this->sqlSelectClause   = $this->buildSelectClause();
  105.  
  106.         $tables            $this->_dataParser->getTables();
  107.         $pkFields          $this->_getPrimaryFieldsList();
  108.         $this->tableRealName    = $tables[$this->_dataParser->getPrimaryTable()]['realname'];
  109.         $this->tableRealNameEsc = $this->_encloseName('\'.$this->_conn->prefixTable(\''.$this->tableRealName.'\').\'');
  110.  
  111.         $sqlPkCondition    $this->buildSimpleConditions($pkFields);
  112.         if ($sqlPkCondition != ''{
  113.             $sqlPkCondition($this->sqlWhereClause !='' ' AND ':' WHERE ').$sqlPkCondition;
  114.         }
  115.  
  116.         //-----------------------
  117.         // Build the record class
  118.         //-----------------------
  119.  
  120.         $src["\nclass ".$this->_DaoRecordClassName.' extends jDaoRecordBase {';
  121.  
  122.         $properties=array();
  123.  
  124.         foreach ($this->_dataParser->getProperties(as $id=>$field{
  125.             $properties[$idget_object_vars($field);
  126.             if ($field->defaultValue !== null{
  127.                 $src[=' public $'.$id.'='.var_export($field->defaultValuetrue).';';
  128.             }
  129.             else
  130.                 $src[=' public $'.$id.';';
  131.         }
  132.  
  133.         // TODO PHP 5.3 : we could remove that
  134.         $src['   public function getProperties() { return '.$this->_DaoClassName.'::$_properties; }';
  135.         $src['   public function getPrimaryKeyNames() { return '.$this->_DaoClassName.'::$_pkFields; }';
  136.         $src['}';
  137.  
  138.         //--------------------
  139.         // Build the dao class
  140.         //--------------------
  141.  
  142.         $src["\nclass ".$this->_DaoClassName.' extends jDaoFactoryBase {';
  143.         $src['   protected $_tables = '.var_export($tablestrue).';';
  144.         $src['   protected $_primaryTable = \''.$this->_dataParser->getPrimaryTable().'\';';
  145.         $src['   protected $_selectClause=\''.$this->sqlSelectClause.'\';';
  146.         $src['   protected $_fromClause;';
  147.         $src['   protected $_whereClause=\''.$this->sqlWhereClause.'\';';
  148.         $src['   protected $_DaoRecordClassName=\''.$this->_DaoRecordClassName.'\';';
  149.         $src['   protected $_daoSelector = \''.$this->_daoId.'\';';
  150.  
  151.         if($this->tools->trueValue != '1'){
  152.             $src[]='   protected $trueValue ='.var_export($this->tools->trueValuetrue).';';
  153.             $src[]='   protected $falseValue ='.var_export($this->tools->falseValuetrue).';';
  154.         }
  155.  
  156.         if($this->_dataParser->hasEvent('deletebefore'|| $this->_dataParser->hasEvent('delete'))
  157.             $src['   protected $_deleteBeforeEvent = true;';
  158.         if ($this->_dataParser->hasEvent('deleteafter'|| $this->_dataParser->hasEvent('delete'))
  159.             $src['   protected $_deleteAfterEvent = true;';
  160.         if ($this->_dataParser->hasEvent('deletebybefore'|| $this->_dataParser->hasEvent('deleteby'))
  161.             $src['   protected $_deleteByBeforeEvent = true;';
  162.         if ($this->_dataParser->hasEvent('deletebyafter'|| $this->_dataParser->hasEvent('deleteby'))
  163.             $src['   protected $_deleteByAfterEvent = true;';
  164.  
  165.         $src['   public static $_properties = '.var_export($propertiestrue).';';
  166.         $src['   public static $_pkFields = array('.$this->_writeFieldNamesWith ($start '\''$end='\''$beetween ','$pkFields).');';
  167.  
  168.         $src[' ';
  169.         $src['public function __construct($conn){';
  170.         $src['   parent::__construct($conn);';
  171.         $src['   $this->_fromClause = \''.$this->sqlFromClause.'\';';
  172.         $src['}';
  173.  
  174.         // cannot put this methods directly into jDaoBase because self cannot refer to a child class
  175.         // FIXME PHP53, we could use the static keyword instead of self
  176.         $src['   public function getProperties() { return self::$_properties; }';
  177.         $src['   public function getPrimaryKeyNames() { return self::$_pkFields;}';
  178.  
  179.         $src[' ';
  180.         $src[' protected function _getPkWhereClauseForSelect($pk){';
  181.         $src['   extract($pk);';
  182.         $src[' return \''.$sqlPkCondition.'\';';
  183.         $src['}';
  184.  
  185.         $src[' ';
  186.         $src['protected function _getPkWhereClauseForNonSelect($pk){';
  187.         $src['   extract($pk);';
  188.         $src['   return \' where '.$this->buildSimpleConditions($pkFields,'',false).'\';';
  189.         $src['}';
  190.  
  191.         //----- Insert method
  192.  
  193.         $src[$this->buildInsertMethod($pkFields);
  194.  
  195.         //-----  update method
  196.  
  197.         $src[$this->buildUpdateMethod($pkFields);
  198.  
  199.         //----- other user methods
  200.  
  201.         $src[$this->buildUserMethods();
  202.  
  203.         $src[$this->buildEndOfClass();
  204.  
  205.         $src['}';//end of class
  206.  
  207.         return implode("\n",$src);
  208.     }
  209.  
  210.     /**
  211.      * build the insert() method in the final class
  212.      * @return string the source of the method
  213.      */
  214.     protected function buildInsertMethod($pkFields{
  215.         $pkai $this->getAutoIncrementPKField();
  216.         $src array();
  217.         $src['public function insert ($record){';
  218.  
  219.         if($pkai !== null){
  220.             // if there is an autoincrement field as primary key
  221.  
  222.             // if a value is given for the autoincrement field, then with do a full insert
  223.             $src[]=' if($record->'.$pkai->name.' > 0 ){';
  224.             $src['    $query = \'INSERT INTO '.$this->tableRealNameEsc.' (';
  225.             $fields $this->_getPropertiesBy('PrimaryTable');
  226.             list($fields$values$this->_prepareValues($fields,'insertPattern''record->');
  227.  
  228.             $src[implode(',',$fields);
  229.             $src[') VALUES (';
  230.             $src[implode(', ',$values);
  231.             $src[")';";
  232.  
  233.             $src['}else{';
  234.  
  235.             $fields $this->_getPropertiesBy($this->propertiesListForInsert);
  236.         }else{
  237.             $fields $this->_getPropertiesBy('PrimaryTable');
  238.         }
  239.  
  240.         if($this->_dataParser->hasEvent('insertbefore'|| $this->_dataParser->hasEvent('insert')){
  241.             $src['   jEvent::notify("daoInsertBefore", array(\'dao\'=>$this->_daoSelector, \'record\'=>$record));';
  242.         }
  243.         
  244.         // if there isn't a autoincrement as primary key, then we do a full insert.
  245.         // if there isn't a value for the autoincrement field and if this is a mysql/sqlserver and pgsql,
  246.         // we do an insert without given primary key. In other case, we do a full insert.
  247.  
  248.         $src['    $query = \'INSERT INTO '.$this->tableRealNameEsc.' (';
  249.  
  250.         list($fields$values$this->_prepareValues($fields,'insertPattern''record->');
  251.  
  252.         $src[implode(',',$fields);
  253.         $src[') VALUES (';
  254.         $src[implode(', ',$values);
  255.         $src[")';";
  256.  
  257.         if($pkai !== null)
  258.             $src['}';
  259.  
  260.         $src['   $result = $this->_conn->exec ($query);';
  261.  
  262.         if($pkai !== null){
  263.             $src['   if(!$result)';
  264.             $src['       return false;';
  265.  
  266.             $src['   if($record->'.$pkai->name.' < 1 ) ';
  267.             $src[$this->buildUpdateAutoIncrementPK($pkai);
  268.         }
  269.  
  270.         // we generate a SELECT query to update field on the record object, which are autoincrement or calculated
  271.         $fields $this->_getPropertiesBy('FieldToUpdate');
  272.         if (count($fields)) {
  273.             $result array();
  274.             foreach ($fields as $id=>$prop){
  275.                 $result[]$this->buildSelectPattern($prop->selectPattern''$prop->fieldName$prop->name);
  276.             }
  277.  
  278.             $sql 'SELECT '.(implode (', ',$result))' FROM '.$this->tableRealNameEsc.' WHERE ';
  279.             $sql.= $this->buildSimpleConditions($pkFields'record->'false);
  280.  
  281.             $src['  $query =\''.$sql.'\';';
  282.             $src['  $rs  =  $this->_conn->query ($query);';
  283.             $src['  $newrecord =  $rs->fetch ();';
  284.             foreach ($fields as $id=>$prop){
  285.                 $src['  $record->'.$prop->name.' = $newrecord->'.$prop->name.';';
  286.             }
  287.         }
  288.  
  289.         if($this->_dataParser->hasEvent('insertafter'|| $this->_dataParser->hasEvent('insert')){
  290.             $src['   jEvent::notify("daoInsertAfter", array(\'dao\'=>$this->_daoSelector, \'record\'=>$record));';
  291.         }
  292.  
  293.         $src['    return $result;';
  294.         $src['}';
  295.  
  296.         return implode("\n",$src);
  297.     }
  298.  
  299.     /**
  300.      * build the update() method for the final class
  301.      * @return string the source of the method
  302.      */
  303.     protected function buildUpdateMethod($pkFields{
  304.         $src array();
  305.         
  306.         $src['public function update ($record){';
  307.         list($fields$values$this->_prepareValues($this->_getPropertiesBy('PrimaryFieldsExcludePk'),'updatePattern''record->');
  308.         
  309.         if(count($fields)){
  310.             
  311.             if($this->_dataParser->hasEvent('updatebefore'|| $this->_dataParser->hasEvent('update')){
  312.                 $src['   jEvent::notify("daoUpdateBefore", array(\'dao\'=>$this->_daoSelector, \'record\'=>$record));';
  313.             }
  314.             
  315.             $src['   $query = \'UPDATE '.$this->tableRealNameEsc.' SET ';
  316.             $sqlSet='';
  317.             foreach($fields as $k=> $fname){
  318.                 $sqlSet.= ', '.$fname'= '$values[$k];
  319.             }
  320.             $src[substr($sqlSet,1);
  321.  
  322.             $sqlCondition $this->buildSimpleConditions($pkFields'record->'false);
  323.             if($sqlCondition!='')
  324.                 $src[' where '.$sqlCondition;
  325.  
  326.             $src["';";
  327.  
  328.             $src['   $result = $this->_conn->exec ($query);';
  329.  
  330.             // we generate a SELECT query to update field on the record object, which are autoincrement or calculated
  331.             $fields $this->_getPropertiesBy('FieldToUpdateOnUpdate');
  332.             if (count($fields)) {
  333.                 $result array();
  334.                 foreach ($fields as $id=>$prop){
  335.                     $result[]$this->buildSelectPattern($prop->selectPattern''$prop->fieldName$prop->name);
  336.                 }
  337.  
  338.                 $sql 'SELECT '.(implode (', ',$result))' FROM '.$this->tableRealNameEsc.' WHERE ';
  339.                 $sql.= $this->buildSimpleConditions($pkFields'record->'false);
  340.  
  341.                 $src['  $query =\''.$sql.'\';';
  342.                 $src['  $rs  =  $this->_conn->query ($query, jDbConnection::FETCH_INTO, $record);';
  343.                 $src['  $record =  $rs->fetch ();';
  344.             }
  345.  
  346.             if($this->_dataParser->hasEvent('updateafter'|| $this->_dataParser->hasEvent('update'))
  347.                 $src['   jEvent::notify("daoUpdateAfter", array(\'dao\'=>$this->_daoSelector, \'record\'=>$record));';
  348.  
  349.             $src['   return $result;';
  350.         }else{
  351.             //the dao is mapped on a table which contains only primary key : update is impossible
  352.             // so we will generate an error on update
  353.             $src["     throw new jException('jelix~dao.error.update.impossible',array('".$this->_daoId."','".$this->_daoPath."'));";
  354.         }
  355.  
  356.         $src[' }';//ends the update function
  357.         return implode("\n",$src);
  358.     }
  359.  
  360.     /**
  361.      * build all methods defined by the developer in the dao file
  362.      * @return string the source of the methods
  363.      */
  364.     protected function buildUserMethods({
  365.         
  366.         $allField $this->_getPropertiesBy('All');
  367.         $primaryFields $this->_getPropertiesBy('PrimaryTable');
  368.         $src array();
  369.  
  370.         foreach($this->_dataParser->getMethods(as $name=>$method){
  371.  
  372.             $defval $method->getParametersDefaultValues();
  373.             if(count($defval)){
  374.                 $mparam='';
  375.                 foreach($method->getParameters(as $param){
  376.                     $mparam.=', $'.$param;
  377.                     if(isset($defval[$param]))
  378.                         $mparam.='=\''.str_replace("'","\'",$defval[$param]).'\'';
  379.                 }
  380.                 $mparam substr($mparam,1);
  381.             }else{
  382.                 $mparam=implode(', $',$method->getParameters());
  383.                 if($mparam != ''$mparam ='$'.$mparam;
  384.             }
  385.  
  386.             $src[' function '.$method->name.' ('$mparam.'){';
  387.  
  388.             $limit='';
  389.  
  390.             $glueCondition =' WHERE ';
  391.             switch($method->type){
  392.                 case 'delete':
  393.                     $this->buildDeleteUserQuery($method$src$primaryFields);
  394.                     break;
  395.                 case 'update':
  396.                     $this->buildUpdateUserQuery($method$src$primaryFields);
  397.                     break;
  398.                 case 'php':
  399.                     $src[$method->getBody();
  400.                     $src['}';
  401.                     break;
  402.  
  403.                 case 'count':
  404.                     $this->buildCountUserQuery($method$src$allField);
  405.                     break;
  406.                 case 'selectfirst':
  407.                 case 'select':
  408.                 default:
  409.                     $limit $this->buildSelectUserQuery($method$src$allField);
  410.             }
  411.  
  412.             if($method->type == 'php')
  413.                 continue;
  414.  
  415.  
  416.             switch($method->type){
  417.                 case 'delete':
  418.                 case 'update' :
  419.                     if ($method->eventBeforeEnabled || $method->eventAfterEnabled{
  420.                         $src['   $args = func_get_args();';
  421.                         $methname ($method->type == 'update'?'Update':'Delete');
  422.                         if ($method->eventBeforeEnabled{
  423.                             $src['   jEvent::notify("daoSpecific'.$methname.'Before", array(\'dao\'=>$this->_daoSelector,\'method\'=>\''.
  424.                             $method->name.'\', \'params\'=>$args));';
  425.                         }
  426.                         if ($method->eventAfterEnabled{
  427.                             $src['   $result = $this->_conn->exec ($__query);';
  428.                             $src['   jEvent::notify("daoSpecific'.$methname.'After", array(\'dao\'=>$this->_daoSelector,\'method\'=>\''.
  429.                                 $method->name.'\', \'params\'=>$args));';
  430.                             $src['   return $result;';
  431.                         else {
  432.                             $src['    return $this->_conn->exec ($__query);';
  433.                         }
  434.                     else {
  435.                         $src['    return $this->_conn->exec ($__query);';
  436.                     }
  437.                     break;
  438.                 case 'count':
  439.                     $src['    $__rs = $this->_conn->query($__query);';
  440.                     $src['    $__res = $__rs->fetch();';
  441.                     $src['    return intval($__res->c);';
  442.                     break;
  443.                 case 'selectfirst':
  444.                     $src['    $__rs = $this->_conn->limitQuery($__query,0,1);';
  445.                     $src['    $this->finishInitResultSet($__rs);';
  446.                     $src['    return $__rs->fetch();';
  447.                     break;
  448.                 case 'select':
  449.                 default:
  450.                     if($limit)
  451.                         $src['    $__rs = $this->_conn->limitQuery($__query'.$limit.');';
  452.                     else
  453.                         $src['    $__rs = $this->_conn->query($__query);';
  454.                     $src['    $this->finishInitResultSet($__rs);';
  455.                     $src['    return $__rs;';
  456.             }
  457.             $src['}';
  458.         }
  459.         return implode("\n",$src);
  460.     }
  461.  
  462.     /**
  463.      *
  464.      */
  465.     protected function buildDeleteUserQuery($method&$src&$primaryFields{
  466.         $src['    $__query = \'DELETE FROM '.$this->tableRealNameEsc.' \';';
  467.         $cond $method->getConditions();
  468.         if($cond !== null{
  469.             $sqlCond $this->buildConditions($cond$primaryFields$method->getParameters()false);
  470.             if(trim($sqlCond!= '')
  471.                 $src['$__query .=\' WHERE '.$sqlCond."';";
  472.         }
  473.     }
  474.  
  475.     /**
  476.      *
  477.      */
  478.     protected function buildUpdateUserQuery($method&$src&$primaryFields{
  479.         $src['    $__query = \'UPDATE '.$this->tableRealNameEsc.' SET ';
  480.         $updatefields $this->_getPropertiesBy('PrimaryFieldsExcludePk');
  481.         $sqlSet='';
  482.         foreach($method->getValues(as $propname=>$value){
  483.             if($value[1]){
  484.                 foreach($method->getParameters(as $param){
  485.                     $value[0str_replace('$'.$param'\'.'.$this->_preparePHPExpr('$'.$param$updatefields[$propname],true).'.\'',$value[0]);
  486.                 }
  487.                 $sqlSet.= ', '.$this->_encloseName($updatefields[$propname]->fieldName)'= '$value[0];
  488.             }else{
  489.                 $sqlSet.= ', '.$this->_encloseName($updatefields[$propname]->fieldName)'= '.
  490.                     $this->tools->escapeValue($updatefields[$propname]->unifiedType$value[0]falsetrue);
  491.             }
  492.         }
  493.         $src[=substr($sqlSet,1).'\';';
  494.         $cond $method->getConditions();
  495.         if($cond !== null{
  496.             $sqlCond $this->buildConditions($cond$primaryFields$method->getParameters()false);
  497.             if(trim($sqlCond!= '')
  498.                 $src['$__query .=\' WHERE '.$sqlCond."';";
  499.         }
  500.     }
  501.  
  502.     /**
  503.      *
  504.      */
  505.     protected function buildCountUserQuery($method&$src&$allField{
  506.         if ($method->distinct !=''{
  507.             $properties $this->_dataParser->getProperties ();
  508.             $tables $this->_dataParser->getTables();
  509.             $prop $properties[$method->distinct];
  510.             $count=' DISTINCT '.$this->_encloseName($tables[$prop->table]['name'].'.'.$this->_encloseName($prop->fieldName);
  511.         }
  512.         else {
  513.             $count='*';
  514.         }
  515.         $src['    $__query = \'SELECT COUNT('.$count.') as c \'.$this->_fromClause.$this->_whereClause;';
  516.         $glueCondition ($this->sqlWhereClause !='' ' AND ':' WHERE ');
  517.  
  518.         $cond $method->getConditions();
  519.         if($cond !== null{
  520.             $sqlCond $this->buildConditions($cond$allField$method->getParameters()true);
  521.             if(trim($sqlCond!= '')
  522.                 $src['$__query .=\''.$glueCondition.$sqlCond."';";
  523.         }
  524.     }
  525.  
  526.     /**
  527.      *
  528.      */
  529.     protected function buildSelectUserQuery($method&$src&$allField{
  530.         $limit '';
  531.         if($method->distinct !=''){
  532.             $select '\''.$this->buildSelectClause($method->distinct).'\'';
  533.         }
  534.         else{
  535.             $select=' $this->_selectClause';
  536.         }
  537.         $src['    $__query = '.$select.'.$this->_fromClause.$this->_whereClause;';
  538.         $glueCondition ($this->sqlWhereClause !='' ' AND ':' WHERE ');
  539.         if$method->type == 'select' && ($lim $method->getLimit ()) !==null){
  540.             $limit =', '.$lim['offset'].', '.$lim['count'];
  541.         }
  542.  
  543.         $sqlCond $this->buildConditions($method->getConditions()$allField$method->getParameters()true$method->getGroupBy());
  544.  
  545.         if(trim($sqlCond!= '')
  546.             $src['$__query .=\''.$glueCondition.$sqlCond."';";
  547.  
  548.         return $limit;
  549.     }
  550.  
  551.  
  552.     /**
  553.     * create FROM clause and WHERE clause for all SELECT query
  554.     */
  555.     protected function buildFromWhereClause(){
  556.  
  557.         $tables $this->_dataParser->getTables();
  558.  
  559.         foreach($tables as $table_name => $table){
  560.             $tables[$table_name]['realname''\'.$this->_conn->prefixTable(\''.$table['realname'].'\').\'';
  561.         }
  562.  
  563.         $primarytable $tables[$this->_dataParser->getPrimaryTable()];
  564.         $ptrealname $this->_encloseName($primarytable['realname']);
  565.         $ptname $this->_encloseName($primarytable['name']);
  566.  
  567.         list($sqlFrom$sqlWhere$this->buildOuterJoins($tables$ptname);
  568.  
  569.         $sqlFrom =$ptrealname.$this->aliasWord.$ptname.$sqlFrom;
  570.  
  571.         foreach($this->_dataParser->getInnerJoins(as $tablejoin){
  572.             $table$tables[$tablejoin];
  573.             $tablename $this->_encloseName($table['name']);
  574.             $sqlFrom .=', '.$this->_encloseName($table['realname']).$this->aliasWord.$tablename;
  575.  
  576.             foreach($table['fk'as $k => $fk){
  577.                 $sqlWhere.=' AND '.$ptname.'.'.$this->_encloseName($fk).'='.$tablename.'.'.$this->_encloseName($table['pk'][$k]);
  578.             }
  579.         }
  580.  
  581.         $this->sqlWhereClause = ($sqlWhere !='' ' WHERE '.substr($sqlWhere,4:'');
  582.         $this->sqlFromClause = ' FROM '.$sqlFrom;
  583.     }
  584.  
  585.     /**
  586.      * generates the part of the FROM clause for outer joins
  587.      * @return array  [0]=> the part of the FROM clause, [1]=> the part to add to the WHERE clause when needed
  588.      */
  589.     protected function buildOuterJoins(&$tables$primaryTableName){
  590.         $sqlFrom '';
  591.         foreach($this->_dataParser->getOuterJoins(as $tablejoin){
  592.             $table$tables[$tablejoin[0]];
  593.             $tablename $this->_encloseName($table['name']);
  594.  
  595.             $r =$this->_encloseName($table['realname']).$this->aliasWord.$tablename;
  596.  
  597.             $fieldjoin='';
  598.             foreach($table['fk'as $k => $fk){
  599.                 $fieldjoin.=' AND '.$primaryTableName.'.'.$this->_encloseName($fk).'='.$tablename.'.'.$this->_encloseName($table['pk'][$k]);
  600.             }
  601.             $fieldjoin=substr($fieldjoin,4);
  602.  
  603.             if($tablejoin[1== 0){
  604.                 $sqlFrom.=' LEFT JOIN '.$r.' ON ('.$fieldjoin.')';
  605.             }elseif($tablejoin[1== 1){
  606.                 $sqlFrom.=' RIGHT JOIN '.$r.' ON ('.$fieldjoin.')';
  607.             }
  608.         }
  609.         return array($sqlFrom'');
  610.     }
  611.  
  612.     /**
  613.     * build a SELECT clause for all SELECT queries
  614.     * @return string the select clause.
  615.     */
  616.     protected function buildSelectClause ($distinct=false){
  617.         $result array();
  618.  
  619.         $tables $this->_dataParser->getTables();
  620.         foreach ($this->_dataParser->getProperties (as $id=>$prop){
  621.  
  622.             $table $this->_encloseName($tables[$prop->table]['name'].'.';
  623.  
  624.             if ($prop->selectPattern !=''){
  625.                 $result[]$this->buildSelectPattern($prop->selectPattern$table$prop->fieldName$prop->name);
  626.             }
  627.         }
  628.  
  629.         return 'SELECT '.($distinct?'DISTINCT ':'').(implode (', ',$result));
  630.     }
  631.  
  632.     /**
  633.      * build an item for the select clause
  634.     */
  635.     protected function buildSelectPattern ($pattern$table$fieldname$propname ){
  636.         if ($pattern =='%s'){
  637.             $field $table.$this->_encloseName($fieldname);
  638.             if ($fieldname != $propname){
  639.                 $field .= ' as '.$this->_encloseName($propname);    
  640.             }
  641.         }else{
  642.             $field str_replace(array("'""%s")array("\\'",$table.$this->_encloseName($fieldname)),$pattern).' as '.$this->_encloseName($propname);
  643.         }
  644.         return $field;
  645.     }
  646.  
  647.     protected function buildEndOfClass({
  648.         return '';
  649.     }
  650.  
  651.     /**
  652.     * format field names with start, end and between strings.
  653.     *   will write the field named info.
  654.     *   eg info == name
  655.     *   echo $field->name
  656.     * @param string   $info    property to get from objects in $using
  657.     * @param string   $start   string to add before the info
  658.     * @param string   $end     string to add after the info
  659.     * @param string   $beetween string to add between each info
  660.     * @param array    $using     list of CopixPropertiesForDAO object. if null, get default fields list
  661.     * @see  jDaoProperty
  662.     */
  663.     protected function _writeFieldsInfoWith ($info$start ''$end=''$beetween ''$using null){
  664.         $result array();
  665.         if ($using === null){
  666.             //if no fields are provided, using _dataParser's as default.
  667.             $using $this->_dataParser->getProperties ();
  668.         }
  669.  
  670.         foreach ($using as $id=>$field){
  671.             $result[$start $field->$info $end;
  672.         }
  673.  
  674.         return implode ($beetween,$result);;
  675.     }
  676.  
  677.     /**
  678.     * format field names with start, end and between strings.
  679.     */
  680.     protected function _writeFieldNamesWith ($start ''$end=''$beetween ''$using null){
  681.         return $this->_writeFieldsInfoWith ('name'$start$end$beetween$using);
  682.     }
  683.  
  684.     protected function _getPrimaryFieldsList({
  685.         $tables            $this->_dataParser->getTables();
  686.         $pkFields          array();
  687.  
  688.         $primTable $tables[$this->_dataParser->getPrimaryTable()];
  689.         $props  $this->_dataParser->getProperties();
  690.         // we want to have primary keys as the same order indicated into primarykey attr
  691.         foreach($primTable['pk'as $pkname{
  692.             foreach($primTable['fields'as $f){
  693.                 if ($props[$f]->fieldName == $pkname{
  694.                     $pkFields[$props[$f]->name$props[$f];
  695.                     break;
  696.                 }
  697.             }
  698.         }
  699.         return $pkFields;
  700.     }
  701.  
  702.     /**
  703.     * gets fields that match a condition returned by the $captureMethod
  704.     * @internal
  705.     */
  706.     protected function _getPropertiesBy ($captureMethod){
  707.         $captureMethod '_capture'.$captureMethod;
  708.         $result array ();
  709.  
  710.         foreach ($this->_dataParser->getProperties(as $field){
  711.             if $this->$captureMethod($field)){
  712.                 $result[$field->name$field;
  713.             }
  714.         }
  715.         return $result;
  716.     }
  717.  
  718.     protected function _capturePrimaryFieldsExcludeAutoIncrement(&$field){
  719.         return ($field->table == $this->_dataParser->getPrimaryTable(&& !$field->autoIncrement);
  720.     }
  721.  
  722.     protected function _capturePrimaryFieldsExcludePk(&$field){
  723.         return ($field->table == $this->_dataParser->getPrimaryTable()) && !$field->isPK;
  724.     }
  725.  
  726.     protected function _capturePrimaryTable(&$field){
  727.         return ($field->table == $this->_dataParser->getPrimaryTable());
  728.     }
  729.  
  730.     protected function _captureAll(&$field){
  731.         return true;
  732.     }
  733.  
  734.     protected function _captureFieldToUpdate(&$field){
  735.         return ($field->table == $this->_dataParser->getPrimaryTable()
  736.                 && !$field->isPK
  737.                 && !$field->isFK
  738.                 && $field->autoIncrement || ($field->insertPattern != '%s' && $field->selectPattern != '')));
  739.     }
  740.  
  741.     protected function _captureFieldToUpdateOnUpdate(&$field){
  742.         return ($field->table == $this->_dataParser->getPrimaryTable()
  743.                 && !$field->isPK
  744.                 && !$field->isFK
  745.                 && $field->autoIncrement || ($field->updatePattern != '%s' && $field->selectPattern != '')));
  746.     }
  747.  
  748.     protected function _captureBinaryField(&$field{
  749.         return ($field->unifiedType == 'binary' || $field->unifiedType == 'varbinary');
  750.     }
  751.  
  752.     /**
  753.     * get autoincrement PK field
  754.     */
  755.     protected function getAutoIncrementPKField ($using null){
  756.         if ($using === null){
  757.             $using $this->_dataParser->getProperties ();
  758.         }
  759.  
  760.         $tb $this->_dataParser->getTables();
  761.         $tb $tb[$this->_dataParser->getPrimaryTable()]['realname'];
  762.  
  763.         foreach ($using as $id=>$field{
  764.             if(!$field->isPK)
  765.                 continue;
  766.             if ($field->autoIncrement{
  767.                 return $field;
  768.             }
  769.         }
  770.         return null;
  771.     }
  772.  
  773.     /**
  774.      * build a WHERE clause with conditions on given properties : conditions are
  775.      * equality between a variable and the field.
  776.      * the variable name is the name of the property, made with an optional prefix
  777.      * given in $fieldPrefix parameter.
  778.      * This method is called to generate WHERE clause for primary keys.
  779.      * @param array $fields  list of jDaoPropery objects
  780.      * @param string $fieldPrefix  an optional prefix to prefix variable names
  781.      * @param boolean $forSelect  if true, the table name or table alias will prefix
  782.      *                             the field name in the query
  783.      * @return string the WHERE clause (without the WHERE keyword)
  784.      * @internal
  785.      */
  786.     protected function buildSimpleConditions (&$fields$fieldPrefix=''$forSelect=true){
  787.         $r ' ';
  788.  
  789.         $first true;
  790.         foreach($fields as $field){
  791.             if (!$first){
  792.                 $r .= ' AND ';
  793.             }else{
  794.                 $first false;
  795.             }
  796.  
  797.             if($forSelect){
  798.                 $condition $this->_encloseName($field->table).'.'.$this->_encloseName($field->fieldName);
  799.             }else{
  800.                 $condition $this->_encloseName($field->fieldName);
  801.             }
  802.  
  803.             $var '$'.$fieldPrefix.$field->name;
  804.             $value $this->_preparePHPExpr($var$field!$field->requiredInConditions'=');
  805.  
  806.             $r .= $condition.'\'.'.$value.'.\'';
  807.         }
  808.  
  809.         return $r;
  810.     }
  811.  
  812.  
  813.     protected function _prepareValues ($fieldList$pattern=''$prefixfield=''){
  814.         $values $fields array();
  815.  
  816.         foreach ((array)$fieldList as $fieldName=>$field{
  817.             if ($pattern != '' && $field->$pattern == ''{
  818.                 continue;
  819.             }
  820.  
  821.             $value $this->_preparePHPExpr('$'.$prefixfield.$fieldName$fieldtrue);
  822.  
  823.             if($pattern != ''){
  824.                 $values[$field->namesprintf($field->$pattern,'\'.'.$value.'.\'');
  825.             }else{
  826.                 $values[$field->name'\'.'.$value.'.\'';
  827.             }
  828.  
  829.             $fields[$field->name$this->_encloseName($field->fieldName);
  830.         }
  831.         return array($fields$values);
  832.     }
  833.  
  834.  
  835.     /**
  836.      * build 'where' clause from conditions declared with condition tag in a user method
  837.      * @param jDaoConditions $cond the condition object which contains conditions data
  838.      * @param array $fields  array of jDaoProperty
  839.      * @param array $params  list of parameters name of the method
  840.      * @param boolean $withPrefix true if the field name should be preceded by the table name/table alias
  841.      * @param array $groupby  list of properties to use in a groupby
  842.      * @return string a WHERE clause (without the WHERE keyword) with eventually an ORDER clause
  843.      * @internal
  844.      */
  845.     protected function buildConditions ($cond$fields$params=array()$withPrefix=true$groupby=null){
  846.         if($cond)
  847.             $sql $this->buildOneSQLCondition ($cond->condition$fields$params$withPrefixtrue);
  848.         else
  849.             $sql '';
  850.  
  851.         if($groupby && count($groupby)) {
  852.             if(trim($sql==''{
  853.                 $sql ' 1=1 ';
  854.             }
  855.             foreach($groupby as $k=>$f{
  856.                 if ($withPrefix)
  857.                     $groupby[$k]$this->_encloseName($fields[$f]->table).'.'.$this->_encloseName($fields[$f]->fieldName);
  858.                 else
  859.                     $groupby[$k]$this->_encloseName($fields[$f]->fieldName);
  860.             }
  861.             $sql .= ' GROUP BY '.implode (', '$groupby);
  862.         }
  863.  
  864.         $order array ();
  865.         foreach ($cond->order as $name => $way){
  866.             $ord='';
  867.             if (isset($fields[$name])){
  868.                 if ($withPrefix)
  869.                     $ord $this->_encloseName($fields[$name]->table).'.'.$this->_encloseName($fields[$name]->fieldName);
  870.                 else
  871.                     $ord $this->_encloseName($fields[$name]->fieldName);
  872.             }elseif($name[0== '$'){
  873.                 $ord '\'.'.$name.'.\'';
  874.             }else{
  875.                 continue;
  876.             }
  877.             if($way[0== '$'){
  878.                 $order[]=$ord.' \'.( strtolower('.$way.') ==\'asc\'?\'asc\':\'desc\').\'';
  879.             }else{
  880.                 $order[]=$ord.' '.$way;
  881.             }
  882.         }
  883.         if(count ($order0){
  884.             if(trim($sql==''{
  885.                 $sql ' 1=1 ';
  886.             }
  887.             $sql.=' ORDER BY '.implode (', '$order);
  888.         }
  889.         return $sql;
  890.     }
  891.  
  892.     /**
  893.      * build a condition for the SQL WHERE clause.
  894.      * this method call itself recursively.
  895.      * @param jDaoCondition $cond a condition object which contains conditions data
  896.      * @param array $fields  array of jDaoProperty
  897.      * @param array $params  list of parameters name of the method
  898.      * @param boolean $withPrefix true if the field name should be preceded by the table name/table alias
  899.      * @param boolean $principal  should be true for the first call, and false for recursive call
  900.      * @return string a WHERE clause (without the WHERE keyword)
  901.      * @see jDaoGenerator::buildConditions
  902.      * @internal
  903.      */
  904.     protected function buildOneSQLCondition ($condition$fields$params$withPrefix$principal=false){
  905.  
  906.         $r ' ';
  907.  
  908.         //direct conditions for the group
  909.         $first true;
  910.         foreach ($condition->conditions as $cond){
  911.             if (!$first){
  912.                 $r .= ' '.$condition->glueOp.' ';
  913.             }
  914.             $first false;
  915.  
  916.             $prop $fields[$cond['field_id']];
  917.  
  918.             if($withPrefix){
  919.                 $f $this->_encloseName($prop->table).'.'.$this->_encloseName($prop->fieldName);
  920.             }else{
  921.                 $f $this->_encloseName($prop->fieldName);
  922.             }
  923.  
  924.             $r .= $f.' ';
  925.  
  926.             if($cond['operator'== 'IN' || $cond['operator'== 'NOT IN'){
  927.                 if($cond['isExpr']){
  928.                     $phpexpr $this->_preparePHPCallbackExpr($prop);
  929.                     $phpvalue 'implode(\',\', array_map( '.$phpexpr.', '.$cond['value'].'))';
  930.                     $value'(\'.'.$phpvalue.'.\')';
  931.                 }else{
  932.                     $value'('.$cond['value'].')';
  933.                 }
  934.                 $r.=$cond['operator'].' '.$value;
  935.             }elseif($cond['operator'== 'IS NULL' || $cond['operator'== 'IS NOT NULL'){
  936.                 $r.=$cond['operator'].' ';
  937.             }else{
  938.                 if($cond['isExpr']){
  939.                     $value=str_replace("'","\\'",$cond['value']);
  940.                     // we need to know if the expression is like "$foo" (1) or a thing like "concat($foo,'bla')" (2)
  941.                     // because of the nullability of the parameter. If the value of the parameter is null and the operator
  942.                     // is = or <>, then we need to generate a thing like :
  943.                     // - in case 1: ($foo === null ? 'IS NULL' : '='.$this->_conn->quote($foo))
  944.                     // - in case 2: '= concat('.($foo === null ? 'NULL' : $this->_conn->quote($foo)).' ,\'bla\')'
  945.                     if($value[0== '$'){
  946.                         $value '\'.'.$this->_preparePHPExpr($value$prop!$prop->requiredInConditions,$cond['operator']).'.\'';
  947.                     }else{
  948.                         foreach($params as $param){
  949.                             $value str_replace('$'.$param'\'.'.$this->_preparePHPExpr('$'.$param$prop!$prop->requiredInConditions).'.\'',$value);
  950.                         }
  951.                         $value $cond['operator'].' '.$value;
  952.                     }
  953.                 else {
  954.                     $value $cond['operator'].' ';
  955.                     if ($cond['operator'== 'LIKE' || $cond['operator'== 'NOT LIKE'{
  956.                         $value .= $this->tools->escapeValue('varchar'$cond['value']falsetrue);
  957.                     else {
  958.                         $value .= $this->tools->escapeValue($prop->unifiedType$cond['value']falsetrue);
  959.                     }
  960.                 }
  961.                 $r.=$value;
  962.             }
  963.         }
  964.         //sub conditions
  965.         foreach ($condition->group as $conditionDetail){
  966.             if (!$first){
  967.                 $r .= ' '.$condition->glueOp.' ';
  968.             }
  969.             $r .= $this->buildOneSQLCondition($conditionDetail$fields$params$withPrefix);
  970.             $first=false;
  971.         }
  972.  
  973.         //adds parenthesis around the sql if needed (non empty)
  974.         if (strlen (trim ($r)) && (!$principal ||($principal && $condition->glueOp != 'AND'))){
  975.             $r '('.$r.')';
  976.         }
  977.         return $r;
  978.     }
  979.  
  980.     protected function _preparePHPExpr($expr$field$checknull=true$forCondition=''){
  981.         $opnull $opval '';
  982.         if($checknull && $forCondition != ''){
  983.             if($forCondition == '=')
  984.                 $opnull 'IS ';
  985.             elseif($forCondition == '<>')
  986.                 $opnull 'IS NOT ';
  987.             else
  988.                 $checknull=false;
  989.         }
  990.         $type '';
  991.         if ($forCondition != 'LIKE' && $forCondition != 'NOT LIKE')
  992.             $type strtolower($field->unifiedType);
  993.  
  994.         if ($forCondition != ''{
  995.             $forCondition '\' '.$forCondition.' \'.'// spaces for operators like LIKE
  996.         }
  997.  
  998.         switch($type){
  999.             case 'integer':
  1000.                 if($checknull){
  1001.                     $expr'('.$expr.' === null ? \''.$opnull.'NULL\' : '.$forCondition.'intval('.$expr.'))';
  1002.                 }else{
  1003.                     $expr$forCondition.'intval('.$expr.')';
  1004.                 }
  1005.                 break;
  1006.             case 'double':
  1007.             case 'float':
  1008.             case 'numeric':
  1009.             case 'decimal':
  1010.                 if($checknull){
  1011.                     $expr='('.$expr.' === null ? \''.$opnull.'NULL\' : '.$forCondition.'jDb::floatToStr('.$expr.'))';
  1012.                 }else{
  1013.                     $expr=$forCondition.'jDb::floatToStr('.$expr.')';
  1014.                 }
  1015.                 break;
  1016.             case 'boolean':
  1017.                 if($checknull){
  1018.                     $expr'('.$expr.' === null ? \''.$opnull.'NULL\' : '.$forCondition.'$this->_prepareValue('.$expr.', "boolean", true))';
  1019.                 }else{
  1020.                     $expr$forCondition.'$this->_prepareValue('.$expr.', "boolean", true)';
  1021.                 }
  1022.                 break;
  1023.             default:
  1024.                 if ($type=='varbinary' || $type=='binary')
  1025.                     $qparam ',true';
  1026.                 else
  1027.                     $qparam '';
  1028.  
  1029.                 if ($checknull{
  1030.                    $expr '('.$expr.' === null ? \''.$opnull.'NULL\' : '.$forCondition.'$this->_conn->quote2('.$expr.',false'.$qparam.'))';
  1031.                 }
  1032.                 else {
  1033.                    $expr $forCondition.'$this->_conn->quote'.($qparam?'2('.$expr.',true,true)':'('.$expr.')');
  1034.                 }
  1035.         }
  1036.         return $expr;
  1037.     }
  1038.  
  1039.     protected function _preparePHPCallbackExpr($field){
  1040.         $type strtolower($field->unifiedType);
  1041.         // TODO PHP53: generate a closure instead of create_function
  1042.         switch($type){
  1043.             case 'integer':
  1044.                 return 'create_function(\'$__e\',\'return intval($__e);\')';
  1045.             case 'double':
  1046.             case 'float':
  1047.             case 'numeric':
  1048.             case 'decimal':
  1049.                 return 'create_function(\'$__e\',\'return jDb::floatToStr($__e);\')';
  1050.             case 'boolean':
  1051.                 return 'array($this, \'_callbackBool\')';
  1052.             default:
  1053.                 if ($type=='varbinary' || $type=='binary')
  1054.                     return 'array($this, \'_callbackQuoteBin\')';
  1055.                 else
  1056.                     return 'array($this, \'_callbackQuote\')';
  1057.         }
  1058.     }
  1059.  
  1060.     protected function _encloseName($name){
  1061.         return $this->tools->encloseName($name);
  1062.     }
  1063.  
  1064.     protected function buildUpdateAutoIncrementPK($pkai{
  1065.         return '       $record->'.$pkai->name.'= $this->_conn->lastInsertId();';
  1066.     }
  1067. }

Documentation generated on Mon, 19 Sep 2011 14:12:15 +0200 by phpDocumentor 1.4.3