PHP Connection::getSchemaBuilder方法代码示例

 /**
  * Create a new FieldTypeSchema instance.
  *
  * @param FieldType  $fieldType
  * @param Repository $cache
  */
 public function __construct(FieldType $fieldType, Container $container, Repository $cache)
 {
     $this->cache = $cache;
     $this->container = $container;
     $this->fieldType = $fieldType;
     $this->connection = $container->make('db')->connection();
     $this->schema = $this->connection->getSchemaBuilder();
 }

 /**
  * {@inheritdoc}
  */
 public function version($id)
 {
     $schema = $this->connection->getSchemaBuilder();
     if (!$schema->hasTable($this->tableName)) {
         return null;
     }
     $version = $this->connection->table($this->tableName)->where('version', $id)->first();
     if ($version) {
         return (array) $version;
     }
     return null;
 }

 /**
  * Create Schema
  *
  * @return AdapterInterface
  */
 public function createSchema()
 {
     /* @var \Illuminate\Database\Schema\Blueprint $table */
     $this->adapter->getSchemaBuilder()->create($this->tableName, function ($table) {
         $table->string('version');
     });
 }

 /**
  * Retrieve the schema builder for the database connection. And set a custom blueprint resolver to return an
  * instance of the Culpa Blueprint class.
  *
  * @param Connection $connection
  * @return \Illuminate\Database\Schema\Builder
  */
 protected static function getSchemaBuilder(Connection $connection)
 {
     $schemaBuilder = $connection->getSchemaBuilder();
     $schemaBuilder->blueprintResolver(function ($table, $callback) {
         return new Blueprint($table, $callback);
     });
     return $schemaBuilder;
 }

 public function getSchemaBuilder()
 {
     if (empty($this->builder)) {
         return parent::getSchemaBuilder();
     }
     $class = $this->builder;
     return new $class($this);
 }

 /**
  * @param \Illuminate\Database\Connection $db
  */
 public function initialize(Connection $db)
 {
     $builder = $db->getSchemaBuilder();
     $tables = ['networks' => function (Blueprint $table) {
         $table->increments('id');
         $table->string('server');
         $table->unique(['server']);
     }, 'channels' => function (Blueprint $table) {
         $table->increments('id');
         $table->integer('network_id')->unsigned();
         $table->string('channel');
         $table->unique(['network_id', 'channel']);
         $table->foreign('network_id')->references('id')->on('networks');
     }, 'nicks' => function (Blueprint $table) {
         $table->increments('id');
         $table->integer('network_id')->unsigned();
         $table->string('nick');
         $table->unique(['network_id', 'nick']);
         $table->foreign('network_id')->references('id')->on('networks');
     }, 'logs' => function (Blueprint $table) {
         $table->increments('id');
         $table->integer('channel_id')->unsigned();
         $table->integer('nick_id')->unsigned();
         $table->timestamp('timestamp');
         $table->text('message');
         $table->foreign('channel_id')->references('id')->on('channels');
         $table->foreign('nick_id')->references('id')->on('nicks');
     }, 'words' => function (Blueprint $table) {
         $table->increments('id');
         $table->string('word', 40);
     }, 'logs_words' => function (Blueprint $table) {
         $table->increments('id');
         $table->integer('logs_id')->unsigned();
         $table->integer('word_id')->unsigned();
         $table->foreign('logs_id')->references('id')->on('logs');
         $table->foreign('word_id')->references('id')->on('words');
     }];
     foreach ($tables as $table => $callback) {
         if ($builder->hasTable($table)) {
             continue;
         }
         $builder->create($table, $callback);
     }
 }

 /**
  * Preparar Migration.
  */
 public function __construct()
 {
     $this->con = app('db')->connection($this->getConnection());
     $this->builder = $this->con->getSchemaBuilder();
     $this->grammar = $this->con->getSchemaGrammar();
 }

 /**
  * Construct an instance of a BaseMigration.
  */
 public function __construct()
 {
     $this->db = app('db')->connection($this->connection);
     $this->builder = $this->db->getSchemaBuilder();
 }

 public function tearDown()
 {
     $this->connection->getSchemaBuilder()->dropIfExists('riders');
     $this->connection->getSchemaBuilder()->dropIfExists('classes');
 }

 /**
  * Overrride build function
  *
  * @param Connection $connection
  * @param Grammar    $grammar
  */
 public function build(Connection $connection, Grammar $grammar)
 {
     $command = $this->parseCommand($this->commands[0]->get('name'));
     $schema = $connection->getSchemaBuilder();
     if ($command === "drop") {
         $schema->dropIfExists($this->getI18NTableName());
     }
     parent::build($connection, $grammar);
     if ($command === "create") {
         $primary = $this->i18n_primary;
         $i18n_columns = $this->i18n_columns;
         $table_name = $this->table;
         $schema->create($this->getI18NTableName(), function (Blueprint $table) use($table_name, $primary, $i18n_columns) {
             foreach ($primary as $name => $col) {
                 $table->columns[] = $col;
                 $table->foreign($col->get('name'))->references($col->get('name'))->on($table_name)->onDelete('cascade');
             }
             foreach ($i18n_columns as $col) {
                 $table->columns[] = $col;
             }
             $table->string($this->i18n_code_field, 10);
             $table->primary(array_merge(array_keys($primary), [$this->i18n_code_field]));
         });
     }
 }

 public function __construct(Illuminate\Database\Connection $connection = NULL)
 {
     static::$connection = $connection ?: Forge::find('db.connection');
     static::$schema = static::$connection->getSchemaBuilder();
     static::$instance = $this;
 }