PHP Model::getConnectionName方法代码示例

 /**
  * Get the hydrated models without eager loading.
  *
  * @param  array  $columns
  * @return \Illuminate\Database\Eloquent\Model[]
  */
 public function getModels($columns = ['*'])
 {
     $results = $this->query->get($columns);
     $connection = $this->model->getConnectionName();
     return $this->model->hydrate($results, $connection)->all();
 }

 /**
  * Get the current connection name for the model.
  *
  * @return string
  */
 public function getConnectionName()
 {
     $tenant = tenant();
     if (is_null($tenant)) {
         return parent::getConnectionName();
     }
     return array_get($tenant, 'id');
 }

 /**
  * @return string
  */
 public function getConnectionName()
 {
     // overrules connection name in case of using multi tenancy
     if (env('HYN_MULTI_TENANCY_HOSTNAME') && is_null($this->connection)) {
         return 'tenant';
     }
     // fallback to parent method
     return parent::getConnectionName();
 }

 /**
  * Create a new pivot model instance.
  *
  * @param  \Illuminate\Database\Eloquent\Model  $parent
  * @param  array   $attributes
  * @param  string  $table
  * @param  bool    $exists
  * @return void
  */
 public function __construct(Model $parent, $attributes, $table, $exists = false)
 {
     parent::__construct();
     // The pivot model is a "dynamic" model since we will set the tables dynamically
     // for the instance. This allows it work for any intermediate tables for the
     // many to many relationship that are defined by this developer's classes.
     $this->setRawAttributes($attributes, true);
     $this->setTable($table);
     $this->setConnection($parent->getConnectionName());
     // We store off the parent instance so we will access the timestamp column names
     // for the model, since the pivot model timestamps aren't easily configurable
     // from the developer's point of view. We can use the parents to get these.
     $this->parent = $parent;
     $this->exists = $exists;
     $this->timestamps = $this->hasTimestampAttributes();
 }

 /**
  * Get the hydrated models without eager loading.
  *
  * @param  array  $columns
  * @return array|static[]
  */
 public function getModels($columns = array('*'))
 {
     // First, we will simply get the raw results from the query builders which we
     // can use to populate an array with Eloquent models. We will pass columns
     // that should be selected as well, which are typically just everything.
     $results = $this->query->get($columns);
     $connection = $this->model->getConnectionName();
     $models = array();
     // Once we have the results, we can spin through them and instantiate a fresh
     // model instance for each records we retrieved from the database. We will
     // also set the proper connection name for the model after we create it.
     foreach ($results as $result) {
         $models[] = $model = $this->model->newFromBuilder($result);
         $model->setConnection($connection);
     }
     return $models;
 }

 /**
  * Determine if two models have the same ID and belong to the same table.
  *
  * @param  \Illuminate\Database\Eloquent\Model  $model
  * @return bool
  */
 public function is(Model $model)
 {
     return $this->getKey() === $model->getKey() && $this->getTable() === $model->getTable() && $this->getConnectionName() === $model->getConnectionName();
 }

 /**
  * Generate a cache key
  *
  * @return string
  */
 public function generateCacheKey()
 {
     return md5($this->model->getConnectionName() . $this->builder->toSql() . serialize($this->builder->getBindings()));
 }

 /**
  * Hydrate related models.
  *
  * @param  Model    $related
  * @param  Relation $relation
  * @param  array    $results
  * @return array
  */
 protected function hydrate(Model $related, Relation $relation, array $results)
 {
     $models = $related->hydrate($results, $related->getConnectionName())->all();
     if (count($models) > 0 && method_exists($relation, 'hydratePivotRelation')) {
         $r = new ReflectionMethod(get_class($relation), 'hydratePivotRelation');
         $r->setAccessible(true);
         $r->invoke($relation, $models);
     }
     return $models;
 }

 /**
  * Add new Value to entity.
  *
  * @param Property $property
  * @param mixed    $value
  *
  * @return Value
  */
 public function addValue(Property $property, $value)
 {
     $instance = self::getType($property->type);
     if ($instance !== null) {
         $v = $instance->newInstance([], false);
     } else {
         $v = new Value();
     }
     $v->setConnection($this->entity->getConnectionName());
     $v->setRelation('property', $property);
     $v->forceFill(['property_id' => $property->getKey(), 'value' => $value]);
     if ($property->multiple) {
         $this->getPropertyValue($property->name)->push($v);
     } else {
         $this->getPropertyValues($property->name)->put($property->name, $v);
     }
     return $v;
 }