Bibliography Data Science - Big Data DevOps Software Engineering

B06XPJML5D ISBN-13: 978-1449373320

See: Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems, 1st Edition, Publisher ‏ : ‎ O’Reilly Media; 1st edition (April 18, 2017)

Fair Use Source:

Data Science - Big Data Python Software Engineering


” (WP)

SQLAlchemy is an open-sourceSQL toolkit and object-relational mapper (ORM) for the Python programming language released under the MIT License.[5]

Original author(s)Michael Bayer[1][2]
Initial releaseFebruary 14, 2006; 15 years ago[3]
Stable release1.4.15 / May 11, 2021; 2 months ago[4]
Written inPython
Operating systemCross-platform
TypeObject-relational mapping
LicenseMIT License[5] 


SQLAlchemy’s philosophy is that relational databases behave less like object collections as the scale gets larger and performance starts being a concern, while object collections behave less like tables and rows as more abstraction is designed into them. For this reason it has adopted the data mapper pattern (similar to Hibernate for Java) rather than the active record pattern used by a number of other object-relational mappers.[6] However, optional plugins allow users to develop using declarative syntax.[7]


SQLAlchemy was first released in February 2006[8][3] and has quickly become one of the most widely used object-relational mapping tools in the Python community, alongside Django‘s ORM.


This section possibly contains original research. Please improve it by verifying the claims made and adding inline citations. Statements consisting only of original research should be removed. (November 2019) (Learn how and when to remove this template message)

The following example represents an n-to-1 relationship between movies and their directors. It is shown how user-defined Python classes create corresponding database tables, how instances with relationships are created from either side of the relationship, and finally how the data can be queried—illustrating automatically generated SQL queries for both lazy and eager loading.

Schema definition

Creating two Python classes and according database tables in the DBMS:

from sqlalchemy import *
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relation, sessionmaker

Base = declarative_base()

class Movie(Base):
    __tablename__ = "movies"

    id = Column(Integer, primary_key=True)
    title = Column(String(255), nullable=False)
    year = Column(Integer)
    directed_by = Column(Integer, ForeignKey(""))

    director = relation("Director", backref="movies", lazy=False)

    def __init__(self, title=None, year=None):
        self.title = title
        self.year = year

    def __repr__(self):
        return "Movie(%r, %r, %r)" % (self.title, self.year, self.director)

class Director(Base):
    __tablename__ = "directors"

    id = Column(Integer, primary_key=True)
    name = Column(String(50), nullable=False, unique=True)

    def __init__(self, name=None): = name

    def __repr__(self):
        return "Director(%r)" % (

engine = create_engine("dbms://user:pwd@host/dbname")

Data insertion

One can insert a director-movie relationship via either entity:

Session = sessionmaker(bind=engine)
session = Session()

m1 = Movie("Robocop", 1987)
m1.director = Director("Paul Verhoeven")

d2 = Director("George Lucas")
d2.movies = [Movie("Star Wars", 1977), Movie("THX 1138", 1971)]



alldata = session.query(Movie).all()
for somedata in alldata:

SQLAlchemy issues the following query to the DBMS (omitting aliases):

SELECT, movies.title, movies.year, movies.directed_by,,
FROM movies LEFT OUTER JOIN directors ON = movies.directed_by

The output:

Movie('Robocop', 1987L, Director('Paul Verhoeven'))
Movie('Star Wars', 1977L, Director('George Lucas'))
Movie('THX 1138', 1971L, Director('George Lucas'))

Setting lazy=True (default) instead, SQLAlchemy would first issue a query to get the list of movies and only when needed (lazy) for each director a query to get the name of the according director:

SELECT, movies.title, movies.year, movies.directed_by
FROM movies

FROM directors
WHERE = %s

See also


  1. ^ Mike Bayer is the creator of SQLAlchemy and Mako Templates for Python.
  2. ^ Interview Mike Bayer SQLAlchemy #pydata #python
  3. a b “Download – SQLAlchemy”. SQLAlchemy. Retrieved 21 February 2015.
  4. ^ “Releases – sqlalchemy/sqlalchemy”. Retrieved 17 May 2021 – via GitHub.
  5. a b “zzzeek / sqlalchemy / source / LICENSE”. BitBucket. Retrieved 21 February 2015.
  6. ^ in The architecture of open source applications
  7. ^ Declarative
  8. ^


External links


” (WP)


Fair Use Sources:



See: Practical SQL: A Beginner’s Guide to Storytelling with Data

Fair Use Source:

C# .NET Cloud Data Science - Big Data History Software Engineering

Microsoft SQL Server

“” (CS9PR)

Previous: — Next:


Fair Use Sources:

Data Science - Big Data History Software Engineering

Oracle SQL Released – First Commercial Version of a SQL Database – 1979 AD

Return to Timeline of the History of Computers

Oracle released the first commercial version of SQL in 1979.

See also: Microsoft SQL Server (1989)

Fair Use Sources:

Data Science - Big Data History Software Engineering

SQL Relational Database Programming Language Invented by Edgar Codd of IBM – 1974 AD

Return to Timeline of the History of Computers

SQL is a relational database programming language and was developed by Edgar Codd in 1974 and is still important in the programming language world.

Fair Use Sources:

See also: Relational Databases (1970 AD), Microsoft SQL Server (1989)

Data Science - Big Data History Software Engineering

Relational Databases – 1970 AD

Return to Timeline of the History of Computers


SQL is a database programming language and was developed by Edgar Codd in 1974 and is still important in the programming language world.

Relational Database

Edgar F. Codd (1923–2003)

Storing large amounts of data was one of the early uses for computers, but it wasn’t immediately obvious how the data should be organized. At IBM’s San Jose research laboratory, computer scientist Edgar Codd devised an approach for organizing and arranging data that was more efficient than other models. Instead of grouping together data belonging to the same entity, his approach created large tables of data that had the same conceptual types, with identifying numbers (IDs) defining the relationships between records in different the tables.

For example, an insurance company might have one table of customers, with each customer having a CUSTOMER ID and a name. Then there might be another table of insurance policies, with each having a POLICY ID, a CUSTOMER ID, and a POLICY TYPE ID. A third table might link the POLICY TYPE ID and the details of the policy. In this example, to find the insurance policies for a customer, the computer would first find the CUSTOMER ID, and then find all of the policies that had the same CUSTOMER ID. To get the details of each policy, the system would take the POLICY ID, look it up in the table of policies to get the POLICY TYPE ID, and then search the table of policy types to find the details.

Codd’s groundbreaking research showed that organizing data in this fashion made it more efficient to store, faster to access, and easier to program. Most importantly, he showed that it was possible to create a general-purpose database engine for storing data on the computer’s hard drive, freeing programmers from the task and allowing them to concentrate on their applications. Once the database was developed and deployed, improvements to the underlying software benefitted all of the applications that relied on it. For his work, Codd was awarded the 1981 A.M. Turing Award.

Today the operating systems of both Apple’s iPhone and Google’s Android create a relational database on every smartphone for every app that’s installed, making Codd’s invention one of the dominant ways of storing data.

SEE ALSO First Disk Storage Unit (1956), Edgar Codd’s IBM SQL Relational Database Programming Language Invented (1974), Microsoft SQL Server (1989)

Edgar Codd created large tables of data that had the same conceptual types.

Fair Use Source: B07C2NQSPV