Cassandra Database Operations | NoSQL Database Elements | Apache Cassandra Tutorial | Edureka Video Lecture | Cassandra: Learn and Master - Database Management

[Music]
hey folks this is our fourth session
these are the set of objectives that we
are expecting to accomplish by the end
of this session today we have the
various data types are available in
Cassandra the collection types the
user-defined types that we can have the
basic kernel operations that we can
perform various other set are functions
that we can make use that we can
leverage from with Cassandra and midis
are the possibilities of indexing and
where exactly this indexing really makes
sense that's primarily what our major
objectives are in this session so well
now moving on with these cql data types
there's a bunch of video types that we
have there is the ax skies primarily the
strings we have begins
we have blob we bullion we have counters
we have double we have float then we
have integers then we vine its we have
text okay it's time you UID with our
card we have my cat in is primarily 32
in here 32 bits text is in utf-8 in here
I'll it is primarily for IP addresses
you won't primarily see the usage of ein
it's that extensions really int takes
timestamp time UUID it represents the
time UID of type 1 and then UID can
represent either type 1 or type for UID
then we give our cards it has the utf-8
is primarily something that has specific
limitation or with respect to the size
as well so the number of characters that
it can store in here then we have the
variant it's the integers now the
buildin types of the blob blob is
similar to what we have in our DBMS as
well the blob in Selah the binary large
objects so every time we actually want
the stores data in the form of
hexadecimals or acceptable carriage
that's primarily and we want to store
large objects in an encrypted format
that's primarily what blob is primarily
for so maximum ly we can say that the
limitation is probably for two gigabytes
of the blob
we don't really store all of the known
primarily you won't see much of throwing
huge amounts of data in there that
primarily what blob is for the counter
is the incremental values unless the
increments is actually being specified
so I mean how exactly the increment was
actually primarily specified so you need
to actually have an increment or
decrement err so just like we have in
here's the run counter so that's how the
increment is actually the run is
primarily to run the implementers to
execute the increment or in itself as
well that's what the counter is
primarily for so the counter doesn't
actually we cannot set the counter on
our own it's primarily something that
actually needs to be incremented or
decremented we're gonna set a specific
value of the counter that's actually a
limitation of a counter Krammer counter
is primarily just to actually it's more
effective
I mean that's why we don't really
specify counters for the primary keys or
the partitioning keys and then there is
no consistency in the explorations it
doesn't have any time to live even
though we can remove a counter at any
point of time but there is no assuredly
and that it doesn't really make sense
there is no guarantee on the updates how
the updates will be responded what it'll
be the consistency of the updates while
we're working with counters so so Wi-Fi
merrily you won't see that extensive
amount of usage with counters but yes
the timestamps are very very important
building data type that we have in
Cassandra and they're extensively used
for performing operations well we're
working with Cassandra it's as simple as
we have time stamps in any other formats
there will biggest formats that we have
in time zones in time stamps so all the
common standard formats are primarily
being assumed there's time stamp so I
mean if it's milliseconds then we can
assume it as an integer efforts with the
form of a date/time a plus milliseconds
then we need to specify it as a string
but in both the cases the timezone is
not assumed so if we actually want to
specify the time zone that's primarily
where and we can use either of the two
string options with the date and time
plus the UTC differences if you see
changes that's the primary difference of
using a timestamp the UUID and the time
UUID UUID is primarily the universal
unique ID it is just it's a unique ID
that gets generated based on this system
and that
generated based on the VM it's a 32 bit
backside the symbol character so it can
be an alphanumeric character and it will
always be differentiated between the
dashes so that is the convention of how
UUID behaves have a standard UID
response back
the only difference where the time UID
is my malli is based on time so it's
primarily in the nanoseconds so after
100 nanoseconds there will be a
different time interval that actually
gets created off so it's a good catch to
actually make use of time UUID as a
primary key it's always good advantage
of working with primary keys in there
then in collections there are a very
important useful type a useful part in
working with collections there are three
major form the collections that is less
than math and they're set we use one of
the collections in our previous use case
who were working on we're now selling
you that we can either make use of lists
or map when we are actually working with
collections that's primarily what this
collection is about so unless we specify
the type of Gillis mortars that I will
it's an its type integer or its type
string or its any other type so set is
primarily a unique identifier the list
actually stores data in the form of
ordered elements so our map is primarily
based on the key value format so will be
key and there will be a corresponding
value to that respect to key that is the
primary difference of using a collection
collection primarily be used if we are
actually trying to preserve some
specific objects or if we are trying to
preserve multiple objects for a specific
entity and itself that is the major
usage there and we can make use of
collection in the types the usually the
types the Cassandra always gives us an
advantage of creating our own do types
we can create our type we can modify we
can change the types and we can always
delete them off now there are ways of
actually creating there are types we
define the create type the name of the
attribute and then what is the format of
corresponding type so this is primarily
where we can actually specify this makes
more sense if we are actually making use
of a time that's actually available for
more complex objects for example in case
of when we are making use of any complex
objects probably something similar to
just like the example we have braces and
then we have
there's there's an actually beaut a
fields named birthday of time timestamp
there's nationality that is wait and
then there's height so there are four
different attributes are linked to one
single type so the advantage it gives us
in here is if we want actually restored
objects if we want to store more complex
objects that's really what Pacific time
actually specifies or refers to let's
try to explore this one over VM
to give a better understanding it's
always good to go to a few examples
we log into the machine here comes the
Machine loaded in now
Cassandra strong abdominal
which shows the error it's not starting
ok it's working yet again it started now
scribe this is never okay now if you go
back to the Korean type name of we
create type and then the name of since
we are only in the key space so we don't
need to specify the cases we just need
to specify the type name and the
attributes that will be specified in
here right so we create type in the user
ID user and new text and we have Patras
text so we have two types describe
no if we describe the IDI user this is
the type for that specific user we
altered type name of the type ET user if
we want to add more columns if we
actually want to make few changes we
alters the name of the attribute that we
are actually specifying where exactly do
we want to specify two processes alters
name type
altars
you
okay so now we actually if we want to
specify the type based on that specific
user
now alter type alters type the user
alters type user dot full name to type
needy users
we have last name and
screaming it's too
you
rename name - first name know what's
described the users
okay so know the name was actually being
specified replace so let's rename first
name - first name - name and address -
street scape the shoes captain's more
easier okay try now see the type has
been changed itself we can modify the
custom user types these are defined
types and we can alter the states and we
can always drop the type so drop type II
the user will drop since the start being
used by any of the tables to live so
that's why yeah since it's right there
anymore so it's being deleted now that's
how the table works now we can
systematically make use of any F we can
perform any of the operations or in the
Cassandra datasource whether it's
creating an entity it's modifying the
existing data or it's removing that it
are completely Oliphant Howard there are
different ways of actually performing
those operations there are various ways
of how we can actually write the data in
there creating we always use a concept
of insert but that we will have to
update all the values since it's a
column based structure primarily it
requires the value only for one single
that is the primary clarifier because
based on that it actually makes a
decision how we actually want to store
data in there how the data will be
separated our other than that it doesn't
really require any of the unless there
is no other attribute that's actually
being specified in here create a table
let's copy one of the tables in here
it's clear the same table this execute
in here describe the tables
we have the tables in here turn into
for my stocks and the ID for this one
suck star from pharma stocks
and by default it actually I modified
all the values that are actually being
specified in here that I have the
identifier corresponding to that
specific on if I'm Vicki was mandatory
it did not give me any restriction on be
specifying or not putting values for any
other attributes other than the
specified attribute in here now if we
insert means word ID name value vs e NS
e2 name
Lupin
the UST PSC we see is an integer student
radio choir value may see one PSC is
1/1000 for 30 this is for 30 it's
written here select data we have two
different records not actually being
specified it's why it's a column based
so I mean it doesn't really necessarily
require that we put no value for all the
fields in there that the biggest
advantage of specifying it in here this
is how the casandra's insert works now
if we're actually trying to insert data
into the collections when we have
specified the types in there now we're
putting data inside the elements we
always need to specify the values in the
form of squirrel braces and then the
comma-separated attributes in case of a
list always specify the data in the form
comma separator attributes in here
however in case we won't actually
specified suppose we alter table for
stocks ox and column and listing
and pricing list int now we have one and
spoons one and I think there's one three
there's wonders to this teen
let's see for the lists specific
attributes we make use of the square
braces in the air and then by default we
modify the changes in there now let's
suppose we add at 425 for let's see two
again ten
now if we try to create alter the table
that set its right creating the set of
type string by saying options bring at
the field have a new field now options
try to create the options in there by
comma five one six options
this is how the structure actually
identifies in here that this is the list
and this is D int this is C it's
specified it says the errors that
invalid list literal four options of
typeset int now if we actually to use
the curly braces to store the values in
here select them from the ecology
achievement since it is a set so it will
always remove the duplications in there
if the Lord specifies so the difference
the thing that actually differs from the
list as compared to a set is that it
maintains the insertion order the list
it doesn't care about the duplication
second it is always refer to a square
braces within the C AQL and then in case
of set said always removes duplication
so the you won't get redundant yet
either second set will primarily not
really work in case of round braces so
it will always be in within the curly
braces that will be specified in here
nonce try to have try to change
or map
see it's actually specifying that the
attributes are not really specified
inside these specific attributes in here
what we do is we specify text now if we
achieved in the interest there is a new
competitors now insert in two
competitors I see what is the structure
for actually storing the data inside
with the key it's a curly brace key and
then value and then so on so go so now
if we actually go back 5-1 Sun
formal/informal
catalog
try to create one
the label input
the competitors
the computer trills now see how exactly
this specifies in here with the curly
braces on the key and stick value in
itself string I forgot
shrink shrink see this is the key value
format you have specified in there so
let's try Sonic's
store from
there's the competitors that we have
there no that's how the set works the
uniqueness in place for list it's
primarily how the objects are being
preserved in there then in case of a map
it's a key/value format do you have to
specify the type of two different
attributes one is the key another is the
map whichever is the unique identifier
then based on that the map will decide
this is the type of the key and based on
the time that we have specified that the
map will preserve the data in that
format and that's how these three major
types of collections that can be used at
the various possible data types within
Cassandra so based on the usage of how
do you want to store the data in and
which format you can choose either of
them now exactly I mean these are
developed the truths which in case a
blob in case of string we can always
have in single chords in case of time
UID we can have it always has the delay
of 100 nanoseconds then UUID it's always
a 32-bit hexadecimals then boolean is
always it's case insensitive that's
always a good key so it can either be
small or larger then the numbered
constants the identifiers the integers
what form of integers is the structure
of integers that we'll be able to
specify now if look into it in a little
more detail I mean how this is something
similar to what we just ran in our c qo
earlier how we define the set with the
curly braces and whatever the value is
that's being specified in here you
specify the values in here that's a
string so it will always be in single
quotes then in case of map there's a key
value format so the key value will be a
1 format and the value will be a further
format or they can be both of the same
format if they are of type string then
you have to keep them inside single
chords if they are of type integer or
boolean or numbers then you don't need
to specify them inside the single quotes
these words the exponential notations
and this is not even though this is not
really a good practice and this is not
something that's really common but in
case of exponential values I mean when
we are talking about very high values
high volume values and specifying a
unique identifier for prime
for in case of the decimal values where
that's double our floor we can still
make use of the exponential column
values just like we have specified in
here minus 2.6 or 3 4 5 e plus 38 so
this'll actually an exponential value
that goes to this will be considered as
a value that will be specified in here
the if not exists is primarily if the
row actually identifies if the row being
actually created I mean the only usage
for this if not exist is them actually
by default the insert statement doesn't
really return anything so in case if you
want to literally if you want to make
sure that the true was true was created
at Bernard so that's what they if not
exists does performs in here while we're
working with the insert and the
important thing is that we always write
if not exist at the end of the query
it's like in here for example
now if the object in here it actually
specified that the object was already
theorem placed so it didn't not actually
create this row again it did not create
the row again now let's suppose if I
actually specify this for a different ID
sorry gifts the competitors it applied
deep valley so whichever value was
changed since there was any ID so that's
why don't return anything so it created
any row so the applied that is what's
the if not X this response packed now if
it don't actually execute this query it
does not respond as anything it doesn't
really actually tell us though that this
object was really modified or not name-o
it's trying to see let's see what
actually happened if this is actually
working this works as an absurd it's not
like this since this already is there in
place so it doesn't modify it doesn't
make a change in there's not suppose we
actually specify P
value
it did not part if I devalue since the
file Wars quality and there was no
specific CD back before or bando is
still empty what 7 for most this was
already existing sweetheart did Roy
excuse me anything that's why it
returned as false
it doesn't recreate the feel that is the
difference between actually making use
of if not exist or directly using an
insert statement it actually helps us
off to I don't tell us that it tells you
or gives you the information that this
field is actually this row is already in
place it's already available and there
the time to leave is actually the
specific for if you want to give a
lifetime to the attributes that are
actually being specified in there and
this is actually how the tomb so
actually calls off they get eligible for
tomb stored when we actually do the
cleaning when we do the compaction and
since we're actually removing it off as
soon as it cools off if we have a big it
marked for deletion as soon as they get
back for deletion the tubes tube
actually gets a table of tube dough gets
active and then as soon as the data act
is actually being specified to the
specific lifetime of that attribute then
based on that it will be actually
available for those specific set of
columns so now let's suppose
so the time to live for a new farm is is
10 now if we actually go back and now
the timestamp used to actually specify
the restriction of actually specifying
it grows at a specific time stamp at a
specific time that at this point of time
this actually attribute will be actually
specified by if you want to store the
data at insert data at a specific time
interval that's what the timestamp Bach
is specified used for now since this is
actually since we use timestamp or at a
specific position or a specific location
so that's why I primarily will not be
able to preserve the time SAP not be
able to use timestamp with the ioniq is
a statement simultaneously in a one
single query however we can use a
timestamp as well as at the time to live
in the same statement in the same point
of time so as soon as it gets inserted
at this specific time stamp it will
automatically be available then only the
time to live will actually be available
but then only at that point of time it
will be available and then based on that
we'll be able to that's how the lifetime
of this specific group will be specified
the restrictions for creating the data
there's one is with the counter columns
come to columns is a probable one and
then we can actually create a new table
in the key space in a different session
altogether we cannot do that we cannot
insert a results unless
no no if you go back here I see the time
to live for new forma was 10 seconds now
if you see if you see this new forever I
got deleted off automatically the reason
for that was it's time to live worse 10
seconds so as soon as it treats the 10
seconds 10 you are dying off so this is
how the deep ETL works when you insert
the data inside Cassandra and you
specify the time to live for a specific
insert true in there it's available in
Cassandra column family only in that
specific duration time span and as soon
as that's time Sam dies off the
tombstone automatically gets activated
and the tomb storm automatically skims
it are from the column family and this
gets an title for deletion
that's how gouken inserts data in Kisan
various possible combinations we can
make use of the TTL s for a specific
duration we can make use after if not
exist if not exist is primarily if we
want to get a response on how this query
was executed whether this query was
executed successfully in case that rule
was already available in there or not
then this will not be in your rule will
not be inserted or updated if we don't
want any of those operations to be
executed then we don't necessarily
requires if not make use of if not exist
if we want to give a specific time frame
then we can make use of the TTL in here
the time to live or we can make use of
the time stamp based on which we can
specify that at this specific time stamp
these attributes will be actually
preserved or these attributes will be
saved up our the issue in here is that
Cassandra doesn't allow us to sort
because of both if not exist as well as
the TTL at the same point of time we can
use either of them but on the other hand
we can make use of the time to live and
timestamp in one single query at a
single point of time in that process the
execution first on goes on with the time
stamp at which point of time this data
will be inserted and as soon as that
timestamp is reached after then posts
that the time to live actually gets
enable off and post that interval as
soon as the data is actually inserted
off the lifespan of an that specific row
actually starts off that's how the data
can be inserted in Cassandra and now
when we talking about the three walls
there are various possible ways of
retrievals the first one the simplest
one I just showed you off I using this
chart so that means it's an anonymous
one so we will be able to achieve all
the rules that are specifying in here
now in others to actually retrieving all
the data we can always have the
conditional operations the conditional
keywords and conditional statements that
we can make use while working with this
electrode she was we can have the
distinctions we can use a distinct
keyword we can use the conditional using
the bare so we can have the limitations
what retrieving the number of records
that we want to receive using the limit
we can make use of the filtering in case
we want to retrieve data other than the
primary fields are the primary key or we
can make use of the indexes columns in
there and then we can make use
then there's a possibility that we can
make use of we can group by the data or
we can order by the data are based on
the conditions that we are actually
specifying in here now in select if
you're actually trying to there are two
possible ways one is actually receiving
the complete data in using these charts
that means wildcard character or we can
retrieve all a specific set of columns
only the columns that we really require
and then we can use the distinction this
diction is primarily used when we
actually want to retrieve the data only
that is actually different that is
unique in nature but we don't receive
the duplicate elements in place based on
the partition keys as well in place we
can retrieve the fields we can retrieve
the actual columns itself in the form of
their direct names or we can specify
some alias names for those columns as
well see in here slide we retrieving all
the fields now let's suppose if we want
retrieve only specific fields we see
so it will give us only t3 basic fields
in here only three different columns not
all of the columns in here now if we
actually want to achieve
stocks
now as you see we're actually retrieving
the fields as using the alias name
that's relatively simple and relatively
identical to how we retrieve it in the
our DBMS on the RDBMS site so I'm sure
people are working on RDBMS which would
be quite easy for them now whenever
actually it primarily makes sense to
actually make use of the aliases when we
are actually making use when we are
actually trying to call in from the
existing namespace or key space in here
if you see without really necessarily
make use of if you see how we're
actually calling the prom we don't
actually make use of the actual
namespace in here since we're already in
the namespace now if we actually see the
name spaces spaces use system
now if we select search it was an error
right this is North unconfident a
lovebird if we make use of stocks the
key space now if you see we are able to
access the data from one namespace
column family a column family that's in
one namespace or within the different
column family using the name of the key
space and then dark the name of the
actual column family in here that's what
they from actually specifies so I mean
it depends on how exactly we're actually
want to specify then the limit how many
number of rows we want to specify how
many number of rows do we actually want
to retrieve in one single execution now
suppose let's use stocks again stocks
you're dreaming all searching these
seven rows now if I want to limit only
to retrieve me the latest most tools
based on the time Siam that actually it
inserts because by default Cassandra
will preserve a timestamp for every
record that has been inserted so the
recent most attributes are actually
being sorted will be retrieved in here
so now let's suppose stood like this
uh-huh
give a better picture of which one
something retrieved the filtering
actually the condition actually
primarily being made use of for the
partitioning key the partitioning key is
primarily based on what is the part that
will be the part of the corresponding
primary key that we have specified while
creating the column family table that we
have defined earlier now if you see that
there are different sections there are
primarily five different sections of any
UID that we have in place then we are
actually trying to search based on that
specific attribute or that specific key
it doesn't really actually specify the
the specific partitioning based on the
specific primary key to actually return
or all the partitioning keys that are
actually available in this in this
specific partition so they attributes
are actually being specified or the
attributes then available in there will
be actually being specified in there
based on the condition and then if you
actually want to do the filtering a
little more optimized when we have
multiple columns in the primary key in
here so the first one is for the
partitioning key and the second one is
for the class word key now if we
actually specify the relationship and if
you want to retrieve the data
primarily based on the combination of
both the elements that we have in here
both the columns can be used while
actually retrieving the data in itself
the partitioning key structure as well
as the other section of the primary key
that is the cluster key in this what
happens is that when we are actually
using both components of the primary key
while retrieving so it actually
retrieves data first it refines data
based on the clustered key the data is
sorted so there is it is retreat based
on that and then it's being filtered
using or it's being a kid refute word
using the partitioning key part of the
actual primary key and that's how the
partitioning key and primary key and
clustered key work now the group I is
primarily similar to how we use make use
of group I whose
goodbye name now see what stay around is
in here group is currently only
supported on the columns of the primary
key God name now since this attribute is
actually primarily being supported on
you and I D that's why you actually are
specifying the aggregations based on ET
the partitioning key that's why now
since in years limit three so it will
return money the first three in the list
since there's not much gratification
since there's no similarity so it
doesn't really help much in actually
grouping by group is primarily if you
are actually making use of group by you
primarily have to make use of the order
bias from first try the order PI by name
sending now see the error in here is
it's primarily works on the partition
key now since it's neither equal and
narshe
in so what actually happens in here is
where I T
nothing since there is no cluster called
Dasani there's no clustered column let's
see describe table box
plus the name of the table as far formal
stocks trying to describe since the only
section of the primary key that's why
the order by and the group I don't
actually really perform well so I
actually I executed put the queries
before actually going to the slide skin
this is a very important thing that we
should keep in mind to see what is the
error if we actually go through the
error give you an understanding first
take a look at the structure of the
table the primary key is only IDs so
there is no costard column in place
right so there's no specific ordering
that's actually being specified now
since there is no specific ordering that
is actually being specified on any of
the attributes so the challenge is that
there would be Cassandra doesn't know
how to do the order by because since
actually expects the order by based on
the a clustered column because clustered
is in Cassandra it's the clustered
column that is responsible for actually
performing the clustering now since
there is no clustering there is no
clustered column that is part of the
primary key so the order by doesn't work
doesn't perform any execution it gives
you an error it tells you hate so sorry
there's no question column in place so
you will not be able to perform the
ordering now for guru by again group by
actually works both of them work
primarily with in conjunction with the
primary key so the primary key when I
say the primary key it's the partition
key the partition key section of the
primary key so now it's important that
we should have that partition key in
place whether while we are actually
using the retrieval by where clause or
we're actually grouping it by using that
specific attribute so you have to
specify the grouping and ordering based
on and the primary key attributes or the
partition keys that's why the execution
doesn't actually really work in here but
if we create a partition key but
multiple attributes in there then based
on that we'll be able to specify a more
than one single column in there for
comparisons now the filtering is
primarily more for example let's suppose
no filtering is an important feature
because since we don't actually let's
clear this off for select or from former
formal stocks to cheese's all of the
things now if we actually use a ver
class
we're NSC is it going to 420c it will
tell us that this is not an applicable
since you're not actually you know this
is not a primary comms so Cassano
doesn't really understand how forms will
behave so what we do is we enable
filtering filtering now as soon as you
actually enable the filtering this is a
default filtering that actually gets
enabled in here it's actually able to
filters the corresponding the specific
key that is neither an index attribute
that that column is neither index nor
that column is part of the primary key
if none of those attributes are
available then you actually need to
specify you have to enable the filtering
for that specific condition so Cassandra
bypasses the conventional performance
shrinks and the performance
optimizations to actually make sure that
we are able to retrieve the attributes
that can be part of the cluster or non
clustered columns this is actually
something that we will be able to be
using a large because in Cassandra it's
not relatively necessary at every point
of time that you will be able to
retrieve data or you will be able to
retrieve all the data at any point of
time and it's not possible that every
time you will be aware about the
corresponding primary key is there's a
lot of possibilities that you might want
to receive the data of using ethnic
column because since it's an
unstructured stored so there is no
necessary condition or there is no
necessary restriction that will always
be receiving data based on the specific
primary key or any parts of the primary
key if you're actually trying to find
specific attributes that can be possible
across various that can be found within
a list or a bunch of different values in
here proves 500
now see the NSC is a non-primary
attribute this is not a primary
attribute so it doesn't really allow
this what we do is now let's pros ID
now when we actually execute the enforce
the primary key it actually gives the
filtering of all the possible options
that aren't match the ID with ins the
round braces options the list of options
that we have so that means we've given
three options that's one five and three
so the execution will be matched for all
three of options so first it will match
the ID with the first that has one then
it will match the values for five and
then it will match the values for three
so it will achieve all the attributes
and that's how the in works so I mean
when you are actually trying to retrieve
data in the form of a conditional with a
bunch of values that we have in place
now update is primarily to modify the
changes they modify this T so I mean
similar to at the execution of insert
statements you have similar syntaxes the
only difference is in here and by the
values while inserting however in case
of update we made use of set keyword and
the actual attributes that are actually
being specified we have again we can
make use of the TTL the time to live as
well as the if not exist or if exist or
the timestamp we can use all those three
possible conditions will do the upgrade
as well and this is another big
advantage with update is that it can
work as an absurd as well something
similar to insert so if the data doesn't
exist
Khan doesn't exist it will create that
column and if that column is not there
it will update the column with the new
attributes the new informations can't
update for ma stocks set name name use a
cone to Sun where PT is equal to three
see we updated the table we sit
flower name menu Squanto 20 misty it is
equal to five
we have updated the values for we have
dated multiple fields in this same query
using the comma separated we update the
name of the actual field the name of the
actual table sets the name of the actual
column the value dents another column
column name then value and the condition
we are actually specifying using TTL
five
no this is for five seconds too often
that the value should be changed off
that's why the fields try this again now
see the value has change again as soon
as the fields are changed off as soon as
the time until you who has died off the
values are again the values again come
back to normal again let's try the time
two three four eighty three supply white
or earlier that was son no one's rights
again let's see as soon as we actually
change it doesn't reverse to the old
values it actually removes off the value
completely altogether that's that's how
the time to live works in case of update
so it's very important that we know how
we're actually making an update using
the TTL because if we actually update
the value with the TTL so we're actually
losing the current value as well as the
previous really so it's important that
we make sure that we define the
attributes based on that now this is
updating the attribute cell since by
default it will eart let's suppose it
won't let you updates the fields without
the parts of the partitioning key since
ID is not theirs it doesn't let you
allow the modify it's very important
that we should have the the partitioning
key in there while we're actually
updating and the reason for that is
because since the partition key is the
attribute that actually means that
decides how the data is actually being
flown into the commit logs so it's
important that Cassandra always get self
partitioning key because without that I
central doesn't really know how to make
a decision of making the changes for
those partitioning keys or how to update
the fields in there then we can update
we can define a specific partition with
including in case of the conditions that
we are specifying
we can update the list as well we can
update any possible well that's a list
or that's a map any of the other
operations now deleting we can always
delete multiple columns or multiple
fields based on the conditions and
there's a possibility that or we might
actually remove all the fields in here
so for example it's a course that we
you see one leads why'd you delete the
field name the actual column name - man
you from Parma where ID is equal to five
singer from former yeah ID is equal to
five
now what it actually changed was it's
removed the value it deleted only the
specific columns in there now if you
actually want to delete the complete
rule we call delete deletes from where
ID is equal to one to delete the
complete row so the next or from Parma
please come to one it does not return
anything since that field is not
available in there straw now let's try
to receive all the fields see the first
row has gone off casualty complete row
so there are possibilities that we might
actually remove only specific columns or
we might actually remove off the
complete row in all together that's how
exactly we can actually specify and then
we can make use of deleting the data
based on the time stamp based on a
specific time stamp and then deleting
data from a collection or from a
specific attribute that are actually
being specified in there for example
let's suppose if you're actually trying
to until remove a specific element
inside pause let's try if we are
actually trying to remove an element out
of four I didn't lead pricing pricing
pricing three nice too
you
now if you see based on the indexing of
two that means it deletes the element
that has index two of pricing from
farmers from column table from stocks
where I T is equal on to four so that
means the ideas for that is this role in
side pricing the element that actually
stands at the second index that means 0
1 2 that means 18
that's what 18 is missing off it removed
off the element at that specific index
same can be applied for a map as well
based on the key that's actually
available there so let's suppose the key
is where is a key and that's 6 ok
competitors competitors this one it's
the key so much delete off the specific
key and value since the key is 1 so
that's why we give the key this is the
key in here and in guess off the list
this is the index so this is an
important difference you should know
that this is the index in case of the
key in case of a list and this is the
key in case of M in case of a map so
this is the name of the index the name
of the key in case of a map so if this
is a string or if this is an
alphanumeric number that has been
specified as key in computers for
example then we need to specify
accordingly at the materialised will is
primarily where and we actually try to
create specific parts we actually tried
to create any fuse some specific views
are some specific columns or some
specific amount of data that we are
actually trying to use and then we are
actually primarily used with and we
actually have high volume of data when
there is lot of cardinality that's where
many lies who primarily make sense so
when there are lot of amount of data and
that's actually in there that's why we
make use of the materialized view for
defining visualize view we have to
create it's something similar to what we
create a materialized view we define the
materialized view using the create
statement and then we specify the Select
statement on which attributes we
actually want to create so there are
three major sections three major
components of that comprise that the
materialized view comprises
the select statement that actually
retrieves the data that will be the part
of data the primary key information for
the specific bit utilized view and the
options for the view and the options
that will be available for creating
these you in itself just like in here we
create a materialized view prom wherein
the conditional statement is from and
where this is the where this is the
conditional statement this is the
primary statement this is the optional
statement the width is primarily the
optional statement these are the options
that we can have we can specify and the
new attribute that will be specified in
here now primarily since this is only
for retrieval so we cannot perform any
we cannot make use of any aliases
there is no availability of aliases and
the second there is no possibility of
using any aggregate functions we cannot
make use of any aggregate functions as
well as similar to the way we can I can
actually specify changes of other
sections of tables and column families
are any other attributes that we have in
there we don't have a similar access of
alteration cannot change the column
names or the columns actually or the
number of columns actually we actually
need to drop become pretty much live
view and recreate it again so now if
we're actually trying to specify the
data that we're actually trying to
specify then in that case we actually
need to create the attribute that are
specified in here but the conversions
there are some essential conversions
that's to blob so we can always do a
conversion from strings to blob or into
blob or pig into blobs of all the
conversions if you wants to make a
conversion from a bun datatype blob in
order to do a little faster retrieval
and do a little faster processing we
there are different kinds of attributes
based on the kind of data types that we
have in place example let's create type
o thurs table pharma stocks and kiss
club since the field next one so this is
the blob one key is Susan's key this is
empty
so what we will do is insert
obtained in two dates table form a stock
copy this ox set blobs as int
sweets of d
this is the blob conversion of the
actual data that was of type int
and that was 40x conversion so for all
the attributes for all the types of data
types that we have based on that we can
actually specify the conversions in
there now if we want to return the data
for retrieve the data from blob the
nectar like click keys
since there was only one kiss and that's
why actually did the conversions come in
two keys
so that's how we can actually get the
retrievals we can do the conversions
from idle is the time UUID is we can
always have the date date off and now
the min/max the unix time of timestamp
off the time UUID always gives you the
time specific informations and the date
off then now the max I'm UID the
meantime UID it actually it generates
the maximum time UUID and by default you
don't necessarily require to specify it
automatically requires the time uit
however if you actually want you can
specify the time as well and there then
based on that it will generates then the
unix time is from primarily the unix
timestamp the format in unix so based on
that you can generate the timestamp that
we have in there then the tokens when we
are actually creating the tokens we can
actually specify the range of tokens how
exactly how the competition of the
tokens can be given by how the tokens
will actually look like in the
partitioning key well we're actually
trying to define the keys in there
that's how the tokens actually specify
in here the time to Lu is actually the
data is actually being marked for the
tombstone so we don't necessarily then
add the aggregate functions are actually
more useful that make more sense I could
get a get functions are relatively very
easy and simple there's counts there's
max there's men there's average there's
some examples like we have
count counts 86 store six can
since it stars make if we give you the
maximum ID the minimum ID the smallest
one give you smallest worn the average
means for the sum of ideas
now some the advantage of using great
functions is we can still perform the
other queries that are actually
applicable in here we can still perform
the conventional retrieval our fields
other than the aggregate operations
while working with Cassandra
it's always a good advantage so I mean
being the aggregates whether we are
using counts and giving the total number
of fields these sum the addition of all
the fields worst we can always have some
user-defined functions we can create a
function and then based on that function
we can have how we actually specify a
function the creating a function is we
can always write functions in Java since
working with since Cassandra is
primarily a java-based application so we
can always write functions in Java and
then actually move on and let those
functions be applicable here and then
from based on that we can actually make
use of those functions within Cassandra
itself we can always rob the functions
in there in place for example if we
actually try to create a function using
Chavez functions or Javas predefined or
any of your own redefine functions so
based on this so make sure that that
specific function class is available in
the class part then only this will work
and in here's example is primarily given
is working on a strategy our function
that's already available in the library
however in case we have any custom
user-defined function that you want to
use within Cassandra for that you will
have to make sure the library for that
is already available within the Karass
Lib so that when you are actually
creating the user-defined functions it's
actually able to access it from that
specific location or specific file in
here it's very simple the create
function if it's not available you make
use you may or may not make use of the
if not exists the name of the function
the input parameter what is the type
input and what is the type of the
attribute and then this is actually
makes sure that this is actually
performed on it returns a double what is
the return type and the language is Java
since its reports will be cassandra
supports two languages primarily Java
and JavaScript even though Java is more
popular with Java and we returns the
value that's are actually being
from the Jawas actual functions so I
mean this is the function that actually
is responsible for performing the
operation in the execution so you can
replace this with your own custom
function that will be specified in here
you can drop once you have you can drop
the function at any point of time
whatever is the name of the function you
can drop that function in here for the
security security has actually improves
a lot there's a lot of authorization
authentication that Cassandra actually
supports then we are actually specifying
when we're actually making use of the
conditionals we can specify the rules
for specific configurations we creates a
specific table for example per se there
are these comma column families that we
actually have specified in here then we
create the rules corresponding that will
actually specify supervisors rule we
have created a rule for example create
supervisor and once you have the rule in
place then you can actually assign the
corresponding tables to those rules now
if you actually what kind of operation
do you want to perform that's based on
the rules that you actually will specify
on those specific column families for
example if you actually want to make any
changes if you want to modify then you
make use of to modify current and then
if you actually just want to make use of
selects I read all the rule you give him
you assign him with the Select so it's
very simple card modify this is the rule
right this is the permission ORN which
column family do you want to specify the
column family is orders and what is the
role this is the role name now once you
actually have the rule name you can
specify the credentials you can specify
these specific you can create an al ghul
that have who has the credentials and
specific conditions or a specific
credentials might be can be specified to
them so that means we can club multiple
roles together we can have multiple
conditions or conditional clubbing in
between each other the indexing is
primarily for accessing data that is
already there and you just want to
retrieve the data that's already being
specified for more faster retrieval
without actually making use of there is
the default indexing that's like what
how the allow filtering works on it
actually primarily identifies it
actually has there's actually a separate
table
that actually performs the indexing or
we can make use of the custom indexes we
create the index on our or on a specific
field and then we can delete the index
if required in case of creating and
deleting the index it always gives us an
easy solution it's always an easy way of
actually identifying or retrieving the
data from the various possible ways of
manipulators manipulations that we can
perform without making use of any of the
primary key sections well that's
primarily its what we'll be exploring
today well that's primarily it for this
module
that's my do for so I'm actually going
on to the module try you mind you that's
what we have for mindfulness right the
case study you're working in sharper
calm your company sells products
specific guitar products contain
different attributes few of them are
correct name descriptions or there might
be other fields as well for the catalog
may be huge and assumes at few years you
got funding from games yarns we expand
your business in different countries
your product or increase from 1 million
two hundred million now you're facing a
challenge that some of the products were
different from the others and have
different attributes as well youth heart
of going with cursor know it's or don't
be scalable and provides high
availability keeping all the things in
mind you must design a database schema
for products catalog and provide details
of the low mention keys primary key
partition key secondary index if any
table details metallized view if any
things you need to probably tell should
be kept in mind details by product court
works could be cell okay so now we fee
have the additional field so what we can
do is we'll have a products table will
have the time you whitey it will be the
primary it we will be IT it's the time
uit we need
then it's text and so on and so then
primary key would be time your ID sign
it's time UID so if your increments
would I need the creation date we need
the product name you need the name that
will be the second component of the
primary key then we can define some
secondary indexes we can do some
indexing on the category or brand we can
create index products plans on category
product category
product cat product banned in sprint
let's see what okay we'll have the
products product so we'll have a primary
key and that will have two different
components the partition key will be the
idea to be time UID that will actually
give us the creation date that point of
time the second will be the name of the
products that will be responsible for
sorting the data in the cluster so that
would work as the clustered key in there
for the primary key section of the
product and then we'll create two
different indexes one for category based
on the category the park and another 40
branding so the indexes will actually
help us in specifying the details in
there we might actually specify the
details in there there might be one
there might be another's product product
catalog that will be another stable then
there might be sellers that will have
the link to the tool Amana have the
product ideas so it will have different
product IDs in there so because there
might be different sellers in there so
this will actually define the
relationship from the seller to the
products then there will be product
catalog then there will be brands and it
would be brands IT theory catalog IT
so these will be a set of tables that
will have will have a product table with
a product catalog table we will have a
brand we will have brand table we will
have a seller table in here this is a
structure that might be here so in there
I will not primarily have any metallized
views I mean there aren't that optimal
they don't give an optimal performance
so we're going to we'll skip across the
emitter list view we'll only have the
secondary indexes that will actually
help us in giving an extensive
performance that's all that's the schema
I would prefer to go of it and that's
how this schema will work and it will
help us in optimizing the views thank
you again for everyone for joining in
this session I hope you have enjoyed
listening to this video please be kind
enough to like it and you can comment
any of your doubts and queries and we
will reply them at the earliest do look
out for more videos in our playlist and
subscribe to any rekha channel to learn
more happy learning