Apache Cassandra is a wide-column store NoSQL database designed to scale globally with extreme speed and reliability. Try it out for free with the serverless AstraDB http://astra.dev/cass100sec

#programming #database #100SecondOfCode

🔗 Resources

Use Cassandra with Astra http://astra.dev/cass100sec
Cassandra Docs https://cassandra.apache.org/doc/latest/

Related Databases: 

SQL in 100 Seconds https://youtu.be/zsjvFFKOm3c
Redis in 100 Seconds https://youtu.be/G1rOthIU-uo

🔥 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 Apache Cassandra ?
- SQL vs NoSQL
- Cassandra vs SQL
- Is Cassandra a good database?
- What is Cassandra used for?
- When was Cassandra created?
2024-02-04T05:23:43.318Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
1acb8093-b937-4346-874c-a7495202f798
2b4b0ea738d23a9dbe4b32df341d74855957016d8d6d860cc170217bf941f881
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
Cassandra, a wide column store NoSQL database famous for its ability to distribute petabytes of data with unmatched reliability and performance.
It was created in 2008 by Avinash Lakshman, who was responsible for scaling Facebook's inbox search feature.
By 2010, became a top level Apache project, and today is used at scale by big companies like Apple, which manages a staggering 100 petabytes of data across 100 of thousands of server instances.
It's a general purpose database with use cases for e commerce, content management, audit logging, and everything in between.
Each instance of Cassandra is called a node, and typically stores about 2 terabytes of data.
What makes it special though is that nodes can be easily distributed to scale horizontally.
Every node has the same read write capabilities of another node, but is responsible for its own partition of data.
Nodes are grouped together in a cluster or ring, and data is typically replicated on multiple nodes, which means no single point of failure and 100% uptime.
The data is wrapped in a key space, giving developers rule over how it replicates in the cluster.
Each key space contains 1 or more tables, which represent tabular data like you might find in a relational database.
However, it's schema less and can handle unstructured data, which developers can manage with the Cassandra Query Language.
The easiest way to get started is by creating a free server database with Astra.
It deploys to the cloud of your choice, then scales automatically on demand.
1st, we'll need to define a key space, which access a container for replication.
Next, we'll need to connect to the database, which can be accomplished in a variety of ways.
It has SDKs for major languages, and a tool called star that makes data accessible via REST, GraphQL, and gRPC.
Or you can execute raw CQL code, which is a subset of SQL.
Create a table and include a primary key to uniquely identify every row.
Then each column will have its own name and data type.
Now add data to that table with the insert into statement.
Then you to read data from the table.
It's also possible to use the where clause to filter and query the data, but an index will be required on the column.
On the surface, this may look a lot like a relational database, but it doesn't support Joins and that's by design.
Instead of modeling data into small normal tables, in Cassandra, it's denormalized to match the structure of known queries, making reads much faster at scale.
And it's also possible to implement storage attached indexing to handle complex relational queries.
This has been Cassandra in 100 seconds.
Rule.
Let me know if you wanna see a full tutorial in the comments.
Thanks for watching, and I will see you in the next one.

Speaker 0: Cassandra, a wide column store NoSQL database famous for its ability to distribute petabytes of data with unmatched reliability and performance. It was created in 2008 by Avinash Lakshman, who was responsible for scaling Facebook's inbox search feature. By 2010, became a top level Apache project, and today is used at scale by big companies like Apple, which manages a staggering 100 petabytes of data across 100 of thousands of server instances. It's a general purpose database with use cases for e commerce, content management, audit logging, and everything in between. Each instance of Cassandra is called a node, and typically stores about 2 terabytes of data.

What makes it special though is that nodes can be easily distributed to scale horizontally. Every node has the same read write capabilities of another node, but is responsible for its own partition of data. Nodes are grouped together in a cluster or ring, and data is typically replicated on multiple nodes, which means no single point of failure and 100% uptime. The data is wrapped in a key space, giving developers rule over how it replicates in the cluster. Each key space contains 1 or more tables, which represent tabular data like you might find in a relational database.

However, it's schema less and can handle unstructured data, which developers can manage with the Cassandra Query Language. The easiest way to get started is by creating a free server database with Astra. It deploys to the cloud of your choice, then scales automatically on demand. 1st, we'll need to define a key space, which access a container for replication. Next, we'll need to connect to the database, which can be accomplished in a variety of ways.

It has SDKs for major languages, and a tool called star that makes data accessible via REST, GraphQL, and gRPC. Or you can execute raw CQL code, which is a subset of SQL. Create a table and include a primary key to uniquely identify every row. Then each column will have its own name and data type. Now add data to that table with the insert into statement.

Then you to read data from the table. It's also possible to use the where clause to filter and query the data, but an index will be required on the column. On the surface, this may look a lot like a relational database, but it doesn't support Joins and that's by design. Instead of modeling data into small normal tables, in Cassandra, it's denormalized to match the structure of known queries, making reads much faster at scale. And it's also possible to implement storage attached indexing to handle complex relational queries.

This has been Cassandra in 100 seconds. Rule. Let me know if you wanna see a full tutorial in the comments. Thanks for watching, and I will see you in the next one.
Cassandra, a wide column store NoSQL database famous for its ability to distribute petabytes of data with unmatched reliability and performance. It was created in 2008 by Avinash Lakshman, who was responsible for scaling Facebook's inbox search feature. By 2010, became a top level Apache project, and today is used at scale by big companies like Apple, which manages a staggering 100 petabytes of data across 100 of thousands of server instances. It's a general purpose database with use cases for e commerce, content management, audit logging, and everything in between. Each instance of Cassandra is called a node, and typically stores about 2 terabytes of data. What makes it special though is that nodes can be easily distributed to scale horizontally.
databases
data management
data
computer science
microsoft
Every node has the same read write capabilities of another node, but is responsible for its own partition of data.
Nodes are grouped together in a cluster or ring, and data is typically replicated on multiple nodes, which means no single point of failure and 100% uptime. The data is wrapped in a key space, giving developers rule over how it replicates in the cluster. Each key space contains 1 or more tables, which represent tabular data like you might find in a relational database. However, it's schema less and can handle unstructured data, which developers can manage with the Cassandra Query Language. The easiest way to get started is by creating a free server database with Astra. It deploys to the cloud of your choice, then scales automatically on demand. 1st, we'll need to define a key space, which access a container for replication. Next, we'll need to connect to the database, which can be accomplished in a variety of ways. It has SDKs for major languages, and a tool called star that makes data accessible via REST, GraphQL, and gRPC. Or you can execute raw CQL code, which is a subset of SQL. Create a table and include a primary key to uniquely identify every row. Then each column will have its own name and data type. Now add data to that table with the insert into statement. Then you to read data from the table. It's also possible to use the where clause to filter and query the data, but an index will be required on the column. On the surface, this may look a lot like a relational database, but it doesn't support Joins and that's by design. Instead of modeling data into small normal tables, in Cassandra, it's denormalized to match the structure of known queries, making reads much faster at scale. And it's also possible to implement storage attached indexing to handle complex relational queries. This has been Cassandra in 100 seconds. Rule. Let me know if you wanna see a full tutorial in the comments. Thanks for watching, and I will see you in the next one.
databases
infrastructure
data management
data
software
systems
networking
programming
Cassandra, a wide column store NoSQL database famous for its ability to distribute petabytes of data with unmatched reliability and performance. It was created in 2008 by Avinash Lakshman, who was responsible for scaling Facebook's inbox search feature. By 2010, became a top level Apache project, and today is used at scale by big companies like Apple, which manages a staggering 100 petabytes of data across 100 of thousands of server instances. It's a general purpose database with use cases for e commerce, content management, audit logging, and everything in between. Each instance of Cassandra is called a node, and typically stores about 2 terabytes of data. What makes it special though is that nodes can be easily distributed to scale horizontally. Every node has the same read write capabilities of another node, but is responsible for its own partition of data. Nodes are grouped together in a cluster or ring, and data is typically replicated on multiple nodes, which means no single point of failure and 100% uptime. The data is wrapped in a key space, giving developers rule over how it replicates in the cluster. Each key space contains 1 or more tables, which represent tabular data like you might find in a relational database. However, it's schema less and can handle unstructured data, which developers can manage with the Cassandra Query Language. The easiest way to get started is by creating a free server database with Astra. It deploys to the cloud of your choice, then scales automatically on demand. 1st, we'll need to define a key space, which access a container for replication. Next, we'll need to connect to the database, which can be accomplished in a variety of ways. It has SDKs for major languages, and a tool called star that makes data accessible via REST, GraphQL, and gRPC. Or you can execute raw CQL code, which is a subset of SQL. Create a table and include a primary key to uniquely identify every row. Then each column will have its own name and data type. Now add data to that table with the insert into statement. Then you to read data from the table. It's also possible to use the where clause to filter and query the data, but an index will be required on the column. On the surface, this may look a lot like a relational database, but it doesn't support Joins and that's by design. Instead of modeling data into small normal tables, in Cassandra, it's denormalized to match the structure of known queries, making reads much faster at scale. And it's also possible to implement storage attached indexing to handle complex relational queries. This has been Cassandra in 100 seconds. Rule. Let me know if you wanna see a full tutorial in the comments. Thanks for watching, and I will see you in the next one.
Cassandra,
cassandra
a
a
wide
wide
column
column
store
store
NoSQL
nosql
database
database
famous
famous
for
for
its
its
ability
ability
to
to
distribute
distribute
petabytes
petabytes
of
of
data
data
with
with
unmatched
unmatched
reliability
reliability
and
and
performance.
performance
It
it
was
was
created
created
in
in
2008
2008
by
by
Avinash
avinash
Lakshman,
lakshman
who
who
was
was
responsible
responsible
for
for
scaling
scaling
Facebook's
facebook's
inbox
inbox
search
search
feature.
feature
By
by
2010,
2010
became
became
a
a
top
top
level
level
Apache
apache
project,
project
and
and
today
today
is
is
used
used
at
at
scale
scale
by
by
big
big
companies
companies
like
like
Apple,
apple
which
which
manages
manages
a
a
staggering
staggering
100
100
petabytes
petabytes
of
of
data
data
across
across
100
100
of
of
thousands
thousands
of
of
server
server
instances.
instances
It's
it's
a
a
general
general
purpose
purpose
database
database
with
with
use
use
cases
cases
for
for
e
e
commerce,
commerce
content
content
management,
management
audit
audit
logging,
logging
and
and
everything
everything
in
in
between.
between
Each
each
instance
instance
of
of
Cassandra
cassandra
is
is
called
called
a
a
node,
node
and
and
typically
typically
stores
stores
about
about
2
2
terabytes
terabytes
of
of
data.
data
What
what
makes
makes
it
it
special
special
though
though
is
is
that
that
nodes
nodes
can
can
be
be
easily
easily
distributed
distributed
to
to
scale
scale
horizontally.
horizontally
Every
every
node
node
has
has
the
the
same
same
read
read
write
write
capabilities
capabilities
of
of
another
another
node,
node
but
but
is
is
responsible
responsible
for
for
its
its
own
own
partition
partition
of
of
data.
data
Nodes
nodes
are
are
grouped
grouped
together
together
in
in
a
a
cluster
cluster
or
or
ring,
ring
and
and
data
data
is
is
typically
typically
replicated
replicated
on
on
multiple
multiple
nodes,
nodes
which
which
means
means
no
no
single
single
point
point
of
of
failure
failure
and
and
100%
100%
uptime.
uptime
The
the
data
data
is
is
wrapped
wrapped
in
in
a
a
key
key
space,
space
giving
giving
developers
developers
rule
rule
over
over
how
how
it
it
replicates
replicates
in
in
the
the
cluster.
cluster
Each
each
key
key
space
space
contains
contains
1
1
or
or
more
more
tables,
tables
which
which
represent
represent
tabular
tabular
data
data
like
like
you
you
might
might
find
find
in
in
a
a
relational
relational
database.
database
However,
however
it's
it's
schema
schema
less
less
and
and
can
can
handle
handle
unstructured
unstructured
data,
data
which
which
developers
developers
can
can
manage
manage
with
with
the
the
Cassandra
cassandra
Query
query
Language.
language
The
the
easiest
easiest
way
way
to
to
get
get
started
started
is
is
by
by
creating
creating
a
a
free
free
server
server
database
database
with
with
Astra.
astra
It
it
deploys
deploys
to
to
the
the
cloud
cloud
of
of
your
your
choice,
choice
then
then
scales
scales
automatically
automatically
on
on
demand.
demand
1st,
1st
we'll
we'll
need
need
to
to
define
define
a
a
key
key
space,
space
which
which
access
access
a
a
container
container
for
for
replication.
replication
Next,
next
we'll
we'll
need
need
to
to
connect
connect
to
to
the
the
database,
database
which
which
can
can
be
be
accomplished
accomplished
in
in
a
a
variety
variety
of
of
ways.
ways
It
it
has
has
SDKs
sdks
for
for
major
major
languages,
languages
and
and
a
a
tool
tool
called
called
star
star
that
that
makes
makes
data
data
accessible
accessible
via
via
REST,
rest
GraphQL,
graphql
and
and
gRPC.
grpc
Or
or
you
you
can
can
execute
execute
raw
raw
CQL
cql
code,
code
which
which
is
is
a
a
subset
subset
of
of
SQL.
sql
Create
create
a
a
table
table
and
and
include
include
a
a
primary
primary
key
key
to
to
uniquely
uniquely
identify
identify
every
every
row.
row
Then
then
each
each
column
column
will
will
have
have
its
its
own
own
name
name
and
and
data
data
type.
type
Now
now
add
add
data
data
to
to
that
that
table
table
with
with
the
the
insert
insert
into
into
statement.
statement
Then
then
you
you
to
to
read
read
data
data
from
from
the
the
table.
table
It's
it's
also
also
possible
possible
to
to
use
use
the
the
where
where
clause
clause
to
to
filter
filter
and
and
query
query
the
the
data,
data
but
but
an
an
index
index
will
will
be
be
required
required
on
on
the
the
column.
column
On
on
the
the
surface,
surface
this
this
may
may
look
look
a
a
lot
lot
like
like
a
a
relational
relational
database,
database
but
but
it
it
doesn't
doesn't
support
support
Joins
joins
and
and
that's
that's
by
by
design.
design
Instead
instead
of
of
modeling
modeling
data
data
into
into
small
small
normal
normal
tables,
tables
in
in
Cassandra,
cassandra
it's
it's
denormalized
denormalized
to
to
match
match
the
the
structure
structure
of
of
known
known
queries,
queries
making
making
reads
reads
much
much
faster
faster
at
at
scale.
scale
And
and
it's
it's
also
also
possible
possible
to
to
implement
implement
storage
storage
attached
attached
indexing
indexing
to
to
handle
handle
complex
complex
relational
relational
queries.
queries
This
this
has
has
been
been
Cassandra
cassandra
in
in
100
100
seconds.
seconds
Rule.
rule
Let
let
me
me
know
know
if
if
you
you
wanna
wanna
see
see
a
a
full
full
tutorial
tutorial
in
in
the
the
comments.
comments
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, the host explains the benefits of using the new version of Cassandra, a general purpose database designed to store data on scale. The database is a cluster or ring, and can handle unstructured data. It can be used to access a single point of failure and handle uptime by allowing developers to manage and manipulate the data. The host recommends creating a free server database and using the default implementation of the new version, writing the data into a table and filtering and query the data.
Cassandra in 100 Seconds
Cassandra, a wide column store NoSQL database famous for its ability to distribute petabytes of data with unmatched reliability and performance. It was created in 2008 by Avinash Lakshman, who was responsible for scaling Facebook's inbox search feature. By 2010, became a top level Apache project, and today is used at scale by big companies like Apple, which manages a staggering 100 petabytes of data across 100 of thousands of server instances. It's a general purpose database with use cases for e commerce, content management, audit logging, and everything in between. Each instance of Cassandra is called a node, and typically stores about 2 terabytes of data. What makes it special though is that nodes can be easily distributed to scale horizontally. Every node has the same read write capabilities of another node, but is responsible for its own partition of data. Nodes are grouped together in a cluster or ring, and data is typically replicated on multiple nodes, which means no single point of failure and 100% uptime. The data is wrapped in a key space, giving developers rule over how it replicates in the cluster. Each key space contains 1 or more tables, which represent tabular data like you might find in a relational database. However, it's schema less and can handle unstructured data, which developers can manage with the Cassandra Query Language. The easiest way to get started is by creating a free server database with Astra. It deploys to the cloud of your choice, then scales automatically on demand. 1st, we'll need to define a key space, which access a container for replication. Next, we'll need to connect to the database, which can be accomplished in a variety of ways. It has SDKs for major languages, and a tool called star that makes data accessible via REST, GraphQL, and gRPC. Or you can execute raw CQL code, which is a subset of SQL. Create a table and include a primary key to uniquely identify every row. Then each column will have its own name and data type. Now add data to that table with the insert into statement. Then you to read data from the table. It's also possible to use the where clause to filter and query the data, but an index will be required on the column. On the surface, this may look a lot like a relational database, but it doesn't support Joins and that's by design. Instead of modeling data into small normal tables, in Cassandra, it's denormalized to match the structure of known queries, making reads much faster at scale. And it's also possible to implement storage attached indexing to handle complex relational queries. This has been Cassandra in 100 seconds. Rule. Let me know if you wanna see a full tutorial in the comments. Thanks for watching, and I will see you in the next one.
In this video, the host explains the benefits of using the new version of Cassandra, a general purpose database designed to store data on scale. The database is a cluster or ring, and can handle unstructured data. It can be used to access a single point of failure and handle uptime by allowing developers to manage and manipulate the data. The host recommends creating a free server database and using the default implementation of the new version, writing the data into a table and filtering and query the data.

        [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 : Cassandra in 100 Seconds 
        and a small summary : In this video, the host explains the benefits of using the new version of Cassandra, a general purpose database designed to store data on scale. The database is a cluster or ring, and can handle unstructured data. It can be used to access a single point of failure and handle uptime by allowing developers to manage and manipulate the data. The host recommends creating a free server database and using the default implementation of the new version, writing the data into a table and filtering and query the data.
        [/INST]
        
        Generate the video : Cassandra, a wide column store NoSQL database famous for its ability to distribute petabytes of data with unmatched reliability and performance. It was created in 2008 by Avinash Lakshman, who was responsible for scaling Facebook's inbox search feature. By 2010, became a top level Apache project, and today is used at scale by big companies like Apple, which manages a staggering 100 petabytes of data across 100 of thousands of server instances. It's a general purpose database with use cases for e commerce, content management, audit logging, and everything in between. Each instance of Cassandra is called a node, and typically stores about 2 terabytes of data. What makes it special though is that nodes can be easily distributed to scale horizontally. Every node has the same read write capabilities of another node, but is responsible for its own partition of data. Nodes are grouped together in a cluster or ring, and data is typically replicated on multiple nodes, which means no single point of failure and 100% uptime. The data is wrapped in a key space, giving developers rule over how it replicates in the cluster. Each key space contains 1 or more tables, which represent tabular data like you might find in a relational database. However, it's schema less and can handle unstructured data, which developers can manage with the Cassandra Query Language. The easiest way to get started is by creating a free server database with Astra. It deploys to the cloud of your choice, then scales automatically on demand. 1st, we'll need to define a key space, which access a container for replication. Next, we'll need to connect to the database, which can be accomplished in a variety of ways. It has SDKs for major languages, and a tool called star that makes data accessible via REST, GraphQL, and gRPC. Or you can execute raw CQL code, which is a subset of SQL. Create a table and include a primary key to uniquely identify every row. Then each column will have its own name and data type. Now add data to that table with the insert into statement. Then you to read data from the table. It's also possible to use the where clause to filter and query the data, but an index will be required on the column. On the surface, this may look a lot like a relational database, but it doesn't support Joins and that's by design. Instead of modeling data into small normal tables, in Cassandra, it's denormalized to match the structure of known queries, making reads much faster at scale. And it's also possible to implement storage attached indexing to handle complex relational queries. This has been Cassandra in 100 seconds. Rule. Let me know if you wanna see a full tutorial in the comments. Thanks for watching, and I will see you in the next one.
        