Easily add a "table = something" to the query.

@example
where("count = ?", 5)
// or
where(["count = ?" => 5], ["name LIKE 'Radium%'"]);

@param string $columm Column name
@param mixed  $value  Column value

@return object
976188
public function where($column, $value = null)
    {
        if (!isset($this->query['where'])) {
            $this->query['where'] = array();
        }

        // Are we merging this with the previous?
        // This is used when coming out of Model.
        if ($this->mergeNextWhere and count($this->query['where']) > 0) {
            $this->mergeNextWhere = false;
            return $this->_and($column, $value);
        }

        // Array? too easy
        if (is_array($column)) {
            $this->query['where'][] = $column;
        } else {
            $this->query['where'][] = array($column => $value);
        }

        return $this;
    }
1348270
public function addShowOnValue(Column\AbstractColumn $col, $value = null, $comparison = Filter::EQUAL)
    {
        $this->showOnValues[] = [
            'column' => $col,
            'value' => $value,
            'comparison' => $comparison,
        ];
    }
745165
public static function where($column, $value)
    {
        try {
            self::init();
            $query = 'SELECT * FROM ' . self::$modelTable . ' WHERE '. $column. ' = '. $value;
            return new QueryBuilder(self::$connect, $query);

        } catch (\Exception $exception) {
            var_dump($exception->getMessage());
        }
    }
645601
public function where($column, $op = null, $value = null)
    {
        $this->parseWhereMethod($column, $op, $value, 'where');

        return $this;
    }
902478
public function or_where($column, $op = null, $value = null)
	{
		if($column instanceof \Closure)
		{
			$this->or_where_open();
			$column($this);
			$this->or_where_close();
			return $this;
		}

		if (is_array($column))
		{
			foreach ($column as $key => $val)
			{
				if (is_array($val))
				{
					$this->or_where($val[0], $val[1], $val[2]);
				}
				else
				{
					$this->or_where($key, '=', $val);
				}
			}
		}
		else
		{
			if(func_num_args() === 2)
			{
				$value = $op;
				$op = '=';
			}
			$this->_where[] = array('OR' => array($column, $op, $value));
		}
		return $this;
	}
999305
public function orWhereLike($column, $value)
    {
        try {
            if (!is_null($this->query)) {
                $this->query .= ' OR '.$column. ' LIKE "'.$value.'"';
                return $this;
            }

        } catch (\Exception $exception) {
            var_dump($exception->getMessage());
        }
    }
1006494
public function orWhere($column, $operator = null, $value = null)
    {
        return $this->where($column, $operator, $value, 'or');
    }
568700
public function where(string $column, $value, $operator = self::OPERATOR_EQ, $connector = self::LOGICAL_AND): self
    {
        $this->criteria($this->where, $column, $value, $operator, $connector);

        return $this;
    }
82724
public function addWhere($column, $operator = null, $value = null, $boolean = 'and')
    {
        if ($boolean !== 'and') {
            throw new NotSupportedException('Only support "and" in where clause');
        }

        // Here we will make some assumptions about the operator. If only 2 values are
        // passed to the method, we will assume that the operator is an equals sign
        // and keep going. Otherwise, we'll require the operator to be passed in.
        if (func_num_args() == 2) {
            list( $value, $operator ) = [$operator, '='];
        }
        // If the columns is actually a Closure instance, we will assume the developer
        // wants to begin a nested where statement which is wrapped in parenthesis.
        // We'll add that Closure to the query then return back out immediately.
        if ($column instanceof Closure) {
            throw new NotSupportedException('Closure in where clause is not supported');
        }
        // If the given operator is not found in the list of valid operators we will
        // assume that the developer is just short-cutting the '=' operators and
        // we will set the operators to '=' and set the values appropriately.
        if ( ! ComparisonOperator::isValidOperator($operator)) {
            list( $value, $operator ) = [$operator, '='];
        }
        // If the value is a Closure, it means the developer is performing an entire
        // sub-select within the query and we will need to compile the sub-select
        // within the where clause to get the appropriate query record results.
        if ($value instanceof Closure) {
            throw new NotSupportedException('Closure in where clause is not supported');
        }
        $attributeValueList = $this->marshalItem([
            'AttributeValueList' => $value,
        ]);

        $this->where[$column] = [
            'AttributeValueList' => [$attributeValueList['AttributeValueList']],
            'ComparisonOperator' => ComparisonOperator::getDynamoDbOperator($operator),
        ];

        return $this;
    }
422170
public function where($column, $value=null)
    {
        try {
            if (!is_null($this->query)) {
                if($column instanceof \Closure) {
                    $this->groupWhere($column);
                } else {
                    $this->query .= ' AND '.$column. ' = "'.$value.'"';
                }
                return $this;
            }

        } catch (\Exception $exception) {
            var_dump($exception->getMessage());
        }
    }
896476
final public function countByColumn($column, $value, $field = null)
    {
        $this->validateShortcutData();
        $alias = 'count';

        if ($field === null) {
            $field = $this->getPk();
        }

        return (int) $this->db->select()
                            ->count($field, $alias)
                            ->from(static::getTableName())
                            ->whereEquals($column, $value)
                            ->query($alias);
    }
1020618
public function orWhereMonth($column, $operator, $value = null)
    {
        $this->wConditions()->orMonth(...func_get_args());

        return $this;
    }
434533
public function increment($column, $value)
    {
        $this->params[':column'] = $value;
        $query = "UPDATE `{$this->table}` {$this->join} SET `$column` = `$column` + :$column";
        if ($this->condition) {
            $query .= " WHERE {$this->condition}";
        }
        if ($this->limit) {
            $query .= " LIMIT {$this->limit}";
        }

        return $this->connection->execQuery($query, $this->params);
    }
606510
protected function addWhere($query, $column, $operator, $value)
    {
        if ('in' === $operator) {
            return $query->whereIn($column, $value);
        } elseif ('between' === $operator) {
            return $query->whereBetween($column, $value);
        } else {
            return $query->where($column, $operator, $value);
        }
    }
1186347
public function setColumn(string $column, $value)
    {
        $this->table->getColumn($column);

        $this->columnData[$column] = $value;
    }
695837
public function setColumn($column, $value)
    {
        // Iterate through the objects.
        foreach ($this->data as $data) {
            // Set the property.
            $data->$column = $value;
        }

        return $this;
    }
1370831
public function set(string $column, string $value)
    {
        $this->addSet($this->dialect()->quoteName($column) . ' = ?', [$value]);

        return $this;
    }