[core] Fix false-positive immutability check for normalized options.

paimon-core/src/main/java/org/apache/paimon/schema/SchemaManager.java

@@ -321,14 +321,18 @@ public static TableSchema generateTableSchema(
         for (SchemaChange change : changes) {
             if (change instanceof SetOption) {
                 SetOption setOption = (SetOption) change;
-                if (hasSnapshots.get()) {
-                    checkAlterTableOption(
-                            oldOptions,
-                            setOption.key(),
-                            oldOptions.get(setOption.key()),
-                            setOption.value());
+                String oldValue = oldOptions.get(setOption.key());
+                String newValue = setOption.value();
+                boolean unchanged =
+                        Objects.equals(oldValue, newValue)
+                                || isUnchangedNormalizedKey(
+                                        setOption.key(), oldValue, newValue, oldTableSchema);
+                if (hasSnapshots.get() && !unchanged) {
+                    checkAlterTableOption(oldOptions, setOption.key(), oldValue, newValue);
+                }
+                if (!unchanged) {
+                    newOptions.put(setOption.key(), setOption.value());
                 }
-                newOptions.put(setOption.key(), setOption.value());
             } else if (change instanceof RemoveOption) {
                 RemoveOption removeOption = (RemoveOption) change;
                 if (hasSnapshots.get()) {
@@ -1251,6 +1255,32 @@ public void rollbackTo(
         }
     }
 
+    /**
+     * Checks whether a key whose old value is null actually hasn't changed. This handles keys like
+     * 'primary-key' and 'partition' that are stripped from options during schema normalization and
+     * stored in dedicated schema fields instead.
+     */
+    public static boolean isUnchangedNormalizedKey(
+            String key, @Nullable String oldValue, String newValue, TableSchema tableSchema) {
+        if (oldValue != null) {
+            return false;
+        }
+        if (CoreOptions.PRIMARY_KEY.key().equals(key)) {
+            return normalizeKeyList(newValue).equals(tableSchema.primaryKeys());
+        }
+        if (CoreOptions.PARTITION.key().equals(key)) {
+            return normalizeKeyList(newValue).equals(tableSchema.partitionKeys());
+        }
+        return false;
+    }
+
+    private static List<String> normalizeKeyList(String value) {
+        return Arrays.stream(value.split(","))
+                .map(String::trim)
+                .filter(s -> !s.isEmpty())
+                .collect(Collectors.toList());
+    }
+
     public static void checkAlterTableOption(
             Map<String, String> options, String key, @Nullable String oldValue, String newValue) {
         if (CoreOptions.IMMUTABLE_OPTIONS.contains(key)) {

paimon-core/src/main/java/org/apache/paimon/table/AbstractFileStoreTable.java

@@ -337,7 +337,9 @@ private void checkImmutability(Map<String, String> dynamicOptions) {
         dynamicOptions.forEach(
                 (k, newValue) -> {
                     String oldValue = oldOptions.get(k);
-                    if (!Objects.equals(oldValue, newValue)) {
+                    if (!Objects.equals(oldValue, newValue)
+                            && !SchemaManager.isUnchangedNormalizedKey(
+                                    k, oldValue, newValue, tableSchema)) {
                         SchemaManager.checkAlterTableOption(oldOptions, k, oldValue, newValue);
                     }
                 });

paimon-core/src/test/java/org/apache/paimon/schema/SchemaManagerTest.java

@@ -460,6 +460,30 @@ public void testAlterImmutableOptionsOnEmptyTable() throws Exception {
                 .hasMessage("Change 'merge-engine' is not supported yet.");
     }
 
+    @Test
+    public void testCopyWithPrimaryKeyInOptions() throws Exception {
+        // Table created with primary-key in options — normalizePrimaryKeys strips it from the
+        // options map and stores it in the dedicated primaryKeys field. When the same value
+        // reappears in dynamicOptions (e.g. Spark 4.x merging Table.properties() into scan
+        // options), the immutability check should recognize it hasn't actually changed.
+        Map<String, String> tableOptions = new HashMap<>();
+        tableOptions.put("primary-key", "f0,f1");
+        Schema schema =
+                new Schema(
+                        rowType.getFields(),
+                        Collections.emptyList(),
+                        Collections.emptyList(),
+                        tableOptions,
+                        "");
+        Path tableRoot = new Path(tempDir.toString(), "table");
+        SchemaManager manager = new SchemaManager(LocalFileIO.create(), tableRoot);
+        manager.createTable(schema);
+
+        FileStoreTable table = FileStoreTableFactory.create(LocalFileIO.create(), tableRoot);
+        assertThatCode(() -> table.copy(Collections.singletonMap("primary-key", "f0,f1")))
+                .doesNotThrowAnyException();
+    }
+
     @Test
     public void testDropPrimaryKeyOnEmptyTable() throws Exception {
         Path tableRoot = new Path(tempDir.toString(), "table");