First pass at new interfaces for insert / update / delete that should make them more performant for inserting multipled rows in a single statement.

Signed-off-by: Zach Musgrave <zach@liquidata.co>

Author: zachmu

engine_test.go

@@ -3812,7 +3812,7 @@ func TestGenerators(t *testing.T) {
 	}
 }
 
-func insertRows(t *testing.T, table sql.Inserter, rows ...sql.Row) {
+func insertRows(t *testing.T, table sql.InsertableTable, rows ...sql.Row) {
 	t.Helper()
 
 	for _, r := range rows {

memory/table.go

@@ -28,7 +28,7 @@ type Table struct {
 }
 
 var _ sql.Table = (*Table)(nil)
-var _ sql.Inserter = (*Table)(nil)
+var _ sql.InsertableTable = (*Table)(nil)
 var _ sql.FilteredTable = (*Table)(nil)
 var _ sql.ProjectedTable = (*Table)(nil)
 var _ sql.IndexableTable = (*Table)(nil)

sql/core.go

@@ -205,28 +205,76 @@ type IndexableTable interface {
 	IndexKeyValues(*Context, []string) (PartitionIndexKeyValueIter, error)
 }
 
-// Inserter allow rows to be inserted in them.
-type Inserter interface {
-	// Insert the given row.
+// InsertableTable is a table that can process insertion of new rows.
+type InsertableTable interface {
+	// Inserter returns an Inserter for this table. The Inserter will get one call to Insert() for each row to be
+	// inserted, and will end with a call to Close() to finalize the insert operation.
+	Inserter(*Context) RowInserter
+}
+
+// RowInserter is an insert cursor that can insert one or more values to a table.
+type RowInserter interface {
+	// Insert inserts the row given, returning an error if it cannot. Insert will be called once for each row to process
+	// for the insert operation, which may involve many rows. After all rows in an operation have been processed, Close
+	// is called.
 	Insert(*Context, Row) error
+	// Close finalizes the insert operation, persisting its result.
+	Close(*Context) error
+}
+
+// DeleteableTable is a table that can process the deletion of rows
+type DeletableTable interface {
+	// Deleter returns a RowDeleter for this table. The RowDeleter will get one call to Delete for each row to be deleted,
+	// and will end with a call to Close() to finalize the delete operation.
+	Deleter(*Context, Row) RowDeleter
+}
+
+// RowDeleter is a delete cursor that can delete one or more rows from a table.
+type RowDeleter interface {
+	// Delete deletes the given row. Returns ErrDeleteRowNotFound if the row was not found. Delete will be called once for
+	// each row to process for the delete operation, which may involve many rows. After all rows have been processed,
+	// Close is called.
+	Delete(*Context, Row) error
+	// Close finalizes the delete operation, persisting the result.
+	Close(*Context) error
+}
+
+type Closer interface {
+	Close(*Context) error
 }
 
-// Deleter allow rows to be deleted from tables.
-type Deleter interface {
-	// Delete the given row. Returns ErrDeleteRowNotFound if the row was not found.
+type RowReplacer interface {
+	// Insert inserts the row given, returning an error if it cannot. Insert will be called once for each row to process
+	// for the replace operation, which may involve many rows. After all rows in an operation have been processed, Close
+	// is called.
+	Insert(*Context, Row) error
+	// Delete deletes the given row. Returns ErrDeleteRowNotFound if the row was not found. Delete will be called once for
+	// each row to process for the delete operation, which may involve many rows. After all rows have been processed,
+	// Close is called.
 	Delete(*Context, Row) error
+	// Close finalizes the replace operation, persisting the result.
+	Close(*Context) error
 }
 
 // Replacer allows rows to be replaced through a Delete (if applicable) then Insert.
-type Replacer interface {
-	Deleter
-	Inserter
+type ReplaceableTable interface {
+	// Replacer returns a RowReplacer for this table. The RowReplacer will have Insert and optionally Delete called once
+	// for each row, followed by a call to Close() when all rows have been processed.
+	Replacer() RowReplacer
+}
+
+// UpdateableTable is a table that can process updates of existing rows via update statements.
+type UpdatableTable interface {
+	// Updater returns a RowUpdater for this table. The RowUpdater will have Update called once for each row to be
+	// updated, followed by a call to Close() when all rows have been processed.
+	Updater(ctx *Context) RowUpdater
 }
 
-// Updater allows rows to be updated.
-type Updater interface {
+type RowUpdater interface {
 	// Update the given row. Provides both the old and new rows.
 	Update(ctx *Context, old Row, new Row) error
+	// Close finalizes the delete operation, persisting the result.
+	Close(*Context) error
 }
 
 // Database represents the database.

sql/plan/delete.go

@@ -37,9 +37,9 @@ func (p *DeleteFrom) Children() []sql.Node {
 	return []sql.Node{p.Node}
 }
 
-func getDeletable(node sql.Node) (sql.Deleter, error) {
+func getDeletable(node sql.Node) (sql.DeletableTable, error) {
 	switch node := node.(type) {
-	case sql.Deleter:
+	case sql.DeletableTable:
 		return node, nil
 	case *ResolvedTable:
 		return getDeletableTable(node.Table)
@@ -53,9 +53,9 @@ func getDeletable(node sql.Node) (sql.Deleter, error) {
 	return nil, ErrDeleteFromNotSupported.New()
 }
 
-func getDeletableTable(t sql.Table) (sql.Deleter, error) {
+func getDeletableTable(t sql.Table) (sql.DeletableTable, error) {
 	switch t := t.(type) {
-	case sql.Deleter:
+	case sql.DeletableTable:
 		return t, nil
 	case sql.TableWrapper:
 		return getDeletableTable(t.Underlying())

sql/plan/insert.go

@@ -45,9 +45,9 @@ func (p *InsertInto) Schema() sql.Schema {
 	}}
 }
 
-func getInsertable(node sql.Node) (sql.Inserter, error) {
+func getInsertable(node sql.Node) (sql.InsertableTable, error) {
 	switch node := node.(type) {
-	case sql.Inserter:
+	case sql.InsertableTable:
 		return node, nil
 	case *ResolvedTable:
 		return getInsertableTable(node.Table)
@@ -56,9 +56,9 @@ func getInsertable(node sql.Node) (sql.Inserter, error) {
 	}
 }
 
-func getInsertableTable(t sql.Table) (sql.Inserter, error) {
+func getInsertableTable(t sql.Table) (sql.InsertableTable, error) {
 	switch t := t.(type) {
-	case sql.Inserter:
+	case sql.InsertableTable:
 		return t, nil
 	case sql.TableWrapper:
 		return getInsertableTable(t.Underlying())
@@ -74,10 +74,10 @@ func (p *InsertInto) Execute(ctx *sql.Context) (int, error) {
 		return 0, err
 	}
 
-	var replaceable sql.Replacer
+	var replaceable sql.ReplaceableTable
 	if p.IsReplace {
 		var ok bool
-		replaceable, ok = insertable.(sql.Replacer)
+		replaceable, ok = insertable.(sql.ReplaceableTable)
 		if !ok {
 			return 0, ErrReplaceIntoNotSupported.New()
 		}

sql/plan/update.go

@@ -60,9 +60,9 @@ func (p *Update) Children() []sql.Node {
 	return []sql.Node{p.Node}
 }
 
-func getUpdatable(node sql.Node) (sql.Updater, error) {
+func getUpdatable(node sql.Node) (sql.UpdatableTable, error) {
 	switch node := node.(type) {
-	case sql.Updater:
+	case sql.UpdatableTable:
 		return node, nil
 	case *ResolvedTable:
 		return getUpdatableTable(node.Table)
@@ -76,9 +76,9 @@ func getUpdatable(node sql.Node) (sql.Updater, error) {
 	return nil, ErrUpdateNotSupported.New()
 }
 
-func getUpdatableTable(t sql.Table) (sql.Updater, error) {
+func getUpdatableTable(t sql.Table) (sql.UpdatableTable, error) {
 	switch t := t.(type) {
-	case sql.Updater:
+	case sql.UpdatableTable:
 		return t, nil
 	case sql.TableWrapper:
 		return getUpdatableTable(t.Underlying())