databricks

type Auth interface {
	Configure(config *databricks.Config)
}

type DatabricksConf struct {
	WorkspaceUrl string
	Auth         Auth
	WarehouseId  string
}

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

type Executor interface {
	stdsql.StdSqlExecutor
}

type OAuthM2mAuth struct {
	ClientId     string
	ClientSecret string
}

type Pacing struct {
	// FirstInterval is the spacing adopted the first time a request is refused.
	// Until then a workspace is unpaced and runs at whatever the callers and the
	// SDK's own client-side limiter allow, so a workspace that is never refused pays
	// nothing for any of this.
	FirstInterval time.Duration
	// MaxInterval caps the spacing. Past it, waiting longer no longer buys a caller
	// anything its own deadline will not decide first.
	MaxInterval time.Duration
	// MaxPause caps how long one refusal may hold requests back, and with it the
	// Retry-After the API asks for. A wait longer than this outlives the per-attempt
	// timeout the SDK puts on a request, so honouring it verbatim would turn a
	// refusal into a request that times out mid-flight instead of one that waits.
	MaxPause time.Duration
	// DecayAfter is how many consecutive accepted requests it takes to halve the
	// spacing again. The quota is shared with everything else running against the
	// workspace, so a client has to keep probing back towards full speed rather than
	// stay slow for the rest of the process's life.
	DecayAfter int
	// MaxAttempts bounds how many times one request may be refused before the error
	// is handed to the caller.
	MaxAttempts int
	// WaitBudget bounds how long one request may spend held back across all of its
	// attempts. It exists for the same reason as MaxPause: the waiting happens inside
	// the SDK's per-attempt timeout, so it cannot be unbounded.
	WaitBudget time.Duration
}

type RateLimitedError struct {
	// StatusCode, ErrorCode and Message are what the workspace answered with. They are
	// deliberately not part of Error(): the SDK re-sends any error whose *text*
	// contains REQUEST_LIMIT_EXCEEDED — a workaround for SCIM answering 500 on a rate
	// limit — and it runs that check on whatever error the transport hands back. An
	// error quoting the API's own code or message would therefore go straight back
	// under the blind five-minute retry this type exists to prevent. Callers that want
	// them in a log line read the fields.
	StatusCode int
	ErrorCode  string
	Message    string
	// RetryAfter is the wait the API last asked for, zero when it asked for nothing.
	RetryAfter time.Duration
	// Attempts is how many times the request was sent and refused.
	Attempts int
	// Waited is how long this request spent held back before giving up.
	Waited time.Duration
}

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

type ThrottleStats struct {
	// Refusals is how many requests the workspace refused for exceeding its quota.
	Refusals int
	// Waited is the total time requests spent held back. It sums over concurrent
	// requests, so it can exceed the wall clock of the run.
	Waited time.Duration
	// Interval is the spacing currently handed out. Zero means unpaced.
	Interval time.Duration
}

type TokenAuth struct {
	Token string
}