►
Description
In this community standup, we'll be showing new features around case sensitivity and collations in 5.0. We'll also provide a glimpse into how these features were designed, and what considerations and constraints guide the EF team - performance, cross-database support, usability and more. Come see how we design EF features under the hood!
Community Links: https://www.theurlist.com/efcore-standup-2020-10-28
Featuring: Arthur Vickers @ajcvickers, Shay Rojansky @shayrojansky
#EntityFramework #EFCore #DotNet
A
A
A
A
Hello,
welcome
to
the
entity
framework
community
stand
up,
we're
back
again
with
some
more
hopefully
interesting,
stuff
on
entity
framework,
I'm
here
with
two
members
of
the
team.
We
have
jeremy
and
shai
this
week.
Maybe
some
other
people
in
in
the
background
shai
is
gonna
present
the
majority
of
this,
with
some
information
and
demos
on
collation,
for
which
I'm
gonna
hopefully
learn
some
stuff
as
well,
and
before
we
get
started,
we
have
well
as
we
get
started.
A
That's
the
idea
to
just
give
you
an
idea
of
what,
where
what
the
current
releases
are,
what
we're
working
on
you
know
what
to
look
out
for
things
that
are
relevant
today,
so
the
first
of
these
is
jeremy,
has
put
together,
together
with
the
team,
a
very
complete
survey
for
what
you
want
out
of
entertainment
core,
and
this
is
an
important
part
of
our
planning
into
ef
course,
60
and
beyond.
There's
lots
of
ways
you
can
get
to
this
survey.
A
What
I'm
going
to
show
here
and
it's
managed
to
open
in
my
stream
yard
view
again
but
we'll
deal
with,
that
is
just
a
link
to
net
ef
core.
So
this
is
dotnet
af
core
on
on
github,
and
if
you
click
on
issues
here,
we
have
three
pinned
issues
at
the
top.
The
first
one
is
the
status
update,
so
I'll
come
back
to
in
a
minute.
The
second
one
is
for
this
show.
So
if
you
have
ideas,
community
stand
up
for
guests
for
demos.
A
B
No
just
super
excited
to
get
feedback.
A
lot
of
people
have
already
responded.
We
tried
to
keep
the
survey
short,
but
there's
a
lot
to
entity
framework,
and
so
we
have
a
lot
of
questions
to
ask.
Nothing's
required
feel
free
to
skip
over
what
you
want,
but
the
team
is
is
very
committed.
The
team
spend
a
lot
of
time
thoughtfully,
producing
the
the
questions
in
the
survey
and
are
very
serious
about
taking
that
feedback
to
input
into
our
6.0
planning.
So
we
appreciate
everyone's
time
and
attention
to
that.
A
Indeed,
yes-
and
I
think
I
said
said
something
on
twitter
along
the
lines
of
don't
just
assume
that
what
other
people
want
out
of
ef
is
what
you
want.
There's
one
of
the
challenges
we
have
is
there's
so
many
features
that
people
want
and
there's
a
lot
of
variety
there
so
make
sure
your
voice
is
heard
about
what
you
think
is
important.
A
Okay,
so
what's
going
on
now?
Well,
hopefully,
you
already
know
ef
core50
rc2
is
on
is
on
nuget,
I'm
not
going
to
click
the
link
because
it
will
switch
my
windows
around
again,
but
it's
there.
Ga
rtm
is
going
to
be
out
at
dot
net
comp,
which
starts
on
november
9th,
so
that
week
you
should
see
the
rtm
we've
been
feature
complete
since
rc1,
so
rc2,
basically
just
has
bug
fixes
and
some
tweaks
to
improve,
based
on
your
feedback,
but
get
rc.
What
get
rc2
now
and
use
it
go
live
license.
A
It's
feature
complete
and
let
us
know
you
know
if
anything
breaks
or
what
you
like,
what
you
don't
like.
The
current
work
that
we're
doing
is
basically
docs,
so
we
were
attempting
to
get
everything
document.
All
the
new
features
of
ef
core
5.0
documented
by
the
release
date,
which
I
think
we're
making
good
progress
on,
and
I'm
going
to
point
to
some
of
those
links
in
a
second.
A
So,
as
I
said
at
the
beginning,
all
of
this
is
this.
This
idea
of
giving
updates
on
what
we're
working
on
comes
from
the
weekly
updates
and
if
I
go
back
to
my
edge
here
again,
like
I
said,
go
to
dotnet
af
core
go
to
issues,
there's
a
pinned
issue
at
the
top
for
the
weekly
updates,
the
the
top
part
of
it
is
basically
general
information
about.
A
You
can
link
to
find
out
all
of
the
issues
that
we
fixed
in
different
releases,
including
the
the
lts
releases,
and
then
you
can
jump
to
the
latest
update
which
will
take
you
to
the
one
from
last
week,
and
here
we
have
the
similar
information
to
what
I've
been,
what
I've
been
talking
about
and
then
often
some
other
like
more
detailed
information.
So
in
this
case
we'll
I've
linked
here
to
a
lot
of
these
documents
that
we're
working
on.
A
So
some
of
them
that
you
may
have
seen
already,
for
example,
is
we
have
this
awesome
blazer
documentation
that
jeremy
and
the
and
the
blazer
team
and
shy
worked
on
so
take
that
out.
Look
at
that
if
you're
using
blazer
with
the
af
core.
But
then
we
have,
you
know
now
documentation
for
how
to
configure
many
to
many
how
to
configure
tpt
those
kinds
of
those
kinds
of
documentation.
A
A
So
feel
free
to.
Let
me
rearrange
my
monitors
quickly,
forgive
me
so
that
I
can.
I
can
see
the
stream
yard
stuff
again,
so
that
was
that
one
yes,
so
I'm
gonna
put
this
back
over
here.
I'll
get
better
at
this,
and
here
we
are
now
I
can
now.
I
can
see
the
other
guys
so
shai
do
you
want
to
talk
about
this
a
little
bit?
This
is
a
post
about
using
azure
identity
with
azure
sql.
C
Yeah
and
in
like
two
words
when
you're
you,
when
you
use
azure
sql,
then
basically
you
have
to
do
yeah.
You
pass
an
access
token,
one
of
the
ways
to
authenticate
and
those
tokens
are
instead
of
your
username
and
password.
The
thing
is
is
that
you
also
have
to
change
them.
You
have
to
rotate
them.
The
thing
with
access
tokens
is
that
they
expire
after
a
certain
amount
of
time
and
the
whole
mechanics
around.
Managing
that.
How
do
you
manage
connections
and
change?
C
The
access
tokens
as
your
application
is
running,
is
not
a
trivial
thing,
so
here
there's
there's
a
nice
section
specifically
about
efcor.
This
is
about,
in
general,
a
library
called
azure
identity,
which
kind
of
manages
all
that
stuff
for
you.
It
also
has
a
section
specifically
about
how
to
do
things
in
if
core
this
actually
spawned
quite
a
discussion
behind
the
scenes,
and
this
will
be
improved
a
little
bit
so
performance
wise,
there's
some
things
that
this
could
do
better.
C
A
So
one
thing
that
this
blog
post
is
doing-
and
I
think,
is
part
of
the
guidance
that
we
we
give
now
is,
that
is
to
use
a
an
interceptor
to
do
this,
and
one
of
the
big
advantages
of
doing
that
is
that
the
interceptor
runs
in
an
async
context.
So
if
you
need
to
get
your
azure
token
through
async,
I
o
then
you're
not
going
to
do
with
doing
blocking
blocking
I
o
for
that.
A
C
Shy
yeah,
so
this
one
is
really
more
of
a
low
level
thing,
so
I
also
maintain
the
mpg
sequel
system,
data
driver
or
ado.
So
this
is
not
e.
Of
course.
That's
the
really
low
level
thing
that
powers
that
really
talks
to
the
database
over
the
network
and,
along
with
so
along
with
ef
core5
and
net
core
5
or
don
f5.
C
Sorry,
there's
going
to
be
an
mpg
sql
5
as
well,
and
one
of
the
major
features
there
are
that
we
are
implementing
a
big
big
like
big
new
support
for
cancellations
and
timeouts,
and
that
exploration
that
whole
subject
is
much
more
complicated
than
it
sounds,
so
what
it
basically
means.
That
is
that
you
can
pass
a
cancellation
token
to
a
command
the
db
command
and
it
will
actually
get
respected.
C
A
B
It
was
a
a
fun
short
introduction
to
ef
core.
We
showed
using
it
with
sql
server
and
with
cosmos.
It
was
great
because
I
had
some
hiccups,
you
know
forgetting
to
save
so
we
did.
Some
live
troubleshooting
had
some
some
vulnerability
exposed
there,
but
I'll
say
the
other
thing.
It's
interesting
case
of
force
for
the
trees.
I
was
so
excited
to
show
off
discriminators
and
cosmos
dbe
that
different
types
are
automatically
tagged
in
containers
that
I
didn't
think
of
the
overarching
best
practice
of.
B
If
you
have
blogs
in
cosmos
db,
your
posts
should
probably
just
be
contained
in
the
blog,
so
there
is
a
little
bit
of
that,
but
we
posted
the
updates
to
the
comments
and
for
anyone
interested
in
seeing
what
it
looks
like.
Those
parallels
between
sql
server
and
azure
cosmos
db
definitely
check
that
out.
A
Yeah,
I
really
I
really
enjoyed
this.
It
was
really
good
that,
despite
the
pain
that
jeremy
went
by,
not
saving
the
power
there's
a
issue,
so
blog
post
here
from
eric
ej,
so
one
of
the
things
that
we've
we've
done
recently
is
got
together
across
the
various
adr.net
drivers
and
said:
hey,
let's.
Let's
actually
let
me
take
a
step
back
here
and
talk
about
connection
timeouts
and
command
timeouts.
So
this
this
confuses
a
lot
of
people
myself
included.
A
Initially
ado.net
has
a
connection
timer
and
that's
what
typically
you
put
in
the
connection
string
historically
and
it's
the
timeout
associated
with
opening
closing
connections
and
things
like
that.
There's
also
a
thing
called:
a
command
timeout,
which
was
not
previously
possible
to
set
in
the
connection
string
and
had
to
be
set
by
a
property
on
db
command,
the
command,
timeout
property,
and
that
was
a
separate
timeout
for
when
you're
executing
that
command
so
separate
to
the
one
related
to
the
connection.
A
So
what
we've
done
is
get
together
with
bradley
granger
and
bryce
and
shai
and
other
people
around
the
ecosystem,
who
have
ado.net
providers
and
created
a
common
way
to
now
set
the
command
timeout
in
the
connection
string,
which
stops
you
having
to
like
get
hold
of
your
db
command
and
set
it
explicitly
or
go
through
an
af
api
to
do
it
or
whatever,
and
we
want
to
make
sure
we
try
and
do
this
consistently
across
across
ado.net
providers.
So
eric
sent
a
pr
into
for
microsoft,
data
sql
client
there
for
sql
server.
A
A
So
many
thanks
to
eric
for
that,
and
we
already
talked
about
the
survey.
It's
already.
It's
also
on
the
on
the
blog
here,
so
you
can
get
to
it
through
that.
If
that's
easier
for
you,
please
do
that
and
then
this
is
the
documentation
on
collations
and
case
sensitivity
and
remember,
I
was
showing
you
links
to
the
docs.
This
is
one
that
shy,
wrote
quite
quite
a
while
ago.
Now,
actually
it
was
originally
written
and
then
I
think
updated
as
we
did
more.
A
C
Okay,
so
yeah
I've
been
wanting
to
do
this.
This
kind
of
mini
talk
for
a
while.
This
is
about
a
feature,
basically
we're
talking
about
something
called
collations,
which
I'm
sure
most
people
aren't
very
aware
of,
but
basically,
let's
talk
about
it
in
terms
of
case
sensitivity
and
case
insensitivity.
So
if
you're
comparing
strings,
are
you
using
them
with
case
or
without
case
I'll,
say
two
things
about
this
before
diving
into
code?
This
is
all
going
to
be
about
code.
C
First,
it's
not
like
one
of
the
large
features
being
being
published
being
released
now
with
ef45.
This
is
not
like
a
many-to-many
thing,
which
you
know
is
a
huge
splash
or
whatever
it's
it's
a
minor
thing.
It's
it's
a
small
thing.
The
second
thing
I'm
going
to
say
about
it
is
anybody
who
has
who
knows
about
collations,
probably
regrets
that
they
know
about
collations.
Nobody.
C
Happy
to
have
known
to
have
encountered
collations
or
case
sensitivity,
it's
like
an
infamous
point
of
pain
for
everybody
in
the
world.
So
if
you
have
no
idea
what
I'm
talking
about
good
for
you,
I
I
really.
I
really
wish
for
you
that
you
don't
have
to.
However
we
this
is
a
subject
that
you
know
programmers
have
to
deal
with
a
lot,
unfortunately,
because
human
languages
are
messy
they're,
not
like
computer
languages.
C
Unfortunately,
so
I'm
going
to
switch
over
to
my
code
right
away,
jeremy,
if
you
can
do
the
same,
and
let's
start
by
looking
at
some
code,
so
the
whole
thing
is
going
to
be
around
code
first.
So
this
is
a
very
small
code
sample
I'm
going
to
go
through
this.
It
shows
some
very
cool
things
coming
in
in
ef,
ef,
core
five
so
and
then
dotnet
five.
Actually
so
the
first
thing
that
you
can
see
which
is
kind
of
weird,
I
wonder
how
many
people
know
about
this.
C
There
is
no
program
class
and
there's
no
static
void
main
function
here.
So
those
are
those
of
you
who
have
been
following
c
sharp
nine.
You
guys
are
probably
aware
this
is
what's
called
top
level
statements,
a
very
cool
feature
in
coming
in
c,
sharp
nine
like
right,
like
in
a
couple
weeks,
basically,
instead
of
all
the
ceremony
of
having,
if
you
want
to
do
like
a
small
program
like
what
I'm
doing
here,
there's
no
need
for
all
that
ceremony,
the
class
with
the
program
and
all
that
kind
of
stuff.
C
You
can
just
write
your
program
as
it
is
at
the
top
level,
no
namespace,
no
class,
no
method.
I
love
it.
It's
perfect
for
samples,
it's
perfect,
for
you
know
demos
things
like
this
and
it's
perfect
for
little
scripts.
You
can
use
c-sharp
in
a
kind
of
a
scripty
mindset,
all
of
a
sudden
which
is
new
in
this
in
this
kind
of
world.
Anyway,
that's
top
level
state
pass.
C
A
C
C
Just
so
you
know,
so
I'm
in
the
clear
I'm
doing
things
right.
Basically,
we
create
the
context
we
immediately
delete
and
create
the
database.
So
every
time
I'm
running
this,
it's
going
to
re
like
recreate
the
database.
That's
going
to
be
useful.
We
have
a
very
simple
trivial
kind
of
query:
we're
basically
looking
at
our
blogs,
we're
going
to
select
and
filter
out
all
the
blogs,
whose
name
is
who
note
the
case
lowercase
through
very
important
today.
B
A
A
A
A
C
Anyway,
so
we're
basically
just
selecting
these
blogs,
whose
name
is
foo
and
we're
counting
them
we're
going
to
output
that
to
the
to
the
you
know,
to
the
console.
Our
blog
context
is
pretty
simple,
so
we
have
a
db
set
of
blogs.
We
have
our
options
builder.
We
configure
sql
server.
Oh
there's
a
weird
thing
here,
so
that's
going
to
allow
me
to
talk
about
another
cool
5.0
feature
this
time
in
eve
core.
C
So
this
is
what
we
call
simple
logging,
it's
not
yet
documented,
but
it's
soon
going
to
be
documented,
so
obviously
you've
always
been
able
to
log
from
ef
core.
Obviously
it's
always
been
there,
but
it's
been
a
little
bit
difficult.
You
you
had
to
do
a
lot
of
ceremony
and
there's
been
some.
You
know
some
catches
around
it,
so
this
is
something
that
arthur
did
in
this
release.
Basically,
a
one
line
thing
just
tell
it
log
to
console
write
line,
tell
it.
I
want
information
level.
C
Logging
you're
done
so
this
is
again
incredibly
useful
for
starting
up
when
you're.
You
know
when
you
want
to
do
a
sample
or
you're
starting
up
some
some
new
project.
You
don't
have
to
mess
around
with
the
you
know,
the
dependency
injection
or
anything
that
anything
else.
That's
related
to
the
logging,
so
very
nice
little
feature
that
everybody
can
use
to
quickly
get
up
to
speed.
A
Yeah,
so
on
the
dock,
I
think
that
doc,
that
an
early
version
of
documentation
is
live,
but
the
the
rest
is
written
and
just
in
pr
waiting
for
me
to
have
time
to
clean
it
up
and
push
it.
But
we
show
in
that
documentation,
jeremy,
an
example
where
we
write
to
debug
the
the
debug
output
in
visual
studio,
or
we
write
to
a
file
to
get
a
quick
login
to
a
file.
So
it's
pretty
flexible,
it's
the
kind
of
the
moral
equivalent
of
the
database
dot
log
from
ef
ef6.
A
Although
it's
it's
it's
more,
it's
it's
more
flexible
and
powerful
in
some
ways,
less
flexible
in
other
ways.
But
then
that's
okay,
because
ef6
really
didn't
have
any
good
logging,
whereas
af
core
has
the
microsoft
extensions
login,
which
is
very
powerful,
integrates
with
ceralog
or
whatever
you
want
to
use
and
really,
I
would
say,
if
you're
doing,
logging
in
your
application.
It
probably
makes
sense
to
set
it
up
to
go
through
that
mechanism
and,
like
shy,
said
this.
C
B
A
C
A
C
Who
knows
anyway,
I'm
gonna,
I'm
gonna
go
on
a
little
bit,
so
if
you
notice
so
in
my
on
model,
creating
I'm
going
to
see
the
single
blog
into
our
database,
it
has
a
name
foo
note
once
again,
the
foo
here
and
the
foo
here
are
not
the
same
food
there's
a
case
difference.
We
are
going
to
get
to
that
very
soon
and
last
but
not
least,
is
our
actual
entity
class
with
an
idea
and
a
name
and
here's
our
third
feature.
C
That's
coming
for
ef
ef5,
so
we
did
not
introduce
index
support
in
ef
core5
because
it's
been
there
you've
been
able
to
create
indexes
for
a
while
and
since
forever.
However,
what
we
do
have
is,
you
can
now
introduce
them
with
attributes.
So
this
is
an
attribute
that
we
use
on
the
blog
to
say:
please
create
an
index
on
name
previously.
You
would
have
to
go
into
your
on
model,
creating
and
use
the
fluent
api
to
do
this.
Some
people
really
love
attributes
instead
and
that's
fine.
C
We
we
want
to
help
those
people
out
too,
so
you
now
have
this
this
option
as
well.
So
our
name
field,
which
is
the
thing
that
we're
going
to
be
select
filtering
on
now,
has
an
index
which
is
obviously
kind
of
tells
you
what
is
coming
right.
So
I
hope
this
sample
is
is
clear
to
everybody
and
we
can
start
actually
talking
about
what
happens
here.
So
the
question
is:
what's
actually
going
to
be
the
result
of
this
statement
right,
it's
the
most
trivial
program
you
can
ever
do
and
the
answer
is.
C
Unfortunately,
it
depends.
That's
the
answer
that
nobody
likes
to
hear.
So
I
actually
literally
cannot
tell
you
exactly
what's
going
to
result
here,
because
the
answer
depends
on
which
database
you're
using
it
turns
out
that
sql
server
is
a
case
insensitive
database
by
default.
So
if
I
run
this
with
sql
server,
let's
just
do
that.
I'm
going
to
actually
start
running
stuff,
hopefully
nothing
crashes.
C
Okay,
so
you
see
our
sql
coming
out
as
expected
and
we
got
one
blog,
and
this
is
showing
you
that
sql
server,
just
like
that
by
default
is
case
insensitive
because
these
do
not
actually
match
completely
they're,
not
an
ordinal
match
they
only
match
in
a
case
in
sensitive
environment.
However,
if
I
switch
this
around
and
use
the
npg
sql
driver
which
connects
to
my
postgres
database,
it's
going
to
be
the
same
thing
running
I'm
going
to
get
zero
blocks,
so
this
is
already
a
non-ideal
situation.
C
Some
people
come
to
ef
core,
with
an
expectation
that
it's
going
to
make
the
world
like
whatever
database
you're
on
the
world
is
going
to.
You
know,
behave
the
same
and
look
the
same
where
some
people
expect
us
to
kind
of
cover
over
all
the
differences
between
the
databases
and
as
you
can
see,
we
don't
do
that.
So
we
do
that
when
it's
possible,
but
we
cannot
coerce
one
database,
the
for
example.
We
cannot
go
to
sql
server
and
coerce
it
to
always
be
case
sensitive
right.
That's
not
its
natural
behavior
and.
C
C
Yes,
exactly
it
will
do
that
and
besides
there's
lots
of
people
out
there
using
existing.
You
know,
sql
server
databases
and
the
reporting
programs
and
their
logic
is
case.
Insensitive
because
that's
what
the
default
sql
server
is,
so
it
doesn't
make
any
sense
for
us
to
say
no,
we've
decided
to
make
the
world
case
sensitive
or
or
case
insensitive
for
that
matter.
So
we
don't
do
that
and
that's
that's
an
important
kind
of
thing
so
now
for
the
ef
core
five
feature.
C
Finally,
because
all
this
has
been
like
just
an
introduction,
so
what
if
I
st
if
I
do
want
to
have
a
sql
server,
but
I
want
my
my
searches
to
be
case
sensitive,
so
there's,
of
course,
there's
a
trick
for
this
that
we
introduced
for
you.
Let
me
just
copy
paste
that
for
you,
so
this
is
the
new
the
new
stuff
right.
If
you
look
at
this,
this
is
escort
five.
You
can
use
this
if
you're
on
the
rcs.
C
This
is
a
new
thing
where,
when
I'm
configuring
my
model,
I'm
telling
ef
that
the
collation
to
be
used
at
the
database
level.
Is
this
gibberish
right
here?
You
don't
really
have
to
understand
this.
It's
it's
a
code,
but
the
point
here
is
that
we're
applying
it
to
the
database
as
as
a
whole
to
the
entire
database.
C
What
is
happening
here
so
each
database
has
its
own
naming
schemes
for
these
things
called
collations.
We
don't
really
care
the
cs
that
you
see
here
means
case
sensitive,
the
as
means
accent
sensitive,
so
it
cares
about
accents
and
it
cares
about
case,
unlike
the
default
collation
right,
let's
run
this
program
now,
as
is
oop.
Of
course.
I
have
a
problem.
I
have
a
problem
because
I
forgot
to
switch
back
to
sql
server
and
and
that
collation
doesn't
work
for
npg
sql.
B
C
A
A
A
So
you
get
something
which
kind
of
looks
like
it
works
the
same
across
all
databases
until
you
get
some
special
character
which
isn't
treated
the
same
or
some
language
which
isn't
treated
the
same
and
then
and
then
your
your
your
behavior
across
your
databases
is
different
again
so
rather
than
try
and
make
an
abstraction
which
we
think
will
probably
fail,
because
when
you
typically
are
doing
this,
you
really
care
about
the
what
what
you're?
Comparing
that's?
A
Why
you've
bothered
to
you
know,
do
the
collations
and
learn
about
it,
so
it
actually
becomes
a
very
difficult
problem
to
to
create
a
simple
abstraction,
we're
not
totally
ruling
that
out
in
the
future.
If
we
find
common
enough
cases
where
there's
common
enough
behavior
of
databases-
maybe
we'll
do
something,
but
for
right
now,
rather
than
try
to
create
something,
that's
going
to
be
a
pit
of
failure
for
people
because
they
won't
really
understand.
A
What's
going
on
we're
making
it
so
that
if
you're
using
sql
server,
you
choose
what
collection
and
if
you're,
using
postgres,
you
choose
what
creation.
And
if
you
have
an
application
that
uses
both.
Then
we,
you
can
easily
write
conditional
code
that
says
on
postgres
use
this
on
a
sql
server.
Do
that,
but
then
you're
making
an
explicit
choice
that
you
consider
these
these
things
to
be
the
same
enough,
that
they
work
for
your
application,
so
that
that's
kind
of
what
I
meant.
C
Yeah-
and
I
think
it's
a
great
example
again
of
how
we
don't
we
don't
try
to
abstract
away
things
and
hide
things
in
general
at
all
cost.
We
can
do
that
where
it
makes
total
sense,
but
we
really
try
to
avoid
doing
it
when
it
doesn't,
and
I'm
just
I'm
gonna
use
this.
I
was
thinking
of
talking
about
this
a
bit
later,
but
you
know
what
what
arthur
just
said
is
a
good
segue
into
this
collations
again
are
not
just
about
case
sensitivity,
so
collations
is
an
abstract
concept
which
basically
tells
you.
C
How
do
I
compare
two
strings
and
also
how
do
I
order
them
like
in
what
order
do
I
sort
them?
There's
very
weird
things
there.
So
it's
there's
case
sensitivity.
Of
course,
there's
also
accent
sensitivity,
so
anybody
coming
from
you
know
non-english
languages.
Basically,
as
usual,
you
have
the
same
letter,
but
you
have
some
squiggly
over
it.
C
Should
that
be
taken
into
account
when
you
are
comparing
letters,
the
answer
is:
it
depends
once
again
that
the
answer
nobody
likes
in
some
applications
and
context
you
you
definitely
want
it
to
matter
and
others
you
don't
want
it
to
matter.
So
that's
a
choice
that
you
have
to
make
as
a
developer
for
for
each
and
every
part
of
your
application
by
the
way
and
one
one
favorite
story
of
mine,
I
just
I
can't
resist.
C
C
People
maybe
already
know
what
I'm
going
to
talk
about,
because
I
think
turkish
is
a
little
bit
famous
in
this
field
of
galatians.
Basically,
it
turns
out
that
in
turkish,
this
is
not
the
uppercase
version
of
this.
They
actually
in
turkish.
You
actually
do
have
two
eyes:
one
has
a
dot
at
the
top
and
another
one
has
does
not
have
the
dot
and
they're
pronounced
differently
and
the
the
uppercase
version
of
this
looks
like
this,
but
it
actually
has
a
dot
over
the
uppercase
thing
there
right.
C
So
that's
pretty
crazy
and
it's
what
it
shows
is
that
the
whole
concept
of
saying
just
do
a
you
know
a
case.
Insensitive
comparison
doesn't
mean
anything.
In
fact,
you
have
to
know
which
language
you're
in
or
which
collation
you're
in
to
be
more
precise.
In
order
to
even
talk
about
these,
these
things
right
so
yeah
human
human
languages.
A
C
Actually,
that's
a
great
idea
and
there's
a
whole
database
aspect
to
date
times
and
mismatches.
Yes,
okay,
I'm
gonna
move
on
now
because
anyway,
so
I'm
going
to
run
this
again,
we've
defined
the
collision
at
our
at
the
database
level
and
all
of
a
sudden.
We
have
a
postgres
result
here,
although
we're
running
on
sql
server
right,
so
we've
configured
the
database
to
be
case
sensitive
now,
which
is
weird.
C
This
is
the
opposite
of
what
sql
server
usually
does
I'm
going
to
scroll
up
here
a
little
bit
and
all
this
logging
stuff
that
you
see-
and
you
see
that
now
we
have
this-
create
database
here-
that
we
we
did
that
he
of
course
sent
for
us
to
be
precise
and
all
of
a
sudden
there's
a
clause
on
create
database.
That
tells
it
to
just
add
the
collation.
That's
all
it
is
basically
is
to
tell
sql
server
up
front.
Please
use
in
you
know
a
case
a
case,
sensitive
collation
or
whatever
collision.
C
C
Absolutely
so
did
you
really
have
to
raise
that
question?
Yes,
it's
important,
so
sql
server
actually
does
support
modifying
the
database
collection
after
the
fact,
so
you
can
alter
the
the
the
collision
and,
in
fact,
if
you
have
an
existing
database,
you
have
everything.
You
know
you
have
a
model
and
you
have
a
database,
and
you
add
this
line,
which
I
just
added
and
you
create
a
migration
you're
going
to
actually
see
us
altering
the
database
and
changing
the
collation.
C
However,
that's
something
where
I
really
really
recommend
reading
the
sql
server
docs
before
you
do
it,
because
it
has
some
some
tricks
and
complications.
Obviously,
you
can
understand
that
this
this
thing
has
to
go
and
change
a
lot
of
things
in
your
existing
database
right.
It's
not
just
a
bit
that
you
flip
somewhere.
It
could
impact
it
will
impact
indexes
and
things
as
we
will
soon
see.
So,
if
you
want
to
change
your
database,
collation
be
very
wary
and
do
this
slowly.
That's
that's
all
I'm
going
to
say
about
the
subject.
A
C
C
Absolutely
so,
but
even
before
we
talk
about
the
query,
a
more
common
scenario
is
that
maybe
we
have
the
database
I'm
going
to
comment
this
out
and
sql
server
is
case
and
sensitive
and
that's
fine,
but
we
just
have
a
column
in
there
or
maybe
some
columns
that
we
want
to
make
case
sensitive.
So
not
the
you
know,
not
all
columns
are
created
equal
and
not
all
of
them
deserve
the
same
collision.
The
same
case
sensitivity
strategy,
so
we've
also
added
that
for
you
as
well,
and
that
can
be
easily
done
as
follows.
C
So
what
we're
doing
here
this
should,
I
hope
this
is
familiar
to
anybody
who's.
Who
has
a
bit
of
experience
with
you.
Of
course,
we
basically
take
the
the
entity,
the
blog
and
we
drill
in
we
go
to
configure
a
specific
property
on
that
block,
the
name
property
and
on
that
property.
This
is
the
new
stuff.
Here
we
tell
it
to
use
the
same
collation
so
again,
the
same
cryptic
code
just
applied
to
the
column
instead
of
the
entire
database.
C
C
And
so
you
see,
we
still
have
the
same
result.
We're
still
doing
case
sensitive
comparisons,
but
if
we
scroll
up
then
now
what's
changed
is
not
the
create
database,
it's
the
create
table.
Probably
so.
This
is
a
pretty
niche
kind
of
feature.
I'm
guessing
not
a
lot
of
people
knew
that
they
could
do
this,
but
it
turns
out
that
in
most
databases
you
can
you
have
this
cloth
here
after
the
type
of
the
the
the
column
which
is
text
in
this
case
you
can
specify
which
collision
it
has.
C
This
is
like
a
facet
of
the
column,
it
sticks
with
the
column
and
it's
going
to
affect
any
operation
that
you
perform
on
the
column.
That's
that's
pretty
important
right
and
one
thing
so
we've
been
talking
a
lot
about
case
sensitivity
and
everything.
This
also
affects
sorting.
I
mentioned
this
at
some
point,
so
collation
also
tells
you
where,
to
put
so,
which
character
comes
first,
like
think
about
the
phone
book.
How
do
you
like
order
the
phone
book
and
now
think
about
how
you
order
the
phone
book
with
languages
that
have
squigglies
on
them?
C
Do
the
letters
with
the
squigglies
come
before
or
after
or
what
what
goes?
Which
squiggly
comes?
You
know
which
quickly
comes
before,
because
there's
multiple
squigglies
that
can
appear
on
a
single
letter,
so
this
is
all
very
complicated
and
this
is
going
to
affect
your
order
by
clause.
So
if
you
order
by
the
name,
then
that's
going
to
actually
determine
the
way
that
you
know
things
come
out
of
the
database.
C
What's
the
the
usual
pattern
for
doing
this,
I'm
gonna
switch
this
around
back
to
postgres
for
a
second
which
is
again
case
sensitive
by
default,
and
let's
say
we
now
want
to
actually
flip
this
and
make
a
case
insensitive
kind
of
thing.
So
if
I
want
to
force
the
database
to
do
a
case,
insensitive
thing-
and
I
don't
have
this
nifty
cool
ef
corcolation
feature
the
usual
thing
that
we
do
is
it's
very
simple:
I'm
just
going
to
code
it
like
this.
Every
developer
has
done
this.
C
You
just
go
like
this
right
yep
I
mean
I'm
happy,
I'm
happy.
People
are
chuckling,
but
it
actually
is
pretty.
I
mean,
let's
face
it,
if
we're
doing
c
sharp
like
normal
c
sharp.
This
is
not
necessarily
bad.
It's
it's
fine,
it
could
be
fine,
it
could
be
bad.
I
don't
know
so.
The
thing
is
so
now,
I'm
in
postgres
I'm
going
to
do.
C
Control
f5
here
gonna
run
this
and
I
can
see
that
now
our
case
insensitive
as
we
wanted
so
again,
post
just
by
default,
is
case
sensitive,
but
we've
just
modified
that
in
the
query
itself
and
we've
done
that
very
easily
we've.
If
you
look
at
your
sql,
what
you
now
see
is
this
thing,
so
we've
ef
core
translates
this
two
lower
this.net
function
into
a
very
similar
function
on
the
database
side
and
postgres
called
lower,
and
because
we
lowercase
this
that
becomes
equal
to
that
and
everything
is
fine.
C
So
why
do
we
need
all
this
kind?
All
this
fancy
stuff,
and
this
is
where
this
is,
where
I'm
going
to
go
into
a
little
bit
of
performance,
and
this
is
a
very,
very
important
point.
So
I'm
going
to
switch
here,
I
have
a.
I
have
a
sql
server
kind
of
console,
we're
flipping
back
between
postgres
and
sql
server,
which
is
basically
the
story
of
my
life
that
just
summarized
my
entire
life
right
there
for
the
past
since
I've
joined
microsoft.
C
If
we
look
at
this,
so
we
have
this
query,
I'm
just
going
to
run
it
just
to
oops.
I
need
to
select
my
database
bug
number
two
in
my
demo,
so
we're
on
sql
server.
We
can
see
the
result
here.
Sql
server
has
this
feature
where
we
can
tell
it
to
tell
us
how
it's
going
to
execute
the
query.
This
is
an
extremely
important
thing.
This
is
maybe
the
most
important
thing
I'm
going
to
talk
about
in
this
in
this
presentation.
C
So
what
I'm
interested
in
is
how
sql
server
plans
to
execute
my
query.
I'm
going
to
turn
this
on
and
then
I'm
going
to
run
it
instead
of
the
actual
response,
I'm
seeing
this
complicated.
Looking
thing,
this
is
something
that
anybody
who
does
database
with
a
little
bit
of
perf
sensitivity
should
probably
get
familiar
with
in
your
in
your
specific
database.
All
databases
have
some
sort
of
you
know
feature
for
explaining
to
you
how
things
work,
how
your
queries
are
going
to
work.
C
C
What
the
this
version
basically
is
using
the
index
that
we've
defined
remember
with
the
cool
new
attribute
from
e45,
so
this
uses
that
index
and
this
doesn't
use
that
index,
if
you
think
about
it
for
a
second
that
kind
of
makes
sense,
because
the
index
doesn't
know
about
the
lower.
The
lower
is
something
that
I
integrated
in
my
query,
but
the
index
has
been
prepared
well
in
advance.
C
If
I'm
just
asking
what
is
equal
to
foo,
then
we
can
just
use
that
index
and
jump
into
the
correct
place
in
the
index
and
and
so
on,
and
do
do
everything
that's
needed
to
be
done.
But
if
I
do
this
because
I'm
I'm
I'm
gonna
filtering
and
filtering
on
the
result
of
a
function,
we're
obligated
to
go
through
the
entire
table
and
we
can't
really
use
the
index.
So
there
is
the
word
index.
C
B
A
C
So
I'm
going
to
be
very,
very
technical
here.
What
this
does
is
basically
modify
your
create
the
database
sqldl
statement
when
you
create
databases,
and
also
it's
going
to
cause,
alter
database
statements
to
be
issued.
If
you
change
your
collation,
what
then
happens
in
your
database?
So
what
the
actual
effect
is
on
existing
columns
is
going
to
be
database
dependent.
So
different
databases
are
going
to
behave
a
little
bit
differently
around
this
question
and
I'm
I'm.
C
A
C
C
So
anybody's
anybody
thinking
about
these
questions,
I
just
recommend
reading
the
docs,
so
sql
server
has
specific
docs
on
how
to
alter
your
collation
and
what
that
implies.
Go
through
those
docs
understand
them
and
then
do
that
on
pre-production
before
you
do
anything
on
life.
That's
all
I
can
say.
C
Okay,
I
wanted
to
show
the
exact
same
thing
happening
on
postgres,
because
that's
going
to
bring
me
to
another
point
and
also
I
love
this
cross
database
kind
of
thing
in
general.
So
this
is
a
postgres
window
that
you
see
here,
I'm
not
going
to
yeah.
So
we're
doing
the
same
thing
in
postgres.
Instead
of
doing
this
set
show
plan
on
kind
of
thing
we
just
prefixed
with
explain
so
same
same
thing
different.
You
know
different
way
of
doing
it.
C
So
if
I
do
this
one,
then
I
see
something
called
a
sequential
scan.
So
you
see
that
there's
a
query
plan
being
outputted.
It
doesn't
look
at
all
like
sql
server,
because
it's
a
different
database,
but
the
idea
is
the
same.
It's
going
to
give
us
an
idea
of
how
our
query
is
going
to
get
executed
and
then
I'm
going
to
go
on
the
other
one,
which
is
going
to
be
obviously
much
slower
and
find
that
we
actually
have
the
same
query
plan.
So
what
gives
so?
A
C
C
Never
ever
do
a
perf
investigation
on
a
table
with
a
single
row
in
it,
because
it's
meaningless
databases
are
very,
very
intelligent
beasts
and
what
they
do
is
they
plan
their
queries,
so
they're
going
to
execute
your
query,
also
based
on
the
data
that
they
find
inside
the
table.
What
progress
is
doing
here
is
it's
looking
here
and
it's
saying:
okay,
yeah
sure,
there's
an
index
here
that
can
speed
up
this
kind
of
query,
but
it
has
only
one
row:
I'm
not
going
to
bother
with
that
index.
C
C
I'm
just
gonna
say
that
in
postgres,
this
inserts
50
000
rows
into
this
table
and
I'm
going
to
execute
it
right
now
and
that
just
happened
in
653
milliseconds
and
my
table
now
has
fifty
thousand
rows
and
one
fifty
thousand
and
one
rows
now.
If
I,
if
I
start
to
do
this,
I'm
gonna
end
up
with
something
very
different.
C
This
this
thing
now
does
an
index
only
scan,
so
it's
using
my
index,
but
this
thing
here
is
still
doing
a
sequential
scan.
So
I
hope
this
really
should
drive
the
point
home.
This
query
is
going
over
50
000
rows
in
your
database
and
50.
000
is
not
that
much.
It
could
go
over
a
million.
If
that's
what
you
have,
whereas
this
one
is
going
over
a
lot
less.
A
Question
question
from
me
on
the
the
this
I'm
learning
so
much
here
so
when
that,
when
you
did
the
sequel,
show
the
sql
server
cache
plan
the
the
query
plan?
Is
it
not?
Does
it
not,
then
look
at
the
amount
of
data
in
in
the
rows
is
that
something
that
only
postgres
does
or
is
that
just
sql
server
displaying
the
information
differently
or
maybe
just
doing
it
in
a
different
way?
So.
A
C
C
A
A
C
Okay,
excellent,
so,
regardless
of
collations,
this
is
like
the
main
takeaway
from
this.
I
hope
any
everybody
out
there
is
kind
of
looking
at
the
actual
sql
coming
out
of
ef,
core
or
nadi,
of
course,
whatever
it
is,
that
you're
using
and
those
hot
queries.
So
nobody
cares
about
a
query
that
you
run
twice
at
startup,
but
if
you're
running
a
query
like
every
time,
somebody
you
know
gets
to
your
website
and
it's
expensive
or
potentially
expensive,
you
should
probably
be
looking
into
it
with
this
kind
of
tool.
This
is
super
important.
C
A
What
if
I
want
to
look
what,
if
I
can't
change
my
database
and
therefore
I
can't
do
an
alter
column
to
set
the
collation
on
it,
so
I
could
let
you
say
just
do
the
lower
and
I
understand
or
upper
or
you
know
it
would
basically
work
the
same,
and
that
would
work
but
not
hit.
My
index,
which
you
know,
is
a
big
problem,
but
what,
if
I
actually,
rather
than
doing
lower
upper,
I
actually
want
to
say
actually.
I
know
this.
A
C
B
C
C
For
that
that
gives
me
the
opportunity
to
anyway
so
yeah
what
arthur
is
basically
saying
what
what
happens
if
I
want
to
specify
the
specific
collision
that
I
want
inside
my
query
right,
I
don't
want
to
say
too
lower.
I
I
want
to
use.
I
want
to
specify
one
of
these
cryptic
things,
but
I
want
to
do
it
at
the
level
of
my
query.
The
reason
you
would
want
to
do
this,
but
one
of
the
reasons
you
would
want
to
do
this
also
is
that
it's
possible.
C
A
C
C
But
I
asked
you
too:
that's
nice,
so
I'm
gonna
duplicate
and
show
this
basically
the
latest.
The
third
and
latest
feature
the
last
feature,
which
is
part
of
collisions
instead
of
the
two
lower
here,
I'm
going
to
replace
this
and
I'm
going
to
use
something
a
new
nifty
thing:
I'm
going
to
use
this
new
thing
right
here
and
I'm
gonna
take
the
cryptic
code
from
down
here
and
paste
it
here
like
that,
nice
right.
C
So
what
this
does,
it's,
you
can
think
of
it
as
an
alternative
to
to
to
lower,
because
it
really
kind
of
is
rather
than
applying
a
function
to
lower.
This
will
cause
I'm
going
to
just
run
this.
Maybe
let's
go
back
to
sql
server,
because
I
don't
want
to
get
burned
by
this
sql
server
specific
relation
again.
I'm
learning.
C
C
You
see
select
from
everything
is
familiar
here,
nice
and
cozy,
but
then,
after
our
column,
here
we
have
this
clause,
which
is
super
weird,
and
this
thing
the
cola
and
this
code
binds,
if
you
will
to
the
column
here
and
bubbles
up,
so
that
this
expression
is
gonna
actually
use
this
correlation,
which
is
why,
once
again,
we
get
zero
blocks
out,
because
it's
applying
a
case,
sensitive
collation,
now
a
few
notes
about
this.
So
this
is
very
cool.
C
But
once
again,
like
arthur
said,
if
I
just
do
things
like
this,
then
I
have
the
exact
same
problem
as
to
lower,
so
I'm
not
going
to
be
using
my
index.
This
is
because
the
index
I
created
was
created
with
the
column
or
database
collation,
so
it's
already
created
it's
already
there
and
what
I'm
specifying
in
my
query
simply
doesn't
match.
So
I
can't
use
it.
So
you
have
to
be
very
careful
with
this.
C
C
I
actually
didn't
check
this
before
before
doing
so.
The
the
list
of
databases
which
support
this-
I
don't
have
off
the
top
of
my
head,
if
I
remember
correctly,
that's
postgres
and
mysql
and
unfortunately
not
sql
server.
So
you
can
leverage
this,
but
at
least
in
theory.
This
would
allow
this
this
feature
to
run
super
efficiently.
As
long
as
this
thing
happens
to
match
an
index
that
you
do
have
on
your
column,
that
index
is
going
to
get
selected
and
therefore
your
query
will
be
fast,
so
this
actually
can
be
used
safely.
C
B
C
C
Absolutely
so
the
nice
thing
about
this
is
collation
is
something
if,
logically,
you
kind
of
apply
to
your
column
or,
more
precisely,
to
your
expression,
then
what
you
do
with
that
column
or
expression.
It
doesn't
matter
it's
going
to
bubble
up
in
in,
even
if
that
column
is
inside
a
lot
of
functions
and
then
at
some
point
you
have
a
starts
with
on
what
comes
out
of
that.
The
collation.
This
is
a
bit
advanced
bubbles
up
through
that
expression
tree
and
it's
going
to
affect
that
starts
with
because
it
starts
with.
C
A
Yes,
so
what
I
was
going
to
say
is
so
going
back
to
the
the
point
about
you
may
be
able
to
write
this
and
have
it
hit
index.
Presumably
that
would
be
a
very
good
case
to
go
and
use
the
explain
or
the
other
query.
Whatever
other
query
plan
commands,
you
have
for
your
database
so
that
you
can
see
when
you
do
that
that
you
run
those
queries,
it
really
is
hitting
those
indexes
like
you
think
it
is
exactly.
C
A
C
Fail
fast,
behavior
on
any
sort
of
table
scan
a
full
table,
scan
some
tables.
If
you're
scanning
the
entire
table,
you've
basically
failed
and
your
website
is
not
going
to
work
right.
Yes,
so
I
I
I
would
propose
this,
but
I'm
you
know,
I'm
just
the
guy
doing
ef
core
and
database
drivers
so,
but
I
think
it
makes
sense
because
we
don't
have
this,
it's
our
the
the
the
you
know
the
charge
is
on
us.
A
I
I
I'm
not
a
sql
server
expert
by
any
means,
but
I
wonder
if
it's
possible
in
sql
server
to
kind
of
create
a
view
or
even
just
some
computed
columns
for
if
you
needed
different
collations,
so
you
could
effectively
duplicate.
You
know
the
data
and
get
indexes
in
that
way.
Maybe
that's
a
way
you
can
do
a
similar
thing
on
sql
server.
B
B
C
Jeremy's
jeremy's
made
a
big
mistake
here.
He's
he's
forgotten
a
letter
there.
What
is
written
there
is
not
like
it's.
I
like
yeah,
it's
it's
it's
a
it's
an
okay
mistake.
I
like
is
this
postgres
specific
construct?
It's
a
very
supposed
postgres
specific
thing.
It's
exactly
like
like,
except
it's
insensitive.
So.
C
A
it's
a
postgres
feature,
basically
that
says
do
dislike,
but
do
it
insensitively?
That's
a
great
question.
I
I'm
not
sure
I
have
the
the
answer.
I
would
assume
that
if
there's
a
collation,
if
there's
an
index
there
with
a
collation,
that's
case
insensitive,
I
like
would
at
least
be
able
to
leverage
it,
but
whether
it
actually
does.
I
have
no
idea-
and
the
answer
is
you
should
that
should
be
checked
with
explain.
A
A
B
C
So
there's
there
is
one
more
thing
I
wanted
to
say
so,
the
normal
thing,
if
you
want
case
insensitive,
match
in.net,
is
this
thing
here
so
in.net
forget
databases
for
a
second.
What
you're
supposed
to
do
is
you
have
a
string?
You
call
string
equals
you
give
what
you
want
to
compare
to
and
then
you
use
this
enum
string
comparison
to
say
I
want
an
ordinal
but
ignores
case
comparison.
C
This
is
the
idiomatic
normal
way
to
express
this
in
c
sharp
and
we've
received
a
lot
of
requests
to
to
allow
that
we've
received
them,
among
other
things,
because
this
was
allowed
in
back
in
ef6
and
people.
Porting
code
had
trouble,
you
know
putting
their
code,
but
but
a
deeper
reason
is
that,
basically,
this
is
the
way
you
would
program
this
in
c
sharp.
So
why
not?
Let
people
just
do
this,
you
know
in
in
the
database
and
that
that's
like
I'm
going
to
get
on
my
soapbox
a
bit.
C
I
love
link
link
is
amazing,
but
it's
a
blessing
and
a
curse
at
the
same
time,
it's
a
blessing
because
it
allows
everything
happens.
You
use
the
same
constructs
in
c
sharp
to
express
things
in
the
database,
but
it's
a
curse,
because
it
also
creates
this
expectation
that,
whatever
you
do
in
c-sharp
we're
going
to
be
able
to
just
you
know,
do
for
you
on
the
database.
C
C
So
then
people
ask
but,
but
you
have
to
lower
right.
Why
do
you
translate
this?
If,
if
it's
so
bad,
and
the
answer
for
that
is,
when
you're
doing
too
lower
you're
doing
something
very
explicit,
so
there's
you're
applying
a
function
and
there's
a
certain
expectation
that
it
kind
of
pops
out
at
you,
you're,
applying
a
function
and
therefore
there's
a
problem
with
index
usage.
If
you
know
databases,
then
that's
something
that
that's
supposed
to
like
tickle
you
in
a
way,
whereas,
if
you
look
at
this
code,
there's
nothing
about
it.
C
That
seems
to
even
suggest
that
it
could
run
in
an
efficient
way
and
that's
the
crux
of
the
matter-
and
this
is
maybe
something
that
well,
we
talk
about
a
lot
with
our
users
on
github.
We
try
very
hard
to
never
make
a
simple,
intuitive
basic
c-sharp
construct,
translate
in
a
way
that's
going
to
really
mess
up
your
performance,
so
we
want
the
normal
idiomatic
code
to
be
reasonable
in
terms
of
in
terms
of
perf.
Of
course,
it
has
to
provide
the
correct
results.
C
That's
the
the
most
important
thing,
but
it
should
also
provide
reasonable
perf,
and
this
is
something
that
a
lot
of
people
it
takes
them
some
time
to
actually
understand
this
kind
of
point.
So
it's
fine.
If
you
opt
into
something
which
makes
you
not
use
an
index,
that's
completely
fine
and
we're
giving
you
all
the
tools
to
do
that,
but
you
have
to
do
the
opting
in,
and
it
has
to
be
very,
very
clear
in
your
code
when
somebody
else
is
reviewing
your
code.
It
has
to
kind
of
pop
out.
C
A
Yeah
that
and
that
ties
back
very
very
nicely
to
what
we
were
talking
about
right
at
the
beginning,
because
I
was
bringing
up
the.
Why
don't
we
just
completely
abstract
this
out
and
that's
the
the
the
api
there
that
she
showed
you
know
with
the
case?
Insensitive
comparison,
that's
that's
exactly
the
api
where
doing
it
and
an
abstract
way,
which
I
just
talked
about,
we
think
would
not
be
helpful
in
the
long
run.
It
would
not
create
a
pit
of
success.
It
would
create
a
pivx,
a
sailor
of
people.
A
Writing
queries
that
didn't
perform
without
them,
having
an
understanding
of
why
it's
a
it's,
a
difficult
balance
to
make
between
the
level
of
abstraction
and
where
it's
okay
for
it
to
be
different
on
different
databases
or
where
it's
okay
for
us
to
do
something.
You
know
again,
arguing
that
too
lower,
which
I
agree
with
is
explicit
and
the
other
one
isn't,
I
think,
is
a
good
argument.
A
So
you
don't
have
to
have
them
clutter
your
logs,
but
we
try
and
put
those
warnings
in
there
just
so
that
if
you're
not
aware
that
you're
doing
collate
in
a
query
and
that's
gonna,
you
know
destroy
your
index
and
I'm
not
sure
if
we
have
a
warning
for
that
or
not.
But
I
think
if
we
don't
it's
on
the
backlog,
then
then
we
at
least
try
and
give
you
that
in
in
your
logs.
A
That's
why,
except
your
message
review
that
the
team's
been
working
hard
on
is
so
important
too,
because
it's
good
exceptions
are
yes.
If
you've
used
the
old
stack
and
you've
got
exceptions
like
the
metadata
at
line
406
in
edmx
doesn't
have
this
thing
that
you've
never
heard
of
then
you'll
you'll
understand
bad
exceptions
very
well.
B
C
B
C
That's
obviously
a
very
database
specific
question.
There's
no
answer
in
the
abstract.
Every
database
has
some
sort
of
explain
or
show
query
plan
kind
of
thing.
Sql
server,
which
I'm
not
an
expert
at
has
a
profiler,
so
you
can
actually
see
you
can
connect
to
your
sql
server
database
and
you
can
see
the
query
streaming
in
and
you
can
see
how
they're
doing
at
least
in
terms
of
times.
C
A
A
Let's
because,
like
shai
says
this
is
a
very
service-specific
so
for
sql
server,
it
outputs
a
query
which
defines
the
parameters
and
the
query
in
a
way
that
you
can
copy
and
paste
into
sql
server
management,
studio
or
your
tool
of
choice,
execute
it
and
then
use
that
to
get
statistics
on
the
query
plan
and
all
of
those
kind
of
things
and
that's
also
visible.
If
you're
just
debugging
your
application,
you
can
you
can
open
up
your
link,
query
and
there's
a
debug
view
under
there
and
and
in
there
there's.
A
If
you
really
want
tpc
be
sure
to
go
vote
for
the
issue
on
github.
So
so
we
know
that's
what
you
want
you
know
personally,
I
I
would
be
disappointed
if
we
don't
do
tpc,
because
I
feel
that
tpc
often
is
a
better
strategy
than
tpt.
While
tph
is,
I
think,
usually
the
the
the
the
default
that
you
should
go
with,
but
that's
very
controversial
to
me.
Tpp
is
usually
the
default
you
shouldn't
go
with
and
you
should
either
do
tph
or
tpc.
A
That
being
said,
you
know
we're
not
just
driven
by
what
I
want
we're
driven
by
what
customers
want.
So
we'll
you
know
vote
for
it.
If
you
want
it
async
streaming,
I'm
not
really
sure
what
that
means,
but
iasync
innumerable
has
been
in
since
dot
net
core
3
0.
I
think,
and
we
support
it
in
ef
core
301.
So
so
it's
in
31
and
5.0
view.
A
We
have
some
additional
support
for
views
in
5.0,
in
that
you
can
now
map
a
query
to
a
view
and
still
do
updates
to
the
table,
and
that's
super
easy
to
do.
You
just
need
to
do
a
two
query
or
two
view,
or
something
like
that.
I
can't
remember
the
exact
apis,
so
we
have
that
still
still
views
is
one
of
those
things
which
is
very
there's
many,
many
things
related
to
views
that
we
could
do
so.
That's
another
thing
where
go
to
github.