Append one or more values to an array.

@param mixed $column
@param mixed $value
@param bool  $unique

@return bool
543722
public function push($column, $value = null, $unique = false)
    {
        $operation = $unique ? 'merge' : 'append';

        $this->compileWheres();
        $result = $this->query->update([
            $column => r\row($column)->{$operation}($value),
        ])->run();

        return 0 == (int) $result['errors'];
    }
51596
public function joinColumn($joinColumn, $references = 'id', $unique = false)
    {
        $this->addJoinColumn(null, $joinColumn, $references, false, $unique);

        return $this;
    }
812513
public function unique($column, $value, $policy)
    {
        if ($this->shouldNotBeEmpty($value)) {
            return !DB::table($policy)->where($column, '=', $value)->exists();
        }

        return true;
    }
219500
public function set(string $column, $value): UpdateQuery
    {
        $this->values[$column] = $value;

        return $this;
    }
1260259
public function addColumn($col)
    {
        $col = $this->createColumn($col);
        $this->columns[$col->getUniqueId()] = $col;
    }
952283
protected function isArrayAllKeySequential($value)
    {
        if (! is_array($value)) {
            return false;
        }

        if (count($value) <= 0) {
            return true;
        }

        return array_unique(array_map('is_int', array_keys($value))) === [true];
    }
200052
public function addUnique($columns)
    {
        $unique = new Unique($columns, $this);

        $this->actions[] =  function () use ($unique) {
             return $this->manipulation->create($unique);
        };

        return $this;
    }
660754
public function where($column, $value = null)
    {
        // If the column is an array, we will assume it is an array of key-value pairs
        // and can add them each as a where clause.
        if (is_array($column)) {
            return $this->whereNested(function ($query) use ($column) {
                foreach ($column as $key => $value) {
                    $query->where($key, $value);
                }
            });
        }

        $this->wheres[] = compact('column', 'value');

        return $this;
    }
1326567
public function appendColumnToUniqueIndexes(string $columnName)
    {
        if (!isset($this->columns[$columnName])) {
            throw InvalidArgumentException::format(
                'Invalid column name supplied to %s: expecting one of (%s), \'%s\' given',
                __METHOD__, Debug::formatValues(array_keys($this->columns)), $columnName
            );
        }

        foreach ($this->indexes as $key => $index) {
            if ($index->isUnique()) {
                $this->indexes[$key] = new Index(
                    $index->getName(),
                    true,
                    array_unique(array_merge($index->getColumnNames(), [$columnName]))
                );
            }
        }
    }
1029396
final public function distinct($column)
    {
        if (!is_array($column)) {
            $column = explode(',', $column);
        }
        $column = array_map([$this, 'formatColumn'], $column);

        $this->_sql['distinct'] = array_merge($this->_sql['distinct'], $column);
        return $this;
    }
475597
public function append($value, $key = null): Arrayy
    {
        $this->checkTypeWrapper($value);

        return parent::append($value, $key);
    }
593520
def unique_append(self, value):
    
    if value not in self:
        try:
            super(self.__class__, self).append(Uri(value))
        except AttributeError as err:
            if isinstance(value, MODULE.rdfclass.RdfClassBase):
                super(self.__class__, self).append(value)
            else:
                raise err
682416
public function append($key, $value) {
        try {
            $result = $this->getRedis()->append($key, $value);
            if ($result !== false) {
                return $result;
            }
            throw new ImpossibleValueException();
        } catch (RedisException $ex) {
            throw new ConnectException();
        }
    }
1216818
protected function incrementOrDecrement(string $sign, $columns, $value)
    {
        if (!is_array($columns)) {
            $columns = [$columns];
        }

        $values = [];

        foreach ($columns as $k => $v) {
            if (is_numeric($k)) {
                $values[$v] = function (Expression $expr) use ($sign, $v, $value) {
                    $expr->column($v)->{$sign}->value($value);
                };
            } else {
                $values[$k] = function (Expression $expr) use ($sign, $k, $v) {
                    $expr->column($k)->{$sign}->value($v);
                };
            }
        }

        return $this->set($values);
    }
158226
@Override
    protected boolean i_updateRow(Connection conn,
                                  String table,
                                  String[] columns,
                                  String[] values,
                                  String uniqueColumn,
                                  boolean[] numeric) throws SQLException {

        // prepare update statement
        StringBuilder sql = new StringBuilder(64);
        sql.append("UPDATE ").append(table).append(" SET ");
        boolean needComma = false;
        for (int i = 0; i < columns.length; i++) {
            if (!columns[i].equals(uniqueColumn)) {
                if (needComma) {
                    sql.append(", ");
                } else {
                    needComma = true;
                }
                sql.append(columns[i] + " = ");
                if (values[i] == null) {
                    sql.append("NULL");
                } else {
                    sql.append('?');
                }
            }
        }
        sql.append(" WHERE ");
        sql.append(uniqueColumn);
        sql.append(" = ?");
        if (logger.isDebugEnabled()) {
            logger.debug("About to execute: " + sql.toString());
        }
        PreparedStatement stmt = conn.prepareStatement(sql.toString());

        try {
            // populate values
            int varIndex = 0;
            for (int i = 0; i < columns.length; i++) {
                if (!columns[i].equals(uniqueColumn) && values[i] != null) {
                    varIndex++;
                    if (numeric != null && numeric[i]) {
                        setNumeric(stmt, varIndex, columns[i], values[i]);
                    } else {
                        stmt.setString(varIndex, values[i]);
                    }
                }
            }
            varIndex++;
            stmt
                    .setString(varIndex, getSelector(columns,
                                                     values,
                                                     uniqueColumn));

            // execute and return true if existing row was updated
            return stmt.executeUpdate() > 0;

        } finally {
            closeStatement(stmt);
        }
    }
487008
public function where($column, $value = null)
    {
        if (is_array($value)) {
            return $this->whereIn($column, $value);
        }

        if ($column instanceof Closure) {
            return $this->using($column);
        }

        $this->wheres[] = compact('column', 'value');

        return $this;
    }
206069
function set($parm, $value = null)
    {
        if(is_array($parm)){
            foreach($parm as $k=>$v){ $this->__columns[$k] = $v; }
            return $this;
        }
        elseif(isset($this->__columns[$parm])) {
            $this->__columns[$parm] = $value;
            return $this;
        }
        else return false;
    }