Wednesday, December 7, 2022
HomeiOS DevelopmentManaging SQLite Database with SwiftyDB

Managing SQLite Database with SwiftyDB


Selecting a approach for storing information completely is one thing that’s all the time wanted when growing purposes. There are numerous choices we are able to decide from: To create single recordsdata, to make use of CoreData or create a SQLite database. The final possibility 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 perspective, 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 referred to as SwiftyDB. It’s a third-party library, which, because the creator says, is a plug-and-play part certainly. SwiftyDB reliefs builders from the trouble of making a SQLite database manually, and from defining all required tables and fields. That occurs routinely by the library utilizing the properties of the category (or lessons) used as information fashions. Moreover that, all database operations are carried out beneath 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 anticipate SwiftyDB to make miracles. It’s a dependable library that may do fairly properly what it’s alleged to do, however there are nonetheless some lacking options which might be most likely meant to be added within the (close to or distant) future. Nevertheless, it’s nonetheless remaing an excellent instrument that deserves some particular consideration, due to this fact on this tutorial we’ll undergo the fundamentals of SwiftyDB.

On your reference, yow will discover its documentation right here, which you must positively see after having gone by means of this textual content. If you happen to have been all the time prepared to work with SQLite databases however hesitated to take action, I consider that SwiftyDB is an effective begin to try this.

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

Concerning the Demo App

In our publish at present we’re going to create a extremely easy word taking app able to doing all the essential operations one would anticipate:

  • Record notes
  • Create new notes
  • Replace current notes
  • Delete notes

Apparently, SwiftyDB goes to take cost of managing the information into an SQLite database. All of the listed operations above are adequate to display all the things you want so can get began working with SwiftyDB simply.

To make it potential for us to remain into the purpose, I’ve created a starter venture which you must obtain and start with. If 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 will be nice in the event you would additionally run the venture 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.

t50_1_note_list

By tapping on an current word we’ll have the ability to edit it and replace it, and when swiping to the left we’ll have the ability to delete it:

t50_2_delete_note

Composing a brand new word is feasible by tapping on the plus (+) button on the navigation bar. So as to have a adequate working instance, right here’s a listing of actions that we are able to carry out when enhancing a word (new or current one):

  1. Set title and physique for the word.
  2. Change the font title.
  3. Change the font measurement.
  4. Change the textual content shade.
  5. Import photographs to the word.
  6. Transfer the photographs round and place them to a special place.

All values matching to the above operations will probably be saved to the database. To make it a bit extra clear for the final two elements 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 main points are coming later).

t50_3_edit_note

A final however essential element I’ve to say about is that regardless that you’re downloading a starter venture to work on, by the tip 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 if you’re as much as it, however first, shut the starter venture you probably 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 venture. Merely getting the library recordsdata and including them to the venture isn’t going to work, so we now have to carry out the set up utilizing the CocoaPods dependency supervisor. The method is straightforward, and also you’ll have the ability to do it very quickly in any respect, even you probably have by no means used CocoaPods earlier than. For you reference nevertheless, 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 going down. 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 venture exists by utilizing 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 simplest approach to try this is by typing the next command and let CocoaPods create one for us:

A brand new file named Podfile will probably be created to the venture folder. Open it utilizing a textual content editor (ideally not TextEdit), and modify it in accordance with the subsequent snippet:

t50_4_podfile

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

When you end enhancing the file, save and shut it. Then, just remember to’ve closed the starter venture on Xcode and return to Terminal. Sort the subsequent command:

t50_5_pod_install_2

Wait once more for a couple of moments, and you then’re able to go. As an alternative of opening the starter venture, open the NotesDB.xcworkspace on Xcode this time.

t50_6_folder_after_installation

Starting With SwiftyDB – Our Mannequin

Contained in the NotesDB venture there’s a file referred to as Notice.swift, nevertheless it’s at the moment empty. That is our entry level at present, as we’re going to create a few lessons that may symbolize a word entity programmatically. In a extra theoretical degree, our upcoming work right here consists of the Mannequin half within the iOS MVC sample.

What we’d like 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 venture:

When working with SwiftyDB there are a couple of however particular guidelines to comply with, and within the above class header line you possibly can 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 an alternative of easy information (array with dictionaries) when retrieving information from the database. If there are properties with “incompatible” datatypes, then we’ll should take further actions so we convert them into the recommended 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 technique:

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

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

As you may discover, the above properties describe a word and all of the attributes we wish to save (title, textual content, textual content shade, font title and measurement, creation and modification dates), however there’s nothing there concerning the photographs {that a} word can probably 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 present 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 approach, so we are able to 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 the most effective time to say about, and that’s the indisputable 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 methods to take care of this. What we’re allowed to do is to make use of one of many supported datatypes (see the hyperlink I offered somewhat after the start of this half), and essentially the most appropriate datatype is NSData. So, as an alternative of saving the photographs array to the database, we’ll be saving the next (new) property:

However how are we alleged 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 approach 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 understand, a category might be archived (in different languages often known as serialized) if solely all of its properties might be serialised too, and in our case that is potential, because the datatypes (NSData and String) of the 2 properties within the ImageDescriptor class are serialisable. Nevertheless that’s not sufficient, as we additionally should encode and decode them so as to efficiently archive and unarchive respectively, and that’s why we really need the NSCoding protocol. By utilizing it we’ll implement the strategies proven subsequent (one in every of them is an init technique), 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 useful customized init technique. 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 probably be used from the SwiftyDB.
  2. To find out about some guidelines utilized when utilizing SwiftyDB.
  3. To see some essential limitations concerning the datatypes that may be saved within the database utilizing SwiftyDB.

Notice: If you happen to’re seeing some errors proper now on Xcode, then construct the venture as soon as (Command-B) to eliminate them.

Major Keys and Ignored Properties

It’s all the time beneficial to make use of main keys when coping with databases, as such keys will help you uniquely determine information within the database tables and carry out varied operations by utilizing them (for instance, replace a particular document). You’ll find right here a great definition about what a main 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 supplies the PrimaryKeys protocol, which needs to be applied by all lessons that the respective tables ought to have a main key so their objects to be uniquely recognized. The way in which to try this is sort of simple and normal, so let’s get into the purpose right away:

Within the NotesDB venture 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 main key within the respective desk within the sqlite database. Nevertheless, if extra main keys are required, you then simply have to put in writing them within the row separated by comma (for instance, return ["key1", "key2", "key3"]).

Moreover that, not all properties of a category ought to all the time be saved to the database, and you must explicitly order SwiftyDB to not embrace 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 supplies referred to as IgnoredProperties:

If there have been extra properties we wouldn’t wish to should 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 the event 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 circulate of all of the lacking functionalities.

So, the very first thing we’d like is having notes, due to this fact the app should be informed methods to save them correctly utilizing the SwiftyDB and our two new lessons. 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 think about 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 word. Please don’t overlook that this array exists; it’ll grow to be useful shortly.
  • currentFontName: It holds the title of the at the moment utilized font to the textview.
  • currentFontSize: It’s the font measurement of the textual content within the textview.
  • editedNoteID: The noteID worth (main key) of a word that’s about to be up to date. We’ll use it later.

Because the basic performance already exists within the starter venture, what we now have to do is to implement the lacking logic within the saveNote() technique. We’ll start by doing two issues: First we gained’t permit saving if there isn’t any textual content within the title or the physique of the word. 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 best values to the correct properties. The pictures want particular remedy, and we’ll do it proper after.

A couple of feedback now:

  • The noteID property expects any Int quantity that may work as the first key. You’ll be able to 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 main key, however typically 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 high-quality, because it additionally consists of the best possibility for having a novel int worth.
  • As we save a word 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 should take is to transform the textual content shade 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 methods to save the photographs now. We’ll create a brand new technique which will probably 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 every one. Every such object will probably be appended to the photographs array.

So as to create this new technique 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 focus on about it.

<

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

}

Right here’s what’s going down within the above technique:

  1. For starters we examine if the photographs array is initialised or not. If it’s nil we initialise it, if not, we simply take away any current information from it. The second will grow to be helpful later, once we’ll be updating an current word.
  2. Then for every picture view we create a novel title for its picture. Every title will probably be much like this: “img_12345679_1”.
  3. We initialise a brand new ImageDescriptor object by utilizing our customized init technique and by offering the picture view body and the picture title as parameters. The toNSData() technique has been applied as an extension of the CGRect and yow will discover it within the Extensions.swift file. Its objective 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 technique might 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 cause that the NSCoding protocol and the implementation of its strategies are required within the ImageDescriptor class.

The else case above might sound 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 word. Nevertheless, “nil” just isn’t 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 may carry out the precise saving to the database. There’s one thing essential you must know at this level: SwiftyDB supplies the choice to carry out any database-related operation synchronously or asynchronously. Which technique you must choose is dependent upon the character of the app you construct. Nevertheless, I’d recommend to make use of the asynchronous technique, as this gained’t block the primary thread whereas a database operation is in progress, and it gained’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 technique to save our information in right here. As you’ll see, the respective SwiftyDB technique comprises a closure that returns the results of the operation. You’ll be able to learn particulars about that end result object right here, and really I’m recommending to take action now.

Let’s implement now our new technique so we are able to focus on extra about it:

It’s straightforward to know from the above implementation that we’re going to make use of the identical technique for updating notes too. We make sure that 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 document or it’ll replace an current one.

Moreover, you see that the second parameter in our technique is a completion handler. We name it with the correct 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 operating asynchronously on the background. That approach, you’ll have the ability to notify the caller strategies when the background process has completed, and switch any potential 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 end result, 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 other case, we go true to point a profitable operation.

Again to the EditNoteViewController class as soon as once more, let’s get completed with the saveNote() technique. We’ll name the one created proper above, and if the word 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 correct worth relying on whether or not the editedNoteID property is nil or not, which means whether or not the word is being up to date or not.

At this level you possibly can run the app and attempt to save new notes. If you happen to went step-by-step all alongside the way in which up up to now, you then’ll have the ability to save your notes with none issues.

Loading and Itemizing Notes

With the creation and saving of recent notes being functioning, we are able to 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 technique within the Notice.swift file for loading our information.

The SwiftyDB technique that performs the precise loading is the asyncObjectsForType(...), and it really works asynchronously. The end result will comprise both an error, or a group with word 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 information. Within the second case, we go the Notice objects to the completion handler so we are able to use them out of this technique.

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

Moreover that, initialize a brand new Notice object as properly, so we are able to use the loadAllNotes(...) technique we created earlier:

Time to put in writing a extremely easy new technique that may name the one above and cargo all saved objects from the database to the notes array:

Discover that in any case notes get loaded we use the primary thread to reload the tableview. Previous to that in fact we maintain them to the notes array.

The above two strategies are all we’d like for getting the saved notes from the database. That easy! Don’t overlook although that the loadNotes() should be referred to as someplace, and this may occur within the viewDidLoad() technique:

Loading the notes just isn’t sufficient, as we should use them as soon as they’re fetched. So, let’s begin updating the tableview strategies, beginning by the full variety of rows:

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

If you happen to run the app now, all notes that you’ve got created thus far will probably be listed to the tableview.

An Various Manner To Fetch Knowledge

Only a bit earlier we used the asyncObjectsForType(...) technique of the SwiftyDB library to load our notes from the database. This technique returns an array of objects (in our case Notice objects) as you’ve seen, and I think about this to be fairly useful. 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 will help you on that, because it supplies an alternate approach for retrieving information. There’s a way referred to as asyncDataForType(...) (or dataForType(...) if you wish to make synchronous operations), and it returns a colletion of dictionaries on this type: [[String: SQLiteValue]] (the place SQLiteValue is any of the allowed datatypes).

You’ll find extra right here and right here. I depart it for you as an train to complement the Notice class and cargo easy information as properly, as an alternative 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 current word. In different phrases, we have to current the EditNoteViewController with the main points of a word 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’d like a brand new property for storing the ID of the chosen word, so go to the highest of the category and add the next line:

Now, let’s implement the subsequent UITableViewDelegate technique, 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(...) technique let’s go the worth of the idOfNoteToEdit to the subsequent view controller:

The half job has been executed now. Earlier than we swap to the EditNoteViewController class and proceed there, let’s make one other fast detour by paying a go to to the Notice class so as to implement a easy new technique that may retrieve only a single word 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 so as to apply limitations to the outcomes that will probably be returned. Utilizing the equal(...) class technique of the Filter class is only a technique 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 document will probably be returned as a result of we all know that this discipline is the first key and there’s no technique to have a couple of information with the identical key.

The discovered outcomes will probably 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 should 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 word gained’t be proven.

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

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

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

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

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

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

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

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

… 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 Record

If you happen to examined the app up up to now, you then would have positively realized that the notes checklist just isn’t up to date if you create a brand new word or if you replace an current one. That’s cheap to occur as a result of the app isn’t able to that but, nevertheless 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 adjustments 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 word. Now, go to EditNoteViewController class and add the next property:

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

Exchange that single line with the next bunch of code:

The correct delegate operate will probably be referred to as each time {that a} new word is created or an current one is being up to date any more. However what we simply did consists of the half job solely. Let’s swap to the NoteListViewController.swift file, and to start with let’s undertake the brand new protocol to the header line of the category:

Subsequent, within the prepareForSegue(...) technique 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 word has been created:

As you see, we simply fetch from the database the thing 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 word within the notes assortment. As soon as that occurs, we load the up to date word 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 word will probably be proven immediately.

Deleting Data

The final main characteristic that’s nonetheless lacking from our demo app is the word deletion. It’s straightforward to know that we’d like one final technique applied within the Notice class that will probably be referred to as evey time we wish to delete a word, so open the Notice.swift file.

The one new factor on this half is the SwiftyDB technique that performs the precise deletion from the database, as you will notice within the following implementation. Like earlier than, that is another 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 needs to be deleted from the database.

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

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

At first, we discover the correct word object matching to the chosen cell within the notes assortment. Subsequent, we name our new technique 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?

Presumably you’re questioning how we are able to kind our information whereas fetching them from the database. Sorting is sort 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 approach that the latest modified notes seem to the highest.

Sadly, SwiftyDB doesn’t help information sorting on the time of penning this tutorial. This can be a drawback certainly, however there’s an answer: To manually kind the information if you want so. To display this, let’s create one final technique within the NoteListViewController.swift file referred to as sortNotes(). On this one we’ll use the Swift’s default kind() operate:

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

The above technique should be referred to as every time the notes array will get modified. First, let’s replace the loadNotes technique as proven subsequent:

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

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

Abstract

Undoubtably, SwiftyDB is a good instrument 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 are able to 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 means of 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 possibly can seek advice from for additional help. In our instance at present, 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 possibly can have as many tables as you need, so long as you create the respective fashions in code (let’s say the respective lessons). Personally, I’d positively use SwiftyDB in my tasks, and as a matter of reality, I’m planning to take action. In any case, now you understand 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 another instrument 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!

On your reference, you possibly can obtain the complete venture on GitHub.



RELATED ARTICLES

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Most Popular

Recent Comments