PHP Doctrine_Table::getColumnName方法代码示例

 /**
  * Return all columns as an array
  *
  * Array must contain 'type' for column type, 'notnull' true/false
  * for the column's nullability, and 'values' for enum values, 'primary'
  * true/false for primary key. Key = column's name
  *
  * @return array
  */
 public function getColumns()
 {
     $foreignKeyColumns = array();
     foreach ($this->_table->getRelations() as $alias => $relation) {
         $localColumn = strtolower($relation['local']);
         $foreignKeyColumns[$localColumn] = $relation['class'];
     }
     $data = $this->_table->getColumns();
     $cols = array();
     foreach ($data as $name => $def) {
         $isPrimary = isset($def['primary']) ? $def['primary'] : false;
         $isForeignKey = isset($foreignKeyColumns[strtolower($name)]);
         $columnName = $this->_table->getColumnName($name);
         $fieldName = $this->_table->getFieldName($columnName);
         $cols[$fieldName] = array('type' => $def['type'], 'notnull' => isset($def['notnull']) ? $def['notnull'] : false, 'values' => isset($def['values']) ? $def['values'] : array(), 'primary' => $isPrimary, 'foreignKey' => $isForeignKey, 'class' => $isForeignKey ? $foreignKeyColumns[strtolower($name)] : null);
     }
     return $cols;
 }

 /**
  * Inserts a table row with specified data.
  *
  * @param Doctrine_Table $table     The table to insert data into.
  * @param array $values             An associative array containing column-value pairs.
  *                                  Values can be strings or Doctrine_Expression instances.
  * @return integer                  the number of affected rows. Boolean false if empty value array was given,
  */
 public function insert(Doctrine_Table $table, array $fields)
 {
     $tableName = $table->getTableName();
     // column names are specified as array keys
     $cols = array();
     // the query VALUES will contain either expresions (eg 'NOW()') or ?
     $a = array();
     foreach ($fields as $fieldName => $value) {
         $cols[] = $this->quoteIdentifier($table->getColumnName($fieldName));
         if ($value instanceof Doctrine_Expression) {
             $a[] = $value->getSql();
             unset($fields[$fieldName]);
         } else {
             $a[] = '?';
         }
     }
     // build the statement
     $query = 'INSERT INTO ' . $this->quoteIdentifier($tableName) . ' (' . implode(', ', $cols) . ')' . ' VALUES (' . implode(', ', $a) . ')';
     return $this->exec($query, array_values($fields));
 }

 /**
  * Inserts a table row with specified data.
  *
  * @param Doctrine_Table $table     The table to insert data into.
  * @param array $values             An associative array containing column-value pairs.
  *                                  Values can be strings or Doctrine_Expression instances.
  * @return integer                  the number of affected rows. Boolean false if empty value array was given,
  */
 public function insert(Doctrine_Table $table, array $fields)
 {
     $tableName = $table->getTableName();
     // column names are specified as array keys
     $cols = array();
     // the query VALUES will contain either expresions (eg 'NOW()') or ?
     $a = array();
     foreach ($fields as $fieldName => $value) {
         if ($table->isIdentifier($fieldName) && $table->isIdentifierAutoincrement() && $value == null) {
             // Autoincrement fields should not be added to the insert statement
             // if their value is null
             unset($fields[$fieldName]);
             continue;
         }
         $cols[] = $this->quoteIdentifier($table->getColumnName($fieldName));
         if ($value instanceof Doctrine_Expression) {
             $a[] = $value->getSql();
             unset($fields[$fieldName]);
         } else {
             $a[] = '?';
         }
     }
     if (count($fields) == 0) {
         // Real fix #1786 and #2327 (default values when table is just 'id' as PK)
         return $this->exec('INSERT INTO ' . $this->quoteIdentifier($tableName) . ' ' . ' VALUES (DEFAULT)');
     }
     // build the statement
     $query = 'INSERT INTO ' . $this->quoteIdentifier($tableName) . ' (' . implode(', ', $cols) . ')' . ' VALUES (' . implode(', ', $a) . ')';
     return $this->exec($query, array_values($fields));
 }

 /**
  * getIdentifiers
  * gives a list of identifiers from given table
  *
  * the identifiers are in format:
  * [componentName].[identifier]
  *
  * @param Doctrine_Table $table     table object to retrieve identifiers from
  */
 public function getIdentifiers(Doctrine_Table $table)
 {
     $componentNameToLower = strtolower($table->getComponentName());
     if (is_array($table->getIdentifier())) {
         $columns = array();
         foreach ((array) $table->getIdentifierColumnNames() as $identColName) {
             $columns[] = $componentNameToLower . '_' . $identColName;
         }
     } else {
         $columns = $componentNameToLower . '_' . $table->getColumnName($table->getIdentifier());
     }
     return $columns;
 }

    /**
     * Execute a SQL REPLACE query. A REPLACE query is identical to a INSERT
     * query, except that if there is already a row in the table with the same
     * key field values, the REPLACE query just updates its values instead of
     * inserting a new row.
     *
     * The REPLACE type of query does not make part of the SQL standards. Since
     * practically only MySQL implements it natively, this type of query is
     * emulated through this method for other DBMS using standard types of
     * queries inside a transaction to assure the atomicity of the operation.
     *
     * @access public
     *
     * @param string $table name of the table on which the REPLACE query will
     *  be executed.
     * @param array $fields associative array that describes the fields and the
     *  values that will be inserted or updated in the specified table. The
     *  indexes of the array are the names of all the fields of the table. The
     *  values of the array are also associative arrays that describe the
     *  values and other properties of the table fields.
     *
     *  Here follows a list of field properties that need to be specified:
     *
     *    value:
     *          Value to be assigned to the specified field. This value may be
     *          of specified in database independent type format as this
     *          function can perform the necessary datatype conversions.
     *
     *    Default:
     *          this property is required unless the Null property
     *          is set to 1.
     *
     *    type
     *          Name of the type of the field. Currently, all types Metabase
     *          are supported except for clob and blob.
     *
     *    Default: no type conversion
     *
     *    null
     *          Boolean property that indicates that the value for this field
     *          should be set to null.
     *
     *          The default value for fields missing in INSERT queries may be
     *          specified the definition of a table. Often, the default value
     *          is already null, but since the REPLACE may be emulated using
     *          an UPDATE query, make sure that all fields of the table are
     *          listed in this function argument array.
     *
     *    Default: 0
     *
     *    key
     *          Boolean property that indicates that this field should be
     *          handled as a primary key or at least as part of the compound
     *          unique index of the table that will determine the row that will
     *          updated if it exists or inserted a new row otherwise.
     *
     *          This function will fail if no key field is specified or if the
     *          value of a key field is set to null because fields that are
     *          part of unique index they may not be null.
     *
     *    Default: 0
     *
     * @return integer      the number of affected rows
     */
    public function replace(Doctrine_Table $table, array $fields, array $keys)
    {
        if (empty($keys)) {
            throw new Doctrine_Connection_Exception('Not specified which fields are keys');
        }

        $columns = array();
        $values = array();
        $params = array();
        foreach ($fields as $fieldName => $value) {
            $columns[] = $table->getColumnName($fieldName);
            $values[] = '?';
            $params[] = $value;
        }

        $query = 'REPLACE INTO ' . $this->quoteIdentifier($table->getTableName()) . ' (' . implode(',', $columns) . ') VALUES (' . implode(',', $values) . ')';

        return $this->exec($query, $params);
    }

 /**
  * 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;
 }

 /**
  * Get the name of the column
  *
  * @return string $name
  */
 public function getName()
 {
     return $this->table->getColumnName($this->name);
 }

 /**
  * Execute a SQL REPLACE query. A REPLACE query is identical to a INSERT
  * query, except that if there is already a row in the table with the same
  * key field values, the REPLACE query just updates its values instead of
  * inserting a new row.
  *
  * The REPLACE type of query does not make part of the SQL standards. Since
  * practically only MySQL implements it natively, this type of query is
  * emulated through this method for other DBMS using standard types of
  * queries inside a transaction to assure the atomicity of the operation.
  *
  * @access public
  *
  * @param string $table name of the table on which the REPLACE query will
  *  be executed.
  * @param array $fields associative array that describes the fields and the
  *  values that will be inserted or updated in the specified table. The
  *  indexes of the array are the names of all the fields of the table. The
  *  values of the array are also associative arrays that describe the
  *  values and other properties of the table fields.
  *
  *  Here follows a list of field properties that need to be specified:
  *
  *    value:
  *          Value to be assigned to the specified field. This value may be
  *          of specified in database independent type format as this
  *          function can perform the necessary datatype conversions.
  *
  *    Default:
  *          this property is required unless the Null property
  *          is set to 1.
  *
  *    type
  *          Name of the type of the field. Currently, all types Metabase
  *          are supported except for clob and blob.
  *
  *    Default: no type conversion
  *
  *    null
  *          Boolean property that indicates that the value for this field
  *          should be set to null.
  *
  *          The default value for fields missing in INSERT queries may be
  *          specified the definition of a table. Often, the default value
  *          is already null, but since the REPLACE may be emulated using
  *          an UPDATE query, make sure that all fields of the table are
  *          listed in this function argument array.
  *
  *    Default: 0
  *
  *    key
  *          Boolean property that indicates that this field should be
  *          handled as a primary key or at least as part of the compound
  *          unique index of the table that will determine the row that will
  *          updated if it exists or inserted a new row otherwise.
  *
  *          This function will fail if no key field is specified or if the
  *          value of a key field is set to null because fields that are
  *          part of unique index they may not be null.
  *
  *    Default: 0
  *
  * @return integer      the number of affected rows
  */
 public function replace(Doctrine_Table $table, array $fields, array $keys)
 {
     $count = count($fields);
     $query = $values = '';
     $keys = $colnum = 0;
     for (reset($fields); $colnum < $count; next($fields), $colnum++) {
         $name = key($fields);
         if ($colnum > 0) {
             $query .= ',';
             $values .= ',';
         }
         $query .= $table->getColumnName($name);
         if (isset($fields[$name]['null']) && $fields[$name]['null']) {
             $value = 'NULL';
         } else {
             $type = isset($fields[$name]['type']) ? $fields[$name]['type'] : null;
             $value = $this->quote($fields[$name]['value'], $type);
         }
         $values .= $value;
         if (isset($fields[$name]['key']) && $fields[$name]['key']) {
             if ($value === 'NULL') {
                 throw new Doctrine_Connection_Mysql_Exception('key value ' . $name . ' may not be NULL');
             }
             $keys++;
         }
     }
     if ($keys == 0) {
         throw new Doctrine_Connection_Mysql_Exception('not specified which fields are keys');
     }
     $query = 'REPLACE INTO ' . $table->getTableName() . ' (' . $query . ') VALUES (' . $values . ')';
     return $this->exec($query);
 }