Merge branch 'columnar-swift:main' into main

Author: willtemperley

.swift-format

@@ -0,0 +1,71 @@
+{
+  "fileScopedDeclarationPrivacy" : {
+    "accessLevel" : "private"
+  },
+  "indentation" : {
+    "spaces" : 2
+  },
+  "indentConditionalCompilationBlocks" : false,
+  "indentSwitchCaseLabels" : false,
+  "lineBreakAroundMultilineExpressionChainComponents" : false,
+  "lineBreakBeforeControlFlowKeywords" : false,
+  "lineBreakBeforeEachArgument" : false,
+  "lineBreakBeforeEachGenericRequirement" : false,
+  "lineLength" : 80,
+  "maximumBlankLines" : 1,
+  "multiElementCollectionTrailingCommas" : true,
+  "noAssignmentInExpressions" : {
+    "allowedFunctions" : [
+      "XCTAssertNoThrow"
+    ]
+  },
+  "prioritizeKeepingFunctionOutputTogether" : false,
+  "respectsExistingLineBreaks" : true,
+  "rules" : {
+    "AllPublicDeclarationsHaveDocumentation" : false,
+    "AlwaysUseLiteralForEmptyCollectionInit" : true,
+    "AlwaysUseLowerCamelCase" : true,
+    "AmbiguousTrailingClosureOverload" : false,
+    "BeginDocumentationCommentWithOneLineSummary" : true,
+    "DoNotUseSemicolons" : true,
+    "DontRepeatTypeInStaticProperties" : true,
+    "FileScopedDeclarationPrivacy" : true,
+    "FullyIndirectEnum" : true,
+    "GroupNumericLiterals" : true,
+    "IdentifiersMustBeASCII" : true,
+    "NeverForceUnwrap" : true,
+    "NeverUseForceTry" : true,
+    "NeverUseImplicitlyUnwrappedOptionals" : true,
+    "NoAccessLevelOnExtensionDeclaration" : true,
+    "NoAssignmentInExpressions" : true,
+    "NoBlockComments" : true,
+    "NoCasesWithOnlyFallthrough" : true,
+    "NoEmptyTrailingClosureParentheses" : true,
+    "NoLabelsInCasePatterns" : true,
+    "NoLeadingUnderscores" : false,
+    "NoParensAroundConditions" : true,
+    "NoPlaygroundLiterals" : true,
+    "NoVoidReturnOnFunctionSignature" : true,
+    "OmitExplicitReturns" : true,
+    "OneCasePerLine" : true,
+    "OneVariableDeclarationPerLine" : true,
+    "OnlyOneTrailingClosureArgument" : true,
+    "OrderedImports" : true,
+    "ReplaceForEachWithForLoop" : true,
+    "ReturnVoidInsteadOfEmptyTuple" : true,
+    "TypeNamesShouldBeCapitalized" : true,
+    "UseEarlyExits" : false,
+    "UseExplicitNilCheckInConditions" : true,
+    "UseLetInEveryBoundCaseVariable" : true,
+    "UseShorthandTypeNames" : true,
+    "UseSingleLinePropertyGetter" : true,
+    "UseSynthesizedInitializer" : true,
+    "UseTripleSlashForDocumentationComments" : true,
+    "UseWhereClausesInForLoops" : false,
+    "ValidateDocumentationComments" : true
+  },
+  "spacesBeforeEndOfLineComments": 2,
+  "spacesAroundRangeFormationOperators" : false,
+  "tabWidth" : 2,
+  "version" : 1
+}

Scripts/format.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
-git ls-files -- '*.swift' ':(exclude)Sources/Arrow/Generated/*' | xargs -0 swift format format --parallel --in-place
-git ls-files -- '*.swift' ':(exclude)Sources/Arrow/Generated/*' | xargs -0 swift format lint --strict --parallel
+git ls-files -- '*.swift' | xargs -0 swift format format --parallel --in-place
+git ls-files -- '*.swift' | xargs -0 swift format lint --strict --parallel

Sources/Arrow/ArrowBufferBuilder.swift

@@ -49,7 +49,6 @@ public class BaseBufferBuilder {
       }
       return UInt(data.length * 2)
     }
-
     return UInt(len * 2)
   }
 }
@@ -223,35 +222,31 @@ public class VariableBufferBuilder<T>: ValuesBufferBuilder<T>, ArrowBufferBuilde
       isNull = true
       binData = Data(bytes: &nullVal, count: MemoryLayout<UInt32>.size)
     }
-
     var currentIndex: Int32 = 0
     var currentOffset: Int32 = Int32(binData.count)
     if index > 0 {
       currentIndex = self.offsets.rawPointer.advanced(by: offsetIndex).load(as: Int32.self)
       currentOffset += currentIndex
       if currentOffset > self.values.length {
-        self.value_resize(UInt(currentOffset))
+        self.valueResize(UInt(currentOffset))
       }
     }
-
     if isNull {
       self.nullCount += 1
       BitUtility.clearBit(index + self.offset, buffer: self.nulls)
     } else {
       BitUtility.setBit(index + self.offset, buffer: self.nulls)
     }
-
     binData.withUnsafeBytes { bufferPointer in
       let rawPointer = bufferPointer.baseAddress!
       self.values.rawPointer.advanced(by: Int(currentIndex))
         .copyMemory(from: rawPointer, byteCount: binData.count)
     }
-
     self.offsets.rawPointer.advanced(by: (offsetIndex + MemoryLayout<Int32>.stride))
       .storeBytes(of: currentOffset, as: Int32.self)
   }
 
-  public func value_resize(_ length: UInt) {
+  public func valueResize(_ length: UInt) {
     if length > self.values.length {
       let resizeLength = resizeLength(self.values, len: length)
       var values = ArrowBuffer.createBuffer(resizeLength, size: UInt(MemoryLayout<UInt8>.size))

Sources/Arrow/ArrowReader.swift

@@ -1,4 +1,5 @@
 // Copyright 2025 The Apache Software Foundation
+// Copyright 2025 The Columnar-Swift Contributors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -15,10 +16,10 @@
 import FlatBuffers
 import Foundation
 
-let FILEMARKER = "ARROW1"
-let CONTINUATIONMARKER = UInt32(0xFFFF_FFFF)
+let fileMarker = "ARROW1"
+let continuationMarker = UInt32(0xFFFF_FFFF)
 
-public class ArrowReader {  // swiftlint:disable:this type_body_length
+public class ArrowReader {
   private class RecordBatchData {
     let schema: Schema
     let recordBatch: FlatRecordBatch
@@ -294,7 +295,7 @@ public class ArrowReader {  // swiftlint:disable:this type_body_length
     var streamData = input
     var schemaMessage: Schema?
     while length != 0 {
-      if length == CONTINUATIONMARKER {
+      if length == continuationMarker {
         offset += Int(MemoryLayout<UInt32>.size)
         length = getUInt32(input, offset: offset)
         if length == 0 {
@@ -343,11 +344,13 @@ public class ArrowReader {  // swiftlint:disable:this type_body_length
     return .success(result)
   }
 
-  /*
-   This is for reading the Arrow file format. The Arrow file format supports
-   random accessing the data.  The Arrow file format contains a header and
-   footer around the Arrow streaming format.
-   */
+  /// This is for reading the Arrow file format. The Arrow file format supports
+  /// random access.  The Arrow file format contains a header and footer around
+  /// the Arrow streaming format.
+  /// - Parameters:
+  ///   - fileData: the file content
+  ///   - useUnalignedBuffers: to be removed.
+  /// - Returns: An `ArrowReaderResult` on success, or an `ArrowError` on failure.
   public func readFile(
     _ fileData: Data,
     useUnalignedBuffers: Bool = false
@@ -378,7 +381,7 @@ public class ArrowReader {  // swiftlint:disable:this type_body_length
       }
 
       var messageOffset: Int64 = 1
-      if messageLength == CONTINUATIONMARKER {
+      if messageLength == continuationMarker {
         messageOffset += 1
         messageLength = fileData.withUnsafeBytes { rawBuffer in
           rawBuffer.loadUnaligned(
@@ -424,8 +427,7 @@ public class ArrowReader {  // swiftlint:disable:this type_body_length
       if !validateFileData(fileData) {
         return .failure(.ioError("Not a valid arrow file."))
       }
-
-      let markerLength = FILEMARKER.utf8.count
+      let markerLength = fileMarker.utf8.count
       let footerLengthEnd = Int(fileData.count - markerLength)
       let data = fileData[..<(footerLengthEnd)]
       return readFile(data)
@@ -475,6 +477,4 @@ public class ArrowReader {  // swiftlint:disable:this type_body_length
       return .failure(.unknownError("Unhandled header type: \(message.headerType)"))
     }
   }
-
 }
-// swiftlint:disable:this file_length

Sources/Arrow/ArrowReaderHelper.swift

@@ -341,10 +341,10 @@ func validateBufferIndex(_ recordBatch: org_apache_arrow_flatbuf_RecordBatch, in
 }
 
 func validateFileData(_ data: Data) -> Bool {
-  let markerLength = FILEMARKER.utf8.count
+  let markerLength = fileMarker.utf8.count
   let startString = String(decoding: data[..<markerLength], as: UTF8.self)
   let endString = String(decoding: data[(data.count - markerLength)...], as: UTF8.self)
-  return startString == FILEMARKER && endString == FILEMARKER
+  return startString == fileMarker && endString == fileMarker
 }
 
 func getUInt32(_ data: Data, offset: Int) -> UInt32 {

Sources/Arrow/ArrowWriter.swift

@@ -152,7 +152,7 @@ public class ArrowWriter {
       let startIndex = writer.count
       switch writeRecordBatch(batch: batch) {
       case .success(let rbResult):
-        withUnsafeBytes(of: CONTINUATIONMARKER.littleEndian) {
+        withUnsafeBytes(of: continuationMarker.littleEndian) {
           writer.append(Data($0))
         }
         withUnsafeBytes(of: rbResult.1.o.littleEndian) {
@@ -397,7 +397,7 @@ public class ArrowWriter {
     let writer: any DataWriter = InMemDataWriter()
     switch toMessage(info.schema) {
     case .success(let schemaData):
-      withUnsafeBytes(of: CONTINUATIONMARKER.littleEndian) { writer.append(Data($0)) }
+      withUnsafeBytes(of: continuationMarker.littleEndian) { writer.append(Data($0)) }
       withUnsafeBytes(of: UInt32(schemaData.count).littleEndian) { writer.append(Data($0)) }
       writer.append(schemaData)
     case .failure(let error):
@@ -407,7 +407,7 @@ public class ArrowWriter {
     for batch in info.batches {
       switch toMessage(batch) {
       case .success(let batchData):
-        withUnsafeBytes(of: CONTINUATIONMARKER.littleEndian) { writer.append(Data($0)) }
+        withUnsafeBytes(of: continuationMarker.littleEndian) { writer.append(Data($0)) }
         withUnsafeBytes(of: UInt32(batchData[0].count).littleEndian) { writer.append(Data($0)) }
         writer.append(batchData[0])
         writer.append(batchData[1])
@@ -416,7 +416,7 @@ public class ArrowWriter {
       }
     }
 
-    withUnsafeBytes(of: CONTINUATIONMARKER.littleEndian) { writer.append(Data($0)) }
+    withUnsafeBytes(of: continuationMarker.littleEndian) { writer.append(Data($0)) }
     withUnsafeBytes(of: UInt32(0).littleEndian) { writer.append(Data($0)) }
     if let memWriter = writer as? InMemDataWriter {
       return .success(memWriter.data)
@@ -449,14 +449,14 @@ public class ArrowWriter {
     let fileHandle = FileHandle(forUpdatingAtPath: fileName.path)!
     defer { fileHandle.closeFile() }
 
-    var markerData = FILEMARKER.data(using: .utf8)!
+    var markerData = fileMarker.data(using: .utf8)!
     addPadForAlignment(&markerData)
 
     var writer: any DataWriter = FileDataWriter(fileHandle)
     writer.append(markerData)
     switch writeFile(&writer, info: info) {
     case .success:
-      writer.append(FILEMARKER.data(using: .utf8)!)
+      writer.append(fileMarker.data(using: .utf8)!)
     case .failure(let error):
       return .failure(error)
     }

Tests/ArrowTests/ArrayTests.swift

@@ -159,7 +159,7 @@ final class ArrayTests: XCTestCase {  // swiftlint:disable:this type_body_length
     XCTAssertEqual(milliBuilder.length, 3)
     XCTAssertEqual(milliBuilder.capacity, 136)
     let milliArray = try milliBuilder.finish()
-    let milliType = milliArray.arrowData.type as! ArrowTypeTime32  // swiftlint:disable:this force_cast
+    let milliType = milliArray.arrowData.type as! ArrowTypeTime32
     XCTAssertEqual(milliType.unit, .milliseconds)
     XCTAssertEqual(milliArray.length, 3)
     XCTAssertEqual(milliArray[1], 1_000_000)
@@ -173,7 +173,7 @@ final class ArrayTests: XCTestCase {  // swiftlint:disable:this type_body_length
     XCTAssertEqual(secBuilder.length, 3)
     XCTAssertEqual(secBuilder.capacity, 136)
     let secArray = try secBuilder.finish()
-    let secType = secArray.arrowData.type as! ArrowTypeTime32  // swiftlint:disable:this force_cast
+    let secType = secArray.arrowData.type as! ArrowTypeTime32
     XCTAssertEqual(secType.unit, .seconds)
     XCTAssertEqual(secArray.length, 3)
     XCTAssertEqual(secArray[1], nil)
@@ -189,7 +189,7 @@ final class ArrayTests: XCTestCase {  // swiftlint:disable:this type_body_length
     XCTAssertEqual(nanoBuilder.length, 3)
     XCTAssertEqual(nanoBuilder.capacity, 264)
     let nanoArray = try nanoBuilder.finish()
-    let nanoType = nanoArray.arrowData.type as! ArrowTypeTime64  // swiftlint:disable:this force_cast
+    let nanoType = nanoArray.arrowData.type as! ArrowTypeTime64
     XCTAssertEqual(nanoType.unit, .nanoseconds)
     XCTAssertEqual(nanoArray.length, 3)
     XCTAssertEqual(nanoArray[1], nil)
@@ -203,7 +203,7 @@ final class ArrayTests: XCTestCase {  // swiftlint:disable:this type_body_length
     XCTAssertEqual(microBuilder.length, 3)
     XCTAssertEqual(microBuilder.capacity, 264)
     let microArray = try microBuilder.finish()
-    let microType = microArray.arrowData.type as! ArrowTypeTime64  // swiftlint:disable:this force_cast
+    let microType = microArray.arrowData.type as! ArrowTypeTime64
     XCTAssertEqual(microType.unit, .microseconds)
     XCTAssertEqual(microArray.length, 3)
     XCTAssertEqual(microArray[1], 20000)
@@ -220,7 +220,7 @@ final class ArrayTests: XCTestCase {  // swiftlint:disable:this type_body_length
     XCTAssertEqual(secBuilder.length, 3)
     XCTAssertEqual(secBuilder.capacity, 264)
     let secArray = try secBuilder.finish()
-    let secType = secArray.arrowData.type as! ArrowTypeTimestamp  // swiftlint:disable:this force_cast
+    let secType = secArray.arrowData.type as! ArrowTypeTimestamp
     XCTAssertEqual(secType.unit, .seconds)
     XCTAssertNil(secType.timezone)
     XCTAssertEqual(secArray.length, 3)
@@ -238,7 +238,7 @@ final class ArrayTests: XCTestCase {  // swiftlint:disable:this type_body_length
     XCTAssertEqual(msBuilder.length, 3)
     XCTAssertEqual(msBuilder.capacity, 264)
     let msArray = try msBuilder.finish()
-    let msType = msArray.arrowData.type as! ArrowTypeTimestamp  // swiftlint:disable:this force_cast
+    let msType = msArray.arrowData.type as! ArrowTypeTimestamp
     XCTAssertEqual(msType.unit, .milliseconds)
     XCTAssertEqual(msType.timezone, "America/New_York")
     XCTAssertEqual(msArray.length, 3)
@@ -255,7 +255,7 @@ final class ArrayTests: XCTestCase {  // swiftlint:disable:this type_body_length
     XCTAssertEqual(usBuilder.length, 3)
     XCTAssertEqual(usBuilder.capacity, 264)
     let usArray = try usBuilder.finish()
-    let usType = usArray.arrowData.type as! ArrowTypeTimestamp  // swiftlint:disable:this force_cast
+    let usType = usArray.arrowData.type as! ArrowTypeTimestamp
     XCTAssertEqual(usType.unit, .microseconds)
     XCTAssertEqual(usType.timezone, "UTC")
     XCTAssertEqual(usArray.length, 3)
@@ -272,7 +272,7 @@ final class ArrayTests: XCTestCase {  // swiftlint:disable:this type_body_length
     XCTAssertEqual(nsBuilder.length, 3)
     XCTAssertEqual(nsBuilder.capacity, 264)
     let nsArray = try nsBuilder.finish()
-    let nsType = nsArray.arrowData.type as! ArrowTypeTimestamp  // swiftlint:disable:this force_cast
+    let nsType = nsArray.arrowData.type as! ArrowTypeTimestamp
     XCTAssertEqual(nsType.unit, .nanoseconds)
     XCTAssertNil(nsType.timezone)
     XCTAssertEqual(nsArray.length, 3)
@@ -281,7 +281,7 @@ final class ArrayTests: XCTestCase {  // swiftlint:disable:this type_body_length
     XCTAssertEqual(nsArray[2], 1_609_545_600_000_000_000)
   }
 
-  func testStructArray() throws {  // swiftlint:disable:this function_body_length
+  func testStructArray() throws {
     class StructTest {
       var fieldBool: Bool = false
       var fieldInt8: Int8 = 0