diff --git a/SQLiteSwift.xcodeproj/project.pbxproj b/SQLiteSwift.xcodeproj/project.pbxproj
index 1e34f75..b45c961 100644
--- a/SQLiteSwift.xcodeproj/project.pbxproj
+++ b/SQLiteSwift.xcodeproj/project.pbxproj
@@ -217,10 +217,12 @@
 					FF831B441C70E05400851CE6 = {
 						CreatedOnToolsVersion = 7.2.1;
 						DevelopmentTeam = 6JW63865Y3;
+						LastSwiftMigration = 0830;
 					};
 					FF831B4E1C70E05400851CE6 = {
 						CreatedOnToolsVersion = 7.2.1;
 						DevelopmentTeam = 6JW63865Y3;
+						LastSwiftMigration = 0830;
 					};
 				};
 			};
@@ -437,6 +439,7 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SKIP_INSTALL = YES;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 3.0;
 			};
 			name = Debug;
 		};
@@ -456,6 +459,7 @@
 				PRODUCT_BUNDLE_IDENTIFIER = com.yoshiyuki.SQLiteSwift;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SKIP_INSTALL = YES;
+				SWIFT_VERSION = 3.0;
 			};
 			name = Release;
 		};
@@ -466,6 +470,7 @@
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
 				PRODUCT_BUNDLE_IDENTIFIER = com.yoshiyuki.SQLiteSwiftTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_VERSION = 3.0;
 			};
 			name = Debug;
 		};
@@ -476,6 +481,7 @@
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
 				PRODUCT_BUNDLE_IDENTIFIER = com.yoshiyuki.SQLiteSwiftTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_VERSION = 3.0;
 			};
 			name = Release;
 		};
diff --git a/SQLiteSwift/SQLite.swift b/SQLiteSwift/SQLite.swift
index ea59562..0ff6063 100644
--- a/SQLiteSwift/SQLite.swift
+++ b/SQLiteSwift/SQLite.swift
@@ -10,10 +10,10 @@ import Foundation
 import FMDB
 
 class SQLite {
-    static private var conn: SQLite?
-    private let dbFilePath: String
-    private var _db:FMDatabase?
-    private var db: FMDatabase {
+    static fileprivate var conn: SQLite?
+    fileprivate let dbFilePath: String
+    fileprivate var _db:FMDatabase?
+    fileprivate var db: FMDatabase {
         get {
             if let tmpDb = _db {
                 return tmpDb
@@ -31,11 +31,11 @@ class SQLite {
     /// Create Table according to sql parameter
     /// - parameter sql: sql statement
     /// - returns: true on Success, false on Failure
-    func createTable(sql:String) -> Bool {
+    func createTable(_ sql:String) -> Bool {
         return executeUpdate(sql,nil)
     }
     
-    func deleteTable(tables:[String]) -> Bool {
+    func deleteTable(_ tables:[String]) -> Bool {
         let sql = "DROP TABLE IF EXISTS"
         var result:Bool = true
         tables.forEach{
@@ -46,19 +46,19 @@ class SQLite {
         return result
     }
     
-    func insert(sql:String,values:[AnyObject]!) -> Bool {
+    func insert(_ sql:String,values:[AnyObject]!) -> Bool {
         return executeUpdate(sql,values)
     }
     
-    func update(sql:String,values:[AnyObject]!) -> Bool {
+    func update(_ sql:String,values:[AnyObject]!) -> Bool {
         return executeUpdate(sql,values)
     }
     
-    func delete(sql:String,values:[AnyObject]!) -> Bool {
+    func delete(_ sql:String,values:[AnyObject]!) -> Bool {
         return executeUpdate(sql, values)
     }
     
-    private func executeUpdate(sql:String, _ values: [AnyObject]!) -> Bool{
+    fileprivate func executeUpdate(_ sql:String, _ values: [AnyObject]!) -> Bool{
         do {
             try db.executeUpdate(sql, values: values)
             if isOutput {
@@ -71,7 +71,7 @@ class SQLite {
         }
     }
     
-    private func executeQuery(sql:String, values:[AnyObject]!) -> FMResultSet? {
+    fileprivate func executeQuery(_ sql:String, values:[AnyObject]!) -> FMResultSet? {
         if isOutput {
             print("Query: \(sql)")
         }
@@ -79,25 +79,25 @@ class SQLite {
     }
     
     func beginTransaction(){
-        if !db.inTransaction() {
+        if !db.isInTransaction {
             db.open()
             db.beginTransaction()
         }
     }
     
     var inTransaction:Bool {
-        return db.inTransaction()
+        return db.isInTransaction
     }
     
     func commit() {
-        if db.inTransaction() {
+        if db.isInTransaction {
             db.commit()
             db.close()
         }
     }
     
     func rollback(){
-        if db.inTransaction() {
+        if db.isInTransaction {
             db.rollback()
         }
     }
@@ -105,25 +105,25 @@ class SQLite {
     /// Return whether DBFile is exist
     /// - returns: true on exist, false on not exist
     func isExistDBFile() -> Bool {
-        let fileManager: NSFileManager = NSFileManager.defaultManager()
-        return fileManager.fileExistsAtPath(self.dbFilePath)
+        let fileManager: FileManager = FileManager.default
+        return fileManager.fileExists(atPath: self.dbFilePath)
     }
     
     /// Return whether Tables are exist
     /// - parameter table names string array
     /// - returns: false & table array on not exist , true & blank array on all tables exist
-    func isExistTable(tables:[String]) -> (result:Bool,tables:[String]?) {
+    func isExistTable(_ tables:[String]) -> (result:Bool,tables:[String]?) {
         let sql = "SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name=?;"
         var rtnBl:Bool = true
         var noExistTables:[String] = []
         for table in tables {
-            let result = executeQuery(sql, values: [table])
+            let result = executeQuery(sql, values: [table as AnyObject])
             defer { result?.close() }
             guard let theResult = result else {
                 return (false,nil)
             }
             theResult.next()
-            if theResult.intForColumnIndex(0) == 0 {
+            if theResult.int(forColumnIndex: 0) == 0 {
                 rtnBl = false
                 noExistTables.append(table)
             }
@@ -131,7 +131,7 @@ class SQLite {
         return (!rtnBl && noExistTables.count>0) ? (false,noExistTables) : (rtnBl,nil)
     }
     
-    func select(sql:String,values:[AnyObject]!) -> [[String:AnyObject]] {
+    func select(_ sql:String,values:[AnyObject]!) -> [[String:AnyObject]] {
         let result = executeQuery(sql, values: values)
         defer { result?.close() }
         var rtn:[[String:AnyObject]] = []
@@ -140,11 +140,13 @@ class SQLite {
         }
         while  theResult.next() {
             var dict:[String:AnyObject] = [:]
-            for(key,value) in theResult.resultDictionary() {
-                let theKey = key as! String
-                dict[theKey] = value
+            if let resultDictionary = theResult.resultDictionary {
+                for(key,value) in resultDictionary {
+                    let theKey = key as! String
+                    dict[theKey] = value as AnyObject
+                }
+                rtn.append(dict)
             }
-            rtn.append(dict)
         }
         return rtn
     }
diff --git a/SQLiteSwift/SQLiteSwift.swift b/SQLiteSwift/SQLiteSwift.swift
index 4729e5b..8d2fafb 100644
--- a/SQLiteSwift/SQLiteSwift.swift
+++ b/SQLiteSwift/SQLiteSwift.swift
@@ -10,13 +10,13 @@ import Foundation
 
 public protocol SSMappable {
     static var table:String { get }
-    func dbMap(connector:SSConnector)
+    func dbMap(_ connector:SSConnector)
     init()
 }
 
-public class SQLiteConnection{
+open class SQLiteConnection{
     internal var conn: SQLite
-    public var isOutput:Bool {
+    open var isOutput:Bool {
         set{ conn.isOutput = newValue }
         get{ return conn.isOutput }
     }
@@ -27,30 +27,30 @@ public class SQLiteConnection{
         print("SQLiteConnection is deinit!!!")
     }
     
-    public func isExistTable<T:SSMappable>() -> SSResult<T> {
+    open func isExistTable<T:SSMappable>() -> SSResult<T> {
         return executeInTransaction{
             [unowned self] in
             return SSResult<T>(result: self.conn.isExistTable([T.table]).result)
         }
     }
     
-    public func createTable<T:SSMappable>() -> SSResult<T>{
+    open func createTable<T:SSMappable>() -> SSResult<T>{
         let model = T()
-        let connector = SSConnector(type: .Scan)
+        let connector = SSConnector(type: .scan)
         model.dbMap(connector)
         return executeInTransaction{
             [unowned self] in
             return SSResult<T>(result: self.conn.createTable(self.makeCreateStatement(connector, model: model)))
         }
     }
-    public func deleteTable<T:SSMappable>() -> SSResult<T> {
+    open func deleteTable<T:SSMappable>() -> SSResult<T> {
         return executeInTransaction{
             [unowned self] in
             return SSResult<T>(result:self.conn.deleteTable([T.table]))
         }
     }
     
-    private func executeInTransaction<T>(execute:()->T) -> T{
+    fileprivate func executeInTransaction<T>(_ execute:()->T) -> T{
         if !conn.inTransaction {
             conn.beginTransaction()
             defer {
@@ -61,8 +61,8 @@ public class SQLiteConnection{
         return execute()
     }
     
-    public func table<T:SSMappable>() -> SSTable<T>{
-        let connector = SSConnector(type: .Map)
+    open func table<T:SSMappable>() -> SSTable<T>{
+        let connector = SSConnector(type: .map)
         return executeInTransaction{
             [unowned self] in
             let table = SSTable<T>()
@@ -77,8 +77,8 @@ public class SQLiteConnection{
         }
     }
     
-    public func insert<T:SSMappable>(model:T) -> SSResult<T> {
-        let connector = SSConnector(type:.Scan)
+    open func insert<T:SSMappable>(_ model:T) -> SSResult<T> {
+        let connector = SSConnector(type:.scan)
         model.dbMap(connector)
         return executeInTransaction{
             [unowned self] in
@@ -86,8 +86,8 @@ public class SQLiteConnection{
         }
     }
     
-    public func update<T:SSMappable>(model:T) -> SSResult<T> {
-        let connector = SSConnector(type:.Scan)
+    open func update<T:SSMappable>(_ model:T) -> SSResult<T> {
+        let connector = SSConnector(type:.scan)
         model.dbMap(connector)
         guard let thePKey = getPrimaryKey(connector)?.value else{
             return SSResult<T>(result: false)
@@ -103,8 +103,8 @@ public class SQLiteConnection{
         }
     }
     
-    public func query<T:SSMappable>(query:String,params:[AnyObject]) -> SSTable<T>{
-        let connector = SSConnector(type: .Map)
+    open func query<T:SSMappable>(_ query:String,params:[AnyObject]) -> SSTable<T>{
+        let connector = SSConnector(type: .map)
         return executeInTransaction{
             [unowned self] in
             let table = SSTable<T>()
@@ -119,8 +119,8 @@ public class SQLiteConnection{
         }
     }
     
-    public func delete<T:SSMappable>(model:T) -> SSResult<T> {
-        let connector = SSConnector(type:.Scan)
+    open func delete<T:SSMappable>(_ model:T) -> SSResult<T> {
+        let connector = SSConnector(type:.scan)
         model.dbMap(connector)
         guard let theKey = getPrimaryKey(connector)?.value else{
             return SSResult<T>(result: false)
@@ -131,17 +131,17 @@ public class SQLiteConnection{
         }
     }
     
-    public func beginTransaction(){
+    open func beginTransaction(){
         conn.beginTransaction()
     }
-    public func commit(){
+    open func commit(){
         conn.commit()
     }
-    public func rollback(){
+    open func rollback(){
         conn.rollback()
     }
     
-    private func getPrimaryKey(connector:SSConnector) -> SSScan? {
+    fileprivate func getPrimaryKey(_ connector:SSConnector) -> SSScan? {
         for item in connector.scans{
             if item.isPrimaryKey && item.value != nil {
                 return item
@@ -150,49 +150,49 @@ public class SQLiteConnection{
         return nil
     }
     
-    private func makeUpdateStatement<T:SSMappable>(connector:SSConnector, model:T) -> String {
+    fileprivate func makeUpdateStatement<T:SSMappable>(_ connector:SSConnector, model:T) -> String {
         var columns = String.empty
         let scans = removePrimaryKey(connector)
         let count = scans.count
-        scans.enumerate().forEach{
-            let separator = count-1 == $0.index ? String.empty : ","+String.whiteSpace
+        scans.enumerated().forEach{
+            let separator = count-1 == $0.offset ? String.empty : ","+String.whiteSpace
             columns += "\($0.element.name)=?" + separator
         }
         let theKey = getPrimaryKey(connector)!
         return "UPDATE \(T.table) SET \(columns) WHERE \(theKey.name)=?;"
     }
     
-    private func makeCreateStatement<T:SSMappable>(connector:SSConnector,model:T) -> String {
+    fileprivate func makeCreateStatement<T:SSMappable>(_ connector:SSConnector,model:T) -> String {
         var columns:String = String.empty
-        connector.scans.enumerate().forEach{
-            let separator = (connector.scans.count-1) == $0.index ? String.empty : ","+String.whiteSpace
+        connector.scans.enumerated().forEach{
+            let separator = (connector.scans.count-1) == $0.offset ? String.empty : ","+String.whiteSpace
             columns += $0.element.createColumnStatement() + separator
         }
         return "CREATE TABLE \(T.table)(\(columns));"
     }
     
-    private func makeSelectAllStatement<T:SSMappable>(model:T) -> String {
+    fileprivate func makeSelectAllStatement<T:SSMappable>(_ model:T) -> String {
         return "SELECT * From \(T.table);"
     }
     
-    private func makeInsertStatement<T:SSMappable>(connector:SSConnector, model:T) -> String {
+    fileprivate func makeInsertStatement<T:SSMappable>(_ connector:SSConnector, model:T) -> String {
         var columns = String.empty
         let count = connector.scans.count{ $0.value != nil }
-        connector.scans.select{ $0.value != nil }.enumerate().forEach{
-            let separator = count-1 == $0.index ? String.empty : ","+String.whiteSpace
+        connector.scans.select{ $0.value != nil }.enumerated().forEach{
+            let separator = count-1 == $0.offset ? String.empty : ","+String.whiteSpace
             columns += $0.element.name + separator
         }
         return "INSERT INTO \(T.table)(\(columns)) VALUES(\(makePlaceholderStatement(count)));"
     }
     
-    private func makeDeleteStatement<T:SSMappable>(connector:SSConnector,model:T) -> String {
+    fileprivate func makeDeleteStatement<T:SSMappable>(_ connector:SSConnector,model:T) -> String {
         let theKey = getPrimaryKey(connector)!
         return "DELETE FROM \(T.table) WHERE \(theKey.name)=?;"
     }
     
-    private func getValues(connector:SSConnector) -> [AnyObject] {
+    fileprivate func getValues(_ connector:SSConnector) -> [AnyObject] {
         var values: [AnyObject] = []
-        connector.scans.enumerate().forEach{
+        connector.scans.enumerated().forEach{
             if let theValue = $0.element.value {
                 values.append(theValue)
             }
@@ -200,7 +200,7 @@ public class SQLiteConnection{
         return values
     }
     
-    private func getAllValue(connector:SSConnector) -> [AnyObject] {
+    fileprivate func getAllValue(_ connector:SSConnector) -> [AnyObject] {
         return removePrimaryKey(connector).map{
             if let theValue = $0.value {
                 return theValue
@@ -209,15 +209,15 @@ public class SQLiteConnection{
         }
     }
     
-    private func removePrimaryKey(connector:SSConnector) -> [SSScan] {
+    fileprivate func removePrimaryKey(_ connector:SSConnector) -> [SSScan] {
         var scans = connector.scans
-        for scan in scans.enumerate() {
-            if scan.element.isPrimaryKey { scans.removeAtIndex(scan.index) }
+        for scan in scans.enumerated() {
+            if scan.element.isPrimaryKey { scans.remove(at: scan.offset) }
         }
         return scans
     }
     
-    private func makePlaceholderStatement(count:Int) -> String {
+    fileprivate func makePlaceholderStatement(_ count:Int) -> String {
         var rtn = String.empty
         for i in 0..<count {
             rtn += "?"
@@ -230,27 +230,27 @@ public class SQLiteConnection{
     
     func scan<T:SSMappable>() -> (SSConnector,T){
         let model = T()
-        let connector = SSConnector(type: .Scan)
+        let connector = SSConnector(type: .scan)
         model.dbMap(connector)
         return (connector,model)
     }
     func mapping<T:SSMappable>() -> T{
         let model = T()
-        let connector = SSConnector(type: .Scan)
+        let connector = SSConnector(type: .scan)
         model.dbMap(connector)
         var values:[String:AnyObject] = [:]
-        for item in connector.scans.enumerate() {
+        for item in connector.scans.enumerated() {
             switch item.element.type! {
-            case .CL_Integer:
-                values[item.element.name] = 0
-            case .CL_Text:
-                values[item.element.name] = "sample\(item.index)"
+            case .cl_Integer:
+                values[item.element.name] = 0 as AnyObject
+            case .cl_Text:
+                values[item.element.name] = "sample\(item.offset)" as AnyObject
             default:
                 break
             }
         }
         connector.values = values
-        connector.type = .Map
+        connector.type = .map
         model.dbMap(connector)
         return model
     }
@@ -259,25 +259,25 @@ public class SQLiteConnection{
 /// Use for let work to column. e.g) scan column info, mapping value to column variables
 public protocol SSWorker{
     var value: AnyObject? { get set }
-    func work<T>(inout lhs:T?)
+    func work<T>(_ lhs:inout T?)
 }
 
-public class SSConnector {
+open class SSConnector {
     var values:[String:AnyObject?]=[:]
     var scans:[SSScan] = []
     var type:SSType
     public init(type:SSType){
         self.type = type
     }
-    public subscript (name:String,attrs:CLAttr...) -> SSWorker{
+    open subscript (name:String,attrs:CLAttr...) -> SSWorker{
         switch self.type {
-        case .Map:  // return map worker
+        case .map:  // return map worker
             let map = SSMap()
             if let theValue = values[name]{
                 map.value = theValue
             }
             return map
-        case .Scan: // return scan worker
+        case .scan: // return scan worker
             let scan = SSScan(name,attrs: attrs)
             scans.append(scan)
             return scan
@@ -286,54 +286,54 @@ public class SSConnector {
 }
 
 public enum SSType {
-    case Scan
-    case Map
+    case scan
+    case map
 }
 
 public enum CLType{
-    case CL_Integer
-    case CL_Text
-    case CL_Real
+    case cl_Integer
+    case cl_Text
+    case cl_Real
 //    case CL_BLOB
 }
 
 public enum CLAttr{
-    case PrimaryKey
-    case AutoIncrement
-    case NotNull
-    case Unique
-    case Default(AnyObject)
-    case Check(String)
+    case primaryKey
+    case autoIncrement
+    case notNull
+    case unique
+    case `default`(AnyObject)
+    case check(String)
 }
 
 public func == (lhs:CLAttr,rhs:CLAttr) -> Bool{
     switch (lhs,rhs) {
-    case (.PrimaryKey,.PrimaryKey):
+    case (.primaryKey,.primaryKey):
         return true
-    case (.AutoIncrement,.AutoIncrement):
+    case (.autoIncrement,.autoIncrement):
         return true
-    case (.NotNull,.NotNull):
+    case (.notNull,.notNull):
         return true
-    case (.Unique,.Unique):
+    case (.unique,.unique):
         return true
-    case (.Default,.Default):
+    case (.default,.default):
         return true
-    case (.Check,.Check):
+    case (.check,.check):
         return true
     default:
         return false
     }
 }
 
-infix operator <- {
-    precedence 20
-    associativity none
+precedencegroup WorkPrecedence {
+    associativity: none
 }
+infix operator <- : WorkPrecedence
 
-public func <- <T>(inout lhs:T?,rhs:SSWorker){
+public func <- <T>(lhs:inout T?,rhs:SSWorker){
     rhs.work(&lhs)
 }
-
+import Swift
 
 
 
diff --git a/SQLiteSwift/SSMap.swift b/SQLiteSwift/SSMap.swift
index fb47324..4648c27 100644
--- a/SQLiteSwift/SSMap.swift
+++ b/SQLiteSwift/SSMap.swift
@@ -8,9 +8,9 @@
 
 import Foundation
 
-public class SSMap: SSWorker{
-    public var value : AnyObject?
-    public func work<T>(inout lhs: T?){
+open class SSMap: SSWorker{
+    open var value : AnyObject?
+    open func work<T>(_ lhs: inout T?){
         
         guard let theValue = self.value else {
             return
@@ -20,11 +20,11 @@ public class SSMap: SSWorker{
            return
         }
         
-        if lhs.dynamicType == Optional<Bool>.self {
+        if type(of: lhs) == Optional<Bool>.self {
             let val = theValue as? Int
             lhs = (val != 0) as? T
-        }else if lhs.dynamicType == Optional<String>.self {
-            lhs = String(theValue) as? T
+        }else if type(of: lhs) == Optional<String>.self {
+            lhs = String(describing: theValue) as? T
         }else{
             lhs = self.value as? T
         }
diff --git a/SQLiteSwift/SSResult.swift b/SQLiteSwift/SSResult.swift
index d2f2dc9..ed7f47f 100644
--- a/SQLiteSwift/SSResult.swift
+++ b/SQLiteSwift/SSResult.swift
@@ -8,9 +8,9 @@
 
 import Foundation
 
-public class SSResult<T:SSMappable> {
-    public var result:Bool
+open class SSResult<T:SSMappable> {
+    open var result:Bool
     init(result:Bool){
         self.result = result
     }
-}
\ No newline at end of file
+}
diff --git a/SQLiteSwift/SSScan.swift b/SQLiteSwift/SSScan.swift
index 48ece7d..ce874d0 100644
--- a/SQLiteSwift/SSScan.swift
+++ b/SQLiteSwift/SSScan.swift
@@ -8,10 +8,10 @@
 
 import Foundation
 
-public class SSScan: SSWorker{
+open class SSScan: SSWorker{
     var attrs:[CLAttr]
     var type: CLType?
-    public var value:AnyObject?
+    open var value:AnyObject?
     var name:String
     init(_ name:String, attrs:[CLAttr]){
         self.name = name
@@ -20,61 +20,61 @@ public class SSScan: SSWorker{
     func createColumnStatement() -> String{
         var statement = name
         switch type! {
-        case .CL_Integer:
+        case .cl_Integer:
             statement += String.whiteSpace + "INTEGER"
-        case .CL_Text:
+        case .cl_Text:
             statement += String.whiteSpace + "TEXT"
-        case .CL_Real:
+        case .cl_Real:
             statement += String.whiteSpace + "REAL"
         }
         for item in attrs {
             switch item {
-            case .AutoIncrement:
+            case .autoIncrement:
                 statement += String.whiteSpace + "AUTOINCREMENT"
-            case .PrimaryKey:
+            case .primaryKey:
                 statement += String.whiteSpace + "PRIMARY KEY"
-            case .NotNull:
+            case .notNull:
                 statement += String.whiteSpace + "NOT NULL"
-            case .Unique:
+            case .unique:
                 statement += String.whiteSpace + "UNIQUE"
-            case .Default(let value):
+            case .default(let value):
                 statement += String.whiteSpace + "DEFAULT \(value)"
-            case .Check(let value):
+            case .check(let value):
                 statement += String.whiteSpace + "CHECK(\(value))"
             }
         }
         return statement
     }
     
-    public func work<T>(inout lhs: T?) {
-        if lhs.dynamicType == Optional<Int>.self {
-            self.type = CLType.CL_Integer
-            self.value = lhs as? AnyObject
+    open func work<T>(_ lhs: inout T?) {
+        if type(of: lhs) == Optional<Int>.self {
+            self.type = CLType.cl_Integer
+            self.value = lhs as AnyObject
         }
-        if lhs.dynamicType == Optional<Bool>.self {
-            self.type = CLType.CL_Integer
+        if type(of: lhs) == Optional<Bool>.self {
+            self.type = CLType.cl_Integer
             if let theLhs = lhs {
-                self.value = theLhs as! Bool ? 1 : 0
+                self.value = (theLhs as! Bool ? 1 : 0 ) as AnyObject
             }
             return
         }
         //Real
-        if lhs.dynamicType == Optional<Double>.self || lhs.dynamicType == Optional<Float>.self {
-            self.type = CLType.CL_Real
+        if type(of: lhs) == Optional<Double>.self || type(of: lhs) == Optional<Float>.self {
+            self.type = CLType.cl_Real
         }
         //Text
-        if lhs.dynamicType == Optional<String>.self {
-            self.type = CLType.CL_Text
+        if type(of: lhs) == Optional<String>.self {
+            self.type = CLType.cl_Text
         }
         
         if let theLhs = lhs {
-            self.value = theLhs as? AnyObject
+            self.value = theLhs as AnyObject
         }
     }
     
     var isPrimaryKey : Bool {
         for attr in self.attrs {
-            if attr == .PrimaryKey {
+            if attr == .primaryKey {
                 return true
             }
         }
diff --git a/SQLiteSwift/SSTable.swift b/SQLiteSwift/SSTable.swift
index a1d1ba1..d84dd98 100644
--- a/SQLiteSwift/SSTable.swift
+++ b/SQLiteSwift/SSTable.swift
@@ -8,6 +8,6 @@
 
 import Foundation
 
-public class SSTable<T:SSMappable> {
-    public var records:[T] = []
-}
\ No newline at end of file
+open class SSTable<T:SSMappable> {
+    open var records:[T] = []
+}
diff --git a/SQLiteSwift/SequenceTypeExtensions.swift b/SQLiteSwift/SequenceTypeExtensions.swift
index cdb9d0d..b82205e 100644
--- a/SQLiteSwift/SequenceTypeExtensions.swift
+++ b/SQLiteSwift/SequenceTypeExtensions.swift
@@ -8,8 +8,8 @@
 
 import Foundation
 
-extension SequenceType {
-    func count(judge:(Self.Generator.Element) -> Bool) -> Int {
+extension Sequence {
+    func count(_ judge:(Self.Iterator.Element) -> Bool) -> Int {
         var count = 0
         for item in self {
             if judge(item) { count += 1 }
@@ -17,18 +17,18 @@ extension SequenceType {
         return count
     }
     
-    func select(judge:(Self.Generator.Element) -> Bool) -> [Self.Generator.Element] {
-        var rtn:[Self.Generator.Element] = []
+    func select(_ judge:(Self.Iterator.Element) -> Bool) -> [Self.Iterator.Element] {
+        var rtn:[Self.Iterator.Element] = []
         for item in self{
             if judge(item) { rtn.append(item) }
         }
         return rtn
     }
     
-    func first(judge:(Self.Generator.Element) -> Bool) -> Self.Generator.Element? {
+    func first(_ judge:(Self.Iterator.Element) -> Bool) -> Self.Iterator.Element? {
         for item in self {
             if judge(item) { return item }
         }
         return nil
     }
-}
\ No newline at end of file
+}
diff --git a/SQLiteSwiftTests/SQLiteSwiftTests.swift b/SQLiteSwiftTests/SQLiteSwiftTests.swift
index 59c5fb0..c3cdb7a 100644
--- a/SQLiteSwiftTests/SQLiteSwiftTests.swift
+++ b/SQLiteSwiftTests/SQLiteSwiftTests.swift
@@ -11,14 +11,14 @@ import XCTest
 
 class SQLiteSwiftTests: XCTestCase {
     let dbFile:String = "sqliteswift.db"
-    let dir = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0]
-    private var dbFilePath: String {
+    let dir = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0]
+    fileprivate var dbFilePath: String {
         get{
             return self.dir + "/" + self.dbFile
         }
     }
     var _conn :SQLite?
-    private var conn: SQLite{
+    fileprivate var conn: SQLite{
         if _conn == nil {
             _conn = SQLite(self.dbFilePath)
             return _conn!
@@ -202,7 +202,7 @@ class SQLiteSwiftTests: XCTestCase {
         
         let users:[User] = [user,user2]
         
-        users.enumerate().forEach{
+        users.enumerated().forEach{
             let result:SSResult<User> = SQLiteConnection(filePath: dbFilePath).insert($0.element)
             XCTAssertTrue(result.result)
         }
@@ -264,7 +264,7 @@ class SQLiteSwiftTests: XCTestCase {
         
         let connection = SQLiteConnection(filePath: dbFilePath)
         connection.beginTransaction()
-        users.enumerate().forEach{
+        users.enumerated().forEach{
             let result:SSResult<User> = connection.insert($0.element)
             XCTAssertTrue(result.result)
         }
@@ -318,7 +318,7 @@ class SQLiteSwiftTests: XCTestCase {
     
     func testPerformanceExample() {
         // This is an example of a performance test case.
-        self.measureBlock {
+        self.measure {
             // Put the code you want to measure the time of here.
         }
     }
diff --git a/SQLiteSwiftTests/SQLiteTests.swift b/SQLiteSwiftTests/SQLiteTests.swift
index d0519de..a75b756 100644
--- a/SQLiteSwiftTests/SQLiteTests.swift
+++ b/SQLiteSwiftTests/SQLiteTests.swift
@@ -11,15 +11,15 @@ import XCTest
 
 class SQLiteTests: XCTestCase {
     let dbFile:String = "sqliteswift.db"
-    let dir = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0]
-    private var dbFilePath: String {
+    let dir = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0]
+    fileprivate var dbFilePath: String {
         get{
             return self.dir + "/" + self.dbFile
         }
     }
     
     var _conn :SQLite?
-    private var conn: SQLite{
+    fileprivate var conn: SQLite{
         if _conn == nil {
             _conn = SQLite(self.dbFilePath)
             return _conn!
@@ -77,7 +77,7 @@ class SQLiteTests: XCTestCase {
     
     func testPerformanceExample() {
         // This is an example of a performance test case.
-        self.measureBlock {
+        self.measure {
             // Put the code you want to measure the time of here.
         }
     }
diff --git a/SQLiteSwiftTests/User.swift b/SQLiteSwiftTests/User.swift
index 4df1a31..82acdeb 100644
--- a/SQLiteSwiftTests/User.swift
+++ b/SQLiteSwiftTests/User.swift
@@ -21,11 +21,11 @@ class User: SSMappable {
         
     }
     
-    func dbMap(connector:SSConnector){
+    func dbMap(_ connector:SSConnector){
         id       <- connector["id", .PrimaryKey, .AutoIncrement, .NotNull]
         name     <- connector["name", .Unique]
         age      <- connector["age", .Check("age>0")]
         nickname <- connector["nickname", .Default("None")]
         isMan    <- connector["isMan"]
     }
-}
\ No newline at end of file
+}