Buscar en moleculax
How To Install and Use PostgreSQL 9.4 on Debian 8


Introduction

Relational databases are the cornerstone of data organization for a multitude of needs. They power everything from online shopping to rocket launches. A database that is both venerable but very much still in the game is PostgreSQL. PostgreSQL follows most of the SQL standard, has ACID transactions, has support for foreign keys and views, and is still in active development.
If the application that you're running needs stability, package quality, and easy administration, Debian 8 (codename "Jessie") is one of the best candidates for a Linux distribution. It moves a bit more slowly than other "distros," but its stability and quality is well recognized. If your application or service needs a database, the combination of Debian 8 and PostgreSQL is one of the best in town.
In this article we will show you how to install PostgreSQL on a new Debian 8 Stable instance and get started.

Prerequisites

The first thing is to get a Debian 8 Stable system going. You can follow the instructions from the Initial Server Setup with Debian 8 article. This tutorial assumes you have aø Debian 8 Stable Droplet ready.
Except otherwise noted, all of the commands in this tutorial should be run as a non-root user with sudo privileges. To learn how to create users and grant them sudo privileges, check out Initial Server Setup with Debian 8.

Installing PostgreSQL

Before installing PostgreSQL, make sure that you have the latest information from the Debian repositories by updating the apt package list with:
    

  • sudo apt-get update

    •
You should see the package lists being updated and the following message:
Reading package lists... Done.
There are several packages that start with postgresql:
To install directly the postgresql-9.4 package:
    

  • sudo apt-get install postgresql-9.4 postgresql-client-9.4

    •
When asked, type Y to install the packages. If everything went fine, the packages are now downloaded from the repository and installed.

Checking the Installation

To check that the PostgreSQL server was correctly installed and is running, you can use the command ps:
# ps -ef | grep postgre
You should see something like this on the terminal:
postgres 32164     1  0 21:58 ?        00:00:00 /usr/lib/postgresql/9.4/bin/postgres -D /var/lib/   postgresql/9.4/main -c config_file=/etc/postgresql/9.4/main/postgresql.conf
postgres 32166 32164  0 21:58 ?        00:00:00 postgres: checkpointer process
postgres 32167 32164  0 21:58 ?        00:00:00 postgres: writer process
postgres 32168 32164  0 21:58 ?        00:00:00 postgres: wal writer process
postgres 32169 32164  0 21:58 ?        00:00:00 postgres: autovacuum launcher process
postgres 32170 32164  0 21:58 ?        00:00:00 postgres: stats collector process
Success! PostgreSQL has been successfully installed and is running.

Accessing the PostgreSQL Database

On Debian, PostgreSQL is installed with a default user and default database both called postgres. To connect to the database, first you need to switch to the postgres user by issuing the following command while logged in as root (this will not work with sudo access):
    

  • su - postgres

    •
You now should be logged as postgres. To start the PostgreSQL console, type psql:
    

  • psql

    •
Done! You should be logged on the PostgreSQL console. You should see the following prompt:
psql (9.4.2)
Type "help" for help.

postgres=#
To exit the psql console just use the command \q.

Creating New Roles

By default, Postgres uses a concept called "roles" to aid in authentication and authorization. These are, in some ways, similar to regular Unix-style accounts, but PostgreSQL does not distinguish between users and groups and instead prefers the more flexible term "role".
Upon installation PostgreSQL is set up to use "ident" authentication, meaning that it associates PostgreSQL roles with a matching Unix/Linux system account. If a PostgreSQL role exists, it can be signed in by logging into the associated Linux system account.
The installation procedure created a user account called postgres that is associated with the default Postgres role.
To create additional roles we can use the createuser command. Mind that this command should be issued as the user postgres, not inside the PostgreSQL console:
    

  • createuser --interactive

    •
This basically is an interactive shell script that calls the correct PostgreSQL commands to create a user to your specifications. It will ask you some questions: the name of the role, whether it should be a superuser, if the role should be able to create new databases, and if the role will be able to create new roles. Theman page has more information:
    

  • man createuser

    •

Creating a New Database

PostgreSQL is set up by default with authenticating roles that are requested by matching system accounts. (You can get more information about this at postgresql.org). It also comes with the assumption that a matching database will exist for the role to connect to. So if I have a user called test1, that role will attempt to connect to a database called test1 by default.
You can create the appropriate database by simply calling this command as the postgres user:
    

  • createdb test1

    •
The new database test1 now is created.

Connecting to PostgreSQL with the New User

Let's assume that you have a Linux account named test1, created a PostgreSQL test1 role to match it, and created the database test1. To change the user account in Linux to test1:
    

  • su - test1

    •
Then, connect to the test1 database as the test1 PostgreSQL role using the command:
    

  • psql

    •
Now you should see the PostgreSQL prompt with the newly created user test1 instead of postgres.

Creating and Deleting Tables

Now that you know how to connect to the PostgreSQL database system, we will start to go over how to complete some basic tasks.
First, let's create a table to store some data. Let's create a table that describes playground equipment.
The basic syntax for this command is something like this:
CREATE TABLE table_name (
    column_name1 col_type (field_length) column_constraints,
    column_name2 col_type (field_length),
    column_name3 col_type (field_length)
);
As you can see, we give the table a name, and then define the columns that we want, as well as the column type and the max length of the field data. We can also optionally add table constraints for each column.
You can learn more about how to create and manage tables in Postgres in the How To Create, Remove, & Manage Tables in PostgreSQL on a Cloud Server article.
For our purposes, we're going to create a simple table like this:
CREATE TABLE playground (
    equip_id serial PRIMARY KEY,
    type varchar (50) NOT NULL,
    color varchar (25) NOT NULL,
    location varchar(25) check (location in ('north', 'south', 'west', 'east', 'northeast', 'southeast', 'southwest', 'northwest')),
    install_date date
);
We have made a playground table that inventories the equipment that we have. This starts with an equipment ID, which is of the serial type. This data type is an auto-incrementing integer. We have given this column the constraint of primary key which means that the values must be unique and not null.
For two of our columns, we have not given a field length. This is because some column types don't require a set length because the length is implied by the type.
We then give columns for the equipment type and color, each of which cannot be empty. We then create a location column and create a constraint that requires the value to be one of eight possible values. The last column is a date column that records the date that we installed the equipment.
To see the tables, use the command \dt on the psql prompt. The result would be similar to
             List of relations
 Schema |    Name    | Type  |  Owner 
--------+------------+-------+----------
 public | playground | table | postgres
As you can see, we have our playground table.

Adding, Querying, and Deleting Data in a Table

Now that we have a table created, we can insert some data into it.
Let's add a slide and a swing. We do this by calling the table we're wanting to add to, naming the columns and then providing data for each column. Our slide and swing could be added like this:
INSERT INTO playground (type, color, location, install_date) VALUES ('slide', 'blue', 'south', '2014-04-28');
INSERT INTO playground (type, color, location, install_date) VALUES ('swing', 'yellow', 'northwest', '2010-08-16');
You should notice a few things. First, keep in mind that the column names should not be quoted, but the column values that you're entering do need quotes.
Another thing to keep in mind is that we do not enter a value for the equip_id column. This is because this is auto-generated whenever a new row in the table is created.
We can then get back the information we've added by typing:
SELECT * FROM playground;
The output should be
 equip_id | type  | color  | location  | install_date 
----------+-------+--------+-----------+--------------
        1 | slide | blue   | south     | 2014-04-28
        2 | swing | yellow | northwest | 2010-08-16
Here, you can see that our equip_id has been filled in successfully and that all of our other data has been organized correctly. If our slide breaks, and we remove it from the playground, we can also remove the row from our table by typing:
DELETE FROM playground WHERE type = 'slide';
If we query our table again:
SELECT * FROM playground;
We will see our slide is no longer a part of the table:
 equip_id | type  | color | location | install_date 
----------+-------+-------+----------+--------------
        1 | slide | blue  | south    | 2014-04-28

Useful Commands

Here are a few commands that can help you get an idea of your current environment:
  • \?: Get a full list of psql commands, including those not listed here.
  • \h: Get help on SQL commands. You can follow this with a specific command to get help with the syntax.
  • \q: Quit the psql program and exit to the Linux prompt.
  • \d: List available tables, views, and sequences in current database.
  • \du: List available roles
  • \dp: List access privileges
  • \dt: List tables
  • \l: List databases
  • \c: Connect to a different database. Follow this by the database name.
  • \password: Change the password for the username that follows.
  • \conninfo: Get information about the current database and connection.
With these commands you should be able to navigate the PostgreSQL databases, tables, and roles in no time.

Conclusion

You should now have a fully functional PostgreSQL database up and running on your Debian system. Congratulations! There is a plethora of documentation to go from here:
  • Installing the package postgresql-doc: sudo apt-get install postgresql-doc
  • README file installed at /usr/share/doc/postgresql-doc-9.4/tutorial/README
For a full list of supported SQL commands in PostgreSQL follow this link:
To compare the different functionalities of the databases you can check out:
For a better understanding of roles and permissions see:

.


Powered by

http://emiliogomez.com.ar