►
From YouTube: PATCH Support
Description
Shirshanka Das and Ryan Holstein (Acryl Data) give a demo of PATCH Support to the DataHub UI during the DataHub August 2022 Community Town Hall.
Learn more about DataHub: https://datahubproject.io
Join us on Slack: http://slack.datahubproject.io
Follow us on Twitter: https://twitter.com/datahubproject
A
So,
ryan-
and
I
are
going
to
talk
to
you
about
patches
because,
what's
more
exciting
than
getting
data
in,
it's
actually
fixing
it
up
right,
and
so
obviously
this
is
not
about
patchwork
on
a
carpet
or
a
rug,
but
it's
actually
the
next
thing,
which
is
the
technical
definition
of
what
a
patch
is,
and
so
for
people
who
are
familiar.
The
http
spec
supports
patch
as
a
verb.
A
You
can
actually
patch
resources
using
http
and
jsonpatch,
specifically,
is
a
spec
for
an
rfc
and
a
spec
for
using
the
http
patch
method
to
specify
deltas
on
json
documents.
So
this
could
be
sets
updates.
Ads,
removes
anything
you
can
dream
of.
They
have
figured
out
a
way
to
express
it,
it's
very
verbose,
but
it
is
a
complete
spec
and
it
works.
A
What
do
we
do
with
it?
Well,
let's
say
you
want
to
add
an
owner
to
a
data
set.
Now
there
are
two
ways
to
do.
This.
One
is
using
a
direct
graphql
api
and
if
there
is
a
specific
graphql
api
built
for
adding
an
owner,
you
can
use
it,
but
if
you
want
to
use
the
lower
level
metadata
service
apis,
the
rest
apis.
A
Typically,
what
you
have
to
do
is
first
get
all
the
owners
of
the
data
set
and
then
add
the
specific
owner
that
you
want.
So,
for
example,
let's
say
pam
was
an
owner,
a
technical
owner
for
a
data
set
d,
and
we
wanted
to
add
lin
as
a
business
owner
for
the
same
data
set
d.
We
would
first
get
the
owner's
information,
the
owner's
aspect
for
the
data
set
d.
A
It
would
come
back
as
a
json
list
with
pam
in
as
a
entry
inside
it
and
we
would
take
lin
business
owner,
add
it
on
to
the
list
and
then
write
it
back.
So
that's
kind
of
how
a
lot
of
the
existing
interactions
with
data
hub
programmatically
work
when
you
want
to
add,
add
an
owner
or
add
upstream
lineage
or
add
you
know,
make
any
mutations
on
the
metadata
model.
A
However,
there
are
problems
right
one.
Obviously
there
could
be
race
conditions
between
the
time
that
you
get
the
in
ownership
information
and
then
you
write
it
back.
Maybe
someone
else
got
added
into
the
ownership
list
and
now
you've
got
a
problem.
You
added
lynn
and
then
you
and
maybe
removed
bob
who
got
added
in
the
between
in
mid
in
the
middle
of
this
performance.
Obviously,
is
an
issue.
A
A
A
So
we're
going
from
if
people
are
familiar
with
the
metadata
change
proposal
event,
it
basically
gives
you
the
ability
to
specify
an
entity
type.
The
entity
earned
the
kind
of
change
you're
making,
which
is
right
now.
Only
support
for
upsert
is
present
the
aspect
name
and
then
the
aspect
value
which
includes
the
serialized
version
of
the
aspect,
so
we're
moving
from
there
to
support
for
patch,
and
that
means
you
can
start
adding
json
patches
in
the
value
of
the
aspect
itself
and
specify
the
change
type
as
being
an
aspect
as
a
as
a
patch.
A
So
the
new
batch
based
protocol
will
work
over
files.
It
will
work
over
kafka
and,
of
course,
it
will
work
over
the
service
api,
which
means
in
app
code.
You
can
talk
to
the
client,
sdk
and
say
hey.
I
just
want
to
add
len
as
a
business
owner
to
this
data
set.
The
client
sdk
will
do
the
work
to
generate
the
patch
under
the
covers,
send
it
over
files.
Kafka,
as
well
as
the
service
api
and
the
nice
thing
about
it
on
the
server
side,
is
that
the
final
read
modify.
B
B
A
B
Right,
sorry
about
that,
so
now
you
can
see
that
this
john
doe
is
added
as
an
owner
over
here
with
technical
owner
as
his
type
and
now
I'll
do
a
remove
of
that
owner
and
we'll
see
that
it
doesn't
actually
impact
that
data
hub
owner
on
there
right.
So
that
is
gone.
I'm
able
to
add
a
tag
with
keeping
this
legacy
tag,
I'm
able
to
add
an
owner
keeping
this
data
hub
owner
and
then
I'm
able
to
remove
that
owner
right.
A
So
what
ryan
showed
obviously
was
the
serialized
form
of
the
patches?
Obviously
we
don't
expect
everyone
to
be
handwriting.
Those
patches
so
what's
coming
to
the
sdk
on
the
python,
as
well
as
the
java
side
is
improvements
to
make
those
patches
easier
to
generate.
So
you
can
imagine
an
api
like
you
know,
a
patch
builder,
where
you
give
it
an
entity
earn
and
then
you
just
get
a
method
called
an
ad
owner,
and
then
you
give
it
an
emitter
and
it
applies
it
and
similarly
for
the
java
side.
A
A
And
then,
finally,
you
know
we
love
annotations
in
our
metadata
model
and
we
like
to
get
to
model
driven
everything,
and
so,
where
we
are
targeting
that
support
to
show
up
is
you
should
be
able
to
do
the
most
common
customizations
that
you
want
on
the
metadata
model
in
terms
of
generating
these
patch
apis
and
implementations
purely
using
the
model.
So
you
should
be
able
to
annotate
an
aspect
as
supporting
patch
supporting
certain
kinds
of
capabilities
on
those
patch
applications,
and
we
should
be
able
to
auto
generate
the
implementation
for
you.
A
So
I'm
really
excited
because
it
actually
opens
up
the
next
set
of
capabilities
in
what
you
can
do
with
the
metadata
model.
We've
always
gotten
a
lot
of
great
grades
on
being
metadata
model
driven
but
incremental
or
delta
supports
was
always
something
we
weren't
great
at,
and
I'm
really
excited
about
what
patch
support
will
bring
to
all
of
the
abilities
for
you
to
send
metadata
events
from
pretty
much
anywhere
in
your
stack.