There are several new things :
- Integration with Windows Live (you can put your Live mail and it will connect)

- Metro interface (my WLM picture appeared a bit later)

- Ribbons in explorer (you can go to the usual interface using the Desktop button or Windows Explorer button on the previous screen)

- A neat task manager (you can go back to the metro interface with the windows button in the bottom left)

- IE 10

SQL Server

Size of database :

EXEC sp_spaceused

Size of all the tables > 10mo :

--Removes the procedure if it already exists
IF OBJECT_ID('dbo.GetSizeOfAllTables') IS NOT NULL
DROP PROCEDURE dbo.GetSizeOfAllTables
GO
--Gets the number of rows and size in MB of every table in the current database
CREATE PROCEDURE GetSizeOfAllTables
AS
DECLARE @TableName VARCHAR(100)

--Cursor storing all the user tables names
DECLARE tableCursor CURSOR
FOR
SELECT [name]
FROM dbo.sysobjects
WHERE  OBJECTPROPERTY(id, N'IsUserTable') = 1
FOR READ ONLY

--We create a temp table to hold the result of sp_spaceused
CREATE TABLE #TempTable
(
    tableName varchar(100),
    numberOfRows varchar(100),
    reservedSize varchar(50),
    dataSize varchar(50),
    indexSize varchar(50),
    unusedSize varchar(50)
)

OPEN tableCursor
--Get the first table name from the cursor
FETCH NEXT FROM tableCursor INTO @TableName
WHILE (@@Fetch_Status >= 0)
BEGIN
    --Dump the results of the sp_spaceused query to the temp table
    INSERT  #TempTable
        EXEC sp_spaceused @TableName

    FETCH NEXT FROM tableCursor INTO @TableName
END
CLOSE tableCursor
DEALLOCATE tableCursor

--Select all records and compute the data we want
SELECT * FROM
    (SELECT tableName, RTRIM(numberOfRows) as 'rows', ROUND((CONVERT(FLOAT, SUBSTRING(dataSize, 1, LEN(dataSize)-3)) + CONVERT(FLOAT, SUBSTRING(indexSize, 1, LEN(indexSize)-3)))/1024, 3) as 'Size'
    FROM #TempTable) T
WHERE Size > 10

--Clean up behind us
DROP TABLE #TempTable
GO
EXEC GetSizeOfAllTables

Current users

--Create a table to hold the data from sp_who
CREATE TABLE #temp
(
    spid varchar(100),
    ecid varchar(100),
    statuts varchar(100),
    loginame varchar(100),
    hostname varchar(50),
    blk varchar(50),
    dbname varchar(50),
    cmd varchar(50),
    requestID varchar(50),
);

INSERT INTO #temp EXEC sp_who

--Get the data we want
SELECT COUNT(*) AS cnt, loginame FROM #temp WHERE dbname = 'OnlyForTest' GROUP BY loginame ORDER BY cnt DESC;

--Clean up
DROP TABLE #temp

Current queries

SELECT COUNT(*) AS cnt, text FROM sys.dm_exec_requests
CROSS APPLY sys.dm_exec_sql_text(sql_handle) WHERE status='running' GROUP BY text ORDER BY cnt DESC;

Oracle

Size of the instance

SELECT sys_context('USERENV','DB_NAME'), SUM(bytes)/1024/1024 "Mb" FROM dba_data_files

Size of the tablespaces

SELECT b.tablespace_name, tbs_size SizeMB, a.free_space FreeMB
FROM  (SELECT tablespace_name, round(SUM(bytes)/1024/1024 ,2) AS free_space
FROM dba_free_space
GROUP BY tablespace_name) a,
(SELECT tablespace_name, SUM(bytes)/1024/1024 AS tbs_size
FROM dba_data_files
GROUP BY tablespace_name) b
WHERE a.tablespace_name(+)=b.tablespace_name

Size of the schemas (only the one above 10MB)

SELECT owner, (SUM(bytes)/1024/1024)
FROM dba_segments WHERE owner NOT IN ('SYS')
GROUP BY owner HAVING (SUM(bytes)/1024/1024) > 10

Size of the tables (only the one above 10MB)

SELECT owner, table_name, TRUNC(sum(bytes)/1024/1024) Meg
FROM
    (SELECT segment_name table_name, owner, bytes
    FROM dba_segments
    WHERE segment_type = 'TABLE'
    UNION ALL
    SELECT i.table_name, i.owner, s.bytes
    FROM dba_indexes i, dba_segments s
    WHERE s.segment_name = i.index_name
    AND   s.owner = i.owner
    AND   s.owner = i.owner
    AND   s.segment_type = 'INDEX'
    UNION ALL
    SELECT l.table_name, l.owner, s.bytes
    FROM dba_lobs l, dba_segments s
    WHERE s.segment_name = l.segment_name
    AND   s.owner = l.owner
    AND   s.segment_type = 'LOBSEGMENT'
    UNION ALL
    SELECT l.table_name, l.owner, s.bytes
    FROM dba_lobs l, dba_segments s
    WHERE s.segment_name = l.index_name
    AND   s.owner = l.owner
    AND   s.segment_type = 'LOBINDEX')
WHERE owner NOT IN ('SYS')
GROUP BY table_name, owner
HAVING SUM(bytes)/1024/1024 > 10
ORDER BY SUM(bytes) desc

Current users and queries

SELECT COUNT(*) AS cnt, a.username, b.sql_text
FROM v$session a, v$sqlarea b
WHERE sql_address=b.address
GROUP BY a.username, b.sql_text

First you need to set up DB2 drivers : you can get it here (Data Server Driver Package, NOT the ODBC) or here here (I used this one). You will need to create an account for both.
You can then untar the archive, select the good folder (odbc_cli_driver/linuxia32) and untar the archive present there, for example in /home/vincent/db2driver .

If you try to build and install ibm_db right now it will tell you to set up the DB2 environment so let’s do it.

vincent@ubuntu:~$ export IBM_DB_LIB=/home/vincent/db2driver/lib
vincent@ubuntu:~$ export IBM_DB_DIR=/home/vincent/db2driver

You should now be install to build install ibm_db :

vincent@ubuntu:~$ cd /home/Downloads/ibm_db/
vincent@ubuntu:~/home/Downloads/ibm_db/$ python setup.py build
vincent@ubuntu:~/home/Downloads/ibm_db/$ python setup.py install

Try to import it in python and you should get the following error :

vincent@ubuntu:/home/vincent/Downloads/ibm_db-1.0.4# python
Python 2.7.1+ (r271:86832, Apr 11 2011, 18:05:24)
[GCC 4.5.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import ibm_db
Traceback (most recent call last):
  File "", line 1, in
ImportError: libdb2.so.1: cannot open shared object file: No such file or directory

Huuum still not working…after a little googling I found how to resolve it in this issue .

You have to do the following :

vincent@ubuntu:~/Downloads/ibm_db-1.0.4$ sudo nano /etc/ld.so.conf.d/db2.conf
[sudo] password for vincent:
vincent@ubuntu:~/Downloads/ibm_db-1.0.4$ sudo ldconfig
vincent@ubuntu:~/Downloads/ibm_db-1.0.4$ python
Python 2.7.1+ (r271:86832, Apr 11 2011, 18:05:24)
[GCC 4.5.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import ibm_db
Traceback (most recent call last):
  File "", line 1, in
ImportError: libstdc++.so.5: cannot open shared object file: No such file or directory

Install the libstdc++5 package and voila!

vincent@ubuntu:~/Downloads/ibm_db-1.0.4$ sudo apt-get install libstdc++5
....
incent@ubuntu:~/Downloads/ibm_db-1.0.4$ python
Python 2.7.1+ (r271:86832, Apr 11 2011, 18:05:24)
[GCC 4.5.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import ibm_db
>>>

It should work now !

MySQL

Size of database :

SELECT LOCALTIMESTAMP, table_schema AS 'Name', ROUND( SUM( data_length + index_length ) /1024 /1024, 3 ) AS 'Size (MB)'
FROM information_schema.tables
WHERE table_schema = 'name_of_our_database'
GROUP BY table_schema

Size of all the tables :

SELECT LOCALTIMESTAMP, table_name, table_rows,
ROUND(data_length/1024/1024,2) + ROUND(index_length/1024/1024,2) FROM information_schema.tables
WHERE table_schema NOT IN ('information_schema','mysql')

Current users and queries

SELECT LOCALTIMESTAMP, COUNT(*) AS cnt, user, host, info
FROM INFORMATION_SCHEMA.PROCESSLIST GROUP BY user, info ORDER BY cnt DESC;

If you have the slow query (doc here) activated, it’s really worth getting the data from it.

PostgreSQL

Size of all the databases from the instance (we don’t use pg_size_pretty because we want all our reports to use the same unit and we exclude the basic databases)

SELECT localtimestamp, pg_database.datname, (pg_database_size(pg_database.datname)::float/1024/1024)::numeric(8,3)
FROM pg_database WHERE datname NOT IN ('template0','template1','postgres')

Size of the tablespaces (same thing as before)

SELECT localtimestamp, spcname, (pg_tablespace_size(oid)::float/1024/1024)::numeric(8,3)
FROM pg_tablespace WHERE spcname != 'pg_global';

Size of the tables (only the one above 10MB)

SELECT * FROM (
    SELECT localtimestamp, nspname || '.' || relname AS "table", reltuples,
    (pg_total_relation_size(C.oid)::float/1024/1024)::numeric(8,3) AS "size"
    FROM pg_class C LEFT JOIN pg_namespace N ON (N.oid = C.relnamespace)
    WHERE nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast') AND C.relkind <> 'i') T
WHERE size > 10

Current users and queries

SELECT localtimestamp, COUNT(*) AS cnt, usename, current_query
FROM pg_stat_activity GROUP BY usename,current_query ORDER BY cnt DESC;

To start, we need to install the necessary packages :

[root@oracletest database]# yum install binutils compat-libstdc++* elfutils* gcc gcc-c++ glibc* compat-glibc* ksh libaio* libstdc++* make sysstat unixODBC unixODBC-devel


We now need to create the users and groups :

[root@oracletest database]# groupadd oinstall
[root@oracletest database]# groupadd dba
[root@oracletest database]# useradd -g oinstall -G dba oracle
[root@oracletest database]# passwd oracle


Tune the kernel a bit :

[root@oracletest database]# nano /etc/sysctl.conf
//Then add these lines at the end of the file
kernel.shmall = 2097152
kernel.shmmax = 2147483648
kernel.shmmni = 4096
kernel.sem = 250 32000 100 128
fs.file-max = 6815744
fs.aio-max-nr = 1048576
net.ipv4.ip_local_port_range = 9000 65500
net.core.rmem_default = 4194304
net.core.rmem_max = 4194304
net.core.wmem_default = 262144
net.core.wmem_max = 1048576
//And validates it
[root@oracletest database]# /sbin/sysctl -p


Change the shell limits :

[root@oracletest database]# nano /etc/security/limits.conf
//Then add these lines at the end of the file
oracle soft nproc 2047
oracle hard nproc 16384
oracle soft nofile 1024
oracle hard nofile 65536

[root@oracletest database]# nano /etc/pam.d/login
//Then add this line at the end of the file
session required pam_limits.so


Modify the bash profile :

[root@oracletest ~]# nano /home/oracle/.bash_profile
//Then add these lines at the end of the file
ulimit -u 16384 -n 65536
umask 022
ORACLE_BASE=/u01/app; export ORACLE_BASE
ORACLE_SID=orcl; export ORACLE_SID
ORACLE_HOME=$ORACLE_BASE/product/11.2.0/db1 #depends on your directory
PATH=$ORACLE_HOME/bin:$PATH; export PATH


Create the directories :

[root@oracletest database]# mkdir -p /u01/app/
[root@oracletest database]# chown -R oracle.oinstall /u01


And for the X (you might have to open a new console for that to work):

[root@oracletest vincent]# xhost +


You can now su – oracle, run the ./runInstaller script and follows what the installer says (a couple of scripts to run at the end).
It might tell that you don’t have the necessary packages, but it somehow doesn’t recognize higher versions or 64bits versions of these one so you can safely continue.
You can now access EM on https://hostname:1518/em .

You can download the iso there http://www.centos.org/modules/tinycontent/index.php?id=30 in the 6 or 6.0 directory.

Once you load it on your server or VM, you will have to choose the media from which to install CentOS.
Choose URL and you now have 2 options : use one of your image in your network or use a CentOS mirror.

The CentOS mirrors URL are the following (choose the one according to your architecture) :

It will now retrieve the image and start the installation with the GUI.

I found after having spent some time on the script that pg_archivecleanup (http://developer.postgresql.org/pgdocs/postgres/pgarchivecleanup.html) existed, but our server is running PostgreSQL 8.3 and I had some library problems when compiling it as a standalone so I just finished my ksh script.
I delete all the files older than the most recent starting WAL file and log every deletion with the timestamp of file creation.

#!/bin/ksh

archive_directory=/home/vincent/postgres/archive #put your own directory obviously
backup_labels=$archive_directory/*.backup
files=$archive_directory/*
log_path=/home/vincent/logs/clean.log #a made-up directory, you get the idea

if [ ! -f $log_path ];then
	touch $log_path
	echo -e "Cleaning of WAL archives log\n\n" >> $log_path
fi

#Gets the last backup label created
latest_file_path=`ls -tr $backup_labels | tail -1`
#Gets the name of the start file
start_wal=$(echo `basename $latest_file_path` | cut -d'.' -f1)

current_time=`date +"%Y-%m-%d %H:%M"` 

echo -e "\nCleaning started at : ${current_time}" >> $log_path
echo -e "\tKeep WAL file ${start_wal} and later\n" >> $log_path

for file in $files
do
	if [ $file -ot $latest_file_path ]; then
		time=`ls -l $file | awk '{ print $6, $7 }'`
		rm $file
		echo "Removing file ${file} (created at ${time})" >> $log_path
	fi
done

echo -e "\n--------------------------------------------------" >> $log_path

I used xlrd as the API to read the excel files and the zipfile module to unzip.

My first thought was to parse each line and insert the whole file in a single really big INSERT. Needless to say it was really slow.
I then thought of converting the xls files to csv files and then use the LOAD INTO syntax from MySQL, which is quite fast (~3s for 30k lines).

I found a script doing close to what I wanted here so I took the core and tweaked it a bit : choose a sheet, a delimiter and remove unwanted characters.

For the example, let’s say we have 2 tables (table1 and table2) to load into (indentation are whitespace, not tab) :

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import xlrd
import csv
import MySQLdb
import os
import re
import zipfile

#Gets and formats the data from the sheet
def sheet_to_dictionary(excel_file, sheet_number):
   book = xlrd.open_workbook(excel_file)
   formatter = lambda(t,v): format_excel_value(book,t,v)
   raw_sheet = book.sheet_by_index(sheet_number)
   data = []

   for row in range(raw_sheet.nrows):
      (types, values) = (raw_sheet.row_types(row), raw_sheet.row_values(row))
      data.append(map(formatter, zip(types, values)))

   return ({ 'sheet_data': data })

#Format Excel date to isodate
def exceldate_to_isodate(datetuple):
   (y,m,d, hh,mm,ss) = datetuple
   nonzero = lambda n: n!=0
   date = "%04d-%02d-%02d" % (y,m,d) if filter(nonzero,(y,m,d)) else ''
   return date

#Clean the excel formatting
def format_excel_value(book, type, value):
   if type == 2: # NUMBER
      if value == int(value): value = int(value)
   elif type == 3: # DATE
      datetuple = xlrd.xldate_as_tuple(value, book.datemode)
      value = exceldate_to_isodate(datetuple)
   elif type == 5: # ERROR
      value = xlrd.error_text_from_code[value]
   elif type == 1 and '\n' in value: #There was some \n characters in my files that i needed to remove
      value = value.replace('\n',' ')
   return value

#UTF-8 the strings
def utf8ize(l):
   return [unicode(s).encode("utf-8") if hasattr(s,'encode') else s for s in l]

#Creates the CSV
def create_csv(table, file_path, delimit):
   file = open(file_path, 'wb')
   csvout = csv.writer(file, delimiter=delimit, doublequote=False, escapechar='\\')
   csvout.writerows(map(utf8ize, table))

#Load the table1 CSV into the table1 table
def load_table1(file_path):
   sql = """LOAD DATA LOCAL INFILE '%s'
   INTO TABLE table1 FIELDS TERMINATED BY ',' LINES TERMINATED BY '\n' IGNORE 1 LINES
   (col1, col2, col3)
   """ % (file_path)
   execute_sql(sql)

#Load the table2 CSV into the table2 table
def load_table2(file_path):
#Using ';' as a delimiter since there are ',' in the rows
   sql = """LOAD DATA LOCAL INFILE '%s'
   INTO TABLE table2 FIELDS TERMINATED BY ';' LINES TERMINATED BY '\n' IGNORE 1 LINES
   (col1, col2, col3)
   """ % (file_path)
   execute_sql(sql)

def execute_sql(sql):
   connection = MySQLdb.connect(host = "127.0.0.1", user = "root", passwd = "password", db = "test")
   cursor = connection.cursor()
   cursor.execute(sql)
   cursor.close
   connection.commit()
   connection.close

#Unzip the archive containing the excel files
re_zip = re.compile(r'(\.zip)$')
zip_filename = filter(re_zip.search, os.listdir(".")) #Using the script directory, but you could easily change that

#Should have only one zip file in the directory
z = zipfile.ZipFile(zip_filename[0])
names = z.namelist()
z.extractall()
z.close()

#Loads the xls data into the database and removes the files when we're done with them
for filename in names:
   if "table1" in filename:
      csv_name = 'table1.csv'
      table = sheet_to_dictionary(filename, 3)
      create_csv(table['sheet_data'], csv_name, ',')
      load_non_mandate(csv_name)
      os.remove(filename)
      os.remove(csv_name)
   if "table2" in filename:
      csv_name = 'table2.csv'
      table = sheet_to_dictionary(filename, 9)
      create_csv(table['sheet_data'], csv_name, ';') #There was some commas in the columns, preventing me to use a basic CSV
      load_time_reporting(csv_name)
      os.remove(filename)
      os.remove(csv_name)

os.remove(zip_filename[0])
#When the script is finished, data is loaded in the tables and all the files, including the zip are deleted, you could also
#archive them if you want

This part covers DDL (like creating table, adding constraints) and DML (insert/update/delete data).
Maybe I should have done it in first but anyway let’s begin.

Summary :

1. Using DDL Statements to Create and Manage Tables
2. Manipulating Data

Using DDL Statements to Create and Manage Tables

The main database objects :
The 047 certification will only represent the following objects :

• Table : the basic structure to stock data, organized in columns and rows
• Constraint : an element used on a table that will decide how the table will accept or reject data
• Index : an object that accelerates searches in a table : it copies and sorts only a small chunk of data that will be used when we lookup for data in this table
• Sequence : an object that generates unique numbers, typically used for primary key
• View : a virtual table created by filtering the data of a real table, used when we don’t need the whole table
• Synonym : an alias for a database object
• User : the database objects owner
• Role : one (or several) privilege(s) that can be granted to users

All these objects except users, roles and public synonyms are called schema objects. That means it belongs to a schema (collection of objects) and thus can be owned by a user.
The three left are non-schema objects : no user can own it.

List the data types that are available for columns :
Before creating a table, we can ask ourselves what kind of data types we can use in a column’s table.
Here is the list :

• CHAR(n) : stock a fixed-length alphanumerical value, n represents the length of the value. If the value is shorter than n, it will pad the value with blanks. n is optional : if not present, the database uses a value of 1
• VARCHAR2(n) : stock a variable-length alphanumerical value, n represents the maximal length of the value. If the value is shorter than n, it will not pad the value. n is mandatory and it needs a minimal value of 1.
• NUMBER(n,m) : stock numeric value (negative, 0, positive), n is the maximum number of digits in the value and m is the maximum number of digits of decimals. They are both optional (m default value is 0 though so the value will be rounded)
• DATE : stock dates in litterals (depending on the parameter NLS_DATE_FORMAT, generally DD-MON-RR like 10-APR-10) or using conversions functions previously seen.
• TIMESTAMP(n) : type of dates that stores up to the fractional seconds, n is optional and is the precision for fractional seconds (default 6)
• TIMESTAMP(n) WITH TIME ZONE : same as above but adds a time zone region name or an offset for time zone
• TIMESTAMP(n) WITH LOCAL TIME ZONE : same as above but the offset for time zone is retrieved from the user’s session and not stored in the column
• INTERVAL YEAR(n) TO MONTH : used to store a period of time in month or year value (like the difference between 2 dates) with n being optional and in 0-9
• INTERVAL DAY(n) TO SECOND (n) : same as above but the value is in seconds, minutes, hours and days with n being optional and in 0-9.
• BLOB : means Binary Large OBjects, used to store binary objects like video or pictures, it can’t be used as primary key or with DISTINCT, GROUP BY, ORDER BY and joins
• CLOB : means Character Large OBjects, same as above but used to store large texts
• NCLOB : same as above but used to store large texts in Unicode

Create a simple table :
Now we have seen the different data types, we can safely create tables.
For example how could we create the table used in the previous articles ?

    CREATE TABLE employees
    (
    id              NUMBER,
    first_name      VARCHAR2(30),
    last_name       VARCHAR2(40),
    monthly_salary  NUMBER
    );
    

As you can see, tables are created using the words CREATE TABLE followed by the desired name of the database and column’s names and their type (see previous paragraph) in parentheses.

A quick word on the names of database objects : it should have between 1 and 30 characters, the first one must be a letter, you can use letters, numbers, $ (dollar), _ (underscore) and # (pound) in it.
It also should not be one of the database reserved words.
The name isn’t case sensitive except if you use double quotes. If it’s the case, the name is case sensitive and you can also use some more special characters. The counterpart is you always have to use double quotes to reference this table so it’s not recommended to use it.
The name must also be unique in his namespace (same concept as programmation) : in a schema, constraints and indexes are in their own namespaces but tables, views, sequences and private synonyms are are in one namespace.
What does it mean? You can’t have 2 tables called employees in the same schema but one table called employees and an index also called employees in the same schema is ok.
To conclude this reflection, don’t forget to give meaningful and easy to read names.

Review the table structure
We’ve already seen that in a previous article so that’s going to be quick.
We can see the structure of a table using the DESCRIBE command :

    DESCRIBE employees;
    DESC employees;
    

DESC is a synonym for DESCRIBE.

Explain how constraints are created at the time of table creation
There are several constraints :

• NOT NULL : a column that has this constraint must have a value. If it doesn’t, the statement will fail
• UNIQUE : a column that has this constraint ensure that its value won’t be present in any other rows. You can use UNIQUE on a combination of columns
• PRIMARY KEY : identifier of rows in a table, it’s a combination of NOT NULL and UNIQUE. You can use a multi-column primary key : it’s called a composite primary key but you can have only one primary key per table
• FOREIGN KEY : a foreign key works with a primary key from another table, it’s a reference to it, to preserve data integrity
• CHECK : this constraint add a rule to a column following an expression (there is an example after)

There is no CREATE CONSTRAINT command, you have to add constraints for tables in a CREATE TABLE or ALTER TABLE command.

    -- out of line primary key constraint
    CREATE TABLE employees
    (
    id              NUMBER,
    first_name      VARCHAR2(30),
    last_name       VARCHAR2(40),
    monthly_salary  NUMBER,
    CONSTRAINT employees_pk PRIMARY KEY (id)
    );

     -- in line primary key constraint
    CREATE TABLE employees
    (
    id              NUMBER CONSTRAINT employees_pk PRIMARY KEY,
    first_name      VARCHAR2(30),
    last_name       VARCHAR2(40),
    monthly_salary  NUMBER
    );

     -- not null constraint : a value has to be provided in the monthly salary column
    CREATE TABLE employees
    (
    id              NUMBER,
    first_name      VARCHAR2(30),
    last_name       VARCHAR2(40),
    monthly_salary  NUMBER CHECK NOT NULL
    );

    -- check constraint : monthly salary must be between 0 et 5000
    CREATE TABLE employees
    (
    id              NUMBER,
    first_name      VARCHAR2(30),
    last_name       VARCHAR2(40),
    monthly_salary  NUMBER CHECK (monthly_salary IN (0, 5000))
    );

    --Add a primary key constraint on id (supposing we didn't add one before), in line
    ALTER TABLE employees
    MODIFY id CONSTRAINT employees_pk PRIMARY KEY;

    --same as above, out of line
    ALTER TABLE employees
    ADD CONSTRAINT employees_pk PRIMARY KEY (id);

    --Add a not null constraint
    ALTER TABLE employees
    MODIFY monthly_salary NOT NULL;
    

Note that the NOT NULL constraint can only be added with an in line method.

If you don’t provide a name to the constraint, the database will automatically assign one.

Manipulating Data

Describe each data manipulation language (DML) statement
There are five DML statements :

• SELECT : displays data from a table or a view
• INSERT : inserts data in a table
• UPDATE : modifies data in a table
• DELETE : removes data from a table
• MERGE : inserts or modifies data in a table depending on whether or not a condition matches

Insert rows into a table
INSERT is used to add rows in a table, for the example let’s add some rows in the table employees.

    INSERT INTO employees
    (id, first_name, last_name, monthly_salary)
    VALUES
    (1, 'Eric', 'Leyton', 2000);

    -- Or since the value matches the list of columns
    INSERT INTO employees
    VALUES
    (1, 'Eric', 'Leyton', 2000);
    

So which one should we use?
It’s the same answer than for SELECT *, if you modify the columns, for example switch the place of first_name and last_name, the statement will run successfully but the data won’t be correct.

Of course, INSERT statements have to respect the constraint on the table (PRIMARY KEY, NOT NULL, etc..).

How could we be sure that the id will be unique?

    --Create a sequence object
    CREATE SEQUENCE seq_employees_id;
    --Insert data using the sequence
    INSERT INTO employees
    (id, first_name, last_name, monthly_salary)
    VALUES
    (seq_employees_id.NEXTVAL, 'Eric', 'Leyton', 2000);
    

Update rows in a table
UPDATE is used to modify existing data in a table, identified with a WHERE clause if necessary.

    UPDATE employees
    SET first_name = 'Leyla',
        monthly_salary = 2200
    WHERE id = 1
    

The WHERE clause is very important : without it, all the rows of the table would be updated.

The UPDATE statement also have to respect the constraints.

Delete rows from a table
DELETE is used to delete existing data in a table, identified with a WHERE clause generally (except if you want to delete all the rows in a table).

    DELETE FROM employees
    WHERE id = 1
    

Control transactions
When we use DML, we generally also use TCL (Transaction Control Language).
TCL provides the functionality to save or rollback changes made to the database.
There are 3 TCL :

• COMMIT : saves changes to the database
• ROLLBACK : undoes changes to the last COMMIT or SAVEPOINT
• SAVEPOINT : allows to commit ot rollback at certain point

There are 2 types of COMMIT : explicit and implicit.

    -- Explicit commit
    COMMIT;
    -- Or COMMIT WORK; ANSI standard
    

Implicit commit occurs before and after any DDL (such as CREATE, ALTER, etc …) and when the user exits the application.
Before changes are committed, they’re only visible to the one that made the change and so other users could use obsolete data without knowing.

ROLLBACK removes changes made to the database up to the last COMMIT or SAVEPOINT.

    COMMIT;
    DELETE FROM employees;
    --Oops forgot the WHERE clause and deleted the whole table
    ROLLBACK;
    -- No problem the datas are back
    

SAVEPOINT allows to perform ROLLBACK at a point by naming a SCN (System Change Number).

    UPDATE employees SET monthly_salary = 2000
    SAVEPOINT sp_1;
    UPDATE employees SET monthly_salary = 3000
    SAVEPOINT sp_2;
    UPDATE employees SET monthly_salary = 30000
    --Oops
    ROLLBACK WORK TO sp_2;
    COMMIT;
    

RMAN (Recovery Manager) is the the backup and recovery tool recommended by Oracle.

There are several ways to create RMAN jobs : EM interface, command-line and scripts.Before the technical stuff, we should learn the backup vocabulary.

First of all, there is 2 types of backup : user-managed (using OS commands) and server-managed (using database tools like RMAN).

This article will only deal with backup of the second type.

There are 3 choices to make :

• closed (database is shutdown) or open (database is running, but needs to be in archivelog mode)
• whole (backup of all the datafiles and control files) or partial (only a part of it)
• full (backup of all the files) or incremental (backup of only the blocks that changed since the last backup)

RMAN can backup datafile, archive redo log, SPFILE and control file and offers 3 types of backup type : backup set (oracle format which needs to be restored before use), compressed backup set (same as backup set but compressed) and image copy (immediatly interchangeable with the source).

The backup and recovery operations are done using processes known as channels (disk or tape).

The RMAN repository contains metadata about the target database and its backup (name, location) and is stored in the controlfile of the target database.

Optionnaly, you can store it in a catalog database.

You can also use an auxiliary database, created from a backup from the target database.

Consistent backups

We can do that in command line or with EM.

EM 10g version : Maintenance > Schedule Backup > choose customized as backup strategy
EM 11g version : Availabilty > Schedule Backup > choose customized as backup strategy
Select Offline Backup and follow instructions

Command line version : create a script backup_full_offline.rman

run {
shutdown immediate;
startup mount;
allocate channel c1 type disk;
backup as backupset database
format 'd:\backup\offline_full_whole.bus';
alter database open;
}

and run it with :

 rman target sys/oracle@orcl11g @offline_full_whole.rman

Or run each command separately in the rman appli.

Open backups

This backup is of course also reliable (database must be in archivelog mode).
Same as before.
Example of a script :

run {
allocate channel c1 type disk; #2 channels for parallelisation
allocate channel c2 type disk;
backup
format '/home/oracle/%d_t%t_s%s_p%p' #d = database_id, s = backup set number, p = piece number
(database); #save everything including archivelog files
release channel c1;
release channel c2;
}

You can also assign a tag to a backupset (a logical name).

To check if the database can be restored, use:

 restore database validate

Incremental backups

Incremental backups relies on a first full backup of the database, known as level 0.

backup as backupset incremental level 0 database plus archivelog;

When the level 0 backup is done, we will perform level 1 backup that will backup only the block that have changed since the last level 0 backup.

backup as backupset incremental level 1 database plus archivelog;

You can specify if you want the incremental backup to be cumulative (quicker) or differential (default value).
Not necessarily faster than full backup because you have to scan the whole backup to look for changes.
There’s a process to speed this up : Change Tracking Writer which will write the address of each block that has changed in a file.

Copy images

Make an identical copy of datafiles/controlfile/archivelog

backup as copy database; #backup datafile and controlfile to the flash area
backup as copy archivelog all delete all input; #backup archivelog files to the flash area

Backup of backups

If you use tapes you can use these commands :

backup recovery area;
backup recovery files;

which will backup the flash area and files related to recovery to tape.

Managing backups

You can check the backup sets, copies or other files using list :

LIST backup;
LIST copy;
LIST backup of archivelog all;

You can also ask what needs to be backed up or obsolete files :

REPORT need backup;
REPORT obsolete;

LIST and REPORT commands use the rman repository for information and thus we can’t be sure if the files really exist. To check, use this command :

CROSSCHECK backup of database;

If there is data in rman repository but there isn’t corresponding files, use this :

DELETE EXPIRED backup;
DELETE obsolete will delete the files and the info in the repository.

Recover and restore

The DRA (Data Recovery Advisor) is a new tool in 11g used for diagnosing and repairing databases.
Commands :

list failure;
advise failure; #generate script to repaire the failure
repair failure; #start the script

To restore a database, use :

#optional : set until time | to recover the database until that ime
restore database;
recover database; #use the archive logs to repeat the queries
alter database open resetlogs; #reset the online redo logs

If you want to restore only a tablespace or a datafile :

restore datafile '/disk/something.dbf';
restore tablespace example;

You also have to ensure the controlfile (vital for the database) will be have an autobackup :

configure controlfile autobackup on;

This command will enable an automatic backup of controlfile during every RMAN operation that can be easily restored :

restore controlfile from autobackup;

If you want to restore a database that has a copy image :

switch database to copy;