PostgreSQL is an open source Relational Database Management System (RDBMS). In this article, I’ll provide an introduction to getting started with PostgreSQL. Here is what we’ll cover:

• Installation
• Administration
• Basic Database Operations

Installation

If you have homebrew installed on your system, you can run the command below on your terminal to quickly install PostgreSQL:

brew install postgresql

Others can download the latest version of PostgreSQL here and follow the installation steps.

Once downloaded, to verify you’ve got PostgreSQL installed, run the following command to check your PostgreSQL version:

postgres --version

Administration

PostgreSQL can be administered from the command line using the psql utility, by running the command below:

psql postgres

This should get your psql utility running. psql is PostgreSQL’s command line tool. While there are many third-party tools available for administering PostgreSQL databases, I haven’t felt the need to install any other tool yet. psql is pretty neat and works just fine.

To quit from the psql interface, you can type \q and you’re out.

If you need help, type \help on your psql terminal. This will list all the available help options. You can type in \help [Command Name], in case you need help with a particular command. For example, typing in \help UPDATE from within psql will show you the syntax of the update option.

Description: update rows of a table
[ WITH [ RECURSIVE ] with_query [, ...] ]
UPDATE [ ONLY ] table_name [ * ] [ [ AS ] alias ]
    SET { column_name = { expression | DEFAULT } |
          ( column_name [, ...] ) = ( { expression | DEFAULT } [, ...] ) |
          ( column_name [, ...] ) = ( sub-SELECT )
        } [, ...]
    [ FROM from_list ]
    [ WHERE condition | WHERE CURRENT OF cursor_name ]
    [ RETURNING * | output_expression [ [ AS ] output_name ] [, ...] ]

If you’re a beginner, you may still not understand. A quick Google search will provide you examples of its use or you can always search the official psql documentation which will provide many examples.

When you first install PostgreSQL, there are a few common administrative tasks that you’ll frequently perform.

The first thing would be to check for existing users and databases. Run the command below to list all databases:

\list or \l

In the figure above, you can see three default databases and a superuser akultomar that get created when you install PostgreSQL.

To list all users, use the \du command. The attributes of the user tell us that they’re a Superuser.

Basic Database Operations

To perform basic database operations, you use the Structured Query Language (commonly known as SQL).

Create a database

To create a database, you use the create database command. In the example below, we’ll create a database named riskzone.

If you forget the semicolon at the end, the = sign at the postgres prompt is replaced with a - as in the figure below. This is basically an indication that you need to terminate your query. You’ll understand it’s significance when you actually start writing longer queries. For now just put a semi-colon to complete the SQL statement and hit return.

Create a user

To create a user, you use the create user command. In the example below, we’ll create a user named no_one.

When you create a user, the message shown is CREATE ROLE. Users are roles with login rights. I have used them interchangeably. You’ll also notice that the Attributes column is empty for the user no_one. This means that the user no_one has no administrative permissions. They can only read data and cannot create another user or database.

You can set a password for your user. To a set password for an existing user, you need use the \password command below:

postgres=#\password no_one 

To set a password when a user is created, the command below can be used:

postgres=#create user no_two with login password 'qwerty';

Delete a user or database

The drop command can be used to delete a database or user, as in the commands below.

drop database <database_name>
drop user <user_name>

This command needs to be used very carefully. Things dropped don’t come back unless you have a backup in place.

If we run the \du and \l that we learned about earlier to display the list of users and databases respectively, we can see that our newly created no_one user and riskzone database.

When you specify psql postgres (without a username), it logs into the postgres database using the default superuser (akultomar in my case). To log into a database using a specific user, you can use the command below:

psql [database_name] [user_name]

Let’s login to the riskzone database with the no_one user. Hit \q to quit from the earlier postgres database and then run the command below to log into riskzone with the user no_one.

I hoped you like the short introduction to PostgreSQL. I’ll be writing another article to help you understand roles better. If you’re new to SQL, my advice would be to practice as much as you can. Get your hands dirty and create your own little tables and practice.

How to get started with PostgreSQL was originally published in We’ve moved to freeCodeCamp.org/news on Medium, where people are continuing the conversation by highlighting and responding to this story.

Dealing with timestamp to readable date conversion could be cumbersome sometimes. There are so many different objects available NSDate, Date, NSCalendar, Calendar, DateFormatter and the list goes on. Now, which one should I use 🤔? It gets confusing. So I wrote this little piece of code to help myself(you can help yourselves too) deal with greater issues at hand than converting timestamp to readable dates😐.

A quick summary of what the above code does. If the date is today then the output is in time format such as “2:07 AM”. Next, if the date is that of yesterday or tomorrow then it outputs “Yesterday” or “Tomorrow”, yeah, pretty obvious. Next, if the date falls in the current week, the output is in the day format such as “Wednesday”. Anything out of the current week you get a date such as “Jan 20, 2018”. You can check out the link below for all different formats for DateFormatter.

NSDateFormatter.com - Live Date Formatting Playground for Swift

Easy Timestamp to Readable Date Converter was originally published in Quick Code on Medium, where people are continuing the conversation by highlighting and responding to this story.

It is a common observation that users drop off a little on your login screen. This is how I tackle my facebook addiction💪 . This tutorial teaches you how to utilize Touch ID for a faster and easier login. I’ll take you through the steps soon, just let me brief you a little.

Most apps use Touch ID as a second degree authentication. This tutorial is NOT about providing a second degree authentication (although you can do that too if you read this article). It’s about using Touch ID to make that server call to login the user.

Now how do you get the user’s credentials from their thumb print to make that server call? 🤔 This is where Keychain service comes in. When the user signs up or logs into your app for the first time, save the credentials to your app’s keychain. Next time, when the user logs out and then visits the login screen again, flash a popup asking them to login using Touch ID. When the user provides a valid Touch ID, get those user credentials you saved earlier to the keychain, make your API call, and Boom!🤝.

So there are two steps involved here:

• First, you need to save the user’s credentials to the keychain. You can do this when the user signs up or when they log into your app for the first time.
• Second, use Touch ID to verify the user, then retrieve their credentials from the keychain service.

I’m using KeychainPasswordItem, a nice wrapper over Keychain available on developer.apple.com here. They have a very good, detailed example on how to use this generic keychain. Go have a look.

As part of the first step, use the call method below with the user’s email as account and password when the user signs up and logs in.

We are storing the user’s email to UserDefaults to be used later. It would be better if you flash a popup to ask the user’s permission to use this feature. I’m skipping that part for this tutorial😁.

Use Touch ID to access the keychain

To use Touch ID, you first need to add the LocalAuthentication framework to your project binaries. You can do this by going to Project > Build Phases > Link Binary With Libraries:

Next, import the LocalAuthentication framework in your login view controller.

import LocalAuthentication

We’ve filled our userName textfield with the user account email we saved earlier to UserDefaults.

Next, we need to check whether authentication is possible on the current device. Check out the following code:

We invoke authenticateUserUsingTouchId() in viewDidAppear(). LAContext is a subclass of NSObject, and represents our current authentication context. Now, if authentication is possible, validate Touch ID’s authenticity by calling evaluatePolicy()

context.evaluatePolicy() gives us the Touch ID popup with our last accessed user name, which we gave as our localizedReason in the evaluatePolicy() method.

This completes Part 1 of Step 2: getting the user to authenticate using Touch ID. Next up is using Touch ID to access the Keychain where we save or retrieve user credentials for login.

When the user provides a valid Touch ID, we need to load the password from the Keychain and make our POST call to login the user.

if authSuccessful {             self.loadPasswordFromKeychainAndAuthenticateUser(lastAccessedUserName)
}

That’s it! You can upgrade your authentication framework to support multiple accounts. After verifying Touch ID’s authenticity, flash a popup and ask the user to select the account they wish login. Then retrieve the user’s credentials corresponding to that account from the Keychain. Thanks for reading!

How to use Touch ID for a quicker, easier login to your app was originally published in We’ve moved to freeCodeCamp.org/news on Medium, where people are continuing the conversation by highlighting and responding to this story.