Try Postgres with Neon https://bit.ly/neon-fireship right now. Postgres is one of the most popular open-source SQL databases. It is an object-relational database that supports a wide range of datatypes and design patterns. Learn the basics in this fast intro tutorial. 

#programming #database #100SecondsOfCode

💬 Chat with Me on Discord

https://discord.gg/fireship

🔗 Resources

Postgres Docs https://www.postgresql.org/docs/
Futuristic Databases https://youtu.be/jb2AvF8XzII
SQL in 100 Seconds https://youtu.be/zsjvFFKOm3c

🔥 Get More Content - Upgrade to PRO

Upgrade at https://fireship.io/pro
Use code YT25 for 25% off PRO access 

🎨 My Editor Settings

- Atom One Dark 
- vscode-icons
- Fira Code Font

🔖 Topics Covered

- What is Postgres?
- Postgres quickstart tutorial
- Postgres vs MySQL
- Postgres vs SQLite
- Postgres vs Oracle
- What makes postgres different?
- What is an object-relational database?
2024-02-04T05:02:21.020Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
a8d9be05-12fb-49e6-91b1-007eddbbea67
e06177a553038be29b184e6d34a338a08a9bbfbddfad507812c7c629d51b410c
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
PostgreSQL, the most trusted name in open source relational databases.
Its development dates all the way back to 1986 at UC Berkeley under the direction of Michael Stonebraker.
Like other pure relational databases, it stores data in tables, columns, and rows, and uses structured query language to read and write data.
However, Postgres is technically an object relational database, which means it can create its own custom data types to store objects with properties use and support advanced features like inheritance and polymorphism.
When writing data, it runs fully ACID compliant transactions, but also adds its own special sauce called multi version concurrency control, which gives each transaction a snapshot of the database, allowing multiple transactions to run at the same time without traffic jams or locks.
Developers also love its extensibility.
Queries can be reused by writing stored procedures, and it even supports languages beyond SQL like Python and C.
And it has a robust ecosystem of mentions, like PostGIS to provide geospatial data for apps like Uber, or Citus who shard and distribute the database to any scale, or pgembedding to give AI chatbots long term memory, and the list goes on.
To get started, you can download and install it locally, or better yet, use a free cloud database like Neon, which provides auto scaling out the box and a nice UI to manage your data, in addition to a bunch of other advanced features like branching.
Create a new database, then head over to the SQL editor to run your first query, or connect it to your IDE UE with an extension like SQL Tools.
We could get started by creating a new table, but because this is an object relational database, let's begin by creating a custom data type, which defines the structure of object with corresponding properties and types.
What's awesome about Postgres though is that we have more exotic data modeling options.
Like, arrays can be used by putting brackets in front of a type, then make it a 2 dimensional array by adding another set of brackets.
We also have JSON data types to handle unstructured data and even key uvaluepairs with extensions like h store.
Now that we have this custom type, we can use it within 1 or more tables, like one table for programmers and another for designers.
Once the table is created, we can then use an insert statement to add a row of data into it.
Notice the use of a double colon to cast a estring into JSON or h store types.
And now finally, we can read the data with a select statement that uses dot notation to access the properties on our custom object.
Every table has a unique primary key, and we can create relationships by storing the primary key from one table as the foreign key on another, like a programmer might own many Lambos.
We can then find those Lambos by doing a join query that compares the programmer's ID to the Lambos owner ID.
This has been PostgreSQL in in 100 seconds.
Big shout out to NeonDB for sponsoring and making this awesome database free to use in the cloud.
Thanks for watching and I will see you in the next one.

Speaker 0: PostgreSQL, the most trusted name in open source relational databases. Its development dates all the way back to 1986 at UC Berkeley under the direction of Michael Stonebraker. Like other pure relational databases, it stores data in tables, columns, and rows, and uses structured query language to read and write data. However, Postgres is technically an object relational database, which means it can create its own custom data types to store objects with properties use and support advanced features like inheritance and polymorphism. When writing data, it runs fully ACID compliant transactions, but also adds its own special sauce called multi version concurrency control, which gives each transaction a snapshot of the database, allowing multiple transactions to run at the same time without traffic jams or locks.

Developers also love its extensibility. Queries can be reused by writing stored procedures, and it even supports languages beyond SQL like Python and C. And it has a robust ecosystem of mentions, like PostGIS to provide geospatial data for apps like Uber, or Citus who shard and distribute the database to any scale, or pgembedding to give AI chatbots long term memory, and the list goes on. To get started, you can download and install it locally, or better yet, use a free cloud database like Neon, which provides auto scaling out the box and a nice UI to manage your data, in addition to a bunch of other advanced features like branching. Create a new database, then head over to the SQL editor to run your first query, or connect it to your IDE UE with an extension like SQL Tools.

We could get started by creating a new table, but because this is an object relational database, let's begin by creating a custom data type, which defines the structure of object with corresponding properties and types. What's awesome about Postgres though is that we have more exotic data modeling options. Like, arrays can be used by putting brackets in front of a type, then make it a 2 dimensional array by adding another set of brackets. We also have JSON data types to handle unstructured data and even key uvaluepairs with extensions like h store. Now that we have this custom type, we can use it within 1 or more tables, like one table for programmers and another for designers.

Once the table is created, we can then use an insert statement to add a row of data into it. Notice the use of a double colon to cast a estring into JSON or h store types. And now finally, we can read the data with a select statement that uses dot notation to access the properties on our custom object. Every table has a unique primary key, and we can create relationships by storing the primary key from one table as the foreign key on another, like a programmer might own many Lambos. We can then find those Lambos by doing a join query that compares the programmer's ID to the Lambos owner ID.

This has been PostgreSQL in in 100 seconds. Big shout out to NeonDB for sponsoring and making this awesome database free to use in the cloud. Thanks for watching and I will see you in the next one.
PostgreSQL, the most trusted name in open source relational databases. Its development dates all the way back to 1986 at UC Berkeley under the direction of Michael Stonebraker. Like other pure relational databases, it stores data in tables, columns, and rows, and uses structured query language to read and write data. However, Postgres is technically an object relational database, which means it can create its own custom data types to store objects with properties use and support advanced features like inheritance and polymorphism. When writing data, it runs fully ACID compliant transactions, but also adds its own special sauce called multi version concurrency control, which gives each transaction a snapshot of the database, allowing multiple transactions to run at the same time without traffic jams or locks. Developers also love its extensibility. Queries can be reused by writing stored procedures, and it even supports languages beyond SQL like Python and C. And it has a robust ecosystem of mentions, like PostGIS to provide geospatial data for apps like Uber, or Citus who shard and distribute the database to any scale, or pgembedding to give AI chatbots long term memory, and the list goes on. To get started, you can download and install it locally, or better yet, use a free cloud database like Neon, which provides auto scaling out the box and a nice UI to manage your data, in addition to a bunch of other advanced features like branching. Create a new database, then head over to the SQL editor to run your first query, or connect it to your IDE UE with an extension like SQL Tools. We could get started by creating a new table, but because this is an object relational database, let's begin by creating a custom data type, which defines the structure of object with corresponding properties and types. What's awesome about Postgres though is that we have more exotic data modeling options.
databases
software
data management
data
software development
programming
microsoft
Like, arrays can be used by putting brackets in front of a type, then make it a 2 dimensional array by adding another set of brackets.
We also have JSON data types to handle unstructured data and even key uvaluepairs with extensions like h store. Now that we have this custom type, we can use it within 1 or more tables, like one table for programmers and another for designers. Once the table is created, we can then use an insert statement to add a row of data into it.
databases
data management
data
Notice the use of a double colon to cast a estring into JSON or h store types.
And now finally, we can read the data with a select statement that uses dot notation to access the properties on our custom object. Every table has a unique primary key, and we can create relationships by storing the primary key from one table as the foreign key on another, like a programmer might own many Lambos. We can then find those Lambos by doing a join query that compares the programmer's ID to the Lambos owner ID. This has been PostgreSQL in in 100 seconds. Big shout out to NeonDB for sponsoring and making this awesome database free to use in the cloud. Thanks for watching and I will see you in the next one.
databases
data
PostgreSQL, the most trusted name in open source relational databases. Its development dates all the way back to 1986 at UC Berkeley under the direction of Michael Stonebraker. Like other pure relational databases, it stores data in tables, columns, and rows, and uses structured query language to read and write data. However, Postgres is technically an object relational database, which means it can create its own custom data types to store objects with properties use and support advanced features like inheritance and polymorphism. When writing data, it runs fully ACID compliant transactions, but also adds its own special sauce called multi version concurrency control, which gives each transaction a snapshot of the database, allowing multiple transactions to run at the same time without traffic jams or locks. Developers also love its extensibility. Queries can be reused by writing stored procedures, and it even supports languages beyond SQL like Python and C. And it has a robust ecosystem of mentions, like PostGIS to provide geospatial data for apps like Uber, or Citus who shard and distribute the database to any scale, or pgembedding to give AI chatbots long term memory, and the list goes on. To get started, you can download and install it locally, or better yet, use a free cloud database like Neon, which provides auto scaling out the box and a nice UI to manage your data, in addition to a bunch of other advanced features like branching. Create a new database, then head over to the SQL editor to run your first query, or connect it to your IDE UE with an extension like SQL Tools. We could get started by creating a new table, but because this is an object relational database, let's begin by creating a custom data type, which defines the structure of object with corresponding properties and types. What's awesome about Postgres though is that we have more exotic data modeling options. Like, arrays can be used by putting brackets in front of a type, then make it a 2 dimensional array by adding another set of brackets. We also have JSON data types to handle unstructured data and even key uvaluepairs with extensions like h store. Now that we have this custom type, we can use it within 1 or more tables, like one table for programmers and another for designers. Once the table is created, we can then use an insert statement to add a row of data into it. Notice the use of a double colon to cast a estring into JSON or h store types. And now finally, we can read the data with a select statement that uses dot notation to access the properties on our custom object. Every table has a unique primary key, and we can create relationships by storing the primary key from one table as the foreign key on another, like a programmer might own many Lambos. We can then find those Lambos by doing a join query that compares the programmer's ID to the Lambos owner ID. This has been PostgreSQL in in 100 seconds. Big shout out to NeonDB for sponsoring and making this awesome database free to use in the cloud. Thanks for watching and I will see you in the next one.
PostgreSQL,
postgresql
the
the
most
most
trusted
trusted
name
name
in
in
open
open
source
source
relational
relational
databases.
databases
Its
its
development
development
dates
dates
all
all
the
the
way
way
back
back
to
to
1986
1986
at
at
UC
uc
Berkeley
berkeley
under
under
the
the
direction
direction
of
of
Michael
michael
Stonebraker.
stonebraker
Like
like
other
other
pure
pure
relational
relational
databases,
databases
it
it
stores
stores
data
data
in
in
tables,
tables
columns,
columns
and
and
rows,
rows
and
and
uses
uses
structured
structured
query
query
language
language
to
to
read
read
and
and
write
write
data.
data
However,
however
Postgres
postgres
is
is
technically
technically
an
an
object
object
relational
relational
database,
database
which
which
means
means
it
it
can
can
create
create
its
its
own
own
custom
custom
data
data
types
types
to
to
store
store
objects
objects
with
with
properties
properties
use
use
and
and
support
support
advanced
advanced
features
features
like
like
inheritance
inheritance
and
and
polymorphism.
polymorphism
When
when
writing
writing
data,
data
it
it
runs
runs
fully
fully
ACID
acid
compliant
compliant
transactions,
transactions
but
but
also
also
adds
adds
its
its
own
own
special
special
sauce
sauce
called
called
multi
multi
version
version
concurrency
concurrency
control,
control
which
which
gives
gives
each
each
transaction
transaction
a
a
snapshot
snapshot
of
of
the
the
database,
database
allowing
allowing
multiple
multiple
transactions
transactions
to
to
run
run
at
at
the
the
same
same
time
time
without
without
traffic
traffic
jams
jams
or
or
locks.
locks
Developers
developers
also
also
love
love
its
its
extensibility.
extensibility
Queries
queries
can
can
be
be
reused
reused
by
by
writing
writing
stored
stored
procedures,
procedures
and
and
it
it
even
even
supports
supports
languages
languages
beyond
beyond
SQL
sql
like
like
Python
python
and
and
C.
c
And
and
it
it
has
has
a
a
robust
robust
ecosystem
ecosystem
of
of
mentions,
mentions
like
like
PostGIS
postgis
to
to
provide
provide
geospatial
geospatial
data
data
for
for
apps
apps
like
like
Uber,
uber
or
or
Citus
citus
who
who
shard
shard
and
and
distribute
distribute
the
the
database
database
to
to
any
any
scale,
scale
or
or
pgembedding
pgembedding
to
to
give
give
AI
ai
chatbots
chatbots
long
long
term
term
memory,
memory
and
and
the
the
list
list
goes
goes
on.
on
To
to
get
get
started,
started
you
you
can
can
download
download
and
and
install
install
it
it
locally,
locally
or
or
better
better
yet,
yet
use
use
a
a
free
free
cloud
cloud
database
database
like
like
Neon,
neon
which
which
provides
provides
auto
auto
scaling
scaling
out
out
the
the
box
box
and
and
a
a
nice
nice
UI
ui
to
to
manage
manage
your
your
data,
data
in
in
addition
addition
to
to
a
a
bunch
bunch
of
of
other
other
advanced
advanced
features
features
like
like
branching.
branching
Create
create
a
a
new
new
database,
database
then
then
head
head
over
over
to
to
the
the
SQL
sql
editor
editor
to
to
run
run
your
your
first
first
query,
query
or
or
connect
connect
it
it
to
to
your
your
IDE
ide
UE
ue
with
with
an
an
extension
extension
like
like
SQL
sql
Tools.
tools
We
we
could
could
get
get
started
started
by
by
creating
creating
a
a
new
new
table,
table
but
but
because
because
this
this
is
is
an
an
object
object
relational
relational
database,
database
let's
let's
begin
begin
by
by
creating
creating
a
a
custom
custom
data
data
type,
type
which
which
defines
defines
the
the
structure
structure
of
of
object
object
with
with
corresponding
corresponding
properties
properties
and
and
types.
types
What's
what's
awesome
awesome
about
about
Postgres
postgres
though
though
is
is
that
that
we
we
have
have
more
more
exotic
exotic
data
data
modeling
modeling
options.
options
Like,
like
arrays
arrays
can
can
be
be
used
used
by
by
putting
putting
brackets
brackets
in
in
front
front
of
of
a
a
type,
type
then
then
make
make
it
it
a
a
2
2
dimensional
dimensional
array
array
by
by
adding
adding
another
another
set
set
of
of
brackets.
brackets
We
we
also
also
have
have
JSON
json
data
data
types
types
to
to
handle
handle
unstructured
unstructured
data
data
and
and
even
even
key
key
uvaluepairs
uvaluepairs
with
with
extensions
extensions
like
like
h
h
store.
store
Now
now
that
that
we
we
have
have
this
this
custom
custom
type,
type
we
we
can
can
use
use
it
it
within
within
1
1
or
or
more
more
tables,
tables
like
like
one
one
table
table
for
for
programmers
programmers
and
and
another
another
for
for
designers.
designers
Once
once
the
the
table
table
is
is
created,
created
we
we
can
can
then
then
use
use
an
an
insert
insert
statement
statement
to
to
add
add
a
a
row
row
of
of
data
data
into
into
it.
it
Notice
notice
the
the
use
use
of
of
a
a
double
double
colon
colon
to
to
cast
cast
a
a
estring
estring
into
into
JSON
json
or
or
h
h
store
store
types.
types
And
and
now
now
finally,
finally
we
we
can
can
read
read
the
the
data
data
with
with
a
a
select
select
statement
statement
that
that
uses
uses
dot
dot
notation
notation
to
to
access
access
the
the
properties
properties
on
on
our
our
custom
custom
object.
object
Every
every
table
table
has
has
a
a
unique
unique
primary
primary
key,
key
and
and
we
we
can
can
create
create
relationships
relationships
by
by
storing
storing
the
the
primary
primary
key
key
from
from
one
one
table
table
as
as
the
the
foreign
foreign
key
key
on
on
another,
another
like
like
a
a
programmer
programmer
might
might
own
own
many
many
Lambos.
lambos
We
we
can
can
then
then
find
find
those
those
Lambos
lambos
by
by
doing
doing
a
a
join
join
query
query
that
that
compares
compares
the
the
programmer's
programmer's
ID
id
to
to
the
the
Lambos
lambos
owner
owner
ID.
id
This
this
has
has
been
been
PostgreSQL
postgresql
in
in
in
in
100
100
seconds.
seconds
Big
big
shout
shout
out
out
to
to
NeonDB
neondb
for
for
sponsoring
sponsoring
and
and
making
making
this
this
awesome
awesome
database
database
free
free
to
to
use
use
in
in
the
the
cloud.
cloud
Thanks
thanks
for
for
watching
watching
and
and
I
i
will
will
see
see
you
you
in
in
the
the
next
next
one.
one
success
In this video, a speaker explains the benefits of using Postgres as an object thirteen databases, including its use of structured query language and multi-factor concurrency control. They also discuss the use of Postgres for various database types and its ecosystem of mentions. The speaker then explains how to create a new table and use it to read and write data, and how to access and save data using a specific command. They also mention the use of a free cloud database called NeonDB for sponsoring and making this database free to use in the cloud.
PostgreSQL in 100 Seconds
PostgreSQL, the most trusted name in open source relational databases. Its development dates all the way back to 1986 at UC Berkeley under the direction of Michael Stonebraker. Like other pure relational databases, it stores data in tables, columns, and rows, and uses structured query language to read and write data. However, Postgres is technically an object relational database, which means it can create its own custom data types to store objects with properties use and support advanced features like inheritance and polymorphism. When writing data, it runs fully ACID compliant transactions, but also adds its own special sauce called multi version concurrency control, which gives each transaction a snapshot of the database, allowing multiple transactions to run at the same time without traffic jams or locks. Developers also love its extensibility. Queries can be reused by writing stored procedures, and it even supports languages beyond SQL like Python and C. And it has a robust ecosystem of mentions, like PostGIS to provide geospatial data for apps like Uber, or Citus who shard and distribute the database to any scale, or pgembedding to give AI chatbots long term memory, and the list goes on. To get started, you can download and install it locally, or better yet, use a free cloud database like Neon, which provides auto scaling out the box and a nice UI to manage your data, in addition to a bunch of other advanced features like branching. Create a new database, then head over to the SQL editor to run your first query, or connect it to your IDE UE with an extension like SQL Tools. We could get started by creating a new table, but because this is an object relational database, let's begin by creating a custom data type, which defines the structure of object with corresponding properties and types. What's awesome about Postgres though is that we have more exotic data modeling options. Like, arrays can be used by putting brackets in front of a type, then make it a 2 dimensional array by adding another set of brackets. We also have JSON data types to handle unstructured data and even key uvaluepairs with extensions like h store. Now that we have this custom type, we can use it within 1 or more tables, like one table for programmers and another for designers. Once the table is created, we can then use an insert statement to add a row of data into it. Notice the use of a double colon to cast a estring into JSON or h store types. And now finally, we can read the data with a select statement that uses dot notation to access the properties on our custom object. Every table has a unique primary key, and we can create relationships by storing the primary key from one table as the foreign key on another, like a programmer might own many Lambos. We can then find those Lambos by doing a join query that compares the programmer's ID to the Lambos owner ID. This has been PostgreSQL in in 100 seconds. Big shout out to NeonDB for sponsoring and making this awesome database free to use in the cloud. Thanks for watching and I will see you in the next one.
In this video, a speaker explains the benefits of using Postgres as an object thirteen databases, including its use of structured query language and multi-factor concurrency control. They also discuss the use of Postgres for various database types and its ecosystem of mentions. The speaker then explains how to create a new table and use it to read and write data, and how to access and save data using a specific command. They also mention the use of a free cloud database called NeonDB for sponsoring and making this database free to use in the cloud.

        [INST]
        You are youtuber called Fireship you make engaging high-intensity and entertaining coding tutorials and tech news. 
        you covers a wide range of topics relevant to programmers, aiming to help them learn and improve their skills quickly.
        
        Given the title of the video : PostgreSQL in 100 Seconds 
        and a small summary : In this video, a speaker explains the benefits of using Postgres as an object thirteen databases, including its use of structured query language and multi-factor concurrency control. They also discuss the use of Postgres for various database types and its ecosystem of mentions. The speaker then explains how to create a new table and use it to read and write data, and how to access and save data using a specific command. They also mention the use of a free cloud database called NeonDB for sponsoring and making this database free to use in the cloud.
        [/INST]
        
        Generate the video : PostgreSQL, the most trusted name in open source relational databases. Its development dates all the way back to 1986 at UC Berkeley under the direction of Michael Stonebraker. Like other pure relational databases, it stores data in tables, columns, and rows, and uses structured query language to read and write data. However, Postgres is technically an object relational database, which means it can create its own custom data types to store objects with properties use and support advanced features like inheritance and polymorphism. When writing data, it runs fully ACID compliant transactions, but also adds its own special sauce called multi version concurrency control, which gives each transaction a snapshot of the database, allowing multiple transactions to run at the same time without traffic jams or locks. Developers also love its extensibility. Queries can be reused by writing stored procedures, and it even supports languages beyond SQL like Python and C. And it has a robust ecosystem of mentions, like PostGIS to provide geospatial data for apps like Uber, or Citus who shard and distribute the database to any scale, or pgembedding to give AI chatbots long term memory, and the list goes on. To get started, you can download and install it locally, or better yet, use a free cloud database like Neon, which provides auto scaling out the box and a nice UI to manage your data, in addition to a bunch of other advanced features like branching. Create a new database, then head over to the SQL editor to run your first query, or connect it to your IDE UE with an extension like SQL Tools. We could get started by creating a new table, but because this is an object relational database, let's begin by creating a custom data type, which defines the structure of object with corresponding properties and types. What's awesome about Postgres though is that we have more exotic data modeling options. Like, arrays can be used by putting brackets in front of a type, then make it a 2 dimensional array by adding another set of brackets. We also have JSON data types to handle unstructured data and even key uvaluepairs with extensions like h store. Now that we have this custom type, we can use it within 1 or more tables, like one table for programmers and another for designers. Once the table is created, we can then use an insert statement to add a row of data into it. Notice the use of a double colon to cast a estring into JSON or h store types. And now finally, we can read the data with a select statement that uses dot notation to access the properties on our custom object. Every table has a unique primary key, and we can create relationships by storing the primary key from one table as the foreign key on another, like a programmer might own many Lambos. We can then find those Lambos by doing a join query that compares the programmer's ID to the Lambos owner ID. This has been PostgreSQL in in 100 seconds. Big shout out to NeonDB for sponsoring and making this awesome database free to use in the cloud. Thanks for watching and I will see you in the next one.
        