# Core Concepts

Understanding these fundamental concepts will help you get the most out of Euno.

***

## What is a Resource?

In Euno, everything in your data stack is represented as a **resource**.

A resource can be:

* 📊 A database table or view
* 📈 A dashboard or chart
* 🔄 A dbt model or transformation
* 📁 A schema or database
* 🔢 A column within a table
* 📝 A Looker Explore or Tableau workbook

**Key Point:** Euno discovers resources automatically from your connected data sources. You don't need to manually catalog anything.

### Resource Properties

Each resource has properties that describe it:

* **Identity Properties:** Name, URI, native ID
* **Descriptive Properties:** Description, owner, tags
* **Usage Properties:** Query counts, view counts, costs
* **Metadata Properties:** Last updated, created date, source

***

## Universal Resource Identifiers (URIs)

Every resource in Euno has a unique identifier called a **URI**.

### Why URIs Matter

URIs allow Euno to:

* Uniquely identify every resource across your entire data stack
* Connect resources across different platforms
* Track resources even when they're renamed
* Build accurate lineage relationships

### URI Structure

URIs follow a hierarchical pattern:

```
platform.technology.identifier.path.to.resource
```

**Examples:**

**Snowflake Table:**

```
table.snowflake.us_west_2.abc123.analytics_db.public.users
```

**dbt Model:**

```
dbt_model.abc123.my_dbt_project.main.stg_users
```

**Tableau Dashboard:**

```
tableau_workbook.my_server.sales_metrics
```

**Looker Dashboard:**

```
looker_dashboard.my_instance.executive_overview
```

### URI Components Explained

Let's break down a Snowflake table URI:

```
table.snowflake.us_west_2.abc123.analytics_db.public.users
  │      │          │       │         │         │      │
  │      │          │       │         │         │      └─ Table name
  │      │          │       │         │         └──────── Schema name
  │      │          │       │         └────────────────── Database name
  │      │          │       └──────────────────────────── Account ID
  │      │          └──────────────────────────────────── Region
  │      └─────────────────────────────────────────────── Technology
  └────────────────────────────────────────────────────── Resource type
```

> 💡 **Pro Tip:** URIs are always lowercase. Euno automatically normalizes names to ensure consistency.

For detailed URI formats by resource type, see [URI Structure Deep Dive](https://docs.euno.ai/developer-reference/technical-concepts/universal-resource-identifier-uri).

***

## Relationships Between Resources

Resources don't exist in isolation—they're connected through **relationships**.

### Types of Relationships

Euno tracks three primary relationship types:

#### 1. **Dependency** (Lineage)

Shows data flow from upstream → downstream.

**Example:**

```
raw.users → stg_users → dim_customers → revenue_dashboard
```

* `raw.users` is **upstream of** `stg_users`
* `revenue_dashboard` is **downstream of** `dim_customers`

**Questions this answers:**

* "What tables feed into this dashboard?"
* "If I change this table, what breaks?"
* "Where does this data come from?"

#### 2. **Containment** (Hierarchy)

Shows parent-child relationships.

**Example:**

```
Database
  └─ Schema
      └─ Table
          └─ Column
```

**Questions this answers:**

* "What columns are in this table?"
* "What tables are in this schema?"
* "What's the full path to this resource?"

#### 3. **Defined-by** (Logical Definition)

Shows which tool defines a resource's logic.

**Example:**

```
dim_customers (table) is defined by dim_customers (dbt model)
```

This means:

* The table exists in Snowflake
* But its logic is managed by dbt
* Changes should be made in dbt, not directly in Snowflake

**Questions this answers:**

* "Where is this table's transformation logic?"
* "Is this table managed by dbt?"
* "What's the source of truth for this resource?"

### Visualizing Relationships

Euno provides two ways to explore relationships:

1. **Graph View:** Visual representation of lineage
2. **Resource Detail Page:** Lists of upstream/downstream resources

For detailed relationship types and examples, see [Relationships Reference](https://docs.euno.ai/developer-reference/technical-concepts/relationships).

***

## Column-Level Lineage

Euno tracks relationships not just at the table/model level, but at the **column level**.

### Why Column Lineage Matters

Understanding column-level lineage helps you:

* Trace sensitive data (PII) through your entire pipeline
* Understand calculation dependencies
* Perform precise impact analysis
* Document data transformations

### Example

```
Source Table: raw.orders
  └─ Column: customer_id

Transformation: stg_orders (dbt model)
  └─ SQL: SELECT customer_id, ...
  └─ Column: customer_id

Final Table: dim_customers
  └─ Column: customer_key (derived from customer_id)

Dashboard: Tableau - Sales Report
  └─ Field: Customer Key
```

You can see exactly how `customer_id` flows from raw data → staging → dimensional model → BI dashboard.

***

## Resource Sponsorship & Lifecycle

Euno needs to know how to handle resources when they're no longer detected in a source integration.

### What is a Sponsor?

A **sponsor** is the source integration that discovered a resource.

**Example:**

* Your dbt integration discovers the `dim_customers` model
* dbt is now the **sponsor** of that resource
* If dbt stops detecting it, Euno can automatically clean it up

### Cleanup Strategies

You can configure how Euno handles resources that disappear:

#### **Time-Based Cleanup** (Default)

Remove resources that haven't been detected in X days (default: 7 days)

**Use when:** You want a grace period for temporary issues

#### **Immediate Cleanup**

Remove resources as soon as they're not detected

**Use when:** You want your catalog to always reflect current state

#### **No Cleanup**

Keep all resources indefinitely

**Use when:** You want to preserve historical resources for auditing

For more details, see [Resource Sponsorship & Cleanup](https://docs.euno.ai/developer-reference/technical-concepts/resource-sponsorship-and-cleanup-in-euno).

***

## Resource Types

Euno supports many resource types across different platforms:

* Databases, Schemas, Tables, Views, Columns, etc. from Data Warehouse resources
* Models, Metrics, Pipelines, etc. from Semantic Layers & ETL Tools
* Dashboards, Reports, Visualizations, Data Sources/Models, etc. from BI Tools

***

## Usage & Performance Metadata

Euno automatically collects usage data from your sources:

### Warehouse Usage

* **Query Count:** How many times was this queried?
* **Query Cost / Runtime:** (For supported integrations) How much did queries cost?
* **Storage:** How much space does this use?

### BI Usage

* **Impressions:** How many times was this viewed?
* **Users:** Who viewed this?
* **Last Accessed:** When was this last used?

### Transformation Performance

* **Build Time:** How long does this model take to build?
* **Build Status:** Did the last run succeed or fail?
* **Freshness:** Is the data up to date?

### Why This Matters

Usage data helps you:

* **Identify unused resources** → Candidates for deprecation
* **Find expensive queries** → Optimization opportunities
* **Prioritize work** → Focus on high-impact resources
* **Understand adoption** → See what people actually use

***

## Active Metadata Management

You can enrich resources with custom metadata:

### Fixed Tags

Pre-defined tags with specific values:

* Owner
* Description
* Status (Active, Deprecated, etc.)
* Certification Level

### Active Tags

Live tags that are calculated based on the latest state of your data:

* Relies on PII
* Certified Dashboard
* Usage Level

***

## Euno Query Language (EQL)

EQL (Euno Query Language) is a powerful query language for finding and filtering resources in Euno's data model.

### What is EQL?

EQL allows you to:

* **Filter resources** using specific property values
* **Explore relationships** such as dependencies and hierarchies
* **Query metrics** and usage patterns
* **Build complex queries** by combining conditions with logical operators

### Key EQL Concepts

**Resource Filtering:**

* Filter by resource type: `type = 'dbt_model'`
* Filter by properties: `database_schema = 'sales'`
* Combine conditions: `type = 'table' AND database = 'analytics'`

**Relationship Queries:**

* Find upstream dependencies: `has upstream(type='dbt_source')`
* Find downstream resources: `has downstream(type='tableau_dashboard')`
* Explore parent-child relationships: `has parent(type='schema')`

**Logical Operations:**

* AND: `type = 'table' AND database = 'analytics'`
* OR: `type = 'dbt_model' OR type = 'dbt_source'`
* NOT: `NOT (type = 'looker_look')`

### Example EQL Queries

**Find dbt models that depend on specific sources:**

```
type="dbt_model" AND has upstream((type='dbt_source' AND database_schema='raw'), 1)
```

**Find dashboards with no upstream dependencies:**

```
type = 'looker_dashboard' AND NOT has upstream(TRUE)
```

**Find tables with high query costs:**

```
type = 'table' AND total_query_cost_30d > 1000
```

For complete EQL documentation, see [Understanding EQL](https://docs.euno.ai/using-euno/euno-query-language-eql).

***

## Metadata Activation

Euno doesn't just catalog metadata—it **activates** it:

### What is Metadata Activation?

Using metadata to trigger automated actions:

**Examples:**

* **Workflow:** Notify #data-team when new ungoverned resources appear
* **Data Model Sync:** Auto-update Looker when dbt changes

This is what makes Euno more than just a catalog—it's an active governance and automation platform.

***

## Key Takeaways

1. ✓ **Everything is a Resource** - Tables, dashboards, models, columns, etc.
2. ✓ **URIs Uniquely Identify Resources** - Across all platforms
3. ✓ **Relationships Connect Resources** - Dependency, containment, definition
4. ✓ **Column-Level Lineage** - Track data at the most granular level
5. ✓ **Usage Data Drives Decisions** - Optimize based on actual behavior
6. ✓ **Metadata Activation** - Turn passive metadata into automated actions

***

## Next Steps

Now that you understand the core concepts:

1. **Try the Quickstart Guide** - See these concepts in action
2. **Explore the Data Model Screen** - Navigate your actual resources
3. **Use the AI Assistant** - Ask questions about your metadata
4. **Set Up Your First Workflow** - Activate your metadata

***

## Related Documentation

* [Universal Resource Identifier (URI)](https://docs.euno.ai/developer-reference/technical-concepts/universal-resource-identifier-uri) - Detailed URI structure
* [Relationships](https://docs.euno.ai/developer-reference/technical-concepts/relationships) - Complete relationship reference
* [Resource Sponsorship & Cleanup](https://docs.euno.ai/developer-reference/technical-concepts/resource-sponsorship-and-cleanup-in-euno) - Lifecycle management
* [Quickstart Guide](https://docs.euno.ai/getting-started/quickstart-guide) - Hands-on tutorial