Upgrade Arrow C++ to 20.0.0 (#528)

adamreeve · JoshuaOloton · web-flow · commit bf5cdfe76135 · 2025-06-01T19:51:51.000+12:00
Co-authored-by: Joshua Oloton &lt;olotonjoshua@gmail.com&gt;
diff --git a/README.md b/README.md
@@ -270,7 +270,7 @@ dotnet jb cleanupcode "csharp" "csharp.test" "csharp.benchmark" --profile="Built
 Building ParquetSharp natively requires the following dependencies:
 - A modern C++ compiler toolchain
 - .NET SDK 8.0
-- Apache Arrow (19.0.1)
+- Apache Arrow (20.0.0)
 
 For building Arrow (including Parquet) and its dependencies, we recommend using Microsoft's [vcpkg](https://vcpkg.io).
 The build scripts will use an existing vcpkg installation if either of the `VCPKG_INSTALLATION_ROOT` or `VCPKG_ROOT` environment variables are defined, otherwise vcpkg will be downloaded into the build directory.
diff --git a/cpp/ColumnDecryptionProperties.cpp b/cpp/ColumnDecryptionProperties.cpp
@@ -11,9 +11,11 @@ extern "C"
 {
     PARQUETSHARP_EXPORT ExceptionInfo* ColumnDecryptionProperties_Deep_Clone(const std::shared_ptr<ColumnDecryptionProperties>* properties, std::shared_ptr<ColumnDecryptionProperties>** clone)
     {
-        TRYCATCH(*clone = new std::shared_ptr((*properties)->DeepClone());)
+        // Note: This no longer does a true deep clone but we keep this C++ method for compatibility with the
+        // .NET library so that the C++ shared pointers may be freed independently.
+        TRYCATCH(*clone = new std::shared_ptr(*properties);)
     }
-	
+
     PARQUETSHARP_EXPORT void ColumnDecryptionProperties_Free(const std::shared_ptr<const ColumnDecryptionProperties>* properties)
     {
         delete properties;
diff --git a/cpp/ColumnEncryptionProperties.cpp b/cpp/ColumnEncryptionProperties.cpp
@@ -11,9 +11,11 @@ extern "C"
 {
     PARQUETSHARP_EXPORT ExceptionInfo* ColumnEncryptionProperties_Deep_Clone(const std::shared_ptr<ColumnEncryptionProperties>* properties, std::shared_ptr<ColumnEncryptionProperties>** clone)
     {
-        TRYCATCH(*clone = new std::shared_ptr((*properties)->DeepClone());)
+        // Note: This no longer does a true deep clone but we keep this C++ method for compatibility with the
+        // .NET library so that the C++ shared pointers may be freed independently.
+        TRYCATCH(*clone = new std::shared_ptr(*properties);)
     }
-	
+
     PARQUETSHARP_EXPORT void ColumnEncryptionProperties_Free(const std::shared_ptr<const ColumnEncryptionProperties>* properties)
     {
         delete properties;
diff --git a/cpp/Enums.cpp b/cpp/Enums.cpp
@@ -59,12 +59,9 @@ namespace
 		static_assert(ParquetCipher::AES_GCM_CTR_V1 == 1);
 
 		static_assert(ParquetVersion::PARQUET_1_0 == 0);
-		ARROW_SUPPRESS_DEPRECATION_WARNING
-		static_assert(ParquetVersion::PARQUET_2_0 == 1);
-		ARROW_UNSUPPRESS_DEPRECATION_WARNING
-		static_assert(ParquetVersion::PARQUET_2_4 == 2);
-		static_assert(ParquetVersion::PARQUET_2_6 == 3);
-		static_assert(ParquetVersion::PARQUET_2_LATEST == 3);
+		static_assert(ParquetVersion::PARQUET_2_4 == 1);
+		static_assert(ParquetVersion::PARQUET_2_6 == 2);
+		static_assert(ParquetVersion::PARQUET_2_LATEST == 2);
 
 		static_assert(Type::BOOLEAN == 0);
 		static_assert(Type::INT32 == 1);
diff --git a/cpp/FileDecryptionProperties.cpp b/cpp/FileDecryptionProperties.cpp
@@ -13,7 +13,9 @@ extern "C"
 {
     PARQUETSHARP_EXPORT ExceptionInfo* FileDecryptionProperties_Deep_Clone(const std::shared_ptr<FileDecryptionProperties>* properties, std::shared_ptr<FileDecryptionProperties>** clone)
     {
-        TRYCATCH(*clone = new std::shared_ptr((*properties)->DeepClone());)
+        // Note: This no longer does a true deep clone but we keep this C++ method for compatibility with the
+        // .NET library so that the C++ shared pointers may be freed independently.
+        TRYCATCH(*clone = new std::shared_ptr(*properties);)
     }
 
     PARQUETSHARP_EXPORT void FileDecryptionProperties_Free(const std::shared_ptr<const FileDecryptionProperties>* properties)
diff --git a/cpp/FileEncryptionProperties.cpp b/cpp/FileEncryptionProperties.cpp
@@ -11,7 +11,9 @@ extern "C"
 {
     PARQUETSHARP_EXPORT ExceptionInfo* FileEncryptionProperties_Deep_Clone(const std::shared_ptr<FileEncryptionProperties>* properties, std::shared_ptr<FileEncryptionProperties>** clone)
     {
-        TRYCATCH(*clone = new std::shared_ptr((*properties)->DeepClone());)
+        // Note: This no longer does a true deep clone but we keep this C++ method for compatibility with the
+        // .NET library so that the C++ shared pointers may be freed independently.
+        TRYCATCH(*clone = new std::shared_ptr(*properties);)
     }
 
     PARQUETSHARP_EXPORT void FileEncryptionProperties_Free(const std::shared_ptr<const FileEncryptionProperties>* properties)
diff --git a/cpp/arrow/FileReader.cpp b/cpp/arrow/FileReader.cpp
@@ -93,13 +93,13 @@ extern "C"
       }
       if (columns == nullptr)
       {
-        PARQUET_THROW_NOT_OK(reader->GetRecordBatchReader(row_groups_vec, &batch_reader));
+        PARQUET_ASSIGN_OR_THROW(batch_reader, reader->GetRecordBatchReader(row_groups_vec));
       }
       else
       {
         std::vector<int> columns_vec(columns_count);
         std::copy(columns, columns + columns_count, columns_vec.begin());
-        PARQUET_THROW_NOT_OK(reader->GetRecordBatchReader(row_groups_vec, columns_vec, &batch_reader));
+        PARQUET_ASSIGN_OR_THROW(batch_reader, reader->GetRecordBatchReader(row_groups_vec, columns_vec));
       }
       PARQUET_THROW_NOT_OK(arrow::ExportRecordBatchReader(batch_reader, stream_out));
     )
diff --git a/cpp/arrow/FileWriter.cpp b/cpp/arrow/FileWriter.cpp
@@ -113,9 +113,9 @@ extern "C"
     )
   }
 
-  PARQUETSHARP_EXPORT ExceptionInfo* FileWriter_NewRowGroup(FileWriter* writer, int64_t chunk_size)
+  PARQUETSHARP_EXPORT ExceptionInfo* FileWriter_NewRowGroup(FileWriter* writer)
   {
-    TRYCATCH(PARQUET_THROW_NOT_OK(writer->NewRowGroup(chunk_size));)
+    TRYCATCH(PARQUET_THROW_NOT_OK(writer->NewRowGroup());)
   }
 
   PARQUETSHARP_EXPORT ExceptionInfo* FileWriter_NewBufferedRowGroup(FileWriter* writer)
diff --git a/csharp.test/Arrow/TestFileWriter.cs b/csharp.test/Arrow/TestFileWriter.cs
@@ -222,7 +222,7 @@ public async Task TestWriteRowGroupColumns()
                 for (var rowGroupIdx = 0; rowGroupIdx < numRowGroups; ++rowGroupIdx)
                 {
                     var start = rowGroupIdx * rowsPerRowGroup;
-                    writer.NewRowGroup(rowsPerRowGroup);
+                    writer.NewRowGroup();
 
                     using (var intArray = new Int32Array.Builder()
                         .AppendRange(Enumerable.Range(start, rowsPerRowGroup))
@@ -268,7 +268,7 @@ public async Task TestWriteRowGroupColumnsChunked()
                 {
                     var start0 = rowGroupIdx * rowsPerRowGroup;
                     var start1 = start0 + chunkSize;
-                    writer.NewRowGroup(rowsPerRowGroup);
+                    writer.NewRowGroup();
 
                     {
                         using var intArray0 = new Int32Array.Builder()
diff --git a/csharp.test/TestPhysicalTypeRoundtrip.cs b/csharp.test/TestPhysicalTypeRoundtrip.cs
@@ -163,7 +163,7 @@ private static void AssertReadRoundtrip(ResizableBuffer buffer, ExpectedColumn[]
 
             var numRows = expectedColumns.First().Values.Length;
 
-            Assert.AreEqual("parquet-cpp-arrow version 19.0.1", fileMetaData.CreatedBy);
+            Assert.AreEqual("parquet-cpp-arrow version 20.0.0", fileMetaData.CreatedBy);
             Assert.AreEqual(new Dictionary<string, string> {{"case", "Test"}, {"Awesome", "true"}}, fileMetaData.KeyValueMetadata);
             Assert.AreEqual(expectedColumns.Length, fileMetaData.NumColumns);
             Assert.AreEqual(numRows, fileMetaData.NumRows);
@@ -174,7 +174,7 @@ private static void AssertReadRoundtrip(ResizableBuffer buffer, ExpectedColumn[]
             // The parquet format only stores an integer file version (1 or 2) and
             // 2 gets mapped to the latest 2.x version.
             Assert.AreEqual(ParquetVersion.PARQUET_2_6, fileMetaData.Version);
-            Assert.AreEqual("parquet-cpp-arrow version 19.0.1", fileMetaData.WriterVersion.ToString());
+            Assert.AreEqual("parquet-cpp-arrow version 20.0.0", fileMetaData.WriterVersion.ToString());
 
             using var rowGroupReader = fileReader.RowGroup(0);
             var rowGroupMetaData = rowGroupReader.MetaData;
diff --git a/csharp.test/TestWriterProperties.cs b/csharp.test/TestWriterProperties.cs
@@ -14,7 +14,7 @@ public static void TestDefaultProperties()
         {
             var p = WriterProperties.GetDefaultWriterProperties();
 
-            Assert.AreEqual("parquet-cpp-arrow version 19.0.1", p.CreatedBy);
+            Assert.AreEqual("parquet-cpp-arrow version 20.0.0", p.CreatedBy);
             Assert.AreEqual(Compression.Uncompressed, p.Compression(new ColumnPath("anypath")));
             Assert.AreEqual(int.MinValue, p.CompressionLevel(new ColumnPath("anypath")));
             Assert.AreEqual(1024 * 1024, p.DataPageSize);
@@ -24,7 +24,7 @@ public static void TestDefaultProperties()
             Assert.AreEqual(1024 * 1024, p.MaxRowGroupLength);
             Assert.AreEqual(ParquetVersion.PARQUET_2_6, p.Version);
             Assert.AreEqual(1024, p.WriteBatchSize);
-            Assert.False(p.WritePageIndex);
+            Assert.True(p.WritePageIndex);
             Assert.False(p.PageChecksumEnabled);
         }
 
@@ -41,8 +41,8 @@ public static void TestPropertiesBuilder()
                 .MaxRowGroupLength(789)
                 .Version(ParquetVersion.PARQUET_1_0)
                 .WriteBatchSize(666)
-                .DisableWritePageIndex()
                 .EnableWritePageIndex()
+                .DisableWritePageIndex()
                 .EnablePageChecksum()
                 .Build();
 
@@ -56,7 +56,7 @@ public static void TestPropertiesBuilder()
             Assert.AreEqual(789, p.MaxRowGroupLength);
             Assert.AreEqual(ParquetVersion.PARQUET_1_0, p.Version);
             Assert.AreEqual(666, p.WriteBatchSize);
-            Assert.True(p.WritePageIndex);
+            Assert.False(p.WritePageIndex);
             Assert.True(p.PageChecksumEnabled);
         }
 
@@ -112,7 +112,7 @@ public static void TestOverrideDefaults()
                 DefaultWriterProperties.MaxRowGroupLength = 789;
                 DefaultWriterProperties.Version = ParquetVersion.PARQUET_1_0;
                 DefaultWriterProperties.WriteBatchSize = 666;
-                DefaultWriterProperties.WritePageIndex = true;
+                DefaultWriterProperties.WritePageIndex = false;
                 DefaultWriterProperties.PageChecksumEnabled = true;
 
                 using var builder = new WriterPropertiesBuilder();
@@ -130,7 +130,7 @@ public static void TestOverrideDefaults()
                 Assert.AreEqual(789, p.MaxRowGroupLength);
                 Assert.AreEqual(ParquetVersion.PARQUET_1_0, p.Version);
                 Assert.AreEqual(666, p.WriteBatchSize);
-                Assert.True(p.WritePageIndex);
+                Assert.False(p.WritePageIndex);
                 Assert.True(p.PageChecksumEnabled);
             }
             finally
diff --git a/csharp/Arrow/FileWriter.cs b/csharp/Arrow/FileWriter.cs
@@ -211,9 +211,21 @@ public void NewBufferedRowGroup()
         /// before creating a new row group or closing the file.
         /// </summary>
         /// <param name="chunkSize">The number of rows to be written in this row group</param>
+        [Obsolete("Use the override that does not have a chunkSize parameter because this parameter has no effect")]
         public void NewRowGroup(long chunkSize)
         {
-            ExceptionInfo.Check(FileWriter_NewRowGroup(_handle.IntPtr, chunkSize));
+            ExceptionInfo.Check(FileWriter_NewRowGroup(_handle.IntPtr));
+            GC.KeepAlive(_handle);
+        }
+
+        /// <summary>
+        /// Start writing a new row group to the file. After calling this method,
+        /// each column required in the schema must be written using WriteColumn
+        /// before creating a new row group or closing the file.
+        /// </summary>
+        public void NewRowGroup()
+        {
+            ExceptionInfo.Check(FileWriter_NewRowGroup(_handle.IntPtr));
             GC.KeepAlive(_handle);
         }
 
@@ -328,7 +340,7 @@ private static extern unsafe IntPtr FileWriter_OpenStream(
         private static extern unsafe IntPtr FileWriter_WriteRecordBatches(IntPtr writer, CArrowArrayStream* stream);
 
         [DllImport(ParquetDll.Name)]
-        private static extern IntPtr FileWriter_NewRowGroup(IntPtr writer, long chunkSize);
+        private static extern IntPtr FileWriter_NewRowGroup(IntPtr writer);
 
         [DllImport(ParquetDll.Name)]
         private static extern IntPtr FileWriter_NewBufferedRowGroup(IntPtr writer);
diff --git a/csharp/ColumnDecryptionProperties.cs b/csharp/ColumnDecryptionProperties.cs
@@ -27,6 +27,7 @@ public void Dispose()
         /// </summary>
         public byte[] Key => ExceptionInfo.Return<AesKey>(Handle, ColumnDecryptionProperties_Key).ToBytes();
 
+        [Obsolete("Re-using ColumnDecryptionProperties no longer requires deep cloning")]
         public ColumnDecryptionProperties DeepClone() => new ColumnDecryptionProperties(ExceptionInfo.Return<IntPtr>(Handle, ColumnDecryptionProperties_Deep_Clone));
 
         [DllImport(ParquetDll.Name)]
diff --git a/csharp/ColumnEncryptionProperties.cs b/csharp/ColumnEncryptionProperties.cs
@@ -24,6 +24,7 @@ public void Dispose()
         public byte[] Key => ExceptionInfo.Return<AesKey>(Handle, ColumnEncryptionProperties_Key).ToBytes();
         public string KeyMetadata => ExceptionInfo.ReturnString(Handle, ColumnEncryptionProperties_Key_Metadata, ColumnEncryptionProperties_Key_Metadata_Free);
 
+        [Obsolete("Re-using ColumnEncryptionProperties no longer requires deep cloning")]
         public ColumnEncryptionProperties DeepClone() => new ColumnEncryptionProperties(ExceptionInfo.Return<IntPtr>(Handle, ColumnEncryptionProperties_Deep_Clone));
 
         [DllImport(ParquetDll.Name)]
diff --git a/csharp/FileDecryptionProperties.cs b/csharp/FileDecryptionProperties.cs
@@ -42,6 +42,7 @@ public AadPrefixVerifier? AadPrefixVerifier
             }
         }
 
+        [Obsolete("Re-using FileDecryptionProperties no longer requires deep cloning")]
         public FileDecryptionProperties DeepClone() => new FileDecryptionProperties(ExceptionInfo.Return<IntPtr>(Handle, FileDecryptionProperties_Deep_Clone));
 
         [DllImport(ParquetDll.Name)]
diff --git a/csharp/FileEncryptionProperties.cs b/csharp/FileEncryptionProperties.cs
@@ -51,9 +51,7 @@ public void Dispose()
             return columnHandle == IntPtr.Zero ? null : new ColumnEncryptionProperties(columnHandle);
         }
 
-        /// <summary>
-        /// Create a deep clone of the file encryption properties object.
-        /// </summary>
+        [Obsolete("Re-using FileEncryptionProperties no longer requires deep cloning")]
         public FileEncryptionProperties DeepClone() => new FileEncryptionProperties(ExceptionInfo.Return<IntPtr>(Handle, FileEncryptionProperties_Deep_Clone));
 
         [DllImport(ParquetDll.Name)]
diff --git a/csharp/FileMetaData.cs b/csharp/FileMetaData.cs
@@ -72,7 +72,7 @@ public IReadOnlyDictionary<string, string> KeyValueMetadata
         /// <summary>
         /// Get the Parquet format version of the file.
         /// </summary>
-        public ParquetVersion Version => ExceptionInfo.Return<ParquetVersion>(_handle, FileMetaData_Version);
+        public ParquetVersion Version => ExceptionInfo.Return<CppParquetVersion>(_handle, FileMetaData_Version).ToPublicEnum();
         /// <summary>
         /// Get the version of the writer that created the file.
         /// </summary>
@@ -114,7 +114,7 @@ public bool Equals(FileMetaData? other)
         private static extern IntPtr FileMetaData_Size(IntPtr fileMetaData, out int size);
 
         [DllImport(ParquetDll.Name)]
-        private static extern IntPtr FileMetaData_Version(IntPtr fileMetaData, out ParquetVersion version);
+        private static extern IntPtr FileMetaData_Version(IntPtr fileMetaData, out CppParquetVersion version);
 
         [DllImport(ParquetDll.Name)]
         private static extern IntPtr FileMetaData_Writer_Version(IntPtr fileMetaData, out AppVer applicationVersion);
diff --git a/csharp/ParquetSharp.csproj b/csharp/ParquetSharp.csproj
@@ -12,7 +12,7 @@
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <NoWarn>1591;</NoWarn>
-    <VersionPrefix>19.0.1</VersionPrefix>
+    <VersionPrefix>20.0.0-beta1</VersionPrefix>
     <Company>G-Research</Company>
     <Authors>G-Research</Authors>
     <Product>ParquetSharp</Product>
diff --git a/csharp/ParquetVersion.cs b/csharp/ParquetVersion.cs
@@ -1,13 +1,58 @@
+using System;
+
 namespace ParquetSharp
 {
     public enum ParquetVersion
     {
         // ReSharper disable InconsistentNaming
         PARQUET_1_0 = 0,
+        [Obsolete("Specific minor Parquet versions should be used")]
         PARQUET_2_0 = 1,
         PARQUET_2_4 = 2,
         PARQUET_2_6 = 3,
         PARQUET_2_LATEST = 3
         // ReSharper restore InconsistentNaming
     }
+
+    /// <summary>
+    /// Type enum with values that match the C++ Parquet library.
+    /// These are not guaranteed to be stable between releases, but we need to keep
+    /// the ParquetVersion values above stable to ensure ABI compatibility.
+    /// </summary>
+    internal enum CppParquetVersion
+    {
+        // ReSharper disable InconsistentNaming
+        PARQUET_1_0 = 0,
+        PARQUET_2_4 = 1,
+        PARQUET_2_6 = 2,
+        // ReSharper restore InconsistentNaming
+    }
+
+    internal static class ParquetVersionExtensions
+    {
+        public static ParquetVersion ToPublicEnum(this CppParquetVersion enumValue)
+        {
+            return enumValue switch
+            {
+                CppParquetVersion.PARQUET_1_0 => ParquetVersion.PARQUET_1_0,
+                CppParquetVersion.PARQUET_2_4 => ParquetVersion.PARQUET_2_4,
+                CppParquetVersion.PARQUET_2_6 => ParquetVersion.PARQUET_2_6,
+                _ => throw new ArgumentOutOfRangeException(nameof(enumValue), enumValue, null)
+            };
+        }
+
+        public static CppParquetVersion ToCppEnum(this ParquetVersion enumValue)
+        {
+            return enumValue switch
+            {
+                ParquetVersion.PARQUET_1_0 => CppParquetVersion.PARQUET_1_0,
+#pragma warning disable CS0618 // Type or member is obsolete
+                ParquetVersion.PARQUET_2_0 => CppParquetVersion.PARQUET_2_6,
+#pragma warning restore CS0618 // Type or member is obsolete
+                ParquetVersion.PARQUET_2_4 => CppParquetVersion.PARQUET_2_4,
+                ParquetVersion.PARQUET_2_6 => CppParquetVersion.PARQUET_2_6,
+                _ => throw new ArgumentOutOfRangeException(nameof(enumValue), enumValue, null)
+            };
+        }
+    }
 }
diff --git a/csharp/PublicAPI/net471/PublicAPI.Unshipped.txt b/csharp/PublicAPI/net471/PublicAPI.Unshipped.txt
@@ -1,3 +1,4 @@
 #nullable enable
 override ParquetSharp.Schema.GroupNode.ToString() -> string!
 override ParquetSharp.Schema.PrimitiveNode.ToString() -> string!
+ParquetSharp.Arrow.FileWriter.NewRowGroup() -> void
diff --git a/csharp/PublicAPI/net6/PublicAPI.Unshipped.txt b/csharp/PublicAPI/net6/PublicAPI.Unshipped.txt
@@ -1,3 +1,4 @@
 #nullable enable
 override ParquetSharp.Schema.GroupNode.ToString() -> string!
 override ParquetSharp.Schema.PrimitiveNode.ToString() -> string!
+ParquetSharp.Arrow.FileWriter.NewRowGroup() -> void
diff --git a/csharp/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt b/csharp/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt
@@ -1,3 +1,4 @@
 #nullable enable
 override ParquetSharp.Schema.GroupNode.ToString() -> string!
 override ParquetSharp.Schema.PrimitiveNode.ToString() -> string!
+ParquetSharp.Arrow.FileWriter.NewRowGroup() -> void
diff --git a/csharp/WriterProperties.cs b/csharp/WriterProperties.cs
@@ -59,7 +59,7 @@ public void Dispose()
         /// <summary>
         /// The version of the Parquet format to write.
         /// </summary>
-        public ParquetVersion Version => ExceptionInfo.Return<ParquetVersion>(Handle, WriterProperties_Version);
+        public ParquetVersion Version => ExceptionInfo.Return<CppParquetVersion>(Handle, WriterProperties_Version).ToPublicEnum();
         /// <summary>
         /// The number of records to batch together when writing.
         /// </summary>
@@ -173,7 +173,7 @@ public ulong MaxStatisticsSize(ColumnPath path)
         private static extern IntPtr WriterProperties_Max_Row_Group_Length(IntPtr writerProperties, out long length);
 
         [DllImport(ParquetDll.Name)]
-        private static extern IntPtr WriterProperties_Version(IntPtr writerProperties, out ParquetVersion version);
+        private static extern IntPtr WriterProperties_Version(IntPtr writerProperties, out CppParquetVersion version);
 
         [DllImport(ParquetDll.Name)]
         private static extern IntPtr WriterProperties_Write_Batch_Size(IntPtr writerProperties, out long size);
diff --git a/csharp/WriterPropertiesBuilder.cs b/csharp/WriterPropertiesBuilder.cs
@@ -360,7 +360,7 @@ public WriterPropertiesBuilder MaxRowGroupLength(long maxRowGroupLength)
         /// <returns>This builder instance.</returns>
         public WriterPropertiesBuilder Version(ParquetVersion version)
         {
-            ExceptionInfo.Check(WriterPropertiesBuilder_Version(_handle.IntPtr, version));
+            ExceptionInfo.Check(WriterPropertiesBuilder_Version(_handle.IntPtr, version.ToCppEnum()));
             GC.KeepAlive(_handle);
             return this;
         }
@@ -657,7 +657,7 @@ private static void OnDefaultRefProperty<T>(T? defaultPropertyValue, Action<T> s
         private static extern IntPtr WriterPropertiesBuilder_Max_Row_Group_Length(IntPtr builder, long maxRowGroupLength);
 
         [DllImport(ParquetDll.Name)]
-        private static extern IntPtr WriterPropertiesBuilder_Version(IntPtr builder, ParquetVersion version);
+        private static extern IntPtr WriterPropertiesBuilder_Version(IntPtr builder, CppParquetVersion version);
 
         [DllImport(ParquetDll.Name)]
         private static extern IntPtr WriterPropertiesBuilder_Write_Batch_Size(IntPtr builder, long writeBatchSize);
diff --git a/vcpkg.json b/vcpkg.json

Original file line number	Diff line number	Diff line change
`@@ -11,9 +11,11 @@ extern "C"`
`11`	`11`	`{`
`12`	`12`	`PARQUETSHARP_EXPORT ExceptionInfo* ColumnDecryptionProperties_Deep_Clone(const std::shared_ptr<ColumnDecryptionProperties>* properties, std::shared_ptr<ColumnDecryptionProperties>** clone)`
`13`	`13`	`{`
`14`		`- TRYCATCH(clone = new std::shared_ptr((properties)->DeepClone());)`
	`14`	`+ // Note: This no longer does a true deep clone but we keep this C++ method for compatibility with the`
	`15`	`+ // .NET library so that the C++ shared pointers may be freed independently.`
	`16`	`+ TRYCATCH(clone = new std::shared_ptr(properties);)`
`15`	`17`	`}`
`16`		`-`
	`18`	`+`
`17`	`19`	`PARQUETSHARP_EXPORT void ColumnDecryptionProperties_Free(const std::shared_ptr<const ColumnDecryptionProperties>* properties)`
`18`	`20`	`{`
`19`	`21`	`delete properties;`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,9 @@ extern "C"`
`13`	`13`	`{`
`14`	`14`	`PARQUETSHARP_EXPORT ExceptionInfo* FileDecryptionProperties_Deep_Clone(const std::shared_ptr<FileDecryptionProperties>* properties, std::shared_ptr<FileDecryptionProperties>** clone)`
`15`	`15`	`{`
`16`		`- TRYCATCH(clone = new std::shared_ptr((properties)->DeepClone());)`
	`16`	`+ // Note: This no longer does a true deep clone but we keep this C++ method for compatibility with the`
	`17`	`+ // .NET library so that the C++ shared pointers may be freed independently.`
	`18`	`+ TRYCATCH(clone = new std::shared_ptr(properties);)`
`17`	`19`	`}`
`18`	`20`
`19`	`21`	`PARQUETSHARP_EXPORT void FileDecryptionProperties_Free(const std::shared_ptr<const FileDecryptionProperties>* properties)`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,9 @@ extern "C"`
`11`	`11`	`{`
`12`	`12`	`PARQUETSHARP_EXPORT ExceptionInfo* FileEncryptionProperties_Deep_Clone(const std::shared_ptr<FileEncryptionProperties>* properties, std::shared_ptr<FileEncryptionProperties>** clone)`
`13`	`13`	`{`
`14`		`- TRYCATCH(clone = new std::shared_ptr((properties)->DeepClone());)`
	`14`	`+ // Note: This no longer does a true deep clone but we keep this C++ method for compatibility with the`
	`15`	`+ // .NET library so that the C++ shared pointers may be freed independently.`
	`16`	`+ TRYCATCH(clone = new std::shared_ptr(properties);)`
`15`	`17`	`}`
`16`	`18`
`17`	`19`	`PARQUETSHARP_EXPORT void FileEncryptionProperties_Free(const std::shared_ptr<const FileEncryptionProperties>* properties)`
Original file line number	Diff line number	Diff line change
`@@ -93,13 +93,13 @@ extern "C"`
`93`	`93`	`}`
`94`	`94`	`if (columns == nullptr)`
`95`	`95`	`{`
`96`		`- PARQUET_THROW_NOT_OK(reader->GetRecordBatchReader(row_groups_vec, &batch_reader));`
	`96`	`+ PARQUET_ASSIGN_OR_THROW(batch_reader, reader->GetRecordBatchReader(row_groups_vec));`
`97`	`97`	`}`
`98`	`98`	`else`
`99`	`99`	`{`
`100`	`100`	`std::vector<int> columns_vec(columns_count);`
`101`	`101`	`std::copy(columns, columns + columns_count, columns_vec.begin());`
`102`		`- PARQUET_THROW_NOT_OK(reader->GetRecordBatchReader(row_groups_vec, columns_vec, &batch_reader));`
	`102`	`+ PARQUET_ASSIGN_OR_THROW(batch_reader, reader->GetRecordBatchReader(row_groups_vec, columns_vec));`
`103`	`103`	`}`
`104`	`104`	`PARQUET_THROW_NOT_OK(arrow::ExportRecordBatchReader(batch_reader, stream_out));`
`105`	`105`	`)`
Original file line number	Diff line number	Diff line change
`@@ -113,9 +113,9 @@ extern "C"`
`113`	`113`	`)`
`114`	`114`	`}`
`115`	`115`
`116`		`- PARQUETSHARP_EXPORT ExceptionInfo* FileWriter_NewRowGroup(FileWriter* writer, int64_t chunk_size)`
	`116`	`+ PARQUETSHARP_EXPORT ExceptionInfo* FileWriter_NewRowGroup(FileWriter* writer)`
`117`	`117`	`{`
`118`		`- TRYCATCH(PARQUET_THROW_NOT_OK(writer->NewRowGroup(chunk_size));)`
	`118`	`+ TRYCATCH(PARQUET_THROW_NOT_OK(writer->NewRowGroup());)`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`PARQUETSHARP_EXPORT ExceptionInfo* FileWriter_NewBufferedRowGroup(FileWriter* writer)`
Original file line number	Diff line number	Diff line change
`@@ -222,7 +222,7 @@ public async Task TestWriteRowGroupColumns()`
`222`	`222`	`for (var rowGroupIdx = 0; rowGroupIdx < numRowGroups; ++rowGroupIdx)`
`223`	`223`	`{`
`224`	`224`	`var start = rowGroupIdx * rowsPerRowGroup;`
`225`		`- writer.NewRowGroup(rowsPerRowGroup);`
	`225`	`+ writer.NewRowGroup();`
`226`	`226`
`227`	`227`	`using (var intArray = new Int32Array.Builder()`
`228`	`228`	`.AppendRange(Enumerable.Range(start, rowsPerRowGroup))`
`@@ -268,7 +268,7 @@ public async Task TestWriteRowGroupColumnsChunked()`
`268`	`268`	`{`
`269`	`269`	`var start0 = rowGroupIdx * rowsPerRowGroup;`
`270`	`270`	`var start1 = start0 + chunkSize;`
`271`		`- writer.NewRowGroup(rowsPerRowGroup);`
	`271`	`+ writer.NewRowGroup();`
`272`	`272`
`273`	`273`	`{`
`274`	`274`	`using var intArray0 = new Int32Array.Builder()`