@param Column $column
@param        $eloquent

@return array
556150
protected function isUnique(Column $column, $eloquent)
    {
        foreach (scheme()->indexes($eloquent->getTable()) as $indexName => $index) {
            if (in_array($column->getName(), $index->getColumns(), true) && $index->isUnique()) {
                return true;
            }
        }

        return false;
    }
1301469
final public function fetchColumns($column, $key, $value)
    {
        $this->validateShortcutData();

        return $this->db->select($column)
                        ->from(static::getTableName())
                        ->whereEquals($key, $value)
                        ->queryAll($column);
    }
1257991
protected function isForeignKey($column, $eloquent)
    {
        foreach ($foreign = scheme()->foreignKeys($eloquent->getTable()) as $foreign) {
            if (in_array($column->getName(), $foreign->getLocalColumns(), true)) {
                return $foreign;
            }
        }

        return false;
    }
224299
public function column($column)
    {
        return $this
            ->map(function (CollectionableInterface $entity) use ($column) {
                return $this->getFieldValue($entity, $column);
            })
            ->toArray()
        ;
    }
417040
public static function getTreeByQuery(EloquentBuilder $query, array $columns = ['*'])
    {
        /**
         * @var Entity $instance
         */
        $instance = new static;
        $columns = $instance->prepareTreeQueryColumns($columns);
        return $query->get($columns)->toTree();
    }
288186
protected function getColumnSqlDefinition(Column $column)
    {
        $buffer = [];
        if ($column->isIdentity()) {
            $buffer[] = $column->getType() === 'biginteger' ? 'BIGSERIAL' : 'SERIAL';
        } else {
            $sqlType = $this->getSqlType($column->getType(), $column->getLimit());
            $buffer[] = \strtoupper($sqlType['name']);
            // integers cant have limits in postgres
            if (static::PHINX_TYPE_DECIMAL === $sqlType['name'] && ($column->getPrecision() || $column->getScale())) {
                $buffer[] = \sprintf(
                    '(%s, %s)',
                    $column->getPrecision() ?: $sqlType['precision'],
                    $column->getScale() ?: $sqlType['scale']
                );
            } elseif ($sqlType['name'] === 'geography') {
                // geography type must be written with geometry type and srid, like this: geography(POLYGON,4326)
                $buffer[] = \sprintf(
                    '(%s,%s)',
                    \strtoupper($sqlType['type']),
                    $sqlType['srid']
                );
            } elseif (!\in_array($sqlType['name'], ['integer', 'smallint', 'bigint'], true)) {
                if ($column->getLimit() || isset($sqlType['limit'])) {
                    $buffer[] = sprintf('(%s)', $column->getLimit() ?: $sqlType['limit']);
                }
            }

            $timeTypes = [
                'time',
                'timestamp',
            ];
            if (in_array($sqlType['name'], $timeTypes) && $column->isTimezone()) {
                $buffer[] = strtoupper('with time zone');
            }
        }

        $buffer[] = $column->isNull() ? 'NULL' : 'NOT NULL';

        if (null !== $column->getDefault()) {
            $buffer[] = $this->getDefaultValueDefinition($column->getDefault());
        }

        return implode(' ', $buffer);
    }
715747
public function pluck($column, $key = null)
    {
        $results = $this->toBase()->pluck($column, $key);

        // If the model has a mutator for the requested column, we will spin through
        // the results and mutate the values so that the mutated version of these
        // columns are returned as you would expect from these Eloquent models.
        if (! $this->model->hasGetMutator($column) &&
            ! $this->model->hasCast($column) &&
            ! in_array($column, $this->model->getDates())) {
            return $results;
        }

        return $results->map(function ($value) use ($column) {
            return $this->model->newFromBuilder([$column => $value])->{$column};
        });
    }
251532
public function pluck($column) {

		$plucked = [];

		while(parent :: valid()) {
            
            $current = parent :: current();

            if(true === is_array($column)) {

            	$tmp = $current;
            	$insert = true;

            	foreach($column as $index) {

            		if(false === isset($tmp[$index])) {
            			
            			$insert = false;
            			break;
            		}

            		$tmp = $tmp[$index];
            	}

            	if(true === $insert) {
            		$plucked[] = $tmp;
            	}
            }

            if(true === isset($current[$column])) {
            	$plucked[] = $current[$column];
            }

            parent :: next();
        }

        switch($this -> convert) {

			case self :: TYPE_ARRAY: return $plucked;
			case self :: TYPE_OBJECT: return (object) $plucked;
			case self :: TYPE_JSON: return json_encode($plucked);
		}
	}
114169
public static function pluckOrLists(Builder $query, $column, $key = null)
	{
		if(\Illuminate\Foundation\Application::VERSION < '5.2') {
			$result = $query->lists($column, $key);
		} else {
			$result = $query->pluck($column, $key);
		}

		return $result;
	}
1152883
protected function column(Column $column) : ColumnExpr
    {
        return Expr::column($this->relatedTable->getName(), $column);
    }
1117568
public function pluck($column, $key = null)
    {
        return parent::pluck(
            $this->getColumnName($column),
            $key
        );
    }
705028
public function pluck($column, $key = null)
    {
        $results = $this->toBase()->pluck($column, $key);

        // If the model has a mutator for the requested column, we will spin through
        // the results and mutate the values so that the mutated version of these
        // columns are returned as you would expect from these Eloquent models.
        if (! $this->model->hasGetMutator($column) &&
            ! $this->model->hasCast($column) &&
            ! in_array($column, $this->model->getDates())) {
            return $results;
        }

        $keys = array_keys($results);
        $results = array_map(
            function ($value) use ($column) {
                return $this->model->newFromBuilder([$column => $value])->$column;
            },
            $results,
            $keys
        );
        return $results;
    }
1001595
public function pluck(string $column, string $key = null): Collection
    {
        $models = $this->queryRelate->getQuery()->pluck($column, $key);

        $this->resetQueryRelate();

        return $models;
    }
1257833
public function findForeignKey(string $column): ?AbstractForeignKey
    {
        foreach ($this->foreignKeys as $reference) {
            if ($reference->getColumn() == $column) {
                return $reference;
            }
        }

        return null;
    }
708354
public function lists($column, $key = null)
	{
		$results = $this->query->lists($column, $key);

		// If the model has a mutator for the requested column, we will spin through
		// the results and mutate the values so that the mutated version of these
		// columns are returned as you would expect from these FlyORM models.
		if ($this->model->hasGetMutator($column))
		{
			foreach ($results as $key => &$value)
			{
				$fill = array($column => $value);

				$value = $this->model->newFromBuilder($fill)->$column;
			}
		}

		return $results;
	}
1094258
public function column($column)
    {
        $result = $this->fields($column)->one(); 

        // only return something if something is found
        if (is_array($result))
        {
            return reset($result);
        }
    }
193666
protected function inputType($column, $eloquent)
    {
        static $columns = [];

        if (method_exists($this, 'inputTypes')
            && array_key_exists($column, $types = $this->inputTypes())
        ) {
            return $types[$column];
        }

        if ($eloquent instanceof AttachableInterface
            && array_key_exists($column, $attachments = $eloquent->getAttachedFiles())
        ) {
            return $this->getAttachmentType($column, $attachments);
        }

        $columns = array_merge($columns, $this->allColumns($eloquent));

        // map column database type to input type
        if ($column = array_get($columns, $column)) {
            return $this->mapColumnTypeToFieldType($column);
        }

        if ($chain = $this->isRelationColumn($column)) {
            list($relColumn, $table) = $this->resolveRelationsChain($chain, $eloquent);

            return $this->inputType($relColumn, $table->getRelated());
        }

        return 'text';
    }