Quote column names

Literal expressions are now made with `init(literal:)`:

    Expression<Int>(literal: "1 + 1")

By default, `init(_:)` is for identifiers, like column names:

    Expression<Int>("id") // returns quoted identifier: \"id\"

This makes things a bit safer and more flexible.

Signed-off-by: Stephen Celis <[email protected]>

Author: stephencelis

Documentation/Index.md

@@ -45,18 +45,18 @@ db.create(table: users) { t in
     t.column(email, unique: true)
 }
 // CREATE TABLE "users" (
-//     id INTEGER PRIMARY KEY NOT NULL,
-//     name TEXT,
-//     email TEXT NOT NULL UNIQUE
+//     "id" INTEGER PRIMARY KEY NOT NULL,
+//     "name" TEXT,
+//     "email" TEXT NOT NULL UNIQUE
 // )
 
 var alice: Query?
 if let insertedID = users.insert(name <- "Alice", email <- "[email protected]") {
-	println("inserted id: \(insertedID)")
-	// inserted id: 1
-	alice = users.filter(id == insertedID)
+    println("inserted id: \(insertedID)")
+    // inserted id: 1
+    alice = users.filter(id == insertedID)
 }
-// INSERT INTO "users" (name, email) VALUES ('Alice', '[email protected]')
+// INSERT INTO "users" ("name", "email") VALUES ('Alice', '[email protected]')
 
 for user in users {
     println("id: \(user[id]), name: \(user[name]), email: \(user[email])"
@@ -65,10 +65,10 @@ for user in users {
 // SELECT * FROM "users"
 
 alice?.update(email <- replace(email, "mac.com", "me.com"))?
-// UPDATE "users" SET email = replace(email, "mac.com", "me.com") WHERE (id = 1)
+// UPDATE "users" SET "email" = replace("email", 'mac.com', 'me.com') WHERE ("id" = 1)
 
 alice?.delete()?
-// DELETE FROM "users" WHERE (id = 1)
+// DELETE FROM "users" WHERE ("id" = 1)
 
 users.count
 // SELECT count(*) FROM "users"

README.md

@@ -22,14 +22,14 @@ class QueryTests: XCTestCase {
     func test_select_withExpression_compilesSelectClause() {
         let query = users.select(email)
 
-        let SQL = "SELECT email FROM \"users\""
+        let SQL = "SELECT \"email\" FROM \"users\""
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
     func test_select_withVariadicExpressions_compilesSelectClause() {
         let query = users.select(email, count(*))
 
-        let SQL = "SELECT email, count(*) FROM \"users\""
+        let SQL = "SELECT \"email\", count(*) FROM \"users\""
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
@@ -43,7 +43,7 @@ class QueryTests: XCTestCase {
     func test_selectDistinct_withExpression_compilesSelectClause() {
         let query = users.select(distinct: age)
 
-        let SQL = "SELECT DISTINCT age FROM \"users\""
+        let SQL = "SELECT DISTINCT \"age\" FROM \"users\""
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
@@ -60,7 +60,7 @@ class QueryTests: XCTestCase {
         let query = users.join(managers, on: managers[id] == users[manager_id])
 
         let SQL = "SELECT * FROM \"users\" " +
-            "INNER JOIN \"users\" AS \"managers\" ON (\"managers\".id = \"users\".manager_id)"
+            "INNER JOIN \"users\" AS \"managers\" ON (\"managers\".\"id\" = \"users\".\"manager_id\")"
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
@@ -70,7 +70,7 @@ class QueryTests: XCTestCase {
         let query = users.join(.LeftOuter, managers, on: managers[id] == users[manager_id])
 
         let SQL = "SELECT * FROM \"users\" " +
-            "LEFT OUTER JOIN \"users\" AS \"managers\" ON (\"managers\".id = \"users\".manager_id)"
+            "LEFT OUTER JOIN \"users\" AS \"managers\" ON (\"managers\".\"id\" = \"users\".\"manager_id\")"
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
@@ -82,8 +82,8 @@ class QueryTests: XCTestCase {
 
         let SQL = "SELECT * FROM \"users\" " +
             "INNER JOIN \"users\" AS \"managers\" " +
-            "ON ((\"managers\".id = \"users\".manager_id) " +
-            "AND \"managers\".admin)"
+            "ON ((\"managers\".\"id\" = \"users\".\"manager_id\") " +
+            "AND \"managers\".\"admin\")"
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
@@ -96,8 +96,8 @@ class QueryTests: XCTestCase {
             .join(managed, on: managed[manager_id] == users[id])
 
         let SQL = "SELECT * FROM \"users\" " +
-            "INNER JOIN \"users\" AS \"managers\" ON (\"managers\".id = \"users\".manager_id) " +
-            "INNER JOIN \"users\" AS \"managed\" ON (\"managed\".manager_id = \"users\".id)"
+            "INNER JOIN \"users\" AS \"managers\" ON (\"managers\".\"id\" = \"users\".\"manager_id\") " +
+            "INNER JOIN \"users\" AS \"managed\" ON (\"managed\".\"manager_id\" = \"users\".\"id\")"
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in middleManagers {} }
     }
 
@@ -118,7 +118,7 @@ class QueryTests: XCTestCase {
     func test_filter_compilesWhereClause() {
         let query = users.filter(admin == true)
 
-        let SQL = "SELECT * FROM \"users\" WHERE (admin = 1)"
+        let SQL = "SELECT * FROM \"users\" WHERE (\"admin\" = 1)"
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
@@ -128,57 +128,57 @@ class QueryTests: XCTestCase {
             .filter(age >= 21)
 
         let SQL = "SELECT * FROM \"users\" " +
-            "WHERE ((email = '[email protected]') " +
-            "AND (age >= 21))"
+            "WHERE ((\"email\" = '[email protected]') " +
+            "AND (\"age\" >= 21))"
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
     func test_group_withSingleExpressionName_compilesGroupClause() {
         let query = users.group(age)
 
-        let SQL = "SELECT * FROM \"users\" GROUP BY age"
+        let SQL = "SELECT * FROM \"users\" GROUP BY \"age\""
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
     func test_group_withVariadicExpressionNames_compilesGroupClause() {
         let query = users.group(age, admin)
 
-        let SQL = "SELECT * FROM \"users\" GROUP BY age, admin"
+        let SQL = "SELECT * FROM \"users\" GROUP BY \"age\", \"admin\""
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
     func test_group_withExpressionNameAndHavingBindings_compilesGroupClause() {
         let query = users.group(age, having: age >= 30)
 
-        let SQL = "SELECT * FROM \"users\" GROUP BY age HAVING (age >= 30)"
+        let SQL = "SELECT * FROM \"users\" GROUP BY \"age\" HAVING (\"age\" >= 30)"
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
     func test_group_withExpressionNamesAndHavingBindings_compilesGroupClause() {
         let query = users.group([age, admin], having: age >= 30)
 
-        let SQL = "SELECT * FROM \"users\" GROUP BY age, admin HAVING (age >= 30)"
+        let SQL = "SELECT * FROM \"users\" GROUP BY \"age\", \"admin\" HAVING (\"age\" >= 30)"
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
     func test_order_withSingleExpressionName_compilesOrderClause() {
         let query = users.order(age)
 
-        let SQL = "SELECT * FROM \"users\" ORDER BY age"
+        let SQL = "SELECT * FROM \"users\" ORDER BY \"age\""
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
     func test_order_withVariadicExpressionNames_compilesOrderClause() {
         let query = users.order(age, email)
 
-        let SQL = "SELECT * FROM \"users\" ORDER BY age, email"
+        let SQL = "SELECT * FROM \"users\" ORDER BY \"age\", \"email\""
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
     func test_order_withExpressionAndSortDirection_compilesOrderClause() {
         let query = users.order(age.desc, email.asc)
 
-        let SQL = "SELECT * FROM \"users\" ORDER BY age DESC, email ASC"
+        let SQL = "SELECT * FROM \"users\" ORDER BY \"age\" DESC, \"email\" ASC"
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
@@ -223,19 +223,19 @@ class QueryTests: XCTestCase {
     }
 
     func test_subscript_withExpression_returnsNamespacedExpression() {
-        ExpectExecution(db, "SELECT \"users\".admin FROM \"users\"", users.select(users[admin]))
-        ExpectExecution(db, "SELECT \"users\".salary FROM \"users\"", users.select(users[salary]))
-        ExpectExecution(db, "SELECT \"users\".age FROM \"users\"", users.select(users[age]))
-        ExpectExecution(db, "SELECT \"users\".email FROM \"users\"", users.select(users[email]))
+        ExpectExecution(db, "SELECT \"users\".\"admin\" FROM \"users\"", users.select(users[admin]))
+        ExpectExecution(db, "SELECT \"users\".\"salary\" FROM \"users\"", users.select(users[salary]))
+        ExpectExecution(db, "SELECT \"users\".\"age\" FROM \"users\"", users.select(users[age]))
+        ExpectExecution(db, "SELECT \"users\".\"email\" FROM \"users\"", users.select(users[email]))
         ExpectExecution(db, "SELECT \"users\".* FROM \"users\"", users.select(users[*]))
     }
 
     func test_subscript_withAliasAndExpression_returnsAliasedExpression() {
         let managers = users.alias("managers")
-        ExpectExecution(db, "SELECT \"managers\".admin FROM \"users\" AS \"managers\"", managers.select(managers[admin]))
-        ExpectExecution(db, "SELECT \"managers\".salary FROM \"users\" AS \"managers\"", managers.select(managers[salary]))
-        ExpectExecution(db, "SELECT \"managers\".age FROM \"users\" AS \"managers\"", managers.select(managers[age]))
-        ExpectExecution(db, "SELECT \"managers\".email FROM \"users\" AS \"managers\"", managers.select(managers[email]))
+        ExpectExecution(db, "SELECT \"managers\".\"admin\" FROM \"users\" AS \"managers\"", managers.select(managers[admin]))
+        ExpectExecution(db, "SELECT \"managers\".\"salary\" FROM \"users\" AS \"managers\"", managers.select(managers[salary]))
+        ExpectExecution(db, "SELECT \"managers\".\"age\" FROM \"users\" AS \"managers\"", managers.select(managers[age]))
+        ExpectExecution(db, "SELECT \"managers\".\"email\" FROM \"users\" AS \"managers\"", managers.select(managers[email]))
         ExpectExecution(db, "SELECT \"managers\".* FROM \"users\" AS \"managers\"", managers.select(managers[*]))
     }
 
@@ -252,12 +252,12 @@ class QueryTests: XCTestCase {
             .order(users[email].desc)
             .limit(1, offset: 2)
 
-        let SQL = "SELECT \"users\".email, count(\"users\".email) FROM \"users\" " +
+        let SQL = "SELECT \"users\".\"email\", count(\"users\".\"email\") FROM \"users\" " +
             "LEFT OUTER JOIN \"users\" AS \"managers\" " +
-            "ON ((\"managers\".id = \"users\".manager_id) AND (\"managers\".admin = 1)) " +
-            "WHERE \"users\".age BETWEEN 21 AND 32 " +
-            "GROUP BY \"users\".age HAVING (count(\"users\".email) > 1) " +
-            "ORDER BY \"users\".email DESC " +
+            "ON ((\"managers\".\"id\" = \"users\".\"manager_id\") AND (\"managers\".\"admin\" = 1)) " +
+            "WHERE \"users\".\"age\" BETWEEN 21 AND 32 " +
+            "GROUP BY \"users\".\"age\" HAVING (count(\"users\".\"email\") > 1) " +
+            "ORDER BY \"users\".\"email\" DESC " +
             "LIMIT 1 " +
             "OFFSET 2"
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
@@ -283,7 +283,7 @@ class QueryTests: XCTestCase {
     }
 
     func test_insert_insertsRows() {
-        let SQL = "INSERT INTO \"users\" (email, age) VALUES ('[email protected]', 30)"
+        let SQL = "INSERT INTO \"users\" (\"email\", \"age\") VALUES ('[email protected]', 30)"
 
         ExpectExecutions(db, [SQL: 1]) { _ in
             XCTAssertEqual(1, self.users.insert(self.email <- "[email protected]", self.age <- 30).ID!)
@@ -293,15 +293,15 @@ class QueryTests: XCTestCase {
     }
 
     func test_insert_withQuery_insertsRows() {
-        db.execute("CREATE TABLE \"emails\" (email TEXT)")
+        db.execute("CREATE TABLE \"emails\" (\"email\" TEXT)")
         let emails = db["emails"]
         let admins = users.select(email).filter(admin == true)
 
-        ExpectExecution(db, "INSERT INTO \"emails\" SELECT email FROM \"users\" WHERE (admin = 1)", emails.insert(admins))
+        ExpectExecution(db, "INSERT INTO \"emails\" SELECT \"email\" FROM \"users\" WHERE (\"admin\" = 1)", emails.insert(admins))
     }
 
     func test_insert_insertsDefaultRow() {
-        db.execute("CREATE TABLE \"timestamps\" (id INTEGER PRIMARY KEY, timestamp TEXT DEFAULT CURRENT_DATETIME)")
+        db.execute("CREATE TABLE \"timestamps\" (\"id\" INTEGER PRIMARY KEY, \"timestamp\" TEXT DEFAULT CURRENT_DATETIME)")
         let table = db["timestamps"]
 
         ExpectExecutions(db, ["INSERT INTO \"timestamps\" DEFAULT VALUES": 1]) { _ in
@@ -310,7 +310,7 @@ class QueryTests: XCTestCase {
     }
 
     func test_replace_replaceRows() {
-        let SQL = "INSERT OR REPLACE INTO \"users\" (email, age) VALUES ('[email protected]', 30)"
+        let SQL = "INSERT OR REPLACE INTO \"users\" (\"email\", \"age\") VALUES ('[email protected]', 30)"
 
         ExpectExecutions(db, [SQL: 1]) { _ in
             XCTAssertEqual(1, self.users.replace(self.email <- "[email protected]", self.age <- 30).ID!)