PHP Column::setType方法代码示例

 protected function populateFromOptions($options)
 {
     foreach ($options as $name => $attrs) {
         $column = new Column($name);
         if (isset($attrs['field'])) {
             $column->setFieldName($attrs['field']);
         }
         if (isset($attrs['type'])) {
             $column->setType($attrs['type']);
         }
         if (isset($attrs['sortable'])) {
             $column->setSortable($attrs['sortable']);
         }
         if (isset($attrs['label'])) {
             $column->setLabel($attrs['label']);
         }
         if (isset($attrs['format'])) {
             $column->setFormat($attrs['format']);
         }
         if (isset($attrs['format_function'])) {
             $column->setFormatFunction($attrs['format_function']);
         }
         if (isset($attrs['template'])) {
             $column->setTemplate($attrs['template']);
         }
         if (isset($attrs['boolean_actions'])) {
             $column->setBooleanActions($attrs['boolean_actions']);
         }
         if (isset($attrs['get_methods'])) {
             $column->setMethods($attrs['get_methods']);
         }
         $this->add($column);
     }
 }

 public function createEnumColumn($defaultValues, $defaultValue)
 {
     $column = new Column();
     $column->setType(PropelTypes::ENUM);
     $column->setValueSet($defaultValues);
     $column->setDefaultValue($defaultValue);
     return $column;
 }

 /**
  * Constructs an instance from a list of column headers as returned by the
  * Google Analytics API.
  *
  * @param array $headers
  * @param Google\Analytics\API $api
  */
 public function __construct(array $headers, API $api)
 {
     $headerCount = count($headers);
     for ($i = 0; $i < $headerCount; $i++) {
         self::_validateHeader($headers[$i]);
         try {
             $column = $api->getColumn($headers[$i]['name']);
         } catch (InvalidArgumentException $e) {
             /* I don't expect this to happen but in case it does, we can
             			create a representation of the column by building it on the
             			fly, though it will be missing most of the available
             			properties. */
             $column = new Column();
             $column->setID(API::addPrefix($headers[$i]['name']));
             $column->setType($headers[$i]['columnType']);
             $column->setDataType($headers[$i]['dataType']);
         }
         $this->_columns[] = $column;
         $this->_columnIndicesByName[$column->getName()] = $i;
     }
 }

 /**
  * Creates the column from a given array
  *
  * @param array $columns
  */
 public function setColumns($columns)
 {
     if (false == is_array($columns)) {
         return;
     }
     foreach ($columns as $name => $options) {
         $column = new Column();
         $type = $this->getOptionByKey("type", $options);
         $length = $this->getOptionByKey("length", $options);
         $notNull = $this->getOptionByKey("notNull", $options);
         $autoIncrement = $this->getOptionByKey("autoIncrement", $options);
         $index = $this->getOptionByKey("index", $options);
         $collate = $this->getOptionByKey("collate", $options);
         $column->setName($name);
         // Set all options if set
         if (false != $type) {
             $column->setType($type);
         }
         if (false != $length) {
             $column->setLength($length);
         }
         if (false != $notNull) {
             $column->setNotNull($notNull);
         }
         if (false != $autoIncrement) {
             $column->setAutoIncrement($autoIncrement);
         }
         if (false != $index) {
             $column->setIndex($index);
         }
         if (false != $collate) {
             $column->setCollate($collate);
         }
         // Add column
         $this->columns[] = $column;
     }
 }

 /**
  * Populates the properties that store cached dimensions and metrics,
  * either from the database or from the API directly, depending on when
  * the data that we have was last fetched.
  */
 private function _refreshColumnMetadata()
 {
     /* If we're not using a database, the best we can do is to cache the
        column metadata for the duration of this process' existence. */
     if (self::$_dbConn) {
         try {
             $lastFetchData = self::_getLastFetchData('google_analytics_api_columns');
             if ($lastFetchData) {
                 $fetchDate = (int) $lastFetchData['fetch_date'];
                 $etag = $lastFetchData['etag'];
             } else {
                 $fetchDate = null;
                 $etag = null;
             }
             $columns = null;
             $newETag = null;
             if ($this->_bypassColumnCache || !$fetchDate || $fetchDate <= time() - GOOGLE_ANALYTICS_API_METADATA_CACHE_DURATION) {
                 $this->_bypassColumnCache = false;
                 $request = new APIRequest('metadata/ga/columns');
                 if ($etag) {
                     $request->setHeader('If-None-Match: ' . $etag);
                 }
                 $columns = $this->_makeRequest($request);
                 if ($columns) {
                     $stmt = self::$_DB_STATEMENTS['google_analytics_api_columns']['insert'];
                     foreach ($columns as $column) {
                         $stmt->bindValue(':name', $column->getName(), \PDO::PARAM_STR);
                         $stmt->bindValue(':type', $column->getType(), \PDO::PARAM_STR);
                         $stmt->bindValue(':data_type', $column->getDataType(), \PDO::PARAM_STR);
                         $stmt->bindValue(':replaced_by', $column->getReplacementColumn(), \PDO::PARAM_STR);
                         $stmt->bindValue(':group', $column->getGroup(), \PDO::PARAM_STR);
                         $stmt->bindValue(':ui_name', $column->getUIName(), \PDO::PARAM_STR);
                         $stmt->bindValue(':description', $column->getDescription(), \PDO::PARAM_STR);
                         $stmt->bindValue(':calculation', $column->getCalculation(), \PDO::PARAM_STR);
                         $stmt->bindValue(':min_template_index', $column->getMinTemplateIndex(), \PDO::PARAM_INT);
                         $stmt->bindValue(':max_template_index', $column->getMaxTemplateIndex(), \PDO::PARAM_INT);
                         $stmt->bindValue(':min_template_index_premium', $column->getPremiumMinTemplateIndex(), \PDO::PARAM_INT);
                         $stmt->bindValue(':max_template_index_premium', $column->getPremiumMaxTemplateIndex(), \PDO::PARAM_INT);
                         $stmt->bindValue(':allowed_in_segments', $column->isAllowedInSegments(), \PDO::PARAM_INT);
                         $stmt->bindValue(':deprecated', $column->isDeprecated(), \PDO::PARAM_INT);
                         $stmt->execute();
                     }
                     $stmt = null;
                 }
                 if (array_key_exists('etag', $this->_responseParsed) && $this->_responseParsed['etag']) {
                     $newETag = $this->_responseParsed['etag'];
                 } else {
                     $responseHeader = $this->getResponseHeaderAsAssociativeArray();
                     if (array_key_exists('ETag', $responseHeader) && $responseHeader['ETag']) {
                         $newETag = $responseHeader['ETag'];
                     }
                 }
                 if ($newETag) {
                     self::_storeFetchData('google_analytics_api_columns', count($columns), $newETag);
                 }
             }
             if (!$columns) {
                 $columns = array();
                 $stmt = self::$_dbConn->query('SELECT * FROM google_analytics_api_columns');
                 $stmt->bindColumn('name', $name, \PDO::PARAM_STR);
                 $stmt->bindColumn('type', $type, \PDO::PARAM_STR);
                 $stmt->bindColumn('data_type', $dataType, \PDO::PARAM_STR);
                 $stmt->bindColumn('replaced_by', $replacement, \PDO::PARAM_STR);
                 $stmt->bindColumn('group', $group, \PDO::PARAM_STR);
                 $stmt->bindColumn('ui_name', $uiName, \PDO::PARAM_STR);
                 $stmt->bindColumn('description', $description, \PDO::PARAM_STR);
                 $stmt->bindColumn('calculation', $calculation, \PDO::PARAM_STR);
                 /* Null values get cast to zeros if I bind them as
                    integers, so we'll rely on the object's setter to take care
                    of the type casting. */
                 $stmt->bindColumn('min_template_index', $minTemplateIndex, \PDO::PARAM_STR);
                 $stmt->bindColumn('max_template_index', $maxTemplateIndex, \PDO::PARAM_STR);
                 $stmt->bindColumn('min_template_index_premium', $minTemplateIndexPremium, \PDO::PARAM_STR);
                 $stmt->bindColumn('max_template_index_premium', $maxTemplateIndexPremium, \PDO::PARAM_STR);
                 $stmt->bindColumn('allowed_in_segments', $allowedInSegments, \PDO::PARAM_BOOL);
                 $stmt->bindColumn('deprecated', $deprecated, \PDO::PARAM_BOOL);
                 while ($stmt->fetch(\PDO::FETCH_BOUND)) {
                     $column = new Column();
                     $column->setID('ga:' . $name);
                     $column->setReplacementColumn($replacement);
                     $column->setType($type);
                     $column->setDataType($dataType);
                     $column->setGroup($group);
                     $column->setUIName($uiName);
                     $column->setDescription($description);
                     $column->setCalculation($calculation);
                     if ($minTemplateIndex !== null) {
                         $column->setMinTemplateIndex($minTemplateIndex);
                     }
                     if ($maxTemplateIndex !== null) {
                         $column->setMaxTemplateIndex($maxTemplateIndex);
                     }
                     if ($minTemplateIndexPremium !== null) {
                         $column->setPremiumMinTemplateIndex($minTemplateIndexPremium);
                     }
//.........这里部分代码省略.........

 public function testColumnIsFKAndPK()
 {
     $column = new Column();
     $column->setName('id');
     $column->setPrimaryKey(true);
     $column->setAutoIncrement(true);
     $column->setType('integer');
     $table = new Table();
     $table->setCommonName('table_one');
     $table->addColumn($column);
     $db = new Database();
     $db->setName('MultipleTables');
     $db->addTable($table);
     $column = new Column();
     $column->setName('id');
     $column->setPrimaryKey(true);
     $column->setAutoIncrement(true);
     $column->setType('integer');
     $c2 = new Column();
     $c2->setPrimaryKey(true);
     $c2->setName('foreign_id');
     $c2->setType('integer');
     $table = new Table();
     $table->setCommonName('table_two');
     $table->addColumn($column);
     $table->addColumn($c2);
     $fk = new ForeignKey();
     $fk->setName('FK_1');
     $fk->addReference('foreign_id', 'id');
     $fk->setForeignTableCommonName('table_one');
     $table->addForeignKey($fk);
     $db->addTable($table);
     $expected = implode("\n", array('digraph G {', 'nodetable_one [label="{<table>table_one|<cols>id (integer) [PK]\\l}", shape=record];', 'nodetable_two [label="{<table>table_two|<cols>id (integer) [PK]\\lforeign_id (integer) [FK] [PK]\\l}", shape=record];', 'nodetable_two:cols -> nodetable_one:table [label="foreign_id=id"];', '}', ''));
     $this->assertEquals($expected, PropelDotGenerator::create($db));
 }

 public function testIsPhpArrayType()
 {
     $column = new Column();
     $this->assertFalse($column->isPhpArrayType());
     $column->setType(PropelTypes::PHP_ARRAY);
     $this->assertTrue($column->isPhpArrayType());
 }

 public function parseToDataObj()
 {
     $file_buffer = strtolower($this->_file_buffer);
     $file_buffer = str_replace("\n", ' ', $file_buffer);
     $file_buffer = str_replace("\t", ' ', $file_buffer);
     $file_buffer = preg_replace('/\\s+/si', " ", $file_buffer);
     $tables = explode('create table ', $file_buffer);
     // first ones throw away since all table definitions start with "create table" and this is exploding by it
     array_shift($tables);
     $db = array();
     // empty table array
     foreach ($tables as $table) {
         $TableDef = new Table();
         trim($table);
         preg_match('/`(.*?)`/', $table, $matches);
         $TableDef->name = trim($matches[1]);
         unset($matches);
         $column_pieces = explode('`' . $TableDef->name . '`', $table);
         $table_columns = $column_pieces[1];
         $columns = explode(',', $table_columns);
         foreach ($columns as $column) {
             $Col = new Column();
             $column = ' ' . trim($column) . ' ';
             // strip out things before a  ` unless it's UNIQUE or PRIMARY, and then parse those.
             if (stripos($column, 'unique') == 1) {
                 $keys = explode('`', $column);
                 foreach ($keys as $key) {
                     if (isset($TableDef->columns[$key])) {
                         $TableDef->columns[$key]->unique = true;
                         $TableDef->unique_keys[] = $key;
                     }
                 }
             } else {
                 if (stripos($column, 'primary') == 1) {
                     $keys = explode('`', $column);
                     foreach ($keys as $key) {
                         if (isset($TableDef->columns[$key])) {
                             $TableDef->columns[$key]->primary = true;
                             $TableDef->primary_keys[] = $key;
                         }
                     }
                 } else {
                     if (stripos($column, 'index') == 1) {
                         $keys = explode('`', $column);
                         foreach ($keys as $key) {
                             if (isset($TableDef->columns[$key])) {
                                 $TableDef->columns[$key]->index = true;
                                 $TableDef->index_keys[] = $key;
                             }
                         }
                     } else {
                         $original_column = $column;
                         // do appropriate stuff
                         $column = preg_replace('/.*?`(.*?)/', '`$1', $column, 1);
                         // thank you mr gregory
                         preg_match_all('/`([a-zA-Z0-9_]+)`[\\s]*([\\w]+)[\\s]*\\(*[\\s]*([0-9]*)[\\s]*\\)*[\\s]+([^,]+)./', $column, $matches);
                         if (!isset($matches[1][0])) {
                             print_r($original_column);
                             continue;
                         }
                         $Col->name = $matches[1][0];
                         $Col->setType($this->convertToStandardType($matches[2][0]));
                         $size_array = $this->convertToStandardSizeArray($matches[3][0]);
                         $Col->setSize($size_array[0], $size_array[1]);
                         $column = ' ' . trim($matches[4][0]) . ' ';
                         unset($matches);
                         if (substr($Col->name, -3) == '_id') {
                             $TableDef->possible_foreign_keys[] = $Col->name;
                         }
                         // match for binary, unsigned, or unsigned zerofill for attributes
                         if (stripos($column, 'unsigned zerofill')) {
                             $Col->setAttributes('unsigned zerofill');
                         } else {
                             if (stripos($column, '')) {
                                 $Col->setAttributes('unsigned');
                             } else {
                                 if (stripos($column, 'binary')) {
                                     $Col->setAttributes('binary');
                                 }
                             }
                         }
                         // match "null" or "not null" and define the nullable attribute
                         if (stripos($column, 'not null')) {
                             $Col->nullable = false;
                         } else {
                             $Col->nullable = true;
                         }
                         // match primary, unique, index, or fulltext for index
                         if (stripos($column, ' primary')) {
                             $Col->primary = true;
                             $TableDef->primary_keys[] = $Col->name;
                         } else {
                             if (stripos($column, ' unique')) {
                                 $Col->unique = true;
                                 $TableDef->unique_keys[] = $Col->name;
                             } else {
                                 if (stripos($column, ' index')) {
                                     $Col->index = true;
                                     $TableDef->index_keys[] = $Col->name;
                                 }
//.........这里部分代码省略.........