Question

我有一个类，该类使用可以相互连接以看起来像“本机” SQL语句的函数来生成SQLite查询。

这是当前正在使用的协议：

/// Protocol for any object directly related with a database table.
public protocol Table {

    /// Generic enum implementing the table columns.
    associatedtype Columns: (RawRepresentable & CodingKey & CaseIterable & Hashable)

    /// The name of the table that will be represented in the entity. 
    /// Could be declarated as let in the struct that implements this protocol.
    static var tablename: String { get }
}

这里是实现Table协议的结构

public struct TMAEVersion : Table {

    /// Properties
    public var statusMobile: String?
    public var version: String?

    /// Overriding the default name to account for the special name of the table
    public var tablename: String = "TMAEVersion"

    /// Table columns keys
    public enum CodingKeys : String, CodingKey, CaseIterable {
        case statusMobile = "status_mobile"
        case version = "Version"
    }

    public typealias Columns = CodingKeys
}

这是当前正在工作的Query类，它使用Table协议实现了该功能：

public class Query<T> {

    // MARK: Properties

    public var columns = [String]()
    public var table: String = ""
    public var literal: String = ""

    fileprivate var showLogs: Bool = true

    // MARK: Init

    public init(literal: String) {
        self.literal = literal
    }

    /// Empty init for normal queries that don't take a literal
    public init(showingLogs: Bool? = nil) {
        if let showingLogs = showingLogs { showLogs = showingLogs }
    }
}

public extension Query where T: Table {

    // MARK: Select

    func generateSelect(_ distinct: Bool? = nil , _ columns: [String], from tablename: String) -> Query {
        let statement = Select(distinct: distinct ?? false, columns: columns)
        self.columns = statement.columns
        self.table = tablename
        self.literal += statement.sentence
        return self
    }

    func select(distinct: Bool? = nil, _ columns: CodingKey...) -> Query {
        return generateSelect(distinct ?? false, columns.map { $0.stringValue }, from: T.tablename)
    }

    func select(distinct: Bool? = nil, _ columns: T.Columns...) -> Query {
        return generateSelect(distinct ?? false, columns.map { $0.stringValue }, from: T.tablename)
    }

    /// Note: Comparator and Operator are enums containing cases like:
    /// - Comparator: equal, diff, greaterThan...
    /// - Operator: and, or...
    func generateWhere(_ col: String, _ comp: Comparator, _ val: Any, _ op: Operator?) -> Query {
        let statement = Where(column: col, value: val, comparator: comp, operator: op)
        self.literal += statement.sentence
        return self
    }

    func `where`(_ lc: CodingKey, _ comp: Comparator, _ rc: CodingKey) -> Query {
        return generateWhere(column, comp, value, nil)
    }
}

工作示例：

public func currentVersion() -> String? {
    return Query<TMAEVersion>()
            .select(.Version)
            .order(by: .Version)
            .execute().first?
            .Version
}

我想避免做Query<SomeTable>()的需要，所以我尝试过的是（这是出现错误的地方）：

func select<T: Table>(distinct: Bool?, columns: [T.Columns]) -> Query {
    // Code...
}

错误显示：“函数签名中未使用通用参数'T'”。

我知道这样做可以解决问题，但是我需要避免使用参数from: T.Type，但我不知道该怎么办。

func select<T: Table>(from: T.Type, distinct: Bool?, columns: [T.Columns]) -> Query

此外，我尝试在init（）函数中传递表协议，但它需要具有属性，因此...问题仍然存在。

有什么想法吗？

已编辑：添加了示例和实现

Answer 1

如果我理解正确，则您使用以下语法：

let sentence = Query<SomeTable>().select(.field1, .field2)

，您需要以下语法：

let sentence = Query().select(.field1, .field2)

您的代码中有很多小错误，我想您实际上是想使用这种语法（select是 static 方法）：

let sentence = Query.select(.field1, .field2)

为此，列需要知道其表。在撰写本文时，拥有两个具有相同Columns类型的不同表是合法的，这是不明确的。（请注意，上面的语法绝对是不可能的，因为无法知道枚举.field1属于什么，但是我们可以更进一步了。）

因此，首先，我们需要一个知道其表的ColumnIdentifier：

public protocol ColumnIdentifier: RawRepresentable & CodingKey & CaseIterable & Hashable {
    associatedtype TableType: Table
}

接下来，Table需要断言其ColumnIdentifer属于它。这样可以防止多种表类型引用相同的ColumnIdentifier。

public protocol Table {
    associatedtype Columns: ColumnIdentifier where Columns.TableType == Self
    static var tablename: String { get }
}

然后查询看起来像（略有简化）：

struct Query<T: Table> {
    static func select<C: ColumnIdentifier>(_ columns: C...) -> Query
        where C.TableType == T
    {
        return Query()
    }
}

以表格实现为例：

struct SomeTable: Table {
    enum Columns: String, ColumnIdentifier {
        case field1
        case field2
        typealias TableType = SomeTable
    }

    static var tablename: String { "table" }
}

请注意，我不认为有任何方法可以避免使用typealias TableType = SomeTable。将一种类型嵌套在另一种类型中不会以任何方式将它们连接起来。您不能说“我的包含类型”或类似的内容。

此方法将防止表交叉链接其他表的列标识符。例如：

struct OtherTable: Table {
    typealias Columns = SomeTable.Columns
    static var tablename: String { "otherTable" }
}
// 'Table' requires the types 'OtherTable' and 'SomeTable.Columns.TableType' (aka 'SomeTable') be equivalent

所有这些，您都可以（接近）描述语法：

let sentence = Query.select(SomeTable.Columns.field1, .field2)

请注意，您仍然需要在{em>某处这里SomeTable。否则，您将不知道枚举.field1的来源。

就我个人而言，我不会这样做。我会使用from版本。简单明了。

public protocol Table {
    associatedtype Columns: ColumnIdentifier
    static var tablename: String { get }
}

public protocol ColumnIdentifier: RawRepresentable & CodingKey & CaseIterable & Hashable {}

struct Query<T: Table> {
    static func select(from: T.Type = T.self, columns: T.Columns...) -> Query
    {
        return Query()
    }
}

struct SomeTable: Table {
    enum Columns: String, ColumnIdentifier {
        case field1
        case field2
    }
}

let sentence = Query.select(from: SomeTable.self, columns: .field1, .field2)

请注意from: T.Type = T.self的小技巧。这意味着“当返回类型已知时，您不需要包括它。”因此，例如，如果没有from：

func f() -> Query<SomeTable> {
    return Query.select(columns: .field1, .field2)
}

如何在Swift中的泛型类中的函数参数中使用泛型

1 个答案: