maxframe 1.3.0__cp311-cp311-win_amd64.whl → 2.0.0b1__cp311-cp311-win_amd64.whl

maxframe/codegen/spe/dataframe/tests/missing/test_dropna.py

@@ -0,0 +1,50 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+
+from ...... import dataframe as md
+from .....core import EngineAcceptance
+from ....core import SPECodeContext
+from ...missing import DataFrameDropNAAdapter
+
+
+@pytest.fixture
+def df1():
+    return md.DataFrame(
+        [
+            [None, 10.0, None, "1000"],
+            [2, None, False, "2000"],
+            [3, None, None, "3000"],
+            [4, None, True, None],
+        ],
+        index=md.Index([1, 2, 3, 4], name="test_idx"),
+        columns=list("ABCD"),
+    )
+
+
+def test_drop_na(df1):
+    adapter = DataFrameDropNAAdapter()
+    context = SPECodeContext()
+    df = df1.dropna(thresh=2)
+    assert adapter.accepts(df.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(df.op, context)
+    expected_results = ["var_1 = var_0.dropna(axis=0, thresh=2)"]
+    assert results == expected_results
+
+    df = df1.dropna(thresh=2, ignore_index=True)
+    assert adapter.accepts(df.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(df.op, context)
+    expected_results = ["var_2 = var_0.dropna(axis=0, thresh=2).reset_index(drop=True)"]
+    assert results == expected_results

maxframe/codegen/spe/dataframe/tests/missing/test_fillna.py

@@ -0,0 +1,94 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+
+from ...... import dataframe as md
+from .....core import EngineAcceptance
+from ....core import SPECodeContext
+from ...missing import DataFrameFillNAAdapter
+
+
+@pytest.fixture
+def df1():
+    return md.DataFrame(
+        [
+            [None, 10.0, None, "1000"],
+            [2, None, False, "2000"],
+            [3, None, None, "3000"],
+            [4, None, True, None],
+        ],
+        index=md.Index([1, 2, 3, 4], name="test_idx"),
+        columns=list("ABCD"),
+    )
+
+
+@pytest.fixture
+def df2():
+    return md.DataFrame(
+        [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]],
+        index=[4, 3, 2, 1],
+        columns=list("ABCE"),
+    )
+
+
+def test_fill_na_with_scalar(df1):
+    adapter = DataFrameFillNAAdapter()
+    context = SPECodeContext()
+    df = df1.fillna(3)
+    assert adapter.accepts(df.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(df.op, context)
+    expected_results = [
+        "var_1 = var_0.fillna(value=3, method=None, axis=0, limit=None, downcast=None)"
+    ]
+    assert results == expected_results
+
+
+def test_dataframe_fill_na_with_dict(df1):
+    adapter = DataFrameFillNAAdapter()
+    context = SPECodeContext()
+    df = df1.fillna({"A": 1, "C": True, "D": "filled"})
+    assert adapter.accepts(df.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(df.op, context)
+    expected_results = [
+        "var_1 = var_0.fillna(value={'A': 1, 'C': True, 'D': 'filled'},"
+        " method=None, axis=0, limit=None, downcast=None)"
+    ]
+    assert results == expected_results
+
+
+def test_fill_na_with_dataframe(df1, df2):
+    adapter = DataFrameFillNAAdapter()
+    context = SPECodeContext()
+    df = df1.fillna(df2)
+    assert adapter.accepts(df.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(df.op, context)
+    expected_results = [
+        "var_1 = var_0.fillna(value=var_2, method=None, axis=0, limit=None,"
+        " downcast=None)"
+    ]
+    assert results == expected_results
+
+
+def test_fill_na_in_column(df1):
+    adapter = DataFrameFillNAAdapter()
+    context = SPECodeContext()
+    df = df1.fillna(method="bfill", axis=1)
+    assert adapter.accepts(df.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(df.op, context)
+    expected_results = [
+        "var_1 = var_0.fillna(value=None, method='bfill', axis=1, limit=None,"
+        " downcast=None)"
+    ]
+    assert results == expected_results

maxframe/codegen/spe/dataframe/tests/missing/test_replace.py

@@ -0,0 +1,45 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import maxframe.dataframe as md
+
+from ....core import SPECodeContext
+from ...missing import DataFrameReplaceAdapter
+
+
+def test_dataframe_replace():
+    df1 = md.DataFrame(
+        {"A": [0, 1, 2, 3, 4], "B": [5, 6, 7, 8, 9], "C": ["a", "b", "c", "d", "e"]}
+    )
+    df = df1.replace(to_replace=0, value=5)
+    adapter = DataFrameReplaceAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(df.op, context)
+    expected_results = [
+        "var_1 = var_0.replace(to_replace=0, value=5, limit=None, regex=False)"
+    ]
+    assert results == expected_results
+
+
+def test_series_replace():
+    s1 = md.Series([1, 2, 3, 4, 5])
+    s = s1.replace(to_replace=1, value=5)
+
+    adapter = DataFrameReplaceAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(s.op, context)
+    expected_results = [
+        "var_1 = var_0.replace(to_replace=1, value=5, limit=None, regex=False)"
+    ]
+    assert results == expected_results

maxframe/codegen/spe/dataframe/tests/test_arithmetic.py

@@ -0,0 +1,73 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import maxframe.dataframe as md
+import maxframe.tensor as mt
+
+from ...core import SPECodeContext
+from ..arithmetic import DataFrameBinOpAdapter, DataFrameUnaryFuncAdapter
+
+
+def test_common_unary():
+    s1 = mt.random.randint(0, 100, size=(5, 2))
+    v1 = md.DataFrame(s1, columns=["A", "B"], chunk_size=1)
+    df = v1.abs()
+    adapter = DataFrameUnaryFuncAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(df.op, context)
+    expected_results = ["var_1 = np.abs(var_0)"]
+    assert results == expected_results
+
+
+def test_round():
+    adapter = DataFrameUnaryFuncAdapter()
+    context = SPECodeContext()
+
+    s1 = mt.random.randint(0, 100, size=(5, 2))
+    v1 = md.DataFrame(s1, columns=["A", "B"], chunk_size=1)
+
+    df = v1.round({"A": 0, "B": 1})
+    results = adapter.generate_code(df.op, context)
+    expected_results = ["var_1 = var_0.round({'A': 0, 'B': 1})"]
+    assert results == expected_results
+
+    df = v1.round(1)
+    results = adapter.generate_code(df.op, context)
+    expected_results = ["var_2 = var_0.round(1)"]
+    assert results == expected_results
+
+
+def test_binary_with_axis():
+    s1 = mt.random.randint(0, 100, size=(5, 2))
+    s2 = mt.random.randint(0, 100, size=(5, 2))
+    v1 = md.DataFrame(s1, columns=["A", "B"], chunk_size=1)
+    v2 = md.DataFrame(s2, columns=["A", "B"], chunk_size=1)
+    df = v1.add(v2, axis="columns")
+    adapter = DataFrameBinOpAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(df.op, context)
+    expected_results = ["var_2 = var_0.add(var_1, axis=1)"]
+    assert results == expected_results
+
+
+def test_binary_without_axis():
+    s1 = mt.random.randint(0, 100, size=(5, 2))
+    v1 = md.DataFrame(s1, columns=["A", "B"], chunk_size=1)
+    v2 = md.DataFrame(s1, columns=["A", "B"], chunk_size=1)
+    df = v1["A"].add(v2["B"])
+    adapter = DataFrameBinOpAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(df.op, context)
+    expected_results = ["var_2 = var_0.add(var_1)"]
+    assert results == expected_results

maxframe/codegen/spe/dataframe/tests/test_datasource.py

@@ -0,0 +1,184 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+from odps import ODPS
+
+from ..... import dataframe as md
+from ..... import tensor as mt
+from .....dataframe.datasource.index import from_pandas
+from .....io.odpsio import ODPSTableIO
+from .....tests.utils import flaky, tn
+from ....core import EngineAcceptance
+from ...core import SPECodeContext
+from ..datasource import (
+    DataFrameDateRangeAdapter,
+    DataFrameFromRecordsAdapter,
+    DataFrameReadODPSTableAdapter,
+    IndexDataSourceAdapter,
+    SeriesFromTensorAdapter,
+)
+
+
+def _run_generated_code(code: str, ctx: SPECodeContext) -> dict:
+    local_vars = ctx.constants.copy()
+    local_vars["DataFrameReadODPSTableAdapter"] = DataFrameReadODPSTableAdapter
+    exec(code, local_vars, local_vars)
+    return local_vars
+
+
+def test_date_range():
+    rng = md.date_range(start="1/1/2018", end="1/08/2018")
+    context = SPECodeContext()
+    adapter = DataFrameDateRangeAdapter()
+    results = adapter.generate_code(rng.op, context)
+    assert "pd" in context.imports["pandas"]
+    expected_results = [
+        "var_0 = pd.date_range(start=pd.Timestamp('2018-01-01 00:00:00'), "
+        "end=pd.Timestamp('2018-01-08 00:00:00'), periods=8, freq=const_0, "
+        "normalize=False, inclusive='both')"
+    ]
+    assert results == expected_results
+
+
+def test_from_records():
+    data = mt.array(
+        [(3, "a"), (2, "b"), (1, "c"), (0, "d")],
+        dtype=[("col_1", "i4"), ("col_2", "U1")],
+    )
+    df = md.from_records(data)
+    context = SPECodeContext()
+    adapter = DataFrameFromRecordsAdapter()
+    results = adapter.generate_code(df.op, context)
+    assert "pd" in context.imports["pandas"]
+    expected_results = ["var_1 = pd.DataFrame.from_records(var_0, coerce_float=False)"]
+    assert results == expected_results
+
+
+def test_series_from_tensor():
+    s = md.Series(["a", "b", "c", "d"], index=md.Index(["p", "q", "r", "t"]))
+    context = SPECodeContext()
+    adapter = SeriesFromTensorAdapter()
+    results = adapter.generate_code(s.op, context)
+    assert "np" in context.imports["numpy"]
+    assert "pd" in context.imports["pandas"]
+    expected_results = [
+        "var_2 = pd.Series(var_0, index=var_1, name=None, dtype=np.dtype('<U1'))"
+    ]
+    assert results == expected_results
+
+
+@flaky(max_runs=3)
+def test_read_odps_table_simple_table():
+    odps_entry = ODPS.from_environments()
+    halo_table_io = ODPSTableIO(odps_entry)
+    table_name = tn("test_read_odps_table_simple_table_spe")
+
+    odps_entry.delete_table(table_name, if_exists=True)
+    table = odps_entry.create_table(
+        table_name, ",".join(f"{c} double" for c in "abcde"), lifecycle=1
+    )
+    pd_data = pd.DataFrame(np.random.rand(100, 5), columns=list("abcde"))
+    with halo_table_io.open_writer(table_name) as writer:
+        writer.write(pa.Table.from_pandas(pd_data, preserve_index=False))
+
+    df = md.read_odps_table(table_name)
+    ctx = SPECodeContext()
+    results = DataFrameReadODPSTableAdapter().generate_code(df.op, ctx)
+    expected_results = [
+        f"var_0 = DataFrameReadODPSTableAdapter._read_as_pandas("
+        f"'{table.full_table_name}', None, None, None, False, const_0)"
+    ]
+    assert results == expected_results
+    exec_results = _run_generated_code(results[0], ctx)
+    pd.testing.assert_frame_equal(pd_data, exec_results["var_0"])
+
+    df = md.read_odps_table(table_name, index_col="a")
+    ctx = SPECodeContext()
+    results = DataFrameReadODPSTableAdapter().generate_code(df.op, ctx)
+    expected_results = [
+        f"var_0 = DataFrameReadODPSTableAdapter._read_as_pandas("
+        f"'{table.full_table_name}', None, ['b', 'c', 'd', 'e'], ['a'], False, const_0)"
+    ]
+    assert results == expected_results
+    exec_results = _run_generated_code(results[0], ctx)
+    pd.testing.assert_frame_equal(pd_data.set_index("a"), exec_results["var_0"])
+
+    df = md.read_odps_table(table_name, columns=["a", "b"])
+    ctx = SPECodeContext()
+    results = DataFrameReadODPSTableAdapter().generate_code(df.op, ctx)
+    expected_results = [
+        f"var_0 = DataFrameReadODPSTableAdapter._read_as_pandas("
+        f"'{table.full_table_name}', None, ['a', 'b'], None, False, const_0)"
+    ]
+    assert results == expected_results
+    exec_results = _run_generated_code(results[0], ctx)
+    pd.testing.assert_frame_equal(pd_data[["a", "b"]], exec_results["var_0"])
+
+    table.drop()
+
+
+@flaky(max_runs=3)
+def test_read_odps_table_with_parts():
+    odps_entry = ODPS.from_environments()
+    halo_table_io = ODPSTableIO(odps_entry)
+    table_name = tn("test_read_odps_table_with_parts_spe")
+
+    odps_entry.delete_table(table_name, if_exists=True)
+    table = odps_entry.create_table(
+        table_name, (",".join(f"{c} double" for c in "abcde"), "pt string"), lifecycle=1
+    )
+    pd_data = pd.DataFrame(np.random.rand(100, 5), columns=list("abcde"))
+    with halo_table_io.open_writer(table_name, partition="pt=20240309") as writer:
+        writer.write(pa.Table.from_pandas(pd_data, preserve_index=False))
+
+    df = md.read_odps_table(table_name, partition="pt=20240309")
+    ctx = SPECodeContext()
+    results = DataFrameReadODPSTableAdapter().generate_code(df.op, ctx)
+    expected_results = [
+        f"var_0 = DataFrameReadODPSTableAdapter._read_as_pandas("
+        f"'{table.full_table_name}', ['pt=20240309'], None, None, False, const_0)"
+    ]
+    assert results == expected_results
+    exec_results = _run_generated_code(results[0], ctx)
+    pd.testing.assert_frame_equal(pd_data, exec_results["var_0"])
+
+    df = md.read_odps_table(table_name, append_partitions=True)
+    ctx = SPECodeContext()
+    results = DataFrameReadODPSTableAdapter().generate_code(df.op, ctx)
+    expected_results = [
+        f"var_0 = DataFrameReadODPSTableAdapter._read_as_pandas("
+        f"'{table.full_table_name}', None, None, None, True, const_0)"
+    ]
+    assert results == expected_results
+    exec_results = _run_generated_code(results[0], ctx)
+    expected = pd_data.copy()
+    expected["pt"] = "20240309"
+    pd.testing.assert_frame_equal(expected, exec_results["var_0"])
+
+    table.drop()
+
+
+def test_index_data_source():
+    pd_idx = pd.MultiIndex.from_tuples([(1, 1), (2, 2), (3, 3)], names=["x", "y"])
+    idx1 = from_pandas(pd_idx)
+    context = SPECodeContext()
+    adapter = IndexDataSourceAdapter()
+    assert adapter.accepts(idx1.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(idx1.op, context)
+    expected_results = ["var_0 = const_0"]
+    assert results == expected_results
+    assert context.constants["const_0"] is pd_idx

maxframe/codegen/spe/dataframe/tests/test_datastore.py

@@ -0,0 +1,200 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional
+
+import pandas as pd
+import pytest
+from odps import ODPS
+
+from ..... import dataframe as md
+from .....config import options
+from .....io.odpsio import HaloTableIO
+from .....tests.utils import flaky, tn
+from ...core import SPECodeContext
+from ..datastore import DataFrameToODPSTableAdapter
+
+
+@pytest.fixture
+def df1():
+    return md.DataFrame(
+        [[1, 10, "A"], [2, 20, "A"], [3, 30, "B"], [4, 40, "B"]],
+        index=list("abcd"),
+        columns=list("abc"),
+    )
+
+
+@pytest.fixture
+def df2():
+    return md.DataFrame(
+        [[1, 10, "A"], [2, 20, "A"], [3, 30, "B"], [4, 40, "B"]],
+        index=pd.MultiIndex.from_arrays([["A", "A", "B", "B"], [1, 2, 3, 4]]),
+        columns=list("abc"),
+    )
+
+
+@pytest.fixture(autouse=True)
+def auto_use_common_table():
+    try:
+        options.use_common_table = True
+        yield
+    finally:
+        options.use_common_table = False
+
+
+def _run_generated_code(
+    code: str, ctx: SPECodeContext, input_val: pd.DataFrame
+) -> dict:
+    local_vars = ctx.constants.copy()
+    local_vars["DataFrameToODPSTableAdapter"] = DataFrameToODPSTableAdapter
+    local_vars["var_0"] = input_val
+    exec(code, local_vars, local_vars)
+    return local_vars
+
+
+def _table_to_dataframe(
+    table_name: str, partition: Optional[str] = None
+) -> pd.DataFrame:
+    odps_entry = ODPS.from_environments()
+    halo_table_io = HaloTableIO(odps_entry)
+    with halo_table_io.open_reader(table_name, partition) as reader:
+        return reader.read_all().to_pandas()
+
+
+@flaky(max_runs=3)
+def test_to_odps_no_partition_no_index(df1):
+    odps_entry = ODPS.from_environments()
+    table_name = tn("test_to_odps_no_part_spe")
+    odps_entry.delete_table(table_name, if_exists=True)
+
+    res = md.to_odps_table(df1, table_name, index=False)
+    ctx = SPECodeContext()
+    results = DataFrameToODPSTableAdapter().generate_code(res.op, ctx)
+    expected_result = (
+        f"DataFrameToODPSTableAdapter._write_as_table(var_0, '{table_name}', "
+        f"None, None, False, None, overwrite=False, lifecycle=None, table_properties=None)"
+    )
+    assert results[0] == expected_result
+    _run_generated_code(results[0], ctx, df1.op.get_data())
+    pd.testing.assert_frame_equal(
+        df1.op.get_data().reset_index(drop=True), _table_to_dataframe(table_name)
+    )
+    odps_entry.delete_table(table_name, if_exists=True)
+
+
+@flaky(max_runs=3)
+def test_to_odps_no_partition_index(df1):
+    odps_entry = ODPS.from_environments()
+    table_name = tn("test_to_odps_no_part_idx_spe")
+    odps_entry.delete_table(table_name, if_exists=True)
+
+    res = md.to_odps_table(df1, table_name)
+    ctx = SPECodeContext()
+    results = DataFrameToODPSTableAdapter().generate_code(res.op, ctx)
+    expected_result = (
+        f"DataFrameToODPSTableAdapter._write_as_table(var_0, '{table_name}', "
+        f"None, None, True, None, overwrite=False, lifecycle=None, table_properties=None)"
+    )
+    assert results[0] == expected_result
+    _run_generated_code(results[0], ctx, df1.op.get_data())
+    pd.testing.assert_frame_equal(
+        df1.op.get_data(),
+        _table_to_dataframe(table_name).set_index("index").rename_axis(None),
+    )
+    odps_entry.delete_table(table_name, if_exists=True)
+
+
+@flaky(max_runs=3)
+def test_to_odps_no_partition_multi_index(df2):
+    odps_entry = ODPS.from_environments()
+    table_name = tn("test_to_odps_no_part_multi_idx_spe")
+    odps_entry.delete_table(table_name, if_exists=True)
+
+    res = md.to_odps_table(df2, table_name)
+    ctx = SPECodeContext()
+    results = DataFrameToODPSTableAdapter().generate_code(res.op, ctx)
+    expected_result = (
+        f"DataFrameToODPSTableAdapter._write_as_table(var_0, '{table_name}', "
+        f"None, None, True, None, overwrite=False, lifecycle=None, table_properties=None)"
+    )
+    assert results[0] == expected_result
+    _run_generated_code(results[0], ctx, df2.op.get_data())
+    pd.testing.assert_frame_equal(
+        df2.op.get_data(),
+        _table_to_dataframe(table_name)
+        .set_index(["level_0", "level_1"])
+        .rename_axis([None, None]),
+    )
+    odps_entry.delete_table(table_name, if_exists=True)
+
+
+@pytest.mark.parametrize("create", [False, True])
+@flaky(max_runs=3)
+def test_to_odps_part_index(df1, create):
+    odps_entry = ODPS.from_environments()
+    existing_tag = "existing_" if create else ""
+    table_name = tn(f"test_to_odps_part_index_{existing_tag}spe")
+    odps_entry.delete_table(table_name, if_exists=True)
+
+    if create:
+        odps_entry.create_table(
+            table_name, ("index string, a bigint, b bigint", "pt string, c string")
+        )
+
+    res = md.to_odps_table(df1, table_name, partition="pt=20240109", partition_col="c")
+    ctx = SPECodeContext()
+    results = DataFrameToODPSTableAdapter().generate_code(res.op, ctx)
+    expected_result = (
+        f"DataFrameToODPSTableAdapter._write_as_table(var_0, '{table_name}', "
+        f"'pt=20240109', ['c'], True, None, overwrite=False, lifecycle=None, table_properties=None)"
+    )
+    assert results[0] == expected_result
+    _run_generated_code(results[0], ctx, df1.op.get_data())
+
+    data_parts = []
+    for c_value in df1.op.get_data().c.unique():
+        result_df = _table_to_dataframe(table_name, f"pt=20240109,c={c_value}")
+        result_df["c"] = c_value
+        data_parts.append(result_df)
+    result_df = pd.concat(data_parts)
+
+    pd.testing.assert_frame_equal(
+        df1.op.get_data(), result_df.set_index("index").rename_axis(None)
+    )
+    odps_entry.delete_table(table_name, if_exists=True)
+
+
+@pytest.mark.parametrize(
+    "idx, col_def, pt_def",
+    [
+        (0, "index string, a bigint, b bigint", "pt string"),
+        (1, "index string, a bigint, b bigint, d bigint", "pt string, c string"),
+    ],
+)
+@flaky(max_runs=3)
+def test_schema_mismatch(df1, idx, col_def, pt_def):
+    odps_entry = ODPS.from_environments()
+    table_name = tn(f"test_schema_mismatch_{idx}")
+    odps_entry.delete_table(table_name, if_exists=True)
+
+    odps_entry.create_table(table_name, (col_def, pt_def))
+    with pytest.raises(ValueError):
+        res = md.to_odps_table(
+            df1, table_name, partition="pt=20240109", partition_col="c"
+        )
+        ctx = SPECodeContext()
+        results = DataFrameToODPSTableAdapter().generate_code(res.op, ctx)
+        _run_generated_code(results[0], ctx, df1.op.get_data())
+
+    odps_entry.delete_table(table_name, if_exists=True)