better formating + basic querying

levydsa · levydsa · commit 6cf7d6035522 · 2024-08-22T16:09:51.000-03:00
diff --git a/.gitignore b/.gitignore
@@ -6,3 +6,4 @@ DerivedData/
 .swiftpm/configuration/registries.json
 .swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
 .netrc
+test.db
diff --git a/.swift-format b/.swift-format
@@ -0,0 +1,58 @@
+{
+  "fileScopedDeclarationPrivacy" : {
+    "accessLevel" : "private"
+  },
+  "indentation" : {
+    "spaces" : 4
+  },
+  "indentConditionalCompilationBlocks" : true,
+  "indentSwitchCaseLabels" : false,
+  "lineBreakAroundMultilineExpressionChainComponents" : false,
+  "lineBreakBeforeControlFlowKeywords" : false,
+  "lineBreakBeforeEachArgument" : false,
+  "lineBreakBeforeEachGenericRequirement" : false,
+  "lineLength" : 100,
+  "maximumBlankLines" : 1,
+  "prioritizeKeepingFunctionOutputTogether" : false,
+  "respectsExistingLineBreaks" : true,
+  "rules" : {
+    "AllPublicDeclarationsHaveDocumentation" : false,
+    "AlwaysUseLowerCamelCase" : true,
+    "AmbiguousTrailingClosureOverload" : true,
+    "BeginDocumentationCommentWithOneLineSummary" : false,
+    "DoNotUseSemicolons" : true,
+    "DontRepeatTypeInStaticProperties" : true,
+    "FileScopedDeclarationPrivacy" : true,
+    "FullyIndirectEnum" : true,
+    "GroupNumericLiterals" : true,
+    "IdentifiersMustBeASCII" : true,
+    "NeverForceUnwrap" : false,
+    "NeverUseForceTry" : false,
+    "NeverUseImplicitlyUnwrappedOptionals" : false,
+    "NoAccessLevelOnExtensionDeclaration" : true,
+    "NoAssignmentInExpressions" : true,
+    "NoBlockComments" : true,
+    "NoCasesWithOnlyFallthrough" : true,
+    "NoEmptyTrailingClosureParentheses" : true,
+    "NoLabelsInCasePatterns" : true,
+    "NoLeadingUnderscores" : false,
+    "NoParensAroundConditions" : true,
+    "NoVoidReturnOnFunctionSignature" : true,
+    "OneCasePerLine" : true,
+    "OneVariableDeclarationPerLine" : true,
+    "OnlyOneTrailingClosureArgument" : true,
+    "OrderedImports" : true,
+    "ReturnVoidInsteadOfEmptyTuple" : true,
+    "UseEarlyExits" : false,
+    "UseLetInEveryBoundCaseVariable" : true,
+    "UseShorthandTypeNames" : true,
+    "UseSingleLinePropertyGetter" : true,
+    "UseSynthesizedInitializer" : true,
+    "UseTripleSlashForDocumentationComments" : true,
+    "UseWhereClausesInForLoops" : false,
+    "ValidateDocumentationComments" : false
+  },
+  "spacesAroundRangeFormationOperators" : false,
+  "tabWidth" : 4,
+  "version" : 1
+}
diff --git a/Package.swift b/Package.swift
@@ -4,18 +4,18 @@
 import PackageDescription
 
 let package = Package(
-  name: "Libsql",
-  products: [
-    .library(name: "Libsql", targets: ["Libsql"])
-  ],
-  targets: [
-    .target(
-      name: "Libsql",
-      dependencies: ["CLibsql"],
-      linkerSettings: [
-        .unsafeFlags(["-L", "Sources/CLibsql/target/release"])
-      ]),
-    .systemLibrary(name: "CLibsql"),
-    .testTarget(name: "LibsqlTests", dependencies: ["Libsql"]),
-  ]
+    name: "Libsql",
+    products: [
+        .library(name: "Libsql", targets: ["Libsql"])
+    ],
+    targets: [
+        .target(
+            name: "Libsql",
+            dependencies: ["CLibsql"],
+            linkerSettings: [
+                .unsafeFlags(["-L", "Sources/CLibsql/target/release"])
+            ]),
+        .systemLibrary(name: "CLibsql"),
+        .testTarget(name: "LibsqlTests", dependencies: ["Libsql"]),
+    ]
 )
diff --git a/Sources/Libsql/Libsql.swift b/Sources/Libsql/Libsql.swift
@@ -1,51 +1,256 @@
 import CLibsql
+import Foundation
+
+enum Value {
+    case integer(Int64)
+    case text(String)
+    case blob(Data)
+    case real(Double)
+}
+
+protocol ValueRepresentable {
+    func toValue() -> Value
+}
+
+extension Int: ValueRepresentable {
+    func toValue() -> Value { .integer(Int64(self)) }
+}
+
+extension Int64: ValueRepresentable {
+    func toValue() -> Value { .integer(self) }
+}
+
+extension String: ValueRepresentable {
+    func toValue() -> Value { .text(self) }
+}
+
+extension Data: ValueRepresentable {
+    func toValue() -> Value { .blob(self) }
+}
+
+extension Double: ValueRepresentable {
+    func toValue() -> Value { .real(self) }
+}
 
 enum LibsqlError: Error {
-  case runtimeError(String)
+    case runtimeError(String)
+    case unexpectedType
 }
 
-class Database {
-  var inner: libsql_database_t
+class Row {
+    var inner: libsql_row_t
+
+    fileprivate init?(fromPtr inner: libsql_row_t?) {
+        guard let inner = inner else {
+            return nil
+        }
+
+        self.inner = inner
+    }
+
+    func getData(_ index: Int32) throws -> Data {
+        var slice: blob = blob()
 
-  deinit {
-    print("closing")
-    libsql_close(self.inner)
-  }
+        var err: UnsafePointer<CChar>?
+        if libsql_get_blob(self.inner, index, &slice, &err) != 0 {
+            defer { libsql_free_string(err) }
+            throw LibsqlError.runtimeError(String(cString: err!))
+        }
+
+        return Data(bytes: slice.ptr, count: Int(slice.len))
+    }
+
+    func getDouble(_ index: Int32) throws -> Double {
+        var double: Double = 0
+
+        var err: UnsafePointer<CChar>?
+        if libsql_get_float(self.inner, index, &double, &err) != 0 {
+            defer { libsql_free_string(err) }
+            throw LibsqlError.runtimeError(String(cString: err!))
+        }
+
+        return double
+    }
+
+    func getString(_ index: Int32) throws -> String {
+        var string: UnsafePointer<CChar>? = nil
+
+        var err: UnsafePointer<CChar>?
+        if libsql_get_string(self.inner, index, &string, &err) != 0 {
+            defer { libsql_free_string(err) }
+            throw LibsqlError.runtimeError(String(cString: err!))
+        }
+
+        return String(cString: string!)
+    }
+
+    func getInt(_ index: Int32) throws -> Int {
+        var integer: Int64 = 0
+
+        var err: UnsafePointer<CChar>?
+        if libsql_get_int(self.inner, index, &integer, &err) != 0 {
+            defer { libsql_free_string(err) }
+            throw LibsqlError.runtimeError(String(cString: err!))
+        }
+        return Int(integer)
+    }
+}
 
-  init?(path: String) throws {
-    var db: libsql_database_t? = nil
-    var err: UnsafePointer<CChar>? = nil
+class Rows {
+    var inner: libsql_rows_t
 
-    try path.withCString { path in
-      if libsql_open_file(path, &db, &err) != 0 {
-        throw LibsqlError.runtimeError(String(cString: err!))
-      }
+    fileprivate init(fromPtr inner: libsql_rows_t) {
+        self.inner = inner
     }
 
-    if let db = db {
-      self.inner = db
-    } else {
-      return nil
+    deinit {
+        libsql_free_rows(self.inner)
     }
-  }
 
-  init?(url: String, authToken: String) throws {
-    var db: libsql_database_t? = nil
-    var err: UnsafePointer<CChar>? = nil
+    func next() throws -> Row? {
+        var row: libsql_row_t?
 
-    try url.withCString { url in
-      try authToken.withCString { authToken in
-        if libsql_open_remote(url, authToken, &db, &err) == 0 {
-          defer { libsql_free_string(err) }
-          throw LibsqlError.runtimeError(String(cString: err!))
+        var err: UnsafePointer<CChar>?
+        if libsql_next_row(self.inner, &row, &err) != 0 {
+            defer { libsql_free_string(err) }
+            throw LibsqlError.runtimeError(String(cString: err!))
         }
-      }
+
+        return Row(fromPtr: row)
+
     }
+}
+
+class Connection {
+    var inner: libsql_connection_t
+
+    deinit {
+        libsql_disconnect(self.inner)
+    }
+
+    fileprivate init(fromPtr inner: libsql_connection_t) {
+        self.inner = inner
+    }
+
+    func query(_ sql: String) throws -> Rows {
+        var rows: libsql_rows_t? = nil
+        try sql.withCString { sql in
+            var err: UnsafePointer<CChar>? = nil
+            if libsql_query(self.inner, sql, &rows, &err) != 0 {
+                defer { libsql_free_string(err) }
+                throw LibsqlError.runtimeError(String(cString: err!))
+            }
+        }
+
+        return Rows(fromPtr: rows!)
+    }
+
+    func execute(_ sql: String) throws {
+        try sql.withCString { sql in
+            var err: UnsafePointer<CChar>? = nil
+            if libsql_execute(self.inner, sql, &err) != 0 {
+                defer { libsql_free_string(err) }
+                throw LibsqlError.runtimeError(String(cString: err!))
+            }
+        }
+    }
+
+    func execute(_ sql: String, _ params: ValueRepresentable...) throws {
+        var stmt: libsql_stmt_t? = nil
+
+        try sql.withCString { sql in
+            var err: UnsafePointer<CChar>? = nil
+            if libsql_prepare(self.inner, sql, &stmt, &err) != 0 {
+                defer { libsql_free_string(err) }
+                throw LibsqlError.runtimeError(String(cString: err!))
+            }
+        }
+
+        for (i, v) in params.enumerated() {
+            let i = Int32(i + 1)
+
+            switch v.toValue() {
+            case .integer(let integer):
+                var err: UnsafePointer<CChar>? = nil
+                if libsql_bind_int(stmt, i, integer, &err) != 0 {
+                    defer { libsql_free_string(err) }
+                    throw LibsqlError.runtimeError(String(cString: err!))
+                }
+            case .text(let text):
+                try text.withCString { text in
+                    var err: UnsafePointer<CChar>? = nil
+                    if libsql_bind_string(stmt, i, text, &err) != 0 {
+                        defer { libsql_free_string(err) }
+                        throw LibsqlError.runtimeError(String(cString: err!))
+                    }
+                }
+            case .blob(let blob):
+                try blob.withUnsafeBytes { blob in
+                    let blob = blob.baseAddress?.assumingMemoryBound(to: UInt8.self)
+                    var err: UnsafePointer<CChar>? = nil
+                    if libsql_bind_string(stmt, i, blob, &err) != 0 {
+                        defer { libsql_free_string(err) }
+                        throw LibsqlError.runtimeError(String(cString: err!))
+                    }
+                }
+            case .real(let real):
+                var err: UnsafePointer<CChar>? = nil
+                if libsql_bind_float(stmt, i, real, &err) != 0 {
+                    defer { libsql_free_string(err) }
+                    throw LibsqlError.runtimeError(String(cString: err!))
+                }
+            }
+        }
+
+    }
+}
+
+class Database {
+    var inner: libsql_database_t
+
+    deinit {
+        libsql_close(self.inner)
+    }
+
+    func connect() throws -> Connection {
+        var conn: libsql_connection_t? = nil
+        var err: UnsafePointer<CChar>? = nil
+
+        if libsql_connect(self.inner, &conn, &err) != 0 {
+            defer { libsql_free_string(err) }
+            throw LibsqlError.runtimeError(String(cString: err!))
+        }
+
+        return Connection(fromPtr: conn!)
+    }
+
+    init(_ path: String) throws {
+        var db: libsql_database_t? = nil
+        var err: UnsafePointer<CChar>? = nil
+
+        try path.withCString { path in
+            if libsql_open_ext(path, &db, &err) != 0 {
+                defer { libsql_free_string(err) }
+                throw LibsqlError.runtimeError(String(cString: err!))
+            }
+        }
+
+        self.inner = db!
+    }
+
+    init(url: String, authToken: String) throws {
+        var db: libsql_database_t? = nil
+        var err: UnsafePointer<CChar>? = nil
+
+        try url.withCString { url in
+            try authToken.withCString { authToken in
+                if libsql_open_remote(url, authToken, &db, &err) != 0 {
+                    defer { libsql_free_string(err) }
+                    throw LibsqlError.runtimeError(String(cString: err!))
+                }
+            }
+        }
 
-    if let db = db {
-      self.inner = db
-    } else {
-      return nil
+        self.inner = db!
     }
-  }
 }
diff --git a/Tests/LibsqlTests/LibsqlTests.swift b/Tests/LibsqlTests/LibsqlTests.swift
