DataLiteCore swift package

Sources/DataLiteCore/Classes/Function+Options.swift

@@ -0,0 +1,62 @@
+import Foundation
+import DataLiteC
+
+extension Function {
+    /// An option set representing the options for an SQLite function.
+    ///
+    /// This structure defines an option set to configure various options for an SQLite function.
+    /// Options can be combined using bitwise OR operations.
+    ///
+    /// Example usage:
+    /// ```swift
+    /// let options: Function.Options = [.deterministic, .directonly]
+    /// ```
+    ///
+    /// - SeeAlso: [SQLite Function Flags](https://www.sqlite.org/c3ref/c_deterministic.html)
+    public struct Options: OptionSet, Hashable, Sendable {
+        // MARK: - Properties
+        
+        /// The raw value type used to store the SQLite function options.
+        public var rawValue: Int32
+        
+        // MARK: - Options
+        
+        /// Indicates that the function is deterministic.
+        ///
+        /// A deterministic function always gives the same output when it has the same input parameters.
+        /// For example, a mathematical function like sqrt() is deterministic.
+        public static let deterministic = Self(rawValue: SQLITE_DETERMINISTIC)
+        
+        /// Indicates that the function may only be invoked from top-level SQL.
+        ///
+        /// A function with the `directonly` option cannot be used in a VIEWs or TRIGGERs, or in schema structures
+        /// such as CHECK constraints, DEFAULT clauses, expression indexes, partial indexes, or generated columns.
+        ///
+        /// The `directonly` option is recommended for any application-defined SQL function that has side-effects
+        /// or that could potentially leak sensitive information. This will prevent attacks in which an application
+        /// is tricked into using a database file that has had its schema surreptitiously modified to invoke the
+        /// application-defined function in ways that are harmful.
+        public static let directonly = Self(rawValue: SQLITE_DIRECTONLY)
+        
+        /// Indicates that the function is innocuous.
+        ///
+        /// The `innocuous` option means that the function is unlikely to cause problems even if misused.
+        /// An innocuous function should have no side effects and should not depend on any values other
+        /// than its input parameters.
+        /// The `abs()` function is an example of an innocuous function.
+        /// The `load_extension()` SQL function is not innocuous because of its side effects.
+        ///
+        /// `innocuous` is similar to `deterministic`, but is not exactly the same.
+        /// The `random()` function is an example of a function that is innocuous but not deterministic.
+        public static let innocuous = Self(rawValue: SQLITE_INNOCUOUS)
+        
+        // MARK: - Inits
+        
+        /// Creates an SQLite function option set from a raw value.
+        ///
+        /// - Parameter rawValue: The raw value representing the SQLite function options.
+        public init(rawValue: Int32) {
+            self.rawValue = rawValue
+        }
+    }
+}