// updateRow adds to the batch the kv operations necessary to update a table row
// with the given values.
//
// The row corresponding to oldValues is updated with the ones in updateValues.
// Note that updateValues only contains the ones that are changing.
//
// The return value is only good until the next call to UpdateRow.
func (ru *rowUpdater) updateRow(
b *client.Batch,
oldValues []parser.Datum,
updateValues []parser.Datum,
) ([]parser.Datum, error) {
if len(oldValues) != len(ru.fetchCols) {
return nil, util.Errorf("got %d values but expected %d", len(oldValues), len(ru.fetchCols))
}
if len(updateValues) != len(ru.updateCols) {
return nil, util.Errorf("got %d values but expected %d", len(updateValues), len(ru.updateCols))
}
primaryIndexKey, secondaryIndexEntries, err := ru.helper.encodeIndexes(ru.fetchColIDtoRowIndex, oldValues)
if err != nil {
return nil, err
}
// Check that the new value types match the column types. This needs to
// happen before index encoding because certain datum types (i.e. tuple)
// cannot be used as index values.
for i, val := range updateValues {
if ru.marshalled[i], err = sqlbase.MarshalColumnValue(ru.updateCols[i], val); err != nil {
return nil, err
}
}
// Update the row values.
copy(ru.newValues, oldValues)
for i, updateCol := range ru.updateCols {
ru.newValues[ru.fetchColIDtoRowIndex[updateCol.ID]] = updateValues[i]
}
newPrimaryIndexKey := primaryIndexKey
rowPrimaryKeyChanged := false
var newSecondaryIndexEntries []sqlbase.IndexEntry
if ru.primaryKeyColChange {
newPrimaryIndexKey, newSecondaryIndexEntries, err = ru.helper.encodeIndexes(ru.fetchColIDtoRowIndex, ru.newValues)
if err != nil {
return nil, err
}
rowPrimaryKeyChanged = !bytes.Equal(primaryIndexKey, newPrimaryIndexKey)
} else {
newSecondaryIndexEntries, err = sqlbase.EncodeSecondaryIndexes(
ru.helper.tableDesc.ID, ru.helper.indexes, ru.fetchColIDtoRowIndex, ru.newValues)
if err != nil {
return nil, err
}
}
if rowPrimaryKeyChanged {
err := ru.rd.deleteRow(b, oldValues)
if err != nil {
return nil, err
}
err = ru.ri.insertRow(b, ru.newValues)
return ru.newValues, err
}
// Update secondary indexes.
for i, newSecondaryIndexEntry := range newSecondaryIndexEntries {
secondaryIndexEntry := secondaryIndexEntries[i]
secondaryKeyChanged := !bytes.Equal(newSecondaryIndexEntry.Key, secondaryIndexEntry.Key)
if secondaryKeyChanged {
if log.V(2) {
log.Infof("Del %s", secondaryIndexEntry.Key)
}
b.Del(secondaryIndexEntry.Key)
// Do not update Indexes in the DELETE_ONLY state.
if _, ok := ru.deleteOnlyIndex[i]; !ok {
if log.V(2) {
log.Infof("CPut %s -> %v", newSecondaryIndexEntry.Key, newSecondaryIndexEntry.Value)
}
b.CPut(newSecondaryIndexEntry.Key, newSecondaryIndexEntry.Value, nil)
}
}
}
// Add the new values.
for i, val := range updateValues {
col := ru.updateCols[i]
if ru.helper.columnInPK(col.ID) {
// Skip primary key columns as their values are encoded in the row
// sentinel key which is guaranteed to exist for as long as the row
// exists.
continue
}
ru.key = keys.MakeColumnKey(newPrimaryIndexKey, uint32(col.ID))
if ru.marshalled[i].RawBytes != nil {
// We only output non-NULL values. Non-existent column keys are
// considered NULL during scanning and the row sentinel ensures we know
// the row exists.
if log.V(2) {
log.Infof("Put %s -> %v", ru.key, val)
}
b.Put(&ru.key, &ru.marshalled[i])
} else {
// The column might have already existed but is being set to NULL, so
// delete it.
if log.V(2) {
log.Infof("Del %s", ru.key)
}
b.Del(&ru.key)
}
ru.key = nil
}
return ru.newValues, nil
}
// insertRow adds to the batch the kv operations necessary to insert a table row
// with the given values.
func (ri *rowInserter) insertRow(b *client.Batch, values []parser.Datum) error {
if len(values) != len(ri.insertCols) {
return util.Errorf("got %d values but expected %d", len(values), len(ri.insertCols))
}
// Encode the values to the expected column type. This needs to
// happen before index encoding because certain datum types (i.e. tuple)
// cannot be used as index values.
for i, val := range values {
// Make sure the value can be written to the column before proceeding.
var err error
if ri.marshalled[i], err = sqlbase.MarshalColumnValue(ri.insertCols[i], val); err != nil {
return err
}
}
primaryIndexKey, secondaryIndexEntries, err := ri.helper.encodeIndexes(ri.insertColIDtoRowIndex, values)
if err != nil {
return err
}
// Write the row sentinel. We want to write the sentinel first in case
// we are trying to insert a duplicate primary key: if we write the
// secondary indexes first, we may get an error that looks like a
// uniqueness violation on a non-unique index.
ri.key = keys.MakeNonColumnKey(primaryIndexKey)
if log.V(2) {
log.Infof("CPut %s -> NULL", ri.key)
}
// Each sentinel value needs a distinct RawBytes field as the computed
// checksum includes the key the value is associated with.
ri.sentinelValue.SetBytes([]byte{})
b.CPut(&ri.key, &ri.sentinelValue, nil)
ri.key = nil
for _, secondaryIndexEntry := range secondaryIndexEntries {
if log.V(2) {
log.Infof("CPut %s -> %v", secondaryIndexEntry.Key, secondaryIndexEntry.Value)
}
ri.key = secondaryIndexEntry.Key
b.CPut(&ri.key, secondaryIndexEntry.Value, nil)
}
ri.key = nil
// Write the row columns.
for i, val := range values {
col := ri.insertCols[i]
if ri.helper.columnInPK(col.ID) {
// Skip primary key columns as their values are encoded in the row
// sentinel key which is guaranteed to exist for as long as the row
// exists.
continue
}
if ri.marshalled[i].RawBytes != nil {
// We only output non-NULL values. Non-existent column keys are
// considered NULL during scanning and the row sentinel ensures we know
// the row exists.
ri.key = keys.MakeColumnKey(primaryIndexKey, uint32(col.ID))
if log.V(2) {
log.Infof("CPut %s -> %v", ri.key, val)
}
b.CPut(&ri.key, &ri.marshalled[i], nil)
ri.key = nil
}
}
return nil
}
// updateRow adds to the batch the kv operations necessary to update a table row
// with the given values.
//
// The row corresponding to oldValues is updated with the ones in updateValues.
// Note that updateValues only contains the ones that are changing.
//
// The return value is only good until the next call to UpdateRow.
func (ru *rowUpdater) updateRow(
b *client.Batch,
oldValues []parser.Datum,
updateValues []parser.Datum,
) ([]parser.Datum, error) {
if len(oldValues) != len(ru.fetchCols) {
return nil, errors.Errorf("got %d values but expected %d", len(oldValues), len(ru.fetchCols))
}
if len(updateValues) != len(ru.updateCols) {
return nil, errors.Errorf("got %d values but expected %d", len(updateValues), len(ru.updateCols))
}
primaryIndexKey, secondaryIndexEntries, err := ru.helper.encodeIndexes(ru.fetchColIDtoRowIndex, oldValues)
if err != nil {
return nil, err
}
// The secondary index entries returned by rowHelper.encodeIndexes are only
// valid until the next call to encodeIndexes. We need to copy them so that
// we can compare against the new secondary index entries.
secondaryIndexEntries = append(ru.indexEntriesBuf[:0], secondaryIndexEntries...)
ru.indexEntriesBuf = secondaryIndexEntries
// Check that the new value types match the column types. This needs to
// happen before index encoding because certain datum types (i.e. tuple)
// cannot be used as index values.
for i, val := range updateValues {
if ru.marshalled[i], err = sqlbase.MarshalColumnValue(ru.updateCols[i], val); err != nil {
return nil, err
}
}
// Update the row values.
copy(ru.newValues, oldValues)
for i, updateCol := range ru.updateCols {
ru.newValues[ru.fetchColIDtoRowIndex[updateCol.ID]] = updateValues[i]
}
rowPrimaryKeyChanged := false
var newSecondaryIndexEntries []sqlbase.IndexEntry
if ru.primaryKeyColChange {
var newPrimaryIndexKey []byte
newPrimaryIndexKey, newSecondaryIndexEntries, err =
ru.helper.encodeIndexes(ru.fetchColIDtoRowIndex, ru.newValues)
if err != nil {
return nil, err
}
rowPrimaryKeyChanged = !bytes.Equal(primaryIndexKey, newPrimaryIndexKey)
} else {
newSecondaryIndexEntries, err =
ru.helper.encodeSecondaryIndexes(ru.fetchColIDtoRowIndex, ru.newValues)
if err != nil {
return nil, err
}
}
if rowPrimaryKeyChanged {
if err := ru.fks.checkIdx(ru.helper.tableDesc.PrimaryIndex.ID, oldValues, ru.newValues); err != nil {
return nil, err
}
for i := range newSecondaryIndexEntries {
if !bytes.Equal(newSecondaryIndexEntries[i].Key, secondaryIndexEntries[i].Key) {
if err := ru.fks.checkIdx(ru.helper.indexes[i].ID, oldValues, ru.newValues); err != nil {
return nil, err
}
}
}
if err := ru.rd.deleteRow(b, oldValues); err != nil {
return nil, err
}
if err := ru.ri.insertRow(b, ru.newValues, false); err != nil {
return nil, err
}
return ru.newValues, nil
}
// Add the new values.
// TODO(dan): This has gotten very similar to the loop in insertRow, see if
// they can be DRY'd. Ideally, this would also work for
// truncateAndBackfillColumnsChunk, which is currently abusing rowUdpdater.
for i, family := range ru.helper.tableDesc.Families {
update := false
for _, colID := range family.ColumnIDs {
if _, ok := ru.updateColIDtoRowIndex[colID]; ok {
update = true
break
}
}
if !update {
continue
}
if i > 0 {
// HACK: MakeFamilyKey appends to its argument, so on every loop iteration
// after the first, trim primaryIndexKey so nothing gets overwritten.
// TODO(dan): Instead of this, use something like engine.ChunkAllocator.
primaryIndexKey = primaryIndexKey[:len(primaryIndexKey):len(primaryIndexKey)]
}
if len(family.ColumnIDs) == 1 && family.ColumnIDs[0] == family.DefaultColumnID {
// Storage optimization to store DefaultColumnID directly as a value. Also
// backwards compatible with the original BaseFormatVersion.
idx, ok := ru.updateColIDtoRowIndex[family.DefaultColumnID]
if !ok {
continue
}
ru.key = keys.MakeFamilyKey(primaryIndexKey, uint32(family.ID))
if log.V(2) {
log.Infof("Put %s -> %v", ru.key, ru.marshalled[idx].PrettyPrint())
}
b.Put(&ru.key, &ru.marshalled[idx])
ru.key = nil
continue
}
ru.key = keys.MakeFamilyKey(primaryIndexKey, uint32(family.ID))
ru.valueBuf = ru.valueBuf[:0]
var lastColID sqlbase.ColumnID
familySortedColumnIDs, ok := ru.helper.sortedColumnFamily(family.ID)
if !ok {
panic("invalid family sorted column id map")
}
for _, colID := range familySortedColumnIDs {
if ru.helper.columnInPK(colID) {
if family.ID != 0 {
return nil, errors.Errorf("primary index column %d must be in family 0, was %d", colID, family.ID)
}
// Skip primary key columns as their values are encoded in the key of
// each family. Family 0 is guaranteed to exist and acts as a sentinel.
continue
}
idx, ok := ru.fetchColIDtoRowIndex[colID]
if !ok {
return nil, errors.Errorf("column %d was expected to be fetched, but wasn't", colID)
}
col := ru.fetchCols[idx]
if ru.newValues[idx].Compare(parser.DNull) == 0 {
continue
}
if lastColID > col.ID {
panic(fmt.Errorf("cannot write column id %d after %d", col.ID, lastColID))
}
colIDDiff := col.ID - lastColID
lastColID = col.ID
ru.valueBuf, err = sqlbase.EncodeTableValue(ru.valueBuf, colIDDiff, ru.newValues[idx])
if err != nil {
return nil, err
}
}
if family.ID != 0 && len(ru.valueBuf) == 0 {
// The family might have already existed but every column in it is being
// set to NULL, so delete it.
if log.V(2) {
log.Infof("Del %s", ru.key)
}
b.Del(&ru.key)
} else {
ru.value.SetTuple(ru.valueBuf)
if log.V(2) {
log.Infof("Put %s -> %v", ru.key, ru.value.PrettyPrint())
}
b.Put(&ru.key, &ru.value)
}
ru.key = nil
}
// Update secondary indexes.
for i, newSecondaryIndexEntry := range newSecondaryIndexEntries {
secondaryIndexEntry := secondaryIndexEntries[i]
secondaryKeyChanged := !bytes.Equal(newSecondaryIndexEntry.Key, secondaryIndexEntry.Key)
if secondaryKeyChanged {
if err := ru.fks.checkIdx(ru.helper.indexes[i].ID, oldValues, ru.newValues); err != nil {
return nil, err
}
if log.V(2) {
log.Infof("Del %s", secondaryIndexEntry.Key)
}
b.Del(secondaryIndexEntry.Key)
// Do not update Indexes in the DELETE_ONLY state.
if _, ok := ru.deleteOnlyIndex[i]; !ok {
if log.V(2) {
log.Infof("CPut %s -> %v", newSecondaryIndexEntry.Key, newSecondaryIndexEntry.Value.PrettyPrint())
}
b.CPut(newSecondaryIndexEntry.Key, &newSecondaryIndexEntry.Value, nil)
}
}
}
return ru.newValues, nil
}
func (sc *SchemaChanger) truncateAndBackfillColumnsChunk(
added []sqlbase.ColumnDescriptor,
dropped []sqlbase.ColumnDescriptor,
nonNullableColumn string,
defaultExprs []parser.TypedExpr,
evalCtx parser.EvalContext,
sp sqlbase.Span,
) (roachpb.Key, bool, error) {
var curSentinel roachpb.Key
done := false
err := sc.db.Txn(func(txn *client.Txn) error {
tableDesc, err := getTableDescFromID(txn, sc.tableID)
if err != nil {
return err
}
// Short circuit the backfill if the table has been deleted.
if tableDesc.Deleted {
done = true
return nil
}
// Run a scan across the table using the primary key. Running
// the scan and applying the changes in many transactions is
// fine because the schema change is in the correct state to
// handle intermediate OLTP commands which delete and add
// values during the scan.
b := &client.Batch{}
b.Scan(sp.Start, sp.End, ColumnTruncateAndBackfillChunkSize)
if err := txn.Run(b); err != nil {
return err
}
// Use a different batch to truncate/backfill columns.
writeBatch := &client.Batch{}
marshalled := make([]roachpb.Value, len(defaultExprs))
done = true
for _, result := range b.Results {
var sentinelKey roachpb.Key
for _, kv := range result.Rows {
// Still processing table.
done = false
if nonNullableColumn != "" {
return fmt.Errorf("column %s contains null values", nonNullableColumn)
}
if sentinelKey == nil || !bytes.HasPrefix(kv.Key, sentinelKey) {
// Sentinel keys have a 0 suffix indicating 0 bytes of
// column ID. Strip off that suffix to determine the
// prefix shared with the other keys for the row.
sentinelKey = sqlbase.StripColumnIDLength(kv.Key)
// Store away key for the next table row as the point from
// which to start from.
curSentinel = sentinelKey
// Delete the entire dropped columns. This used to use SQL
// UPDATE in the past to update the dropped column to
// NULL; but a column in the process of being dropped is
// placed in the table descriptor mutations, and a SQL
// UPDATE of a column in mutations will fail.
for _, columnDesc := range dropped {
// Delete the dropped column.
colKey := keys.MakeColumnKey(sentinelKey, uint32(columnDesc.ID))
if log.V(2) {
log.Infof("Del %s", colKey)
}
writeBatch.Del(colKey)
}
// Add the new columns and backfill the values.
for i, expr := range defaultExprs {
if expr == nil {
continue
}
col := added[i]
colKey := keys.MakeColumnKey(sentinelKey, uint32(col.ID))
d, err := expr.Eval(evalCtx)
if err != nil {
return err
}
marshalled[i], err = sqlbase.MarshalColumnValue(col, d)
if err != nil {
return err
}
if log.V(2) {
log.Infof("Put %s -> %v", colKey, d)
}
// Insert default value into the column. If this row
// was recently added the default value might have
// already been populated, because the
// ColumnDescriptor is in the WRITE_ONLY state.
// Reinserting the default value is not a big deal.
//
// Note: a column in the WRITE_ONLY state cannot be
// populated directly through SQL. A SQL INSERT cannot
// directly reference the column, and the INSERT
// populates the column with the default value.
writeBatch.Put(colKey, &marshalled[i])
}
}
}
}
if err := txn.Run(writeBatch); err != nil {
for _, r := range writeBatch.Results {
if r.PErr != nil {
return convertBackfillError(tableDesc, writeBatch, r.PErr)
}
}
return err
}
return nil
})
return curSentinel.PrefixEnd(), done, err
}
// insertRow adds to the batch the kv operations necessary to insert a table row
// with the given values.
func (ri *rowInserter) insertRow(b *client.Batch, values []parser.Datum, ignoreConflicts bool) error {
if len(values) != len(ri.insertCols) {
return errors.Errorf("got %d values but expected %d", len(values), len(ri.insertCols))
}
putFn := insertCPutFn
if ignoreConflicts {
putFn = insertPutFn
}
// Encode the values to the expected column type. This needs to
// happen before index encoding because certain datum types (i.e. tuple)
// cannot be used as index values.
for i, val := range values {
// Make sure the value can be written to the column before proceeding.
var err error
if ri.marshalled[i], err = sqlbase.MarshalColumnValue(ri.insertCols[i], val); err != nil {
return err
}
}
if err := ri.fks.checkAll(values); err != nil {
return err
}
primaryIndexKey, secondaryIndexEntries, err := ri.helper.encodeIndexes(ri.insertColIDtoRowIndex, values)
if err != nil {
return err
}
// Add the new values.
// TODO(dan): This has gotten very similar to the loop in updateRow, see if
// they can be DRY'd. Ideally, this would also work for
// truncateAndBackfillColumnsChunk, which is currently abusing rowUdpdater.
for i, family := range ri.helper.tableDesc.Families {
if i > 0 {
// HACK: MakeFamilyKey appends to its argument, so on every loop iteration
// after the first, trim primaryIndexKey so nothing gets overwritten.
// TODO(dan): Instead of this, use something like engine.ChunkAllocator.
primaryIndexKey = primaryIndexKey[:len(primaryIndexKey):len(primaryIndexKey)]
}
if len(family.ColumnIDs) == 1 && family.ColumnIDs[0] == family.DefaultColumnID {
// Storage optimization to store DefaultColumnID directly as a value. Also
// backwards compatible with the original BaseFormatVersion.
idx, ok := ri.insertColIDtoRowIndex[family.DefaultColumnID]
if !ok {
continue
}
if ri.marshalled[idx].RawBytes != nil {
// We only output non-NULL values. Non-existent column keys are
// considered NULL during scanning and the row sentinel ensures we know
// the row exists.
ri.key = keys.MakeFamilyKey(primaryIndexKey, uint32(family.ID))
putFn(b, &ri.key, &ri.marshalled[idx])
ri.key = nil
}
continue
}
ri.key = keys.MakeFamilyKey(primaryIndexKey, uint32(family.ID))
ri.valueBuf = ri.valueBuf[:0]
var lastColID sqlbase.ColumnID
familySortedColumnIDs, ok := ri.helper.sortedColumnFamily(family.ID)
if !ok {
panic("invalid family sorted column id map")
}
for _, colID := range familySortedColumnIDs {
if ri.helper.columnInPK(colID) {
if family.ID != 0 {
return errors.Errorf("primary index column %d must be in family 0, was %d", colID, family.ID)
}
// Skip primary key columns as their values are encoded in the key of
// each family. Family 0 is guaranteed to exist and acts as a sentinel.
continue
}
idx, ok := ri.insertColIDtoRowIndex[colID]
if !ok {
// Column not being inserted.
continue
}
col := ri.insertCols[idx]
if values[idx].Compare(parser.DNull) == 0 {
continue
}
if lastColID > col.ID {
panic(fmt.Errorf("cannot write column id %d after %d", col.ID, lastColID))
}
colIDDiff := col.ID - lastColID
lastColID = col.ID
ri.valueBuf, err = sqlbase.EncodeTableValue(ri.valueBuf, colIDDiff, values[idx])
if err != nil {
return err
}
}
if family.ID == 0 || len(ri.valueBuf) > 0 {
ri.value.SetTuple(ri.valueBuf)
putFn(b, &ri.key, &ri.value)
}
ri.key = nil
}
for i := range secondaryIndexEntries {
e := &secondaryIndexEntries[i]
putFn(b, &e.Key, &e.Value)
}
return nil
}