SQL

PDF generated using the open source mwlib toolkit. See http://code.pediapress.com/ for more information.
PDF generated at: Sun, 27 May 2012 01:27:47 UTC
Contents
Articles
Overview 1
SQL 1
Data 14
Metadata 16

Databases 26
Flat file database 26
Relational database 29
MySQL 34
LAMP 44
Information retrieval 45
Data Definition Language 55
NoSQL 57

Database objects 64
Table 64
Column 65
Field 66
Row 67
Data type 68

Database connectivity 73
Application programming interface 73
Database transaction 79
Open Database Connectivity 82
Java Database Connectivity 85

Statements 91
Select 91
Insert 96
Update 99
Merge 101
Delete 103
Join 106
 Set operations 120
Commit 124
Rollback 125
Truncate 126

References
Article Sources and Contributors 127
Image Sources, Licenses and Contributors 131

Article Licenses
License 132
 1

Overview

SQL
SQL
Paradigm(s) Multi-paradigm

Appeared in 1974

Designed by Donald D. Chamberlin

Raymond F. Boyce

Developer ISO/IEC

Stable release SQL:2011 (2011)

Typing discipline Static, strong

Major implementations Many

Dialects SQL-86, SQL-89, SQL-92, SQL:1999, SQL:2003, SQL:2008, SQL:2011

Influenced by Datalog

Influenced [1]
Agena, CQL, LINQ, Windows PowerShell

OS Cross-platform

Usual filename .sql

extensions

Website "ISO/IEC 9075-1:2008: Information technology – Database languages – SQL – Part 1: Framework
[2]
(SQL/Framework)"

SQL
Structured Query Language

Filename extension .sql

Internet media type application/x-sql

Developed by ISO/IEC

Initial release 1986

Latest release SQL:2008 / 2008

Type of format Database

Standard(s) ISO/IEC 9075

Open format? Yes

Website [3]

SQL (  /ˈɛskjuːˈɛl/ "S-Q-L";[4] sometimes referred to as Structured Query Language) is a special-purpose

programming language designed for managing data in relational database management systems (RDBMS).
SQL 2

Originally based upon relational algebra and tuple relational calculus,[5] its scope includes data insert, query, update
and delete, schema creation and modification, and data access control.
SQL was one of the first commercial languages for Edgar F. Codd's relational model, as described in his influential
1970 paper, "A Relational Model of Data for Large Shared Data Banks".[6] Despite not adhering to the relational
model as described by Codd, it became the most widely used database language.[7][8] Although SQL is often
described as, and to a great extent is, a declarative language, it also includes procedural elements. SQL became a
standard of the American National Standards Institute (ANSI) in 1986, and of the International Organization for
Standards (ISO) in 1987. Since then, the standard has been enhanced several times with added features. However,
issues of SQL code portability between major RDBMS products still exist due to lack of full compliance with, or
different interpretations of, the standard. Among the reasons mentioned are the large size and incomplete
specification of the standard, as well as vendor lock-in.

History
SQL was initially developed at IBM by Donald D. Chamberlin and Raymond F. Boyce in the early 1970s. This
version, initially called SEQUEL (Structured English Query Language), was designed to manipulate and retrieve
data stored in IBM's original quasi-relational database management system, System R, which a group at IBM San
Jose Research Laboratory had developed during the 1970s.[9] The acronym SEQUEL was later changed to SQL
because "SEQUEL" was a trademark of the UK-based Hawker Siddeley aircraft company.[10]
The first Relational Database Management System (RDBMS) was RDMS, developed at MIT in the early 1970s,
soon followed by Ingres, developed in 1974 at U.C. Berkeley. Ingres implemented a query language known as
QUEL, which was later supplanted in the marketplace by SQL.[10]
In the late 1970s, Relational Software, Inc. (now Oracle Corporation) saw the potential of the concepts described by
Codd, Chamberlin, and Boyce and developed their own SQL-based RDBMS with aspirations of selling it to the U.S.
Navy, Central Intelligence Agency, and other U.S. government agencies. In June 1979, Relational Software, Inc.
introduced the first commercially available implementation of SQL, Oracle V2 (Version2) for VAX computers.
Oracle V2 beat IBM's August release of the System/38 RDBMS to market by a few weeks.
After testing SQL at customer test sites to determine the usefulness and practicality of the system, IBM began
developing commercial products based on their System R prototype including System/38, SQL/DS, and DB2, which
were commercially available in 1979, 1981, and 1983, respectively.[11]
The SQL language is subdivided into several
language elements, including:
• Clauses, which are constituent components of
statements and queries. (In some cases, these
are optional.)[12]
• Expressions, which can produce either scalar This chart shows several of the SQL language elements that compose a
values or tables consisting of columns and single statement.
rows of data.
• Predicates, which specify conditions that can be evaluated to SQL three-valued logic (3VL) or Boolean
(true/false/unknown) truth values and which are used to limit the effects of statements and queries, or to change
program flow.
• Queries, which retrieve the data based on specific criteria. This is the most important element of SQL.
• Statements, which may have a persistent effect on schemata and data, or which may control transactions,
program flow, connections, sessions, or diagnostics.
• SQL statements also include the semicolon (";") statement terminator. Though not required on every platform,
it is defined as a standard part of the SQL grammar.
SQL 3

• Insignificant whitespace is generally ignored in SQL statements and queries, making it easier to format SQL
code for readability.

Queries
The most common operation in SQL is the query, which is performed with the declarative SELECT statement.
SELECT retrieves data from one or more tables, or expressions. Standard SELECT statements have no persistent
effects on the database. Some non-standard implementations of SELECT can have persistent effects, such as the
SELECT INTO syntax that exists in some databases.[13]
Queries allow the user to describe desired data, leaving the database management system (DBMS) responsible for
planning, optimizing, and performing the physical operations necessary to produce that result as it chooses.
A query includes a list of columns to be included in the final result immediately following the SELECT keyword.
An asterisk ("*") can also be used to specify that the query should return all columns of the queried tables. SELECT
is the most complex statement in SQL, with optional keywords and clauses that include:
• The FROM clause which indicates the table(s) from which data is to be retrieved. The FROM clause can include
optional JOIN subclauses to specify the rules for joining tables.
• The WHERE clause includes a comparison predicate, which restricts the rows returned by the query. The WHERE
clause eliminates all rows from the result set for which the comparison predicate does not evaluate to True.
• The GROUP BY clause is used to project rows having common values into a smaller set of rows. GROUP BY is
often used in conjunction with SQL aggregation functions or to eliminate duplicate rows from a result set. The
WHERE clause is applied before the GROUP BY clause.
• The HAVING clause includes a predicate used to filter rows resulting from the GROUP BY clause. Because it
acts on the results of the GROUP BY clause, aggregation functions can be used in the HAVING clause predicate.
• The ORDER BY clause identifies which columns are used to sort the resulting data, and in which direction they
should be sorted (options are ascending or descending). Without an ORDER BY clause, the order of rows
returned by an SQL query is undefined.
The following is an example of a SELECT query that returns a list of expensive books. The query retrieves all rows
from the Book table in which the price column contains a value greater than 100.00. The result is sorted in ascending
order by title. The asterisk (*) in the select list indicates that all columns of the Book table should be included in the
result set.

SELECT *
FROM Book
WHERE price > 100.00
ORDER BY title;

The example below demonstrates a query of multiple tables, grouping, and aggregation, by returning a list of books
and the number of authors associated with each book.

SELECT Book.title,
count(*) AS Authors
FROM Book JOIN Book_author
ON Book.isbn = Book_author.isbn
GROUP BY Book.title;

Example output might resemble the following:

Title Authors
---------------------- -------
SQL Examples and Guide 4
SQL 4

The Joy of SQL 1

An Introduction to SQL 2
Pitfalls of SQL 1

Under the precondition that isbn is the only common column name of the two tables and that a column named title
only exists in the Books table, the above query could be rewritten in the following form:

SELECT title,
count(*) AS Authors
FROM Book NATURAL JOIN Book_author
GROUP BY title;

However, many vendors either do not support this approach, or require certain column naming conventions in order
for natural joins to work effectively.
SQL includes operators and functions for calculating values on stored values. SQL allows the use of expressions in
the select list to project data, as in the following example which returns a list of books that cost more than 100.00
with an additional sales_tax column containing a sales tax figure calculated at 6% of the price.

SELECT isbn,
title,
price,
price * 0.06 AS sales_tax
FROM Book
WHERE price > 100.00
ORDER BY title;

Subqueries
Queries can be nested so that the results of one query can be used in another query via a relational operator or
aggregation function. A nested query is also known as a subquery. While joins and other table operations provide
computationally superior (i.e. faster) alternatives in many cases, the use of subqueries introduces a hierarchy in
execution which can be useful or necessary. In the following example, the aggregation function AVG receives as
input the result of a subquery:

SELECT isbn, title, price

FROM Book
WHERE price < AVG(SELECT price FROM Book)
ORDER BY title;

Null and three-valued logic (3VL)

The idea of Null was introduced into SQL to handle missing information in the relational model. The introduction of
Null (or Unknown) along with True and False is the foundation of three-valued logic. Null does not have a value
(and is not a member of any data domain) but is rather a placeholder or "mark" for missing information. Therefore
comparisons with Null can never result in either True or False but always in the third logical result.[14]
SQL uses Null to handle missing information. It supports three-valued logic (3VL) and the rules governing SQL
three-valued logic are shown below (p and q represent logical states).[15] The word NULL is also a reserved keyword
in SQL, used to identify the Null special marker.
Additionally, since SQL operators return Unknown when comparing anything with Null, SQL provides two
Null-specific comparison predicates: IS NULL and IS NOT NULL test whether data is or is not Null.[14]
SQL 5

Note that SQL returns only results for which the WHERE clause returns a value of True; i.e. it excludes results with
values of False and also excludes those whose value is Unknown.

p AND q p p OR q p

True False Unknown True False Unknown

q True True False Unknown q True True True True

False False False False False True False Unknown

Unknown Unknown False Unknown Unknown True Unknown Unknown

p NOT p p=q p

True False True False Unknown

False True q True True False Unknown

Unknown Unknown False False True Unknown

Unknown Unknown Unknown Unknown

Universal quantification is not explicitly supported by SQL, and must be worked out as a negated existential
quantification.[16][17][18]
There is also the "<row value expression> IS DISTINCT FROM <row value expression>" infixed comparison
operator which returns TRUE unless both operands are equal or both are NULL. Likewise, IS NOT DISTINCT
FROM is defined as "NOT (<row value expression> IS DISTINCT FROM <row value expression>)".

Data manipulation
The Data Manipulation Language (DML) is the subset of SQL used to add, update and delete data:
• INSERT adds rows (formally tuples) to an existing table, e.g.,:

INSERT INTO My_table

(field1, field2, field3)
VALUES
('test', 'N', NULL);

• UPDATE modifies a set of existing table rows, e.g.,:

UPDATE My_table
SET field1 = 'updated value'
WHERE field2 = 'N';

• DELETE removes existing rows from a table, e.g.,:

DELETE FROM My_table

WHERE field2 = 'N';

• MERGE is used to combine the data of multiple tables. It combines the INSERT and UPDATE elements. It is
defined in the SQL:2003 standard; prior to that, some databases provided similar functionality via different
syntax, sometimes called "upsert".
SQL 6

Transaction controls
Transactions, if available, wrap DML operations:
• START TRANSACTION (or BEGIN WORK, or BEGIN TRANSACTION, depending on SQL dialect) mark the
start of a database transaction, which either completes entirely or not at all.
• SAVE TRANSACTION (or SAVEPOINT ) save the state of the database at the current point in transaction

CREATE TABLE tbl_1(id int);

INSERT INTO tbl_1(id) VALUES(1);
INSERT INTO tbl_1(id) VALUES(2);
COMMIT;
UPDATE tbl_1 SET id=200 WHERE id=1;
SAVEPOINT id_1upd;
UPDATE tbl_1 SET id=1000 WHERE id=2;
ROLLBACK to id_1upd;
SELECT id from tbl_1;

• COMMIT causes all data changes in a transaction to be made permanent.

• ROLLBACK causes all data changes since the last COMMIT or ROLLBACK to be discarded, leaving the state of
the data as it was prior to those changes.
Once the COMMIT statement completes, the transaction's changes cannot be rolled back.
COMMIT and ROLLBACK terminate the current transaction and release data locks. In the absence of a START
TRANSACTION or similar statement, the semantics of SQL are implementation-dependent. Example: A classic bank
transfer of funds transaction.

START TRANSACTION;
UPDATE Account SET amount=amount-200 WHERE account_number=1234;
UPDATE Account SET amount=amount+200 WHERE account_number=2345;

IF ERRORS=0 COMMIT;
IF ERRORS<>0 ROLLBACK;

Data definition
The Data Definition Language (DDL) manages table and index structure. The most basic items of DDL are the
CREATE, ALTER, RENAME, DROP and TRUNCATE statements:
• CREATE creates an object (a table, for example) in the database, e.g.,:

CREATE TABLE My_table(

my_field1 INT,
my_field2 VARCHAR(50),
my_field3 DATE NOT NULL,
PRIMARY KEY (my_field1, my_field2)
);

• ALTER modifies the structure of an existing object in various ways, for example, adding a column to an existing
table or a constraint, e.g.,:

ALTER TABLE My_table ADD my_field4 NUMBER(3) NOT NULL;

SQL 7

• TRUNCATE deletes all data from a table in a very fast way, deleting the data inside the table and not the table
itself. It usually implies a subsequent COMMIT operation, i.e., it cannot be rolled back.(data is not written to the
logs for rollback later, unlike DELETE )

TRUNCATE TABLE My_table;

• DROP deletes an object in the database, usually irretrievably, i.e., it cannot be rolled back, e.g.,:

DROP TABLE My_table;

Data types
Each column in an SQL table declares the type(s) that column may contain. ANSI SQL includes the following data
types.[19]

Character strings
• CHARACTER(n) or CHAR(n) — fixed-width n-character string, padded with spaces as needed
• CHARACTER VARYING(n) or VARCHAR(n) — variable-width string with a maximum size of n characters
• NATIONAL CHARACTER(n) or NCHAR(n) — fixed width string supporting an international character set
• NATIONAL CHARACTER VARYING(n) or NVARCHAR(n) — variable-width NCHAR string

Bit strings
• BIT(n) — an array of n bits
• BIT VARYING(n) — an array of up to n bits

Numbers
• INTEGER and SMALLINT
• FLOAT, REAL and DOUBLE PRECISION
• NUMERIC(precision, scale) or DECIMAL(precision, scale)
For example, the number 123.45 has a precision of 5 and a scale of 2. The precision is a positive integer that
determines the number of significant digits in a particular radix (binary or decimal). The scale is a non-negative
integer. A scale of 0 indicates that the number is an integer. For a decimal number with scale S, the exact numeric
value is the integer value of the significant digits divided by 10S.
SQL provides a function to round numerics or dates, called TRUNC (in Informix, DB2, PostgreSQL, Oracle and
MySQL) or ROUND (in Informix, Sybase, Oracle, PostgreSQL and Microsoft SQL Server)[20]

Date and time

• DATE — for date values (e.g., 2011-05-03)
• TIME — for time values (e.g., 15:51:36). The granularity of the time value is usually a tick (100 nanoseconds).
• TIME WITH TIME ZONE or TIMETZ — the same as TIME, but including details about the time zone in
question.
• TIMESTAMP — This is a DATE and a TIME put together in one variable (e.g., 2011-05-03 15:51:36).
• TIMESTAMP WITH TIME ZONE or TIMESTAMPTZ — the same as TIMESTAMP, but including details about
the time zone in question.
SQL provides several functions for generating a date / time variable out of a date / time string (TO_DATE,
TO_TIME, TO_TIMESTAMP), as well as for extracting the respective members (seconds, for instance) of such
variables. The current system date / time of the database server can be called by using functions like NOW.
SQL 8

Data control
The Data Control Language (DCL) authorizes users and groups of users to access and manipulate data. Its two main
statements are:
• GRANT authorizes one or more users to perform an operation or a set of operations on an object.
• REVOKE eliminates a grant, which may be the default grant.
Example:

GRANT SELECT, UPDATE

ON My_table
TO some_user, another_user;

REVOKE SELECT, UPDATE

ON My_table
FROM some_user, another_user;

Procedural extensions
SQL is designed for a specific purpose: to query data contained in a relational database. SQL is a set-based,
declarative query language, not an imperative language such as C or BASIC. However, there are extensions to
Standard SQL which add procedural programming language functionality, such as control-of-flow constructs. These
include:

Source Common Full Name

Name

ANSI/ISO Standard SQL/PSM SQL/Persistent Stored Modules

Interbase/ PSQL Procedural SQL

Firebird

IBM DB2 SQL PL SQL Procedural Language (implements SQL/PSM)

IBM Informix SPL Stored Procedural Language

Microsoft/ T-SQL Transact-SQL

Sybase

Mimer SQL SQL/PSM SQL/Persistent Stored Module (implements SQL/PSM)

MySQL SQL/PSM SQL/Persistent Stored Module (implements SQL/PSM)

Oracle PL/SQL Procedural Language/SQL (based on Ada)

PostgreSQL PL/pgSQL Procedural Language/PostgreSQL Structured Query Language (based on Oracle PL/SQL)

PostgreSQL PL/PSM Procedural Language/Persistent Stored Modules (implements SQL/PSM)

In addition to the standard SQL/PSM extensions and proprietary SQL extensions, procedural and object-oriented
programmability is available on many SQL platforms via DBMS integration with other languages. The SQL
standard defines SQL/JRT extensions (SQL Routines and Types for the Java Programming Language) to support
Java code in SQL databases. SQL Server 2005 uses the SQLCLR (SQL Server Common Language Runtime) to host
managed .NET assemblies in the database, while prior versions of SQL Server were restricted to using unmanaged
extended stored procedures which were primarily written in C. PostgreSQL allows functions to be written in a wide
variety of languages including Perl, Python, Tcl, and C.[21]
SQL 9

Criticism
SQL deviates in several ways from its theoretical foundation, the relational model and its tuple calculus.
In that model, a table is a set of tuples, while in SQL, tables and query results are lists of rows: the same row may
occur multiple times, and the order of rows can be employed in queries (e.g. in the LIMIT clause).
Furthermore, additional features (such as NULL and views) were introduced without founding them directly on the
relational model, which makes them more difficult to interpret.
Critics argue that SQL should be replaced with a language that strictly returns to the original foundation - see, e.g.,
The Third Manifesto.
Other criticisms of SQL include:
• Implementations are incompatible between vendors. In particular date and time syntax, string concatenation,
NULLs, and comparison case sensitivity vary from vendor to vendor. A particular exception is PostgreSQL, which
strives for compliance.[22]

Cross-vendor portability
Popular implementations of SQL commonly omit support for basic features of Standard SQL, such as the DATE or
TIME data types. The most obvious such examples, and incidentally the most popular commercial, proprietary SQL
DBMSs, are Oracle (whose DATE behaves as DATETIME,[23][24] and lacks a TIME type[25]) and the MS SQL
Server (before the 2008 version). As a result, SQL code can rarely be ported between database systems without
modifications.
There are several reasons for this lack of portability between database systems:
• The complexity and size of the SQL standard means that most implementors do not support the entire standard.
• The standard does not specify database behavior in several important areas (e.g., indexes, file storage…), leaving
implementations to decide how to behave.
• The SQL standard precisely specifies the syntax that a conforming database system must implement. However,
the standard's specification of the semantics of language constructs is less well-defined, leading to ambiguity.
• Many database vendors have large existing customer bases; where the SQL standard conflicts with the prior
behavior of the vendor's database, the vendor may be unwilling to break backward compatibility.
• Software vendors often desire to create incompatibilities with other products, as it provides a strong incentive for
their existing users to remain loyal (see vendor lock-in).

Standardization
SQL was adopted as a standard by the American National Standards Institute (ANSI) in 1986 as SQL-86[26] and the
International Organization for Standardization (ISO) in 1987. Nowadays the standard is subject to continuous
improvement by the Joint Technical Committee ISO/IEC JTC 1, Information technology, Subcommittee SC 32, Data
management and interchange which affiliate to ISO as well as IEC. He is commonly denoted conforming to the
pattern: ISO/IEC 9075-n:yyyy Part n: title or ISO/IEC 9075 as a shortcut.
ISO/IEC 9075 is complemented by ISO/IEC 13249: SQL Multimedia and Application Packages which defines SQL
based interfaces and packages to widely spread applications like video, audio and spatial data.
Until 1996, the National Institute of Standards and Technology (NIST) data management standards program certified
SQL DBMS compliance with the SQL standard. Vendors now self-certify the compliance of their products.[27]
The original SQL standard declared that the official pronunciation for SQL is "es queue el".[7] Many
English-speaking database professionals still use the nonstandard[28] pronunciation /ˈsiːkwəl/ (like the word
"sequel"), including Donald Chamberlin himself.[29]
The SQL standard has gone through a number of revisions, as shown below:
SQL 10

Year Name Alias Comments

1986 SQL-86 SQL-87 First formalized by ANSI.

1989 SQL-89 FIPS Minor revision, adopted as FIPS 127-1.

127-1

1992 SQL-92 SQL2, Major revision (ISO 9075), Entry Level SQL-92 adopted as FIPS 127-2.
FIPS
127-2

1999 SQL:1999 SQL3 Added regular expression matching, recursive queries, triggers, support for procedural and control-of-flow
statements, non-scalar types, and some object-oriented features.

2003 SQL:2003 SQL Introduced XML-related features, window functions, standardized sequences, and columns with auto-generated
2003 values (including identity-columns).

2006 SQL:2006 SQL ISO/IEC 9075-14:2006 defines ways in which SQL can be used in conjunction with XML. It defines ways of
2006 importing and storing XML data in an SQL database, manipulating it within the database and publishing both XML
and conventional SQL-data in XML form. In addition, it enables applications to integrate into their SQL code the
use of XQuery, the XML Query Language published by the World Wide Web Consortium (W3C), to concurrently
[30]
access ordinary SQL-data and XML documents.

2008 SQL:2008 SQL Legalizes ORDER BY outside cursor definitions. Adds INSTEAD OF triggers. Adds the TRUNCATE
2008 [31]
statement.

2011 SQL:2011

Interested parties may purchase SQL standards documents from ISO, IEC or ANSI. A draft of SQL:2008 is freely
available as a zip archive.[32]

Standard structure
The SQL standard is divided into nine parts.
• ISO/IEC 9075-1:2011 Part 1: Framework (SQL/Framework). It provides logical concepts.
• ISO/IEC 9075-2:2011 Part 2: Foundation (SQL/Foundation). It contains the most central elements of the
language and consists of both mandatory and optional features.
• ISO/IEC 9075-3:2008 Part 3: Call-Level Interface (SQL/CLI). It defines interfacing components (structures,
procedures, variable bindings) that can be used to execute SQL statements from applications written in Ada, C
respectively C++, COBOL, Fortran, MUMPS, Pascal or PL/I. (For Java see part 10.) SQL/CLI is defined in such
a way that SQL statements and SQL/CLI procedure calls are treated as separate from the calling application's
source code. Open Database Connectivity is a well-known superset of SQL/CLI. This part of the standard consists
solely of mandatory features.
• ISO/IEC 9075-4:2011 Part 4: Persistent Stored Modules (SQL/PSM) It standardizes procedural extensions for
SQL, including flow of control, condition handling, statement condition signals and resignals, cursors and local
variables, and assignment of expressions to variables and parameters. In addition, SQL/PSM formalizes
declaration and maintenance of persistent database language routines (e.g., "stored procedures"). This part of the
standard consists solely of optional features.
• ISO/IEC 9075-9:2008 Part 9: Management of External Data (SQL/MED). It provides extensions to SQL that
define foreign-data wrappers and datalink types to allow SQL to manage external data. External data is data that
is accessible to, but not managed by, an SQL-based DBMS. This part of the standard consists solely of optional
features.
• ISO/IEC 9075-10:2008 Part 10: Object Language Bindings (SQL/OLB). It defines the syntax and semantics of
SQLJ, which is SQL embedded in Java (see also part 3). The standard also describes mechanisms to ensure binary
portability of SQLJ applications, and specifies various Java packages and their contained classes. This part of the
SQL 11

standard consists solely of optional features. As opposed to SQL/OLB JDBC - which is not part of the SQL
standard - defines an API.
• ISO/IEC 9075-11:2011 Part 11: Information and Definition Schemas (SQL/Schemata). It defines the
Information Schema and Definition Schema, providing a common set of tools to make SQL databases and objects
self-describing. These tools include the SQL object identifier, structure and integrity constraints, security and
authorization specifications, features and packages of ISO/IEC 9075, support of features provided by SQL-based
DBMS implementations, SQL-based DBMS implementation information and sizing items, and the values
supported by the DBMS implementations.[33] This part of the standard contains both mandatory and optional
features.
• ISO/IEC 9075-13:2008 Part 13: SQL Routines and Types Using the Java Programming Language
(SQL/JRT). It specifies the ability to invoke static Java methods as routines from within SQL applications
('Java-in-the-database'). It also calls for the ability to use Java classes as SQL structured user-defined types. This
part of the standard consists solely of optional features.
• ISO/IEC 9075-14:2011 Part 14: XML-Related Specifications (SQL/XML). It specifies SQL-based extensions
for using XML in conjunction with SQL. The XMLType data type is introduced, as well as several routines,
functions, and XML-to-SQL data type mappings to support manipulation and storage of XML in an SQL
database.[30] This part of the standard consists solely of optional features.
ISO/IEC 9075 is complemented by ISO/IEC 13249 SQL Multimedia and Application Packages. This closely related
but separate standard is developed by the same committee. It defines interfaces and packages which are based on
SQL. The aim is an unified access to typical database applications like text, pictures, data mining or spatial data.
• ISO/IEC 13249-1:2007 Part 1: Framework
• ISO/IEC 13249-2:2003 Part 2: Full-Text
• ISO/IEC 13249-3:2011 Part 3: Spatial
• ISO/IEC 13249-5:2003 Part 5: Still image
• ISO/IEC 13249-6:2006 Part 6: Data mining
• ISO/IEC 13249-8:xxxx Part 8: Metadata registries (MDR) (work in progress)

Alternatives
A distinction should be made between alternatives to relational query languages and alternatives to SQL. Below are
proposed relational alternatives to SQL. See navigational database and NoSQL for alternatives to relational:
• .QL - object-oriented Datalog
• 4D Query Language (4D QL)
• Datalog
• HTSQL - URL based query method
• IBM Business System 12 (IBM BS12) - one of the first fully relational database management systems, introduced
in 1982
• ISBL
• Java Persistence Query Language (JPQL) - The query language used by the Java Persistence API [34] and
Hibernate persistence library
• JoSQL[35] - Runs SQL statements written as Strings to query collections from inside Java code.
• LINQ - Runs SQL statements written like language constructs to query collections directly from inside .Net code.
• Object Query Language
• QBE (Query By Example) created by Moshè Zloof, IBM 1977
• Quel introduced in 1974 by the U.C. Berkeley Ingres project.
• Tutorial D
• SBQL - the Stack Based Query Language (SBQL [36])
SQL 12

• UnQL - the Unstructured Query Language, a functional superset of SQL, developed by the authors of SQLite and
CouchDB
• XQuery

Notes
[1] Paul, Ryan. "A guided tour of the Microsoft Command Shell" (http:/ / arstechnica. com/ business/ news/ 2005/ 10/ msh. ars/ 4). Ars Technica.
. Retrieved 10 April 2011.
[2] http:/ / www. iso. org/ iso/ catalogue_detail. htm?csnumber=45498
[3] "ISO/IEC 9075-1:2008: Information technology – Database languages – SQL – Part 1: Framework (SQL/Framework)" (http:/ / www. iso.
org/ iso/ catalogue_detail. htm?csnumber=45498).
[4] Beaulieu, Alan (April 2009). Mary E Treseler. ed. Learning SQL (2nd ed.). Sebastapol, CA, USA: O'Reilly. ISBN 978-0-596-52083-0.
[5] Darwen, Hugh (2005-04-15). "More on Relational Algebra versus Calculus" (http:/ / www. dbdebunk. com/ page/ page/ 1897740. htm). In
Pascal, Fabian. Database Debunkings.
[6] Codd, Edgar F (June 1970). "A Relational Model of Data for Large Shared Data Banks" (http:/ / www. acm. org/ classics/ nov95/ toc. html).
Communications of the ACM (Association for Computing Machinery) 13 (6): 377–87. doi:10.1145/362384.362685. . Retrieved 2007-06-09.
[7] Chapple, Mike. "SQL Fundamentals" (http:/ / databases. about. com/ od/ sql/ a/ sqlfundamentals. htm). Databases. About.com. . Retrieved
2009-01-28.
[8] "Structured Query Language (SQL)" (http:/ / publib. boulder. ibm. com/ infocenter/ db2luw/ v9/ index. jsp?topic=com. ibm. db2. udb. admin.
doc/ doc/ c0004100. htm). International Business Machines. October 27, 2006. . Retrieved 2007-06-10.
[9] Chamberlin, Donald D; Boyce, Raymond F (1974). "SEQUEL: A Structured English Query Language" (http:/ / www. almaden. ibm. com/ cs/
people/ chamberlin/ sequel-1974. pdf) (PDF). Proceedings of the 1974 ACM SIGFIDET Workshop on Data Description, Access and Control
(Association for Computing Machinery): 249–64. . Retrieved 2007-06-09.
[10] Oppel, Andy (February 27, 2004). Databases Demystified (http:/ / www. mhprofessional. com/ product. php?cat=112& isbn=0071469605).
San Francisco, CA: McGraw-Hill Osborne Media. pp. 90–1. ISBN 0-07-146960-5. .
[11] "History of IBM, 1978" (http:/ / www-03. ibm. com/ ibm/ history/ history/ year_1978. html). IBM Archives. IBM. . Retrieved 2007-06-09.
[12] ANSI/ISO/IEC International Standard (IS). Database Language SQL—Part 2: Foundation (SQL/Foundation). 1999.
[13] "Transact-SQL Reference" (http:/ / msdn2. microsoft. com/ en-us/ library/ ms188029(SQL. 90). aspx). SQL Server Language Reference.
SQL Server 2005 Books Online. Microsoft. 2007-09-15. . Retrieved 2007-06-17
[14] ISO/IEC. ISO/IEC 9075-2:2003, "SQL/Foundation". ISO/IEC.
[15] Coles, Michael (2005-06-27). "Four Rules for Nulls" (http:/ / www. sqlservercentral. com/ columnists/ mcoles/ fourrulesfornulls. asp). SQL
Server Central (Red Gate Software). .
[16] M. Negri, G. Pelagatti, L. Sbattella (1989) Semantics and problems of universal quantification in SQL (http:/ / portal. acm. org/ citation.
cfm?id=63224. 68822& coll=GUIDE& dl=GUIDE).
[17] Fratarcangeli, Claudio (1991). Technique for universal quantification in SQL. Retrieved from ACM.org. (http:/ / portal. acm. org/ citation.
cfm?id=126482. 126484& coll=GUIDE& dl=GUIDE& CFID=5934371& CFTOKEN=55309005)
[18] Kawash, Jalal (2004). Complex quantification in Structured Query Language (SQL): a tutorial using relational calculus - Journal of
Computers in Mathematics and Science Teaching ISSN 0731-9258 Volume 23, Issue 2, 2004 AACE Norfolk, Virginia. Retrieved from
Thefreelibrary.com (http:/ / www. thefreelibrary. com/ Complex+ quantification+ in+ Structured+ Query+ Language+ (SQL):+ a+ tutorial. . .
-a0119901477).
[19] Information Technology — Database Language SQL (http:/ / www. contrib. andrew. cmu. edu/ ~shadow/ sql/ sql1992. txt). CMU.
(proposed revised text of DIS 9075)].
[20] Arie Jones, Ryan K. Stephens, Ronald R. Plew, Alex Kriegel, Robert F. Garrett (2005), SQL Functions Programmer's Reference. Wiley, 127
pages.
[21] PostgreSQL contributors (2011). "PostgreSQL server programming" (http:/ / www. postgresql. org/ docs/ 9. 1/ static/ server-programming.
html). PostgreSQL 9.1 official documentation. postgresql.org. . Retrieved 2012-03-09.
[22] PostgreSQL contributors (2012). "About PostgreSQL" (http:/ / www. postgresql. org/ about/ ). PostgreSQL 9.1 official website.
postgresql.org. . Retrieved 2012-03-09. "PostgreSQL prides itself in standards compliance. Its SQL implementation strongly conforms to the
ANSI-SQL:2008 standard."
[23] Lorentz, Diana; Roeser, Mary Beth; Abraham, Sundeep; Amor, Angela; Arora, Geeta; Arora, Vikas; Ashdown, Lance; Baer, Hermann et al
(2010-10) [1996]. "Basic Elements of Oracle SQL: Data Types" (http:/ / download. oracle. com/ docs/ cd/ E11882_01/ server. 112/ e17118/
sql_elements001. htm#sthref154). Oracle Database SQL Language Reference 11g Release 2 (11.2). Oracle Database Documentation Library.
Redwood City, CA: Oracle USA, Inc.. . Retrieved 2010-12-29. "For each DATE value, Oracle stores the following information: century, year,
month, date, hour, minute, and second".
[24] Lorentz, Diana; Roeser, Mary Beth; Abraham, Sundeep; Amor, Angela; Arora, Geeta; Arora, Vikas; Ashdown, Lance; Baer, Hermann et al
(2010-10) [1996]. "Basic Elements of Oracle SQL: Data Types" (http:/ / download. oracle. com/ docs/ cd/ E11882_01/ server. 112/ e17118/
sql_elements001. htm#sthref154). Oracle Database SQL Language Reference 11g Release 2 (11.2). Oracle Database Documentation Library.
Redwood City, CA: Oracle USA, Inc.. . Retrieved 2010-12-29. "The datetime data types are DATE…".
SQL 13

[25] Lorentz, Diana; Roeser, Mary Beth; Abraham, Sundeep; Amor, Angela; Arora, Geeta; Arora, Vikas; Ashdown, Lance; Baer, Hermann et al
(2010-10) [1996]. "Basic Elements of Oracle SQL: Data Types" (http:/ / download. oracle. com/ docs/ cd/ E11882_01/ server. 112/ e17118/
sql_elements001. htm#i54335). Oracle Database SQL Language Reference 11g Release 2 (11.2). Oracle Database Documentation Library.
Redwood City, CA: Oracle USA, Inc.. . Retrieved 2010-12-29. "Do not define columns with the following SQL/DS and DB2 data types,
because they have no corresponding Oracle data type:… TIME".
[26] "Finding Aid" (http:/ / special. lib. umn. edu/ findaid/ xml/ cbi00168. xml). X3H2 Records, 1978–95. American National Standards Institute.
.
[27] Doll, Shelley (June 19, 2002). "Is SQL a Standard Anymore?" (http:/ / articles. techrepublic. com. com/ 5100-10878_11-1046268. html).
TechRepublic's Builder.com. TechRepublic. . Retrieved 2010-01-07.
[28] Melton, Jim; Alan R Simon (1993). "1.2. What is SQL?". Understanding the New SQL: A Complete Guide. Morgan Kaufmann. p. 536.
ISBN 1-55860-245-3. "SQL (correctly pronounced "ess cue ell," instead of the somewhat common "sequel")…"
[29] Gillespie, Patrick. "Pronouncing SQL: S-Q-L or Sequel?" (http:/ / patorjk. com/ blog/ 2012/ 01/ 26/ pronouncing-sql-s-q-l-or-sequel/ ).
Pronouncing SQL: S-Q-L or Sequel?. . Retrieved 12 February 2012.
[30] Wagner, Michael (2010). SQL/XML:2006 - Evaluierung der Standardkonformität ausgewählter Datenbanksysteme. Diplomica Verlag.
p. 100. ISBN 3-8366-9609-6.
[31] SQL:2008 now an approved ISO international standard (http:/ / iablog. sybase. com/ paulley/ 2008/ 07/
sql2008-now-an-approved-iso-international-standard/ ). Sybase. 2008-7. .
[32] (Zip) SQL:2008 draft (http:/ / www. wiscorp. com/ sql200n. zip). Whitemarsh Information Systems Corporation. .
[33] ISO/IEC 9075-11:2008: Information and Definition Schemas (SQL/Schemata). 2008. p. 1.
[34] http:/ / www. oracle. com/ technetwork/ articles/ javaee/ jpa-137156. html
[35] "JoSQL official website" (http:/ / josql. sourceforge. net). sourceforge.net. . Retrieved 2012-03-09.
[36] http:/ / www. sbql. pl

References
• Codd, Edgar F (June 1970). "A Relational Model of Data for Large Shared Data Banks" (http://www.acm.org/
classics/nov95/toc.html). Communications of the ACM 13 (6): 377–87. doi:10.1145/362384.362685.
• Discussion on alleged SQL flaws (C2 wiki)
• C. J. Date with Hugh Darwen: A Guide to the SQL standard : a users guide to the standard database language
SQL, 4th ed., Addison Wesley, USA 1997, ISBN 978-0-201-96426-4

External links
• 1995 SQL Reunion: People, Projects, and Politics, by Paul McJones (ed.) (http://www.mcjones.org/System_R/
SQL_Reunion_95/sqlr95.html): transcript of a reunion meeting devoted to the personal history of relational
databases and SQL.
• American National Standards Institute. X3H2 Records, 1978–1995 (http://special.lib.umn.edu/findaid/xml/
cbi00168.xml) Charles Babbage Institute Collection documents the H2 committee’s development of the NDL and
SQL standards.
• Oral history interview with Donald D. Chamberlin (http://purl.umn.edu/107215) Charles Babbage Institute In
this oral history Chamberlin recounts his early life, his education at Harvey Mudd College and Stanford
University, and his work on relational database technology. Chamberlin was a member of the System R research
team and, with Raymond F. Boyce, developed the SQL database language. Chamberlin also briefly discusses his
more recent research on XML query languages.
• Comparison of Different SQL Implementations (http://troels.arvin.dk/db/rdbms/) This comparison of various
SQL implementations is intended to serve as a guide to those interested in porting SQL code between various
RDBMS products, and includes comparisons between SQL:2008, PostgreSQL, DB2, MS SQL Server, MySQL,
Oracle, and Informix.
Data 14

Data
Data (  /ˈdeɪtə/ DAY-tə, /ˈdætə/ DA-tə, or /ˈdɑːtə/ DAH-tə) are values of qualitative or quantitative variables,
belonging to a set of items. Data in computing (or data processing) are often represented by a combination of items
organized in rows and multiple variables organized in columns. Data are typically the results of measurements and
can be visualised using graphs or images. Data as an abstract concept can be viewed as the lowest level of
abstraction from which information and then knowledge are derived. Raw data, i.e., unprocessed data, refers to a
collection of numbers, characters and is a relative term; data processing commonly occurs by stages, and the
"processed data" from one stage may be considered the "raw data" of the next. Field data refers to raw data collected
in an uncontrolled in situ environment. Experimental data refers to data generated within the context of a scientific
investigation by observation and recording.
The word data is the plural of datum, neuter past participle of the Latin dare, "to give", hence "something given". In
discussions of problems in geometry, mathematics, engineering, and so on, the terms givens and data are used
interchangeably. Such usage is the origin of data as a concept in computer science or data processing: data are
numbers, words, images, etc., accepted as they stand.

Usage in English
In English, the word datum is still used in the general sense of "an item given". In cartography, geography, nuclear
magnetic resonance and technical drawing it is often used to refer to a single specific reference datum from which
distances to all other data are measured. Any measurement or result is a datum, but data point is more usual,[1] albeit
tautological. Both datums (see usage in datum article) and the originally Latin plural data are used as the plural of
datum in English, but data is commonly treated as a mass noun and used with a verb in the singular form, especially
in day-to-day usage. For example, This is all the data from the experiment. This usage is inconsistent with the rules
of Latin grammar and traditional English (These are all the data from the experiment). Even when a very small
quantity of data is referenced (one number, for example) the phrase piece of data is often used, as opposed to datum.
The debate over appropriate usage is ongoing.[2][3][4]
The IEEE Computer Society, allows usage of data as either a mass noun or plural based on author preference.[5]
Other professional organizations and style guides[6] require that authors treat data as a plural noun. For example, the
Air Force Flight Test Center specifically states that the word data is always plural, never singular.[7]
Data is most often used as a singular mass noun in educated everyday usage.[8][9] Some major newspapers such as
The New York Times use it either in the singular or plural. In the New York Times the phrases "the survey data are
still being analyzed" and "the first year for which data is available" have appeared within one day.[10] In scientific
writing data is often treated as a plural, as in These data do not support the conclusions, but it is also used as a
singular mass entity like information. British usage now widely accepts treating data as singular in standard
English,[11] including everyday newspaper usage[12] at least in non-scientific use.[13] UK scientific publishing still
prefers treating it as a plural.[14] Some UK university style guides recommend using data for both singular and plural
use[15] and some recommend treating it only as a singular in connection with computers.[16]

Meaning of data, information and knowledge

The terms data, information and knowledge are frequently used for overlapping concepts. The main difference is in
the level of abstraction being considered. Data is the lowest level of abstraction, information is the next level, and
finally, knowledge is the highest level among all three.[17] Data on its own carries no meaning. For data to become
information, it must be interpreted and take on a meaning. For example, the height of Mt. Everest is generally
considered as "data", a book on Mt. Everest geological characteristics may be considered as "information", and a
report containing practical information on the best way to reach Mt. Everest's peak may be considered as
Data 15

"knowledge".
Information as a concept bears a diversity of meanings, from everyday usage to technical settings. Generally
speaking, the concept of information is closely related to notions of constraint, communication, control, data, form,
instruction, knowledge, meaning, mental stimulus, pattern, perception, and representation.
Beynon-Davies uses the concept of a sign to distinguish between data and information; data are symbols while
information occurs when symbols are used to refer to something.[18]
It is people and computers who collect data and impose patterns on it. These patterns are seen as information which
can be used to enhance knowledge. These patterns can be interpreted as truth, and are authorized as aesthetic and
ethical criteria. Events that leave behind perceivable physical or virtual remains can be traced back through data.
Marks are no longer considered data once the link between the mark and observation is broken.[19]
Mechanical computing devices are classified according to the means by which they represent data. An analog
computer represents a datum as a voltage, distance, position, or other physical quantity. A digital computer
represents a datum as a sequence of symbols drawn from a fixed alphabet. The most common digital computers use a
binary alphabet, that is, an alphabet of two characters, typically denoted "0" and "1". More familiar representations,
such as numbers or letters, are then constructed from the binary alphabet.
Some special forms of data are distinguished. A computer program is a collection of data, which can be interpreted
as instructions. Most computer languages make a distinction between programs and the other data on which
programs operate, but in some languages, notably Lisp and similar languages, programs are essentially
indistinguishable from other data. It is also useful to distinguish metadata, that is, a description of other data. A
similar yet earlier term for metadata is "ancillary data." The prototypical example of metadata is the library catalog,
which is a description of the contents of books.

References
This article is based on material taken from the Free On-line Dictionary of Computing prior to 1 November 2008 and
incorporated under the "relicensing" terms of the GFDL, version 1.3 or later.
[1] Matt Dye (2001). "Writing Reports" (http:/ / www. bris. ac. uk/ Depts/ DeafStudiesTeaching/ dissert/ Writing Reports. htm). University of
Bristol. .
[2] "Data is a singular noun" (http:/ / nxg. me. uk/ note/ 2005/ singular-data/ ). .
[3] "Grammarist: Data" (http:/ / www. grammarist. com/ usage/ data/ ). .
[4] "Dictionary.com Data" (http:/ / dictionary. reference. com/ browse/ data). .
[5] "IEEE Computer Society Style Guide, DEF" (http:/ / www. computer. org/ portal/ web/ publications/ styleguidedef). IEEE Computer Society.
.
[6] "WHO Style Guide" (http:/ / whqlibdoc. who. int/ hq/ 2004/ WHO_IMD_PUB_04. 1. pdf). Geneva: World Health Organization. 2004. p. 43.
.
[7] The Author's Guide to Writing Air Force Flight Test Center Technical Reports. Air Force Flight Test Center.
[8] New Oxford Dictionary of English, 1999
[9] "...in educated everyday usage as represented by the Guardian newspaper, it is nowadays most often used as a singular." http:/ / www. eisu2.
bham. ac. uk/ johnstf/ revis006. htm
• "When Serving the Lord, Ministers Are Often Found to Neglect Themselves" (http:/ / www. nytimes. com/ 2009/ 01/ 10/ us/ 10religion.
html). New York Times. 2009. .
• "Investment Tax Cuts Help Mostly the Rich" (http:/ / www. nytimes. com/ 2009/ 01/ 10/ business/ 10charts. html). New York Times.
2009. .
[11] New Oxford Dictionary of English. 1999.
[12] Tim Johns (1997). "Data: singular or plural?" (http:/ / www. eisu2. bham. ac. uk/ johnstf/ revis006. htm). . "...in educated everyday usage as
represented by The Guardian newspaper, it is nowadays most often used as a singular."
[13] "Data" (http:/ / www. askoxford. com/ concise_oed/ data?view=uk). Compact Oxford Dictionary. .
[14] "Data: singular or plural?" (http:/ / www. eisu2. bham. ac. uk/ johnstf/ revis006. htm). Blair Wisconsin International University. .
[15] "Singular or plural" (http:/ / www. nottingham. ac. uk/ public-affairs/ uon-style-book/ singular-plural. htm). University of Nottingham Style
Book. University of Nottingham. .
[16] "Computers and computer systems" (http:/ / openlearn. open. ac. uk/ mod/ resource/ view. php?id=182902). OpenLearn. .
Data 16

[17] Akash Mitra (2011). "Classifying data for successful modeling" (http:/ / www. dwbiconcepts. com/ data-warehousing/ 12-data-modelling/
101-classifying-data-for-successful-modeling. html). .
• P. Beynon-Davies (2002). Information Systems: An introduction to informatics in organisations. Basingstoke, UK: Palgrave Macmillan.
ISBN 0-333-96390-3.
• P. Beynon-Davies (2009). Business information systems. Basingstoke, UK: Palgrave. ISBN 978-0-230-20368-6.
[19] Sharon Daniel. The Database: An Aesthetics of Dignity.

External links
• Data is a singular noun (http://purl.org/nxg/note/singular-data) (a detailed assessment)

Metadata
The term metadata is an ambiguous term which is used for two fundamentally different concepts (types). Although
the expression "data about data" is often used, it does not apply to both in the same way. Structural metadata, the
design and specification of data structures, cannot be about data, because at design time the application contains no
data. In this case the correct description would be "data about the containers of data". Descriptive metadata, on the
other hand, is about individual instances of application data, the data content. In this case, a useful description
(resulting in a disambiguating neologism) would be "data about data content" or "content about content" thus
metacontent. Descriptive, Guide and the National Information Standards Organization concept of administrative
metadata are all subtypes of metacontent.
Metadata (metacontent) is traditionally found in the card catalogs of libraries. As information has become
increasingly digital, metadata is also used to describe digital data using metadata standards specific to a particular
discipline. By describing the contents and context of data files, the quality of the original data/files is greatly
increased. For example, a webpage may include metadata specifying what language it's written in, what tools were
used to create it, and where to go for more on the subject, allowing browsers to automatically improve the experience
of users.

Definition
Metadata (metacontent) is defined as data providing information about one or more aspects of the data, such as:
• Means of creation of the data
• Purpose of the data
• Time and date of creation
• Creator or author of data
• Location on a computer network where the data was created
• Standards used
For example, a digital image may include metadata that describes how large the picture is, the color depth, the image
resolution, when the image was created, and other data. A text document's metadata may contain information about
how long the document is, who the author is, when the document was written, and a short summary of the document.
Metadata is data. As such, metadata can be stored and managed in a database, often called a Metadata registry or
Metadata repository.[1] However, without context and a point of reference, it can be impossible to identify metadata
just by looking at it.[2] For example: by itself, a database containing several numbers, all 13 digits long could be the
results of calculations or a list of numbers to plug into an equation - without any other context, the numbers
themselves can be perceived as the data. But if given the context that this database is a log of a book collection, those
13-digit numbers may now be ISBNs - information that refers to the book, but is not itself the information within the
book.
Metadata 17

The term "metadata" was coined in 1968 by Philip Bagley, in his book "Extension of programming language
concepts" [3] where it is clear that he uses the term in the ISO 11179 "traditional" sense, which is "structural
metadata" i.e. "data about the containers of data"; rather than the alternate sense "content about individual instances
of data content" or metacontent, the type of data usually found in library catalogues. [4][5] Since then the fields of
information management, information science, information technology, librarianship and GIS have widely adopted
the term. In these fields the word metadata is defined as "data about data".[6] While this is the generally accepted
definition, various disciplines have adopted their own more specific explanation and uses of the term.

Libraries
Metadata has been used in various forms as a means of cataloging archived information. The Dewey Decimal
System employed by libraries for the classification of library materials is an early example of metadata usage.
Library catalogues used 3x5 inch cards to display a book's title, author, subject matter, and a brief plot synopsis
along with an abbreviated alpha-numeric identification system which indicated the physical location of the book
within the library's shelves. Such data helps classify, aggregate, identify, and locate a particular book. Another form
of older metadata collection is the use by US Census Bureau of what is known as the "Long Form." The Long Form
asks questions that are used to create demographic data to create patterns and to find patterns of distribution.[7] For
the purposes of this article, an "object" refers to any of the following:
• A physical item such as a book, CD, DVD, map, chair, table, flower pot, etc.
• An electronic file such as a digital image, digital photo, document, program file, database table, etc.

Photographs
Metadata may be written into a digital photo file that will identify who owns it, copyright & contact information,
what camera created the file, along with exposure information and descriptive information such as keywords about
the photo, making the file searchable on the computer and/or the Internet. Some metadata is written by the camera
and some is input by the photographer and/or software after downloading to a computer. However, not all digital
cameras enable you to edit metadata[8]; this functionality has been available on most Nikon DSLRs since the Nikon
D3 and on most new Canon cameras since the Canon EOS 7D.
Photographic Metadata Standards are governed by organizations that develop the following standards. They include,
but are not limited to:
• IPTC Information Interchange Model IIM (International Press Telecommunications Council),
• IPTC Core Schema for XMP
• XMP – Extensible Metadata Platform (an Adobe standard)
• Exif – Exchangeable image file format, Maintained by CIPA (Camera & Imaging Products Association) and
published by JEITA (Japan Electronics and Information Technology Industries Association)
• Dublin Core (Dublin Core Metadata Initiative – DCMI)
• PLUS (Picture Licensing Universal System).
Metadata 18

Video
Metadata is particularly useful in video, where information about its contents (such as transcripts of conversations
and text descriptions of its scenes) are not directly understandable by a computer, but where efficient search is
desirable.

Web pages
Web pages often include metadata in the form of meta tags. Description and keywords meta tags are commonly used
to describe the Web page's content. Most search engines use this data when adding pages to their search index.

Creation of metadata
Metadata can be created either by automated information processing or by manual work. Elementary metadata
captured by computers can include information about when a file was created, who created it, when it was last
updated, file size and file extension.

Metadata types
The metadata application is manyfold covering a large variety of fields of application there are nothing but
specialised and well accepted models to specify types of metadata. Bretheron & Singley (1994) distinguish between
two distinct classes: structural/control metadata and guide metadata.[9] Structural metadata is used to describe the
structure of computer systems such as tables, columns and indexes. Guide metadata is used to help humans find
specific items and is usually expressed as a set of keywords in a natural language. According to Ralph Kimball
metadata can be divided into 2 similar categories—Technical metadata and Business metadata. Technical metadata
correspond to internal metadata, business metadata to external metadata. Kimball adds a third category named
Process metadata. On the other hand, NISO distinguishes between three types of metadata: descriptive, structural
and administrative.[6] Descriptive metadata is the information used to search and locate an object such as title,
author, subjects, keywords, publisher; structural metadata gives a description of how the components of the object
are organised; and administrative metadata refers to the technical information including file type. Two sub-types
of administrative metadata are rights management metadata and preservation metadata.

Metadata structures
Metadata (metacontent), or more correctly, the vocabularies used to assemble metadata (metacontent) statements, is
typically structured according to a standardized concept using a well-defined metadata scheme, including: metadata
standards and metadata models. Tools such as controlled vocabularies, taxonomies, thesauri, data dictionaries and
metadata registries can be used to apply further standardization to the metadata. Structural metadata commonality is
also of paramount importance in data model development and in database design.

Metadata syntax
Metadata (metacontent) syntax refers to the rules created to structure the fields or elements of metadata
(metacontent).[10] A single metadata scheme may be expressed in a number of different markup or programming
languages, each of which requires a different syntax. For example, Dublin Core may be expressed in plain text,
HTML, XML and RDF.[11]
A common example of (guide) metacontent is the bibliographic classification, the subject, the Dewey Decimal class
number. There is always an implied statement in any "classification" of some object. To classify an object as, for
example, Dewey class number 514 (Topology) (e.g. a book has this number on the spine) the implied statement is:
"<book><subject heading><514>. This is a subject-predicate-object triple, or more importantly, a
class-attribute-value triple. The first two elements of the triple (class, attribute) are pieces of some structural
Metadata 19

metadata having a defined semantic. The third element is a value, preferably from some controlled vocabulary, some
reference (master) data. The combination of the metadata and master data elements results in a statement which is a
metacontent statement i.e. "metacontent = metadata + master data". All these elements can be thought of as
"vocabulary". Both metadata and master data are vocabularies which can be assembled into metacontent statements.
There are many sources of these vocabularies, both meta and master data: UML, EDIFACT, XSD,
Dewey/UDC/LoC, SKOS, ISO-25964, Pantone, Linnaean Binomial Nomenclature etc. Using controlled
vocabularies for the components of metacontent statements, whether for indexing or finding, is endorsed by
ISO-25964 [12]: "If both the indexer and the searcher are guided to choose the same term for the same concept, then
relevant documents will be retrieved." This is particularly relevant when considering that the behemoth of the
internet, Google, is simply indexing then matching text strings, there is no intelligence or "inferencing" occurring.

Hierarchical, linear and planar schemata

Metadata schema can be hierarchical in nature where relationships exist between metadata elements and elements are
nested so that parent-child relationships exist between the elements. An example of a hierarchical metadata schema
is the IEEE LOM schema where metadata elements may belong to a parent metadata element. Metadata schema can
also be one dimensional, or linear, where each element is completely discrete from other elements and classified
according to one dimension only. An example of a linear metadata schema is Dublin Core schema which is one
dimensional. Metadata schema are often two dimensional, or planar, where each element is completely discrete from
other elements but classified according to two orthogonal dimensions.[13]

Metadata hypermapping
In all cases where the metadata schemata exceed the planar depiction, some type of hypermapping is required to
enable display and view of metadata according to chosen aspect and to serve special views. Hypermapping
frequently applies to layering of geographical and geological information overlays.[14]

Granularity
Granularity is a term that applies to data as well as to metadata. The degree to which metadata is structured is
referred to as its granularity. Metadata with a high granularity allows for deeper structured information and enables
greater levels of technical manipulation however, a lower level of granularity means that metadata can be created for
considerably lower costs but will not provide as detailed information. The major impact of granularity is not only on
creation and capture, but moreover on maintenance. As soon as the metadata structures get outdated, the access to
the referred data will get outdated. Hence granularity shall take into account the effort to create as well as the effort
to maintain.

Metadata standards
International standards apply to metadata. Much work is being accomplished in the national and international
standards communities, especially ANSI (American National Standards Institute) and ISO (International
Organization for Standardization) to reach consensus on standardizing metadata and registries.
The core standard is ISO/IEC 11179-1:2004 [15] and subsequent standards (see ISO/IEC 11179). All yet published
registrations according to this standard cover just the definition of metadata and do not serve the structuring of
metadata storage or retrieval neither any administrative standardisation. It is important to note that this standard
refers to metadata as data about containers of data and not to metadata (metacontent) as data about data contents. It
should also be noted that this standard describes itself originally as a "data element" registry, describing disembodied
data elements, and explicitly disavows the capability of containing complex structures. Thus the original term "data
element" is more applicable than the later applied buzzword "metadata".
Metadata 20

Metadata usage

Data Virtualization
Data Virtualization has emerged as the new software technology to complete the virtualization stack in the
enterprise. Metadata is used in Data Virtualization servers which are enterprise infrastructure components, alongside
Database and Application servers. Metadata in these servers is saved as persistent repository and describes business
objects in various enterprise systems and applications. Structural metadata commonality is also important to support
data virtualization and data federation.

SVN Checkout Metadata

.SVN hidden files created in the web root folder which can reveal crucial information of the code repositories.

Statistics and census services

Standardization work has had a large impact on efforts to build metadata systems in the statistical community.
Several metadata standards are described, and their importance to statistical agencies is discussed. Applications of
the standards at the Census Bureau, Environmental Protection Agency, Bureau of Labor Statistics, Statistics Canada,
and many others are described. Emphasis is on the impact a metadata registry can have in a statistical agency.

Library and information science

Libraries employ metadata in library catalogues, most commonly as part of an Integrated Library Management
System. Metadata is obtained by cataloguing resources such as books, periodicals, DVDs, web pages or digital
images. This data is stored in the integrated library management system, ILMS, using the MARC metadata standard.
The purpose is to direct patrons to the physical or electronic location of items or areas they seek as well as to provide
a description of the item/s in question.
More recent and specialized instances of library metadata include the establishment of digital libraries including
e-print repositories and digital image libraries. While often based on library principles the focus on non-librarian use,
especially in providing metadata means they do not follow traditional or common cataloging approaches. Given the
custom nature of included materials metadata fields are often specially created e.g. taxonomic classification fields,
location fields, keywords or copyright statement. Standard file information such as file size and format are usually
automatically included.[16]
Standardization for library operation has been a key topic in international standardization (ISO) for decades.
Standards for metadata in digital libraries include Dublin Core, METS, MODS, DDI, ISO standard Digital Object
Identifier (DOI), ISO standard Uniform Resource Name (URN), PREMIS schema, Ecological Metadata Language,
and OAI-PMH. Leading libraries in the world give hints on their metadata standards strategies.[17][18]

Metadata and the law

United States
Problems involving metadata in litigation in the United States are becoming widespread. Courts have looked at
various questions involving metadata, including the discoverability of metadata by parties. Although the Federal
Rules of Civil Procedure have only specified rules about electronic documents, subsequent case law has elaborated
on the requirement of parties to reveal metadata.[19] In October 2009, the Arizona Supreme Court has ruled that
metadata records are public record.[20]
Document Metadata has proven particularly important in legal environments in which litigation has requested
metadata, which can include sensitive information detrimental to a party in court.
Metadata 21

Using metadata removal tools to "clean" documents can mitigate the risks of unwittingly sending sensitive data. This
process partially (see Data remanence) protects law firms from potentially damaging leaking of sensitive data
through Electronic Discovery.

Metadata in healthcare
Australian researches in medicine started a lot of metadata definition for applications in health care. That approach
offers the first recognized attempt to adhere to international standards in medical sciences instead of defining a
proprietary standard under the WHO umbrella first.
The medical community yet did not approve the need to follow metadata standards despite respective research.[21]

Metadata and data warehousing

Data warehouse (DW) is a repository of an organization's electronically stored data. Data warehouses are designed to
manage and store the data whereas the Business Intelligence (BI) focuses on the usage of data to facilitate reporting
and analysis.[22]
The purpose of a data warehouse is to house standardized, structured, consistent, integrated, correct, cleansed and
timely data, extracted from various operational systems in an organization. The extracted data is integrated in the
data warehouse environment in order to provide an enterprise wide perspective, one version of the truth. Data is
structured in a way to specifically address the reporting and analytic requirements. The design of structural metadata
commonality using a data modeling method such as entity relationship model diagraming is very important in any
data warehouse development effort.
An essential component of a data warehouse/business intelligence system is the metadata and tools to manage and
retrieve metadata. Ralph Kimball[23] describes metadata as the DNA of the data warehouse as metadata defines the
elements of the data warehouse and how they work together.
Kimball et al.[24] refers to three main categories of metadata: Technical metadata, business metadata and process
metadata. Technical metadata is primarily definitional while business metadata and process metadata are primarily
descriptive. Keep in mind that the categories sometimes overlap.
• Technical metadata defines the objects and processes in a DW/BI system, as seen from a technical point of view.
The technical metadata includes the system metadata which defines the data structures such as: Tables, fields,
data types, indexes and partitions in the relational engine, and databases, dimensions, measures, and data mining
models. Technical metadata defines the data model and the way it is displayed for the users, with the reports,
schedules, distribution lists and user security rights.
• Business metadata is content from the data warehouse described in more user-friendly terms. The business
metadata tells you what data you have, where it comes from, what it means and what its relationship is to other
data in the data warehouse. Business metadata may also serves as documentation for the DW/BI system. Users
who browse the data warehouse are primarily viewing the business metadata.
• Process metadata is used to describe the results of various operations in the data warehouse. Within the ETL
process all key data from tasks are logged on execution. This includes start time, end time, CPU seconds used,
disk reads, disk writes and rows processed. When troubleshooting the ETL or query process, this sort of data
becomes valuable. Process metadata is the fact measurement when building and using a DW/BI system. Some
organizations make a living out of collecting and selling this sort of data to companies - in that case the process
metadata becomes the business metadata for the fact and dimension tables. Process metadata is in interest of
business people who can use the data to identify the users of their products, which products they are using and
what level of service they are receiving.
Metadata 22

Metadata on the Internet

The HTML format used to define web pages allows for the inclusion of a variety of types of metadata, from basic
descriptive text, dates and keywords to further advanced metadata schemes such as the Dublin Core, e-GMS, and
AGLS[25] standards. Pages can also be geotagged with coordinates. Metadata may be included in the page's header
or in a separate file. Microformats allow metadata to be added to on-page data in a way that users do not see, but
computers can readily access.
Interestingly, many search engines are cautious about using metadata in their ranking algorithms due to exploitation
of metadata and the practice of search engine optimization, SEO, to improve rankings. See Meta element article for
further discussion. Studies show that search engines respond to web pages with metadata implementations[26].

Metadata on the broadcast industry

In broadcast industry, metadata are linked to audio and video Broadcast media to:
• identify the media: clip or playlist names, duration, timecode, etc.
• describe the content: notes regarding the quality of video content, rating, description (for example, during a sport
event, keywords like goal, red card will be associated to some clips)
• classify media: metadata allow to sort the media or to easily and quickly find a video content (a TV news could
urgently need some archive content for a subject). For example, the BBC have a large subject classification
system, Lonclass, a customized version of the more general-purpose Universal Decimal Classification.
These metadata can be linked to the video media thanks to the video servers. All last broadcasted sport events like
FIFA World Cup or Olympic Games use these metadata to distribute their video content to TV stations through
keywords. It's often the host broadcaster[27] who is in charge of organizing metadata through its International
Broadcast Centre and its video servers. Those metadata are recorded with the images and are entered by metadata
operators (loggers) who associate in live metadata available in metadata grids through software (such as
Multicam(LSM) or IPDirector used during FIFA World Cup or Olympic Games).[28][29]

Geospatial metadata
Metadata that describe geographic objects (such as datasets, maps, features, or simply documents with a geospatial
component) have a history dating back to at least 1994 (refer MIT Library page on FGDC Metadata [30]). This class
of metadata is described more fully on the Geospatial metadata page.

Ecological & environmental metadata

Ecological and environmental metadata are intended to document the who, what, when, where, why, and how of data
collection for a particular study. Metadata should be generated in a format commonly used by the most relevant
science community, such as Darwin Core, Ecological Metadata Language,[31] or Dublin Core. Metadata editing tools
exist to facilitate metadata generation (e.g. Metavist,[32] Mercury: Metadata Search System, Morpho[33]). Metadata
should describe provenance of the data (where it originated, as well as any transformations the data underwent) and
how to give credit for (cite) the data products.
Metadata 23

Metadata on CDs and DVDs

CDs such as recordings of music will carry a layer of metadata about the recordings such as dates, artist, genre,
copyright owner, etc. The metadata, not normally displayed by CD players, can be accessed and displayed by
specialized music playback and/or editing applications.

Cloud applications
With the availability of Cloud applications, which include those to add metadata to content, metadata is increasingly
available over the Internet.

Metadata administration and management

Metadata storage
Metadata can be stored either internally,[34] in the same file as the data, or externally, in a separate file. Metadata that
is embedded with content is called embedded metadata. A data repository typically stores the metadata detached
from the data. Both ways have advantages and disadvantages:
• Internal storage allows transferring metadata together with the data it describes; thus, metadata is always at hand
and can be manipulated easily. This method creates high redundancy and does not allow holding metadata
together.
• External storage allows bundling metadata, for example in a database, for more efficient searching. There is no
redundancy and metadata can be transferred simultaneously when using streaming. However, as most formats use
URIs for that purpose, the method of how the metadata is linked to its data should be treated with care. What if a
resource does not have a URI (resources on a local hard disk or web pages that are created on-the-fly using a
content management system)? What if metadata can only be evaluated if there is a connection to the Web,
especially when using RDF? How to realize that a resource is replaced by another with the same name but
different content?
Moreover, there is the question of data format: storing metadata in a human-readable format such as XML can be
useful because users can understand and edit it without specialized tools. On the other hand, these formats are not
optimized for storage capacity; it may be useful to store metadata in a binary, non-human-readable format instead to
speed up transfer and save memory.

Database management
Each relational database system has its own mechanisms for storing metadata. Examples of relational-database
metadata include:
• Tables of all tables in a database, their names, sizes and number of rows in each table.
• Tables of columns in each database, what tables they are used in, and the type of data stored in each column.
In database terminology, this set of metadata is referred to as the catalog. The SQL standard specifies a uniform
means to access the catalog, called the information schema, but not all databases implement it, even if they
implement other aspects of the SQL standard. For an example of database-specific metadata access methods, see
Oracle metadata. Programmatic access to metadata is possible using APIs such as JDBC, or SchemaCrawler.[35]
Metadata 24

• Agris: International Information System for the Agricultural Sciences and • Metadata publishing
Technology
• Classification scheme • Metadata registry
• Crosswalk (metadata) • METAFOR Common Metadata for Climate Modelling Digital
Repositories
• DataONE • Microcontent
• Data Dictionary (aka metadata repository) • Microformat
• Dublin Core • Multicam(LSM)
• Folksonomy • Ontology (computer science)
• GEOMS – Generic Earth Observation Metadata Standard • Official statistics
• IPDirector • Paratext
• ISO/IEC 11179 • Preservation Metadata
• Knowledge tag • SDMX
• Mercury: Metadata Search System • Semantic Web
• Meta element • SGML
• Metadata Access Point Interface • The Metadata Company
• Metadata discovery • Universal Data Element Framework
• Metadata facility for Java • Vocabulary OneSource
• Metadata from Wikiversity • XSD

References
[1] Hüner, K.; Otto, B.; Österle, H.: Collaborative management of business metadata, in: International Journal of Information Management, 2011
[2] "Metadata Standards And Metadata Registries: An Overview" (http:/ / www. bls. gov/ ore/ pdf/ st000010. pdf) (PDF). . Retrieved
2011-12-23.
[3] Extension of programming language concepts, http:/ / www. dtic. mil/ dtic/ tr/ fulltext/ u2/ 680815. pdf
[4] Bagley, Philip (Nov 1968), Extension of programming language concepts, Philadelphia: University City Science Center
[5] "The notion of "metadata" introduced by Bagley". Solntseff, N+1; Yezerski, A (1974), A survey of extensible programming languages,
Annual Review in Automatic Programming, 7, Elsevier Science Ltd, pp. 267–307, doi:10.1016/0066-4138(74)90001-9
[6] NISO. Understanding Metadata (http:/ / www. niso. org/ publications/ press/ UnderstandingMetadata. pdf). NISO Press.
ISBN 1-880124-62-9. . Retrieved 5 January 2010.
[7] National Archives of Australia (2002). "AGLS Metadata Element Set - Part 2: Usage Guide - A non-technical guide to using AGLS metadata
for describing resources" (http:/ / www. naa. gov. au/ records-management/ publications/ agls-element. aspx). . Retrieved 17 March 2010.
[8] Rutter, Chris. "What is metadata: copyright photos in 4 steps" (http:/ / www. digitalcameraworld. com/ 2012/ 02/ 28/
what-is-metadata-copyright-photos-in-4-steps/ ). Digital Camera Magazine. Future Publishing. .
[9] Bretherton, F. P.; Singley, P.T. (1994). "Metadata: A User's View, Proceedings of the International Conference on Very Large Data Bases
(VLDB)". pp. 1091–1094.
[10] Cathro, Warwick (1997). "Metadata: an overview" (http:/ / www. nla. gov. au/ nla/ staffpaper/ cathro3. html). . Retrieved 6 January 2010.
[11] DCMI (5 Oct 2009). "Semantic Recommendations" (http:/ / dublincore. org/ specifications/ ). . Retrieved 6 January 2010.
[12] http:/ / www-personal. umich. edu/ ~kdow/ ISO_CD_25964-1(E). pdf
[13] "Types of Metadata" (http:/ / www. infodiv. unimelb. edu. au/ metadata/ add_info. html). University of Melbourne. 15 August 2006. .
Retrieved 6 January 2010.
[14] THE DESIGN AND DEVELOPMENT OF A GEOLOGIC HYPERMAP PROTOTYPE (http:/ / www. isprs. org/ proceedings/ XXXII/
part4/ www. ifp. uni. . . / kuebler51. pdf)
[15] "ISO/IEC 11179-1:2004 Information technology - Metadata registries (MDR) - Part 1: Framework" (http:/ / www. iso. org/ iso/
iso_catalogue/ catalogue_tc/ catalogue_detail. htm?csnumber=39438). Iso.org. 2009-03-18. . Retrieved 2011-12-23.
[16] Solodovnik, I. (2011). " Metadata issues in Digital Libraries: key concepts and perspectives (http:/ / leo. cilea. it/ index. php/ jlis/ article/
view/ 4663)". JLIS.It, 2(2). doi:10.4403/jlis.it-4663
[17] Library of Congress Network Development and MARC Standards Office (2005-09-08). "Library of Congress Washington DC on metadata"
(http:/ / www. loc. gov/ standards/ metadata. html). Loc.gov. . Retrieved 2011-12-23.
[18] Deutsche Nationalbibliothek Frankfurt on metadata (http:/ / www. d-nb. de/ standardisierung/ . . . / metadaten. htm)
[19] Gelzer, Reed D. (February 2008). "Metadata, Law, and the Real World: Slowly, the Three Are Merging" (http:/ / library. ahima. org/ xpedio/
groups/ public/ documents/ ahima/ bok1_036537. hcsp?dDocName=bok1_036537). Journal of AHIMA (American Health Information
Management Association) 79 (2): 56–57, 64. . Retrieved 8 January 2010.
Metadata 25

[20] Walsh, Jim (30 October 2009). "Ariz. Supreme Court rules electronic data is public record" (http:/ / www. azcentral. com/ arizonarepublic/
local/ articles/ 2009/ 10/ 30/ 20091030metadata1030. html). The Arizona Republic (Arizona, United States). . Retrieved 8 January 2010.
[21] M. Löbe, M. Knuth, R. Mücke TIM: A Semantic Web Application for the Specification of Metadata Items in Clinical Research (http:/ /
ceur-ws. org/ Vol-559/ Paper1. pdf), CEUR-WS.org, urn:nbn:de:0074-559-9
[22] Inmon, W.H. Tech Topic: What is a Data Warehouse? Prism Solutions. Volume 1. 1995.
[23] Kimball, Ralph (2008). The Data Warehouse Lifecycle Toolkit (Second Edition ed.). New York: Wiley. pp. 10, 115–117, 131–132, 140,
154–155. ISBN 978-0-470-14977-5.
[24] Kimball 2008
[25] National Archives of Australia, AGLS Metadata Standard, accessed 7 January 2010, (http:/ / www. naa. gov. au/ records-management/
create-capture-describe/ describe/ AGLS/ index. aspx)
[26] The impact of webpage content characteristics on webpage visibility in search engine results http:/ / web. simmons. edu/ ~braun/ 467/
part_1. pdf
[27] "HBS is the FIFA host broadcaster" (http:/ / www. hbs. tv/ hostbroadcasting/ ). Hbs.tv. 2011-08-06. . Retrieved 2011-12-23.
[28] Host Broadcast Media Server and Related Applications (http:/ / www. evs-global. com/ 01/ MyDocuments/
CS_BOB_EVScontributon_0808_ENG. pdf)
[29] "logs during sport events" (http:/ / broadcastengineering. com/ worldcup/ fifa-world-cup-techonlogy-0610/ ). Broadcastengineering.com. .
Retrieved 2011-12-23.
[30] http:/ / libraries. mit. edu/ guides/ subjects/ metadata/ standards/ fgdc. html
[31] http:/ / knb. ecoinformatics. org/ software/ eml/ eml-2. 0. 1/ index. html
[32] "Metavist 2" (http:/ / metavist. djames. net/ ). Metavist.djames.net. . Retrieved 2011-12-23.
[33] "KNB Data :: Morpho" (http:/ / knb. ecoinformatics. org/ morphoportal. jsp). Knb.ecoinformatics.org. 2009-05-20. . Retrieved 2011-12-23.
[34] Dan O'Neill. "ID3.org" (http:/ / id3. org). .
[35] Sualeh Fatehi. "SchemaCrawler" (http:/ / schemacrawler. sourceforge. net/ ). SourceForge. .

External links
• Mercury: Metadata Management, Data Discovery and Access (http://mercury.ornl.gov/ornldaac), managed by
Oak Ridge National Laboratory Distributed Active Archive Center
• Metacrap: Putting the torch to seven straw-men of the meta-utopia (http://www.well.com/~doctorow/
metacrap.htm) – Cory Doctorow's opinion on the limitations of metadata on the Internet, 2001
• Retrieving Meta Data from Documents and Pictures Online (http://www.anonwatch.com/?p=9) - AnonWatch
• Understanding Metadata (http://www.niso.org/publications/press/UnderstandingMetadata.pdf) - NISO, 2004
• DataONE (http://www.dataone.org) Investigator Toolkit
• Journal of Library Metadata (Routledge, Taylor & Francis Group). ISSN 1937-5034. http://www.
informaworld.com/openurl?genre=journal&issn=1938-6389. Retrieved 8 January 2010.
• International Journal of Metadata, Semantics and Ontologies (IJMSO) (Inderscience Publishers).
ISSN 1744-263X. http://www.inderscience.com/ijmso. Retrieved 8 January 2010.
• AFC2IC Vocabulary OneSource Tool (https://gcic.af.mil/onesource)
• On metadata and metacontent (http://www.metalounge.org/_literature_52579/
Stephen_Machin_–_ON_METADATA_AND_METACONTENT)
• Managing Metadata (http://library.caltech.edu/laura/) blog
 26

Databases

Flat file database

A flat file database describes any of various means to encode a database model (most commonly a table) as a single
file (such as .txt or .ini).

Overview
A "flat file" is a plain text or mixed text and
binary file which usually contains one record per
line[2] or 'physical' record (example on disc or
tape). Within such a record, the single fields can
be separated by delimiters, e.g. commas, or have
a fixed length. In the latter case, padding may be
needed to achieve this length. Extra formatting
may be needed to avoid delimiter collision. Example of a flat file model
[1]

There are no structural relationships between the

records.

Typical examples of flat files are /etc/passwd and /etc/group on Unix-like operating systems. Another
example of a flat file is a name-and-address list with the fields Name, Address, and Phone Number.
A list of names, addresses, and phone numbers written on a sheet of paper is a flat file database. This can also be
done with any typewriter or word processor. A spreadsheet or text editor program may be used to implement flat file
databases.

History
The first uses of computing machines were implementations of simple databases. Herman Hollerith conceived the
idea that census data could be represented by holes punched in paper cards and tabulated by machine. He sold his
concept to the US Census Bureau; thus, the Census of 1890 was the first ever computerized database—consisting, in
essence, of thousands of boxes full of punched cards.
Hollerith's enterprise grew into computer giant IBM, which dominated the data processing market for most of the
20th century. IBM's fixed-length field, 80-column punch cards became the ubiquitous means of inputting electronic
data until the 1970s.
In the 1980s, configurable flat-file database computer applications were popular on DOS and the Macintosh. These
programs were designed to make it easy for individuals to design and use their own databases, and were almost on
par with word processors and spreadsheets in popularity. Examples of flat-file database products were early versions
of FileMaker and the shareware PC-File. Some of these, like dBase II, offered limited relational capabilities,
allowing some data to be shared between files.
Flat file database 27

Contemporary implementations
FairCom's c-tree is an example of a modern enterprise-level solution, and spreadsheet software is often used for this
purpose, but aside from that there are very few programs available today that would allow a novice to create and use
a general-purpose flat file database. WebDNA is one of them: it is a scripting language designed for the World Wide
Web, with an hybrid flat file in-memory databases system making easy to build resilient database-driven websites.
With the in-memory concept, WebDNA searches and database updates are almost realtime while the data is stored as
text files within the website itself. Otherwise, flat file database is implemented in Microsoft Works (available only
for some versions of Windows) and Apple Works, sometimes named ClarisWorks Office (available for Macintosh
and some versions on the Windows platform). Over time, products like Borland's Paradox, and Microsoft's Access
started offering some relational capabilities, as well as built-in programming languages. Database Management
Systems (DBMS) like MySQL or Oracle generally require programmers to build applications.
Flat file databases are still used internally by many computer applications to store configuration data. Many
applications allow users to store and retrieve their own information from flat files using a pre-defined set of fields.
Examples are programs to manage collections of books or appointments. Some small address book applications are
essentially single-purpose flat file databases. As of 2011 one of the most popular flat file database engines is the
SQLite, which is part of the PHP5 standard distribution.

Data transfer operations

Flat Files are used not only as data storage tools in DB and CMS systems, but also as data transfer tools to remote
servers (in which case they become known as information streams). In recent years, this latter implementation has
been replaced with XML files, which not only contain but also describe the data. Those still using Flat Files to
transfer information are mainframes employing specific procedures that nobody dares to modify. One criticism often
raised against the XML format as a way to perform mass data transfer operations is that file size is significantly
larger with respect to that of Flat Files, which is generally reduced to the bare minimum. The solution to this
problem consists in XML file compression (a solution that applies equally well to Flat Files), which has nowadays
gained EXI standards (i.e., Efficient XML Interchange, which is often used by mobile devices). It is advisable that
transfer data be performed via EXI rather than Flat Files because defining the compression method is not required,
because libraries reading the file contents are readily available, and because there is no need for the two
communicating systems to preliminarily establish a protocol describing data properties such as position, alignment,
type, format, etc. However, in those circumstances where the sheer mass of data and/or the inadequacy of legacy
systems becomes a problem, the only viable solution remains the use of Flat Files. In order to successfully handle
those problems connected with data communication, format, validation, control and much else (be it a Flat File or an
XML file data source), it is advisable to adopt a Data Quality Firewall.
XML is being gradually replaced by JSON, YAML and possibly other structured text formats.

Terms
"Flat file database" may be defined very narrowly, or more broadly. The narrower interpretation is correct in
database theory; the broader covers the term as generally used.
Strictly, a flat file database should consist of nothing but data and, if records vary in length, delimiters. More
broadly, the term refers to any database which exists in a single file in the form of rows and columns, with no
relationships or links between records and fields except the table structure.
Terms used to describe different aspects of a database and its tools differ from one implementation to the next, but
the concepts remain the same. FileMaker uses the term "Find", while MySQL uses the term "Query"; but the concept
is the same. FileMaker "files", in version 7 and above, are equivalent to MySQL "databases", and so forth. To avoid
confusing the reader, one consistent set of terms is used throughout this article.
Flat file database 28

However, the basic terms "record" and "field" are used in nearly every flat file database implementation.

Example database
The following example illustrates the basic elements of a flat-file database. The data arrangement consists of a series
of columns and rows organized into a tabular format. This specific example uses only one table.
The columns include: name (a person's name, second column); team (the name of an athletic team supported by the
person, third column); and a numeric unique ID, (used to uniquely identify records, first column).
Here is an example textual representation of the described data:

id name team
1 Amy Blues
2 Bob Reds
3 Chuck Blues
4 Dick Blues
5 Ethel Reds
6 Fred Blues
7 Gilly Blues
8 Hank Reds

This type of data representation is quite standard for a flat-file database, although there are some additional
considerations that are not readily apparent from the text:
• Data types: each column in a database table such as the one above is ordinarily restricted to a specific data type.
Such restrictions are usually established by convention, but not formally indicated unless the data is transferred to
a relational database system.
• Separated columns: In the above example, individual columns are separated using whitespace characters. This is
also called indentation or "fixed-width" data formatting. Another common convention is to separate columns
using one or more delimiter characters. There are many different conventions for depicting data such as that above
in text. (See e.g., Comma-separated values, Delimiter-separated values, Markup language, Programming
language). Using delimiters incurs some overhead in locating them every time they are processed (unlike
fixed-width formatting) which may have some performance implications. However, use of character delimiters
(especially commas) is also a crude form of data compression which may assist overall performance by reducing
data volumes - especially for data transmission purposes. Use of character delimiters which include a length
component (Declarative notation) is comparatively rare but vastly reduces the overhead associated with locating
the extent of each field.
• Relational algebra: Each row or record in the above table meets the standard definition of a tuple under
relational algebra (the above example depicts a series of 3-tuples). Additionally, the first row specifies the field
names that are associated with the values of each row.
• Database management system: Since the formal operations possible with a text file are usually more limited
than desired, the text in the above example would ordinarily represent an intermediary state of the data prior to
being transferred into a database management system.
Flat file database 29

References
[1] Data Integration Glossary (http:/ / knowledge. fhwa. dot. gov/ tam/ aashto. nsf/ All+ Documents/ 4825476B2B5C687285256B1F00544258/
$FILE/ DIGloss. pdf), U.S. Department of Transportation, August 2001.
[2] Fowler, Glenn (1994), "cql: Flat file database query language" (http:/ / www. research. att. com/ ~gsf/ publications/ cql-1994. pdf), WTEC'94:
Proceedings of the USENIX Winter 1994 Technical Conference on USENIX Winter 1994 Technical Conference, record

Relational database
A relational database is a collection of data items organized as a set
of formally described tables from which data can be accessed easily. A
relational database is created using the relational model. The software
used in a relational database is called a relational database management
system (RDBMS). A relational database is the predominant choice in A visual diagram showing the relationship
storing data, over other models like the hierarchical database model or between the two tables, as indicated by the arrow
the network model.

Contents

Terminology
The term relational database was originally defined by and is attributed to Edgar Codd at IBM Almaden Research
Center in 1970.[1]
Relational database theory uses a set of
mathematical terms, which are roughly
equivalent to SQL database
terminology. The table below
summarizes some of the most
important relational database terms and
their SQL database equivalents.

Relational database terminology.

Relational term SQL equivalent

relation, base relvar table

derived relvar view, query result, result set

tuple row

attribute column
Relational database 30

Relations or Tables
A relation is defined as a set of tuples that have the same attributes. A tuple usually represents an object and
information about that object. Objects are typically physical objects or concepts. A relation is usually described as a
table, which is organized into rows and columns. All the data referenced by an attribute are in the same domain and
conform to the same constraints.
The relational model specifies that the tuples of a relation have no specific order and that the tuples, in turn, impose
no order on the attributes. Applications access data by specifying queries, which use operations such as select to
identify tuples, project to identify attributes, and join to combine relations. Relations can be modified using the
insert, delete, and update operators. New tuples can supply explicit values or be derived from a query. Similarly,
queries identify tuples for updating or deleting. It is necessary for each tuple of a relation to be uniquely identifiable
by some combination (one or more) of its attribute values. This combination is referred to as the primary key.

Base and derived relations

In a relational database, all data are stored and accessed via relations. Relations that store data are called "base
relations", and in implementations are called "tables". Other relations do not store data, but are computed by
applying relational operations to other relations. These relations are sometimes called "derived relations". In
implementations these are called "views" or "queries". Derived relations are convenient in that though they may grab
information from several relations, they act as a single relation. Also, derived relations can be used as an abstraction
layer.

Domain
A domain describes the set of possible values for a given attribute, and can be considered a constraint on the value of
the attribute. Mathematically, attaching a domain to an attribute means that any value for the attribute must be an
element of the specified set.
The character data value 'ABC', for instance, is not in the integer domain. The integer value 123, satisfies the domain
constraint.

Constraints
Constraints make it possible to further restrict the domain of an attribute. For instance, a constraint can restrict a
given integer attribute to values between 1 and 10. Constraints provide one method of implementing business rules
in the database. SQL implements constraint functionality in the form of check constraints.
Constraints restrict the data that can be stored in relations. These are usually defined using expressions that result in
a boolean value, indicating whether or not the data satisfies the constraint. Constraints can apply to single attributes,
to a tuple (restricting combinations of attributes) or to an entire relation.
Since every attribute has an associated domain, there are constraints (domain constraints). The two principal rules
for the relational model are known as entity integrity and referential integrity. ('"Referential integrity is the state in
which all values of all foreign keys are valid. Referential integrity is based on entity integrity. Entity integrity
requires that each entity have a unique key. For example, if every row in a table represents relationships for a unique
entity, the table should have one column or a set of columns that provides a unique identifier for the rows of the
table. This column (or set of columns) is called the parent key of the table. To ensure that the parent key does not
contain duplicate values, a unique index must be defined on the column or columns that constitute the parent key.
Defining the parent key is called entity integrity"')
Relational database 31

Primary keys
A primary key uniquely defines a relationship within a database. In order for an attribute to be a good primary key it
must not repeat. While natural attributes are sometimes good primary keys, surrogate keys are often used instead. A
surrogate key is an artificial attribute assigned to an object which uniquely identifies it (for instance, in a table of
information about students at a school they might all be assigned a student ID in order to differentiate them). The
surrogate key has no intrinsic (inherent) meaning, but rather is useful through its ability to uniquely identify a tuple.
Another common occurrence, especially in regards to N:M cardinality is the composite key. A composite key is a
key made up of two or more attributes within a table that (together) uniquely identify a record. (For example, in a
database relating students, teachers, and classes. Classes could be uniquely identified by a composite key of their
room number and time slot, since no other class could have exactly the same combination of attributes. In fact, use of
a composite key such as this can be a form of data verification, albeit a weak one.)

Foreign key
A foreign key is a field in a relational table that matches the primary key column of another table. The foreign key
can be used to cross-reference tables. Foreign keys need not have unique values in the referencing relation. Foreign
keys effectively use the values of attributes in the referenced relation to restrict the domain of one or more attributes
in the referencing relation.
A foreign key could be described formally as: "For all tuples in the referencing relation projected over the
referencing attributes, there must exist a tuple in the referenced relation projected over those same attributes such
that the values in each of the referencing attributes match the corresponding values in the referenced attributes."

Stored procedures
A stored procedure is executable code that is associated with, and generally stored in, the database. Stored
procedures usually collect and customize common operations, like inserting a tuple into a relation, gathering
statistical information about usage patterns, or encapsulating complex business logic and calculations. Frequently
they are used as an application programming interface (API) for security or simplicity. Implementations of stored
procedures on SQL DBMSs often allow developers to take advantage of procedural extensions (often
vendor-specific) to the standard declarative SQL syntax.
Stored procedures are not part of the relational database model, but all commercial implementations include them.

Index
An index is one way of providing quicker access to data. Indices can be created on any combination of attributes on
a relation. Queries that filter using those attributes can find matching tuples randomly using the index, without
having to check each tuple in turn. This is analogous to using the index of a book to go directly to the page on which
the information you are looking for is found i.e. you do not have to read the entire book to find what you are looking
for. Relational databases typically supply multiple indexing techniques, each of which is optimal for some
combination of data distribution, relation size, and typical access pattern. Indices are usually implemented via B+
trees, R-trees, and bitmaps.
Indices are usually not considered part of the database, as they are considered an implementation detail, though
indices are usually maintained by the same group that maintains the other parts of the database. It should be noted
that use of efficient indexes on both primary and foreign keys can dramatically improve query performance. This is
because B-tree indexes result in query times proportional to log(n) where N is the number of rows in a table and hash
indexes result in constant time queries (no size dependency so long as the relevant part of the index fits into
memory).
Relational database 32

Relational operations
Queries made against the relational database, and the derived relvars in the database are expressed in a relational
calculus or a relational algebra. In his original relational algebra, Codd introduced eight relational operators in two
groups of four operators each. The first four operators were based on the traditional mathematical set operations:
• The union operator combines the tuples of two relations and removes all duplicate tuples from the result. The
relational union operator is equivalent to the SQL UNION operator.
• The intersection operator produces the set of tuples that two relations share in common. Intersection is
implemented in SQL in the form of the INTERSECT operator.
• The difference operator acts on two relations and produces the set of tuples from the first relation that do not exist
in the second relation. Difference is implemented in SQL in the form of the EXCEPT or MINUS operator.
• The cartesian product of two relations is a join that is not restricted by any criteria, resulting in every tuple of the
first relation being matched with every tuple of the second relation. The cartesian product is implemented in SQL
as the CROSS JOIN join operator.
The remaining operators proposed by Codd involve special operations specific to relational databases:
• The selection, or restriction, operation retrieves tuples from a relation, limiting the results to only those that meet
a specific criteria, i.e. a subset in terms of set theory. The SQL equivalent of selection is the SELECT query
statement with a WHERE clause.
• The projection operation extracts only the specified attributes from a tuple or set of tuples.
• The join operation defined for relational databases is often referred to as a natural join. In this type of join, two
relations are connected by their common attributes. SQL's approximation of a natural join is the INNER JOIN
join operator.
• The relational division operation is a slightly more complex operation, which involves essentially using the tuples
of one relation (the dividend) to partition a second relation (the divisor). The relational division operator is
effectively the opposite of the cartesian product operator (hence the name).
Other operators have been introduced or proposed since Codd's introduction of the original eight including relational
comparison operators and extensions that offer support for nesting and hierarchical data, among others.

Normalization
Normalization was first proposed by Codd as an integral part of the relational model. It encompasses a set of
procedures designed to eliminate nonsimple domains (non-atomic values) and the redundancy (duplication) of data,
which in turn prevents data manipulation anomalies and loss of data integrity. The most common forms of
normalization applied to databases are called the normal forms. Normalization trades reducing redundancy for
increased information entropy. Normalization is criticised because it increases complexity and processing overhead
required to join multiple tables representing what are conceptually a single item .

Relational database management systems

Relational databases, as implemented in relational database management systems, have become a predominant
choice for the storage of information in new databases used for financial records, manufacturing and logistical
information, personnel data and much more. Relational databases have often replaced legacy hierarchical databases
and network databases because they are easier to understand and use, even though they are much less efficient. As
computer power has increased, the inefficiencies of relational databases, which made them impractical in earlier
times, have been outweighed by their ease of use. However, relational databases have been challenged by Object
Databases, which were introduced in an attempt to address the object-relational impedance mismatch in relational
database, and XML databases.
Relational database 33

The three leading commercial relational database vendors are Oracle, Microsoft, and IBM.[2] The three leading open
source implementations are MySQL, PostgreSQL, and SQLite. Amazon Relational Database Service is a database as
a service offering MySQL and Oracle database engines.

Watermarking for Relational Databases

Digital watermarking for relational databases emerged as a candidate solution to provide copyright protection,
tamper detection, traitor tracing, maintaining integrity of relational data. Many watermarking techniques have been
proposed in the literature to address these purposes.

Notes
[1] Codd, E.F. (1970). "A Relational Model of Data for Large Shared Data Banks". Communications of the ACM 13 (6): 377–387.
doi:10.1145/362384.362685.
[2] Gartner Says Worldwide Relational Database Market Increased 14 Percent in 2006 (http:/ / www. gartner. com/ it/ page. jsp?id=507466),
includes revenue estimates for leading database companies

References
• Raju Halder, Shantanu Pal, and Agostino Cortesi (2010). "Watermarking Techniques for Relational Databases:
Survey, Classification and Comparison", The Journal of Universal Computer Science, vol 16(21), pp. 3164-3190,
2010.
• Difference between dbms and rdbms. In Scribd. Retrieved April 5, 2012, from http://www.scribd.com/
mandeepdhaliwal/d/37351788-22161565-Difference-Between-Dbms-and-Rdbms
MySQL 34

MySQL
MySQL

Developer(s) Oracle (formerly Sun, formerly MySQL AB)

Initial release 23 May 1995

Stable release [1]

5.5.24 / 7 May 2012

Preview release 5.6.5 / 10 April 2012

Written in [2]
C, C++

Operating system Cross-platform

Available in English

Type RDBMS

License GNU General Public License (version 2, with linking exception) or proprietary EULA

Website [3]
www.mysql.com
[4]
dev.mysql.com

MySQL (  /maɪˌɛskjuːˈɛl/ "My S-Q-L",[5] officially, but also incorrectly called /maɪˈsiːkwəl/ "My Sequel") is the
world's most used[6] relational database management system (RDBMS)[7] that runs as a server providing multi-user
access to a number of databases. It is named after co-founder Michael Widenius' daughter, My.[8] The SQL phrase
stands for Structured Query Language.[9]
The MySQL development project has made its source code available under the terms of the GNU General Public
License, as well as under a variety of proprietary agreements. MySQL was owned and sponsored by a single
for-profit firm, the Swedish company MySQL AB, now owned by Oracle Corporation.[10]
Free-software-open source projects that require a full-featured database management system often use MySQL. For
commercial use, several paid editions are available, and offer additional functionality. Applications which use
MySQL databases include: TYPO3, Joomla, WordPress, phpBB, Drupal and other software built on the LAMP
software stack. MySQL is also used in many high-profile, large-scale World Wide Web products, including
Wikipedia, Google[11] (though not for searches), Facebook,[12] and Twitter.[13]

Uses
MySQL is a popular choice of database for use in web applications, and is a central component of the widely used
LAMP open source web application software stack—LAMP is an acronym for "Linux, Apache, MySQL,
Perl/PHP/Python".
MySQL is an open source database management system and is used in some of the most frequently visited websites
on the Internet, including Flickr,[14] Nokia.com,[15] YouTube[16] and as previously mentioned, Wikipedia,[17]
Google,[18] Facebook[19][20] and Twitter.[13]
MySQL 35

Platforms and interfaces

MySQL is written in C and C++. Its SQL parser is written in yacc, and a home-brewed lexical analyzer named
sql_lex.cc.[21]
MySQL works on many different system platforms, including AIX, BSDi, FreeBSD, HP-UX, eComStation, i5/OS,
IRIX, Linux, Mac OS X, Microsoft Windows, NetBSD, Novell NetWare, OpenBSD, OpenSolaris, OS/2 Warp,
QNX, Solaris, Symbian, SunOS, SCO OpenServer, SCO UnixWare, Sanos and Tru64. A port of MySQL to
OpenVMS also exists.[22]
Many programming languages with language-specific APIs include libraries for accessing MySQL databases. These
include MySQL Connector/Net for integration with Microsoft's Visual Studio (languages such as C# and VB are
most commonly used) and the JDBC driver for Java. In addition, an ODBC interface called MyODBC allows
additional programming languages that support the ODBC interface to communicate with a MySQL database, such
as ASP or ColdFusion. The HTSQL - URL-based query method also ships with a MySQL adapter, allowing direct
interaction between a MySQL database and any web client via structured URLs.

Management and graphical frontends

MySQL is primarily an RDBMS and ships with no GUI tools to
administer MySQL databases or manage data contained within the
databases. Users may use the included command line tools, or
download MySQL front-ends from various parties that have developed
desktop software and web applications to manage MySQL databases,
build database structures, and work with data records.

Official
MySQL Workbench in Windows
The official MySQL Workbench is a free integrated environment
developed by MySQL AB, that enables users to graphically administer
MySQL databases and visually design database structures. MySQL Workbench replaces the previous package of
software, MySQL GUI Tools. Similar to other third-party packages, but still considered the authoritative MySQL
frontend, MySQL Workbench lets users manage the following:
• Database design & modeling
• SQL development – replacing MySQL Query Browser
• Database administration – replacing MySQL Administrator
MySQL Workbench is available in two editions, the regular free and open source Community Edition which may be
downloaded from the MySQL website, and the proprietary Standard Edition which extends and improves the feature
set of the Community Edition.

Third-party
Third-party proprietary and free graphical administration applications (or "front ends") are available that integrate
with MySQL and enable users to work with database structure and data visually. Some well-known front ends, in
alphabetical order, are:
• Adminer – a free MySQL front end written in one PHP script, capable of managing multiple databases, with
many CSS skins available.
• DaDaBIK – an Open Source software, written in PHP, which provides a customizable Web CRUD/front-end to a
database.
• DBEdit – a free front end for MySQL and other databases.
MySQL 36

• dbForge GUI Tools — a set of tools for database management that includes separate applications for schema
comparison and synchronization, data comparison and synchronization, and building queries.
• HeidiSQL – a full featured free front end that runs on Windows, and can connect to local or remote MySQL
servers to manage databases, tables, column structure, and individual data records. Also supports specialised GUI
features for date/time fields and enumerated multiple-value fields.[23]
• LibreOffice Base - LibreOffice Base allows the creation and management of databases, preparation of forms and
reports that provide end users easy access to data. Like Access, it can be used as a front-end for various database
systems, including Access databases (JET), ODBC data sources, and MySQL or PostgreSQL.[24]
• Navicat – a series of proprietary graphical database management applications, developed for Windows,
Macintosh and Linux.
• OpenOffice.org – OpenOffice.org Base can manage MySQL databases. (You must install all of the
OpenOffice.org suite. It is free and open source.)
• phpMyAdmin – a free Web-based front end widely installed by Web hosts worldwide, since it is developed in
PHP and is included in the convenient LAMP stack, MAMP, and WAMP software bundle installers.
• SQLBuddy - a free Web-based front end, developed in PHP.
• Sequel Pro [25] - a free, open-source front end for OS X.
• SQLYog [26] - a free community UI for MySQL.
• Toad for MySQL – a free development and administration front end for MySQL from Quest Software
Other available proprietary MySQL front ends include dbForge Studio for MySQL, Epictetus, Oracle SQL
Developer, SchemaBank, SQLPro SQL Client, Toad Data Modeler,

Command line
MySQL ships with a suite of command-line tools for tasks such as querying the database, backing up data,
inspecting status, performing common tasks such as creating a database, and many more. A variety of third-party
command-line tools is also available, including Maatkit, which is written in Perl.

Deployment
MySQL can be built and installed manually from source code, but this can be tedious so it is more commonly
installed from a binary package unless special customizations are required. On most Linux distributions the package
management system can download and install MySQL with minimal effort, though further configuration is often
required to adjust security and optimization settings.
Though MySQL began as a low-end alternative to more powerful proprietary databases, it has gradually evolved to
support higher-scale needs as well. It is still most commonly used in small to medium scale single-server
deployments, either as a component in a LAMP-based web application or as a standalone database server. Much of
MySQL's appeal originates in its relative simplicity and ease of use, which is enabled by an ecosystem of open
source tools such as phpMyAdmin. In the medium range, MySQL can be scaled by deploying it on more powerful
hardware, such as a multi-processor server with gigabytes of memory.
There are however limits to how far performance can scale on a single server, so on larger scales, multi-server
MySQL deployments are required to provide improved performance and reliability. A typical high-end configuration
can include a powerful master database which handles data write operations and is replicated to multiple slaves that
handle all read operations.[27] The master server synchronizes continually with its slaves so in the event of failure a
slave can be promoted to become the new master, minimizing downtime. Further improvements in performance can
be achieved by caching the results from database queries in memory using memcached, or breaking down a database
into smaller chunks called shards which can be spread across a number of distributed server clusters.[28]
MySQL 37

Cloud-based deployment
Another deployment option is running MySQL on cloud computing platforms such as Amazon EC2. There are two
common deployment models for MySQL on the cloud:
• Virtual Machine Image - cloud users can upload a machine image of their own with MySQL installed, or use a
ready-made machine image with an optimized installation of MySQL on it, such as the one provided by Amazon
EC2.[29]
• MySQL as a Service - some cloud platforms offer MySQL "as a service". In this configuration, application
owners do not have to install and maintain the MySQL database on their own. Instead, the database service
provider takes responsibility for installing and maintaining the database, and application owners pay according to
their usage.[30] Two notable cloud-based MySQL services are the Amazon Relational Database Service, and the
Xeround Cloud Database, which runs on EC2, Rackspace and Heroku.
A third option is managed MySQL hosting on the cloud, where the database is not offered as a service, but the cloud
provider hosts the database and manages it on the application owner's behalf. As of 2011, of the major cloud
providers, only Rackspace offers managed hosting for MySQL databases.[31]

Features
As of April 2009, MySQL offered MySQL 5.1 in two different variants: the open source MySQL Community Server
and the commercial Enterprise Server. MySQL 5.5 is offered under the same licences.[32] They have a common code
base and include the following features:
• A broad subset of ANSI SQL 99, as well as extensions
• Cross-platform support
• Stored procedures
• Triggers
• Cursors
• Updatable Views
• Information schema
• Strict mode
• X/Open XA distributed transaction processing (DTP) support; two phase commit as part of this, using Oracle's
InnoDB engine
• Independent storage engines (MyISAM for read speed, InnoDB for transactions and referential integrity, MySQL
Archive for storing historical data in little space)
• Transactions with the InnoDB, and Cluster storage engines; savepoints with InnoDB
• SSL support
• Query caching
• Sub-SELECTs (i.e. nested SELECTs)
• Replication support (i.e. Master-Master Replication & Master-Slave Replication) with one master per slave, many
slaves per master, no automatic support for multiple masters per slave.
• Full-text indexing and searching using MyISAM engine
• Embedded database library
• Partial Unicode support (UTF-8 and UCS-2 encoded strings are limited to the BMP)
• ACID compliance when using transaction capable storage engines (InnoDB and Cluster)[33]
• Partititoned tables with pruning of partitions in optimiser
• Shared-nothing clustering through MySQL Cluster
• Hot backup (via mysqlhotcopy) under certain conditions[34]
The developers release monthly versions of the MySQL Server. The sources can be obtained from MySQL's website
or from MySQL's Bazaar repository, both under the GPL license.
MySQL 38

Distinguishing features
MySQL implements the following features, which some other RDBMS systems may not:
• Multiple storage engines, allowing one to choose the one that is most effective for each table in the application (in
MySQL 5.0, storage engines must be compiled in; in MySQL 5.1, storage engines can be dynamically loaded at
run time):
• Native storage engines (MyISAM, Falcon, Merge, Memory (heap), Federated, Archive, CSV, Blackhole,
Cluster, EXAMPLE, Maria, and InnoDB, which was made the default as of 5.5)
• Partner-developed storage engines (solidDB, NitroEDB, ScaleDB, TokuDB, Infobright (formerly
Brighthouse), Kickfire, XtraDB, IBM DB2).[35] InnoDB used to be a partner-developed storage engine, but
with recent acquisitions, Oracle now owns both MySQL core and InnoDB.
• Community-developed storage engines (memcache engine, httpd, PBXT, Revision Engine)
• Custom storage engines
• Commit grouping, gathering multiple transactions from multiple connections together to increase the number of
commits per second. (PostgreSQL has an advanced form of this functionality[36])

Limitations
MySQL does not currently comply with the SQL standard for some of the implemented functionality, including
issues like silent ignore of standard SQL syntax, including silent ignore of check constraints, foreign key
references, and other features used to enforce business logic consistency.[37] Triggers are currently limited to one per
action / timing, i.e. maximum one after insert and one before insert on the same table.[38] There are no triggers on
views.[38]

Product history
Milestones in MySQL development include:
• Original development of MySQL by Michael Widenius and David Axmark beginning in 1994[39]
• First internal release on 23 May 1995
• Windows version was released on 8 January 1998 for Windows 95 and NT
• Version 3.19: End of 1996, from www.tcx.se
• Version 3.20: January 1997
• Version 3.21: production release 1998, from www.mysql.com
• Version 3.22: alpha, beta from 1998
• Version 3.23: beta from June 2000, production release 22 January 2001[40]
• Version 4.0: beta from August 2002, production release March 2003 (unions)
• Version 4.01: beta from August 2003, Jyoti adopts MySQL for database tracking
• Version 4.1: beta from June 2004, production release October 2004 (R-trees and B-trees, subqueries, prepared
statements)
• Version 5.0: beta from March 2005, production release October 2005 (cursors, stored procedures, triggers, views,
XA transactions)
The developer of the Federated Storage Engine states that "The Federated Storage Engine is a
proof-of-concept storage engine",[41] but the main distributions of MySQL version 5.0 included it and turned it
on by default. Documentation of some of the short-comings appears in "MySQL Federated Tables: The
Missing Manual".[42]
• Sun Microsystems acquired MySQL AB on 26 February 2008.[10]
• Version 5.1: production release 27 November 2008 (event scheduler, partitioning, plugin API, row-based
replication, server log tables)
MySQL 39

Version 5.1 contained 20 known crashing and wrong result bugs in addition to the 35 present in version 5.0
(almost all fixed as of release 5.1.51).[43]
MySQL 5.1 and 6.0 showed poor performance when used for data warehousing — partly due to its inability to
utilize multiple CPU cores for processing a single query.[44]
• Oracle acquired Sun Microsystems on 27 January 2010.[45]
• MySQL Server 5.5 is currently generally available (as of December 2010). Enhancements and features include:
• The default storage engine is InnoDB, which supports transactions and referential integrity constraints.
• Improved InnoDB I/O subsystem[46]
• Improved SMP support[47]
• Semisynchronous replication.
• SIGNAL and RESIGNAL statement in compliance with the SQL standard.
• Support for supplementary Unicode character sets utf16, utf32, and utf8mb4.
• New options for user-defined partitioning.

Versions

[48][49][50][51][52][53]

Future releases
MySQL Server 6.0.11-alpha was announced[54] on May 22, 2009 as the last release of the 6.0 line. Future MySQL
Server development uses a New Release Model. Features developed for 6.0 are being incorporated into future
releases.
MySQL 5.6, a development milestone release, was announced at the MySQL users conference 2011. New features
include performance improvements to the query optimizer, higher transactional throughput in InnoDB, new
NoSQL-style memcached APIs, improvements to partitioning for querying and managing very large tables,
improvements to replication and better performance monitoring by expanding the data available through the
PERFORMANCE_SCHEMA.[55] In July further previews with a BINLOG API, group commit, and InnoDB full
text searching were released.
MySQL 40

Licensing and support

Both the MySQL server software itself and the client libraries use dual-licensing distribution. They are offered under
GPL,[56] beginning from 28 June 2000[57] (which Oracle has extended with a FLOSS License Exception)[58] or to
use a proprietary license.[59]
First of all support can be obtained from the official manual, which is available at http:/ / dev. mysql. com/ doc/
refman/5.5/en/index.html. Free support additionally is available in different IRC channels and forums.
Apart from that Oracle offers paid support via their MySQL Enterprise products. They differ in the scope of services
and in price.

Corporate backing history

In October 2005, Oracle Corporation acquired Innobase OY, the Finnish company that developed the third-party
InnoDB storage engine that allows MySQL to provide such functionality as transactions and foreign keys. After the
acquisition, an Oracle press release mentioned that the contracts that make the company's software available to
MySQL AB would be due for renewal (and presumably renegotiation) some time in 2006.[60] During the MySQL
Users Conference in April 2006, MySQL issued a press release that confirmed that MySQL and Innobase OY agreed
to a "multi-year" extension of their licensing agreement.[61]
In February 2006, Oracle Corporation acquired Sleepycat Software,[62] makers of the Berkeley DB, a database
engine providing the basis for another MySQL storage engine. This had little effect, as Berkeley DB was not widely
used, and was deprecated (due to lack of use) in MySQL 5.1.12, a pre-GA release of MySQL 5.1 released in October
2006.[63]
In January 2008, Sun Microsystems bought MySQL for $1 billion.[64]
In April 2009, Oracle Corporation entered into an agreement to purchase Sun Microsystems,[65] then owners of
MySQL copyright and trademark. Sun's board of directors unanimously approved the deal, it was also approved by
Sun's shareholders, and by the U.S. government on 20 August 2009.[66] On 14 December 2009, Oracle pledged to
continue to enhance MySQL[67] as it had done for the previous four years.
A movement against Oracle's acquisition of MySQL, to "Save MySQL"[68] from Oracle was started by one of the
MySQL founders, Monty Widenius. The petition of 50,000+ developers and users called upon the European
Commission to block approval of the acquisition. At the same time, several Free Software opinion leaders (including
Eben Moglen, Pamela Jones of Groklaw, Jan Wildeboer and Carlo Piana, who also acted as co-counsel in the merger
regulation procedure) advocated for the unconditional approval of the merger. As part of the negotiations with the
European Commission, Oracle committed that MySQL server will continue to use the dual-licensing strategy long
used by MySQL AB with commercial and GPL versions available until at least 2015. The antitrust of the EU had
been "pressuring it to divest MySQL as a condition for approval of the merger." But, as revealed by Wikileaks, the
US Department of Justice and Antitrust, at the request of Oracle, pressured the EU to unconditionally approve the
merger.[69] The Oracle acquisition was eventually unconditionally approved by the European Commission on 21
January 2010.[70]
Meanwhile, Monty Widenius has released a GPL-only fork, MariaDB. MariaDB is based on the same code base as
MySQL server 5.1 and strives to maintain compatibility with Oracle provided versions.[71]
MySQL 41

Conflict with NuSphere

In 15 June of 2001 NuSphere sued MySQL AB, TcX DataKonsult AB and its original authors Michael Widenius and
David Axmark in U.S District Court in Boston.[72] [73] In 2002, MySQL AB sued Progress NuSphere for copyright
and trademark infringement in United States district court. NuSphere had allegedly violated MySQL's copyright by
linking MySQL's GPL'ed code with NuSphere Gemini table without being in compliance with the license. After a
preliminary hearing before Judge Patti Saris on 27 February 2002, the parties entered settlement talks and eventually
settled.[74] After the hearing, FSF commented that "Judge Saris made clear that she sees the GNU GPL to be an
enforceable and binding license."[75]

Forks
• Drizzle – a fork targeted at the web-infrastructure and cloud computing markets. The developers of the product
describe it as a "smaller, slimmer and (hopefully) faster version of MySQL". As such is planned to have many
common MySQL features stripped out, including stored procedures, query cache, prepared statements, views, and
triggers. This is a complete rewrite of the server that does not maintain compatibility with MySQL.
• MariaDB – a community-developed branch of the MySQL database, the impetus being the community
maintenance of its free status under GPL as opposed to any uncertainty of MySQL license status under its current
ownership by Oracle. The intent also being to maintain high fidelity with MySQL, ensuring a "drop-in"
replacement capability with library binary equivalency and exacting matching with MySQL APIs and commands.
It includes the XtraDB storage engine as a replacement for InnoDB.
• Percona Server – a fork that includes the XtraDB storage engine. It is an enhanced version of MySQL that is fully
compatible, and deviates as little as possible from it, while still providing beneficial new features, better
performance, and improved instrumentation for analysis of performance and usage.
• OurDelta – a fork compiled with various patches, including patches from MariaDB, Percona, and Google.

References
[1] "Changes in MySQL 5.5.24" (http:/ / dev. mysql. com/ doc/ refman/ 5. 5/ en/ news-5-5-24. html). Oracle Corporation. . Retrieved 7 may
2012.
[2] "MySQL" (http:/ / www. ohloh. net/ p/ mysql/ analyses/ latest). Ohloh.net. .
[3] http:/ / www. mysql. com/
[4] http:/ / dev. mysql. com/
[5] "What is MySQL?, MySQL 5.1 Reference Manual" (http:/ / dev. mysql. com/ doc/ refman/ 5. 1/ en/ what-is-mysql. html). MySQL AB. .
Retrieved 2010-03-19. "The official way to pronounce “MySQL” is “My Ess Que Ell” (not “my sequel”)"
[6] http:/ / www. mysql. com/ why-mysql/ marketshare/
[7] Robin Schumacher, Arjen Lentz. "Dispelling the Myths" (http:/ / dev. mysql. com/ tech-resources/ articles/ dispelling-the-myths. html).
MySQL AB. . Retrieved 2007-02-10.
[8] "History of MySQL, MySQL 5.1 Reference Manual" (http:/ / dev. mysql. com/ doc/ refman/ 5. 1/ en/ history. html). MySQL AB. . Retrieved
2011-08-26.
[9] "What is MySQL, MySQL 5.1 Reference Manual" (http:/ / dev. mysql. com/ doc/ refman/ 5. 1/ en/ what-is-mysql. html). MySQL AB. .
Retrieved 2011-08-26.
[10] "Sun Microsystems Announces Completion of MySQL Acquisition; Paves Way for Secure, Open Source Platform to Power the Network
Economy" (http:/ / www. sun. com/ aboutsun/ pr/ 2008-02/ sunflash. 20080226. 1. xml). Sun Microsystems. 26 February 2008. .
[11] "Google Runs MySQL" (http:/ / zurlocker. typepad. com/ theopenforce/ 2005/ 12/ googles_use_of_. html). TheOpenForce. . Retrieved
2010-08-03. "AdWords was built using the MySQL database"
[12] "MySQL at Facebook" (http:/ / www. youtube. com/ watch?v=Zofzid6xIZ4). O'Reilly, Mark callaghan. . Retrieved 2010-08-03. "x,000
servers, ... Master-slave replication, InnoDB"
[13] "Big and Small Data at Twitter: MySQL CE 2011" (http:/ / nosql. mypopescu. com/ post/ 4687379038/
big-and-small-data-at-twitter-mysql-ce-2011). Nosql.mypopescu.com. 17 April 2011. . Retrieved 2011-10-20.
[14] "YouTube, Flickr, and Wikipedia to Share their Secrets of Success at the 2007 MySQL Conference & Expo" (http:/ / dev. mysql. com/
tech-resources/ articles/ mysqluc-2007. html). MySQL. 10 April 2007. . Retrieved 2009-12-09.
[15] "MySQL.com" (http:/ / www. mysql. com/ customers/ view/ ?id=579). MySQL.com. . Retrieved 2012-02-01.
[16] "MySQL Customers by Industry : Web: Social Networks" (http:/ / www. mysql. com/ customers/ industry/ ?id=85). . Retrieved 2012-01-05.
MySQL 42

[17] "Wikimedia servers – System architecture" (http:/ / meta. wikimedia. org/ wiki/ Wikimedia_servers#System_architecture). . Retrieved
2011-01-16.
[18] Claburn, Thomas (24 April 2007). "Google Releases Improved MySQL Code" (http:/ / www. informationweek. com/ news/ internet/
showArticle. jhtml?articleID=199201237). Information Week. . Retrieved 2008-11-30.
[19] Sobel, Jason (21 December 2007). "Keeping Up" (http:/ / blog. facebook. com/ blog. php?post=7899307130). Facebook Blog. . Retrieved
2008-10-30.
[20] Malik, Om (25 April 2008). "Facebook’s Insatiable Hunger for Hardware" (http:/ / gigaom. com/ 2008/ 04/ 25/
facebooks-insatiable-hunger-for-hardware/ ). GigaOM. . Retrieved 2008-10-30.
[21] "MySQL Internals Manual" (http:/ / dev. mysql. com/ doc/ internals/ en/ index. html). Dev.mysql.com. 4 March 2009. . Retrieved
2009-06-08.
[22] Jean-François Piéronne. "PCSI Kits of Open Source Software for OpenVMS" (http:/ / www. pi-net. dyndns. org/ anonymous/ kits/ ).
Pi-net.dyndns.org. . Retrieved 2009-06-08.
[23] "HeidiSQL Grid editing features" (http:/ / www. heidisql. com/ screenshots. php?which=grideditors). .
[24] "LibreOffice Base" (http:/ / www. libreoffice. org/ features/ base/ ). . Retrieved 2012-01-05.
[25] http:/ / www. sequelpro. com/
[26] http:/ / code. google. com/ p/ sqlyog/
[27] "The future of replication in MySQL" (http:/ / www. facebook. com/ note. php?note_id=126049465932). Facebook. . Retrieved 2009-12-09.
[28] "Database Sharding" (http:/ / www. codefutures. com/ dbshards-cloud/ ). Code Futures. . Retrieved 2009-12-09.
[29] Running "MySQL on Amazon EC2 with EBS (Elastic Block Store)" (http:/ / aws. amazon. com/ articles/ 1663). Amazon Web Services.
Running. Retrieved 2011-11-20.
[30] Finley, Klint. "7 Cloud-Based Database Services" (http:/ / www. readwriteweb. com/ cloud/ 2011/ 01/ 7-cloud-based-database-service. php).
ReadWriteWeb (http:/ / www. readwriteweb. com). . Retrieved 2011-11-09.
[31] "MySQL Server Support at Rackspace" (http:/ / www. rackspace. com/ managed_hosting/ services/ database/ mysql/ ). Rackspace.com. .
Retrieved 2011-11-10.
[32] "Which Should I Use: MySQL Enterprise or MySQL Community Server?" (http:/ / www. mysql. com/ products/ which-edition. html).
MySQL AB. . Retrieved 2009-04-08.
[33] "MySQL :: InnoDB 1.1 for MySQL 5.5 User’s Guide :: C InnoDB Glossary :: ACID" (http:/ / dev. mysql. com/ doc/ innodb/ 1. 1/ en/
glossary. html#glos_acid). . Retrieved 2011-01-05.
[34] "4.6.9. mysqlhotcopy - A Database Backup Program" (http:/ / dev. mysql. com/ doc/ refman/ 5. 1/ en/ mysqlhotcopy. html). MySQL 5.1
Reference Manual. Oracle. . Retrieved 23 September 2009. "mysqlhotcopy is a Perl script [...]. It uses Lock Tables, Flush Tables, and cp or
scp to make a database backup quickly [...] but it can be run only on the same machine where the database directories are located.
mysqlhotcopy works only for backing up MyISAM and Archive tables. It runs on Unix and NetWare."
[35] "The DB2 for i (IBMDB2I) Storage Engine for MySQL on IBM i" (http:/ / solutions. mysql. com/ engines/ ibm_db2_storage_engine. html).
MySQL. . Retrieved 2010-01-18.
[36] "Group commit in PostgreSQL" (http:/ / planet. mysql. com/ entry/ ?id=26651). . Retrieved 2012-04-08.
[37] "dev.mysql.com" (http:/ / dev. mysql. com/ doc/ refman/ 5. 6/ en/ innodb-foreign-key-constraints. html). dev.mysql.com. . Retrieved
2012-02-01.
[38] "dev.mysql.com" (http:/ / dev. mysql. com/ doc/ refman/ 5. 6/ en/ create-trigger. html). dev.mysql.com. . Retrieved 2012-02-01.
[39] "Five Questions With Michael Widenius - Founder And Original Developer of MySQL" (http:/ / www. opensourcereleasefeed. com/
interview/ show/ five-questions-with-michael-widenius-founder-and-original-developer-of-mysql). Opensourcereleasefeed.com. . Retrieved
2009-06-08.
[40] "MySQL 3.23 Declared Stable" (http:/ / web. archive. org/ web/ 20010815175526/ http:/ / www. mysql. com/ news/ article-54. html). .
[41] "Capttofu: FederatedX Pluggable Storage Engine Released!" (http:/ / capttofu. livejournal. com/ 5798. html). Capttofu.livejournal.com. .
Retrieved 2009-04-03.
[42] "Oreillynet.com" (http:/ / www. oreillynet. com/ pub/ a/ databases/ 2006/ 08/ 10/ mysql-federated-tables. html). Oreillynet.com. 2008-10-09.
. Retrieved 2012-02-01.
[43] "Archives - Oops, we did it again (MySQL 5.1 released as GA wi" (http:/ / www. planetmysql. org/ entry. php?id=16232). Planet MySQL.
29 November 2008. . Retrieved 2009-04-03.
[44] "TPC-H Run on MySQL 5.1 and 6.0 | MySQL Performance Blog" (http:/ / www. mysqlperformanceblog. com/ 2008/ 04/ 10/
tpc-h-run-on-mysql-51-and-60/ ). MySQL Performance Blog. . Retrieved 2009-06-08.
[45] "Oracle.com" (http:/ / www. oracle. com/ us/ sun/ index. htm). Oracle.com. 2010-09-07. . Retrieved 2012-02-01.
[46] "dev.mysql.com" (http:/ / dev. mysql. com/ doc/ refman/ 5. 5/ en/ innodb-io-changes. html). dev.mysql.com. . Retrieved 2012-02-01.
[47] "dev.mysql.com" (http:/ / dev. mysql. com/ doc/ refman/ 5. 5/ en/ smp-improvements. html). dev.mysql.com. . Retrieved 2012-02-01.
[48] "B.3. Changes in Release 3.23.x (Lifecycle Support Ended)" (http:/ / dev. mysql. com/ doc/ refman/ 4. 1/ en/ news-3-23-x. html). Oracle. .
Retrieved 2010-08-24.
[49] "B.2. Changes in Release 4.0.x (Lifecycle Support Ended)" (http:/ / dev. mysql. com/ doc/ refman/ 4. 1/ en/ news-4-0-x. html). Oracle. .
Retrieved 2010-08-24.
[50] "B.1. Changes in Release 4.1.x (Lifecycle Support Ended)" (http:/ / dev. mysql. com/ doc/ refman/ 4. 1/ en/ news-4-1-x. html). Oracle. .
Retrieved 2010-08-24.
MySQL 43

[51] "C.1. Changes in Release 5.0.x (Production)" (http:/ / dev. mysql. com/ doc/ refman/ 5. 0/ en/ news-5-0-x. html#news-5-0-x). Oracle. .
Retrieved 2010-08-24.
[52] "C.1. Changes in Release 5.1.x (Production)" (http:/ / dev. mysql. com/ doc/ refman/ 5. 1/ en/ news-5-1-x. html#news-5-1-x). Oracle. .
Retrieved 2010-08-24.
[53] "C.1. Changes in Release 5.5.x (Development)" (http:/ / dev. mysql. com/ doc/ refman/ 5. 5/ en/ news-5-5-x. html#news-5-5-x). Oracle. .
Retrieved 2010-08-24.
[54] "MySQL Lists: packagers: MySQL 6.0.11 Alpha has been released!" (http:/ / lists. mysql. com/ packagers/ 418). Lists.mysql.com. .
Retrieved 2012-02-01.
[55] "What's New in MySQL 5.6" (http:/ / dev. mysql. com/ tech-resources/ articles/ whats-new-in-mysql-5. 6. html). MySQL Developer Zone. .
Retrieved 2011-04-21.
[56] "Oracle :: MySQL Open Source License" (http:/ / www. mysql. com/ products/ licensing/ opensource-license. html). Mysql.com. . Retrieved
2009-06-08.
[57] "MySQL GOES GPL" (http:/ / web. archive. org/ web/ 20010812012244/ http:/ / www. mysql. com/ news/ article-23. html). .
[58] "Oracle :: FLOSS License Exception" (http:/ / www. mysql. com/ company/ legal/ licensing/ foss-exception. html). Mysql.com. . Retrieved
2009-06-08.
[59] "Oracle :: MySQL Commercial License" (http:/ / www. mysql. com/ company/ legal/ licensing/ commercial-license. html). Mysql.com. .
Retrieved 2009-06-08.
[60] "Oracle Plans to Increase Support for Open Source Software" (http:/ / www. oracle. com/ innodb/ index. html). Oracle and InnoDB. .
[61] "MySQL to Promote New Open Source DB Engines from its Partners and Dev Community" (http:/ / www. mysql. com/ news-and-events/
press-release/ release_2006_21. html). MySQL AB. .
[62] "Oracle Buys Sleepycat, Is JBoss Next?" (http:/ / www. informationweek. com/ software/ showArticle. jhtml?articleID=180200853).
Charles Babcock. .
[63] "MySQL 5.1.12 change list" (http:/ / mysql. mirror. iweb. ca/ doc/ refman/ 5. 1/ en/ news-5-1-12. html). .
[64] "Sun to Acquire MySQL" (http:/ / www. mysql. com/ news-and-events/ sun-to-acquire-mysql. html). .
[65] "Oracle to Buy Sun" (http:/ / www. sun. com/ aboutsun/ pr/ 2009-04/ sunflash. 20090420. 1. xml). Sun Microsystems Press Release. .
[66] Thomasch, Paul (20 August 2009). "Oracle wins U.S. approval to buy Sun Microsystems" (http:/ / www. reuters. com/
articlebssTechMediaTelecomNews/ idUSN2053486920090820). Reuters. . Retrieved 2009-09-30.
[67] Whitney, Lance (2009-12-14). "Cnet.com" (http:/ / news. cnet. com/ 8301-1001_3-10414686-92. html). News.cnet.com. . Retrieved
2012-02-01.
[68] "Help saving MySQL" (http:/ / monty-says. blogspot. com/ 2009/ 12/ help-saving-mysql. html). .
[69] Wikileaks Cable Offers New Insights Into Oracle-Sun Deal (http:/ / www. pcworld. com/ businesscenter/ article/ 239132/
wikileaks_cable_offers_new_insights_into_oraclesun_deal. html), By Chris Kanaracus, IDG News 30 Aug 2011 8:10 pm
[70] "Mergers: Commission clears Oracle's proposed acquisition of Sun Microsystems" (http:/ / europa. eu/ rapid/ pressReleasesAction.
do?reference=IP/ 10/ 40). .
[71] "MariaDB vs MySQL" (http:/ / askmonty. org/ wiki/ MariaDB_versus_MySQL). .
[72] "Letter of Tom Basil to MySQL Life mailing list" (http:/ / no. spam. ee/ ~tonu/ mysql/ tombasil. txt). .
[73] "FAQ on MySQL vs. NuSphere Dispute" (http:/ / web. archive. org/ web/ 20010717185237/ http:/ / mysql. com/ news/ article-75. html). .
[74] See Progress Software Corporation v. MySQL AB, 195 F. Supp. 2d 328 (D. Mass. 2002), on defendant's motion for preliminary injunction.
[75] "Judge Saris defers GNU GPL Questions for Trial in MySQL vs. Progress Software" (http:/ / www. gnu. org/ press/ 2002-03-01-pi-MySQL.
html). gnu.org. . Retrieved 24 March 2011.

External links
• Official website (http://www.mysql.com)
• MySQL (https://twitter.com/mysql) on Twitter
• MySQL (https://www.facebook.com/7802084642) on Facebook
• MySQL site at Oracle.com (http://www.oracle.com/us/products/mysql/index.html)
• Planet MySQL (http://www.planetmysql.org) - an aggregation of MySQL-related blogs
• MySQL Blog (http://blogs.oracle.com/MySQL/)
• Interview with David Axmark, MySQL co-founder (http://intruders.tv/en-tech/
mysql-co-founder-david-axmark-on-sun-s-billion-dollar-acquisition/) Video
• MySQL (http://www.dmoz.org//Computers/Software/Databases/MySQL//) at the Open Directory Project
LAMP 44

LAMP
LAMP is an acronym for a solution stack of free, open source software, referring to the first letters of Linux
(operating system), Apache HTTP Server, MySQL (database software) and PHP (or sometimes Perl or Python),
principal components to build a viable general purpose web server.[1]
The exact combination of software included in a LAMP package may vary, especially with respect to the web
scripting software, as PHP may be replaced or supplemented by Perl and/or Python.[2] Similar terms exist for
essentially the same software suite (AMP) running on other operating systems, such as Microsoft Windows
(WAMP), Mac OS (MAMP), Solaris (SAMP), iSeries (iAMP), or OpenBSD (OAMP).
Though the original authors of these programs did not design them all to work specifically with each other, the
development philosophy and tool sets are shared and were developed in close conjunction. The software
combination has become popular because it is free of cost, open-source, and therefore easily adaptable, and because
of the ubiquity of its components which are bundled with most current Linux distributions.
When used together, they form a solution stack of technologies that support application servers.

Software components

Linux
Like the other LAMP components, Linux is free open-source software which means the source code is available for
the operating system, which can be edited according to specific needs.

Apache
Apache is an open source web server, the most popular in use.[3]

MySQL
MySQL is a multithreaded, multi-user, SQL database management system (DBMS) now owned by Oracle
Corporation.[4] Alternatives at this level of the stack do also exist, for example by using PostgreSQL (LAPP) [5]
MySQL has been owned by Oracle Corporation since January 27, 2010 through the purchase of Sun
Microsystems.[6][7] Sun had acquired MySQL originally on February 26, 2008.

PHP, Perl, or Python

PHP is a reflective programming language originally designed for producing dynamic web pages. PHP is used
mainly in server-side application software. Perl and Python can be used similarly.

Variants and equivalents on other platforms

With the growing use of LAMP, variations and retronyms appeared for other combinations of operating system, web
server, database, and software language. For example the equivalent installation on a Microsoft Windows operating
system is known as WAMP.An alternative running IIS in place of Apache called WIMP. Variants involving other
operating systems include MAMP (Macintosh), SAMP (Solaris), FAMP (FreeBSD) and iAMP (iSeries). The web
server or database management system also vary. LEMP is a version where Apache has been replaced with the more
lightweight web server NGINX.[8] A version where MySQL has been replaced by PostgresSQL is called LAPP.
The GNU project is advocating people to use the term "GLAMP" since what is known as "Linux" is known to GNU
as the GNU/Linux system.[9]
LAMP 45

References
[1] Lee, James; Brent Ware (December 2002). Open Source Web Development with LAMP: Using Linux, Apache, MySQL, Perl, and PHP.
Addison Wesley. ISBN 0-201-77061-X.
[2] Dale Dougherty (January 26, 2001). "LAMP: The Open Source Web Platform" (http:/ / www. onlamp. com/ pub/ a/ onlamp/ 2001/ 01/ 25/
lamp. html). ONLamp. .
[3] "Market Share for Top Servers Across All Domains August 1995 - February 2011" (http:/ / news. netcraft. com/ archives/ category/
web-server-survey/ ). News.netcraft.com. . Retrieved 2011-02-22.
[4] Top Reasons for Product Managers to Embed MySQL (http:/ / www. mysql. com/ why-mysql/ topreasons_pm. html) on [mySQL.com]
[5] A LAPP appliance (http:/ / www. turnkeylinux. org/ lapp) on [turnkeylinux.org]
[6] Robin Schumacher & Arjen Lentz Dispelling the Myths (http:/ / dev. mysql. com/ tech-resources/ articles/ dispelling-the-myths. html)
[7] Charles Babcock, InformationWeek Sun Locks Up MySQL, Looks To Future Web Development (http:/ / www. informationweek. com/ news/
showArticle. jhtml?articleID=206900327)
[8] Setting Up a LEMP stack on Ubuntu 9.04 (http:/ / chrisjohnston. org/ 2009/ setting-up-a-lemp-stack-ubuntu-904)
[9] GNU.org (https:/ / www. gnu. org/ philosophy/ words-to-avoid. html#LAMP) -- Words to avoid

External links
• Install a LAMP server on Ubuntu Linux (https://help.ubuntu.com/community/ApacheMySQLPHP)
• Install a LAMP server on Debian GNU/Linux (http://wiki.debian.org/LaMp)
• Install a LAMP server on SUSE Linux (http://en.opensuse.org/SDB:Linux_Apache_MySQL_PHP)

Information retrieval
Information retrieval (IR) is the area of study concerned with searching for documents, for information within
documents, and for metadata about documents, as well as that of searching structured storage, relational databases,
and the World Wide Web. There is overlap in the usage of the terms data retrieval, document retrieval, information
retrieval, and text retrieval, but each also has its own body of literature, theory, praxis, and technologies. IR is
interdisciplinary, based on computer science, mathematics, library science, information science, information
architecture, cognitive psychology, linguistics, statistics and law.
Automated information retrieval systems are used to reduce what has been called "information overload". Many
universities and public libraries use IR systems to provide access to books, journals and other documents. Web
search engines are the most visible IR applications.

History

“
But do you know that, although I have kept the diary [on a phonograph] for months past, it never once struck me how I was going to find any
particular part of it in case I wanted to look it up?
”
—Dr Seward, Bram Stoker's Dracula, 1897

The idea of using computers to search for relevant pieces of information was popularized in the article As We May
Think by Vannevar Bush in 1945.[1] The first automated information retrieval systems were introduced in the 1950s
and 1960s. By 1970 several different techniques had been shown to perform well on small text corpora such as the
Cranfield collection (several thousand documents).[1] Large-scale retrieval systems, such as the Lockheed Dialog
system, came into use early in the 1970s.
In 1992, the US Department of Defense along with the National Institute of Standards and Technology (NIST),
cosponsored the Text Retrieval Conference (TREC) as part of the TIPSTER text program. The aim of this was to
look into the information retrieval community by supplying the infrastructure that was needed for evaluation of text
retrieval methodologies on a very large text collection. This catalyzed research on methods that scale to huge
Information retrieval 46

corpora. The introduction of web search engines has boosted the need for very large scale retrieval systems even
further.
The use of digital methods for storing and retrieving information has led to the phenomenon of digital obsolescence,
where a digital resource ceases to be readable because the physical media, the reader required to read the media, the
hardware, or the software that runs on it, is no longer available. The information is initially easier to retrieve than if it
were on paper, but is then effectively lost.

Timeline
• Before the 1900s
1801: Joseph Marie Jacquard invents the Jacquard loom, the first machine to use punched cards to control a
sequence of operations.
1880s: Herman Hollerith invents an electro-mechanical data tabulator using punch cards as a machine readable
medium.
1890 Hollerith cards, keypunches and tabulators used to process the 1890 US Census data.
• 1920s-1930s
Emanuel Goldberg submits patents for his "Statistical Machine” a document search engine that used
photoelectric cells and pattern recognition to search the metadata on rolls of microfilmed documents.
• 1940s–1950s
late 1940s: The US military confronted problems of indexing and retrieval of wartime scientific research
documents captured from Germans.
1945: Vannevar Bush's As We May Think appeared in Atlantic Monthly.
1947: Hans Peter Luhn (research engineer at IBM since 1941) began work on a mechanized punch
card-based system for searching chemical compounds.
1950s: Growing concern in the US for a "science gap" with the USSR motivated, encouraged funding and
provided a backdrop for mechanized literature searching systems (Allen Kent et al.) and the invention of
citation indexing (Eugene Garfield).
1950: The term "information retrieval" appears to have been coined by Calvin Mooers[2].
1951: Philip Bagley conducted the earliest experiment in computerized document retrieval in a master thesis at
MIT.[3]
1955: Allen Kent joined Case Western Reserve University, and eventually became associate director of the
Center for Documentation and Communications Research. That same year, Kent and colleagues published a
paper in American Documentation describing the precision and recall measures as well as detailing a proposed
"framework" for evaluating an IR system which included statistical sampling methods for determining the
number of relevant documents not retrieved.
1958: International Conference on Scientific Information Washington DC included consideration of IR
systems as a solution to problems identified. See: Proceedings of the International Conference on Scientific
Information, 1958 (National Academy of Sciences, Washington, DC, 1959)
1959: Hans Peter Luhn published "Auto-encoding of documents for information retrieval."
• 1960s:
early 1960s: Gerard Salton began work on IR at Harvard, later moved to Cornell.
1960: Melvin Earl (Bill) Maron and John Lary Kuhns[4] published "On relevance, probabilistic indexing, and
information retrieval" in the Journal of the ACM 7(3):216–244, July 1960.
1962:
Information retrieval 47

• Cyril W. Cleverdon published early findings of the Cranfield studies, developing a model for IR system
evaluation. See: Cyril W. Cleverdon, "Report on the Testing and Analysis of an Investigation into the
Comparative Efficiency of Indexing Systems". Cranfield Collection of Aeronautics, Cranfield, England,
1962.
• Kent published Information Analysis and Retrieval.
1963:
• Weinberg report "Science, Government and Information" gave a full articulation of the idea of a "crisis of
scientific information." The report was named after Dr. Alvin Weinberg.
• Joseph Becker and Robert M. Hayes published text on information retrieval. Becker, Joseph; Hayes, Robert
Mayo. Information storage and retrieval: tools, elements, theories. New York, Wiley (1963).
1964:
• Karen Spärck Jones finished her thesis at Cambridge, Synonymy and Semantic Classification, and continued
work on computational linguistics as it applies to IR.
• The National Bureau of Standards sponsored a symposium titled "Statistical Association Methods for
Mechanized Documentation." Several highly significant papers, including G. Salton's first published
reference (we believe) to the SMART system.
mid-1960s:
• National Library of Medicine developed MEDLARS Medical Literature Analysis and Retrieval System,
the first major machine-readable database and batch-retrieval system.
• Project Intrex at MIT.
1965: J. C. R. Licklider published Libraries of the Future.
1966: Don Swanson was involved in studies at University of Chicago on Requirements for Future
Catalogs.
late 1960s: F. Wilfrid Lancaster completed evaluation studies of the MEDLARS system and published the
first edition of his text on information retrieval.
1968:
• Gerard Salton published Automatic Information Organization and Retrieval.
• John W. Sammon, Jr.'s RADC Tech report "Some Mathematics of Information Storage and Retrieval..."
outlined the vector model.
1969: Sammon's "A nonlinear mapping for data structure analysis" (IEEE Transactions on Computers)
was the first proposal for visualization interface to an IR system.
• 1970s
early 1970s:
• First online systems—NLM's AIM-TWX, MEDLINE; Lockheed's Dialog; SDC's ORBIT.
• Theodor Nelson promoting concept of hypertext, published Computer Lib/Dream Machines.
1971: Nicholas Jardine and Cornelis J. van Rijsbergen published "The use of hierarchic clustering in
information retrieval", which articulated the "cluster hypothesis." (Information Storage and Retrieval, 7(5),
pp. 217–240, December 1971)
1975: Three highly influential publications by Salton fully articulated his vector processing framework and
term discrimination model:
• A Theory of Indexing (Society for Industrial and Applied Mathematics)
• A Theory of Term Importance in Automatic Text Analysis (JASIS v. 26)
• A Vector Space Model for Automatic Indexing (CACM 18:11)
1978: The First ACM SIGIR conference.
Information retrieval 48

1979: C. J. van Rijsbergen published Information Retrieval (Butterworths). Heavy emphasis on probabilistic
models.
• 1980s
1980: First international ACM SIGIR conference, joint with British Computer Society IR group in Cambridge.
1982: Nicholas J. Belkin, Robert N. Oddy, and Helen M. Brooks proposed the ASK (Anomalous State of
Knowledge) viewpoint for information retrieval. This was an important concept, though their automated
analysis tool proved ultimately disappointing.
1983: Salton (and Michael J. McGill) published Introduction to Modern Information Retrieval (McGraw-Hill),
with heavy emphasis on vector models.
1985: Blair and Maron publish: An Evaluation of Retrieval Effectiveness for a Full-Text Document-Retrieval
System
mid-1980s: Efforts to develop end-user versions of commercial IR systems.
1985–1993: Key papers on and experimental systems for visualization interfaces.
Work by Donald B. Crouch, Robert R. Korfhage, Matthew Chalmers, Anselm Spoerri and others.
1989: First World Wide Web proposals by Tim Berners-Lee at CERN.
• 1990s
1992: First TREC conference.
1997: Publication of Korfhage's Information Storage and Retrieval[5] with emphasis on visualization and
multi-reference point systems.
late 1990s: Web search engines implementation of many features formerly found only in experimental IR
systems. Search engines become the most common and maybe best instantiation of IR models, research, and
implementation.

Overview
An information retrieval process begins when a user enters a query into the system. Queries are formal statements of
information needs, for example search strings in web search engines. In information retrieval a query does not
uniquely identify a single object in the collection. Instead, several objects may match the query, perhaps with
different degrees of relevancy.
An object is an entity that is represented by information in a database. User queries are matched against the database
information. Depending on the application the data objects may be, for example, text documents, images,[6] audio,[7]
mind maps[8] or videos. Often the documents themselves are not kept or stored directly in the IR system, but are
instead represented in the system by document surrogates or metadata.
Most IR systems compute a numeric score on how well each object in the database matches the query, and rank the
objects according to this value. The top ranking objects are then shown to the user. The process may then be iterated
if the user wishes to refine the query.[9]
Information retrieval 49

Performance and correctness measures

Many different measures for evaluating the performance of information retrieval systems have been proposed. The
measures require a collection of documents and a query. All common measures described here assume a ground truth
notion of relevancy: every document is known to be either relevant or non-relevant to a particular query. In practice
queries may be ill-posed and there may be different shades of relevancy.

Precision
Precision is the fraction of the documents retrieved that are relevant to the user's information need.

In binary classification, precision is analogous to positive predictive value. Precision takes all retrieved documents
into account. It can also be evaluated at a given cut-off rank, considering only the topmost results returned by the
system. This measure is called precision at n or P@n.
Note that the meaning and usage of "precision" in the field of Information Retrieval differs from the definition of
accuracy and precision within other branches of science and technology.

Recall
Recall is the fraction of the documents that are relevant to the query that are successfully retrieved.

In binary classification, recall is called sensitivity. So it can be looked at as the probability that a relevant document
is retrieved by the query.
It is trivial to achieve recall of 100% by returning all documents in response to any query. Therefore recall alone is
not enough but one needs to measure the number of non-relevant documents also, for example by computing the
precision.

Fall-Out
The proportion of non-relevant documents that are retrieved, out of all non-relevant documents available:

In binary classification, fall-out is closely related to specificity . It can be looked at as the

probability that a non-relevant document is retrieved by the query.
It is trivial to achieve fall-out of 0% by returning zero documents in response to any query.

F-measure
The weighted harmonic mean of precision and recall, the traditional F-measure or balanced F-score is:

This is also known as the measure, because recall and precision are evenly weighted.
The general formula for non-negative real is:

.
Information retrieval 50

Two other commonly used F measures are the measure, which weights recall twice as much as precision, and the
measure, which weights precision twice as much as recall.
The F-measure was derived by van Rijsbergen (1979) so that "measures the effectiveness of retrieval with
respect to a user who attaches times as much importance to recall as precision". It is based on van Rijsbergen's

effectiveness measure . Their relationship is where .

Average precision
Precision and recall are single-value metrics based on the whole list of documents returned by the system. For
systems that return a ranked sequence of documents, it is desirable to also consider the order in which the returned
documents are presented. By computing a precision and recall at every position in the ranked sequence of
documents, one can plot a precision-recall curve, plotting precision as a function of recall . Average
precision computes the average value of over the interval from to :[10]

This integral is in practice replaced with a finite sum over every position in the ranked sequence of documents:

where is the rank in the sequence of retrieved documents, is the number of retrieved documents, is the
[10]
precision at cut-off in the list, and is the change in recall from items to .
This finite sum is equivalent to:

where is an indicator function equaling 1 if the item at rank is a relevant document, zero otherwise.[11]
Note that the average is over all relevant documents and the relevant documents not retrieved get a precision score of
zero.
Some authors choose to interpolate the function to reduce the impact of "wiggles" in the curve.[12][13] For
example, the PASCAL Visual Object Classes challenge (a benchmark for computer vision object detection)
computes average precision by averaging the precision over a set of evenly spaced recall levels {0, 0.1, 0.2, ...
1.0}[12][13]:

where is an interpolated precision that takes the maximum precision over all recalls greater than :
.
An alternative is to derive an analytical function by assuming a particular parametric distribution for the
underlying decision values. For example, a binormal precision-recall curve can be obtained by assuming decision
values in both classes to follow a Gaussian distribution.[14]
Average precision is also sometimes referred to geometrically as the area under the precision-recall curve.
Information retrieval 51

R-Precision
Precision at R-th position in the ranking of results for a query that has R relevant documents. This measure is highly
correlated to Average Precision. Also, Precision is equal to Recall at the R-th position.

Mean average precision

Mean average precision for a set of queries is the mean of the average precision scores for each query.

where Q is the number of queries.

Discounted cumulative gain

DCG uses a graded relevance scale of documents from the result set to evaluate the usefulness, or gain, of a
document based on its position in the result list. The premise of DCG is that highly relevant documents appearing
lower in a search result list should be penalized as the graded relevance value is reduced logarithmically proportional
to the position of the result.
The DCG accumulated at a particular rank position is defined as:

Since result set may vary in size among different queries or systems, to compare performances the normalised
version of DCG uses an ideal DCG. To this end, it sorts documents of a result list by relevance, producing an ideal
DCG at position p ( ), which normalizes the score:

The nDCG values for all queries can be averaged to obtain a measure of the average performance of a ranking
algorithm. Note that in a perfect ranking algorithm, the will be the same as the producing an
nDCG of 1.0. All nDCG calculations are then relative values on the interval 0.0 to 1.0 and so are cross-query
comparable.
Information retrieval 52

Other Measures
• Mean reciprocal rank
• Spearman's rank correlation coefficient

Model types
For the information retrieval to be
efficient, the documents are typically
transformed into a suitable
representation. There are several
representations. The picture on the
right illustrates the relationship of
some common models. In the picture,
the models are categorized according
to two dimensions: the mathematical
basis and the properties of the model.

Categorization of IR-models (translated from German entry, original source Dominik

First dimension: mathematical Kuropka
[15]
).
basis
• Set-theoretic models represent documents as sets of words or phrases. Similarities are usually derived from
set-theoretic operations on those sets. Common models are:
• Standard Boolean model
• Extended Boolean model
• Fuzzy retrieval
• Algebraic models represent documents and queries usually as vectors, matrices, or tuples. The similarity of the
query vector and document vector is represented as a scalar value.
• Vector space model
• Generalized vector space model
• (Enhanced) Topic-based Vector Space Model
• Extended Boolean model
• Latent semantic indexing aka latent semantic analysis
• Probabilistic models treat the process of document retrieval as a probabilistic inference. Similarities are computed
as probabilities that a document is relevant for a given query. Probabilistic theorems like the Bayes' theorem are
often used in these models.
• Binary Independence Model
• Probabilistic relevance model on which is based the okapi (BM25) relevance function
• Uncertain inference
• Language models
• Divergence-from-randomness model
• Latent Dirichlet allocation
• Feature-based retrieval models view documents as vectors of values of feature functions (or just features) and
seek the best way to combine these features into a single relevance score, typically by learning to rank methods.
Feature functions are arbitrary functions of document and query, and as such can easily incorporate almost any
other retrieval model as just a yet another feature.
Information retrieval 53

Second dimension: properties of the model

• Models without term-interdependencies treat different terms/words as independent. This fact is usually
represented in vector space models by the orthogonality assumption of term vectors or in probabilistic models by
an independency assumption for term variables.
• Models with immanent term interdependencies allow a representation of interdependencies between terms.
However the degree of the interdependency between two terms is defined by the model itself. It is usually directly
or indirectly derived (e.g. by dimensional reduction) from the co-occurrence of those terms in the whole set of
documents.
• Models with transcendent term interdependencies allow a representation of interdependencies between terms, but
they do not allege how the interdependency between two terms is defined. They relay an external source for the
degree of interdependency between two terms. (For example a human or sophisticated algorithms.)

Major figures
• Thomas Bayes
• Claude E. Shannon
• Gerard Salton
• Hans Peter Luhn
• Cyril Cleverdon
• W. Bruce Croft
• Karen Spärck Jones
• Calvin Mooers
• C. J. van Rijsbergen
• Stephen E. Robertson
• Martin Porter
• Amit Singhal

Awards in the field

• Tony Kent Strix award
• Gerard Salton Award

References
[1] Singhal, Amit (2001). "Modern Information Retrieval: A Brief Overview" (http:/ / singhal. info/ ieee2001. pdf). Bulletin of the IEEE
Computer Society Technical Committee on Data Engineering 24 (4): 35–43. .
[2] Mooers, Calvin N.; Theory Digital Handling Non-numerical Information (Zator Technical Bulletin No. 48) 5, cited in "information, n.". OED
Online. December 2011. Oxford University Press.
[3] Doyle, Lauren; Becker, Joseph (1975). Information Retrieval and Processing. Melville. pp. 410 pp.. ISBN 0-471-22151-1.
[4] Maron, Melvin E. (2008). "An Historical Note on the Origins of Probabilistic Indexing" (http:/ / yunus. hacettepe. edu. tr/ ~tonta/ courses/
spring2008/ bby703/ maron-on-probabilistic indexing-2008. pdf). Information Processing and Management 44 (2): 971–972.
doi:10.1016/j.ipm.2007.02.012. .
[5] Korfhage, Robert R. (1997). Information Storage and Retrieval (http:/ / www. wiley. com/ WileyCDA/ WileyTitle/
productCd-0471143383,descCd-authorInfo. html). Wiley. pp. 368 pp.. ISBN 978-0-471-14338-3. .
[6] Goodrum, Abby A. (2000). "Image Information Retrieval: An Overview of Current Research". Informing Science 3 (2).
[7] Foote, Jonathan (1999). "An overview of audio information retrieval". Multimedia Systems (Springer).
[8] Beel, Jöran; Gipp, Bela; Stiller, Jan-Olaf (2009). "Information Retrieval On Mind Maps - What Could It Be Good For?" (http:/ / www.
sciplore. org/ publications_en. php). Proceedings of the 5th International Conference on Collaborative Computing: Networking, Applications
and Worksharing (CollaborateCom'09). Washington, DC: IEEE. .
[9] Frakes, William B. (1992). Information Retrieval Data Structures & Algorithms (http:/ / www. scribd. com/ doc/ 13742235/
Information-Retrieval-Data-Structures-Algorithms-William-B-Frakes). Prentice-Hall, Inc.. ISBN 0-13-463837-9. .
Information retrieval 54

[10] Zhu, Mu (2004). "Recall, Precision and Average Precision" (http:/ / sas. uwaterloo. ca/ stats_navigation/ techreports/ 04WorkingPapers/
2004-09. pdf). .
[11] Turpin, Andrew; Scholer, Falk (2006). "User performance versus precision measures for simple search tasks". Proceedings of the 29th
Annual international ACM SIGIR Conference on Research and Development in information Retrieval (Seattle, WA, August 06-11, 2006) (New
York, NY: ACM): 11–18. doi:10.1145/1148170.1148176. ISBN 1-59593-369-7.
[12] Everingham, Mark; Van Gool, Luc; Williams, Christopher K. I.; Winn, John; Zisserman, Andrew (June 2010). "The PASCAL Visual Object
Classes (VOC) Challenge" (http:/ / pascallin. ecs. soton. ac. uk/ challenges/ VOC/ pubs/ everingham10. pdf). International Journal of
Computer Vision (Springer) 88 (2): 303–338. doi:10.1007/s11263-009-0275-4. . Retrieved 2011-08-29.
[13] Manning, Christopher D.; Raghavan, Prabhakar; Schütze, Hinrich (2008). Introduction to Information Retrieval (http:/ / nlp. stanford. edu/
IR-book/ html/ htmledition/ evaluation-of-ranked-retrieval-results-1. html). Cambridge University Press. .
[14] K.H. Brodersen, C.S. Ong, K.E. Stephan, J.M. Buhmann (2010). The binormal assumption on precision-recall curves (http:/ / icpr2010. org/
pdfs/ icpr2010_ThBCT8. 28. pdf). Proceedings of the 20th International Conference on Pattern Recognition, 4263-4266.
[15] http:/ / www. logos-verlag. de/ cgi-bin/ engbuchmid?isbn=0514& lng=eng& id=

External links
• ACM SIGIR: Information Retrieval Special Interest Group (http://www.acm.org/sigir/)
• BCS IRSG: British Computer Society - Information Retrieval Specialist Group (http://irsg.bcs.org/)
• Text Retrieval Conference (TREC) (http://trec.nist.gov)
• Forum for Information Retrieval Evaluation (FIRE) (http://www.isical.ac.in/~fire)
• Chinese Web Information Retrieval Forum (CWIRF) (http://www.cwirf.org/)
• Information Retrieval (http://www.dcs.gla.ac.uk/Keith/Preface.html) (online book) by C. J. van Rijsbergen
• Information Retrieval Wiki (http://ir.dcs.gla.ac.uk/wiki/)
• Information Retrieval Facility (http://ir-facility.org/)
• Information Retrieval @ DUTH (http://www.nonrelevant.net)
• Introduction to Information Retrieval (online book) by Christopher D. Manning, Prabhakar Raghavan and Hinrich
Schütze, Cambridge University Press. 2008. (http://www-csli.stanford.edu/~hinrich/
information-retrieval-book.html)
Data Definition Language 55

Data Definition Language

A data definition language or data description language (DDL) is a syntax similar to a computer programming
language for defining data structures, especially database schemas.

History
The data definition language concept and name was first introduced in relation to the Codasyl database model, where
the schema of the database was written in a language syntax describing the records, fields, and sets of the user data
model. Later it was used to refer to a subset of Structured Query Language (SQL) for creating tables and constraints.
SQL-92 introduced a schema manipulation language and schema information tables to query schemas. These
information tables were specified as SQL/Schemata in SQL:2003. The term DDL is also used in a generic sense to
refer to any formal language for describing data or information structures.

SQL
Unlike many data description languages, SQL uses a collection of imperative verbs whose effect is to modify the
schema of the database by adding, changing, or deleting definitions of tables or other objects. These statements can
be freely mixed with other SQL statements, so the DDL is not truly a separate language.

CREATE statements
Create - To make a new database, table, index, or stored query. A CREATE statement in SQL creates an object
inside of a relational database management system (RDBMS). The types of objects that can be created depends on
which RDBMS is being used, but most support the creation of tables, indexes, users, synonyms and databases. Some
systems (such as PostgreSQL) allow CREATE, and other DDL commands, inside of a transaction and thus they may
be rolled back.

CREATE TABLE statement

Perhaps the most common CREATE command is the CREATE TABLE command. The typical usage is:
CREATE [TEMPORARY] TABLE [table name] ( [column definitions] ) [table
parameters].
Column Definitions: A comma-separated list consisting of any of the following
• Column definition: [column name] [data type] {NULL | NOT NULL} {column options}
• Primary key definition: PRIMARY KEY ( [comma separated column list] )
• Constraints: {CONSTRAINT} [constraint definition]
• RDBMS specific functionality
For example, the command to create a table named employees with a few sample columns would be:

CREATE TABLE employees (

id INTEGER PRIMARY KEY,
first_name VARCHAR(50) null,
last_name VARCHAR(75) not null,
dateofbirth DATE null
);
Data Definition Language 56

DROP statements
Drop - To destroy an existing database, table, index, or view.
A DROP statement in SQL removes an object from a relational database management system (RDBMS). The types
of objects that can be dropped depends on which RDBMS is being used, but most support the dropping of tables,
users, and databases. Some systems (such as PostgreSQL) allow DROP and other DDL commands to occur inside of
a transaction and thus be rolled back. The typical usage is simply:
DROP objecttype objectname.
For example, the command to drop a table named employees would be:

DROP TABLE employees;

The DROP statement is distinct from the DELETE and TRUNCATE statements, in that they do not remove the table
itself. For example, a DELETE statement might delete some (or all) data from a table while leaving the table itself in
the database, whereas a DROP statement would remove the entire table from the database.

ALTER statements
Alter - To modify an existing database object.
An ALTER statement in SQL changes the properties of an object inside of a relational database management system
(RDBMS). The types of objects that can be altered depends on which RDBMS is being used. The typical usage is:
ALTER objecttype objectname parameters.
For example, the command to add (then remove) a column named bubbles for an existing table named sink would
be:

ALTER TABLE sink ADD bubbles INTEGER;

ALTER TABLE sink DROP COLUMN bubbles;

Referential integrity statements

Finally, another kind of DDL sentence in SQL is one used to define referential integrity relationships, usually
implemented as primary key and foreign key tags in some columns of the tables.
These two statements can be included inside a CREATE TABLE or an ALTER TABLE sentence.

Other languages
• XML Schema is an example of a DDL for XML.
• Simple Declarative Language

External links
• How to change data type of a column MS SQL - How to change data type of a column [1]

References
[1] http:/ / aspxtutorial. com/ post/ 2010/ 07/ 01/ MS-SQL-How-to-change-the-data-type-of-a-column-using-query. aspx
NoSQL 57

NoSQL
In computing, NoSQL is a class of database management system identified by its non-adherence to the widely used
relational database management system (RDBMS) model:
• It does not use SQL as its query language
NoSQL database systems rose alongside major internet companies, such as Google, Amazon, and Facebook,
which had significantly different challenges in dealing with huge quantities of data that the traditional RDBMS
solutions could not cope with. NoSQL database systems are developed to manage large volumes of data that
do not necessarily follow a fixed schema. Data is partitioned among different machines (for performance
questions and due its size) so JOIN operations are not usable and ACID guarantees are not given.
• It may not give full ACID guarantees
Usually only eventual consistency is guaranteed or transactions limited to single data items. This means that
given a sufficiently long period of time over which no changes are sent, all updates can be expected to
propagate eventually through the system.
• It has a distributed, fault-tolerant architecture
Several NoSQL systems employ a distributed architecture, with the data held in a redundant manner on several
servers. In this way, the system can easily scale out by adding more servers, and failure of a server can be
tolerated. This type of database typically scales horizontally and is used for managing big amounts of data,
when the performance and real-time nature is more important than consistency (as indexing a large number of
documents, serving pages on high-traffic websites, and delivering streaming media).
NoSQL database systems are often highly optimized for retrieve and append operations and often offer little
functionality beyond record storage (e.g. key-value stores). The reduced run time flexibility compared to full SQL
systems is compensated by significant gains in scalability and performance for certain data models.
In short, NoSQL database management systems are useful when working with a huge quantity of data and the data's
nature does not require a relational model for the data structure. The data could be structured, but it is of minimal
importance and what really matters is the ability to store and retrieve great quantities of data, and not the
relationships between the elements. For example, to store millions of key-value pairs in one or a few associative
arrays or to store millions of data records. This is particularly useful for statistical or real-time analyses for growing
list of elements (such as Twitter posts or the Internet server logs from a big group of users).

History
Carlo Strozzi used the term NoSQL in 1998 to name his lightweight, open-source relational database that did not
expose the standard SQL interface.[1] (Strozzi suggests that, as the current NoSQL movement "departs from the
relational model altogether; it should therefore have been called more appropriately 'NoREL', or something to that
effect.")[2]
Eric Evans, a Rackspace employee, reintroduced the term NoSQL in early 2009 when Johan Oskarsson of Last.fm
wanted to organize an event to discuss open-source distributed databases.[3] The name attempted to label the
emergence of a growing number of non-relational, distributed data stores that often did not attempt to provide ACID
(atomicity, consistency, isolation, durability) guarantees, which are the key attributes of classic relational database
systems such as Sybase, IBM DB2, MySQL, Microsoft SQL Server, PostgreSQL, Oracle RDBMS, Informix, Oracle
Rdb, etc.
In 2011, work began on UnQL (Unstructured Query Language), a specification for a query language for NoSQL
databases.[4] It is built to query collections (versus tables) of documents (versus rows) with loosely defined fields
(versus columns). UnQL is claimed to be a superset of SQL within which SQL is a very constrained type of UnQL
NoSQL 58

for which the queries always return the same fields (same number, names and types). However, UnQL does not
cover the data definition language (DDL) SQL statements like CREATE TABLE or CREATE INDEX.[5]

Architecture
Typical modern relational databases have shown poor performance on certain data-intensive applications, including
indexing a large number of documents, serving pages on high-traffic websites, and delivering streaming media.[6]
Typical RDBMS implementations are tuned either for small but frequent read/write transactions or for large batch
transactions with rare write accesses. NoSQL, on the other hand, can service heavy read/write workloads.[6]
Real-world NoSQL deployments include Digg's 3 TB for green badges (markers that indicate stories voted for by
others in a social network; this lasted less than three months and was abandoned.),[7] the 6 TB database of the
European Commission's ENSEMBLE platform for air quality models evaluation and intercomparison[8] and
Facebook's 50 TB for inbox search.[9]
NoSQL architectures often provide weak consistency guarantees, such as eventual consistency, or transactions
restricted to single data items. Some systems, however, provide full ACID guarantees in some instances by adding a
supplementary middleware layer (e.g., AppScale and CloudTPS).[10][11] Two systems have been developed that
provide snapshot isolation for column stores: Google's Percolator system based on BigTable,[12] and a transactional
system for HBase called "HBaseSI" developed at the University of Waterloo.[13] [14] These systems, developed
independently, use similar concepts to achieve multi-row distributed ACID transactions with snapshot isolation
guarantee for the underlying column store, without the extra overhead of data management, middleware system
deployment, or maintenance introduced by the middleware layer.
Several NoSQL systems employ a distributed architecture, with the data held in a redundant manner on several
servers, often using a distributed hash table. In this way, the system can readily scale out by adding more servers,
and failure of a server can be tolerated.[15]
Some NoSQL advocates promote very simple interfaces such as associative arrays or key-value pairs. Other systems,
such as native XML databases, promote support of the XQuery standard. Newer systems such as CloudTPS also
support join queries.[16]

Taxonomy
Often, NoSQL databases are categorized according to the way they store the data and fall under categories such as
key-value stores, BigTable implementations, document store databases, and graph databases. NoSQL database
systems rose alongside major internet companies, such as Google, Amazon, Twitter, and Facebook which had
significantly different challenges in dealing with data that the traditional RDBMS solutions could not cope with
(although most of Facebook's infrastructure is built on SQL databases[17] and so is Twitter's [18]). With the rise of the
real-time web, there was a need to provide curated information out of large volumes of data which more or less
followed similar horizontal structures. These companies realized that performance and real-time nature was more
important than consistency, which traditional relational databases were spending a high amount of processing time to
achieve. As such, NoSQL databases are often highly optimized for retrieve and append operations and often offer
little functionality beyond record storage (e.g. key-value stores). The reduced run time flexibility compared to full
SQL systems is compensated by significant gains in scalability and performance for certain data models.
NoSQL implementations can be categorized by their manner of implementation:
NoSQL 59

Document store
A document-oriented database stores, retrieves, and manages semi structured data. The element of data is called
document.
Different implementations offer different ways of organizing and/or grouping documents:
• Collections
• Tags
• Non-visible Metadata
• Directory hierarchies
Compared to relational databases we could say, for example, that collections are to tables as documents are to
records. But there is one big difference: every record in a table has the same number of fields, while documents in a
collection could have completely different fields.
Encodings in use include XML, YAML, JSON, and BSON, as well as binary forms like PDF and Microsoft Office
documents (MS Word, Excel, and so on).
Documents are addressed in the database via a unique key that represents that document. One of the other defining
characteristics of a document-oriented database is that, beyond the simple key-document (or key-value) lookup that
you can use to retrieve a document, the database will offer an API or query language that will allow you to retrieve
documents based on their contents.

Name Language Notes

BaseX Java, XQuery XML database

Clusterpoint C++ geared for Full text search

Apache CouchDB Erlang JSON store

eXist XQuery XML database

Jackrabbit Java

Lotus Notes and IBM Lotus Domino LotusScript, Java, IBM X Pages, thers MultiValue

MarkLogic Server XQuery XML database

MongoDB C++ BSON store (binary format JSON)

OpenLink Virtuoso C++, C#, Java, SPARQL middleware and database engine hybrid

OrientDB Java

SimpleDB Erlang

Terrastore Java

Graph
This kind of database is designed for data whose relations are well represented as a graph (elements interconnected
with an undetermined number of relations between them). The kind of data could be social relations, public transport
links, road maps or network topologies, by example.
NoSQL 60

Name Language Notes

AllegroGraph SPARQL RDF GraphStore

DEX Java, C++ High-performance Graph Database

FlockDB Scala

InfiniteGraph Java High-performance, scalable, distributed Graph Database

Neo4j Java

OpenLink Virtuoso C++, C#, Java, SPARQL middleware and database engine hybrid

OrientDB Java

Pregel

Sones GraphDB C#

OWLIM Java, SPARQL 1.1 RDF graph store with reasoning

Key-value store
Key-value stores allow the application to store its data in a schema-less way. The data could be stored in a datatype
of a programming language or an object. Because of this, there is no need for a fixed data model.[19] [20] The
following types exist:

Eventually‐consistent key‐value store

• Apache Cassandra
• Dynamo
• Hibari
• OpenLink Virtuoso
• Project Voldemort
• Riak [21]

Hierarchical key-value store

• GT.M[22]
• InterSystems Caché

Hosted services
• Freebase
• OpenLink Virtuoso
• Datastore on Google Appengine
• Amazon DynamoDB
• Cloudant Data Layer (CouchDB)
NoSQL 61

Key-value cache in RAM

• memcached
• OpenLink Virtuoso
• Oracle Coherence
• NCache
• Redis
• Hazelcast
• Tuple space
• Velocity

Key-value stores on solid state or rotating disk

• BigTable
• CDB
• Keyspace
• LevelDB
• membase
• MemcacheDB
• MongoDB
• OpenLink Virtuoso
• Tarantool
• Tokyo Cabinet
• TreapDB
• Tuple space

Ordered key-value stores

• Berkeley DB
• IBM Informix C-ISAM
• InfinityDB
• MemcacheDB
• NDBM

Multivalue databases
• Northgate Information Solutions Reality, the original Pick/MV Database
• Extensible Storage Engine (ESE/NT)
• jBASE
• OpenQM
• Revelation Software's OpenInsight
• Rocket U2
• D3 Pick database
• InterSystems Caché
• InfinityDB
NoSQL 62

Object database
• db4o
• Eloquera
• GemStone/S
• InterSystems Caché
• JADE
• NeoDatis ODB
• ObjectDB
• Objectivity/DB
• ObjectStore
• OpenLink Virtuoso
• Versant Object Database
• Wakanda
• ZODB

RDF database
• Meronymy SPARQL Database Server

Tabular
• BigTable
• Apache Hadoop
• Apache Hbase
• Hypertable
• Mnesia
• OpenLink Virtuoso

Tuple store
• Apache River
• OpenLink Virtuoso
• Tarantool

References
[1] Lith, Adam; Jakob Mattson (2010). "Investigating storage solutions for large data: A comparison of well performing and scalable data storage
solutions for real time extraction and batch insertion of data" (http:/ / publications. lib. chalmers. se/ records/ fulltext/ 123839. pdf) (PDF).
Göteborg: Department of Computer Science and Engineering, Chalmers University of Technology. p. 70. . Retrieved 12 May 2011. "Carlo
Strozzi first used the term NoSQL in 1998 as a name for his open source relational database that did not offer a SQL interface[...]"
[2] "NoSQL Relational Database Management System: Home Page" (http:/ / www. strozzi. it/ cgi-bin/ CSA/ tw7/ I/ en_US/ nosql/ Home Page).
Strozzi.it. 2 October 2007. . Retrieved 29 March 2010.
[3] "NOSQL 2009" (http:/ / blog. sym-link. com/ 2009/ 05/ 12/ nosql_2009. html). Blog.sym-link.com. 12 May 2009. . Retrieved 29 March 2010.
[4] "Home — UnQL Specification — Confluence" (http:/ / unqlspec. org/ display/ UnQL/ Home). Unqlspec.org. 2011-08-16. . Retrieved
2012-05-01.
[5] Avram, Abel (04). "Interview: Richard Hipp on UnQL, a New Query Language for Document Databases" (http:/ / www. infoq. com/ news/
2011/ 08/ UnQL). http:/ / www. infoq. com. . Retrieved 7 September 2011.
[6] Agrawal, Rakesh et al. (2008). "The Claremont report on database research" (http:/ / db. cs. berkeley. edu/ claremont/ claremontreport08.
pdf). SIGMOD Record (ACM) 37 (3): 9–19. doi:10.1145/1462571.1462573. ISSN 0163-5808. .
[7] "Looking to the future with Cassandra | Digg About" (http:/ / about. digg. com/ blog/ looking-future-cassandra). About.digg.com. 9
September 2009. . Retrieved 29 March 2010.
[8] "ENSEMBLE" (http:/ / ensemble. jrc. ec. europa. eu). ensemble.jrc.ec.europa.eu. 24 February 2012. . Retrieved 24 February 2012.
NoSQL 63

[9] "Cassandra" (http:/ / www. facebook. com/ note. php?note_id=24413138919& id=9445547199& index=9). facebook.com. 25 August 2008. .
Retrieved 19 August 2011.
[10] "Datastore Agnostic Transaction Support for Cloud Infrastructures" (http:/ / cs. ucsb. edu/ ~ckrintz/ papers/ ieeecloud11. pdf). IEEE. 4 July
2011. .
[11] "CloudTPS: Scalable Transactions for Web Applications in the Cloud" (http:/ / www. globule. org/ publi/ CSTWAC_ircs53. html).
Globule.org. . Retrieved 29 March 2010.
[12] "Large-scale Incremental Processing Using Distributed Transactions and Notifications" (http:/ / www. usenix. org/ events/ osdi10/ tech/
full_papers/ Peng. pdf). The 9th USENIX Symposium on Operating Systems Design and Implementation (OSDI 2010), 4–6 Oct 2010,
Vancouver, BC, Canada. . Retrieved 15 October 2010.
[13] "Supporting Multi-row Distributed Transactions with Global Snapshot Isolation Using Bare-bones [[HBase (http:/ / www. cs. uwaterloo. ca/
~c15zhang/ ZhangDeSterckGrid2010. pdf)]"]. The 11th ACM/IEEE International Conference on Grid Computing (Grid 2010), 25-29 Oct
2010, Brussels, Belgium. . Retrieved 15 October 2010.
[14] "HBaseSI: A Solution for Multi-row Distributed Transactions with Global Strong Snapshot Isolation on Clouds" (http:/ / chenzhang. info/
HBaseSI. pdf). Scalable Computing: Practice and Experience, 12, July 2011. . Retrieved 15 October 2011.
[15] "Cassandra: Structured Storage System over a P2P Network" (http:/ / static. last. fm/ johan/ nosql-20090611/ cassandra_nosql. pdf) (PDF). .
Retrieved 29 March 2010.
[16] "Consistent Join Queries in Cloud Data Stores" (http:/ / www. globule. org/ publi/ CJQCDS_ircs68. html). Globule.org. . Retrieved 31
January 2011.
[17] Callaghan, Mark. "MySQL and Database Engineering" (https:/ / www. facebook. com/ notes/ facebook-engineering/
mysql-and-database-engineering-mark-callaghan/ 10150599729938920). . Retrieved 7 March 2012.
[18] Cole, Jeremy. "MySQL at Twitter" (http:/ / engineering. twitter. com/ 2012/ 04/ mysql-at-twitter. html). . Retrieved 16 April 2012.
[19] Sandy (14 January 2011). "Key Value stores and the NoSQL movement" (http:/ / dba. stackexchange. com/ a/ 619). http:/ / dba.
stackexchange. com/ questions/ 607/ what-is-a-key-value-store-database: Stackexchange. . Retrieved 1 January 2012. "Key value stores allow
the application developer to store schema-less data. This data is usually consisting of a string that represents the key, and the actual data that is
considered to be the value in the "key — value" relationship. The data itself is usually some kind of primitive of the programming language (a
string, an integer, an array) or an object that is being marshalled by the programming languages bindings to the key value store. This replaces
the need for fixed data model and makes the requirement for properly formatted."
[20] Marc Seeger (21 September 2009). "Key-Value Stores: a practical overview" (http:/ / blog. marc-seeger. de/ assets/ papers/
Ultra_Large_Sites_SS09-Seeger_Key_Value_Stores. pdf). http:/ / blog. marc-seeger. de/ 2009/ 09/ 21/ key-value-stores-a-practical-overview/
: Marc Seeger. . Retrieved 1 January 2012. "Key-Value stores provide a high performance alternative to relational database systems when it
comes to storing and accessing data. This paper provides a short overview over some of the currently available key-value stores and their
interface to the Ruby programming language."
[21] "Riak: An Open Source Scalable Data Store" (https:/ / wiki. basho. com). 28 November 2010. . Retrieved 28 November 2010.
[22] Tweed, Rob; George James (2010). "A Universal NoSQL Engine, Using a Tried and Tested Technology" (http:/ / www. mgateway. com/
docs/ universalNoSQL. pdf) (PDF). p. 25. . "Without exception, the most successful and well-known of the NoSQL databases have been
developed from scratch, all within just the last few years. Strangely, it seems that nobody looked around to see whether there were any
existing, successfully implemented database technologies that could have provided a sound foundation for meeting Web-scale demands. Had
they done so, they might have discovered two products, GT.M and Caché..."

External links
• NoSQL whitepaper (http://www.christof-strauch.de/nosqldbs.pdf)
• NoSQL general introduction article (http://www.infoq.com/articles/graph-nosql-neo4j)
• Managing Data Relationships in Distributed Cache (http://www.alachisoft.com/resources/articles/
managing-data-relationships.html)
• How RDF Databases Differ from Other NoSQL Solutions (http://blog.datagraph.org/2010/04/rdf-nosql-diff)
 64

Database objects

Table
In relational databases and flat file databases, a table is a set of data elements (values) that is organized using a
model of vertical columns (which are identified by their name) and horizontal rows. A table has a specified number
of columns, but can have any number of rows . Each row is identified by the values appearing in a particular column
subset which has been identified as a unique key index. Table is another term for relations; although there is the
difference in that a table is usually a multi-set (bag) of rows whereas a relation is a set and does not allow duplicates.
Besides the actual data rows, tables generally have associated with them some meta-information, such as constraints
on the table or on the values within particular columns.
The data in a table does not have to be physically stored in the database. Views are also relational tables, but their
data are calculated at query time. Another example are nicknames, which represent a pointer to a table in another
database.

Comparisons with other data structures

In non-relational systems, hierarchical databases, the distant counterpart of a table is a structured file, representing
the rows of a table in each record of the file and each column in a record.
Unlike a spreadsheet, the datatype of field is ordinarily defined by the schema describing the table. Some relational
systems are less strict about field datatype definitions.

Tables versus relations

In terms of the relational model of databases, a table can be considered a convenient representation of a relation, but
the two are not strictly equivalent. For instance, an SQL table can potentially contain duplicate rows, whereas a true
relation cannot contain duplicate tuples. Similarly, representation as a table implies a particular ordering to the rows
and columns, whereas a relation is explicitly unordered. However, the database system does not guarantee any
ordering of the rows unless an ORDER BY clause is specified in the SELECT statement that queries the table.
An equally valid representations of a relation is as an n-dimensional chart, where n is the number of attributes (a
table's columns). For example, a relation with two attributes and three values can be represented as a table with two
columns and three rows, or as a two-dimensional graph with three points. The table and graph representations are
only equivalent if the ordering of rows is not significant, and the table has no duplicate rows.

Table types
Two types of tables exist.
• A relational table, which is the basic structure to hold user data in a relational database.
• An object table, which is a table that uses an object type to define a column. It is defined to hold instances of
objects of a defined type.
In SQL, use the CREATE TABLE statement to create these tables.[1]
Table 65

References
[1] Diana Lorentz and Joan Gregoire (Primary Authors) (December 2003). "CREATE TABLE" (http:/ / www. stanford. edu/ dept/ itss/ docs/
oracle/ 10g/ server. 101/ b10759/ statements_7002. htm#i2095331). Oracle Database SQL Reference 10g Release 1 (10.1). Oracle
Corporation. Part Number B10759-01. .

Column
In the context of a relational database table, a column is a set of data values of a particular simple type, one for each
row of the table.[1] The columns provide the structure according to which the rows are composed.
The term field is often used interchangeably with column, although many consider it more correct to use field (or
field value) to refer specifically to the single item that exists at the intersection between one row and one column.
In relational database terminology, column's equivalent is called attribute.
For example, a table that represents companies might have the following columns:
• ID (integer identifier, unique to each row)
• Name (text)
• Address line 1 (text)
• Address line 2 (text)
• City (integer identifier, drawn from a separate table of cities, from which any state or country information would
be drawn)
• Postal code (text)
• Industry (integer identifier, drawn from a separate table of industries)
• etc.
Each row would provide a data value for each column and would then be understood as a single structured data
value, in this case representing a company. More formally, each row can be interpreted as a relvar, composed of a set
of tuples, with each tuple consisting of the two items: the name of the relevant column and the value this row
provides for that column.

Column 1 Column 2

Row 1 Row 1, Column 1 Row 1, Column 2

Row 2 Row 2, Column 1 Row 2, Column 2

Row 3 Row 3, Column 1 Row 3, Column 2

Examples of database: MySQL, SQL Server, Access, Oracle, Sybase, DB2.

Coding involved: SQL [Structured Query Language]
See more at SQL.

References
[1] The term "column" also has equivalent application in other, more generic contexts. See e.g., Flat file database, Table (information).
Field 66

Field
In computer science, data that has several parts can be divided into fields. Relational databases arrange data as sets
of database records, also called rows. Each record consists of several fields; the fields of all records form the
columns.
In object-oriented programming, field (also called data member or member variable) is the data encapsulated within
a class or object. In the case of a regular field (also called instance variable), for each instance of the object there is
an instance variable: for example, an Employee class has a Name field and there is one distinct name per
employee. A static field (also called class variable) is one variable, which is shared by all instances.[1]

Fixed length
Fields that contain a fixed number of bytes are known as fixed length fields. A four byte field for example may
contain a 31 bit binary integer plus a sign bit (32 bits in all). A 30 byte name field may contain a persons name
typically padded with blanks at the end. The disadvantage of using fixed length fields is that some part of the field
may be wasted but space is still required for the maximum length case. Also, where fields are omitted, padding for
the missing fields is still required to maintain fixed start positions within a record for instance.

Variable length
A variable length field may sometimes consist of two components:-
• a length prefix (such as a two byte unsigned binary field) followed by
• the actual variable length data itself (maximum length 32,765)
Processing variable fields of this type is generally much faster than other formats since it is not necessary to parse
the input to determine the beginning of the next field.
Alternatively, fields of variable length may, for instance, be separated by commas (see Comma-separated values)
when the end of each individual field must be determined by scanning for the delimiter "one byte at a time". Missing
fields can be identified by two or more consecutive commas. It is not possible to use comma separated fields for
exclusively binary fields since particular binary strings may be misinterpreted as a comma delimiter although unique
binary values could be used instead, provided they do not occur naturally within the string.

References
[1] "Data fields" (http:/ / www. sliccware. com/ WebHelp/ Load_Definition/ Definitions/ Data_Fields/ Data_Fields. htm). SLICCWARE. .
Retrieved 2011-08-12.
Row 67

Row
In the context of a relational database, a row—also called a record or tuple—represents a single, implicitly
structured data item in a table. In simple terms, a database table can be thought of as consisting of rows and columns
or fields. Each row in a table represents a set of related data, and every row in the table has the same structure.
For example, in a table that represents companies, each row would represent a single company. Columns might
represent things like company name, company street address, whether the company is publicly held, its VAT
number, etc.. In a table that represents the association of employees with departments, each row would associate one
employee with one department.
In a less formal usage, e.g. for a database which is not formally relational, a record is equivalent to a row as
described above, but is not usually referred to as a row.
The implicit structure of a row, and the meaning of the data values in a row, requires that the row be understood as
providing a succession of data values, one in each column of the table. The row is then interpreted as a relvar
composed of a set of tuples, with each tuple consisting of the two items: the name of the relevant column and the
value this row provides for that column.
Each column expects a data value of a particular type. For example, one column might require a unique identifier,
another might require text representing a person's name, another might require an integer representing hourly pay in
cents.

Column 1 Column 2

Row 1 Row 1, Column 1 Row 1, Column 2

Row 2 Row 2, Column 1 Row 2, Column 2

Row 3 Row 3, Column 1 Row 3, Column 2

Data type 68

Data type
In certain technical fields (especially computer programming and statistics), a data type is a classification
identifying one of various types of data, such as real-valued, integer or Boolean, that determines the possible values
for that type; the operations that can be done on values of that type; the meaning of the data; and the way values of
that type can be stored.[1][2] Most data types in statistics have comparable types in computer programming, and
vice-versa, as shown in the following table:

Statistics Computer programming

real-valued (interval scale) floating-point

real-valued (ratio scale)

count data (but, usually non-negative) integer

binary data Boolean

categorical data enumerated type

random vector list or array

random matrix two-dimensional array

random tree tree

The rest of this article addresses data types from a computer science perspective. For their use in statistics, see
statistical data type.

Overview
Data types are used within type systems, which offer various ways of defining, implementing and using them.
Different type systems ensure varying degrees of type safety. Formally, a type can be defined as "any property of a
programme we can determine without executing the program".[3]
Almost all programming languages explicitly include the notion of data type, though different languages may use
different terminology. Common data types may include:
• integers,
• booleans,
• characters,
• floating-point numbers,
• alphanumeric strings.
For example, in the Java programming language, the "int" type represents the set of 32-bit integers ranging in value
from -2,147,483,648 to 2,147,483,647, as well as the operations that can be performed on integers, such as addition,
subtraction, and multiplication. Colors, on the other hand, are represented by three bytes denoting the amounts each
of red, green, and blue, and one string representing that color's name; allowable operations include addition and
subtraction, but not multiplication.
Most programming languages also allow the programmer to define additional data types, usually by combining
multiple elements of other types and defining the valid operations of the new data type. For example, a programmer
might create a new data type named "complex number" that would include real and imaginary parts. A data type also
represents a constraint placed upon the interpretation of data in a type system, describing representation,
interpretation and structure of values or objects stored in computer memory. The type system uses data type
information to check correctness of computer programs that access or manipulate the data.
Data type 69

Classes of data types

Machine data types

All data in computers based on digital electronics is represented as bits (alternatives 0 and 1) on the lowest level. The
smallest addressable unit of data is usually a group of bits called a byte (usually an octet, which is 8 bits). The unit
processed by machine code instructions is called a word (as of 2011, typically 32 or 64 bits). Most instructions
interpret the word as a binary number, such that a 32-bit word can represent unsigned integer values from 0 to
or signed integer values from to . Because of two's complement, the machine language
and machine doesn't need to distinguish between these unsigned and signed data types for the most part.
There is a specific set of arithmetic instructions that use a different interpretation of the bits in word as a
floating-point number.
Machine data types need to be exposed or made available in systems or low-level programming languages, allowing
fine-grained control over hardware. The C programming language, for instance, supplies integer types of various
widths, such as short and long. If a corresponding native type does not exist on the target platform, the compiler
will break them down into code using types that do exist. For instance, if a 32-bit integer is requested on a 16 bit
platform, the compiler will tacitly treat it as an array of two 16 bit integers.
Several languages allow binary and hexadecimal literals, for convenient manipulation of machine data.
In higher level programming, machine data types are often hidden or abstracted as an implementation detail that
would render code less portable if exposed. For instance, a generic numeric type might be supplied instead of
integers of some specific bit-width.

The boolean type

The Boolean type represents the values: true and false. Although only two values are possible, they are rarely
implemented as a single binary digit for efficiency reasons. Many programming languages do not have an explicit
boolean type, instead interpreting (for instance) 0 as false and other values as true.

Numeric types
Such as:
• The integer data types, or "whole numbers". May be subtyped according to their ability to contain negative values
(e.g. unsigned in C and C++). May also have a small number of predefined subtypes (such as short and
long in C/C++); or allow users to freely define subranges such as 1..12 (e.g. Pascal/Ada).
• Floating point data types, sometimes misleadingly called reals, contain fractional values. They usually have
predefined limits on both their maximum values and their precision.
• Fixed point data types are convenient for representing monetary values. They are often implemented internally as
integers, leading to predefined limits.
• Bignum or arbitrary precision numeric types lack predefined limits. They are not primitive types, and are used
sparingly for efficiency reasons.
Data type 70

String and text types

Such as
• Alphanumeric character. A letter of the alphabet, digit, blank space, punctuation mark, etc.
• Alphanumeric strings, a sequence of characters. They are typically used to represent words and text.
Character and string types can store sequences of characters from a character set such as ASCII. Since most
character sets include the digits, it is possible to have a numeric string, such as "1234". However, many languages
would still treat these as belonging to a different type to the numeric value 1234.
Character and string types can have different subtypes according to the required character "width". The original 7-bit
wide ASCII was found to be limited, and superseded by 8 and 16-bit sets, which can encode a wide variety of
non-Latin alphabets (Hebrew, Chinese) and other symbols. Strings may be either stretch-to-fit or of fixed size, even
in the same programming language. They may also be subtyped by their maximum size.
Note: strings are not primitive in all languages, for instance C: they may be composed from arrays of characters.

Enumerations
The enumerated type. This has values which are different from each other, and which can be compared and assigned,
but which do not necessarily have any particular concrete representation in the computer's memory; compilers and
interpreters can represent them arbitrarily. For example, the four suits in a deck of playing cards may be four
enumerators named CLUB, DIAMOND, HEART, SPADE, belonging to an enumerated type named suit. If a variable
V is declared having suit as its data type, one can assign any of those four values to it. Some implementations allow
programmers to assign integer values to the enumeration values, or even treat them as type-equivalent to integers.

Derived types
Types can be based on, or derived from, the basic types explained above.
In some language, such as C, functions have a type derived from the type of their return value.

Pointers and references

The main non-composite, derived type is the pointer, a data type whose value refers directly to (or "points to")
another value stored elsewhere in the computer memory using its address. It is a primitive kind of reference. (In
everyday terms, a page number in a book could be considered a piece of data that refers to another one). Pointers are
often stored in a format similar to an integer; however, attempting to dereference or "look up" a pointer whose value
was never a valid memory address would cause a program to crash. To ameliorate this potential problem, pointers
are considered a separate type to the type of data they point to, even if the underlying representation is the same.

Composite types
Composite types are derived from more than one primitive type. This can be done in a number of ways. The ways
they are combined are called data structures. Composing a primitive type into a compound type generally results in a
new type, e.g. array-of-integer is a different type to integer.
• An array stores a number of elements of the same type in a specific order. They are accessed using an integer to
specify which element is required (although the elements may be of almost any type). Arrays may be fixed-length
or expandable.
• Record (also called tuple or struct) Records are among the simplest data structures. A record is a value that
contains other values, typically in fixed number and sequence and typically indexed by names. The elements of
records are usually called fields or members.
• Union. A union type definition will specify which of a number of permitted primitive types may be stored in its
instances, e.g. "float or long integer". Contrast with a record, which could be defined to contain a float and an
Data type 71

integer; whereas, in a union, there is only one value at a time.

• A tagged union (also called a variant, variant record, discriminated union, or disjoint union) contains an additional
field indicating its current type, for enhanced type safety.
• A set is an abstract data structure that can store certain values, without any particular order, and no repeated
values. Values themselves are not retrieved from sets, rather one tests a value for membership to obtain a boolean
"in" or "not in".
• An object contains a number of data fields, like a record, and also a number of programme code fragments for
accessing or modifying them. Data structures not containing code, like those above, are called plain old data
structure.
Many others are possible, but they tend to be further variations and compounds of the above.

Abstract types
Any type that does not specify an implementation is an Abstract data type. For instance, a stack (which is an abstract
type) can be implemented as an array (a contiguous block of memory containing multiple values), or as a linked list
(a set of non-contiguous memory blocks linked by pointers).
Abstract types can be handled by code that does not know or "care" what underlying types are contained in them.
Programming that is agnostic about concrete data types is called generic programming. Arrays and records can also
contain underlying types, but are considered concrete because they specify how their contents or elements are laid
out in memory.
Examples include:
• A smart pointer is the abstract counterpart to a pointer. Both are kinds of reference
• A hash or dictionary or map or Map/Associative array/Dictionary is a more flexible variation on a record, in
which name-value pairs can be added and deleted freely.
• A queue is a first-in first-out list. Variations are Deque and Priority queue.
• A set can store certain values, without any particular order, and with no repeated values.
• A stack is a last-in, first out.
• A tree is a hierarchical structure.
• A graph.

Utility types
For convenience, high-level languages may supply ready-made "real world" data types, for instance times, dates and
monetary values, even where the language allows them to be built from primitive types.

Type systems
A type system associates types with each computed value. By examining the flow of these values, a type system
attempts to prove that no type errors can occur. The type system in question determines what constitutes a type error,
but a type system generally seeks to guarantee that operations expecting a certain kind of value are not used with
values for which that operation does not make sense.
A compiler may use the static type of a value to optimize the storage it needs and the choice of algorithms for
operations on the value. In many C compilers the

float

data type, for example, is represented in 32 bits, in accord with the IEEE specification for single-precision floating
point numbers. They will thus use floating-point-specific microprocessor operations on those values (floating-point
addition, multiplication, etc.).
Data type 72

The depth of type constraints and the manner of their evaluation affect the typing of the language. A programming
language may further associate an operation with varying concrete algorithms on each type in the case of type
polymorphism. Type theory is the study of type systems, although the concrete type systems of programming
languages originate from practical issues of computer architecture, compiler implementation, and language design.
Type systems may be variously static or dynamic, strong or weak typing, and so forth.

References
[1] http:/ / foldoc. org/ data+ type
[2] Shaffer, C.A. Data Structures and Algorthms, 1.2
[3] Programming Languages: Application and Interpretation, Shriram Krishnamurthi, Brown University

Further reading
• Luca Cardelli, Peter Wegner. On Understanding Types, Data Abstraction, and Polymorphism, (http://citeseer.
ist.psu.edu/cardelli85understanding.html) from Computing Surveys, (December, 1985)
• Various Data Types in C (http://www.allcompiler.com/2011/07/various-data-types-in-c.html)
 73

Database connectivity

Application programming interface

An application programming interface (API) is a specification intended to be used as an interface by software
components to communicate with each other. An API may include specifications for routines, data structures, object
classes, and variables. An API specification can take many forms, including an International Standard such as
POSIX or vendor documentation such as the Microsoft Windows API, or the libraries of a programming language,
e.g. Standard Template Library in C++ or Java API.
An API differs from an application binary interface (ABI) in that the former is source code based while the latter is a
binary interface. For instance POSIX is an API, while the Linux Standard Base is an ABI.[1]

Language used
An API can be:
• language-dependent, meaning it is only available by using the syntax and elements of a particular language, which
makes the API more convenient to use.
• language-independent, written so that it can be called from several programming languages. This is a desirable
feature for a service-oriented API that is not bound to a specific process or system and may be provided as remote
procedure calls or web services. For example, a website that allows users to review local restaurants is able to
layer their reviews over maps taken from Google Maps, because Google Maps has an API that facilitates this
functionality. Google Maps' API controls what information a third-party site can use and how they can use it.
The term API may be used to refer to a complete interface, a single function, or even a set of APIs provided by an
organization. Thus, the scope of meaning is usually determined by the context of usage.

Detailed explanation
An API may describe the ways in which a particular task is performed. In procedural languages like C language the
action is usually mediated by a function call. Hence the API usually includes a description of all the
functions/routines it provides. For instance: the math.h include file for the C language contains the definition of
the function prototypes of the mathematical functions available in the C language library for mathematical
processing (usually called libm). This file describes how to use the functions included in the given library: the
function prototype is a signature that describes the number and types of the parameters to be passed to the functions
and the type of the return value. The behavior of the functions is usually described in more details in a human
readable format in printed books or in electronic formats like the man pages: e.g. on Unix systems the command
man 3 sqrt will present the signature of the function sqrt in the form:

SYNOPSIS
#include <math.h>
double sqrt(double X);
float sqrtf(float X);
DESCRIPTION
DESCRIPTION
sqrt computes the positive square root of the argument. ...
RETURNS
Application programming interface 74

On success, the square root is returned. If X is real and

positive...

That means that the function returns the square root of a positive floating point number (single or double
precision) as another floating point number. Hence the API in this case can be interpreted as the collection of the
include files used by the C language and its human readable description provided by the man pages.

Documentation
Many program development environments provide the documentation associated with an API in some digital format,
e.g. perl comes with the tool perldoc:

$ perldoc -f sqrt
sqrt EXPR
sqrt #Return the square root of EXPR. If EXPR is omitted,
returns
#square root of $_. Only works on non-negative
operands, unless
#you've loaded the standard Math::Complex module.

python comes with the tool pydoc:

$ pydoc math.sqrt
Help on built-in function sqrt in math:
math.sqrt = sqrt(...)
sqrt(x)
Return the square root of x.

ruby comes with the tool ri:

$ ri Math::sqrt
------------------------------------------------------------- Math::sqrt
Math.sqrt(numeric) => float
------------------------------------------------------------------------
Returns the non-negative square root of _numeric_.

Java comes with the documentation organized in HTML pages (JavaDoc format), while Microsoft distributes the
API documentation for its languages (Visual C++, C#, Visual Basic, F#, etc...) embedded in Visual Studio's help
system.

API in object-oriented languages

In object-oriented languages, an API usually includes a description of a set of class definitions, with a set of
behaviors associated with those classes. A behavior is the set of rules for how an object, derived from that class, will
act in a given circumstance. This abstract concept is associated with the real functionalities exposed, or made
available, by the classes that are implemented in terms of class methods (or more generally by all its public
components hence all public methods, but also possibly including any internal entity made public, like fields,
constants, nested objects, enums...).
The API in this case can be conceived as the totality of all the methods publicly exposed by the classes (usually
called the class interface). This means that the API prescribes the methods by which one interacts with/handles the
objects derived from the class definitions.
Application programming interface 75

More generally, one can see the API as the collection of all the kinds of objects one can derive from the class
definitions, and their associated possible behaviors. Again: the use is mediated by the public methods, but in this
interpretation, the methods are seen as a technical detail of how the behavior is implemented.
For instance: a class representing a Stack can simply expose publicly two methods push() (to add a new item
to the stack), and pop() (to extract the last item, ideally placed on top of the stack).
In this case the API can be interpreted as the two methods pop() and push(), or, more generally, as the idea that
one can use an item of type Stack that implements the behavior of a stack: a pile exposing its top to add/remove
elements. The second interpretation appears more appropriate in the spirit of object orientation.
This concept can be carried to the point where a class interface in an API has no methods at all, but only behaviors
associated with it. For instance, the Java language and Lisp (programming language) API include the interface
Serializable, which is a marker interface that requires that each class that implements it should behave in a
serialized fashion. This does not require to have any public method, but rather requires that any class that
implements it to have a representation that can be saved (serialized) at any time (this is typically true for any class
containing simple data and no link to external resources, like an open connection to a file, a remote system, or an
external device).
Similarly the behavior of an object in a concurrent (multi-threaded) environment is not necessarely determined by
specific methods, belonging to the interface implemented, but still belongs to the API for that Class of objects, and
should be described in the documentation.[2]
In this sense, in object-oriented languages, the API defines a set of object behaviors, possibly mediated by a set of
class methods.
In such languages, the API is still distributed as a library. For example, the Java language libraries include a set of
APIs that are provided in the form of the JDK used by the developers to build new Java programs. The JDK includes
the documentation of the API in JavaDoc notation.
The quality of the documentation associated with an API is often a factor determining its success in terms of ease of
use.

API libraries and frameworks

An API is usually related to a software library: the API describes and prescribes the expected behavior while the
library is an actual implementation of this set of rules. A single API can have multiple implementations (or none,
being abstract) in the form of different libraries that share the same programming interface.
An API can also be related to a software framework: a framework can be based on several libraries implementing
several APIs, but unlike the normal use of an API, the access to the behavior built into the framework is mediated by
extending its content with new classes plugged into the framework itself. Moreover the overall program flow of
control can be out of the control of the caller, and in the hands of the framework via inversion of control or a similar
mechanisms.[3]

API and protocols

An API can also be an implementation of a protocol.
In general the difference between an API and a protocol is that the protocol defines a standard way to exchange
requests and responses based on a common transport and agreeing on a data/message exchange format, while an API
(not implementing a protocol) is usually implemented as a library to be used directly: hence there can be no
transport involved (no information physically transferred from/to some remote machine), but rather only simple
information exchange via function calls (local to the machine where the elaboration takes place) and data is
exchanged in formats expressed in a specific language.[4]
Application programming interface 76

When an API implements a protocol it can be based on proxy methods for remote invocations that underneath rely
on the communication protocol. The role of the API can be exactly to hide the detail of the transport protocol. E.g.:
RMI is an API that implements the JRMP protocol or the IIOP as RMI-IIOP.
Protocols are usually shared between different technologies (system based on given computer programming
languages in a given operating system) and usually allow the different technologies to exchange information, acting
as an abstraction/mediation level between the two worlds. While APIs can be specific to a given technology: hence
the APIs of a given language cannot be used in other languages, unless the function calls are wrapped with specific
adaptation libraries.

Object API and protocols

An object API can prescribe a specific object exchange format, an object exchange protocol can define a way to
transfer the same kind of information in a message sent to a remote system.
When a message is exchanged via a protocol between two different platforms using objects on both sides, the object
in a programming language can be transformed (marshalled and unmarshalled) in an object in a remote and different
language: so, e.g., a program written in Java invokes a service via SOAP or IIOP written in C# both programs use
APIs for remote invocation (each locally to the machine where they are working) to (remotely) exchange
information that they both convert from/to an object in local memory.
Instead when a similar object is exchanged via an API local to a single machine the object is effectively exchanged
(or a reference to it) in memory: e.g. via the memory allocated by a single process, or among multiple processes
using shared memory or other sharing techologies like tuple spaces.

API sharing and reuse via virtual machine

Some languages like those running in a virtual machine (e.g. .NET CLI compliant languages in the Common
Language Runtime and JVM compliant languages in the Java Virtual Machine) can share APIs.
In this case the virtual machine enables the language interoperation thanks to the common denominator of the virtual
machine that abstracts from the specific language using an intermediate bytecode and its language binding.
Hence this approach maximizes the code reuse potential for all the existing libraries and related APIs.

Web APIs
When used in the context of web development, an API is typically defined as a set of Hypertext Transfer Protocol
(HTTP) request messages, along with a definition of the structure of response messages, which is usually in an
Extensible Markup Language (XML) or JavaScript Object Notation (JSON) format. While "Web API" is virtually a
synonym for web service, the recent trend (so-called Web 2.0) has been moving away from Simple Object Access
Protocol (SOAP) based services towards more direct Representational State Transfer (REST) style
communications.[5] Web APIs allow the combination of multiple services into new applications known as
mashups.[6]
Application programming interface 77

Web use to share content

The practice of publishing APIs has allowed web communities to create an open architecture for sharing content and
data between communities and applications. In this way, content that is created in one place can be dynamically
posted and updated in multiple locations on the web.
1. Photos can be shared from sites like Flickr and Photobucket to social network sites like Facebook and MySpace.
2. Content can be embedded, e.g. embedding a presentation from SlideShare on a LinkedIn profile.
3. Content can be dynamically posted. Sharing live comments made on Twitter with a Facebook account, for
example, is enabled by their APIs.
4. Video content can be embedded on sites which are served by another host.
5. User information can be shared from web communities to outside applications, delivering new functionality to
the web community that shares its user data via an open API. One of the best examples of this is the Facebook
Application platform. Another is the Open Social platform.[7]

Implementations
The POSIX standard defines an API that allows a wide range of common computing functions to be written in a way
such that they may operate on many different systems (Mac OS X, and various Berkeley Software Distributions
(BSDs) implement this interface); however, making use of this requires re-compiling for each platform. A
compatible API, on the other hand, allows compiled object code to function without any changes to the system
implementing that API. This is beneficial to both software providers (where they may distribute existing software on
new systems without producing and distributing upgrades) and users (where they may install older software on their
new systems without purchasing upgrades), although this generally requires that various software libraries
implement the necessary APIs as well.
Microsoft has shown a strong commitment to a backward compatible API, particularly within their Windows API
(Win32) library, such that older applications may run on newer versions of Windows using an executable-specific
setting called "Compatibility Mode".[8]
Apple Inc. has shown less concern, breaking compatibility or implementing an API in a slower "emulation mode";
this allows greater freedom in development, at the cost of making older software obsolete.
Among Unix-like operating systems, there are many related but incompatible operating systems running on a
common hardware platform (particularly Intel 80386-compatible systems). There have been several attempts to
standardize the API such that software vendors may distribute one binary application for all these systems; however,
to date, none of these have met with much success. The Linux Standard Base is attempting to do this for the Linux
platform, while many of the BSD Unixes, such as FreeBSD, NetBSD, and OpenBSD, implement various levels of
API compatibility for both backward compatibility (allowing programs written for older versions to run on newer
distributions of the system) and cross-platform compatibility (allowing execution of foreign code without
recompiling).
Application programming interface 78

Release policies
The two options for releasing API are:
1. Protecting information on APIs from the general public. For example, Sony used to make its official PlayStation
2 API available only to licensed PlayStation developers. This enabled Sony to control who wrote PlayStation 2
games. This gives companies quality control privileges and can provide them with potential licensing revenue
streams.
2. Making APIs freely available. For example, Microsoft makes the Microsoft Windows API public, and Apple
releases its APIs Carbon and Cocoa, so that software can be written for their platforms.
A mix of the two behaviors can be used as well.

APIs and Copyrights

In 2010 Oracle sued Google for having distributed a new implementation of Java embedded in the Android operating
system.[9] The litigation concerns also the fact that Google did not acquire any permission to reproduce the Java API.
Instead a similar permission was given to the OpenJDK project.

API examples
• ASPI for SCSI device interfacing
• Carbon and Cocoa for the Macintosh
• DirectX for Microsoft Windows
• EHLLAPI
• Java APIs
• ODBC for Microsoft Windows
• OpenAL cross-platform sound API
• OpenCL cross-platform API for general-purpose computing for CPUs & GPUs
• OpenGL cross-platform graphics API
• OpenMP API that supports multi-platform shared memory multiprocessing programming in C, C++ and Fortran
on many architectures, including Unix and Microsoft Windows platforms.
• Simple DirectMedia Layer (SDL)
• Talend integrates its data management with BPM from Bonita Open Solution

Language bindings and interface generators

APIs that are intended to be used by more than one high-level programming language often provide, or are
augmented with, facilities to automatically map the API to features (syntactic or semantic) that are more natural in
those languages. This is known as language binding, and is itself an API. The aim is to encapsulate most of the
required functionality of the API, leaving a "thin" layer appropriate to each language.
Below are listed some interface generator tools which bind languages to APIs at compile time.
• SWIG open-source interfaces bindings generator from many languages to many languages (Typically
Compiled->Scripted)
• F2PY:[10] Fortran to Python interface generator.
Application programming interface 79

References
[1] Stoughton, Nick (April 2005). "Update on Standards" (https:/ / db. usenix. org/ publications/ login/ 2005-04/ openpdfs/ standards2004. pdf)
(PDF). USENIX. . Retrieved 2009-06-04.
[2] Bloch, Joshua (2008). "Effective Java (2nd edition)" (http:/ / java. sun. com/ docs/ books/ effective/ ). Addison-Wesley. pp. 259–312.
ISBN 978-0-321-35668-0. .
[3] Fowler, Martin. "Inversion Of Control" (http:/ / martinfowler. com/ bliki/ InversionOfControl. html). .
[4] "API vs Protocol" (http:/ / c2. com/ cgi/ wiki?ApiVsProtocol). .
[5] Benslimane, Djamal; Schahram Dustdar, and Amit Sheth (2008). "Services Mashups: The New Generation of Web Applications" (http:/ /
dsonline. computer. org/ portal/ site/ dsonline/ menuitem. 9ed3d9924aeb0dcd82ccc6716bbe36ec/ index. jsp?& pName=dso_level1&
path=dsonline/ 2008/ 09& file=w5gei. xml& xsl=article. xsl). IEEE Internet Computing, vol. 12, no. 5. Institute of Electrical and Electronics
Engineers. pp. 13–15. .
[6] Niccolai, James (2008-04-23), "So What Is an Enterprise Mashup, Anyway?" (http:/ / www. pcworld. com/ businesscenter/ article/ 145039/
so_what_is_an_enterprise_mashup_anyway. html), PC World,
[7] "Dynamic Community content via APIs". October 26, 2009.
[8] Microsoft (October 2001). "Run Older Programs On Windows XP" (http:/ / www. microsoft. com/ windowsxp/ using/ helpandsupport/
learnmore/ appcompat. mspx). Microsoft. p. 4. .
[9] "Oracle and the End of Programming As We Know It" (http:/ / www. drdobbs. com/ jvm/ 232901227). DrDobbs. 2012-05-01. . Retrieved
2012-05-09.
[10] "F2PY.org" (http:/ / www. f2py. org/ ). F2PY.org. . Retrieved 2011-12-18.

External links
• How to design a good API and why it matters (http://lcsd05.cs.tamu.edu/slides/keynote.pdf)
• How to Write an API (http://www.lior.ca/publications/api_design.pdf)
• LMAX Application Programming Interface (API) technology (http://www.lmax.com/trading-tech/api-trading)

Database transaction
A transaction comprises a unit of work performed within a database management system (or similar system) against
a database, and treated in a coherent and reliable way independent of other transactions. Transactions in a database
environment have two main purposes:
1. To provide reliable units of work that allow correct recovery from failures and keep a database consistent even in
cases of system failure, when execution stops (completely or partially) and many operations upon a database
remain uncompleted, with unclear status.
2. To provide isolation between programs accessing a database concurrently. If this isolation is not provided the
programs outcome are possibly erroneous.
A database transaction, by definition, must be atomic, consistent, isolated and durable.[1] Database practitioners often
refer to these properties of database transactions using the acronym ACID.
Transactions provide an "all-or-nothing" proposition, stating that each work-unit performed in a database must either
complete in its entirety or have no effect whatsoever. Further, the system must isolate each transaction from other
transactions, results must conform to existing constraints in the database, and transactions that complete successfully
must get written to durable storage.
Database transaction 80

Purpose
Databases and other data stores which treat the integrity of data as paramount often include the ability to handle
transactions to maintain the integrity of data. A single transaction consists of one or more independent units of work,
each reading and/or writing information to a database or other data store. When this happens it is often important to
ensure that all such processing leaves the database or data store in a consistent state.
Examples from double-entry accounting systems often illustrate the concept of transactions. In double-entry
accounting every debit requires the recording of an associated credit. If one writes a check for €100 to buy groceries,
a transactional double-entry accounting system must record the following two entries to cover the single transaction:
1. Debit €100 to Groceries Expense Account
2. Credit €100 to Checking Account
A transactional system would make both entries pass or both entries would fail. By treating the recording of multiple
entries as an atomic transactional unit of work the system maintains the integrity of the data recorded. In other
words, nobody ends up with a situation in which a debit is recorded but no associated credit is recorded, or vice
versa.

Transactional databases
A 'transactional database is a DBMS where write transactions on the database are able to be rolled back if they are
not completed properly (e.g. due to power or connectivity loss).
Most modern relational database management systems fall into the category of databases that support transactions.
In a database system a transaction might consist of one or more data-manipulation statements and queries, each
reading and/or writing information in the database. Users of database systems consider consistency and integrity of
data as highly important. A simple transaction is usually issued to the database system in a language like SQL
wrapped in a transaction, using a pattern similar to the following:
1. Begin the transaction
2. Execute a set of data manipulations and/or queries
3. If no errors occur then commit the transaction and end it
4. If errors occur then rollback the transaction and end it
If no errors occurred during the execution of the transaction then the system commits the transaction. A transaction
commit operation applies all data manipulations within the scope of the transaction and persists the results to the
database. If an error occurs during the transaction, or if the user specifies a rollback operation, the data manipulations
within the transaction are not persisted to the database. In no case can a partial transaction be committed to the
database since that would leave the database in an inconsistent state(Article by Vishak P Nair).
Internally, multi-user databases store and process transactions, often by using a transaction ID or XID.
There are multiple varying ways for transactions to be implemented other than the simple way documented above.
Nested transactions, for example, are transactions which contain statements within them that start new transactions
(i.e. sub-transactions). Multi-level transactions are similar but have a few extra properties. Another type of
transaction is the compensating transaction.
Database transaction 81

In SQL
SQL is inherently transactional, and a transaction is automatically started when another ends. Some databases extend
SQL and implement a START TRANSACTION statement, but while seemingly signifying the start of the
transaction it merely deactivates autocommit.
The result of any work done after this point will remain invisible to other database-users until the system processes a
COMMIT statement. A ROLLBACK statement can also occur, which will undo any work performed since the last
transaction. Both COMMIT and ROLLBACK will end the transaction, and start anew. If autocommit was disabled
using START TRANSACTION, autocommit will often also be reenabled.
Some database systems allow the synonyms BEGIN, BEGIN WORK and BEGIN TRANSACTION, and may have
other options available.

Distributed transactions
Database systems implement distributed transactions as transactions against multiple applications or hosts. A
distributed transaction enforces the ACID properties over multiple systems or data stores, and might include systems
such as databases, file systems, messaging systems, and other applications. In a distributed transaction a coordinating
service ensures that all parts of the transaction are applied to all relevant systems. As with database and other
transactions, if any part of the transaction fails, the entire transaction is rolled back across all affected systems.

Transactional filesystems
The Namesys Reiser4 filesystem for Linux[2] supports transactions, and as of Microsoft Windows Vista, the
Microsoft NTFS filesystem[3] supports distributed transactions across networks.

References
[1] A transaction is a group of operations that are atomic, consistent, isolated, and durable ([[ACID (http:/ / msdn. microsoft. com/ en-us/ library/
aa366402(VS. 85). aspx)]).]
[2] http:/ / namesys. com/ v4/ v4. html#committing
[3] http:/ / msdn. microsoft. com/ library/ default. asp?url=/ library/ en-us/ fileio/ fs/ portal. asp

Further reading
• Philip A. Bernstein, Eric Newcomer (2009): Principles of Transaction Processing, 2nd Edition (http://www.
elsevierdirect.com/product.jsp?isbn=9781558606234), Morgan Kaufmann (Elsevier), ISBN 978-1-55860-623-4
• Gerhard Weikum, Gottfried Vossen (2001), Transactional information systems: theory, algorithms, and the
practice of concurrency control and recovery, Morgan Kaufmann, ISBN 1-55860-508-8
Open Database Connectivity 82

Open Database Connectivity

In computing, ODBC (Open Database Connectivity) is a standard C programming language interface for accessing
database management systems (DBMS). The designers of ODBC aimed to make it independent of database systems
and operating systems. An application can use ODBC to query data from a DBMS, regardless of the operating
system or DBMS it uses.
ODBC accomplishes DBMS independence by using an ODBC driver as a translation layer between the application
and the DBMS. The application uses ODBC functions through an ODBC driver manager with which it is linked, and
the driver passes the query to the DBMS.

Overview
ODBC defines a standard C API for accessing a relational DBMS. It was developed by the SQL Access Group in
1992 to standardize the use of a DBMS by an application. ODBC provides a universal middleware layer between the
application and DBMS, allowing the application developer to use a single interface. If changes are made to the
DBMS specification, only the driver needs updating. An ODBC driver can be thought of as analogous to a printer or
other driver, providing a standard set of functions for the application to use, and implementing DBMS-specific
functionality.
An application that can use ODBC is referred to as "ODBC-compliant". Any ODBC-compliant application can
access any DBMS for which a driver is installed. Drivers exist for all major DBMSs and even for text or CSV files.

History
Microsoft, in partnership with Simba Technologies, created ODBC by adapting the SQL Access Group CLI.[1] The
standard was based on Call Level Interface (CLI) specifications from the SQL Access Group, X/Open (after 1996
part of The Open Group), and the ISO/IEC. ODBC 1.0 was released in September 1992.[2] After ODBC 2.0,
Microsoft decided to align ODBC 3.0 with the CLI specification making its way through X/Open and ISO. In 1995,
SQL/CLI became part of the international SQL standard.[3]
Version history:[4]
• 1.0: released in September 1992[5]
• 2.0: ca 1994
• 2.5
• 3.0: ca 1995
• 3.5: ca 1997
• 3.8: ca 2009, with Windows 7[6]

Drivers
An ODBC driver enables an ODBC-compliant application to use a data source, normally a DBMS. (Some
non-DBMS drivers exist, for such data sources as CSV files. Such drivers implement a small DBMS.) ODBC drivers
exist for most DBMSs, including Oracle, PostgreSQL, MySQL, Microsoft SQL Server (but not for the Compact aka
CE edition), Sybase ASE, and DB2.
Because different technologies have different capabilities, most ODBC drivers do not implement all functionality
defined in the ODBC standard. Some drivers offer extra functionality not defined by the standard.
Open Database Connectivity 83

ODBC Driver Manager

The Driver Manager (DM) is the software that loads a particular driver based on the connection information.[7] An
application is actually linked to the DM. When the application calls the ODBC function to connect to the DBMS, the
DM parses the connection string and loads the appropriate driver.
Windows and Mac OS X include a driver manager. Other operating systems can avail themselves of either of two
free implementations, iODBC or unixODBC.

Bridging configurations
A bridge is a special kind of driver: a driver that uses another driver-based technology.

JDBC-ODBC bridges
A JDBC-ODBC bridge consists of a JDBC driver which employs an ODBC driver to connect to a target database.
This driver translates JDBC method calls into ODBC function calls. Programmers usually use such a bridge when a
particular database lacks a JDBC driver. Sun Microsystems included one such bridge in the JVM, but viewed it as a
stop-gap measure while few JDBC drivers existed. Sun never intended its bridge for production environments, and
generally recommends against its use. As of 2008 independent data-access vendors deliver JDBC-ODBC bridges
which support current standards for both mechanisms, and which far outperform the JVM built-in.

ODBC-JDBC bridges
An ODBC-JDBC bridge consists of an ODBC driver which uses the services of a JDBC driver to connect to a
database. This driver translates ODBC function-calls into JDBC method-calls. Programmers usually use such a
bridge when they lack an ODBC driver for a particular database but have access to a JDBC driver.

OLE DB
Microsoft provides an OLE DB-ODBC bridge for simplifying development in COM aware languages (i.e. Visual
Basic). This bridge forms part of the MDAC system component bundle, together with other database drivers.

References
[1] Harindranath, G; Jože Zupančič (2001). New perspectives on information systems development: theory, methods, and practice (http:/ / books.
google. com/ books?id=O8Loa-c0TyoC). Springer. p. 451. ISBN 978-0-306-47251-0. . Retrieved 2010-07-28. "The first ODBC drivers [...]
used the SIMBA query processor, which translated calls into the Microsoft Jet ISAM calls, and dispatched the calls to the appropriate ISAM
driver to access the backend [...]"
[2] "Linux/UNIX ODBC - What is ODBC?" (http:/ / www. easysoft. com/ developer/ interfaces/ odbc/ linux. html#what_is_odbc). .
[3] ISO/IEC 9075-3 -- Information technology -- Database languages -- SQL -- Part 3: Call-Level Interface (SQL/CLI)
[4] "ODBC Versions" (http:/ / www. easysoft. com/ developer/ interfaces/ odbc/ linux. html#odbc_versions). Linux/UNIX ODBC. Easysoft. .
Retrieved 2009-10-27.
[5] Antal, Tiberiu Alexandru. "Access to an Oracle database using JDBC" (http:/ / www. east. utcluj. ro/ mb/ mep/ antal/ Articole/ orajdbc_2004.
pdf) (PDF). Cluj-Napoca: Technical University of Cluj-Napoca. p. 2. . Retrieved 2009-10-27. "ODBC 1.0 was released in September 1992"
[6] "What's New in ODBC 3.8" (http:/ / msdn. microsoft. com/ en-us/ library/ ee388580(VS. 85). aspx). Microsoft. . Retrieved 2010-01-13.
"Windows 7 includes an updated version of ODBC, ODBC 3.8."
[7] Sybase. "Introduction to ODBC" (http:/ / infocenter. sybase. com/ help/ index. jsp?topic=/ com. sybase. help. sdk_12. 5. 1. aseodbc/ html/
aseodbc/ aseodbc5. htm). . Sybase. . Retrieved 8 October 2011.
Open Database Connectivity 84

External links
• Microsoft ODBC Overview (http://support.microsoft.com/kb/110093)
• List of ODBC Drivers at SQLSummit.com (http://www.SQLSummit.com/ODBCVend.htm)
• OS400 and i5OS ODBC Administration (http://publib.boulder.ibm.com/infocenter/iseries/v5r3/topic/rzaii/
rzaiiodbcadm.htm)
• Presentation slides from www.roth.net (http://www.roth.net/perl/odbc/conf/sld002.htm)
• Early ODBC White Paper (http://www.openlinksw.com/info/docs/odbcwhp/tableof.htm)
Java Database Connectivity 85

Java Database Connectivity

JDBC
Type Data Access API

Website Java SE 7 [1]

JDBC is a Java-based data access technology (Java Standard Edition platform) from Sun Microsystems, Inc.. It is
not an acronym as it is unofficially referred to as Java Database Connectivity. This technology is an API for the
Java programming language that defines how a client may access a database. It provides methods for querying and
updating data in a database. JDBC is oriented towards relational databases. A JDBC-to-ODBC bridge enables
connections to any ODBC-accessible data source in the JVM host environment.

History and implementation

Sun Microsystems released JDBC as part of JDK 1.1 on February 19, 1997.[2] It has since formed part of the Java
Standard Edition.
The JDBC classes are contained in the Java package java.sql and javax.sql.
Starting with version 3.1 , JDBC has been developed under the Java Community Process. JSR 54 specifies JDBC 3.0
(included in J2SE 1.4), JSR 114 specifies the JDBC Rowset additions, and JSR 221 is the specification of JDBC 4.0
(included in Java SE 6).[3]
The latest version, JDBC 4.1, is specified by a a maintenance release of JSR 221[4] and is included in Java SE 7.[5]

Functionality
JDBC allows multiple implementations to exist and be used by the same application. The API provides a mechanism
for dynamically loading the correct Java packages and registering them with the JDBC Driver Manager. The Driver
Manager is used as a connection factory for creating JDBC connections.
JDBC connections support creating and executing statements. These may be update statements such as SQL's
CREATE, INSERT, UPDATE and DELETE, or they may be query statements such as SELECT. Additionally,
stored procedures may be invoked through a JDBC connection. JDBC represents statements using one of the
following classes:
• Statement – the statement is sent to the database server each and every time.
• PreparedStatement – the statement is cached and then the execution path is pre determined on the database
server allowing it to be executed multiple times in an efficient manner.
• CallableStatement – used for executing stored procedures on the database.
Update statements such as INSERT, UPDATE and DELETE return an update count that indicates how many rows
were affected in the database. These statements do not return any other information.
Query statements return a JDBC row result set. The row result set is used to walk over the result set. Individual
columns in a row are retrieved either by name or by column number. There may be any number of rows in the result
set. The row result set has metadata that describes the names of the columns and their types.
There is an extension to the basic JDBC API in the javax.sql.
JDBC connections are often managed via a connection pool rather than obtained directly from the driver. Examples
of connection pools include BoneCP [6], C3P0 [7] and DBCP [8]
Java Database Connectivity 86

Examples
The method Class.forName(String) is used to load the JDBC driver class. The line below causes the JDBC
driver from some jdbc vendor to be loaded into the application. (Some JVMs also require the class to be instantiated
with .newInstance().)

Class.forName( "com.somejdbcvendor.TheirJdbcDriver" );

In JDBC 4.0, it's no longer necessary to explicitly load JDBC drivers using Class.forName(). See JDBC 4.0
Enhancements in Java SE 6 [9].
When a Driver class is loaded, it creates an instance of itself and registers it with the DriverManager. This
can be done by including the needed code in the driver class's static block. E.g.,
DriverManager.registerDriver(Driver driver)
Now when a connection is needed, one of the DriverManager.getConnection() methods is used to create
a JDBC connection.

Connection conn = DriverManager.getConnection(

"jdbc:somejdbcvendor:other data needed by some jdbc vendor",
"myLogin",
"myPassword" );
try {
/* you use the connection here */
} finally {
//It's important to close the connection when you are done with it
try { conn.close(); } catch (Throwable ignore) { /* Propagate the original exception
instead of this one that you may want just logged */ }
}

The URL used is dependent upon the particular JDBC driver. It will always begin with the "jdbc:" protocol, but the
rest is up to the particular vendor. Once a connection is established, a statement can be created.

Statement stmt = conn.createStatement();

try {
stmt.executeUpdate( "INSERT INTO MyTable( name ) VALUES ( 'my name' ) " );
} finally {
//It's important to close the statement when you are done with it
try { stmt.close(); } catch (Throwable ignore) { /* Propagate the original exception
instead of this one that you may want just logged */ }
}

Note that Connections, Statements, and ResultSets often tie up operating system resources such as sockets or file
descriptors. In the case of Connections to remote database servers, further resources are tied up on the server, e.g.,
cursors for currently open ResultSets. It is vital to close() any JDBC object as soon as it has played its part;
garbage collection should not be relied upon. Forgetting to close() things properly results in spurious errors and
misbehaviour. The above try-finally construct is a recommended code pattern to use with JDBC objects.
Data is retrieved from the database using a database query mechanism. The example below shows creating a
statement and executing a query.
Statement stmt = conn.createStatement();
try {
ResultSet rs = stmt.executeQuery( "SELECT * FROM MyTable" );
Java Database Connectivity 87

try {
while ( rs.next() ) {
int numColumns = rs.getMetaData().getColumnCount();
for ( int i = 1 ; i <= numColumns ; i++ ) {
// Column numbers start at 1.
// Also there are many methods on the result set to return
// the column as a particular type. Refer to the Sun documentation
// for the list of valid conversions.
System.out.println( "COLUMN " + i + " = " + rs.getObject(i) );
}
}
} finally {
try { rs.close(); } catch (Throwable ignore) { /* Propagate the original exception
instead of this one that you may want just logged */ }
}
} finally {
try { stmt.close(); } catch (Throwable ignore) { /* Propagate the original exception
instead of this one that you may want just logged */ }
}

Typically, however, it would be rare for a seasoned Java programmer to code in such a fashion. The usual practice
would be to abstract the database logic into an entirely different class and to pass preprocessed strings (perhaps
derived themselves from a further abstracted class) containing SQL statements and the connection to the required
methods. Abstracting the data model from the application code makes it more likely that changes to the application
and data model can be made independently.
An example of a PreparedStatement query, using conn and class from first example.
PreparedStatement ps =
conn.prepareStatement( "SELECT i.*, j.* FROM Omega i, Zappa j WHERE i.name = ? AND j.num = ?" );
try {
// In the SQL statement being prepared, each question mark is a placeholder
// that must be replaced with a value you provide through a "set" method invocation.
// The following two method calls replace the two placeholders; the first is
// replaced by a string value, and the second by an integer value.
ps.setString(1, "Poor Yorick");
ps.setInt(2, 8008);

// The ResultSet, rs, conveys the result of executing the SQL statement.
// Each time you call rs.next(), an internal row pointer, or cursor,
// is advanced to the next row of the result. The cursor initially is
// positioned before the first row.
ResultSet rs = ps.executeQuery();
try {
while ( rs.next() ) {
int numColumns = rs.getMetaData().getColumnCount();
for ( int i = 1 ; i <= numColumns ; i++ ) {
// Column numbers start at 1.
// Also there are many methods on the result set to return
Java Database Connectivity 88

// the column as a particular type. Refer to the Sun documentation

// for the list of valid conversions.
System.out.println( "COLUMN " + i + " = " + rs.getObject(i) );
} // for
} // while
} finally {
try { rs.close(); } catch (Throwable ignore) { /* Propagate the original exception
instead of this one that you may want just logged */ }
}
} finally {
try { ps.close(); } catch (Throwable ignore) { /* Propagate the original exception
instead of this one that you may want just logged */ }
} // try

If a database operation fails, JDBC raises an SQLException. There is typically very little one can do to recover
from such an error, apart from logging it with as much detail as possible. It is recommended that the SQLException
be translated into an application domain exception (an unchecked one) that eventually results in a transaction
rollback and a notification to the user.
An example of a database transaction:

boolean autoCommitDefault = conn.getAutoCommit();

try {
conn.setAutoCommit(false);

/* You execute statements against conn here transactionally */

conn.commit();
} catch (Throwable e) {
try { conn.rollback(); } catch (Throwable ignore) {}
throw e;
} finally {
try { conn.setAutoCommit(autoCommitDefault); } catch (Throwable ignore) {}
}

Here are examples of host database types which Java can convert to with a function.

setXXX() Methods
Oracle Datatype setXXX()

CHAR setString()

VARCHAR2 setString()
Java Database Connectivity 89

NUMBER setBigDecimal()

setBoolean()

setByte()

setShort()

setInt()

setLong()

setFloat()

setDouble()

INTEGER setInt()

FLOAT setDouble()

CLOB setClob()

BLOB setBlob()

RAW setBytes()

LONGRAW setBytes()

DATE setDate()

setTime()

setTimestamp()

For an example of a CallableStatement (to call stored procedures in the database), see the Java SE 7 [1].

JDBC drivers
JDBC drivers are client-side adapters (installed on the client machine, not on the server) that convert requests from
Java programs to a protocol that the DBMS can understand.

Types
There are commercial and free drivers available for most relational database servers. These drivers fall into one of
the following types:
• Type 1 that calls native code of the locally available ODBC driver.
• Type 2 that calls database vendor native library on a client side. This code then talks to database over network.
• Type 3, the pure-java driver that talks with the server-side middleware that then talks to database.
• Type 4, the pure-java driver that uses database native protocol.
There is also a type called internal JDBC driver, driver embedded with JRE in Java-enabled SQL databases. It's used
for Java stored procedures. This does not belong to the above classification, although it would likely be either a type
2 or type 4 driver (depending on whether the database itself is implemented in Java or not). An example of this is the
KPRB driver supplied with Oracle RDBMS. "jdbc:default:connection" is a relatively standard way of referring
making such a connection (at least Oracle and Apache Derby support it). The distinction here is that the JDBC client
is actually running as part of the database being accessed, so access can be made directly rather than through network
protocols.
Java Database Connectivity 90

Sources
• SQLSummit.com publishes list of drivers, including JDBC drivers and vendors
• Sun Microsystems provides a list of some JDBC drivers and vendors [10]
• Simba Technologies ships an SDK for building custom JDBC Drivers for any custom/proprietary relational data
source
• RSSBus Type 4 JDBC Drivers for applications, databases, and web services [11].
• DataDirect Technologies provides a comprehensive suite of fast Type 4 JDBC drivers for all major database the
advertise as Type 5[12]
• IDS Software provides a Type 3 JDBC driver for concurrent access to all major databases. Supported features
include resultset caching, SSL encryption, custom data source, dbShield
• OpenLink Software ships JDBC Drivers for a variety of databases, including Bridges to other data access
mechanisms (e.g., ODBC, JDBC) which can provide more functionality than the targeted mechanism
• JDBaccess is a Java persistence library for MySQL and Oracle which defines major database access operations in
an easy usable API above JDBC
• JNetDirect provides a suite of fully Sun J2EE certified high performance JDBC drivers.
• HSQLDB is a RDBMS with a JDBC driver and is available under a BSD license.
• SchemaCrawler[13] is an open source API that leverages JDBC, and makes database metadata available as plain
old Java objects (POJOs)

References
[1] http:/ / download. oracle. com/ javase/ 7/ docs/
[2] "SUN SHIPS JDK 1.1 -- JAVABEANS INCLUDED" (http:/ / web. archive. org/ web/ 20080210044125/ http:/ / www. sun. com/ smi/ Press/
sunflash/ 1997-02/ sunflash. 970219. 0001. xml). www.sun.com. Sun Microsystems. 1997-02-19. Archived from the original (http:/ / www.
sun. com/ smi/ Press/ sunflash/ 1997-02/ sunflash. 970219. 0001. xml) on 2008-02-10. . Retrieved 2010-02-15. "February 19, 1997 - The JDK
1.1 [...] is now available [...]. This release of the JDK includes: [...] Robust new features including JDBC[tm] for database connectivity"
[3] JDBC API Specification Version: 4.0 (http:/ / java. sun. com/ products/ jdbc/ download. html#corespec40).
[4] JSR-000221 JDBC API Specification 4.1 (Maintenance Release) (http:/ / jcp. org/ aboutJava/ communityprocess/ mrel/ jsr221/ index. html)
[5] http:/ / docs. oracle. com/ javase/ 7/ docs/ technotes/ guides/ jdbc/ jdbc_41. html
[6] http:/ / jolbox. com
[7] http:/ / sourceforge. net/ projects/ c3p0
[8] http:/ / commons. apache. org/ dbcp
[9] http:/ / www. onjava. com/ pub/ a/ onjava/ 2006/ 08/ 02/ jjdbc-4-enhancements-in-java-se-6. html
[10] http:/ / developers. sun. com/ product/ jdbc/ drivers
[11] http:/ / www. rssbus. com/ jdbc/
[12] "New Type 5 JDBC Driver - DataDirect Connect" (http:/ / www. datadirect. com/ products/ features/ data-connectivity/ type-5-jdbc/ index.
html). .
[13] Sualeh Fatehi. "SchemaCrawler" (http:/ / schemacrawler. sourceforge. net/ ). SourceForge. .

External links
• Java SE 7 (http://download.oracle.com/javase/7/docs/) This documentation has examples where the JDBC
resources are not closed appropriately (swallowing primary exceptions and being able to cause
NullPointerExceptions) and has code prone to SQL injection
• java.sql API Javadoc documentation
• javax.sql API Javadoc documentation
• O/R Broker (http://www.orbroker.org) Scala JDBC framework
• SqlTool (http://www.hsqldb.org/doc/2.0/util-guide/sqltool-chapt.html) Open source, command-line, generic
JDBC client utility. Works with any JDBC-supporting database.
 91

Statements

Select
"SELECT" redirects here. For the trade association, see SELECT (Electrical Contractors' Association of
Scotland).
The SQL SELECT statement returns a result set of records from one or more tables.[1][2]
A SELECT statement retrieves zero or more rows from one or more database tables or database views. In most
applications, SELECT is the most commonly used Data Manipulation Language (DML) command. As SQL is a
declarative programming language, SELECT queries specify a result set, but do not specify how to calculate it. The
database translates the query into a "query plan" which may vary between executions, database versions and
database software. This functionality is called the "query optimizer" as it is responsible for finding the best possible
execution plan for the query, within applicable constraints.
The SELECT statement has many optional clauses:
• WHERE specifies which rows to retrieve.
• GROUP BY groups rows sharing a property so that an aggregate function can be applied to each group.
• HAVING selects among the groups defined by the GROUP BY clause.
• ORDER BY specifies an order in which to return the rows.

Examples
Table "T" Query Result

SELECT * FROM T;
C1 C2 C1 C2

1 a 1 a

2 b 2 b

SELECT C1 FROM T;
C1 C2 C1

1 a 1

2 b 2

SELECT * FROM T WHERE C1 = 1;

C1 C2 C1 C2

1 a 1 a

2 b

SELECT * FROM T ORDER BY C1 DESC;

C1 C2 C1 C2

1 a 2 b

2 b 1 a
Select 92

Given a table T, the query SELECT * FROM T will result in all the elements of all the rows of the table being
shown.
With the same table, the query SELECT C1 FROM T will result in the elements from the column C1 of all the
rows of the table being shown. This is similar to a projection in Relational algebra, except that in the general case,
the result may contain duplicate rows. This is also known as a Vertical Partition in some database terms, restricting
query output to view only specified fields or columns.
With the same table, the query SELECT * FROM T WHERE C1 = 1 will result in all the elements of all the
rows where the value of column C1 is '1' being shown — in Relational algebra terms, a selection will be performed,
because of the WHERE clause. This is also known as a Horizontal Partition, restricting rows output by a query
according to specified conditions.
With more than one table, the result set will be every combination of rows. So if two tables are T1 and T2, SELECT
* FROM T1, T2 will result in every combination of T1 rows with every T2 rows. E.g., if T1 has 3 rows and T2
has 5 rows, then 15 rows will result.

Limiting result rows

Often it is convenient to indicate a maximum number of rows that are returned. This can be used for testing or to
prevent consuming excessive resources if the query returns more information than expected. The approach to do this
often varies per vendor.
In ISO SQL:2003, result sets may be limited by using
• cursors, or
• By introducing SQL window function to the SELECT-statement
ISO SQL:2008 introduced the FETCH FIRST clause.

ROW_NUMBER() window function

ROW_NUMBER() OVER may be used for a simple table on the returned rows, e.g. to return no more than ten rows:

SELECT * FROM
( SELECT
ROW_NUMBER() OVER (ORDER BY sort_key ASC) AS row_number,
columns
FROM tablename
) foo
WHERE row_number <= 10

ROW_NUMBER can be non-deterministic: if sort_key is not unique, each time you run the query it is possible to get
different row numbers assigned to any rows where sort_key is the same. When sort_key is unique, each row will
always get a unique row number.

RANK() window function

The RANK() OVER window function acts like ROW_NUMBER, but may return more than n rows in case of tie
conditions, e.g. to return the top-10 youngest persons:

SELECT * FROM (
SELECT
RANK() OVER (ORDER BY age ASC) AS ranking,
person_id,
person_name,
Select 93

age
FROM person
) foo
WHERE ranking <= 10

The above code could return more than ten rows, e.g. if there are two people of the same age, it could return eleven
rows.

FETCH FIRST clause

Since ISO SQL:2008 results limits can be specified as in the following example using the FETCH FIRST clause.
SELECT * FROM T FETCH FIRST 10 ROWS ONLY
This clause currently is supported by IBM DB2, Sybase SQL Anywhere, PostgreSQL, EffiProz and HSQLDB
version 2.0.

Result limits
Not all DBMSes support the mentioned window functions, and non-standard syntax has to be used. Below, variants
of the simple limit query for different DBMSes are listed:

SELECT * FROM T LIMIT 10 OFFSET Netezza, MySQL, Sybase SQL Anywhere, PostgreSQL (also supports the standard, since version
20 8.4), SQLite, HSQLDB, H2, Vertica, Polyhedra

SELECT * from T WHERE ROWNUM <= Oracle (also supports the standard, since Oracle8i)
10

SELECT FIRST 10 * from T Ingres

SELECT FIRST 10 * FROM T order Informix

by a

SELECT SKIP 20 FIRST 10 * FROM Informix (row numbers are filtered after order by is evaluated. SKIP clause was introduced in a
T order by c, d v10.00.xC4 fixpack)

SELECT TOP 10 * FROM T MS SQL Server, Sybase ASE, MS Access, Sybase IQ

SELECT TOP 10 START AT 20 * Sybase SQL Anywhere (also supports the standard, since version 9.0.1)
FROM T

SELECT FIRST 10 SKIP 20 * FROM Interbase, Firebird

T

SELECT * FROM T ROWS 20 TO 30 Firebird (since version 2.1)

SELECT * FROM T DB2

WHERE ID_T > 10 FETCH FIRST 10
ROWS ONLY

SELECT * FROM T DB2 (new rows are filtered after comparing with key column of table T)
WHERE ID_T > 20 FETCH FIRST 10
ROWS ONLY
Select 94

Hierarchical query
Some databases provide specialised syntax for hierarchical data.

Window function
A window function in SQL:2003 is an aggregate function applied to a partition of the result set.
For example,

sum(population) OVER( PARTITION BY city )

calculates the sum of the populations of all rows having the same city value as the current row.
Partitions are specified using the OVER clause which modifies the aggregate. Syntax:

<OVER_CLAUSE> :: =
OVER ( [ PARTITION BY <expr>, ... ]
[ ORDER BY <expression> ] )

The OVER clause can partition and order the result set. Ordering is used for order-relative functions such as
row_number.

Query evaluation ANSI

The processing of a SELECT statement according to ANSI SQL would be the following:[3]

select g.*
from users u
inner join groups g on g.Userid = u.Userid
where u.LastName = 'Smith'
and u.FirstName = 'John'

2. the FROM clause is evaluated, a cross join or Cartesian product is produced for the first two tables in the FROM
clause resulting in a virtual table as Vtable1
3. the ON clause is evaluated for vtable1; only records which meet the join condition g.Userid = u.Userid are
inserted into Vtable2
4. If an outer join is specified, records which were dropped from vTable2 are added into VTable 3, for instance if
the above query were:

select u.*
from users u
left join groups g on g.Userid = u.Userid
where u.LastName = 'Smith'
and u.FirstName = 'John'

all users who did not belong to any groups would be added back into Vtable3
5. the WHERE clause is evaluated, in this case only group information for user John Smith would be added to
vTable4
6. the GROUP BY is evaluated; if the above query were:

select g.GroupName, count(g.*) as NumberOfMembers

from users u
inner join groups g on g.Userid = u.Userid
group by GroupName
Select 95

vTable5 would consist of members returned from vTable4 arranged by the grouping, in this case the GroupName
7. the HAVING clause is evaluated for groups for which the HAVING clause is true and inserted into vTable6. For
example:

select g.GroupName, count(g.*) as NumberOfMembers

from users u
inner join groups g on g.Userid = u.Userid
group by GroupName
having count(g.*) > 5

8. the SELECT list is evaluated and returned as Vtable 7

9. the DISTINCT clause is evaluated; duplicate rows are removed and returned as Vtable 8
10. the ORDER BY clause is evaluated, ordering the rows and returning VCursor9. This is a cursor and not a table
because ANSI defines a cursor as an ordered set of rows (not relational).

References
[1] Microsoft. "Transact-SQL Syntax Conventions" (http:/ / msdn2. microsoft. com/ en-us/ library/ ms189499. aspx). .
[2] MySQL. "SQL SELECT Syntax" (http:/ / dev. mysql. com/ doc/ refman/ 5. 0/ en/ select. html). .
[3] Inside Microsoft SQL Server 2005: T-SQL Querying by Itzik Ben-Gan, Lubor Kollar, and Dejan Karka

• Horizontal & Vertical Partitioning, Microsoft SQL Server 2000 Books Online

External links
• Windowed Tables and Window function in SQL (http://wwwlgis.informatik.uni-kl.de/cms/fileadmin/
courses/SS2008/NEDM/RDDM.Chapter.06.Windows_and_Query_Functions_in_SQL.pdf), Stefan Deßloch
• Oracle SELECT Syntax. (http://download.oracle.com/docs/cd/B14117_01/server.101/b10759/
statements_10002.htm)
• Firebird SELECT Syntax. (http://www.firebirdsql.org/rlsnotesh/rlsnotes210.html#rnfb20x-dml-select-syntax)
• Mysql SELECT Syntax. (http://dev.mysql.com/doc/refman/5.1/en/select.html)
• Postgres SELECT Syntax. (http://www.postgresql.org/docs/current/static/sql-select.html)
• SQLite SELECT Syntax. (http://www.sqlite.org/lang_select.html)
Insert 96

Insert
An SQL INSERT statement adds one or more records to any single table in a relational database.

Basic form
Insert statements have the following form:
• INSERT INTO table (column1 [, column2, column3 ... ]) VALUES (value1 [, value2, value3 ... ])
The number of columns and values must be the same. If a column is not specified, the default value for the column is
used. The values specified (or implied) by the INSERT statement must satisfy all the applicable constraints (such as
primary keys, CHECK constraints, and NOT NULL constraints). If a syntax error occurs or if any constraints are
violated, the new row is not added to the table and an error returned instead.
Example:

INSERT INTO phone_book (name, number) VALUES ('John Doe', '555-1212');

Shorthand may also be used, taking advantage of the order of the columns when the table was created. It is not
required to specify all columns in the table since any other columns will take their default value or remain null:
• INSERT INTO table VALUES (value1, [value2, ... ])
Example for inserting data into 2 columns in the phone_book table and ignoring any other columns which may be
after the first 2 in the table.

INSERT INTO phone_book VALUES ('John Doe', '555-1212');

Advanced forms

Multirow inserts
A SQL feature (since SQL-92) is the use of row value constructors to insert multiple rows at a time in a single SQL
statement:

INSERT INTO table (column-a, [column-b, ...])

VALUES ('value-1a', ['value-1b', ...]),
('value-2a', ['value-2b', ...]),
...

This feature is supported by DB2, SQL Server (since version 10.0 - i.e. 2008), PostgreSQL (since version 8.2),
MySQL, sqlite (since version 3.7.11) and H2.
Example (assuming that 'name' and 'number' are the only columns in the 'phone_book' table):

INSERT INTO phone_book VALUES ('John Doe', '555-1212'), ('Peter Doe',

'555-2323');

which may be seen as a shorthand for the two statements

INSERT INTO phone_book VALUES ('John Doe', '555-1212');

INSERT INTO phone_book VALUES ('Peter Doe', '555-2323');

Note that the two separate statements may have different semantics (especially with respect to statement triggers)
and may not provide the same performance as a single multi-row insert.
To insert multiple rows in MS SQL you can use such a construction:
Insert 97

INSERT INTO phone_book

SELECT 'John Doe', '555-1212'
UNION ALL
SELECT 'Peter Doe', '555-2323';

Note that this is not a valid SQL statement according to the SQL standard (SQL:2003) due to the incomplete
subselect clause.
To do the same in Oracle use the DUAL table, which always consists of a single row only:

INSERT INTO phone_book

SELECT 'John Doe', '555-1212' FROM DUAL
UNION ALL
SELECT 'Peter Doe','555-2323' FROM DUAL

A standard-conforming implementation of this logic shows the following example, or as shown above:

INSERT INTO phone_book

SELECT 'John Doe', '555-1212' FROM LATERAL ( VALUES (1) ) AS t(c)
UNION ALL
SELECT 'Peter Doe','555-2323' FROM LATERAL ( VALUES (1) ) AS t(c)

Oracle PL/SQL supports the "INSERT ALL" statement, where multiple insert statements are terminated by a
SELECT:[1]

INSERT ALL
INTO phone_book VALUES ('John Doe', '555-1212')
INTO phone_book VALUES ('Peter Doe', '555-2323')
SELECT * FROM DUAL;

In Firebird inserting multiple rows can be achieved like this:

INSERT INTO phone_book ("name", "number")

SELECT 'John Doe', '555-1212' FROM RDB$DATABASE
UNION ALL
SELECT 'Peter Doe', '555-2323' FROM RDB$DATABASE;

Firebird however restricts the number of rows than can be inserted in this way, since there is a limit to the number
contexts that can be used in a single query.

Copying rows from other tables

An INSERT statement can also be used to retrieve data from other tables, modify it if necessary and insert it directly
into the table. All this is done in a single SQL statement that does not involve any intermediary processing in the
client application. A subselect is used instead of the VALUES clause. The subselect can contain joins, function calls,
and it can even query the same table into which the data is inserted. Logically, the select is evaluated before the
actual insert operation is started. An example is given below.

INSERT INTO phone_book2

SELECT *
FROM phone_book
WHERE name IN ('John Doe', 'Peter Doe')
Insert 98

A variation is needed when some of the data from the source table is being inserted into the new table, but not the
whole record. (Or when the tables' schemas are not the same.)

INSERT INTO phone_book2 ( [name], [phoneNumber] )

SELECT [name], [phoneNumber]
FROM phone_book
WHERE name IN ('John Doe', 'Peter Doe')

The SELECT statement produces a (temporary) table, and the schema of that temporary table must match with the
schema of the table where the data is inserted into.

Retrieving the key

Database designers that use a surrogate key as the primary key for every table will run into the occasional scenario
where they need to automatically retrieve the database generated primary key from an SQL INSERT statement for
use in another SQL statements. Most systems do not allow SQL INSERT statements to return row data. Therefore, it
becomes necessary to implement a workaround in such scenarios. Common implementations include:
• Using a database-specific stored procedure that generates the surrogate key, performs the INSERT operation, and
finally returns the generated key. For example, in Microsoft SQL Server, the key is retrieved via the
SCOPE_IDENTITY() special function, while in SQLite the function is named last_insert_rowid().
• Using a database-specific SELECT statement on a temporary table containing last inserted row(s). DB2
implements this feature in the following way:

SELECT *
FROM NEW TABLE (
INSERT INTO phone_book
VALUES ( 'Peter Doe','555-2323' )
) AS t

DB2 for z/OS implements this feature in the following way.

SELECT EMPNO, HIRETYPE, HIREDATE

FROM FINAL TABLE (
INSERT INTO EMPSAMP (NAME, SALARY, DEPTNO, LEVEL)
VALUES(’Mary Smith’, 35000.00, 11, ’Associate’)
);

• Using a SELECT statement after the INSERT statement with a database-specific function that returns the
generated primary key for the most recently inserted row. For example, LAST_INSERT_ID() for MySQL.
• Using a unique combination of elements from the original SQL INSERT in a subsequent SELECT statement.
• Using a GUID in the SQL INSERT statement and retrieving it in a SELECT statement.
• Using the OUTPUT clause in the SQL INSERT statement for MS-SQL Server 2005 and MS-SQL Server 2008.
• Using an INSERT statement with RETURNING clause for Oracle.

INSERT INTO phone_book VALUES ( 'Peter Doe','555-2323' )

RETURNING phone_book_id INTO v_pb_id

• Using an INSERT statement with RETURNING clause for PostgreSQL (since 8.2). The returned list is identical
to the result of a SELECT.
Firebird has the same syntax; the statement may add at most one row.[2]
Insert 99

INSERT INTO phone_book VALUES ( 'Peter Doe','555-2323' )

RETURNING phone_book_id

• Using the IDENTITY() function in H2 returns the last identity inserted.

SELECT IDENTITY();

Triggers
If triggers are defined on the table on which the INSERT statement operates, those triggers are evaluated in the
context of the operation. BEFORE INSERT triggers allow the modification of the values that shall be inserted into
the table. AFTER INSERT triggers cannot modify the data anymore, but can be used to initiate actions on other
tables, for example to implement auditing mechanism.

References
[1] "Oracle PL/SQL: INSERT ALL" (http:/ / psoug. org/ snippet/ Oracle-PL-SQL-INSERT-ALL_589. htm). psoug.org. . Retrieved 2010-09-02.
[2] "Firebird 2.5 Language Reference Update" (http:/ / www. firebirdsql. org/ file/ documentation/ reference_manuals/ reference_material/ html/
langrefupd25-insert. html#langrefupd25-insert-returning). . Retrieved 2011-10-24.

External links
• Oracle SQL INSERT statement (Oracle Database SQL Language Reference, 11g Release 2 (11.2) on oracle.com)
(http://download.oracle.com/docs/cd/E11882_01/server.112/e10592/statements_9014.htm)
• Microsoft Access Append Query Examples and SQL INSERT Query Syntax (http://www.fmsinc.com/
MicrosoftAccess/query/snytax/append-query.html)

Update
An SQL UPDATE statement changes the data of one or more records in a table. Either all the rows can be updated,
or a subset may be chosen using a condition.
The UPDATE statement has the following form:[1]
UPDATE table_name SET column_name = value [, column_name = value ...] [WHERE condition]
For the UPDATE to be successful, the user must have data manipulation privileges (UPDATE privilege) on the table
or column, the updated value must not conflict with all the applicable constraints (such as primary keys, unique
indexes, CHECK constraints, and NOT NULL constraints).
In some databases, such as PostgreSQL, when a FROM clause is present, what essentially happens is that the target
table is joined to the tables mentioned in the fromlist, and each output row of the join represents an update operation
for the target table. When using FROM you should ensure that the join produces at most one output row for each row
to be modified. In other words, a target row shouldn't join to more than one row from the other table(s). If it does,
then only one of the join rows will be used to update the target row, but which one will be used is not readily
predictable.[2]
Because of this indeterminacy, referencing other tables only within sub-selects is safer, though often harder to read
and slower than using a join.
Update 100

Examples
Set the value of column C1 in table T to 1, only in those rows where the value of column C2 is "a".

UPDATE T
SET C1 = 1
WHERE C2 = 'a'

In table T, set the value of column C1 to 9 and the value of C3 to 4 for all rows for which the value of column C2 is
"a".

UPDATE T
SET C1 = 9,
C3 = 4
WHERE C2 = 'a'

Increase value of column C1 by 1 if the value in column C2 is "a".

UPDATE T
SET C1 = C1 + 1
WHERE C2 = 'a'

Prepend the value in column C1 with the string "text" if the value in column C2 is "a".

UPDATE T
SET C1 = 'text' || C1
WHERE C2 = 'a'

Set the value of column C1 in table T1 to 2, only if the value of column C2 is found in the sub list of values in
column C3 in table T2 having the column C4 equal to 0.

UPDATE T1
SET C1 = 2
WHERE C2 IN ( SELECT C3
FROM T2
WHERE C4 = 0)

You may also update multiple columns in a single update statement:

UPDATE T
SET C1 = 1,
C2 = 2

Complex conditions and JOINs are also possible:

UPDATE T
SET A = 1
WHERE C1 = 1
AND C2 = 2

Some databases allow the non-standard use of the FROM clause:

UPDATE a
SET a.[updated_column] = updatevalue
FROM articles a
Update 101

JOIN classification c
ON a.articleID = c.articleID
WHERE c.classID = 1

Or on Oracle systems (assuming there is an index on classification.articleID)

UPDATE
(
SELECT *
FROM articles
JOIN classification
ON articles.articleID = classification.articleID
WHERE classification.classID = 1
)
SET [updated_column] = updatevalue

Potential Issues
See Halloween Problem. It is possible for certain kinds of UPDATE statements to become an infinite loop when the
WHERE clause and one or more SET clauses may utilize an intertwined index.

References
[1] http:/ / dev. mysql. com/ doc/ refman/ 5. 0/ en/ update. html simplified from this page
[2] http:/ / www. postgresql. org/ docs/ 8. 1/ static/ sql-update. html

Merge
A relational database management system uses SQL MERGE (upsert) statements to INSERT new records or
UPDATE existing records depending on whether or not a condition matches. It was officially introduced in the
SQL:2003 standard, and expanded in the SQL:2008 standard.

Usage
MERGE INTO table_name USING table_reference ON (condition)
WHEN MATCHED THEN
UPDATE SET column1 = value1 [, column2 = value2 ...]
WHEN NOT MATCHED THEN
INSERT (column1 [, column2 ...]) VALUES (value1 [, value2 ...

Right join is employed over the Target (the INTO table) and the Source (the USING table / view / sub-query). That
is:
• rows present in the Source but missing from the Target do run the action > specifically the NOT MATCHED
action
• rows missing from the Source and present in Target are ignored > no action is performed on the Target.
If multiple Source rows match a given Target row, an error is mandated by SQL:2003 standards. You cannot update
a Target row multiple times with a MERGE statement
Merge 102

Implementations
Database management systems Oracle Database, DB2, Teradata and MS SQL support the standard syntax. Some
also add non-standard SQL extensions.

Synonymous
Some database implementations adopted the term "Upsert" (a portmanteau of update and insert) to a database
statement, or combination of statements, that inserts a record to a table in a database if the record does not exist or, if
the record already exists, updates the existing record. It is also used to abbreviate the "MERGE" equivalent
pseudo-code.
It is used in Microsoft SQL Azure and MongoDB.
MongoDB provides an atomic upsert operation, which creates a new document by combining the criteria for the
update with the fields to change.
Example
suppose a collection is used to track the number of times each page of a website is viewed. Upserts can be
used to avoid "seeding" the collection with all possible pages in advance. The collection starts off empty:

> db.pages.find()

On each page view, the page's document is created if it doesn't exist yet and its views are incremented if it does.

> db.pages.update({"_id" : "http://www.example.com"}, {"$inc" : {"views" : 1}}, true)

> db.pages.find()
{ "_id" : "http://www.example.com", "views" : 1 }
> db.pages.update({"_id" : "http://www.example.com"}, {"$inc" : {"views" : 1}}, true)
{ "_id" : "http://www.example.com", "views" : 2 }

Other non-standard implementations

Some other database management systems support this, or very similar behavior, through their own, non-standard
SQL extensions.
MySQL, for example, supports the use of INSERT ... ON DUPLICATE KEY UPDATE syntax[1] which can be
used to achieve the same effect. It also supports REPLACE INTO syntax[2], which first deletes the row, if exists,
and then inserts the new one.
SQLite's INSERT OR REPLACE INTO works similarly.
Firebird supports MERGE INTO though fails at throwing error when multiple Source data. Additionally a
single-row version, UPDATE OR INSERT INTO tablename (columns) VALUES (values)
[MATCHING (columns)], but the latter does not give you the option to take different actions on insert vs. update
(e.g. setting a new sequence value only for new rows, not for existing ones.)
IBM DB2 extends syntax with multiple WHEN MATCHED and WHEN NOT MATCHED clauses, distinguishing
them with ... AND some-condition guards.
Microsoft SQL extends with supporting guards and also with supporting Left Join via WHEN NOT MATCHED BY
SOURCE clauses.
Merge 103

References
[1] MySQL :: MySQL 5.1 Reference Manual :: 12.2.4.3 INSERT ... ON DUPLICATE KEY UPDATE Syntax (http:/ / dev. mysql. com/ doc/
refman/ 5. 1/ en/ insert-on-duplicate. html)
[2] MySQL 5.1 Reference Manual: 11.2.6 REPLACE Syntax (http:/ / dev. mysql. com/ doc/ refman/ 5. 1/ en/ replace. html)

• Hsu, Leo; Obe, Regina (May 18, 2008). "Cross Compare of SQL Server, MySQL, and PostgreSQL" (http://
www.postgresonline.com/journal/archives/51-Cross-Compare-of-SQL-Server,-MySQL,-and-PostgreSQL.
html). Postgres OnLine Journal. Retrieved 8 October 2010.
• Chodorow, Kristina; Mike Dirolf (September 2010). MongoDB: The Definitive Guide. O'Reilly.
ISBN 978-1-449-38156-1.

External links
• Oracle 11g Release 2 documentation (http://download.oracle.com/docs/cd/E14072_01/server.112/e10592/
statements_9016.htm) on MERGE
• Firebird 2.1 documentation (http://www.firebirdsql.org/refdocs/langrefupd21-merge.html) on MERGE
• DB2 v9 MERGE statement (http://publib.boulder.ibm.com/infocenter/db2luw/v9/topic/com.ibm.db2.udb.
admin.doc/doc/r0010873.htm)
• SQL Server 2008 documentation (http://msdn.microsoft.com/en-us/library/bb510625.aspx)
• H2 (1.2) SQL Syntax page (http://www.h2database.com/html/grammar.html#merge)

Delete
In the database structured query language (SQL), the DELETE statement removes one or more records from a table.
A subset may be defined for deletion using a condition, otherwise all records are removed.[1]

Usage
The DELETE statement follows the syntax:
DELETE FROM table_name [WHERE condition];
Any rows that match the WHERE condition will be removed from the table. If the WHERE clause is omitted, all rows
in the table are removed. The DELETE statement should thus be used with caution.
The DELETE statement does not return any rows; that is, it will not generate a result set.
Executing a DELETE statement can cause triggers to run that can cause deletes in other tables. For example, if two
tables are linked by a foreign key and rows in the referenced table are deleted, then it is common that rows in the
referencing table would also have to be deleted to maintain referential integrity.

Examples
Delete rows from table pies where the column flavour equals Lemon Meringue:

DELETE FROM pies

WHERE flavour='Lemon Meringue';

Delete rows in trees, if the value of height is smaller than 80.

DELETE FROM trees

WHERE height < 80;

Delete all rows from mytable:

Delete 104

DELETE FROM mytable;

Delete rows from mytable using a subquery in the where condition:

DELETE FROM mytable

WHERE id IN (
SELECT id
FROM mytable2
);

Delete rows from mytable using a list of values:

DELETE FROM mytable

WHERE id IN (
value1,
value2,
value3,
value4,
value5
);

Example with related tables

Suppose there is a simple database that lists people and addresses. More than one person can live at a particular
address and a person can live at more than one address (this is an example of a many-to-many relationship). The
database only has three tables, person, address, and pa, with the following data:
person

pid name

1 Joe

2 Bob

3 Ann

address

aid description

100 2001 Main St.

200 35 Pico Blvd.

pa
Delete 105

pid aid

1 100

2 100

3 100

1 200

The pa table relates the person and address tables, showing that Joe, Bob and Ann all live at 2001 Main Street, but
Joe also takes up residence on Pico Boulevard.
In order to remove joe from the database, two deletes must be executed:

DELETE FROM person WHERE pid=1;

DELETE FROM pa WHERE pid=1;

To maintain referential integrity, Joe's records must be removed from both person and pa. The means by which
integrity is sustained can happen differently in varying relational database management systems . It could be that
beyond just having three tables, the database also has been set up with a trigger so that whenever a row is deleted
from person any linked rows would be deleted from pa. Then the first statement:

DELETE FROM person WHERE pid=1;

would automatically trigger the second:

DELETE FROM pa WHERE pid=1;

Related commands
Deleting all rows from a table can be very time consuming. Some DBMS offer a TRUNCATE TABLE command
that works a lot quicker, as it only alters metadata and typically does not spend time enforcing constraints or firing
triggers.
DELETE only deletes the rows. For deleting a table entirely the DROP command can be used.

References
[1] "SQL Delete Statement" (http:/ / www. w3schools. com/ Sql/ sql_delete. asp). w3schools.com. .
Join 106

Join
A SQL join clause combines records from two or more tables in a database. It creates a set that can be saved as a
table or used as is. A JOIN is a means for combining fields from two tables by using values common to each. ANSI
standard SQL specifies four types of JOIN: INNER, OUTER, LEFT, and RIGHT. As a special case, a table (base
table, view, or joined table) can JOIN to itself in a self-join.
A programmer writes a JOIN predicate to identify the records for joining. If the evaluated predicate is true, the
combined record is then produced in the expected format, a record set or a temporary table.

Sample tables
Relational databases are often normalized to eliminate duplication of information when objects may have
one-to-many relationships. For example, a Department may be associated with many different Employees. Joining
two tables effectively creates another table which combines information from both tables. This is at some expense in
terms of the time it takes to compute the join. While it is also possible to simply maintain a denormalized table if
speed is important, duplicate information may take extra space, and add the expense and complexity of maintaining
data integrity if data which is duplicated later changes.
All subsequent explanations on join types in this article make use of the following two tables. The rows in these
tables serve to illustrate the effect of different types of joins and join-predicates. In the following tables the
DepartmentID column of the Department table (which can be designated as
Department.DepartmentID) is the primary key, while Employee.DepartmentID is a foreign key.

Employee table
LastName DepartmentID

Rafferty 31

Jones 33

Steinberg 33

Robinson 34

Smith 34

John NULL

Department table
DepartmentID DepartmentName

31 Sales

33 Engineering

34 Clerical

35 Marketing

Note: In the Employee table above, the employee "John" has not been assigned to any department yet. Also, note that
no employees are assigned to the "Marketing" department.
This is the SQL to create the aforementioned tables.

CREATE TABLE department

(
Join 107

DepartmentID INT,
DepartmentName VARCHAR(20)
);

CREATE TABLE employee

(
LastName VARCHAR(20),
DepartmentID INT
);

INSERT INTO department(DepartmentID, DepartmentName) VALUES(31,

'Sales');
INSERT INTO department(DepartmentID, DepartmentName) VALUES(33,
'Engineering');
INSERT INTO department(DepartmentID, DepartmentName) VALUES(34,
'Clerical');
INSERT INTO department(DepartmentID, DepartmentName) VALUES(35,
'Marketing');

INSERT INTO employee(LastName, DepartmentID) VALUES('Rafferty', 31);

INSERT INTO employee(LastName, DepartmentID) VALUES('Jones', 33);
INSERT INTO employee(LastName, DepartmentID) VALUES('Steinberg', 33);
INSERT INTO employee(LastName, DepartmentID) VALUES('Robinson', 34);
INSERT INTO employee(LastName, DepartmentID) VALUES('Smith', 34);
INSERT INTO employee(LastName, DepartmentID) VALUES('John', NULL);

Inner join
An inner join is the most common join operation used in applications and can be regarded as the default join-type.
Inner join creates a new result table by combining column values of two tables (A and B) based upon the
join-predicate. The query compares each row of A with each row of B to find all pairs of rows which satisfy the
join-predicate. When the join-predicate is satisfied, column values for each matched pair of rows of A and B are
combined into a result row. The result of the join can be defined as the outcome of first taking the Cartesian product
(or Cross join) of all records in the tables (combining every record in table A with every record in table B)—then
return all records which satisfy the join predicate. Actual SQL implementations normally use other approaches like a
hash join or a sort-merge join where possible, since computing the Cartesian product is very inefficient.
SQL specifies two different syntactical ways to express joins: "explicit join notation" and "implicit join notation".
The "explicit join notation" uses the JOIN keyword to specify the table to join, and the ON keyword to specify the
predicates for the join, as in the following example:

SELECT *
FROM employee
INNER JOIN department ON employee.DepartmentID =
department.DepartmentID;

The "implicit join notation" simply lists the tables for joining, in the FROM clause of the SELECT statement, using
commas to separate them. Thus it specifies a cross join, and the WHERE clause may apply additional
filter-predicates (which function comparably to the join-predicates in the explicit notation).
Join 108

The following example is equivalent to the previous one, but this time using implicit join notation:

SELECT *
FROM employee, department
WHERE employee.DepartmentID = department.DepartmentID;

The queries given in the examples above will join the Employee and Department tables using the DepartmentID
column of both tables. Where the DepartmentID of these tables match (i.e. the join-predicate is satisfied), the query
will combine the LastName, DepartmentID and DepartmentName columns from the two tables into a result row.
Where the DepartmentID does not match, no result row is generated.
Thus the result of the execution of either of the two queries above will be:

Employee.LastName Employee.DepartmentID Department.DepartmentName Department.DepartmentID

Robinson 34 Clerical 34

Jones 33 Engineering 33

Smith 34 Clerical 34

Steinberg 33 Engineering 33

Rafferty 31 Sales 31

Note: Programmers should take special care when joining tables on columns that can contain NULL values, since
NULL will never match any other value (not even NULL itself), unless the join condition explicitly uses the IS
NULL or IS NOT NULL predicates.
Notice that the employee "John" and the department "Marketing" do not appear in the query execution results.
Neither of these has any matching records in the other respective table: "John" has no associated department, and no
employee has the department ID 35 ("Marketing"). Depending on the desired results, this behavior may be a subtle
bug, which can be avoided with an outer join.
One can further classify inner joins as equi-joins, as natural joins, or as cross-joins.

Equi-join
An equi-join is a specific type of comparator-based join, or theta join, that uses only equality comparisons in the
join-predicate. Using other comparison operators (such as <) disqualifies a join as an equi-join. The query shown
above has already provided an example of an equi-join:

SELECT *
FROM employee
JOIN department ON employee.DepartmentID = department.DepartmentID;

We can write equi-join as below,

SELECT * FROM employee, department WHERE employee.DepartmentID =

department.DepartmentID;

If columns in an equijoin have the same name, SQL/92 provides an optional shorthand notation for expressing
equi-joins, by way of the USING construct[1]:

SELECT *
FROM employee
INNER JOIN department USING (DepartmentID);
Join 109

The USING construct is more than mere syntactic sugar, however, since the result set differs from the result set of
the version with the explicit predicate. Specifically, any columns mentioned in the USING list will appear only
once, with an unqualified name, rather than once for each table in the join. In the above case, there will be a single
DepartmentID column and no employee.DepartmentID or department.DepartmentID.
The USING clause is not supported by SQL Server and Sybase.

Natural join
A natural join is a type of equi-join where the join predicate arises implicitly by comparing all columns in both tables
that have the same column-names in the joined tables. The resulting joined table contains only one column for each
pair of equally named columns.
Most experts agree that NATURAL JOINs are dangerous and therefore strongly discourage their use.[2] The danger
comes from inadvertently adding a new column, named the same as another column in the other table. An existing
natural join might then "naturally" use the new column for comparisons, making comparisons/matches using
different criteria (from different columns) than before. Thus an existing query could produce different results, even
though the data in the tables have not been changed, but only augmented.
The above sample query for inner joins can be expressed as a natural join in the following way:

SELECT *
FROM employee
NATURAL JOIN department;

As with the explicit USING clause, only one DepartmentID column occurs in the joined table, with no qualifier:

DepartmentID Employee.LastName Department.DepartmentName

34 Smith Clerical

33 Jones Engineering

34 Robinson Clerical

33 Steinberg Engineering

31 Rafferty Sales

PostgreSQL, MySQL and Oracle support natural joins, but not Microsoft T-SQL or IBM DB2. The columns used in
the join are implicit so the join code does not show which columns are expected, and a change in column names may
change the results. An INNER JOIN performed on 2 tables having the same field name has the same effect.[3]

Cross join
CROSS JOIN returns the Cartesian product of rows from tables in the join. In other words, it will produce rows
which combine each row from the first table with each row from the second table. [4]
Example of an explicit cross join:

SELECT *
FROM employee
CROSS JOIN department;

Example of an implicit cross join:

SELECT *
FROM employee, department;
Join 110

Employee.LastName Employee.DepartmentID Department.DepartmentName Department.DepartmentID

Rafferty 31 Sales 31

Jones 33 Sales 31

Steinberg 33 Sales 31

Smith 34 Sales 31

Robinson 34 Sales 31

John NULL Sales 31

Rafferty 31 Engineering 33

Jones 33 Engineering 33

Steinberg 33 Engineering 33

Smith 34 Engineering 33

Robinson 34 Engineering 33

John NULL Engineering 33

Rafferty 31 Clerical 34

Jones 33 Clerical 34

Steinberg 33 Clerical 34

Smith 34 Clerical 34

Robinson 34 Clerical 34

John NULL Clerical 34

Rafferty 31 Marketing 35

Jones 33 Marketing 35

Steinberg 33 Marketing 35

Smith 34 Marketing 35

Robinson 34 Marketing 35

John NULL Marketing 35

The cross join does not apply any predicate to filter records from the joined table. Programmers can further filter the
results of a cross join by using a WHERE clause.

Outer joins
An outer join does not require each record in the two joined tables to have a matching record. The joined table
retains each record—even if no other matching record exists. Outer joins subdivide further into left outer joins, right
outer joins, and full outer joins, depending on which table(s) one retains the rows from (left, right, or both).
(In this case left and right refer to the two sides of the JOIN keyword.)
No implicit join-notation for outer joins exists in standard SQL.
Join 111

Left outer join

The result of a left outer join (or simply left join) for table A and B always contains all records of the "left" table
(A), even if the join-condition does not find any matching record in the "right" table (B). This means that if the ON
clause matches 0 (zero) records in B, the join will still return a row in the result—but with NULL in each column
from B. This means that a left outer join returns all the values from the left table, plus matched values from the right
table (or NULL in case of no matching join predicate). If the right table returns one row and the left table returns
more than one matching row for it, the values in the right table will be repeated for each distinct row on the left table.
From Oracle 9i onwards the LEFT OUTER JOIN statement can be used as well as Oracle's older (+) syntax.[5]
For example, this allows us to find an employee's department, but still shows the employee(s) even when they have
not been assigned to a department (contrary to the inner-join example above, where unassigned employees were
excluded from the result).
Example of a left outer join, with the additional result row italicized:

SELECT *
FROM employee
LEFT OUTER JOIN department ON employee.DepartmentID =
department.DepartmentID;

Employee.LastName Employee.DepartmentID Department.DepartmentName Department.DepartmentID

Jones 33 Engineering 33

Rafferty 31 Sales 31

Robinson 34 Clerical 34

Smith 34 Clerical 34

John NULL NULL NULL

Steinberg 33 Engineering 33

Oracle supports the alternate syntax:

SELECT * FROM employee, department WHERE employee.DepartmentID =

department.DepartmentID(+)

Sybase supports the alternate syntax:

SELECT * FROM employee, department WHERE employee.DepartmentID *=

department.DepartmentID

Right outer join

A right outer join (or right join) closely resembles a left outer join, except with the treatment of the tables reversed.
Every row from the "right" table (B) will appear in the joined table at least once. If no matching row from the "left"
table (A) exists, NULL will appear in columns from A for those records that have no match in B. A right outer join
returns all the values from the right table and matched values from the left table (NULL in case of no matching join
predicate). For example, this allows us to find each employee and his or her department, but still show departments
that have no employees.
Below is an example of a right outer join, with the additional result row italicized:

SELECT *
FROM employee
RIGHT OUTER JOIN department ON employee.DepartmentID =
Join 112

department.DepartmentID;

Employee.LastName Employee.DepartmentID Department.DepartmentName Department.DepartmentID

Smith 34 Clerical 34

Jones 33 Engineering 33

Robinson 34 Clerical 34

Steinberg 33 Engineering 33

Rafferty 31 Sales 31

NULL NULL Marketing 35

Oracle supports the alternate syntax:

SELECT * FROM employee, department WHERE employee.DepartmentID(+) =

department.DepartmentID

Right and left outer joins are functionally equivalent. Neither provides any functionality that the other does not, so
right and left outer joins may replace each other as long as the table order is switched.

Full outer join

Conceptually, a full outer join combines the effect of applying both left and right outer joins. Where records in the
FULL OUTER JOINed tables do not match, the result set will have NULL values for every column of the table that
lacks a matching row. For those records that do match, a single row will be produced in the result set (containing
fields populated from both tables).
For example, this allows us to see each employee who is in a department and each department that has an employee,
but also see each employee who is not part of a department and each department which doesn't have an employee.
Example full outer join:

SELECT *
FROM employee
FULL OUTER JOIN department ON employee.DepartmentID =
department.DepartmentID;

Employee.LastName Employee.DepartmentID Department.DepartmentName Department.DepartmentID

Smith 34 Clerical 34

Jones 33 Engineering 33

Robinson 34 Clerical 34

John NULL NULL NULL

Steinberg 33 Engineering 33

Rafferty 31 Sales 31

NULL NULL Marketing 35

Some database systems do not support the full outer join functionality directly, but they can emulate it through the
use of an inner join and UNION ALL selects of the "single table rows" from left and right tables respectively. The
same example can appear as follows:
Join 113

SELECT employee.LastName, employee.DepartmentID,

department.DepartmentName, department.DepartmentID
FROM employee
INNER JOIN department ON employee.DepartmentID =
department.DepartmentID

UNION ALL

SELECT employee.LastName, employee.DepartmentID, cast(NULL as

varchar(20)), cast(NULL as integer)
FROM employee
WHERE NOT EXISTS (SELECT * FROM department WHERE employee.DepartmentID
= department.DepartmentID)

UNION ALL

SELECT cast(NULL as varchar(20)), cast(NULL as integer),

department.DepartmentName, department.DepartmentID
FROM department
WHERE NOT EXISTS (SELECT * FROM employee WHERE employee.DepartmentID =
department.DepartmentID)

Self-join
A self-join is joining a table to itself.[6]

Example
A query to find all pairings of two employees in the same country is desired. If there were two separate tables for
employees and a query which requested employees in the first table having the same country as employees in the
second table, a normal join operation could be used to find the answer table. However, all the employee information
is contained within a single large table.[7]
Consider a modified Employee table such as the following:

Employee Table
EmployeeID LastName Country DepartmentID

123 Rafferty Australia 31

124 Jones Australia 33

145 Steinberg Australia 33

201 Robinson United States 34

305 Smith Germany 34

306 John Germany NULL

An example solution query could be as follows:

SELECT F.EmployeeID, F.LastName, S.EmployeeID, S.LastName, F.Country

FROM Employee F
Join 114

INNER JOIN Employee S ON F.Country = S.Country

WHERE F.EmployeeID < S.EmployeeID
ORDER BY F.EmployeeID, S.EmployeeID;

Which results in the following table being generated.

Employee Table after Self-join by Country

EmployeeID LastName EmployeeID LastName Country

123 Rafferty 124 Jones Australia

123 Rafferty 145 Steinberg Australia

124 Jones 145 Steinberg Australia

305 Smith 306 John Germany

For this example:

• F and S are aliases for the first and second copies of the employee table.
• The condition F.Country = S.Country excludes pairings between employees in different countries. The
example question only wanted pairs of employees in the same country.
• The condition F.EmployeeID < S.EmployeeID excludes pairings where the EmployeeID of the first
employee is greater than or equal to the EmployeeID of the second employee. In other words, the effect of this
condition is to exclude duplicate pairings and self-pairings. Without it, the following less useful table would be
generated (the table below displays only the "Germany" portion of the result):

EmployeeID LastName EmployeeID LastName Country

305 Smith 305 Smith Germany

305 Smith 306 John Germany

306 John 305 Smith Germany

306 John 306 John Germany

Only one of the two middle pairings is needed to satisfy the original question, and the topmost and bottommost are
of no interest at all in this example.

Merge rows
To be able to do a select so as to merge multiple rows into 1 row : "group_concat notation".
MySQL uses the group_concat keyword to achieve that goal, and PostgreSQL 9.0 has the string_agg
function. Versions before 9.0 required the use of something like

array_to_string(array_agg(value),', ')

or the creation of an aggregate function.

Join 115

Using the Employee Table:

LastName DepartmentID

Rafferty 31

Jones 33

Steinberg 33

Robinson 34

Smith 34

John NULL

to achieve the following results Table

DepartmentID LastNames

NULL John

31 Rafferty

33 Jones, Steinberg

34 Robinson, Smith

MySQL
SELECT DepartmentID, group_concat(LastName) as LastNames
FROM employee
GROUP BY DepartmentID;

PostgreSQL
First the function _group_concat and aggregate group_concat need to be created before that query can be possible.

CREATE OR REPLACE FUNCTION _group_concat(text, text)

RETURNS text AS $$
SELECT CASE
WHEN $2 IS NULL THEN $1
WHEN $1 IS NULL THEN $2
ELSE $1 operator(pg_catalog.||) ', ' operator(pg_catalog.||) $2
END
$$ IMMUTABLE LANGUAGE SQL;

error// Join SQL

CREATE AGGREGATE group_concat (
BASETYPE = text,
SFUNC = _group_concat,
STYPE = text
);

SELECT DepartmentID, group_concat(LastName) as LastNames

FROM employee
GROUP BY DepartmentID;
Join 116

As for version 9.0:

SELECT DepartmentID, string_agg(LastName, ', ') as LastNames

FROM employee
GROUP BY DepartmentID;

Microsoft T-SQL
For versions prior to Microsoft SQL Server 2005, the function group_concat must be created as a user-defined
aggregate function before that query can be possible, shown here in C#.

using System;
using System.Collections.Generic;
using System.Data.SqlTypes;
using System.IO;
using Microsoft.SqlServer.Server;

[Serializable]
[SqlUserDefinedAggregate(Format.UserDefined, MaxByteSize=8000)]
public struct group_concat : IBinarySerialize{
private List values;

public void Init() {

this.values = new List();
}

public void Accumulate(SqlString value) {

this.values.Add(value.Value);
}

public void Merge(strconcat value) {

this.values.AddRange(value.values.ToArray());
}

public SqlString Terminate() {

return new SqlString(string.Join(", ",
this.values.ToArray()));
}

public void Read(BinaryReader r) {

int itemCount = r.ReadInt32();
this.values = new List(itemCount);
for (int i = 0; i < itemCount; i++) {
this.values.Add(r.ReadString());
}
}

public void Write(BinaryWriter w) {

w.Write(this.values.Count);
Join 117

foreach (string s in this.values) {

w.Write(s);
}
}
}

Then you can use the following query:

SELECT DepartmentID, dbo.group_concat(LastName) as LastNames

FROM employee
GROUP BY DepartmentID;

From version 2005, one can accomplish this task using FOR XML PATH:

SELECT DepartmentID,
STUFF(
(SELECT
',' + LastName
FROM (
SELECT LastName
FROM employee e2
WHERE e1.DepartmentID=e2.DepartmentID OR
(e1.DepartmentID IS NULL AND
e2.DepartmentID IS NULL)
) t1
ORDER BY LastName
FOR XML PATH('')
)
,1,1, ''
) AS LastNames
FROM employee e1
GROUP BY DepartmentID

Alternatives
The effect of an outer join can also be obtained using a UNION ALL between an INNER JOIN and a SELECT of
the rows in the "main" table that do not fulfill the join condition. For example

SELECT employee.LastName, employee.DepartmentID,

department.DepartmentName
FROM employee
LEFT OUTER JOIN department ON employee.DepartmentID =
department.DepartmentID;

can also be written as

SELECT employee.LastName, employee.DepartmentID,

department.DepartmentName
FROM employee
INNER JOIN department ON employee.DepartmentID =
department.DepartmentID
Join 118

UNION ALL

SELECT employee.LastName, employee.DepartmentID, cast(NULL as

varchar(20))
FROM employee
WHERE NOT EXISTS (SELECT * FROM department WHERE employee.DepartmentID
= department.DepartmentID)

Implementation
Much work in database-systems has aimed at efficient implementation of joins, because relational systems
commonly call for joins, yet face difficulties in optimising their efficient execution. The problem arises because
inner joins operate both commutatively and associatively. In practice, this means that the user merely supplies the list
of tables for joining and the join conditions to use, and the database system has the task of determining the most
efficient way to perform the operation. A query optimizer determines how to execute a query containing joins. A
query optimizer has two basic freedoms:
1. Join order: Because it joins functions commutatively and associatively, the order in which the system joins
tables does not change the final result-set of the query. However, join-order could have an enormous impact on
the cost of the join operation, so choosing the best join order becomes very important.
2. Join method: Given two tables and a join condition, multiple algorithms can produce the result-set of the join.
Which algorithm runs most efficiently depends on the sizes of the input tables, the number of rows from each
table that match the join condition, and the operations required by the rest of the query.
Many join-algorithms treat their inputs differently. One can refer to the inputs to a join as the "outer" and "inner" join
operands, or "left" and "right", respectively. In the case of nested loops, for example, the database system will scan
the entire inner relation for each row of the outer relation.
One can classify query-plans involving joins as follows:[8]
left-deep
using a base table (rather than another join) as the inner operand of each join in the plan
right-deep
using a base table as the outer operand of each join in the plan
bushy
neither left-deep nor right-deep; both inputs to a join may themselves result from joins
These names derive from the appearance of the query plan if drawn as a tree, with the outer join relation on the left
and the inner relation on the right (as convention dictates).
Join 119

Join algorithms
Three fundamental algorithms for performing a join operation are known: Nested loop join, Sort-merge join and
Hash join.

Notes
[1] Simplifying Joins with the USING Keyword (http:/ / www. java2s. com/ Tutorial/ Oracle/ 0140__Table-Joins/
SimplifyingJoinswiththeUSINGKeyword. htm)
[2] Ask Tom "Oracle support of ANSI joins." (http:/ / asktom. oracle. com/ pls/ asktom/ f?p=100:11:0::::P11_QUESTION_ID:13430766143199)
Back to basics: inner joins » Eddie Awad's Blog (http:/ / awads. net/ wp/ 2006/ 03/ 20/ back-to-basics-inner-joins/ #comment-2837)
[3] Why SQL Server Doesn’t Support Natural Join Syntax (http:/ / database. blogs. webucator. com/ 2010/ 03/ 31/
why-sql-server-doesnt-support-natural-join-syntax/ )
[4] SQL CROSS JOIN (http:/ / www. sqlguides. com/ sql_cross_join. php)
[5] Oracle Left Outer Join. "Oracle Left Outer Join" (http:/ / www. dba-oracle. com/ tips_oracle_left_outer_join. htm). Oracle Tips. Burleson
Consulting. . Retrieved 15 July 2011.
[6] Shah 2005, p. 165
[7] Adapted from Pratt 2005, pp. 115–6
[8] Yu & Meng 1998, p. 213

References
• Pratt, Phillip J (2005), A Guide To SQL, Seventh Edition, Thomson Course Technology,
ISBN 978-0-619-21674-0
• Shah, Nilesh (2005) [2002], Database Systems Using Oracle - A Simplified Guide to SQL and PL/SQL Second
Edition (International ed.), Pearson Education International, ISBN 0-13-191180-5
• Yu, Clement T.; Meng, Weiyi (1998), Principles of Database Query Processing for Advanced Applications (http:/
/books.google.com/?id=aBHRDhrrehYC), Morgan Kaufmann, ISBN 978-1-55860-434-6, retrieved 2009-03-03

External links
• Specific to products
• Sybase ASE 15 Joins (http://infocenter.sybase.com/help/index.jsp?topic=/com.sybase.help.ase_15.0.
sqlug/html/sqlug/sqlug138.htm)
• MySQL 5.5 Joins (http://dev.mysql.com/doc/refman/5.5/en/join.html)
• PostgreSQL Join with Query Explain (http://www.postgresqlguide.com/
retrieving-data-from-multiple-tables-by-using-sql-join.aspx)
• PostgreSQL 8.3 Joins (http://www.postgresql.org/docs/8.3/static/tutorial-join.html)
• Joins in Microsoft SQL Server (http://msdn2.microsoft.com/en-us/library/ms191517.aspx)
• Joins in MaxDB 7.6 (http://maxdb.sap.com/currentdoc/45/f31c38e95511d5995d00508b5d5211/content.
htm)
• Joins in Oracle 11g (http://download.oracle.com/docs/cd/B28359_01/server.111/b28286/queries006.
htm)
• General
• A Visual Explanation of SQL Joins (http://www.codinghorror.com/blog/archives/000976.html)
• Another visual explanation of SQL joins, along with some set theory (http://www.halfgaar.net/
sql-joins-are-easy)
• SQL join types classified with examples (http://www.gplivna.eu/papers/sql_join_types.htm)
• An alternative strategy to using FULL OUTER JOIN (http://weblogs.sqlteam.com/jeffs/archive/2007/04/
19/Full-Outer-Joins.aspx)
Set operations 120

Set operations
UNION operator
In SQL the UNION clause combines the results of two SQL queries into a single table of all matching rows. The two
queries must result in the same number of columns and compatible data types in order to unite. Any duplicate
records are automatically removed unless UNION ALL is used.
UNION can be useful in data warehouse applications where tables aren't perfectly normalized.[1] A simple example
would be a database having tables sales2005 and sales2006 that have identical structures but are separated
because of performance considerations. A UNION query could combine results from both tables.
Note that UNION does not guarantee the order of rows. Rows from the second operand may appear before, after, or
mixed with rows from the first operand. In situations where a specific order is desired, ORDER BY must be used.
Note that UNION ALL may be much faster than plain UNION.

Examples
Given these two tables:

sales2005
person amount

Joe 1000

Alex 2000

Bob 5000

sales2006
person amount

Joe 2000

Alex 2000

Zach 35000

Executing this statement:

SELECT * FROM sales2005

UNION
SELECT * FROM sales2006;

yields this result set, though the order of the rows can vary because no ORDER BY clause was supplied:
Set operations 121

person amount

Joe 1000

Alex 2000

Bob 5000

Joe 2000

Zach 35000

Note that there are two rows for Joe because those rows are distinct across their columns. There is only one row for
Alex because those rows are not distinct for both columns.
UNION ALL gives different results, because it will not eliminate duplicates. Executing this statement:

SELECT * FROM sales2005

UNION ALL
SELECT * FROM sales2006;

would give these results, again allowing variance for the lack of an ORDER BY statement:

person amount

Joe 1000

Joe 2000

Alex 2000

Alex 2000

Bob 5000

Zach 35000

The discussion of full outer joins also has an example that uses UNION.

INTERSECT operator
The SQL INTERSECT operator takes the results of two queries and returns only rows that appear in both result
sets. For purposes of duplicate removal the INTERSECT operator does not distinguish between NULLs. The
INTERSECT operator removes duplicate rows from the final result set. The INTERSECT ALL operator does not
remove duplicate rows from the final result set.

Example
The following example INTERSECT query returns all rows from the Orders table where Quantity is between 50
and 100.

SELECT *
FROM Orders
WHERE Quantity BETWEEN 1 AND 100

INTERSECT

SELECT *
FROM Orders
WHERE Quantity BETWEEN 50 AND 200;
Set operations 122

EXCEPT operator
The SQL EXCEPT operator takes the distinct rows of one query and returns the rows that do not appear in a second
result set. The EXCEPT ALL operator (not supported in MSSQL) does not remove duplicates. For purposes of row
elimination and duplicate removal, the EXCEPT operator does not distinguish between NULLs.
Notably, the Oracle platform provides a MINUS operator which is functionally equivalent to the SQL standard
EXCEPT DISTINCT operator [2].

Example
The following example EXCEPT query returns all rows from the Orders table where Quantity is between 1 and 49,
and those with a Quantity between 76 and 100.
Worded another way; the query returns all rows where the Quantity is between 1 and 100, apart from rows where the
quantity is between 50 and 75.

SELECT *
FROM Orders
WHERE Quantity BETWEEN 1 AND 100

EXCEPT

SELECT *
FROM Orders
WHERE Quantity BETWEEN 50 AND 75;

Alternatively, in implementations of the SQL language without the EXCEPT operator, the equivalent form of a
LEFT JOIN where the right hand values are NULL can be used instead.

Example
The following example is equivalent to the above example but without using the EXCEPT operator.

SELECT o1.*
FROM (
SELECT *
FROM Orders
WHERE Quantity BETWEEN 1 AND 100) o1
LEFT JOIN (
SELECT *
FROM Orders
WHERE Quantity BETWEEN 50 AND 75) o2
ON o1.id = o2.id
WHERE o2.id IS NULL
Set operations 123

References
[1] "a UNION ALL views technique for managing maintenance and performance in your large data warehouse environment ... This UNION
ALL technique has saved many of my clients with issues related to time-sensitive database designs. These databases usually have an extremely
volatile current timeframe, month, or day portion and the older data is rarely updated. Using different container DASD allocations,
tablespaces, tables, and index definitions, the settings can be tuned for the specific performance considerations for these different volatility
levels and update frequency situations." Terabyte Data Warehouse Table Design Choices - Part 2 (http:/ / www. dbazine. com/ datawarehouse/
dw-articles/ beulke4) (URL accessed on July 25, 2006)
[2] http:/ / download-east. oracle. com/ docs/ cd/ B19306_01/ server. 102/ b14200/ ap_standard_sql003. htm#g14847

External links
• MSDN documentation on UNION in Transact-SQL for SQL Server (http://msdn2.microsoft.com/en-us/
library/ms180026.aspx)
• Naming of select list items in set operations (http://www.sqlexpert.co.uk/2007/11/
order-by-clause-in-statements-with.html)
• UNION in MySQL with Examples (http://www.mysqltutorial.org/sql-union-mysql.aspx)
• UNION in MySQL (http://dev.mysql.com/doc/refman/5.0/en/union.html)
• UNION Clause in PostgreSQL (http://www.postgresql.org/docs/current/static/sql-select.html#SQL-UNION)
• SQL UNION and UNION ALL (http://www.w3schools.com/sql/sql_union.asp)
• Sort order within UNION statement (http://www.sqlexpert.co.uk/2007/11/
order-by-clause-in-statements-with.html)
• Designing a data flow that loads a warehouse table (http://publib.boulder.ibm.com/infocenter/db2luw/v8/
index.jsp?topic=/com.ibm.dwe.tutorial.doc/tutetlmod1_lesson2.htm)
• Oracle 11g documentation for UNION (ALL), INTERSECT and MINUS (http://download.oracle.com/docs/
cd/B28359_01/server.111/b28286/queries004.htm)
• SQL Set Operators (http://www.gplivna.eu/papers/sql_set_operators.htm)
Commit 124

Commit
In the context of computer science and data management, commit refers to the idea of making a set of tentative
changes permanent. A popular usage is at the end of a transaction. A commit is an act of committing.

Data management
A COMMIT statement in SQL ends a transaction within a relational database management system (RDBMS) and
makes all changes visible to other users. The general format is to issue a BEGIN WORK statement, one or more
SQL statements, and then the COMMIT statement. Alternatively, a ROLLBACK statement can be issued, which
undoes all the work performed since BEGIN WORK was issued. A COMMIT statement will also release any
existing savepoints that may be in use.
In terms of transactions, the opposite of commit is to discard the tentative changes of a transaction, a rollback.

Revision control
Commits are also done for revision control systems for source code such as Subversion or Concurrent Versions
System. A commit in the context of these version control systems refers to submitting the latest changes of the
source code to the repository, and making these changes part of the head revision of the repository. Thus, when other
users do an UPDATE or a checkout from the repository, they will receive the latest committed version, unless
they specify they wish to retrieve a previous version of the source code in the repository. Version control systems
also have similar functionality to SQL databases in that they allow rolling back to previous versions easily. In this
context, a commit with version control systems is not as dangerous as it allows easy rollback, even after the commit
has been done.

Notes
Rollback 125

Rollback
In database technologies, a rollback is an operation which returns the database to some previous state. Rollbacks are
important for database integrity, because they mean that the database can be restored to a clean copy even after
erroneous operations are performed. They are crucial for recovering from database server crashes; by rolling back
any transaction which was active at the time of the crash, the database is restored to a consistent state.
The rollback feature is usually implemented with a transaction log, but can also be implemented via multiversion
concurrency control.

Cascading rollback
A cascading rollback occurs in database systems when a transaction (T1) causes a failure and a rollback must be
performed. Other transactions dependent on T1's actions must also be rollbacked due to T1's failure, thus causing a
cascading effect. That is, one transaction's failure causes many to fail.
Practical database recovery techniques guarantee cascadeless rollback, therefore a cascading rollback is not a
desirable result.

SQL
In SQL, ROLLBACK is a command that causes all data changes since the last BEGIN WORK, or START
TRANSACTION to be discarded by the relational database management system (RDBMS), so that the state of the
data is "rolled back" to the way it was before those changes were made.
A ROLLBACK statement will also release any existing savepoints that may be in use.
In most SQL dialects, ROLLBACKs are connection specific. This means that if two connections are made to the same
database, a ROLLBACK made in one connection will not affect any other connections. This is vital for proper
concurrency.

References
• Ramez Elmasri (2007). Fundamentals of Database Systems. Pearson Addison Wesley. ISBN 0-321-36957-2.
• "ROLLBACK Transaction" [1], Microsoft SQL Server.
• "Sql Commands" [2], MySQL.

References
[1] http:/ / msdn2. microsoft. com/ en-us/ library/ ms181299. aspx
[2] http:/ / www. pantz. org/ software/ mysql/ mysqlcommands. html
Truncate 126

Truncate
In SQL, the TRUNCATE TABLE statement is a Data Definition Language (DDL) operation that marks the extents
of a table for deallocation (empty for reuse). The result of this operation quickly removes all data from a table,
typically bypassing a number of integrity enforcing mechanisms. It was officially introduced in the SQL:2008
standard.
The TRUNCATE TABLE mytable statement is logically (though not physically) equivalent to the DELETE
FROM mytable statement (without a WHERE clause). The following characteristics distinguish TRUNCATE
TABLE from DELETE:
• In the Oracle Database, TRUNCATE is implicitly preceded and followed by a commit operation. (This may also
be the case in MySQL, depending on the chosen storage engine.)
• Typically, TRUNCATE TABLE quickly deletes all records in a table by deallocating the data pages used by the
table. This reduces the resource overhead of logging the deletions, as well as the number of locks acquired.
Records removed this way cannot be restored in a rollback operation. Two notable exceptions to this rule are the
implementations found in PostgreSQL and Microsoft SQL Server, both of which allow TRUNCATE TABLE
statements to be committed or rolled back transactionally.
• You cannot specify a WHERE clause in a TRUNCATE TABLE statement—it is all or nothing.
• TRUNCATE TABLE cannot be used when a foreign key references the table to be truncated, since TRUNCATE
TABLE statements do not fire triggers. This could result in inconsistent data because ON DELETE/ON
UPDATE triggers would not fire.
• In some database systems, TRUNCATE TABLE resets the count of an Identity column back to the identity's seed.
• In Microsoft SQL Server 2000 and beyond in full recovery mode, every change to the database is logged, so
TRUNCATE TABLE statements can be used for tables involved in log shipping. [1]

References
[1] "Description of the effects of nonlogged and minimally logged operations on transaction log backup and the restore process in SQL Server"
(http:/ / support. microsoft. com/ kb/ 272093). Microsoft. December 2005. .
Article Sources and Contributors 127

Article Sources and Contributors

SQL  Source: http://en.wikipedia.org/w/index.php?oldid=493736607  Contributors: 28421u2232nfenfcenc, 28bytes, 62.253.64.xxx, 64.168.29.xxx, A.R., Aaron Brenneman, Aarthib123,
Acroterion, ActiveSelective, Adashiel, Admrboltz, Adrian.walker, AgentCDE, Ahoerstemeier, Aidan W, Ajcumming, Aka042, Alai, Alalia 17, Alansohn, Alec.korba, Alexius08,
AlistairMcMillan, AllanManangan, Allens, Allstarecho, Alon, Alpha 4615, Alterego, Alvin-cs, AnandKumria, Anclation, Andr3w, Andre Engels, AndrewWTaylor, Andrisi, Andy Dingley,
Angela, Anoko moonlight, Anonymous Dissident, Aou, Apienczy, Arcann, Aresgunther, Arvi, Aseld, Ashley Y, Asix, Avillia, Avé, Az1568, B15nes7, B6nb3k, BL, Badseed, Baiji, Barefootguru,
Basil.bourque, Beetstra, Behringerdj, Beland, Ben D., Ben-Zin, BenFrantzDale, Beno1000, Bernd vdB, Bevo, Bill Huffman, Bkwillwm, BlindEagle, Blonkm, Bobdc, Bobstay, Bodmerb, Bomazi,
Bonadea, Bongwarrior, Booles, Boshomi, Bovineone, Branko, Brassrat70s, Bricaniwi, Brick Thrower, Bryan Derksen, Bstan72, Bumm13, Bunnyhop11, Burgher, Butterscotch, CALR, CF84,
CRGreathouse, Caltrop, CambridgeBayWeather, Camw, Can't sleep, clown will eat me, Canterbury Tail, Capnchicken, Channard, Charles Matthews, Cherry Cotton, Chowbok, Christian75,
Chtirrell, Cic, Closedmouth, Coffeehood, Cometstyles, Comps, Conversion script, Coolboy1234, Coremayo, Countersubject, Cpl Syx, Craig Stuntz, Crowne, Crysb, Cuchullain, Cuckoosnest,
Cwolfsheep, Cww, Cybercobra, D6, DH85868993, Damian Yerrick, Dan Atkinson, DanBishop, DanP, Danakil, Dancter, Danim, Davep.org, DavidWikiuser, Dbtfz, Dcoetzee, DePiep,
Decon1985, Decoy, DefaultLocale, Deflective, Delikedi, Denelson83, Dennis forbes, DennisWithem, Dhies88, Dianelos, DigitalEnthusiast, Dittaeva, Dlohcierekim's sock, Dlyons493, Dmsar,
Doctorx0079, Docu, DopefishJustin, Download, Dpr, DrJolo, Dreadstar, Dreftymac, Drgrussell, Dsan, Duncharris, Dysprosia, Długosz, EarthPerson, Eboyjr, Ed Poor, Edward, Edwinludo,
Egrabczewski, Ehajiyev, Ehheh, ElectricRay, Elfguy, Elkman, Eloquence, Elwikipedista, Emperorbma, Entoaggie09, Enviroboy, Epbr123, Escape Orbit, Evildeathmath, Ezeu, Falcor84, Fastily,
FatalError, Favonian, FelisLeo, Ferdna, Finalius, Fleurydj, FrancoGG, Francs2000, Frando, Franl, Frap, Frecklefoot, Fred Bradstadt, Ftiercel, Furrykef, Fæ, GHe, Gabrielsroka, Gadfium,
Galoubet, Gawat123, Gefstar1, Gennaro Prota, Ghettoblaster, Gil Gamesh, Gilliam, Gioto, GnuDoyng, Goethean, Goki, Gopher292, Goplat, Gosub, GraemeL, Grafen, Graham87,
GrandPoohBah, Grauenwolf, Greco-German, Greg Lindahl, GregCovey, Gregbard, GregorB, Grigrim, Ground Zero, Gsapient, Gzuckier, Hairy Dude, Hakkinen, Hankwang, Hardeeps, Hari,
Harlock jds, Harperska, Harry, Haza-w, Herbythyme, Heron, Hirzel, Hongooi, Hu12, Huzarus, Hydrargyrum, Hymek, Iancarter, Ida Shaw, Incnis Mrsi, Infojunkie23, Inonit, Intgr, Ioannes
Pragensis, Iolar, ItsMeowAnywhere, Ivan Pozdeev, J.delanoy, JCLately, JLaTondre, Jacek79, Jackacon, JamesNK, Jamesday, Jan Hidders, Jarash, Jasper Deng, Jay, Jay-Sebastos, Jaysweet,
Jc3s5h, Jdlambert, Jeenware, Jeffq, Jeffrey Smith, Jerome Charles Potts, Jezmck, Jimbo Wales, Jimhark, Jimmytharpe, JnRouvignac, Joelm, Joeyjojo Junior, John Vandenberg, JohnCD,
JohnOwens, Johnmc, Joieko, Jon Awbrey, Jonas AGX, Jonearles, Jonik, Jorge Stolfi, Jpk, Jpvinall, Jschnur, Jsmethers, Jsnx, Julesd, Jusdafax, Just James, Justinkaz, Jwissick, Jzcool, Jzel6201,
KD5TVI, Kaimiddleton, Karl-Henner, Kelti, Kesava84, KeyStroke, KingsleyIdehen, Kitch, Kizor, Kku, Klausness, Koavf, Kop, Kovianyo, Kpelt, Kreca, Kruusamägi, Kubra, Kuru, Kvdveer,
Kwamikagami, KymFarnik, La comadreja, Lambiam, Lankiveil, Larsinio, Lavarock86, Leandrod, Leave Mr Mitchell alone!, Lfstevens, Liao, Libcub, Littlebluenick, Logiphile, Lost.goblin,
Lotje, Love1710, Loveenatayal, Lowellian, Ltruett, Lucian Sunday, Lukaseder, LuoShengli, M7, MacTed, Macaldo, Mackseem, Magnus Manske, Mahamoty, Mahanga, Mandarax, Mark Renier,
Mark T, Markhobley, MartinRinehart, Master2841, Materialscientist, MathiasRav, Mathmo, Matt.smart, MaxEnt, Maximaximax, Mdchachi, Mdd, Meh222, MeltBanana, Mendel, Mentifisto,
Merphant, Mersperto, Metroking, Michael Hardy, MichaelSpeer, Michele.alessandrini, Mikeblas, Mild Bill Hiccup, Mindmatrix, Minghong, MinorContributor, Miskin, Mitch Ames, MoRsE,
Modster, Mojodaddy, Moontube, MrOllie, Mt.toth, Mxn, Mzajac, NYKevin, Nasa-verve, Naveen0665, NawlinWiki, Nbarth, Neilc, Netfriend, Neum, NiceGuyEduardo, Nick Garvey, Nikola
Smolenski, Njbooher, Nohat, Norm mit, Nricardo, Nsd, Nurg, Octahedron80, Od Mishehu, Oli Filth, Olivier Debre, Oljtn, Ondrejk, Opticyclic, Orzetto, Osmodiar, Paul Foxworthy, Paul Mackay,
Paul.mcjones, Paulmlieberman, Peruvianllama, Peter.vanroose, Philip Trueman, Philippe Perrault, Piano non troppo, PierreAbbat, Piet Delport, Platypus222, Plcsys, Plrk, Plugwash, Pmcjones,
Pogonomyrmex, Possum, Pouya, Power piglet, Powerlord, Pparazorback, Prashanthns, Puffin, Pukkie, Qu1j0t3, Quantum00, Quebec99, Quintote, R'n'B, RW Marloe, Racklever, RadioKirk,
RainbowOfLight, Randomned, Ravi555, Razorx, Rdeleonp, Rdmil, Rdsmith4, RedWolf, Reedy, Reikon, RevRagnarok, Rfc1394, Rfl, Rhobite, Ribaw1, Riffic, Rjwilmsi, Roadrunner, RobertG,
RockMFR, Ronstone, Royote, Rp, Ruakh, Rursus, Ruud Koot, Rwwww, S figueiredo, S.Örvarr.S, SF007, Salix alba, SallyBoseman, Salvio giuliano, Sam Korn, Sander Säde, Saramar10,
SarekOfVulcan, Saric, Savh, Sbose7890, Sbvb, Scanos, Schaef, Schuetzm, SciberDoc, Sergioledesma, Severa, Sgkay, Shizhao, Shuipzv3, Siafu, Simetrical, SiobhanHansa, Sippsin, Sjakkalle, Sjc,
Skreyola, SkyWalker, Slavering.dog, Smartweb, Smeyerinnewton, Smithhogg, Smu95rp, Somme111, SouthLake, Spectrum266, Spezied, Sql pol, SqlPac, Sstrader, Starbeard, Starius, Stephenb,
Steve Alvesteffer, Stevietheman, Stifle, Stratadrake, Subflux, SuezanneC Baskerville, SummerWithMorons, Svick, Swanyboy2, Syzy, Ta bu shi da yu, Tablizer, Tagtool, Tasc, Tcncv, Tcutcher,
Tgeller, The Anome, The Letter J, The Thing That Should Not Be, TheExtruder, Thekaleb, Theone256, Thetorpedodog, Thirtyfootscrew, Thom2729, ThomasStrohmann, Three-quarter-ten,
Thumperward, Thunderbritches, TigerShark, Tiha, TimTay, Timwi, Tizio, Tjmoel, Tobias Bergemann, Todd Vierling, Tomtheeditor, Toreau, Traal, Traxer, Trevorloflin, Trlovejoy, Troels Arvin,
TunaSushi, Turnstep, Ucanlookitup, Ulf Abrahamsson, Ummit, Uncle G, Unforgettableid, Unknown W. Brackets, Velella, Ville Oikarinen, Vincenzo.romano, Viridity, Visor, Vitund,
Vivek.pandey, Vivio Testarossa, VoluntarySlave, Vonfraginoff, Vrenator, WOSlinker, Wadamja, Washburnmav, Wei.cs, Weialawaga, Wernher, Wesley, West.andrew.g, Weylinp, WikHead,
Wikiklrsc, William Avery, Winchelsea, Wingnut909, Wiretse, Wisq, Wragge, Wulfila, X-Fi6, XSTRIKEx6864, Xdenizen, Xibe, Xjhx001, Yeneesha, Yeng-Wang-Yeh, Ysangkok, Yzchang,
Zhenqinli, Zigger, Zundark, Ævar Arnfjörð Bjarmason, 1478 anonymous edits

Data  Source: http://en.wikipedia.org/w/index.php?oldid=494314798  Contributors: 192.75.241.xxx, 208.245.214.xxx, A.M.Lewis, Aadal, Aarktica, Abramjackson, Achaemenes II,
Acronymsical, Adam M. Gadomski, Aditya, AdjustShift, Adrian J. Hunter, Ahoerstemeier, Alasdair, Aldie, Aldrichg, Aleenf1, Alexius08, AlistairMcMillan, Amd628, Andrew Levine,
AndrewHowse, Angrytoast, Antandrus, Apollo, Arikanari, Aroundthewayboy, Arthena, Arthur Rubin, Astral, Atif.t2, Avoided, Beetstra, Begewe, Beyondthislife, Bhadani, Bikeable, Blake
Burba, Blue Hoopy Frood, Bluemask, Bluerasberry, Bobo192, Bomac, Bongwarrior, Boxplot, Bped1985, Bpilstrom, COMPATT, COMPFUNK2, CRGreathouse, Calabe1992, Calvin 1998,
Capricorn42, Ccloudies, Cenarium, Christopher Denman, Chuunen Baka, Clenny93, Coemgenus, Colincbn, Connectel, Conversion script, Cool moe dee 345, Corpx, Corti, Cpiral, Cpl Syx,
CustardJack, Cybercobra, DJDunsie, DancingPhilosopher, Daniel.Cardenas, DanielDeibler, Dar-Ape, Daven200520, Dawnseeker2000, Dcljr, Decltype, Deflective, DerHexer, Dfletter, Dhaluza,
Djkernen, Dmarquard, Dmccreary, Dmyersturnbull, Donald swager, Dontdoit, Dotancohen, Dreadstar, Dthomsen8, Duncharris, Dungodung, Dycedarg, EJF, EagleFan, Ec5618, Edgar181, El C,
ElKevbo, Elitejoe24, Elonka, Emperorbma, Epbr123, Eric, Espoo, Ewawer, Excirial, Faramir333, Fnlayson, Former user, Frozenevolution, Funandtrvl, Furrykef, G716, GDibyendu, GKantaris,
GMBosman, Gaelen S., Galoubet, Gbbinning, Geneb1955, General Wesc, Georgea76, Georgethorne, Giftlite, Glane23, Glenn, Gogo Dodo, Goldwein, GrahamN, Gregbard, GregorB, Gsonnenf,
Guaka, Gurch, Harej, Hateless, Headbomb, Heimstern, HexaChord, HkQwerty, Huntthetroll, Hydrargyrum, IGeMiNix, IanMSpencer, Icseaturtles, Idunno271828, IlyaHaykinson, Informatwr,
Inkwina, Insanity Incarnate, Invincible Ninja, Ioannes Pragensis, J.delanoy, JForget, JHunterJ, JMK, JamesBWatson, January, Jdlambert, Jensgb, Jeremy1989, Jgallihugh, Jkl, Joe Kress,
Joebeone, Joeblakesley, Joffan, John Reaves, Johnflan, Johnuniq, Jojhutton, Jondel, Jschwa1, Jtneill, KGasso, Kablammo, Kayau, Kb3edk, Kbolino, Kbrose, KellyCoinGuy, Kencf0618, Kenny
sh, Kevin Saff, KeyStroke, Kku, Kubanczyk, Kumudupinto, Kuru, Kurykh, Kvan, Kwamikagami, Lambiam, Lapsus Linguae, LedgendGamer, Leithp, Lights, Lil.Mizz.Charmz, Logan, Loupeter,
Luccas, MER-C, Machine Elf 1735, Magdalena Szarafin, Marasmusine, Marek69, Mark Renier, Materialscientist, MattTM, Mav, Mayur, Mbubel, Mdd, Me lkjhgfdsa, Meiskam,
Mephistophelian, Mercurydaac, Metricopolus, Michael Hardy, Mike Rosoft, Miss Madeline, Mr Stop 2000-2000-1999 to 2006 versus TCP, Mxn, NawlinWiki, Netoholic, NewEnglandYankee,
Nick, Nigelloring, Niteowlneils, Nuwewsco, Oberst, Onecanadasquarebishopsgate, Oxymoron83, PRF Brown, PTJoshua, Pacifistpanda, Passportguy, Pearle, Pengo, PeterSymonds, PhilKnight,
Philip Trueman, Piano non troppo, Pinethicket, Pontsticill, Pooresd, Prari, Prepare2fire, Quadell, R3m0t, Radon210, RainbowOfLight, Rajsandhi, RandomP, Ravedave, RayGates, Rdococ,
RedWolf, RevRagnarok, Riana, Rkitko, Robbie andrew, RodC, Romanm, Roozbeh, Rrburke, Sa'y, Salvio giuliano, Sanjayanand, Sbfw, Sbwoodside, SchreiberBike, Scott MacLean, Seaphoto,
Secretlondon, Sergio.ballestrero, Sesu Prime, Shadowjams, Shipmaster, Sina2, Sjakkalle, Skempe42, Skittleys, Sky Attacker, Sleekgray, Snowded, SoCalSuperEagle, SpaceFlight89, Stepp-Wulf,
Stevenson-Perez, Subramanyam.avvaru, Sugsez, Supertouch, Suriel1981, Swtimaginations123, THF, Tcncv, Teifif, Tgeairn, The Anome, The Rationalist, The wub, Thinktdub, TimBentley,
TimVickers, Tin, Tobias Bergemann, Tommy2010, Tompsci, Tracytheta, Trepeche, Triwbe, Trusilver, TubularWorld, TutterMouse, TuukkaH, Tuxedo junction, Twilightloverforev, Venullian,
VictorianMutant, Vihelik, Vlmastra, Voxii, Wasbeer, Wavelength, Wayne Slam, Welsh, Wereon, WhatisFeelings?, Whooooooknows, WikidSmaht, Wikipelli, Wile E. Heresiarch, WinterSpw,
WojPob, Woohookitty, Wwmbes, XKL, Xhaoz, Xiaopo, Zerokewl, Zipircik, Zzuuzz, ‫ﻣﺎﻧﻲ‬, 605 anonymous edits

Metadata  Source: http://en.wikipedia.org/w/index.php?oldid=492393950  Contributors: 0612, 121a0012, 16@r, 210.49.109.xxx, 7, AGK, AGToth, Abdul raja, Acdg, Ahoerstemeier, Akhristov,
Al Adriance, Alansohn, Albert ip, AlexChurchill, Algocu, AlistairMcMillan, Allen Moore, Allens, Allthingsace, Andrea Parri, Andrew Gray, Andrew Werdna, AndrewHowse, AndrewRH,
Androo, Andy Dingley, AnmaFinotera, Anna Lincoln, Anna Montull, Antandrus, Anthony Borla, Antonielly, Apapadop, Armaced, Arpabr, Artaxiad, Arthena, Avicennasis, Balajiveera, Beardo,
Beetstra, Belbernard, BenRogers, Benbludget, Beyer, Bigpinkthing, Biker JR, BioPupil, Blackphiber, Blitzmut, Boardhead, Btwied, BurntSky, CFilm, CRJO-CRJO, CTZMSC3, Cab88,
Canyouhearmenow, Carly805, Catgut, Cdc, Ceceliadid, Celticst, Chandan Patel, Charles T. Betz, CharlesC, Chievous, ClaudioFerreira, Cnash11, Coinchon, Cole2, Conversion script,
Crimsonmargarine, Crysb, Cureden, DEddy, DGG, DMacks, Dalbon, DanBri, Daniel5127, DarkSaber2k, Daswani.Amit, Dave Hay, David B in Canberra, David Gerard, David Woolley,
David.T.Bath, Davidryan168, DePiep, Deborah-jl, Dedmonds, Demerara, Denverjeffrey, Devarakondar, Diannaa, Dicklyon, Dmccreary, Doug Bell, Drrwebber, Dwlegg, ECEstats,
Eeheeheeheeheeheehee, El benito, Elf, Elving, Emperorbma, Emre D., EnDumEn, Enfresdezh, Equilibrioception, Error, Europrobe, EvenT, Evercat, Everyking, Evil Monkey, Exe, Face.real,
Feldermouse, FlamingSilmaril, Flarn2006, Fmccown, Francs2000, FredMBrown, FreplySpang, Fritzpoll, GRAHAMUK, Gaius Cornelius, Galoubet, Garion96, Gautam3, Gbevin, Genealbert,
GhostGirl, Gioto, Girl2k, GoingBatty, Graham87, Graybeal, Green caterpillar, GregLindahl, GregorB, Guffydrawers, Gurch, Gywst, H10130, Halaster, HarryAlffa, Harryzilber, Heron,
Hiplibrarianship, Hmains, Hugonius, Hvn0413, Hvs, IRowlands, Iancarter, Iluvcapra, Inkington, Isiaunia, Itai, J Milburn, J04n, JRR Trollkien, Jacobolus, Jamacfarlane, Jasongao99, Jdmbellevue,
Jeffrey Mall, Jehochman, Jerome Charles Potts, Jewers, Jgjournalist, Jinzhanguwm, Jleedev, Jmundo, Joejoejoejoejoejoejoejoejoe, John Hubbard, John Vandenberg, JohnRonald, JonHarder,
Jordgette, JosebaAbaitua, Jschwa1, Juliancolton, Jusdafax, Just plain Bill, Kazrak, Keilana, Kenta, Kevin B12, KeyStroke, Khalid hassani, Khym Chanur, Killiondude, Kim Bruning, Kku,
Klower, Kraftlos, Kuru, Kvng, Kylemew, LOL, Lando Calrissian, Lazy Techie, Lcme, LeeHunter, Les733, Lethesl, Lheuer, Ligulem, LinaMishima, Ljagerman, Lotje, Lowellian, Luckyz, Lulu of
the Lotus-Eaters, M4gnum0n, MDE, MacGyverMagic, Malyctenar, Manfred-jeu, Mani1, Maork, Mark Renier, Markhurd, Masgatotkaca, Matthewvelie, Matěj Grabovský, Mav, Mboverload,
Mdd, MetaWorker, Metajohng, Michael Hardy, MikeLynch, Mild Bill Hiccup, Millmoss, Miss Madeline, Mjb, Modify, Mrbradleyt, Mudkipzss, Mushin, Mwestby828, Mxn, N.Fegen,
Nadimghaznavi, Natalya, NawlinWiki, Neo-Jay, Nerdonpurpose, Newbyguesses, Nichtich, Nickg, Niduzzi, Night Gyr, Nixdorf, Nopetro, Northgrove, Notinasnaid, Nowa, Nscwikiedt, Nyttend,
Ojw, Omassey, OnceAlpha, Ottomachin, Pathoschild, Patrick, PatrickFisher, Paul Asman, Peciv, Peepeefigjam123, PerryTachett, Pete Short, Phantomsteve, Phillipgi, Pigsonthewing,
Pinkgirl9595, Pinku.nagpal, Poor Yorick, Poornima vijayan, Protonk, Public Menace, Purslane, R'n'B, Rabbit67890, Raffaele Megabyte, Ramu50, Rarcher88, RayGates, RedWolf, ResearchRave,
Reswobslc, Rexdeaz, Rhagen7, Richard.decal, Rjwilmsi, Rnathanday, Robth, Ronvelig, Ronz, Rspeer, S. Cruz, S.K., SCEhardt, SEWilco, Sallyrenee, Santamoly, Schandi, ScienceGolfFanatic,
SebastianHelm, Sgb, Shaddim, Shadowjams, Shanebdavis, Sieuthulin, Sk19842, Skizzik, Sky Attacker, Snaxe920, Soler97, Soliloquial, Somewherepurple, Soocom1, Soumyasch, Spalding,
Article Sources and Contributors 128

Spdegabrielle, SqueakBox, Srobak, StaticGull, Stephen B Streater, Stevertigo, Stevietheman, Stolkin, Strike Eagle, StuartGilbert, Stuartyeates, Sualeh, Superm401, Syaskin, Synctext, TJRC,
TaintedMustard, Tajymoid, Tarquin, The Epopt, TheDude813, Thetawave, Tikiwont, Timtrent, Tipiac, Tkmi.itu.dk, Tnekevets, Tobias Bergemann, Tokailoverock, Tongbram, Tony1212,
Tosahilchopra, Tregonsee, Treybien, Trilliumz, Tverbeek, Typhoon, Udayan.warnekar, Uliwitness, UninvitedCompany, UnitedStatesian, Utcursch, Vegard, Vigilius, Vik-Thor, Vincent jonsson,
VitalyTarasov, Volphy, Wafulz, Warren, Whatyousage44, Wik, Wikky Horse, Wingwalker13, Wireless friend, Woodshed, Writ Keeper, WriterHound, Yerpo, Ylvabarker, Yonkie, Zundark,
Zyb5586, 630 anonymous edits

Flat file database  Source: http://en.wikipedia.org/w/index.php?oldid=492618481  Contributors: 100110100, 2mcm, ANONYMOUS COWARD0xC0DE, Adrianwn, Aeronbuchanan, AltiMario,
Andrewsailer, Anonymous3190, Antonrojo, Apokrif, Arcann, ArnoldReinhold, Asfarer, Bayerischermann, Begewe, Brighterorange, Brunnock, Byapparov, Capi crimm, Carmichael, Charles
Matthews, Chaser, Christophe.billiottet, Clam0p, Computerboy0, CrazyArcher, Cyktsui, DARTH SIDIOUS 2, Damiankelly, Danim, Dannyg007, Darktemplar, Dreftymac, Enric Naval,
Everyking, Ewlyahoocom, Excirial, Fadookie, Fieldday-sunday, Ghettoblaster, Grstain, Gzornenplatz, Habbie, HaywardRoy, ICberg7, J Di, Jackol, Jamelan, Jerome Charles Potts, JoanneB,
Jonin69, Jpvinall, Kevins, Larsinio, Lee J Haywood, Leirith, Luisgarcc, Mandarax, Mandra Oleka, Mark Renier, Mark T, Master Lexx, McGeddon, Mdd, Mild Bill Hiccup, Mindmatrix,
Minghong, MrOllie, Night Gyr, Notbyworks, OlEnglish, Omicronpersei8, Orpheus, Oxymoron83, Pantergraph, Phantomsteve, PhiLho, Philip Trueman, Piano non troppo, Psb777, Public
Menace, Quiddity, Qxz, Rayngwf, RedWolf, Reedy, SDSWIKI, Sam Pointon, Sandcat01, SchnitzelMannGreek, Sedimin, Seidenstud, Shades1Of1Grey, Shanes, Skaryzgik, Slazenger, Sonett72,
SteinerMW, Stephen Morley, Stolkin, Suffusion of Yellow, Tannin, Tobias Bergemann, TommyEd, Trolleymusic, WeißNix, Xiong, 173 anonymous edits

Relational database  Source: http://en.wikipedia.org/w/index.php?oldid=494331392  Contributors: *Kat*, 01001, 127, 217.162.105.xxx, 64.192.12.xxx, Abolen, Adamcscott, Adamrush,
Admrboltz, Agateller, Ahoerstemeier, Alain Amiouni, Alansohn, Andre Engels, Angela, Anuja297, Appzter, Astheg, AutumnSnow, Banes, Beland, Beno1000, Bitnine, Bobo2000, Boothy443,
Booyabazooka, Bpalitaa, Brick Thrower, Bsdlogical, CALR, Calmer Waters, Calvernaz, Chris.Giles, Chrislk02, Conversion script, Craig Stuntz, Cww, DARTH SIDIOUS 2, DVdm, Dandv,
Danim, Dannydaman9, Darth Mike, Dave6, David Delony, Dfeuer, DinosaursLoveExistence, Dionyziz, Dirk P Broer, Drgs100, Dschwart11, Dumbledad, EagleFan, Eik Corell, El C, ElKevbo,
Emperorbma, Fabrictramp(public), FatalError, FayssalF, Ferkelparade, Fidimayor, Fieldday-sunday, Filiocht, Findling67, FlyingDoctor, Francs2000, Fratrep, Fred Bradstadt, Freediving-beava,
Frigotoni, Fuddle, Gaur1982, Gerbrant, Giftlite, Glane23, GoingBatty, Graham87, HJ Mitchell, Hapsiainen, Harold f, Herostratus, Hmrox, Hp-NJITWILL, I do not exist, ILikeBeer, IRP,
Ideogram, Iohannes Animosus, J.delanoy, JCLately, JLaTondre, JaGa, Jacobrothstein, Jan Hidders, Jitendraapi, Jncraton, John Vandenberg, Johnuniq, Jon Awbrey, Jwoodger, Jóna Þórunn, K
faiad, KingsleyIdehen, Klausness, KnowledgeOfSelf, Kostmo, Kraron, Kristensson, Krogstadt, Kuru, Larsinio, Leandrod, Lfstevens, Linlasj, Logthis, Looxix, Luna Santin, MC MasterChef,
MER-C, Mac, MainlyDigGrammar, Mandarax, Manop, Mark Renier, Mark T, Mav, Mckaysalisbury, Merlion444, Metroking, Michael Hardy, Michael Hodgson, Mikeblas, MilerWhite,
Mindmatrix, Msikma, NHRHS2010, Nannahara, Nanshu, Nisantha04, Niteowlneils, Nocohen, Ns.code, Odie5533, Olinga, Oursinees324, OwenBlacker, Oxymoron83, Pablo323, Pdcook, Pearle,
Philcha, Pietdesomere, Pinkadelica, Psb777, Psychcf, Quitchy, Rasmus Faber, RayGates, Rchertzy, Rfl, Romanm, Rrburke, SandyGeorgia, Scouser0phil, Sequologist, Sfe1, Sgiovannini, Shinju,
Sir Nicholas de Mimsy-Porpington, Sir Vicious, Slightlyusefulcat, Smjg, Solipsist, Sonett72, Specialbrad, Spiritia, Spudtater, SqlPac, Stare at the sun, SteinbDJ, Steve Casburn, Supten, TJRC,
Tcncv, Tcnuk, Ted Longstaffe, Teles, TheDJ, Thingg, Tobias Bergemann, Todd Vredevoogd, Tom harrison, Triddle, Triwbe, Troels Arvin, Turnstep, Utcursch, Vespristiano, Wavelength,
Wesley, Wolfraem, Wolfsbane2k, Xiong, Xphile2868, Zahid Abdassabur, Zipircik, 511 anonymous edits

MySQL  Source: http://en.wikipedia.org/w/index.php?oldid=494545391  Contributors: 142.177.80.xxx, 16@r, 16x9, 1exec1, 2mcm, 4v4l0n42, A bit iffy, Aaboelela, Aaron Ray, Aaron44126,
Acdx, Action potential, Adamryanlee, Addshore, Aforencich, Ahsanmani, Aldie, Alexius08, AlistairMcMillan, Allencheung, Altenmann, Altonbr, Amgc56, Amux, Andrarias, Andre Engels,
Andrewferrier, AndriuZ, Aneah, Ann Stouter, Antilived, Applejack1234, April Arcus, Arite, Artagnon, Aruton, Asenine, Astronautics, Atlantia, Attlas, Aviv007, Awfief, Axan.bulut, Axecution,
AxelBoldt, Ayeroxor, Az1568, BCube, BMT, BW, BaldPark, Barefootguru, Bazzargh, Beetstra, Beetstra public, Beno1000, Bentogoa, Bevo, Bg, Bkarwin, Blacktrance, Blindmatrix, Blocked!,
Blue Em, Bluemoose, Boatman, Bobblewik, Bobo192, Bobsawyer20, Bobzchemist, Bofoc Tagar, Bogdangiusca, Bookbrad, Borgx, Brainsnorkel, BraneJ, BrianAker, Brianski, Briantw, Brick
Thrower, Brion VIBBER, Britton ohl, Brockert, Bruggeri, Bryan, Bryan Derksen, Bunnyhop11, Burgundavia, Buryshane, Bwisey, Byte, CDV, CLW, CWenger, Callmeonnet, Calltech,
CambridgeBayWeather, Camilo Sanchez, Can't sleep, clown will eat me, Cander0000, Capricorn42, CaptTofu, Carl T, Cbdorsett, Cburnett, Centrx, ChadMiller, ChandraSukiman, Charles
Gaudette, CharlotteWebb, Chealer, Cheyer, Chiclops, Chiragpinjar, Chris Mitchell, Chris Wood, Cleared as filed, ClementSeveillac, Cliffashford, ClockworkLunch, Closedmouth, Coffee, Cokoli,
Colindolly, Colinstu, Conti, Conversion script, CoolKid1993, Coolboy1234, Copito42, Coredumperror, Cosmotron, Coyote376, Craigm71, Crazyman6721, Cst17, Cybercobra, DStoykov,
Dalahäst, Dan100, Daniel.Cardenas, Danielluyo, Dank, Darkfate, Darkride, David Biddulph, David H Braun (1964), Davidelit, Davidhorman, Db the dba, Deadcorpse, Deflective, Dejvid, Den
fjättrade ankan, Dennis714, Derek Ross, Designdroide, Designer1993, Dexp, Dfoxvog, Dfreeman@akebulan.com, Dgw, Diannaa, Diberri, DigitalSorceress, Dinnerface, Dinomite, Dittaeva,
Djg2006, Dmillman, DocteurCosmos, Dontdeletecontent, Doradus, Downtown dan seattle, Dreemteem, Dustinhess, E0steven, Ebelular, Ed g2s, Editore99, Edward, ElTyrant, Electriccatfish2,
Elwikipedista, Emwave, Engleman, Eomund, Erget2005, Exert, Faganp, Faisal.akeel, Fchoong, Fhussain, Finbarr Saunders, Flamingspinach, Fokat, FootholdTechnology, Formulax, Frap, Freyk,
Frungi, Fubar Obfusco, Furrykef, Fvw, GFHandel, Gadfium, Garo, Gary King, Gavinatkinson, Gbeeker, Ghepeu, Gilad.maayan, Gimmetoo, Glenn, Goa103, Graham87, Grantmx, Grath,
Greenman, Greg Lindahl, GregorB, Gregoroq, Grog.Wilson, Gronky, Groogle, Grymwulf, Gtg264f, Gutworth, Guycalledryan, Gwern, H@r@ld, HDCase, Haakon, Hannes Röst, Hao2lian,
HarrisonFisk, Havermayer, HexaChord, HiDrNick, Holsen32, Hossein.ir, Hulagutten, Hydrargyrum, Hydrogen Iodide, I already forgot, Imroy, Intgr, Iridescent, IronGargoyle, Irrevenant, Isotopp,
Itsmesid, IvanStepaniuk, Ixfd64, J JMesserly, JHunterJ, JLaTondre, JM.Beaubourg, Jaberwocky6669, James Crippen, James Plummer, Jamesday, Jasper Chua, Jasper Deng, Jawnsy, JayW,
Jayron32, JeLuF, Jeffwang, Jeremy Visser, JeremyCole, Jerome Charles Potts, Jim1138, Jj137, Jkelly, Jmmorris, Joelrwilliams, Joelwest, Johansosa, John Vandenberg, JohnMGarrison, Jon787,
Jonabbey, Jonkaz, Jonsafari, JorgeGG, Josephers, Juancnuno, Julekmen, Julyscripter, JzG, KGasso, Kainaw, Kalakatha, Kalkadoon, Karan.102, Karimarie, Karl-Henner, Kbdank71, Kesla,
Kgoarany, KillerLegend, Kipitis, Kiwi128, Kkm010, Kl4m, Kl4m-AWB, Kristof vt, Ksn, Kuru, Kvdveer, Kwamikagami, Kwiki, LA2, Larsinio, Ldonna, LenzGr, LeslieBD, Lichtgestalt,
LimoWreck, LinguistAtLarge, Linkspamremover, LittleDan, Lmxspice, Locos epraix, LokiClock, Lotje, Lrusso99, M4gnum0n, MK8, ML, Mac Davis, Macutty, Madduck, Magnus.de,
Male1979, Manning Bartlett, Marianolu, MarkAtwood, MarkPilgrim, Marqmike2, Martarius, Materialscientist, Matthew-New, Matthuxtable, Mattworld, Mausy5043, Maxim, McGeddon, Mchl,
Mckaysalisbury, Medovina, Mhillyer, Midom, Miha Ulanov, Mike2ykme, Mikeblas, Mindmatrix, Minesweeper, Minghong, Miszobi, Mjb, Mjhoogev, Mmmready, Moeron, Montybarker,
Moondyne, MoreNet, Morgankevinj huggle, Morte, Mountaingoat, Mpopp75, Mr Minchin, Mr. Credible, MrOllie, Msjaiswal, Mushroom, Mwindrim, Mxn, MySchizoBuddy, Mz2000, N3hima,
N5iln, Nanshu, NapoliRoma, Nattee, NeilSantos, Neilc, Nemolan, Neocodesoftware, Neustradamus, Nevetsjc, New Thought, NicM, NickCatal, Nickdc, Nickshanks, Nicoglop, Ninestrokes,
Nixeagle, Nmacu, Noerrorsfound, Nohat, Noleander, Norandav, Norm mit, Nurg, OAC, Oberiko, Odalcet, Ohyoko, Oleg Alexandrov, Oli Filth, Omegamormegil, Oneiros, Opticyclic, Orderud,
Orenburg1, Orzelf, OsamaK, Palosirkka, Parthian Scribe, Patrias, Patrick, Patsw, Pauli133, Paulvallee, Pcbene, Pedant17, Pedro, Pegasos2, Peter Hitchmough, Peter Winnberg,
PeterMoulding.com, Peterl, Petri Krohn, Pgan002, Pgillman, Philip Trueman, PhilipMW, Piano non troppo, Pillefj, Pmalkowski, Pnm, Preeeemo, Prius 2, Qpniteflyqp, Qu1j0t3, Quadra23,
Quasipalm, Qwertyus, R'n'B, Rabarberski, Radnam, Rafert, Rajasekaran Deepak, Ramu50, Rannpháirtí anaithnid, Raysonho, Raztus, Rbuj, Rdnk, Rdsmith4, Realkyhick, Red banana3, RedWolf,
RedYeti, Reedy, Reinderien, Returnkey, Rgrof, Rich Farmbrough, RichF, Rjwilmsi, Rochkind, Rodhullandemu, Ronz, Rubicon, Russelljtdyer, S-n-ushakov, SF007, Saiswa, Sajmure, Sandb,
Sandeep74, Sander Säde, Sarcasting the hallucination, Satanuke, Satertek, Scarfy, Seb26, Sebleblanc, Sebquantic, Secretlondon, Semi, ShakataGaNai, Shareme, ShaunMacPherson, Sherbrooke,
Shlomital, Shoaler, Shortride, Sibyllaviki, Silverfish70, Simple Bob, Simplytaty, Sisutcliffe, Skamecrazy123, SkyWalker, Slezak, Sligocki, SloppyG, Smileyborg, Snoyes, Sobchakw,
Someslowly, Sonez1113, Spikey, Spock of Vulcan, Squash Racket, Stassats, Staticmain, StefanHinz, Stephen Gilbert, SteveChervitzTrutane, SteveSims, Stevenjgarner, Stevertigo, Stevietheman,
StuffOfInterest, Subversive.sound, SummerWithMorons, Super3boy, SuperMidget, Suruena, Suwatest, Sverdrup, TJRC, Tadman, Taw, Tcnuk, Techietim, Technopat, Tedickey, Texture, Tgeairn,
ThePlaz, Thebritt, Thecheesykid, Theone00, Thetorpedodog, Thomas Willerich, Thommym, Thumperward, Tim Starling, TimTay, Timl2k4, Timwi, Tisane, Tkbwik, Tkynerd, TobiasPersson,
Toby Douglass, Tomjenkins52, TommyG, Tonusamuel, Travelbird, Tripathisoft, Troels Arvin, Turnstep, Twinxor, UU, Ullika, Ultra 11, Uncle G, UnixMan45, Unknown W. Brackets,
VOGELLA, Vbgamer45, Vegaswikian, Veinor, Vespristiano, ViktorHaag, VincentV, ViperSnake151, Vipuser, Vivek.pandey, Vlad, Voidxor, Wdflake, Wereon, Weylinp, Whale plane, Where,
Wikieditor06, William Avery, Winterst, Wk muriithi, Wlievens, Wolfc01, Wolkykim, Wykypydya, Xieqi200, Xiong, Xmm0, Xompanthy, XtinaS, Xumxum, Yamla, Ydriuf, YellowLeftHand,
Youcantryreachingme, Yourbane, Zacchiro, Zaiken, Zero0w, Zeus, ZigArt, Zippanova, Zondor, Zzuuzz, ^demon, Ævar Arnfjörð Bjarmason, 1089 anonymous edits

LAMP  Source: http://en.wikipedia.org/w/index.php?oldid=490877441  Contributors: 2mcm, 5alam83, AJR, Abtin, Abune, Accrisoft, Acjelen, Ahunt, AlexKarpman, AlistairMcMillan,
Amolshah, Andreas Kaufmann, Anthonypants, Apnicsolutions, Bill.D Nguyen, Bkkbrad, Blanford robinson, Bomazi, Brian Kendig, BrianJones, Bunnyhop11, Bytebear, Cander0000, ChaosR,
Chimin 07, Cjcollier, ColdFusion650, Cradam, Csabo, Cybercobra, Davidkazuhiro, Dcirovic, Deepakr, Den fjättrade ankan, Djg2006, DoohanOK, Dragon8Fire, Durrantm, DwayneP, El Cubano,
Electrolite, Elephant in a tornado, Eptin, Eyu100, Faisal.akeel, Farooqakbarkhan, Fences and windows, ForumJoiner, FrYGuY, Frap, Frbe, Fred Bradstadt, Freefox, G.armellin, Gardar Rurak,
GargoyleMT, Generalmiaow, George Leung, Ghettoblaster, Gigs, Gracehoper, GraemeL, Greyskinnedboy, Gronky, Haakon, Haidut, Haysead, Htmlapps, Issinoho, Ivansanchez, JLaTondre,
Jamse, Jasper Deng, Jeffrey O. Gustafson, Jerryobject, Jimcreate, Jlee1973, Johan D'Hondt, John.szucs, Joncojonathan, Jwarhol, KTC, Karnesky, Kbrose, Kent zacharias, Kingflamz,
Kl4m-AWB, Korny O'Near, Korte, Kozuch, Kuukunen, Kylex3y, Lethe, LicenseFee, Liftarn, Løde, MZMcBride, Mahanga, Mariuz, Marudubshinki, Materialscientist, Mfrisk, Michael Slone,
Michael.Urban, Minghong, Mirokado, Morn, MrOllie, Mzajac, Najoj, NapoliRoma, Nate1481, Nealmcb, Neustradamus, Nicblais, Nick Wallis, Nigelj, NoClutter, Nono64, Northernhenge,
Nuwewsco, Patrick, Pearle, Pengo, Pepve, Peterdjones, Peteresch, PhilKnight, Pinecar, Pmc, Pne, Pnm, Prophile, Quantum Burrito, QuiteUnusual, RadaVarshavskaya, Raffaele Megabyte,
Raggiskula, RandalSchwartz, Reedy, Requiem18th, Rich Farmbrough, Rjmars97, Rjwilmsi, Rkarlsba, Robert K S, Ronz, Ryandsmith, S Carpenter, Salgueiro, SamJohnston, Samkass, Samwaltz,
Shanti subr, Sherbrooke, Sir Nicholas de Mimsy-Porpington, Skarebo, Slady, Sligocki, Smalljim, Snowolf, Spartanicus, Staalmannen, Stu42j, Superm401, Supernerd, Suruena, Szlampy, TJRC,
Taejo, The wub, Thumperward, ThunderPeel2001, Timosa, Tobias Conradi, Tomhannen, Toussaint, Trungie, Txomin, UU, Utcursch, Vasiliy Faronov, Veinor, Vicsar, Visor, Vorik111, Wangi,
Welshmike, WhiteEcho, Wikidrone, Wshato, Xaje, Yosofun, ZacBowling, Zalmoxe, 355 anonymous edits

Information retrieval  Source: http://en.wikipedia.org/w/index.php?oldid=492258980  Contributors: AKA MBG, AaronSw, Accurizer, AlistairMcMillan, Allens, Altenmann, Ameliablue, AnAj,
Andris, Andyjsmith, AntiVan, Anypodetos, Anþony, Apokrif, Appler, Aragor, Armando49, Artod, B7T, Baseball1015, Beland, Bmicomp, Bobareann, Borgx, Buettcher, Burkhard, C messier,
Cache22, Ceyockey, ChaTo, Charles Matthews, CharlotteWebb, Chickensquare, Chrissi, Christopher Parham, Ciphers, Ckatz, Clamster5, Clark Mobarry, Conversion script, Custard Pie Tarlet,
DJ Clayworth, DSiv, Devantheryv, Disooqi, Dmolla, Dominich01, Dominik Kuropka, Drmeier8, Drrprasath, Dtunkelang, Dudesleeper, Eidenberger, EncMstr, Enochlau, Erahana, Erhard002,
Erianna, ErinM, Espertus, Eupraxis, Evenmadderjon, Falazar, Fastily, Favonian, Flyskippy1, Fmccown, Gabr, Gavinsam1994, Gdupont, GerryWolff, Ggrefenstette, Giftlite, Glendac, Gmelli,
Gorpik, GraemeL, Graham87, Greenrd, Gregman2, Hdez.maria, Helensol, Helwr, Herr blaschke, Hiemstra, Hike395, Hosszuka, Indigo1300, Intgr, Itman, JackyR, Jarash, Jfroelich, Johnchallis,
Article Sources and Contributors 129

Jonsafari, Josevellezcaldas, KKramer, KYPark, Kessler, Kku, Krauss, LA2, LanguageMan, LatentDrK, LazyEditor, London25, Lwives, MIT Trekkie, Macrakis, Magioladitis, Male1979,
Marek.rei, Marian, MarkSweep, Marregui, Masao, Maynelaw, Mderijke, Michael Hardy, Modify, Moiencore, MrOllie, Msbmsb, Myasuda, Neil Dodgson, NeilN, Nichtich, Nickg, Niduzzi,
Nkour, Notheruser, Nprieve, OZJ, Oleg Alexandrov, PL290, Packerliu, Pacung, Pfaff9, Pgan002, Ph.eyes, PhysPhD, Pinkadelica, Pintaio, Planetneutral, Prashantmore 1, PrincessofLlyr, Public
Menace, Puvar, Qwertyus, R'n'B, Rainmannn, Rama, Rami ghorab, Ray3055, Rbrewer42, Rich Farmbrough, RichardF, Riclas, Rjwilmsi, Rodrigobartels, Rodrigoluk, Ronz, SWAdair, Sanchom,
Sderose, Sebastjanmm, Sepreece, Serapio, ShahChirag, Shodanium, Silvonen, SimonD, Slightsmile, Smb1001, Sonermanc, Spadarabdon, Spiritia, St73ir, Stephen Turner, Stoni, StuffyProf, Sue
Myburgh, Summertime30, Tamarkot, Textminer, Tgeairn, That Guy, From That Show!, The Anome, Themindset, ThomasHofmann, TigerHokieFan, Tobi Kellner, Torla42, Trimaine, U608854,
UKoch, Unyoyega, Urhixidur, Utcursch, Vmenkov, Vuongvina, Waitak, WakingLili, Wavehunter, Wavelength, Wikinaut, Wimt, Worldguy, X7q, Yannick56, Zollerriia, 345 anonymous edits

Data Definition Language  Source: http://en.wikipedia.org/w/index.php?oldid=494138094  Contributors: 16@r, Academic Challenger, Aitias, Alansohn, Aleenf1, Ankit Maity, Anna Lincoln,
Aymatth2, BL, Babbage, Bentogoa, BioStu, Boshomi, C628, Caspertheghost, Cecilkorik, Chupon, CodeNaked, Cometstyles, Cybersprocket, Danim, Decoy, Dgw, Eags, Elektrik Shoos, Eliazar,
Elonka, Emvee, Entropy, Fresheneesz, Ftiercel, Gcdinsmore, Goplat, GregorB, Heimstern, Hu12, Isotope23, JLaTondre, JakobVoss, Jason Quinn, JoeB, Juansempere, Katieh5584, Kbrose,
KeyStroke, Lectonar, Luna Santin, Mayur, Mhkay, Mindmatrix, Modster, MrRadioGuy, Nate Silva, NerdyScienceDude, Nick Garvey, Riki, Rstinejr, Santoshijd, Shriram, Sjgilbertz, Skew-t,
SkyWalker, SqlPac, Squids and Chips, Svick, Tobias382, Tomsimtim, Trevorbjork, Tumble, Unyoyega, Vy0123, WOSlinker, WeißNix, Whywhenwhohow, WikHead, Wwwwolf, Zanimum, 154
anonymous edits

NoSQL  Source: http://en.wikipedia.org/w/index.php?oldid=494478753  Contributors: Adtadt, Al3xpopescu, Alexandre.Morgaut, Alexrakia, AlisonW, Amire80, Anastrophe, AndrewBass,
Anujsahni, Argv0, Arjayay, Arto B, Asafdapper, AxelBoldt, BD2412, Bbulkow, Bdijkstra, Bearcat, Beland, Benatkin, Benhoyt, Bhaskar, Biofinderplus, Boshomi, Bovineone, Brocsima,
CaptTofu, Ceefour, Cekli829, Charbelgereige, ChristianGruen, Ciges, Clemwang, Cnorvell, ColdShine, Coldacid, Corrector623, Craigbeveridge, Crosbiesmith, Cybercobra, Cyril.wack,
DamarisC, Dancrumb, DatabACE, DavidBourguignon, DavidSol, Davidhorman, Dericofilho, Dm, Dmccreary, Dmitri.grigoriev, Dredwolff, Drttm, Dshelby, Dstainer, Duncan, Ebalter, Eco
schranzer, Edlich, Ehn, Eno, EricBloch, ErikHaugen, Ertugka, Euphoria, Excirial, Farvartish, Fiskbil, Fraktalek, Frap, Freshnfruity, Furrykef, Fxsjy, Gaborcselle, Germanviscuso, Getmoreatp,
Gkorland, GlobalsDB, GoingBatty, Gonim, Gorman, Gpierre, GraemeL, Gstein, Headbomb, Heelmijnlevenlang, Hloeung, Hoelzro, Inmortalnet, Irmatov, JLaTondre, Jabawack81, Jandalhandler,
Javalangstring, Jeffdexter77, JnRouvignac, Jonasfagundes, Joolean, Jottinger, Jrudisin, Jstplace, Jubalkessler, Justinsheehy, Kbrose, Kgfleischmann, Khiladi 2010, Ki2010, KiloByte, Kkbhumana,
Knudmoeller, Koavf, Komap, Korrawit, Leegee23, Leotohill, Lfstevens, Lguzenda, Linas, Looris, Luebbert42, Luisramos22, MMSequeira, Mabdul, MacTed, Magnuschr, ManikSurtani,
Marasmusine, Matspca, Mbarrenecheajr, Mbonaci, Mhegi, Miami33139, Mitpradeep, Mjresin, Morphh, Mortense, MrWerewolf, Mshefer, Mtrencseni, Mydoghasworms, Natishalom, Nawroth,
Netmesh, Neustradamus, Nick Number, Nileshbansal, Ntoll, OmerMor, Omidnoorani, Ostrolphant, PatrickFisher, Pcap, Peak, Peter Gulutzan, Phillips-Martin, Phoe6, Phunehehe, Plustgarten,
Pnm, Poohneat, ProfessorBaltasar, R39132, Rabihnassar, Raysonho, Really Enthusiastic, Rfl, Robert1947, RobertG, Robhughadams, Ronz, Rpk512, Rtweed1955, Russss, Sae1962, SamJohnston,
Sandy.toast, ScottConroy, Sduplooy, Seancribbs, Seraphimblade, Shadowjams, Shepard, Shijucv, Smyth, Socialuser, Sorenriise, Sstrader, Stephen Bain, Stephen E Browne, Steve03Mills,
Stevedekorte, Stimpy77, Syaskin, TJRC, Tabletop, Tagishsimon, Techsaint, Tedder, Theandrewdavis, Thomas.uhl, ThomasMueller, Thumperward, Tobiasivarsson, Tomdo08, Trbdavies,
Tshanky, Tuvrotya, Tylerskf, Ugurbost, Uhbif19, Violaaa, Viper007Bond, Volt42, Voodootikigod, Vychtrle, Walter Görlitz, Wavelength, Weimanm, Whimsley, White gecko, Whooym, William
greenly, Winston Chuen-Shih Yang, Winterst, Woohookitty, Wyverald, YPavan, Zapher67, Zond, 506 anonymous edits

Table  Source: http://en.wikipedia.org/w/index.php?oldid=487997224  Contributors: 12george1, 16@r, Ajraddatz, Alai, Arcann, AutumnSnow, Blanchardb, Bobo192, Bongwarrior, Bruxism,
Cbrunschen, Cyfal, DARTH SIDIOUS 2, Danim, Dreftymac, Epbr123, Funnyfarmofdoom, Gurch, IMSoP, IanCarter, J36miles, Jamelan, Jerome Charles Potts, Larsinio, LeonardoGregianin,
Lfstevens, Mark Renier, Materialscientist, Mblumber, Mikeblas, Mikeo, Mindmatrix, Morad86, N0nr3s, Nibs208, Ofus, Pyfan, Quentar, S.K., Sae1962, Senator2029, Sietse Snel, SimonP,
Sippsin, Sonett72, SqlPac, Stolze, TheParanoidOne, TommyG, Turnstep, Txomin, Ummit, Versageek, Yug1rt, Zhenqinli, 91 anonymous edits

Column  Source: http://en.wikipedia.org/w/index.php?oldid=486441482  Contributors: AbsoluteFlatness, Arcann, CesarB, CommonsDelinker, Danim, Dreftymac, Fæ, GermanX, Huiren92,
Jmabel, KeyStroke, Mark T, Mzuther, RJFJR, Sae1962, Sietse Snel, SqlPac, 石 庭 豐, 10 anonymous edits

Field  Source: http://en.wikipedia.org/w/index.php?oldid=483848310  Contributors: 16@r, 220 of Borg, Alan012, Alanlevin, Antandrus, Anwar saadat, Arcann, Btx40, CWenger, CanisRufus,
Ceyockey, Cybercobra, Dcoetzee, Dreftymac, Garyzx, JeffTan, Luís Felipe Braga, Mark Arsten, Mark Renier, Michael Hardy, My another account, Nuujinn, Patrick, PersOnLine, RadioFan,
Sae1962, Sjakkalle, Skizzik, Spoon!, Taemyr, TakuyaMurata, Tizio, Tommy2010, Waltpohl, Xqsd, 32 anonymous edits

Row  Source: http://en.wikipedia.org/w/index.php?oldid=480551062  Contributors: 2help, Allen3, CommonsDelinker, D4g0thur, Danim, David H Braun (1964), Flip, GLaDOS, Gail, GermanX,
Glacialfox, GregorySmith, Jamespurs, Jerroleth, Jmabel, KKramer, KeyStroke, Liujiang, Mark T, Mxg75, Mzuther, Oyauguru, Pnm, Pol098, Retodon8, Rjd0060, Ronhjones, Shaka one, Sietse
Snel, SootySwift, Troels Arvin, Yamamoto Ichiro, 28 anonymous edits

Data type  Source: http://en.wikipedia.org/w/index.php?oldid=492655161  Contributors: AThing, Acrollins, Agrophobe, Alik Kirillovich, Andrew J. MacDonald, Anghammarad, Antonielly,
Arjayay, Armageddon11, Arthena, B4hand, Bender235, Bensin, Benwing, Blanzik, Bookinvestor, Busfault, Canaima, Captain-n00dle, CaseyPenk, Causa sui, Chealer, Chilvan, Christian75,
Cybercobra, DVdm, DanBishop, Danielcreech, David Shay, DeadEyeArrow, Dejawolf, Diannaa, Dreftymac, Duke Ganote, EAderhold, EdC, Eghanvat, Elunah, Elwikipedista, Esap, Face,
Falcon8765, Floatjon, Friendlydata, Garyzx, Gaspercat, Gendut, GeorgeBills, Ghettoblaster, Guoguo12, Halaster, HappyDog, Hardyplants, Hash Dollar, Hmmwhatsthisdo, Hooperbloob,
HumphreyW, JCLately, Jb-adder, Jeh, Johnteslade, Kbrose, KrakatoaKatie, Krischik, Kwiki, L Kensington, LaMona, Lambiam, Leotohill, Libcub, Logiphile, M4gnum0n, MC10, Maelor, Maian,
Mark Renier, Martin Bravenboer, MattGiuca, Mawode, Mbxp, Mdd, Michal Jurosz, MilerWhite, Millermk90, Minimac, Mjb, Mr Stephen, MrTsuna20, Mxcatania, NHSavage, Neelix, Neilc,
Neo63, Nibuod, Nightstallion, Omnipaedista, Oroso, Pcap, Peter.C, Peterdjones, Public Menace, R'n'B, RHaworth, Raffaele Megabyte, Rahulghose, Raymondwinn, Reaper Eternal, Renku,
Rettetast, Ru.va, S, S.Örvarr.S, Shell Kinney, Slon02, Slugger, SoWhy, Socrates2008, TakuyaMurata, Teji, The Thing That Should Not Be, Thecheesykid, Thincat, Tide rolls, Tobias Bergemann,
Tokigun, Triwbe, Ttwaring, TutterMouse, TuukkaH, Wikiji, Wimt, 263 anonymous edits

Application programming interface  Source: http://en.wikipedia.org/w/index.php?oldid=493666252  Contributors: 213.121.101.xxx, 24.108.233.xxx, 24.93.53.xxx, 4483APK, 64.105.112.xxx,
90, AaronL, Aarsalankhalid, AbdulKhaaliq2, Adah, Addshore, Ae-a, Aeons, Aeternus, Ahunt, Ahzahraee, Airplaneman, Alan d, Alex43223, Altaf.attari86, Altenmann, Amanuse, Ancheta Wis,
Andre Engels, Andremi, Andres, Andrey86, Andy16666, Anteru, Apoltix, Arindra r, Arjayay, Arthur Davies Sikopo, Aruton, Ashamerie, Asydwaters, Atheken, Atreys, Aude, Auntof6, Avk15gt,
Awg1010, Bamyers99, Bdesham, Beano, Bearcat, Betterusername, Bevo, Bhat sudha, Bikingviking, Blackcats, Bobo192, Boing! said Zebedee, Bookiewookie, Borgx, Boyprose, Brianski, Bryan
Derksen, BryanG, Bryanmonroe, CYD, Calton, CanisRufus, Capricorn42, Chadsmith729, Chameleon, Chealer, Chicago god, Chiefcoolbreeze, Chituokol1, ClaudiaHetman, CloudNine, Colonoh,
Consult.kirthi, Conversion script, Coolbloke94, Courcelles, Cybercobra, Cynical, DShantz, Damian Yerrick, Daniduc, Danja, Darklight, Davejohnsan, Davemck, David Gerard, Davron, Dawidl,
DeeKay64, Deepugn, Dennislees, Derek farn, Detnos, Diego Moya, Diomidis Spinellis, Dipskinny, Discospinster, Dmarquard, Download, Dqpeck, Dr Marcus Hill, Dreadstar, Drewmeyers,
Dschach, Dsnelling, Dylan620, EVula, Ebessman, Ed Poor, Edcolins, Edwardkerlin, Efa, Egmontaz, Ehn, Elf, Ellmist, Eloquence, Enochlau, Enric Naval, Epbr123, Eric Agbozo, Espoo, Excirial,
Farrwill, Fieldday-sunday, Fitch, Frap, Freakimus, Frecklefoot, FrummerThanThou, Funvill, Fæ, GRAHAMUK, Gak, GeoffPurchase, Giftlite, Graham87, Greensburger, Griznant, HUB, Hadal,
Harryboyles, Hashar, HenkeB, Heraclius, Hfastedge, Hmains, Husond, InShaneee, Infinitycomeo, Itai, Ivan007, Ixfd64, Izno, JHunterJ, JLaTondre, JWSchmidt, Jakuzem, JamesMLane,
Jbolden1517, Jengod, Jerryobject, Jesse V., Jidanni, Jitse Niesen, Jleedev, Jmclaury, JoeB34, John of Reading, John.n-irl, JohnBlackburne, JulesH, Julien, Julienj, K12u, Kbolino, Kernel
Saunters, Kichik, Kickin' Da Speaker, Kim Bruning, King of Hearts (old account 2), KnowledgeOfSelf, Kocio, Kurdo777, Landon1980, Lavers, Lee Daniel Crocker, Lekshmann, Leoholbel,
Liempt, Limbo socrates, Liorma, LizardJr8, Lockeownzj00, Looc4s, Lord Chamberlain, the Renowned, Loren.wilton, Loshsu, Lotje, Lupin, M5, Mac, Mange01, Manop, Martyn Lovell,
Marudubshinki, Materialscientist, Mattknox, Mav, Mbeychok, Meldraft, Mflore4d, Michael Hardy, Michael Hodgson, Michaelas10, Miguel, Mihai cartoaje, Miketwardos, Minghong, Minirogue,
Miohtama, MoreThanMike, Morg, Mountain, Mpbaumg, MrOllie, Mrh30, Mshivaram.ie22, Mwarf, Myc2001, Nanshu, Neelix, NewEnglandYankee, Nopetro, Notinasnaid, Nsda, Obradovic
Goran, Ocean Shores, Ohspite, Old Guard, OlegMarchuk, Oulrij, Oxymoron83, Pascal.Tesson, PaymentVision, Peak, Pearll's sun, Pengo, Pepe.agell, Percede, Pgimeno, Philip Trueman, Phuzion,
Piano non troppo, Plamka, Poweroid, Prari, Pwforaker, Queenmomcat, Quinet, Quux, Qwertyus, Qxz, R'n'B, RJHall, Rackspacecloud, Raise exception, Randomalious, RedWolf, Redlentil,
Reemrevnivek, Renatko, Rich Farmbrough, RichMorin, Riluve, Rktur, Robert K S, Robneild, Rocastelo, Ronocdh, RoyBoy, Rs rams, Rudyray, Rwwww, SERIEZ, SQGibbon, ST47, Sakhal,
Salvatore Ingala, Sam Korn, Scohil, Scott Ritchie, Seth Nimbosa, Sfmontyo, Shlomif, SimonTrew, SirSandGoblin, Sj, Skeejay, Skysmith, Slady, Slurrymaster, SocialRadiusOly, Sodium,
Soumyasch, Spencer, Spikey, SqueakBox, Stephenchou0722, SteveBaker, Steven J. Anderson, Suruena, Syvanen, Szajd, T-borg, Ta bu shi da yu, Tantrumizer, TastyPoutine, Tedickey, Teryx,
Teutonic Tamer, The Anome, The Thing That Should Not Be, TheSoundAndTheFury, TheresaWilson, Thiotimoline, Thisisborin9, Tide rolls, Tijuana Brass, Tony1, Torchiest, Transpar3nt,
TrentonLipscomb, Troymccluresf, Tseay11, Uriyan, Utype, Uzume, Varworld, Vikramtheone, Visvadinu, Vkorpor, Voidxor, WTRiker, WaltBusterkeys, Wapcaplet, Wavelength, Whatsnxt,
Whitehorse212, WikHead, Willy-os, Wjejskenewr, Wysprgr2005, Xqt, Yaris678, YordanGeorgiev, Yurik, Zachlipton, Zeno Gantner, Zhinz, ZimZalaBim, Zodon, 계정명뭘로하지, 764
anonymous edits

Database transaction  Source: http://en.wikipedia.org/w/index.php?oldid=489496803  Contributors: 16@r, Adi92, Ajk, Al3ksk, AmandeepJ, AnmaFinotera, Binksternet, Burschik,
CharlotteWebb, Clausen, Comps, Craig Stuntz, DCEdwards1966, Damian Yerrick, Dauerad, Derbeth, DnetSvg, Fratrep, Geniac, Georgeryp, Gerd-HH, Gf uip, Ghettoblaster, GregRobson,
Haham hanuka, Hbent, Hede2000, Highguard, HumphreyW, Intgr, JCLately, Jason Quinn, Jeltz, Karel Anthonissen, KellyCoinGuy, KeyStroke, Khukri, Larsinio, Leeborkman, Lingliu07, Lubos,
Luc4, Lysy, M4gnum0n, Mark Renier, Matiash, MegaHasher, Mike Schwartz, Mikeblas, Mindmatrix, Mintleaf, Neilc, Nixdorf, OMouse, Obradovic Goran, Orderud, Owen, Paul Foxworthy,
Pcap, Pepper, RedWolf, Roesser, SAE1962, Sandrarossi, SebastianHelm, Sobia akhtar, SqlPac, Stevag, T0m, Timo, Triwger, Troels Arvin, Turnstep, WeißNix, Zerksis, Zhenqinli, 100
anonymous edits

Open Database Connectivity  Source: http://en.wikipedia.org/w/index.php?oldid=434753869  Contributors: AKGhetto, AlistairMcMillan, Allens, Andreas Kaufmann, AndriuZ, Arch dude,
Auric, AvicAWB, Avé, BobGibson, BonsaiViking, Borgx, Bovineone, Cander0000, CanisRufus, Canterbury Tail, Charlesgold, ClaudioSantos, Computafreak, Craig Stuntz, DFulbright, Danim,
David Gerard, Derbeth, Dittaeva, DragonHawk, Drewgut, Eglobe55, Electrolite, Epim, Everlasting Winner, Gcm, GreyCat, Harry Wood, Inzy, Irish all the way, JLaTondre, Jandalhandler, Jay,
Article Sources and Contributors 130

Jkelly, Jklowden, JonathanMonroe, KeyStroke, KingsleyIdehen, Kuru, Kyouteki, Kzafer, Larsinio, Lkstrand, Lowellian, Lurcher300b, Mabuse, MacTed, Magnus.de, Manop, Mark Renier,
Markhurd, Martijn Hoekstra, Maximaximax, MeltBanana, Michael Hardy, Mikeblas, Mindmatrix, Minesweeper, Minghong, Mintleaf, Misog, Mitsukai, NapoliRoma, Nikos 1993, Nixdorf,
NoahSussman, Orlady, Orpheus, Oxda, Paul Foxworthy, Pedant17, Pill, Pmsyyz, Polluks, Power piglet, PrisonerOfIce, Quuxa, Raffaele Megabyte, Rajkumar9795, Reconsider the static, Reedy,
RenniePet, Rrabins, Seanwong, Sega381, Spellmaster, Sspecter, Struway, Swhalen, The Anome, The wub, Thumperward, Tide rolls, Tin, TommyG, Viridae, Wez, Whpq, Wikipelli, William
Avery, Winterst, Ysangkok, Yug1rt, 213 anonymous edits

Java Database Connectivity  Source: http://en.wikipedia.org/w/index.php?oldid=492897988  Contributors: AS, Andreas Kaufmann, Arcann, Atozjava, Audriusa, Beetstra, Bkrakesh, Blaine-dev,
Brick Thrower, CambridgeBayWeather, Cameltrader, Cander0000, Caomhin, Captmjc, Cherkash, Chowbok, Chrismacgr, Coldacid, Danim, Dddelfin, Derbeth, Dinosaurdarrell, DivideByZero14,
Doug Bell, Drewgut, Edward, Ehheh, Ehn, Elandon, Eumolpo, Evgeni Sergeev, Explanator, FOOL, Faisal.akeel, Ferengi, Ferrans, Fikus, Forage, Frecklefoot, Fred Bradstadt, Fuhghettaboutit,
Fyyer, GLumba, GraemeL, Graham87, GreyCat, Harryboyles, Iain.dalton, Insomnia64, JDvorak, JLaTondre, Jacks435, Jameboy, Jay, Jems421, JeremyStein, Jeronimo, Jjaazz, Joffeloff, Josepant,
Josephw, Julesd, Katieh5584, Kaydell, KingsleyIdehen, Klausness, Lenaic, Leszek4444, M4design, M4gnum0n, MER-C, MacTed, Mark Renier, Materialscientist, MeltBanana, Mindmatrix,
Mintleaf, Moribunt, MrOllie, Nlevitt, Noq, Pako, Pillefj, Pinecar, Pinkyf, Piojo, Pne, Poor Yorick, Praslisa, Ravenmewtwo, RedWolf, Reedy, Rm1507, SJK, Sae1962, Schw3rt, Sfmontyo,
ShaunMacPherson, Sjc, SmackEater, Sohail.sikora, Sqlinfo, Srecd, Sualeh, Supreme geek overlord, Tcncv, The Anome, The Aviv, Theresa knott, Tom 99, Twsx, Unclejedd, Warren, Wikipelli,
Winterst, Yaniv Kunda, Yaxh, Zundark, Дарко Максимовић, 185 anonymous edits

Select  Source: http://en.wikipedia.org/w/index.php?oldid=494307209  Contributors: 2aprilboy, Ahoerstemeier, Ajmas, Andr3w, Arcann, Avé, Berny68, Bovineone, Centrx, Chester Markel,
CodeNaked, Cww, Da404lewzer, Dancter, Danielluyo, Data64, Dp462090, Dparvin, Ed Poor, EvanCarroll, Faradayplank, Gadfium, GargoyleMT, Graden, GregorB, GreyCat, Gurch, Helix84,
Isotope23, JLaTondre, JaGa, Jay, John Vandenberg, Jpmague, Jpo, Kayvee, LHOON, Larsinio, LinguistAtLarge, Locke Cole, Lowellian, Maashatra11, Macrakis, Mais oui!, Mark Renier,
Materialscientist, Mikeblas, Mild Bill Hiccup, Mindmatrix, Mormegil, MrOllie, Mxn, Ngpd, Nic Waller, Niketanp, Octahedron80, OdiProfanum, PaD, Paul Pogonyshev, Piano non troppo, Plrk,
Randycjones, Resilvajr77, S.K., Shoone, SpeedyGonsales, Spetzgrad, SqlPac, Sqlinfo, Stolze, Svick, Tedmund, TerriersFan, The Fortunate Unhappy, Tomhubbard, Troels Arvin, Twsx,
Unforgiven24, Unknown W. Brackets, Victor falk, WOSlinker, Wgillett, WikHead, Wmenton, Wwphx, Xjhx001, Yug1rt, 124 anonymous edits

Insert  Source: http://en.wikipedia.org/w/index.php?oldid=488896850  Contributors: Adanbrown, Ahoerstemeier, Alvin-cs, Amarsir, Antandrus, Ben2k9, Blcm, Bshow, Chester Markel, Dancter,
DaveChild, DeadEyeArrow, Dparvin, Drake Wilson, Dze27, ESkog, Ed Poor, Edward, Frap, Ftiercel, Fzzzy, GSwarthout, Gadfium, GargoyleMT, Ginsengbomb, GregorB, GreyCat,
Griffinofwales, Iamavandalizer, Isotope23, JLaTondre, Jason Quinn, Jercos, Kingmotley, Larsinio, LinguistAtLarge, Mark Renier, Mikeblas, Mindmatrix, Mnb20, Mounaam, Neilc,
Nogoodshitname, PauloCalipari, Pope on a Rope, Reswobslc, Riki, Rjwilmsi, Slackwise, SqlPac, Stolze, Svick, TeunSpaans, The Fortunate Unhappy, Troels Arvin, Tsijun, Unknown W.
Brackets, Utkwes, Yug1rt, 105 anonymous edits

Update  Source: http://en.wikipedia.org/w/index.php?oldid=476285613  Contributors: Amux, CodeNaked, Dbolton, Gadfium, GargoyleMT, GregorB, GreyCat, Hmzabeeh62, Ipeattie, Isotope23,
Kakoui, Larsinio, LinguistAtLarge, Mark Renier, Mikeblas, Mindmatrix, Nic Waller, PauloCalipari, Puffin, Reedy, S.K., Sean.hoyland, SqlPac, Stolze, Sumail, The Fortunate Unhappy, Timc,
Troels Arvin, Ubern00b, Uncle Milty, Xaje, Yug1rt, Zain Ebrahim111, 68 anonymous edits

Merge  Source: http://en.wikipedia.org/w/index.php?oldid=488936530  Contributors: Az1568, Bovineone, Bunnyhop11, Burtonator, Cowtowncoder, Edam, Ftiercel, Greenrd, GreyCat, Krauss,
Mark Renier, Mikeblas, MrOllie, Patriotic dissent, Reedy, Rgauf, Samdorr, Scrooll, SqlPac, Sqlinfo, Stolze, The Fortunate Unhappy, Unordained, Xaje, Xenodevil, Ysangkok, 24 anonymous
edits

Delete  Source: http://en.wikipedia.org/w/index.php?oldid=493366501  Contributors: Aaronmatthews, Anakin101, Bongwarrior, Bruce1ee, Candid Dauth, Chick Bowen, Closedmouth, Dancter,
Fnielsen, Frap, GargoyleMT, GregorB, GreyCat, Intgr, Isotope23, JNMofMV, Jason Quinn, Jwoodger, Kaimiddleton, Kratos 84, LHOON, Larsinio, Lectonar, LinguistAtLarge, MBisanz, MJGR,
Mary*wu, Mikeblas, Mindmatrix, Nabilla00, Nic Waller, OdiProfanum, Slon02, Some jerk on the Internet, SqlPac, The Fortunate Unhappy, Troels Arvin, Turnstep, Unixxx, Wavelength, Yug1rt,
65 anonymous edits

Join  Source: http://en.wikipedia.org/w/index.php?oldid=493968949  Contributors: 28421u2232nfenfcenc, 28bytes, Adamrmoss, Addshore, Ajgorhoe, Ajraddatz, Alansohn, Alessandro57,
Alexey Izbyshev, Alexius08, Algorithm, AlistairMcMillan, Amniarix, Andr3w, AndrewN, AndrewWTaylor, Angryxpeh, Aranel, Arcann, Azazyel, Back ache, Banazir, BenFrantzDale, Benatkin,
Bevo, Bilby, Bluezy, Bobnewstadt, BrandonCsSanders, Cabe6403, Caltas, Can't sleep, clown will eat me, Canterbury Tail, CardinalDan, Cbuckley, Chris55, Chrismacgr, Church of emacs, Chzz,
Cintari, Cmrudolph, Conrad.Irwin, Constantine Kon, CousinJohn, Crypticstargate, Cynthia Blue, DARTH SIDIOUS 2, DBBell, DBigXray, Damian Yerrick, Dan Forward, David Eppstein,
DeRien, Decrease789, Defenestrate, Dhdawe, Dobi, Dparvin, DruidZ, Dtwong, EJSawyer, ESkog, Ed Poor, Ed g2s, Edward, Elektrik Shoos, Elwikipedista, Erwin, Esofomuso,
Faithlessthewonderboy, Flyingcheese, FourtySix&Two, Frap, Fred Bradstadt, Fremsoft, Friedo, Fundamentisto, Futurix, Gadfium, Gail, GeorgeVarghese12, Ghiraddje, Gilliam, Gintsp, Glane23,
Goethean, Gogo Dodo, Golbez, GrayFullbuster, GregorB, Gwandoya, Haymaker, Hebrews412, Herbythyme, HorsePunchKid, Hpetya, Hsdav, Hu12, Insanephantom, Io Katai, Iridescence,
Iridiumcao, Isotope23, Itmozart, JCLately, Jatin.ramanathan, Jeepday, Johannes Simon, Jpatokal, Juliano, JustinRosenstein, Jwalantsoneji, Jwoodger, Kaelar, Kazvorpal, Kingmotley, Kite07712,
Klausness, Krassonkel, Kubigula, Lambiam, Landon1980, Larsinio, LateToTheGame, Laug, Leeannedy, Lemming, LeoHeska, Likejune, Loren.wilton, Lousyd, Lozeldafan, Lucio, Lyonzy90,
MER-C, Mandarax, MarchHare, Markhurd, Martinvie, Materialscientist, MaxMahem, Mbarbier, Mbloore, Mckaysalisbury, MelbourneStar, Mentifisto, Mfyuce, MiguelM, Mike.lifeguard,
Mike929t, Mikeblas, Mindmatrix, Mitar, Mmichaelc, Moogwrench, MrOllie, Murphydactyl, Mwtoews, Nbarth, Neilc, NewEnglandYankee, Newtman, Nichtich, Nirion, Nithinhere, Noitidart,
Nricardo, Oddbodz, OdiProfanum, Omicronpersei8, OracleGuy, Orange Suede Sofa, OrangeDog, Oshah, OverlordQ, Palosirkka, Pasteurizer, Paulwehr, Pedant17, Perijove, Pgan002, Philip
Trueman, PhilipMW, Plustgarten, Pne, Pnm, Possum, PseudoSudo, Pseudomonas, Qviri, Rahi1234, Ramanna.Sathyanarayana, Raztus, Rburhum, Redhanker, Reedy, Rjohnson84, Roga Danar,
RokerHRO, RoyGoldsmith, Russellsim, Sam Allison, Santhoshseeks, SarekOfVulcan, Scolebourne, Seaphoto, Shadowjams, Sharon.delarosa, Shinmawa, Silvaran, SimonP, Sippsin, Smjg,
Soluch, SpK, Spitfire8520, SpuriousQ, SqlPac, Sreecanthr, Ssavelan, St33lbird, Stevecudmore, Steven Zhang, Stolze, Storkk, Subversive.sound, SynergyBlades, Ta bu shi da yu, TangentCube,
Taral, Tbsdy lives, Tfischer, The Fortunate Unhappy, The Thing That Should Not Be, Thekaleb, Thekingfofa, Thumperward, Titusjan, Troels Arvin, Tuntable, Tweisbach, Unknown W. Brackets,
Unschool, Vikashrajan, Viriditas, Wasell, Wavelength, WinContro, Woohookitty, WouterBolsterlee, X96lee15, Xanderiel, Yangshuai, Ysangkok, Zanemoody, 1027 anonymous edits

Set operations  Source: http://en.wikipedia.org/w/index.php?oldid=456104708  Contributors: AlanBarrett, Cmweiss, CodeNaked, Dcoetzee, Epbr123, Ftiercel, Gintsp, Googl, GregorB,
Isotope23, Kaimiddleton, Larsinio, LinguistAtLarge, Mikeblas, Mindmatrix, Noformation, QNeX, Racklever, Reedy, S.K., SqlPac, Stolze, The Fortunate Unhappy, 43 anonymous edits

Commit  Source: http://en.wikipedia.org/w/index.php?oldid=444485927  Contributors: Ajgorhoe, Amalas, Arashb31, Donovan Heinrich, G7yunghi, Gpvos, Gtrmp, JCLately, Jthiesen, Lmalecki,
Mark Renier, Michael Slone, Mikeblas, Nabla, Radagast83, RedWolf, RockMFR, Schapel, SqlPac, Stevertigo, Yuvysingh, Zucchinidreams, 24 anonymous edits

Rollback  Source: http://en.wikipedia.org/w/index.php?oldid=488124118  Contributors: Alexius08, Apokrif, Brick Thrower, Craig Stuntz, Emperorbma, Feinoha, Gadfium, J.s.banger, JCLately,
JonHarder, Khalid hassani, M4gnum0n, Mattisse, Mikeblas, Mindmatrix, Oxymoron83, Pegship, Piotrus, Pne, Rfl, SimonP, Turnstep, Unknown W. Brackets, Vedant, Wikiklrsc, 20 anonymous
edits

Truncate  Source: http://en.wikipedia.org/w/index.php?oldid=465790642  Contributors: BeSeeingYou, BlackSmith.Fi, Bunnyhop11, Chrisleonard, Er sachinagarwal, Ftiercel, GargoyleMT,
GreyCat, Igno2, Isotope23, Jay Johnston, Jidanni, Larsinio, LinguistAtLarge, Mark Renier, Mikeblas, Mysdaao, Nathanator, NewWikiMan, Nicopedia, NotAnonymous0, PaD, QNeX, SqlPac,
Stangel, The Fortunate Unhappy, Troels Arvin, Zawersh, 25 anonymous edits
Image Sources, Licenses and Contributors 131

Image Sources, Licenses and Contributors

File:Loudspeaker.svg  Source: http://en.wikipedia.org/w/index.php?title=File:Loudspeaker.svg  License: Public Domain  Contributors: Bayo, Gmaxwell, Husky, Iamunknown, Mirithing,
Myself488, Nethac DIU, Omegatron, Rocket000, The Evil IP address, Wouterhagens, 19 anonymous edits
File:SQL ANATOMY wiki.svg  Source: http://en.wikipedia.org/w/index.php?title=File:SQL_ANATOMY_wiki.svg  License: unknown  Contributors: :User:SqlPac, modified by Ferdna.
Original uploader was Ferdna at en.wikipedia
Image:Flat File Model.svg  Source: http://en.wikipedia.org/w/index.php?title=File:Flat_File_Model.svg  License: Public Domain  Contributors: Wgabrie (talk) 16:48, 13 March 2009 (UTC)
Image:Emp Tables (Database).PNG  Source: http://en.wikipedia.org/w/index.php?title=File:Emp_Tables_(Database).PNG  License: Public Domain  Contributors: Jamesssss
Image:Relational database terms.svg  Source: http://en.wikipedia.org/w/index.php?title=File:Relational_database_terms.svg  License: Public Domain  Contributors: User:Booyabazooka
Image:Mysqlwb-homepage.png  Source: http://en.wikipedia.org/w/index.php?title=File:Mysqlwb-homepage.png  License: GNU General Public License  Contributors: Official screenshot as
published on MySQL.com. Original uploader was Tomjenkins52 at en.wikipedia
Image:Information-Retrieval-Models.png  Source: http://en.wikipedia.org/w/index.php?title=File:Information-Retrieval-Models.png  License: GNU Free Documentation License  Contributors:
Deadstar, ThomasHofmann, 1 anonymous edits
License 132

License
Creative Commons Attribution-Share Alike 3.0 Unported
//creativecommons.org/licenses/by-sa/3.0/