PHP fORM::scalarize方法代码示例

 /**
  * Creates the fDatabase::translatedQuery() update statement params
  *
  * @return array  The parameters for an fDatabase::translatedQuery() SQL update statement
  */
 protected function constructUpdateParams()
 {
     $class = get_class($this);
     $schema = fORMSchema::retrieve($class);
     $table = fORM::tablize($class);
     $column_info = $schema->getColumnInfo($table);
     $assignments = array();
     $params = array($table);
     foreach ($column_info as $column => $info) {
         if ($info['auto_increment'] && !fActiveRecord::changed($this->values, $this->old_values, $column) && count($column_info) > 1) {
             continue;
         }
         $assignments[] = '%r = ' . $info['placeholder'];
         $value = fORM::scalarize($class, $column, $this->values[$column]);
         if ($value === NULL && $info['not_null'] && $info['default'] !== NULL) {
             $value = $info['default'];
         }
         $params[] = $column;
         $params[] = $value;
     }
     $sql = 'UPDATE %r SET ' . join(', ', $assignments) . ' WHERE ';
     array_unshift($params, $sql);
     return fORMDatabase::addPrimaryKeyWhereParams($schema, $params, $table, $table, $this->values, $this->old_values);
 }

 /**
  * Stores a record in the database, whether existing or new
  * 
  * This method will start database and filesystem transactions if they have
  * not already been started.
  * 
  * @throws fValidationException  When ::validate() throws an exception
  * 
  * @return fActiveRecord  The record object, to allow for method chaining
  */
 public function store()
 {
     $class = get_class($this);
     if (fORM::getActiveRecordMethod($class, 'store')) {
         return $this->__call('store', array());
     }
     fORM::callHookCallbacks($this, 'pre::store()', $this->values, $this->old_values, $this->related_records, $this->cache);
     try {
         $table = fORM::tablize($class);
         $column_info = fORMSchema::retrieve()->getColumnInfo($table);
         // New auto-incrementing records require lots of special stuff, so we'll detect them here
         $new_autoincrementing_record = FALSE;
         if (!$this->exists()) {
             $pk_columns = fORMSchema::retrieve()->getKeys($table, 'primary');
             if (sizeof($pk_columns) == 1 && $column_info[$pk_columns[0]]['auto_increment'] && !$this->values[$pk_columns[0]]) {
                 $new_autoincrementing_record = TRUE;
                 $pk_column = $pk_columns[0];
             }
         }
         $inside_db_transaction = fORMDatabase::retrieve()->isInsideTransaction();
         if (!$inside_db_transaction) {
             fORMDatabase::retrieve()->translatedQuery('BEGIN');
         }
         fORM::callHookCallbacks($this, 'post-begin::store()', $this->values, $this->old_values, $this->related_records, $this->cache);
         $this->validate();
         fORM::callHookCallbacks($this, 'post-validate::store()', $this->values, $this->old_values, $this->related_records, $this->cache);
         // Storing main table
         $sql_values = array();
         foreach ($column_info as $column => $info) {
             $value = fORM::scalarize($class, $column, $this->values[$column]);
             $sql_values[$column] = fORMDatabase::escapeBySchema($table, $column, $value);
         }
         // Most databases don't like the auto incrementing primary key to be set to NULL
         if ($new_autoincrementing_record && $sql_values[$pk_column] == 'NULL') {
             unset($sql_values[$pk_column]);
         }
         if (!$this->exists()) {
             $sql = $this->constructInsertSQL($sql_values);
         } else {
             $sql = $this->constructUpdateSQL($sql_values);
         }
         $result = fORMDatabase::retrieve()->translatedQuery($sql);
         // If there is an auto-incrementing primary key, grab the value from the database
         if ($new_autoincrementing_record) {
             $this->set($pk_column, $result->getAutoIncrementedValue());
         }
         // Storing *-to-many relationships
         fORMRelated::store($class, $this->values, $this->related_records);
         fORM::callHookCallbacks($this, 'pre-commit::store()', $this->values, $this->old_values, $this->related_records, $this->cache);
         if (!$inside_db_transaction) {
             fORMDatabase::retrieve()->translatedQuery('COMMIT');
         }
         fORM::callHookCallbacks($this, 'post-commit::store()', $this->values, $this->old_values, $this->related_records, $this->cache);
     } catch (fException $e) {
         if (!$inside_db_transaction) {
             fORMDatabase::retrieve()->translatedQuery('ROLLBACK');
         }
         fORM::callHookCallbacks($this, 'post-rollback::store()', $this->values, $this->old_values, $this->related_records, $this->cache);
         if ($new_autoincrementing_record && self::hasOld($this->old_values, $pk_column)) {
             $this->values[$pk_column] = self::retrieveOld($this->old_values, $pk_column);
             unset($this->old_values[$pk_column]);
         }
         throw $e;
     }
     fORM::callHookCallbacks($this, 'post::store()', $this->values, $this->old_values, $this->related_records, $this->cache);
     $was_new = !$this->exists();
     // If we got here we succefully stored, so update old values to make exists() work
     foreach ($this->values as $column => $value) {
         $this->old_values[$column] = array($value);
     }
     // If the object was just inserted into the database, save it to the identity map
     if ($was_new) {
         $hash = self::hash($this->values, $class);
         if (!isset(self::$identity_map[$class])) {
             self::$identity_map[$class] = array();
         }
         self::$identity_map[$class][$hash] = $this;
     }
     return $this;
 }

 /**
  * Validates values for an fActiveRecord object against the database schema and any additional rules that have been added
  *
  * @internal
  *
  * @param  fActiveRecord  $object      The instance of the class to validate
  * @param  array          $values      The values to validate
  * @param  array          $old_values  The old values for the record
  * @return array  An array of messages
  */
 public static function validate($object, $values, $old_values)
 {
     $class = get_class($object);
     $table = fORM::tablize($class);
     $schema = fORMSchema::retrieve($class);
     self::initializeRuleArrays($class);
     $validation_messages = array();
     // Convert objects into values for validation
     foreach ($values as $column => $value) {
         $values[$column] = fORM::scalarize($class, $column, $value);
     }
     foreach ($old_values as $column => $column_values) {
         foreach ($column_values as $key => $value) {
             $old_values[$column][$key] = fORM::scalarize($class, $column, $value);
         }
     }
     $message_array = self::checkPrimaryKeys($schema, $object, $values, $old_values);
     if ($message_array) {
         $validation_messages[key($message_array)] = current($message_array);
     }
     $column_info = $schema->getColumnInfo($table);
     foreach ($column_info as $column => $info) {
         $message = self::checkAgainstSchema($schema, $object, $column, $values, $old_values);
         if ($message) {
             $validation_messages[$column] = $message;
         }
     }
     $messages = self::checkUniqueConstraints($schema, $object, $values, $old_values);
     if ($messages) {
         $validation_messages = array_merge($validation_messages, $messages);
     }
     foreach (self::$valid_values_rules[$class] as $column => $valid_values) {
         $message = self::checkValidValuesRule($class, $values, $column, $valid_values);
         if ($message) {
             $validation_messages[$column] = $message;
         }
     }
     foreach (self::$regex_rules[$class] as $column => $rule) {
         $message = self::checkRegexRule($class, $values, $column, $rule['regex'], $rule['message']);
         if ($message) {
             $validation_messages[$column] = $message;
         }
     }
     foreach (self::$conditional_rules[$class] as $rule) {
         $messages = self::checkConditionalRule($schema, $class, $values, $rule['main_columns'], $rule['conditional_values'], $rule['conditional_columns']);
         if ($messages) {
             $validation_messages = array_merge($validation_messages, $messages);
         }
     }
     foreach (self::$one_or_more_rules[$class] as $rule) {
         $message = self::checkOneOrMoreRule($schema, $class, $values, $rule['columns']);
         if ($message) {
             $validation_messages[join(',', $rule['columns'])] = $message;
         }
     }
     foreach (self::$only_one_rules[$class] as $rule) {
         $message = self::checkOnlyOneRule($schema, $class, $values, $rule['columns']);
         if ($message) {
             $validation_messages[join(',', $rule['columns'])] = $message;
         }
     }
     return $validation_messages;
 }

 /**
  * Escapes a value for a DB call based on database schema
  * 
  * @internal
  * 
  * @param  string $table                The table to store the value
  * @param  string $column               The column to store the value in, may also be shorthand column name like `table.column` or `table=>related_table.column` or concatenated column names like `table.column||table.other_column`
  * @param  mixed  $value                The value to escape
  * @param  string $comparison_operator  Optional: should be `'='`, `'!='`, `'!'`, `'<>'`, `'<'`, `'<='`, `'>'`, `'>='`, `'IN'`, `'NOT IN'`
  * @return string  The SQL-ready representation of the value
  */
 public static function escapeBySchema($table, $column, $value, $comparison_operator = NULL)
 {
     // handle concatenated column names
     if (preg_match('#\\|\\|#', $column)) {
         if (is_object($value) && is_callable(array($value, '__toString'))) {
             $value = $value->__toString();
         } elseif (is_object($value)) {
             $value = (string) $value;
         }
         $column_info = array('not_null' => FALSE, 'default' => NULL, 'type' => 'varchar');
     } else {
         // Handle shorthand column names like table.column and table=>related_table.column
         if (preg_match('#(\\w+)(?:\\{\\w+\\})?\\.(\\w+)$#D', $column, $match)) {
             $table = $match[1];
             $column = $match[2];
         }
         $column_info = fORMSchema::retrieve()->getColumnInfo($table, $column);
         // Some of the tables being escaped for are linking tables that might break with classize()
         if (is_object($value)) {
             $class = fORM::classize($table);
             $value = fORM::scalarize($class, $column, $value);
         }
     }
     if ($comparison_operator !== NULL) {
         $comparison_operator = strtr($comparison_operator, array('!' => '<>', '!=' => '<>'));
     }
     $valid_comparison_operators = array('=', '!=', '!', '<>', '<=', '<', '>=', '>', 'IN', 'NOT IN');
     if ($comparison_operator !== NULL && !in_array(strtoupper($comparison_operator), $valid_comparison_operators)) {
         throw new fProgrammerException('The comparison operator specified, %1$s, is invalid. Must be one of: %2$s.', $comparison_operator, join(', ', $valid_comparison_operators));
     }
     $co = is_null($comparison_operator) ? '' : ' ' . strtoupper($comparison_operator) . ' ';
     if ($column_info['not_null'] && $value === NULL && $column_info['default'] !== NULL) {
         $value = $column_info['default'];
     }
     if (is_null($value)) {
         $prepared_value = 'NULL';
     } else {
         $prepared_value = self::retrieve()->escape($column_info['type'], $value);
     }
     if ($prepared_value == 'NULL') {
         if ($co) {
             if (in_array(trim($co), array('=', 'IN'))) {
                 $co = ' IS ';
             } elseif (in_array(trim($co), array('<>', 'NOT IN'))) {
                 $co = ' IS NOT ';
             }
         }
     }
     return $co . $prepared_value;
 }