scrapper

type Annotation struct {
	AnnotationName  string `json:"annotation_name"`
	AnnotationValue string `json:"annotation_value"`
}

type BigIntValue big.Int

type Capabilities struct {
	// ConstraintsViaQueryTables indicates that QueryTables with WithConstraints()
	// populates TableRow.Constraints, making a separate QueryTableConstraints call unnecessary.
	ConstraintsViaQueryTables bool
	// EstimateQuery describes EstimateQuery support for this dialect. Its zero
	// value means EstimateQuery returns ErrUnsupported. Callers should consult
	// this before calling EstimateQuery so they can pick an appropriate UI
	// ("this will scan ~X bytes" vs "~Y rows") or skip the call entirely.
	EstimateQuery EstimateQueryCapability
	// PlatformUsers describes QueryPlatformUsers support. Its zero value means
	// the platform has no user listing and QueryPlatformUsers returns
	// ErrUnsupported, so a caller never calls it.
	PlatformUsers PlatformUsersCapability
}

type CatalogColumnRow struct {
	Instance           string  `db:"instance"             json:"instance"             ch:"instance"             bigquery:"instance"`
	Database           string  `db:"database"             json:"database"             ch:"_database"            bigquery:"database"`
	Schema             string  `db:"schema"               json:"schema"               ch:"schema"               bigquery:"schema"`
	Table              string  `db:"table"                json:"table"                ch:"table"                bigquery:"table"`
	IsView             bool    `db:"is_view"              json:"is_view"              ch:"is_view"              bigquery:"is_view"`
	IsTable            bool    `db:"is_table"             json:"is_table"             ch:"is_table"             bigquery:"is_table"`
	IsMaterializedView bool    `db:"is_materialized_view" json:"is_materialized_view" ch:"is_materialized_view" bigquery:"is_materialized_view"`
	TableType          string  `db:"table_type"           json:"table_type"           ch:"table_type"           bigquery:"table_type"`
	Column             string  `db:"column"               json:"column"               ch:"column"               bigquery:"column"`
	Type               string  `db:"type"                 json:"type"                 ch:"type"                 bigquery:"type"`
	Position           int32   `db:"position"             json:"position"             ch:"position"             bigquery:"position"`
	Comment            *string `db:"comment"              json:"comment"              ch:"comment"              bigquery:"comment"`
	TableComment       *string `db:"table_comment"        json:"table_comment"        ch:"table_comment"        bigquery:"table_comment"`
	ColumnTags         []*Tag  `                          json:"column_tags"`
	TableTags          []*Tag  `                          json:"table_tags"`
	IsStructColumn     bool    `db:"is_struct_column"     json:"is_struct_column"     ch:"is_struct_column"     bigquery:"is_struct_column"`
	IsArrayColumn      bool    `db:"is_array_column"      json:"is_array_column"      ch:"is_array_column"      bigquery:"is_array_column"`
	FieldSchemas       []*SchemaColumnField
	// Precision and Scale are an exact numeric column's declared size, and
	// NumericCategory what kind of number the column holds, all filled by
	// ResolveNumeric. Both sizes are nil for every other column, and for a
	// numeric whose size the warehouse does not report: a nil scale is not a
	// scale of 0.
	Precision       *int64          `db:"numeric_precision" json:"precision,omitempty"        ch:"numeric_precision"`
	Scale           *int64          `db:"numeric_scale"     json:"scale,omitempty"            ch:"numeric_scale"`
	NumericCategory NumericCategory `                       json:"numeric_category,omitempty"`
}

type ColumnValue struct {
	Name   string
	Value  Value
	IsNull bool
}

type CustomMetricsRow struct {
	Segments     []*SegmentValue
	ColumnValues []*ColumnValue
}

type DatabaseRow struct {
	Instance      string  `db:"instance"       json:"instance"       ch:"instance"       bigquery:"instance"`
	Database      string  `db:"database"       json:"database"       ch:"_database"      bigquery:"database"`
	Description   *string `db:"description"    json:"description"    ch:"description"    bigquery:"description"`
	DatabaseType  *string `db:"database_type"  json:"database_type"  ch:"database_type"  bigquery:"database_type"`
	DatabaseOwner *string `db:"database_owner" json:"database_owner" ch:"database_owner" bigquery:"database_owner"`
}

type DoubleValue float64

type DwhFqn struct {
	InstanceName string
	DatabaseName string
	SchemaName   string
	ObjectName   string
}

type EstimateQueryCapability struct {
	// Supported is true when EstimateQuery may return a *QueryEstimate rather
	// than ErrUnsupported.
	Supported bool
	// ReportsBytes is true when the estimate can populate QueryEstimate.BytesScanned.
	ReportsBytes bool
	// ReportsRows is true when the estimate can populate QueryEstimate.Rows.
	ReportsRows bool
	// CanBeExact is true when the dialect is capable of authoritative estimates
	// rather than planner guesses (BigQuery dry-run). Individual estimates may
	// still come back with QueryEstimate.Exact=false (e.g. BigQuery non-PRECISE
	// accuracy); planner-based dialects are never exact. Planner estimates
	// depend on fresh table statistics and can be off by orders of magnitude.
	CanBeExact bool
}

type HasTableFqn interface {
	TableFqn() DwhFqn
}

type IgnoredValue struct{}

type InstanceHost struct {
	// Host is the hostname exactly as the warehouse reported it, including any
	// vendor domain suffix.
	Host string
	// Kind classifies the host, since one account is typically reachable under
	// several names that encode different identifier forms. One of the
	// InstanceHost* constants; empty when the warehouse gave no classification.
	Kind string
}

type InstanceIdentity struct {
	// Raw holds each value keyed by the warehouse construct that produced it
	// (the InstanceIdentity* constants). A key is absent when the warehouse did
	// not report it; no key is guaranteed present.
	Raw map[string]string
	// Hosts are the hostnames the warehouse reports for the instance itself.
	// Hostnames of unrelated infrastructure the instance happens to talk to
	// (object storage, OCSP responders) are not included.
	Hosts []InstanceHost
}

type InstanceIdentityQuerier interface {
	// QueryInstanceIdentity returns every form of its own identity the
	// warehouse will report. It returns ErrUnsupported when the platform has
	// no such concept.
	QueryInstanceIdentity(ctx context.Context) (*InstanceIdentity, error)
}

type IntValue int64

type JsonValue string

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

type MockScrapperCapabilitiesCall struct {
	*gomock.Call
}

type MockScrapperCloseCall struct {
	*gomock.Call
}

type MockScrapperDialectTypeCall struct {
	*gomock.Call
}

type MockScrapperEstimateQueryCall struct {
	*gomock.Call
}

type MockScrapperIsPermissionErrorCall struct {
	*gomock.Call
}

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

type MockScrapperQueryCatalogCall struct {
	*gomock.Call
}

type MockScrapperQueryCustomMetricsCall struct {
	*gomock.Call
}

type MockScrapperQueryDatabasesCall struct {
	*gomock.Call
}

type MockScrapperQueryPlatformUsersCall struct {
	*gomock.Call
}

type MockScrapperQuerySchemasCall struct {
	*gomock.Call
}

type MockScrapperQuerySegmentsCall struct {
	*gomock.Call
}

type MockScrapperQueryShapeCall struct {
	*gomock.Call
}

type MockScrapperQuerySqlDefinitionsCall struct {
	*gomock.Call
}

type MockScrapperQueryTableConstraintsCall struct {
	*gomock.Call
}

type MockScrapperQueryTableMetricsCall struct {
	*gomock.Call
}

type MockScrapperQueryTablesCall struct {
	*gomock.Call
}

type MockScrapperRunRawQueryCall struct {
	*gomock.Call
}

type MockScrapperSqlDialectCall struct {
	*gomock.Call
}

type MockScrapperValidateConfigurationCall struct {
	*gomock.Call
}

type NoEnoughPermissionsError struct {
	Err error
}

type NumericCategory string

type PlatformUser struct {
	// Login is the name the platform authenticates, as the platform shows it.
	// It is the same string query history reports as the user who ran a
	// statement, so the two can be joined.
	Login string `json:"login"`
	// PlatformId is the platform's own stable id for the user, where it has
	// one that survives a rename (Snowflake USER_ID, Databricks SCIM id,
	// Postgres oid).
	PlatformId string `json:"platform_id,omitempty"`
	// Type is the kind of login as the platform states it; see the
	// PlatformUserType* constants for the platforms that have one.
	Type string `json:"type,omitempty"`
	// Email the platform holds for the user.
	Email string `json:"email,omitempty"`
	// DisplayName is the user's name for humans, where it differs from Login.
	DisplayName string `json:"display_name,omitempty"`
	// Comment is the free-text description an administrator left on the user.
	// It often says what a service login is for.
	Comment string `json:"comment,omitempty"`
	// Disabled is true when the login exists but cannot sign in (disabled,
	// locked or expired, as the platform reports it). Nil when unknown.
	Disabled *bool `json:"disabled,omitempty"`
	// CreatedAt is when the user was created. Nil when unknown.
	CreatedAt *time.Time `json:"created_at,omitempty"`
	// LastLoginAt is the user's last successful sign-in. Nil when unknown or
	// never.
	LastLoginAt *time.Time `json:"last_login_at,omitempty"`
	// DefaultRole is the role a session starts with.
	DefaultRole string `json:"default_role,omitempty"`
	// Roles are the roles or groups granted to the user directly, sorted and
	// without duplicates. Roles say a lot about what a login is for
	// (LOADER, TRANSFORMER, REPORTER).
	Roles []string `json:"roles,omitempty"`
}

type PlatformUserFact string

type PlatformUserListing struct {
	// Source names where the listing was read, as <platform>.<source>
	// ("snowflake.account_usage.users", "bigquery.iam_policy"). A reconciled
	// listing has PlatformUsersReconciledSource.
	Source string `json:"source"`
	// Kind says whether the source is SQL or an API. Empty on a reconciled
	// listing.
	Kind PlatformUserSourceKind `json:"kind,omitempty"`
	// Refused is set, with the platform's error, when the source refused the
	// connecting role: a grant would let it answer.
	Refused string `json:"refused,omitempty"`
	// Unavailable is set when this platform's version or edition has no such
	// source (a view, a column or an API it lacks): no grant fixes it.
	Unavailable string `json:"unavailable,omitempty"`
	// Failed is set when reading the source failed for any other reason (a
	// timeout, a 5xx, a dropped connection): a later attempt may answer.
	//
	// A listing with any of Refused, Unavailable or Failed set holds no users
	// and claims no completeness; see Answered.
	Failed string `json:"failed,omitempty"`

	// Users sorted by Login, one per login.
	Users []*PlatformUser `json:"users"`
	// Completeness says how much of the platform's users the listing holds.
	Completeness PlatformUsersCompleteness `json:"completeness,omitempty"`
	// CompletenessReason explains a limited, empty or unknown listing, and
	// names the grant that would complete it where one would.
	CompletenessReason string `json:"completeness_reason,omitempty"`
	// SkippedFacts lists the facts the listing could not read in full, with
	// the kind of skip and the reason: absent on the platform, refused for
	// every user, hidden for the users the role may not see the details of
	// (Snowflake SHOW USERS), or read only in part (Redshift group roles
	// without its RBAC roles). A fact a user simply does not have (a user
	// without an email) is not listed.
	SkippedFacts []SkippedPlatformUserFact `json:"skipped_facts,omitempty"`
	// contains filtered or unexported fields
}

type PlatformUserSkipKind string

type PlatformUserSourceKind string

type PlatformUsers struct {
	// Sources in the order the platform trusts them, most trusted first:
	// Reconcile takes a fact from the first source that has it.
	Sources []*PlatformUserListing `json:"sources"`
}

type PlatformUsersCapability struct {
	// Supported is true when QueryPlatformUsers may return a listing rather
	// than ErrUnsupported.
	Supported bool `json:"supported"`
	// Grant names, in the platform's own terms, what lets the connecting role
	// read every user and every fact, so a caller can quote it in a
	// recommendation ("grant X to see all your users").
	Grant string `json:"grant,omitempty"`
}

type PlatformUsersCompleteness string

type QueryEstimate struct {
	// BytesScanned is the estimated number of bytes the query would read/process.
	BytesScanned *int64
	// Rows is a planner estimate of rows processed, intended as a scan-size
	// proxy. Where the engine exposes a plan tree (Postgres) this is the
	// largest per-node estimate — i.e. the heaviest scan — rather than the
	// final result cardinality, which collapses to 1 for aggregates.
	Rows *int64
	// Exact is true only when authoritative rather than a planner estimate
	// (BigQuery dry-run: TotalBytesProcessed, with TotalBytesProcessedAccuracy).
	Exact bool
}

type QueryShapeColumn struct {
	Name       string `json:"name"`
	NativeType string `json:"native_type"`
	Position   int32  `json:"position"`
	// Kind is what NativeType means on this warehouse, filled in by
	// RunRawQuery and QueryShape. Pass it to SqlLiteral to write a value of
	// this column back into SQL. KindUnknown when the type is not one
	// NativeValueKind recognises.
	Kind ValueKind `json:"kind,omitempty"`
	// Precision and Scale are an exact numeric column's declared size
	// (KindNumeric), from the driver (sql.ColumnType.DecimalSize) or, when it
	// reports none, from NativeType (DECIMAL(20,6)). Both are nil for every
	// other kind, and for a numeric whose size is not known: one declared
	// without it (a Postgres NUMERIC, an Oracle NUMBER), or one whose driver
	// reports neither and names it bare (Databricks, Athena). A nil scale is
	// not a scale of 0.
	Precision *int64 `json:"precision,omitempty"`
	Scale     *int64 `json:"scale,omitempty"`
	// SinglePrecision marks a KindFloat column that holds a single-precision
	// float (IsSinglePrecisionFloat), about 7 significant digits rather than a
	// double's 15. Always false for every other kind.
	SinglePrecision bool `json:"single_precision,omitempty"`
}

type QueryTablesConfig struct {
	IncludeConstraints bool
}

type QueryTablesOption func(*QueryTablesConfig)

type RawQueryRowIterator interface {
	// Columns describes the shape of the result. Stable for the lifetime of
	// the iterator — valid before the first Next call and unchanged after.
	Columns() []*QueryShapeColumn

	// Next returns the next row or io.EOF when exhausted.
	//
	// The returned slice is positional with Columns(); each cell is a fresh
	// *ColumnValue the caller may retain. NULL cells have IsNull=true and
	// Value=nil.
	//
	// Implementations MUST auto-close resources before returning io.EOF.
	// Safe to call after EOF (keeps returning io.EOF).
	Next(ctx context.Context) ([]*ColumnValue, error)

	// Close releases the underlying cursor / driver rows / warehouse job.
	// Safe to call multiple times.
	Close() error
}

type SchemaColumnField struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Human readable name of the column as present in dbt or data warehouse.
	HumanName string `protobuf:"bytes,2,opt,name=human_name,json=humanName,proto3" json:"human_name,omitempty"`
	// Native data type of the column as present in data warehouse.
	NativeType string `protobuf:"bytes,4,opt,name=native_type,json=nativeType,proto3" json:"native_type,omitempty"`
	// Description of the column
	Description *string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
	// Ordinal position of the column in the table, starting from 1
	OrdinalPosition int32 `protobuf:"varint,6,opt,name=ordinal_position,json=ordinalPosition,proto3" json:"ordinal_position,omitempty"`
	// Indicates that the column type could be used as a struct/json in a data warehouse
	IsStruct bool `protobuf:"varint,7,opt,name=is_struct,json=isStruct,proto3" json:"is_struct,omitempty"`
	// Indicates that the column is a repeated field in a data warehouse (e.g. array)
	IsRepeated bool `protobuf:"varint,8,opt,name=is_repeated,json=isRepeated,proto3" json:"is_repeated,omitempty"`
	// Fields inside of the struct/record like column
	Fields []*SchemaColumnField `protobuf:"bytes,9,rep,name=fields,proto3" json:"fields,omitempty"`
}

type SchemaRow struct {
	Instance    string  `db:"instance"     json:"instance"     ch:"instance"     bigquery:"instance"`
	Database    string  `db:"database"     json:"database"     ch:"_database"    bigquery:"database"`
	Schema      string  `db:"schema"       json:"schema"       ch:"schema"       bigquery:"schema"`
	Description *string `db:"description"  json:"description"  ch:"description"  bigquery:"description"`
	SchemaType  *string `db:"schema_type"  json:"schema_type"  ch:"schema_type"  bigquery:"schema_type"`
	SchemaOwner *string `db:"schema_owner" json:"schema_owner" ch:"schema_owner" bigquery:"schema_owner"`
}

type Scrapper interface {
	DialectType() string
	SqlDialect() sqldialect.Dialect
	IsPermissionError(err error) bool
	// Capabilities returns what this scrapper supports beyond the base interface.
	Capabilities() Capabilities
	ValidateConfiguration(ctx context.Context) (warnings []string, err error)
	QueryCatalog(ctx context.Context) ([]*CatalogColumnRow, error)
	QueryTableMetrics(ctx context.Context, lastMetricsFetchTime time.Time) ([]*TableMetricsRow, error)
	QuerySqlDefinitions(ctx context.Context) ([]*SqlDefinitionRow, error)
	QueryTables(ctx context.Context, opts ...QueryTablesOption) ([]*TableRow, error)
	QueryDatabases(ctx context.Context) ([]*DatabaseRow, error)
	// QuerySchemas lists the schemas (or the warehouse concept mapped to a
	// schema, e.g. ClickHouse databases, BigQuery datasets, Oracle users)
	// visible to the connection. Scope filtering is driven by the context
	// (scope.WithScope) exactly like QueryTables, not by a parameter.
	QuerySchemas(ctx context.Context) ([]*SchemaRow, error)
	QuerySegments(ctx context.Context, sql string, args ...any) ([]*SegmentRow, error)
	QueryCustomMetrics(ctx context.Context, sql string, args ...any) ([]*CustomMetricsRow, error)
	QueryShape(ctx context.Context, sql string) ([]*QueryShapeColumn, error)
	// RunRawQuery executes an arbitrary user-supplied SELECT and returns a
	// streaming iterator over typed rows. Unlike QueryCustomMetrics it does
	// not filter segment* columns and does not collapse text columns to
	// IgnoredValue — it is designed for generic "run this query" surfaces
	// rather than the agent's metrics/profile/segments path.
	//
	// The caller must Close() the iterator. Callers that want a row cap
	// should stop iteration after N calls to Next().
	RunRawQuery(ctx context.Context, sql string) (RawQueryRowIterator, error)
	// EstimateQuery returns a pre-execution scan estimate for an arbitrary
	// SELECT, or ErrUnsupported when the dialect cannot estimate reliably.
	// It must obtain the estimate from engine metadata (dry-run / EXPLAIN) and
	// MUST NOT execute the query. Consult Capabilities().EstimateQuery to learn
	// which dimensions (bytes vs rows) a given dialect can populate.
	EstimateQuery(ctx context.Context, sql string) (*QueryEstimate, error)
	QueryTableConstraints(ctx context.Context) ([]*TableConstraintRow, error)
	// QueryPlatformUsers lists the platform's users (logins) with every fact
	// the platform states about them, one listing per source. It returns
	// ErrUnsupported when Capabilities().PlatformUsers is not supported.
	// Otherwise a source the role may not read, that this version lacks, or
	// that failed is a state of the result (PlatformUserListing.Refused,
	// Unavailable, Failed), and a fact that cannot be read is skipped with the
	// reason: the call fails only on a real failure of the connection (see
	// CollectPlatformUsers). Users are not scoped: scope.WithScope selects
	// tables, not logins.
	QueryPlatformUsers(ctx context.Context) (*PlatformUsers, error)
	// This will close underlying execer, such scrapper can't be used anymore
	Close() error
}

type SegmentRow struct {
	Segment string `db:"segment"`
	Count   *int64 `db:"num_rows"`
}

type SegmentValue struct {
	Name  string
	Value string
}

type SkippedPlatformUserFact struct {
	Fact PlatformUserFact `json:"fact"`
	// Kind says whether a grant would let the fact be read. Empty only on a
	// listing stored before skips had a kind, which says nothing either way.
	Kind   PlatformUserSkipKind `json:"kind,omitempty"`
	Reason string               `json:"reason"`
}

type SqlDefinitionRow struct {
	Instance           string  `db:"instance"             json:"instance"              ch:"instance"             bigquery:"instance"`
	Database           string  `db:"database"             json:"database"              ch:"_database"            bigquery:"database"`
	Schema             string  `db:"schema"               json:"schema"                ch:"schema"               bigquery:"schema"`
	Table              string  `db:"table"                json:"table"                 ch:"table"                bigquery:"table"`
	IsView             bool    `db:"is_view"              json:"is_view"               ch:"is_view"              bigquery:"is_view"`
	IsTable            bool    `db:"is_table"             json:"is_table"              ch:"is_table"             bigquery:"is_table"`
	IsMaterializedView bool    `db:"is_materialized_view" json:"is_materialized_view"  ch:"is_materialized_view" bigquery:"is_materialized_view"`
	TableType          string  `db:"table_type"           json:"table_type"            ch:"table_type"           bigquery:"table_type"`
	Sql                string  `db:"sql"                  json:"sql"                   ch:"sql"                  bigquery:"sql"`
	Description        *string `                          json:"description,omitempty"`
	Tags               []*Tag  `                          json:"tags,omitempty"`
}

type StringValue string

type TableChangeEvent struct {
	// When the change was committed. Use for time-travel AS OF.
	Timestamp time.Time

	// Database-specific version identifier.
	// Databricks: Delta version number. BigQuery: job_id. Snowflake: empty (hourly bucket).
	Version string

	// Type of operation: "INSERT", "UPDATE", "DELETE", "MERGE", "COPY", "TRUNCATE", "OTHER"
	Operation string

	// Row counts (nil if not available)
	RowsInserted *int64
	RowsUpdated  *int64
	RowsDeleted  *int64
}

type TableChangeHistoryProvider interface {
	FetchTableChangeHistory(
		ctx context.Context,
		fqn DwhFqn,
		from, to time.Time,
		limit int,
	) ([]*TableChangeEvent, error)
}

type TableConstraintRow struct {
	Instance             string `db:"instance"              json:"instance"              ch:"instance"              bigquery:"instance"`
	Database             string `db:"database"              json:"database"              ch:"_database"             bigquery:"database"`
	Schema               string `db:"schema"                json:"schema"                ch:"schema"                bigquery:"schema"`
	Table                string `db:"table"                 json:"table"                 ch:"table"                 bigquery:"table"`
	ConstraintName       string `db:"constraint_name"       json:"constraint_name"       ch:"constraint_name"       bigquery:"constraint_name"`
	ColumnName           string `db:"column_name"           json:"column_name"           ch:"column_name"           bigquery:"column_name"`
	ConstraintType       string `db:"constraint_type"       json:"constraint_type"       ch:"constraint_type"       bigquery:"constraint_type"`
	ColumnPosition       int32  `db:"column_position"       json:"column_position"       ch:"column_position"       bigquery:"column_position"`
	ConstraintExpression string `db:"constraint_expression" json:"constraint_expression" ch:"constraint_expression" bigquery:"constraint_expression"`
	IsEnforced           *bool  `db:"is_enforced"           json:"is_enforced"           ch:"is_enforced"           bigquery:"is_enforced"`
}

type TableMetricsRow struct {
	Instance  string     `db:"instance"   json:"instance"   ch:"instance"   bigquery:"instance"`
	Database  string     `db:"database"   json:"database"   ch:"_database"  bigquery:"database"`
	Schema    string     `db:"schema"     json:"schema"     ch:"schema"     bigquery:"schema"`
	Table     string     `db:"table"      json:"table"      ch:"table"      bigquery:"table"`
	RowCount  *int64     `db:"row_count"  json:"row_count"  ch:"row_count"  bigquery:"row_count"`
	UpdatedAt *time.Time `db:"updated_at" json:"updated_at" ch:"updated_at" bigquery:"updated_at"`
	SizeBytes *int64     `db:"size_bytes" json:"size_bytes" ch:"size_bytes" bigquery:"size_bytes"`
}

type TableRow struct {
	Instance           string                 `db:"instance"             json:"instance"             ch:"instance"             bigquery:"instance"`
	Database           string                 `db:"database"             json:"database"             ch:"_database"            bigquery:"database"`
	Schema             string                 `db:"schema"               json:"schema"               ch:"schema"               bigquery:"schema"`
	Table              string                 `db:"table"                json:"table"                ch:"table"                bigquery:"table"`
	TableType          string                 `db:"table_type"           json:"table_type"           ch:"table_type"           bigquery:"table_type"`
	Description        *string                `db:"description"          json:"description"          ch:"description"          bigquery:"description"`
	Tags               []*Tag                 `db:"tags"                 json:"tags"`
	IsView             bool                   `db:"is_view"              json:"is_view"              ch:"is_view"`
	IsTable            bool                   `db:"is_table"             json:"is_table"             ch:"is_table"`
	IsMaterializedView bool                   `db:"is_materialized_view" json:"is_materialized_view" ch:"is_materialized_view"`
	Options            map[string]interface{} `db:"options"              json:"options"`
	Annotations        []*Annotation          `db:"annotations"          json:"annotations"`

	// Constraints is optionally populated by QueryTables when WithConstraints() is passed.
	// When non-nil, callers may skip a separate QueryTableConstraints call.
	Constraints []*TableConstraintRow `json:"constraints,omitempty"`
}

type Tag struct {
	// Optionally prefix (`tag.` / `policytag.` / etc)
	TagName  string `json:"tag_name"`
	TagValue string `json:"tag_value"`
}

type TimeValue time.Time

type Unwrapper interface {
	Unwrap() Scrapper
}

type Value interface {
	// contains filtered or unexported methods
}

type ValueKind string

type WithSetInstance interface {
	SetInstance(instance string)
}