# 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](/developer-reference/technical-concepts/universal-resource-identifier-uri.md). *** ## 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](/developer-reference/technical-concepts/relationships.md). *** ## 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](/developer-reference/technical-concepts/resource-sponsorship-and-cleanup-in-euno.md). *** ## 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](/using-euno/euno-query-language-eql.md). *** ## 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)](/developer-reference/technical-concepts/universal-resource-identifier-uri.md) - Detailed URI structure * [Relationships](/developer-reference/technical-concepts/relationships.md) - Complete relationship reference * [Resource Sponsorship & Cleanup](/developer-reference/technical-concepts/resource-sponsorship-and-cleanup-in-euno.md) - Lifecycle management * [Quickstart Guide](/getting-started/quickstart-guide.md) - Hands-on tutorial --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.euno.ai/getting-started/core-concepts.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.