Get the columns that should be used in a list array.

@param  string  $column
@param  string  $key
@return array
320207
protected function getListSelect($column, $key)
    {
        $select = is_null($key) ? array($column) : array($column, $key);

        if (($dot = strpos($select[0], '.')) !== false) {
            $select[0] = substr($select[0], $dot + 1);
        }

        return $select;
    }
205469
private function getCondition($column)
    {
        return H::array_first($this->conditions, function ($condition) use ($column) {
            return $condition['column'] === $column;
        });
    }
1081889
public function pluck($column, $key = null)
    {
        $cacheKey = $this->generateKey([$column, $key]);

        return $this->cacheResults(get_called_class(), __FUNCTION__, $cacheKey, function () use ($column, $key) {
            return $this->model->pluck($column, $key);
        });
    }
244970
public function plunk($column, $key = null, $limit = null, $useMaster = false)
    {
        $this->sql['columns'] == '' && $this->columns(is_null($key) ? $column : [$key, $column]);
        $result = $this->select(0, $limit, $useMaster);
        $return = [];
        foreach ($result as $row) {
            is_null($key) ? $return[] = $row[$column] : $return[$row[$key]] = $row[$column];
        }
        return $return;
    }
646862
public static function column(array $array, $column_key)
    {
        $retarr = [];
        foreach ($array as $arr) {
            if (is_array($column_key)) {
                $ret = [];
                foreach ($column_key as $key) {
                    $ret[] = isset($arr[$key]) ? $arr[$key] : null;
                }
                $retarr[] = $ret;
            } else {
                $retarr[] = $arr[$column_key];
            }
        }
        return $retarr;
    }
1301469
final public function fetchColumns($column, $key, $value)
    {
        $this->validateShortcutData();

        return $this->db->select($column)
                        ->from(static::getTableName())
                        ->whereEquals($key, $value)
                        ->queryAll($column);
    }
1137348
public function getColumnValues($column)
    {
        $values = array();
        foreach ($this as $item) {
            /** @var Aoe_Scheduler_Model_Job $item */
            $values[] = $item->getDataUsingMethod($column);
        }
        return $values;
    }
383653
private function transformColumns($columns)
    {
        return array_map(function ($column) {
            return [
                'CID' => $column->cid,
                'Field' => $column->name,
                'Type' => $column->type,
                'Null' => $column->notnull,
                'Key' => $column->pk,
                'Default' => $column->dflt_value,
            ];
        }, $columns);
    }
539165
public function getColumnMeta($column)
	{
		$field = $this->pdo->driver->fetchField($this->resource, $column);
		$field = (array)$field;
		
		return $field;
	}
32027
public function find($key, $columns = ['*'])
    {
        $this->model = $this->model->newQueryWithoutScopes()->findOrFail($key, $columns);

        return $this->model;
    }
225476
public static function value_to_key($data, $column)
	{
		/* init the return array */
		$return = array();

		/* itterate over all the elements */
		foreach ($data as $key => $val)
		{
			if (is_object($val))
			{
				$return[$val->$column] = $val;
			}
			else
			{
				$return[$val[$column]] = $val;
			}
		}

		/* return the array */
		return $return;
	}
687943
public static function column(array $array, $key, $index = null)
    {
        if (function_exists('array_column')) {
            return array_column($array, $key, $index);
        }

        $out = [];
        array_walk(
            $array,
            function ($item) use ($key, $index, &$out) {
                null !== $index ? $out[$item[$index]] = $item[$key] : $out[] = $item[$key];
            }
        );

        return $out;
    }
1171998
protected function pluckFromArrayColumn($queryResult, $column, $key)
    {
        $results = [];

        if (is_null($key)) {
            foreach ($queryResult as $row) {
                $results[] = $row[$column];
            }
        } else {
            foreach ($queryResult as $row) {
                $results[$row[$key]] = $row[$column];
            }
        }

        return collect($results);
    }
1001595
public function pluck(string $column, string $key = null): Collection
    {
        $models = $this->queryRelate->getQuery()->pluck($column, $key);

        $this->resetQueryRelate();

        return $models;
    }
684268
public function getCol($column = 0)
    {
        $sql = $this->toSQL();
        return $this->table->getCol($sql, $this->getParams(), $column);
    }
464094
public function pluck(string $column, string $keyBy = ''): array
    {
        $pdoStatement = $this->provideStatement();
        $pdoStatement = $this->execute($pdoStatement);
        $rows = $pdoStatement->fetchAll(\PDO::FETCH_ASSOC);
        if (empty($rows)) {
            return [];
        }
        if (!isset($rows[0][$column])) {
            throw new DatabaseException('Column not found in result.');
        }
        if (!empty($keyBy) && !isset($rows[0][$keyBy])) {
            throw new DatabaseException('Column to use as key not found in result.');
        }
        $indexKey = (!empty($keyBy)) ? $keyBy : null;
        return array_column($rows, $column, $indexKey);
    }
472271
public function pluck($column, $key = null)
    {
        $results = $this->get(is_null($key) ? [$column] : [$column, $key]);
        // If the columns are qualified with a table or have an alias, we cannot use
        // those directly in the "pluck" operations since the results from the DB
        // are only keyed by the column itself. We'll strip the table out here.
        return array_pluck($results, $this->stripTableForPluck($column), $this->stripTableForPluck($key));
    }