})
})
})
})
})
})
})
- **Improved Boolean cell styling:** Boolean values in the data grid now have distinct visual weights to make it easier to visually scan result sets and prevent confusion with empty cells.
})
## June 18, 2025
- **DuckDB 1.3.1:** MotherDuck supports DuckDB 1.3.1, a bugfix release. Additional details are available in the [DuckDB 1.3.1 changelog](https://github.com/duckdb/duckdb/releases/tag/v1.3.1).
- **`PIVOT` statements in MotherDuck UI:** The MotherDuck UI now supports [`PIVOT` statements](https://duckdb.org/docs/stable/sql/statements/pivot.html), with pivot columns also appearing in the Column Explorer. `PIVOT` transforms distinct column values into separate columns with aggregated data.
- **New `STORAGE_INFO` View in `MD_INFORMATION_SCHEMA`:** Organization admins can now review detailed storage breakdowns per database using the new [`STORAGE_INFO` view](/sql-reference/motherduck-sql-reference/md_information_schema/storage_info/) in the [`MD_INFORMATION_SCHEMA`](/sql-reference/motherduck-sql-reference/md_information_schema/introduction/).
## June 12, 2025
- **Improved query execution UX:** After 5 seconds, the run button now displays a timer showing how long the query has been running. It also offers clearer visual cues for canceling a query on mouseover and focus.
## June 5, 2025
- **Overwrite a database with a zero-copy clone:** The new [`COPY FROM DATABASE (OVERWRITE)` command](/sql-reference/motherduck-sql-reference/copy-database-overwrite/) replaces all data in the target database with the source’s contents in a single atomic operation, waiting for active writes to finish and blocking new ones during the process.
- **Copy SQL definitions for views from the Object Explorer:** The dropdown menu for views in the left-hand panel of the MotherDuck UI now lets you copy the associated SQL definition without opening the table summary.
## May 29, 2025
MotherDuck now supports DuckDB version 1.3.0 🎉
DuckDB 1.3.0 improves performance in real-world scenarios for faster queries, new SQL syntax, and smarter Parquet file handling. Learn more in the [changelog](https://github.com/duckdb/duckdb/releases/tag/v1.3.0) here.
### Parquet improvements
- **[New `TRY()` expression for safer queries:](https://duckdb.org/2025/05/21/announcing-duckdb-130.html#try-expression)** More graceful handling for bad data by returning `NULL` instead of an error on problematic rows
- **[Pushdown of arbitrary expressions into scans:](https://github.com/duckdb/duckdb/pull/16430)** Reductions in unnecessary data processing to deliver up to 30x faster queries
- **[Pushdown of inequality conditions into joins:](https://github.com/duckdb/duckdb/pull/16508)** Major speedups for incremental dbt models and join-heavy queries
### SQL syntax updates
- **[Python-style lambda syntax:](https://github.com/duckdb/duckdb/pull/17235)** You can now use `lambda x: x + 1` instead of `x -> x + 1`; the old syntax is deprecated, but still supported.
- **[`cast_to_type()` function:](https://github.com/duckdb/duckdb/pull/17209)** Dynamically cast values to match column types - useful in generic expressions and `CASE` statements when writing macros.
- **[Recursive JSON access:](https://github.com/duckdb/duckdb/pull/17406)** New `json_each()` and `json_tree()` functions make it easier to traverse nested JSON structures.
- **[Struct field updates:](https://github.com/duckdb/duckdb/pull/17003)** Individual fields in structs can now be modified using `ALTER`; all fields are rewritten even if only one is updated.
- **[Prepared statements metadata:](https://github.com/duckdb/duckdb/pull/16541)** The `duckdb_prepared_statements()` function returns all prepared statements in the session.
- **[More flexible type definitions:](https://github.com/duckdb/duckdb/pull/17404)** Support has been added for `CREATE OR REPLACE TYPE`, `CREATE TYPE IF NOT EXISTS`, and `CREATE TEMPORARY TYPE`.
- **[Preserved order for `OR` filters:](https://github.com/duckdb/duckdb/pull/17180)** Execution now preserves the order of clauses in `WHERE` conditions using `OR`.
- **[Function alias visibility:](https://github.com/duckdb/duckdb/pull/16600)** `duckdb_functions()` now returns aliases in addition to the function outputs.
### Parquet improvements
- **[Late materialization:](https://github.com/duckdb/duckdb/pull/17036)** Queries are 3–10x faster with `LIMIT` due to deferred column loading
- **[~15% average speedup on reads:](https://github.com/duckdb/duckdb/pull/16595)** New scan and filter efficiency improvements
- **[30%+ faster write throughput:](https://github.com/duckdb/duckdb/pull/17061)** Improved multithreaded export performance
- **[Better compression for large strings:](https://github.com/duckdb/duckdb/pull/17164)** Large string values are now dictionary-compressed
- **[Smarter rowgroup combining:](https://github.com/duckdb/duckdb/pull/17118)** Files are more efficient due to merging small rowgroups at write time
Learn more in the official [DuckDB Labs 1.3.0 announcement](https://duckdb.org/2025/05/21/announcing-duckdb-130.html).
While you can continue using your current version of DuckDB, we encourage you to [upgrade your DuckDB clients to 1.3.0](https://duckdb.org/docs/installation/?version=stable&environment=cli&platform=macos&download_method=package_manager) as soon as you can to take advantage of the fixes and performance improvements.
### Additional updates from this release are outlined below -
- Query results now display in a redesigned table that delivers enhanced performance when viewing and exploring data - column headers now include type information for better context. Additional table functionality, including sorting and filtering of results, is coming in future releases.
## May 22, 2025
- **Faster queries on complex filters and wide tables:** We've significantly boosted performance for queries with IN filters, selective joins, and LIMIT clauses. Expect noticeable speedups on wide tables or those with large string or JSON columns.
- **New keybindings for power users:**
- Toggle Instant SQL for the current SQL cell: `cmd/ctrl+shift+.`
- Toggle Object Explorer: `cmd/ctrl+b`
- Toggle Inspector (Column Explorer): `cmd/ctrl+i`
- Toggle worksheet mode for the current SQL cell: `cmd/ctrl+e`
- **Org-wide Active Accounts:** Organization admins can now view all active accounts and their associated ducklings in the [Active Accounts](https://app.motherduck.com/settings/active-accounts) section of MotherDuck settings.
- **Smarter Instant SQL caching:** Instant SQL now accounts for filters in your WHERE clause when building its cache, offering a greater number of relevant rows as you work.
- **Full row count in flat table results:** SQL cells now display a full result row count when viewing results in "flat" table mode.
- **GPT 4.1 Support in `prompt` function**: The `PROMPT` function now supports OpenAI's GPT 4.1 series models. Refer to the [function documentation](../../sql-reference/motherduck-sql-reference/ai-functions/prompt/) for more details.
## May 16, 2025
- **Multiple SQL statements now supported in Instant SQL:** Execute individual statements within multi-statement SQL cells by clicking on the desired statement while [Instant SQL](https://motherduck.com/blog/introducing-instant-sql/) is enabled.
- **Copy Table Names directly from Object Explorer:** Use the options menu on any table in the Object Explorer to copy its name to your clipboard. Paste exact table references into any SQL editor—eliminating typos and saving time when writing queries.
For earlier updates, see the [release notes archive](/about-motherduck/release-notes-archive/).
---
Source: https://motherduck.com/docs/concepts/architecture-and-capabilities
---
sidebar_position: 1
title: Architecture and capabilities
description: MotherDuck's serverless architecture combining cloud scale with DuckDB's efficiency through Dual Execution.
---
import Image from '@theme/IdealImage';
import Versions from '@site/src/components/Versions';
import InteractiveColumnDiagram from '@site/src/components/InteractiveColumnDiagram';
export const architectureColumns = [
{
label: 'Clients',
nodes: [
{
id: 'ui',
title: 'MotherDuck UI',
subtitle: 'SQL IDE, notebooks, Dives',
icon: 'ui',
color: 'green',
feature: 'Instant SQL previews on every keystroke, no explicit query run needed',
href: '/docs/getting-started/interfaces/motherduck-quick-tour/',
},
{
id: 'sdks',
title: 'DuckDB SDKs',
subtitle: 'Python, Node.js, Go, Rust, R, Java',
icon: 'code',
color: 'green',
href: '/docs/getting-started/interfaces/client-apis/',
},
{
id: 'cli',
title: 'DuckDB CLI',
subtitle: 'Local compute and storage',
icon: 'terminal',
color: 'green',
href: '/docs/getting-started/interfaces/connect-query-from-duckdb-cli/',
},
{
id: 'pg',
title: 'Postgres endpoint',
subtitle: 'BI tools, any Postgres client',
icon: 'plug',
color: 'green',
feature: 'Use any Postgres-compatible tool, no DuckDB install needed',
href: '/docs/getting-started/interfaces/postgres-endpoint/',
},
{
id: 'mcp',
title: 'MCP server',
subtitle: 'AI assistants',
icon: 'bot',
color: 'green',
feature: 'Fully managed remote server for Claude, ChatGPT, Cursor, and other AI tools',
href: '/docs/getting-started/mcp-getting-started/',
},
],
},
{
label: 'MotherDuck',
nodes: [
{
id: 'governance',
title: 'Governance',
subtitle: 'Auth, sharing, secrets, admin',
icon: 'shield',
color: 'yellow',
href: '/docs/key-tasks/sharing-data/sharing-overview/',
},
{
id: 'ducklings',
title: 'Ducklings',
subtitle: 'Serverless DuckDB compute',
icon: 'cpu',
color: 'yellow',
feature: 'Sub-100ms cold start with read replicas for horizontal scaling',
href: '/docs/concepts/scaling-patterns/',
},
{
id: 'dives',
title: 'Dives',
subtitle: 'Interactive visualizations',
icon: 'chart',
color: 'yellow',
feature: 'Shareable live dashboards powered by SQL, with version history',
href: '/docs/key-tasks/ai-and-motherduck/dives/',
},
{
id: 'catalog',
title: 'Catalog',
subtitle: 'Databases, schemas, tables, views',
icon: 'layers',
color: 'yellow',
href: '/docs/concepts/database-concepts/',
},
{
id: 'storage',
title: 'Storage',
subtitle: 'Managed storage and DuckLake',
icon: 'harddrive',
color: 'yellow',
feature: 'Transactional lakehouse format with automatic optimization',
href: '/docs/integrations/file-formats/ducklake/',
},
],
},
{
label: 'External sources',
nodes: [
{
id: 'cloud-storage',
title: 'Cloud storage',
subtitle: 'S3, GCS, Azure, R2',
icon: 'cloud',
color: 'sky',
href: '/docs/key-tasks/cloud-storage/querying-s3-files/',
},
{
id: 'databases',
title: 'Databases',
subtitle: 'Postgres, SQLite, MySQL',
icon: 'server',
color: 'sky',
href: '/docs/integrations/',
},
{
id: 'ducklake-byob',
title: 'DuckLake BYOB',
subtitle: 'Bring your own S3 or R2 bucket',
icon: 'lake',
color: 'sky',
href: '/docs/integrations/file-formats/ducklake/',
},
],
},
];
export const architectureConnectors = [
{
label: 'Dual\nExecution',
tooltip: 'Queries are automatically routed to the optimal location: local DuckDB, MotherDuck cloud, or both',
},
{
label: 'Query &\ningest',
tooltip: 'Query external sources in place or load data into MotherDuck storage',
},
];
MotherDuck is a serverless cloud analytics service with a unique architecture that combines the power and scale of the cloud with the efficiency and convenience of DuckDB.
MotherDuck's key components are:
- The MotherDuck cloud service
- MotherDuck's DuckDB SDK
- Dual Execution
- The MotherDuck web UI
(Data Loading)"] R1["Read Scaling Duckling 1"] R2["Read Scaling Duckling 2"] end S1 --> RW E1 --> R1 E2 --> R1 E3 --> R2 E4 --> R2 ``` Read scaling lets you serve hundreds or thousands of concurrent end users through a single service account while maintaining predictable performance. ## Hypertenancy use cases ### Customer-facing analytics Hypertenancy is particularly powerful for [customer-facing analytics](/getting-started/customer-facing-analytics/). Each of your customers can have their own service account with isolated Ducklings: - **Data isolation**: Each customer's data stays in their own database - **Compute isolation**: One customer's workload never impacts another - **Cache isolation**: Each customer's Duckling maintains its own cache, so cached query results and data remain private and predictable - **Independent sizing**: Scale resources per customer based on their tier or needs - **Predictable costs**: Bill customers accurately based on their actual compute usage For a hands-on guide to building customer-facing analytics with per-customer service accounts, see the [Builder's Guide](/key-tasks/customer-facing-analytics/3-tier-cfa-guide/). ### Development and production pipelines Service accounts enable clean separation between deployment environments. Each environment gets its own isolated compute: | Environment | Service Account | Duckling Size | Purpose | |-------------|-----------------|---------------|---------| | Local/Dev | `dev-pipeline` | Pulse | Interactive development and testing | | Staging | `staging-pipeline` | Standard | Pre-production validation | | Production | `prod-pipeline` | Standard/Jumbo/... | Production workloads | This separation ensures: - Development experiments never impact production performance - Each environment has appropriately sized compute - Clear cost attribution per environment - Easy rollback by switching service account credentials ### Data warehouse and data pipeline workloads For data pipelines, you can assign dedicated service accounts to different stages of your data workflow. If you're using dbt you can run dbt models with different duckling sizes. | Pipeline Stage | Service Account | Duckling Size | Workload Pattern | |----------------|-----------------|---------------|------------------| | Ingestion | `ingest-service` | Jumbo/Mega | Bulk data loading, high I/O | | Transformation | `transform-service-standard` / `transform-service-jumbo` / | Standard/Jumbo | dbt models, ETL jobs | | Reporting | `reporting-service` | Pulse (read scaling) | Dashboard queries, read-heavy | This pattern provides: - **Workload isolation**: Heavy batch ingestion jobs won't slow down interactive reporting queries - **Right-sized compute**: Each stage gets the Duckling size optimized for its workload - **Cost visibility**: Track compute costs per pipeline stage - **Independent scheduling**: Run ingestion during off-peak hours without affecting daytime analysts ### Analytics and data science For internal analytics teams, hypertenancy means analysts and data scientists each get their own compute. A data scientist running a complex ML feature extraction job won't slow down an analyst building a quick dashboard. ## Why single-node beats distributed for per-user compute Traditional distributed data warehouses use clusters with multiple nodes that coordinate to execute queries. This architecture introduces: - Network latency between nodes - Coordination overhead - Data shuffling costs For queries that operate on one user's data at a time (the common pattern in hypertenancy), single-node execution on a Duckling eliminates this overhead entirely. The result is often faster query performance and lower costs compared to distributed systems, especially for interactive analytics workloads. DuckDB's efficient columnar execution, combined with MotherDuck's fast storage architecture, means queries can handle datasets larger than memory with minimal performance impact. ## Related content - **Learn about Duckling sizes**: [Duckling Sizes](/about-motherduck/billing/duckling-sizes/) - **Configure read scaling**: [Read Scaling](/key-tasks/authenticating-and-connecting-to-motherduck/read-scaling/) - **Build customer-facing analytics**: [Customer-Facing Analytics Overview](/getting-started/customer-facing-analytics/) - **Set up per-customer service accounts**: [Create and configure service accounts](/key-tasks/service-accounts-guide/create-and-configure-service-accounts/) --- Source: https://motherduck.com/docs/concepts/object-name-resolution --- sidebar_position: 5 title: Object name resolution description: Fully qualified naming conventions and database resolution rules in MotherDuck. --- import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; # Object name resolution ## Fully qualified naming convention Fully qualified names (FQN) in MotherDuck are of the form `