Heed linter warnings

Note sure how to get the line length of Query back down below 500 without harming readability though.

Documentation/Index.md

@@ -1130,7 +1130,7 @@ let queryWithLevel =
 chain.with(chain, 
            columns: [id, managerId, level], 
            recursive: true,
-           materializationHint: .materialize,
+           hint: .materialize,
            as: queryWithLevel)
 // WITH RECURSIVE
 //   "chain" ("id", "manager_id", "level") AS MATERIALIZED (

Sources/SQLite/Typed/Query.swift

@@ -498,9 +498,9 @@ extension QueryType {
         query.clauses.limit = length.map { ($0, offset) }
         return query
     }
-    
+
     // MARK: WITH
-    
+
     /// Sets a `WITH` clause on the query.
     ///
     ///     let users = Table("users")
@@ -517,14 +517,15 @@ extension QueryType {
     ///
     ///   -  recursive: Whether to evaluate the expression recursively.
     ///
-    ///   -  materializationHint: Provides a hint to the query planner for how the expression should be implemented.
+    ///   -  hint: Provides a hint to the query planner for how the expression should be implemented.
     ///
     ///   -  subquery: A query that generates the rows for the table expression.
     ///
     /// - Returns: A query with the given `ORDER BY` clause applied.
-    public func with(_ alias: Table, columns: [Expressible]? = nil, recursive: Bool = false, materializationHint: MaterializationHint? = nil, as subquery: QueryType) -> Self {
+    public func with(_ alias: Table, columns: [Expressible]? = nil, recursive: Bool = false,
+                     hint: MaterializationHint? = nil, as subquery: QueryType) -> Self {
         var query = self
-        let clause = WithClauses.Clause(alias: alias, columns: columns, materializationHint: materializationHint, query: subquery)
+        let clause = WithClauses.Clause(alias: alias, columns: columns, hint: hint, query: subquery)
         query.clauses.with.recursive = query.clauses.with.recursive || recursive
         query.clauses.with.clauses.append(clause)
         return query
@@ -636,38 +637,38 @@ extension QueryType {
             ])
         })
     }
-    
+
     fileprivate var withClause: Expressible? {
         guard !clauses.with.clauses.isEmpty else {
             return nil
         }
 
         let innerClauses = ", ".join(clauses.with.clauses.map { (clause) in
             let hintExpr: Expression<Void>?
-            if let hint = clause.materializationHint {
+            if let hint = clause.hint {
                 hintExpr = Expression<Void>(literal: hint.rawValue)
             } else {
                 hintExpr = nil
             }
-            
+
             let columnExpr: Expression<Void>?
             if let columns = clause.columns {
                 columnExpr = "".wrap(", ".join(columns))
             } else {
                 columnExpr = nil
             }
-            
+
             let expressions: [Expressible?] = [
                 clause.alias.tableName(),
                 columnExpr,
                 Expression<Void>(literal: "AS"),
                 hintExpr,
                 "".wrap(clause.query) as Expression<Void>
             ]
-            
+
             return " ".join(expressions.compactMap { $0 })
         })
-        
+
         return " ".join([
             Expression<Void>(literal: clauses.with.recursive ? "WITH RECURSIVE" : "WITH"),
             innerClauses
@@ -1318,12 +1319,12 @@ struct WithClauses {
     struct Clause {
         var alias: Table
         var columns: [Expressible]?
-        var materializationHint: MaterializationHint?
+        var hint: MaterializationHint?
         var query: QueryType
     }
     /// The `RECURSIVE` flag is applied to the entire `WITH` clause
     var recursive: Bool = false
-    
+
     /// Each `WITH` clause may have multiple subclauses
     var clauses: [Clause] = []
 }
@@ -1345,7 +1346,7 @@ public struct QueryClauses {
     var limit: (length: Int, offset: Int?)?
 
     var union = [(all: Bool, table: QueryType)]()
-    
+
     var with = WithClauses()
 
     fileprivate init(_ name: String, alias: String?, database: String?) {

Tests/SQLiteTests/QueryIntegrationTests.swift

@@ -230,28 +230,28 @@ class QueryIntegrationTests: SQLiteTestCase {
         let result = Array(try db.prepare(users.select(email).order(Expression<Int>.random()).limit(1)))
         XCTAssertEqual(1, result.count)
     }
-    
+
     func test_with_recursive() {
         let nodes = Table("nodes")
         let id = Expression<Int64>("id")
         let parent = Expression<Int64?>("parent")
         let value = Expression<Int64>("value")
-                
+
         try! db.run(nodes.create { builder in
             builder.column(id)
             builder.column(parent)
             builder.column(value)
         })
-        
+
         try! db.run(nodes.insertMany([
             [id <- 0, parent <- nil, value <- 2],
             [id <- 1, parent <- 0, value <- 4],
             [id <- 2, parent <- 0, value <- 9],
             [id <- 3, parent <- 2, value <- 8],
             [id <- 4, parent <- 2, value <- 7],
-            [id <- 5, parent <- 4, value <- 3],
+            [id <- 5, parent <- 4, value <- 3]
         ]))
-        
+
         // Compute the sum of the values of node 5 and its ancestors
         let ancestors = Table("ancestors")
         let sum = try! db.scalar(
@@ -268,7 +268,7 @@ class QueryIntegrationTests: SQLiteTestCase {
                               )
                      )
         )
-        
+
         XCTAssertEqual(21, sum)
     }
 }

Tests/SQLiteTests/QueryTests.swift

@@ -58,7 +58,7 @@ class QueryTests: XCTestCase {
     func test_selectDistinct_withStar_compilesSelectClause() {
         assertSQL("SELECT DISTINCT * FROM \"users\"", users.select(distinct: *))
     }
-    
+
     func test_union_compilesUnionClause() {
         assertSQL("SELECT * FROM \"users\" UNION SELECT * FROM \"posts\"", users.union(posts))
         assertSQL("SELECT * FROM \"users\" UNION ALL SELECT * FROM \"posts\"", users.union(all: true, posts))
@@ -224,41 +224,41 @@ class QueryTests: XCTestCase {
             users.join(managers, on: managers[id] == users[managerId])
         )
     }
-    
+
     func test_with_compilesWithClause() {
         let temp = Table("temp")
-        
+
         assertSQL("WITH \"temp\" AS (SELECT * FROM \"users\") SELECT * FROM \"temp\"",
                   temp.with(temp, as: users))
     }
-    
+
     func test_with_recursive_compilesWithClause() {
         let temp = Table("temp")
-        
+
         assertSQL("WITH RECURSIVE \"temp\" AS (SELECT * FROM \"users\") SELECT * FROM \"temp\"",
                   temp.with(temp, recursive: true, as: users))
-        
+
         assertSQL("WITH \"temp\" AS (SELECT * FROM \"users\") SELECT * FROM \"temp\"",
                   temp.with(temp, recursive: false, as: users))
     }
-    
+
     func test_with_materialization_compilesWithClause() {
         let temp = Table("temp")
-        
+
         assertSQL("WITH \"temp\" AS MATERIALIZED (SELECT * FROM \"users\") SELECT * FROM \"temp\"",
-                  temp.with(temp, materializationHint: .materialized, as: users))
-        
+                  temp.with(temp, hint: .materialized, as: users))
+
         assertSQL("WITH \"temp\" AS NOT MATERIALIZED (SELECT * FROM \"users\") SELECT * FROM \"temp\"",
-                  temp.with(temp, materializationHint: .notMaterialized, as: users))
+                  temp.with(temp, hint: .notMaterialized, as: users))
     }
-    
+
     func test_with_columns_compilesWithClause() {
         let temp = Table("temp")
 
         assertSQL("WITH \"temp\" (\"id\", \"email\") AS (SELECT * FROM \"users\") SELECT * FROM \"temp\"",
-                  temp.with(temp, columns: [id, email], recursive: false, materializationHint: nil, as: users))
+                  temp.with(temp, columns: [id, email], recursive: false, hint: nil, as: users))
     }
-    
+
     func test_with_multiple_compilesWithClause() {
         let temp = Table("temp")
         let second = Table("second")
@@ -267,8 +267,8 @@ class QueryTests: XCTestCase {
         let query = temp
             .with(temp, recursive: true, as: users)
             .with(second, recursive: true, as: posts)
-            .with(third, materializationHint: .materialized, as:categories)
-        
+            .with(third, hint: .materialized, as: categories)
+
         assertSQL(
             """
             WITH RECURSIVE \"temp\" AS (SELECT * FROM \"users\"),