func (u *updateNode) Next() (bool, error) {
next, err := u.run.rows.Next()
if !next {
if err == nil {
// We're done. Finish the batch.
err = u.tw.finalize(u.p.ctx())
}
return false, err
}
if u.run.explain == explainDebug {
return true, nil
}
tracing.AnnotateTrace()
oldValues := u.run.rows.Values()
// Our updated value expressions occur immediately after the plain
// columns in the output.
updateValues := oldValues[len(u.tw.ru.fetchCols):]
oldValues = oldValues[:len(u.tw.ru.fetchCols)]
u.checkHelper.loadRow(u.tw.ru.fetchColIDtoRowIndex, oldValues, false)
u.checkHelper.loadRow(u.updateColsIdx, updateValues, true)
if err := u.checkHelper.check(&u.p.evalCtx); err != nil {
return false, err
}
// Ensure that the values honor the specified column widths.
for i := range updateValues {
if err := sqlbase.CheckValueWidth(u.tw.ru.updateCols[i], updateValues[i]); err != nil {
return false, err
}
}
// Update the row values.
for i, col := range u.tw.ru.updateCols {
val := updateValues[i]
if !col.Nullable && val == parser.DNull {
return false, sqlbase.NewNonNullViolationError(col.Name)
}
}
newValues, err := u.tw.row(u.p.ctx(), append(oldValues, updateValues...))
if err != nil {
return false, err
}
resultRow, err := u.rh.cookResultRow(newValues)
if err != nil {
return false, err
}
u.run.resultRow = resultRow
return true, nil
}
// GenerateInsertRow prepares a row tuple for insertion. It fills in default
// expressions, verifies non-nullable columns, and checks column widths.
func GenerateInsertRow(
defaultExprs []parser.TypedExpr,
insertColIDtoRowIndex map[sqlbase.ColumnID]int,
insertCols []sqlbase.ColumnDescriptor,
evalCtx parser.EvalContext,
tableDesc *sqlbase.TableDescriptor,
rowVals parser.DTuple,
) (parser.DTuple, error) {
// The values for the row may be shorter than the number of columns being
// inserted into. Generate default values for those columns using the
// default expressions.
if len(rowVals) < len(insertCols) {
// It's not cool to append to the slice returned by a node; make a copy.
oldVals := rowVals
rowVals = make(parser.DTuple, len(insertCols))
copy(rowVals, oldVals)
for i := len(oldVals); i < len(insertCols); i++ {
if defaultExprs == nil {
rowVals[i] = parser.DNull
continue
}
d, err := defaultExprs[i].Eval(&evalCtx)
if err != nil {
return nil, err
}
rowVals[i] = d
}
}
// Check to see if NULL is being inserted into any non-nullable column.
for _, col := range tableDesc.Columns {
if !col.Nullable {
if i, ok := insertColIDtoRowIndex[col.ID]; !ok || rowVals[i] == parser.DNull {
return nil, sqlbase.NewNonNullViolationError(col.Name)
}
}
}
// Ensure that the values honor the specified column widths.
for i := range rowVals {
if err := sqlbase.CheckValueWidth(insertCols[i], rowVals[i]); err != nil {
return nil, err
}
}
return rowVals, nil
}
func (n *insertNode) Next() (bool, error) {
ctx := n.editNodeBase.p.ctx()
if next, err := n.run.rows.Next(); !next {
if err == nil {
// We're done. Finish the batch.
err = n.tw.finalize(ctx)
}
return false, err
}
if n.run.explain == explainDebug {
return true, nil
}
rowVals := n.run.rows.Values()
// The values for the row may be shorter than the number of columns being
// inserted into. Generate default values for those columns using the
// default expressions.
if len(rowVals) < len(n.insertCols) {
// It's not cool to append to the slice returned by a node; make a copy.
oldVals := rowVals
rowVals = make(parser.DTuple, len(n.insertCols))
copy(rowVals, oldVals)
for i := len(oldVals); i < len(n.insertCols); i++ {
if n.defaultExprs == nil {
rowVals[i] = parser.DNull
continue
}
d, err := n.defaultExprs[i].Eval(&n.p.evalCtx)
if err != nil {
return false, err
}
rowVals[i] = d
}
}
// Check to see if NULL is being inserted into any non-nullable column.
for _, col := range n.tableDesc.Columns {
if !col.Nullable {
if i, ok := n.insertColIDtoRowIndex[col.ID]; !ok || rowVals[i] == parser.DNull {
return false, sqlbase.NewNonNullViolationError(col.Name)
}
}
}
// Ensure that the values honor the specified column widths.
for i := range rowVals {
if err := sqlbase.CheckValueWidth(n.insertCols[i], rowVals[i]); err != nil {
return false, err
}
}
n.checkHelper.loadRow(n.insertColIDtoRowIndex, rowVals, false)
if err := n.checkHelper.check(&n.p.evalCtx); err != nil {
return false, err
}
_, err := n.tw.row(ctx, rowVals)
if err != nil {
return false, err
}
for i, val := range rowVals {
if n.run.rowTemplate != nil {
n.run.rowTemplate[n.run.rowIdxToRetIdx[i]] = val
}
}
resultRow, err := n.rh.cookResultRow(n.run.rowTemplate)
if err != nil {
return false, err
}
n.run.resultRow = resultRow
return true, nil
}
