dbms

type BaseBatchWriter struct {
	Task *Task
	// contains filtered or unexported fields
}

type BaseConfig struct {
	Username     string                `json:"username"`     // Username
	Password     string                `json:"password"`     // Password
	Column       []string              `json:"column"`       // Column Information
	Connection   dbmsreader.ConnConfig `json:"connection"`   // Connection Information
	WriteMode    string                `json:"writeMode"`    // Write Mode, e.g., Insert
	BatchSize    int                   `json:"batchSize"`    // Batch Size for Single Write
	BatchTimeout time2.Duration        `json:"batchTimeout"` // Batch Timeout for Single Write
	PreSQL       []string              `json:"preSQL"`       // Prepared SQL Statement
	PostSQL      []string              `json:"postSQL"`      // Ending SQL Statement
	// contains filtered or unexported fields
}

type BaseDbHandler struct {
	// contains filtered or unexported fields
}

type BatchWriter interface {
	JobID() int64                                                   // Job ID - A unique identifier for a job or task.
	TaskGroupID() int64                                             // Task Group ID - A unique identifier for a group of tasks.
	TaskID() int64                                                  // Task ID - A unique identifier for a specific task within a task group.
	BatchSize() int                                                 // Batch Size - The number of records to be written in a single batch.
	BatchTimeout() time.Duration                                    // Batch Timeout - The maximum time allowed for a single batch write operation.
	BatchWrite(ctx context.Context, records []element.Record) error // Batch Write - The process of writing data in batches.
}

type Config interface {
	GetUsername() string                                                     // Get Username
	GetPassword() string                                                     // Get Password
	GetURL() string                                                          // Get Connection URL
	GetColumns() []dbmsreader.Column                                         // Get Column Information
	GetBaseTable() *database.BaseTable                                       // Get Table Information
	GetWriteMode() string                                                    // Get Write Mode
	GetBatchSize() int                                                       // Batch Size for Single Write
	GetBatchTimeout() time.Duration                                          // Batch Timeout for Single Write
	GetRetryStrategy(j schedule.RetryJudger) (schedule.RetryStrategy, error) // Get Retry Strategy
	IgnoreOneByOneError() bool                                               // Ignore Individual Retry Errors
	GetPreSQL() []string                                                     // Get Prepared SQL Statement
	GetPostSQL() []string                                                    // Get Ending SQL Statement
}

type DbHandler interface {
	Execer(name string, conf *config.JSON) (Execer, error)      // Obtain an executor through the database name and configuration
	Config(conf *config.JSON) (Config, error)                   // Obtain relational database configuration through configuration
	TableParam(config Config, execer Execer) database.Parameter // Obtain table parameters through relational database configuration and executor
}

type Execer interface {
	Table(*database.BaseTable) database.Table
	// Obtain relational database configuration through configuration
	PingContext(ctx context.Context) error

	QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)
	// BaseDbHandler Basic Database Execution Handler Encapsulation
	ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)

	FetchTableWithParam(ctx context.Context, param database.Parameter) (database.Table, error)

	BatchExec(ctx context.Context, opts *database.ParameterOptions) (err error)
	// NewBaseDbHandler Create a database execution handler encapsulation using the executor function newExecer and database transaction execution options opts
	BatchExecStmt(ctx context.Context, opts *database.ParameterOptions) (err error)

	BatchExecWithTx(ctx context.Context, opts *database.ParameterOptions) (err error)

	BatchExecStmtWithTx(ctx context.Context, opts *database.ParameterOptions) (err error)

	Close() error
}

type Job struct {
	*plugin.BaseJob

	Handler DbHandler // Database handle
	Execer  Execer    // Executor
	// contains filtered or unexported fields
}

type Task struct {
	*writer.BaseTask

	Handler DbHandler
	Execer  Execer
	Config  Config
	Table   database.Table
}