moose-lib 0.6.90__py3-none-any.whl → 0.6.283__py3-none-any.whl

moose_lib/utilities/sql.py

@@ -31,4 +31,3 @@ def clickhouse_param_type_for_value(value: Any) -> str:
     if not isinstance(value, str):
         print(f"unhandled type {type(value)}", file=sys.stderr)
     return "String"
-

{moose_lib-0.6.90.dist-info → moose_lib-0.6.283.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moose_lib
-Version: 0.6.90
+Version: 0.6.283
 Home-page: https://www.fiveonefour.com/moose
 Author: Fiveonefour Labs Inc.
 Author-email: support@fiveonefour.com
@@ -15,6 +15,7 @@ Requires-Dist: humanfriendly>=10.0
 Requires-Dist: clickhouse_connect>=0.7.16
 Requires-Dist: requests>=2.32.3
 Requires-Dist: sqlglot[rs]>=27.16.3
+Requires-Dist: confluent-kafka[json,schemaregistry]>=2.11.1
 Dynamic: author
 Dynamic: author-email
 Dynamic: description
@@ -26,3 +27,20 @@ Dynamic: requires-python
 # Python Moose Lib
 
 Python package which contains moose utils
+
+## Column Autocomplete with MooseModel
+
+For LSP autocomplete when working with columns, use `MooseModel` instead of `BaseModel`:
+
+```python
+from moose_lib import MooseModel, OlapTable
+
+class User(MooseModel):
+    user_id: int
+    email: str
+
+# Autocomplete works when typing User.user_id
+query = f"SELECT {User.user_id:col}, {User.email:col} FROM users"
+```
+
+See [MooseModel Autocomplete Guide](docs/moose-model-autocomplete.md) for details.

moose_lib-0.6.283.dist-info/RECORD

@@ -0,0 +1,63 @@
+moose_lib/__init__.py,sha256=jvIQmk1u6fG59qsiLziJbdEL2ZZsNLQgkvgyGL9tpU0,1491
+moose_lib/blocks.py,sha256=mKajYpnQ42V5fvw65-D-PEX8JcZG0MOX7BIYuY5CIxQ,25363
+moose_lib/commons.py,sha256=pVan-44bZceHy-4cNxMnDlDsgbp27J5q3a-Dd_NWXiU,6574
+moose_lib/data_models.py,sha256=sxd30I9Fkz9bJzg3t_Smq5ahj03fG67vXqqNs-ZDL_o,24100
+moose_lib/dmv2_serializer.py,sha256=CL_Pvvg8tJOT8Qk6hywDNzY8MYGhMVdTOw8arZi3jng,49
+moose_lib/internal.py,sha256=6AfSogkixdAY44IeYCeWlrdXu2XAxaiGH0TzZfKy6OI,35767
+moose_lib/main.py,sha256=P9E2bg1LvVM8ZrCC-mN0DqplgzQ7h6F17onIkOmAyn0,21008
+moose_lib/query_builder.py,sha256=YenSawKqXD2n-rQ74FRfNoZ2KZpBiOv7a5G3CEFm1wg,6793
+moose_lib/query_param.py,sha256=9qTEjO6OLHDkuwdUtdNqw_ye-A5ny5y_AZ1S37PfKwk,7009
+moose_lib/secrets.py,sha256=GhsFlIWtGbUQYqEMClrCxcvUPEXxtF-zFkjEcmbco1c,4245
+moose_lib/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+moose_lib/clients/redis_client.py,sha256=S-KdZaDVWKb4t5isedjF3z9wDcBx-PaTHyS9JBNt3NQ,12115
+moose_lib/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+moose_lib/config/config_file.py,sha256=a6JdyxfjIUfTcl_Xm-zA4ATMXJHVIaP-eBQpGvsz7f4,3890
+moose_lib/config/runtime.py,sha256=a6pPBD96wEsJKV4LKxoFjiRtbmTtuwzS0N0IEs-s6mo,8657
+moose_lib/dmv2/__init__.py,sha256=REhStLFoYuQz7-VzswoUxm8NAvaqd-HkEkM_Ybb6QPQ,3367
+moose_lib/dmv2/_registry.py,sha256=iO08jI6adyyszYyt53qgYphhLhwMo9JDXqmEfLj0L1Y,741
+moose_lib/dmv2/_source_capture.py,sha256=qC-foQOkhl0GIQmCk5NVBq7SUhXGWy22fMbtNFWYsAY,1222
+moose_lib/dmv2/consumption.py,sha256=gJhCKKbgQ_VHiKddkiI-Z8r0bfBfeROTK1KVuII-OY4,13100
+moose_lib/dmv2/ingest_api.py,sha256=j5fPjC0TnAnQLX-U9v-kpNyt2kTgPuaZ-QoFhCmuujc,2594
+moose_lib/dmv2/ingest_pipeline.py,sha256=d4UND75j9GuCi2EgUpsidySB_fi_7bho251Gev9P6g8,8659
+moose_lib/dmv2/life_cycle.py,sha256=7MqN1bIS9aX2wX9lgHFZtTUAf9GNrYvz6a7g5Kpw5-o,1256
+moose_lib/dmv2/materialized_view.py,sha256=rMivRcHw3BuLA6hfRULSe2-DcwOTVZEJHnCjxLhwp9E,4966
+moose_lib/dmv2/moose_model.py,sha256=5QGf5ep1tRa9qWA-rTNiF78id6ZLqZGRuqhNxaE0KlU,5268
+moose_lib/dmv2/olap_table.py,sha256=tk1dR8_SirJLFvQS2nDpE9pHx8fhfulSCwcqoozyrtc,41803
+moose_lib/dmv2/registry.py,sha256=LIx-LEyTIw2KWUjZoECIfw6jCPAsNP_kWDql-KxjizY,2955
+moose_lib/dmv2/sql_resource.py,sha256=LT28uq38rJ5hZSeu8Bmvvx6kt6T4qPUfKZiCo6im9ac,2117
+moose_lib/dmv2/stream.py,sha256=5HR9s9Wub7NPZNnFmU6gc-IsHMhJDyGYqicnrYH23qA,18542
+moose_lib/dmv2/types.py,sha256=K7QcL2WtM0vq_yy4NTwX8MOv0VdZ0Gza6LKG5H9CnKg,4667
+moose_lib/dmv2/view.py,sha256=9Me1p-1etvUkiomRxOreiUjwQbQokOd1eHsQZTtpsCE,1383
+moose_lib/dmv2/web_app.py,sha256=DtG_vgCFJ2Czb7ukqsQc6JO7BvGWjqwNce8LRFt_FIk,5494
+moose_lib/dmv2/web_app_helpers.py,sha256=wYHKJIl6lC7UNfw7DeLgDWOwt0OrzSXzM1a99rlSTfw,2899
+moose_lib/dmv2/workflow.py,sha256=aBBRmSo5nLxG_AVWjpRDkE9WsGetF6ILMNCW9H2F40I,6456
+moose_lib/streaming/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+moose_lib/streaming/streaming_function_runner.py,sha256=f551lwAEv8-gt3qLsZ12Rkqn1lllcCjpMQv53UKLjaw,25356
+moose_lib/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+moose_lib/utilities/sql.py,sha256=-OvBWZWRHU817zl2fU_wFlgGLbtoK83e-b09kFW4kaE,903
+tests/__init__.py,sha256=jfCJcz0MBRIZe-gEcfvbe2f-Ns8_nx9O3hVudbHGjbg,53
+tests/conftest.py,sha256=CRrm2SPmuMUctPx1KufzmrhlrIL9BEIdi4iK8SI0OQA,993
+tests/test_backward_compatibility.py,sha256=G8bqSbRllF6SgkFyXruZRzPy15Pk9BdCeY-6X2ND6p0,2272
+tests/test_cluster_validation.py,sha256=U2SOvvwFxwW7JeeO2RtkMjjPBXzCHVR4E2WRShD07hI,2605
+tests/test_codec.py,sha256=Mfn7_pjgc1jPYtXhhcKzmHhe6kURJzjlY5jV0chwYUY,2340
+tests/test_column_formatting.py,sha256=eFrpg1l7KCk2kSJeQxrtifgIsgaDwyk5J7lzaGV2SHU,2057
+tests/test_fixedstring.py,sha256=wQbQLEMXgWRx7B7jtLomkP6HEaNFhhfbRkfVReoJY-E,1552
+tests/test_iceberg_config.py,sha256=6Xrl_jyoPhFtFEkLmBXnuGteqxU83kRqeFeHU92ch3I,3692
+tests/test_int_types.py,sha256=9JOpHdKir9xRjRemS_YzWZ0mGwBXYG0WzaZzMnD0A08,6528
+tests/test_kafka_config.py,sha256=2QsdAanJGKbk33jnDrrMvGLJnNAj7_ZJsJtNdQ0Rh4Y,4307
+tests/test_materialized.py,sha256=rw8ae4FoY0TZzthCLrOxiznwRDH90U079pUjVJvX7MQ,2520
+tests/test_metadata.py,sha256=m8BDuFFFQggPz8mBRQw0UB_K5wrtvawQrsHamlOzyNg,1131
+tests/test_moose.py,sha256=jsw7tRS8FyPsVxD5xD9QvpV3axx5wOajc26yMt9boDE,2021
+tests/test_moose_model.py,sha256=p2bQLreqRh-6WmthyhB2Vyc-gSHsOQsEOLnx9_RtxSA,4208
+tests/test_olap_table_moosemodel.py,sha256=_ZXruANx-EvN2mZvUoVfaO-UlihKEEeXoIVyVLA-gyg,2455
+tests/test_olap_table_versioning.py,sha256=XsSia_Pz_whHLVU1uT7Wm9fK55DJxpTsvzYMyj1Ihu8,6832
+tests/test_query_builder.py,sha256=65JUTd9uudVjT7sJpYdUDTGhlp1s40OPEhyOVN6Ayfc,4204
+tests/test_redis_client.py,sha256=t_c5s9r2CiJHlP6K_VRud5sr68urwN0iU5p2VA5D294,3225
+tests/test_s3queue_config.py,sha256=m5JDL_w-73cRYp9HarB3JHQCLNwApzKyfnm4Aa4biec,14233
+tests/test_secrets.py,sha256=QfkFq2fWxnFj2Wk37VIPVB7LfgizH50s7lQi4YAnZ9Q,8797
+tests/test_simple_aggregate.py,sha256=aXT2QjSCByY9_ygRcoAyLhEFgKZB4z7LFJg75GU_ntQ,4072
+tests/test_web_app.py,sha256=swuAEOdmbrDnKo2K9BRl0kBKIeSI2r_SfUS5ZF3x55g,6585
+moose_lib-0.6.283.dist-info/METADATA,sha256=eWeFg2UNYKGaLdXgni4g7S4-8MRAQv-l3WUqDRm0qC8,1270
+moose_lib-0.6.283.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+moose_lib-0.6.283.dist-info/top_level.txt,sha256=XEns2-4aCmGp2XjJAeEH9TAUcGONLnSLy6ycT9FSJh8,16
+moose_lib-0.6.283.dist-info/RECORD,,

tests/__init__.py

@@ -1 +1 @@
-# Empty __init__.py to mark this as a Python package 
+# Empty __init__.py to mark this as a Python package

tests/conftest.py

@@ -3,4 +3,41 @@ import os
 import sys
 
 # Add the package root to Python path for imports
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))) 
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+
+@pytest.fixture(autouse=True)
+def clear_registries():
+    """Clear all global registries before each test to prevent conflicts."""
+    from moose_lib.dmv2._registry import (
+        _tables,
+        _streams,
+        _ingest_apis,
+        _apis,
+        _api_name_aliases,
+        _api_path_map,
+        _sql_resources,
+        _workflows,
+    )
+
+    # Clear all registries
+    _tables.clear()
+    _streams.clear()
+    _ingest_apis.clear()
+    _apis.clear()
+    _api_name_aliases.clear()
+    _api_path_map.clear()
+    _sql_resources.clear()
+    _workflows.clear()
+
+    yield
+
+    # Clean up after test (optional, but good practice)
+    _tables.clear()
+    _streams.clear()
+    _ingest_apis.clear()
+    _apis.clear()
+    _api_name_aliases.clear()
+    _api_path_map.clear()
+    _sql_resources.clear()
+    _workflows.clear()

tests/test_backward_compatibility.py

@@ -0,0 +1,85 @@
+"""
+Tests ensuring MooseModel doesn't break existing BaseModel usage
+"""
+
+from pydantic import BaseModel
+from moose_lib.dmv2 import OlapTable, OlapConfig, MooseModel
+from moose_lib.data_models import Column
+
+
+def test_basemodel_olaptable_still_works():
+    """Existing code using BaseModel should continue working"""
+
+    class LegacyUser(BaseModel):
+        user_id: int
+        email: str
+
+    # Old pattern still works
+    table = OlapTable[LegacyUser]("legacy_users")
+
+    assert table.name == "legacy_users"
+    assert hasattr(table, "cols")
+    assert isinstance(table.cols.user_id, Column)
+
+
+def test_moosemodel_and_basemodel_can_coexist():
+    """Projects can mix MooseModel and BaseModel"""
+
+    class NewModel(MooseModel):
+        new_field: int
+
+    class OldModel(BaseModel):
+        old_field: str
+
+    new_table = OlapTable[NewModel]("new_table")
+    old_table = OlapTable[OldModel]("old_table")
+
+    # Both work
+    assert new_table.name == "new_table"
+    assert old_table.name == "old_table"
+
+    # New model has direct column access
+    assert isinstance(NewModel.new_field, Column)
+
+    # Old model doesn't (expected)
+    assert (
+        not isinstance(OldModel.old_field, Column)
+        if hasattr(OldModel, "old_field")
+        else True
+    )
+
+
+def test_moosemodel_cols_matches_direct_access():
+    """MooseModel.cols.field and MooseModel.field should return same Column"""
+
+    class Analytics(MooseModel):
+        event_id: int
+        timestamp: str
+
+    # Both access methods return the same Column
+    direct = Analytics.event_id
+    via_cols = Analytics.cols.event_id
+
+    assert direct.name == via_cols.name
+    assert direct.data_type == via_cols.data_type
+
+
+def test_existing_query_patterns_unchanged():
+    """Existing query patterns should work identically"""
+
+    class Metrics(MooseModel):
+        metric_id: int
+        value: float
+
+    table = OlapTable[Metrics]("metrics")
+
+    # Pattern 1: Using table.cols (existing pattern)
+    col_via_table = table.cols.metric_id
+    assert isinstance(col_via_table, Column)
+
+    # Pattern 2: Using Model.cols (also existing)
+    col_via_model = Metrics.cols.metric_id
+    assert isinstance(col_via_model, Column)
+
+    # Both are equivalent
+    assert col_via_table.name == col_via_model.name

tests/test_cluster_validation.py

@@ -0,0 +1,85 @@
+"""Tests for OlapTable cluster validation."""
+
+import pytest
+from moose_lib import OlapTable, OlapConfig, MergeTreeEngine, ReplicatedMergeTreeEngine
+from pydantic import BaseModel
+
+
+class SampleModel(BaseModel):
+    """Test model for cluster validation tests."""
+
+    id: str
+    value: int
+
+
+def test_cluster_only_is_allowed():
+    """Test that specifying only cluster works."""
+    table = OlapTable[SampleModel](
+        "TestClusterOnly",
+        OlapConfig(
+            engine=MergeTreeEngine(),
+            order_by_fields=["id"],
+            cluster="test_cluster",
+        ),
+    )
+    assert table is not None
+
+
+def test_explicit_params_only_is_allowed():
+    """Test that specifying explicit keeper_path and replica_name without cluster works."""
+    table = OlapTable[SampleModel](
+        "TestExplicitOnly",
+        OlapConfig(
+            engine=ReplicatedMergeTreeEngine(
+                keeper_path="/clickhouse/tables/{database}/{table}",
+                replica_name="{replica}",
+            ),
+            order_by_fields=["id"],
+        ),
+    )
+    assert table is not None
+
+
+def test_cluster_and_explicit_params_raises_error():
+    """Test that specifying both cluster and explicit keeper_path/replica_name raises an error."""
+    with pytest.raises(
+        ValueError,
+        match=r"Cannot specify both 'cluster' and explicit replication params",
+    ):
+        OlapTable[SampleModel](
+            "TestBothClusterAndExplicit",
+            OlapConfig(
+                engine=ReplicatedMergeTreeEngine(
+                    keeper_path="/clickhouse/tables/{database}/{table}",
+                    replica_name="{replica}",
+                ),
+                order_by_fields=["id"],
+                cluster="test_cluster",
+            ),
+        )
+
+
+def test_non_replicated_engine_with_cluster_is_allowed():
+    """Test that non-replicated engines can have a cluster specified."""
+    table = OlapTable[SampleModel](
+        "TestMergeTreeWithCluster",
+        OlapConfig(
+            engine=MergeTreeEngine(),
+            order_by_fields=["id"],
+            cluster="test_cluster",
+        ),
+    )
+    assert table is not None
+
+
+def test_replicated_engine_without_cluster_or_explicit_params_is_allowed():
+    """Test that ReplicatedMergeTree without cluster or explicit params works (ClickHouse Cloud mode)."""
+    table = OlapTable[SampleModel](
+        "TestCloudMode",
+        OlapConfig(
+            engine=ReplicatedMergeTreeEngine(),
+            order_by_fields=["id"],
+            # No cluster, no keeper_path, no replica_name
+        ),
+    )
+    assert table is not None

tests/test_codec.py

@@ -0,0 +1,75 @@
+from datetime import datetime
+from typing import Annotated, Any
+from pydantic import BaseModel
+from moose_lib import Key, ClickHouseCodec, UInt64
+from moose_lib.data_models import _to_columns
+
+
+def test_codec_single():
+    """Test single codec annotation converts to correct ClickHouse CODEC."""
+
+    class CodecTest(BaseModel):
+        id: Key[str]
+        data: Annotated[str, ClickHouseCodec("ZSTD(3)")]
+
+    columns = _to_columns(CodecTest)
+    by_name = {col.name: col for col in columns}
+
+    assert by_name["data"].codec == "ZSTD(3)"
+    assert by_name["id"].codec is None
+
+
+def test_codec_chain():
+    """Test codec chain annotation (Delta, LZ4)."""
+
+    class CodecChainTest(BaseModel):
+        timestamp: Annotated[datetime, ClickHouseCodec("Delta, LZ4")]
+        value: Annotated[float, ClickHouseCodec("Gorilla, ZSTD")]
+
+    columns = _to_columns(CodecChainTest)
+    by_name = {col.name: col for col in columns}
+
+    assert by_name["timestamp"].codec == "Delta, LZ4"
+    assert by_name["value"].codec == "Gorilla, ZSTD"
+
+
+def test_codec_with_level():
+    """Test codec with compression level."""
+
+    class CodecLevelTest(BaseModel):
+        log_blob: Annotated[Any, ClickHouseCodec("ZSTD(3)")]
+        combination_hash: Annotated[list[UInt64], ClickHouseCodec("ZSTD(1)")]
+
+    columns = _to_columns(CodecLevelTest)
+    by_name = {col.name: col for col in columns}
+
+    assert by_name["log_blob"].codec == "ZSTD(3)"
+    assert by_name["combination_hash"].codec == "ZSTD(1)"
+
+
+def test_codec_specialized():
+    """Test specialized codecs."""
+
+    class SpecializedCodecTest(BaseModel):
+        timestamp: Annotated[datetime, ClickHouseCodec("Delta")]
+        counter: Annotated[int, ClickHouseCodec("DoubleDelta")]
+        temperature: Annotated[float, ClickHouseCodec("Gorilla")]
+
+    columns = _to_columns(SpecializedCodecTest)
+    by_name = {col.name: col for col in columns}
+
+    assert by_name["timestamp"].codec == "Delta"
+    assert by_name["counter"].codec == "DoubleDelta"
+    assert by_name["temperature"].codec == "Gorilla"
+
+
+def test_codec_none():
+    """Test codec with NONE (uncompressed)."""
+
+    class NoCodecTest(BaseModel):
+        data: Annotated[str, ClickHouseCodec("NONE")]
+
+    columns = _to_columns(NoCodecTest)
+    by_name = {col.name: col for col in columns}
+
+    assert by_name["data"].codec == "NONE"

tests/test_column_formatting.py

@@ -0,0 +1,80 @@
+"""Tests for Column string formatting and interpolation"""
+
+from moose_lib.data_models import Column
+
+
+def test_column_str_returns_quoted_identifier():
+    """Column.__str__() should return backtick-quoted identifier"""
+    col = Column(
+        name="user_id",
+        data_type="String",
+        required=True,
+        unique=False,
+        primary_key=False,
+    )
+
+    assert str(col) == "`user_id`"
+
+
+def test_column_format_spec_col():
+    """Column with :col format spec should return quoted identifier"""
+    col = Column(
+        name="email", data_type="String", required=True, unique=False, primary_key=False
+    )
+
+    result = f"{col:col}"
+    assert result == "`email`"
+
+
+def test_column_format_spec_c():
+    """Column with :c format spec should return quoted identifier"""
+    col = Column(
+        name="timestamp",
+        data_type="DateTime",
+        required=True,
+        unique=False,
+        primary_key=False,
+    )
+
+    result = f"{col:c}"
+    assert result == "`timestamp`"
+
+
+def test_column_format_spec_empty():
+    """Column with no format spec should return quoted identifier"""
+    col = Column(
+        name="count", data_type="Int64", required=True, unique=False, primary_key=False
+    )
+
+    result = f"{col}"
+    assert result == "`count`"
+
+
+def test_column_with_special_chars():
+    """Column names with hyphens should be quoted"""
+    col = Column(
+        name="user-id",
+        data_type="String",
+        required=True,
+        unique=False,
+        primary_key=False,
+    )
+
+    assert str(col) == "`user-id`"
+
+
+def test_column_in_fstring_interpolation():
+    """Column should work in f-string SQL construction"""
+    user_id_col = Column(
+        name="user_id",
+        data_type="String",
+        required=True,
+        unique=False,
+        primary_key=False,
+    )
+    email_col = Column(
+        name="email", data_type="String", required=True, unique=False, primary_key=False
+    )
+
+    query = f"SELECT {user_id_col:col}, {email_col:col} FROM users"
+    assert query == "SELECT `user_id`, `email` FROM users"

tests/test_fixedstring.py

@@ -0,0 +1,43 @@
+from datetime import datetime
+from typing import Annotated
+from pydantic import BaseModel
+from moose_lib import Key, FixedString
+from moose_lib.data_models import _to_columns
+
+
+def test_fixedstring_annotation():
+    """Test FixedString annotation converts to correct ClickHouse type with str base type."""
+
+    class FixedStringTest(BaseModel):
+        id: Key[str]
+        created_at: datetime
+        md5_hash: Annotated[str, FixedString(16)]
+        sha256_hash: Annotated[str, FixedString(32)]
+        ipv6_address: Annotated[str, FixedString(16)]
+
+    columns = _to_columns(FixedStringTest)
+    by_name = {col.name: col for col in columns}
+
+    assert by_name["md5_hash"].data_type == "FixedString(16)"
+    assert by_name["sha256_hash"].data_type == "FixedString(32)"
+    assert by_name["ipv6_address"].data_type == "FixedString(16)"
+
+    # Verify other fields still work
+    assert by_name["id"].data_type == "String"
+    assert by_name["created_at"].data_type == "DateTime"
+
+
+def test_fixedstring_different_sizes():
+    """Test various FixedString sizes."""
+
+    class FixedStringSizes(BaseModel):
+        mac_address: Annotated[str, FixedString(6)]
+        uuid_binary: Annotated[str, FixedString(16)]
+        sha512_hash: Annotated[str, FixedString(64)]
+
+    columns = _to_columns(FixedStringSizes)
+    by_name = {col.name: col for col in columns}
+
+    assert by_name["mac_address"].data_type == "FixedString(6)"
+    assert by_name["uuid_binary"].data_type == "FixedString(16)"
+    assert by_name["sha512_hash"].data_type == "FixedString(64)"

tests/test_iceberg_config.py

@@ -0,0 +1,105 @@
+import pytest
+from moose_lib import OlapTable, OlapConfig
+from moose_lib.blocks import IcebergS3Engine
+from pydantic import BaseModel
+
+
+class SampleData(BaseModel):
+    id: str
+    name: str
+    value: int
+
+
+def test_iceberg_engine_basic_creation():
+    """Test basic IcebergS3Engine creation with required fields"""
+    engine = IcebergS3Engine(path="s3://bucket/warehouse/table/", format="Parquet")
+    assert engine.path == "s3://bucket/warehouse/table/"
+    assert engine.format == "Parquet"
+    assert engine.aws_access_key_id is None
+    assert engine.aws_secret_access_key is None
+    assert engine.compression is None
+
+
+def test_iceberg_engine_with_all_options():
+    """Test IcebergS3Engine with all optional configuration"""
+    engine = IcebergS3Engine(
+        path="s3://bucket/table/",
+        format="ORC",
+        aws_access_key_id="AKIATEST",
+        aws_secret_access_key="secret123",
+        compression="zstd",
+    )
+    assert engine.path == "s3://bucket/table/"
+    assert engine.format == "ORC"
+    assert engine.aws_access_key_id == "AKIATEST"
+    assert engine.aws_secret_access_key == "secret123"
+    assert engine.compression == "zstd"
+
+
+def test_iceberg_engine_missing_path():
+    """Test that missing path raises ValueError"""
+    with pytest.raises(ValueError, match="IcebergS3 engine requires 'path'"):
+        IcebergS3Engine(path="", format="Parquet")
+
+
+def test_iceberg_engine_missing_format():
+    """Test that missing format raises ValueError"""
+    with pytest.raises(ValueError, match="IcebergS3 engine requires 'format'"):
+        IcebergS3Engine(path="s3://bucket/table/", format="")
+
+
+def test_iceberg_engine_invalid_format():
+    """Test that invalid format raises ValueError (only Parquet and ORC supported)"""
+    with pytest.raises(ValueError, match="format must be 'Parquet' or 'ORC'"):
+        IcebergS3Engine(path="s3://bucket/table/", format="JSON")
+
+
+def test_iceberg_rejects_order_by():
+    """Test that IcebergS3 engine rejects ORDER BY clauses (read-only external table)"""
+    with pytest.raises(
+        ValueError, match="IcebergS3Engine does not support ORDER BY clauses"
+    ):
+        OlapConfig(
+            engine=IcebergS3Engine(path="s3://bucket/table/", format="Parquet"),
+            order_by_fields=["id"],
+        )
+
+
+def test_iceberg_rejects_partition_by():
+    """Test that IcebergS3 engine rejects PARTITION BY clauses (read-only external table)"""
+    with pytest.raises(
+        ValueError, match="IcebergS3Engine does not support PARTITION BY clause"
+    ):
+        OlapConfig(
+            engine=IcebergS3Engine(path="s3://bucket/table/", format="Parquet"),
+            partition_by="toYYYYMM(timestamp)",
+        )
+
+
+def test_iceberg_rejects_sample_by():
+    """Test that IcebergS3 engine rejects SAMPLE BY clauses (read-only external table)"""
+    with pytest.raises(
+        ValueError, match="IcebergS3Engine does not support SAMPLE BY clause"
+    ):
+        OlapConfig(
+            engine=IcebergS3Engine(path="s3://bucket/table/", format="Parquet"),
+            sample_by_expression="cityHash64(id)",
+        )
+
+
+def test_iceberg_table_in_olap_table():
+    """Test creating OlapTable with IcebergS3Engine and custom settings"""
+    table = OlapTable[SampleData](
+        "lake_events",
+        OlapConfig(
+            engine=IcebergS3Engine(
+                path="s3://datalake/events/",
+                format="Parquet",
+                aws_access_key_id="AKIATEST",
+                aws_secret_access_key="secret123",
+            )
+        ),
+    )
+    assert table.name == "lake_events"
+    assert isinstance(table.config.engine, IcebergS3Engine)
+    assert table.config.engine.path == "s3://datalake/events/"