@param   string $type
@param   string $name
@param   Closure|string $column
@param   array $arguments (optional)

@return  $this
774112
protected function addFunction(string $type, string $name, $column, array $arguments = []): self
    {
        if ($column instanceof Closure) {
            $column = Expression::fromClosure($column);
        } elseif (is_array($column)) {
            foreach ($column as &$c) {
                if ($c instanceof Closure) {
                    $c = Expression::fromClosure($c);
                }
            }
        }

        $func = array_merge(['type' => $type, 'name' => $name, 'column' => $column], $arguments);

        return $this->addExpression('function', $func);
    }
404559
public function more($column, $argument)
    {
        $this->conditions = [$this->grammar->buildId($column) . ' > ' . $argument];

        return $this;
    }
705391
protected function addMethod($name, array $arguments = array())
    {
        $this->methods[] = new MethodCall($this, $name, $arguments);

        return $this;
    }
326396
public function addColumn(
        $name,
        $type = 'text',
        $signed = true,
        $allowNull = true,
        $default = '',
        $comment = '',
        $options = []
    ) {
        $column = $name;

        if (!($column instanceof Column)) {
            $column = new Column($name, $type, $signed, $allowNull, $default, $comment, $options);
        }

        if ($this->hasColumn($column->getName())) {
            return $this;
        }

        $this->prepareColumn($column);

        $query = PostgresqlGrammar::addColumn(
            $this->getName(),
            $column->getName(),
            $column->getType() . $column->getLength(),
            $column->getAllowNull(),
            $column->getDefault()
        );

        $this->db->setQuery($query)->execute();

        if ($column->getComment()) {
            $query = PostgresqlGrammar::comment('COLUMN', $this->getName(), $column->getName(), $column->getComment());
            $this->db->setQuery($query)->execute();
        }

        return $this->reset();
    }
972864
protected function addIndex($name, $type, $column)
    {
        if (isset($this->indexes[$name])) {
            $this->indexes[$name]['columns'][] = $column;
        }
        else {
            $this->indexes[$name] = [
                'name' => $name,
                'type' => $type,
                'columns' => [
                    $column
                ]
            ];
        }
    }
143700
public function key($type, $columns, $name)
		{
			$parameters = array('name' => $name, 'columns' => (array) $columns);

			return $this->command($type, $parameters);
		}
1081640
public function addColumn( $table, $name, $type )
    {
        return $this->handler->addColumn( $table, $name, $type );
    }
1308282
function (name, type, opts) {
            opts = opts || {};
            this.operations.push(merge({op:"setColumnType", name:name, type:type}, opts));
        }
1313969
public function setType(string $type): self
    {
        if (!\in_array($type, self::COLUMN_TYPES, true)) {
            throw new \InvalidArgumentException('Not supported column type '. $type);
        }

        $this->type = $type;

        return $this;
    }
73688
public function clear($type, $name)
    {
        if (isset($this->clients[$type][$name])) {
            $this->clients[$type][$name]->shutdown();
            unset($this->clients[$type][$name]);
        }

        return $this;
    }
1306732
public function bind($name, \Closure $type)
    {
        $name = '\\'.ltrim($name, '\\');
        $this->bindings[$name] = $type;
    }
575134
protected function bindValues($name, $type, $values)
    {
        if (!is_array($values)) {
            return $this->builder->createNamedParameter($values, $type);
        }

        foreach ($values as $key => $value) {
            $values[$key] = $this->bindValues($name, $type, $value);
        }

        return $values;
    }
1354009
public static function passive(string $name, Type $type): self
    {
        $self = new self($name, $type);
        $self->passive = true;

        return $self;
    }
1228873
private function cannotCheck($type, $name, $args)
    {
        if (isset($args[0]) && (is_object($args[0]) && get_class($args[0]) === 'Closure')) {
            $type = 'closure';
            $args[1] = $args[0];
        } elseif (is_string($args[0]) && strpos($args[0], '::') !== false) {
            $type = 'method';
        }

        $this->check('not-equals', $type, $name, $args);
    }
1356369
public function andMore($column, $argument)
    {
        $this->conditions[] = 'AND ' . $this->grammar->buildId($column) . ' > ' . $argument;

        return $this;
    }
635692
public function emit($type, $name, $arguments = [])
    {
        $fullName = $type . '.' . $name;
        if (!empty($this->events) && isset($this->events[$fullName])) {
            foreach ($this->events[$fullName] as $e) {
                call_user_func_array($e, $arguments);
            }
        }
    }
1010458
protected function addColumn($type, $name, array $parameters = array())
    {
        $attributes = array_merge(compact('type', 'name'), $parameters);

        $this->columns[] = $column = new Fluent($attributes);

        return $column;
    }