PHP Doctrine_Table::hasColumn方法代码示例

 /**
  * Generates foreign keys for the plugin table based on the owner table.
  * These columns are automatically added to the generated model so we can
  * create foreign keys back to the table object that owns the plugin.
  *
  * @param Doctrine_Table $table     the table object that owns the plugin
  * @return array                    an array of foreign key definitions
  */
 public function buildForeignKeys(Doctrine_Table $table)
 {
     $fk = array();
     foreach ((array) $table->getIdentifier() as $field) {
         $def = $table->getDefinitionOf($field);
         unset($def['autoincrement']);
         unset($def['sequence']);
         unset($def['primary']);
         $col = $table->hasColumn($field) ? $field : $table->getColumnName($field) . ' as ' . $field;
         $def['primary'] = true;
         $fk[$col] = $def;
     }
     return $fk;
 }

 /**
  * guessColumns
  *
  * @param array $classes                    an array of class names
  * @param Doctrine_Table $foreignTable      foreign table object
  * @return array                            an array of column names
  */
 public function guessColumns(array $classes, Doctrine_Table $foreignTable)
 {
     $conn = $this->_table->getConnection();
     foreach ($classes as $class) {
         try {
             $table = $conn->getTable($class);
         } catch (Doctrine_Table_Exception $e) {
             continue;
         }
         $columns = $this->getIdentifiers($table);
         $found = true;
         foreach ((array) $columns as $column) {
             if (!$foreignTable->hasColumn($column)) {
                 $found = false;
                 break;
             }
         }
         if ($found) {
             break;
         }
     }
     if (!$found) {
         throw new Doctrine_Relation_Exception("Couldn't find columns.");
     }
     return $columns;
 }

 /**
  * Helper function to run doctrine level validation on data.  Returns an
  * array('colname' => 'error message').  Only 1 validation error message
  * will be returned per column.
  *
  * @param Doctrine_Table $table
  * @param array   $data
  * @return array
  */
 protected function do_validate($table, $data)
 {
     $errs = array();
     if ($data) {
         // check for static "remote_validate" function on table
         $cls = $table->getClassnameToReturn();
         if (method_exists($cls, self::$VALIDATE_METHOD_NAME)) {
             $myerrs = call_user_func(array($cls, self::$VALIDATE_METHOD_NAME), $data);
             if (count($myerrs)) {
                 return $myerrs;
                 // return early
             }
         }
         // normal doctrine validation
         foreach ($data as $column => $value) {
             if (!$table->hasColumn($column)) {
                 $errs[$column] = 'Unknown column';
             } else {
                 $col_err = false;
                 $stack = $table->validateField($column, $value);
                 // get the first problem (if any)
                 if (isset($stack[$column]) && count($stack[$column])) {
                     $col_err = $stack[$column][0];
                 }
                 $stack->clear();
                 // check extra unique columns, which aren't unique in the
                 // models, but should be validated as such
                 if (!$col_err && in_array($column, $this->enforce_uniques)) {
                     $found = $table->findOneBy($column, $value);
                     if ($found) {
                         $col_err = 'unique';
                     }
                 }
                 // set error for this column
                 if ($col_err) {
                     $errs[$column] = $col_err;
                 }
             }
         }
     }
     return $errs;
 }