WHERE some_column=some_value
513519
public static function update($table, $record, $condition = null)
    {
        if(empty($record) || empty($condition)) return null;

        $query = array("UPDATE $table SET ");
        array_push($query, implode('=? , ', array_keys($record)));
        array_push($query, "=? WHERE $condition");
        return implode($query);
    }
538183
def where_values(attribute, type = :integer)
      return @where_values[attribute] if @where_values.key?(attribute)
      @where_values[attribute] ||= array_of_values(@wheres[attribute], type)
    end
1153805
def find(self, id, columns=None):
        
        if not columns:
            columns = ['*']

        return self.where('id', '=', id).first(1, columns)
411268
public function whereGreaterThan($column, $value, $filter = false)
    {
        return $this->where($column, '>', $value, $filter);
    }
996566
def equal_to(self, key, value):
        
        self._where[key] = utils.encode(value)
        return self
473332
def filter(self, column, condition='!=', value=None):
        
        ret = self.__class__(
            columns=self.columns, row_columns=self.row_columns, tab=self.tab,
            key_on=self.key_on)
        for row in self:
            if getattr(row[column], condition, None):
                if eval('row[column].%s(%s)' % (condition, value)):
                    ret.append(row)
            if eval('row[column] %s value' % condition):
                ret.append(row)
        return ret
576885
def eval_where(where_list,composite_row,nix,tables_dict):
  ""
  # todo: do I need to use 3vl instead of all() to merge where_list?
  evaluator = Evaluator(composite_row,nix,tables_dict)
  return all(evaluator.eval(w) for w in where_list)
642860
private static List<Object> andWhere(ActiveRecord activeRecord, int[] pos, StringBuilder sqlBuf) {
        if (!activeRecord.whereValues.isEmpty()) {
            if (sqlBuf.indexOf(Const.SPACE + Const.SQL_WHERE + Const.SPACE) == -1) {
                sqlBuf.append(Const.SPACE + Const.SQL_WHERE + Const.SPACE);
            }
            return activeRecord.whereValues.stream()
                    .map(where -> {
                        if ("IS".equals(where.getOpt())) {
                            sqlBuf.append(where.getKey()).append(" ").append(where.getValue());
                            return null;
                        } else {
                            String c = where.getOpt();
                            sqlBuf.append(where.getKey()).append(" ").append(c).append(" ");
                            if (c.equals(Const.SQL_IN)) {
                                sqlBuf.append(Const.IN_START);
                            }
                            sqlBuf.append(":p").append(pos[0]++);
                            if (c.equals(Const.SQL_IN)) {
                                sqlBuf.append(Const.IN_END);
                            }
                        }
                        sqlBuf.append(" AND ");
                        return where.getValue();
                    })
                    .filter(Objects::nonNull)
                    .collect(Collectors.toList());
        }
        return null;
    }
702768
public function ne($value, bool $is_column = false): WhereStatement
    {
        return $this->isNot($value, $is_column);
    }
1337550
public function orWhere($column, $operator, $value = null)
    {
        $this->orWheres[] = new Where($column, $operator, $value, 'OR');

        return $this;
    }
1227395
public function where($column, $value, $operator = '=', $table = null)
    {
        $table = $table? $table : $this->table;
        $this->wheres[] = [
            'table' => $table,
            'column' => $column,
            'value' => $value,
            'operator' => $operator
        ];
        return $this;
    }
251774
public function greaterThan($value, bool $is_column = false): WhereStatement
    {
        return $this->addCondition($value, '>', $is_column);
    }
78136
public function whereEqualsOrGreaterThan($column, $value, $filter = false)
    {
        return $this->where($column, '>=', $value, $filter);
    }
309424
def hasColumn(self, column, recurse=True, flags=0):
        
        return column in self.columns(recurse=recurse, flags=flags)
186353
public Where<T, ID> ge(String columnName, Object value) throws SQLException {
		addClause(new SimpleComparison(columnName, findColumnFieldType(columnName), value,
				SimpleComparison.GREATER_THAN_EQUAL_TO_OPERATION));
		return this;
	}
711606
public function whereNotEquals($column, $value, $filter = false)
    {
        return $this->where($column, '!=', $value, $filter);
    }
554005
def _where_clause(where):
        
        assert isinstance(where, tuple)
        if len(where) == 3:
            where_col, operator, where_val = where
        else:
            where_col, where_val = where
            operator = '='
        assert operator in SELECT_WHERE_OPERATORS

        # Concatenate WHERE clause (ex: **first_name='John'**)
        return "{0}{1}'{2}'".format(where_col, operator, where_val)