SurrealDB is a "NewSQL" multi-model database with an impressive list of features from popular relational, graph, and document paradigms. Its query language is based on SQL, but does not rely on JOINs for queries. 

Full Tutorial Coming Soon on Beyond Fireship  https://www.youtube.com/channel/UC2Xd-TjJByJyK2w1zNwY0zQ

#database #programming #100SecondsOfCode 

🔗 Resources

SurrealDB Github https://github.com/surrealdb/surrealdb
Surreal Docs https://surrealdb.com/
SQL in 100 Seconds https://youtu.be/zsjvFFKOm3c
7 Database Paradigms https://youtu.be/W2Z7fbCLSTw

🔥 Get More Content - Upgrade to PRO

Upgrade to Fireship PRO at https://fireship.io/pro
Use code lORhwXd2 for 25% off your first payment. 

🎨 My Editor Settings

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

🔖 Topics Covered

- What is SurrealDB? 
- Is SurrealDB legit?
- Databases written in Rust
- Multi-model databases
- What is the best database? 
- Database with realtime updates
2024-02-04T05:19:57.439Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
680f744a-a224-4b39-a80a-249a52d1b1a3
15e2a800b750dce30c3281c5aa10bbfacc29e2c11df9cdc2607339717d4dd3e5
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
Surreal DB, an open source new SQL database that delivers every feature you've ever dreamed of.
ACID, scalable, full text search, real time, graph, relational, multi tenant, temporal, schema less, schema full, server less, embedded are all words that can describe SurrealDB.
A multi model database that combines elements of relational graph and document paradigms into a simple package that can be queried with an SQL like language.
Development It was started by Jamie and Toby Morgan Hitchcock in 2015, and it was open sourced in July 2022.
The engine is written in Rust and can support multiple sense layers like Ty KB to scale horizontally in the cloud or as a single node both in memory or on disk.
Most importantly though, it can handle complex relationships like traditional relational databases, but does so without Joins.
Instead, it uses techniques like record links and graph connections that not only handle complex data models, but also result in concise developer friendly code.
By default, it's schema less, which means you can implicitly create unstructured true data in any table.
However, you can opt into schema full tables when the data model becomes well defined.
It's also ACID compliant, allowing you to run transactions across multiple tables, which also emit events when the data changes, so you can listen to real time updates from a front end application, kind of like Fire database, and the feature list goes on with things like geospatial data and predefined analytics views, all of which can be locked down with permissions out of the box.
To get started, install it on your machine, then run it locally with the CLI, then execute code using its rest API or a client library for your favorite language.
It's just like SQL.
We can use statements like create to add a record to the database.
Every record has a unique ID comprised of 2 parts.
The left side is the table the record belongs to, and the right side can be whatever you want, or if left out, it will be automatically generated.
And now use set to define the data before that record, or try content for a more JSON like syntax.
Now that we have some data populated, we can query it with a select statement.
It supports the where clause to filter by a condition, and has a variety of built in functions like count to fetch aggregate data or is to validate common data formats like an email.
And if that's not enough, you can even embed your own JavaScript logic directly into a query.
But remember, there are no joins in the surreal life.
Instead of foreign keys, Record IDs can be stored in any other record.
That makes it possible to query that data using a simple select statement that uses dot notation to specify the fields that should be joined in.
That takes care of most relationships, but you can even add graph edges between records using the relate statement.
You can now query This data efficiently using arrows to traverse between nodes and edges.
This has been surreal DB in 100 seconds.
If you wanna go beyond 100 seconds, check out my new channel, Beyond Fire shit, where I'll be taking you on an extended surreal journey.
Thanks for watching, and I will see you in the next one.

Speaker 0: Surreal DB, an open source new SQL database that delivers every feature you've ever dreamed of. ACID, scalable, full text search, real time, graph, relational, multi tenant, temporal, schema less, schema full, server less, embedded are all words that can describe SurrealDB. A multi model database that combines elements of relational graph and document paradigms into a simple package that can be queried with an SQL like language. Development It was started by Jamie and Toby Morgan Hitchcock in 2015, and it was open sourced in July 2022. The engine is written in Rust and can support multiple sense layers like Ty KB to scale horizontally in the cloud or as a single node both in memory or on disk.

Most importantly though, it can handle complex relationships like traditional relational databases, but does so without Joins. Instead, it uses techniques like record links and graph connections that not only handle complex data models, but also result in concise developer friendly code. By default, it's schema less, which means you can implicitly create unstructured true data in any table. However, you can opt into schema full tables when the data model becomes well defined. It's also ACID compliant, allowing you to run transactions across multiple tables, which also emit events when the data changes, so you can listen to real time updates from a front end application, kind of like Fire database, and the feature list goes on with things like geospatial data and predefined analytics views, all of which can be locked down with permissions out of the box.

To get started, install it on your machine, then run it locally with the CLI, then execute code using its rest API or a client library for your favorite language. It's just like SQL. We can use statements like create to add a record to the database. Every record has a unique ID comprised of 2 parts. The left side is the table the record belongs to, and the right side can be whatever you want, or if left out, it will be automatically generated.

And now use set to define the data before that record, or try content for a more JSON like syntax. Now that we have some data populated, we can query it with a select statement. It supports the where clause to filter by a condition, and has a variety of built in functions like count to fetch aggregate data or is to validate common data formats like an email. And if that's not enough, you can even embed your own JavaScript logic directly into a query. But remember, there are no joins in the surreal life.

Instead of foreign keys, Record IDs can be stored in any other record. That makes it possible to query that data using a simple select statement that uses dot notation to specify the fields that should be joined in. That takes care of most relationships, but you can even add graph edges between records using the relate statement. You can now query This data efficiently using arrows to traverse between nodes and edges. This has been surreal DB in 100 seconds.

If you wanna go beyond 100 seconds, check out my new channel, Beyond Fire shit, where I'll be taking you on an extended surreal journey. Thanks for watching, and I will see you in the next one.
Surreal DB, an open source new SQL database that delivers every feature you've ever dreamed of. ACID, scalable, full text search, real time, graph, relational, multi tenant, temporal, schema less, schema full, server less, embedded are all words that can describe SurrealDB. A multi model database that combines elements of relational graph and document paradigms into a simple package that can be queried with an SQL like language. Development It was started by Jamie and Toby Morgan Hitchcock in 2015, and it was open sourced in July 2022. The engine is written in Rust and can support multiple sense layers like Ty KB to scale horizontally in the cloud or as a single node both in memory or on disk. Most importantly though, it can handle complex relationships like traditional relational databases, but does so without Joins. Instead, it uses techniques like record links and graph connections that not only handle complex data models, but also result in concise developer friendly code. By default, it's schema less, which means you can implicitly create unstructured true data in any table. However, you can opt into schema full tables when the data model becomes well defined. It's also ACID compliant, allowing you to run transactions across multiple tables, which also emit events when the data changes, so you can listen to real time updates from a front end application, kind of like Fire database, and the feature list goes on with things like geospatial data and predefined analytics views, all of which can be locked down with permissions out of the box. To get started, install it on your machine, then run it locally with the CLI, then execute code using its rest API or a client library for your favorite language. It's just like SQL. We can use statements like create to add a record to the database. Every record has a unique ID comprised of 2 parts. The left side is the table the record belongs to, and the right side can be whatever you want, or if left out, it will be automatically generated. And now use set to define the data before that record, or try content for a more JSON like syntax. Now that we have some data populated, we can query it with a select statement. It supports the where clause to filter by a condition, and has a variety of built in functions like count to fetch aggregate data or is to validate common data formats like an email. And if that's not enough, you can even embed your own JavaScript logic directly into a query.
databases
data management
data
programming
software development
software
But remember, there are no joins in the surreal life.
Instead of foreign keys, Record IDs can be stored in any other record. That makes it possible to query that data using a simple select statement that uses dot notation to specify the fields that should be joined in. That takes care of most relationships, but you can even add graph edges between records using the relate statement.
databases
data
You can now query This data efficiently using arrows to traverse between nodes and edges. This has been surreal DB in 100 seconds. If you wanna go beyond 100 seconds, check out my new channel, Beyond Fire shit, where I'll be taking you on an extended surreal journey. Thanks for watching, and I will see you in the next one.
Surreal DB, an open source new SQL database that delivers every feature you've ever dreamed of. ACID, scalable, full text search, real time, graph, relational, multi tenant, temporal, schema less, schema full, server less, embedded are all words that can describe SurrealDB. A multi model database that combines elements of relational graph and document paradigms into a simple package that can be queried with an SQL like language. Development It was started by Jamie and Toby Morgan Hitchcock in 2015, and it was open sourced in July 2022. The engine is written in Rust and can support multiple sense layers like Ty KB to scale horizontally in the cloud or as a single node both in memory or on disk. Most importantly though, it can handle complex relationships like traditional relational databases, but does so without Joins. Instead, it uses techniques like record links and graph connections that not only handle complex data models, but also result in concise developer friendly code. By default, it's schema less, which means you can implicitly create unstructured true data in any table. However, you can opt into schema full tables when the data model becomes well defined. It's also ACID compliant, allowing you to run transactions across multiple tables, which also emit events when the data changes, so you can listen to real time updates from a front end application, kind of like Fire database, and the feature list goes on with things like geospatial data and predefined analytics views, all of which can be locked down with permissions out of the box. To get started, install it on your machine, then run it locally with the CLI, then execute code using its rest API or a client library for your favorite language. It's just like SQL. We can use statements like create to add a record to the database. Every record has a unique ID comprised of 2 parts. The left side is the table the record belongs to, and the right side can be whatever you want, or if left out, it will be automatically generated. And now use set to define the data before that record, or try content for a more JSON like syntax. Now that we have some data populated, we can query it with a select statement. It supports the where clause to filter by a condition, and has a variety of built in functions like count to fetch aggregate data or is to validate common data formats like an email. And if that's not enough, you can even embed your own JavaScript logic directly into a query. But remember, there are no joins in the surreal life. Instead of foreign keys, Record IDs can be stored in any other record. That makes it possible to query that data using a simple select statement that uses dot notation to specify the fields that should be joined in. That takes care of most relationships, but you can even add graph edges between records using the relate statement. You can now query This data efficiently using arrows to traverse between nodes and edges. This has been surreal DB in 100 seconds. If you wanna go beyond 100 seconds, check out my new channel, Beyond Fire shit, where I'll be taking you on an extended surreal journey. Thanks for watching, and I will see you in the next one.
Surreal
surreal
DB,
db
an
an
open
open
source
source
new
new
SQL
sql
database
database
that
that
delivers
delivers
every
every
feature
feature
you've
you've
ever
ever
dreamed
dreamed
of.
of
ACID,
acid
scalable,
scalable
full
full
text
text
search,
search
real
real
time,
time
graph,
graph
relational,
relational
multi
multi
tenant,
tenant
temporal,
temporal
schema
schema
less,
less
schema
schema
full,
full
server
server
less,
less
embedded
embedded
are
are
all
all
words
words
that
that
can
can
describe
describe
SurrealDB.
surrealdb
A
a
multi
multi
model
model
database
database
that
that
combines
combines
elements
elements
of
of
relational
relational
graph
graph
and
and
document
document
paradigms
paradigms
into
into
a
a
simple
simple
package
package
that
that
can
can
be
be
queried
queried
with
with
an
an
SQL
sql
like
like
language.
language
Development
development
It
it
was
was
started
started
by
by
Jamie
jamie
and
and
Toby
toby
Morgan
morgan
Hitchcock
hitchcock
in
in
2015,
2015
and
and
it
it
was
was
open
open
sourced
sourced
in
in
July
july
2022.
2022
The
the
engine
engine
is
is
written
written
in
in
Rust
rust
and
and
can
can
support
support
multiple
multiple
sense
sense
layers
layers
like
like
Ty
ty
KB
kb
to
to
scale
scale
horizontally
horizontally
in
in
the
the
cloud
cloud
or
or
as
as
a
a
single
single
node
node
both
both
in
in
memory
memory
or
or
on
on
disk.
disk
Most
most
importantly
importantly
though,
though
it
it
can
can
handle
handle
complex
complex
relationships
relationships
like
like
traditional
traditional
relational
relational
databases,
databases
but
but
does
does
so
so
without
without
Joins.
joins
Instead,
instead
it
it
uses
uses
techniques
techniques
like
like
record
record
links
links
and
and
graph
graph
connections
connections
that
that
not
not
only
only
handle
handle
complex
complex
data
data
models,
models
but
but
also
also
result
result
in
in
concise
concise
developer
developer
friendly
friendly
code.
code
By
by
default,
default
it's
it's
schema
schema
less,
less
which
which
means
means
you
you
can
can
implicitly
implicitly
create
create
unstructured
unstructured
true
true
data
data
in
in
any
any
table.
table
However,
however
you
you
can
can
opt
opt
into
into
schema
schema
full
full
tables
tables
when
when
the
the
data
data
model
model
becomes
becomes
well
well
defined.
defined
It's
it's
also
also
ACID
acid
compliant,
compliant
allowing
allowing
you
you
to
to
run
run
transactions
transactions
across
across
multiple
multiple
tables,
tables
which
which
also
also
emit
emit
events
events
when
when
the
the
data
data
changes,
changes
so
so
you
you
can
can
listen
listen
to
to
real
real
time
time
updates
updates
from
from
a
a
front
front
end
end
application,
application
kind
kind
of
of
like
like
Fire
fire
database,
database
and
and
the
the
feature
feature
list
list
goes
goes
on
on
with
with
things
things
like
like
geospatial
geospatial
data
data
and
and
predefined
predefined
analytics
analytics
views,
views
all
all
of
of
which
which
can
can
be
be
locked
locked
down
down
with
with
permissions
permissions
out
out
of
of
the
the
box.
box
To
to
get
get
started,
started
install
install
it
it
on
on
your
your
machine,
machine
then
then
run
run
it
it
locally
locally
with
with
the
the
CLI,
cli
then
then
execute
execute
code
code
using
using
its
its
rest
rest
API
api
or
or
a
a
client
client
library
library
for
for
your
your
favorite
favorite
language.
language
It's
it's
just
just
like
like
SQL.
sql
We
we
can
can
use
use
statements
statements
like
like
create
create
to
to
add
add
a
a
record
record
to
to
the
the
database.
database
Every
every
record
record
has
has
a
a
unique
unique
ID
id
comprised
comprised
of
of
2
2
parts.
parts
The
the
left
left
side
side
is
is
the
the
table
table
the
the
record
record
belongs
belongs
to,
to
and
and
the
the
right
right
side
side
can
can
be
be
whatever
whatever
you
you
want,
want
or
or
if
if
left
left
out,
out
it
it
will
will
be
be
automatically
automatically
generated.
generated
And
and
now
now
use
use
set
set
to
to
define
define
the
the
data
data
before
before
that
that
record,
record
or
or
try
try
content
content
for
for
a
a
more
more
JSON
json
like
like
syntax.
syntax
Now
now
that
that
we
we
have
have
some
some
data
data
populated,
populated
we
we
can
can
query
query
it
it
with
with
a
a
select
select
statement.
statement
It
it
supports
supports
the
the
where
where
clause
clause
to
to
filter
filter
by
by
a
a
condition,
condition
and
and
has
has
a
a
variety
variety
of
of
built
built
in
in
functions
functions
like
like
count
count
to
to
fetch
fetch
aggregate
aggregate
data
data
or
or
is
is
to
to
validate
validate
common
common
data
data
formats
formats
like
like
an
an
email.
email
And
and
if
if
that's
that's
not
not
enough,
enough
you
you
can
can
even
even
embed
embed
your
your
own
own
JavaScript
javascript
logic
logic
directly
directly
into
into
a
a
query.
query
But
but
remember,
remember
there
there
are
are
no
no
joins
joins
in
in
the
the
surreal
surreal
life.
life
Instead
instead
of
of
foreign
foreign
keys,
keys
Record
record
IDs
ids
can
can
be
be
stored
stored
in
in
any
any
other
other
record.
record
That
that
makes
makes
it
it
possible
possible
to
to
query
query
that
that
data
data
using
using
a
a
simple
simple
select
select
statement
statement
that
that
uses
uses
dot
dot
notation
notation
to
to
specify
specify
the
the
fields
fields
that
that
should
should
be
be
joined
joined
in.
in
That
that
takes
takes
care
care
of
of
most
most
relationships,
relationships
but
but
you
you
can
can
even
even
add
add
graph
graph
edges
edges
between
between
records
records
using
using
the
the
relate
relate
statement.
statement
You
you
can
can
now
now
query
query
This
this
data
data
efficiently
efficiently
using
using
arrows
arrows
to
to
traverse
traverse
between
between
nodes
nodes
and
and
edges.
edges
This
this
has
has
been
been
surreal
surreal
DB
db
in
in
100
100
seconds.
seconds
If
if
you
you
wanna
wanna
go
go
beyond
beyond
100
100
seconds,
seconds
check
check
out
out
my
my
new
new
channel,
channel
Beyond
beyond
Fire
fire
shit,
shit
where
where
I'll
i'll
be
be
taking
taking
you
you
on
on
an
an
extended
extended
surreal
surreal
journey.
journey
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 representative explains the benefits of Surreal DB, an open source new SQL database that combines various features into a single package. It is multi-channel, ACID compliant, and can handle complex relationships. It is also flexible and allows for efficient queries and builds in functions. It is also multi-channel and has been built into a new channel called Beyond Fire shit.
SurrealDB in 100 Seconds
Surreal DB, an open source new SQL database that delivers every feature you've ever dreamed of. ACID, scalable, full text search, real time, graph, relational, multi tenant, temporal, schema less, schema full, server less, embedded are all words that can describe SurrealDB. A multi model database that combines elements of relational graph and document paradigms into a simple package that can be queried with an SQL like language. Development It was started by Jamie and Toby Morgan Hitchcock in 2015, and it was open sourced in July 2022. The engine is written in Rust and can support multiple sense layers like Ty KB to scale horizontally in the cloud or as a single node both in memory or on disk. Most importantly though, it can handle complex relationships like traditional relational databases, but does so without Joins. Instead, it uses techniques like record links and graph connections that not only handle complex data models, but also result in concise developer friendly code. By default, it's schema less, which means you can implicitly create unstructured true data in any table. However, you can opt into schema full tables when the data model becomes well defined. It's also ACID compliant, allowing you to run transactions across multiple tables, which also emit events when the data changes, so you can listen to real time updates from a front end application, kind of like Fire database, and the feature list goes on with things like geospatial data and predefined analytics views, all of which can be locked down with permissions out of the box. To get started, install it on your machine, then run it locally with the CLI, then execute code using its rest API or a client library for your favorite language. It's just like SQL. We can use statements like create to add a record to the database. Every record has a unique ID comprised of 2 parts. The left side is the table the record belongs to, and the right side can be whatever you want, or if left out, it will be automatically generated. And now use set to define the data before that record, or try content for a more JSON like syntax. Now that we have some data populated, we can query it with a select statement. It supports the where clause to filter by a condition, and has a variety of built in functions like count to fetch aggregate data or is to validate common data formats like an email. And if that's not enough, you can even embed your own JavaScript logic directly into a query. But remember, there are no joins in the surreal life. Instead of foreign keys, Record IDs can be stored in any other record. That makes it possible to query that data using a simple select statement that uses dot notation to specify the fields that should be joined in. That takes care of most relationships, but you can even add graph edges between records using the relate statement. You can now query This data efficiently using arrows to traverse between nodes and edges. This has been surreal DB in 100 seconds. If you wanna go beyond 100 seconds, check out my new channel, Beyond Fire shit, where I'll be taking you on an extended surreal journey. Thanks for watching, and I will see you in the next one.
In this video, a representative explains the benefits of Surreal DB, an open source new SQL database that combines various features into a single package. It is multi-channel, ACID compliant, and can handle complex relationships. It is also flexible and allows for efficient queries and builds in functions. It is also multi-channel and has been built into a new channel called Beyond Fire shit.

        [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 : SurrealDB in 100 Seconds 
        and a small summary : In this video, a representative explains the benefits of Surreal DB, an open source new SQL database that combines various features into a single package. It is multi-channel, ACID compliant, and can handle complex relationships. It is also flexible and allows for efficient queries and builds in functions. It is also multi-channel and has been built into a new channel called Beyond Fire shit.
        [/INST]
        
        Generate the video : Surreal DB, an open source new SQL database that delivers every feature you've ever dreamed of. ACID, scalable, full text search, real time, graph, relational, multi tenant, temporal, schema less, schema full, server less, embedded are all words that can describe SurrealDB. A multi model database that combines elements of relational graph and document paradigms into a simple package that can be queried with an SQL like language. Development It was started by Jamie and Toby Morgan Hitchcock in 2015, and it was open sourced in July 2022. The engine is written in Rust and can support multiple sense layers like Ty KB to scale horizontally in the cloud or as a single node both in memory or on disk. Most importantly though, it can handle complex relationships like traditional relational databases, but does so without Joins. Instead, it uses techniques like record links and graph connections that not only handle complex data models, but also result in concise developer friendly code. By default, it's schema less, which means you can implicitly create unstructured true data in any table. However, you can opt into schema full tables when the data model becomes well defined. It's also ACID compliant, allowing you to run transactions across multiple tables, which also emit events when the data changes, so you can listen to real time updates from a front end application, kind of like Fire database, and the feature list goes on with things like geospatial data and predefined analytics views, all of which can be locked down with permissions out of the box. To get started, install it on your machine, then run it locally with the CLI, then execute code using its rest API or a client library for your favorite language. It's just like SQL. We can use statements like create to add a record to the database. Every record has a unique ID comprised of 2 parts. The left side is the table the record belongs to, and the right side can be whatever you want, or if left out, it will be automatically generated. And now use set to define the data before that record, or try content for a more JSON like syntax. Now that we have some data populated, we can query it with a select statement. It supports the where clause to filter by a condition, and has a variety of built in functions like count to fetch aggregate data or is to validate common data formats like an email. And if that's not enough, you can even embed your own JavaScript logic directly into a query. But remember, there are no joins in the surreal life. Instead of foreign keys, Record IDs can be stored in any other record. That makes it possible to query that data using a simple select statement that uses dot notation to specify the fields that should be joined in. That takes care of most relationships, but you can even add graph edges between records using the relate statement. You can now query This data efficiently using arrows to traverse between nodes and edges. This has been surreal DB in 100 seconds. If you wanna go beyond 100 seconds, check out my new channel, Beyond Fire shit, where I'll be taking you on an extended surreal journey. Thanks for watching, and I will see you in the next one.
        