Move whole WHERE clause to a column named `column`.
517877
def move_where_clause_to_column(self, column='condition', key=None):
        
        if self.conditions:
            expr = " AND ".join(self.conditions)
            params = self.params
            self.params = []
            self.conditions = []
        else:
            expr = '1'
            params = []
        self.add_column('({0}) AS {1}'.format(expr, column),
                        key or column,
                        params)
1207864
def find_column(t):
    """"""
    pos = t.lexer.lexpos
    data = t.lexer.lexdata
    last_cr = data.rfind('\n', 0, pos)
    if last_cr < 0:
        last_cr = -1
    column = pos - last_cr
    return column
373857
def normalize_column_name(name):
    """"""
    if not isinstance(name, six.string_types):
        raise ValueError('%r is not a valid column name.' % name)

    # limit to 63 characters
    name = name.strip()[:63]
    # column names can be 63 *bytes* max in postgresql
    if isinstance(name, six.text_type):
        while len(name.encode('utf-8')) >= 64:
            name = name[:len(name) - 1]

    if not len(name) or '.' in name or '-' in name:
        raise ValueError('%r is not a valid column name.' % name)
    return name
328774
function selectByIdWhereSql () {
    // get id column
    var idColumn = this.model.columnName('id')
    // every where statement will begin with the alias and column name
    var columnSql = `${this.alias}.${this.quoteName(idColumn)}`
    // sql for where query
    var sql
    // if ids are array build in query
    if (Array.isArray(this.args.where.id)) {
        var i = 0
        // get placeholder for each in value
        var placeholders = _.map(this.args.where.id, id => {
            // get param name
            var paramName = `id${i}`
            // increment param counter
            i++
            // set value for param placeholder
            this.params[paramName] = id
            // create placeholder
            return this.unhexId(`:${paramName}`)
        })
        // return where sql
        sql = `WHERE ${columnSql} IN(${placeholders.join(', ')})`
    }
    // otherwise build equals query
    else {
        // set value for param placeholder
        this.params.id = this.args.where.id
        // get place holder
        var placeholder = this.unhexId(':id')
        // return where sql
        sql = `WHERE ${columnSql} = ${placeholder}`
    }
    // and deleted check if d column exists and set in args
    if (defined(this.model.columns.d) && typeof this.args.where.isDeleted === 'boolean') {
        sql += ` AND ${this.alias}.d = ${this.args.where.isDeleted ? 1 : 0}`
    }

    return sql
}
1256241
def apply(self, query, value, alias):
        
        try:
            value = uuid.UUID(value)
            return query.filter(self.column == value)
        except ValueError:
            return query
1233039
public Where<T, ID> le(String columnName, Object value) throws SQLException {
		addClause(new SimpleComparison(columnName, findColumnFieldType(columnName), value,
				SimpleComparison.LESS_THAN_EQUAL_TO_OPERATION));
		return this;
	}
268845
public Message5WH_Builder setWhere(Object where, int line, int column){
		this.whereLocation = where;
		this.whereLine = line;
		this.whereColumn = column;
		return this;
	}
155957
def update(self, columns=(), by=(), where=(), **kwds):
        
        return self._seu('update', columns, by, where, kwds)
1138909
def move_column(column=1, file=sys.stdout):
    
    move.column(column).write(file=file)
670444
def _remove_column(self, name):
        
        self._columns = filter(lambda c: c.name != name, self._columns)

        return self
445526
def delete(table, where=(), **kwargs):
    """"""
    where = dict(where, **kwargs).items()
    sql, args = makeSQL("DELETE", table, where=where)
    return execute(sql, args).rowcount
1226817
public void moveSQLToField(ResultSet resultset, int iColumn) throws SQLException
    {
        int sResult = resultset.getInt(iColumn);
        if (resultset.wasNull())
            this.setString(Constants.BLANK, false, DBConstants.READ_MOVE);  // Null value
        else
        {
            if ((!this.isNullable()) && (sResult == NAN))
                this.setString(Constants.BLANK, false, DBConstants.READ_MOVE);  // Null value
            else
                this.setValue(sResult, false, DBConstants.READ_MOVE);
        }
    }
613480
def ColumnToIndex (col):
        """"""
        ndx = 0
        for c in col:
                ndx = ndx * 26 + ord(c.upper()) - 64
        return ndx
321132
def delete(self, table, where=None):
        """"""
        if where:
            where_key, where_val = where
            query = "DELETE FROM {0} WHERE {1}='{2}'".format(wrap(table), where_key, where_val)
        else:
            query = 'DELETE FROM {0}'.format(wrap(table))
        self.execute(query)
        return True
15082
def drop_column(self, table, name):
        """"""
        try:
            self.execute('ALTER TABLE {0} DROP COLUMN {1}'.format(wrap(table), name))
            self._printer('\tDropped column {0} from {1}'.format(name, table))
        except ProgrammingError:
            self._printer("\tCan't DROP '{0}'; check that column/key exists in '{1}'".format(name, table))
        return name
54006
public Where<T, ID> in(String columnName, Iterable<?> objects) throws SQLException {
		addClause(new In(columnName, findColumnFieldType(columnName), objects, true));
		return this;
	}
654868
final protected function where_like($column, $replace, $position = 'both', $or = false){
        switch( strtolower($position) ){
            case 'left':
                $replace = '%'.$replace;
                break;
            case 'right':
                $replace = $replace.'%';
                break;
            default:
                $replace = '%'.$replace.'%';
                break;
        }
        $column = $this->escape_column_name($column);
        $this->_wheres[] = [$this->and_or($or), $this->db->prepare("{$column} LIKE %s", $replace)];
        return $this;
    }