Start a new UPDATE query.

@param array $nvp An NVP array containing columns their value to be updated.

@return object returns the current squibble object.
163847
public function update($t, $nvp = array()){
		if(is_array($t)){
			$nvp = $t;
		}elseif(is_string($t)){
			$this->table($t);
		}
		$columns = [];
		foreach(array_keys($nvp) as $s){
			$column = \Dorsataio\Squibble\Resource\Extract::fromColumn($s);
			$column['value'] = $nvp[$s];
			array_push($columns, $column);
		}
		$this->_sql = $this->getUpdateStatement($columns);
		return $this;
	}
1030561
public function update(array $params = [])
    {
        if (is_null($this->getId())) {
            $this->createBasket();
        }

        $params = array_merge($params, $this->updateParams);

        $this->callResourceAction(function ($params) {
            return $this->client->basketResource($this->version)
                                ->update($this->getId(), $params);
        }, $params);

        $this->updateParams = [];
    }
1141013
public function setStatus($v)
    {
        if ($v !== null) {
            $v = (int) $v;
        }

        if ($this->status !== $v) {
            $this->status = $v;
            $this->modifiedColumns[GamecurrencyTableMap::COL_STATUS] = true;
        }

        return $this;
    }
203934
protected function performUpdate(?Session $session, array $payload)
    {
        if ($session === null) {
            throw new NullValueException('Attempted to update null session');
        }

        return $session->updateExisting($payload);
    }
93760
public function updatedAt($start = null, $end = null)
    {
        /* @var $this ActiveQuery */
        $model = $this->noInitModel;
        if (!is_string($model->updatedAtAttribute) || empty($model->updatedAtAttribute)) {
            return $this;
        }
        return static::range($this, $model->updatedAtAttribute, $start, $end);
    }
822041
public function update($table, array $values = null)
    {
        $builder         = new Update($this->driver);
        $this->lastQuery = $builder;

        if ($values) {
            $builder->values($values);
        }

        return $builder->update($table);
    }
1237570
public function update(array $values)
    {
        if (!$this->hasId()) {
            throw new UpdateException('ID not set - did you call find($id) before update($values)?');
        }

        if (!$this->isUpdatable()) {
            throw new UpdateException('Permission denied: Entity can not be updated');
        }

        $this->transactional(function () use ($values) {
            $this->forceUpdate($values);
        });

        return $this;
    }
1326744
public function update(array $data) {
        $statement = new UpdateStatement($data);
        $statement->setStatementContext($this->statementContext);
        $statement->setCondition($this->condition);
        $sql = $statement->parse();

        $rowCount = $this->connection->execute($sql, $this->statementContext->getParameters());

        $this->clear();

        return $rowCount;
    }
1332270
public function update(array $fields = []) {
        $query = new UpdateQuery($this->getTable());
        $query->fields(!empty($fields)? $fields : $this->getFields());
        $query->whereConditionGroup($this->getWhereConditionGroup());
        return $this->connection->exec($query);
    }
704393
public function setStartPositionId($v)
    {
        if ($v !== null) {
            $v = (int) $v;
        }

        if ($this->start_position_id !== $v) {
            $this->start_position_id = $v;
            $this->modifiedColumns[SkillTableMap::COL_START_POSITION_ID] = true;
        }

        if ($this->aStartPosition !== null && $this->aStartPosition->getId() !== $v) {
            $this->aStartPosition = null;
        }

        return $this;
    }
383717
protected function updateRecord(Query $query): bool
	{
		$lockingColumn = $this->getLockingColumn();

		$lockVersion = $this->columns[$lockingColumn]++;

		$query->where($lockingColumn, '=', $lockVersion);

		$result = parent::updateRecord($query);

		if(!$result)
		{
			$this->columns[$lockingColumn]--;

			throw new StaleRecordException('Attempted to update a stale record.');
		}

		return $result;
	}
1023190
public function update($package = null, $version = null, $dryRun = false)
    {
        if ($dryRun) {
            $this->setDryRun(true);
        }

        $package = !empty($version) ? $package . ':' . $version : $package;

        return $this->runCommand(self::UPDATE, $package, self::ROOT_REQS . self::DEFAULT_ARGS);
    }
462564
public function setPHP($v)
    {
        if ($this->php_unserialized !== $v) {
            $this->php_unserialized = $v;
            $this->php = serialize($v);
            $this->modifiedColumns[] = RemoteHistoryContaoPeer::PHP;
        }


        return $this;
    }
756213
protected function update()
	{
		// New objects can't be updated, neither can frozen
		if ($this->is_new())
		{
			return false;
		}

		// Non changed objects don't have to be saved, but return true anyway (no reason to fail)
		if ( ! $this->is_changed(array_keys(static::properties())))
		{
			return true;
		}

		$this->observe('before_update');

		// Create the query and limit to primary key(s)
		$query       = Query::forge(get_called_class(), static::connection(true));
		$primary_key = static::primary_key();
		$properties  = array_keys(static::properties());
		//Add the primary keys to the where
		$this->add_primary_keys_to_where($query);

		// Set all current values
		foreach ($properties as $p)
		{
			if ( ! in_array($p, $primary_key) )
			{
				if (array_key_exists($p, $this->_original))
				{
					$this->{$p} !== $this->_original[$p] and $query->set($p, isset($this->_data[$p]) ? $this->_data[$p] : null);
				}
				else
				{
					array_key_exists($p, $this->_data) and $query->set($p, $this->_data[$p]);
				}
			}
		}

		// Return false when update fails
		if ( ! $query->update())
		{
			return false;
		}

		// update the original property on success
		$this->observe('after_update');

		return true;
	}
548588
public function update($object, $flushed = true)
    {
        $this->preUpdate($object, $flushed);
        $em = $this->getEntityManager();
        $em->persist($object);
        if ($flushed) {
            $em->flush($object);
        }
        $this->postUpdate($object, $flushed);
        return $object;
    }
684870
function update() {
		$where = $this->criteria();
		$this->table->notify($this, "update", $where);
		$rowset = $this->table->update($where, $this->changes());
		if (!count($rowset)) {
			throw new \UnexpectedValueException("No row updated");
		}
		$this->data = $rowset->current()->data;
		$this->cell = array();
		return $this;
	}
1218858
public function init(array $setting)
    {
        if (empty($this->vitex->pdo)) {
            $this->vitex->runMiddleware(new \vitex\ext\Pdo($setting));
            $this->DB = $this->vitex->pdo;
            $this->pdo = $this->DB->pdo;
        }
        return $this;
    }