Add the given column update; the value may be null.
192654
private void addColumn(String storeName, String rowKey, String colName, byte[] colValue) {
        Map<String, Map<String, byte[]>> rowMap = m_columnAdds.get(storeName);
        if (rowMap == null) {
            rowMap = new HashMap<>();
            m_columnAdds.put(storeName, rowMap);
        }
        
        Map<String, byte[]> colMap = rowMap.get(rowKey);
        if (colMap == null) {
            colMap = new HashMap<>();
            rowMap.put(rowKey, colMap);
        }
        
        byte[] oldValue = colMap.put(colName, colValue);
        if (oldValue == null) {
            m_totalUpdates++;
        } else if (!Arrays.equals(oldValue, colValue)) {
            m_logger.debug("Warning: duplicate column mutation with different value: " +
                           "store={}, row={}, col={}, old={}, new={}",
                           new Object[]{storeName, rowKey, colName, oldValue, colValue});
        }
    }
814403
private String alterColumnSetNotNull(String tableName, List<String> columnNames) {
        List<String> statement = new ArrayList<>();
        statement.add("ALTER TABLE");
        statement.add(quotize(tableName));

        for (String columnName : columnNames) {
            statement.add("ALTER COLUMN");
            statement.add(quotize(columnName));
            statement.add("SET NOT NULL");
        }

        return join(statement, " ");
    }
399412
def _updateColumnValues(self, index, hidden):
        
        if hidden or not self.isVisible():
            return
        
        column = self.columnOf(index)
        if not column in self._loadedColumns:
            self._loadedColumns.add(column)
            
            records = self.collectRecords()
            self.loadColumnsRequested.emit(records, column)
160513
private BoundStatement addColumnDelete(String tableName, String key, String colName) {
        PreparedStatement prepState = m_dbservice.getPreparedUpdate(Update.DELETE_COLUMN, tableName);
        BoundStatement boundState = prepState.bind();
        boundState.setString(0, key);
        boundState.setString(1, colName);
        return boundState;
    }
747845
public void addColumn(DefaultTableColumn column) {
        column.setModelIndex(columnModel.getColumnCount());
        columnModel.addColumn(column);
    }
1352648
public Row addColumn(int index, String name, Object value) {
        Objects.requireNonNull(name, "Name of the column cannot be null");
        Objects.requireNonNull(value, "Value of " + name + " cannot be null");
        final Column column = new Column(index, name, value);
        return this.addColumn(column);
    }
1290725
public void addColumn(ColumnSchema column) {

        String name = column.getName().name;

        if (findColumn(name) >= 0) {
            throw Error.error(ErrorCode.X_42504, name);
        }

        if (column.isIdentity()) {
            if (identityColumn != -1) {
                throw Error.error(ErrorCode.X_42525, name);
            }

            identityColumn   = getColumnCount();
            identitySequence = column.getIdentitySequence();
        }

        addColumnNoCheck(column);
    }
816698
@Override
	public int update(DataColumnConstraints dataColumnConstraints)
			throws SQLException {

		UpdateBuilder<DataColumnConstraints, Void> ub = updateBuilder();
		ub.updateColumnValue(DataColumnConstraints.COLUMN_MIN,
				dataColumnConstraints.getMin());
		ub.updateColumnValue(DataColumnConstraints.COLUMN_MIN_IS_INCLUSIVE,
				dataColumnConstraints.getMinIsInclusive());
		ub.updateColumnValue(DataColumnConstraints.COLUMN_MAX,
				dataColumnConstraints.getMax());
		ub.updateColumnValue(DataColumnConstraints.COLUMN_MAX_IS_INCLUSIVE,
				dataColumnConstraints.getMaxIsInclusive());
		ub.updateColumnValue(DataColumnConstraints.COLUMN_DESCRIPTION,
				dataColumnConstraints.getDescription());

		setUniqueWhere(ub.where(), dataColumnConstraints.getConstraintName(),
				dataColumnConstraints.getConstraintType(),
				dataColumnConstraints.getValue());

		PreparedUpdate<DataColumnConstraints> update = ub.prepare();
		int updated = update(update);

		return updated;
	}
756963
def upsert(self, table, value, update_columns=None, commit=True):
        
        if not isinstance(value, dict):
            raise TypeError('Input value should be a dictionary')

        if not update_columns:
            update_columns = value.keys()

        value_q, _args = self._value_parser(value, columnname=False)

        _sql = ''.join(['INSERT INTO ', self._backtick(table), ' (', self._backtick_columns(value), ') VALUES ',
                        '(', value_q, ') ',
                        'ON DUPLICATE KEY UPDATE ',
                        ', '.join(['='.join([k, 'VALUES('+k+')']) for k in update_columns]), ';'])

        if self.debug:
            return self.cur.mogrify(_sql, _args)

        self.cur.execute(_sql, _args)
        if commit:
            self.conn.commit()
        return self.cur.lastrowid
110377
public void addUpdate(final Update update) {
        if (updates == null) {
            updates = new ArrayList<Update>();
        }
        updates.add(update);
    }
1364188
private void alterColumn(AlterTableOptions alterTableOptions, Schema schema, ColumnInfo columnInfo,
            AtomicBoolean updated)
    {
        if (!KuduDBDataHandler.hasColumn(schema, columnInfo.getColumnName()))
        {
            // add if column is not in schema
            alterTableOptions.addNullableColumn(columnInfo.getColumnName(),
                    KuduDBValidationClassMapper.getValidTypeForClass(columnInfo.getType()));
            updated.set(true);
        }
        else
        {
            // check for type, drop and add if not consistent TODO: throw
            // exception or override?
            if (!schema.getColumn(columnInfo.getColumnName()).getType()
                    .equals(KuduDBValidationClassMapper.getValidTypeForClass(columnInfo.getType())))
            {
                alterTableOptions.dropColumn(columnInfo.getColumnName());
                alterTableOptions.addNullableColumn(columnInfo.getColumnName(),
                        KuduDBValidationClassMapper.getValidTypeForClass(columnInfo.getType()));
                updated.set(true);
            }
        }
    }
1113617
public static void addIfNotNull(JSONWriter writer, String field,
			Date value, final SimpleDateFormat format) throws JSONException {
		if (value == null)
			return;
		writer.key(field);
		writer.value(format.format(value));
	}
484718
public int update() {
        this.beforeCheck();
        String       sql             = this.buildUpdateSQL(null, updateColumns);
        List<Object> columnValueList = new ArrayList<>();
        updateColumns.forEach((key, value) -> columnValueList.add(value));
        columnValueList.addAll(paramValues);
        return this.execute(sql, columnValueList);
    }
562752
void addColumn(String columnName)
    {
        data.add(new ArrayList<String>());
        columnNames.add(columnName);
    }
285552
public void put(Boolean value) {
		if (value == null) {
			this.compiledStatement.bindNull(compiledStatementBindIndex++);
		} else {
			this.compiledStatement.bindLong(compiledStatementBindIndex++, (value == true ? 1 : 0));
		}
	}
132509
private void addColumn(StringBuilder builder, Column column) {
		builder.append(column.getColumnName());
		builder.append(" ");
		builder.append(column.getDataType().getType());
		Boolean optional = column.isOptional();
		if (optional != null) {
			builder.append(optional ? " NULL" : " NOT NULL");
		}
		String extraQualifier = column.getExtraQualifier();
		if (extraQualifier != null) {
			builder.append(" ");
			builder.append(extraQualifier);
		}
	}
1206469
static void mergeUpdate(HashMappedList rowSet, Row row, Object[] newData,
                            int[] cols) {

        Object[] data = (Object[]) rowSet.get(row);

        if (data != null) {
            for (int j = 0; j < cols.length; j++) {
                data[cols[j]] = newData[cols[j]];
            }
        } else {
            rowSet.add(row, newData);
        }
    }