Increment a column's value by a given amount.

@param  string $column
@param  int    $amount
@param  array  $extra
@return int
430115
public function increment( $column, $amount = 1, array $extra = [] ) {
		if ( ! is_numeric( $amount ) ) {
			throw new \InvalidArgumentException( 'Non-numeric value passed to increment method.' );
		}

		return (int) parent::increment( $column, $amount, $extra );
	}
554686
public function sum($column, bool $distinct = false): self
    {
        return $this->addFunction('aggregateFunction', 'SUM', $column, ['distinct' => $distinct]);
    }
513881
public function append($elements, $extra = null)
    {
        $quote  = (bool)$extra;
        $column = $elements;

        if ($column) {
            if ($quote) {
                $column = $this->_getDriver()->quoteName($elements);
            }

            $this->_conditions[] = $column;
        }
    }
1056727
public function getCount($collection, $column, $value, $excludeId = null, $idColumn = null, array $extra = [])
    {
        $builder = $this->em->createQueryBuilder();

        $builder->select('count(e)')->from($collection, 'e');
        $builder->where("e.{$column} = :{$column}");

        if (!is_null($excludeId) && $excludeId != 'NULL') {
            $idColumn = $idColumn ?: 'id';
            $builder->andWhere("e.{$idColumn} <> :{$idColumn}");
        }

        foreach ($extra as $key => $extraValue) {
            $builder->andWhere("e.{$key} = :{$key}");
        }

        $query = $builder->getQuery();
        $query->setParameter($column, $value);

        if (!is_null($excludeId) && $excludeId != 'NULL') {
            $query->setParameter($idColumn, $excludeId);
        }

        foreach ($extra as $key => $extraValue) {
            $query->setParameter($key, $extraValue);
        }

        return $query->getSingleScalarResult();
    }
440469
public function getMultiCount($collection, $column, array $values, array $extra = [])
    {
        $builder = $this->em->createQueryBuilder();

        $builder->select('count(e)')->from($collection, 'e');
        $builder->where($builder->expr()->in(":{$column}", ":{$column}"));

        foreach ($extra as $key => $extraValue) {
            $builder->andWhere("e.{$key} = :{$key}");
        }

        $query = $builder->getQuery();
        $query->setParameter($column, $values);

        foreach ($extra as $key => $extraValue) {
            $query->setParameter($key, $extraValue);
        }

        return $query->presence();
    }
1016845
protected function incrementOrDecrementAttributeValue($column, $amount, $extra, $method)
    {
        $this->{$column} = $this->{$column} + ($method === 'increment' ? $amount : $amount * -1);

        $this->forceFill($extra);

        $this->syncOriginalAttribute($column);
    }
150567
public function greaterThen($column, $value, $conjunction = 'AND')
    {
        return $this->addExpression(new Condition\Basic($column, '>=', $value, $conjunction));
    }
636526
public function setExtraData($extra_data){
        if(!$this->setModified('extra_data', $extra_data)->isModified()){
            return $this;
        }
        $this->extra_data = $extra_data;

        return $this;
    }
31332
public int increment (int key, int amount)
    {
        Record rec = locateRecord(key);
        if (rec == null) {
            put(key, amount);
            return amount;
        } else {
            return (rec.value += amount);
        }
    }
1346132
public function increments($column)
    {
        $result = parent::increments($column);
        $this->addCachePrimary($column);

        return $result;
    }
542237
public function integer($column, $autoIncrement = false, $unsigned = false)
    {
        return $this->table->addColumn($column, Type::INTEGER, compact('autoIncrement', 'unsigned'));
    }
825444
public function setExtra($extra)
    {
        $resultData = $this->hydrateIfJsonToArray($extra);
        if (!empty($resultData)) {
            $this->extra = $resultData;
        }
        else {
            $this->extra = [];
        }
    }
993547
public function inc($field, $amount = 1) {
        $this->checkIncOrDecAmount($amount);

        $data = [$field => ['exp', "{$field} + {$amount}"]];
        return $this->update($data);
    }
746691
public function increment($column, $amount = 1, array $extra = [])
    {
        if (! is_numeric($amount)) {
            throw new InvalidArgumentException('Non-numeric value passed to increment method.');
        }

        $wrapped = $this->grammar->wrap($column);

        $columns = array_merge([$column => $this->raw("$wrapped + $amount")], $extra);

        return $this->update($columns);
    }
675948
private function incrementAction($column, $step = 1, $sign = '')
    {
        $sql = 'update `' . $this->table . '` set `'.$column.'` = `'.$column.'` '.$sign.' '.$step;

        if (!is_null($this->where)) {
            $sql .= ' ' . $this->where;

            $this->where = null;
        }

        $stmt = $this->connection->prepare($sql);

        $this->bind($stmt, $this->where_data_binding);

        $stmt->execute();

        return (int) $stmt->rowCount();
    }
334692
public function count($column = '*', bool $distinct = false): self
    {
        if (!is_array($column)) {
            $column = [$column];
        }
        $distinct = $distinct || (count($column) > 1);
        return $this->addFunction('aggregateFunction', 'COUNT', $column, ['distinct' => $distinct]);
    }
672682
public function append($elements, $extra = null)
    {
        $elements = (array)$elements;
        reset($elements);
        if ($header = current($elements)) {
            $this->_columns = array_keys($header);
        }

        if ($maxLength = count($this->_columns)) {
            $index = 0;
            foreach ($elements as $data) {
                $data      = array_values((array)$data);
                $dataCount = count($data);

                if ($dataCount < $maxLength) {
                    $data = $data + array_fill($dataCount, $maxLength - $dataCount, null);

                } elseif ($dataCount > $maxLength) {
                    $data = array_slice($data, 0, $maxLength);
                }

                $this->_conditions[$index++] = $data;
            }
        }
    }