Struct mz_catalog::memory::objects::Source

pub struct Source {
    pub create_sql: Option<String>,
    pub global_id: GlobalId,
    pub data_source: DataSourceDesc,
    pub desc: RelationDesc,
    pub timeline: Timeline,
    pub resolved_ids: ResolvedIds,
    pub custom_logical_compaction_window: Option<CompactionWindow>,
    pub is_retained_metrics_object: bool,
}

Fields

create_sql: Option<String>

Parse-able SQL that defines this table.

global_id: GlobalId

GlobalId used to reference this source from outside the catalog.

data_source: DataSourceDesc

desc: RelationDesc

RelationDesc of this source, derived from the create_sql.

timeline: Timeline

The timeline this source exists on.

resolved_ids: ResolvedIds

Other catalog objects referenced by this table, e.g. custom types.

custom_logical_compaction_window: Option<CompactionWindow>

This value is ignored for subsources, i.e. for DataSourceDesc::IngestionExport. Instead, it uses the primary sources logical compaction window.

is_retained_metrics_object: bool

Whether the source’s logical compaction window is controlled by METRICS_RETENTION

Implementations

impl Source

pub fn new( plan: CreateSourcePlan, global_id: GlobalId, resolved_ids: ResolvedIds, custom_logical_compaction_window: Option<CompactionWindow>, is_retained_metrics_object: bool, ) -> Source

Creates a new Source.

Panics

• If an ingestion-based plan is not given a cluster_id.
• If a non-ingestion-based source has a defined cluster config in its plan.
• If a non-ingestion-based source is given a cluster_id.

pub fn source_type(&self) -> &str

Type of the source.

pub fn connection_id(&self) -> Option<CatalogItemId>

Connection ID of the source, if one exists.

pub fn global_id(&self) -> GlobalId

The single GlobalId that refers to this Source.

pub fn user_controllable_persist_shard_count(&self) -> i64

The expensive resource that each source consumes is persist shards. To prevent abuse, we want to prevent users from creating sources that use an unbounded number of persist shards. But we also don’t want to count persist shards that are mandated by teh system (e.g., the progress shard) so that future versions of Materialize can introduce additional per-source shards (e.g., a per-source status shard) without impacting the limit calculation.

Trait Implementations

impl Clone for Source

fn clone(&self) -> Source

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Source

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Serialize for Source

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.