Hint at index to use

@param mixed $columns
@param string $mode
@return $this
961540
public function hint($columns, $mode = null)
    {
        $this->hint = $columns;
        $this->hintMode = $mode;
        return $this;
    }
1373523
public function group($columns)
    {
        settype($columns, 'array'); //force to an array

        $this->group = array_unique(array_merge($this->group, $columns));
        return $this;
    }
71244
public function columns(array $columns)
    {
        $columns = array_unique($columns);

        foreach ($columns as &$column) {
            $column = $this->dialect()->quoteTable($column);
        }
        unset($column);

        $this->columns = $columns;

        return $this;
    }
886574
public function setMode($mode)
    {
        Assertion::choice($mode, $this->availableModes, "Mode '{$mode}' does not exist.");
        $this->mode = $mode;

        return $this;
    }
548483
public function dropIndex(array $columns): AbstractTable
    {
        if (empty($schema = $this->current->findIndex($columns))) {
            throw new SchemaException(
                "Undefined index ['" . join("', '", $columns) . "'] in '{$this->getName()}'"
            );
        }

        //Dropping index from current schema
        $this->current->forgetIndex($schema);

        return $this;
    }
333692
public function groupBy($columns): self
    {
        if (!is_array($columns)) {
            $columns = [$columns];
        }
        $this->sql->addGroupBy($columns);
        return $this;
    }
643313
public function addIndex($columns, $name = null)
    {
        return $this->addKey(new Key(Key::TYPE_INDEX, (array) $columns, $name));
    }
629159
function using($columns)
    {
        $lastJoin = $this->getLastJoinSource();

        if (null === $columns) {
            $lastJoin->right = null;
            return $this;
        }

        $columns = is_array($columns) ? $columns : func_get_args();

        if ($lastJoin->right instanceof Using) {
            $lastJoin->right->expression = array_merge(
                $lastJoin->right->expression,
                $columns
            );
        } else {
            $lastJoin->right = new Grouping($columns);
        }
        return $this;
    }
739766
public function columns($columns)
    {
        if( is_array($columns) ||
            is_string($columns) ||
            $columns instanceof Expression ) {
            $this->columns = $columns;
        } else {
            throw new InvalidArgumentException('Invalid columns parameter');
        }
        return $this;
    }
998217
public function group($columns)
	{
		if (is_null($this->group))
		{
			$this->group = new Query\QueryElement('GROUP BY', $columns);
		}
		else
		{
			$this->group->append($columns);
		}

		return $this;
	}
1189527
public function columns(array $columns)
    {
        $this->getColumns()->setColumns($columns);

        $this->manager->columns();

        return $this;
    }
1047658
protected function _addSelect(array $columns) {
		if(array_values($columns) === $columns) {
			foreach($columns as $k=>$v) {
				unset($columns[$k]);
				$columns[$v] = $v;
			}
		}
		$this->columns = array_merge($this->columns, $columns);
		return $this;
	}
793096
public function select($columns = "*")
    {
        $this->start = $columns;
        $this->queryType = self::QUERY_SELECT;
        return $this;
    }
451957
function setColumns($columns) {
		$this->columns = array();

		if ($columns === null) {
			return $this;
		}

		if (is_string($columns)) {
			return $this->addColumn($columns);
		}

		foreach ($columns as $alias => &$column) {
			$this->addColumn($column, is_int($alias) ? null : $alias);
		}
		return $this;
	}
401639
public function orWhereMultiple(array $columns)
    {
        $instance = $this->whereStrategyInstance();

        $instance->whereStrategy()->orWhereMultiple($columns);

        return $instance;
    }
705695
public function columns(array $columns): self
    {
        foreach ($columns as $name => $alias) {
            if (!is_string($name)) {
                $this->column($alias, null);
                continue;
            }
            if (is_string($alias)) {
                $this->column($name, $alias);
            } else {
                $this->column($alias, $name);
            }
        }
        return $this;
    }
677046
public function withColumnsButIgnoringConstraints(array $columns) : Table
    {
        if ($this->columns === $columns) {
            return $this;
        }

        return new self($this->name, $columns);
    }