►
Description
Presented by Javier Fontan, Senior Software Developer, source[d]
At source{d} we analyze a huge amount of git repositories and extract insights on source code. To do this we have created a powerful engine for language-agnostic analysis of your source code and git history. The git history part of the analysis is handled by Gitbase, an SQL database engine that is able to understand git repositories and is MySQL protocol compatible. You'll learn about our journey, from what began as a side project to the current state, its internals and the different solutions we approached.
About GitMerge
Git Merge is the pre-eminent Git-focused conference: a full-day offering technical content and user case studies, plus a day of workshops for Git users of all levels. Git Merge is dedicated to amplifying new voices in the Git community and to showcasing the most thought-provoking projects from contributors, maintainers and community managers around the world. Find out more at git-merge.com
A
Hi,
it's
been
told,
I've
been
going
to
talk
about,
get
base
and
show
you
little
bit
what
it
can
do
and
how
it
does.
This
search
is
that
you
can
do
so
before
going
to
get
base
itself
I'm
going
to
tell
you
a
little
bit
what
we
do.
So
you
understand
why
we
did
it
at
source.
We
make
tools
to
do
large
skills,
code,
analysis
and
machine
learning
on
source
code
and
all
of
the
projects
I'm
going
to
talk
about
is
open
source.
A
All
the
tools
that
fit
into
searching
into
git
repositories,
analyzing
source
code,
doing
queries
or
checking,
which
is
the
language
of
file,
are
behind
an
umbrella
called
the
source
engine
and
key
base.
Is
one
of
these
ones
so
get
base?
Is
a
database
server
that
uses
my
sickle
white
protocol
and
a
sequel
Lyle
dialect
to
query
git
repositories?
But
that
means
that
you
can
use
my
sequel,
clients
or
libraries
to
connect
to
it
and
use
a
comment.
A
Sql
dialect
to
do
the
queries,
you
don't
need
to
learn
another
thing.
The
other
feature
that
it
has
is
that
it
gets
information
directly
from
the
git
repositories.
We
are
not
getting
information
from
the
git
repo
and
put
it
into
a
database,
but
we
are
querying
directly
the
the
information
in
a
git
repository.
A
The
other
thing
is
that
is
read-only.
You
can
only
do
queries.
You
can
do
modifications
to
this
to
this
data.
This
is
a
usual
usage
of
the
get
base.
Do
you
provide
good
base
with
a
directory
with
repositories?
It
starts
up
and
binds
to
a
port.
Probably
you
find
these
three
3306
port
familiar.
If
you've
used
my
sequel,
then
you
can
use
my
sequel
client
to
connect
to
it.
In
this
case,
we
are
using
my
sequel,
client
that
comes
with
my
sequel
distribution
and
you
can
start
run
in
sub-queries
in
this
case.
A
I'm
running
show
tables,
and
you
can
see
the
tables
much
a
lot
of
the
objects
that
we
have
in
good
repositories.
This
is
a
very
basic
example
of
things
that
you
can
do
and
it's
example.
We
are
using
group
by
an
account
to
get
a
number
of
comedy
repository.
As
you
can
see,
this
is
very
similar
to
what
you
can
do
in
a
normal
database,
and
that
does
the
idea
that
you
don't
need
to
do
something
strange,
and
this
is
what
you
get
in
my
sequel,
client.
A
This
is
another
query
to
get
the
number
of
labs
in
the
head
commit
here,
we
are
using.
Other
features
like
join
and
filtering
were
to
get
only
the
the
reference
head
for
all
the
repositories
that
is
pointing
to,
and
this
is
the
solution
this
other
one
is
a
little
bit
more
complex,
and
here
we
are
getting
some
information
that
is
not
directly
into
the
git
repositories.
If
you
look
at
the
bottom
of
the
query,
there's
a
function
called
language.
This
language
function
can
retrieve
the
the
language
of
the
file
we
are
requiring.
A
So
in
this
way
we
can
filter
in
this.
This
query
will
filter
in
all
the
files
that
are
written
in
go
language.
Another
nice
feature
that
we
are
showing
here
is
that
this?
U
ast
function
that
is
on
top
UST
means
universal,
abstract,
syntax
tree.
There
is
an
absence
industry
modify,
so
we
can
query
these
three
the
same
way.
It
doesn't
matter
the
the
language
we
will
make
it
like
a
standardized
ast
in
this
case.
What
we
are
doing
is
we
are
filtering
only
the
the
functions
to
do
that
you
use
XPath.
A
That
is
the
one
that
deals
with
you
ASDs
that
I
told
you
before
and
and
read
that
lets
you
tell
the
source
code.
Language
of
of
the
files.
Entry
is
a
support
from
github,
so
linguist.
So
if
you're
interesting
about
it,
and
then
we
are
a
couple
of
other
projects,
palasa
and
ball
db2
create
indexes.
They
will
talk
about
key
base,
uses
Vulcan,
iterator,
modern
architecture.
That
is
the
most
common
one
for
relational
databases.
It
only
has
one
that
races
for
all
the
repository,
so
you
don't
need
to
be
jumping
between
different
databases.
A
If
you
want
to
query
things
from
different
ones
and
then
it
maps
the
basic
objects
as
stables
in
in
in
the
database.
These
are
the
basic
tables
mapped
into
into
get
base.
So
bro
your
dude,
you
already
know
about
commits
and
blobs.
So
that's
what
you're
going
to
to
get
in
the
tables,
but
then
we
have
some
relation
tables.
So
if
you
want
to
get
all
the
blobs
in
a
comet,
you
can
use
commit
blobs
to
do
this.
A
Relation
git
is
super
good
in
storing
things,
but
sometimes
it
is
not
as
good
when
you're
retrieving
them.
The
performance
is
not
always
the
best
and
what
we
try
to
do
is
to
read
as
less
objects
as
possible
from
the
front
disk.
We
we
are
using
different
techniques,
but
the
most
interesting
ones
are
well
the
first
one.
Is
we
cash
as
many
objects
as
possible
in
memory,
so
we
won't
have
to
read
them
in
and
compress
again
and
so
on,
and
so
on.
A
We
a
technical
squash
tables
and
indexes
to
understand
where
the
squash
tables
means
in
this
square.
This
query
is
getting
all
the
repositories
which
had
come.
It
has
competed
for
name
hard
one-ton
when
its
parts,
these
three
generated
and
big
specifically
does
is,
if
you
see
at
the
left,
left
side,
there
is
a
references
table
this
reps
table.
It
gets
all
the
references
from
all
the
repositories,
then
it
goes
through
AG.
A
Where
know
where
all
that
filters,
only
the
ones
that
have
a
name
head
and
go
into
the
joint
on
the
right
side,
there
is
the
comet
table
gets
all
the
commits
from
all
the
repositories,
and
then
it
goes
through
the
where
node
well,
they
are
filtered
only
the
ones
that
have
committed
all
four
names.
Have
you
frontin
go
into
the
join
and
only
the
ones
that
match
the
ref
and
the
comet
go
through.
As
you
can
see,
this
is
not
very
effective.
A
What
we
do
is
that
we
convert
this
into
a
series
of
chain.
It
are
traitors
in
the
first
one
that
is
Sun
on
on
the
bottom,
it
gets
only
the
references
from
the
head
of
all
the
repositories
we're
only
getting
one
reference
from
each
of
the
repos.
Then
we
feed
this
information
to
the
next
one,
so
it
the
comet.
It
only
gets
the
Comets
that
belong
to
these
reference
reference
and
so
on.
So,
as
you
can
see,
we
only
get
one
graph
and
one
commit
purple
repo.
A
A
They
can
be
defined
by
the
user
and
we
use
bit
on
indexes.
So
we
can
do
composing,
so
we
can
do
ants
and
orders
between
them.
We
stored
the
name
of
the
pack
file
and
also
the
offset
this
subject,
so
we
can
bypass
the
gate
in
Texas
and
we
can
go
directly
to
the
file
and
retrieve
the
object
that
we
want.
These
letters
go
around
to
others
of
magnitude
faster
in
some
queries,
and
this
is
an
example
of
a
query.
A
Well,
a
query
of
a
create
index
where
we
a
create
an
index
for
the
for
the
column,
commit
out
of
her
name
in
comets
and
that's
what
I
have
for
today.
If
you
want
to
know
something
more,
you
can
approach
me.
I
can
tell
you
a
little
bit
more
about
it,
but
you
can
also
go
to
the
2d
project
web
page
and
that's
it.
Thank
you.