database

package
v0.1.6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 6, 2023 License: Apache-2.0 Imports: 15 Imported by: 0

README

数据库存储开发者指南

数据库存储是数据库查询和执行SQL的框架，用于数据库的抽象,其底层是借助golang标准库的database/sql的接口来实现的。

数据库存储简介

数据库存储通过封装golang标准库的database/sql的DB结构体用于查询和执行数据库SQL，在db.go封装了较为丰富的方法，不仅提供database/sql的DB原有的方法BeginTx，PingContext，QueryContext和ExecContext，而且还提供了FetchTable和FetchTableWithParam用于获取表结构，FetchRecord和FetchRecordWithTx用于获取表中的记录，BatchExec，BatchExecWithTx和BatchExecStmtWithTx用于执行写入记录语句。

但是对于不同的数据库使用数据库存储可以实现不同的数据库方言dialect，本文档会介绍如何实现数据库方言dialect接口。

数据库方言dialect接口介绍

实现dialect接口的前提是数据库对应的驱动库可以实现golang标准库的database/sql的接口。

具体实现时，可以参考以下目录去实现，这里以mysql为例

storage--database--mysql----+--config.go        
                            |--doc.go
							|--field.go
                            |--source.go
                            |--table.go

通过这种方式，目前已经实现了mysql，postgres，db2

数据源接口
//Dialect 数据库方言
type Dialect interface {
	Source(*BaseSource) (Source, error) //数据源
}

//Source 数据源,包含驱动信息，包信息，配置文件以及连接信息
type Source interface {
	Config() *config.JSON   //配置信息
	Key() string            //一般是连接信息
	DriverName() string     //驱动名，用于sql.Open的第1个参数
	ConnectName() string    //连接信息，用于sql.Open的第2个参数
	Table(*BaseTable) Table //获取具体表
}

具体实现Source接口时，可以组合BaseSource以简化具体实现Source接口的实现Table方法可以返回具体的表结构接口。可以看mysql包source.go的实现。

另外，连接信息依赖Config的依赖。目前Config需要用下面的方式定义，否则无法使用dbms包来实现datax的插件，可以看mysql包config.go的实现。

type Config struct {
	URL      string `json:"url"`      //数据库url，包含数据库地址，数据库其他参数
	Username string `json:"username"` //用户名
	Password string `json:"password"` //密码
}

此外，需要使用init函数将具体Dialect注册

func init() {
	var d Dialect
	database.RegisterDialect(d.Name(), d)
}
表结构接口
//Table 表结构
type Table interface {
	fmt.Stringer

	Quoted() string   //引用的表名全称
	Instance() string //实例名，例如对于mysql就是数据库
	Schema() string   //模式名，例如对于oracle就是用户名（模式名）
	Name() string     //表名，例如对于mysql就是表
	Fields() []Field  //显示所有列
}

//FieldsFetcher Table的补充方法，用于特殊获取表的所有列
type FieldsFetcher interface {
	FetchFields(ctx context.Context, db *DB) error //获取具体列
}

//FieldAdder Table的补充方法，用于新增表的列
type FieldAdder interface {
	AddField(*BaseField) //新增具体列
}

//ExecParameter Table的补充方法，用于写模式获取生成sql语句的方法
type ExecParameter interface {
	ExecParam(string, *sql.TxOptions) (Parameter, bool)
}

具体实现Table接口时，可以组合BaseTable以简化具体Table接口的实现，其中Fields方法必须返回相应数据库的具体字段接口集合。具体可以看mysql包table.go的实现。

FetchFields和FieldAdder只可以实现一个，一般选择FieldAdder接口。ExecParameter可以用于实现批量入表的SQL语句，如对于mysql，可以实现replace into的方法插入，目前默认实现了普遍适用的insert方法，但是对于如实现oracle使用gora驱动的话，insert方法不适用于这种情况。

//Parameter 带有表，事务模式，sql语句的执行参数
type Parameter interface {
	Table() Table                                 //表或者视图
	TxOptions() *sql.TxOptions                    //事务模式
	Query([]element.Record) (string, error)       //sql prepare语句
	Agrs([]element.Record) ([]interface{}, error) //prepare参数
}

如上对于实现replace into的方法插入需要实现Parameter，可以组合BaseParam简化具体实现Parameter接口的实现，可以参考mysql包table.go的实现。

字段接口
//Field 数据库字段
type Field interface {
	fmt.Stringer

	Index() int                   //索引
	Name() string                 //字段名
	Quoted() string               //引用字段名
	BindVar(int) string           //占位符号
	Select() string               //select字段名
	Type() FieldType              //字段类型
	Scanner() Scanner             //扫描器,用于将数据库对应数据转化成列
	Valuer(element.Column) Valuer //赋值器,用于将列转化成数据库对应数据
}

具体实现Field接口时，可以组合BaseField以简化具体实现Field接口的实现，Type()方法必须返回相应数据库的列类型，Scanner必须返回相应数据库的扫描器，Valuer须返回相应数据库的扫描器。具体可以看mysql包中field.go的实现。

//ColumnType 列类型,抽象 sql.ColumnType，也方便自行实现对应函数
type ColumnType interface {
	Name() string                                   //列名
	ScanType() reflect.Type                         //扫描类型
	Length() (length int64, ok bool)                //长度
	DecimalSize() (precision, scale int64, ok bool) //精度
	Nullable() (nullable, ok bool)                  //是否为空
	DatabaseTypeName() string                       //列数据库类型名
}

//FieldType 字段类型
type FieldType interface {
	ColumnType

	IsSupportted() bool //是否支持该类型
}

具体实现FieldType接口时，可以组合BaseFieldType以简化具体实现FieldFieldType接口的实现，ColumnType在事实上是sql.ColumnType的抽象。具体可以看mysql包field.go的实现。

//Scanner 列数据扫描器 数据库驱动的值扫描成列数据
type Scanner interface {
	sql.Scanner

	Column() element.Column //获取列数据
}

具体实现Scanner的接口时,可以组合BaseFieldType以简化具体实现FieldType接口的实现,Scanner的作用将数据库驱动读取到的数据转化为单列的数据。具体可以看mysql包field.go的实现。

//Valuer 赋值器 将对应数据转化成数据库驱动的值
type Valuer interface {
	driver.Valuer
}

//ValuerGoType 用于赋值器的golang类型判定,是Field的可选功能，
//就是对对应驱动的值返回相应的值，方便GoValuer进行判定
type ValuerGoType interface {
	GoType() GoType
}

具体实现Valuer的接口时,可以组合GoValuer以简化具体实现Valuer接口的实现，使用GoValuer需要在数据库层Field实现ValuerGoType接口，Valuer的作用将单列的数据转化为数据库驱动写入的数据类型。具体可以看mysql包field.go的实现。

Documentation

Overview

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(
	func() (element.Record, error) {
		return element.NewDefaultRecord(), nil
	},
	func(r element.Record) error {
		gotRecords = append(gotRecords, r)
		return nil
	})); err != nil {
	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
}

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
}

要使用上述特性，各类实现标准库database/sql的接口的数据库 通过RegisterDialect通过名字注册一下数据库方言接口 当然数据库配置文件要满足Config的格式 

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 //获取具体表
}

当然这里可以使用BaseSource来简化Source的实现 数据源接口返回对应的表 Table 表结构 

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) //新增具体列
}

如果有特别的SQL获取列方式，则需要实现下列接口去获取 

type FieldsFetcher interface {
	FetchFields(ctx context.Context, db *DB) error //获取具体列
}

如果在批量处理数据时需要除了insert批量处理数据的语句，或者特殊的insert语句时,还需要实现下列接口 

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 //赋值器
}

当然这里可以使用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                       //列数据库类型名
}

扫描器接口Scanner是将数据库驱动底层的数据转化成列Column类型，用于读取数据 

type Scanner interface {
	sql.Scanner
	Column() element.Column //获取列数据
}

当然这里可以使用BaseScanner来简化Scanner的实现 赋值器接口Valuer是将列Column数据库转化成驱动底层的数据，用于处理数据 

type Valuer interface {
	driver.Valuer
}

特别地，如果使用GoValuer来作为赋值器Valuer的简单实现 那么需要在FieldType的基础上简单实现下列接口就可以实现对应的Valuer 

type ValuerGoType interface {
	GoType() GoType
}

通过上述内容的实现，我们就可以愉快的使用数据库

Index

Constants

View Source 
const (
	DefaultMaxOpenConns = 4
	DefaultMaxIdleConns = 4
)

默认参数

View Source 
const (
	WriteModeInsert = "insert"
)

写入数据库模式

Variables

View Source 
var (
	ErrNotValuerGoType = errors.New("field type is not ValuerGoType") //接口不是ValuerGoType的错误
)

字段错误相关

Functions

func RegisterDialect 

func RegisterDialect(name string, dialect Dialect)

RegisterDialect 注册数据库方言，当注册名称相同或者dialect为空时会panic

func UnregisterAllDialects 

func UnregisterAllDialects()

UnregisterAllDialects 注销所有的数据库方言

Types

type BaseFetchHandler 

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

BaseFetchHandler 基础获取记录句柄

func NewBaseFetchHandler 

func NewBaseFetchHandler(createRecord func() (element.Record, error),
	onRecord func(element.Record) error) *BaseFetchHandler

NewBaseFetchHandler 创建基础获取记录句柄

func (*BaseFetchHandler) CreateRecord 

func (b *BaseFetchHandler) CreateRecord() (element.Record, error)

CreateRecord 创建记录

func (*BaseFetchHandler) OnRecord 

func (b *BaseFetchHandler) OnRecord(r element.Record) error

OnRecord 处理记录r

type BaseField 

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

BaseField 基础字段，主要存储列名name和列类型fieldType

func NewBaseField 

func NewBaseField(index int, name string, fieldType FieldType) *BaseField

NewBaseField 根据列名name和列类型fieldType获取基础字段 用于嵌入其他Field，方便实现各个数据库的Field

func (*BaseField) FieldType 

func (b *BaseField) FieldType() FieldType

FieldType 返回字段类型

func (*BaseField) Index 

func (b *BaseField) Index() int

Index 返回字段名

func (*BaseField) Name 

func (b *BaseField) Name() string

Name 返回字段名

func (*BaseField) String 

func (b *BaseField) String() string

String 打印时显示字符串

type BaseFieldType 

type BaseFieldType struct {
	ColumnType
}

BaseFieldType 基础字段类型，嵌入其他各种数据库字段类型实现

func NewBaseFieldType 

func NewBaseFieldType(typ ColumnType) *BaseFieldType

NewBaseFieldType 获取字段类型

func (*BaseFieldType) IsSupportted 

func (*BaseFieldType) IsSupportted() bool

IsSupportted 是否支持被解析

type BaseParam 

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

BaseParam 基础参数，用于嵌入各类数据库sql参数的

func NewBaseParam 

func NewBaseParam(table Table, txOpts *sql.TxOptions) *BaseParam

NewBaseParam 通过表table和事务参数txOps生成基础参数

func (*BaseParam) SetTable added in v0.1.4 

func (b *BaseParam) SetTable(table Table)

SetTable 设置表

func (*BaseParam) Table 

func (b *BaseParam) Table() Table

Table 获取表

func (*BaseParam) TxOptions 

func (b *BaseParam) TxOptions() *sql.TxOptions

TxOptions 获取事务参数

type BaseScanner 

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

BaseScanner 基础扫描器，嵌入其他各种数据库扫描器实现

func (*BaseScanner) Column 

func (b *BaseScanner) Column() element.Column

Column 取得列值，方便统一取得列值

func (*BaseScanner) SetColumn 

func (b *BaseScanner) SetColumn(c element.Column)

SetColumn 设置列值，用于数据库方言的列数据设置

type BaseSource 

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

BaseSource 基础数据源，用于存储json配置文件 用于嵌入Source，方便实现各个数据库的Field

func NewBaseSource 

func NewBaseSource(conf *config.JSON) *BaseSource

NewBaseSource 通过json配置文件conf生成基础数据源

func (*BaseSource) Config 

func (b *BaseSource) Config() *config.JSON

Config 基础数据源的配置文件

type BaseTable 

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

BaseTable 基本表，用于嵌入各种数据库Table的实现

func NewBaseTable 

func NewBaseTable(instance, schema, name string) *BaseTable

NewBaseTable ，通过实例名，模式名，表明获取基本表

func (*BaseTable) AppendField 

func (b *BaseTable) AppendField(f Field)

AppendField 追加列

func (*BaseTable) Fields 

func (b *BaseTable) Fields() []Field

Fields 显示所有列

func (*BaseTable) Instance 

func (b *BaseTable) Instance() string

Instance 实例名，例如对于mysql就是数据库，对于oracle就是实例

func (*BaseTable) Name 

func (b *BaseTable) Name() string

Name 表名，例如对于mysql就是表

func (*BaseTable) Schema 

func (b *BaseTable) Schema() string

Schema 模式名，例如对于mysql就是数据库，对于oracle就是用户名

func (*BaseTable) String 

func (b *BaseTable) String() string

String 用于打印的显示字符串

type ColumnType 

type ColumnType interface {
	Name() string                                   //列名
	ScanType() reflect.Type                         //扫描类型
	Length() (length int64, ok bool)                //长度
	DecimalSize() (precision, scale int64, ok bool) //精度
	Nullable() (nullable, ok bool)                  //是否为空
	DatabaseTypeName() string                       //列数据库类型名
}

ColumnType 列类型,抽象 sql.ColumnType，也方便自行实现对应函数

type Config 

type Config struct {
	Pool PoolConfig `json:"pool"`
}

Config 数据库连接基础配置，一般用于sql.DB的配置

func NewConfig 

func NewConfig(conf *config.JSON) (c *Config, err error)

NewConfig 从Json配置中获取数据库连接配置c err是指Json配置无法转化为数据库连接配置

type DB 

type DB struct {
	Source
	// contains filtered or unexported fields
}

DB 用户维护数据库连接池

func NewDB 

func NewDB(source Source) (d *DB, err error)

NewDB 从数据源source中获取数据库连接池

func (*DB) BatchExec 

func (d *DB) BatchExec(ctx context.Context, opts *ParameterOptions) (err error)

BatchExec 批量执行sql并处理多行记录

func (*DB) BatchExecStmt 

func (d *DB) BatchExecStmt(ctx context.Context, opts *ParameterOptions) (err error)

BatchExecStmt 批量prepare/exec执行sql并处理多行记录

func (*DB) BatchExecStmtWithTx 

func (d *DB) BatchExecStmtWithTx(ctx context.Context, opts *ParameterOptions) (err error)

BatchExecStmtWithTx 批量事务prepare/exec执行sql并处理多行记录

func (*DB) BatchExecWithTx 

func (d *DB) BatchExecWithTx(ctx context.Context, opts *ParameterOptions) (err error)

BatchExecWithTx 批量事务执行sql并处理多行记录

func (*DB) BeginTx 

func (d *DB) BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error)

BeginTx 获取事务

func (*DB) Close 

func (d *DB) Close() (err error)

Close 关闭数据连接池

func (*DB) ExecContext 

func (d *DB) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)

ExecContext 执行query并获取结果

func (*DB) FetchRecord 

func (d *DB) FetchRecord(ctx context.Context, param Parameter, handler FetchHandler) (err error)

FetchRecord 通过上下文ctx，sql参数param以及记录处理函数onRecord 获取多行记录返回错误

func (*DB) FetchRecordWithTx 

func (d *DB) FetchRecordWithTx(ctx context.Context, param Parameter, handler FetchHandler) (err error)

FetchRecordWithTx 通过上下文ctx，sql参数param以及记录处理函数onRecord 使用事务获取多行记录并返回错误

func (*DB) FetchTable 

func (d *DB) FetchTable(ctx context.Context, t *BaseTable) (Table, error)

FetchTable 通过上下文ctx和基础表数据t，获取对应的表并会返回错误

func (*DB) FetchTableWithParam 

func (d *DB) FetchTableWithParam(ctx context.Context, param Parameter) (Table, error)

FetchTableWithParam 通过上下文ctx和sql参数param，获取对应的表并会返回错误

func (*DB) PingContext 

func (d *DB) PingContext(ctx context.Context) error

PingContext 通过query查询多行数据

func (*DB) QueryContext 

func (d *DB) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)

QueryContext 通过query查询多行数据

type DBWrapper 

type DBWrapper struct {
	*DB
	// contains filtered or unexported fields
}

DBWrapper 数据库连接池包装，用于复用相关的数据库连接池(单元到实例：user)

func Open 

func Open(name string, conf *config.JSON) (dw *DBWrapper, err error)

Open 通过数据库name和json配置conf 获取可以复用的数据库连接池包装,类似智能指针

func (*DBWrapper) Close 

func (d *DBWrapper) Close() (err error)

Close 释放数据库连接池，如果有多个引用，则不会关闭该数据库连接池，没有引用时就直接关闭

type Dialect 

type Dialect interface {
	Source(*BaseSource) (Source, error) //数据源
}

Dialect 数据库方言

type ExecParameter 

type ExecParameter interface {
	ExecParam(string, *sql.TxOptions) (Parameter, bool)
}

ExecParameter Table的补充方法，用于写模式获取生成sql语句的方法

type FetchHandler 

type FetchHandler interface {
	OnRecord(element.Record) error
	CreateRecord() (element.Record, error)
}

FetchHandler 获取记录句柄

type Field 

type Field interface {
	fmt.Stringer

	Index() int                   //索引
	Name() string                 //字段名
	Quoted() string               //引用字段名
	BindVar(int) string           //占位符号, 从1开始
	Select() string               //select字段名
	Type() FieldType              //字段类型
	Scanner() Scanner             //扫描器
	Valuer(element.Column) Valuer //赋值器
}

Field 数据库字段

type FieldAdder 

type FieldAdder interface {
	AddField(*BaseField) //新增具体列
}

FieldAdder Table的补充方法，用于新增表的列

type FieldType 

type FieldType interface {
	ColumnType

	IsSupportted() bool //是否支持
}

FieldType 字段类型

type FieldsFetcher 

type FieldsFetcher interface {
	FetchFields(ctx context.Context, db *DB) error //获取具体列
}

FieldsFetcher Table的补充方法，用于特殊获取表的所有列

type GoType 

type GoType uint8

GoType golang的类型 

const (
	GoTypeUnknown GoType = iota //未知类型
	GoTypeBool                  //布尔类型
	GoTypeInt64                 //Int64类型
	GoTypeFloat64               //Float64类型
	GoTypeString                //字符串类型
	GoTypeBytes                 //字节流类型
	GoTypeTime                  //时间类型
)

golang的类型枚举

func (GoType) String 

func (t GoType) String() string

String golang的类型枚举字符串描述

type GoValuer 

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

GoValuer 使用GoType类型生成赋值器，主要通过字段f和传入参数列值c来 完成使用GoType类型生成赋值器,方便实现GoValuer

func NewGoValuer 

func NewGoValuer(f Field, c element.Column) *GoValuer

NewGoValuer 主要通过字段f和传入参数列值c来完成使用GoType类型生成赋值器的生成

func (*GoValuer) Value 

func (g *GoValuer) Value() (driver.Value, error)

Value 根据ValuerGoType生成对应的驱动接受的值

type InsertParam 

type InsertParam struct {
	*BaseParam
}

InsertParam 插入参数

func NewInsertParam 

func NewInsertParam(t Table, txOps *sql.TxOptions) *InsertParam

NewInsertParam 通过表table和事务参数txOps插入参数

func (*InsertParam) Agrs 

func (i *InsertParam) Agrs(records []element.Record) (valuers []interface{}, err error)

Agrs 通过多条记录 records生成批量插入参数

func (*InsertParam) Query 

func (i *InsertParam) Query(records []element.Record) (query string, err error)

Query 通过多条记录 records生成批量插入sql语句

type Judger 

type Judger interface {
	schedule.RetryJudger

	ShouldOneByOne(err error) bool
}

Judger 错误判断器

type Parameter 

type Parameter interface {
	SetTable(Table)                               //设置表或者视图
	Table() Table                                 //表或者视图
	TxOptions() *sql.TxOptions                    //事务模式
	Query([]element.Record) (string, error)       //sql prepare语句
	Agrs([]element.Record) ([]interface{}, error) //prepare参数
}

Parameter 带有表，事务模式，sql语句的执行参数

type ParameterOptions 

type ParameterOptions struct {
	Table     Table            //表或者视图
	Mode      string           //写入模式，例如mysql
	TxOptions *sql.TxOptions   //事务模式
	Records   []element.Record //写入行
}

ParameterOptions 参数选项

type PoolConfig 

type PoolConfig struct {
	MaxOpenConns    int            `json:"maxOpenConns"`    //最大打开连接数
	MaxIdleConns    int            `json:"maxIdleConns"`    //最大空闲时连接数
	ConnMaxIdleTime time2.Duration `json:"connMaxIdleTime"` //最大连接空闲时间
	ConnMaxLifetime time2.Duration `json:"connMaxLifetime"` //最大连接存活时间
}

PoolConfig 数据库连接池配置 一般让最大打开连接数和最大空闲时连接数一致，否则会导致释放连接不及导致文件数不足

func (*PoolConfig) GetMaxIdleConns 

func (c *PoolConfig) GetMaxIdleConns() int

GetMaxIdleConns 获取空闲时最大连接数，默认返回为4

func (*PoolConfig) GetMaxOpenConns 

func (c *PoolConfig) GetMaxOpenConns() int

GetMaxOpenConns 获取最大连接数，默认返回值为4

type Scanner 

type Scanner interface {
	sql.Scanner

	Column() element.Column //获取列数据
}

Scanner 列数据扫描器 数据库驱动的值扫描成列数据

type Source 

type Source interface {
	Config() *config.JSON   //配置信息
	Key() string            //一般是连接信息
	DriverName() string     //驱动名，用于sql.Open的第1个参数
	ConnectName() string    //连接信息，用于sql.Open的第2个参数
	Table(*BaseTable) Table //获取具体表
}

Source 数据源,包含驱动信息，包信息，配置文件以及连接信息

func NewSource 

func NewSource(name string, conf *config.JSON) (source Source, err error)

NewSource 通过数据库方言的名字获取对应数据源

type Table 

type Table interface {
	fmt.Stringer

	Quoted() string   //引用的表名全称
	Instance() string //实例名，例如对于mysql就是数据库
	Schema() string   //模式名，例如对于oracle就是用户名（模式名）
	Name() string     //表名，例如对于mysql就是表
	Fields() []Field  //显示所有列
}

Table 表结构

type TableConfigSetter 

type TableConfigSetter interface {
	SetConfig(conf *config.JSON)
}

TableConfigSetter Table的补充方法，用于设置json配置文件

type TableQueryParam 

type TableQueryParam struct {
	*BaseParam
}

TableQueryParam 表结构查询参数

func NewTableQueryParam 

func NewTableQueryParam(table Table) *TableQueryParam

NewTableQueryParam 通过表Table生成表结构查询参数

func (*TableQueryParam) Agrs 

func (t *TableQueryParam) Agrs(_ []element.Record) (a []interface{}, err error)

Agrs 生成参数，不过为空

func (*TableQueryParam) Query 

func (t *TableQueryParam) Query(_ []element.Record) (s string, err error)

Query 生成select * from table where 1=2来获取表结构

type Valuer 

type Valuer interface {
	driver.Valuer
}

Valuer 赋值器 将对应数据转化成数据库驱动的值

type ValuerGoType 

type ValuerGoType interface {
	GoType() GoType
}

ValuerGoType 用于赋值器的golang类型判定,是Field的可选功能， 就是对对应驱动的值返回相应的值，方便GoValuer进行判定

type WithConnector 

type WithConnector interface {
	Connector() (driver.Connector, error) //go 1.10 获取连接
}

WithConnector 带有连接的数据源, 数据源优先调用该方法生成数据连接池DB

Source Files

View all Source files

Directories

Path Synopsis
Package db2 实现了db2的数据库方言Dialect，支持db2 10.x+ 对应数据库
 Package db2 实现了db2的数据库方言Dialect，支持db2 10.x+ 对应数据库
Package mysql 实现了mysql的数据库方言Dialect，支持mysql 5.6+ 对应数据库 驱动为github.com/go-sql-driver/mysql 数据源Source使用BaseSource来简化实现, 对github.com/go-sql-driver/mysql 驱动进行包装.对于数据库配置，需要和Config一致 表Table使用BaseTable来简化实现,也是基于github.com/go-sql-driver/mysql的 封装,Table实现了FieldAdder的方式去获取列,在ExecParameter中实现写入模式为 replace的repalce into批量数据处理模式,写入模式为insert的插入模式复用 已有的database.InsertParam 列Field使用BaseField来简化实现,其中FieldType采用了原来的sql.ColumnType， 并实现了ValuerGoType 扫描器Scanner使用BaseScanner来简化实现 赋值器Valuer 使用了GoValuer的实现方式
 Package mysql 实现了mysql的数据库方言Dialect，支持mysql 5.6+ 对应数据库 驱动为github.com/go-sql-driver/mysql 数据源Source使用BaseSource来简化实现, 对github.com/go-sql-driver/mysql 驱动进行包装.对于数据库配置，需要和Config一致 表Table使用BaseTable来简化实现,也是基于github.com/go-sql-driver/mysql的 封装,Table实现了FieldAdder的方式去获取列,在ExecParameter中实现写入模式为 replace的repalce into批量数据处理模式,写入模式为insert的插入模式复用 已有的database.InsertParam 列Field使用BaseField来简化实现,其中FieldType采用了原来的sql.ColumnType， 并实现了ValuerGoType 扫描器Scanner使用BaseScanner来简化实现 赋值器Valuer 使用了GoValuer的实现方式
Package oracle 实现了oracle的数据库方言Dialect，支持oracle 10.5+ 对应数据库
 Package oracle 实现了oracle的数据库方言Dialect，支持oracle 10.5+ 对应数据库
Package postgres 实现了postgres的数据库方言Dialect，支持postgres 8.0+ 对应数据库
 Package postgres 实现了postgres的数据库方言Dialect，支持postgres 8.0+ 对应数据库
Package sqlserver 实现了sqlserver的数据库方言Dialect，支持mssql 2005+ 对应数据库
 Package sqlserver 实现了sqlserver的数据库方言Dialect，支持mssql 2005+ 对应数据库

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.