sendable + general cleanup (linting)

Author: true-false-maybe

README.md

@@ -1,6 +1,6 @@
 # ClickHouseNIO
 
-![Swift 5](https://img.shields.io/badge/Swift-5-orange.svg) ![SPM](https://img.shields.io/badge/SPM-compatible-green.svg) ![Platforms](https://img.shields.io/badge/Platforms-macOS%20Linux-green.svg) [![codebeat badge](https://codebeat.co/badges/d15d7e95-d3df-4f97-974c-c3a7d9c07a9e)](https://codebeat.co/projects/github-com-patrick-zippenfenig-clickhousenio-main) [![CircleCI](https://circleci.com/gh/patrick-zippenfenig/ClickHouseNIO/tree/main.svg?style=svg)](https://circleci.com/gh/patrick-zippenfenig/ClickHouseNIO/tree/main) 
+![Swift 5](https://img.shields.io/badge/Swift-5-orange.svg) ![SPM](https://img.shields.io/badge/SPM-compatible-green.svg) ![Platforms](https://img.shields.io/badge/Platforms-macOS%20Linux-green.svg) [![codebeat badge](https://codebeat.co/badges/d15d7e95-d3df-4f97-974c-c3a7d9c07a9e)](https://codebeat.co/projects/github-com-patrick-zippenfenig-clickhousenio-main) [![CircleCI](https://circleci.com/gh/patrick-zippenfenig/ClickHouseNIO/tree/main.svg?style=svg)](https://circleci.com/gh/patrick-zippenfenig/ClickHouseNIO/tree/main)
 
 High performance Swift [ClickHouse](https://clickhouse.tech) client based on [SwiftNIO 2](https://github.com/apple/swift-nio). It is inspired by the [ClickHouse source code](https://github.com/ClickHouse/ClickHouse/tree/master/src/Client) (C++), but written in pure Swift.
 
@@ -31,7 +31,7 @@ This client provides raw query capabilities. Connection pooling or relational ab
 $ swift build
 ```
 
-## Usage 
+## Usage
 
 1. Connect to a ClickHouseServer. The client requires a `eventLoop` which is usually provided by frameworks which use SwiftNIO. We also use `wait()` for simplicity, but it is discouraged for production code.
 
@@ -40,13 +40,13 @@ import NIO
 import ClickHouseNIO
 
 let config = try ClickHouseConfiguration(
-    hostname: "localhost", 
-    port: 9000, 
-    user: "default", 
-    password: "admin", 
+    hostname: "localhost",
+    port: 9000,
+    user: "default",
+    password: "admin",
     database: "default")
-  
-let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)  
+
+let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
 let connection = try ClickHouseConnection.connect(configuration: config, on: eventLoopGroup.next()).wait()
 ```
 
@@ -81,7 +81,7 @@ let data = [
 try! connection.insert(into: "test", data: data).wait()
 ````
 
-5. Query data and cast is to the exptected array
+5. Query data and cast is to the expected array
 
 ```swift
 try! conn.connection.query(sql: "SELECT * FROM test").map { res in
@@ -104,10 +104,10 @@ For TLS encrypted connections to the ClickHouse server, a `tlsConfiguration` att
 let tls = TLSConfiguration.forClient(certificateVerification: .none)
 
 let config = try ClickHouseConfiguration(
-    hostname: "localhost", 
-    port: 9440, 
-    user: "default", 
-    password: "admin", 
+    hostname: "localhost",
+    port: 9440,
+    user: "default",
+    password: "admin",
     database: "default",
     tlsConfiguration: tls)
 ```
@@ -118,7 +118,7 @@ Because networks unreliable by nature, ClickHouseNIO uses different timeouts to
 ```swift
 
 let config = try ClickHouseConfiguration(
-    hostname: "localhost", 
+    hostname: "localhost",
     ...,
     connectTimeout: .seconds(10),
     readTimeout: .seconds(90),
@@ -127,9 +127,9 @@ let config = try ClickHouseConfiguration(
 ```
 
 All timeouts will close the connection. Different timeouts trigger different exceptions:
-- `connectTimeout` will throw `NIO.ChannelError.connectTimeout(TimeAmount)` if the connection to the ClickHouse server cannot be establised after this period of time.
-- `readTimeout`: If a query is running, and the ClickHouseNIO client does not receive any network package, the conncection is closed and throws `ClickHouseError.readTimeout`. This can happen, if the network connection is interrupted while waiting for a response. Usually, even while waiting for a query result, packages are exchanged very frequently.
-- `queryTimeout` is the total time after a query will be terminated and the connection is closed. Because ClickHouseNIO is also capable of queueing queries, this includes the time in the queue as well. On a very busy server, a long waiting time starts to close connections. If a connection is closed, all queries in the queue will return a failed future with the exception `ClickHouseError.queryTimeout`. 
+- `connectTimeout` will throw `NIO.ChannelError.connectTimeout(TimeAmount)` if the connection to the ClickHouse server cannot be established after this period of time.
+- `readTimeout`: If a query is running, and the ClickHouseNIO client does not receive any network package, the connection is closed and throws `ClickHouseError.readTimeout`. This can happen, if the network connection is interrupted while waiting for a response. Usually, even while waiting for a query result, packages are exchanged very frequently.
+- `queryTimeout` is the total time after a query will be terminated and the connection is closed. Because ClickHouseNIO is also capable of queueing queries, this includes the time in the queue as well. On a very busy server, a long waiting time starts to close connections. If a connection is closed, all queries in the queue will return a failed future with the exception `ClickHouseError.queryTimeout`.
 
 Timeouts can also be specified for a single query with `connection.command(sql: sql, timeout: .seconds(30))`, but keep in mind that this also includes queue time.
 

Sources/ClickHouseNIO/ByteBufferExtensions.swift

@@ -13,7 +13,7 @@ extension ByteBuffer {
     mutating func writeClickHouseString(_ string: String) {
         // We have to access the buffer here directly, because we need to know the byte length
         if let written = string.utf8.withContiguousStorageIfAvailable({ utf8Bytes -> Int in
-            // If it is a continous UTF8 string
+            // If it is a continuous UTF8 string
             writeVarInt64(UInt64(utf8Bytes.count))
             return self.setBytes(utf8Bytes, at: writerIndex)
         }) {
@@ -27,50 +27,49 @@ extension ByteBuffer {
         }
         moveWriterIndex(forwardBy: written)
     }
-    
+
     /// Write a string with a fixed length. Returns the number of bytes written.
     @discardableResult
     @inlinable
     public mutating func setString(_ string: String, at index: Int, maxLength length: Int) -> Int {
         if let written = string.utf8.withContiguousStorageIfAvailable({ utf8Bytes in
-            // If it is a continous UTF8 string
+            // If it is a continuous UTF8 string
             self.setBytes(utf8Bytes.prefix(length), at: writerIndex)
         }) {
             return written
         }
         var string = string
-        let written = string.withUTF8 {
+        return string.withUTF8 {
             self.setBytes($0.prefix(length), at: writerIndex)
         }
-        return written
     }
-    
+
     /// Write a fixed string and zero padd in case the string is too short
     mutating func writeClickHouseFixedString(_ string: String, length: Int) {
-        // Carefull, needs to work with UTF8
+        // Careful, needs to work with UTF8
         let written = setString(string, at: writerIndex, maxLength: length)
         if written < length {
             setRepeatingByte(0, count: length - written, at: writerIndex + written)
         }
         self.moveWriterIndex(forwardBy: length)
     }
-    
+
     mutating func writeClickHouseStrings(_ strings: [String]) {
-        let stringLen = strings.reduce(0, {$0 + $1.count})
+        let stringLen = strings.reduce(0, { $0 + $1.count })
         let offsetLen = strings.count * MemoryLayout<Int>.size
         reserveCapacity(writableBytes + stringLen + offsetLen)
         for string in strings {
             writeClickHouseString(string)
         }
     }
-    
+
     mutating func writeClickHouseFixedStrings(_ strings: [String], length: Int) {
         reserveCapacity(writableBytes + length * strings.count)
         for string in strings {
             writeClickHouseFixedString(string, length: length)
         }
     }
-    
+
     mutating func readClickHouseString() -> String? {
         guard let length = readVarInt64() else {
             return nil
@@ -84,41 +83,41 @@ extension ByteBuffer {
         }
         return readString(length: Int(length))
     }
-    
+
     /// Fancy click house coding...
     mutating func writeVarInt64(_ frm: UInt64) {
         var value = frm
         var byte: UInt8 = 0
         for _ in 0...8 {
             byte = UInt8(value & 0x7F)
-            if (value > 0x7F) {
+            if value > 0x7F {
                 byte |= 0x80
             }
             writeInteger(byte)
             value >>= 7
-            if (value == 0) {
+            if value == 0 {
                 break
             }
         }
     }
-    
+
     mutating func readVarInt64() -> UInt64? {
         var value: UInt64 = 0
         for i: UInt8 in 0...8 {
             guard let byte: UInt8 = readInteger() else {
                 return nil
             }
             value |= UInt64(byte & 0x7F) << UInt64(7 * i)
-            if ((byte & 0x80) == 0) {
+            if (byte & 0x80) == 0 {
                 return value
             }
         }
         return nil
     }
-    
+
     mutating func readClickHouseStrings(numRows: Int) -> [String]? {
         // TODO calculate the required bytes more efficiently
-        
+
         var strings = [String]()
         strings.reserveCapacity(numRows)
         for _ in 0..<numRows {
@@ -129,7 +128,7 @@ extension ByteBuffer {
         }
         return strings
     }
-    
+
     mutating func readIntegerArray<T: FixedWidthInteger>(numRows: Int) -> [T]? {
         guard readableBytes >= MemoryLayout<T>.size * numRows else {
             return nil
@@ -144,56 +143,54 @@ extension ByteBuffer {
         }
         return array
     }
-    
+
     mutating func readOptionalIntegerArray<T: FixedWidthInteger>(numRows: Int) -> [T?]? {
-        guard readableBytes >= (MemoryLayout<T>.size+1) * numRows else {
+        guard readableBytes >= (MemoryLayout<T>.size + 1) * numRows else {
             return nil
         }
-        var isnull = [Bool]()
-        isnull.reserveCapacity(numRows)
+        var isNull = [Bool]()
+        isNull.reserveCapacity(numRows)
         for _ in 0..<numRows {
             guard let set: UInt8 = readInteger(endianness: .little) else {
                 return nil
             }
-            isnull.append(set == 1)
+            isNull.append(set == 1)
         }
-        
+
         var array = [T?]()
         array.reserveCapacity(numRows)
         for i in 0..<numRows {
             guard let value: T = readInteger(endianness: .little) else {
                 return nil
             }
-            if isnull[i] {
+            if isNull[i] {
                 array.append(nil)
             } else {
                 array.append(value)
             }
         }
         return array
     }
-    
+
     mutating func readUuidArray(numRows: Int, endianness: Endianness = .big) -> [UUID]? {
         guard readableBytes >= MemoryLayout<UUID>.size * numRows else {
             return nil
         }
         return [UUID](unsafeUninitializedCapacity: numRows) { (buffer, initializedCount) in
-            let numBytes = readableBytesView.withUnsafeBytes({ $0.copyBytes(to: buffer)})
+            let numBytes = readableBytesView.withUnsafeBytes({ $0.copyBytes(to: buffer) })
             assert(numBytes / MemoryLayout<UUID>.size == numRows)
             moveReaderIndex(forwardBy: numBytes)
             if endianness == .little {
-                for (i,e) in buffer.enumerated() {
+                for (i, e) in buffer.enumerated() {
                     buffer[i] = e.swapBytes()
                 }
             }
             initializedCount = numRows
         }
     }
-    
-    /**
-     Read bytes as a specific array type. The data type should be continuously stored in memory. E.g. Does not work with strings
-     TODO: Ensure that this works for all types... endians might also be an issue
-     */
+
+    /// Read bytes as a specific array type. The data type should be continuously stored in memory. E.g. Does not work with strings
+    /// TODO: Ensure that this works for all types... endians might also be an issue
     mutating func readUnsafeGenericArray<T>(numRows: Int) -> [T]? {
         guard readableBytes >= MemoryLayout<T>.size * numRows else {
             return nil
@@ -207,14 +204,14 @@ extension ByteBuffer {
             initializedCount = numRows
         }
     }
-    
+
     mutating func writeIntegerArray<T: FixedWidthInteger>(_ array: [T]) {
         reserveCapacity(array.count * MemoryLayout<T>.size + writableBytes)
         for element in array {
             writeInteger(element, endianness: .little)
         }
     }
-    
+
     mutating func writeOptionalIntegerArray<T: FixedWidthInteger>(_ array: [T?]) {
         reserveCapacity(array.count * (MemoryLayout<T>.size + 1) + writableBytes)
         // Frist write one array with 0/1 for nullable, then data
@@ -233,7 +230,7 @@ extension ByteBuffer {
             }
         }
     }
-    
+
     /// Write UUID array for clickhouse
     mutating func writeUuidArray(_ array: [UUID], endianness: Endianness = .big) {
         reserveCapacity(array.count * MemoryLayout<UUID>.size + writableBytes)
@@ -256,8 +253,10 @@ extension UUID {
     /// Swap bytes before sending to clickhouse and after retrieval
     fileprivate func swapBytes() -> UUID {
         let bytes = self.uuid
-        let b = (bytes.7,  bytes.6,  bytes.5,  bytes.4,  bytes.3,  bytes.2,  bytes.1, bytes.0,
-                 bytes.15, bytes.14, bytes.13, bytes.12, bytes.11, bytes.10, bytes.9, bytes.8)
+        let b = (
+            bytes.7,  bytes.6,  bytes.5,  bytes.4,  bytes.3,  bytes.2,  bytes.1, bytes.0,
+            bytes.15, bytes.14, bytes.13, bytes.12, bytes.11, bytes.10, bytes.9, bytes.8
+        )
         return UUID(uuid: b)
     }
 }