# IOMETE — Complete Documentation Index

> IOMETE is a Kubernetes-native, self-hosted sovereign data lakehouse platform built on Apache Spark and Apache Iceberg. It runs entirely within customer infrastructure — on-premises, private cloud, or public cloud VPC — so data never leaves the organization's trust perimeter by design.

This is the auto-generated full documentation index. For a curated overview with detailed descriptions, blog index, and FAQ, see [llms.txt](https://iomete.com/resources/llms.txt).

## Overview

- [What is IOMETE?](https://iomete.com/resources/getting-started/what-is-iomete): IOMETE is a Kubernetes-native data lakehouse built on Apache Spark and Iceberg that runs entirely in your own environment: on-prem, cloud or air-gapped.
- [Platform Tour](https://iomete.com/resources/getting-started/platform-tour): A high-level tour of the IOMETE platform covering compute, SQL Editor, Spark jobs, Data Catalog, and more.
- [Architecture](https://iomete.com/resources/getting-started/architecture): How IOMETE works on Kubernetes: control plane, data planes, Spark compute, Iceberg storage, catalog and security model, and how the components connect.
- [Scalability](https://iomete.com/resources/getting-started/scalability): Understand how IOMETE scales across Kubernetes infrastructure, platform services, compute clusters, and storage to handle growing data workloads efficiently.
- [Support](https://iomete.com/resources/getting-started/support): Get help and support for IOMETE, a state-of-the-art Data Lakehouse Platform for AI and Analytics. Learn how to get assistance, report issues, and access resources to enhance your IOMETE experience.

## Deployment

- [Install](https://iomete.com/resources/deployment/on-prem/install): Detailed instructions for deploying IOMETE on-premises within a Kubernetes environment.
- [Deployment Architecture](https://iomete.com/resources/deployment/architecture-deployment): Technical reference for IOMETE's Kubernetes deployment topology, complete service inventory, feature flags, and infrastructure configuration.
- [Storage Migration](https://iomete.com/resources/deployment/storage-migration): Move IOMETE's S3-compatible lakehouse storage to new hardware, a new endpoint or a new provider while keeping the same bucket names. Covers configuration, restarts, cutover and validation.
- [Platform](https://iomete.com/resources/deployment/on-prem/release-notes): Get latest release notes for IOMETE. Learn about new features, enhancements, and bug fixes in each release.
- [Spark](https://iomete.com/resources/deployment/on-prem/release-notes/spark): Release notes for IOMETE Spark images. Learn about new features, improvements, security updates, and bug fixes in each Spark image release.
- [Marketplace Jobs](https://iomete.com/resources/deployment/on-prem/release-notes/marketplace-jobs): Release notes for IOMETE Marketplace Jobs. Learn about updates, improvements, and bug fixes for various data integration and processing jobs.
- [Integrations](https://iomete.com/resources/deployment/on-prem/release-notes/integrations): Release notes for IOMETE integrations, including dbt-iomete, the IOMETE Airflow Plugin, the IOMETE Tableau connector, the IOMETE Power BI connector, and the Arrow Flight SQL ODBC and JDBC drivers.
- [Apache Ozone Deployment](https://iomete.com/resources/deployment/ozone-deployment): Deploy Apache Ozone as S3-compatible object storage and prepare buckets for the IOMETE deployment.
- [Minio Deployment](https://iomete.com/resources/deployment/minio-deployment): Deploy Minio and prepare buckets for the IOMETE deployment.
- [Configure Ingress](https://iomete.com/resources/deployment/configure-ingress): Configure ISTIO as an ingress controller on a Kubernetes cluster and configure it for use with IOMETE
- [Custom DNS](https://iomete.com/resources/deployment/configure-custom-dns): Learn how to easily configure a custom DNS for your IOMETE Data Plane with our step-by-step guide. Covering everything from identifying the Istio Ingress Gateway address to creating DNS records, this document simplifies DNS setup to enhance your data plane's accessibility.
- [Backend Databases](https://iomete.com/resources/deployment/backend-databases): Explore IOMETE's backend database requirements for MySQL and PostgreSQL, tailored for small to large scale users. Learn about CPU, memory, and disk space needs for managing internal and data lake metadata, with tips on enhancing performance and safeguarding data.
- [PostgreSQL Deployment](https://iomete.com/resources/deployment/postgresql-deployment): Deploy a PostgreSQL database for the IOMETE deployment.
- [MySQL Deployment](https://iomete.com/resources/deployment/mysql-deployment): Deploy a MySQL database for the IOMETE deployment.
- [Life Cycle Management (LCM)](https://iomete.com/resources/deployment/life-cycle-management): Learn about IOMETE's comprehensive Life Cycle Management (LCM) for On-premise Kubernetes environment, from efficient installation to seamless upgrades and robust monitoring.
- [Custom Java Truststore](https://iomete.com/resources/deployment/truststore): Create and use a `truststore.jks` file with custom CA certificates to prevent certificate errors when accessing known websites.
- [Network Policies](https://iomete.com/resources/deployment/network-policies): Learn how to configure network policies for IOMETE services in a Kubernetes cluster.
- [Install Data-Plane (Namespace)](https://iomete.com/resources/deployment/connect-namespace): Learn how to install and connect a new Data-Plane to IOMETE Control-Plane.
- [Nutanix NKP](https://iomete.com/resources/deployment/nutanix-nkp): Deploy IOMETE Data Plane Enterprise on Nutanix Kubernetes Platform (NKP), with Nutanix Objects for lakehouse data, Nutanix Volumes for persistent volumes, CloudNativePG for the metadata database and Traefik for console access.
- [Kubernetes Setup Guide](https://iomete.com/resources/deployment/kubernetes): Kubernetes cluster recommendations for IOMETE deployments
- [Multi-Cluster Setup](https://iomete.com/resources/deployment/multi-cluster-setup): How to configure multiple IOMETE instances to share common resources across data centers using a shared global database.

## DBT

- [Getting Started](https://iomete.com/resources/integrations/dbt/getting-started-with-iomete-dbt): Learn how to set up the dbt-iomete adapter, connect to your IOMETE lakehouse, and run your first dbt transformation.
- [Configuration Reference](https://iomete.com/resources/integrations/dbt/dbt-configuration-reference): Reference for dbt-iomete connection, model, incremental, and Python model settings.
- [Materializations](https://iomete.com/resources/integrations/dbt/dbt-materializations): DBT Materializations on IOMETE platform. Learn how to set different materialization types (view, table, incremental) and understand their pros & cons
- [Incremental Models](https://iomete.com/resources/integrations/dbt/dbt-incremental-models): What dbt incremental models are, how is_incremental() and unique_key work, and how to choose a strategy, with examples on Apache Spark and Iceberg.
- [Incremental Models By Examples](https://iomete.com/resources/integrations/dbt/dbt-incremental-models-by-examples): Runnable dbt incremental model examples for every strategy (merge, append, insert_overwrite) and on_schema_change setting, using Apache Iceberg on Spark.

## Airflow

- [Getting Started](https://iomete.com/resources/integrations/airflow/getting-started): Install the IOMETE Airflow Plugin, configure credentials, and trigger your first IOMETE Spark job.
- [Operator Reference](https://iomete.com/resources/integrations/airflow/operator-reference): Reference for IometeOperator parameters, configuration overrides, templates, job run states, and retries.
- [DAG Examples](https://iomete.com/resources/integrations/airflow/examples): Examples for overriding IOMETE Spark job configuration, sequencing jobs, and passing run details through XCom.

## BI Integrations

- [Metabase](https://iomete.com/resources/integrations/bi/metabase): Connect Metabase to IOMETE to build dashboards and explore your data without writing SQL.
- [Apache Superset](https://iomete.com/resources/integrations/bi/apache-superset): This guide explains how to effortlessly integrate iomete with one of the most popular BI tools Apache Superset
- [Overview](https://iomete.com/resources/integrations/bi/power-bi/overview): Choose a Power BI connection method for IOMETE using Arrow Flight or Thrift.
- [Arrow Flight](https://iomete.com/resources/integrations/bi/power-bi/arrow-flight): Install the IOMETE Power BI connector and connect Power BI Desktop or an on-premises data gateway to IOMETE through Arrow Flight SQL.
- [Thrift](https://iomete.com/resources/integrations/bi/power-bi/thrift): Connect Power BI to IOMETE through Thrift using Power BI's built-in Spark connector.
- [Thrift ODBC](https://iomete.com/resources/integrations/bi/power-bi/odbc): Connect Power BI to IOMETE through Thrift using the Simba Spark ODBC driver.
- [Overview](https://iomete.com/resources/integrations/bi/tableau/overview): Choose a Tableau connection method for IOMETE, then build a dashboard on your lakehouse data.
- [Arrow Flight](https://iomete.com/resources/integrations/bi/tableau/arrow-flight): Install the IOMETE Tableau connector and connect Tableau Desktop or Server to IOMETE through Arrow Flight SQL.
- [Thrift](https://iomete.com/resources/integrations/bi/tableau/thrift): Connect Tableau to IOMETE through Thrift Server using Tableau's built-in Spark SQL driver or the CData Spark SQL connector.
- [Redash](https://iomete.com/resources/integrations/bi/redash): Connect Redash to IOMETE to query your data and build visualizations.

## DB Tools

- [DBeaver](https://iomete.com/resources/integrations/dbtools/dbeaver): Connect DBeaver to IOMETE using the Arrow Flight SQL JDBC driver.
- [Dataiku](https://iomete.com/resources/integrations/dbtools/dataiku): Connect Dataiku to IOMETE using the Arrow Flight SQL JDBC Driver.

## Git

- [Git Integration](https://iomete.com/resources/integrations/git/git-integration): This documentation provides details on how to integrate Git with SQL Editor.

## SQL Quick Start

- [SQL DDL Examples](https://iomete.com/resources/reference/sql-quick-start/sql-ddl-examples): This SQL script showcases key DDL operations in IOMETE, a platform based on Spark SQL and Iceberg. It includes database and table creation, CTAS and RTAS operations, and various table alterations.
- [DML Operations](https://iomete.com/resources/reference/sql-quick-start/dml-operations): This SQL script illustrates common queries and DML operations in IOMETE, utilizing Spark SQL and Iceberg. It encompasses database and table creation, data insertion, update and deletion operations and table descriptions.
- [Iceberg Advanced Features](https://iomete.com/resources/reference/sql-quick-start/iceberg-advanced-features): This script illustrates advanced features of Apache Iceberg tables, including branching, tagging, and time-travel. It starts with setting up a sample database and tables, followed by detailed examples of branching operations, querying branches/tags and writing to branches.
- [External Tables](https://iomete.com/resources/reference/sql-quick-start/tables-from-jdbc-csv-json): This SQL script provides a comprehensive guide on data sources and external tables manipulation in IOMETE, with examples covering JDBC, CSV, JSON, Parquet, and ORC. It demonstrates creating tables from various data sources, querying these tables, as well as exporting data back to these sources.
- [Query Federation](https://iomete.com/resources/reference/sql-quick-start/query-federation): Learn how to unify data from MySQL, PostgreSQL, CSV files, and Snowflake tables in a single SQL query with IOMETE. Explore JDBC integration, object storage, and more.
- [Microsoft SQL Server Data Source](https://iomete.com/resources/reference/sql-quick-start/ms-sql-server-datasource): Learn how to connect to Microsoft SQL Server from IOMETE Lakehouse.
- [Oracle Data Source](https://iomete.com/resources/reference/sql-quick-start/oracle-datasource): Learn how to connect to Oracle from IOMETE Lakehouse.

## Iceberg Tables

- [Getting Started](https://iomete.com/resources/reference/iceberg-tables/getting-started): Starting Apache Spark as a compute engine, with Apache Iceberg provider with additional optimization and packaging
- [DDL](https://iomete.com/resources/reference/iceberg-tables/ddl): Data definition language is a syntax for creating and modifying database objects such as tables, indices, and users
- [Queries](https://iomete.com/resources/reference/iceberg-tables/queries): Learn how to use Iceberg tables in Spark for time travel, inspecting table history, snapshots, and metadata, by reading this comprehensive guide with SQL examples.
- [Writes](https://iomete.com/resources/reference/iceberg-tables/writes): Spark SQL examples for writing to Apache Iceberg tables: INSERT INTO, MERGE INTO upserts, INSERT OVERWRITE on partitions, and DELETE, with gotchas.
- [Iceberg Procedures](https://iomete.com/resources/reference/iceberg-tables/iceberg-procedures): Iceberg Spark Procedures Usage Procedures that can be used from any configured Iceberg catalog with CALL in the namespace system
- [Time Travel](https://iomete.com/resources/reference/iceberg-tables/time-travel): Iceberg provides versioning and time travel capabilities, allowing users to query data as it existed at a specific point in time. This feature can be extremely useful for debugging, auditing, and historical analysis.
- [Apache Iceberg Maintenance](https://iomete.com/resources/reference/iceberg-tables/maintenance): Learn how to maintain Iceberg tables for optimal performance and See available configuration options with Iceberg procedures.

## Spark SQL Reference

- [Create Database](https://iomete.com/resources/reference/spark-sql/ddl/create-database): Create a database with the specified name. If not exists, with optional comment and database properties. Syntax, parameters, and examples included.
- [Alter Database](https://iomete.com/resources/reference/spark-sql/ddl/alter-database): Learn how to create and use Personal Access Tokens as an alternative to using passwords for authentication with IOMETE API
- [Drop Database](https://iomete.com/resources/reference/spark-sql/ddl/drop-database): Learn how to drop a database and associated directory in the file system with this tutorial. Syntax, parameters, and examples included.
- [Create Table](https://iomete.com/resources/reference/spark-sql/ddl/create-table): Create Table | Syntax, Parameters, Examples | Delta, CSV, TXT, ORC, JDBC, PARQUET | Partition, Cluster, Sort Data | Copy Data with SELECT
- [Alter Table](https://iomete.com/resources/reference/spark-sql/ddl/alter-table): Learn how to use ALTER TABLE in SQL to rename, add columns, and set/unset table properties. Examples provided. Master table schema changes with ease.
- [Drop Table](https://iomete.com/resources/reference/spark-sql/ddl/drop-table): DROP TABLE syntax reference for Spark SQL. Covers IF EXISTS, PURGE, qualified identifiers, and external table behavior with examples.
- [Create View](https://iomete.com/resources/reference/spark-sql/ddl/create-view): This documentation provides a detailed guide on creating a view using Apache Spark SQL, facilitating a clear understanding of the process.
- [Truncate Table](https://iomete.com/resources/reference/spark-sql/writes/truncate-table): Remove all rows from a table or partition(s) with TRUNCATE TABLE statement. Learn syntax, parameters, and examples for easy table truncation in this comprehensive documentation
- [Insert Into](https://iomete.com/resources/reference/spark-sql/writes/insert-into): This documentation guides users through the process of inserting new rows into a table, offering clear and concise instructions for seamless execution.
- [Merge Into](https://iomete.com/resources/reference/spark-sql/writes/merge-into): Merge into statement is a set of updates, insertions, and deletions based on a source table into a target Delta table
- [Insert Overwrite](https://iomete.com/resources/reference/spark-sql/writes/insert-overwrite): The "INSERT OVERWRITE" statement serves to replace the existing data in a table with updated values.
- [Select](https://iomete.com/resources/reference/spark-sql/queries/select): Learn about Spark's SELECT statement and query syntax conforming to ANSI SQL standards. Retrieve result sets from multiple tables using different constructs and examples.
- [Common Table Expression (CTE)](https://iomete.com/resources/reference/spark-sql/queries/cte): A common table expression (CTE) defines a temporary result set that a user can reference possibly multiple times within the scope of a SQL statement
- [CLUSTER BY Clause](https://iomete.com/resources/reference/spark-sql/queries/cluster-by-clause): The CLUSTER BY clause is used to first repartition the data based on the input expressions and then sort the data within each partition
- [DISTRIBUTE BY Clause](https://iomete.com/resources/reference/spark-sql/queries/distribute-by-clause): The "DISTRIBUTE BY" clause facilitates data repartitioning based on specified input expressions, optimizing data distribution in Apache Spark SQL queries.
- [GROUP BY Clause](https://iomete.com/resources/reference/spark-sql/queries/group-by-clause): Group by clause is used to group the rows based on a set of specified grouping expressions and compute aggregations on the group of rows
- [HAVING BY Clause](https://iomete.com/resources/reference/spark-sql/queries/having-by-clause): The HAVING clause is used to filter the results produced by GROUP BY based on the specified condition
- [Hints](https://iomete.com/resources/reference/spark-sql/queries/hints): Hints give users a way to suggest how Spark SQL to use specific approaches to generate its execution plan.
- [Inline Table](https://iomete.com/resources/reference/spark-sql/queries/inline-table): An inline table is a transient table generated through a VALUES clause, providing a convenient way to create temporary data structures in SQL.
- [File](https://iomete.com/resources/reference/spark-sql/queries/file): By utilizing the "USING FILE" syntax, you can directly query a file in a specified format using SQL, streamlining the interaction with structured data.
- [JOIN](https://iomete.com/resources/reference/spark-sql/queries/join): SQL join is used to combine rows from two relations based on join criteria. It describes the overall join syntax and the sub-sections cover different types of joins along with examples.
- [LIKE Predicate](https://iomete.com/resources/reference/spark-sql/queries/like-predicate): The "LIKE" predicate is employed to search for a particular pattern, offering a flexible and powerful means to filter data based on specified criteria.
- [LIMIT Clause](https://iomete.com/resources/reference/spark-sql/queries/limit-clause): To perform sampling queries in the IOMETE Lakehouse Platform using Spark SQL, you can leverage the "TABLESAMPLE" clause.
- [ORDER BY Clause](https://iomete.com/resources/reference/spark-sql/queries/order-by-clause): The ORDER BY clause is used to return the result rows in a sorted manner in the user specified order
- [Set Operators](https://iomete.com/resources/reference/spark-sql/queries/set-operators): Set operators are employed to merge two input relations into a unified result, facilitating the combination of data sets in a single operation.
- [SORT BY Clause](https://iomete.com/resources/reference/spark-sql/queries/sort-by-clause): The SORT BY clause is used to return the result rows sorted within each partition in the user specified order
- [Sampling Queries](https://iomete.com/resources/reference/spark-sql/queries/sampling-queries): The IOMETE Lakehouse Platform with Spark SQL offers a guide on efficiently executing sampling queries, optimizing data exploration and analysis.
- [Table-valued Functions (TVF)](https://iomete.com/resources/reference/spark-sql/queries/table-valued-functions): A table-valued function (TVF) is a function that yields a relation or a set of rows as its result, providing a mechanism for querying and retrieving data.
- [Use Database](https://iomete.com/resources/reference/spark-sql/queries/use-database): USE statement is used to set the current database. Once set, the unqualified database artifacts that are referenced by SQLs are resolved from the current database
- [WHERE Clause](https://iomete.com/resources/reference/spark-sql/queries/where-clause): The WHERE clause is used to limit the results of the FROM clause of a query or a subquery based on the specified condition
- [Window Functions](https://iomete.com/resources/reference/spark-sql/queries/window-functions): Window functions operate on a group of rows, referred to as a window, and calculate a return value for each row based on the group of rows
- [CASE Clause](https://iomete.com/resources/reference/spark-sql/queries/case-clause): CASE clause uses a rule to return a specific result based on the specified condition, similar to if/else statements in other programming languages
- [PIVOT Clause](https://iomete.com/resources/reference/spark-sql/queries/pivot-clause): The PIVOT clause is used for data perspective based on specific column values, which will be turned to multiple columns used in SELECT clause
- [LATERAL VIEW Clause](https://iomete.com/resources/reference/spark-sql/queries/lateral-view-clause): Literal view clause is used in conjunction with generator functions which will generate a virtual table containing one or more rows
- [TRANSFORM](https://iomete.com/resources/reference/spark-sql/queries/transform): The transform clause is used to specify a Hive-style transform query specification to transform the inputs by running a user-specified command or script
- [Cache](https://iomete.com/resources/reference/spark-sql/cache): Caches contents of a table or output of a query with the given storage level. This reduces scanning of the original files in future queries
- [Column Types](https://iomete.com/resources/reference/spark-sql/column-types): IOMETE Column Types are BOOLEAN, BYTE, SHORT, INT, LONG, FLOAT, DOUBLE, DATE, TIMESTAMP, STRING, BINARY, DECIMAL, ARRAY, STRUCT, MAP. Examples of usage and range of values
- [Datetime Patterns](https://iomete.com/resources/reference/spark-sql/datetime-patterns): Datetime Patterns for Formatting and Parsing. There are several common scenarios for datetime usage in Apache Spark
- [Identifiers](https://iomete.com/resources/reference/spark-sql/identifiers): An identifier is a string used to identify a database object. Spark SQL has regular identifiers and delimited identifiers, which are enclosed within backtick
- [Operators](https://iomete.com/resources/reference/spark-sql/operators): Learn about logical, arithmetic, and comparison operators in SQL. Understand how to use operators such as !, %, *, +, -, /, <, <=, <=>, =, ==, >, >=, and more with examples.
- [Literals](https://iomete.com/resources/reference/spark-sql/literals): String Binary Null Boolean Numeric and Datetime literals. Learn about syntax and examples for each type of literal in SQL.
- [NULL Semantics](https://iomete.com/resources/reference/spark-sql/null-semantics): How to handle NULL - the value of a column specific to a row is not known at the time the row comes into existence in SQL
- [Functions](https://iomete.com/resources/reference/spark-sql/functions): Dive into the world of SQL built-in functions and learn how to manipulate, aggregate, and transform data with ease. Discover how to improve your queries with essential functions like COUNT, SUM, AVG, MIN, MAX, and more.

## Pyspark

- [Joins](https://iomete.com/resources/reference/pyspark/pyspark-join): PySpark join syntax with runnable examples for inner, left, right, full outer, cross, left semi and left anti joins, plus tips to avoid duplicate columns.
- [Storage Partitioned Joins (SPJ)](https://iomete.com/resources/reference/pyspark/pyspark-spj): Joining large tables efficiently

## Open Source Spark Jobs

- [Getting Started](https://iomete.com/resources/open-source-spark-jobs/getting-started): Access the IOMETE Spark Jobs Marketplace to find pre-built jobs for ingestion, compaction, catalog sync, and more, or create your own job templates to share with your organization.
- [Data Compaction](https://iomete.com/resources/open-source-spark-jobs/data-compaction): Keep Iceberg tables fast by running snapshot expiration, orphan file cleanup, data file compaction, and manifest rewrites on a schedule.
- [Lakehouse Backup](https://iomete.com/resources/open-source-spark-jobs/lakehouse-backup): Back up and restore lakehouse files between S3-compatible object stores and HDFS-compatible storage with a Spark job.
- [Query Scheduler Job](https://iomete.com/resources/open-source-spark-jobs/query-scheduler-job): IOMETE's Query Scheduler Job allows you to run warehouse queries on a schedule or manually.
- [Data Catalog Sync](https://iomete.com/resources/open-source-spark-jobs/catalog-sync): The Data Catalog Sync Job indexes tables across all catalogs, making them searchable and manageable in the Data Catalog.
- [Cleanup Untracked Folders](https://iomete.com/resources/open-source-spark-jobs/cleanup-untracked-table-folders): Identify and optionally delete table folders that remain in object storage but are no longer tracked by the catalog.
- [MySQL Database Replication](https://iomete.com/resources/open-source-spark-jobs/mysql-database-replication-job): Replicate MySQL tables to the IOMETE Lakehouse with a configuration-driven Spark job. Supports full load and incremental snapshot sync modes.
- [Kafka Streaming](https://iomete.com/resources/open-source-spark-jobs/kafka-streaming): Stream data from Kafka topics into the IOMETE Lakehouse as Iceberg tables using a configuration-driven Spark Structured Streaming job.
- [File Streaming](https://iomete.com/resources/open-source-spark-jobs/file-streaming): Continuously stream files from object storage into an Iceberg table with the File Streaming Spark job. Supports CSV, JSON, and Amazon S3 with SQS notifications.
- [Ingestion Jobs](https://iomete.com/resources/open-source-spark-jobs/ingesting-jobs): Data ingestion Spark jobs for IOMETE, including MySQL, Oracle, Kafka, Kinesis, file, and Debezium CDC replication into Iceberg tables

## Generic

- [From JDBC Sources](https://iomete.com/resources/tutorials/sync-data-from-jdbc-sources): Sync Data From JDBC Sources. This is an end-to-end guide about how to migrate tables from JDBC sources (MySQL, PostgreSQL, etc.) to IOMETE and display it in the BI dashboard.
- [Export as CSV](https://iomete.com/resources/tutorials/export-as-a-csv-file): Learn how to export data from a table as a CSV file in IOMETE using SQL Editor or by writing a query, and how to bypass limitations for larger exports by exporting to an S3 bucket. Compare pros and cons of each method

## AWS

- [Querying Files in AWS S3](https://iomete.com/resources/tutorials/aws/read-files-from-aws-s3): Querying Files in AWS S3 with IOMETE. This is an end-to-end guide about how to query and move files from your AWS S3 to IOMETE

## Iceberg

- [Compaction behavior - Copy on Write(COW) vs Merge on Read(MOR)](https://iomete.com/resources/tutorials/compaction-cow-mor): This documentation provides details on iceberg table compaction behavior for Copy-on-Write (COW) and Merge-on-Read (MOR) tables.