Verwenden Sie Swift 3.0, um die MySQL-Datenbank zu betreiben
- 高洛峰Original
- 2016-11-22 10:20:441851Durchsuche
Start
In diesem Tutorial verwenden wir das Ubuntu 16.04-System und MySQL 5.7. MySQL 5.7 führt eine Reihe neuer Funktionen ein. Eine davon besteht darin, die Möglichkeit zu bieten, JSON-Daten effizienter zu speichern und gleichzeitig das Innere von JSON-Daten abzufragen. Wenn MySQL 5.7 später die Standard-MySQL-Version unter Ubuntu 16.04 wird, werden wir Ubuntu 16.04 als unser Betriebssystem verwenden.
Wenn Sie Swift noch nicht installiert haben, können Sie es mit apt-get installieren. Installationsanweisungen finden Sie in diesem Artikel. Ende September 2016 begann Apple auch mit der Kompilierung von Swift-Images auf Ubuntu 16.04. Weitere Informationen finden Sie auf Swift.org.
Datenbank erstellen
Wir haben die Datenbank Swift_test genannt, der zugewiesene Benutzer ist Swift und das Passwort ist Swiftpass. Wenn Sie mit MySQL vertraut sind, sollten Sie wissen, dass Sie GRANT ALL ON ausführen müssen Swift_test.* für die Autorisierung.
Das Folgende ist der Befehl für diesen Teil:
# sudo mysql ... mysql> create user swift; Query OK, 0 rows affected (0.00 sec) mysql> create database swift_test; Query OK, 1 row affected (0.00 sec) mysql> grant all on swift_test.* to 'swift'@'localhost' identified by 'swiftpass'; Query OK, 0 rows affected, 1 warning (0.00 sec) mysql> flush privileges; Query OK, 0 rows affected (0.00 sec) mysql> quit Bye
Swift-Paket erstellen
Jetzt beginnen Sie mit der formalen Codierung, erstellen Sie zunächst ein Paket:
# mkdir swift_mysql # swift package init --type executable
Schreiben der .swift-Paketdatei:
import PackageDescription
let package = Package(
name: "swift_mysql",
dependencies:[
.Package(url:"https://github.com/vapor/mysql", majorVersion:1)
]
)Im zweiten Schritt verwenden wir einen Hilfstoolcode, um einige Zufallsdaten zu generieren und diese in die Datenbank einzutragen. Fügen Sie die Datei utils.swift im Verzeichnis „Sources“ hinzu und fügen Sie den folgenden Inhalt hinzu:
import Glibc
class Random {
static let initialize:Void = {
srandom(UInt32(time(nil)))
return ()
}()
}
func randomString(ofLength length:Int) -> String {
Random.initialize
let charactersString = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
let charactersArray:[Character] = Array(charactersString.characters)
var string = ""
for _ in 0..<length {
string.append(charactersArray[Int(random()) % charactersArray.count])
}
return string
}
func randomInt() -> Int {
Random.initialize
return Int(random() % 10000)
}Vapor MySQL
Als nächstes folgt der eigentliche Code. Unsere Datei main.swift verwendet das Modul Vapor MySQL .
Mit der Datenbank verbinden
Fügen Sie den folgenden Code zu Sources/main.swift hinzu:
import Glibc
import MySQL
var mysql:Database
do {
mysql = try Database(host:"localhost",
user:"swift",
password:"swiftpass",
database:"swift_test")
try mysql.execute("SELECT @@version")
} catch {
print("Unable to connect to MySQL: \(error)")
exit(-1)
}Der obige Code richtet die Datenbank ein und verarbeitet MySQL. Der Konstruktor Database(host:String, user:String, Password:String, Database:String) ist selbsterklärend.
Die Anweisung try mysql.execute("SELECT @@version") wird verwendet, um zu testen, ob die Verbindung korrekt und erfolgreich mit der Datenbank hergestellt ist. Wenn der Do-Code-Block fehlerfrei läuft, können Sie mit dem Betrieb der Datenbank beginnen!
Ganzzahlen und Strings
Alle Aufrufe an MySQL erfolgen über die Methodeexecute(_:String). Es ist zu beachten, dass sich diese Methode von einigen abstrakten API-Methoden wie .create(table:String, ...) oder .insert(table:String, ...) unterscheidet. „execute“ ruft die ursprüngliche SQL-Anweisung ab und übergibt sie an Der MySQL-Connector.
do {
try mysql.execute("DROP TABLE IF EXISTS foo")
try mysql.execute("CREATE TABLE foo (bar INT(4), baz VARCHAR(16))")
for i in 1...10 {
let int = randomInt()
let string = randomString(ofLength:16)
try mysql.execute("INSERT INTO foo VALUES (\(int), '\(string)')")
}
// Query
let results = try mysql.execute("SELECT * FROM foo")
for result in results {
if let bar = result["bar"]?.int,
let baz = result["baz"]?.string {
print("\(bar)\t\(baz)")
}
}
} catch {
print("Error: \(error)")
exit(-1)
}Das Abfrageergebnis verwendet ebenfalls die Methode „execute(_:String)“, aber das zurückgegebene Ergebnis ist ein [String:Node]-Wörterbuch. Der Schlüssel des Wörterbuchs entspricht dem Spaltennamen der Datenbank.
Node 类型是 Vapor 中的数据结构，用于转化为不同的类型。你可以从这里获取更多的信息。使用 Node 类型来表达 MySQL 可以方便的转换成对应的 Swift 类型。比如：let bar = result["bar"]?.int 给我们一个整型。
继续
接着我们来看一些更复杂的例子，比如创建一个表，包含了 MySQL 的 DATE， POINT 和 JSON 数据类型。我们的表名叫 samples。
do {
try mysql.execute("DROP TABLE IF EXISTS samples")
try mysql.execute("CREATE TABLE samples (id INT PRIMARY KEY AUTO_INCREMENT, created_at DATETIME, location POINT, reading JSON)")
// ... Date
// ... Point
// ... Sample
// ... Insert
// ... Query
} catch {
print("Error: \(error)")
exit(-1)
}要插入一个日期到数据库中，需要正确的 SQL 语句：
// ... Date let now = Date() let formatter = DateFormatter() formatter.dateFormat = "yyyy-MM-dd HH:mm:ss" // MySQL will accept this format let created_at = formatter.string(from:date)
接下来使用 Swift 元组来创建一个 POINT：
// ... Point let location = (37.20262, -112.98785) // latitude, longitude
最后，我们来处理 MySQL 5.7 中新的 JSON 数据类型，此外我们使用了 Jay 包来快速将一个 Swift 字典 [String:Any] 转换为 JSON 格式的字符串。
// ... Sample
let sample:[String:Any] = [
"heading":90,
"gps":[
"latitude":37.20262,
"longitude":-112.98785
],
"speed":82,
"temperature":200
]提示：你不需要显式在 Package.swift 中声明对 Jay 的依赖，因为在 MySQL 的包中已经包含了这个依赖。接下来我们把 JSON 数据转换为 String，用来拼凑 MySQL 语句。
let sampleData = try Jay(formatting:.minified).dataFromJson(any:sample) // [UInt8] let sampleJSON = String(data:Data(sampleData), encoding:.utf8)
这样我们就有了 date， point 和 JSON 字符串（sample) 了， 现在添加数据到 sample 表中：
// ... Insert let stmt = "INSERT INTO samples (created_at, location, sample) VALUES ('\(created_at)', POINT\(point), '\(sampleJSON)')" try mysql.execute(stmt)
请注意我们在处理 POINT 时候，使用了一些技巧。在对 (point) 展开为字符串 (37.20262, -112.98785) 后，完整的字符串是 POINT(37.20262, -112.98785)，这是 MySQL 所需要的数据，整个语句的字符串如下：
INSERT INTO samples (created_at, location, sample) VALUES ('2016-09-21 22:28:44', POINT(37.202620000000003, -112.98784999999999), '{"gps":{"latitude":37.20262,"longitude":-112.98785},"heading":90,"speed":82,"temperature":200}')获取结果
警告：在写这篇文章的时候(2016-09-22), Vapor MySQL 1.0.0 有一个 bug：在读取 POINT 数据类型时会 crash 掉，所以不得不在下面代码中加入 do 代码块，然后不使用 select 语句。我们在 Vapor MySQL 中记录了这个 issue，等这个 issue 修复以后，我们将更新文章。
在下面的例子中，我们将使用 MySQL 5.7 中引入对 JSON 数据内部的查询特性，使用 SELECT … WHERE 查询 JSON 数据。在这里查询的是 samples 表中 JSON 数据类型 sample中、speed 字段大于 80 的数据。
// ... 查询
let results = try mysql.execute("SELECT created_at,sample FROM samples where JSON_EXTRACT(sample, '$.speed') > 80")
for result in results {
if let sample = result["sample"]?.object,
let speed = sample["speed"]?.int,
let temperature = sample["temperature"]?.int,
let created_at = result["created_at"]?.string {
print("Time:\(created_at)\tSpeed:\(speed)\tTemperature:\(temperature)")
}
}这里做一些说明。JSON_EXTRACT 函数是用来 返回从 JSON 文档中的数据，根据传入的路径参数选择文档中满足条件的数据。在本例中，我们解包了列 sample 中的 speed 值。
为了循环处理结果，我们使用了 for result in results 语句，接着使用 if let 语句验证结果数据。首先使用 let sample = result["sample"]?.object 获取一个字典，对应 MySQL 中的 JSON 文档，这是一句关键的代码！Vapor MySQL 库并没有返回一个 String，而 String 还需进行 JSON 的解析。这个解析工作库已经帮你做了，所以你可以直接使用 sample 字典啦。
剩下的 let 语句给了我们 speed，temperature 和 created_at。注意 created_at 在 MySQL 中是 DATETIME 类型，我们读取它为字符串。为了在 Swift 中转换成 Date 类型，需要使用 .date(from:String) 方法加一个 DateFormatter 来做类型转换。
获取代码
如果你想直接运行代码，请到 github 上下载我们的代码。
在任何地方使用 swift build 进行编译，运行可执行代码，不要忘了你还需要拥有一个数据库，用户名并且授权通过。