Load columns data.

@return void
186498
protected function loadColumns()
    {
        $statement = $this->db->query('SHOW COLUMNS FROM ' . $this->config->getDbTable());

        $this->columns = array();
        while (false !== ($column = $statement->fetchObject())) {
            $this->columns[] = new Column($column, $this->config->getDbPrefix());
        }
    }
1317821
protected function load()
    {
        if ($this->loaded)
        {
            return;
        }

        $table = ORM::getTable(Eresus_Plugin_Registry::getInstance()->load('gallery'), 'Image');
        $q = $table->createSelectQuery();
        $e = $q->expr;

        $q->where(
            $e->lAnd(
                $e->eq('section', $q->bindValue($this->sectionId, null, PDO::PARAM_INT)),
                $e->eq('active', $q->bindValue(true, null, PDO::PARAM_BOOL)),
                $e->neq('groupId', 0)
            ))->
            orderBy('groupId');

        $this->items = $table->loadFromQuery($q);

        $this->loaded = true;
    }
579755
public function load()
    {
        $data = [];

        $settings = $this->database->select('SELECT * FROM '.$this->table);

        foreach ($settings as $setting) {
            $id = $setting->id;
            $value = $setting->value;

            $decoded = json_decode($value, 1, 512);
            if (is_array($decoded)) {
                $value = $decoded;
            }

            Arr::set($data, $id, $value);
        }

        return $data;
    }
207694
public function load()
    {
        $this->resetCollection();
        $this->data = [];
        $data = $this->getData();
        if (empty($data)) {
            return;
        }
        $this->getCollection()->batchInsert($data);
        foreach ($data as $alias => $row) {
            $this->data[$alias] = $row;
        }
    }
707448
public function load($force = false)
    {
        if (!$this->checkExtraColumns()) {
            return;
        }

        if ($this->loaded && !$force) {
            return;
        }

        $this->data = $this->read();
        $this->loaded = true;
    }
769055
private function loadLabels(): void
  {
    $tables = DataLayer::getLabelTables();
    foreach ($tables as $table)
    {
      $rows = DataLayer::getLabelsFromTable($table['table_name'], $table['id'], $table['label']);
      foreach ($rows as $row)
      {
        $this->labels[$row['label']] = $row['id'];
      }
    }
  }
426437
public function load(array $data)
    {
        foreach ($data as $index => $value) {
            $this->set($index, $value);
        }
    }
381699
protected function load()
    {
        if ($this->loaded)
        {
            return;
        }
        $plugin = Eresus_Plugin_Registry::getInstance()->load('gallery');
        /* @var Gallery_Entity_Table_Image $table */
        $table = ORM::getTable($plugin, 'Image');
        $this->items = $table->findInSection($this->sectionId, null, null, true);
        $this->loaded = true;
    }
454739
function load() {
			$all_plugins_data = $this->get_all_data();
			$this->_data      = isset( $all_plugins_data[ $this->_secondary_id ] ) ?
				$all_plugins_data[ $this->_secondary_id ] :
				array();
		}
1214499
public function columns()
    {
        for ($i = 0; $i < $this->columns; ++$i) {
            yield $i + 1 => ($this->rows == 1)
                ? $this->grid[0][$i]
                : new static(array_column($this->grid, $i));
        }
    }
604425
protected function registerColumns()
    {
        $this->hook->action('admin_init', function () {
            $this->getSingularity()->columns($this->columns());
        })->dispatch();
    }
670837
protected function registerColumns()
    {
        $this->hook->action('admin_init', function () {
            $this->singularity->columns($this->columns());
        })->dispatch();
    }
1295086
private static function _loadColumns()
    {
        if (!self::resolveConnection()) {
            return;
        }

        $cls = get_called_class();
        self::$_columns[$cls] = array();

        $escape = Driver::$escape_char;

        // try to create the TORM info table
        $type = Driver::$numeric_column;

        // check if the torm table exists
        $rst   = null;
        $check = false;
        try {
            $rst   = self::query("select id from torm_info");
            $check = true;
        } catch (\Exception $e) {
        }

        // needs to create table
        if (!$check || !is_object($rst) || !$rst->fetch()) {
            $stmt = self::query("create table torm_info (id $type(1))");
            self::closeCursor($stmt);
        }
        if (is_object($rst)) {
            self::closeCursor($rst);
        }

        // insert first value
        $rst = self::query("select id from torm_info");
        if (!$rst->fetch()) {
            $stmt = self::query("insert into torm_info values (1)");
            self::closeCursor($stmt);
        }
        self::closeCursor($rst);

        // hack to dont need a query string to get columns
        $sql  = "select $escape".self::getTableName()."$escape.* from torm_info left outer join $escape".self::getTableName()."$escape on 1=1";
        $rst  = self::query($sql);
        $keys = array_keys($rst->fetch(\PDO::FETCH_ASSOC));

        foreach ($keys as $key) {
            $keyc = self::isIgnoringCase() ? strtolower($key) : $key;
            array_push(self::$_columns[$cls], $keyc);
            self::$_mapping[$cls][$keyc] = $key;
        }
        self::closeCursor($rst);
        self::$_loaded[$cls] = true;
    }
440973
public function columns()
    {
        if ($this->columns->isEmpty()) {
            $this->columns->push($this->current);
        }

        return $this->columns;
    }
1130580
private function loadAll(): void
  {
    $this->findSourceFiles();
    $this->detectNameConflicts();
    $this->getColumnTypes();
    $this->readStoredRoutineMetadata();
    $this->getConstants();
    $this->getOldStoredRoutinesInfo();
    $this->getCorrectSqlMode();

    $this->loadStoredRoutines();

    // Drop obsolete stored routines.
    $this->dropObsoleteRoutines();

    // Remove metadata of stored routines that have been removed.
    $this->removeObsoleteMetadata();

    $this->io->writeln('');

    // Write the metadata to file.
    $this->writeStoredRoutineMetadata();
  }
914359
protected function setDbColumns()
    {
        $connection = $this->model()->eloquent()->getConnectionName();

        $this->dbColumns = collect(Schema::connection($connection)->getColumnListing($this->model()->getTable()));
    }
1116470
public function addColumns(array $columns)
    {
        /*
         * Build a final collection of list column objects
         */
        foreach ($columns as $columnName => $config) {
            $this->allColumns[$columnName] = $this->makeListColumn($columnName, $config);
        }
    }