I decided to build the web service for my iOS and Android app using Perfect which is a Swift server implementation. I am using MySQL to host a database and wanted to a nice way to get the database tables written out as JSON. I had some problems but here is what I came up with:
My first attempt was to create a base class that I could subclass for each table type and do the read/write database operations and the JSON operations in the base class. But I ran into a lot of problems getting the base class to access the overridden properties and methods of the subclasses. Then I discovered this. Fist I create a simple protocol that all the record classes will use:
protocol DatabaseRecord : RequestHandler {
var sqlTableName: String {get}
var loaded: Bool {get set}
func loadRow(row: [String])
func getDictionary() -> [String : String]
func load(forName:String)
func load(forID:Int)
func getAll() -> [AnyObject]
init()
}
Then I create an extension to the protocol so all of this will get added to all of the classes that implement the DatabaseRecord protocol.
extension DatabaseRecord {
The methods here to load from the database don't seem like a big deal, but this just didn't work as a super class because despite all my google searching and efforts I couldn't get the base class to call the subclass methods or get the sqlTableName from the sub classes. But as an extension this jus works without any strange code.
func loadFromDatabase(query:String) {
var mysql = MySQLConnection.mysql;
MySQLConnection.connectToMySQL()
defer {
mysql.close()
}
if mysql.query(query) {
if let results = mysql.storeResults() {
if results.numRows() >= 1 {
if let row = results.next() {
loadRow(row)
return
}
}
}
}
}
func load(forName:String) {
self.loadFromDatabase("SELECT * FROM \(sqlTableName) WHERE name = \"\(forName)\"")
}
func load(forID:Int) {
self.loadFromDatabase("SELECT * FROM \(sqlTableName) WHERE id = \"\(forID)\"")
}
This next method was where I had the most problems. I tried using Self, dynamicType, and everything else I could think of to get the sqlTableName from the subclasses and got it going but the creating objects of my subclasses and adding them to an array that I would return seemed impossible. Now as an extension the sqlTableName just works, and I can create a new object of the correct class using self.dynamicType.init() and add it to the array.
func getAll() -> [AnyObject] {
var records = [AnyObject]()
var mysql = MySQLConnection.mysql;
MySQLConnection.connectToMySQL()
defer {
mysql.close()
}
if mysql.query("SELECT * FROM \(sqlTableName)") {
if let results = mysql.storeResults() {
results.forEachRow { row in
let obj = self.dynamicType.init()
obj.loadRow(row)
if let o = obj as? AnyObject {
records.append(o)
}
}
}
}
return records
}
PerfectLib has a JSON encoder but when I tried to use it, it would crash. It was late and the JSON that I need to generate was simple so I just quickly wrote this to create the JSON for my table:
func encodeAsJSON(dicts:Array<[String:String]>) -> String {
var str: String = "["
for dict in dicts {
var first = true
for (key, value) in dict {
if !first {
str.appendContentsOf(",")
} else {
first = false
}
str.appendContentsOf("{\"\(key)\":\"\(value)\"}")
}
}
str.appendContentsOf("]")
return str
}
Now I can add a request handler to the extension and now all my database record classes have a easy way to take a http get request and turn it into JSON array.
func handleRequest(request: WebRequest, response: WebResponse) {
let records = getAll()
var dicts = Array<[String:String]>()
for rec in records {
if let r = rec as? DatabaseRecord {
let dict = r.getDictionary()
dicts.append(dict)
}
}
response.appendBodyString(encodeAsJSON(dicts))
response.requestCompletedCallback()
}
}
So then I have a simple Swift class representing a SQL database record. For example:
/*
auto_make SQL table
+-------------+------------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------------+------------------+------+-----+---------+----------------+
| id | int(10) unsigned | NO | PRI | NULL | auto_increment |
| name | varchar(255) | YES | | NULL | |
+-------------+------------------+------+-----+---------+----------------+
*/
class AutoMakeRecord: DatabaseRecord {
var id: Int?
var name: String = ""
var loaded: Bool
var sqlTableName: String {
return "auto_make"
}
func loadRow(row: [String])
{
id = Int(row[0]) ?? -1
name = row[1]
loaded = true
}
func getDictionary() -> [String : String] {
var dict = [String: String]()
dict["id"] = String(id!)
dict["name"] = name
return dict
}
required init() {
loaded = false
}
}
Now a public method that registers the routes.
public func PerfectServerModuleInit() {
Routing.Handler.registerGlobally()
// Create Routes
Routing.Routes["/auto_make"] = { _ in return AutoMakeRecord() }
}
And it is easy to create additional classes for database tables and add them to the routes.
Of course I will want to create http handlers that will allow to more than just dump out tables to JSON, but this now gives me the base I need to create the rest of my web service.
Over the last few months we have visited several Florida beaches. First we went to Daytona Beach on the Atlantic coast, and loved it. It was the middle of November, yet the water temperatures were fine and I was surprised how nice it was for being so late in the year. Then we tried Clearwater Beach on the Gulf coast. We were surprised at how nice the sand was, but near the water it was more broken shells than sand and so not quite as nice as Daytona Beach. Also the waves at Daytona Beach were a lot more fun to play. At least so far, and it makes sense, the waves on the Atlantic beaches are much bigger than on the Gulf beaches.
My father was a scientist and was invited to go on a sabbatical to Antarctica with Dr. Wolf Vishniac to do research on detecting life on Mars. However he decided to go on a sabbatical to New England instead. 
I was a bit lazy this morning and took a little longer to do those things I do every morning before going to work, like feeding the chickens and the raven (yes. I have a friendly raven). So, after finally getting going on the bike you would think I would choose the fastest, easiest way to get to work to make up for leaving late, but no. You see, it was a perfect morning, cool temperatures, a blue sky, and no wind. So of course I decided to take the river route to work.
