deleted legacy copy of Handle function for presetIDStrategy

Author: pol-mfilipowicz-viant

io/insert/record_numeric.go

@@ -99,12 +99,7 @@ func (n *numericSequencer) transientDMLBuilder(sess *session, record interface{}
 		values := make([]interface{}, len(sess.columns))
 		copy(values, batchRecordBuffer[0:len(sess.columns)-1]) // don't copy ID pointer (last position in slice)
 
-		maxIdValue, err := sequence.ComputeNextForTransient(recordCount)
-		if err != nil {
-			return nil, 0, err
-		}
-
-		values[len(sess.columns)-1] = &maxIdValue
+		values[len(sess.columns)-1] = nil // set ID to nil for autoincrement
 		resetAutoincrementSQL := &sqlx.SQL{
 			Query: resetAutoincrementQuery,
 			Args:  values,

metadata/product/mysql/sequence/transient.go

@@ -22,93 +22,6 @@ const minSequenceArgs = 3
 // using insert inside new transaction finished by rollback
 type Transient struct{}
 
-// Handle sets new autoincrement value by inserting row using new transaction finished by rollback, uses locking
-func (n *Transient) HandleLegacy(ctx context.Context, db *sql.DB, target interface{}, iopts ...interface{}) (doNext bool, err error) {
-	meta := metadata.New()
-	options := option.AsOptions(iopts)
-
-	argsOps := options.Args()
-	if argsOps == nil {
-		return false, fmt.Errorf("argsOps was empty")
-	}
-
-	targetSequence, ok := target.(*sink.Sequence)
-	if !ok {
-		return false, fmt.Errorf("invalid target, expected :%T, but had: %T", targetSequence, target)
-	}
-
-	tx, err := db.BeginTx(ctx, nil)
-	if err != nil {
-		return false, err
-	}
-	defer io.RunWithError(tx.Rollback, &err)
-
-	lockingOptions := option.Options{argsOps, tx}
-	product := option.Options.Product(options)
-	if product != nil {
-		lockingOptions = append(lockingOptions, product)
-	}
-
-	if err = n.lock(ctx, meta, db, lockingOptions); err != nil {
-		return false, err
-	}
-	fn := func() error { return n.unlock(ctx, meta, db, lockingOptions) }
-	defer io.RunWithError(fn, &err)
-
-	sequence := sink.Sequence{}
-	arguments := argsOps.Unwrap()
-	if len(arguments) < 3 {
-		return false, fmt.Errorf("unable to get sequence's metadata due to: len(arguments) < 3")
-	}
-
-	sequence.Catalog = arguments[0].(string)
-	sequence.Schema = arguments[1].(string)
-	sequence.Name = arguments[2].(string)
-
-	sequenceSQLBuilder := options.SequenceSQLBuilder()
-	if sequenceSQLBuilder == nil {
-		return false, fmt.Errorf("SequenceSQLBuilder was empty")
-	}
-
-	retryMaxCnt := 5
-
-	for i := 1; i <= retryMaxCnt; i++ {
-		err = updateSequence(ctx, db, &sequence, tx)
-		if err != nil {
-			return false, err
-		}
-
-		transientDML, _, err := sequenceSQLBuilder(&sequence)
-		if err != nil {
-			return false, err
-		}
-		if transientDML == nil {
-			return false, fmt.Errorf("transientDML was empty")
-		}
-
-		_ = n.turnFkKeyCheck(tx, 0)
-		_, err = tx.ExecContext(ctx, transientDML.Query, transientDML.Args...)
-		_ = n.turnFkKeyCheck(tx, 1)
-
-		if err != nil && i < retryMaxCnt {
-			continue
-		}
-
-		if err != nil { //temp workaround of cascading sequencer
-			err = fmt.Errorf("unable to get sequence values (attempt %d) using transient dml %v due to: %w", i, transientDML, err)
-		}
-
-		break
-	}
-
-	if err != nil {
-		return false, err
-	}
-
-	*targetSequence = sequence
-	return false, nil
-}
-
 func (n *Transient) turnFkKeyCheck(tx *sql.Tx, flag int) error {
 	_, err := tx.Exec("SET foreign_key_checks = " + strconv.Itoa(flag))
 	return err

metadata/product/mysql/sequence/transient_benchmark_parallel_test.go

@@ -179,163 +179,3 @@ func BenchmarkTransientHandleMultiParallel(b *testing.B) {
 		}
 	})
 }
-
-// Parallel comparison: Handle vs HandleLegacy
-func BenchmarkTransientHandleVsLegacyParallel(b *testing.B) {
-	dsn := os.Getenv("MYSQL_BENCH_DSN")
-	if dsn == "" {
-		b.Skip("set MYSQL_BENCH_DSN to run this benchmark")
-	}
-	schema := os.Getenv("MYSQL_BENCH_SCHEMA")
-	if schema == "" {
-		b.Skip("set MYSQL_BENCH_SCHEMA to run this benchmark")
-	}
-
-	catalog := ""
-	table := "t_seq_bench_par_cmp"
-	idCol := "id"
-
-	records := int64(1)
-	if v := os.Getenv("MYSQL_BENCH_RECORDS"); v != "" {
-		if n, err := strconv.ParseInt(v, 10, 64); err == nil && n > 0 {
-			records = n
-		}
-	}
-
-	db, err := sql.Open("mysql", dsn)
-	if err != nil {
-		b.Fatalf("open dsn: %v", err)
-	}
-	defer db.Close()
-	if err := db.Ping(); err != nil {
-		b.Fatalf("ping: %v", err)
-	}
-
-	if _, err := db.Exec("DROP TABLE IF EXISTS `" + schema + "`.`" + table + "`"); err != nil {
-		b.Fatalf("drop table: %v", err)
-	}
-	if _, err := db.Exec("CREATE TABLE `" + schema + "`.`" + table + "` ( `" + idCol + "` BIGINT AUTO_INCREMENT PRIMARY KEY, `foo_name` TEXT )"); err != nil {
-		b.Fatalf("create table: %v", err)
-	}
-	b.Cleanup(func() {
-		_, _ = db.Exec("DROP TABLE IF EXISTS `" + schema + "`.`" + table + "`")
-	})
-
-	builder := func(seq *sink.Sequence) (*sqlx.SQL, int64, error) {
-		inc := seq.IncrementBy
-		if inc == 0 {
-			inc = 1
-		}
-		target := seq.Value
-		if records > 1 {
-			target = seq.Value + (records-1)*inc
-		}
-		var idArg int64 = target
-		var name = fmt.Sprintf("%d", idArg)
-		sql := &sqlx.SQL{
-			Query: "INSERT INTO `" + schema + "`.`" + table + "` (foo_name,`" + idCol + "`) VALUES (?,?)",
-			Args:  []interface{}{&name, &idArg},
-		}
-		return sql, records, nil
-	}
-
-	args := option.NewArgs(catalog, schema, table)
-	opts := []option.Option{
-		dialect.PresetIDWithTransientTransaction,
-		option.RecordCount(records),
-		args,
-		builder,
-		mysqlprod.MySQL5(),
-	}
-
-	ctx := context.Background()
-	h := &seqpkg.Transient{}
-
-	b.Run("HandleParallel", func(b *testing.B) {
-		b.ReportAllocs()
-		b.ResetTimer()
-		b.RunParallel(func(pb *testing.PB) {
-			for pb.Next() {
-				var seq sink.Sequence
-				if _, err := h.Handle(ctx, db, &seq, option.Options(opts).Interfaces()...); err != nil {
-					b.Fatalf("Handle failed: %v", err)
-				}
-			}
-		})
-	})
-
-	b.Run("HandleLegacyParallel", func(b *testing.B) {
-		b.ReportAllocs()
-		b.ResetTimer()
-		b.RunParallel(func(pb *testing.PB) {
-			for pb.Next() {
-				var seq sink.Sequence
-				if _, err := h.HandleLegacy(ctx, db, &seq, option.Options(opts).Interfaces()...); err != nil {
-					b.Fatalf("HandleLegacy failed: %v", err)
-				}
-			}
-		})
-	})
-
-	/////////
-	// Default to 10 record; override with env if needed
-	recordsN := int64(10)
-	if v := os.Getenv("MYSQL_BENCH_RECORDS_N"); v != "" {
-		if n, err := strconv.ParseInt(v, 10, 64); err == nil && n > 0 {
-			recordsN = n
-		}
-	}
-
-	builderN := func(seq *sink.Sequence) (*sqlx.SQL, int64, error) {
-		inc := seq.IncrementBy
-		if inc == 0 {
-			inc = 1
-		}
-		target := seq.Value
-		if records > 1 {
-			target = seq.Value + (records-1)*inc
-		}
-		var idArg int64 = target
-		var name = fmt.Sprintf("%d", idArg)
-		sql := &sqlx.SQL{
-			Query: "INSERT INTO `" + schema + "`.`" + table + "` (foo_name,`" + idCol + "`) VALUES (?,?)",
-			Args:  []interface{}{&name, &idArg},
-		}
-		return sql, records, nil
-	}
-
-	optsN := []option.Option{
-		dialect.PresetIDWithTransientTransaction,
-		option.RecordCount(recordsN),
-		args,
-		builderN,
-		mysqlprod.MySQL5(),
-	}
-
-	b.Run("HandleParallel N-rec", func(b *testing.B) {
-		b.ReportAllocs()
-		b.ResetTimer()
-		b.RunParallel(func(pb *testing.PB) {
-			for pb.Next() {
-				var seq sink.Sequence
-				if _, err := h.Handle(ctx, db, &seq, option.Options(optsN).Interfaces()...); err != nil {
-					b.Fatalf("Handle failed: %v", err)
-				}
-			}
-		})
-	})
-
-	b.Run("HandleLegacyParallel N-rec", func(b *testing.B) {
-		b.ReportAllocs()
-		b.ResetTimer()
-		b.RunParallel(func(pb *testing.PB) {
-			for pb.Next() {
-				var seq sink.Sequence
-				if _, err := h.HandleLegacy(ctx, db, &seq, option.Options(optsN).Interfaces()...); err != nil {
-					b.Fatalf("HandleLegacy failed: %v", err)
-				}
-			}
-		})
-	})
-
-}