PHP DB::require_table方法代码示例

 /**
  * Check the database schema and update it as necessary.
  *
  * @uses DataExtension->augmentDatabase()
  */
 public function requireTable()
 {
     // Only build the table if we've actually got fields
     $fields = self::database_fields($this->class);
     $table = static::getSchema()->tableName($this->class);
     $extensions = self::database_extensions($this->class);
     $indexes = $this->databaseIndexes();
     // Validate relationship configuration
     $this->validateModelDefinitions();
     if ($fields) {
         $hasAutoIncPK = get_parent_class($this) === 'SilverStripe\\ORM\\DataObject';
         DB::require_table($table, $fields, $indexes, $hasAutoIncPK, $this->stat('create_table_options'), $extensions);
     } else {
         DB::dont_require_table($table);
     }
     // Build any child tables for many_many items
     if ($manyMany = $this->uninherited('many_many')) {
         $extras = $this->uninherited('many_many_extraFields');
         foreach ($manyMany as $relationship => $childClass) {
             // Build field list
             if ($this->class === $childClass) {
                 $childField = "ChildID";
             } else {
                 $childTable = $this->getSchema()->tableName($childClass);
                 $childField = "{$childTable}ID";
             }
             $manymanyFields = array("{$table}ID" => "Int", $childField => "Int");
             if (isset($extras[$relationship])) {
                 $manymanyFields = array_merge($manymanyFields, $extras[$relationship]);
             }
             // Build index list
             $manymanyIndexes = array("{$table}ID" => true, $childField => true);
             $manyManyTable = "{$table}_{$relationship}";
             DB::require_table($manyManyTable, $manymanyFields, $manymanyIndexes, true, null, $extensions);
         }
     }
     // Let any extentions make their own database fields
     $this->extend('augmentDatabase', $dummy);
 }

 /**
  * Check the database schema and update it as necessary.
  *
  * @uses DataExtension->augmentDatabase()
  */
 public function requireTable()
 {
     // Only build the table if we've actually got fields
     $schema = static::getSchema();
     $fields = $schema->databaseFields(static::class, false);
     $table = $schema->tableName(static::class);
     $extensions = self::database_extensions(static::class);
     $indexes = $this->databaseIndexes();
     if ($fields) {
         $hasAutoIncPK = get_parent_class($this) === self::class;
         DB::require_table($table, $fields, $indexes, $hasAutoIncPK, $this->stat('create_table_options'), $extensions);
     } else {
         DB::dont_require_table($table);
     }
     // Build any child tables for many_many items
     if ($manyMany = $this->uninherited('many_many')) {
         $extras = $this->uninherited('many_many_extraFields');
         foreach ($manyMany as $component => $spec) {
             // Get many_many spec
             $manyManyComponent = $schema->manyManyComponent(static::class, $component);
             list($relationClass, $parentClass, $componentClass, $parentField, $childField, $tableOrClass) = $manyManyComponent;
             // Skip if backed by actual class
             if (class_exists($tableOrClass)) {
                 continue;
             }
             // Build fields
             $manymanyFields = array($parentField => "Int", $childField => "Int");
             if (isset($extras[$component])) {
                 $manymanyFields = array_merge($manymanyFields, $extras[$component]);
             }
             // Build index list
             $manymanyIndexes = array($parentField => true, $childField => true);
             DB::require_table($tableOrClass, $manymanyFields, $manymanyIndexes, true, null, $extensions);
         }
     }
     // Let any extentions make their own database fields
     $this->extend('augmentDatabase', $dummy);
 }

 public function augmentDatabase()
 {
     $owner = $this->owner;
     $class = get_class($owner);
     $baseTable = $this->baseTable();
     $classTable = $owner->getSchema()->tableName($owner);
     $isRootClass = $class === $owner->baseClass();
     // Build a list of suffixes whose tables need versioning
     $allSuffixes = array();
     $versionableExtensions = $owner->config()->versionableExtensions;
     if (count($versionableExtensions)) {
         foreach ($versionableExtensions as $versionableExtension => $suffixes) {
             if ($owner->hasExtension($versionableExtension)) {
                 foreach ((array) $suffixes as $suffix) {
                     $allSuffixes[$suffix] = $versionableExtension;
                 }
             }
         }
     }
     // Add the default table with an empty suffix to the list (table name = class name)
     $allSuffixes[''] = null;
     foreach ($allSuffixes as $suffix => $extension) {
         // Check tables for this build
         if ($suffix) {
             $suffixBaseTable = "{$baseTable}_{$suffix}";
             $suffixTable = "{$classTable}_{$suffix}";
         } else {
             $suffixBaseTable = $baseTable;
             $suffixTable = $classTable;
         }
         $fields = DataObject::database_fields($owner->class);
         unset($fields['ID']);
         if ($fields) {
             $options = Config::inst()->get($owner->class, 'create_table_options', Config::FIRST_SET);
             $indexes = $owner->databaseIndexes();
             $extensionClass = $allSuffixes[$suffix];
             if ($suffix && ($extension = $owner->getExtensionInstance($extensionClass))) {
                 if (!$extension instanceof VersionableExtension) {
                     throw new LogicException("Extension {$extensionClass} must implement VersionableExtension");
                 }
                 // Allow versionable extension to customise table fields and indexes
                 $extension->setOwner($owner);
                 if ($extension->isVersionedTable($suffixTable)) {
                     $extension->updateVersionableFields($suffix, $fields, $indexes);
                 }
                 $extension->clearOwner();
             }
             // Build _Live table
             if ($this->hasStages()) {
                 $liveTable = $this->stageTable($suffixTable, static::LIVE);
                 DB::require_table($liveTable, $fields, $indexes, false, $options);
             }
             // Build _versions table
             //Unique indexes will not work on versioned tables, so we'll convert them to standard indexes:
             $nonUniqueIndexes = $this->uniqueToIndex($indexes);
             if ($isRootClass) {
                 // Create table for all versions
                 $versionFields = array_merge(Config::inst()->get('SilverStripe\\ORM\\Versioning\\Versioned', 'db_for_versions_table'), (array) $fields);
                 $versionIndexes = array_merge(Config::inst()->get('SilverStripe\\ORM\\Versioning\\Versioned', 'indexes_for_versions_table'), (array) $nonUniqueIndexes);
             } else {
                 // Create fields for any tables of subclasses
                 $versionFields = array_merge(array("RecordID" => "Int", "Version" => "Int"), (array) $fields);
                 $versionIndexes = array_merge(array('RecordID_Version' => array('type' => 'unique', 'value' => '"RecordID","Version"'), 'RecordID' => true, 'Version' => true), (array) $nonUniqueIndexes);
             }
             // Cleanup any orphans
             $this->cleanupVersionedOrphans("{$suffixBaseTable}_versions", "{$suffixTable}_versions");
             // Build versions table
             DB::require_table("{$suffixTable}_versions", $versionFields, $versionIndexes, true, $options);
         } else {
             DB::dont_require_table("{$suffixTable}_versions");
             if ($this->hasStages()) {
                 $liveTable = $this->stageTable($suffixTable, static::LIVE);
                 DB::dont_require_table($liveTable);
             }
         }
     }
 }