So let’s start with a real database like SQLite.

SQLite is a file based DBRMS and can be used for e.g. web sites. The official docs say:

“SQLite works great as the database engine for most low to medium traffic websites (which is to say, most websites). [..] Generally speaking, any site that gets fewer than 100K hits/day should work fine with SQLite.”

Because Knight Industries is not Google, Amazon nor Facebook we can definitely use SQLite.

Creating and connecting to a database

In Python it is pretty easy to connect to a SQLite database:

from sqlite3 import connect 
db_connection = connect('knight_industries.db')

If the file knight_industries.db does not exist, it will be created automagically. A nice little feature of the sqlite3 library.

But be careful: If You already have a database file and you mess up the path in the connect statement you will wonder why you cannot access your data, because a new file is created silently.

cursor = db_connection.cursor()
cursor.execute('''CREATE TABLE operatives (id INTEGER, name TEXT, birthday DATE)''')
cursor.execute('''INSERT INTO operatives (id, name, birthday) \
                  VALUES (1, "Michael Arthur Long", "1949-01-09")''')

db_connection.commit()
cursor.execute('''SELECT * FROM operatives''')
print cursor.fetchone()
db_connection.close()

The post SQLite3: Python and SQL appeared first on Creatronix.

Motivation

Sometimes you need to retrieve data from a database without knowing the exact string to look up

so wildcards for the rescue

Underscore

Se_en represents a pattern with a wildcard character.

The _ means you can substitute any individual character here without breaking the pattern.

It matches exactly one character.

The names Seven and Se7en both match this pattern.

Percentage sign

The percentage sign % is another wildcard character that can be used with LIKE.

It matches one or more characters

The post SQL-LIKE and wildcards appeared first on Creatronix.

Devon asks us to keep track of our operations aka missions as well. For the first implementation let us assume that a mission has one operative and an operative can participate in multiple missions. that’s what we call an 1 to many relationship.

  +------------+                 +----------+
  |            |1   active in   n|          |
  | operative  +-----------------+ missions |
  |            |                 |          |
  +------------+                 +----------+

Missions have an id, a code name like “Phantom Liberty”, an operative id and a total cost.

To say that the operative id is equivalent to the id in the operative column we use the FOREIGN KEY constraint.

So let’s create the new table in our database:

CREATE TABLE ki_missions 
(id INTEGER, code_name TEXT, operative_id INTEGER, total_cost DECIMAL(15,2), PRIMARY KEY(id), FOREIGN KEY (operative_id) REFERENCES operatives(id));
INSERT INTO ki_missions VALUES (1, "Knight of the Phoenix", 1, 6246382.43);
INSERT INTO ki_missions VALUES (2, "Deadly Maneuvers", 1, 4568893.53);

Our first join

SELECT ki_missions.code_name, ki_operatives.name FROM ki_missions LEFT JOIN ki_operatives ON ki_missions.operative_id = ki_operatives.id;

More on joins https://dsin.files.wordpress.com/2013/03/sqljoins_cheatsheet.png

Next chapter: SQL-Functions – SQL-Basics 3

The post SQL-Basics: Relations appeared first on Creatronix.

Motivation

Let’s assume we work as a data scientist for Knight Industries.  We want to help the Foundation of Law and Government to keep track of our operatives.

We decide to use a classic relational database management system or RDBMS. In order to explore Database Management Systems we can either install one locally or we can use an online tool like SQLFiddle.

To interact with RDBMS we use SQL – the Structured Query Language.

As the name says SQL (speak either S-Q-L or Sequel) is used to write structured queries. Think of “conversations” when You think of “queries”.

So, let’s fire up SQLFiddle.

Creating the table

At first we have an empty database, so we create a table named operatives with the following columns: id, name and birthday

CREATE TABLE ki_operatives (id INTEGER, name TEXT, birthday DATE, PRIMARY KEY(id));

Type that into the left column of the SQLfiddle window and press “Build Scheme”.  Everything green? If not, please check for typos. Please also make sure that MySQL 5.6 is selected in the menu bar.

So we learned our first SQL statement: CREATE TABLE. It does exactly what its name suggest: creating a table in a database.

In SQL it does not matter if you write the statements in all lower or upper case, we could have written as well: “create table”, but as good practice let’s write SQL keywords always in all uppercase letters.

INTEGER, TEXT and DATE are built-in data types of SQL. PRIMARY KEY (id) tells the DBRMS that the id column is a special one: it may not contain duplicates and must always have a value assigned.

With that kind of unique identifier we can always reference an entry in a table.

To check if the table was created we can type

SHOW TABLES;

into the right column and press “Run SQL”.

All we have by now is an empty table. We can check that by typing the following statement into the right column as well and press “Run SQL” again.

SELECT * FROM ki_operatives;

The Output should read like “Record Count: 0;”

SELECT is SQLs way of getting data out of the database. The * means “all columns”, so you don’t need to know all the column names of a table beforehand.

Adding some data

As most important operative we add Michael Arthur Long to our operatives table:

INSERT INTO ki_operatives (id, name, birthday) VALUES (1, "Michael Arthur Long", "1949-01-09");

Good practice: Although You could insert the first record into the database without repeating the column names it is considered a good practice to state the names of the columns you want to insert your data into.

We add three more of our employees to the operatives table.

INSERT INTO ki_operatives (id, name, birthday)VALUES 
(2, "Devon Miles", "1942-07-12");
INSERT INTO ki_operatives (id, name, birthday)VALUES 
(3, "Dr. Bonnie Barstow", "1954-11-24");
INSERT INTO ki_operatives (id, name, birthday)VALUES 
(4, "Reginald Cornelius III", "1952-05-04");

Times they are a changing

Michael Arthur Long gets his new name: Michael Knight. We update his record in our database.

UPDATE ki_operatives SET name = "Michael Knight" WHERE id = 1;

The Update keyword does again exactly what its name suggests: updating a database record. With SET You select a specific column and the WHERE clause specifies the row of the table.

We want to keep track of the different occupations of our team members and add a new column to operatives table.

ALTER TABLE ki_operatives ADD COLUMN occupation TEXT;

With the ALTER TABLE clause we can add or delete columns or change the data type of a column as well.

Let’s update the occupation of all operatives:

UPDATE ki_operatives SET occupation = "Field Agent" WHERE id = 1; 
UPDATE ki_operatives SET occupation = "Head of Operations" WHERE id = 2; 
UPDATE ki_operatives SET occupation = "Technician" WHERE id = 3; 
UPDATE ki_operatives SET occupation = "Truck Driver" WHERE id = 4;

Bonnie left in 1983 to pursue her graduate studies. We remove her from our operatives database.

DELETE FROM ki_operatives WHERE id = 3;

DELETE is the clause for -you guessed it- deleting records from the database. Be careful: Don’t forget the WHERE clause or you delete all columns from the table at once!

Because FLAG needs a lead technician, we add April Curtis as Head of Design Team.

INSERT INTO ki_operatives VALUES (5, "April Curtis", "1952-05-04", "Senior Design Officer");

To evaluate each step of our implementation we can always run

SELECT * FROM operatives;

in the right window by clicking “Run SQL”

Today we learned

• creating a table
• inserting some data into it
• reading data from the table
• adding more columns
• deleting data

In the next article we will deal with the “relational” in the “relational database management system”.

For a relation we need at least to parties / tables that know each other.

Read the next chapter:  SQL-Basics: Relations

The post SQL-Basics: Create – Read – Update – Delete appeared first on Creatronix.

In our example we have two tables which contain almost the same information:

CREATE TABLE installed_device (`id` int, `device` text, `info` text);
INSERT INTO installed_device (`id`, `device`, `info`) VALUES (1, "Device_1", "Works!"), (2, "Device_2", "Doesn't work!");
CREATE TABLE device (`id` int, `device_name` text);
INSERT INTO device (`id`, `device_name`) VALUES  (1, "Device_1"), (2, "Device_2");

installed_device

device

The goal is to replace the values in installed_device’s device column with the id from table device:

UPDATE installed_device SET device = (SELECT id FROM device WHERE device.device_name = installed_device.device);

The Result

The post SQL-Basics – Subqueries: Update column with values from another column appeared first on Creatronix.