gosql

type AnnuallyDbSelector struct {
}

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

type Cluster interface {
	Write(table string, key []byte, handler DBHandler, params ...interface{})
	Read(table string, key []byte, handler DBHandler, params ...interface{})
	GetShardsTotal() int
	TableSelector() TableSelector
}

type Config struct {
	ShardingConfig ShardingConfig
	ShardsConfig   []ShardConfig
}

type ConnConfig struct {
	MaxLifeTime  int
	MaxIdleConns int
	MaxOpenConns int
}

type DBHandler func(*sql.DB, int, *bytes.Buffer) error

type DailyDbSelector struct {
}

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

type DbConfig struct {
	Driver   string
	Dbname   string
	Protocol string
	Host     string
	User     string
	Password string
	Params   map[string]string
	Conn     ConnConfig
}

type DbExecutor func(*sql.DB, DBHandler, int, *bytes.Buffer)

type DbSelector interface {
	Select(int, string, ...interface{}) *bytes.Buffer
}

type Decoder interface {
	Decode(interface{}) error
}

type DynamicCluster struct {
	Re       map[string]*sql.DB
	Config   *Config
	Sharding Sharding
	Selector DbSelector
	Executor DbExecutor
	Lb       Replication
	// contains filtered or unexported fields
}

type MonthlyDbSelector struct {
}

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

type Partition interface {
	Partition([]byte, int) int
}

type Replication interface {
	Replicate(int) int
}

type RoundRobinSelector = distributed.RoundRobinSelector

type Shard interface {
	GetMaster() *sql.DB
	GetReplica() *sql.DB
	GetReplicaTotal() int
}

type ShardConfig struct {
	MasterConfig   DbConfig
	ReplicasConfig []DbConfig
}

type Sharding interface {
	Select(string, []byte, ...interface{}) (int, int, *bytes.Buffer)
	Allocation(int, string, ...interface{}) string
	GetDbname() string
	TableSelector() TableSelector
}

type ShardingConfig struct {
	Dbname string
	Total  int
	Type   string
	Table  []ShardingTableConfig
}

type ShardingTableConfig struct {
	Name  string
	Total int
}

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

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

type StaticCluster struct {
	Sharding Sharding
	Shards   []Shard
	Config   *Config
	Executor DbExecutor
}

type StaticShard struct {
	Master  *sql.DB
	Replica []*sql.DB
	// contains filtered or unexported fields
}

type TableSelector interface {
	Select(string, []byte, ...interface{}) (int, int, *bytes.Buffer)
	Pick(string, int, ...interface{}) *bytes.Buffer
	Total(string) int
}

type YamlClusterConfig struct {
	YamlDBConfig `yaml:",inline"`
	Sharding     YamlShardingConfig `yaml:"sharding"`
}

type YamlConfig struct {
	Cluster YamlClusterConfig   `yaml:"cluster"`
	Shards  []*YamlShardsConfig `yaml:"shards"`
}

type YamlConnConfig struct {
	MaxLifetime  int `yaml:"max_life_time"`
	MaxIdleConns int `yaml:"max_idle_conns"`
	MaxOpenConns int `yaml:"max_open_conns"`
}

type YamlDBConfig struct {
	Driver string         `yaml:"driver"`
	Dbname string         `yaml:"dbname"`
	Type   string         `yaml:"type"`
	Conn   YamlConnConfig `yaml:"conn"`
}

type YamlDecoder = yaml.Decoder

type YamlMasterConfig struct {
	Host           string `yaml:"host"`
	YamlNodeConfig `yaml:",inline"`
}

type YamlNodeConfig struct {
	User     string            `yaml:"user"`
	Password string            `yaml:"password"`
	Protocol string            `yaml:"protocol"`
	Params   map[string]string `yaml:"params"`
}

type YamlReplicasConfig struct {
	Hosts          []string `yaml:"hosts"`
	YamlNodeConfig `yaml:",inline"`
}

type YamlShardingConfig struct {
	DbTotal int                        `yaml:"total"`
	Table   []*YamlTableShardingConfig `yaml:"table"`
}

type YamlShardsConfig struct {
	Master   YamlMasterConfig   `yaml:"master"`
	Replicas YamlReplicasConfig `yaml:"replicas"`
}

type YamlTableShardingConfig struct {
	Name  string `yaml:"name"`
	Total int    `yaml:"total"`
}