planner

type ModulePlan struct {
	Instruction map[string]interface{}

	// Which module is this execution plan generated for
	*module.Module

	// Scope at the module level
	ModuleScope *Scope

	// The execution plan of the submodule
	SubModulesPlan []*ModulePlan

	// The execution plan of the rule under this module
	RulesPlan []*RulePlan
}

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

type ModulePlannerOptions struct {
	Instruction map[string]interface{}
	// make plan for which module
	Module *module.Module

	// Table to Provider mapping
	TableToProviderMap map[string]string
}

type Planner[T any] interface {

	// Name The name of the planner
	Name() string

	// MakePlan Make a plan
	MakePlan(ctx context.Context) (T, *schema.Diagnostics)
}

type ProviderContext struct {

	// Which provider is it?
	ProviderName string

	// Which version
	ProviderVersion string

	DSN string

	// The database stored to
	Schema string

	// A connection to a database instance
	Storage storage.Storage

	// The provider configuration block
	ProviderConfiguration *module.ProviderBlock
}

type ProviderFetchPlan struct {
	*ProviderInstallPlan

	// provider Configuration information used for fetching
	ProviderConfigurationBlock *module.ProviderBlock

	// Which schema to write data to
	FetchToDatabaseSchema string

	// The name of the configuration block to be used, which is left blank if not configured using a configuration file
	ProviderConfigurationName string

	// What is the MD5 of the configuration block if the provider configuration is used
	ProviderConfigurationMD5 string
}

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

type ProviderFetchPlannerOptions struct {

	// Which module is the execution plan being generated for
	Module *module.Module

	// Provider version that wins the vote
	ProviderVersionVoteWinnerMap map[string]string

	// DSNS are used to connect to the database to determine which schema to use when using environment variables
	DSN string

	// A place to send messages to the outside world
	MessageChannel *message.Channel[*schema.Diagnostics]
}

type ProviderInstallPlan struct {
	// Which version of which provider is to be used to pull data
	*registry.Provider
}

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

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

type ProviderVote struct {
	TotalVoteTimes      int
	ProviderName        string
	VersionVoteCountMap map[string]*VersionVoteSummary
	// contains filtered or unexported fields
}

type ProvidersFetchPlan []*ProviderFetchPlan

type ProvidersInstallPlan []*ProviderInstallPlan

type RulePlan struct {
	// The execution plan of the module to which it is associated
	ModulePlan *ModulePlan

	// The module to which it is associated
	Module *module.Module

	// Is the execution plan for which block
	*module.RuleBlock

	// Which provider is the rule bound to? Currently, a rule can be bound to only one provider
	BindingProviderName string

	// Render a good rule - bound Query
	Query string

	// Which tables are used in this Query
	BindingTables []string

	RuleScope *Scope
}

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

type RulePlannerOptions struct {

	// The execution plan of the module to which it is associated
	ModulePlan *ModulePlan

	// The module to which it is associated
	Module *module.Module

	// The scope of the owning module
	ModuleScope *Scope

	// Is the execution plan for which block
	RuleBlock *module.RuleBlock

	// Mapping between the table and the provider
	TableToProviderMap map[string]string
}

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

type VersionVoteSummary struct {

	// Which version
	ProviderVersion *version.Version

	// How many votes did you get
	VoteSet map[*module.Module]struct{}
}