[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"comparison-duckdb-vs-trino-es":3},{"data":4,"meta":457},[5],{"id":6,"documentId":7,"title":8,"slug":9,"excerpt":10,"seoTitle":11,"seoDescription":12,"verdict":13,"body":14,"createdAt":302,"updatedAt":302,"publishedAt":303,"coverImage":304,"leftStack":353,"rightStack":404,"author":449},2,"odon5rexmfakh3clxtym9huj","DuckDB vs Trino: Comparing Embedded OLAP and Distributed Query Engines","duckdb-vs-trino","An in-depth technical comparison of DuckDB, an in-process analytical database, and Trino, a distributed MPP SQL query engine, analyzing architecture, performance, and scale.","DuckDB vs Trino: Embedded OLAP vs Distributed SQL","Compare DuckDB and Trino. Explore how an in-process analytical engine stacks up against a distributed MPP query engine for modern data platform architectures.","Choose DuckDB if you need a lightweight, zero-dependency, in-process OLAP engine for local data analysis, serverless functions, or embedded application workloads where data fits on a single machine or in object storage. Choose Trino if you require a highly scalable, distributed MPP query engine to federate queries across massive, petabyte-scale data lakes, relational databases, and NoSQL stores, managed by a dedicated platform engineering team.",[15,21,26,30,34,38,43,47,51,55,59,63,67,71,75,79,83,87,91,95,99,103,107,111,117,121,125,129,133,137,141,145,149,153,157,161,165,169,190,194,198,202,206,210,214,218,222,226,230,234,238,242,246,250,264,268,272,276],{"type":16,"level":6,"children":17},"heading",[18],{"type":19,"text":20},"text","The Paradigm Shift in Analytical Processing",{"type":22,"children":23},"paragraph",[24],{"type":19,"text":25},"For years, analytical data processing was synonymous with massive, centralized data warehouses or complex distributed computing clusters. Organizations running analytics had to choose between heavy, server-based relational databases or distributed frameworks like Apache Spark. However, the modern data landscape has split into two distinct, highly optimized paradigms: local-first, in-process analytical engines and highly distributed, federated query engines.",{"type":22,"children":27},[28],{"type":19,"text":29},"DuckDB and Trino represent the pinnacles of these two opposing yet complementary paradigms. DuckDB is an embedded, in-process SQL OLAP database engine designed for high-performance analytics on single nodes. It is often described as the \"SQLite for analytics,\" bringing vectorized execution and columnar data processing directly into the host application's memory space. Trino (formerly PrestoSQL) is a distributed, massively parallel processing (MPP) SQL query engine designed to run fast queries against heterogeneous data sources at petabyte scale. Trino does not store data; instead, it acts as a high-performance query execution layer that federates queries across data lakes, relational databases, and NoSQL stores.",{"type":22,"children":31},[32],{"type":19,"text":33},"Understanding the architectural, operational, and performance trade-offs between DuckDB and Trino is critical for data architects designing modern data platforms, local development workflows, or serverless data pipelines.",{"type":16,"level":6,"children":35},[36],{"type":19,"text":37},"Architectural Foundations",{"type":16,"level":39,"children":40},3,[41],{"type":19,"text":42},"DuckDB: In-Process and Vectorized",{"type":22,"children":44},[45],{"type":19,"text":46},"DuckDB’s architecture is built around the concept of in-process execution. Unlike traditional database management systems (DBMS) that run as separate background daemons and communicate with client applications via network sockets or IPC (Inter-Process Communication), DuckDB runs directly inside the host process. When you import DuckDB in a Python script, a Node.js application, or a Rust binary, the database engine is compiled and executed as part of that application's execution thread.",{"type":22,"children":48},[49],{"type":19,"text":50},"This in-process model eliminates the network serialization and deserialization overhead that typically plagues database client-server interactions. Data transfer between the application and the database engine is essentially a zero-copy operation, especially when integrated with memory-sharing formats like Apache Arrow.",{"type":22,"children":52},[53],{"type":19,"text":54},"Internally, DuckDB utilizes a vectorized query execution engine. Traditional databases process data row-by-row (the Volcano style execution model), which introduces significant CPU overhead due to virtual function calls and poor CPU cache utilization. DuckDB processes data in vectors—blocks of columnar data typically containing 1024 to 2048 values. This allows the engine to leverage modern CPU features like SIMD (Single Instruction, Multiple Data) instructions, keeping data in the CPU’s L1/L2 caches and drastically reducing instruction counts per row.",{"type":16,"level":39,"children":56},[57],{"type":19,"text":58},"Trino: Massively Parallel Processing (MPP)",{"type":22,"children":60},[61],{"type":19,"text":62},"Trino is built on a distributed, shared-nothing MPP architecture. A Trino cluster consists of a single coordinator node and multiple worker nodes. The coordinator is responsible for receiving SQL queries from clients, parsing and analyzing them, optimizing the execution plan using a Cost-Based Optimizer (CBO), and decomposing the query into a hierarchy of stages.",{"type":22,"children":64},[65],{"type":19,"text":66},"These stages are split into tasks, which are distributed among the worker nodes. Workers execute these tasks by fetching data from external data sources, processing it in parallel, and streaming intermediate results to other workers or back to the coordinator. Trino’s execution engine is entirely memory-centric. It pipelines data through stages over the network using high-performance HTTP-based internal data transfer, avoiding writing intermediate state to disk unless absolutely necessary (e.g., when spill-to-disk is enabled for memory-intensive queries).",{"type":22,"children":68},[69],{"type":19,"text":70},"Because Trino is strictly a query engine and does not possess native storage, it relies on a connector-based architecture. Each connector acts as a driver that translates Trino's internal physical execution plans into source-specific API calls or data fetches. This allows Trino to query a wide variety of data sources, from object storage (S3, ADLS, GCS) containing Parquet or Iceberg tables, to relational databases like PostgreSQL, to NoSQL stores like Elasticsearch.",{"type":16,"level":6,"children":72},[73],{"type":19,"text":74},"Data Storage, Formats, and Federation",{"type":16,"level":39,"children":76},[77],{"type":19,"text":78},"Storage Models",{"type":22,"children":80},[81],{"type":19,"text":82},"DuckDB provides a proprietary, single-file storage format that supports ACID transactions, MVCC (Multi-Version Concurrency Control), and automatic compression. However, DuckDB is highly optimized to operate as a query engine over external, open-standard formats. It can query Parquet, CSV, JSON, and Arrow files directly, either on local disk or over network protocols like HTTP, S3, and Google Cloud Storage. DuckDB's ability to perform projection and filter pushdown on Parquet files means it only downloads the specific columns and byte ranges required for a query, making cloud-based object storage queries remarkably efficient.",{"type":22,"children":84},[85],{"type":19,"text":86},"Trino has no native storage format. It is designed to query data where it resides. The most common deployment pattern for Trino is as the query engine for a modern data lakehouse, querying open table formats such as Apache Iceberg, Delta Lake, or Apache Hudi stored on cloud object storage. Trino reads the metadata of these table formats to perform partition pruning, file pruning, and min/max statistics filtering, ensuring that workers only fetch the necessary data blocks.",{"type":16,"level":39,"children":88},[89],{"type":19,"text":90},"Query Federation",{"type":22,"children":92},[93],{"type":19,"text":94},"Query federation is where Trino shines. Because of its connector architecture, a single Trino SQL query can join data across entirely different storage systems. For example, a developer can write a query that joins a historical log table stored in Apache Iceberg on AWS S3 with active user profiles stored in a PostgreSQL database, and filter the results against a lookup table in Redis. Trino coordinates the parallel retrieval of data from these disparate sources, performs the join in-memory across its worker nodes, and returns a unified result set to the client.",{"type":22,"children":96},[97],{"type":19,"text":98},"DuckDB also supports query federation, but at a single-node scale. Through its extension system, DuckDB can attach external databases like SQLite, PostgreSQL, and MySQL. Once attached, you can write SQL queries that join tables across these systems or join them with local Parquet files. However, because this execution is limited to a single machine's CPU and memory, it cannot scale to the multi-terabyte or petabyte federated queries that Trino handles with ease.",{"type":16,"level":6,"children":100},[101],{"type":19,"text":102},"Developer Experience and Ecosystem Integration",{"type":16,"level":39,"children":104},[105],{"type":19,"text":106},"DuckDB: Local-First and Data Science Native",{"type":22,"children":108},[109],{"type":19,"text":110},"DuckDB offers an exceptional developer experience, particularly for data scientists, data engineers, and analysts working in local environments or serverless pipelines. Installing DuckDB is as simple as running a package manager command:",{"type":112,"syntax":113,"children":114},"code","bash",[115],{"type":19,"text":116},"pip install duckdb",{"type":22,"children":118},[119],{"type":19,"text":120},"There are no external dependencies, JVMs, or background services to configure. DuckDB integrates seamlessly with the Python data science ecosystem. It can query Pandas DataFrames, Polars DataFrames, and PyArrow tables directly, and can output query results back into these formats with zero-copy memory sharing. This makes DuckDB an ideal SQL interface for local data manipulation, replacing complex Pandas code with clean, standard SQL.",{"type":22,"children":122},[123],{"type":19,"text":124},"Furthermore, DuckDB has introduced user-friendly SQL extensions that simplify common analytical tasks. For example, you can write FROM my_file.parquet SELECT * without needing a formal SELECT ... FROM structure, and it supports automatic schema inference for CSV and JSON files.",{"type":16,"level":39,"children":126},[127],{"type":19,"text":128},"Trino: Enterprise SQL and BI Integration",{"type":22,"children":130},[131],{"type":19,"text":132},"Trino is designed for enterprise-wide data access. The developer experience is centered around standard ANSI SQL compliance. Analysts and developers interact with Trino using standard SQL clients (such as DBeaver, DataGrip, or Superset) via JDBC or ODBC drivers.",{"type":22,"children":134},[135],{"type":19,"text":136},"Trino’s primary ecosystem integration is with enterprise Business Intelligence (BI) tools (like Tableau, PowerBI, and Looker) and data orchestration platforms (like Apache Airflow, Prefect, and Dagster). For data platform teams, Trino provides a single, unified SQL gateway to the entire corporate data estate. Instead of managing separate credentials and connection strings for dozens of databases, analysts connect to Trino, which handles authentication, authorization, and query routing behind the scenes.",{"type":22,"children":138},[139],{"type":19,"text":140},"However, the setup and development loop for Trino are significantly more complex than DuckDB. Testing a query locally often requires running a local Trino container via Docker Compose, configuring catalog properties files, and ensuring network connectivity to mock data sources.",{"type":16,"level":6,"children":142},[143],{"type":19,"text":144},"Operational Complexity and Deployment Models",{"type":16,"level":39,"children":146},[147],{"type":19,"text":148},"DuckDB: Zero-Ops and Serverless",{"type":22,"children":150},[151],{"type":19,"text":152},"From an operational perspective, DuckDB is virtually zero-ops. Because it is an embedded library, there is no infrastructure to provision, scale, patch, or monitor. The lifecycle of the database is tied directly to the lifecycle of the host application process.",{"type":22,"children":154},[155],{"type":19,"text":156},"This makes DuckDB highly suited for serverless deployment models, such as AWS Lambda, Google Cloud Run, or Azure Functions. A serverless function can spin up, import DuckDB, download a small Parquet file from S3, perform an analytical aggregation, and shut down within milliseconds. There is no cold-start overhead associated with establishing database connections or waiting for a cluster to scale.",{"type":16,"level":39,"children":158},[159],{"type":19,"text":160},"Trino: High-Scale Cluster Management",{"type":22,"children":162},[163],{"type":19,"text":164},"Trino is a complex, distributed system that requires dedicated platform engineering resources to deploy, scale, and maintain. A production Trino cluster is typically deployed on Kubernetes (often using Helm charts or Kubernetes Operators) or on managed cloud infrastructure (such as AWS EMR).",{"type":22,"children":166},[167],{"type":19,"text":168},"Operational tasks for Trino administrators include:",{"type":170,"format":171,"children":172},"list","unordered",[173,178,182,186],{"type":174,"children":175},"list-item",[176],{"type":19,"text":177},"JVM Tuning: Since Trino is written in Java, administrators must carefully tune JVM garbage collection (GC) and heap allocations to prevent OutOfMemory (OOM) errors during heavy join or aggregation operations.",{"type":174,"children":179},[180],{"type":19,"text":181},"Resource Groups: Configuring resource groups to manage query concurrency, queueing, and memory limits. This ensures that ad-hoc queries from analysts do not starve critical scheduled BI dashboard refreshes of resources.",{"type":174,"children":183},[184],{"type":19,"text":185},"Autoscaling: Implementing autoscaling policies for worker nodes based on CPU and memory utilization to balance performance and infrastructure costs.",{"type":174,"children":187},[188],{"type":19,"text":189},"Monitoring: Setting up comprehensive monitoring using JMX exporter, Prometheus, and Grafana to track query latencies, active workers, JVM memory pressure, and network transfer rates.",{"type":16,"level":6,"children":191},[192],{"type":19,"text":193},"Performance Characteristics and Scalability Limits",{"type":16,"level":39,"children":195},[196],{"type":19,"text":197},"Single-Node Efficiency vs. Distributed Scale",{"type":22,"children":199},[200],{"type":19,"text":201},"When comparing performance, the primary differentiator is the scale of the data and the hardware boundary.",{"type":22,"children":203},[204],{"type":19,"text":205},"DuckDB is optimized for vertical scaling. On a modern multi-core workstation or cloud virtual machine with fast NVMe storage and abundant RAM, DuckDB is incredibly fast. Because it avoids network overhead, serialization, and distributed coordination, DuckDB can process millions of rows per second on a single machine. For datasets that fit within the machine's RAM (or can be processed using DuckDB's out-of-core execution, which spills temporary data to disk), DuckDB will often outperform a distributed Trino cluster for single-user workloads.",{"type":22,"children":207},[208],{"type":19,"text":209},"However, DuckDB is fundamentally limited by the resources of a single machine. If a query requires processing hundreds of terabytes or petabytes of data, a single machine will run out of memory or disk space, or the execution time will become unacceptably high.",{"type":22,"children":211},[212],{"type":19,"text":213},"Trino is built for horizontal scaling. When a query is too large for a single machine, Trino distributes the workload across tens, hundreds, or thousands of worker nodes. Trino’s execution engine is optimized for high-throughput, parallel data scanning and distributed memory-to-memory shuffles. While Trino introduces network latency and serialization overhead to coordinate these workers, its ability to aggregate the CPU and memory resources of an entire cluster allows it to execute complex queries on petabyte-scale datasets in seconds or minutes.",{"type":16,"level":39,"children":215},[216],{"type":19,"text":217},"Concurrency Models",{"type":22,"children":219},[220],{"type":19,"text":221},"DuckDB is designed for single-process concurrency. While multiple threads within the same process can query DuckDB concurrently, it is not designed to handle hundreds of concurrent, independent client connections over a network. If multiple separate processes attempt to write to a DuckDB database file simultaneously, file locking issues will occur.",{"type":22,"children":223},[224],{"type":19,"text":225},"Trino is built from the ground up for high-concurrency, multi-tenant workloads. It can handle hundreds of concurrent users executing queries simultaneously. Trino’s coordinator manages query queues, allocates resources dynamically, and ensures fair sharing of cluster resources among competing queries.",{"type":16,"level":6,"children":227},[228],{"type":19,"text":229},"Security, Governance, and Multi-Tenancy",{"type":16,"level":39,"children":231},[232],{"type":19,"text":233},"DuckDB: Delegated Security",{"type":22,"children":235},[236],{"type":19,"text":237},"DuckDB does not have a built-in security, authentication, or authorization model. It operates with the permissions of the host process. If the Python script running DuckDB has read/write access to a local directory or an S3 bucket, DuckDB can read and write to those locations. There are no concepts of database users, roles, or grant statements within DuckDB itself. This makes it unsuitable for multi-tenant environments where fine-grained access control is required at the database level.",{"type":16,"level":39,"children":239},[240],{"type":19,"text":241},"Trino: Enterprise-Grade Governance",{"type":22,"children":243},[244],{"type":19,"text":245},"Trino provides robust, enterprise-grade security and governance features. It supports multiple authentication mechanisms, including Kerberos, LDAP, Active Directory, OAuth2, and SAML.",{"type":22,"children":247},[248],{"type":19,"text":249},"For authorization, Trino integrates with external security managers like Apache Ranger, AWS Lake Formation, or Open Policy Agent (OPA). This allows administrators to enforce fine-grained access control, including:",{"type":170,"format":171,"children":251},[252,256,260],{"type":174,"children":253},[254],{"type":19,"text":255},"Role-Based Access Control (RBAC): Restricting access to specific catalogs, schemas, tables, and views based on user roles.",{"type":174,"children":257},[258],{"type":19,"text":259},"Row-Level Filtering: Restricting which rows a user can see based on their identity (e.g., a regional sales manager can only see rows where region = 'US').",{"type":174,"children":261},[262],{"type":19,"text":263},"Column-Level Masking: Masking sensitive data (such as PII or credit card numbers) for unauthorized users while allowing authorized users to see the raw data.",{"type":22,"children":265},[266],{"type":19,"text":267},"This comprehensive security framework makes Trino the standard choice for exposing data lakes to diverse user groups across an enterprise.",{"type":16,"level":6,"children":269},[270],{"type":19,"text":271},"Summary of Key Differences",{"type":22,"children":273},[274],{"type":19,"text":275},"To understand how these two engines compare across key operational and technical dimensions, consider the following structural comparisons:",{"type":170,"format":171,"children":277},[278,282,286,290,294,298],{"type":174,"children":279},[280],{"type":19,"text":281},"Execution Model: DuckDB runs in-process, sharing memory with the host application. Trino runs as a distributed cluster with a coordinator and multiple worker nodes.",{"type":174,"children":283},[284],{"type":19,"text":285},"Primary Use Case: DuckDB is ideal for local data analysis, serverless ETL, and embedded application analytics. Trino is ideal for enterprise data lake querying, federated BI, and ad-hoc interactive SQL at scale.",{"type":174,"children":287},[288],{"type":19,"text":289},"Scale Boundary: DuckDB scales vertically on a single node (gigabytes to low terabytes). Trino scales horizontally across multiple nodes (terabytes to petabytes).",{"type":174,"children":291},[292],{"type":19,"text":293},"Operational Overhead: DuckDB requires zero administration (library-based). Trino requires significant administration (JVM tuning, cluster orchestration, monitoring).",{"type":174,"children":295},[296],{"type":19,"text":297},"Data Federation: DuckDB supports single-node federation via local database attachments. Trino supports massive, distributed federation across heterogeneous cloud and on-premise data sources.",{"type":174,"children":299},[300],{"type":19,"text":301},"Security: DuckDB delegates security entirely to the host operating system or process. Trino provides native integration with enterprise identity providers and fine-grained access control engines.","2026-07-11T17:37:47.052Z","2026-07-11T17:37:47.070Z",{"id":305,"documentId":306,"name":307,"alternativeText":308,"caption":309,"focalPoint":310,"width":311,"height":312,"formats":313,"hash":348,"ext":317,"mime":318,"size":349,"url":350,"previewUrl":310,"provider":351,"provider_metadata":310,"createdAt":352,"updatedAt":352,"publishedAt":352},6,"iztvo5o7sb4xwab1157904n0","duckdb-vs-trino-cover","A technical comparison diagram showing an embedded in-process database architecture on the left and a distributed query engine architecture on the right.","StackAtlas comparison cover",null,1200,630,{"thumbnail":314,"small":324,"medium":332,"large":340},{"name":315,"hash":316,"ext":317,"mime":318,"path":310,"width":319,"height":320,"size":321,"sizeInBytes":322,"url":323},"thumbnail_duckdb-vs-trino-cover","thumbnail_duckdb_vs_trino_cover_542ec26948",".png","image/png",245,129,37.61,37609,"/uploads/thumbnail_duckdb_vs_trino_cover_542ec26948.png",{"name":325,"hash":326,"ext":317,"mime":318,"path":310,"width":327,"height":328,"size":329,"sizeInBytes":330,"url":331},"small_duckdb-vs-trino-cover","small_duckdb_vs_trino_cover_542ec26948",500,263,127.04,127041,"/uploads/small_duckdb_vs_trino_cover_542ec26948.png",{"name":333,"hash":334,"ext":317,"mime":318,"path":310,"width":335,"height":336,"size":337,"sizeInBytes":338,"url":339},"medium_duckdb-vs-trino-cover","medium_duckdb_vs_trino_cover_542ec26948",750,394,254.97,254974,"/uploads/medium_duckdb_vs_trino_cover_542ec26948.png",{"name":341,"hash":342,"ext":317,"mime":318,"path":310,"width":343,"height":344,"size":345,"sizeInBytes":346,"url":347},"large_duckdb-vs-trino-cover","large_duckdb_vs_trino_cover_542ec26948",1000,525,412.38,412380,"/uploads/large_duckdb_vs_trino_cover_542ec26948.png","duckdb_vs_trino_cover_542ec26948",111.66,"/uploads/duckdb_vs_trino_cover_542ec26948.png","local","2026-07-11T17:37:46.838Z",{"id":354,"documentId":355,"title":356,"slug":357,"excerpt":358,"difficulty":359,"estimatedCost":360,"maturity":361,"seoTitle":362,"seoDescription":363,"createdAt":364,"updatedAt":364,"publishedAt":365,"coverImage":366},4,"qk1izapg82lwuip9nizcldcq","DuckDB","duckdb","An embedded, high-performance analytical SQL database engine designed for in-process OLAP workloads and seamless data ecosystem integration.","intermediate","Free (Open Source)","stable","DuckDB Guide: Architecture, Strengths, and Use Cases","Explore DuckDB, the in-process OLAP database. Learn about its vectorized execution engine, columnar storage, limitations, and analytical use cases.","2026-07-11T16:20:03.467Z","2026-07-11T16:20:03.487Z",{"id":6,"documentId":367,"name":368,"alternativeText":369,"caption":370,"focalPoint":310,"width":371,"height":371,"formats":372,"hash":400,"ext":376,"mime":377,"size":401,"url":402,"previewUrl":310,"provider":351,"provider_metadata":310,"createdAt":403,"updatedAt":403,"publishedAt":403},"ukbbtq8s9scvgmyzaubrcsrz","duckdb-cover","Abstract technical illustration representing an embedded columnar database engine with fast data flow paths.","StackAtlas editorial cover",1024,{"thumbnail":373,"medium":382,"small":388,"large":394},{"name":374,"hash":375,"ext":376,"mime":377,"path":310,"width":378,"height":378,"size":379,"sizeInBytes":380,"url":381},"thumbnail_duckdb-cover","thumbnail_duckdb_cover_995fd97993",".jpg","image/jpeg",156,6.77,6765,"/uploads/thumbnail_duckdb_cover_995fd97993.jpg",{"name":383,"hash":384,"ext":376,"mime":377,"path":310,"width":335,"height":335,"size":385,"sizeInBytes":386,"url":387},"medium_duckdb-cover","medium_duckdb_cover_995fd97993",58.3,58302,"/uploads/medium_duckdb_cover_995fd97993.jpg",{"name":389,"hash":390,"ext":376,"mime":377,"path":310,"width":327,"height":327,"size":391,"sizeInBytes":392,"url":393},"small_duckdb-cover","small_duckdb_cover_995fd97993",34.68,34681,"/uploads/small_duckdb_cover_995fd97993.jpg",{"name":395,"hash":396,"ext":376,"mime":377,"path":310,"width":343,"height":343,"size":397,"sizeInBytes":398,"url":399},"large_duckdb-cover","large_duckdb_cover_995fd97993",86.64,86637,"/uploads/large_duckdb_cover_995fd97993.jpg","duckdb_cover_995fd97993",87.77,"/uploads/duckdb_cover_995fd97993.jpg","2026-07-11T16:20:02.938Z",{"id":305,"documentId":405,"title":406,"slug":407,"excerpt":408,"difficulty":409,"estimatedCost":410,"maturity":361,"seoTitle":411,"seoDescription":412,"createdAt":413,"updatedAt":413,"publishedAt":414,"coverImage":415},"jch3a0bu7rj34ewx2akadwtt","Trino","trino","A highly parallel, distributed SQL query engine designed for fast analytical queries against diverse data sources ranging from gigabytes to petabytes.","advanced","Free (Open Source) / Infrastructure cost varies","Trino: Distributed SQL Query Engine for Analytics","Explore Trino, the open-source distributed SQL query engine. Learn its architecture, strengths, limitations, and key data lakehouse use cases.","2026-07-11T17:14:10.304Z","2026-07-11T17:14:10.328Z",{"id":354,"documentId":416,"name":417,"alternativeText":418,"caption":370,"focalPoint":310,"width":311,"height":312,"formats":419,"hash":444,"ext":317,"mime":318,"size":445,"url":446,"previewUrl":310,"provider":351,"provider_metadata":310,"createdAt":447,"updatedAt":447,"publishedAt":448},"im4cne43cntpmb6w0b33h8o6","trino-cover","Abstract technical illustration of a distributed SQL query engine showing connected data nodes and a central processing hub.",{"thumbnail":420,"small":426,"medium":432,"large":438},{"name":421,"hash":422,"ext":317,"mime":318,"path":310,"width":319,"height":320,"size":423,"sizeInBytes":424,"url":425},"thumbnail_trino-cover","thumbnail_trino_cover_95ffe71122",32.78,32775,"/uploads/thumbnail_trino_cover_95ffe71122.png",{"name":427,"hash":428,"ext":317,"mime":318,"path":310,"width":327,"height":328,"size":429,"sizeInBytes":430,"url":431},"small_trino-cover","small_trino_cover_95ffe71122",111.6,111596,"/uploads/small_trino_cover_95ffe71122.png",{"name":433,"hash":434,"ext":317,"mime":318,"path":310,"width":335,"height":336,"size":435,"sizeInBytes":436,"url":437},"medium_trino-cover","medium_trino_cover_95ffe71122",237.15,237150,"/uploads/medium_trino_cover_95ffe71122.png",{"name":439,"hash":440,"ext":317,"mime":318,"path":310,"width":343,"height":344,"size":441,"sizeInBytes":442,"url":443},"large_trino-cover","large_trino_cover_95ffe71122",369.07,369069,"/uploads/large_trino_cover_95ffe71122.png","trino_cover_95ffe71122",108.25,"/uploads/trino_cover_95ffe71122.png","2026-07-11T17:14:10.088Z","2026-07-11T17:14:10.089Z",{"id":450,"documentId":451,"name":452,"slug":453,"bio":310,"createdAt":454,"updatedAt":455,"publishedAt":456},1,"lv2wpsnmnajx4jmhrvo1zne6","Jose Henriquez","jose-henriquez","2026-07-04T16:49:01.335Z","2026-07-04T16:49:39.022Z","2026-07-04T16:49:39.004Z",{"pagination":458},{"page":450,"pageSize":459,"pageCount":450,"total":450},25]