Managing SQLite Database with SwiftyDB

Selecting a method for storing information completely is one thing that’s all the time wanted when growing purposes. There are numerous choices we will choose from: To create single information, to make use of CoreData or create a SQLite database. The final choice consists of some further trouble because the database should be created first, and all tables and fields to be already outlined earlier than an app makes use of them. Moreover, and from the programming standpoint, it’s not that straightforward to handle a SQLite database when information must be saved, up to date or retrieved.

These issues appear to vanish when utilizing a comparatively new library that was popped on the GitHub known as SwiftyDB. It’s a third-party library, which, because the creator says, is a plug-and-play element certainly. SwiftyDB reliefs builders from the trouble of making a SQLite database manually, and from defining all required tables and fields. That occurs robotically by the library utilizing the properties of the category (or courses) used as information fashions. In addition to that, all database operations are carried out below the hood, so builders can give attention to the implementation of the app logic solely. A easy but highly effective API makes it actually a bit of cake when coping with the database.

It’s mandatory to say although that you simply shouldn’t count on SwiftyDB to make miracles. It’s a dependable library that may do fairly nicely what it’s purported to do, however there are nonetheless some lacking options which might be in all probability meant to be added within the (close to or distant) future. Nevertheless, it’s nonetheless remaing a fantastic software that deserves some particular consideration, due to this fact on this tutorial we’ll undergo the fundamentals of SwiftyDB.

To your reference, you will discover its documentation right here, which you need to positively see after having gone by this textual content. In the event you have been all the time keen to work with SQLite databases however hesitated to take action, I consider that SwiftyDB is an efficient begin to do this.

With the above mentioned, let’s get going with the exploration of a brand new, fairly promising software.

In regards to the Demo App

In our put up at this time we’re going to create a very easy notice taking app able to doing all the essential operations one would count on:

  • Listing notes
  • Create new notes
  • Replace present notes
  • Delete notes

Apparently, SwiftyDB goes to take cost of managing the info into an SQLite database. All of the listed operations above are adequate to reveal the whole lot you want so can get began working with SwiftyDB simply.

To make it attainable for us to remain into the purpose, I’ve created a starter undertaking which you need to obtain and start with. While you get it, open it in Xcode and navigate round so that you get acquainted with it. As you’ll see, all the essential performance is there, with the many of the data-related options to be lacking. It could be nice in case you would additionally run the undertaking no less than as soon as, so that you see what’s all about.

The app is navigation primarily based, and within the first view controller there’s a tableview the place all notes are supposed to be listed.


By tapping on an present notice we’ll be capable of edit it and replace it, and when swiping to the left we’ll be capable of delete it:


Composing a brand new notice is feasible by tapping on the plus (+) button on the navigation bar. With a purpose to have a adequate working instance, right here’s a listing of actions that we will carry out when modifying a notice (new or present one):

  1. Set title and physique for the notice.
  2. Change the font title.
  3. Change the font measurement.
  4. Change the textual content colour.
  5. Import photographs to the notice.
  6. Transfer the pictures round and place them to a distinct place.

All values matching to the above operations will likely be saved to the database. To make it a bit extra clear for the final two components particularly, the precise photographs are going to be saved to the paperwork listing of the app, whereas we’re going to save simply the title and body for every picture to the database. However not simply that; moreover we’re going to create a brand new class for managing photographs (with the small print are coming later).


A final however essential element I’ve to say about is that although you’re downloading a starter undertaking to work on, by the top of the subsequent half you’ll be having a workspace. That’s as a result of we’ll use CocoaPods to obtain the SwiftyDB library, and some other dependencies that come alongside.

Please get going whenever you’re as much as it, however first, shut the starter undertaking in case you have already opened it in Xcode.

Putting in SwiftyDB

The very first thing we now have to do is to obtain the SwiftyDB library and use it in our undertaking. Merely getting the library information and including them to the undertaking isn’t going to work, so we now have to carry out the set up utilizing the CocoaPods dependency supervisor. The method is easy, and also you’ll be capable of do it very quickly in any respect, even in case you have by no means used CocoaPods earlier than. For you reference nonetheless, have a look to the earlier hyperlink.

Putting in CocoaPods

We’re going to start by putting in CocoaPods to our system. You probably have put in CocoaPods already please skip this step. If not then go forward and open Terminal. Sort the next command to put in CocoaPods:

Press Return, present your password and sit again whereas the obtain course of is happening. Don’t shut Terminal as soon as it’s completed, we’re nonetheless needing it.

Putting in SwiftyDB and Different Dependencies

Navigate to the folder the place the starter undertaking exists through the use of the cd command (nonetheless in Terminal):

It’s now time to create a Podfile that describes the library (or libraries) we wish to obtain to CocoaPods. The best method to do this is by typing the next command and let CocoaPods create one for us:

A brand new file named Podfile will likely be created to the undertaking folder. Open it utilizing a textual content editor (ideally not TextEdit), and modify it based on the subsequent snippet:


The road that can really do the entire job is the pod "SwiftyDB". CocoaPods will obtain SwiftyDB library and all of its dependencies through the use of that line, and it’ll create some new subfolders together with an Xcode workspace.

When you end modifying the file, save and shut it. Then, just be sure you’ve closed the starter undertaking on Xcode and return to Terminal. Sort the subsequent command:


Wait once more for a number of moments, and then you definitely’re able to go. As a substitute of opening the starter undertaking, open the NotesDB.xcworkspace on Xcode this time.


Starting With SwiftyDB – Our Mannequin

Contained in the NotesDB undertaking there’s a file known as Notice.swift, nevertheless it’s presently empty. That is our entry level at this time, as we’re going to create a few courses that can characterize a notice entity programmatically. In a extra theoretical stage, our upcoming work right here consists of the Mannequin half within the iOS MVC sample.

What we want initially is to import the SwiftyDB library, in order you guess go to the highest of the file and add this line:

Now, let’s declare our most essential class on this undertaking:

When working with SwiftyDB there are a number of however particular guidelines to observe, and within the above class header line you’ll be able to see two of them:

  1. A category with properties meant to be saved in a database utilizing SwiftyDB should be a subclass of the NSObject class.
  2. A category with properties meant to be saved in a database utilizing SwiftyDB should undertake the Storable protocol (it’s a SwiftyDB protocol).

Now we now have to think about the properties we wish to have on this class, and right here it comes once more a brand new rule from SwiftyDB: The datatypes of the properties should be any of these listed right here so as to have the ability to load whole Notice objects, as a substitute of straightforward information (array with dictionaries) when retrieving information from the database. If there are properties with “incompatible” datatypes, then we’ll need to take further actions so we convert them into the prompt ones (we’ll see that in particulars in only a whereas). By default, properties with such datatypes are merely ignored by SwiftyDB when it’s about time to avoid wasting to database, and no respective fields are created to the desk. Additionally, we’ll give particular remedy to some other properties within the class that we don’t actually wish to be saved to the database.

The final rule for now says {that a} class that conforms to the Storable protocol should essentially implement the init methodology:

Now that we now have all the information we want, let’s begin declaring the properties of our class. Not all for now, as a few of them require extra dialogue. Nevertheless, listed here are the fundamentals:

Useless to remark any of them, aside from the primary one. When that object will get initialised it can create a brand new database (named notes.sqlite) if it doesn’t exist and it’ll create a desk robotically. The desk fields will match to the properties having a correct datatype. However, if the database already exists, it can simply open.

As you may discover, the above properties describe a notice and all of the attributes we wish to save (title, textual content, textual content colour, font title and measurement, creation and modification dates), however there’s nothing there relating to the pictures {that a} notice can presumably have. Deliberately, we’re going to create a brand new class for photographs, the place we’ll retailer two properties solely: The body and the picture title.

So, nonetheless being within the Notice.swift file, create the next class above or beneath the prevailing one:

Notice that the body is represented as a NSData object on this class, and never as a CGRect. It’s essential to do it that method, so we will simply retailer that worth to the database later. You’ll see shortly how we’re going to deal with it, and also you’ll additionally perceive why we undertake the NSCoding protocol.

Again to the Notice class, let’s declare an ImageDescriptor array as proven subsequent:

There’s a limitation that now’s one of the best time to say about, and that’s the incontrovertible fact that SwiftyDB does not retailer collections to the database. In easy phrases, that signifies that our photographs array won’t ever be saved to the database, so we now have to determine find out how to cope with this. What we’re allowed to do is to make use of one of many supported datatypes (see the hyperlink I supplied a bit of after the start of this half), and essentially the most appropriate datatype is NSData. So, as a substitute of saving the photographs array to the database, we’ll be saving the next (new) property:

However how are we purported to go from the photographs array with ImageDescriptor objects to the imagesData NSData object? Nicely, the reply is by archiving the photographs array utilizing the NSKeyedArchiver class and producing that method a NSData object. We’ll see later how that is actually being executed in code, however now that we all know what we now have to do, we should return to the ImageDescriptor class and have some additions.

As you already know, a category may be archived (in different languages also referred to as serialized) if solely all of its properties may be serialised too, and in our case that is attainable, because the datatypes (NSData and String) of the 2 properties within the ImageDescriptor class are serialisable. Nevertheless that’s not sufficient, as we additionally need to encode and decode them with a purpose to efficiently archive and unarchive respectively, and that’s why we really want the NSCoding protocol. By utilizing it we’ll implement the strategies proven subsequent (one among them is an init methodology), and we’ll correctly encode and decode our two properties:

For extra details about the NSCoding protocol and the NSKeyedArchiver class have a look right here and right here, it’s pointless to debate extra about them right here and now.

Along with all of the above, let’s outline a fairly helpful customized init methodology. It’s actually easy, so no have to make any feedback:

At this level our first fast assembly with the SwiftyDB library involves its finish. Though we didn’t do a lot SwiftyDB stuff, this half was mandatory for 3 causes:

  1. To create a category that will likely be used from the SwiftyDB.
  2. To find out about some guidelines utilized when utilizing SwiftyDB.
  3. To see some essential limitations relating to the datatypes that may be saved within the database utilizing SwiftyDB.

Notice: In the event you’re seeing some errors proper now on Xcode, then construct the undertaking as soon as (Command-B) to do away with them.

Major Keys and Ignored Properties

It’s all the time advisable to make use of major keys when coping with databases, as such keys may also help you uniquely establish information within the database tables and carry out numerous operations through the use of them (for instance, replace a particular file). Yow will discover right here a great definition about what a major secret’s.

It’s straightforward to specify a number of properties of a category as the first key (or keys) for the respective desk within the database in SwiftyDB. The library offers the PrimaryKeys protocol, which ought to be applied by all courses that the respective tables ought to have a major key so their objects to be uniquely recognized. The best way to do this is kind of simple and commonplace, so let’s get into the purpose right away:

Within the NotesDB undertaking you’ll discover a file named Extensions.swift. Click on it on the Undertaking Navigator so that you open it. Add the next traces there:

In our demo, we would like the noteID property to be the one major key within the respective desk within the sqlite database. Nevertheless, if extra major keys are required, then you definitely simply have to jot down them within the row separated by comma (for instance, return ["key1", "key2", "key3"]).

In addition to that, not all properties of a category ought to all the time be saved to the database, and you need to explicitly order SwiftyDB to not embody them. For instance, within the Notice class we now have two properties that aren’t going to be saved to the database (both as a result of they can’t or we don’t need so): The photographs array and the database object. How will we explicitly exclude these two? By implementing one other protocol that the SwiftyDB library offers known as IgnoredProperties:

If there have been extra properties we wouldn’t wish to need to the database they need to be added above too. For instance, let’s say that we now have the next property:

… and that we don’t need it to be saved to the database. In that case, we must always add it to the IgnoredProperties protocol implementation too:

Notice: Import the MARKDOWN_HASH6211c316cc840902a4df44c828a26fbeMARKDOWN_HASH library to the MARKDOWN_HASH1dbda56f2122b1744ebf59bb64bbffdfMARKDOWN_HASH file in case you see any errors.

Saving a New Notice

Having executed the naked minimal implementation within the Notice class, it’s time to show to the functionalities of the demo app. We nonetheless haven’t added any strategies to our new class; we’ll achieve this by following the implementation movement of all of the lacking functionalities.

So, the very first thing we want is having notes, due to this fact the app should be informed find out how to save them correctly utilizing the SwiftyDB and our two new courses. That is going to happen principally within the EditNoteViewController class, so it’s about time to open the respective file utilizing the Undertaking Navigator. Earlier than we write the primary line of code right here, I contemplate fairly essential to spotlight the many of the properties discovered there:

  • imageViews: This array holds all of the picture view objects that comprise photographs added to a notice. Please don’t neglect that this array exists; it’ll turn into helpful shortly.
  • currentFontName: It holds the title of the presently utilized font to the textview.
  • currentFontSize: It’s the font measurement of the textual content within the textview.
  • editedNoteID: The noteID worth (major key) of a notice that’s about to be up to date. We’ll use it later.

Because the basic performance already exists within the starter undertaking, what we now have to do is to implement the lacking logic within the saveNote() methodology. We’ll start by doing two issues: First we received’t permit saving if there isn’t any textual content within the title or the physique of the notice. Second, we’ll dismiss the keyboard if it’s appeared by the point of saving:

We’ll proceed now by initializing a brand new Notice object, and by assigning the correct values to the right properties. The photographs want particular remedy, and we’ll do it proper after.

A couple of feedback now:

  • The noteID property expects any Int quantity that can work as the first key. You may create or generate any worth you need so long as it’s distinctive. On this case we set the integer half of the present timestamp as our major key, however usually this isn’t a good suggestion in actual world purposes because the timestamp comprises too many digits. Nevertheless for our demo software it’s simply wonderful, because it additionally consists of the simplest choice for having a singular int worth.
  • As we save a notice for first time, we set the present timestamp (expressed as a NSDate object) to each creation and modification date properties.
  • The one particular motion we positively need to take is to transform the textual content colour of the textview right into a NSData object. That is achieved by archiving the colour object utilizing the NSKeyedArchiver class.

Let’s give attention to find out how to save the pictures now. We’ll create a brand new methodology which will likely be fed with the picture views array. We’ll carry out two issues in it: We’ll save the precise picture of every picture view to the paperwork listing of the app, and we’ll create an ImageDescriptor object for each. Every such object will likely be appended to the photographs array.

With a purpose to create this new methodology we’re going to make a small detour, and to return to the Notice.swift file once more. Let’s see the implementation first, after which we’ll talk about about it.


pre lang=”swift”>
func storeNoteImagesFromImageViews(imageViews: [PanningImageView]) {
if imageViews.depend > 0 {
if photographs == nil {
photographs = ImageDescriptor
else {


Right here’s what’s happening within the above methodology:

  1. For starters we test if the photographs array is initialised or not. If it’s nil we initialise it, if not, we simply take away any present information from it. The second will turn into helpful later, after we’ll be updating an present notice.
  2. Then for every picture view we create a singular title for its picture. Every title will likely be much like this: “img_12345679_1”.
  3. We initialise a brand new ImageDescriptor object through the use of our customized init methodology and by offering the picture view body and the picture title as parameters. The toNSData() methodology has been applied as an extension of the CGRect and you will discover it within the Extensions.swift file. Its goal is to transform a body to a NSData object. As soon as the brand new ImageDescriptor object is prepared, it’s appended to the photographs array.
  4. We save the precise picture to the paperwork listing. The saveImage(_: withName:) class methodology may be discovered within the Helper.swift file, together with couple extra helpful class strategies.
  5. Lastly, when all picture views have been processed, we convert the photographs array to a NSData object by archiving it and we assign it to the imagesData property. The final line above is the precise motive that the NSCoding protocol and the implementation of its strategies are required within the ImageDescriptor class.

The else case above may appear reduntant, nevertheless it’s required. By default, the imagesData property is nil and it’ll stay like that if no photographs get added to the notice. Nevertheless, “nil” will not be acknowledged by SQLite. What SQLite understands is the equal of NSNull, and that’s what we offer transformed to a NSData object.

Again to the EditNoteViewController.swift file once more to make use of what we simply created:

Let’s return now to the Notice.swift file, and let’s implement the tactic that can carry out the precise saving to the database. There’s one thing essential you need to know at this level: SwiftyDB offers the choice to carry out any database-related operation synchronously or asynchronously. Which methodology you need to choose relies on the character of the app you construct. Nevertheless, I’d recommend to make use of the asynchronous methodology, as this received’t block the principle thread whereas a database operation is in progress, and it received’t have an effect on the consumer expertise by freezing (even immediately) the UI. However I’m saying once more, it’s completely as much as you.

We’ll use the asynchronous method to save our information in right here. As you’ll see, the respective SwiftyDB methodology comprises a closure that returns the results of the operation. You may learn particulars about that outcome object right here, and really I’m recommending to take action now.

Let’s implement now our new methodology so we will talk about extra about it:

It’s straightforward to know from the above implementation that we’re going to make use of the identical methodology for updating notes too. We be sure to set the shouldUpdate Bool worth as a parameter to the tactic upfront, after which relying on its worth the asyncDataObject(...) will both create a brand new file or it’ll replace an present one.

Moreover, you see that the second parameter in our methodology is a completion handler. We name it with the right parameter worth, relying on whether or not the saving is profitable or not. I’d recommend you to all the time use completion handlers when you’ve gotten duties working asynchronously on the background. That method, you’ll be capable of notify the caller strategies when the background activity has completed, and switch any attainable outcomes or information again.

What you see taking place above is what you’ll see taking place in different database-related strategies too. We’ll all the time be checking for an error within the outcome, and we’ll proceed accordingly relying on whether or not there’s any or not. Within the above case if there’s an error, we name our completion handler passing the false worth, which means that the saving was failed. If the alternative case, we cross true to point a profitable operation.

Again to the EditNoteViewController class as soon as once more, let’s get completed with the saveNote() methodology. We’ll name the one created proper above, and if the notice saving has been profitable we’ll simply pop the view controller. If there’s an error, then we’ll show a message.

Discover the shouldUpdate variable within the above implementation. It will get the right worth relying on whether or not the editedNoteID property is nil or not, which means whether or not the notice is being up to date or not.

At this level you’ll be able to run the app and attempt to save new notes. In the event you went step-by-step all alongside the way in which up so far, then you definitely’ll be capable of save your notes with none issues.

Loading and Itemizing Notes

With the creation and saving of latest notes being functioning, we will transfer on and make our app able to loading saved notes from the database. The loaded notes are supposed to be listed within the NoteListViewController class. Nevertheless, earlier than we begin working on this class, let’s create first a brand new methodology within the Notice.swift file for loading our information.

The SwiftyDB methodology that performs the precise loading is the asyncObjectsForType(...), and it really works asynchronously. The outcome will comprise both an error, or a group with notice objects (an array) loaded from the database. Within the first case, we name the completion handler passing the nil worth in order to point to the caller that there was an issue whereas loading the info. Within the second case, we cross the Notice objects to the completion handler so we will use them out of this methodology.

Let’s head to the NoteListViewController.swift file now. Initially, we should declare an array that can comprise Notice objects (these loaded from the database). It’s going to be the datasource of our tableview (clearly). So, on the high of the category add the next line:

In addition to that, initialize a brand new Notice object as nicely, so we will use the loadAllNotes(...) methodology we created earlier:

Time to jot down a very easy new methodology that can name the one above and cargo all saved objects from the database to the notes array:

Discover that in spite of everything notes get loaded we use the principle thread to reload the tableview. Previous to that in fact we maintain them to the notes array.

The above two strategies are all we want for getting the saved notes from the database. That easy! Don’t neglect although that the loadNotes() should be known as someplace, and it will occur within the viewDidLoad() methodology:

Loading the notes will not be sufficient, as we should use them as soon as they’re fetched. So, let’s begin updating the tableview strategies, beginning by the overall variety of rows:

Subsequent, let’s show some notice information to the tableview. To be particular, we’ll show the title, and the creation and modification dates for every notice:

In the event you run the app now, all notes that you’ve got created thus far will likely be listed to the tableview.

An Various Approach To Fetch Information

Only a bit earlier we used the asyncObjectsForType(...) methodology of the SwiftyDB library to load our notes from the database. This methodology returns an array of objects (in our case Notice objects) as you’ve seen, and I contemplate this to be fairly helpful. Nevertheless, it’s not all the time that helpful to retrieve objects from the database; there are circumstances the place fetching an array with the precise information values can be extra handy.

SwiftyDB may also help you on that, because it offers an alternate method for retrieving information. There’s a technique known as asyncDataForType(...) (or dataForType(...) if you wish to make synchronous operations), and it returns a colletion of dictionaries on this kind: [[String: SQLiteValue]] (the place SQLiteValue is any of the allowed datatypes).

Yow will discover extra right here and right here. I depart it for you as an train to complement the Notice class and cargo easy information as nicely, as a substitute of objects solely.

Updating A Notice

One of many options we would like our demo app to have is the potential to edit and replace an present notice. In different phrases, we have to current the EditNoteViewController with the small print of a notice that’s being chosen just by tapping to the respective cell, and retailer to the database its modified information as soon as it will get saved once more.

Beginning within the NoteListViewController.swift file, we want a brand new property for storing the ID of the chosen notice, so go to the highest of the category and add the next line:

Now, let’s implement the subsequent UITableViewDelegate methodology, the place we discover the noteID worth primarily based on the chosen row, after which we carry out the segue to point out the EditNoteViewController:

Within the prepareForSegue(...) methodology let’s cross the worth of the idOfNoteToEdit to the subsequent view controller:

The half job has been executed now. Earlier than we change to the EditNoteViewController class and proceed there, let’s make one other fast detour by paying a go to to the Notice class with a purpose to implement a easy new methodology that can retrieve only a single notice utilizing the ID worth that’s being given with. Right here’s the implementation:

The brand new factor right here is that for first time we use a filter with a purpose to apply limitations to the outcomes that will likely be returned. Utilizing the equal(...) class methodology of the Filter class is only a method to set the filter we would like. Don’t miss to go to this hyperlink to see extra methods for making use of filters when fetching information or objects from the database.

By utilizing the filter within the trend proven above, we really ask from SwiftyDB to load solely these information the place the noteID equals to the worth given as a parameter to the tactic. In fact, only one file will likely be returned as a result of we all know that this area is the first key and there’s no method to have multiple information with the identical key.

The discovered outcomes will likely be returned as an array of Notice objects, so it’s essential to get the primary (and solely) merchandise from that assortment. After that, we positively need to convert the picture information (if exists) to an array of ImageDescriptor objects, and assign it to the photographs property. That’s essential, as a result of if we skip it any photographs initially added to the loaded notice received’t be proven.

On the finish we name the completion handler based on whether or not the notice fetching was profitable or not. Within the first case we cross the fetched object to the completion handler so it may be utilized by the caller, whereas within the second case we simply cross nil as there’s no object.

Now we will head to the EditNoteViewController.swift file, and declare and initialize on the identical time a brand new Notice property to the category:

This object will likely be used firstly for calling the brand new methodology we applied above, after which to comprise the loaded information from the database.

We’re nearly to load the notice specified by the editedNoteID property utilizing the loadSingleNote(...) methodology. For our goal, we’re going to outline the viewWillAppear(_:) methodology, and in there we’ll develop our logic.

As you will note within the following code snippet, all values will likely be populated correctly as soon as the loadSingleNoteWithID(...) methodology returns the fetched notice by the completion handler. That signifies that we begin setting the notice title, physique, textual content colour, font, and so on, however not solely. If there are photographs included to the notice, we’ll be creating photographs views for each, utilizing in fact the frames specified within the ImageDescriptor objects.

Don’t miss that after having populated all values, we assign the notice to the editedNote object, so we will use it afterward.

There may be one final step required: To replace the saveNote() methodology, so when a notice is being up to date to keep away from creating a brand new Notice object, and to not set a brand new major key and creation date.

So, discover these three traces (contained in the saveNote() methodology):

… and exchange them with the next snippet:

The remaining a part of the tactic stays as is (no less than for now).

Updating the Notes Listing

In the event you examined the app up so far, then you definitely would have positively realized that the notes listing will not be up to date whenever you create a brand new notice or whenever you replace an present one. That’s cheap to occur as a result of the app isn’t able to that but, nonetheless on this half we’re about to repair this undesirable behaviour.

As you might guess, we’re going to use the Delegation sample to inform the NoteListViewController class about modifications made to notes within the EditNoteViewController. Our start line is to create a brand new protocol within the EditNoteViewController with two required strategies, these proven beneath:

In each circumstances we offer to the delegate strategies the ID worth of the brand new or edited notice. Now, go to EditNoteViewController class and add the next property:

Lastly, let’s revisit one final time the saveNote() methodology. At first find the subsequent line contained in the completion handler block:

Exchange that single line with the next bunch of code:

The right delegate operate will likely be known as each time {that a} new notice is created or an present one is being up to date to any extent further. However what we simply did consists of the half job solely. Let’s change to the NoteListViewController.swift file, and to begin with let’s undertake the brand new protocol to the header line of the category:

Subsequent, within the prepareForSegue(...) methodology let’s make this class the delegate of the EditNoteViewController. Proper beneath the let editNoteViewController = segue.destinationViewController as! EditNoteViewController line add the subsequent one as proven to this snippet:

Fairly good, because the many of the job has been executed. What we’re nonetheless lacking is the implementation of the 2 delegate strategies. First, let’s deal with the scenario the place a brand new notice has been created:

As you see, we simply fetch from the database the article specified by the noteID parameter worth, and (if exists) we append it to the notes array and reload the tableview.

Let’s see now the subsequent one:

On this case we first discover the index of the up to date notice within the notes assortment. As soon as that occurs, we load the up to date notice from the database and we exchange the previous object with the brand new one. By refreshing the tableview, the brand new modification date of the up to date notice will likely be proven immediately.

Deleting Data

The final main characteristic that’s nonetheless lacking from our demo app is the notice deletion. It’s straightforward to know that we want one final methodology applied within the Notice class that will likely be known as evey time we wish to delete a notice, so open the Notice.swift file.

The one new factor on this half is the SwiftyDB methodology that performs the precise deletion from the database, as you will note within the following implementation. Like earlier than, that is yet one more operation executed asynchronously, and we now have a completion handler to name as soon as the execution is over once more. Lastly, there’s a filter to specify the row that ought to be deleted from the database.

Let’s open the NoteListViewController.swift now, and let’s outline the subsequent UITableViewDataSource methodology:

By having added the above methodology to our code, every time you swipe in direction of left on a notice cell the default Delete button will seem to the correct facet. Furthermore, the code that will likely be executed when the Delete button is tapped is the one which will likely be outlined within the physique of the if assertion above. Let’s achieve this:

At first, we discover the right notice object matching to the chosen cell within the notes assortment. Subsequent, we name our new methodology within the Notice class to delete it, and if that operation is profitable we take away the Notice object from the notes array and reload the tableview so we replace the UI.

It was simply that!

And What About Sorting?

Probably you’re questioning how we will kind our information whereas fetching them from the database. Sorting is kind of helpful, as it may be primarily based on a number of fields, to be carried out in ascending or descending order and finally change the order of the returned information. For instance, we may kind our notes in a method that the newest modified notes seem to the highest.

Sadly, SwiftyDB doesn’t assist information sorting on the time of penning this tutorial. It is a drawback certainly, however there’s an answer: To manually kind the info whenever you want so. To reveal this, let’s create one final methodology within the NoteListViewController.swift file known as sortNotes(). On this one we’ll use the Swift’s default kind() operate:

Since NSDate objects can’t be in contrast immediately, we convert them to timestamp values (double values) first. Then we carry out the comparability and we return the outcome. The above code results in notice sorting the place the newest modified notes are within the first positions of the notes array.

The above methodology should be known as at any time when the notes array will get modified. First, let’s replace the loadNotes methodology as proven subsequent:

Then, we should do the identical to the 2 following delegate strategies:

By working the app once more now, you’ll see all notes listed on the tableview primarily based on their modification date.


Undoubtably, SwiftyDB is a superb software that can be utilized in quite a lot of purposes with out a lot effort. It’s actually quick and dependable to what’s made to do, and we will all agree that may cowl a number of wants when a database should be utilized in our apps. On this demo tutorial we went by the fundamentals of this library, however that is what you just about have to know. In fact, there’s all the time the official documentation you’ll be able to discuss with for additional help. In our instance at this time, and for the sake of the tutorial, we created a database with one desk solely matching to the Notice class. In real-world apps although, you’ll be able to have as many tables as you need, so long as you create the respective fashions in code (let’s say the respective courses). Personally, I might positively use SwiftyDB in my tasks, and as a matter of reality, I’m planning to take action. In any case, now you already know about it, you’ve seen the way it works and the way it may be used. It’s as much as you to resolve if that is yet one more software in your toolbox or not. Anyway, I hope the time you spent studying isn’t wasted, and also you’ve realized one other new factor, or two. And till our subsequent tutorial comes, have all an exquisite time!

To your reference, you’ll be able to obtain the total undertaking on GitHub.

Leave a Reply