diff --git a/README.md b/README.md index cc3b61e..a069e17 100644 --- a/README.md +++ b/README.md @@ -170,7 +170,7 @@ go generate ./... #### license -用于自动新增go代码文件中许可证 +用于自动新增go代码文件中许可证并使用gofmt -s -w格式化代码 ```bash go run tools/license/main.go diff --git a/cmd/datax/tools/wizard.go b/cmd/datax/tools/wizard.go index 29e06fa..82f01c0 100644 --- a/cmd/datax/tools/wizard.go +++ b/cmd/datax/tools/wizard.go @@ -28,13 +28,13 @@ import ( coreconst "github.com/Breeze0806/go-etl/datax/common/config/core" ) -//Wizard 配置向导工具 +// Wizard 配置向导工具 type Wizard struct { dataSourceFile string csvFile string } -//NewWizard 根据数据源文件dataSourceFile，源目的文件csvFile生成配置向导工具 +// NewWizard 根据数据源文件dataSourceFile，源目的文件csvFile生成配置向导工具 func NewWizard(dataSourceFile, csvFile string) (w *Wizard) { w = &Wizard{ dataSourceFile: dataSourceFile, @@ -43,7 +43,7 @@ func NewWizard(dataSourceFile, csvFile string) (w *Wizard) { return } -//GenerateConfigsAndScripts 生成配置文件集和执行脚本 +// GenerateConfigsAndScripts 生成配置文件集和执行脚本 func (w *Wizard) GenerateConfigsAndScripts() (err error) { var dataSource *config.JSON if dataSource, err = config.NewJSONFromFile(w.dataSourceFile); err != nil { diff --git a/config/json.go b/config/json.go index a1b4deb..6a2e79c 100644 --- a/config/json.go +++ b/config/json.go @@ -12,26 +12,26 @@ // See the License for the specific language governing permissions and // limitations under the License. -//Package config 提供JSON配置 +// Package config 提供JSON配置 package config import ( "github.com/Breeze0806/go/encoding" ) -//JSON JSON格式配置文件 +// JSON JSON格式配置文件 type JSON struct { *encoding.JSON } -//NewJSONFromEncodingJSON 从编码JSON j中获取JSON +// NewJSONFromEncodingJSON 从编码JSON j中获取JSON func NewJSONFromEncodingJSON(j *encoding.JSON) *JSON { return &JSON{ JSON: j, } } -//NewJSONFromString 从字符串s 获取json配置 ，并在json格式错误时返回错误 +// NewJSONFromString 从字符串s 获取json配置 ，并在json格式错误时返回错误 func NewJSONFromString(s string) (*JSON, error) { JSON, err := encoding.NewJSONFromString(s) if err != nil { @@ -40,7 +40,7 @@ func NewJSONFromString(s string) (*JSON, error) { return NewJSONFromEncodingJSON(JSON), nil } -//NewJSONFromBytes 从字节流b 获取json配置 ，并在json格式错误时返回错误 +// NewJSONFromBytes 从字节流b 获取json配置 ，并在json格式错误时返回错误 func NewJSONFromBytes(b []byte) (*JSON, error) { JSON, err := encoding.NewJSONFromBytes(b) if err != nil { @@ -49,8 +49,8 @@ func NewJSONFromBytes(b []byte) (*JSON, error) { return NewJSONFromEncodingJSON(JSON), nil } -//NewJSONFromFile 从文件名为filename的文件中获取json配置 -//并在json格式错误或者读取文件错误时返回错误 +// NewJSONFromFile 从文件名为filename的文件中获取json配置 +// 并在json格式错误或者读取文件错误时返回错误 func NewJSONFromFile(filename string) (*JSON, error) { JSON, err := encoding.NewJSONFromFile(filename) if err != nil { @@ -59,16 +59,18 @@ func NewJSONFromFile(filename string) (*JSON, error) { return NewJSONFromEncodingJSON(JSON), nil } -//GetConfig 获取path路径对应的值配置文件,对于下列json -//{ -// "a":{ -// "b":[{ -// c:"x" -// }] +// GetConfig 获取path路径对应的值配置文件,对于下列json +// +// { +// "a":{ +// "b":[{ +// c:"x" +// }] +// } // } -//} -//要访问到x字符串 path每层的访问路径为a,a.b,a.b.0，a.b.0.c -//如果path对应的不是json结构或者不存在，就会返回错误 +// +// 要访问到x字符串 path每层的访问路径为a,a.b,a.b.0，a.b.0.c +// 如果path对应的不是json结构或者不存在，就会返回错误 func (j *JSON) GetConfig(path string) (*JSON, error) { JSON, err := j.GetJSON(path) if err != nil { @@ -77,16 +79,18 @@ func (j *JSON) GetConfig(path string) (*JSON, error) { return NewJSONFromEncodingJSON(JSON), nil } -//GetBoolOrDefaullt 获取path路径对应的BOOL值,对于下列json -//{ -// "a":{ -// "b":[{ -// c:"x" -// }] +// GetBoolOrDefaullt 获取path路径对应的BOOL值,对于下列json +// +// { +// "a":{ +// "b":[{ +// c:"x" +// }] +// } // } -//} -//要访问到x字符串 path每层的访问路径为a,a.b,a.b.0，a.b.0.c -//如果path对应的不是int64或者不存在，就会返回defaultValue +// +// 要访问到x字符串 path每层的访问路径为a,a.b,a.b.0，a.b.0.c +// 如果path对应的不是int64或者不存在，就会返回defaultValue func (j *JSON) GetBoolOrDefaullt(path string, defaultValue bool) bool { if v, err := j.GetBool(path); err == nil { return v @@ -94,16 +98,18 @@ func (j *JSON) GetBoolOrDefaullt(path string, defaultValue bool) bool { return defaultValue } -//GetInt64OrDefaullt 获取path路径对应的int64值,对于下列json -//{ -// "a":{ -// "b":[{ -// c:"x" -// }] +// GetInt64OrDefaullt 获取path路径对应的int64值,对于下列json +// +// { +// "a":{ +// "b":[{ +// c:"x" +// }] +// } // } -//} -//要访问到x字符串 path每层的访问路径为a,a.b,a.b.0，a.b.0.c -//如果path对应的不是int64或者不存在，就会返回defaultValue +// +// 要访问到x字符串 path每层的访问路径为a,a.b,a.b.0，a.b.0.c +// 如果path对应的不是int64或者不存在，就会返回defaultValue func (j *JSON) GetInt64OrDefaullt(path string, defaultValue int64) int64 { if v, err := j.GetInt64(path); err == nil { return v @@ -111,16 +117,18 @@ func (j *JSON) GetInt64OrDefaullt(path string, defaultValue int64) int64 { return defaultValue } -//GetFloat64OrDefaullt 获取path路径对应的float64值,对于下列json -//{ -// "a":{ -// "b":[{ -// c:"x" -// }] +// GetFloat64OrDefaullt 获取path路径对应的float64值,对于下列json +// +// { +// "a":{ +// "b":[{ +// c:"x" +// }] +// } // } -//} -//要访问到x字符串 path每层的访问路径为a,a.b,a.b.0，a.b.0.c -//如果path对应的不是float64或者不存在，就会返回defaultValue +// +// 要访问到x字符串 path每层的访问路径为a,a.b,a.b.0，a.b.0.c +// 如果path对应的不是float64或者不存在，就会返回defaultValue func (j *JSON) GetFloat64OrDefaullt(path string, defaultValue float64) float64 { if v, err := j.GetFloat64(path); err == nil { return v @@ -128,16 +136,18 @@ func (j *JSON) GetFloat64OrDefaullt(path string, defaultValue float64) float64 { return defaultValue } -//GetStringOrDefaullt 获取path路径对应的字符串值,对于下列json -//{ -// "a":{ -// "b":[{ -// c:"x" -// }] +// GetStringOrDefaullt 获取path路径对应的字符串值,对于下列json +// +// { +// "a":{ +// "b":[{ +// c:"x" +// }] +// } // } -//} -//要访问到x字符串 path每层的访问路径为a,a.b,a.b.0，a.b.0.c -//如果path对应的不是字符串或者不存在，就会返回defaultValue +// +// 要访问到x字符串 path每层的访问路径为a,a.b,a.b.0，a.b.0.c +// 如果path对应的不是字符串或者不存在，就会返回defaultValue func (j *JSON) GetStringOrDefaullt(path string, defaultValue string) string { if v, err := j.JSON.GetString(path); err == nil { return v @@ -145,16 +155,18 @@ func (j *JSON) GetStringOrDefaullt(path string, defaultValue string) string { return defaultValue } -//GetConfigArray 获取path路径对应的配置数组,对于下列json -//{ -// "a":{ -// "b":[{ -// c:"x" -// }] +// GetConfigArray 获取path路径对应的配置数组,对于下列json +// +// { +// "a":{ +// "b":[{ +// c:"x" +// }] +// } // } -//} -//要访问到x字符串 path每层的访问路径为a,a.b,a.b.0，a.b.0.c -//如果path对应的不是配置数组或者不存在，就会返回错误 +// +// 要访问到x字符串 path每层的访问路径为a,a.b,a.b.0，a.b.0.c +// 如果path对应的不是配置数组或者不存在，就会返回错误 func (j *JSON) GetConfigArray(path string) ([]*JSON, error) { a, err := j.JSON.GetArray(path) if err != nil { @@ -170,16 +182,18 @@ func (j *JSON) GetConfigArray(path string) ([]*JSON, error) { return JSONs, nil } -//GetConfigMap 获取path路径对应的配置映射,对于下列json -//{ -// "a":{ -// "b":[{ -// c:"x" -// }] +// GetConfigMap 获取path路径对应的配置映射,对于下列json +// +// { +// "a":{ +// "b":[{ +// c:"x" +// }] +// } // } -//} -//要访问到x字符串 path每层的访问路径为a,a.b,a.b.0，a.b.0.c -//如果path对应的不是配置映射或者不存在，就会返回错误 +// +// 要访问到x字符串 path每层的访问路径为a,a.b,a.b.0，a.b.0.c +// 如果path对应的不是配置映射或者不存在，就会返回错误 func (j *JSON) GetConfigMap(path string) (map[string]*JSON, error) { m, err := j.JSON.GetMap(path) if err != nil { @@ -194,7 +208,7 @@ func (j *JSON) GetConfigMap(path string) (map[string]*JSON, error) { return JSONs, nil } -//CloneConfig 克隆json配置文件 +// CloneConfig 克隆json配置文件 func (j *JSON) CloneConfig() *JSON { return &JSON{ JSON: j.JSON.Clone(), diff --git a/datax/README.md b/datax/README.md index 766f5dc..0c11c24 100644 --- a/datax/README.md +++ b/datax/README.md @@ -447,7 +447,7 @@ GetConfig中要访问到x字符串 path每层的访问路径为a,a.b,a.b.0，a.b ### 5.1 新增许可证（license） -当你开发完一个功能后在提交前，请运行如下命令用于自动加入许可证 +当你开发完一个功能后在提交前，请运行如下命令用于自动加入许可证并使用gofmt -s -w格式化代码 ```bash go run tools/license/main.go diff --git a/datax/common/config/core/const.go b/datax/common/config/core/const.go index 29b1a68..c90ea5c 100644 --- a/datax/common/config/core/const.go +++ b/datax/common/config/core/const.go @@ -14,7 +14,7 @@ package core -//datax 配置文件路径 +// datax 配置文件路径 var ( //datax全局配置路劲 DataxCoreContainerTaskgroupChannel = "core.container.taskGroup.channel" diff --git a/datax/common/plugin/job.go b/datax/common/plugin/job.go index c5f62a9..d876466 100644 --- a/datax/common/plugin/job.go +++ b/datax/common/plugin/job.go @@ -14,7 +14,7 @@ package plugin -//Job 工作 +// Job 工作 type Job interface { Plugin //工作ID @@ -25,7 +25,7 @@ type Job interface { SetCollector(JobCollector) //todo 设置工作采集器目前未使用 } -//BaseJob 基础工作，用于辅助和简化工作接口的实现 +// BaseJob 基础工作，用于辅助和简化工作接口的实现 type BaseJob struct { *BasePlugin @@ -33,29 +33,29 @@ type BaseJob struct { collector JobCollector } -//NewBaseJob 获取NewBaseJob +// NewBaseJob 获取NewBaseJob func NewBaseJob() *BaseJob { return &BaseJob{ BasePlugin: NewBasePlugin(), } } -//JobID 工作ID +// JobID 工作ID func (b *BaseJob) JobID() int64 { return b.id } -//SetJobID 设置工作ID +// SetJobID 设置工作ID func (b *BaseJob) SetJobID(jobID int64) { b.id = jobID } -//Collector 采集器 +// Collector 采集器 func (b *BaseJob) Collector() JobCollector { return b.collector } -//SetCollector 设置采集器 +// SetCollector 设置采集器 func (b *BaseJob) SetCollector(collector JobCollector) { b.collector = collector } diff --git a/datax/common/plugin/job_collector.go b/datax/common/plugin/job_collector.go index 09b13f1..e60c96a 100644 --- a/datax/common/plugin/job_collector.go +++ b/datax/common/plugin/job_collector.go @@ -16,8 +16,8 @@ package plugin import "github.com/Breeze0806/go/encoding" -//JobCollector 工作信息采集器，用于统计整个工作的进度，错误信息等 -//toto 当前未实现监控模块，为此需要在后面来实现这个接口的结构体 +// JobCollector 工作信息采集器，用于统计整个工作的进度，错误信息等 +// toto 当前未实现监控模块，为此需要在后面来实现这个接口的结构体 type JobCollector interface { JSON() *encoding.JSON JSONByKey(key string) *encoding.JSON diff --git a/datax/common/plugin/loader/center.go b/datax/common/plugin/loader/center.go index c843183..d44ca89 100644 --- a/datax/common/plugin/loader/center.go +++ b/datax/common/plugin/loader/center.go @@ -30,40 +30,40 @@ var _centor = ¢or{ writers: make(map[string]spi.Writer), } -//RegisterReader 注册名字为name的读取器reader -//当name重复，reader为空或者reader的task和job为空会panic +// RegisterReader 注册名字为name的读取器reader +// 当name重复，reader为空或者reader的task和job为空会panic func RegisterReader(name string, reader spi.Reader) { if err := _centor.registerReader(name, reader); err != nil { panic(err) } } -//RegisterWriter 注册名字为name的写入器writer -//当name重复，writer为空或者writer的task和job为空会panic +// RegisterWriter 注册名字为name的写入器writer +// 当name重复，writer为空或者writer的task和job为空会panic func RegisterWriter(name string, writer spi.Writer) { if err := _centor.registerWriter(name, writer); err != nil { panic(err) } } -//UnregisterReaders 注销所有读取器 +// UnregisterReaders 注销所有读取器 func UnregisterReaders() { _centor.unregisterReaders() } -//UnregisterWriters 注销所有写入器 +// UnregisterWriters 注销所有写入器 func UnregisterWriters() { _centor.unregisterWriters() } -//LoadJobPlugin 目前未正常实现该函数，仅仅是个架子 +// LoadJobPlugin 目前未正常实现该函数，仅仅是个架子 // todo: 实现handle ? func LoadJobPlugin(typ plugin.Type, name string) (plugin.Job, error) { return newdefaultJobPlugin(), nil } -//LoadReaderJob ,根据名字name获取读取器的工作 -//如果name不存在，返回的布尔值为false +// LoadReaderJob ,根据名字name获取读取器的工作 +// 如果name不存在，返回的布尔值为false func LoadReaderJob(name string) (reader.Job, bool) { r, ok := _centor.reader(name) if !ok { @@ -72,8 +72,8 @@ func LoadReaderJob(name string) (reader.Job, bool) { return r.Job(), true } -//LoadReaderTask ,根据名字name获取读取器的任务 -//如果name不存在，返回的布尔值为false +// LoadReaderTask ,根据名字name获取读取器的任务 +// 如果name不存在，返回的布尔值为false func LoadReaderTask(name string) (reader.Task, bool) { r, ok := _centor.reader(name) if !ok { @@ -82,8 +82,8 @@ func LoadReaderTask(name string) (reader.Task, bool) { return r.Task(), true } -//LoadWriterJob ,根据名字name获取写入器的工作 -//如果name不存在，返回的布尔值为false +// LoadWriterJob ,根据名字name获取写入器的工作 +// 如果name不存在，返回的布尔值为false func LoadWriterJob(name string) (writer.Job, bool) { w, ok := _centor.writer(name) if !ok { @@ -92,8 +92,8 @@ func LoadWriterJob(name string) (writer.Job, bool) { return w.Job(), true } -//LoadWriterTask ,根据名字name获取写入器的任务 -//如果name不存在，返回的布尔值为false +// LoadWriterTask ,根据名字name获取写入器的任务 +// 如果name不存在，返回的布尔值为false func LoadWriterTask(name string) (writer.Task, bool) { w, ok := _centor.writer(name) if !ok { diff --git a/datax/common/plugin/pluggable.go b/datax/common/plugin/pluggable.go index 3b1db1b..9b16b9a 100644 --- a/datax/common/plugin/pluggable.go +++ b/datax/common/plugin/pluggable.go @@ -20,7 +20,7 @@ import ( "github.com/Breeze0806/go-etl/config" ) -//Pluggable 可插件化接口 +// Pluggable 可插件化接口 type Pluggable interface { //插件开发者,一般写入插件配置中 Developer() (string, error) @@ -56,8 +56,8 @@ type Pluggable interface { Destroy(ctx context.Context) error } -//BasePluggable 基础可插件化 -//用于辅助各类可插件化接口实现，简化其实现 +// BasePluggable 基础可插件化 +// 用于辅助各类可插件化接口实现，简化其实现 type BasePluggable struct { pluginConf *config.JSON pluginJobConf *config.JSON @@ -65,62 +65,62 @@ type BasePluggable struct { peerPluginJobConf *config.JSON } -//NewBasePluggable 创建可插件化插件 +// NewBasePluggable 创建可插件化插件 func NewBasePluggable() *BasePluggable { return &BasePluggable{} } -//SetPluginConf 设置插件配置 +// SetPluginConf 设置插件配置 func (b *BasePluggable) SetPluginConf(conf *config.JSON) { b.pluginConf = conf } -//SetPluginJobConf 设置插件工作配置 +// SetPluginJobConf 设置插件工作配置 func (b *BasePluggable) SetPluginJobConf(conf *config.JSON) { b.pluginJobConf = conf } -//SetPeerPluginName 设置对应工作名 +// SetPeerPluginName 设置对应工作名 func (b *BasePluggable) SetPeerPluginName(name string) { b.peerPluginName = name } -//SetPeerPluginJobConf 设置对应工作配置 +// SetPeerPluginJobConf 设置对应工作配置 func (b *BasePluggable) SetPeerPluginJobConf(conf *config.JSON) { b.peerPluginJobConf = conf } -//Developer 插件开发者,当developer不存在或者不是字符串时会返回错误 +// Developer 插件开发者,当developer不存在或者不是字符串时会返回错误 func (b *BasePluggable) Developer() (string, error) { return b.pluginConf.GetString("developer") } -//Description 插件描述,当description不存在或者不是字符串时会返回错误 +// Description 插件描述,当description不存在或者不是字符串时会返回错误 func (b *BasePluggable) Description() (string, error) { return b.pluginConf.GetString("description") } -//PluginName 插件名称,当name不存在或者不是字符串时会返回错误 +// PluginName 插件名称,当name不存在或者不是字符串时会返回错误 func (b *BasePluggable) PluginName() (string, error) { return b.pluginConf.GetString("name") } -//PluginConf 插件配置 +// PluginConf 插件配置 func (b *BasePluggable) PluginConf() *config.JSON { return b.pluginConf } -//PluginJobConf 工作配置 +// PluginJobConf 工作配置 func (b *BasePluggable) PluginJobConf() *config.JSON { return b.pluginJobConf } -//PeerPluginName 对应插件名称 +// PeerPluginName 对应插件名称 func (b *BasePluggable) PeerPluginName() string { return b.peerPluginName } -//PeerPluginJobConf 设置个性化配置 +// PeerPluginJobConf 设置个性化配置 func (b *BasePluggable) PeerPluginJobConf() *config.JSON { return b.peerPluginJobConf } diff --git a/datax/common/plugin/plugin.go b/datax/common/plugin/plugin.go index 9642fdf..b091744 100644 --- a/datax/common/plugin/plugin.go +++ b/datax/common/plugin/plugin.go @@ -20,7 +20,7 @@ import ( "github.com/Breeze0806/go-etl/config" ) -//Plugin 插件 +// Plugin 插件 type Plugin interface { Pluggable //预检查 @@ -35,39 +35,39 @@ type Plugin interface { PostHandler(ctx context.Context, conf *config.JSON) error } -//BasePlugin 基础插件，用于辅助和简化插件的实现 +// BasePlugin 基础插件，用于辅助和简化插件的实现 type BasePlugin struct { *BasePluggable } -//NewBasePlugin 创建基础插件 +// NewBasePlugin 创建基础插件 func NewBasePlugin() *BasePlugin { return &BasePlugin{ BasePluggable: NewBasePluggable(), } } -//PreCheck 预检查空方法 +// PreCheck 预检查空方法 func (b *BasePlugin) PreCheck(ctx context.Context) error { return nil } -//Post 后置通知空方法 +// Post 后置通知空方法 func (b *BasePlugin) Post(ctx context.Context) error { return nil } -//Prepare 预备空方法 +// Prepare 预备空方法 func (b *BasePlugin) Prepare(ctx context.Context) error { return nil } -//PreHandler 预处理空方法 +// PreHandler 预处理空方法 func (b *BasePlugin) PreHandler(ctx context.Context, conf *config.JSON) error { return nil } -//PostHandler 后置通知处理空方法 +// PostHandler 后置通知处理空方法 func (b *BasePlugin) PostHandler(ctx context.Context, conf *config.JSON) error { return nil } diff --git a/datax/common/plugin/record_receiver.go b/datax/common/plugin/record_receiver.go index def4188..3fa4a59 100644 --- a/datax/common/plugin/record_receiver.go +++ b/datax/common/plugin/record_receiver.go @@ -18,7 +18,7 @@ import ( "github.com/Breeze0806/go-etl/element" ) -//RecordReceiver 记录接收器 +// RecordReceiver 记录接收器 type RecordReceiver interface { GetFromReader() (element.Record, error) //从reader中读取记录 Shutdown() error // 关闭 diff --git a/datax/common/plugin/record_sender.go b/datax/common/plugin/record_sender.go index c436ef2..81de409 100644 --- a/datax/common/plugin/record_sender.go +++ b/datax/common/plugin/record_sender.go @@ -18,7 +18,7 @@ import ( "github.com/Breeze0806/go-etl/element" ) -//RecordSender 记录发送器 +// RecordSender 记录发送器 type RecordSender interface { CreateRecord() (element.Record, error) //创建记录 SendWriter(record element.Record) error //将记录发往写入器 diff --git a/datax/common/plugin/task.go b/datax/common/plugin/task.go index 2c52569..898ccee 100644 --- a/datax/common/plugin/task.go +++ b/datax/common/plugin/task.go @@ -20,7 +20,7 @@ import ( "github.com/pingcap/errors" ) -//Task 任务接口 +// Task 任务接口 type Task interface { Plugin @@ -47,7 +47,7 @@ type Task interface { Format(format string) string } -//BaseTask 基础任务，用于辅助和简化任务接口的实现 +// BaseTask 基础任务，用于辅助和简化任务接口的实现 type BaseTask struct { *BasePlugin @@ -57,59 +57,59 @@ type BaseTask struct { collector TaskCollector } -//NewBaseTask 创建基础任务 +// NewBaseTask 创建基础任务 func NewBaseTask() *BaseTask { return &BaseTask{ BasePlugin: NewBasePlugin(), } } -//TaskCollector 任务信息收集器 +// TaskCollector 任务信息收集器 func (b *BaseTask) TaskCollector() TaskCollector { return b.collector } -//SetTaskCollector 设置任务信息收集器 +// SetTaskCollector 设置任务信息收集器 func (b *BaseTask) SetTaskCollector(collector TaskCollector) { b.collector = collector } -//TaskID 任务ID +// TaskID 任务ID func (b *BaseTask) TaskID() int64 { return b.taskID } -//SetTaskID 设置任务ID +// SetTaskID 设置任务ID func (b *BaseTask) SetTaskID(taskID int64) { b.taskID = taskID } -//TaskGroupID 任务组ID +// TaskGroupID 任务组ID func (b *BaseTask) TaskGroupID() int64 { return b.taskGroupID } -//SetTaskGroupID 设置任务组ID +// SetTaskGroupID 设置任务组ID func (b *BaseTask) SetTaskGroupID(taskGroupID int64) { b.taskGroupID = taskGroupID } -//JobID 工作ID +// JobID 工作ID func (b *BaseTask) JobID() int64 { return b.jobID } -//SetJobID 设置工作ID +// SetJobID 设置工作ID func (b *BaseTask) SetJobID(jobID int64) { b.jobID = jobID } -//Wrapf 包裹错误 +// Wrapf 包裹错误 func (b *BaseTask) Wrapf(err error, format string, args ...interface{}) error { return errors.Wrapf(err, b.Format(format), args...) } -//Format 日志格式 +// Format 日志格式 func (b *BaseTask) Format(format string) string { return fmt.Sprintf("jobId : %v taskgroupId: %v taskId: %v %v", b.jobID, b.taskGroupID, b.taskID, format) } diff --git a/datax/common/plugin/task_collector.go b/datax/common/plugin/task_collector.go index 87e05e1..a725eb4 100644 --- a/datax/common/plugin/task_collector.go +++ b/datax/common/plugin/task_collector.go @@ -16,8 +16,8 @@ package plugin import "github.com/Breeze0806/go-etl/element" -//TaskCollector 任务收集器 -//todo 当前未使用 +// TaskCollector 任务收集器 +// todo 当前未使用 type TaskCollector interface { CollectDirtyRecordWithError(record element.Record, err error) CollectDirtyRecordWithMsg(record element.Record, msgErr string) diff --git a/datax/common/plugin/type.go b/datax/common/plugin/type.go index ce77d83..e9aa10c 100644 --- a/datax/common/plugin/type.go +++ b/datax/common/plugin/type.go @@ -14,10 +14,10 @@ package plugin -//Type 插件类型 +// Type 插件类型 type Type string -//插件类型枚举 +// 插件类型枚举 var ( Reader Type = "reader" //读取器 Writer Type = "writer" //写入器 @@ -25,7 +25,7 @@ var ( Handler Type = "handler" //处理器 ) -//NewType 新增类型 +// NewType 新增类型 func NewType(s string) Type { return Type(s) } @@ -34,7 +34,7 @@ func (t Type) String() string { return string(t) } -//IsValid 是否合法 +// IsValid 是否合法 func (t Type) IsValid() bool { switch t { case Reader, Writer, Transformer, Handler: diff --git a/datax/common/spi/reader.go b/datax/common/spi/reader.go index 549c057..1f2f5db 100644 --- a/datax/common/spi/reader.go +++ b/datax/common/spi/reader.go @@ -16,7 +16,7 @@ package spi import "github.com/Breeze0806/go-etl/datax/common/spi/reader" -//Reader 读取器 +// Reader 读取器 type Reader interface { Job() reader.Job //获取读取工作,一般不能为空 Task() reader.Task //获取读取任务,一般不能为空 diff --git a/datax/common/spi/reader/job.go b/datax/common/spi/reader/job.go index 5e5ef0f..2dc12d5 100644 --- a/datax/common/spi/reader/job.go +++ b/datax/common/spi/reader/job.go @@ -21,7 +21,7 @@ import ( "github.com/Breeze0806/go-etl/datax/common/plugin" ) -//Job 工作 +// Job 工作 type Job interface { plugin.Job diff --git a/datax/common/spi/reader/task.go b/datax/common/spi/reader/task.go index 80fda0a..2b1ef50 100644 --- a/datax/common/spi/reader/task.go +++ b/datax/common/spi/reader/task.go @@ -20,7 +20,7 @@ import ( "github.com/Breeze0806/go-etl/datax/common/plugin" ) -//Task 任务 +// Task 任务 type Task interface { plugin.Task diff --git a/datax/common/spi/writer.go b/datax/common/spi/writer.go index e6ab2ab..f59a675 100644 --- a/datax/common/spi/writer.go +++ b/datax/common/spi/writer.go @@ -16,7 +16,7 @@ package spi import "github.com/Breeze0806/go-etl/datax/common/spi/writer" -//Writer 写入器 +// Writer 写入器 type Writer interface { Job() writer.Job //获取写入工作,一般不能为空 Task() writer.Task //获取写入任务,一般不能为空 diff --git a/datax/common/spi/writer/job.go b/datax/common/spi/writer/job.go index 6b376be..9d9d0d4 100644 --- a/datax/common/spi/writer/job.go +++ b/datax/common/spi/writer/job.go @@ -21,7 +21,7 @@ import ( "github.com/Breeze0806/go-etl/datax/common/plugin" ) -//Job 工作 +// Job 工作 type Job interface { plugin.Job diff --git a/datax/common/spi/writer/task.go b/datax/common/spi/writer/task.go index e846ca8..4387213 100644 --- a/datax/common/spi/writer/task.go +++ b/datax/common/spi/writer/task.go @@ -20,7 +20,7 @@ import ( "github.com/Breeze0806/go-etl/datax/common/plugin" ) -//Task 写入任务 +// Task 写入任务 type Task interface { plugin.Task @@ -30,19 +30,19 @@ type Task interface { SupportFailOver() bool } -//BaseTask 基础写入任务，辅助和简化写入任务接口的实现 +// BaseTask 基础写入任务，辅助和简化写入任务接口的实现 type BaseTask struct { *plugin.BaseTask } -//NewBaseTask 创建基础任务 +// NewBaseTask 创建基础任务 func NewBaseTask() *BaseTask { return &BaseTask{ BaseTask: plugin.NewBaseTask(), } } -//SupportFailOver 是否支持故障转移，就是是否在写入后失败重试 +// SupportFailOver 是否支持故障转移，就是是否在写入后失败重试 func (b *BaseTask) SupportFailOver() bool { return false } diff --git a/datax/common/util/error_record_checker.go b/datax/common/util/error_record_checker.go index 7311a50..6ea73c2 100644 --- a/datax/common/util/error_record_checker.go +++ b/datax/common/util/error_record_checker.go @@ -14,6 +14,6 @@ package util -//ErrorRecordChecker 错误检查器 todo未使用 +// ErrorRecordChecker 错误检查器 todo未使用 type ErrorRecordChecker struct { } diff --git a/datax/core/container.go b/datax/core/container.go index 7103ae9..3922228 100644 --- a/datax/core/container.go +++ b/datax/core/container.go @@ -19,39 +19,39 @@ import ( "github.com/Breeze0806/go-etl/datax/core/statistics/container" ) -//Container 容器 +// Container 容器 type Container interface { Start() error Metrics() *container.Metrics } -//BaseCotainer 基础容器 +// BaseCotainer 基础容器 type BaseCotainer struct { conf *config.JSON metrics *container.Metrics } -//NewBaseCotainer 创建基础容器 +// NewBaseCotainer 创建基础容器 func NewBaseCotainer() *BaseCotainer { return &BaseCotainer{} } -//SetMetrics 设置指标 +// SetMetrics 设置指标 func (b *BaseCotainer) SetMetrics(metrics *container.Metrics) { b.metrics = metrics } -//Metrics 指标 +// Metrics 指标 func (b *BaseCotainer) Metrics() *container.Metrics { return b.metrics } -//SetConfig 设置JSON配置 +// SetConfig 设置JSON配置 func (b *BaseCotainer) SetConfig(conf *config.JSON) { b.conf = conf } -//Config JSON配置 +// Config JSON配置 func (b *BaseCotainer) Config() *config.JSON { return b.conf } diff --git a/datax/core/job/container.go b/datax/core/job/container.go index 7956a60..e52a2f4 100644 --- a/datax/core/job/container.go +++ b/datax/core/job/container.go @@ -38,7 +38,7 @@ import ( "github.com/pingcap/errors" ) -//Container 工作容器环境，所有的工作都在本容器环境中执行 +// Container 工作容器环境，所有的工作都在本容器环境中执行 type Container struct { ctx context.Context *core.BaseCotainer @@ -61,8 +61,8 @@ type Container struct { wg sync.WaitGroup } -//NewContainer 通过上下文ctx和JSON配置conf生成工作容器环境 -//当container job id小于0时，会报错 +// NewContainer 通过上下文ctx和JSON配置conf生成工作容器环境 +// 当container job id小于0时，会报错 func NewContainer(ctx context.Context, conf *config.JSON) (c *Container, err error) { c = &Container{ BaseCotainer: core.NewBaseCotainer(), @@ -79,7 +79,7 @@ func NewContainer(ctx context.Context, conf *config.JSON) (c *Container, err err return } -//Start 工作容器开始工作 +// Start 工作容器开始工作 func (c *Container) Start() (err error) { log.Infof("DataX jobContainer %v starts job.", c.jobID) defer c.destroy() @@ -125,8 +125,8 @@ func (c *Container) Start() (err error) { return nil } -//destroy 销毁，在jobReader不为空时进行销毁 -//在jobWriter不为空时进行销毁 +// destroy 销毁，在jobReader不为空时进行销毁 +// 在jobWriter不为空时进行销毁 func (c *Container) destroy() (err error) { if c.jobReader != nil { if rerr := c.jobReader.Destroy(c.ctx); rerr != nil { @@ -146,9 +146,9 @@ func (c *Container) destroy() (err error) { return } -//init 检查并初始化读取器和写入器工作 -//当配置文件读取器和写入器的名字和参数不存在的情况下会报错 -//另外，读取器和写入器工作初始化失败也会导致报错 +// init 检查并初始化读取器和写入器工作 +// 当配置文件读取器和写入器的名字和参数不存在的情况下会报错 +// 另外，读取器和写入器工作初始化失败也会导致报错 func (c *Container) init() (err error) { c.readerPluginName, err = c.Config().GetString(coreconst.DataxJobContentReaderName) if err != nil { @@ -196,8 +196,8 @@ func (c *Container) init() (err error) { return } -//prepare 准备读取器和写入器工作 -//如果读取器和写入器工作准备失败就会报错 +// prepare 准备读取器和写入器工作 +// 如果读取器和写入器工作准备失败就会报错 func (c *Container) prepare() (err error) { if err = c.prepareReaderJob(); err != nil { return err @@ -210,20 +210,20 @@ func (c *Container) prepare() (err error) { return } -//prepareReaderJob 准备读取工作 +// prepareReaderJob 准备读取工作 func (c *Container) prepareReaderJob() error { return c.jobReader.Prepare(c.ctx) } -//prepareReaderJob 准备写入工作 +// prepareReaderJob 准备写入工作 func (c *Container) prepareWriterJob() error { return c.jobWriter.Prepare(c.ctx) } -//split 切分读取器和写入器工作 -//先进行读取工作切分成多个任务，再根据读取工作切分的结果进行写入工作切分多个任务 -//然后逐个将单个读取任务、单个写入任务和转化器组合成完整任务组，由于reader，writer，channel模型 -//切分时读取器和写入器的比例为1:1，所以这里可以将reader和writer的配置整合到一起 +// split 切分读取器和写入器工作 +// 先进行读取工作切分成多个任务，再根据读取工作切分的结果进行写入工作切分多个任务 +// 然后逐个将单个读取任务、单个写入任务和转化器组合成完整任务组，由于reader，writer，channel模型 +// 切分时读取器和写入器的比例为1:1，所以这里可以将reader和writer的配置整合到一起 func (c *Container) split() (err error) { if err = c.adjustChannelNumber(); err != nil { return @@ -267,7 +267,7 @@ func (c *Container) split() (err error) { return nil } -//schedule 使用调度器将任务组进行调度，进入执行队列中 +// schedule 使用调度器将任务组进行调度，进入执行队列中 func (c *Container) schedule() (err error) { var tasksConfigs []*config.JSON tasksConfigs, err = c.distributeTaskIntoTaskGroup() @@ -336,7 +336,7 @@ func (c *Container) setStats(taskGroup *taskgroup.Container, i int) { c.Metrics().Set("metrics."+strconv.Itoa(i), stats) } -//post 后置通知 +// post 后置通知 func (c *Container) post() (err error) { if err = c.jobReader.Post(c.ctx); err != nil { return err @@ -349,7 +349,7 @@ func (c *Container) post() (err error) { return } -//mergeTaskConfigs 逐个将单个读取任务、单个写入任务和转化器组合成完整任务组 +// mergeTaskConfigs 逐个将单个读取任务、单个写入任务和转化器组合成完整任务组 func (c *Container) mergeTaskConfigs(readerConfs, writerConfs []*config.JSON) (taskConfigs []*config.JSON, err error) { if len(readerConfs) != len(writerConfs) { err = errors.New("the number of reader tasks are not equal to the number of writer tasks") @@ -391,8 +391,8 @@ func (c *Container) mergeTaskConfigs(readerConfs, writerConfs []*config.JSON) (t return } -//distributeTaskIntoTaskGroup 公平的分配 task 到对应的 taskGroup 中。 -//公平体现在：会考虑 task 中对资源负载作的 load 标识进行更均衡的作业分配操作。 +// distributeTaskIntoTaskGroup 公平的分配 task 到对应的 taskGroup 中。 +// 公平体现在：会考虑 task 中对资源负载作的 load 标识进行更均衡的作业分配操作。 func (c *Container) distributeTaskIntoTaskGroup() (confs []*config.JSON, err error) { var tasksConfigs []*config.JSON tasksConfigs, err = c.Config().GetConfigArray(coreconst.DataxJobContent) @@ -434,8 +434,8 @@ func (c *Container) distributeTaskIntoTaskGroup() (confs []*config.JSON, err err return } -//adjustChannelNumber 自适应化通道数量 -//依次根据字节流大小，记录数大小以及通道数大小生成通道数量 +// adjustChannelNumber 自适应化通道数量 +// 依次根据字节流大小，记录数大小以及通道数大小生成通道数量 func (c *Container) adjustChannelNumber() error { var needChannelNumberByByte int64 = math.MaxInt32 var needChannelNumberByRecord int64 = math.MaxInt32 @@ -497,8 +497,8 @@ func (c *Container) adjustChannelNumber() error { return errors.New("job speed should be setted") } -//initReaderJob 初始化读取工作 -//当读取插件名找不到读取工作或者初始化失败就会报错 +// initReaderJob 初始化读取工作 +// 当读取插件名找不到读取工作或者初始化失败就会报错 func (c *Container) initReaderJob(collector plugin.JobCollector, readerConfig, writerConfig *config.JSON) (job reader.Job, err error) { ok := false job, ok = loader.LoadReaderJob(c.readerPluginName) @@ -518,8 +518,8 @@ func (c *Container) initReaderJob(collector plugin.JobCollector, readerConfig, w return } -//initReaderJob 初始化写入工作 -//当写入插件名找不到写入工作或者初始化失败就会报错 +// initReaderJob 初始化写入工作 +// 当写入插件名找不到写入工作或者初始化失败就会报错 func (c *Container) initWriterJob(collector plugin.JobCollector, readerConfig, writerConfig *config.JSON) (job writer.Job, err error) { ok := false job, ok = loader.LoadWriterJob(c.writerPluginName) @@ -539,7 +539,7 @@ func (c *Container) initWriterJob(collector plugin.JobCollector, readerConfig, w return } -//preHandle 事实上对于使用者是空壳，reader和writer未实现对应逻辑PreHandle +// preHandle 事实上对于使用者是空壳，reader和writer未实现对应逻辑PreHandle func (c *Container) preHandle() (err error) { if !c.Config().Exists(coreconst.DataxJobPreHandlerPluginType) { return @@ -570,7 +570,7 @@ func (c *Container) preHandle() (err error) { return } -//postHandle 事实上对于使用者是空壳，reader和writer未实现对应逻辑PostHandle +// postHandle 事实上对于使用者是空壳，reader和writer未实现对应逻辑PostHandle func (c *Container) postHandle() (err error) { if !c.Config().Exists(coreconst.DataxJobPostHandlerPluginType) { return @@ -607,12 +607,12 @@ func (c *Container) postHandle() (err error) { // a 库上有表：3, 4 // c 库上有表：5, 6, 7 -// 如果有 4个 taskGroup -// 则 assign 后的结果为： -// taskGroup-0: 0, 4, -// taskGroup-1: 3, 6, -// taskGroup-2: 5, 2, -// taskGroup-3: 1, 7 +// 如果有 4个 taskGroup +// 则 assign 后的结果为： +// taskGroup-0: 0, 4, +// taskGroup-1: 3, 6, +// taskGroup-2: 5, 2, +// taskGroup-3: 1, 7 func doAssign(taskIDMap map[string][]int, taskGroupNumber int) [][]int { taskGroups := make([][]int, taskGroupNumber) var taskMasks []string @@ -640,8 +640,8 @@ func doAssign(taskIDMap map[string][]int, taskGroupNumber int) [][]int { return taskGroups } -//parseAndGetResourceMarkAndTaskIDMap 根据task 配置，获取到： -//资源名称 --> taskId(List) 的 map 映射关系(对资源负载作的 load 标识: 任务编号) +// parseAndGetResourceMarkAndTaskIDMap 根据task 配置，获取到： +// 资源名称 --> taskId(List) 的 map 映射关系(对资源负载作的 load 标识: 任务编号) func parseAndGetResourceMarkAndTaskIDMap(tasksConfigs []*config.JSON) map[string][]int { writerMap := make(map[string][]int) readerMap := make(map[string][]int) diff --git a/datax/core/statistics/container/metrics.go b/datax/core/statistics/container/metrics.go index 6ea777c..120fba9 100644 --- a/datax/core/statistics/container/metrics.go +++ b/datax/core/statistics/container/metrics.go @@ -20,14 +20,14 @@ import ( "github.com/Breeze0806/go/encoding" ) -//Metrics json格式指标 +// Metrics json格式指标 type Metrics struct { sync.RWMutex metricJSON *encoding.JSON } -//NewMetrics json格式指标 +// NewMetrics json格式指标 func NewMetrics() *Metrics { j, _ := encoding.NewJSONFromString("{}") return &Metrics{ @@ -35,21 +35,21 @@ func NewMetrics() *Metrics { } } -//JSON json格式指标 +// JSON json格式指标 func (m *Metrics) JSON() *encoding.JSON { m.RLock() defer m.RUnlock() return m.metricJSON } -//Set 设置path的value +// Set 设置path的value func (m *Metrics) Set(path string, value interface{}) error { m.Lock() defer m.Unlock() return m.metricJSON.Set(path, value) } -//Get 获得path的value +// Get 获得path的value func (m *Metrics) Get(key string) *encoding.JSON { m.RLock() defer m.RUnlock() diff --git a/datax/core/statistics/container/plugin/default_job_collector.go b/datax/core/statistics/container/plugin/default_job_collector.go index b297021..a4b834a 100644 --- a/datax/core/statistics/container/plugin/default_job_collector.go +++ b/datax/core/statistics/container/plugin/default_job_collector.go @@ -20,22 +20,22 @@ import ( "github.com/Breeze0806/go/encoding" ) -//DefaultJobCollector 默认工作收集器 +// DefaultJobCollector 默认工作收集器 type DefaultJobCollector struct { metrics *container.Metrics } -//NewDefaultJobCollector 创建默认工作收集器 +// NewDefaultJobCollector 创建默认工作收集器 func NewDefaultJobCollector(metrics *container.Metrics) plugin.JobCollector { return &DefaultJobCollector{metrics: metrics} } -//JSON 获取json的指标 +// JSON 获取json的指标 func (d *DefaultJobCollector) JSON() *encoding.JSON { return d.metrics.JSON() } -//JSONByKey 获取关键字是key的json的指标 +// JSONByKey 获取关键字是key的json的指标 func (d *DefaultJobCollector) JSONByKey(key string) *encoding.JSON { return d.metrics.Get(key) } diff --git a/datax/core/taskgroup/container.go b/datax/core/taskgroup/container.go index 8803805..02a8b58 100644 --- a/datax/core/taskgroup/container.go +++ b/datax/core/taskgroup/container.go @@ -29,7 +29,7 @@ import ( "github.com/pingcap/errors" ) -//Container 任务组容器环境 +// Container 任务组容器环境 type Container struct { *core.BaseCotainer @@ -47,8 +47,8 @@ type Container struct { retryMaxCount int32 } -//NewContainer 根据JSON配置conf创建任务组容器 -//当jobID 和 taskGroupID非法就会报错 +// NewContainer 根据JSON配置conf创建任务组容器 +// 当jobID 和 taskGroupID非法就会报错 func NewContainer(ctx context.Context, conf *config.JSON) (c *Container, err error) { c = &Container{ BaseCotainer: core.NewBaseCotainer(), @@ -78,22 +78,22 @@ func NewContainer(ctx context.Context, conf *config.JSON) (c *Container, err err return } -//JobID 工作编号 +// JobID 工作编号 func (c *Container) JobID() int64 { return c.jobID } -//TaskGroupID 任务组编号 +// TaskGroupID 任务组编号 func (c *Container) TaskGroupID() int64 { return c.taskGroupID } -//Do 执行 +// Do 执行 func (c *Container) Do() error { return c.Start() } -//Start 开始运行，使用任务调度器执行这些JSON配置 +// Start 开始运行，使用任务调度器执行这些JSON配置 func (c *Container) Start() (err error) { log.Infof("datax job(%v) taskgruop(%v) start", c.jobID, c.taskGroupID) defer log.Infof("datax job(%v) taskgruop(%v) end", c.jobID, c.taskGroupID) @@ -183,7 +183,7 @@ QueueLoop: return nil } -//startTaskExecer 开始任务 +// startTaskExecer 开始任务 func (c *Container) startTaskExecer(te *taskExecer) (err error) { log.Debugf("datax job(%v) taskgruop(%v) task(%v) push", c.jobID, c.taskGroupID, te.Key()) c.wg.Add(1) diff --git a/datax/core/taskgroup/runner/reader.go b/datax/core/taskgroup/runner/reader.go index 8569281..d1e2e13 100644 --- a/datax/core/taskgroup/runner/reader.go +++ b/datax/core/taskgroup/runner/reader.go @@ -21,7 +21,7 @@ import ( "github.com/Breeze0806/go-etl/datax/common/spi/reader" ) -//Reader 读取运行器 +// Reader 读取运行器 type Reader struct { *baseRunner @@ -30,7 +30,7 @@ type Reader struct { describe string } -//NewReader 通过读取任务task、记录发送器sender以及任务关键字taskKey创建读取运行器 +// NewReader 通过读取任务task、记录发送器sender以及任务关键字taskKey创建读取运行器 func NewReader(task reader.Task, sender plugin.RecordSender, taskKey string) *Reader { return &Reader{ baseRunner: &baseRunner{}, @@ -40,12 +40,12 @@ func NewReader(task reader.Task, sender plugin.RecordSender, taskKey string) *Re } } -//Plugin 插件任务 +// Plugin 插件任务 func (r *Reader) Plugin() plugin.Task { return r.task } -//Run 运行，运行顺序：Init->Prepare->StartRead->Post->Destroy +// Run 运行，运行顺序：Init->Prepare->StartRead->Post->Destroy func (r *Reader) Run(ctx context.Context) (err error) { defer func() { log.Debugf("datax reader runner %v starts to destroy", r.describe) @@ -76,7 +76,7 @@ func (r *Reader) Run(ctx context.Context) (err error) { return } -//Shutdown 关闭 +// Shutdown 关闭 func (r *Reader) Shutdown() error { return r.sender.Shutdown() } diff --git a/datax/core/taskgroup/runner/runner.go b/datax/core/taskgroup/runner/runner.go index b053035..e72e322 100644 --- a/datax/core/taskgroup/runner/runner.go +++ b/datax/core/taskgroup/runner/runner.go @@ -20,7 +20,7 @@ import ( "github.com/Breeze0806/go-etl/datax/common/plugin" ) -//Runner 运行器 +// Runner 运行器 type Runner interface { Plugin() plugin.Task //插件任务 Shutdown() error //关闭 diff --git a/datax/core/taskgroup/runner/writer.go b/datax/core/taskgroup/runner/writer.go index ce11010..c7f059c 100644 --- a/datax/core/taskgroup/runner/writer.go +++ b/datax/core/taskgroup/runner/writer.go @@ -21,7 +21,7 @@ import ( "github.com/Breeze0806/go-etl/datax/common/spi/writer" ) -//Writer 写入运行器 +// Writer 写入运行器 type Writer struct { *baseRunner receiver plugin.RecordReceiver @@ -29,7 +29,7 @@ type Writer struct { describe string } -//NewWriter 通过读取任务task、记录接受器receiver以及任务关键字taskKey创建写入运行器 +// NewWriter 通过读取任务task、记录接受器receiver以及任务关键字taskKey创建写入运行器 func NewWriter(task writer.Task, receiver plugin.RecordReceiver, taskKey string) *Writer { return &Writer{ baseRunner: &baseRunner{}, @@ -39,12 +39,12 @@ func NewWriter(task writer.Task, receiver plugin.RecordReceiver, taskKey string) } } -//Plugin 插件任务 +// Plugin 插件任务 func (w *Writer) Plugin() plugin.Task { return w.task } -//Run 运行，运行顺序：Init->Prepare->StartWrite->Post->Destroy +// Run 运行，运行顺序：Init->Prepare->StartWrite->Post->Destroy func (w *Writer) Run(ctx context.Context) (err error) { defer func() { log.Debugf("datax writer runner %v starts to destroy", w.describe) diff --git a/datax/core/taskgroup/task_execer.go b/datax/core/taskgroup/task_execer.go index fd6393b..44318ef 100644 --- a/datax/core/taskgroup/task_execer.go +++ b/datax/core/taskgroup/task_execer.go @@ -50,9 +50,9 @@ type taskExecer struct { attemptCount *atomic.Int32 //执行次数 } -//newTaskExecer 根据上下文ctx，任务配置taskConf，前缀关键字prefixKey -//执行次数attemptCount生成任务执行器，当taskID不存在，工作器名字配置以及 -//对应写入器和读取器不存在时会报错 +// newTaskExecer 根据上下文ctx，任务配置taskConf，前缀关键字prefixKey +// 执行次数attemptCount生成任务执行器，当taskID不存在，工作器名字配置以及 +// 对应写入器和读取器不存在时会报错 func newTaskExecer(ctx context.Context, taskConf *config.JSON, jobID, taskGroupID int64, attemptCount int) (t *taskExecer, err error) { t = &taskExecer{ @@ -118,7 +118,7 @@ func newTaskExecer(ctx context.Context, taskConf *config.JSON, return } -//Start 读取运行器和写入运行器分别在携程中执行 +// Start 读取运行器和写入运行器分别在携程中执行 func (t *taskExecer) Start() { var ctx context.Context t.cancalMutex.Lock() @@ -158,12 +158,12 @@ func (t *taskExecer) Start() { readerWg.Wait() } -//AttemptCount 执行次数 +// AttemptCount 执行次数 func (t *taskExecer) AttemptCount() int32 { return t.attemptCount.Load() } -//Do 执行函数 +// Do 执行函数 func (t *taskExecer) Do() (err error) { log.Debugf("taskExecer %v start to do", t.key) defer func() { @@ -189,12 +189,12 @@ func (t *taskExecer) Do() (err error) { } } -//Key 关键字 +// Key 关键字 func (t *taskExecer) Key() string { return t.key } -//WriterSuportFailOverport 写入器是否支持错误重试 +// WriterSuportFailOverport 写入器是否支持错误重试 func (t *taskExecer) WriterSuportFailOverport() bool { task, ok := t.writerRunner.Plugin().(writer.Task) if !ok { @@ -203,7 +203,7 @@ func (t *taskExecer) WriterSuportFailOverport() bool { return task.SupportFailOver() } -//Shutdown 通过cancel停止写入器，关闭reader和writer +// Shutdown 通过cancel停止写入器，关闭reader和writer func (t *taskExecer) Shutdown() { log.Debugf("taskExecer %v starts to shutdown", t.key) defer log.Debugf("taskExecer %v ends to shutdown", t.key) @@ -245,13 +245,13 @@ Loop: t.writerRunner.Shutdown() } -//Stats 统计信息 +// Stats 统计信息 type Stats struct { TaskID int64 `json:"taskID"` Channel channel.StatsJSON `json:"channel"` } -//Stats 获取统计信息 +// Stats 获取统计信息 func (t *taskExecer) Stats() Stats { return Stats{ TaskID: t.taskID, diff --git a/datax/core/taskgroup/task_manager.go b/datax/core/taskgroup/task_manager.go index 3ee08e8..4ed7e63 100644 --- a/datax/core/taskgroup/task_manager.go +++ b/datax/core/taskgroup/task_manager.go @@ -18,44 +18,44 @@ import ( "github.com/Breeze0806/go-etl/schedule" ) -//taskManager 任务管理器 +// taskManager 任务管理器 type taskManager struct { manager *schedule.MappedTaskManager } -//newTaskManager 创建任务管理器 +// newTaskManager 创建任务管理器 func newTaskManager() *taskManager { return &taskManager{ manager: schedule.NewTaskManager(), } } -//isEmpty 任务管理器是否为空 +// isEmpty 任务管理器是否为空 func (t *taskManager) isEmpty() bool { return t.manager.IsEmpty() } -//size 任务数，包含待执行和运行任务 +// size 任务数，包含待执行和运行任务 func (t *taskManager) size() int { return t.manager.Size() } -//removeRunAndPushRemain 从运行队列移动到待执行队列 +// removeRunAndPushRemain 从运行队列移动到待执行队列 func (t *taskManager) removeRunAndPushRemain(te *taskExecer) { t.manager.RemoveRunAndPushRemain(te) } -//pushRemain 把任务加入待执行队列 +// pushRemain 把任务加入待执行队列 func (t *taskManager) pushRemain(te *taskExecer) { t.manager.PushRemain(te) } -//removeRun 从运行队列移除出任务 +// removeRun 从运行队列移除出任务 func (t *taskManager) removeRun(te *taskExecer) { t.manager.RemoveRun(te) } -//popRemainAndAddRun 从待执行队列移到运行队列中 +// popRemainAndAddRun 从待执行队列移到运行队列中 func (t *taskManager) popRemainAndAddRun() (te *taskExecer, ok bool) { var task schedule.MappedTask task, ok = t.manager.PopRemainAndAddRun() diff --git a/datax/core/transport/channel/channel.go b/datax/core/transport/channel/channel.go index 35b2493..363a8e9 100644 --- a/datax/core/transport/channel/channel.go +++ b/datax/core/transport/channel/channel.go @@ -24,7 +24,7 @@ import ( "golang.org/x/time/rate" ) -//Channel 通道 +// Channel 通道 type Channel struct { limiter *rate.Limiter records *element.RecordChan @@ -32,13 +32,13 @@ type Channel struct { stats Stats } -//Stats Channel的统计信息 +// Stats Channel的统计信息 type Stats struct { sync.RWMutex StatsJSON } -//StatsJSON Channel的JSON统计信息 +// StatsJSON Channel的JSON统计信息 type StatsJSON struct { TotalByte int64 `json:"totalByte"` TotalRecord int64 `json:"totalRecord"` @@ -62,14 +62,14 @@ func (s *Stats) reduce(b int64) { s.Record-- } -//statsJSON 返回json的机构体 +// statsJSON 返回json的机构体 func (s *Stats) statsJSON() StatsJSON { s.RLock() defer s.RUnlock() return s.StatsJSON } -//NewChannel 创建通道 +// NewChannel 创建通道 func NewChannel(ctx context.Context, conf *config.JSON) *Channel { r := -1 b := -1.0 @@ -91,17 +91,17 @@ func NewChannel(ctx context.Context, conf *config.JSON) *Channel { } } -//Size 通道记录大小 +// Size 通道记录大小 func (c *Channel) Size() int { return c.records.Buffered() } -//IsEmpty 通道是否为空 +// IsEmpty 通道是否为空 func (c *Channel) IsEmpty() bool { return c.Size() == 0 } -//Push 将记录r加入通道 +// Push 将记录r加入通道 func (c *Channel) Push(r element.Record) (n int, err error) { if c.limiter != nil { if err = c.limiter.WaitN(c.ctx, int(r.ByteSize())); err != nil { @@ -112,7 +112,7 @@ func (c *Channel) Push(r element.Record) (n int, err error) { return c.records.PushBack(r), nil } -//Pop 将记录弹出，当通道中不存在记录，就会返回false +// Pop 将记录弹出，当通道中不存在记录，就会返回false func (c *Channel) Pop() (r element.Record, ok bool) { r, ok = c.records.PopFront() if r != nil { @@ -121,28 +121,28 @@ func (c *Channel) Pop() (r element.Record, ok bool) { return } -//PushAll 通过fetchRecord函数加入多条记录 +// PushAll 通过fetchRecord函数加入多条记录 func (c *Channel) PushAll(fetchRecord func() (element.Record, error)) error { return c.records.PushBackAll(fetchRecord) } -//PopAll 通过onRecord函数弹出多条记录 +// PopAll 通过onRecord函数弹出多条记录 func (c *Channel) PopAll(onRecord func(element.Record) error) error { return c.records.PopFrontAll(onRecord) } -//Close 关闭 +// Close 关闭 func (c *Channel) Close() { c.records.Close() } -//PushTerminate 加入终止记录 +// PushTerminate 加入终止记录 func (c *Channel) PushTerminate() (n int) { n, _ = c.Push(element.GetTerminateRecord()) return } -//StatsJSON 返回Channel的统计信息 +// StatsJSON 返回Channel的统计信息 func (c *Channel) StatsJSON() StatsJSON { return c.stats.statsJSON() } diff --git a/datax/core/transport/exchange/record_exchanger.go b/datax/core/transport/exchange/record_exchanger.go index 75bb642..a64d748 100644 --- a/datax/core/transport/exchange/record_exchanger.go +++ b/datax/core/transport/exchange/record_exchanger.go @@ -22,26 +22,26 @@ import ( "github.com/Breeze0806/go-etl/element" ) -//错误枚举 +// 错误枚举 var ( ErrTerminate = errors.New("reader is terminated") ErrEmpty = errors.New("chan is empty") ErrShutdown = errors.New("exchange is shutdowned") ) -//RecordExchanger 记录交换器 +// RecordExchanger 记录交换器 type RecordExchanger struct { tran transform.Transformer ch *channel.Channel isShutdown bool } -//NewRecordExchangerWithoutTransformer 生成不带转化器的记录交换器 +// NewRecordExchangerWithoutTransformer 生成不带转化器的记录交换器 func NewRecordExchangerWithoutTransformer(ch *channel.Channel) *RecordExchanger { return NewRecordExchanger(ch, &transform.NilTransformer{}) } -//NewRecordExchanger 根据通道ch和转化器tran生成的记录交换器 +// NewRecordExchanger 根据通道ch和转化器tran生成的记录交换器 func NewRecordExchanger(ch *channel.Channel, tran transform.Transformer) *RecordExchanger { return &RecordExchanger{ tran: tran, @@ -49,8 +49,8 @@ func NewRecordExchanger(ch *channel.Channel, tran transform.Transformer) *Record } } -//GetFromReader 从Reader中获取记录 -//当交换器关闭，通道为空或者收到终止消息也会报错 +// GetFromReader 从Reader中获取记录 +// 当交换器关闭，通道为空或者收到终止消息也会报错 func (r *RecordExchanger) GetFromReader() (newRecord element.Record, err error) { if r.isShutdown { return nil, ErrShutdown @@ -71,19 +71,19 @@ func (r *RecordExchanger) GetFromReader() (newRecord element.Record, err error) } } -//Shutdown 关闭 +// Shutdown 关闭 func (r *RecordExchanger) Shutdown() error { r.isShutdown = true return nil } -//CreateRecord 创建记录 +// CreateRecord 创建记录 func (r *RecordExchanger) CreateRecord() (element.Record, error) { return element.NewDefaultRecord(), nil } -//SendWriter 向写入器写入记录recode,其中还会通过转化器的转化 -//当转化失败或者通道已关闭时就会报错 +// SendWriter 向写入器写入记录recode,其中还会通过转化器的转化 +// 当转化失败或者通道已关闭时就会报错 func (r *RecordExchanger) SendWriter(record element.Record) (err error) { if r.isShutdown { return ErrShutdown @@ -94,12 +94,12 @@ func (r *RecordExchanger) SendWriter(record element.Record) (err error) { return } -//Flush 刷新，空方法 +// Flush 刷新，空方法 func (r *RecordExchanger) Flush() error { return nil } -//Terminate 终止记录交换 +// Terminate 终止记录交换 func (r *RecordExchanger) Terminate() error { r.ch.PushTerminate() return nil diff --git a/datax/doc.go b/datax/doc.go index 89fa0d2..54680bc 100644 --- a/datax/doc.go +++ b/datax/doc.go @@ -13,12 +13,14 @@ // limitations under the License. // Package datax 主要离线数据同步框架，框架如下 -// Database->readerPlugin（reader）->Framework(Exchanger+Transformer) ->writerPlugin（writer）->Database +// +// Database->readerPlugin（reader）->Framework(Exchanger+Transformer) ->writerPlugin（writer）->Database // // 采用Framework + plugin架构构建。将数据源读取和写入抽象成为Reader/Writer插件，纳入到整个同步框架中。 // Reader：Reader为数据采集模块，负责采集数据源的数据，将数据发送给Framework。 // Writer： Writer为数据写入模块，负责不断向Framework取数据，并将数据写入到目的端。 // Framework：Framework用于连接reader和writer，作为两者的数据传输通道，并处理缓冲，流控，并发，数据转换等核心技术问题 +// // JOB--split--+-- task1--+ +--taskGroup1-------+______________________________________________ // |-- task2--| |--taskGroup2 | Reader1->Exchanger1(Transformer)->Writer1 | // |-- task3--|-schedule--|--taskGroup3 | Reader2->Exchanger2(Transformer)->Writer2 | @@ -27,7 +29,6 @@ // | ReaderN->ExchangerN(Transformer)->WriterN | // |______________________________________________| // -// // 核心模块介绍: // // DataX完成单个数据同步的作业，我们称之为Job，DataX接受到一个Job之后，将启动一个进程来完成整个作业同步过程。DataX Job模块是单个作业的中枢管理节点，承担了数据清理、子任务切分(将单一作业计算转化为多个子Task)、TaskGroup管理等功能。 diff --git a/datax/engine.go b/datax/engine.go index dac90a6..3876489 100644 --- a/datax/engine.go +++ b/datax/engine.go @@ -25,33 +25,33 @@ import ( "github.com/pingcap/errors" ) -//Model 模式 +// Model 模式 type Model string -//容器工作模式 +// 容器工作模式 var ( ModelJob Model = "job" //以工作为单位工作 ModelTaskGroup Model = "taskGroup" //以任务组为单位工作 ) -//IsJob 是否以工作为单位工作 +// IsJob 是否以工作为单位工作 func (m Model) IsJob() bool { return m == ModelJob } -//IsTaskGroup 以任务组为单位工作 +// IsTaskGroup 以任务组为单位工作 func (m Model) IsTaskGroup() bool { return m == ModelTaskGroup } -//Engine 执行引擎 +// Engine 执行引擎 type Engine struct { core.Container ctx context.Context conf *config.JSON } -//NewEngine 通过上下文ctx以及JSON配置conf创建新执行引擎 +// NewEngine 通过上下文ctx以及JSON配置conf创建新执行引擎 func NewEngine(ctx context.Context, conf *config.JSON) *Engine { return &Engine{ ctx: ctx, @@ -59,7 +59,7 @@ func NewEngine(ctx context.Context, conf *config.JSON) *Engine { } } -//Start 启动 +// Start 启动 func (e *Engine) Start() (err error) { model := Model(e.conf.GetStringOrDefaullt(coreconst.DataxCoreContainerModel, string(ModelJob))) switch { diff --git a/datax/plugin/reader/csv/config.go b/datax/plugin/reader/csv/config.go index 2214cbf..347b6bb 100644 --- a/datax/plugin/reader/csv/config.go +++ b/datax/plugin/reader/csv/config.go @@ -22,14 +22,14 @@ import ( "github.com/Breeze0806/go-etl/storage/stream/file/csv" ) -//Config csv读入配置 +// Config csv读入配置 type Config struct { csv.InConfig Path []string `json:"path"` } -//NewConfig 读取json配置conf获取csv读入配置 +// NewConfig 读取json配置conf获取csv读入配置 func NewConfig(conf *config.JSON) (c *Config, err error) { c = &Config{} if err = json.Unmarshal([]byte(conf.String()), c); err != nil { diff --git a/datax/plugin/reader/csv/job.go b/datax/plugin/reader/csv/job.go index 3bbef60..69886b6 100644 --- a/datax/plugin/reader/csv/job.go +++ b/datax/plugin/reader/csv/job.go @@ -22,27 +22,27 @@ import ( "github.com/pingcap/errors" ) -//Job 工作 +// Job 工作 type Job struct { *file.Job conf *Config } -//NewJob 创建工作 +// NewJob 创建工作 func NewJob() *Job { return &Job{ Job: file.NewJob(), } } -//Init 初始化 +// Init 初始化 func (j *Job) Init(ctx context.Context) (err error) { j.conf, err = NewConfig(j.PluginJobConf()) return errors.Wrapf(err, "NewConfig fail. val: %v", j.PluginConf()) } -//Split 切分 +// Split 切分 func (j *Job) Split(ctx context.Context, number int) (configs []*config.JSON, err error) { for _, v := range j.conf.Path { conf, _ := config.NewJSONFromString("{}") diff --git a/datax/plugin/reader/csv/reader.go b/datax/plugin/reader/csv/reader.go index 7bc3b46..52ec23b 100644 --- a/datax/plugin/reader/csv/reader.go +++ b/datax/plugin/reader/csv/reader.go @@ -20,24 +20,24 @@ import ( "github.com/Breeze0806/go-etl/datax/plugin/reader/file" ) -//Reader 读取器 +// Reader 读取器 type Reader struct { pluginConf *config.JSON } -//ResourcesConfig 插件资源配置 +// ResourcesConfig 插件资源配置 func (r *Reader) ResourcesConfig() *config.JSON { return r.pluginConf } -//Job 工作 +// Job 工作 func (r *Reader) Job() spireader.Job { job := NewJob() job.SetPluginConf(r.pluginConf) return job } -//Task 任务 +// Task 任务 func (r *Reader) Task() spireader.Task { task := file.NewTask() task.SetPluginConf(r.pluginConf) diff --git a/datax/plugin/reader/db2/job.go b/datax/plugin/reader/db2/job.go index 1886054..9568477 100644 --- a/datax/plugin/reader/db2/job.go +++ b/datax/plugin/reader/db2/job.go @@ -18,7 +18,7 @@ import ( "github.com/Breeze0806/go-etl/datax/plugin/reader/dbms" ) -//Job 工作 +// Job 工作 type Job struct { *dbms.Job } diff --git a/datax/plugin/reader/db2/reader.go b/datax/plugin/reader/db2/reader.go index 4f2b5b6..8d69797 100644 --- a/datax/plugin/reader/db2/reader.go +++ b/datax/plugin/reader/db2/reader.go @@ -21,17 +21,17 @@ import ( "github.com/Breeze0806/go-etl/storage/database" ) -//Reader 读取器 +// Reader 读取器 type Reader struct { pluginConf *config.JSON } -//ResourcesConfig 插件资源配置 +// ResourcesConfig 插件资源配置 func (r *Reader) ResourcesConfig() *config.JSON { return r.pluginConf } -//Job 工作 +// Job 工作 func (r *Reader) Job() spireader.Job { job := &Job{ Job: dbms.NewJob(dbms.NewBaseDbHandler(func(name string, conf *config.JSON) (q dbms.Querier, err error) { @@ -45,7 +45,7 @@ func (r *Reader) Job() spireader.Job { return job } -//Task 任务 +// Task 任务 func (r *Reader) Task() spireader.Task { task := &Task{ Task: dbms.NewTask(dbms.NewBaseDbHandler(func(name string, conf *config.JSON) (q dbms.Querier, err error) { diff --git a/datax/plugin/reader/db2/task.go b/datax/plugin/reader/db2/task.go index 8e68c89..7044942 100644 --- a/datax/plugin/reader/db2/task.go +++ b/datax/plugin/reader/db2/task.go @@ -24,12 +24,12 @@ import ( _ "github.com/Breeze0806/go-etl/storage/database/db2" ) -//Task 任务 +// Task 任务 type Task struct { *dbms.Task } -//StartRead 开始读 +// StartRead 开始读 func (t *Task) StartRead(ctx context.Context, sender plugin.RecordSender) (err error) { return dbms.StartRead(ctx, dbms.NewBaseBatchReader(t.Task, "", nil), sender) } diff --git a/datax/plugin/reader/dbms/config.go b/datax/plugin/reader/dbms/config.go index 7411016..3f149f7 100644 --- a/datax/plugin/reader/dbms/config.go +++ b/datax/plugin/reader/dbms/config.go @@ -21,7 +21,7 @@ import ( "github.com/Breeze0806/go-etl/storage/database" ) -//Config 关系型数据读入器配置 +// Config 关系型数据读入器配置 type Config interface { GetUsername() string //获取用户名 GetPassword() string //获取密码 @@ -33,22 +33,22 @@ type Config interface { GetQuerySQL() []string //获取查询sql } -//Column 列信息 +// Column 列信息 type Column interface { GetName() string //获取表名 } -//BaseColumn 基础列信息 +// BaseColumn 基础列信息 type BaseColumn struct { Name string } -//GetName 获取列名 +// GetName 获取列名 func (b *BaseColumn) GetName() string { return b.Name } -//BaseConfig 基础关系型数据读入器配置 +// BaseConfig 基础关系型数据读入器配置 type BaseConfig struct { Username string `json:"username"` //用户名 Password string `json:"password"` //密码 @@ -59,7 +59,7 @@ type BaseConfig struct { QuerySQL []string `json:"querySql"` //查询sql } -//NewBaseConfig 通过json配置conf获取基础关系型数据读入器配置 +// NewBaseConfig 通过json配置conf获取基础关系型数据读入器配置 func NewBaseConfig(conf *config.JSON) (c *BaseConfig, err error) { c = &BaseConfig{} err = json.Unmarshal([]byte(conf.String()), c) @@ -69,22 +69,22 @@ func NewBaseConfig(conf *config.JSON) (c *BaseConfig, err error) { return } -//GetUsername 获取用户名 +// GetUsername 获取用户名 func (b *BaseConfig) GetUsername() string { return b.Username } -//GetPassword 获取密码 +// GetPassword 获取密码 func (b *BaseConfig) GetPassword() string { return b.Password } -//GetURL 获取关系型数据库连接url +// GetURL 获取关系型数据库连接url func (b *BaseConfig) GetURL() string { return b.Connection.URL } -//GetColumns 获取列信息 +// GetColumns 获取列信息 func (b *BaseConfig) GetColumns() (columns []Column) { for _, v := range b.Column { columns = append(columns, &BaseColumn{ @@ -94,33 +94,33 @@ func (b *BaseConfig) GetColumns() (columns []Column) { return } -//GetBaseTable 获取表信息 +// GetBaseTable 获取表信息 func (b *BaseConfig) GetBaseTable() *database.BaseTable { return database.NewBaseTable(b.Connection.Table.Db, b.Connection.Table.Schema, b.Connection.Table.Name) } -//GetWhere 获取查询条件 +// GetWhere 获取查询条件 func (b *BaseConfig) GetWhere() string { return b.Where } -//GetSplitConfig 获取切分配置 +// GetSplitConfig 获取切分配置 func (b *BaseConfig) GetSplitConfig() SplitConfig { return b.Split } -//GetQuerySQL 获取查询sql +// GetQuerySQL 获取查询sql func (b *BaseConfig) GetQuerySQL() []string { return b.QuerySQL } -//ConnConfig 连接配置 +// ConnConfig 连接配置 type ConnConfig struct { URL string `json:"url"` //连接数据库 Table TableConfig `json:"table"` //表配置 } -//TableConfig 表配置 +// TableConfig 表配置 type TableConfig struct { Db string `json:"db"` //库 Schema string `json:"schema"` //模式 diff --git a/datax/plugin/reader/dbms/db_handler.go b/datax/plugin/reader/dbms/db_handler.go index d7f6ddb..a5b5ca8 100644 --- a/datax/plugin/reader/dbms/db_handler.go +++ b/datax/plugin/reader/dbms/db_handler.go @@ -37,7 +37,7 @@ type BaseDbHandler struct { opts *sql.TxOptions } -//NewBaseDbHandler 通过获取查询器函数newQuerier和事务选项opts获取基础数据库句柄 +// NewBaseDbHandler 通过获取查询器函数newQuerier和事务选项opts获取基础数据库句柄 func NewBaseDbHandler(newQuerier func(name string, conf *config.JSON) (Querier, error), opts *sql.TxOptions) *BaseDbHandler { return &BaseDbHandler{ newQuerier: newQuerier, @@ -45,32 +45,32 @@ func NewBaseDbHandler(newQuerier func(name string, conf *config.JSON) (Querier, } } -//Querier 通过数据库名name和json配置conf获取查询器 +// Querier 通过数据库名name和json配置conf获取查询器 func (d *BaseDbHandler) Querier(name string, conf *config.JSON) (Querier, error) { return d.newQuerier(name, conf) } -//Config 通过json配置conf获取关系型数据库输入配置 +// Config 通过json配置conf获取关系型数据库输入配置 func (d *BaseDbHandler) Config(conf *config.JSON) (Config, error) { return NewBaseConfig(conf) } -//TableParam 通过关系型数据库输入配置config和查询器querier获取表参数 +// TableParam 通过关系型数据库输入配置config和查询器querier获取表参数 func (d *BaseDbHandler) TableParam(config Config, querier Querier) database.Parameter { return NewTableParam(config, querier, d.opts) } -//SplitParam 通过关系型数据库输入配置config和表Table获取切分最小值参数 +// SplitParam 通过关系型数据库输入配置config和表Table获取切分最小值参数 func (d *BaseDbHandler) SplitParam(config Config, querier Querier) database.Parameter { return NewSplitParam(config, querier, d.opts) } -//MinParam 通过关系型数据库输入配置config和查询器querier获取切分表参数 +// MinParam 通过关系型数据库输入配置config和查询器querier获取切分表参数 func (d *BaseDbHandler) MinParam(config Config, table database.Table) database.Parameter { return NewMinParam(config, table, d.opts) } -//MaxParam 通过关系型数据库输入配置config和表询器Table获取切分最大值参数 +// MaxParam 通过关系型数据库输入配置config和表询器Table获取切分最大值参数 func (d *BaseDbHandler) MaxParam(config Config, table database.Table) database.Parameter { return NewMaxParam(config, table, d.opts) } diff --git a/datax/plugin/reader/dbms/job.go b/datax/plugin/reader/dbms/job.go index 9e07aed..3fb64bb 100644 --- a/datax/plugin/reader/dbms/job.go +++ b/datax/plugin/reader/dbms/job.go @@ -27,7 +27,7 @@ import ( "github.com/pingcap/errors" ) -//Job 工作 +// Job 工作 type Job struct { *plugin.BaseJob @@ -36,7 +36,7 @@ type Job struct { handler DbHandler } -//NewJob 通过数据库句柄handler获取工作 +// NewJob 通过数据库句柄handler获取工作 func NewJob(handler DbHandler) *Job { return &Job{ BaseJob: plugin.NewBaseJob(), @@ -44,7 +44,7 @@ func NewJob(handler DbHandler) *Job { } } -//Init 初始化 +// Init 初始化 func (j *Job) Init(ctx context.Context) (err error) { var name string if name, err = j.PluginConf().GetString("dialect"); err != nil { @@ -77,7 +77,7 @@ func (j *Job) Init(ctx context.Context) (err error) { return } -//Destroy 销毁 +// Destroy 销毁 func (j *Job) Destroy(ctx context.Context) (err error) { if j.Querier != nil { err = j.Querier.Close() @@ -116,7 +116,7 @@ func (j *Job) fetchMax(ctx context.Context, splitTable database.Table) (c elemen return } -//Split 切分 +// Split 切分 func (j *Job) Split(ctx context.Context, number int) (configs []*config.JSON, err error) { if len(j.Config.GetQuerySQL()) > 0 { for _, v := range j.Config.GetQuerySQL() { diff --git a/datax/plugin/reader/dbms/parameter.go b/datax/plugin/reader/dbms/parameter.go index 7bb0a92..c57b9ce 100644 --- a/datax/plugin/reader/dbms/parameter.go +++ b/datax/plugin/reader/dbms/parameter.go @@ -23,25 +23,25 @@ import ( "github.com/pingcap/errors" ) -//TableParamConfig 表参数配置 +// TableParamConfig 表参数配置 type TableParamConfig interface { GetColumns() []Column //获取列信息 GetBaseTable() *database.BaseTable //获取表信息 } -//TableParamTable 通过表参数获取对应数据库的表 +// TableParamTable 通过表参数获取对应数据库的表 type TableParamTable interface { Table(*database.BaseTable) database.Table //通过表参数获取对应数据库的表 } -//TableParam 表参数 +// TableParam 表参数 type TableParam struct { *database.BaseParam Config TableParamConfig } -//NewTableParam 获取表参数配置config，通过表参数获取对应数据库的表table和事务选项opts获取表参数 +// NewTableParam 获取表参数配置config，通过表参数获取对应数据库的表table和事务选项opts获取表参数 func NewTableParam(config TableParamConfig, table TableParamTable, opts *sql.TxOptions) *TableParam { return &TableParam{ BaseParam: database.NewBaseParam(table.Table(config.GetBaseTable()), opts), @@ -50,7 +50,7 @@ func NewTableParam(config TableParamConfig, table TableParamTable, opts *sql.TxO } } -//Query 获取查询语句 +// Query 获取查询语句 func (t *TableParam) Query(_ []element.Record) (string, error) { buf := bytes.NewBufferString("select ") if len(t.Config.GetColumns()) == 0 { @@ -68,19 +68,19 @@ func (t *TableParam) Query(_ []element.Record) (string, error) { return buf.String(), nil } -//Agrs 获取查询参数 +// Agrs 获取查询参数 func (t *TableParam) Agrs(_ []element.Record) ([]interface{}, error) { return nil, nil } -//QueryParam 查询参数 +// QueryParam 查询参数 type QueryParam struct { *database.BaseParam Config Config } -//NewQueryParam 通过关系型数据库输入配置config，对应数据库表table和事务选项opts获取查询参数 +// NewQueryParam 通过关系型数据库输入配置config，对应数据库表table和事务选项opts获取查询参数 func NewQueryParam(config Config, table database.Table, opts *sql.TxOptions) *QueryParam { return &QueryParam{ BaseParam: database.NewBaseParam(table, opts), @@ -89,7 +89,7 @@ func NewQueryParam(config Config, table database.Table, opts *sql.TxOptions) *Qu } } -//Query 获取查询语句 +// Query 获取查询语句 func (q *QueryParam) Query(_ []element.Record) (string, error) { if len(q.Config.GetQuerySQL()) > 1 { return "", errors.NewNoStackError("too much querySQL") @@ -118,7 +118,7 @@ func (q *QueryParam) Query(_ []element.Record) (string, error) { return buf.String(), nil } -//Agrs 获取查询参数 +// Agrs 获取查询参数 func (q *QueryParam) Agrs(_ []element.Record) (a []interface{}, err error) { if len(q.Config.GetQuerySQL()) > 0 { return nil, nil @@ -149,14 +149,14 @@ func (q *QueryParam) Agrs(_ []element.Record) (a []interface{}, err error) { return nil, nil } -//SplitParam 切分参数 +// SplitParam 切分参数 type SplitParam struct { *database.BaseParam Config Config } -//NewSplitParam 获取表参数配置config，通过表参数获取对应数据库的表table和事务选项opts获取切分表参数 +// NewSplitParam 获取表参数配置config，通过表参数获取对应数据库的表table和事务选项opts获取切分表参数 func NewSplitParam(config Config, table TableParamTable, opts *sql.TxOptions) *SplitParam { return &SplitParam{ BaseParam: database.NewBaseParam(table.Table(config.GetBaseTable()), opts), @@ -165,7 +165,7 @@ func NewSplitParam(config Config, table TableParamTable, opts *sql.TxOptions) *S } } -//Query 获取查询语句 +// Query 获取查询语句 func (s *SplitParam) Query(_ []element.Record) (string, error) { buf := bytes.NewBufferString("select ") @@ -177,19 +177,19 @@ func (s *SplitParam) Query(_ []element.Record) (string, error) { return buf.String(), nil } -//Agrs 获取查询参数 +// Agrs 获取查询参数 func (s *SplitParam) Agrs(_ []element.Record) ([]interface{}, error) { return nil, nil } -//MinParam 最小值参数 +// MinParam 最小值参数 type MinParam struct { *database.BaseParam Config Config } -//NewMinParam 通过关系型数据库输入配置config，对应数据库表table和事务选项opts获取最小值参数 +// NewMinParam 通过关系型数据库输入配置config，对应数据库表table和事务选项opts获取最小值参数 func NewMinParam(config Config, table database.Table, opts *sql.TxOptions) *MinParam { return &MinParam{ BaseParam: database.NewBaseParam(table, opts), @@ -198,7 +198,7 @@ func NewMinParam(config Config, table database.Table, opts *sql.TxOptions) *MinP } } -//Query 获取查询语句 +// Query 获取查询语句 func (m *MinParam) Query(_ []element.Record) (string, error) { buf := bytes.NewBufferString("select min(") buf.WriteString(m.Config.GetSplitConfig().Key) @@ -212,19 +212,19 @@ func (m *MinParam) Query(_ []element.Record) (string, error) { return buf.String(), nil } -//Agrs 获取查询参数 +// Agrs 获取查询参数 func (m *MinParam) Agrs(_ []element.Record) ([]interface{}, error) { return nil, nil } -//MaxParam 最大值参数 +// MaxParam 最大值参数 type MaxParam struct { *database.BaseParam Config Config } -//NewMaxParam 通过关系型数据库输入配置config，对应数据库表table和事务选项opts获取查询参数 +// NewMaxParam 通过关系型数据库输入配置config，对应数据库表table和事务选项opts获取查询参数 func NewMaxParam(config Config, table database.Table, opts *sql.TxOptions) *MaxParam { return &MaxParam{ BaseParam: database.NewBaseParam(table, opts), @@ -233,7 +233,7 @@ func NewMaxParam(config Config, table database.Table, opts *sql.TxOptions) *MaxP } } -//Query 获取查询语句 +// Query 获取查询语句 func (m *MaxParam) Query(_ []element.Record) (string, error) { buf := bytes.NewBufferString("select max(") buf.WriteString(m.Config.GetSplitConfig().Key) @@ -247,7 +247,7 @@ func (m *MaxParam) Query(_ []element.Record) (string, error) { return buf.String(), nil } -//Agrs 获取查询参数 +// Agrs 获取查询参数 func (m *MaxParam) Agrs(_ []element.Record) ([]interface{}, error) { return nil, nil } diff --git a/datax/plugin/reader/dbms/querier.go b/datax/plugin/reader/dbms/querier.go index c990af6..554d2d7 100644 --- a/datax/plugin/reader/dbms/querier.go +++ b/datax/plugin/reader/dbms/querier.go @@ -21,7 +21,7 @@ import ( "github.com/Breeze0806/go-etl/storage/database" ) -//Querier 查询器 +// Querier 查询器 type Querier interface { //通过基础表信息获取具体表 Table(*database.BaseTable) database.Table diff --git a/datax/plugin/reader/dbms/split.go b/datax/plugin/reader/dbms/split.go index 93cbea3..e828a6f 100644 --- a/datax/plugin/reader/dbms/split.go +++ b/datax/plugin/reader/dbms/split.go @@ -35,7 +35,7 @@ type splitRangeFetcher interface { fetchMin(ctx context.Context, splitTable database.Table) (element.Column, error) } -//SplitConfig 切分配置 +// SplitConfig 切分配置 type SplitConfig struct { Key string `json:"key"` //切分键 //day（日）,min（分钟）,s（秒）,ms（毫秒）,us（微秒）,ns（纳秒） @@ -109,7 +109,7 @@ func (s SplitConfig) checkType(splitTable database.Table) (err error) { return nil } -//SplitRange 切分范围配置 +// SplitRange 切分范围配置 type SplitRange struct { Type string `json:"type"` //类型 bigint, string, time Layout string `json:"layout"` //时间格式 diff --git a/datax/plugin/reader/dbms/task.go b/datax/plugin/reader/dbms/task.go index ce3e602..8b1cc3a 100644 --- a/datax/plugin/reader/dbms/task.go +++ b/datax/plugin/reader/dbms/task.go @@ -26,7 +26,7 @@ import ( "github.com/Breeze0806/go-etl/storage/database" ) -//Task 任务 +// Task 任务 type Task struct { *plugin.BaseTask @@ -36,7 +36,7 @@ type Task struct { Table database.Table } -//NewTask 通过数据库句柄handler获取任务 +// NewTask 通过数据库句柄handler获取任务 func NewTask(handler DbHandler) *Task { return &Task{ BaseTask: plugin.NewBaseTask(), @@ -45,7 +45,7 @@ func NewTask(handler DbHandler) *Task { } } -//Init 初始化 +// Init 初始化 func (t *Task) Init(ctx context.Context) (err error) { var name string if name, err = t.PluginConf().GetString("dialect"); err != nil { @@ -87,7 +87,7 @@ func (t *Task) Init(ctx context.Context) (err error) { return } -//Destroy 销毁 +// Destroy 销毁 func (t *Task) Destroy(ctx context.Context) (err error) { if t.Querier != nil { err = t.Querier.Close() @@ -95,7 +95,7 @@ func (t *Task) Destroy(ctx context.Context) (err error) { return t.Wrapf(err, "Close fail") } -//BatchReader 批量读入器 +// BatchReader 批量读入器 type BatchReader interface { JobID() int64 //工作编号 TaskGroupID() int64 //任务组编号 @@ -105,14 +105,14 @@ type BatchReader interface { Parameter() database.Parameter //查询参数 } -//BaseBatchReader 基础批量读入器 +// BaseBatchReader 基础批量读入器 type BaseBatchReader struct { task *Task mode string opts *sql.TxOptions } -//NewBaseBatchReader 通过任务task，查询模式mode和事务选项opts获取基础批量读入器 +// NewBaseBatchReader 通过任务task，查询模式mode和事务选项opts获取基础批量读入器 func NewBaseBatchReader(task *Task, mode string, opts *sql.TxOptions) *BaseBatchReader { return &BaseBatchReader{ task: task, @@ -121,27 +121,27 @@ func NewBaseBatchReader(task *Task, mode string, opts *sql.TxOptions) *BaseBatch } } -//JobID 工作编号 +// JobID 工作编号 func (b *BaseBatchReader) JobID() int64 { return b.task.JobID() } -//TaskID 任务编号 +// TaskID 任务编号 func (b *BaseBatchReader) TaskID() int64 { return b.task.TaskID() } -//TaskGroupID 任务组编号 +// TaskGroupID 任务组编号 func (b *BaseBatchReader) TaskGroupID() int64 { return b.task.TaskGroupID() } -//Parameter 查询参数 +// Parameter 查询参数 func (b *BaseBatchReader) Parameter() database.Parameter { return NewQueryParam(b.task.Config, b.task.Table, b.opts) } -//通过上下文ctx，查询阐述和数据库句柄handler查询 +// 通过上下文ctx，查询阐述和数据库句柄handler查询 func (b *BaseBatchReader) Read(ctx context.Context, param database.Parameter, handler database.FetchHandler) (err error) { if b.mode == "Tx" { return b.task.Querier.FetchRecordWithTx(ctx, param, handler) @@ -149,7 +149,7 @@ func (b *BaseBatchReader) Read(ctx context.Context, param database.Parameter, ha return b.task.Querier.FetchRecord(ctx, param, handler) } -//StartRead 开始读 +// StartRead 开始读 func StartRead(ctx context.Context, reader BatchReader, sender plugin.RecordSender) (err error) { handler := database.NewBaseFetchHandler(func() (element.Record, error) { return sender.CreateRecord() diff --git a/datax/plugin/reader/file/job.go b/datax/plugin/reader/file/job.go index 5afc748..204433c 100644 --- a/datax/plugin/reader/file/job.go +++ b/datax/plugin/reader/file/job.go @@ -20,19 +20,19 @@ import ( "github.com/Breeze0806/go-etl/datax/common/plugin" ) -//Job 工作 +// Job 工作 type Job struct { *plugin.BaseJob } -//NewJob 新建 +// NewJob 新建 func NewJob() *Job { return &Job{ plugin.NewBaseJob(), } } -//Destroy 销毁 +// Destroy 销毁 func (j *Job) Destroy(ctx context.Context) (err error) { return } diff --git a/datax/plugin/reader/file/task.go b/datax/plugin/reader/file/task.go index 60e71c3..131e21b 100644 --- a/datax/plugin/reader/file/task.go +++ b/datax/plugin/reader/file/task.go @@ -23,21 +23,21 @@ import ( "github.com/Breeze0806/go-etl/storage/stream/file" ) -//Task 任务 +// Task 任务 type Task struct { *plugin.BaseTask streamer *file.InStreamer } -//NewTask 新建任务 +// NewTask 新建任务 func NewTask() *Task { return &Task{ BaseTask: plugin.NewBaseTask(), } } -//Init 初始化任务 +// Init 初始化任务 func (t *Task) Init(ctx context.Context) (err error) { var name string if name, err = t.PluginConf().GetString("opener"); err != nil { @@ -54,7 +54,7 @@ func (t *Task) Init(ctx context.Context) (err error) { return } -//Destroy 销毁 +// Destroy 销毁 func (t *Task) Destroy(ctx context.Context) (err error) { if t.streamer != nil { err = t.streamer.Close() @@ -80,7 +80,7 @@ func (h *handler) OnRecord(r element.Record) error { return h.sender.SendWriter(r) } -//StartRead 开启读取数据发往sender +// StartRead 开启读取数据发往sender func (t *Task) StartRead(ctx context.Context, sender plugin.RecordSender) (err error) { handler := newHander(sender) diff --git a/datax/plugin/reader/file/task_test.go b/datax/plugin/reader/file/task_test.go index 07e3f93..bff8022 100644 --- a/datax/plugin/reader/file/task_test.go +++ b/datax/plugin/reader/file/task_test.go @@ -76,35 +76,35 @@ func (m *mockOpener) Open(filename string) (stream file.InStream, err error) { return &mockInStream{err: m.err}, nil } -//MockSender 模拟发送器 +// MockSender 模拟发送器 type MockSender struct { record element.Record CreateErr error SendErr error } -//CreateRecord 创建记录 +// CreateRecord 创建记录 func (m *MockSender) CreateRecord() (element.Record, error) { return element.NewDefaultRecord(), m.CreateErr } -//SendWriter 发往写入器 +// SendWriter 发往写入器 func (m *MockSender) SendWriter(record element.Record) error { m.record = record return m.SendErr } -//Flush 刷新至写入器 +// Flush 刷新至写入器 func (m *MockSender) Flush() error { return nil } -//Terminate 终止发送数据 +// Terminate 终止发送数据 func (m *MockSender) Terminate() error { return nil } -//Shutdown 关闭 +// Shutdown 关闭 func (m *MockSender) Shutdown() error { return nil } diff --git a/datax/plugin/reader/mysql/job.go b/datax/plugin/reader/mysql/job.go index b4f2e08..8dff6cb 100644 --- a/datax/plugin/reader/mysql/job.go +++ b/datax/plugin/reader/mysql/job.go @@ -18,7 +18,7 @@ import ( "github.com/Breeze0806/go-etl/datax/plugin/reader/dbms" ) -//Job 工作 +// Job 工作 type Job struct { *dbms.Job } diff --git a/datax/plugin/reader/mysql/reader.go b/datax/plugin/reader/mysql/reader.go index b2c2cda..039e678 100644 --- a/datax/plugin/reader/mysql/reader.go +++ b/datax/plugin/reader/mysql/reader.go @@ -24,17 +24,17 @@ import ( _ "github.com/Breeze0806/go-etl/storage/database/mysql" ) -//Reader 读取器 +// Reader 读取器 type Reader struct { pluginConf *config.JSON } -//ResourcesConfig 插件资源配置 +// ResourcesConfig 插件资源配置 func (r *Reader) ResourcesConfig() *config.JSON { return r.pluginConf } -//Job 工作 +// Job 工作 func (r *Reader) Job() spireader.Job { job := &Job{ Job: dbms.NewJob(dbms.NewBaseDbHandler(func(name string, conf *config.JSON) (q dbms.Querier, err error) { @@ -48,7 +48,7 @@ func (r *Reader) Job() spireader.Job { return job } -//Task 任务 +// Task 任务 func (r *Reader) Task() spireader.Task { task := &Task{ Task: dbms.NewTask(dbms.NewBaseDbHandler(func(name string, conf *config.JSON) (q dbms.Querier, err error) { diff --git a/datax/plugin/reader/mysql/task.go b/datax/plugin/reader/mysql/task.go index 37c7f61..517f01c 100644 --- a/datax/plugin/reader/mysql/task.go +++ b/datax/plugin/reader/mysql/task.go @@ -21,12 +21,12 @@ import ( "github.com/Breeze0806/go-etl/datax/plugin/reader/dbms" ) -//Task 任务 +// Task 任务 type Task struct { *dbms.Task } -//StartRead 开始读 +// StartRead 开始读 func (t *Task) StartRead(ctx context.Context, sender plugin.RecordSender) (err error) { return dbms.StartRead(ctx, dbms.NewBaseBatchReader(t.Task, "", nil), sender) } diff --git a/datax/plugin/reader/oracle/job.go b/datax/plugin/reader/oracle/job.go index f51319c..532dbfd 100644 --- a/datax/plugin/reader/oracle/job.go +++ b/datax/plugin/reader/oracle/job.go @@ -16,7 +16,7 @@ package oracle import "github.com/Breeze0806/go-etl/datax/plugin/reader/dbms" -//Job 工作 +// Job 工作 type Job struct { *dbms.Job } diff --git a/datax/plugin/reader/oracle/reader.go b/datax/plugin/reader/oracle/reader.go index 4f49ed9..84a1765 100644 --- a/datax/plugin/reader/oracle/reader.go +++ b/datax/plugin/reader/oracle/reader.go @@ -21,17 +21,17 @@ import ( "github.com/Breeze0806/go-etl/storage/database" ) -//Reader 读取器 +// Reader 读取器 type Reader struct { pluginConf *config.JSON } -//ResourcesConfig 插件资源配置 +// ResourcesConfig 插件资源配置 func (r *Reader) ResourcesConfig() *config.JSON { return r.pluginConf } -//Job 工作 +// Job 工作 func (r *Reader) Job() spireader.Job { job := &Job{ Job: dbms.NewJob(dbms.NewBaseDbHandler(func(name string, conf *config.JSON) (q dbms.Querier, err error) { @@ -45,7 +45,7 @@ func (r *Reader) Job() spireader.Job { return job } -//Task 任务 +// Task 任务 func (r *Reader) Task() spireader.Task { task := &Task{ Task: dbms.NewTask(dbms.NewBaseDbHandler(func(name string, conf *config.JSON) (q dbms.Querier, err error) { diff --git a/datax/plugin/reader/oracle/task.go b/datax/plugin/reader/oracle/task.go index 0576d1a..dbcd3e0 100644 --- a/datax/plugin/reader/oracle/task.go +++ b/datax/plugin/reader/oracle/task.go @@ -24,12 +24,12 @@ import ( _ "github.com/Breeze0806/go-etl/storage/database/oracle" ) -//Task 任务 +// Task 任务 type Task struct { *dbms.Task } -//StartRead 开始读 +// StartRead 开始读 func (t *Task) StartRead(ctx context.Context, sender plugin.RecordSender) (err error) { return dbms.StartRead(ctx, dbms.NewBaseBatchReader(t.Task, "", nil), sender) } diff --git a/datax/plugin/reader/postgres/job.go b/datax/plugin/reader/postgres/job.go index 9933712..b4f102a 100644 --- a/datax/plugin/reader/postgres/job.go +++ b/datax/plugin/reader/postgres/job.go @@ -18,7 +18,7 @@ import ( "github.com/Breeze0806/go-etl/datax/plugin/reader/dbms" ) -//Job 工作 +// Job 工作 type Job struct { *dbms.Job } diff --git a/datax/plugin/reader/postgres/reader.go b/datax/plugin/reader/postgres/reader.go index 4bce1a2..1726333 100644 --- a/datax/plugin/reader/postgres/reader.go +++ b/datax/plugin/reader/postgres/reader.go @@ -24,17 +24,17 @@ import ( _ "github.com/Breeze0806/go-etl/storage/database/postgres" ) -//Reader 读取器 +// Reader 读取器 type Reader struct { pluginConf *config.JSON } -//ResourcesConfig 插件资源配置 +// ResourcesConfig 插件资源配置 func (r *Reader) ResourcesConfig() *config.JSON { return r.pluginConf } -//Job 工作 +// Job 工作 func (r *Reader) Job() spireader.Job { job := &Job{ Job: dbms.NewJob( @@ -49,7 +49,7 @@ func (r *Reader) Job() spireader.Job { return job } -//Task 任务 +// Task 任务 func (r *Reader) Task() spireader.Task { task := &Task{ Task: dbms.NewTask(dbms.NewBaseDbHandler(func(name string, conf *config.JSON) (q dbms.Querier, err error) { diff --git a/datax/plugin/reader/postgres/task.go b/datax/plugin/reader/postgres/task.go index b8fbd6c..2452fca 100644 --- a/datax/plugin/reader/postgres/task.go +++ b/datax/plugin/reader/postgres/task.go @@ -21,12 +21,12 @@ import ( "github.com/Breeze0806/go-etl/datax/plugin/reader/dbms" ) -//Task 任务 +// Task 任务 type Task struct { *dbms.Task } -//StartRead 开始读 +// StartRead 开始读 func (t *Task) StartRead(ctx context.Context, sender plugin.RecordSender) (err error) { return dbms.StartRead(ctx, dbms.NewBaseBatchReader(t.Task, "", nil), sender) } diff --git a/datax/plugin/reader/reader.go b/datax/plugin/reader/reader.go index 5d5879d..6564056 100644 --- a/datax/plugin/reader/reader.go +++ b/datax/plugin/reader/reader.go @@ -21,21 +21,21 @@ import ( "github.com/pingcap/errors" ) -//Reader 数据库读取器 +// Reader 数据库读取器 type Reader interface { spi.Reader ResourcesConfig() *config.JSON //插件资源配置 } -//Maker 写入生成器 +// Maker 写入生成器 type Maker interface { Default() (Reader, error) } -//RegisterReader 通过生成数据库读取器函数new注册到读取器，返回插件资源配置文件地址，在出错时会包err -//目前未在代码中实际使用，而是通过tools/datax/build的go generate命令自动将resources/plugin.json -//中的内容放入到新生成的代码文件中，用以注册Reader +// RegisterReader 通过生成数据库读取器函数new注册到读取器，返回插件资源配置文件地址，在出错时会包err +// 目前未在代码中实际使用，而是通过tools/datax/build的go generate命令自动将resources/plugin.json +// 中的内容放入到新生成的代码文件中，用以注册Reader func RegisterReader(maker Maker) (err error) { var reader Reader if reader, err = maker.Default(); err != nil { diff --git a/datax/plugin/reader/sqlserver/job.go b/datax/plugin/reader/sqlserver/job.go index 7c36da3..6ba54a4 100644 --- a/datax/plugin/reader/sqlserver/job.go +++ b/datax/plugin/reader/sqlserver/job.go @@ -16,7 +16,7 @@ package sqlserver import "github.com/Breeze0806/go-etl/datax/plugin/reader/dbms" -//Job 工作 +// Job 工作 type Job struct { *dbms.Job } diff --git a/datax/plugin/reader/sqlserver/reader.go b/datax/plugin/reader/sqlserver/reader.go index b2abc6b..83305b8 100644 --- a/datax/plugin/reader/sqlserver/reader.go +++ b/datax/plugin/reader/sqlserver/reader.go @@ -24,17 +24,17 @@ import ( _ "github.com/Breeze0806/go-etl/storage/database/sqlserver" ) -//Reader 读取器 +// Reader 读取器 type Reader struct { pluginConf *config.JSON } -//ResourcesConfig 插件资源配置 +// ResourcesConfig 插件资源配置 func (r *Reader) ResourcesConfig() *config.JSON { return r.pluginConf } -//Job 工作 +// Job 工作 func (r *Reader) Job() spireader.Job { job := &Job{ Job: dbms.NewJob(dbms.NewBaseDbHandler(func(name string, conf *config.JSON) (q dbms.Querier, err error) { @@ -48,7 +48,7 @@ func (r *Reader) Job() spireader.Job { return job } -//Task 任务 +// Task 任务 func (r *Reader) Task() spireader.Task { task := &Task{ Task: dbms.NewTask(dbms.NewBaseDbHandler(func(name string, conf *config.JSON) (q dbms.Querier, err error) { diff --git a/datax/plugin/reader/sqlserver/task.go b/datax/plugin/reader/sqlserver/task.go index b4685a6..e2a0c0d 100644 --- a/datax/plugin/reader/sqlserver/task.go +++ b/datax/plugin/reader/sqlserver/task.go @@ -21,12 +21,12 @@ import ( "github.com/Breeze0806/go-etl/datax/plugin/reader/dbms" ) -//Task 任务 +// Task 任务 type Task struct { *dbms.Task } -//StartRead 开始读 +// StartRead 开始读 func (t *Task) StartRead(ctx context.Context, sender plugin.RecordSender) (err error) { return dbms.StartRead(ctx, dbms.NewBaseBatchReader(t.Task, "", nil), sender) } diff --git a/datax/plugin/reader/xlsx/config.go b/datax/plugin/reader/xlsx/config.go index 5653358..2acc8df 100644 --- a/datax/plugin/reader/xlsx/config.go +++ b/datax/plugin/reader/xlsx/config.go @@ -22,19 +22,19 @@ import ( "github.com/Breeze0806/go-etl/storage/stream/file/xlsx" ) -//Config xlsx输入配置 +// Config xlsx输入配置 type Config struct { xlsx.InConfig Xlsxs []Xlsx `json:"xlsxs"` } -//Xlsx xlsx文件配置 +// Xlsx xlsx文件配置 type Xlsx struct { Path string `json:"path"` Sheets []string `json:"sheets"` } -//NewConfig 读取json配置conf获取xlsx输入配置 +// NewConfig 读取json配置conf获取xlsx输入配置 func NewConfig(conf *config.JSON) (c *Config, err error) { c = &Config{} if err = json.Unmarshal([]byte(conf.String()), c); err != nil { diff --git a/datax/plugin/reader/xlsx/job.go b/datax/plugin/reader/xlsx/job.go index f4b8f4b..768e92a 100644 --- a/datax/plugin/reader/xlsx/job.go +++ b/datax/plugin/reader/xlsx/job.go @@ -23,27 +23,27 @@ import ( "github.com/pingcap/errors" ) -//Job 工作 +// Job 工作 type Job struct { *file.Job conf *Config } -//NewJob 创建工作 +// NewJob 创建工作 func NewJob() *Job { return &Job{ Job: file.NewJob(), } } -//Init 初始化 +// Init 初始化 func (j *Job) Init(ctx context.Context) (err error) { j.conf, err = NewConfig(j.PluginJobConf()) return errors.Wrapf(err, "NewConfig fail. val: %v", j.PluginJobConf()) } -//Split 切分 +// Split 切分 func (j *Job) Split(ctx context.Context, number int) (configs []*config.JSON, err error) { for _, x := range j.conf.Xlsxs { conf, _ := config.NewJSONFromString("{}") diff --git a/datax/plugin/reader/xlsx/reader.go b/datax/plugin/reader/xlsx/reader.go index a767a4e..4faa919 100644 --- a/datax/plugin/reader/xlsx/reader.go +++ b/datax/plugin/reader/xlsx/reader.go @@ -20,24 +20,24 @@ import ( "github.com/Breeze0806/go-etl/datax/plugin/reader/file" ) -//Reader 读取器 +// Reader 读取器 type Reader struct { pluginConf *config.JSON } -//ResourcesConfig 插件资源配置 +// ResourcesConfig 插件资源配置 func (r *Reader) ResourcesConfig() *config.JSON { return r.pluginConf } -//Job 工作 +// Job 工作 func (r *Reader) Job() spireader.Job { job := NewJob() job.SetPluginConf(r.pluginConf) return job } -//Task 任务 +// Task 任务 func (r *Reader) Task() spireader.Task { task := file.NewTask() task.SetPluginConf(r.pluginConf) diff --git a/datax/plugin/writer/csv/config.go b/datax/plugin/writer/csv/config.go index 73ba923..3ffd8f8 100644 --- a/datax/plugin/writer/csv/config.go +++ b/datax/plugin/writer/csv/config.go @@ -24,20 +24,20 @@ import ( "github.com/Breeze0806/go-etl/storage/stream/file/csv" ) -//SingleConfig csv单个输入设置 +// SingleConfig csv单个输入设置 type SingleConfig struct { csv.OutConfig file.BaseConfig } -//Config csv输入配置 +// Config csv输入配置 type Config struct { SingleConfig Path []string `json:"path"` } -//NewConfig 通过json配置conf获取csv输入配置 +// NewConfig 通过json配置conf获取csv输入配置 func NewConfig(conf *config.JSON) (*Config, error) { c := &Config{} if err := json.Unmarshal([]byte(conf.String()), c); err != nil { diff --git a/datax/plugin/writer/csv/job.go b/datax/plugin/writer/csv/job.go index ee8f678..614a7bf 100644 --- a/datax/plugin/writer/csv/job.go +++ b/datax/plugin/writer/csv/job.go @@ -22,26 +22,26 @@ import ( "github.com/pingcap/errors" ) -//Job 工作 +// Job 工作 type Job struct { *file.Job conf *Config } -//NewJob 创建工作 +// NewJob 创建工作 func NewJob() *Job { return &Job{ Job: file.NewJob(), } } -//Init 初始化 +// Init 初始化 func (j *Job) Init(ctx context.Context) (err error) { j.conf, err = NewConfig(j.PluginJobConf()) return errors.Wrapf(err, "NewConfig fail. val: %v", j.PluginJobConf()) } -//Split 切分 +// Split 切分 func (j *Job) Split(ctx context.Context, number int) (configs []*config.JSON, err error) { for _, v := range j.conf.Path { conf, _ := config.NewJSONFromString("{}") diff --git a/datax/plugin/writer/csv/writer.go b/datax/plugin/writer/csv/writer.go index a92d58b..3151761 100644 --- a/datax/plugin/writer/csv/writer.go +++ b/datax/plugin/writer/csv/writer.go @@ -20,24 +20,24 @@ import ( "github.com/Breeze0806/go-etl/datax/plugin/writer/file" ) -//Writer 写入器 +// Writer 写入器 type Writer struct { pluginConf *config.JSON } -//ResourcesConfig 插件资源配置 +// ResourcesConfig 插件资源配置 func (w *Writer) ResourcesConfig() *config.JSON { return w.pluginConf } -//Job 工作 +// Job 工作 func (w *Writer) Job() spiwriter.Job { job := NewJob() job.SetPluginConf(w.pluginConf) return job } -//Task 任务 +// Task 任务 func (w *Writer) Task() spiwriter.Task { task := file.NewTask(func(conf *config.JSON) (file.Config, error) { c, err := file.NewBaseConfig(conf) diff --git a/datax/plugin/writer/db2/job.go b/datax/plugin/writer/db2/job.go index 4dcadc8..25fe1dd 100644 --- a/datax/plugin/writer/db2/job.go +++ b/datax/plugin/writer/db2/job.go @@ -16,7 +16,7 @@ package db2 import "github.com/Breeze0806/go-etl/datax/plugin/writer/dbms" -//Job 工作 +// Job 工作 type Job struct { *dbms.Job } diff --git a/datax/plugin/writer/db2/task.go b/datax/plugin/writer/db2/task.go index c048471..115d860 100644 --- a/datax/plugin/writer/db2/task.go +++ b/datax/plugin/writer/db2/task.go @@ -36,12 +36,12 @@ func execMode(writeMode string) string { return dbms.ExecModeNormal } -//Task 任务 +// Task 任务 type Task struct { *dbms.Task } -//StartWrite 开始写 +// StartWrite 开始写 func (t *Task) StartWrite(ctx context.Context, receiver plugin.RecordReceiver) (err error) { return dbms.StartWrite(ctx, dbms.NewBaseBatchWriter(t.Task, execMode(t.Config.GetWriteMode()), nil), receiver) } diff --git a/datax/plugin/writer/db2/writer.go b/datax/plugin/writer/db2/writer.go index f24c41e..a92bc64 100644 --- a/datax/plugin/writer/db2/writer.go +++ b/datax/plugin/writer/db2/writer.go @@ -21,17 +21,17 @@ import ( "github.com/Breeze0806/go-etl/storage/database" ) -//Writer 写入器 +// Writer 写入器 type Writer struct { pluginConf *config.JSON } -//ResourcesConfig 插件资源配置 +// ResourcesConfig 插件资源配置 func (w *Writer) ResourcesConfig() *config.JSON { return w.pluginConf } -//Job 工作 +// Job 工作 func (w *Writer) Job() spiwriter.Job { job := &Job{ Job: dbms.NewJob(dbms.NewBaseDbHandler( @@ -46,7 +46,7 @@ func (w *Writer) Job() spiwriter.Job { return job } -//Task 任务 +// Task 任务 func (w *Writer) Task() spiwriter.Task { task := &Task{ Task: dbms.NewTask(dbms.NewBaseDbHandler( diff --git a/datax/plugin/writer/dbms/batch_writer.go b/datax/plugin/writer/dbms/batch_writer.go index 8ea389a..ca3feca 100644 --- a/datax/plugin/writer/dbms/batch_writer.go +++ b/datax/plugin/writer/dbms/batch_writer.go @@ -28,7 +28,7 @@ import ( "github.com/pingcap/errors" ) -//执行模式 +// 执行模式 const ( ExecModeNormal = "Normal" //无事务执行 ExecModeStmt = "Stmt" //prepare/exec无事务执行 @@ -36,7 +36,7 @@ const ( ExecModeStmtTx = "StmtTx" //prepare/exec事务执行 ) -//BatchWriter 批量写入器 +// BatchWriter 批量写入器 type BatchWriter interface { JobID() int64 //工作编号 TaskGroupID() int64 //任务组编号 @@ -46,7 +46,7 @@ type BatchWriter interface { BatchWrite(ctx context.Context, records []element.Record) error //批量写入 } -//BaseBatchWriter 批量写入器 +// BaseBatchWriter 批量写入器 type BaseBatchWriter struct { Task *Task execMode string @@ -55,7 +55,7 @@ type BaseBatchWriter struct { opts *database.ParameterOptions } -//NewBaseBatchWriter 获取任务task，执行模式execMode，事务选项opts创建批量写入器 +// NewBaseBatchWriter 获取任务task，执行模式execMode，事务选项opts创建批量写入器 func NewBaseBatchWriter(task *Task, execMode string, opts *sql.TxOptions) *BaseBatchWriter { w := &BaseBatchWriter{ Task: task, @@ -84,32 +84,32 @@ func NewBaseBatchWriter(task *Task, execMode string, opts *sql.TxOptions) *BaseB return w } -//JobID 工作编号 +// JobID 工作编号 func (b *BaseBatchWriter) JobID() int64 { return b.Task.JobID() } -//TaskGroupID 任务组编号 +// TaskGroupID 任务组编号 func (b *BaseBatchWriter) TaskGroupID() int64 { return b.Task.TaskGroupID() } -//TaskID 任务组任务编号 +// TaskID 任务组任务编号 func (b *BaseBatchWriter) TaskID() int64 { return b.Task.TaskID() } -//BatchSize 单批次插入数据 +// BatchSize 单批次插入数据 func (b *BaseBatchWriter) BatchSize() int { return b.Task.Config.GetBatchSize() } -//BatchTimeout 单批次插入超时时间 +// BatchTimeout 单批次插入超时时间 func (b *BaseBatchWriter) BatchTimeout() time.Duration { return b.Task.Config.GetBatchTimeout() } -//BatchWrite 批次写入 +// BatchWrite 批次写入 func (b *BaseBatchWriter) BatchWrite(ctx context.Context, records []element.Record) (err error) { if b.strategy != nil { retry := schedule.NewRetryTask(ctx, b.strategy, newWriteTask(func() error { @@ -164,7 +164,7 @@ func (t *writeTask) Do() error { return t.do() } -//StartWrite 通过批量写入器writer和记录接受器receiver将记录写入数据库 +// StartWrite 通过批量写入器writer和记录接受器receiver将记录写入数据库 func StartWrite(ctx context.Context, w BatchWriter, receiver plugin.RecordReceiver) (err error) { recordChan := make(chan element.Record) diff --git a/datax/plugin/writer/dbms/config.go b/datax/plugin/writer/dbms/config.go index b997288..ceb3479 100644 --- a/datax/plugin/writer/dbms/config.go +++ b/datax/plugin/writer/dbms/config.go @@ -34,7 +34,7 @@ var ( defalutBatchTimeout = 1 * time.Second ) -//Config 关系数据库写入器配置 +// Config 关系数据库写入器配置 type Config interface { GetUsername() string //获取用户名 GetPassword() string //获取密码 @@ -50,7 +50,7 @@ type Config interface { GetPostSQL() []string //获取结束的SQL语句 } -//BaseConfig 用于实现基本的关系数据库配置，如无特殊情况采用该配置，帮助快速实现writer +// BaseConfig 用于实现基本的关系数据库配置，如无特殊情况采用该配置，帮助快速实现writer type BaseConfig struct { Username string `json:"username"` //用户名 Password string `json:"password"` //密码 @@ -65,7 +65,7 @@ type BaseConfig struct { newRetryStrategy func(j schedule.RetryJudger) (schedule.RetryStrategy, error) } -//NewBaseConfig 从conf解析出关系数据库配置 +// NewBaseConfig 从conf解析出关系数据库配置 func NewBaseConfig(conf *config.JSON) (c *BaseConfig, err error) { c = &BaseConfig{} err = json.Unmarshal([]byte(conf.String()), c) @@ -93,22 +93,22 @@ func NewBaseConfig(conf *config.JSON) (c *BaseConfig, err error) { return } -//GetUsername 获取用户名 +// GetUsername 获取用户名 func (b *BaseConfig) GetUsername() string { return b.Username } -//GetPassword 获取密码 +// GetPassword 获取密码 func (b *BaseConfig) GetPassword() string { return b.Password } -//GetURL 获取连接url +// GetURL 获取连接url func (b *BaseConfig) GetURL() string { return b.Connection.URL } -//GetColumns 获取列信息 +// GetColumns 获取列信息 func (b *BaseConfig) GetColumns() (columns []dbmsreader.Column) { for _, v := range b.Column { columns = append(columns, &dbmsreader.BaseColumn{ @@ -118,18 +118,18 @@ func (b *BaseConfig) GetColumns() (columns []dbmsreader.Column) { return } -//GetBaseTable 获取表信息 +// GetBaseTable 获取表信息 func (b *BaseConfig) GetBaseTable() *database.BaseTable { return database.NewBaseTable(b.Connection.Table.Db, b.Connection.Table.Schema, b.Connection.Table.Name) } -//GetWriteMode 获取写入模式 +// GetWriteMode 获取写入模式 func (b *BaseConfig) GetWriteMode() string { return b.WriteMode } -//GetBatchTimeout 单次批量超时时间 +// GetBatchTimeout 单次批量超时时间 func (b *BaseConfig) GetBatchTimeout() time.Duration { if b.BatchTimeout.Duration == 0 { return defalutBatchTimeout @@ -137,7 +137,7 @@ func (b *BaseConfig) GetBatchTimeout() time.Duration { return b.BatchTimeout.Duration } -//GetBatchSize 单次批量写入数 +// GetBatchSize 单次批量写入数 func (b *BaseConfig) GetBatchSize() int { if b.BatchSize == 0 { return defalutBatchSize @@ -146,22 +146,22 @@ func (b *BaseConfig) GetBatchSize() int { return b.BatchSize } -//GetPreSQL 获取准备的SQL语句 +// GetPreSQL 获取准备的SQL语句 func (b *BaseConfig) GetPreSQL() []string { return getSQlsWithoutEmpty(b.PreSQL) } -//GetPostSQL 获取结束的SQL语句 +// GetPostSQL 获取结束的SQL语句 func (b *BaseConfig) GetPostSQL() []string { return getSQlsWithoutEmpty(b.PostSQL) } -//IgnoreOneByOneError 忽略一个个重试的错误 +// IgnoreOneByOneError 忽略一个个重试的错误 func (b *BaseConfig) IgnoreOneByOneError() bool { return b.ignoreOneByOneError } -//GetRetryStrategy 获取重试策略 +// GetRetryStrategy 获取重试策略 func (b *BaseConfig) GetRetryStrategy(j schedule.RetryJudger) (schedule.RetryStrategy, error) { return b.newRetryStrategy(j) diff --git a/datax/plugin/writer/dbms/db_handler.go b/datax/plugin/writer/dbms/db_handler.go index fb34d1e..ea80188 100644 --- a/datax/plugin/writer/dbms/db_handler.go +++ b/datax/plugin/writer/dbms/db_handler.go @@ -22,20 +22,20 @@ import ( "github.com/Breeze0806/go-etl/storage/database" ) -//DbHandler 数据库执行句柄封装 +// DbHandler 数据库执行句柄封装 type DbHandler interface { Execer(name string, conf *config.JSON) (Execer, error) //通过数据库名name和配置获取执行器 Config(conf *config.JSON) (Config, error) //通过配置获取关系型数据库配置 TableParam(config Config, execer Execer) database.Parameter //通过关系型数据库配置和执行器获取表参数 } -//BaseDbHandler 基础数据库执行句柄封装 +// BaseDbHandler 基础数据库执行句柄封装 type BaseDbHandler struct { newExecer func(name string, conf *config.JSON) (Execer, error) opts *sql.TxOptions } -//NewBaseDbHandler 通过获取执行器函数newExecer和数据库事务执行选项opts创建数据库执行句柄封装 +// NewBaseDbHandler 通过获取执行器函数newExecer和数据库事务执行选项opts创建数据库执行句柄封装 func NewBaseDbHandler(newExecer func(name string, conf *config.JSON) (Execer, error), opts *sql.TxOptions) *BaseDbHandler { return &BaseDbHandler{ newExecer: newExecer, @@ -43,17 +43,17 @@ func NewBaseDbHandler(newExecer func(name string, conf *config.JSON) (Execer, er } } -//Execer 通过数据库名name和配置获取执行器 +// Execer 通过数据库名name和配置获取执行器 func (d *BaseDbHandler) Execer(name string, conf *config.JSON) (Execer, error) { return d.newExecer(name, conf) } -//Config 通过配置获取关系型数据库配置 +// Config 通过配置获取关系型数据库配置 func (d *BaseDbHandler) Config(conf *config.JSON) (Config, error) { return NewBaseConfig(conf) } -//TableParam 通过关系型数据库配置和执行器获取表参数 +// TableParam 通过关系型数据库配置和执行器获取表参数 func (d *BaseDbHandler) TableParam(config Config, execer Execer) database.Parameter { return dbmsreader.NewTableParam(config, execer, d.opts) } diff --git a/datax/plugin/writer/dbms/execer.go b/datax/plugin/writer/dbms/execer.go index f5f05b1..d37e829 100644 --- a/datax/plugin/writer/dbms/execer.go +++ b/datax/plugin/writer/dbms/execer.go @@ -21,7 +21,7 @@ import ( "github.com/Breeze0806/go-etl/storage/database" ) -//Execer 执行器 +// Execer 执行器 type Execer interface { //通过基础表信息获取具体表 Table(*database.BaseTable) database.Table diff --git a/datax/plugin/writer/dbms/job.go b/datax/plugin/writer/dbms/job.go index 6670c2e..df29f04 100644 --- a/datax/plugin/writer/dbms/job.go +++ b/datax/plugin/writer/dbms/job.go @@ -24,7 +24,7 @@ import ( "github.com/pingcap/errors" ) -//Job 工作 +// Job 工作 type Job struct { *plugin.BaseJob @@ -33,7 +33,7 @@ type Job struct { conf Config //配置 } -//NewJob 通过数据库句柄获取工作 +// NewJob 通过数据库句柄获取工作 func NewJob(handler DbHandler) *Job { return &Job{ BaseJob: plugin.NewBaseJob(), @@ -41,7 +41,7 @@ func NewJob(handler DbHandler) *Job { } } -//Init 初始化 +// Init 初始化 func (j *Job) Init(ctx context.Context) (err error) { var name string if name, err = j.PluginConf().GetString("dialect"); err != nil { @@ -73,7 +73,7 @@ func (j *Job) Init(ctx context.Context) (err error) { return } -//Prepare 准备 +// Prepare 准备 func (j *Job) Prepare(ctx context.Context) (err error) { preSQL := j.conf.GetPreSQL() for _, v := range preSQL { @@ -89,7 +89,7 @@ func (j *Job) Prepare(ctx context.Context) (err error) { return } -//Post 后置 +// Post 后置 func (j *Job) Post(ctx context.Context) (err error) { postSQL := j.conf.GetPostSQL() for _, v := range postSQL { @@ -105,7 +105,7 @@ func (j *Job) Post(ctx context.Context) (err error) { return } -//Destroy 销毁 +// Destroy 销毁 func (j *Job) Destroy(ctx context.Context) (err error) { if j.Execer != nil { err = j.Execer.Close() @@ -113,7 +113,7 @@ func (j *Job) Destroy(ctx context.Context) (err error) { return errors.Wrapf(err, "Close fail") } -//Split 切分任务 +// Split 切分任务 func (j *Job) Split(ctx context.Context, number int) (confs []*config.JSON, err error) { for i := 0; i < number; i++ { confs = append(confs, j.PluginJobConf().CloneConfig()) diff --git a/datax/plugin/writer/dbms/task.go b/datax/plugin/writer/dbms/task.go index 03099a1..5d7738a 100644 --- a/datax/plugin/writer/dbms/task.go +++ b/datax/plugin/writer/dbms/task.go @@ -24,7 +24,7 @@ import ( "github.com/Breeze0806/go-etl/storage/database" ) -//Task 任务 +// Task 任务 type Task struct { *writer.BaseTask @@ -34,7 +34,7 @@ type Task struct { Table database.Table } -//NewTask 通过数据库句柄handler创建任务 +// NewTask 通过数据库句柄handler创建任务 func NewTask(handler DbHandler) *Task { return &Task{ BaseTask: writer.NewBaseTask(), @@ -42,7 +42,7 @@ func NewTask(handler DbHandler) *Task { } } -//Init 初始化 +// Init 初始化 func (t *Task) Init(ctx context.Context) (err error) { var name string if name, err = t.PluginConf().GetString("dialect"); err != nil { @@ -83,7 +83,7 @@ func (t *Task) Init(ctx context.Context) (err error) { return } -//Destroy 销毁 +// Destroy 销毁 func (t *Task) Destroy(ctx context.Context) (err error) { if t.Execer != nil { err = t.Execer.Close() diff --git a/datax/plugin/writer/file/config.go b/datax/plugin/writer/file/config.go index 75ae7b4..90d36d4 100644 --- a/datax/plugin/writer/file/config.go +++ b/datax/plugin/writer/file/config.go @@ -27,19 +27,19 @@ var ( defalutBatchTimeout = 1 * time.Second ) -//Config 文件流输出配置 +// Config 文件流输出配置 type Config interface { GetBatchSize() int //单次批量写入数 GetBatchTimeout() time.Duration //单次批量写入超时时间 } -//BaseConfig 基础文件流输出配置 +// BaseConfig 基础文件流输出配置 type BaseConfig struct { BatchSize int `json:"batchSize"` //单次批量写入数 BatchTimeout time2.Duration `json:"batchTimeout"` //单次批量写入超时时间 } -//NewBaseConfig 通过json配置获取基础文件流输出配置 +// NewBaseConfig 通过json配置获取基础文件流输出配置 func NewBaseConfig(conf *config.JSON) (*BaseConfig, error) { c := &BaseConfig{} if err := json.Unmarshal([]byte(conf.String()), c); err != nil { @@ -48,7 +48,7 @@ func NewBaseConfig(conf *config.JSON) (*BaseConfig, error) { return c, nil } -//GetBatchTimeout 单次批量写入超时时间 +// GetBatchTimeout 单次批量写入超时时间 func (b *BaseConfig) GetBatchTimeout() time.Duration { if b.BatchTimeout.Duration == 0 { return defalutBatchTimeout @@ -56,7 +56,7 @@ func (b *BaseConfig) GetBatchTimeout() time.Duration { return b.BatchTimeout.Duration } -//GetBatchSize 单次批量写入数 +// GetBatchSize 单次批量写入数 func (b *BaseConfig) GetBatchSize() int { if b.BatchSize == 0 { return defalutBatchSize diff --git a/datax/plugin/writer/file/job.go b/datax/plugin/writer/file/job.go index 4639a83..7b92080 100644 --- a/datax/plugin/writer/file/job.go +++ b/datax/plugin/writer/file/job.go @@ -20,19 +20,19 @@ import ( "github.com/Breeze0806/go-etl/datax/common/plugin" ) -//Job 工作 +// Job 工作 type Job struct { *plugin.BaseJob } -//NewJob 创建工作 +// NewJob 创建工作 func NewJob() *Job { return &Job{ plugin.NewBaseJob(), } } -//Destroy 销毁 +// Destroy 销毁 func (j *Job) Destroy(ctx context.Context) (err error) { return } diff --git a/datax/plugin/writer/file/task.go b/datax/plugin/writer/file/task.go index 671d984..7273111 100644 --- a/datax/plugin/writer/file/task.go +++ b/datax/plugin/writer/file/task.go @@ -27,7 +27,7 @@ import ( "github.com/Breeze0806/go-etl/storage/stream/file" ) -//Task 任务 +// Task 任务 type Task struct { *writer.BaseTask @@ -37,7 +37,7 @@ type Task struct { content *config.JSON } -//NewTask 通过获取配置newConfig创建任务 +// NewTask 通过获取配置newConfig创建任务 func NewTask(newConfig func(conf *config.JSON) (Config, error)) *Task { return &Task{ BaseTask: writer.NewBaseTask(), @@ -45,7 +45,7 @@ func NewTask(newConfig func(conf *config.JSON) (Config, error)) *Task { } } -//Init 初始化 +// Init 初始化 func (t *Task) Init(ctx context.Context) (err error) { var name string if name, err = t.PluginConf().GetString("creator"); err != nil { @@ -71,7 +71,7 @@ func (t *Task) Init(ctx context.Context) (err error) { return } -//Destroy 销毁 +// Destroy 销毁 func (t *Task) Destroy(ctx context.Context) (err error) { if t.streamer != nil { err = t.streamer.Close() @@ -79,7 +79,7 @@ func (t *Task) Destroy(ctx context.Context) (err error) { return t.Wrapf(err, "Close fail") } -//StartWrite 开始写 +// StartWrite 开始写 func (t *Task) StartWrite(ctx context.Context, receiver plugin.RecordReceiver) (err error) { var sw file.StreamWriter if sw, err = t.streamer.Writer(t.content); err != nil { diff --git a/datax/plugin/writer/file/task_test.go b/datax/plugin/writer/file/task_test.go index 85075c8..5f44246 100644 --- a/datax/plugin/writer/file/task_test.go +++ b/datax/plugin/writer/file/task_test.go @@ -346,7 +346,7 @@ func TestTask_Init(t *testing.T) { args: args{ ctx: context.TODO(), }, - conf: testJSONFromString(`{"creater":"mock"}`), + conf: testJSONFromString(`{"creator1":"mock"}`), jobConf: testJSONFromString(`{"path":"file1","content":{}}`), wantErr: true, }, diff --git a/datax/plugin/writer/mysql/job.go b/datax/plugin/writer/mysql/job.go index 844b6ce..1a490a1 100644 --- a/datax/plugin/writer/mysql/job.go +++ b/datax/plugin/writer/mysql/job.go @@ -18,7 +18,7 @@ import ( "github.com/Breeze0806/go-etl/datax/plugin/writer/dbms" ) -//Job 工作 +// Job 工作 type Job struct { *dbms.Job } diff --git a/datax/plugin/writer/mysql/task.go b/datax/plugin/writer/mysql/task.go index 1452fc1..c3a978f 100644 --- a/datax/plugin/writer/mysql/task.go +++ b/datax/plugin/writer/mysql/task.go @@ -37,7 +37,7 @@ func execMode(writeMode string) string { return dbms.ExecModeNormal } -//Task 任务 +// Task 任务 type Task struct { *dbms.Task } @@ -54,7 +54,7 @@ func (b *batchWriter) BatchSize() (size int) { return } -//StartWrite 开始写 +// StartWrite 开始写 func (t *Task) StartWrite(ctx context.Context, receiver plugin.RecordReceiver) (err error) { return dbms.StartWrite(ctx, &batchWriter{BaseBatchWriter: dbms.NewBaseBatchWriter(t.Task, execMode(t.Config.GetWriteMode()), nil)}, receiver) } diff --git a/datax/plugin/writer/mysql/writer.go b/datax/plugin/writer/mysql/writer.go index 72c441b..f4ea915 100644 --- a/datax/plugin/writer/mysql/writer.go +++ b/datax/plugin/writer/mysql/writer.go @@ -24,17 +24,17 @@ import ( _ "github.com/Breeze0806/go-etl/storage/database/mysql" ) -//Writer 写入器 +// Writer 写入器 type Writer struct { pluginConf *config.JSON } -//ResourcesConfig 插件资源配置 +// ResourcesConfig 插件资源配置 func (w *Writer) ResourcesConfig() *config.JSON { return w.pluginConf } -//Job 工作 +// Job 工作 func (w *Writer) Job() spiwriter.Job { job := &Job{ Job: dbms.NewJob(dbms.NewBaseDbHandler( @@ -49,7 +49,7 @@ func (w *Writer) Job() spiwriter.Job { return job } -//Task 任务 +// Task 任务 func (w *Writer) Task() spiwriter.Task { task := &Task{ Task: dbms.NewTask(dbms.NewBaseDbHandler( diff --git a/datax/plugin/writer/oracle/job.go b/datax/plugin/writer/oracle/job.go index 6ce1b40..01264c9 100644 --- a/datax/plugin/writer/oracle/job.go +++ b/datax/plugin/writer/oracle/job.go @@ -16,7 +16,7 @@ package oracle import "github.com/Breeze0806/go-etl/datax/plugin/writer/dbms" -//Job 工作 +// Job 工作 type Job struct { *dbms.Job } diff --git a/datax/plugin/writer/oracle/task.go b/datax/plugin/writer/oracle/task.go index 0a068d8..4219cfe 100644 --- a/datax/plugin/writer/oracle/task.go +++ b/datax/plugin/writer/oracle/task.go @@ -35,12 +35,12 @@ func execMode(writeMode string) string { return dbms.ExecModeNormal } -//Task 任务 +// Task 任务 type Task struct { *dbms.Task } -//StartWrite 开始写 +// StartWrite 开始写 func (t *Task) StartWrite(ctx context.Context, receiver plugin.RecordReceiver) (err error) { return dbms.StartWrite(ctx, dbms.NewBaseBatchWriter(t.Task, execMode(t.Config.GetWriteMode()), nil), receiver) } diff --git a/datax/plugin/writer/oracle/writer.go b/datax/plugin/writer/oracle/writer.go index c526886..129d0c6 100644 --- a/datax/plugin/writer/oracle/writer.go +++ b/datax/plugin/writer/oracle/writer.go @@ -21,17 +21,17 @@ import ( "github.com/Breeze0806/go-etl/storage/database" ) -//Writer 写入器 +// Writer 写入器 type Writer struct { pluginConf *config.JSON } -//ResourcesConfig 插件资源配置 +// ResourcesConfig 插件资源配置 func (w *Writer) ResourcesConfig() *config.JSON { return w.pluginConf } -//Job 工作 +// Job 工作 func (w *Writer) Job() spiwriter.Job { job := &Job{ Job: dbms.NewJob(dbms.NewBaseDbHandler( @@ -46,7 +46,7 @@ func (w *Writer) Job() spiwriter.Job { return job } -//Task 任务 +// Task 任务 func (w *Writer) Task() spiwriter.Task { task := &Task{ Task: dbms.NewTask(dbms.NewBaseDbHandler( diff --git a/datax/plugin/writer/postgres/job.go b/datax/plugin/writer/postgres/job.go index 7ef6db5..0df79fa 100644 --- a/datax/plugin/writer/postgres/job.go +++ b/datax/plugin/writer/postgres/job.go @@ -16,7 +16,7 @@ package postgres import "github.com/Breeze0806/go-etl/datax/plugin/writer/dbms" -//Job 工作 +// Job 工作 type Job struct { *dbms.Job } diff --git a/datax/plugin/writer/postgres/task.go b/datax/plugin/writer/postgres/task.go index dabd283..1fbf402 100644 --- a/datax/plugin/writer/postgres/task.go +++ b/datax/plugin/writer/postgres/task.go @@ -35,12 +35,12 @@ func execMode(writeMode string) string { return dbms.ExecModeNormal } -//Task 任务 +// Task 任务 type Task struct { *dbms.Task } -//StartWrite 开始写 +// StartWrite 开始写 func (t *Task) StartWrite(ctx context.Context, receiver plugin.RecordReceiver) (err error) { return dbms.StartWrite(ctx, dbms.NewBaseBatchWriter(t.Task, execMode(t.Config.GetWriteMode()), nil), receiver) } diff --git a/datax/plugin/writer/postgres/writer.go b/datax/plugin/writer/postgres/writer.go index e4798e1..d33be61 100644 --- a/datax/plugin/writer/postgres/writer.go +++ b/datax/plugin/writer/postgres/writer.go @@ -24,17 +24,17 @@ import ( _ "github.com/Breeze0806/go-etl/storage/database/postgres" ) -//Writer 写入器 +// Writer 写入器 type Writer struct { pluginConf *config.JSON } -//ResourcesConfig 插件资源配置 +// ResourcesConfig 插件资源配置 func (w *Writer) ResourcesConfig() *config.JSON { return w.pluginConf } -//Job 工作 +// Job 工作 func (w *Writer) Job() spiwriter.Job { job := &Job{ Job: dbms.NewJob(dbms.NewBaseDbHandler( @@ -49,7 +49,7 @@ func (w *Writer) Job() spiwriter.Job { return job } -//Task 任务 +// Task 任务 func (w *Writer) Task() spiwriter.Task { task := &Task{ Task: dbms.NewTask(dbms.NewBaseDbHandler( diff --git a/datax/plugin/writer/sqlserver/job.go b/datax/plugin/writer/sqlserver/job.go index d78b1fb..b993f7b 100644 --- a/datax/plugin/writer/sqlserver/job.go +++ b/datax/plugin/writer/sqlserver/job.go @@ -16,7 +16,7 @@ package sqlserver import "github.com/Breeze0806/go-etl/datax/plugin/writer/dbms" -//Job 工作 +// Job 工作 type Job struct { *dbms.Job } diff --git a/datax/plugin/writer/sqlserver/task.go b/datax/plugin/writer/sqlserver/task.go index ab3fbb4..b48d9e2 100644 --- a/datax/plugin/writer/sqlserver/task.go +++ b/datax/plugin/writer/sqlserver/task.go @@ -35,12 +35,12 @@ func execMode(writeMode string) string { return dbms.ExecModeNormal } -//Task 任务 +// Task 任务 type Task struct { *dbms.Task } -//StartWrite 开始写 +// StartWrite 开始写 func (t *Task) StartWrite(ctx context.Context, receiver plugin.RecordReceiver) (err error) { return dbms.StartWrite(ctx, dbms.NewBaseBatchWriter(t.Task, execMode(t.Config.GetWriteMode()), nil), receiver) } diff --git a/datax/plugin/writer/sqlserver/writer.go b/datax/plugin/writer/sqlserver/writer.go index c9b5bce..71cab0d 100644 --- a/datax/plugin/writer/sqlserver/writer.go +++ b/datax/plugin/writer/sqlserver/writer.go @@ -21,17 +21,17 @@ import ( "github.com/Breeze0806/go-etl/storage/database" ) -//Writer 写入器 +// Writer 写入器 type Writer struct { pluginConf *config.JSON } -//ResourcesConfig 插件资源配置 +// ResourcesConfig 插件资源配置 func (w *Writer) ResourcesConfig() *config.JSON { return w.pluginConf } -//Job 工作 +// Job 工作 func (w *Writer) Job() spiwriter.Job { job := &Job{ Job: dbms.NewJob(dbms.NewBaseDbHandler( @@ -46,7 +46,7 @@ func (w *Writer) Job() spiwriter.Job { return job } -//Task 任务 +// Task 任务 func (w *Writer) Task() spiwriter.Task { task := &Task{ Task: dbms.NewTask(dbms.NewBaseDbHandler( diff --git a/datax/plugin/writer/writer.go b/datax/plugin/writer/writer.go index c1943ab..a125019 100644 --- a/datax/plugin/writer/writer.go +++ b/datax/plugin/writer/writer.go @@ -21,7 +21,7 @@ import ( "github.com/pingcap/errors" ) -//Writer 写入器 +// Writer 写入器 type Writer interface { spi.Writer @@ -29,14 +29,14 @@ type Writer interface { ResourcesConfig() *config.JSON } -//Maker 写入生成器 +// Maker 写入生成器 type Maker interface { Default() (Writer, error) } -//RegisterWriter 注册创建函数new写入器,返回的是资源插件配置文件地州，出错时会返回error -//目前未在代码中实际使用，而是通过tools/datax/build的tools/datax/build命令自动将resources/plugin.json -//中的内容放入到新生成的代码文件中，用以注册Writer +// RegisterWriter 注册创建函数new写入器,返回的是资源插件配置文件地州，出错时会返回error +// 目前未在代码中实际使用，而是通过tools/datax/build的tools/datax/build命令自动将resources/plugin.json +// 中的内容放入到新生成的代码文件中，用以注册Writer func RegisterWriter(maker Maker) (err error) { var writer Writer diff --git a/datax/plugin/writer/xlsx/config.go b/datax/plugin/writer/xlsx/config.go index e7310a4..488877f 100644 --- a/datax/plugin/writer/xlsx/config.go +++ b/datax/plugin/writer/xlsx/config.go @@ -22,26 +22,26 @@ import ( "github.com/Breeze0806/go-etl/storage/stream/file/xlsx" ) -//SingleConfig xlsx单个输入设置 +// SingleConfig xlsx单个输入设置 type SingleConfig struct { file.BaseConfig xlsx.OutConfig } -//Config xlsx输出配置 +// Config xlsx输出配置 type Config struct { SingleConfig Xlsxs []Xlsx `json:"xlsxs"` } -//Xlsx xlsx内容配置 +// Xlsx xlsx内容配置 type Xlsx struct { Path string `json:"path"` Sheets []string `json:"sheets"` } -//NewConfig 通过json配置conf创建xlsx输出配置 +// NewConfig 通过json配置conf创建xlsx输出配置 func NewConfig(conf *config.JSON) (c *Config, err error) { c = &Config{} if err = json.Unmarshal([]byte(conf.String()), c); err != nil { diff --git a/datax/plugin/writer/xlsx/job.go b/datax/plugin/writer/xlsx/job.go index 56f8bed..0c3d7f6 100644 --- a/datax/plugin/writer/xlsx/job.go +++ b/datax/plugin/writer/xlsx/job.go @@ -22,26 +22,26 @@ import ( "github.com/pingcap/errors" ) -//Job 工作 +// Job 工作 type Job struct { *file.Job conf *Config } -//NewJob 创建工作 +// NewJob 创建工作 func NewJob() *Job { return &Job{ Job: file.NewJob(), } } -//Init 初始化 +// Init 初始化 func (j *Job) Init(ctx context.Context) (err error) { j.conf, err = NewConfig(j.PluginJobConf()) return errors.Wrapf(err, "NewConfig fail. val: %v", j.PluginJobConf()) } -//Split 切分 +// Split 切分 func (j *Job) Split(ctx context.Context, number int) (configs []*config.JSON, err error) { for _, v := range j.conf.Xlsxs { conf, _ := config.NewJSONFromString("{}") diff --git a/datax/plugin/writer/xlsx/writer.go b/datax/plugin/writer/xlsx/writer.go index dc32243..612ea77 100644 --- a/datax/plugin/writer/xlsx/writer.go +++ b/datax/plugin/writer/xlsx/writer.go @@ -20,24 +20,24 @@ import ( "github.com/Breeze0806/go-etl/datax/plugin/writer/file" ) -//Writer 写入器 +// Writer 写入器 type Writer struct { pluginConf *config.JSON } -//ResourcesConfig 插件资源配置 +// ResourcesConfig 插件资源配置 func (w *Writer) ResourcesConfig() *config.JSON { return w.pluginConf } -//Job 工作 +// Job 工作 func (w *Writer) Job() spiwriter.Job { job := NewJob() job.SetPluginConf(w.pluginConf) return job } -//Task 任务 +// Task 任务 func (w *Writer) Task() spiwriter.Task { task := file.NewTask(func(conf *config.JSON) (file.Config, error) { c, err := file.NewBaseConfig(conf) diff --git a/datax/transform/transformer.go b/datax/transform/transformer.go index 1575e52..70a4afe 100644 --- a/datax/transform/transformer.go +++ b/datax/transform/transformer.go @@ -16,15 +16,15 @@ package transform import "github.com/Breeze0806/go-etl/element" -//Transformer 转化器 +// Transformer 转化器 type Transformer interface { DoTransform(element.Record) (element.Record, error) } -//NilTransformer 空转化器 +// NilTransformer 空转化器 type NilTransformer struct{} -//DoTransform 转化 +// DoTransform 转化 func (n *NilTransformer) DoTransform(record element.Record) (element.Record, error) { return record, nil } diff --git a/element/big_int_column_value.go b/element/big_int_column_value.go index e6aaa43..0bbb512 100644 --- a/element/big_int_column_value.go +++ b/element/big_int_column_value.go @@ -20,43 +20,43 @@ import ( "time" ) -//NilBigIntColumnValue 空值整数列值 +// NilBigIntColumnValue 空值整数列值 type NilBigIntColumnValue struct { *nilColumnValue } -//NewNilBigIntColumnValue 创建空值整数列值 +// NewNilBigIntColumnValue 创建空值整数列值 func NewNilBigIntColumnValue() ColumnValue { return &NilBigIntColumnValue{ nilColumnValue: &nilColumnValue{}, } } -//Type 返回列类型 +// Type 返回列类型 func (n *NilBigIntColumnValue) Type() ColumnType { return TypeBigInt } -//Clone 克隆空值整数列值 +// Clone 克隆空值整数列值 func (n *NilBigIntColumnValue) Clone() ColumnValue { return NewNilBigIntColumnValue() } -//BigIntColumnValue 整数列值 +// BigIntColumnValue 整数列值 type BigIntColumnValue struct { notNilColumnValue val BigIntNumber } -//NewBigIntColumnValueFromInt64 从int64 v中获取整数列值 +// NewBigIntColumnValueFromInt64 从int64 v中获取整数列值 func NewBigIntColumnValueFromInt64(v int64) ColumnValue { return &BigIntColumnValue{ val: _DefaultNumberConverter.ConvertBigIntFromInt(v), } } -//NewBigIntColumnValue 从big.Int v中获取整数列值 +// NewBigIntColumnValue 从big.Int v中获取整数列值 func NewBigIntColumnValue(v *big.Int) ColumnValue { return &BigIntColumnValue{ val: &BigInt{ @@ -65,8 +65,8 @@ func NewBigIntColumnValue(v *big.Int) ColumnValue { } } -//NewBigIntColumnValueFromString 从string v中获取整数列值 -//当string v不是整数时,返回错误 +// NewBigIntColumnValueFromString 从string v中获取整数列值 +// 当string v不是整数时,返回错误 func NewBigIntColumnValueFromString(v string) (ColumnValue, error) { num, err := _DefaultNumberConverter.ConvertBigInt(v) if err != nil { @@ -77,37 +77,37 @@ func NewBigIntColumnValueFromString(v string) (ColumnValue, error) { }, nil } -//Type 返回列类型 +// Type 返回列类型 func (b *BigIntColumnValue) Type() ColumnType { return TypeBigInt } -//AsBool 转化成布尔值，不是0的转化为true,是0的转化成false +// AsBool 转化成布尔值，不是0的转化为true,是0的转化成false func (b *BigIntColumnValue) AsBool() (bool, error) { return b.val.Bool() } -//AsBigInt 转化成整数 +// AsBigInt 转化成整数 func (b *BigIntColumnValue) AsBigInt() (BigIntNumber, error) { return b.val, nil } -//AsDecimal 转化成高精度实数 +// AsDecimal 转化成高精度实数 func (b *BigIntColumnValue) AsDecimal() (DecimalNumber, error) { return b.val.Decimal(), nil } -//AsString 转化成字符串，如1234556790转化为1234556790 +// AsString 转化成字符串，如1234556790转化为1234556790 func (b *BigIntColumnValue) AsString() (string, error) { return b.val.String(), nil } -//AsBytes 转化成字节流，如1234556790转化为1234556790 +// AsBytes 转化成字节流，如1234556790转化为1234556790 func (b *BigIntColumnValue) AsBytes() ([]byte, error) { return []byte(b.val.String()), nil } -//AsTime 目前整数无法转化成时间 +// AsTime 目前整数无法转化成时间 func (b *BigIntColumnValue) AsTime() (time.Time, error) { return time.Time{}, NewTransformErrorFormColumnTypes(b.Type(), TypeTime, fmt.Errorf(" val: %v", b.String())) } @@ -116,14 +116,14 @@ func (b *BigIntColumnValue) String() string { return b.val.String() } -//Clone 克隆整数列属性 +// Clone 克隆整数列属性 func (b *BigIntColumnValue) Clone() ColumnValue { return &BigIntColumnValue{ val: b.val.CloneBigInt(), } } -//Cmp 返回1代表大于， 0代表相等， -1代表小于 +// Cmp 返回1代表大于， 0代表相等， -1代表小于 func (b *BigIntColumnValue) Cmp(right ColumnValue) (int, error) { rightValue, err := right.AsBigInt() if err != nil { diff --git a/element/bool_column_value.go b/element/bool_column_value.go index 1d94c90..367ab93 100644 --- a/element/bool_column_value.go +++ b/element/bool_column_value.go @@ -22,53 +22,53 @@ import ( "github.com/shopspring/decimal" ) -//NilBoolColumnValue 空值布尔列值 +// NilBoolColumnValue 空值布尔列值 type NilBoolColumnValue struct { *nilColumnValue } -//NewNilBoolColumnValue 生成空值布尔列值 +// NewNilBoolColumnValue 生成空值布尔列值 func NewNilBoolColumnValue() ColumnValue { return &NilBoolColumnValue{ nilColumnValue: &nilColumnValue{}, } } -//Type 返回列类型 +// Type 返回列类型 func (n *NilBoolColumnValue) Type() ColumnType { return TypeBool } -//Clone 克隆空值布尔列值 +// Clone 克隆空值布尔列值 func (n *NilBoolColumnValue) Clone() ColumnValue { return NewNilBoolColumnValue() } -//BoolColumnValue 布尔列值 +// BoolColumnValue 布尔列值 type BoolColumnValue struct { notNilColumnValue val bool //布尔值 } -//NewBoolColumnValue 从布尔值v生成布尔列值 +// NewBoolColumnValue 从布尔值v生成布尔列值 func NewBoolColumnValue(v bool) ColumnValue { return &BoolColumnValue{ val: v, } } -//Type 返回列类型 +// Type 返回列类型 func (b *BoolColumnValue) Type() ColumnType { return TypeBool } -//AsBool 转化成布尔值 +// AsBool 转化成布尔值 func (b *BoolColumnValue) AsBool() (bool, error) { return b.val, nil } -//AsBigInt 转化成整数，true转化为1，false转化为0 +// AsBigInt 转化成整数，true转化为1，false转化为0 func (b *BoolColumnValue) AsBigInt() (BigIntNumber, error) { if b.val { return NewBigIntColumnValue(big.NewInt(1)).AsBigInt() @@ -76,7 +76,7 @@ func (b *BoolColumnValue) AsBigInt() (BigIntNumber, error) { return NewBigIntColumnValue(big.NewInt(0)).AsBigInt() } -//AsDecimal 转化成高精度实数，true转化为1.0，false转化为0.0 +// AsDecimal 转化成高精度实数，true转化为1.0，false转化为0.0 func (b *BoolColumnValue) AsDecimal() (DecimalNumber, error) { if b.val { return NewDecimalColumnValue(decimal.New(1, 0)).AsDecimal() @@ -84,7 +84,7 @@ func (b *BoolColumnValue) AsDecimal() (DecimalNumber, error) { return NewDecimalColumnValue(decimal.New(0, 1)).AsDecimal() } -//AsString 转化成字符串，true转化为"true"，false转化为"false" +// AsString 转化成字符串，true转化为"true"，false转化为"false" func (b *BoolColumnValue) AsString() (string, error) { if b.val { return b.String(), nil @@ -92,7 +92,7 @@ func (b *BoolColumnValue) AsString() (string, error) { return b.String(), nil } -//AsBytes 转化成字节流，true转化为"true"，false转化为"false" +// AsBytes 转化成字节流，true转化为"true"，false转化为"false" func (b *BoolColumnValue) AsBytes() ([]byte, error) { if b.val { return []byte(b.String()), nil @@ -100,7 +100,7 @@ func (b *BoolColumnValue) AsBytes() ([]byte, error) { return []byte(b.String()), nil } -//AsTime 目前布尔无法转化成时间 +// AsTime 目前布尔无法转化成时间 func (b *BoolColumnValue) AsTime() (time.Time, error) { return time.Time{}, NewTransformErrorFormColumnTypes(b.Type(), TypeTime, fmt.Errorf(" val: %v", b.String())) } @@ -112,12 +112,12 @@ func (b *BoolColumnValue) String() string { return "false" } -//Clone 克隆布尔列值 +// Clone 克隆布尔列值 func (b *BoolColumnValue) Clone() ColumnValue { return NewBoolColumnValue(b.val) } -//Cmp 返回1代表大于， 0代表相等， -1代表小于 +// Cmp 返回1代表大于， 0代表相等， -1代表小于 func (b *BoolColumnValue) Cmp(right ColumnValue) (int, error) { rightValue, err := right.AsBool() if err != nil { diff --git a/element/bytes_column_value.go b/element/bytes_column_value.go index 13b4690..9d56041 100644 --- a/element/bytes_column_value.go +++ b/element/bytes_column_value.go @@ -20,29 +20,29 @@ import ( "time" ) -//NilBytesColumnValue 空值字节流列值 +// NilBytesColumnValue 空值字节流列值 type NilBytesColumnValue struct { *nilColumnValue } -//NewNilBytesColumnValue 创建空值字节流列值 +// NewNilBytesColumnValue 创建空值字节流列值 func NewNilBytesColumnValue() ColumnValue { return &NilBytesColumnValue{ nilColumnValue: &nilColumnValue{}, } } -//Type 返回列类型 +// Type 返回列类型 func (n *NilBytesColumnValue) Type() ColumnType { return TypeBytes } -//Clone 克隆空值字节流列值 +// Clone 克隆空值字节流列值 func (n *NilBytesColumnValue) Clone() ColumnValue { return NewNilBytesColumnValue() } -//BytesColumnValue 字节流列值 +// BytesColumnValue 字节流列值 type BytesColumnValue struct { notNilColumnValue TimeEncoder //时间编码器 @@ -50,26 +50,26 @@ type BytesColumnValue struct { val []byte //字节流值 } -//NewBytesColumnValue 从字节流v 生成字节流列值,做拷贝 +// NewBytesColumnValue 从字节流v 生成字节流列值,做拷贝 func NewBytesColumnValue(v []byte) ColumnValue { new := make([]byte, len(v)) copy(new, v) return NewBytesColumnValueNoCopy(new) } -//NewBytesColumnValueNoCopy 从字节流v 生成字节流列值,不做拷贝 +// NewBytesColumnValueNoCopy 从字节流v 生成字节流列值,不做拷贝 func NewBytesColumnValueNoCopy(v []byte) ColumnValue { return NewBytesColumnValueWithEncoderNoCopy(v, NewStringTimeEncoder(DefaultTimeFormat)) } -//NewBytesColumnValueWithEncoder 从字节流v 和时间编码器e 生成字节流列值,做拷贝 +// NewBytesColumnValueWithEncoder 从字节流v 和时间编码器e 生成字节流列值,做拷贝 func NewBytesColumnValueWithEncoder(v []byte, e TimeEncoder) ColumnValue { new := make([]byte, len(v)) copy(new, v) return NewBytesColumnValueWithEncoderNoCopy(new, NewStringTimeEncoder(DefaultTimeFormat)) } -//NewBytesColumnValueWithEncoderNoCopy 从字节流v 和时间编码器e,不做拷贝 +// NewBytesColumnValueWithEncoderNoCopy 从字节流v 和时间编码器e,不做拷贝 func NewBytesColumnValueWithEncoderNoCopy(v []byte, e TimeEncoder) ColumnValue { return &BytesColumnValue{ val: v, @@ -77,13 +77,13 @@ func NewBytesColumnValueWithEncoderNoCopy(v []byte, e TimeEncoder) ColumnValue { } } -//Type 返回列类型 +// Type 返回列类型 func (b *BytesColumnValue) Type() ColumnType { return TypeBytes } -//AsBool 1, t, T, TRUE, true, True转化为true -//0, f, F, FALSE, false, False转化为false，如果不是上述情况会报错 +// AsBool 1, t, T, TRUE, true, True转化为true +// 0, f, F, FALSE, false, False转化为false，如果不是上述情况会报错 func (b *BytesColumnValue) AsBool() (bool, error) { v, err := strconv.ParseBool(b.String()) if err != nil { @@ -92,8 +92,8 @@ func (b *BytesColumnValue) AsBool() (bool, error) { return v, nil } -//AsBigInt 转化为整数，实数型以及科学性计数法字符串会被取整，不是数值型的会报错 -//如123.67转化为123 123.12转化为123 +// AsBigInt 转化为整数，实数型以及科学性计数法字符串会被取整，不是数值型的会报错 +// 如123.67转化为123 123.12转化为123 func (b *BytesColumnValue) AsBigInt() (BigIntNumber, error) { v, err := NewDecimalColumnValueFromString(b.String()) if err != nil { @@ -102,7 +102,7 @@ func (b *BytesColumnValue) AsBigInt() (BigIntNumber, error) { return v.AsBigInt() } -//AsDecimal 转化为高精度师叔，实数型以及科学性计数法字符串能够转化，不是数值型的会报错 +// AsDecimal 转化为高精度师叔，实数型以及科学性计数法字符串能够转化，不是数值型的会报错 func (b *BytesColumnValue) AsDecimal() (DecimalNumber, error) { v, err := NewDecimalColumnValueFromString(b.String()) if err != nil { @@ -111,19 +111,19 @@ func (b *BytesColumnValue) AsDecimal() (DecimalNumber, error) { return v.AsDecimal() } -//AsString 转化为字符串 +// AsString 转化为字符串 func (b *BytesColumnValue) AsString() (string, error) { return b.String(), nil } -//AsBytes 转化成字节流 +// AsBytes 转化成字节流 func (b *BytesColumnValue) AsBytes() ([]byte, error) { v := make([]byte, len(b.val)) copy(v, b.val) return v, nil } -//AsTime 根据时间编码器转化成时间，不符合时间编码器格式会报错 +// AsTime 根据时间编码器转化成时间，不符合时间编码器格式会报错 func (b *BytesColumnValue) AsTime() (t time.Time, err error) { t, err = b.TimeEncode(b.String()) if err != nil { @@ -136,14 +136,14 @@ func (b *BytesColumnValue) String() string { return string(b.val) } -//Clone 克隆字节流列值 +// Clone 克隆字节流列值 func (b *BytesColumnValue) Clone() ColumnValue { v := make([]byte, len(b.val)) copy(v, b.val) return NewBytesColumnValue(v) } -//Cmp 返回1代表大于， 0代表相等， -1代表小于 +// Cmp 返回1代表大于， 0代表相等， -1代表小于 func (b *BytesColumnValue) Cmp(right ColumnValue) (int, error) { rightValue, err := right.AsBytes() if err != nil { diff --git a/element/column.go b/element/column.go index 30624ee..2e5fd2b 100644 --- a/element/column.go +++ b/element/column.go @@ -20,10 +20,10 @@ import ( "unsafe" ) -//ColumnType 列类型 +// ColumnType 列类型 type ColumnType string -//列类型枚举 +// 列类型枚举 const ( TypeUnknown ColumnType = "unknown" //未知类型 TypeBool ColumnType = "bool" //布尔类型 @@ -34,12 +34,12 @@ const ( TypeTime ColumnType = "time" //时间类型 ) -//String 打印显示 +// String 打印显示 func (c ColumnType) String() string { return string(c) } -//ColumnValue 列值 +// ColumnValue 列值 type ColumnValue interface { fmt.Stringer @@ -53,18 +53,18 @@ type ColumnValue interface { AsTime() (time.Time, error) // 转化为时间 } -//ColumnValueClonable 可克隆列值 +// ColumnValueClonable 可克隆列值 type ColumnValueClonable interface { Clone() ColumnValue //克隆 } -//ColumnValueComparabale 可比较列值 +// ColumnValueComparabale 可比较列值 type ColumnValueComparabale interface { //比较 1代表大于， 0代表相等， -1代表小于 Cmp(ColumnValue) (int, error) } -//Column 列 +// Column 列 type Column interface { ColumnValue AsInt64() (int64, error) //转化为64位整数 @@ -78,59 +78,59 @@ type Column interface { type notNilColumnValue struct{} -//IsNil 是否为空 +// IsNil 是否为空 func (n *notNilColumnValue) IsNil() bool { return false } type nilColumnValue struct{} -//Type 列类型 +// Type 列类型 func (n *nilColumnValue) Type() ColumnType { return TypeUnknown } -//IsNil 是否为空 +// IsNil 是否为空 func (n *nilColumnValue) IsNil() bool { return true } -//AsBool 无法转化布尔值 +// AsBool 无法转化布尔值 func (n *nilColumnValue) AsBool() (bool, error) { return false, ErrNilValue } -//AsBigInt 无法转化整数 +// AsBigInt 无法转化整数 func (n *nilColumnValue) AsBigInt() (BigIntNumber, error) { return nil, ErrNilValue } -//AsDecimal 无法转化高精度实数 +// AsDecimal 无法转化高精度实数 func (n *nilColumnValue) AsDecimal() (DecimalNumber, error) { return nil, ErrNilValue } -//AsString 无法转化字符串 +// AsString 无法转化字符串 func (n *nilColumnValue) AsString() (string, error) { return "", ErrNilValue } -//AsBytes 无法转化字节流 +// AsBytes 无法转化字节流 func (n *nilColumnValue) AsBytes() ([]byte, error) { return nil, ErrNilValue } -//AsTime 无法转化时间 +// AsTime 无法转化时间 func (n *nilColumnValue) AsTime() (time.Time, error) { return time.Time{}, ErrNilValue } -//String 打印显示 +// String 打印显示 func (n *nilColumnValue) String() string { return "" } -//DefaultColumn 默认值 +// DefaultColumn 默认值 type DefaultColumn struct { ColumnValue // 列值 @@ -138,7 +138,7 @@ type DefaultColumn struct { byteSize int } -//NewDefaultColumn 根据列值v,列名name,字节流大小byteSize，生成默认列 +// NewDefaultColumn 根据列值v,列名name,字节流大小byteSize，生成默认列 func NewDefaultColumn(v ColumnValue, name string, byteSize int) Column { return &DefaultColumn{ ColumnValue: v, @@ -147,12 +147,12 @@ func NewDefaultColumn(v ColumnValue, name string, byteSize int) Column { } } -//Name 列名 +// Name 列名 func (d *DefaultColumn) Name() string { return d.name } -//Cmp 比较列，如果不是可比较列值，就会报错 +// Cmp 比较列，如果不是可比较列值，就会报错 func (d *DefaultColumn) Cmp(c Column) (int, error) { if d.Name() != c.Name() { return 0, ErrColumnNameNotEqual @@ -164,7 +164,7 @@ func (d *DefaultColumn) Cmp(c Column) (int, error) { return comparabale.Cmp(c) } -//Clone 克隆列，如果不是可克隆列值，就会报错 +// Clone 克隆列，如果不是可克隆列值，就会报错 func (d *DefaultColumn) Clone() (Column, error) { colnable, ok := d.ColumnValue.(ColumnValueClonable) if !ok { @@ -178,17 +178,17 @@ func (d *DefaultColumn) Clone() (Column, error) { }, nil } -//ByteSize 字节流大小 +// ByteSize 字节流大小 func (d *DefaultColumn) ByteSize() int64 { return int64(d.byteSize) } -//MemorySize 内存大小 +// MemorySize 内存大小 func (d *DefaultColumn) MemorySize() int64 { return int64(d.byteSize + len(d.name) + 4) } -//AsInt64 转化为64位整数 +// AsInt64 转化为64位整数 func (d *DefaultColumn) AsInt64() (int64, error) { bi, err := d.AsBigInt() if err != nil { @@ -197,7 +197,7 @@ func (d *DefaultColumn) AsInt64() (int64, error) { return bi.Int64() } -//AsFloat64 转化为64位实数 +// AsFloat64 转化为64位实数 func (d *DefaultColumn) AsFloat64() (float64, error) { dec, err := d.AsDecimal() if err != nil { @@ -206,7 +206,7 @@ func (d *DefaultColumn) AsFloat64() (float64, error) { return dec.Float64() } -//ByteSize 字节大小 +// ByteSize 字节大小 func ByteSize(src interface{}) int { switch data := src.(type) { case nil: diff --git a/element/decimal_column_value.go b/element/decimal_column_value.go index 49ca857..39a676e 100644 --- a/element/decimal_column_value.go +++ b/element/decimal_column_value.go @@ -21,43 +21,43 @@ import ( "github.com/shopspring/decimal" ) -//NilDecimalColumnValue 空值高精度实数型列值 +// NilDecimalColumnValue 空值高精度实数型列值 type NilDecimalColumnValue struct { *nilColumnValue } -//NewNilDecimalColumnValue 生成空值高精度实数型列值 +// NewNilDecimalColumnValue 生成空值高精度实数型列值 func NewNilDecimalColumnValue() ColumnValue { return &NilDecimalColumnValue{ nilColumnValue: &nilColumnValue{}, } } -//Type 列类型 +// Type 列类型 func (n *NilDecimalColumnValue) Type() ColumnType { return TypeDecimal } -//Clone 克隆 +// Clone 克隆 func (n *NilDecimalColumnValue) Clone() ColumnValue { return NewNilDecimalColumnValue() } -//DecimalColumnValue 高精度实数列值 +// DecimalColumnValue 高精度实数列值 type DecimalColumnValue struct { notNilColumnValue val DecimalNumber //高精度实数 } -//NewDecimalColumnValueFromFloat 根据float64 f生成高精度实数列值 +// NewDecimalColumnValueFromFloat 根据float64 f生成高精度实数列值 func NewDecimalColumnValueFromFloat(f float64) ColumnValue { return &DecimalColumnValue{ val: _DefaultNumberConverter.ConvertDecimalFromFloat(f), } } -//NewDecimalColumnValue 根据高精度实数 d生成高精度实数列值 +// NewDecimalColumnValue 根据高精度实数 d生成高精度实数列值 func NewDecimalColumnValue(d decimal.Decimal) ColumnValue { return &DecimalColumnValue{ val: &Decimal{ @@ -66,8 +66,8 @@ func NewDecimalColumnValue(d decimal.Decimal) ColumnValue { } } -//NewDecimalColumnValueFromString 根据字符串s生成高精度实数列值 -//不是数值型或者科学计数法的字符串，就会报错 +// NewDecimalColumnValueFromString 根据字符串s生成高精度实数列值 +// 不是数值型或者科学计数法的字符串，就会报错 func NewDecimalColumnValueFromString(s string) (ColumnValue, error) { num, err := _DefaultNumberConverter.ConvertDecimal(s) if err != nil { @@ -78,37 +78,37 @@ func NewDecimalColumnValueFromString(s string) (ColumnValue, error) { }, nil } -//Type 列类型 +// Type 列类型 func (d *DecimalColumnValue) Type() ColumnType { return TypeDecimal } -//AsBool 非0转化为true, 0转化为false +// AsBool 非0转化为true, 0转化为false func (d *DecimalColumnValue) AsBool() (bool, error) { return d.val.Bool() } -//AsBigInt 对高精度实数取整，如123.67转化为123 123.12转化为123 +// AsBigInt 对高精度实数取整，如123.67转化为123 123.12转化为123 func (d *DecimalColumnValue) AsBigInt() (BigIntNumber, error) { return d.val.BigInt(), nil } -//AsDecimal 转化为高精度实数 +// AsDecimal 转化为高精度实数 func (d *DecimalColumnValue) AsDecimal() (DecimalNumber, error) { return d.val, nil } -//AsString 转化为字符串， 如10.123 转化为10.123 +// AsString 转化为字符串， 如10.123 转化为10.123 func (d *DecimalColumnValue) AsString() (string, error) { return d.val.String(), nil } -//AsBytes 转化为字节流， 如10.123 转化为10.123 +// AsBytes 转化为字节流， 如10.123 转化为10.123 func (d *DecimalColumnValue) AsBytes() ([]byte, error) { return []byte(d.val.String()), nil } -//AsTime 目前无法转化为时间 +// AsTime 目前无法转化为时间 func (d *DecimalColumnValue) AsTime() (time.Time, error) { return time.Time{}, NewTransformErrorFormColumnTypes(d.Type(), TypeTime, fmt.Errorf(" val: %v", d.String())) } @@ -117,14 +117,14 @@ func (d *DecimalColumnValue) String() string { return d.val.String() } -//Clone 克隆高精度实数列值 +// Clone 克隆高精度实数列值 func (d *DecimalColumnValue) Clone() ColumnValue { return &DecimalColumnValue{ val: d.val, } } -//Cmp 返回1代表大于， 0代表相等， -1代表小于 +// Cmp 返回1代表大于， 0代表相等， -1代表小于 func (d *DecimalColumnValue) Cmp(right ColumnValue) (int, error) { rightValue, err := right.AsDecimal() if err != nil { diff --git a/element/doc.go b/element/doc.go index 014d434..b146980 100644 --- a/element/doc.go +++ b/element/doc.go @@ -12,5 +12,5 @@ // See the License for the specific language governing permissions and // limitations under the License. -//Package element 提供各个类型的列值，列，记录以及记录通道 +// Package element 提供各个类型的列值，列，记录以及记录通道 package element diff --git a/element/error.go b/element/error.go index ad3533d..74e3635 100644 --- a/element/error.go +++ b/element/error.go @@ -19,7 +19,7 @@ import ( "fmt" ) -//错误 +// 错误 var ( ErrColumnExist = errors.New("column exist") //列存在错误 ErrColumnNotExist = errors.New("column does not exist") //列不存在错误 @@ -32,13 +32,13 @@ var ( ErrColumnNameNotEqual = errors.New("column name is not equal") //列名不同 ) -//TransformError 转化错误 +// TransformError 转化错误 type TransformError struct { err error msg string } -//NewTransformError 根据消息msg和错误err生成转化错误 +// NewTransformError 根据消息msg和错误err生成转化错误 func NewTransformError(msg string, err error) *TransformError { for uerr := err; uerr != nil; uerr = errors.Unwrap(err) { err = uerr @@ -49,12 +49,12 @@ func NewTransformError(msg string, err error) *TransformError { } } -//NewTransformErrorFormColumnTypes 从one类型到other类型转化错误err生成转化错误 +// NewTransformErrorFormColumnTypes 从one类型到other类型转化错误err生成转化错误 func NewTransformErrorFormColumnTypes(one, other ColumnType, err error) *TransformError { return NewTransformError(fmt.Sprintf("%s transform to %s", one, other), err) } -//NewTransformErrorFormString 从one到other转化错误err生成转化错误 +// NewTransformErrorFormString 从one到other转化错误err生成转化错误 func NewTransformErrorFormString(one, other string, err error) *TransformError { return NewTransformError(fmt.Sprintf("%s transform to %s", one, other), err) } @@ -70,13 +70,13 @@ func (e *TransformError) Unwrap() error { return e.err } -//SetError 设置错误 +// SetError 设置错误 type SetError struct { err error msg string } -//NewSetError 通过值i设置成累心other类型的错误err生成设置错误 +// NewSetError 通过值i设置成累心other类型的错误err生成设置错误 func NewSetError(i interface{}, other ColumnType, err error) *SetError { for uerr := err; uerr != nil; uerr = errors.Unwrap(err) { err = uerr diff --git a/element/number.go b/element/number.go index 1a04a6b..fd0dd10 100644 --- a/element/number.go +++ b/element/number.go @@ -30,13 +30,13 @@ var _IntTen = big.NewInt(10) var _StrZero = "0" var _DefaultNumberConverter NumberConverter = &Converter{} -//Number 数字 +// Number 数字 type Number interface { Bool() (bool, error) String() string } -//NumberConverter 数字转化器 +// NumberConverter 数字转化器 type NumberConverter interface { ConvertBigIntFromInt(i int64) (num BigIntNumber) ConvertDecimalFromFloat(f float64) (num DecimalNumber) @@ -44,7 +44,7 @@ type NumberConverter interface { ConvertDecimal(s string) (num DecimalNumber, err error) } -//BigIntNumber 高精度整数 +// BigIntNumber 高精度整数 type BigIntNumber interface { Number @@ -54,7 +54,7 @@ type BigIntNumber interface { AsBigInt() *big.Int } -//DecimalNumber 高精度实数 +// DecimalNumber 高精度实数 type DecimalNumber interface { Number @@ -64,76 +64,76 @@ type DecimalNumber interface { AsDecimal() decimal.Decimal } -//Int64 64位整数 +// Int64 64位整数 type Int64 struct { value int64 } -//Bool 转化为布尔值 +// Bool 转化为布尔值 func (i *Int64) Bool() (bool, error) { return i.value != 0, nil } -//Int64 转化为64位整数 +// Int64 转化为64位整数 func (i *Int64) Int64() (int64, error) { return i.value, nil } -//Float64 转化为64位实数 +// Float64 转化为64位实数 func (i *Int64) Float64() (float64, error) { return float64(i.value), nil } -//BigInt 转化为高精度整数 +// BigInt 转化为高精度整数 func (i *Int64) BigInt() BigIntNumber { return i } -//Decimal 转化为高精度实数 +// Decimal 转化为高精度实数 func (i *Int64) Decimal() DecimalNumber { return i } -//Decimal 转化为字符串 +// Decimal 转化为字符串 func (i *Int64) String() string { return strconv.FormatInt(i.value, 10) } -//CloneBigInt 克隆高精度整数 +// CloneBigInt 克隆高精度整数 func (i *Int64) CloneBigInt() BigIntNumber { return &Int64{ value: i.value, } } -//CloneDecimal 克隆高精度实数 +// CloneDecimal 克隆高精度实数 func (i *Int64) CloneDecimal() DecimalNumber { return &Int64{ value: i.value, } } -//AsBigInt 转化为高精度整数 +// AsBigInt 转化为高精度整数 func (i *Int64) AsBigInt() *big.Int { return big.NewInt(i.value) } -//AsDecimal 转化为高精度精度 +// AsDecimal 转化为高精度精度 func (i *Int64) AsDecimal() decimal.Decimal { return decimal.NewFromInt(i.value) } -//BigInt 大整数 +// BigInt 大整数 type BigInt struct { value *big.Int } -//Bool 转化为布尔值 +// Bool 转化为布尔值 func (b *BigInt) Bool() (bool, error) { return b.value.Cmp(_IntZero) != 0, nil } -//Int64 转化为64位整数 +// Int64 转化为64位整数 func (b *BigInt) Int64() (int64, error) { if b.value.IsInt64() { return b.value.Int64(), nil @@ -141,7 +141,7 @@ func (b *BigInt) Int64() (int64, error) { return 0, errors.New("element: BigInt to int64 fail for out of range") } -//Float64 转化为64位实数 +// Float64 转化为64位实数 func (b *BigInt) Float64() (v float64, err error) { f := new(big.Float).SetInt(b.value) if v, _ = f.Float64(); math.Abs(v) > math.MaxFloat64 { @@ -152,61 +152,61 @@ func (b *BigInt) Float64() (v float64, err error) { return } -//BigInt 转化为高精度整数 +// BigInt 转化为高精度整数 func (b *BigInt) BigInt() BigIntNumber { return b } -//Decimal 转化为高精度实数 +// Decimal 转化为高精度实数 func (b *BigInt) Decimal() DecimalNumber { return b } -//Decimal 转化为字符串 +// Decimal 转化为字符串 func (b *BigInt) String() string { return b.value.String() } -//CloneBigInt 克隆高精度整数 +// CloneBigInt 克隆高精度整数 func (b *BigInt) CloneBigInt() BigIntNumber { return &BigInt{ value: new(big.Int).Set(b.value), } } -//CloneDecimal 克隆高精度实数 +// CloneDecimal 克隆高精度实数 func (b *BigInt) CloneDecimal() DecimalNumber { return &BigInt{ value: new(big.Int).Set(b.value), } } -//AsBigInt 转化为高精度整数 +// AsBigInt 转化为高精度整数 func (b *BigInt) AsBigInt() *big.Int { return b.value } -//AsDecimal 转化为高精度精度 +// AsDecimal 转化为高精度精度 func (b *BigInt) AsDecimal() decimal.Decimal { return decimal.NewFromBigInt(b.value, 0) } -//BigIntStr 高精度整数 +// BigIntStr 高精度整数 type BigIntStr struct { value string } -//Bool 转化为布尔值 +// Bool 转化为布尔值 func (b *BigIntStr) Bool() (bool, error) { return false, errors.New("element: BigIntStr to Bool fail for out of range") } -//Int64 转化为64位整数 +// Int64 转化为64位整数 func (b *BigIntStr) Int64() (int64, error) { return 0, errors.New("element: BigIntStr to int64 fail for out of range") } -//Float64 转化为64位实数 +// Float64 转化为64位实数 func (b *BigIntStr) Float64() (v float64, err error) { f, _ := new(big.Float).SetString(b.value) if v, _ = f.Float64(); math.Abs(v) > math.MaxFloat64 { @@ -217,63 +217,63 @@ func (b *BigIntStr) Float64() (v float64, err error) { return } -//BigInt 转化为高精度整数 +// BigInt 转化为高精度整数 func (b *BigIntStr) BigInt() BigIntNumber { return b } -//Decimal 转化为高精度实数 +// Decimal 转化为高精度实数 func (b *BigIntStr) Decimal() DecimalNumber { return b } -//Decimal 转化为字符串 +// Decimal 转化为字符串 func (b *BigIntStr) String() string { return b.value } -//CloneBigInt 克隆高精度整数 +// CloneBigInt 克隆高精度整数 func (b *BigIntStr) CloneBigInt() BigIntNumber { return &BigIntStr{ value: b.value, } } -//CloneDecimal 克隆高精度实数 +// CloneDecimal 克隆高精度实数 func (b *BigIntStr) CloneDecimal() DecimalNumber { return &BigIntStr{ value: b.value, } } -//AsBigInt 转化为高精度整数 +// AsBigInt 转化为高精度整数 func (b *BigIntStr) AsBigInt() *big.Int { v, _ := new(big.Int).SetString(b.value, 10) return v } -//AsDecimal 转化为高精度精度 +// AsDecimal 转化为高精度精度 func (b *BigIntStr) AsDecimal() decimal.Decimal { v, _ := new(big.Int).SetString(b.value, 10) return decimal.NewFromBigInt(v, 0) } -//Float64 64位实数 +// Float64 64位实数 type Float64 struct { value float64 } -//Bool 转化为布尔 +// Bool 转化为布尔 func (f *Float64) Bool() (bool, error) { return f.value != 0.0, nil } -//Float64 转化为64位实数 +// Float64 转化为64位实数 func (f *Float64) Float64() (float64, error) { return f.value, nil } -//BigInt 转化为高精度整数 +// BigInt 转化为高精度整数 func (f *Float64) BigInt() BigIntNumber { s := f.String() pIndex := strings.Index(s, ".") @@ -283,40 +283,40 @@ func (f *Float64) BigInt() BigIntNumber { return convertBigInt(s[:pIndex]).(BigIntNumber) } -//Decimal 转化为高精度实数 +// Decimal 转化为高精度实数 func (f *Float64) Decimal() DecimalNumber { return f } -//Decimal 转化为字符串 +// Decimal 转化为字符串 func (f *Float64) String() string { return strconv.FormatFloat(f.value, 'f', -1, 64) } -//CloneDecimal 克隆高精度实数 +// CloneDecimal 克隆高精度实数 func (f *Float64) CloneDecimal() DecimalNumber { return &Float64{ value: f.value, } } -//AsDecimal 转化为高精度精度 +// AsDecimal 转化为高精度精度 func (f *Float64) AsDecimal() decimal.Decimal { return decimal.NewFromFloat(f.value) } -//DecimalStr 高精度实数 +// DecimalStr 高精度实数 type DecimalStr struct { value string intLen int } -//Bool 转化为布尔 +// Bool 转化为布尔 func (d *DecimalStr) Bool() (bool, error) { return d.value != _StrZero, nil } -//Float64 转化为64位实数 +// Float64 转化为64位实数 func (d *DecimalStr) Float64() (v float64, err error) { f, _ := new(big.Float).SetString(d.value) if v, _ = f.Float64(); math.Abs(v) > math.MaxFloat64 { @@ -327,23 +327,23 @@ func (d *DecimalStr) Float64() (v float64, err error) { return } -//BigInt 转化为高精度整数 +// BigInt 转化为高精度整数 func (d *DecimalStr) BigInt() BigIntNumber { return convertBigInt(d.value[:d.intLen]).(BigIntNumber) } -//Decimal 转化为高精度实数 +// Decimal 转化为高精度实数 func (d *DecimalStr) Decimal() DecimalNumber { return d } -//Decimal 转化为字符串 +// Decimal 转化为字符串 func (d *DecimalStr) String() string { return d.value } -//CloneDecimal 克隆高精度实数 +// CloneDecimal 克隆高精度实数 func (d *DecimalStr) CloneDecimal() DecimalNumber { return &DecimalStr{ value: d.value, @@ -351,7 +351,7 @@ func (d *DecimalStr) CloneDecimal() DecimalNumber { } } -//AsDecimal 转化为高精度精度 +// AsDecimal 转化为高精度精度 func (d *DecimalStr) AsDecimal() decimal.Decimal { intString := d.value if d.intLen+1 < len(d.value) { @@ -361,17 +361,17 @@ func (d *DecimalStr) AsDecimal() decimal.Decimal { return decimal.NewFromBigInt(v, int32(-len(d.value)+d.intLen+1)) } -//Decimal 高精度实数 +// Decimal 高精度实数 type Decimal struct { value decimal.Decimal } -//Bool 转化为布尔 +// Bool 转化为布尔 func (d *Decimal) Bool() (bool, error) { return d.value.Cmp(decimal.Zero) != 0, nil } -//Float64 转化为64位实数 +// Float64 转化为64位实数 func (d *Decimal) Float64() (float64, error) { v, _ := d.value.Float64() if math.Abs(v) > math.MaxFloat64 { @@ -380,7 +380,7 @@ func (d *Decimal) Float64() (float64, error) { return v, nil } -//BigInt 转化为高精度整数 +// BigInt 转化为高精度整数 func (d *Decimal) BigInt() BigIntNumber { exp := d.value.Exponent() value := d.value.Coefficient() @@ -398,46 +398,46 @@ func (d *Decimal) BigInt() BigIntNumber { } } -//Decimal 转化为高精度实数 +// Decimal 转化为高精度实数 func (d *Decimal) Decimal() DecimalNumber { return d } -//Decimal 转化为字符串 +// Decimal 转化为字符串 func (d *Decimal) String() string { return d.value.String() } -//CloneDecimal 克隆高精度实数 +// CloneDecimal 克隆高精度实数 func (d *Decimal) CloneDecimal() DecimalNumber { return &Decimal{ value: d.value.Copy(), } } -//AsDecimal 转化为高精度精度 +// AsDecimal 转化为高精度精度 func (d *Decimal) AsDecimal() decimal.Decimal { return d.value } -//OldConverter 无检查转化 +// OldConverter 无检查转化 type OldConverter struct{} -//ConvertBigIntFromInt 转化成实数 +// ConvertBigIntFromInt 转化成实数 func (c *OldConverter) ConvertBigIntFromInt(i int64) (num BigIntNumber) { return &BigInt{ value: big.NewInt(i), } } -//ConvertDecimalFromFloat 转化成实数 +// ConvertDecimalFromFloat 转化成实数 func (c *OldConverter) ConvertDecimalFromFloat(f float64) (num DecimalNumber) { return &Decimal{ value: decimal.NewFromFloat(f), } } -//ConvertDecimal 把字符串转化成实数 +// ConvertDecimal 把字符串转化成实数 func (c *OldConverter) ConvertDecimal(s string) (num DecimalNumber, err error) { var d decimal.Decimal if d, err = decimal.NewFromString(s); err != nil { @@ -449,7 +449,7 @@ func (c *OldConverter) ConvertDecimal(s string) (num DecimalNumber, err error) { return } -//ConvertBigInt 把字符串转化成整数 +// ConvertBigInt 把字符串转化成整数 func (c *OldConverter) ConvertBigInt(s string) (num BigIntNumber, err error) { b, ok := new(big.Int).SetString(s, 10) if !ok { @@ -462,24 +462,24 @@ func (c *OldConverter) ConvertBigInt(s string) (num BigIntNumber, err error) { return } -//Converter 数字转化器 +// Converter 数字转化器 type Converter struct{} -//ConvertBigIntFromInt 转化成实数 +// ConvertBigIntFromInt 转化成实数 func (c *Converter) ConvertBigIntFromInt(i int64) (num BigIntNumber) { return &Int64{ value: i, } } -//ConvertDecimalFromFloat 转化成实数 +// ConvertDecimalFromFloat 转化成实数 func (c *Converter) ConvertDecimalFromFloat(f float64) (num DecimalNumber) { return &Float64{ value: f, } } -//ConvertDecimal 把字符串转化成实数 +// ConvertDecimal 把字符串转化成实数 func (c *Converter) ConvertDecimal(s string) (num DecimalNumber, err error) { eIndex := strings.IndexAny(s, "Ee") if eIndex == -1 { @@ -525,7 +525,7 @@ func (c *Converter) ConvertDecimal(s string) (num DecimalNumber, err error) { }, nil } -//ConvertBigInt 把字符串转化成整数 +// ConvertBigInt 把字符串转化成整数 func (c *Converter) ConvertBigInt(s string) (num BigIntNumber, err error) { if len(s) == 0 { err = errors.New("element: convertDecimal empty string") diff --git a/element/record.go b/element/record.go index 1ec31c5..2290a4d 100644 --- a/element/record.go +++ b/element/record.go @@ -19,7 +19,7 @@ import ( "strings" ) -//Record 记录 +// Record 记录 type Record interface { fmt.Stringer @@ -35,60 +35,60 @@ type Record interface { var singleTerminateRecord = &TerminateRecord{} -//GetTerminateRecord 获取终止记录 +// GetTerminateRecord 获取终止记录 func GetTerminateRecord() Record { return singleTerminateRecord } -//TerminateRecord 终止记录 +// TerminateRecord 终止记录 type TerminateRecord struct{} -//Add 空方法 +// Add 空方法 func (t *TerminateRecord) Add(Column) error { return nil } -//GetByIndex 空方法 +// GetByIndex 空方法 func (t *TerminateRecord) GetByIndex(i int) (Column, error) { return nil, nil } -//GetByName 空方法 +// GetByName 空方法 func (t *TerminateRecord) GetByName(name string) (Column, error) { return nil, nil } -//Set 空方法 +// Set 空方法 func (t *TerminateRecord) Set(i int, c Column) error { return nil } -//Put 空方法 +// Put 空方法 func (t *TerminateRecord) Put(c Column) error { return nil } -//ColumnNumber 空方法 +// ColumnNumber 空方法 func (t *TerminateRecord) ColumnNumber() int { return 0 } -//ByteSize 空方法 +// ByteSize 空方法 func (t *TerminateRecord) ByteSize() int64 { return 0 } -//MemorySize 空方法 +// MemorySize 空方法 func (t *TerminateRecord) MemorySize() int64 { return 0 } -//String 空方法 +// String 空方法 func (t *TerminateRecord) String() string { return "terminate" } -//DefaultRecord 默认记录 +// DefaultRecord 默认记录 type DefaultRecord struct { names []string //列名数组 columns map[string]Column //列映射 @@ -96,14 +96,14 @@ type DefaultRecord struct { memorySize int64 //内存大小 } -//NewDefaultRecord 创建默认记录 +// NewDefaultRecord 创建默认记录 func NewDefaultRecord() *DefaultRecord { return &DefaultRecord{ columns: make(map[string]Column), } } -//Add 新增列c,若列c已经存在，就会报错 +// Add 新增列c,若列c已经存在，就会报错 func (r *DefaultRecord) Add(c Column) error { if _, ok := r.columns[c.Name()]; ok { return ErrColumnExist @@ -114,7 +114,7 @@ func (r *DefaultRecord) Add(c Column) error { return nil } -//GetByIndex 获取第i列,若索引i超出范围或者不存在，就会报错 +// GetByIndex 获取第i列,若索引i超出范围或者不存在，就会报错 func (r *DefaultRecord) GetByIndex(i int) (Column, error) { if i >= len(r.names) || i < 0 { return nil, ErrIndexOutOfRange @@ -125,7 +125,7 @@ func (r *DefaultRecord) GetByIndex(i int) (Column, error) { return nil, ErrColumnNotExist } -//GetByName 获取列名为name的列,若列名为name的列不存在，就会报错 +// GetByName 获取列名为name的列,若列名为name的列不存在，就会报错 func (r *DefaultRecord) GetByName(name string) (Column, error) { if v, ok := r.columns[name]; ok { return v, nil @@ -133,7 +133,7 @@ func (r *DefaultRecord) GetByName(name string) (Column, error) { return nil, ErrColumnNotExist } -//Set 设置第i列,若索引i超出范围，就会报错 +// Set 设置第i列,若索引i超出范围，就会报错 func (r *DefaultRecord) Set(i int, c Column) error { if i >= len(r.names) || i < 0 { return ErrIndexOutOfRange @@ -148,24 +148,24 @@ func (r *DefaultRecord) Set(i int, c Column) error { return nil } -//Put 设置列,若列名不存在，就会报错 +// Put 设置列,若列名不存在，就会报错 func (r *DefaultRecord) Put(c Column) error { r.columns[c.Name()] = c r.incSize(c) return nil } -//ColumnNumber 列数量 +// ColumnNumber 列数量 func (r *DefaultRecord) ColumnNumber() int { return len(r.columns) } -//ByteSize 字节流大小 +// ByteSize 字节流大小 func (r *DefaultRecord) ByteSize() int64 { return r.byteSize } -//MemorySize 内存大小 +// MemorySize 内存大小 func (r *DefaultRecord) MemorySize() int64 { return r.memorySize } @@ -180,7 +180,7 @@ func (r *DefaultRecord) decSize(c Column) { r.memorySize -= c.MemorySize() } -//String 空方法 +// String 空方法 func (r *DefaultRecord) String() string { b := &strings.Builder{} for i, v := range r.names { diff --git a/element/record_chan.go b/element/record_chan.go index 635df52..033fa9e 100644 --- a/element/record_chan.go +++ b/element/record_chan.go @@ -19,7 +19,7 @@ import ( "sync" ) -//RecordChan 记录通道 修复内存溢出 +// RecordChan 记录通道 修复内存溢出 type RecordChan struct { lock sync.Mutex ch chan Record @@ -29,12 +29,12 @@ type RecordChan struct { const defaultRequestChanBuffer = 1024 -//NewRecordChan 创建记录通道 +// NewRecordChan 创建记录通道 func NewRecordChan(ctx context.Context) *RecordChan { return NewRecordChanBuffer(ctx, 0) } -//NewRecordChanBuffer 创建容量n的记录通道 +// NewRecordChanBuffer 创建容量n的记录通道 func NewRecordChanBuffer(ctx context.Context, n int) *RecordChan { if n <= 0 { n = defaultRequestChanBuffer @@ -46,7 +46,7 @@ func NewRecordChanBuffer(ctx context.Context, n int) *RecordChan { return ch } -//Close 关闭 +// Close 关闭 func (c *RecordChan) Close() { c.lock.Lock() if !c.closed { @@ -56,12 +56,12 @@ func (c *RecordChan) Close() { c.lock.Unlock() } -//Buffered 记录通道内的元素数量 +// Buffered 记录通道内的元素数量 func (c *RecordChan) Buffered() int { return len(c.ch) } -//PushBack 在尾部追加记录r，并且返回队列大小 +// PushBack 在尾部追加记录r，并且返回队列大小 func (c *RecordChan) PushBack(r Record) int { select { case c.ch <- r: @@ -70,7 +70,7 @@ func (c *RecordChan) PushBack(r Record) int { return c.Buffered() } -//PopFront 在头部弹出记录r，并且返回是否还有值 +// PopFront 在头部弹出记录r，并且返回是否还有值 func (c *RecordChan) PopFront() (r Record, ok bool) { select { case r, ok = <-c.ch: @@ -80,7 +80,7 @@ func (c *RecordChan) PopFront() (r Record, ok bool) { return r, ok } -//PushBackAll 通过函数fetchRecord获取多个记录，在尾部追加 +// PushBackAll 通过函数fetchRecord获取多个记录，在尾部追加 func (c *RecordChan) PushBackAll(fetchRecord func() (Record, error)) error { for { r, err := fetchRecord() @@ -91,7 +91,7 @@ func (c *RecordChan) PushBackAll(fetchRecord func() (Record, error)) error { } } -//PopFrontAll 通过函数onRecord从头部弹出所有记录 +// PopFrontAll 通过函数onRecord从头部弹出所有记录 func (c *RecordChan) PopFrontAll(onRecord func(Record) error) error { for { r, ok := c.PopFront() diff --git a/element/string_column_value.go b/element/string_column_value.go index daa140f..30066bf 100644 --- a/element/string_column_value.go +++ b/element/string_column_value.go @@ -20,41 +20,41 @@ import ( "time" ) -//NilStringColumnValue 空值字符串列值 +// NilStringColumnValue 空值字符串列值 type NilStringColumnValue struct { *nilColumnValue } -//NewNilStringColumnValue 创建空值字符串列值 +// NewNilStringColumnValue 创建空值字符串列值 func NewNilStringColumnValue() ColumnValue { return &NilStringColumnValue{ nilColumnValue: &nilColumnValue{}, } } -//Type 列类型 +// Type 列类型 func (n *NilStringColumnValue) Type() ColumnType { return TypeString } -//Clone 克隆空值字符串 +// Clone 克隆空值字符串 func (n *NilStringColumnValue) Clone() ColumnValue { return NewNilStringColumnValue() } -//StringColumnValue 字符串列名 注意：Decimal 123.0（val:1230,exp:-1）和123（val:123,exp:0）不一致 +// StringColumnValue 字符串列名 注意：Decimal 123.0（val:1230,exp:-1）和123（val:123,exp:0）不一致 type StringColumnValue struct { notNilColumnValue TimeEncoder val string } -//NewStringColumnValue 根据字符串s 生成字符串列值 +// NewStringColumnValue 根据字符串s 生成字符串列值 func NewStringColumnValue(s string) ColumnValue { return NewStringColumnValueWithEncoder(s, NewStringTimeEncoder(DefaultTimeFormat)) } -//NewStringColumnValueWithEncoder 根据字符串s 时间编码器e生成字符串列值 +// NewStringColumnValueWithEncoder 根据字符串s 时间编码器e生成字符串列值 func NewStringColumnValueWithEncoder(s string, e TimeEncoder) ColumnValue { return &StringColumnValue{ TimeEncoder: e, @@ -62,13 +62,13 @@ func NewStringColumnValueWithEncoder(s string, e TimeEncoder) ColumnValue { } } -//Type 列类型 +// Type 列类型 func (s *StringColumnValue) Type() ColumnType { return TypeString } -//AsBool 1, t, T, TRUE, true, True转化为true -//0, f, F, FALSE, false, False转化为false，如果不是上述情况会报错 +// AsBool 1, t, T, TRUE, true, True转化为true +// 0, f, F, FALSE, false, False转化为false，如果不是上述情况会报错 func (s *StringColumnValue) AsBool() (v bool, err error) { v, err = strconv.ParseBool(s.val) if err != nil { @@ -77,8 +77,8 @@ func (s *StringColumnValue) AsBool() (v bool, err error) { return } -//AsBigInt 转化为整数，实数型以及科学性计数法字符串会被取整，不是数值型的会报错 -//如123.67转化为123 123.12转化为123 +// AsBigInt 转化为整数，实数型以及科学性计数法字符串会被取整，不是数值型的会报错 +// 如123.67转化为123 123.12转化为123 func (s *StringColumnValue) AsBigInt() (BigIntNumber, error) { v, err := NewDecimalColumnValueFromString(s.val) if err != nil { @@ -87,7 +87,7 @@ func (s *StringColumnValue) AsBigInt() (BigIntNumber, error) { return v.AsBigInt() } -//AsDecimal 转化为整数，实数型以及科学性计数法字符串能够转化，不是数值型的会报错 +// AsDecimal 转化为整数，实数型以及科学性计数法字符串能够转化，不是数值型的会报错 func (s *StringColumnValue) AsDecimal() (DecimalNumber, error) { v, err := NewDecimalColumnValueFromString(s.val) if err != nil { @@ -97,17 +97,17 @@ func (s *StringColumnValue) AsDecimal() (DecimalNumber, error) { return v.AsDecimal() } -//AsString 转化为字符串 +// AsString 转化为字符串 func (s *StringColumnValue) AsString() (string, error) { return s.val, nil } -//AsBytes 转化成字节流 +// AsBytes 转化成字节流 func (s *StringColumnValue) AsBytes() ([]byte, error) { return []byte(s.val), nil } -//AsTime 根据时间编码器转化成时间，不符合时间编码器格式会报错 +// AsTime 根据时间编码器转化成时间，不符合时间编码器格式会报错 func (s *StringColumnValue) AsTime() (t time.Time, err error) { t, err = s.TimeEncode(s.val) if err != nil { @@ -120,12 +120,12 @@ func (s *StringColumnValue) String() string { return s.val } -//Clone 克隆字符串列值 +// Clone 克隆字符串列值 func (s *StringColumnValue) Clone() ColumnValue { return NewStringColumnValue(s.val) } -//Cmp 返回1代表大于， 0代表相等， -1代表小于 +// Cmp 返回1代表大于， 0代表相等， -1代表小于 func (s *StringColumnValue) Cmp(right ColumnValue) (int, error) { rightValue, err := right.AsString() if err != nil { diff --git a/element/time.go b/element/time.go index e07a545..1d64792 100644 --- a/element/time.go +++ b/element/time.go @@ -19,33 +19,33 @@ import ( "time" ) -//DefaultTimeFormat 默认时间格式 +// DefaultTimeFormat 默认时间格式 var DefaultTimeFormat = "2006-01-02 15:04:05.999999999Z07:00" -//TimeDecoder 时间解码器 +// TimeDecoder 时间解码器 type TimeDecoder interface { TimeDecode(t time.Time) (interface{}, error) Layout() string } -//TimeEncoder 时间编码器 +// TimeEncoder 时间编码器 type TimeEncoder interface { TimeEncode(i interface{}) (time.Time, error) } -//StringTimeEncoder 字符串时间编码器 +// StringTimeEncoder 字符串时间编码器 type StringTimeEncoder struct { layout string //go时间格式 } -//NewStringTimeEncoder 根据go时间格式layout的字符串时间编码器 +// NewStringTimeEncoder 根据go时间格式layout的字符串时间编码器 func NewStringTimeEncoder(layout string) TimeEncoder { return &StringTimeEncoder{ layout: layout, } } -//TimeEncode 编码成时间，若i不是string或者不是layout格式，会报错 +// TimeEncode 编码成时间，若i不是string或者不是layout格式，会报错 func (e *StringTimeEncoder) TimeEncode(i interface{}) (time.Time, error) { s, ok := i.(string) if !ok { @@ -54,24 +54,24 @@ func (e *StringTimeEncoder) TimeEncode(i interface{}) (time.Time, error) { return time.Parse(e.layout[:len(s)], s) } -//StringTimeDecoder 字符串时间编码器 +// StringTimeDecoder 字符串时间编码器 type StringTimeDecoder struct { layout string //go时间格式 } -//NewStringTimeDecoder 根据go时间格式layout的字符串时间编码器 +// NewStringTimeDecoder 根据go时间格式layout的字符串时间编码器 func NewStringTimeDecoder(layout string) TimeDecoder { return &StringTimeDecoder{ layout: layout, } } -//TimeDecode 根据go时间格式layout的字符串时间编码成string +// TimeDecode 根据go时间格式layout的字符串时间编码成string func (d *StringTimeDecoder) TimeDecode(t time.Time) (interface{}, error) { return t.Format(d.layout), nil } -//Layout 时间格式 +// Layout 时间格式 func (d *StringTimeDecoder) Layout() string { return d.layout } diff --git a/element/time_column_value.go b/element/time_column_value.go index a610660..2d1c039 100644 --- a/element/time_column_value.go +++ b/element/time_column_value.go @@ -19,29 +19,29 @@ import ( "time" ) -//NilTimeColumnValue 空值时间列值 +// NilTimeColumnValue 空值时间列值 type NilTimeColumnValue struct { *nilColumnValue } -//NewNilTimeColumnValue 创建空值时间列值 +// NewNilTimeColumnValue 创建空值时间列值 func NewNilTimeColumnValue() ColumnValue { return &NilTimeColumnValue{ nilColumnValue: &nilColumnValue{}, } } -//Type 列类型 +// Type 列类型 func (n *NilTimeColumnValue) Type() ColumnType { return TypeTime } -//Clone 克隆空值时间列值 +// Clone 克隆空值时间列值 func (n *NilTimeColumnValue) Clone() ColumnValue { return NewNilTimeColumnValue() } -//TimeColumnValue 时间列值 +// TimeColumnValue 时间列值 type TimeColumnValue struct { notNilColumnValue TimeDecoder //时间解码器 @@ -49,12 +49,12 @@ type TimeColumnValue struct { val time.Time } -//NewTimeColumnValue 根据时间t获得时间列值 +// NewTimeColumnValue 根据时间t获得时间列值 func NewTimeColumnValue(t time.Time) ColumnValue { return NewTimeColumnValueWithDecoder(t, NewStringTimeDecoder(DefaultTimeFormat)) } -//NewTimeColumnValueWithDecoder 根据时间t和时间解码器t获得时间列值 +// NewTimeColumnValueWithDecoder 根据时间t和时间解码器t获得时间列值 func NewTimeColumnValueWithDecoder(t time.Time, d TimeDecoder) ColumnValue { return &TimeColumnValue{ TimeDecoder: d, @@ -62,27 +62,27 @@ func NewTimeColumnValueWithDecoder(t time.Time, d TimeDecoder) ColumnValue { } } -//Type 列类型 +// Type 列类型 func (t *TimeColumnValue) Type() ColumnType { return TypeTime } -//AsBool 无法转化布尔值 +// AsBool 无法转化布尔值 func (t *TimeColumnValue) AsBool() (bool, error) { return false, NewTransformErrorFormColumnTypes(t.Type(), TypeBool, fmt.Errorf("val: %v", t.String())) } -//AsBigInt 无法转化整数 +// AsBigInt 无法转化整数 func (t *TimeColumnValue) AsBigInt() (BigIntNumber, error) { return nil, NewTransformErrorFormColumnTypes(t.Type(), TypeBigInt, fmt.Errorf("val: %v", t.String())) } -//AsDecimal 无法转化高精度实数 +// AsDecimal 无法转化高精度实数 func (t *TimeColumnValue) AsDecimal() (DecimalNumber, error) { return nil, NewTransformErrorFormColumnTypes(t.Type(), TypeDecimal, fmt.Errorf("val: %v", t.String())) } -//AsString 变为字符串 +// AsString 变为字符串 func (t *TimeColumnValue) AsString() (s string, err error) { var i interface{} i, err = t.TimeDecode(t.val) @@ -92,7 +92,7 @@ func (t *TimeColumnValue) AsString() (s string, err error) { return i.(string), nil } -//AsBytes 变为字节流 +// AsBytes 变为字节流 func (t *TimeColumnValue) AsBytes() (b []byte, err error) { var i interface{} i, err = t.TimeDecode(t.val) @@ -102,7 +102,7 @@ func (t *TimeColumnValue) AsBytes() (b []byte, err error) { return []byte(i.(string)), nil } -//AsTime 变为时间 +// AsTime 变为时间 func (t *TimeColumnValue) AsTime() (time.Time, error) { return t.val, nil } @@ -111,14 +111,14 @@ func (t *TimeColumnValue) String() string { return t.val.Format(DefaultTimeFormat) } -//Clone 克隆时间列值 +// Clone 克隆时间列值 func (t *TimeColumnValue) Clone() ColumnValue { return &TimeColumnValue{ val: t.val, } } -//Cmp 返回1代表大于， 0代表相等， -1代表小于 +// Cmp 返回1代表大于， 0代表相等， -1代表小于 func (t *TimeColumnValue) Cmp(right ColumnValue) (int, error) { rightValue, err := right.AsTime() if err != nil { diff --git a/schedule/async_task_scheduler.go b/schedule/async_task_scheduler.go index a9878cf..a7e87fe 100644 --- a/schedule/async_task_scheduler.go +++ b/schedule/async_task_scheduler.go @@ -32,7 +32,7 @@ type asyncTaskResult struct { result chan error } -//AsyncTaskScheduler 异步任务调度器 +// AsyncTaskScheduler 异步任务调度器 type AsyncTaskScheduler struct { tasks chan *asyncTaskWrapper results chan *asyncTaskResult @@ -44,8 +44,8 @@ type AsyncTaskScheduler struct { closed int32 } -//NewAsyncTaskScheduler 通过上下文ctx, 并行任务数numWorker, -//任务数大小chanSize创建异步任务调度器 +// NewAsyncTaskScheduler 通过上下文ctx, 并行任务数numWorker, +// 任务数大小chanSize创建异步任务调度器 func NewAsyncTaskScheduler(ctx context.Context, numWorker, chanSize int) *AsyncTaskScheduler { a := &AsyncTaskScheduler{ @@ -76,7 +76,7 @@ func NewAsyncTaskScheduler(ctx context.Context, return a } -//Push 异步执行任务task +// Push 异步执行任务task func (a *AsyncTaskScheduler) Push(task AsyncTask) (err error) { if goatomic.CompareAndSwapInt32(&a.closed, 1, 1) { return ErrClosed @@ -109,17 +109,17 @@ func (a *AsyncTaskScheduler) Push(task AsyncTask) (err error) { return nil } -//Size 正在异步任务调度器中的任务 +// Size 正在异步任务调度器中的任务 func (a *AsyncTaskScheduler) Size() int32 { return a.size.Load() } -//Errors 错误监听器 +// Errors 错误监听器 func (a *AsyncTaskScheduler) Errors() <-chan error { return a.errors } -//Close 关闭 +// Close 关闭 func (a *AsyncTaskScheduler) Close() error { if !goatomic.CompareAndSwapInt32(&a.closed, 0, 1) { return ErrClosed diff --git a/schedule/doc.go b/schedule/doc.go index 4dc6057..e2014b7 100644 --- a/schedule/doc.go +++ b/schedule/doc.go @@ -12,5 +12,5 @@ // See the License for the specific language governing permissions and // limitations under the License. -//Package schedule 提供资源映射以及任务调度器 +// Package schedule 提供资源映射以及任务调度器 package schedule diff --git a/schedule/resource.go b/schedule/resource.go index 75fc2df..b8cb303 100644 --- a/schedule/resource.go +++ b/schedule/resource.go @@ -14,12 +14,12 @@ package schedule -//Resource 资源 +// Resource 资源 type Resource interface { Close() error //关闭释放资源 } -//MappedResource 可映射资源 +// MappedResource 可映射资源 type MappedResource interface { Resource diff --git a/schedule/resource_map.go b/schedule/resource_map.go index 708f688..4bc9df6 100644 --- a/schedule/resource_map.go +++ b/schedule/resource_map.go @@ -23,22 +23,22 @@ type mappedResouceWrapper struct { useCount int } -//ResourceMap 资源映射，每一个资源类似于智能指针 +// ResourceMap 资源映射，每一个资源类似于智能指针 type ResourceMap struct { mu sync.Mutex resources map[string]*mappedResouceWrapper } -//NewResourceMap 创建资源映射 +// NewResourceMap 创建资源映射 func NewResourceMap() *ResourceMap { return &ResourceMap{ resources: make(map[string]*mappedResouceWrapper), } } -//Get 根据关键字key获取资源，若不存在，就通过函数create创建资源 -//若创建资源错误时，就会返回错误 +// Get 根据关键字key获取资源，若不存在，就通过函数create创建资源 +// 若创建资源错误时，就会返回错误 func (r *ResourceMap) Get(key string, create func() (MappedResource, error)) (resource MappedResource, err error) { var ok bool r.mu.Lock() @@ -58,8 +58,8 @@ func (r *ResourceMap) Get(key string, create func() (MappedResource, error)) (re return } -//Release 根据资源resource释放资源，若不存在，就通过函数create创建资源 -//若创建资源错误时，就会返回错误 +// Release 根据资源resource释放资源，若不存在，就通过函数create创建资源 +// 若创建资源错误时，就会返回错误 func (r *ResourceMap) Release(resource MappedResource) (err error) { r.mu.Lock() fn := r.releaseLocked(resource) @@ -67,7 +67,7 @@ func (r *ResourceMap) Release(resource MappedResource) (err error) { return fn() } -//UseCount 根据资源resource计算已使用个数 +// UseCount 根据资源resource计算已使用个数 func (r *ResourceMap) UseCount(resource MappedResource) int { r.mu.Lock() defer r.mu.Unlock() diff --git a/schedule/retry_strategy.go b/schedule/retry_strategy.go index 7615c29..024b811 100644 --- a/schedule/retry_strategy.go +++ b/schedule/retry_strategy.go @@ -25,7 +25,7 @@ import ( "github.com/pingcap/errors" ) -//NewRetryStrategy 根据配置文件生成重试策略 +// NewRetryStrategy 根据配置文件生成重试策略 func NewRetryStrategy(j RetryJudger, conf *config.JSON) (s RetryStrategy, err error) { var retry *config.JSON if ok := conf.Exists("retry"); !ok { @@ -83,54 +83,54 @@ func NewRetryStrategy(j RetryJudger, conf *config.JSON) (s RetryStrategy, err er return } -//NTimesRetryConfig n次数重复重试策略 +// NTimesRetryConfig n次数重复重试策略 type NTimesRetryConfig struct { N int `json:"n"` Wait time2.Duration `json:"wait"` } -//ForeverRetryConfig 永久重复重试策略 +// ForeverRetryConfig 永久重复重试策略 type ForeverRetryConfig struct { Wait time2.Duration `json:"wait"` } -//ExponentialRetryConfig 幂重复重试策略 +// ExponentialRetryConfig 幂重复重试策略 type ExponentialRetryConfig struct { Init time2.Duration `json:"init"` Max time2.Duration `json:"max"` } -//RetryStrategy 重试策略 +// RetryStrategy 重试策略 type RetryStrategy interface { Next(err error, n int) (retry bool, wait time.Duration) } -//RetryJudger 重试判断器 +// RetryJudger 重试判断器 type RetryJudger interface { ShouldRetry(err error) bool } -//NoneRetryStrategy 无重试策略 +// NoneRetryStrategy 无重试策略 type NoneRetryStrategy struct{} -//NewNoneRetryStrategy 创建无重试策略 +// NewNoneRetryStrategy 创建无重试策略 func NewNoneRetryStrategy() RetryStrategy { return &NoneRetryStrategy{} } -//Next 下一次是否retry需要重试，wait等待时间 +// Next 下一次是否retry需要重试，wait等待时间 func (r *NoneRetryStrategy) Next(err error, n int) (retry bool, wait time.Duration) { return } -//NTimesRetryStrategy n次数重复重试策略 +// NTimesRetryStrategy n次数重复重试策略 type NTimesRetryStrategy struct { j RetryJudger n int wait time.Duration } -//NewNTimesRetryStrategy 通过重试判定器j,最大次数n以及重试间隔wait创建n次数重复重试策略 +// NewNTimesRetryStrategy 通过重试判定器j,最大次数n以及重试间隔wait创建n次数重复重试策略 func NewNTimesRetryStrategy(j RetryJudger, n int, wait time.Duration) RetryStrategy { return &NTimesRetryStrategy{ j: j, @@ -139,7 +139,7 @@ func NewNTimesRetryStrategy(j RetryJudger, n int, wait time.Duration) RetryStrat } } -//Next 通过错误err以及当前次数n获取下次是否重试retry以及下次时间间隔wait +// Next 通过错误err以及当前次数n获取下次是否重试retry以及下次时间间隔wait func (r *NTimesRetryStrategy) Next(err error, n int) (retry bool, wait time.Duration) { if !r.j.ShouldRetry(err) { return false, 0 @@ -151,13 +151,13 @@ func (r *NTimesRetryStrategy) Next(err error, n int) (retry bool, wait time.Dura return true, r.wait } -//ForeverRetryStrategy 永久重试策略 +// ForeverRetryStrategy 永久重试策略 type ForeverRetryStrategy struct { j RetryJudger wait time.Duration } -//NewForeverRetryStrategy 通过重试判定器j以及重试间隔wait创建永久重试策略 +// NewForeverRetryStrategy 通过重试判定器j以及重试间隔wait创建永久重试策略 func NewForeverRetryStrategy(j RetryJudger, wait time.Duration) RetryStrategy { return &ForeverRetryStrategy{ j: j, @@ -165,7 +165,7 @@ func NewForeverRetryStrategy(j RetryJudger, wait time.Duration) RetryStrategy { } } -//Next 通过错误err,获取下次是否重试retry以及下次时间间隔wait,在永久重试策略没有最大重试次数，当前次数n没有作用 +// Next 通过错误err,获取下次是否重试retry以及下次时间间隔wait,在永久重试策略没有最大重试次数，当前次数n没有作用 func (r *ForeverRetryStrategy) Next(err error, _ int) (retry bool, wait time.Duration) { if !r.j.ShouldRetry(err) { return false, 0 @@ -174,7 +174,7 @@ func (r *ForeverRetryStrategy) Next(err error, _ int) (retry bool, wait time.Dur return true, r.wait } -//ExponentialStrategy 幂重试策略 +// ExponentialStrategy 幂重试策略 type ExponentialStrategy struct { j RetryJudger f float64 @@ -182,7 +182,7 @@ type ExponentialStrategy struct { max float64 } -//NewExponentialRetryStrategy 通过重试判定器j,开始时间间隔init以及最大时间间隔max创建幂重试策略 +// NewExponentialRetryStrategy 通过重试判定器j,开始时间间隔init以及最大时间间隔max创建幂重试策略 func NewExponentialRetryStrategy(j RetryJudger, init, max time.Duration) RetryStrategy { rand.Seed(time.Now().UnixNano()) return &ExponentialStrategy{ @@ -193,7 +193,7 @@ func NewExponentialRetryStrategy(j RetryJudger, init, max time.Duration) RetrySt } } -//Next 通过错误err,获取下次是否重试retry以及下次时间间隔wait,在幂重试策略最大时间间隔 +// Next 通过错误err,获取下次是否重试retry以及下次时间间隔wait,在幂重试策略最大时间间隔 func (r *ExponentialStrategy) Next(err error, n int) (retry bool, wait time.Duration) { if !r.j.ShouldRetry(err) { return false, 0 diff --git a/schedule/retry_task.go b/schedule/retry_task.go index 34ac50a..9546309 100644 --- a/schedule/retry_task.go +++ b/schedule/retry_task.go @@ -19,14 +19,14 @@ import ( "time" ) -//RetryTask 重试任务 +// RetryTask 重试任务 type RetryTask struct { ctx context.Context task Task strategy RetryStrategy } -//NewRetryTask 通过上下文关系ctx，重试策略strategy以及任务task生成重试任务 +// NewRetryTask 通过上下文关系ctx，重试策略strategy以及任务task生成重试任务 func NewRetryTask(ctx context.Context, strategy RetryStrategy, task Task) *RetryTask { return &RetryTask{ ctx: ctx, @@ -35,7 +35,7 @@ func NewRetryTask(ctx context.Context, strategy RetryStrategy, task Task) *Retry } } -//Do 同步执行 +// Do 同步执行 func (r *RetryTask) Do() (err error) { ticker := time.NewTicker(1) defer ticker.Stop() diff --git a/schedule/task.go b/schedule/task.go index 3ffaf3b..90f6da2 100644 --- a/schedule/task.go +++ b/schedule/task.go @@ -14,18 +14,18 @@ package schedule -//Task 任务 +// Task 任务 type Task interface { Do() error //同步执行 } -//AsyncTask 异步任务 +// AsyncTask 异步任务 type AsyncTask interface { Do() error //同步执行 Post() error //后续通知 } -//MappedTask 映射任务 +// MappedTask 映射任务 type MappedTask interface { Key() string //映射主键 } diff --git a/schedule/task_manager.go b/schedule/task_manager.go index 275021c..092aec7 100644 --- a/schedule/task_manager.go +++ b/schedule/task_manager.go @@ -16,8 +16,8 @@ package schedule import "sync" -//MappedTaskManager 任务管理器 -//toto 不知道为什么len(remain) + len(run) 无法实时任务数,其中主要是len(run)不准确 +// MappedTaskManager 任务管理器 +// toto 不知道为什么len(remain) + len(run) 无法实时任务数,其中主要是len(run)不准确 type MappedTaskManager struct { sync.Mutex @@ -26,28 +26,28 @@ type MappedTaskManager struct { num int //任务数 } -//NewTaskManager 创建任务管理器 +// NewTaskManager 创建任务管理器 func NewTaskManager() *MappedTaskManager { return &MappedTaskManager{ run: make(map[string]MappedTask), } } -//IsEmpty 任务管理器是否为空 +// IsEmpty 任务管理器是否为空 func (t *MappedTaskManager) IsEmpty() bool { t.Lock() defer t.Unlock() return t.lockedSize() == 0 } -//Size 任务数，包含待执行和运行任务 +// Size 任务数，包含待执行和运行任务 func (t *MappedTaskManager) Size() int { t.Lock() defer t.Unlock() return t.lockedSize() } -//Runs 获取当前在跑的任务 +// Runs 获取当前在跑的任务 func (t *MappedTaskManager) Runs() (tasks []MappedTask) { t.Lock() for _, v := range t.run { @@ -57,12 +57,12 @@ func (t *MappedTaskManager) Runs() (tasks []MappedTask) { return } -//lockedSize 未加锁的任务数 +// lockedSize 未加锁的任务数 func (t *MappedTaskManager) lockedSize() int { return t.num } -//RemoveRunAndPushRemain 从运行队列移动到待执行队列 +// RemoveRunAndPushRemain 从运行队列移动到待执行队列 func (t *MappedTaskManager) RemoveRunAndPushRemain(task MappedTask) { t.Lock() defer t.Unlock() @@ -70,21 +70,21 @@ func (t *MappedTaskManager) RemoveRunAndPushRemain(task MappedTask) { t.lockedPushRemain(task) } -//PushRemain 把任务加入待执行队列 +// PushRemain 把任务加入待执行队列 func (t *MappedTaskManager) PushRemain(task MappedTask) { t.Lock() defer t.Unlock() t.lockedPushRemain(task) } -//RemoveRun 从运行队列移除出任务 +// RemoveRun 从运行队列移除出任务 func (t *MappedTaskManager) RemoveRun(task MappedTask) { t.Lock() defer t.Unlock() t.lockedRemoveRun(task) } -//PopRemainAndAddRun 从待执行队列移到运行队列中 +// PopRemainAndAddRun 从待执行队列移到运行队列中 func (t *MappedTaskManager) PopRemainAndAddRun() (task MappedTask, ok bool) { t.Lock() defer t.Unlock() @@ -95,25 +95,25 @@ func (t *MappedTaskManager) PopRemainAndAddRun() (task MappedTask, ok bool) { return } -//lockedRemoveRun 从运行队列移除任务 +// lockedRemoveRun 从运行队列移除任务 func (t *MappedTaskManager) lockedRemoveRun(task MappedTask) { t.run[task.Key()] = nil delete(t.run, task.Key()) t.num-- } -//lockedPushRemain 将任务加入到待执行队列 +// lockedPushRemain 将任务加入到待执行队列 func (t *MappedTaskManager) lockedPushRemain(task MappedTask) { t.remain = append(t.remain, task) t.num++ } -//lockedPushRemain 将任务加入到运行队列 +// lockedPushRemain 将任务加入到运行队列 func (t *MappedTaskManager) lockedAddRun(task MappedTask) { t.run[task.Key()] = task } -//lockedPopRemain 从待执行队列带出任务te，当代执行队列中没有值时，返回false +// lockedPopRemain 从待执行队列带出任务te，当代执行队列中没有值时，返回false func (t *MappedTaskManager) lockedPopRemain() (task MappedTask, ok bool) { if len(t.remain) == 0 { return nil, false diff --git a/schedule/task_scheduler.go b/schedule/task_scheduler.go index 50e9f80..7a09057 100644 --- a/schedule/task_scheduler.go +++ b/schedule/task_scheduler.go @@ -22,7 +22,7 @@ import ( "go.uber.org/atomic" ) -//已关闭错误 +// 已关闭错误 var ( ErrClosed = errors.New("task schduler closed") ) @@ -32,7 +32,7 @@ type taskWrapper struct { result chan error } -//TaskSchduler 任务调度器 +// TaskSchduler 任务调度器 type TaskSchduler struct { taskWrappers chan *taskWrapper //待执行任务队列 wg sync.WaitGroup @@ -41,7 +41,7 @@ type TaskSchduler struct { size *atomic.Int32 //待执行队列大小 } -//NewTaskSchduler 根据执行者数workerNumer，待执行队列容量cao生成任务调度器 +// NewTaskSchduler 根据执行者数workerNumer，待执行队列容量cao生成任务调度器 func NewTaskSchduler(workerNumer, cap int) *TaskSchduler { t := &TaskSchduler{ taskWrappers: make(chan *taskWrapper, cap), @@ -61,7 +61,7 @@ func NewTaskSchduler(workerNumer, cap int) *TaskSchduler { return t } -//Push 将任务task加入队列，获得执行结果通知信道，在已关闭时报错 +// Push 将任务task加入队列，获得执行结果通知信道，在已关闭时报错 func (t *TaskSchduler) Push(task Task) (<-chan error, error) { if goatomic.CompareAndSwapInt32(&t.stopped, 1, 1) { return nil, ErrClosed @@ -80,12 +80,12 @@ func (t *TaskSchduler) Push(task Task) (<-chan error, error) { } } -//Size 待执行队列大小 +// Size 待执行队列大小 func (t *TaskSchduler) Size() int32 { return t.size.Load() } -//Stop 停止任务调度器 +// Stop 停止任务调度器 func (t *TaskSchduler) Stop() { if !goatomic.CompareAndSwapInt32(&t.stopped, 0, 1) { return diff --git a/storage/database/config.go b/storage/database/config.go index df24c7a..6ad2842 100644 --- a/storage/database/config.go +++ b/storage/database/config.go @@ -21,13 +21,13 @@ import ( "github.com/Breeze0806/go/time2" ) -//Config 数据库连接基础配置，一般用于sql.DB的配置 +// Config 数据库连接基础配置，一般用于sql.DB的配置 type Config struct { Pool PoolConfig `json:"pool"` } -//NewConfig 从Json配置中获取数据库连接配置c -//err是指Json配置无法转化为数据库连接配置 +// NewConfig 从Json配置中获取数据库连接配置c +// err是指Json配置无法转化为数据库连接配置 func NewConfig(conf *config.JSON) (c *Config, err error) { c = &Config{} err = json.Unmarshal([]byte(conf.String()), c) @@ -37,8 +37,8 @@ func NewConfig(conf *config.JSON) (c *Config, err error) { return } -//PoolConfig 数据库连接池配置 -//一般让最大打开连接数和最大空闲时连接数一致，否则会导致释放连接不及导致文件数不足 +// PoolConfig 数据库连接池配置 +// 一般让最大打开连接数和最大空闲时连接数一致，否则会导致释放连接不及导致文件数不足 type PoolConfig struct { MaxOpenConns int `json:"maxOpenConns"` //最大打开连接数 MaxIdleConns int `json:"maxIdleConns"` //最大空闲时连接数 @@ -46,7 +46,7 @@ type PoolConfig struct { ConnMaxLifetime time2.Duration `json:"connMaxLifetime"` //最大连接存活时间 } -//GetMaxOpenConns 获取最大连接数，默认返回值为4 +// GetMaxOpenConns 获取最大连接数，默认返回值为4 func (c *PoolConfig) GetMaxOpenConns() int { if c.MaxOpenConns <= 0 { return DefaultMaxOpenConns @@ -54,7 +54,7 @@ func (c *PoolConfig) GetMaxOpenConns() int { return c.MaxOpenConns } -//GetMaxIdleConns 获取空闲时最大连接数，默认返回为4 +// GetMaxIdleConns 获取空闲时最大连接数，默认返回为4 func (c *PoolConfig) GetMaxIdleConns() int { if c.MaxIdleConns <= 0 { return DefaultMaxIdleConns diff --git a/storage/database/db.go b/storage/database/db.go index d3247f8..b92f97b 100644 --- a/storage/database/db.go +++ b/storage/database/db.go @@ -24,24 +24,24 @@ import ( "github.com/pingcap/errors" ) -//写入数据库模式 +// 写入数据库模式 const ( WriteModeInsert = "insert" ) -//FetchHandler 获取记录句柄 +// FetchHandler 获取记录句柄 type FetchHandler interface { OnRecord(element.Record) error CreateRecord() (element.Record, error) } -//BaseFetchHandler 基础获取记录句柄 +// BaseFetchHandler 基础获取记录句柄 type BaseFetchHandler struct { onRecord func(element.Record) error createRecord func() (element.Record, error) } -//NewBaseFetchHandler 创建基础获取记录句柄 +// NewBaseFetchHandler 创建基础获取记录句柄 func NewBaseFetchHandler(createRecord func() (element.Record, error), onRecord func(element.Record) error) *BaseFetchHandler { return &BaseFetchHandler{ @@ -50,24 +50,24 @@ func NewBaseFetchHandler(createRecord func() (element.Record, error), } } -//OnRecord 处理记录r +// OnRecord 处理记录r func (b *BaseFetchHandler) OnRecord(r element.Record) error { return b.onRecord(r) } -//CreateRecord 创建记录 +// CreateRecord 创建记录 func (b *BaseFetchHandler) CreateRecord() (element.Record, error) { return b.createRecord() } -//DB 用户维护数据库连接池 +// DB 用户维护数据库连接池 type DB struct { Source db *sql.DB } -//NewDB 从数据源source中获取数据库连接池 +// NewDB 从数据源source中获取数据库连接池 func NewDB(source Source) (d *DB, err error) { var c *Config c, err = NewConfig(source.Config()) @@ -104,12 +104,12 @@ func NewDB(source Source) (d *DB, err error) { return } -//FetchTable 通过上下文ctx和基础表数据t，获取对应的表并会返回错误 +// FetchTable 通过上下文ctx和基础表数据t，获取对应的表并会返回错误 func (d *DB) FetchTable(ctx context.Context, t *BaseTable) (Table, error) { return d.FetchTableWithParam(ctx, NewTableQueryParam(d.Table(t))) } -//FetchTableWithParam 通过上下文ctx和sql参数param，获取对应的表并会返回错误 +// FetchTableWithParam 通过上下文ctx和sql参数param，获取对应的表并会返回错误 func (d *DB) FetchTableWithParam(ctx context.Context, param Parameter) (Table, error) { table := param.Table() if fetcher, ok := table.(FieldsFetcher); ok { @@ -131,8 +131,8 @@ func (d *DB) FetchTableWithParam(ctx context.Context, param Parameter) (Table, e return fetchTableByRows(rows, table) } -//FetchRecord 通过上下文ctx，sql参数param以及记录处理函数onRecord -//获取多行记录返回错误 +// FetchRecord 通过上下文ctx，sql参数param以及记录处理函数onRecord +// 获取多行记录返回错误 func (d *DB) FetchRecord(ctx context.Context, param Parameter, handler FetchHandler) (err error) { var query string var agrs []interface{} @@ -158,8 +158,8 @@ func (d *DB) FetchRecord(ctx context.Context, param Parameter, handler FetchHand return readRowsToRecord(rows, param, handler) } -//FetchRecordWithTx 通过上下文ctx，sql参数param以及记录处理函数onRecord -//使用事务获取多行记录并返回错误 +// FetchRecordWithTx 通过上下文ctx，sql参数param以及记录处理函数onRecord +// 使用事务获取多行记录并返回错误 func (d *DB) FetchRecordWithTx(ctx context.Context, param Parameter, handler FetchHandler) (err error) { var query string var agrs []interface{} @@ -198,7 +198,7 @@ func (d *DB) FetchRecordWithTx(ctx context.Context, param Parameter, handler Fet return readRowsToRecord(rows, param, handler) } -//BatchExec 批量执行sql并处理多行记录 +// BatchExec 批量执行sql并处理多行记录 func (d *DB) BatchExec(ctx context.Context, opts *ParameterOptions) (err error) { var param Parameter if param, err = execParam(opts); err != nil { @@ -207,7 +207,7 @@ func (d *DB) BatchExec(ctx context.Context, opts *ParameterOptions) (err error) return d.batchExec(ctx, param, opts.Records) } -//BatchExecStmt 批量prepare/exec执行sql并处理多行记录 +// BatchExecStmt 批量prepare/exec执行sql并处理多行记录 func (d *DB) BatchExecStmt(ctx context.Context, opts *ParameterOptions) (err error) { var param Parameter if param, err = execParam(opts); err != nil { @@ -216,7 +216,7 @@ func (d *DB) BatchExecStmt(ctx context.Context, opts *ParameterOptions) (err err return d.batchExecStmt(ctx, param, opts.Records) } -//BatchExecWithTx 批量事务执行sql并处理多行记录 +// BatchExecWithTx 批量事务执行sql并处理多行记录 func (d *DB) BatchExecWithTx(ctx context.Context, opts *ParameterOptions) (err error) { var param Parameter if param, err = execParam(opts); err != nil { @@ -225,7 +225,7 @@ func (d *DB) BatchExecWithTx(ctx context.Context, opts *ParameterOptions) (err e return d.batchExecWithTx(ctx, param, opts.Records) } -//BatchExecStmtWithTx 批量事务prepare/exec执行sql并处理多行记录 +// BatchExecStmtWithTx 批量事务prepare/exec执行sql并处理多行记录 func (d *DB) BatchExecStmtWithTx(ctx context.Context, opts *ParameterOptions) (err error) { var param Parameter if param, err = execParam(opts); err != nil { @@ -234,27 +234,27 @@ func (d *DB) BatchExecStmtWithTx(ctx context.Context, opts *ParameterOptions) (e return d.batchExecStmtWithTx(ctx, param, opts.Records) } -//BeginTx 获取事务 +// BeginTx 获取事务 func (d *DB) BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error) { return d.db.BeginTx(ctx, opts) } -//PingContext 通过query查询多行数据 +// PingContext 通过query查询多行数据 func (d *DB) PingContext(ctx context.Context) error { return d.db.PingContext(ctx) } -//QueryContext 通过query查询多行数据 +// QueryContext 通过query查询多行数据 func (d *DB) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error) { return d.db.QueryContext(ctx, query, args...) } -//ExecContext 执行query并获取结果 +// ExecContext 执行query并获取结果 func (d *DB) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) { return d.db.ExecContext(ctx, query, args...) } -//Close 关闭数据连接池 +// Close 关闭数据连接池 func (d *DB) Close() (err error) { if d.db != nil { return d.db.Close() diff --git a/storage/database/db2/config.go b/storage/database/db2/config.go index 0c53c27..d7cd8d7 100644 --- a/storage/database/db2/config.go +++ b/storage/database/db2/config.go @@ -24,15 +24,15 @@ import ( "github.com/Breeze0806/go-etl/config" ) -//Config 配置 -//ibm.com/docs/en/db2/11.1?topic=file-data-server-driver-configuration-keywords +// Config 配置 +// ibm.com/docs/en/db2/11.1?topic=file-data-server-driver-configuration-keywords type Config struct { URL string `json:"url"` //数据库url，包含数据库地址，数据库其他参数 Username string `json:"username"` //用户名 Password string `json:"password"` //密码 } -//NewConfig 创建db2配置，如果格式不符合要求，就会报错 +// NewConfig 创建db2配置，如果格式不符合要求，就会报错 func NewConfig(conf *config.JSON) (c *Config, err error) { c = &Config{} err = json.Unmarshal([]byte(conf.String()), c) @@ -42,7 +42,7 @@ func NewConfig(conf *config.JSON) (c *Config, err error) { return } -//FormatDSN 生成数据源连接信息，url有错会报错 +// FormatDSN 生成数据源连接信息，url有错会报错 func (c *Config) FormatDSN() (dsn string, err error) { o := make(values) if err = parseOpts(c.URL, o); err != nil { diff --git a/storage/database/db2/decode_chinese_linux.go b/storage/database/db2/decode_chinese_linux.go index 0ec4c7d..fd2e33b 100644 --- a/storage/database/db2/decode_chinese_linux.go +++ b/storage/database/db2/decode_chinese_linux.go @@ -14,7 +14,7 @@ package db2 -//db2的char和varchar类型在linux下中文字符集是utf-8 +// db2的char和varchar类型在linux下中文字符集是utf-8 func decodeChinese(data []byte) ([]byte, error) { return data, nil } diff --git a/storage/database/db2/decode_chinese_windows.go b/storage/database/db2/decode_chinese_windows.go index 8de1a97..ee168f7 100644 --- a/storage/database/db2/decode_chinese_windows.go +++ b/storage/database/db2/decode_chinese_windows.go @@ -16,7 +16,7 @@ package db2 import "golang.org/x/text/encoding/simplifiedchinese" -//db2的char和varchar类型在windows下中文字符集是gbk +// db2的char和varchar类型在windows下中文字符集是gbk func decodeChinese(data []byte) ([]byte, error) { return simplifiedchinese.GBK.NewDecoder().Bytes(data) } diff --git a/storage/database/db2/field.go b/storage/database/db2/field.go index cc4b59f..77e0a02 100644 --- a/storage/database/db2/field.go +++ b/storage/database/db2/field.go @@ -28,56 +28,56 @@ var ( timeLayout = timestampLayout ) -//Field 字段 +// Field 字段 type Field struct { *database.BaseField } -//NewField 通过基本列属性生成字段 +// NewField 通过基本列属性生成字段 func NewField(bf *database.BaseField) *Field { return &Field{ BaseField: bf, } } -//Quoted 引用，用于SQL语句 +// Quoted 引用，用于SQL语句 func (f *Field) Quoted() string { return Quoted(f.Name()) } -//BindVar SQL占位符，用于SQL语句 +// BindVar SQL占位符，用于SQL语句 func (f *Field) BindVar(_ int) string { return "?" } -//Select 查询时字段，用于SQL查询语句 +// Select 查询时字段，用于SQL查询语句 func (f *Field) Select() string { return Quoted(f.Name()) } -//Type 字段类型 +// Type 字段类型 func (f *Field) Type() database.FieldType { return NewFieldType(f.FieldType()) } -//Scanner 扫描器，用于读取数据 +// Scanner 扫描器，用于读取数据 func (f *Field) Scanner() database.Scanner { return NewScanner(f) } -//Valuer 赋值器，采用GoValuer处理数据 +// Valuer 赋值器，采用GoValuer处理数据 func (f *Field) Valuer(c element.Column) database.Valuer { return database.NewGoValuer(f, c) } -//FieldType 字段类型 +// FieldType 字段类型 type FieldType struct { *database.BaseFieldType goType database.GoType } -//NewFieldType 创建新的字段类型 +// NewFieldType 创建新的字段类型 func NewFieldType(typ database.ColumnType) *FieldType { f := &FieldType{ BaseFieldType: database.NewBaseFieldType(typ), @@ -99,36 +99,36 @@ func NewFieldType(typ database.ColumnType) *FieldType { return f } -//IsSupportted 是否支持解析 +// IsSupportted 是否支持解析 func (f *FieldType) IsSupportted() bool { return f.goType != database.GoTypeUnknown } -//GoType 返回处理数值时的Golang类型 +// GoType 返回处理数值时的Golang类型 func (f *FieldType) GoType() database.GoType { return f.goType } -//Scanner 扫描器 +// Scanner 扫描器 type Scanner struct { f *Field database.BaseScanner } -//NewScanner 根据列类型生成扫描器 +// NewScanner 根据列类型生成扫描器 func NewScanner(f *Field) *Scanner { return &Scanner{ f: f, } } -//Scan 根据列类型读取数据 -//"INTEGER", "BIGINT", "SMALLINT"作为整形处理 -//"DOUBLE", "REAL", "DECIMAL"作为高精度实数处理 -//"DATE", "TIME", "TIMESTAMP" 作为时间处理 -//"CHAR", "VARCHAR"作为字符串处理 -//"BLOB" 作为字节流处理 -//"BOOLEAN" 作为布尔值处理 +// Scan 根据列类型读取数据 +// "INTEGER", "BIGINT", "SMALLINT"作为整形处理 +// "DOUBLE", "REAL", "DECIMAL"作为高精度实数处理 +// "DATE", "TIME", "TIMESTAMP" 作为时间处理 +// "CHAR", "VARCHAR"作为字符串处理 +// "BLOB" 作为字节流处理 +// "BOOLEAN" 作为布尔值处理 func (s *Scanner) Scan(src interface{}) (err error) { var cv element.ColumnValue byteSize := element.ByteSize(src) diff --git a/storage/database/db2/source.go b/storage/database/db2/source.go index 552816c..7d39680 100644 --- a/storage/database/db2/source.go +++ b/storage/database/db2/source.go @@ -23,27 +23,27 @@ func init() { database.RegisterDialect(d.Name(), d) } -//Dialect db2数据库方言 +// Dialect db2数据库方言 type Dialect struct{} -//Source 生成db2数据源 +// Source 生成db2数据源 func (d Dialect) Source(bs *database.BaseSource) (database.Source, error) { return NewSource(bs) } -//Name 数据库方言的注册名 +// Name 数据库方言的注册名 func (d Dialect) Name() string { return "db2" } -//Source db2数据源 +// Source db2数据源 type Source struct { *database.BaseSource //基础数据源 dsn string } -//NewSource 生成db2数据源，在配置文件错误时会报错 +// NewSource 生成db2数据源，在配置文件错误时会报错 func NewSource(bs *database.BaseSource) (s database.Source, err error) { source := &Source{ BaseSource: bs, @@ -59,27 +59,27 @@ func NewSource(bs *database.BaseSource) (s database.Source, err error) { return source, nil } -//DriverName github.com/ibmdb/go_ibm_db的驱动名 +// DriverName github.com/ibmdb/go_ibm_db的驱动名 func (s *Source) DriverName() string { return "go_ibm_db" } -//ConnectName github.com/ibmdb/go_ibm_db的数据源连接信息 +// ConnectName github.com/ibmdb/go_ibm_db的数据源连接信息 func (s *Source) ConnectName() string { return s.dsn } -//Key 数据源的关键字，用于DBWrapper的复用 +// Key 数据源的关键字，用于DBWrapper的复用 func (s *Source) Key() string { return s.dsn } -//Table 生成db2的表 +// Table 生成db2的表 func (s *Source) Table(b *database.BaseTable) database.Table { return NewTable(b) } -//Quoted db2引用函数 +// Quoted db2引用函数 func Quoted(s string) string { return `"` + s + `"` } diff --git a/storage/database/db2/table.go b/storage/database/db2/table.go index fe1dbe1..6250e26 100644 --- a/storage/database/db2/table.go +++ b/storage/database/db2/table.go @@ -23,19 +23,19 @@ import ( "github.com/pingcap/errors" ) -//Table db2表 +// Table db2表 type Table struct { *database.BaseTable } -//NewTable 创建db2表，注意此时BaseTable中的schema参数为空，instance为数据库名，而name是表明 +// NewTable 创建db2表，注意此时BaseTable中的schema参数为空，instance为数据库名，而name是表明 func NewTable(b *database.BaseTable) *Table { return &Table{ BaseTable: b, } } -//Quoted 表引用全名 +// Quoted 表引用全名 func (t *Table) Quoted() string { return Quoted(t.Schema()) + "." + Quoted(t.Name()) } @@ -44,22 +44,22 @@ func (t *Table) String() string { return t.Quoted() } -//AddField 新增列 +// AddField 新增列 func (t *Table) AddField(baseField *database.BaseField) { t.AppendField(NewField(baseField)) } -//ExecParam 获取执行参数 +// ExecParam 获取执行参数 func (t *Table) ExecParam(mode string, txOpts *sql.TxOptions) (database.Parameter, bool) { return nil, false } -//ShouldRetry 重试 +// ShouldRetry 重试 func (t *Table) ShouldRetry(err error) bool { return errors.Cause(err) == driver.ErrBadConn } -//ShouldOneByOne 单个重试 +// ShouldOneByOne 单个重试 func (t *Table) ShouldOneByOne(err error) bool { _, ok := errors.Cause(err).(*go_ibm_db.Error) return ok diff --git a/storage/database/db_wrapper.go b/storage/database/db_wrapper.go index c10dbbc..0600e52 100644 --- a/storage/database/db_wrapper.go +++ b/storage/database/db_wrapper.go @@ -24,14 +24,14 @@ import ( var dbMap = schedule.NewResourceMap() -//DBWrapper 数据库连接池包装，用于复用相关的数据库连接池(单元到实例：user) +// DBWrapper 数据库连接池包装，用于复用相关的数据库连接池(单元到实例：user) type DBWrapper struct { *DB close sync.Once } -//Open 通过数据库name和json配置conf 获取可以复用的数据库连接池包装,类似智能指针 +// Open 通过数据库name和json配置conf 获取可以复用的数据库连接池包装,类似智能指针 func Open(name string, conf *config.JSON) (dw *DBWrapper, err error) { var source Source if source, err = NewSource(name, conf); err != nil { @@ -56,7 +56,7 @@ func Open(name string, conf *config.JSON) (dw *DBWrapper, err error) { }, nil } -//Close 释放数据库连接池，如果有多个引用，则不会关闭该数据库连接池，没有引用时就直接关闭 +// Close 释放数据库连接池，如果有多个引用，则不会关闭该数据库连接池，没有引用时就直接关闭 func (d *DBWrapper) Close() (err error) { d.close.Do(func() { if d.DB != nil { diff --git a/storage/database/dialect.go b/storage/database/dialect.go index ddbaee3..1e1c845 100644 --- a/storage/database/dialect.go +++ b/storage/database/dialect.go @@ -19,7 +19,7 @@ import ( "sync" ) -//Dialect 数据库方言 +// Dialect 数据库方言 type Dialect interface { Source(*BaseSource) (Source, error) //数据源 } @@ -28,14 +28,14 @@ var dialects = &dialectMap{ dialects: make(map[string]Dialect), } -//RegisterDialect 注册数据库方言，当注册名称相同或者dialect为空时会panic +// RegisterDialect 注册数据库方言，当注册名称相同或者dialect为空时会panic func RegisterDialect(name string, dialect Dialect) { if err := dialects.register(name, dialect); err != nil { panic(err) } } -//UnregisterAllDialects 注销所有的数据库方言 +// UnregisterAllDialects 注销所有的数据库方言 func UnregisterAllDialects() { dialects.unregisterAll() } diff --git a/storage/database/doc.go b/storage/database/doc.go index 5eebd83..36f4897 100644 --- a/storage/database/doc.go +++ b/storage/database/doc.go @@ -15,24 +15,25 @@ // Package database 对实现标准库database/sql的接口的数据库进行封装 // 本包提供了DB作为数据库连接池来操作数据库 // DB可以通过FetchRecord来获得每一行的记录，例如数据库方言名为name,数据库配置文件为conf -// source, err := NewSource(name, conf) -// if err != nil { -// fmt.Println(err) -// return -// } -// db, err:= NewDB(source) -// if err != nil { -// fmt.Println(err) -// return -// } -// defer db.Close() -// t, err := db.FetchTable(context.TODO(), NewBaseTable("db", "schema", "table")) -// if err != nil { -// fmt.Println(err) -// return -// } -// var gotRecords []element.Record -// if err = db.FetchRecord(context.TODO(), NewTableQueryParam(t), NewBaseFetchHandler( +// +// source, err := NewSource(name, conf) +// if err != nil { +// fmt.Println(err) +// return +// } +// db, err:= NewDB(source) +// if err != nil { +// fmt.Println(err) +// return +// } +// defer db.Close() +// t, err := db.FetchTable(context.TODO(), NewBaseTable("db", "schema", "table")) +// if err != nil { +// fmt.Println(err) +// return +// } +// var gotRecords []element.Record +// if err = db.FetchRecord(context.TODO(), NewTableQueryParam(t), NewBaseFetchHandler( // func() (element.Record, error) { // return element.NewDefaultRecord(), nil // }, @@ -40,146 +41,173 @@ // gotRecords = append(gotRecords, r) // return nil // })); err != nil { -// fmt.Println(err) -// return -// } +// fmt.Println(err) +// return +// } +// // DB也可以通过BatchExec来批量处理数据 -// source, err := NewSource(name, conf) -// if err != nil { -// fmt.Println(err) -// return -// } -// db, err:= NewDB(source) -// if err != nil { -// fmt.Println(err) -// return -// } -// defer db.Close() -// t, err := db.FetchTable(context.TODO(), NewBaseTable("db", "schema", "table")) -// if err != nil { -// fmt.Println(err) -// return -// } -// columns := [][]element.Column{ -// { -// element.NewDefaultColumn(element.NewBoolColumnValue(false), "f1", 0), -// element.NewDefaultColumn(element.NewBigIntColumnValueFromInt64(1), "f2", 0), -// element.NewDefaultColumn(element.NewDecimalColumnValueFromFloat(1.0), "f3", 0), -// element.NewDefaultColumn(element.NewStringColumnValue("1"), "f4", 0), -// }, -// { -// element.NewDefaultColumn(element.NewBoolColumnValue(true), "f1", 0), -// element.NewDefaultColumn(element.NewBigIntColumnValueFromInt64(2), "f2", 0), -// element.NewDefaultColumn(element.NewDecimalColumnValueFromFloat(2.0), "f3", 0), -// element.NewDefaultColumn(element.NewStringColumnValue("2"), "f4", 0), -// }, -// } -// var wantRecords []element.Record -// for _, row := range columns { -// record := element.NewDefaultRecord() -// for _, c := range row { -// record.Add(c) -// } -// wantRecords = append(wantRecords, record) -// } -// if err = db.BatchExec(context.TODO(), &ParameterOptions{ -// Table: gotTable, -// TxOptions: nil, -// Mode: "insert", -// Records: wantRecords, -// }); err != nil { -// fmt.Println(err) -// return -// } +// +// source, err := NewSource(name, conf) +// if err != nil { +// fmt.Println(err) +// return +// } +// db, err:= NewDB(source) +// if err != nil { +// fmt.Println(err) +// return +// } +// defer db.Close() +// t, err := db.FetchTable(context.TODO(), NewBaseTable("db", "schema", "table")) +// if err != nil { +// fmt.Println(err) +// return +// } +// columns := [][]element.Column{ +// { +// element.NewDefaultColumn(element.NewBoolColumnValue(false), "f1", 0), +// element.NewDefaultColumn(element.NewBigIntColumnValueFromInt64(1), "f2", 0), +// element.NewDefaultColumn(element.NewDecimalColumnValueFromFloat(1.0), "f3", 0), +// element.NewDefaultColumn(element.NewStringColumnValue("1"), "f4", 0), +// }, +// { +// element.NewDefaultColumn(element.NewBoolColumnValue(true), "f1", 0), +// element.NewDefaultColumn(element.NewBigIntColumnValueFromInt64(2), "f2", 0), +// element.NewDefaultColumn(element.NewDecimalColumnValueFromFloat(2.0), "f3", 0), +// element.NewDefaultColumn(element.NewStringColumnValue("2"), "f4", 0), +// }, +// } +// var wantRecords []element.Record +// for _, row := range columns { +// record := element.NewDefaultRecord() +// for _, c := range row { +// record.Add(c) +// } +// wantRecords = append(wantRecords, record) +// } +// if err = db.BatchExec(context.TODO(), &ParameterOptions{ +// Table: gotTable, +// TxOptions: nil, +// Mode: "insert", +// Records: wantRecords, +// }); err != nil { +// fmt.Println(err) +// return +// } +// // DB也可以像sql.DB那样通过BeginTx，QueryContext，ExecContext去实现操作数据库的要求 // 另外database包提供了DBWrapper使得数据库连接池能够被复用 // 它实际上是DB的包装，为此它可以表现的和DB一样，例如 -// db, err:= Open(name, conf) -// if err != nil { -// fmt.Println(err) -// return -// } -// defer db.Close() -// t, err := db.FetchTable(context.TODO(), NewBaseTable("db", "schema", "table")) -// if err != nil { -// fmt.Println(err) -// return -// } +// +// db, err:= Open(name, conf) +// if err != nil { +// fmt.Println(err) +// return +// } +// defer db.Close() +// t, err := db.FetchTable(context.TODO(), NewBaseTable("db", "schema", "table")) +// if err != nil { +// fmt.Println(err) +// return +// } +// // 要使用上述特性，各类实现标准库database/sql的接口的数据库 // 通过RegisterDialect通过名字注册一下数据库方言接口 // 当然数据库配置文件要满足Config的格式 -// type Dialect interface { -// Source(*BaseSource) (Source, error) -// } +// +// type Dialect interface { +// Source(*BaseSource) (Source, error) +// } +// // 数据库方言接口主要是返回数据源接口 -// type Source interface { -// Config() *config.JSON //配置信息 -// Key() string //dbMap Key -// DriverName() string //驱动名，用于sql.Open -// ConnectName() string //连接信息，用于sql.Open -// Table(*BaseTable) Table //获取具体表 -// } +// +// type Source interface { +// Config() *config.JSON //配置信息 +// Key() string //dbMap Key +// DriverName() string //驱动名，用于sql.Open +// ConnectName() string //连接信息，用于sql.Open +// Table(*BaseTable) Table //获取具体表 +// } +// // 当然这里可以使用BaseSource来简化Source的实现 // 数据源接口返回对应的表 // Table 表结构 -// type Table interface { -// fmt.Stringer -// Quoted() string //引用的表名全称 -// Instance() string //实例名，例如对于mysql就是数据库，对于oracle就是实例 -// Schema() string //模式名，例如对于mysql就是数据库，对于oracle就是用户名 -// Name() string //表名，例如对于mysql就是表 -// Fields() []Field //显示所有列 -// } +// +// type Table interface { +// fmt.Stringer +// Quoted() string //引用的表名全称 +// Instance() string //实例名，例如对于mysql就是数据库，对于oracle就是实例 +// Schema() string //模式名，例如对于mysql就是数据库，对于oracle就是用户名 +// Name() string //表名，例如对于mysql就是表 +// Fields() []Field //显示所有列 +// } +// // 当Table一般实现基本的添加列接口用于FetchTable -// type FieldAdder interface { -// AddField(*BaseField) //新增具体列 -// } +// +// type FieldAdder interface { +// AddField(*BaseField) //新增具体列 +// } +// // 如果有特别的SQL获取列方式，则需要实现下列接口去获取 -// type FieldsFetcher interface { -// FetchFields(ctx context.Context, db *DB) error //获取具体列 -// } +// +// type FieldsFetcher interface { +// FetchFields(ctx context.Context, db *DB) error //获取具体列 +// } +// // 如果在批量处理数据时需要除了insert批量处理数据的语句，或者特殊的insert语句时,还需要实现下列接口 -// type ExecParameter interface { -// ExecParam(string, *sql.TxOptions) (Parameter, bool) -// } +// +// type ExecParameter interface { +// ExecParam(string, *sql.TxOptions) (Parameter, bool) +// } +// // 通过传入写入模式字符串以及事务选项获取执行参数 // 当然这里也可以使用BaseTable来简化Table的实现 // 每个表包含多列Field -// type Field interface { -// fmt.Stringer -// Name() string //字段名 -// Quoted() string //引用字段名 -// BindVar(int) string //占位符号 -// Select() string //select字段名 -// Type() FieldType //字段类型 -// Scanner() Scanner //扫描器 -// Valuer(element.Column) Valuer //赋值器 -// } +// +// type Field interface { +// fmt.Stringer +// Name() string //字段名 +// Quoted() string //引用字段名 +// BindVar(int) string //占位符号 +// Select() string //select字段名 +// Type() FieldType //字段类型 +// Scanner() Scanner //扫描器 +// Valuer(element.Column) Valuer //赋值器 +// } +// // 当然这里可以使用BaseField来简化Field的实现 // 这里接口FieldType时sql.ColumnType抽象，一般无需自己实现 // ，如有特殊的需求也可以实现这个接口用于自己的列类型 -// type FieldType interface { -// Name() string //列名 -// ScanType() reflect.Type //扫描类型 -// Length() (length int64, ok bool) //长度 -// DecimalSize() (precision, scale int64, ok bool) //精度 -// Nullable() (nullable, ok bool) //是否为空 -// DatabaseTypeName() string //列数据库类型名 -// } +// +// type FieldType interface { +// Name() string //列名 +// ScanType() reflect.Type //扫描类型 +// Length() (length int64, ok bool) //长度 +// DecimalSize() (precision, scale int64, ok bool) //精度 +// Nullable() (nullable, ok bool) //是否为空 +// DatabaseTypeName() string //列数据库类型名 +// } +// // 扫描器接口Scanner是将数据库驱动底层的数据转化成列Column类型，用于读取数据 -// type Scanner interface { -// sql.Scanner -// Column() element.Column //获取列数据 -// } +// +// type Scanner interface { +// sql.Scanner +// Column() element.Column //获取列数据 +// } +// // 当然这里可以使用BaseScanner来简化Scanner的实现 // 赋值器接口Valuer是将列Column数据库转化成驱动底层的数据，用于处理数据 -// type Valuer interface { -// driver.Valuer -// } +// +// type Valuer interface { +// driver.Valuer +// } +// // 特别地，如果使用GoValuer来作为赋值器Valuer的简单实现 // 那么需要在FieldType的基础上简单实现下列接口就可以实现对应的Valuer -// type ValuerGoType interface { -// GoType() GoType -// } +// +// type ValuerGoType interface { +// GoType() GoType +// } +// // 通过上述内容的实现，我们就可以愉快的使用数据库 package database diff --git a/storage/database/field.go b/storage/database/field.go index a722571..df330ff 100644 --- a/storage/database/field.go +++ b/storage/database/field.go @@ -24,15 +24,15 @@ import ( "github.com/Breeze0806/go-etl/element" ) -//GoType golang的类型 +// GoType golang的类型 type GoType uint8 -//字段错误相关 +// 字段错误相关 var ( ErrNotValuerGoType = errors.New("field type is not ValuerGoType") //接口不是ValuerGoType的错误 ) -//golang的类型枚举 +// golang的类型枚举 const ( GoTypeUnknown GoType = iota //未知类型 GoTypeBool //布尔类型 @@ -43,7 +43,7 @@ const ( GoTypeTime //时间类型 ) -//golang的类型枚举字符串 +// golang的类型枚举字符串 var goTypeMap = map[GoType]string{ GoTypeUnknown: "unknow", GoTypeBool: "bool", @@ -54,7 +54,7 @@ var goTypeMap = map[GoType]string{ GoTypeTime: "time", } -//String golang的类型枚举字符串描述 +// String golang的类型枚举字符串描述 func (t GoType) String() string { if s, ok := goTypeMap[t]; ok { return s @@ -62,7 +62,7 @@ func (t GoType) String() string { return "unknow" } -//Field 数据库字段 +// Field 数据库字段 type Field interface { fmt.Stringer @@ -76,19 +76,19 @@ type Field interface { Valuer(element.Column) Valuer //赋值器 } -//Scanner 列数据扫描器 数据库驱动的值扫描成列数据 +// Scanner 列数据扫描器 数据库驱动的值扫描成列数据 type Scanner interface { sql.Scanner Column() element.Column //获取列数据 } -//Valuer 赋值器 将对应数据转化成数据库驱动的值 +// Valuer 赋值器 将对应数据转化成数据库驱动的值 type Valuer interface { driver.Valuer } -//ColumnType 列类型,抽象 sql.ColumnType，也方便自行实现对应函数 +// ColumnType 列类型,抽象 sql.ColumnType，也方便自行实现对应函数 type ColumnType interface { Name() string //列名 ScanType() reflect.Type //扫描类型 @@ -98,28 +98,28 @@ type ColumnType interface { DatabaseTypeName() string //列数据库类型名 } -//FieldType 字段类型 +// FieldType 字段类型 type FieldType interface { ColumnType IsSupportted() bool //是否支持 } -//ValuerGoType 用于赋值器的golang类型判定,是Field的可选功能， -//就是对对应驱动的值返回相应的值，方便GoValuer进行判定 +// ValuerGoType 用于赋值器的golang类型判定,是Field的可选功能， +// 就是对对应驱动的值返回相应的值，方便GoValuer进行判定 type ValuerGoType interface { GoType() GoType } -//BaseField 基础字段，主要存储列名name和列类型fieldType +// BaseField 基础字段，主要存储列名name和列类型fieldType type BaseField struct { index int name string fieldType FieldType } -//NewBaseField 根据列名name和列类型fieldType获取基础字段 -//用于嵌入其他Field，方便实现各个数据库的Field +// NewBaseField 根据列名name和列类型fieldType获取基础字段 +// 用于嵌入其他Field，方便实现各个数据库的Field func NewBaseField(index int, name string, fieldType FieldType) *BaseField { return &BaseField{ index: index, @@ -128,66 +128,66 @@ func NewBaseField(index int, name string, fieldType FieldType) *BaseField { } } -//Index 返回字段名 +// Index 返回字段名 func (b *BaseField) Index() int { return b.index } -//Name 返回字段名 +// Name 返回字段名 func (b *BaseField) Name() string { return b.name } -//FieldType 返回字段类型 +// FieldType 返回字段类型 func (b *BaseField) FieldType() FieldType { return b.fieldType } -//String 打印时显示字符串 +// String 打印时显示字符串 func (b *BaseField) String() string { return b.name } -//BaseFieldType 基础字段类型，嵌入其他各种数据库字段类型实现 +// BaseFieldType 基础字段类型，嵌入其他各种数据库字段类型实现 type BaseFieldType struct { ColumnType } -//NewBaseFieldType 获取字段类型 +// NewBaseFieldType 获取字段类型 func NewBaseFieldType(typ ColumnType) *BaseFieldType { return &BaseFieldType{ ColumnType: typ, } } -//IsSupportted 是否支持被解析 +// IsSupportted 是否支持被解析 func (*BaseFieldType) IsSupportted() bool { return true } -//BaseScanner 基础扫描器，嵌入其他各种数据库扫描器实现 +// BaseScanner 基础扫描器，嵌入其他各种数据库扫描器实现 type BaseScanner struct { c element.Column } -//SetColumn 设置列值，用于数据库方言的列数据设置 +// SetColumn 设置列值，用于数据库方言的列数据设置 func (b *BaseScanner) SetColumn(c element.Column) { b.c = c } -//Column 取得列值，方便统一取得列值 +// Column 取得列值，方便统一取得列值 func (b *BaseScanner) Column() element.Column { return b.c } -//GoValuer 使用GoType类型生成赋值器，主要通过字段f和传入参数列值c来 -//完成使用GoType类型生成赋值器,方便实现GoValuer +// GoValuer 使用GoType类型生成赋值器，主要通过字段f和传入参数列值c来 +// 完成使用GoType类型生成赋值器,方便实现GoValuer type GoValuer struct { f Field c element.Column } -//NewGoValuer 主要通过字段f和传入参数列值c来完成使用GoType类型生成赋值器的生成 +// NewGoValuer 主要通过字段f和传入参数列值c来完成使用GoType类型生成赋值器的生成 func NewGoValuer(f Field, c element.Column) *GoValuer { return &GoValuer{ f: f, @@ -195,7 +195,7 @@ func NewGoValuer(f Field, c element.Column) *GoValuer { } } -//Value 根据ValuerGoType生成对应的驱动接受的值 +// Value 根据ValuerGoType生成对应的驱动接受的值 func (g *GoValuer) Value() (driver.Value, error) { typ, ok := g.f.Type().(ValuerGoType) if !ok { diff --git a/storage/database/mysql/config.go b/storage/database/mysql/config.go index 1bf73da..8af1ff3 100644 --- a/storage/database/mysql/config.go +++ b/storage/database/mysql/config.go @@ -21,14 +21,14 @@ import ( "github.com/go-sql-driver/mysql" ) -//Config mysql配置，读入的时间都需要解析即parseTime=true +// Config mysql配置，读入的时间都需要解析即parseTime=true type Config struct { URL string `json:"url"` //数据库url，包含数据库地址，数据库其他参数 Username string `json:"username"` //用户名 Password string `json:"password"` //密码 } -//NewConfig 创建mysql配置，如果格式不符合要求，就会报错 +// NewConfig 创建mysql配置，如果格式不符合要求，就会报错 func NewConfig(conf *config.JSON) (c *Config, err error) { c = &Config{} err = json.Unmarshal([]byte(conf.String()), c) @@ -38,7 +38,7 @@ func NewConfig(conf *config.JSON) (c *Config, err error) { return } -//FetchMysqlConfig 获取生成Mysql连接配置，url有错会报错 +// FetchMysqlConfig 获取生成Mysql连接配置，url有错会报错 func (c *Config) FetchMysqlConfig() (conf *mysql.Config, err error) { if conf, err = mysql.ParseDSN(c.URL); err != nil { return diff --git a/storage/database/mysql/field.go b/storage/database/mysql/field.go index 3c4b2fb..08d4624 100644 --- a/storage/database/mysql/field.go +++ b/storage/database/mysql/field.go @@ -28,56 +28,56 @@ var ( datetimeLayout = element.DefaultTimeFormat[:26] ) -//Field 字段 +// Field 字段 type Field struct { *database.BaseField } -//NewField 通过基本列属性生成字段 +// NewField 通过基本列属性生成字段 func NewField(bf *database.BaseField) *Field { return &Field{ BaseField: bf, } } -//Quoted 引用，用于SQL语句 +// Quoted 引用，用于SQL语句 func (f *Field) Quoted() string { return Quoted(f.Name()) } -//BindVar SQL占位符，用于SQL语句 +// BindVar SQL占位符，用于SQL语句 func (f *Field) BindVar(_ int) string { return "?" } -//Select 查询时字段，用于SQL查询语句 +// Select 查询时字段，用于SQL查询语句 func (f *Field) Select() string { return Quoted(f.Name()) } -//Type 字段类型 +// Type 字段类型 func (f *Field) Type() database.FieldType { return NewFieldType(f.FieldType()) } -//Scanner 扫描器，用于读取数据 +// Scanner 扫描器，用于读取数据 func (f *Field) Scanner() database.Scanner { return NewScanner(f) } -//Valuer 赋值器，采用GoValuer处理数据 +// Valuer 赋值器，采用GoValuer处理数据 func (f *Field) Valuer(c element.Column) database.Valuer { return database.NewGoValuer(f, c) } -//FieldType 字段类型 +// FieldType 字段类型 type FieldType struct { *database.BaseFieldType goType database.GoType } -//NewFieldType 创建新的字段类型 +// NewFieldType 创建新的字段类型 func NewFieldType(typ database.ColumnType) *FieldType { f := &FieldType{ BaseFieldType: database.NewBaseFieldType(typ), @@ -101,35 +101,35 @@ func NewFieldType(typ database.ColumnType) *FieldType { return f } -//IsSupportted 是否支持解析 +// IsSupportted 是否支持解析 func (f *FieldType) IsSupportted() bool { return f.GoType() != database.GoTypeUnknown } -//GoType 返回处理数值时的Golang类型 +// GoType 返回处理数值时的Golang类型 func (f *FieldType) GoType() database.GoType { return f.goType } -//Scanner 扫描器 +// Scanner 扫描器 type Scanner struct { f *Field database.BaseScanner } -//NewScanner 根据列类型生成扫描器 +// NewScanner 根据列类型生成扫描器 func NewScanner(f *Field) *Scanner { return &Scanner{ f: f, } } -//Scan 根据列类型读取数据 -//"MEDIUMINT", "INT", "BIGINT", "SMALLINT", "TINYINT", "YEAR"作为整形处理 -//"DOUBLE", "FLOAT", "DECIMAL"作为高精度实数处理 -//"DATE", "DATETIME", "TIMESTAMP" 作为时间处理 -//"TEXT", "LONGTEXT", "MEDIUMTEXT", "TINYTEXT", "CHAR", "VARCHAR", "TIME"作为字符串处理 -//"BLOB", "LONGBLOB", "MEDIUMBLOB", "BINARY", "TINYBLOB", "VARBINARY"作为字节流处理 +// Scan 根据列类型读取数据 +// "MEDIUMINT", "INT", "BIGINT", "SMALLINT", "TINYINT", "YEAR"作为整形处理 +// "DOUBLE", "FLOAT", "DECIMAL"作为高精度实数处理 +// "DATE", "DATETIME", "TIMESTAMP" 作为时间处理 +// "TEXT", "LONGTEXT", "MEDIUMTEXT", "TINYTEXT", "CHAR", "VARCHAR", "TIME"作为字符串处理 +// "BLOB", "LONGBLOB", "MEDIUMBLOB", "BINARY", "TINYBLOB", "VARBINARY"作为字节流处理 func (s *Scanner) Scan(src interface{}) (err error) { var cv element.ColumnValue byteSize := element.ByteSize(src) diff --git a/storage/database/mysql/source.go b/storage/database/mysql/source.go index cec8b3b..aaaff40 100644 --- a/storage/database/mysql/source.go +++ b/storage/database/mysql/source.go @@ -26,20 +26,20 @@ func init() { database.RegisterDialect(d.Name(), d) } -//Dialect mysql数据库方言 +// Dialect mysql数据库方言 type Dialect struct{} -//Source 生产数据源 +// Source 生产数据源 func (d Dialect) Source(bs *database.BaseSource) (database.Source, error) { return NewSource(bs) } -//Name 数据库方言的注册名 +// Name 数据库方言的注册名 func (d Dialect) Name() string { return "mysql" } -//Source mysql数据源 +// Source mysql数据源 type Source struct { *database.BaseSource //基础数据源 @@ -47,7 +47,7 @@ type Source struct { mysqlConf *mysql.Config } -//NewSource 生成mysql数据源，在配置文件错误时会报错 +// NewSource 生成mysql数据源，在配置文件错误时会报错 func NewSource(bs *database.BaseSource) (s database.Source, err error) { source := &Source{ BaseSource: bs, @@ -64,32 +64,32 @@ func NewSource(bs *database.BaseSource) (s database.Source, err error) { return source, nil } -//DriverName github.com/go-sql-driver/mysql的驱动名 +// DriverName github.com/go-sql-driver/mysql的驱动名 func (s *Source) DriverName() string { return "mysql" } -//ConnectName github.com/go-sql-driver/mysql的数据源连接信息 +// ConnectName github.com/go-sql-driver/mysql的数据源连接信息 func (s *Source) ConnectName() string { return s.dsn } -//Key 数据源的关键字，用于DBWrapper的复用 +// Key 数据源的关键字，用于DBWrapper的复用 func (s *Source) Key() string { return s.dsn } -//Table 生成mysql的表 +// Table 生成mysql的表 func (s *Source) Table(b *database.BaseTable) database.Table { return NewTable(b) } -//Connector github.com/go-sql-driver/mysql的数据源连接器 +// Connector github.com/go-sql-driver/mysql的数据源连接器 func (s *Source) Connector() (driver.Connector, error) { return mysql.NewConnector(s.mysqlConf) } -//Quoted mysql引用函数 +// Quoted mysql引用函数 func Quoted(s string) string { return "`" + s + "`" } diff --git a/storage/database/mysql/table.go b/storage/database/mysql/table.go index eb1ae5c..e5b8ff9 100644 --- a/storage/database/mysql/table.go +++ b/storage/database/mysql/table.go @@ -27,22 +27,22 @@ import ( "github.com/pingcap/errors" ) -//WriteModeReplace replace into 写入方式 +// WriteModeReplace replace into 写入方式 const WriteModeReplace = "replace" -//Table mysql表 +// Table mysql表 type Table struct { *database.BaseTable } -//NewTable 创建mysql表，注意此时BaseTable中的schema参数为空，instance为数据库名，而name是表明 +// NewTable 创建mysql表，注意此时BaseTable中的schema参数为空，instance为数据库名，而name是表明 func NewTable(b *database.BaseTable) *Table { return &Table{ BaseTable: b, } } -//Quoted 表引用全名 +// Quoted 表引用全名 func (t *Table) Quoted() string { return Quoted(t.Instance()) + "." + Quoted(t.Name()) } @@ -51,12 +51,12 @@ func (t *Table) String() string { return t.Quoted() } -//AddField 新增列 +// AddField 新增列 func (t *Table) AddField(baseField *database.BaseField) { t.AppendField(NewField(baseField)) } -//ExecParam 获取执行参数，其中replace into的参数方式以及被注册 +// ExecParam 获取执行参数，其中replace into的参数方式以及被注册 func (t *Table) ExecParam(mode string, txOpts *sql.TxOptions) (database.Parameter, bool) { switch mode { case "replace": @@ -65,7 +65,7 @@ func (t *Table) ExecParam(mode string, txOpts *sql.TxOptions) (database.Paramete return nil, false } -//ShouldRetry 重试 +// ShouldRetry 重试 func (t *Table) ShouldRetry(err error) bool { switch cause := errors.Cause(err).(type) { case net.Error: @@ -75,25 +75,25 @@ func (t *Table) ShouldRetry(err error) bool { } } -//ShouldOneByOne 单个重试 +// ShouldOneByOne 单个重试 func (t *Table) ShouldOneByOne(err error) bool { _, ok := errors.Cause(err).(*mysql.MySQLError) return ok } -//ReplaceParam Replace into 参数 +// ReplaceParam Replace into 参数 type ReplaceParam struct { *database.BaseParam } -//NewReplaceParam 通过表table和事务参数txOpts插入参数 +// NewReplaceParam 通过表table和事务参数txOpts插入参数 func NewReplaceParam(t database.Table, txOpts *sql.TxOptions) *ReplaceParam { return &ReplaceParam{ BaseParam: database.NewBaseParam(t, txOpts), } } -//Query 通过多条记录 records生成批量Replace into插入sql语句 +// Query 通过多条记录 records生成批量Replace into插入sql语句 func (rp *ReplaceParam) Query(records []element.Record) (query string, err error) { buf := bytes.NewBufferString("replace into ") buf.WriteString(rp.Table().Quoted()) @@ -123,7 +123,7 @@ func (rp *ReplaceParam) Query(records []element.Record) (query string, err error return buf.String(), nil } -//Agrs 通过多条记录 records生成批量Replace into参数 +// Agrs 通过多条记录 records生成批量Replace into参数 func (rp *ReplaceParam) Agrs(records []element.Record) (valuers []interface{}, err error) { for _, r := range records { for fi, f := range rp.Table().Fields() { diff --git a/storage/database/oracle/config.go b/storage/database/oracle/config.go index 3ebffc8..32fce65 100644 --- a/storage/database/oracle/config.go +++ b/storage/database/oracle/config.go @@ -21,14 +21,14 @@ import ( "github.com/godror/godror" ) -//Config 配置 +// Config 配置 type Config struct { URL string `json:"url"` //数据库url，包含数据库地址，数据库其他参数 Username string `json:"username"` //用户名 Password string `json:"password"` //密码 } -//NewConfig 创建oracle配置，如果格式不符合要求，就会报错 +// NewConfig 创建oracle配置，如果格式不符合要求，就会报错 func NewConfig(conf *config.JSON) (c *Config, err error) { c = &Config{} err = json.Unmarshal([]byte(conf.String()), c) @@ -38,7 +38,7 @@ func NewConfig(conf *config.JSON) (c *Config, err error) { return } -//FetchConnectionParams 获取oracle连接参数，url有错会报错 +// FetchConnectionParams 获取oracle连接参数，url有错会报错 func (c *Config) FetchConnectionParams() (con godror.ConnectionParams, err error) { if con, err = godror.ParseDSN(c.URL); err != nil { return diff --git a/storage/database/oracle/doc.go b/storage/database/oracle/doc.go index 2576d62..0e96235 100644 --- a/storage/database/oracle/doc.go +++ b/storage/database/oracle/doc.go @@ -12,5 +12,5 @@ // See the License for the specific language governing permissions and // limitations under the License. -//Package oracle 实现了oracle的数据库方言Dialect，支持oracle 10.5+ 对应数据库 +// Package oracle 实现了oracle的数据库方言Dialect，支持oracle 10.5+ 对应数据库 package oracle diff --git a/storage/database/oracle/field.go b/storage/database/oracle/field.go index 3368aeb..8cf1d62 100644 --- a/storage/database/oracle/field.go +++ b/storage/database/oracle/field.go @@ -32,24 +32,24 @@ var ( datetimeLayout = element.DefaultTimeFormat[:26] ) -//Field 字段 +// Field 字段 type Field struct { *database.BaseField } -//NewField 通过基本列属性生成字段 +// NewField 通过基本列属性生成字段 func NewField(bf *database.BaseField) *Field { return &Field{ BaseField: bf, } } -//Quoted 引用，用于SQL语句 +// Quoted 引用，用于SQL语句 func (f *Field) Quoted() string { return Quoted(f.Name()) } -//BindVar SQL占位符，用于SQL语句 +// BindVar SQL占位符，用于SQL语句 func (f *Field) BindVar(i int) string { //解决时间格式错误ORA-01861: literal does not match format string switch f.FieldType().DatabaseTypeName() { @@ -62,40 +62,40 @@ func (f *Field) BindVar(i int) string { return ":" + strconv.Itoa(i) } -//Select 查询时字段，用于SQL查询语句 +// Select 查询时字段，用于SQL查询语句 func (f *Field) Select() string { return Quoted(f.Name()) } -//Type 字段类型 +// Type 字段类型 func (f *Field) Type() database.FieldType { return NewFieldType(f.FieldType()) } -//Scanner 扫描器，用于读取数据 +// Scanner 扫描器，用于读取数据 func (f *Field) Scanner() database.Scanner { return NewScanner(f) } -//Valuer 赋值器，采用GoValuer处理数据 +// Valuer 赋值器，采用GoValuer处理数据 func (f *Field) Valuer(c element.Column) database.Valuer { return NewValuer(f, c) } -//FieldType 字段类型 +// FieldType 字段类型 type FieldType struct { *database.BaseFieldType supportted bool } -//NewFieldType 创建新的字段类型 +// NewFieldType 创建新的字段类型 func NewFieldType(typ database.ColumnType) *FieldType { f := &FieldType{ BaseFieldType: database.NewBaseFieldType(typ), } switch f.DatabaseTypeName() { - //由于oracle特殊的转化机制导致所有的数据需要转化为string类型进行插入 + case "BOOLEAN", "BINARY_INTEGER", "NUMBER", "FLOAT", "DOUBLE", @@ -107,25 +107,25 @@ func NewFieldType(typ database.ColumnType) *FieldType { return f } -//IsSupportted 是否支持解析 +// IsSupportted 是否支持解析 func (f *FieldType) IsSupportted() bool { return f.supportted } -//Scanner 扫描器 +// Scanner 扫描器 type Scanner struct { f *Field database.BaseScanner } -//NewScanner 根据列类型生成扫描器 +// NewScanner 根据列类型生成扫描器 func NewScanner(f *Field) *Scanner { return &Scanner{ f: f, } } -//Scan 根据列类型读取数据 +// Scan 根据列类型读取数据 // "BOOLEAN" 做为bool类型处理 // "BINARY_INTEGER" 做为bigint类型处理 // "NUMBER", "FLOAT", "DOUBLE" 做为decimal类型处理 @@ -158,7 +158,8 @@ func (s *Scanner) Scan(src interface{}) (err error) { return fmt.Errorf("src is %v(%T), but not %v", src, src, element.TypeBigInt) } //todo test BFILE - case "BLOB", "LONG", "RAW", "LONG RAW": + case //"BFILE", + "BLOB", "LONG", "RAW", "LONG RAW": switch data := src.(type) { case nil: cv = element.NewNilBytesColumnValue() @@ -232,13 +233,13 @@ func (s *Scanner) Scan(src interface{}) (err error) { return } -//Valuer 赋值器 +// Valuer 赋值器 type Valuer struct { f *Field c element.Column } -//NewValuer 创建新赋值器 +// NewValuer 创建新赋值器 func NewValuer(f *Field, c element.Column) *Valuer { return &Valuer{ f: f, @@ -246,11 +247,11 @@ func NewValuer(f *Field, c element.Column) *Valuer { } } -//Value 赋值 +// Value 赋值 func (v *Valuer) Value() (value driver.Value, err error) { - switch v.f.Type().DatabaseTypeName() { case "BOOLEAN": + //在oracle中插入空字符居然是nil对应NULL if v.c.IsNil() { return "", nil } @@ -262,15 +263,19 @@ func (v *Valuer) Value() (value driver.Value, err error) { return "1", nil } return "0", nil - case "BFILE", "BLOB", "LONG", "RAW", "LONG RAW": + //todo test BFILE + case //"BFILE", + "BLOB", "LONG", "RAW", "LONG RAW": + //竞优这些类型插入的nil对应NULL if v.c.IsNil() { return nil, nil } return v.c.AsBytes() } - + //在oracle中插入空字符居然是nil对应NULL if v.c.IsNil() { return "", nil } + //由于oracle特殊的转化机制导致所有的数据需要转化为string类型进行插入 return v.c.AsString() } diff --git a/storage/database/oracle/source.go b/storage/database/oracle/source.go index 12498b2..65ff37e 100644 --- a/storage/database/oracle/source.go +++ b/storage/database/oracle/source.go @@ -24,27 +24,27 @@ func init() { database.RegisterDialect(d.Name(), d) } -//Dialect oracle数据库方言 +// Dialect oracle数据库方言 type Dialect struct{} -//Source 生成oracle数据源 +// Source 生成oracle数据源 func (d Dialect) Source(bs *database.BaseSource) (database.Source, error) { return NewSource(bs) } -//Name 数据库方言的注册名 +// Name 数据库方言的注册名 func (d Dialect) Name() string { return "oracle" } -//Source oracle数据源 +// Source oracle数据源 type Source struct { *database.BaseSource //基础数据源 dsn string } -//NewSource 生成oracle数据源，在配置文件错误时会报错 +// NewSource 生成oracle数据源，在配置文件错误时会报错 func NewSource(bs *database.BaseSource) (s database.Source, err error) { source := &Source{ BaseSource: bs, @@ -61,27 +61,27 @@ func NewSource(bs *database.BaseSource) (s database.Source, err error) { return source, nil } -//DriverName github.com/godror/godror的驱动名 +// DriverName github.com/godror/godror的驱动名 func (s *Source) DriverName() string { return "godror" } -//ConnectName github.com/godror/godror的数据源连接信息 +// ConnectName github.com/godror/godror的数据源连接信息 func (s *Source) ConnectName() string { return s.dsn } -//Key 数据源的关键字，用于DBWrapper的复用 +// Key 数据源的关键字，用于DBWrapper的复用 func (s *Source) Key() string { return s.dsn } -//Table 生成oracle的表 +// Table 生成oracle的表 func (s *Source) Table(b *database.BaseTable) database.Table { return NewTable(b) } -//Quoted db2引用函数 +// Quoted db2引用函数 func Quoted(s string) string { return `"` + s + `"` } diff --git a/storage/database/oracle/table.go b/storage/database/oracle/table.go index 3acd443..2c3ec8d 100644 --- a/storage/database/oracle/table.go +++ b/storage/database/oracle/table.go @@ -26,22 +26,22 @@ import ( "github.com/pingcap/errors" ) -//WriteModeInsert intert into 写入方式 +// WriteModeInsert intert into 写入方式 const WriteModeInsert = "insert" -//Table oracle表 +// Table oracle表 type Table struct { *database.BaseTable } -//NewTable 创建oracle表，注意此时BaseTable中的schema参数为空，instance为数据库名，而name是表明 +// NewTable 创建oracle表，注意此时BaseTable中的schema参数为空，instance为数据库名，而name是表明 func NewTable(b *database.BaseTable) *Table { return &Table{ BaseTable: b, } } -//Quoted 表引用全名 +// Quoted 表引用全名 func (t *Table) Quoted() string { return Quoted(t.Schema()) + "." + Quoted(t.Name()) } @@ -50,12 +50,12 @@ func (t *Table) String() string { return t.Quoted() } -//AddField 新增列 +// AddField 新增列 func (t *Table) AddField(baseField *database.BaseField) { t.AppendField(NewField(baseField)) } -//ExecParam 获取执行参数，其中replace into的参数方式以及被注册 +// ExecParam 获取执行参数，其中replace into的参数方式以及被注册 func (t *Table) ExecParam(mode string, txOpts *sql.TxOptions) (database.Parameter, bool) { switch mode { case WriteModeInsert: @@ -64,30 +64,30 @@ func (t *Table) ExecParam(mode string, txOpts *sql.TxOptions) (database.Paramete return nil, false } -//ShouldRetry 重试 +// ShouldRetry 重试 func (t *Table) ShouldRetry(err error) bool { return godror.IsBadConn(errors.Cause(err)) } -//ShouldOneByOne 单个重试 +// ShouldOneByOne 单个重试 func (t *Table) ShouldOneByOne(err error) bool { _, ok := errors.Cause(err).(*godror.OraErr) return ok && !godror.IsBadConn(err) } -//InsertParam Insert into 参数 +// InsertParam Insert into 参数 type InsertParam struct { *database.BaseParam } -//NewInsertParam 通过表table和事务参数txOpts插入参数 +// NewInsertParam 通过表table和事务参数txOpts插入参数 func NewInsertParam(t database.Table, txOpts *sql.TxOptions) *InsertParam { return &InsertParam{ BaseParam: database.NewBaseParam(t, txOpts), } } -//Query 通过多条记录 records生成批量insert into插入sql语句 +// Query 通过多条记录 records生成批量insert into插入sql语句 func (ip *InsertParam) Query(_ []element.Record) (query string, err error) { buf := bytes.NewBufferString("insert into ") buf.WriteString(ip.Table().Quoted()) @@ -112,7 +112,7 @@ func (ip *InsertParam) Query(_ []element.Record) (query string, err error) { return buf.String(), nil } -//Agrs 通过多条记录 records生成批量insert into参数 +// Agrs 通过多条记录 records生成批量insert into参数 func (ip *InsertParam) Agrs(records []element.Record) (valuers []interface{}, err error) { for fi, f := range ip.Table().Fields() { var ba [][]byte diff --git a/storage/database/postgres/config.go b/storage/database/postgres/config.go index 599507c..3a68185 100644 --- a/storage/database/postgres/config.go +++ b/storage/database/postgres/config.go @@ -21,14 +21,14 @@ import ( "github.com/Breeze0806/go-etl/config" ) -//Config postgres配置 +// Config postgres配置 type Config struct { URL string `json:"url"` //数据库url，包含数据库地址，数据库其他参数 Username string `json:"username"` //用户名 Password string `json:"password"` //密码 } -//NewConfig 创建postgres配置，如果格式不符合要求，就会报错 +// NewConfig 创建postgres配置，如果格式不符合要求，就会报错 func NewConfig(conf *config.JSON) (c *Config, err error) { c = &Config{} err = json.Unmarshal([]byte(conf.String()), c) @@ -38,7 +38,7 @@ func NewConfig(conf *config.JSON) (c *Config, err error) { return } -//FormatDSN 生成数据源连接信息，url有错会报错 +// FormatDSN 生成数据源连接信息，url有错会报错 func (c *Config) FormatDSN() (dsn string, err error) { var URL *url.URL URL, err = url.Parse(c.URL) diff --git a/storage/database/postgres/field.go b/storage/database/postgres/field.go index 5405c18..d9b23c1 100644 --- a/storage/database/postgres/field.go +++ b/storage/database/postgres/field.go @@ -29,56 +29,56 @@ var ( timestampLayout = element.DefaultTimeFormat[:26] ) -//Field 字段 +// Field 字段 type Field struct { *database.BaseField } -//NewField 通过基本列属性生成字段 +// NewField 通过基本列属性生成字段 func NewField(bf *database.BaseField) *Field { return &Field{ BaseField: bf, } } -//Quoted 引用，用于SQL语句 +// Quoted 引用，用于SQL语句 func (f *Field) Quoted() string { return Quoted(f.Name()) } -//BindVar SQL占位符，用于SQL语句 +// BindVar SQL占位符，用于SQL语句 func (f *Field) BindVar(i int) string { return "$" + strconv.Itoa(i) } -//Select 查询时字段，用于SQL查询语句 +// Select 查询时字段，用于SQL查询语句 func (f *Field) Select() string { return f.Quoted() } -//Type 字段类型 +// Type 字段类型 func (f *Field) Type() database.FieldType { return NewFieldType(f.FieldType()) } -//Scanner 扫描器，用于读取数据 +// Scanner 扫描器，用于读取数据 func (f *Field) Scanner() database.Scanner { return NewScanner(f) } -//Valuer 赋值器，采用GoValuer处理数据 +// Valuer 赋值器，采用GoValuer处理数据 func (f *Field) Valuer(c element.Column) database.Valuer { return database.NewGoValuer(f, c) } -//FieldType 字段类型 +// FieldType 字段类型 type FieldType struct { *database.BaseFieldType goType database.GoType } -//NewFieldType 创建新的字段类型 +// NewFieldType 创建新的字段类型 func NewFieldType(typ database.ColumnType) *FieldType { f := &FieldType{ BaseFieldType: database.NewBaseFieldType(typ), @@ -104,31 +104,31 @@ func NewFieldType(typ database.ColumnType) *FieldType { return f } -//IsSupportted 是否支持解析 +// IsSupportted 是否支持解析 func (f *FieldType) IsSupportted() bool { return f.GoType() != database.GoTypeUnknown } -//GoType 返回处理数值时的Golang类型 +// GoType 返回处理数值时的Golang类型 func (f *FieldType) GoType() database.GoType { return f.goType } -//Scanner 扫描器 +// Scanner 扫描器 type Scanner struct { database.BaseScanner f *Field } -//NewScanner 根据列类型生成扫描器 +// NewScanner 根据列类型生成扫描器 func NewScanner(f *Field) *Scanner { return &Scanner{ f: f, } } -//Scan 根据列类型读取数据 +// Scan 根据列类型读取数据 func (s *Scanner) Scan(src interface{}) (err error) { var cv element.ColumnValue byteSize := element.ByteSize(src) diff --git a/storage/database/postgres/source.go b/storage/database/postgres/source.go index f8584eb..1f21fb0 100644 --- a/storage/database/postgres/source.go +++ b/storage/database/postgres/source.go @@ -27,27 +27,27 @@ func init() { database.RegisterDialect(d.Name(), d) } -//Dialect postgres数据库方言 +// Dialect postgres数据库方言 type Dialect struct{} -//Source 生成postgres数据源 +// Source 生成postgres数据源 func (d Dialect) Source(bs *database.BaseSource) (database.Source, error) { return NewSource(bs) } -//Name 数据库方言的注册名 +// Name 数据库方言的注册名 func (d Dialect) Name() string { return "postgres" } -//Source postgres数据源 +// Source postgres数据源 type Source struct { *database.BaseSource //基础数据源 dsn string } -//NewSource 生成postgres数据源，在配置文件错误时会报错 +// NewSource 生成postgres数据源，在配置文件错误时会报错 func NewSource(bs *database.BaseSource) (s database.Source, err error) { source := &Source{ BaseSource: bs, @@ -63,27 +63,27 @@ func NewSource(bs *database.BaseSource) (s database.Source, err error) { return source, nil } -//DriverName github.com/Breeze0806/go/database/pqto的驱动名 +// DriverName github.com/Breeze0806/go/database/pqto的驱动名 func (s *Source) DriverName() string { return "pgTimeout" } -//ConnectName github.com/Breeze0806/go/database/pqto的数据源连接信息 +// ConnectName github.com/Breeze0806/go/database/pqto的数据源连接信息 func (s *Source) ConnectName() string { return s.dsn } -//Key 数据源的关键字，用于DBWrapper的复用 +// Key 数据源的关键字，用于DBWrapper的复用 func (s *Source) Key() string { return s.dsn } -//Table 生成mysql的表 +// Table 生成mysql的表 func (s *Source) Table(b *database.BaseTable) database.Table { return NewTable(b) } -//Quoted postgres引用函数 +// Quoted postgres引用函数 func Quoted(s string) string { return pq.QuoteIdentifier(s) } diff --git a/storage/database/postgres/table.go b/storage/database/postgres/table.go index a5a7ae1..4bd5436 100644 --- a/storage/database/postgres/table.go +++ b/storage/database/postgres/table.go @@ -26,22 +26,22 @@ import ( "github.com/pingcap/errors" ) -//WriteModeCopyIn copy in写入方式 +// WriteModeCopyIn copy in写入方式 const WriteModeCopyIn = "copyIn" -//Table postgres表 +// Table postgres表 type Table struct { *database.BaseTable } -//NewTable 创建postgres表，注意此时BaseTable中的schema参数为架构名，instance为数据库名，而name是表明 +// NewTable 创建postgres表，注意此时BaseTable中的schema参数为架构名，instance为数据库名，而name是表明 func NewTable(b *database.BaseTable) *Table { return &Table{ BaseTable: b, } } -//Quoted 引用全名 +// Quoted 引用全名 func (t *Table) Quoted() string { return Quoted(t.Schema()) + "." + Quoted(t.Name()) } @@ -50,12 +50,12 @@ func (t *Table) String() string { return t.Quoted() } -//AddField 新增列 +// AddField 新增列 func (t *Table) AddField(baseField *database.BaseField) { t.AppendField(NewField(baseField)) } -//ExecParam 获取执行参数，其中copy in的参数方式以及被注册 +// ExecParam 获取执行参数，其中copy in的参数方式以及被注册 func (t *Table) ExecParam(mode string, txOpts *sql.TxOptions) (database.Parameter, bool) { switch mode { case WriteModeCopyIn: @@ -64,7 +64,7 @@ func (t *Table) ExecParam(mode string, txOpts *sql.TxOptions) (database.Paramete return nil, false } -//ShouldRetry 重试 +// ShouldRetry 重试 func (t *Table) ShouldRetry(err error) bool { switch cause := errors.Cause(err).(type) { case net.Error: @@ -74,25 +74,25 @@ func (t *Table) ShouldRetry(err error) bool { } } -//ShouldOneByOne 单个重试 +// ShouldOneByOne 单个重试 func (t *Table) ShouldOneByOne(err error) bool { _, ok := errors.Cause(err).(*pq.Error) return ok } -//CopyInParam copy in 参数 +// CopyInParam copy in 参数 type CopyInParam struct { *database.BaseParam } -//NewCopyInParam 通过表table和事务参数txOps插入参数 +// NewCopyInParam 通过表table和事务参数txOps插入参数 func NewCopyInParam(t database.Table, txOpts *sql.TxOptions) *CopyInParam { return &CopyInParam{ BaseParam: database.NewBaseParam(t, txOpts), } } -//Query 批量copy in插入sql语句 +// Query 批量copy in插入sql语句 func (ci *CopyInParam) Query(_ []element.Record) (query string, err error) { var columns []string for _, f := range ci.Table().Fields() { @@ -102,7 +102,7 @@ func (ci *CopyInParam) Query(_ []element.Record) (query string, err error) { columns...), nil } -//Agrs 通过多条记录 records生成批量copy in参数 +// Agrs 通过多条记录 records生成批量copy in参数 func (ci *CopyInParam) Agrs(records []element.Record) (valuers []interface{}, err error) { for _, r := range records { for fi, f := range ci.Table().Fields() { diff --git a/storage/database/source.go b/storage/database/source.go index 3ef8fab..1ebbf36 100644 --- a/storage/database/source.go +++ b/storage/database/source.go @@ -21,13 +21,13 @@ import ( "github.com/Breeze0806/go-etl/config" ) -//默认参数 +// 默认参数 const ( DefaultMaxOpenConns = 4 DefaultMaxIdleConns = 4 ) -//Source 数据源,包含驱动信息，包信息，配置文件以及连接信息 +// Source 数据源,包含驱动信息，包信息，配置文件以及连接信息 type Source interface { Config() *config.JSON //配置信息 Key() string //一般是连接信息 @@ -36,12 +36,12 @@ type Source interface { Table(*BaseTable) Table //获取具体表 } -//WithConnector 带有连接的数据源, 数据源优先调用该方法生成数据连接池DB +// WithConnector 带有连接的数据源, 数据源优先调用该方法生成数据连接池DB type WithConnector interface { Connector() (driver.Connector, error) //go 1.10 获取连接 } -//NewSource 通过数据库方言的名字获取对应数据源 +// NewSource 通过数据库方言的名字获取对应数据源 func NewSource(name string, conf *config.JSON) (source Source, err error) { d, ok := dialects.dialect(name) if !ok { @@ -54,20 +54,20 @@ func NewSource(name string, conf *config.JSON) (source Source, err error) { return } -//BaseSource 基础数据源，用于存储json配置文件 -//用于嵌入Source，方便实现各个数据库的Field +// BaseSource 基础数据源，用于存储json配置文件 +// 用于嵌入Source，方便实现各个数据库的Field type BaseSource struct { conf *config.JSON } -//NewBaseSource 通过json配置文件conf生成基础数据源 +// NewBaseSource 通过json配置文件conf生成基础数据源 func NewBaseSource(conf *config.JSON) *BaseSource { return &BaseSource{ conf: conf.CloneConfig(), } } -//Config 基础数据源的配置文件 +// Config 基础数据源的配置文件 func (b *BaseSource) Config() *config.JSON { return b.conf } diff --git a/storage/database/sqlserver/config.go b/storage/database/sqlserver/config.go index fbdefdf..64d102b 100644 --- a/storage/database/sqlserver/config.go +++ b/storage/database/sqlserver/config.go @@ -21,14 +21,14 @@ import ( "github.com/denisenkom/go-mssqldb/msdsn" ) -//Config mssql配置 +// Config mssql配置 type Config struct { URL string `json:"url"` //数据库url，包含数据库地址，数据库其他参数 Username string `json:"username"` //用户名 Password string `json:"password"` //密码 } -//NewConfig 创建mssql配置，如果格式不符合要求，就会报错 +// NewConfig 创建mssql配置，如果格式不符合要求，就会报错 func NewConfig(conf *config.JSON) (c *Config, err error) { c = &Config{} err = json.Unmarshal([]byte(conf.String()), c) @@ -48,7 +48,7 @@ func (c *Config) fetchMssqlConfig() (conf msdsn.Config, err error) { return } -//FormatDSN 获取数据库连接信息 +// FormatDSN 获取数据库连接信息 func (c *Config) FormatDSN() (dsn string, err error) { var conf msdsn.Config conf, err = c.fetchMssqlConfig() diff --git a/storage/database/sqlserver/field.go b/storage/database/sqlserver/field.go index 256e4be..454d080 100644 --- a/storage/database/sqlserver/field.go +++ b/storage/database/sqlserver/field.go @@ -29,56 +29,56 @@ var ( datetimeLayout = element.DefaultTimeFormat[:26] ) -//Field 字段 +// Field 字段 type Field struct { *database.BaseField } -//NewField 通过基本列属性生成字段 +// NewField 通过基本列属性生成字段 func NewField(bf *database.BaseField) *Field { return &Field{ BaseField: bf, } } -//Quoted 引用，用于SQL语句 +// Quoted 引用，用于SQL语句 func (f *Field) Quoted() string { return Quoted(f.Name()) } -//BindVar SQL占位符，用于SQL语句 +// BindVar SQL占位符，用于SQL语句 func (f *Field) BindVar(i int) string { return fmt.Sprintf("@p%d", i) } -//Select 查询时字段，用于SQL查询语句 +// Select 查询时字段，用于SQL查询语句 func (f *Field) Select() string { return f.Quoted() } -//Type 字段类型 +// Type 字段类型 func (f *Field) Type() database.FieldType { return NewFieldType(f.FieldType()) } -//Scanner 扫描器，用于读取数据 +// Scanner 扫描器，用于读取数据 func (f *Field) Scanner() database.Scanner { return NewScanner(f) } -//Valuer 赋值器，采用GoValuer处理数据 +// Valuer 赋值器，采用GoValuer处理数据 func (f *Field) Valuer(c element.Column) database.Valuer { return NewValuer(f, c) } -//FieldType 字段类型 +// FieldType 字段类型 type FieldType struct { *database.BaseFieldType goType database.GoType } -//NewFieldType 创建新的字段类型 +// NewFieldType 创建新的字段类型 func NewFieldType(typ database.ColumnType) *FieldType { f := &FieldType{ BaseFieldType: database.NewBaseFieldType(typ), @@ -101,30 +101,30 @@ func NewFieldType(typ database.ColumnType) *FieldType { return f } -//IsSupportted 是否支持解析 +// IsSupportted 是否支持解析 func (f *FieldType) IsSupportted() bool { return f.GoType() != database.GoTypeUnknown } -//GoType 返回处理数值时的Golang类型 +// GoType 返回处理数值时的Golang类型 func (f *FieldType) GoType() database.GoType { return f.goType } -//Scanner 扫描器 +// Scanner 扫描器 type Scanner struct { f *Field database.BaseScanner } -//NewScanner 根据列类型生成扫描器 +// NewScanner 根据列类型生成扫描器 func NewScanner(f *Field) *Scanner { return &Scanner{ f: f, } } -//Scan 根据列类型读取数据 +// Scan 根据列类型读取数据 func (s *Scanner) Scan(src interface{}) (err error) { var cv element.ColumnValue byteSize := element.ByteSize(src) @@ -205,13 +205,13 @@ func (s *Scanner) Scan(src interface{}) (err error) { return } -//Valuer 赋值器 +// Valuer 赋值器 type Valuer struct { f *Field c element.Column } -//NewValuer 创建新赋值器 +// NewValuer 创建新赋值器 func NewValuer(f *Field, c element.Column) *Valuer { return &Valuer{ f: f, @@ -219,7 +219,7 @@ func NewValuer(f *Field, c element.Column) *Valuer { } } -//Value 赋值 +// Value 赋值 func (v *Valuer) Value() (driver.Value, error) { //不能直接nil，golang的[]byte(nil)的类型是[]byte，但是值是nil，会导致以下错误: //mssql: Implicit conversion from data type nvarchar to binary is not allowed. diff --git a/storage/database/sqlserver/source.go b/storage/database/sqlserver/source.go index d92ffd1..28a0d5e 100644 --- a/storage/database/sqlserver/source.go +++ b/storage/database/sqlserver/source.go @@ -23,27 +23,27 @@ func init() { database.RegisterDialect(d.Name(), d) } -//Dialect mssql数据库方言 +// Dialect mssql数据库方言 type Dialect struct{} -//Source 生成mssql数据源 +// Source 生成mssql数据源 func (d Dialect) Source(bs *database.BaseSource) (database.Source, error) { return NewSource(bs) } -//Name 数据库方言的注册名 +// Name 数据库方言的注册名 func (d Dialect) Name() string { return "sqlserver" } -//Source mssql数据源 +// Source mssql数据源 type Source struct { *database.BaseSource //基础数据源 dsn string } -//NewSource 生成mssql数据源，在配置文件错误时会报错 +// NewSource 生成mssql数据源，在配置文件错误时会报错 func NewSource(bs *database.BaseSource) (s database.Source, err error) { source := &Source{ BaseSource: bs, @@ -59,28 +59,28 @@ func NewSource(bs *database.BaseSource) (s database.Source, err error) { return source, nil } -//DriverName github.com/denisenkom/go-mssqldb的驱动名 +// DriverName github.com/denisenkom/go-mssqldb的驱动名 func (s *Source) DriverName() string { return "sqlserver" } -//ConnectName github.com/denisenkom/go-mssqldb的数据源连接信息 +// ConnectName github.com/denisenkom/go-mssqldb的数据源连接信息 func (s *Source) ConnectName() string { return s.dsn } -//Key 数据源的关键字，用于DBWrapper的复用 +// Key 数据源的关键字，用于DBWrapper的复用 func (s *Source) Key() string { return s.dsn } -//Table 生成mssql的表 +// Table 生成mssql的表 func (s *Source) Table(b *database.BaseTable) database.Table { t := NewTable(b) return t } -//Quoted mysql引用函数 +// Quoted mysql引用函数 func Quoted(s string) string { return `[` + s + `]` } diff --git a/storage/database/sqlserver/table.go b/storage/database/sqlserver/table.go index c033b53..96f3307 100644 --- a/storage/database/sqlserver/table.go +++ b/storage/database/sqlserver/table.go @@ -28,24 +28,24 @@ import ( "github.com/pingcap/errors" ) -//WriteModeCopyIn copy in写入方式 +// WriteModeCopyIn copy in写入方式 const WriteModeCopyIn = "copyIn" -//Table mssql表 +// Table mssql表 type Table struct { *database.BaseTable conf *config.JSON } -//NewTable 创建mssql表，注意此时BaseTable中的schema参数为空，instance为数据库名，而name是表明 +// NewTable 创建mssql表，注意此时BaseTable中的schema参数为空，instance为数据库名，而name是表明 func NewTable(b *database.BaseTable) *Table { return &Table{ BaseTable: b, } } -//Quoted 表引用全名 +// Quoted 表引用全名 func (t *Table) Quoted() string { return Quoted(t.Instance()) + "." + Quoted(t.Schema()) + "." + Quoted(t.Name()) } @@ -54,17 +54,17 @@ func (t *Table) String() string { return t.Quoted() } -//AddField 新增列 +// AddField 新增列 func (t *Table) AddField(baseField *database.BaseField) { t.AppendField(NewField(baseField)) } -//SetConfig 设置配置 +// SetConfig 设置配置 func (t *Table) SetConfig(conf *config.JSON) { t.conf = conf } -//ExecParam 获取执行参数，其中replace into的参数方式以及被注册 +// ExecParam 获取执行参数，其中replace into的参数方式以及被注册 func (t *Table) ExecParam(mode string, txOpts *sql.TxOptions) (database.Parameter, bool) { switch mode { case WriteModeCopyIn: @@ -73,7 +73,7 @@ func (t *Table) ExecParam(mode string, txOpts *sql.TxOptions) (database.Paramete return nil, false } -//ShouldRetry 重试 +// ShouldRetry 重试 func (t *Table) ShouldRetry(err error) bool { switch cause := errors.Cause(err).(type) { case net.Error: @@ -83,25 +83,25 @@ func (t *Table) ShouldRetry(err error) bool { } } -//ShouldOneByOne 单个重试 +// ShouldOneByOne 单个重试 func (t *Table) ShouldOneByOne(err error) bool { _, ok := errors.Cause(err).(*mssql.Error) return ok } -//CopyInParam copy in 参数 +// CopyInParam copy in 参数 type CopyInParam struct { *database.BaseParam } -//NewCopyInParam 通过表table和事务参数txOpts插入参数 +// NewCopyInParam 通过表table和事务参数txOpts插入参数 func NewCopyInParam(t database.Table, txOpts *sql.TxOptions) *CopyInParam { return &CopyInParam{ BaseParam: database.NewBaseParam(t, txOpts), } } -//Query 批量copy in插入sql语句 +// Query 批量copy in插入sql语句 func (ci *CopyInParam) Query(_ []element.Record) (query string, err error) { var conf *config.JSON conf, err = ci.Table().(*Table).conf.GetConfig("bulkOption") @@ -124,7 +124,7 @@ func (ci *CopyInParam) Query(_ []element.Record) (query string, err error) { columns...), nil } -//Agrs 通过多条记录 records生成批量copy in参数 +// Agrs 通过多条记录 records生成批量copy in参数 func (ci *CopyInParam) Agrs(records []element.Record) (valuers []interface{}, err error) { for _, r := range records { for fi, f := range ci.Table().Fields() { diff --git a/storage/database/table.go b/storage/database/table.go index 48efec8..f4ce116 100644 --- a/storage/database/table.go +++ b/storage/database/table.go @@ -26,7 +26,7 @@ import ( "github.com/Breeze0806/go-etl/schedule" ) -//Table 表结构 +// Table 表结构 type Table interface { fmt.Stringer @@ -37,7 +37,7 @@ type Table interface { Fields() []Field //显示所有列 } -//Parameter 带有表，事务模式，sql语句的执行参数 +// Parameter 带有表，事务模式，sql语句的执行参数 type Parameter interface { SetTable(Table) //设置表或者视图 Table() Table //表或者视图 @@ -46,7 +46,7 @@ type Parameter interface { Agrs([]element.Record) ([]interface{}, error) //prepare参数 } -//ParameterOptions 参数选项 +// ParameterOptions 参数选项 type ParameterOptions struct { Table Table //表或者视图 Mode string //写入模式，例如mysql @@ -54,34 +54,34 @@ type ParameterOptions struct { Records []element.Record //写入行 } -//FieldsFetcher Table的补充方法，用于特殊获取表的所有列 +// FieldsFetcher Table的补充方法，用于特殊获取表的所有列 type FieldsFetcher interface { FetchFields(ctx context.Context, db *DB) error //获取具体列 } -//FieldAdder Table的补充方法，用于新增表的列 +// FieldAdder Table的补充方法，用于新增表的列 type FieldAdder interface { AddField(*BaseField) //新增具体列 } -//TableConfigSetter Table的补充方法，用于设置json配置文件 +// TableConfigSetter Table的补充方法，用于设置json配置文件 type TableConfigSetter interface { SetConfig(conf *config.JSON) } -//ExecParameter Table的补充方法，用于写模式获取生成sql语句的方法 +// ExecParameter Table的补充方法，用于写模式获取生成sql语句的方法 type ExecParameter interface { ExecParam(string, *sql.TxOptions) (Parameter, bool) } -//Judger 错误判断器 +// Judger 错误判断器 type Judger interface { schedule.RetryJudger ShouldOneByOne(err error) bool } -//BaseTable 基本表，用于嵌入各种数据库Table的实现 +// BaseTable 基本表，用于嵌入各种数据库Table的实现 type BaseTable struct { instance string schema string @@ -89,7 +89,7 @@ type BaseTable struct { fields []Field } -//NewBaseTable ，通过实例名，模式名，表明获取基本表 +// NewBaseTable ，通过实例名，模式名，表明获取基本表 func NewBaseTable(instance, schema, name string) *BaseTable { return &BaseTable{ instance: instance, @@ -98,43 +98,43 @@ func NewBaseTable(instance, schema, name string) *BaseTable { } } -//Instance 实例名，例如对于mysql就是数据库，对于oracle就是实例 +// Instance 实例名，例如对于mysql就是数据库，对于oracle就是实例 func (b *BaseTable) Instance() string { return b.instance } -//Schema 模式名，例如对于mysql就是数据库，对于oracle就是用户名 +// Schema 模式名，例如对于mysql就是数据库，对于oracle就是用户名 func (b *BaseTable) Schema() string { return b.schema } -//Name 表名，例如对于mysql就是表 +// Name 表名，例如对于mysql就是表 func (b *BaseTable) Name() string { return b.name } -//String 用于打印的显示字符串 +// String 用于打印的显示字符串 func (b *BaseTable) String() string { return b.instance + "." + b.schema + "." + b.name } -//Fields 显示所有列 +// Fields 显示所有列 func (b *BaseTable) Fields() []Field { return b.fields } -//AppendField 追加列 +// AppendField 追加列 func (b *BaseTable) AppendField(f Field) { b.fields = append(b.fields, f) } -//BaseParam 基础参数，用于嵌入各类数据库sql参数的 +// BaseParam 基础参数，用于嵌入各类数据库sql参数的 type BaseParam struct { table Table txOpts *sql.TxOptions } -//NewBaseParam 通过表table和事务参数txOps生成基础参数 +// NewBaseParam 通过表table和事务参数txOps生成基础参数 func NewBaseParam(table Table, txOpts *sql.TxOptions) *BaseParam { return &BaseParam{ table: table, @@ -142,34 +142,34 @@ func NewBaseParam(table Table, txOpts *sql.TxOptions) *BaseParam { } } -//SetTable 设置表 +// SetTable 设置表 func (b *BaseParam) SetTable(table Table) { b.table = table } -//Table 获取表 +// Table 获取表 func (b *BaseParam) Table() Table { return b.table } -//TxOptions 获取事务参数 +// TxOptions 获取事务参数 func (b *BaseParam) TxOptions() *sql.TxOptions { return b.txOpts } -//InsertParam 插入参数 +// InsertParam 插入参数 type InsertParam struct { *BaseParam } -//NewInsertParam 通过表table和事务参数txOps插入参数 +// NewInsertParam 通过表table和事务参数txOps插入参数 func NewInsertParam(t Table, txOps *sql.TxOptions) *InsertParam { return &InsertParam{ BaseParam: NewBaseParam(t, txOps), } } -//Query 通过多条记录 records生成批量插入sql语句 +// Query 通过多条记录 records生成批量插入sql语句 func (i *InsertParam) Query(records []element.Record) (query string, err error) { buf := bytes.NewBufferString("insert into ") buf.WriteString(i.Table().Quoted()) @@ -199,7 +199,7 @@ func (i *InsertParam) Query(records []element.Record) (query string, err error) return buf.String(), nil } -//Agrs 通过多条记录 records生成批量插入参数 +// Agrs 通过多条记录 records生成批量插入参数 func (i *InsertParam) Agrs(records []element.Record) (valuers []interface{}, err error) { for _, r := range records { for fi, f := range i.Table().Fields() { @@ -218,26 +218,26 @@ func (i *InsertParam) Agrs(records []element.Record) (valuers []interface{}, err return } -//TableQueryParam 表结构查询参数 +// TableQueryParam 表结构查询参数 type TableQueryParam struct { *BaseParam } -//NewTableQueryParam 通过表Table生成表结构查询参数 +// NewTableQueryParam 通过表Table生成表结构查询参数 func NewTableQueryParam(table Table) *TableQueryParam { return &TableQueryParam{ BaseParam: NewBaseParam(table, nil), } } -//Query 生成select * from table where 1=2来获取表结构 +// Query 生成select * from table where 1=2来获取表结构 func (t *TableQueryParam) Query(_ []element.Record) (s string, err error) { s = "select * from " s += t.table.Quoted() + " where 1 = 2" return s, nil } -//Agrs 生成参数，不过为空 +// Agrs 生成参数，不过为空 func (t *TableQueryParam) Agrs(_ []element.Record) (a []interface{}, err error) { return nil, nil } diff --git a/storage/stream/file/compress/compress.go b/storage/stream/file/compress/compress.go index f5bb8c5..f1a0e17 100644 --- a/storage/stream/file/compress/compress.go +++ b/storage/stream/file/compress/compress.go @@ -21,10 +21,10 @@ import ( "os" ) -//Type 压缩类型 +// Type 压缩类型 type Type string -//压缩类型枚举 +// 压缩类型枚举 const ( TypeNone Type = "" TypeTarGzip Type = "targz" @@ -33,7 +33,7 @@ const ( TypeGzip Type = "gz" ) -//ReadCloser 获取读取关闭器 +// ReadCloser 获取读取关闭器 func (c Type) ReadCloser(f *os.File) (r io.ReadCloser, err error) { switch c { case TypeNone: @@ -50,7 +50,7 @@ func (c Type) ReadCloser(f *os.File) (r io.ReadCloser, err error) { return } -//WriteCloser 获取写入关闭器 +// WriteCloser 获取写入关闭器 func (c Type) WriteCloser(f *os.File) (w io.WriteCloser, err error) { switch c { case TypeNone: @@ -67,29 +67,29 @@ func (c Type) WriteCloser(f *os.File) (w io.WriteCloser, err error) { return } -//ReadCloser 读取关闭器 +// ReadCloser 读取关闭器 type ReadCloser struct { io.Reader } -//Read 读取p +// Read 读取p func (r *ReadCloser) Read(p []byte) (n int, err error) { return r.Reader.Read(p) } -//Close 关闭 +// Close 关闭 func (r *ReadCloser) Close() error { return nil } -//NewNoneReadCloser 获取无压缩读取关闭器 +// NewNoneReadCloser 获取无压缩读取关闭器 func NewNoneReadCloser(f *os.File) *ReadCloser { return &ReadCloser{ Reader: f, } } -//NewZipReadCloser 获取zip压缩读取关闭器 +// NewZipReadCloser 获取zip压缩读取关闭器 func NewZipReadCloser(f *os.File) (r *ReadCloser, err error) { r = &ReadCloser{} if r.Reader, err = NewZipReader(f); err != nil { @@ -98,7 +98,7 @@ func NewZipReadCloser(f *os.File) (r *ReadCloser, err error) { return } -//NewGzipReadCloser 获取gzip压缩读取关闭器 +// NewGzipReadCloser 获取gzip压缩读取关闭器 func NewGzipReadCloser(f *os.File) (r *ReadCloser, err error) { r = &ReadCloser{} @@ -108,47 +108,47 @@ func NewGzipReadCloser(f *os.File) (r *ReadCloser, err error) { return } -//NoneWriter 无压缩写入器 +// NoneWriter 无压缩写入器 type NoneWriter struct { file *os.File } -//NewNoneWriter 创建无压缩写入器 +// NewNoneWriter 创建无压缩写入器 func NewNoneWriter(f *os.File) (nw *NoneWriter) { return &NoneWriter{ file: f, } } -//Write 写入p +// Write 写入p func (nw *NoneWriter) Write(p []byte) (n int, err error) { return nw.file.Write(p) } -//Close 关闭 +// Close 关闭 func (nw *NoneWriter) Close() error { return nil } -//GzipWriter Gzip压缩写入器 +// GzipWriter Gzip压缩写入器 type GzipWriter struct { writer *gzip.Writer } -//NewGzipWriter 创建gzip压缩写入器 +// NewGzipWriter 创建gzip压缩写入器 func NewGzipWriter(f *os.File) (gw *GzipWriter) { return &GzipWriter{ writer: gzip.NewWriter(f), } } -//Write 写入p +// Write 写入p func (g *GzipWriter) Write(p []byte) (n int, err error) { defer g.writer.Flush() return g.writer.Write(p) } -//Close 关闭 +// Close 关闭 func (g *GzipWriter) Close() error { return g.writer.Close() } diff --git a/storage/stream/file/compress/doc.go b/storage/stream/file/compress/doc.go index d6b1acb..bd726d8 100644 --- a/storage/stream/file/compress/doc.go +++ b/storage/stream/file/compress/doc.go @@ -12,5 +12,5 @@ // See the License for the specific language governing permissions and // limitations under the License. -//Package compress 主要实现了压缩方法 +// Package compress 主要实现了压缩方法 package compress diff --git a/storage/stream/file/compress/zip_reader.go b/storage/stream/file/compress/zip_reader.go index acae1da..76c8e70 100644 --- a/storage/stream/file/compress/zip_reader.go +++ b/storage/stream/file/compress/zip_reader.go @@ -21,14 +21,14 @@ import ( "os" ) -//ZipReader zip的读取器 +// ZipReader zip的读取器 type ZipReader struct { reader *zip.Reader now int nowReader io.ReadCloser } -//NewZipReader 通过文件f创建zip读取器 +// NewZipReader 通过文件f创建zip读取器 func NewZipReader(f *os.File) (zr *ZipReader, err error) { var fi fs.FileInfo fi, err = f.Stat() @@ -43,7 +43,7 @@ func NewZipReader(f *os.File) (zr *ZipReader, err error) { return zr, nil } -//Read 传入p读取 +// Read 传入p读取 func (z *ZipReader) Read(p []byte) (n int, err error) { if z.now == 0 { if err = z.getNowReader(); err != nil { diff --git a/storage/stream/file/compress/zip_writer.go b/storage/stream/file/compress/zip_writer.go index c42195e..344ab3a 100644 --- a/storage/stream/file/compress/zip_writer.go +++ b/storage/stream/file/compress/zip_writer.go @@ -23,13 +23,13 @@ import ( "github.com/google/uuid" ) -//ZipWriter zip压缩写入器 +// ZipWriter zip压缩写入器 type ZipWriter struct { writer *zip.Writer nowWriter io.Writer } -//NewZipWriter 创建zip压缩写入器 +// NewZipWriter 创建zip压缩写入器 func NewZipWriter(f *os.File) (zw *ZipWriter, err error) { var fi fs.FileInfo @@ -47,13 +47,13 @@ func NewZipWriter(f *os.File) (zw *ZipWriter, err error) { return } -//Write 写入p +// Write 写入p func (z *ZipWriter) Write(p []byte) (n int, err error) { defer z.writer.Flush() return z.nowWriter.Write(p) } -//Close 关闭 +// Close 关闭 func (z *ZipWriter) Close() error { return z.writer.Close() } diff --git a/storage/stream/file/csv/config.go b/storage/stream/file/csv/config.go index 469aded..785d345 100644 --- a/storage/stream/file/csv/config.go +++ b/storage/stream/file/csv/config.go @@ -25,7 +25,7 @@ import ( "github.com/Breeze0806/jodaTime" ) -//InConfig csv配置 +// InConfig csv配置 type InConfig struct { Columns []Column `json:"column"` // 列信息 Encoding string `json:"encoding"` // 编码 @@ -36,7 +36,7 @@ type InConfig struct { Compress string `json:"compress"` // 压缩 } -//NewInConfig 通过conf获取csv配置 +// NewInConfig 通过conf获取csv配置 func NewInConfig(conf *config.JSON) (c *InConfig, err error) { c = &InConfig{} err = json.Unmarshal([]byte(conf.String()), c) @@ -104,7 +104,7 @@ func (c *InConfig) comment() rune { return rune(0) } -//OutConfig csv配置 +// OutConfig csv配置 type OutConfig struct { Columns []Column `json:"column"` // 列信息 Encoding string `json:"encoding"` // 编码 @@ -115,7 +115,7 @@ type OutConfig struct { Compress string `json:"compress"` // 压缩 } -//NewOutConfig 通过conf获取csv配置 +// NewOutConfig 通过conf获取csv配置 func NewOutConfig(conf *config.JSON) (c *OutConfig, err error) { c = &OutConfig{} err = json.Unmarshal([]byte(conf.String()), c) @@ -160,7 +160,7 @@ func (c *OutConfig) comma() rune { return []rune(c.Delimiter)[0] } -//Column 列信息 +// Column 列信息 type Column struct { Index string `json:"index"` // 索引 从1开始，代表第几列 Type string `json:"type"` // 类型 bool bigInt decimal string time @@ -169,7 +169,7 @@ type Column struct { goLayout string } -//validate 校验 +// validate 校验 func (c *Column) validate() (err error) { switch element.ColumnType(c.Type) { case element.TypeBool, element.TypeBigInt, @@ -192,7 +192,7 @@ func (c *Column) validate() (err error) { return } -//index 列索引 +// index 列索引 func (c *Column) index() (i int) { if c.indexNum > 0 { return c.indexNum - 1 @@ -201,7 +201,7 @@ func (c *Column) index() (i int) { return c.indexNum - 1 } -//layout 变为golang 时间格式 +// layout 变为golang 时间格式 func (c *Column) layout() string { if c.goLayout != "" { return c.goLayout diff --git a/storage/stream/file/csv/doc.go b/storage/stream/file/csv/doc.go index adbd054..df57704 100644 --- a/storage/stream/file/csv/doc.go +++ b/storage/stream/file/csv/doc.go @@ -12,5 +12,5 @@ // See the License for the specific language governing permissions and // limitations under the License. -//Package csv 主要实现了stream/file的接口 +// Package csv 主要实现了stream/file的接口 package csv diff --git a/storage/stream/file/csv/stream.go b/storage/stream/file/csv/stream.go index 1901aaa..ecf266d 100644 --- a/storage/stream/file/csv/stream.go +++ b/storage/stream/file/csv/stream.go @@ -35,30 +35,30 @@ func init() { file.RegisterCreator("csv", &creator) } -//Opener csv输入流打开器 +// Opener csv输入流打开器 type Opener struct { } -//Open 打开一个名为filename的csv输入流 +// Open 打开一个名为filename的csv输入流 func (o *Opener) Open(filename string) (file.InStream, error) { return NewInStream(filename) } -//Creator csv输出流创建器 +// Creator csv输出流创建器 type Creator struct { } -//Create 创建一个名为filename的csv输出流 +// Create 创建一个名为filename的csv输出流 func (c *Creator) Create(filename string) (file.OutStream, error) { return NewOutStream(filename) } -//Stream csv文件流 +// Stream csv文件流 type Stream struct { file *os.File } -//NewInStream 创建一个名为filename的csv输入流 +// NewInStream 创建一个名为filename的csv输入流 func NewInStream(filename string) (file.InStream, error) { stream := &Stream{} var err error @@ -69,7 +69,7 @@ func NewInStream(filename string) (file.InStream, error) { return stream, nil } -//NewOutStream 创建一个名为filename的csv输出流 +// NewOutStream 创建一个名为filename的csv输出流 func NewOutStream(filename string) (file.OutStream, error) { stream := &Stream{} var err error @@ -80,22 +80,22 @@ func NewOutStream(filename string) (file.OutStream, error) { return stream, nil } -//Writer 新建一个配置未conf的csv流写入器 +// Writer 新建一个配置未conf的csv流写入器 func (s *Stream) Writer(conf *config.JSON) (file.StreamWriter, error) { return NewWriter(s.file, conf) } -//Rows 新建一个配置未conf的csv行读取器 +// Rows 新建一个配置未conf的csv行读取器 func (s *Stream) Rows(conf *config.JSON) (rows file.Rows, err error) { return NewRows(s.file, conf) } -//Close 关闭文件流 +// Close 关闭文件流 func (s *Stream) Close() (err error) { return s.file.Close() } -//Rows 行读取器 +// Rows 行读取器 type Rows struct { columns map[int]Column rc io.ReadCloser @@ -106,7 +106,7 @@ type Rows struct { err error } -//NewRows 通过文件句柄f，和配置文件c 创建行读取器 +// NewRows 通过文件句柄f，和配置文件c 创建行读取器 func NewRows(f *os.File, c *config.JSON) (file.Rows, error) { var conf *InConfig var err error @@ -198,7 +198,7 @@ func (r *Rows) getColum(index int, s string) (element.Column, error) { return element.NewDefaultColumn(element.NewStringColumnValue(s), strconv.Itoa(index), byteSize), nil } -//Writer csv流写入器 +// Writer csv流写入器 type Writer struct { writer *csv.Writer wc io.WriteCloser @@ -206,7 +206,7 @@ type Writer struct { conf *OutConfig } -//NewWriter 通过文件句柄f，和配置文件c 创建csv流写入器 +// NewWriter 通过文件句柄f，和配置文件c 创建csv流写入器 func NewWriter(f *os.File, c *config.JSON) (file.StreamWriter, error) { var conf *OutConfig var err error @@ -230,19 +230,19 @@ func NewWriter(f *os.File, c *config.JSON) (file.StreamWriter, error) { return w, nil } -//Flush 刷新至磁盘 +// Flush 刷新至磁盘 func (w *Writer) Flush() (err error) { w.writer.Flush() return } -//Close 关闭 +// Close 关闭 func (w *Writer) Close() (err error) { w.writer.Flush() return w.wc.Close() } -//Write 将记录record 写入csv文件 +// Write 将记录record 写入csv文件 func (w *Writer) Write(record element.Record) (err error) { if w.conf.HasHeader { if len(w.conf.Header) == 0 { diff --git a/storage/stream/file/in_streamer.go b/storage/stream/file/in_streamer.go index feccd48..66dd5ce 100644 --- a/storage/stream/file/in_streamer.go +++ b/storage/stream/file/in_streamer.go @@ -49,24 +49,24 @@ type Rows interface { Close() error //关闭行读取器 } -//RegisterOpener 通过打开器名称name注册输入流打开器opener +// RegisterOpener 通过打开器名称name注册输入流打开器opener func RegisterOpener(name string, opener Opener) { if err := openers.register(name, opener); err != nil { panic(err) } } -//UnregisterAllOpener 注销所有文件打开器 +// UnregisterAllOpener 注销所有文件打开器 func UnregisterAllOpener() { openers.unregisterAll() } -//InStreamer 输入流包装 +// InStreamer 输入流包装 type InStreamer struct { stream InStream } -//NewInStreamer 通过opener名称name的输入流打开器，并打开名为filename的输入流 +// NewInStreamer 通过opener名称name的输入流打开器，并打开名为filename的输入流 func NewInStreamer(name string, filename string) (streamer *InStreamer, err error) { opener, ok := openers.opener(name) if !ok { diff --git a/storage/stream/file/out_stremer.go b/storage/stream/file/out_stremer.go index e798cfc..0fdada3 100644 --- a/storage/stream/file/out_stremer.go +++ b/storage/stream/file/out_stremer.go @@ -48,7 +48,7 @@ func RegisterCreator(name string, creator Creator) { } } -//UnregisterAllCreater 注销所有文件打开器 +// UnregisterAllCreater 注销所有文件打开器 func UnregisterAllCreater() { creators.unregisterAll() } diff --git a/storage/stream/file/xlsx/config.go b/storage/stream/file/xlsx/config.go index 7a07ddd..97cfcc8 100644 --- a/storage/stream/file/xlsx/config.go +++ b/storage/stream/file/xlsx/config.go @@ -24,7 +24,7 @@ import ( "github.com/xuri/excelize/v2" ) -//InConfig 输入xlsx配置 +// InConfig 输入xlsx配置 type InConfig struct { Columns []Column `json:"column"` //列信息数组 Sheet string `json:"sheet"` //表格名 @@ -32,7 +32,7 @@ type InConfig struct { StartRow int `json:"startRow"` //开始读取行数，从第1行开始 } -//NewInConfig 新建以json配置conf的输入xlsx配置 +// NewInConfig 新建以json配置conf的输入xlsx配置 func NewInConfig(conf *config.JSON) (c *InConfig, err error) { c = &InConfig{} err = json.Unmarshal([]byte(conf.String()), c) @@ -59,7 +59,7 @@ func (c *InConfig) startRow() int { return c.StartRow } -//OutConfig 输出xlsx配置 +// OutConfig 输出xlsx配置 type OutConfig struct { Columns []Column `json:"column"` //列信息数组 Sheets []string `json:"sheets"` //表格名 @@ -69,7 +69,7 @@ type OutConfig struct { SheetRow int `json:"sheetRow"` // sheet最大的行数 } -//NewOutConfig 新建以json配置conf的输出xlsx配置 +// NewOutConfig 新建以json配置conf的输出xlsx配置 func NewOutConfig(conf *config.JSON) (c *OutConfig, err error) { c = &OutConfig{} err = json.Unmarshal([]byte(conf.String()), c) @@ -99,7 +99,7 @@ func (c *OutConfig) sheetRow() int { return c.SheetRow } -//Column 列信息 +// Column 列信息 type Column struct { Index string `json:"index"` //列索引，A,B,C....AA..... Type string `json:"type"` //类型 类型 bool bigInt decimal string time @@ -108,7 +108,7 @@ type Column struct { goLayout string } -//validate 校验 +// validate 校验 func (c *Column) validate() (err error) { switch element.ColumnType(c.Type) { case element.TypeBool, element.TypeBigInt, @@ -127,7 +127,7 @@ func (c *Column) validate() (err error) { return } -//index 列索引 +// index 列索引 func (c *Column) index() (i int) { if c.indexNum > 0 { return c.indexNum - 1 @@ -136,7 +136,7 @@ func (c *Column) index() (i int) { return c.indexNum - 1 } -//layout go时间格式 +// layout go时间格式 func (c *Column) layout() string { if c.goLayout != "" { return c.goLayout diff --git a/storage/stream/file/xlsx/doc.go b/storage/stream/file/xlsx/doc.go index 942f942..377fe36 100644 --- a/storage/stream/file/xlsx/doc.go +++ b/storage/stream/file/xlsx/doc.go @@ -12,5 +12,5 @@ // See the License for the specific language governing permissions and // limitations under the License. -//Package xlsx 主要实现了stream/file的接口 +// Package xlsx 主要实现了stream/file的接口 package xlsx diff --git a/storage/stream/file/xlsx/stream.go b/storage/stream/file/xlsx/stream.go index d146e5d..78b12b0 100644 --- a/storage/stream/file/xlsx/stream.go +++ b/storage/stream/file/xlsx/stream.go @@ -33,31 +33,31 @@ func init() { file.RegisterCreator("xlsx", &creator) } -//Opener xlsx输入流打开器 +// Opener xlsx输入流打开器 type Opener struct { } -//Open 打开一个名为filename的xlsx输入流 +// Open 打开一个名为filename的xlsx输入流 func (o *Opener) Open(filename string) (file.InStream, error) { return NewInStream(filename) } -//Creator xlsx输出流创建器 +// Creator xlsx输出流创建器 type Creator struct { } -//Create 创建一个名为filename的xlsx输出流 +// Create 创建一个名为filename的xlsx输出流 func (c *Creator) Create(filename string) (file.OutStream, error) { return NewOutStream(filename) } -//Stream xlsx文件流 +// Stream xlsx文件流 type Stream struct { file *excelize.File filename string } -//NewInStream 创建一个名为filename的xlsx输入流 +// NewInStream 创建一个名为filename的xlsx输入流 func NewInStream(filename string) (file.InStream, error) { stream := &Stream{} var err error @@ -68,7 +68,7 @@ func NewInStream(filename string) (file.InStream, error) { return stream, nil } -//NewOutStream 创建一个名为filename的xlsx输出流 +// NewOutStream 创建一个名为filename的xlsx输出流 func NewOutStream(filename string) (file.OutStream, error) { stream := &Stream{ filename: filename, @@ -77,17 +77,17 @@ func NewOutStream(filename string) (file.OutStream, error) { return stream, nil } -//Rows 新建一个配置未conf的csv行读取器 +// Rows 新建一个配置未conf的csv行读取器 func (s *Stream) Rows(conf *config.JSON) (file.Rows, error) { return NewRows(s.file, conf) } -//Writer 新建一个配置未conf的xlsx流写入器 +// Writer 新建一个配置未conf的xlsx流写入器 func (s *Stream) Writer(conf *config.JSON) (file.StreamWriter, error) { return NewWriter(s.file, conf) } -//Close 关闭文件流 +// Close 关闭文件流 func (s *Stream) Close() (err error) { if s.filename != "" { err = s.file.SaveAs(s.filename) @@ -96,7 +96,7 @@ func (s *Stream) Close() (err error) { return s.file.Close() } -//Rows 行读取器 +// Rows 行读取器 type Rows struct { *excelize.Rows @@ -105,7 +105,7 @@ type Rows struct { config *InConfig } -//NewRows 通过文件句柄f，和配置文件c 创建行读取器 +// NewRows 通过文件句柄f，和配置文件c 创建行读取器 func NewRows(f *excelize.File, c *config.JSON) (rows *Rows, err error) { var conf *InConfig if conf, err = NewInConfig(c); err != nil { @@ -170,7 +170,7 @@ func (r *Rows) getColum(index int, s string) (element.Column, error) { return element.NewDefaultColumn(element.NewStringColumnValue(s), strconv.Itoa(index), byteSize), nil } -//Writer xlsx流写入器 +// Writer xlsx流写入器 type Writer struct { file *excelize.File writer *excelize.StreamWriter @@ -180,7 +180,7 @@ type Writer struct { columns map[int]Column } -//NewWriter 通过文件句柄f，和配置文件c 创建xlsx流写入器 +// NewWriter 通过文件句柄f，和配置文件c 创建xlsx流写入器 func NewWriter(f *excelize.File, c *config.JSON) (file.StreamWriter, error) { w := &Writer{ file: f, @@ -200,7 +200,7 @@ func NewWriter(f *excelize.File, c *config.JSON) (file.StreamWriter, error) { return w, nil } -//Write 将记录record 写入xlsx文件 +// Write 将记录record 写入xlsx文件 func (w *Writer) Write(record element.Record) (err error) { w.row++ if w.row > w.conf.sheetRow() { @@ -251,12 +251,12 @@ func (w *Writer) Write(record element.Record) (err error) { return w.writer.SetRow(axis, records) } -//Flush 不刷新 +// Flush 不刷新 func (w *Writer) Flush() (err error) { return } -//Close w.writer有可能为空，刷新文件内存到临时文件 +// Close w.writer有可能为空，刷新文件内存到临时文件 func (w *Writer) Close() (err error) { if w.writer != nil { err = w.writer.Flush() diff --git a/tools/license/main.go b/tools/license/main.go index 7357ac9..0bfd1bb 100644 --- a/tools/license/main.go +++ b/tools/license/main.go @@ -21,6 +21,7 @@ import ( "io/fs" "io/ioutil" "os" + "os/exec" "path/filepath" "sync" @@ -94,13 +95,17 @@ func main() { if err = addLicenseHeader(filename); err != nil { log.Errorf("addLicenseHeader %v fail. err : %v", filename, err) } + + if _, err = formatCode(filename); err != nil { + log.Errorf("formatCode %v fail. err : %v", filename, err) + } } }(v) } wg.Wait() } -//添加许可证 +// 添加许可证 func readPackages(path string) (packages []string, err error) { var list []os.FileInfo list, err = ioutil.ReadDir(path) @@ -120,7 +125,7 @@ func readPackages(path string) (packages []string, err error) { return } -//检查许可证 +// 检查许可证 func addLicenseHeader(filename string) error { data, err := ioutil.ReadFile(filename) if err != nil { @@ -149,6 +154,7 @@ func addLicenseHeader(filename string) error { return nil } +// 检查许可证 func checkLicenseHeader(filename string) error { data, err := ioutil.ReadFile(filename) if err != nil { @@ -161,3 +167,20 @@ func checkLicenseHeader(filename string) error { } return fmt.Errorf("has no license header") } + +// 格式化代码 +func formatCode(filename string) (output string, err error) { + return cmdOutput("gofmt", "-s", "-w", filename) +} + +func cmdOutput(cmd string, arg ...string) (output string, err error) { + c := exec.Command(cmd, arg...) + var stdout, stderr bytes.Buffer + c.Stdout = &stdout + c.Stderr = &stderr + if err = c.Run(); err != nil { + err = fmt.Errorf("%v(%s)", err, stderr.String()) + return + } + return stdout.String(), nil +}