►
Description
Better refuel before we get started, this is a “Choose Your Own Adventure” talk—where the audience decides into which rabbit hole(s) we go down. Writing an actual app? Sure! Type system excursions? Always? Or maybe something about our test shenanigans? And of course fields of generated code as far as the eye can see!
More on the website: http://rust.cologne/2017/03/01/web-dev.html
A
I'm
here
tonight
to
talk
about
diesel
OSE.
Oh,
it's
a
rust
library
to
implement
typesafe
secret
queries
and
it's
a
large
topic.
So
this
talk
will
be
in
a
choose.
Your
own
adventure
style,
some
slides,
contain
links
with
questions
and
you
as
an
audience
can
choose
which
topics
we
will
dive
into
next.
So
I've
never
done
this
before
and
I
hope
it
works.
So,
when
I
ask
some
questions,
they're
also
on
the
slides
just
raise
your
hands.
If
you
want
to
hear
more
about
that,
let's
give
it
a
try.
A
So
my
name
is
Pascal
half-life
I
do
web
stuff
by
day
and
rust
enthusiast
for
several
years
now
by
night,
I'm,
one
of
the
co-organizers
here
at
Rus
Cologne,
and
you
can
find
me
on
the
Internet.
My
user
username
is
usually
key,
lock
up
so
first
off
these
are
our
s.
The
domain
as
diesel
dot
RS
is
a
pretty
fancy
site.
We
have
getting
started
guides
that
you
should
probably
give
you
a
good
idea
what
diesel
can
do
and
how
you
can
use
it.
A
A
A
Took
together,
I'm
Zeus
even
as
this
afternoon,
so
no
idea
what
just
happened
our
County
supported
backends
are
Postgres
was
which
has
the
largest
feature,
set
secret
light,
which
is
great
for
embedded
applications
because
well.
Your
final
binary
also
contains
secret
light,
so
you
can
just
copy
the
binary
and
don't
need
to
setup
any
database
on
the
client
where
you
need
to
run
it
and
mice.
As
a
recent,
my
sequel,
which
was
a
bit
of
a
hassle
to
set
up
but
should
work
so
getting
started
with
diesel
shot.
A
A
Good
to
go
the
main
thing
diesel
gives.
You
is
a
really
nice
very
bitter.
That
is,
you
might
write
your
queries
in
rust
and
you
can
be
sure
that,
if
say
compile
they
run
in
production
and
do
what
you
expect
them
to
do.
You
don't
write
sequel,
but
you
can,
if
you
really
want
to,
but
most
features
are
in
the
query
builder
and
you
can
just
write
a
rust
code.
A
The
basic
usage
of
set
theory
builder
is
a
bit
like
this.
Can
you
all
reach
this?
Just
enough
contrast
all
right,
so
you
have
this
to
do
singing
and
you
call
methods
on
it.
Let's
just
think
about
to
dues
as
our
database
table
and
we
want
to
filter
it
like.
We
want
to
find
all
the
to
dues
that
are
not
done
so
we
filter
by
done,
which
is
equal
to
false.
A
A
You
might
be
thinking
well,
there's
probably
a
bit
of
more
stuff
involved.
So
here
it
is.
This
is
our
to
do
struct
and
we
derive
trade,
but
we
see
a
query
rule
and
then
we
use
in
frsky
ma
to
load
the
database
newer
from
our
database
URL
and
use
the
DSL
to
get
the
things
we
were
using.
That
is
the
truth
table
and
the
dance
field.
A
A
C
A
Obviously,
also
we
can
talk
about
everything,
but
it's
gonna
be
a
long
talk
then.
So
that's
that
with
the
DSL.
The
idea
is,
we
need
to
represent
our
database
schema
in
rust.
So,
as
you
do,
we
create
zero
size,
drugs
for
the
tables
and
for
all
the
columns
we
implement
some
fancy
traits.
We
can
use
filter
and
load
and
limit
and
such
fuzzy
structs
magic
happens,
and
we
got
our
DSL
everything
clear
so
far,
yeah
cool.
A
Then
we
have
intuitive
methods
like
a
mapping
from
from
what
you
call
select
and
sequel
is
called
select.
What
you
called
we're
in
sequel
is
filter,
limitless
limit
off
sellers
offset
and
all
that
and
the
real
magic
I
didn't
show
you,
which
was
maybe
obvious
in
the
previous
slide.
They
said
there
are
lots
of
methods
and
there
was
a
lot
of
generating
types
involved.
So
this
is
a
small
example
from
earlier
actually
generates
the
unique
type
select
statement,
type
which
I
hope
you
can
all
read.
A
It
contains
all
the
information
needed
to
generate
a
valid
sequel
statement.
So
there's
we
have
the
three
columns
in
their
sequel
type.
We
have
a
mapping
to
these
columns
in
the
structure
generator
with
idiots
a
we
are
T
to
do
stable.
We
have
no
distinct
clause,
we
have
the
where
clause
and
the
only
part
of
the
where
clause
we
are
considering
is
that
we
want
the
the
dance
column
to
be
equal
to
something
that
is
a
boolean.
We
have
no
other
clause
and
we
have
a
limit
clause
that
contains
something
like
964
I.
A
C
A
If
you
understand
this
slide,
these
are
will
make
sense
to
you,
but
you
don't
need
to
understand
it
to
use
it.
So
if
they're,
no
more
questions,
I'll,
probably
just
go
on,
but
I
thought
this
was
a
good
step,
so
this
type
can
be
turned
into
a
sequel
statement,
and
you
may
ask
yourself
some
other
questions
like
well.
It's
a
lot
of
typing
and
also
this
is
this:
what
it
makes
diesel
really
fast.
So
what
do
you
want
to
hear
about
how
to
reduce
boilerplate
or
why
diesel
is
fast?
A
Okay,
thank
you
who
wants
to
hear
about
making
this
fast
yeah,
indeed,
indeed,
so,
let's
talk
about
performance.
Everyone
wants
to
hear
about
performance,
but
it's
really
simple.
It's
just
like!
Well,
you
have
to
make
types
for
each
query
like
I
just
showed
you.
This
type
represents
exactly
this
query.
A
These
theories
can
also
contain
find
parameters
that
will
be
used
in
your
sequel,
like
if
you
want
to
represent
the
users
ID
it
it's.
It's
not
prudent
to
put
like
the
ID
one
in
the
sequel,
because
then
you
are
vulnerable
to
SQL
injections,
which
are
not
nice,
so
use
bind
parameters
to
send
the
query
and
then
all
the
parameter
Security
uses
to
your
database
and
the
first
part.
A
That
is
the
query
itself
you
can
save,
because
you
know
you
have
this
type,
and
this
type
is
a
query,
so
you
can
save
it
cache
it
and
put
it
in
what's
called
a
prepared
statement.
So
now
your
database
only
needs
to
execute
or
compute.
There
is
a
theory
pass
once
and
the
second
time
you
ask
for
a
hundred
and
done
to
deuce.
The
database
already
knows
how
to
fetch
these
two
deuce
and
it
just
needs
to
get
all
the
bank
parameters
needed
for
security,
which
in
this
case
is
none.
A
So
the
database
already
has
the
prepared
statement
and
you
just
execute
it
another
time.
So
this
is
actually
faster
than
typing
out
the
Sicari
and
submitting
it
to
the
database.
Each
time
does
it
make
sense,
yeah
so
in
case
of
queries
and
you
get
extra
performance
and
also
it's
faster
than
C,
because
usually
in
C,
you
don't
really
want
to
implement
something
like
this,
because
it's
really
really
unsafe
to
write
a
sequel
statement.
Cache
that
also
involves
getting
rows
back
from
the
database
and
because
you
don't
have
the
type
information
we
have.
A
You
need
to
make
sure
that
actually
each
row
contains
exactly
this
type
and
you'll
have
to
type
it
out
by
hand.
Basically-
and
this
would
be
really
unsafe.
So
these
are
gives
us
for
free
and
it's
that's
pretty
much
an
the
idea
Matic
way
to
use
diesel-
and
this
is
faster,
saying
everything
idea
Matic
I
have
seen
before.
A
Okay,
okay,
some
people,
so
this
will
has
a
lot
of
traits
like
well.
You
don't
want
to
know
how
many,
but
maybe
you
are
interested
in
how
using
traits
can
actually
add
stuff
to
this
API.
We
saw
earlier
like
how
is
filter
implemented
and
it's
simple.
You
write
a
trait
and
then
you
implement
it
for
everything.
A
Okay,
not
not!
That's,
not
not
really
so
simple,
but
the
idea
is
you
have
a
trait
that
adds
specific
information
and
specific
methods
to
existing
traits
and
types
which
actually
have
a
bit
of
constraints
on
them.
So
you
don't
need
to
read
that,
but
it's
basically
saying
okay,
you
have
a
theory
of
this
specific
type
and
you
can
add,
like
this
filter
DSL
on
top
of
it.
A
If
you
have
victory
resource
and
you
can
represent
the
thing,
you
implement
the
T
in
the
first
line
as
clearly,
and
that
is
also
what
I
alluded
to
earlier
by
making
the
API
documentation
a
bit
hard
to
navigate
because
the
traits
are
not,
as
you
may
have
seen
in
other
libraries
interlinked,
and
it's
obvious
that
okay,
this
type
improvement
implements
these
five
traits.
So
we
can
click
on
one
of
the
traits
and
oh,
it
returns
a
method.
That
does
that.
So
we
know
exactly
which
methods
we
can
actually
call
on
straight.
But
it's
like.
A
We
have
a
generic
implementation
and
it
fits
a
lot
of
types.
So
you
return
this
special
select
class
I
showed
earlier
and
before
calling
load
on
that,
you
may
want
to
also
add
an
offset.
We
limited
this
by
a
hundred
to
deuce,
but
maybe
you
don't
want
to
have
a
hundred
to
deuce,
but
the
next
hundred
to
do
is
like
we
like
actually
in
lofts,
that
I
just
simply
explained
what
an
offset
is,
the
second
page,
basically
of
all
to
deuce,
but
this
special
select
class
we
saw
earlier.
A
Most
of
the
things
that
can
be
Clary
has
an
offset
message,
so
you
can
use
it
and
you
don't
need
to
be
shy
and
you
don't
need
to
like
navigate
Rostock
by
yourself
and,
oh
maybe
we
can
add
that,
and
maybe
I
can
use
that
just
search
for
it
and
try
it
out.
That's
my
probably
the
most
important
advice
I
can
give
you.
A
A
A
B
A
So
one
of
the
the
cornerstones
of
how
Diesel
can
can
generate
your
queries
is
that
it
knows
how
to
transform
a
raft
structure.
You
wrote
to
something
that
secret
can
represent,
and
vice
versa.
That
is,
there
are
some
sequel
types
and
there
are
some
rough
types
and
there
are
ways
to
convert
between
them.
A
Some
examples
are
that
you
have
a
schema,
may
be
generated
and
the
schema
is
full
of
secret
types
because
it
represents
your
database
schema,
which
obviously
uses
sequel
types,
and
then
you
yourself
defined
a
structure
like
we
have
seen
earlier
the
to
do,
structure
which
uses
types
you
want
to
use.
That
is
rough
times
and
from
from
sequel
to
rust.
A
There's
a
trade
called
from
sickle
and
the
other
way
around
is
called
to
sequel,
pretty
self-explanatory,
I
think
and
most
of
these
map,
one
to
one.
That
is,
if
you
have
a
float
sequel
time,
it's
actually
an
f32
in
rust.
If
you
have
a
big
integer,
it's
a
nice
64,
but
other
types
are
not
so
simple
because
they
can
be
implemented
for
several
rust
types
like
if
you
use
a
standard
time
library
or
the
semi
standard
time,
library
or
chrono,
they
both
can
represent
a
timestamp,
and
maybe
you
can
also
put
it
into
an
integer.
A
So
you
need
to
be
careful
and
this
the
documentation
on
that
is
more
extensive,
because
the
timestamp
documentation,
for
example.
Let
me
just
open
that
over
here,
if
I
can
manage
that,
contains
the
sample
information
that
to
sequel
employees
and
from
sequel
input
both
have
two
versions
and
also
to
use
chroma.
You
need
to
compile
diesel
with
a
feature
called
Rolo,
because
it's
an
external
library-
and
we
don't
want
to
have
every
diesel
user
compiled
if
they
don't
need
to
use
it.
A
There's
only
a
quant
question,
so
I
really
need
to
take
this
link
and
it
doesn't
even
work
what
god
should've
tested
that,
but
nevertheless
it's
another
part
of
the
magic.
It's
a
table
macro
which
allows
you
to
basically
define
a
sequel
table
in
your
Rosco's,
and
this
generates
all
the
DSL
structures
we
saw
earlier.
It's
a
macro
that
is
quite
easy
to
understand.
You
just
call
table
say:
what's
the
table
name
and
what's
the
primary
key
and
then
you
map,
columns
to
sequel
types.
A
A
This
is
what
the
table
macro
expands
to.
It
introduces
two
modules:
the
columns
module
and
the
DSL
module.
It's
introducing
structs
for
all
the
fields
and
also
some
some
for
other
things
like
star,
which
is
just
like
from
select
star
in
sequel
and
table
which
is
represent,
existed
in
the
table
and
not
the
columns
and
some
constants
like
a
tuple
of
other
columns
and
type
definitions
for
convenience.
Let's
look
at
the
DSL
module,
which
it's
pretty
boring
it
just
let
that's
all.
We
have
been
working
with
so
far.
A
It's
the
zero
size
trucks
I
mentioned
earlier
as
one
renamed
the
to
do.
Struct
renamed,
it's
just
the
same
thing
as
a
table
and
the
column
struct.
And
if
we
have
a
look
at
like
this
tract,
we
can
see
it's
zero
sized
structure
so
only
represented
at
compile
time
for
us
and
it
implements
all
these
traits.
That
expression,
query,
fragment
and
a
lot
of
other
stuff,
and
this
allows
us
to
basically
see
okay.
We
can
represent
this
in
sequel.
We
can
call
filter
on
it.
We
can
call
where
we
can
call
order
on
it.
D
C
A
If
do
you
want?
Do
you
all
want
to
hear
about
in
Frisco
and
houses
corresponds
to
table?
Because
that's
the
next
thing
on
my
list,
yeah,
the
schema
inference
you
you
just
talked
about
is
this
micro
column.
We
saw
earlier
it's
wrong
at
compile
time
and
queries
to
database,
hey
database.
What's
the
actual
schema
using
here
and
it
gets
the
information
back
from
the
database
and
all
it
does
is
generates
these
macro
cards.
So
it's
actually
the
other
way
around.
You
don't
use
macro
to
circumvents
in
fátima.
A
You
use
info
steamer
to
not
have
to
define
the
macro
currency
yeah,
but
it's
the
right
thinking
and
also
it
has
a
bunch
of
caveats
you
need
to
know
like,
for
example,
if
you
have
a
database
running
on
your
development
machine
that
has
a
different
schema,
then
your
production
machine.
It
can't
be
used
at
compile
time
to
generate
the
schema
for
your
production
machine,
obviously,
and
know
that
your
death
machine
actually
needs
to
run
the
database.
I
hope
that's!
Okay
with
you,
but
I've
heard.
A
Complaints
from
people
like
I
want
to
develop
this
application
and
I
don't
want
to
set
up
Postgres
on
my
machine.
So
you
need
to
think
about
that
and
for
all
these
people
there
was
a
diesel
print
schema
command
that
prints
on
the
command
line.
Basically
all
the
table
cards
emphysema
generates.
So
if
one
developer
wants
to
use
in
frsky,
MA
and
another
developer,
doesn't
they
can
find
a
compromise?
By
is
the
first
one,
just
using
print
schema,
putting
that
into
version
control
and
all
developers
can
see
it?
A
Let's
talk
about
my
Bryson's,
so
migrations
I,
just
filed
you
put
them
into
by
by
a
convention.
You
put
them
into
a
migrations
directory
and
into
subdirectories
was
the
daytime
prefix,
so
they
will
be
honored
nicely
and
maybe
a
name,
and
then
you
just
create
two
files.
An
app
file
and
the
down
final
vows
are
sequel
right
to
just
write,
actual
sequel
statements
in
there
like
create
table
to
deuce
with
an
idea
title
and
a
done
flag.
Think
we
got
earlier
and
in
the
down
file,
it's
just
the
inverse.
A
That
is,
you
drop
the
data
as
you
drop
the
to
do
stable
and
diesel
has
some
convenience
tool
for
that.
The
diesels
your
light
will
also
has
like
migrations,
sub
commands
that
can
generate
these
files
for
you
with
the
correct
names
and
timestamps,
and
all
that
you
can
apply
them
and
you
can
revert
them.
A
A
It
just
installs
us,
like
all
other
cargo
binaries
into
your
home
directory
I
think
so
it's
not
a
system-wide
thing,
and
this
is
also
a
tool
that
doesn't
change
that
frequently,
so
it
can
be
used
across
multiple
diesel
versions
and
you
can
have
as
many
diesel
projects
as
you
want
to
and
manage
it
with
this,
as
I
said
it
sets
up
to
database.
It
manages
your
migrations
and,
as
we
have
already
seen,
it
can
print
your
schema.
B
A
A
Who
wants
to
talk
about
testing
who
wants
to
talk
about
type
systems?
Okay,
people
want
to
hear
about
type
systems,
so
I
mentioned
in
the
introduction
earlier
that
there
are
some
points.
The
Russ
type
system
is
not
really
good
at,
and
one
of
this
is
that
we
have
a
macros
that
implements
our
column
types
for
tuples
and
it's
well.
A
A
A
Currently
we
support
the
returning
class
and
prospects,
so
you
can
have
inserts,
which
gives
you
back
some
part
of
the
data
you
just
inserted
like
the
ID
or
the
whole
data
set,
and
this
does
only
work
on
post
class,
so
you
can't
use
it
on
my
sequel
and
we
ensure
that
compile
time
by
having
everything
generic
over
the
backend
type.
It's
quite
nice.
So
you
want
to
again
about
testing
pieces
now.
A
I
go
through
it
quickly,
so
we
have
unit
tests.
Your
tests
are
the
basis
for
every
testing
thing
and
most
unit
tests.
We
have
for
our
helper
functions
and
conversion.
Things
like
we
need
to
ensure
that
varies
with
different
types,
have
different
IDs,
let's
not
really
readable,
on
the
slide,
but
I
hope
you
can
guess
what
it
means,
and
we
also
need
to
test
the
conversion
functions
from
a
bit
more
involved
type:
conversions,
like
date/time
cells.
A
It's
it's
basically
like
you
need
to
ensure
that
the
conversion
from
from
rust
to
sequel
to
rust,
works
and
unit
tests
are
a
good
way
to
do
that.
But
more
on
that
later,
we
also
have
integration
tests,
which
assumes
that
you
are
diesel
diesel
user
and
want
to
do
some
stuff.
So
we
run
some
theories
and
see
that
securities
actually
contain
what
we
want
them
to
contain.
A
Just
put
all
the
setup
code
in
the
next
ternal
file
and
include
it
because
you
can't
you
don't
want
to
make
this
public
API
but
including
the
file,
is
always
a
possibility.
Also
for
the
mentioned
round-trips.
We
use
quick
check.
So
this
we
have
implementations
for
all
the
types
and
arbitrary
that
is
it's.
A
trait
for
quick
trick
is
called
arbitrary
implementation
for
other
types.
A
So
we
can
generate
data
that
fits
into
let's
say
timestamp
and
we
can
represent,
as
in
rust,
send
to
the
database,
see
what
we
can
get
back
and
convert
this
rust,
and
hopefully
they
are
the
same.
It's
really
nice
to
find
or
to
not
write
a
lot
of
examples,
but
find
all
the
examples
that
are
relevant
and
the
rust
quick
check
library
has
all
good,
quick
check.
Libraries
also
includes
a
way
to
minimize
your
result,
set
and
find
small
counter
examples.
For
example,
if
the
time
sum
of
zero
was
a
problem,
it'll
tell
us.
A
A
Mentioned
earlier
that
we
want
to
have
your
project
not
compiled
with
invalid
queries.
Let
me
write
a
query
that
can't
possibly
fit
your
schema
and
it
should
not
compile
to
ensure
that
we
have
the
compile
test
tool,
which
is
libraries
that
you
give
some
rust
files
and
it
tries
to
compile
all
of
them,
and
you
have
annotations
in
there
to
say
hey.
A
We
want
to
here
ensure
that,
at
this
line,
this
error
is
wrong,
like
a
compile
time,
error
containing
the
word
type
mismatch,
or
something
like
that
or
method
not
implemented,
and
it's
actually
the
same
tool
that
the
rust
compiler
itself
or
linting
tools
like
Clippy
use.
So
if
you
want
to
have
an
API
that
you
can
be
sure
will
fail
to
compile
in
certain
cases
give
it
a
try.
Compile
test
is
really
nice
for
that.
A
B
E
Might
be
a
new
big
question,
but
I
only
checked
out
the
documentation
on
diesel
dot,
RS
and
one
thing
that
I
found
confusing
was
that
rust
diesel
representation
of
my
query
looked
totally
different
to
the
my
sequel.
Query
I
mean
there's
some
parameters
which
just
don't
match
in
my
brain,
somehow
from
from
the
rust
version
right
stuff
and
from
the
from
the
sequel
version
that
would
come
out
of
it.
E
A
E
D
E
F
Is
it
it's
not
like
damn
NASA
boolean
enjoy
example,
but
if
done
is
like
a
state
or
it's
like
State
and
then
it's
to
do
state
for
example,
and
then
I
have
for
a
key
of
another
table
which
is
like
open
in
progress
done,
and
so
my
question
is:
how
do
you
get
this
presented
with
the
state
in
rusts,
for
example,
in
Java
I
know,
I
would
create
an
enum
where
I
have
like
three
tests.
Free
enum
values
like
open
in
progress
done
and
I
would
need
something
like
that.
F
A
A
F
A
Yes,
you
need
to
implement
to
and
from
sequel,
yes,
these
rights,
but
you
also,
of
course,
need
to
think
about
how
you
represent
is
in
the
database
actually
like
yeah.
If
you
want
to
use
a
string,
it's
probably
an
easy
conversion,
but
if
you
want
to
use
a
custom
sequel
type,
it's
a
bit
more
involved.
A
I
tried
to
write
shell
script
runs
cargo
check
on
the
whole
of
the
diesel
repository
with
several
crates
in
it,
and
I
was
really
surprised
at
first
because
it
was
like
done
in
five
seconds,
but
then
I
noticed
that
I
didn't
actually
change
the
file
deep
inside
the
diesel
right.
So
that
blew
it
up
to
fifty
seconds
in
general.
It's
one
of
costs
so
because
your
application
will
probably
use
diesel,
compile
it
once
and
then
after
like
40
seconds
or
so.
You
have
your
copy
of
diesel.
A
C
A
Actually,
that
was
the
example
we
got
and
we
were
like
well,
but
actually
it's
a
lot
of
work
and
stuff,
but
I
think
there
was
an
open
issue
and
also
a
design
we
want
to
implement.
So
if
you
want
to
get
involved,
maybe
you
can
give
it
a
try.
It's
really
interesting
stuff,
but
I
don't
think
we
have
anything
like
that.
Cowardly
and.
C
Another
question:
when
I
tried
out
this
error
chain
thing:
is
there
I
recognized
it
I
could
put
comments
in
through
the
macros
and
that
they
appeared
in
the
documentation?
Does
that
work
here
was
a
table
macro
true,
because
I
thought
you
had
a
for
you
to
do
so.
You
had
a
generate
documentation
there
as
a
standard
generated
rostock
and
if
you
had
documentation
in
there,
that
would
be
really
cool
because
you
already
have
that
types
and
put-put
documentation.
There.
A
Don't
thing
is
currently
possible
because
the
table
macro
is
actually
really
simple
and
our
happy
pass
is
reduced
in
frsky
mah
and
don't
provide
it
yourself.
So
that's
that's
not
something
we
put
much
effort
into
makes
us
nice
for
you
to
write,
but
it's
certainly
possible
and
shouldn't
be
much
work.
C
A
A
If
you
want
to
have
like
nice
error
messages
and
not
see
a
whole
bunch
of
tuples,
you
need
to
have
something
else
in
tuples,
but
if
you
need
to
well,
if
you,
if
you're
talking
about
compile
times
and
you
haven't
it's
right-
implementation
or
implementation
of
several
traits
and
then
have
that
over
52
variants,
like
I,
can't
help
you
yeah.
This
is
like
a
half
of
our
compile.
Time
is
just
compiling
this
one
trait
for
for
several
tuples.
So
H
list
is
a
way
to
do
that.
But
it's
probably
too
much
to
explain
here
e.
A
Don't
know
we
have
several
feature
flags
I,
think
by
default
it's
only
like
12
or
so
because
same
database
schemas
should
not
have
so
many
columns.
But
there
is
a
large
tables
and
the
huge
tables
feature
feature
you
can
enable
and
then
you
get
like
32
+,
+
52
for
some
reason
the
idea,
but
you
should
not
have
more
than
50
two
columns
in
your
database
data.