-
Notifications
You must be signed in to change notification settings - Fork 8
/
Copy pathchapter_02_repository.html
1428 lines (1337 loc) · 80.1 KB
/
chapter_02_repository.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="generator" content="Asciidoctor 2.0.20">
<title>Repository Pattern</title>
<style>
/* Asciidoctor default stylesheet | MIT License | https://asciidoctor.org */
@import url("//fonts.googleapis.com/css?family=Noto+Sans:300,600italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400,700");
@import url(//asciidoctor.org/stylesheets/asciidoctor.css); /* Default asciidoc style framework - important */
/* customisations by harry */
h1, h2, h3, h4, h5, h6 {
position: relative;
}
a.anchor {
top: 0;
}
/* hide inline ditaa/plantuml source listings for images */
.image-source {
display: none
}
/* make formal codeblocks a bit nicer */
.exampleblock > .content {
padding: 2px;
background-color: white;
border: 0;
margin-bottom: 2em;
}
.exampleblock .title {
text-align: right;
}
/* prev/next chapter links at bottom of page */
.prev_and_next_chapter_links {
margin: 10px;
}
.prev_chapter_link {
float: left;
}
.next_chapter_link {
float: right;
}
/* a few tweaks to existing styles */
#toc li {
margin-top: 0.5em;
}
#footnotes hr {
width: 100%;
}
/* end customisations by harry */
/* CUSTOMISATIONS */
/* Change the values in root for quick customisation. If you want even more fine grain... venture further. */
:root{
--maincolor:#FFFFFF;
--primarycolor:#2c3e50;
--secondarycolor:#ba3925;
--tertiarycolor: #186d7a;
--sidebarbackground:#CCC;
--linkcolor:#b71c1c;
--linkcoloralternate:#f44336;
--white:#FFFFFF;
--black:#000000;
}
/* Text styles */
h1{color:var(--primarycolor) !important;}
h2,h3,h4,h5,h6{color:var(--secondarycolor) !important;}
.title{color:var(--tertiarycolor) !important; font-family:"Noto Sans",sans-serif !important;font-style: normal !important; font-weight: normal !important;}
p{font-family: "Noto Sans",sans-serif !important}
/* Table styles */
th{font-family: "Noto Sans",sans-serif !important}
/* Responsiveness fixes */
video {
max-width: 100%;
}
@media all and (max-width: 600px) {
table {
width: 55vw!important;
font-size: 3vw;
}
</style>
<style>
pre.pygments .hll { background-color: #ffffcc }
pre.pygments { background: #f0f0f0; }
pre.pygments .tok-c { color: #60a0b0; font-style: italic } /* Comment */
pre.pygments .tok-err { border: 1px solid #FF0000 } /* Error */
pre.pygments .tok-k { color: #007020; font-weight: bold } /* Keyword */
pre.pygments .tok-o { color: #666666 } /* Operator */
pre.pygments .tok-ch { color: #60a0b0; font-style: italic } /* Comment.Hashbang */
pre.pygments .tok-cm { color: #60a0b0; font-style: italic } /* Comment.Multiline */
pre.pygments .tok-cp { color: #007020 } /* Comment.Preproc */
pre.pygments .tok-cpf { color: #60a0b0; font-style: italic } /* Comment.PreprocFile */
pre.pygments .tok-c1 { color: #60a0b0; font-style: italic } /* Comment.Single */
pre.pygments .tok-cs { color: #60a0b0; background-color: #fff0f0 } /* Comment.Special */
pre.pygments .tok-gd { color: #A00000 } /* Generic.Deleted */
pre.pygments .tok-ge { font-style: italic } /* Generic.Emph */
pre.pygments .tok-gr { color: #FF0000 } /* Generic.Error */
pre.pygments .tok-gh { color: #000080; font-weight: bold } /* Generic.Heading */
pre.pygments .tok-gi { color: #00A000 } /* Generic.Inserted */
pre.pygments .tok-go { color: #888888 } /* Generic.Output */
pre.pygments .tok-gp { color: #c65d09; font-weight: bold } /* Generic.Prompt */
pre.pygments .tok-gs { font-weight: bold } /* Generic.Strong */
pre.pygments .tok-gu { color: #800080; font-weight: bold } /* Generic.Subheading */
pre.pygments .tok-gt { color: #0044DD } /* Generic.Traceback */
pre.pygments .tok-kc { color: #007020; font-weight: bold } /* Keyword.Constant */
pre.pygments .tok-kd { color: #007020; font-weight: bold } /* Keyword.Declaration */
pre.pygments .tok-kn { color: #007020; font-weight: bold } /* Keyword.Namespace */
pre.pygments .tok-kp { color: #007020 } /* Keyword.Pseudo */
pre.pygments .tok-kr { color: #007020; font-weight: bold } /* Keyword.Reserved */
pre.pygments .tok-kt { color: #902000 } /* Keyword.Type */
pre.pygments .tok-m { color: #40a070 } /* Literal.Number */
pre.pygments .tok-s { color: #4070a0 } /* Literal.String */
pre.pygments .tok-na { color: #4070a0 } /* Name.Attribute */
pre.pygments .tok-nb { color: #007020 } /* Name.Builtin */
pre.pygments .tok-nc { color: #0e84b5; font-weight: bold } /* Name.Class */
pre.pygments .tok-no { color: #60add5 } /* Name.Constant */
pre.pygments .tok-nd { color: #555555; font-weight: bold } /* Name.Decorator */
pre.pygments .tok-ni { color: #d55537; font-weight: bold } /* Name.Entity */
pre.pygments .tok-ne { color: #007020 } /* Name.Exception */
pre.pygments .tok-nf { color: #06287e } /* Name.Function */
pre.pygments .tok-nl { color: #002070; font-weight: bold } /* Name.Label */
pre.pygments .tok-nn { color: #0e84b5; font-weight: bold } /* Name.Namespace */
pre.pygments .tok-nt { color: #062873; font-weight: bold } /* Name.Tag */
pre.pygments .tok-nv { color: #bb60d5 } /* Name.Variable */
pre.pygments .tok-ow { color: #007020; font-weight: bold } /* Operator.Word */
pre.pygments .tok-w { color: #bbbbbb } /* Text.Whitespace */
pre.pygments .tok-mb { color: #40a070 } /* Literal.Number.Bin */
pre.pygments .tok-mf { color: #40a070 } /* Literal.Number.Float */
pre.pygments .tok-mh { color: #40a070 } /* Literal.Number.Hex */
pre.pygments .tok-mi { color: #40a070 } /* Literal.Number.Integer */
pre.pygments .tok-mo { color: #40a070 } /* Literal.Number.Oct */
pre.pygments .tok-sa { color: #4070a0 } /* Literal.String.Affix */
pre.pygments .tok-sb { color: #4070a0 } /* Literal.String.Backtick */
pre.pygments .tok-sc { color: #4070a0 } /* Literal.String.Char */
pre.pygments .tok-dl { color: #4070a0 } /* Literal.String.Delimiter */
pre.pygments .tok-sd { color: #4070a0; font-style: italic } /* Literal.String.Doc */
pre.pygments .tok-s2 { color: #4070a0 } /* Literal.String.Double */
pre.pygments .tok-se { color: #4070a0; font-weight: bold } /* Literal.String.Escape */
pre.pygments .tok-sh { color: #4070a0 } /* Literal.String.Heredoc */
pre.pygments .tok-si { color: #70a0d0; font-style: italic } /* Literal.String.Interpol */
pre.pygments .tok-sx { color: #c65d09 } /* Literal.String.Other */
pre.pygments .tok-sr { color: #235388 } /* Literal.String.Regex */
pre.pygments .tok-s1 { color: #4070a0 } /* Literal.String.Single */
pre.pygments .tok-ss { color: #517918 } /* Literal.String.Symbol */
pre.pygments .tok-bp { color: #007020 } /* Name.Builtin.Pseudo */
pre.pygments .tok-fm { color: #06287e } /* Name.Function.Magic */
pre.pygments .tok-vc { color: #bb60d5 } /* Name.Variable.Class */
pre.pygments .tok-vg { color: #bb60d5 } /* Name.Variable.Global */
pre.pygments .tok-vi { color: #bb60d5 } /* Name.Variable.Instance */
pre.pygments .tok-vm { color: #bb60d5 } /* Name.Variable.Magic */
pre.pygments .tok-il { color: #40a070 } /* Literal.Number.Integer.Long */
</style>
</head>
<body class="article toc2 toc-left">
<div id="buy_the_book" style="position: absolute; top: 0; right: 0; z-index:100">
<a href="/#buy_the_book">
<img src="/images/buy_the_book.svg" alt="buy the book ribbon">
</a>
</div>
<div id="header">
<div id="toc" class="toc2">
<div id="toctitle">Table of Contents</div>
<ul class="sectlevel1">
<li><a href="/book/preface.html">Preface</a></li>
<li><a href="/book/introduction.html">Introduction</a></li>
<li><a href="/book/part1.html">Part 1: Building an Architecture to Support Domain Modeling</a></li>
<li><a href="/book/chapter_01_domain_model.html">1. Domain Modeling</a></li>
<li><a href="/book/chapter_02_repository.html">2. Repository Pattern</a></li>
<li><a href="/book/chapter_03_abstractions.html">3. A Brief Interlude: On Coupling <span class="keep-together">and Abstractions</span></a></li>
<li><a href="/book/chapter_04_service_layer.html">4. Our First Use Case: <span class="keep-together">Flask API and Service Layer</span></a></li>
<li><a href="/book/chapter_05_high_gear_low_gear.html">5. TDD in High Gear and Low Gear</a></li>
<li><a href="/book/chapter_06_uow.html">6. Unit of Work Pattern</a></li>
<li><a href="/book/chapter_07_aggregate.html">7. Aggregates and Consistency Boundaries</a></li>
<li><a href="/book/part2.html">Part 2: Event-Driven Architecture</a></li>
<li><a href="/book/chapter_08_events_and_message_bus.html">8. Events and the Message Bus</a></li>
<li><a href="/book/chapter_09_all_messagebus.html">9. Going to Town on the Message Bus</a></li>
<li><a href="/book/chapter_10_commands.html">10. Commands and Command Handler</a></li>
<li><a href="/book/chapter_11_external_events.html">11. Event-Driven Architecture: Using Events to Integrate Microservices</a></li>
<li><a href="/book/chapter_12_cqrs.html">12. Command-Query Responsibility Segregation (CQRS)</a></li>
<li><a href="/book/chapter_13_dependency_injection.html">13. Dependency Injection (and Bootstrapping)</a></li>
<li><a href="/book/epilogue_1_how_to_get_there_from_here.html">Epilogue: Epilogue</a></li>
<li><a href="/book/appendix_ds1_table.html">Appendix A: Summary Diagram and Table</a></li>
<li><a href="/book/appendix_project_structure.html">Appendix B: A Template Project Structure</a></li>
<li><a href="/book/appendix_csvs.html">Appendix C: Swapping Out the Infrastructure: Do Everything with CSVs</a></li>
<li><a href="/book/appendix_django.html">Appendix D: Repository and Unit of Work Patterns with Django</a></li>
<li><a href="/book/appendix_validation.html">Appendix E: Validation</a></li>
</ul>
</div>
</div>
<div id="content">
<div class="sect1">
<h2 id="chapter_02_repository">2: Repository Pattern<a class="anchor" href="#chapter_02_repository"></a></h2>
<div class="sectionbody">
<div class="paragraph">
<p>It’s time to make good on our promise to use the dependency inversion principle as
a way of decoupling our core logic from infrastructural concerns.</p>
</div>
<div class="paragraph">
<p>
We’ll introduce the <em>Repository</em> pattern, a simplifying abstraction over data storage,
allowing us to decouple our model layer from the data layer. We’ll present a
concrete example of how this simplifying abstraction makes our system more
testable by hiding the complexities of the database.</p>
</div>
<div class="paragraph">
<p><a href="#maps_chapter_02">Before and after the Repository pattern</a> shows a little preview of what we’re going to build:
a <code>Repository</code> object that sits between our domain model and the database.</p>
</div>
<div id="maps_chapter_02" class="imageblock">
<div class="content">
<img src="images/apwp_0201.png" alt="apwp 0201">
</div>
<div class="title">Figure 1. Before and after the Repository pattern</div>
</div>
<div class="admonitionblock tip">
<table>
<tr>
<td class="icon">
<div class="title">Tip</div>
</td>
<td class="content">
<div class="paragraph">
<p>The code for this chapter is in the
chapter_02_repository branch <a href="https://oreil.ly/6STDu">on GitHub</a>.</p>
</div>
<div class="listingblock">
<div class="content">
<pre>git clone https://github.com/cosmicpython/code.git
cd code
git checkout chapter_02_repository
# or to code along, checkout the previous chapter:
git checkout chapter_01_domain_model</pre>
</div>
</div>
</td>
</tr>
</table>
</div>
<div class="sect2">
<h3 id="_persisting_our_domain_model"><a class="anchor" href="#_persisting_our_domain_model"></a>Persisting Our Domain Model</h3>
<div class="paragraph">
<p>
In <a href="/book/chapter_01_domain_model.html">[chapter_01_domain_model]</a> we built a simple domain model that can allocate orders
to batches of stock. It’s easy for us to write tests against this code because
there aren’t any dependencies or infrastructure to set up. If we needed to run
a database or an API and create test data, our tests would be harder to write
and maintain.</p>
</div>
<div class="paragraph">
<p>Sadly, at some point we’ll need to put our perfect little model in the hands of
users and contend with the real world of spreadsheets and web
browsers and race conditions. For the next few chapters we’re going to look at
how we can connect our idealized domain model to external state.</p>
</div>
<div class="paragraph">
<p>
We expect to be working in an agile manner, so our priority is to get to a
minimum viable product as quickly as possible. In our case, that’s going to be
a web API. In a real project, you might dive straight in with some end-to-end
tests and start plugging in a web framework, test-driving things outside-in.</p>
</div>
<div class="paragraph">
<p>But we know that, no matter what, we’re going to need some form of persistent
storage, and this is a textbook, so we can allow ourselves a tiny bit more
bottom-up development and start to think about storage and databases.</p>
</div>
</div>
<div class="sect2">
<h3 id="_some_pseudocode_what_are_we_going_to_need"><a class="anchor" href="#_some_pseudocode_what_are_we_going_to_need"></a>Some Pseudocode: What Are We Going to Need?</h3>
<div class="paragraph">
<p>When we build our first API endpoint, we know we’re going to have
some code that looks more or less like the following.</p>
</div>
<div id="api_endpoint_pseudocode" class="exampleblock">
<div class="title">What our first API endpoint will look like</div>
<div class="content">
<div class="listingblock skip">
<div class="content">
<pre class="pygments highlight"><code data-lang="python"><span></span><span class="tok-nd">@flask</span><span class="tok-o">.</span><span class="tok-n">route</span><span class="tok-o">.</span><span class="tok-n">gubbins</span>
<span class="tok-k">def</span> <span class="tok-nf">allocate_endpoint</span><span class="tok-p">():</span>
<span class="tok-c1"># extract order line from request</span>
<span class="tok-n">line</span> <span class="tok-o">=</span> <span class="tok-n">OrderLine</span><span class="tok-p">(</span><span class="tok-n">request</span><span class="tok-o">.</span><span class="tok-n">params</span><span class="tok-p">,</span> <span class="tok-o">...</span><span class="tok-p">)</span>
<span class="tok-c1"># load all batches from the DB</span>
<span class="tok-n">batches</span> <span class="tok-o">=</span> <span class="tok-o">...</span>
<span class="tok-c1"># call our domain service</span>
<span class="tok-n">allocate</span><span class="tok-p">(</span><span class="tok-n">line</span><span class="tok-p">,</span> <span class="tok-n">batches</span><span class="tok-p">)</span>
<span class="tok-c1"># then save the allocation back to the database somehow</span>
<span class="tok-k">return</span> <span class="tok-mi">201</span></code></pre>
</div>
</div>
</div>
</div>
<div class="admonitionblock note">
<table>
<tr>
<td class="icon">
<div class="title">Note</div>
</td>
<td class="content">
We’ve used Flask because it’s lightweight, but you don’t need
to be a Flask user to understand this book. In fact, we’ll show you how
to make your choice of framework a minor detail.
</td>
</tr>
</table>
</div>
<div class="paragraph">
<p>We’ll need a way to retrieve batch info from the database and instantiate our domain
model objects from it, and we’ll also need a way of saving them back to the
database.</p>
</div>
<div class="paragraph">
<p><em>What? Oh, "gubbins" is a British word for "stuff." You can just ignore that. It’s pseudocode, OK?</em></p>
</div>
</div>
<div class="sect2">
<h3 id="_applying_the_dip_to_data_access"><a class="anchor" href="#_applying_the_dip_to_data_access"></a>Applying the DIP to Data Access</h3>
<div class="paragraph">
<p>
As mentioned in the <a href="/book/introduction.html">introduction</a>, a layered architecture is a common
approach to structuring a system that has a UI, some logic, and a database (see
<a href="#layered_architecture2">Layered architecture</a>).</p>
</div>
<div id="layered_architecture2" class="imageblock width-75">
<div class="content">
<img src="images/apwp_0202.png" alt="apwp 0202">
</div>
<div class="title">Figure 2. Layered architecture</div>
</div>
<div class="paragraph">
<p>Django’s Model-View-Template structure is closely related, as is
Model-View-Controller (MVC). In any case, the aim is to keep the layers
separate (which is a good thing), and to have each layer depend only on the one
below it.</p>
</div>
<div class="paragraph">
<p>
But we want our domain model to have <em>no dependencies whatsoever</em>.<sup class="footnote">[<a id="_footnoteref_1" class="footnote" href="#_footnotedef_1" title="View footnote.">1</a>]</sup>
We don’t want infrastructure concerns bleeding over into our domain model and
slowing our unit tests or our ability to make changes.</p>
</div>
<div class="paragraph">
<p>
Instead, as discussed in the introduction, we’ll think of our model as being on the
"inside," and dependencies flowing inward to it; this is what people sometimes call
<em>onion architecture</em> (see <a href="#onion_architecture">Onion architecture</a>).</p>
</div>
<div id="onion_architecture" class="imageblock width-75">
<div class="content">
<img src="images/apwp_0203.png" alt="apwp 0203">
</div>
<div class="title">Figure 3. Onion architecture</div>
</div>
<div class="listingblock image-source">
<div class="content">
<pre>[ditaa, apwp_0203]
+------------------------+
| Presentation Layer |
+------------------------+
|
V
+--------------------------------------------------+
| Domain Model |
+--------------------------------------------------+
^
|
+---------------------+
| Database Layer |
+---------------------+</pre>
</div>
</div>
<div class="sidebarblock nobreakinside less_space">
<div class="content">
<div class="title">Is This Ports and Adapters?</div>
<div class="paragraph">
<p>If you’ve been reading about architectural patterns, you may be asking
yourself questions like this:</p>
</div>
<div class="quoteblock">
<blockquote>
<div class="paragraph">
<p><em>Is this ports and adapters? Or is it hexagonal architecture? Is that the same as onion architecture? What about the clean architecture? What’s a port, and what’s an adapter? Why do you people have so many words for the same thing?</em></p>
</div>
</blockquote>
</div>
<div class="paragraph">
<p>
Although some people like to nitpick over the differences, all these are
pretty much names for the same thing, and they all boil down to the
dependency inversion principle: high-level modules (the domain) should
not depend on low-level ones (the infrastructure).<sup class="footnote">[<a id="_footnoteref_2" class="footnote" href="#_footnotedef_2" title="View footnote.">2</a>]</sup></p>
</div>
<div class="paragraph">
<p>We’ll get into some of the nitty-gritty around "depending on abstractions,"
and whether there is a Pythonic equivalent of interfaces,
<a href="/book/chapter_04_service_layer.html#depend_on_abstractions">later in the book</a>. See also <a href="#what_is_a_port_and_what_is_an_adapter">What Is a Port and What Is an Adapter, in Python?</a>.</p>
</div>
</div>
</div>
</div>
<div class="sect2">
<h3 id="_reminder_our_model"><a class="anchor" href="#_reminder_our_model"></a>Reminder: Our Model</h3>
<div class="paragraph">
<p>
Let’s remind ourselves of our domain model (see <a href="#model_diagram_reminder">Our model</a>):
an allocation is the concept of linking an <code>OrderLine</code> to a <code>Batch</code>. We’re
storing the allocations as a collection on our <code>Batch</code> object.</p>
</div>
<div id="model_diagram_reminder" class="imageblock">
<div class="content">
<img src="images/apwp_0103.png" alt="apwp 0103">
</div>
<div class="title">Figure 4. Our model</div>
</div>
<div class="paragraph">
<p>Let’s see how we might translate this to a relational database.</p>
</div>
<div class="sect3">
<h4 id="_the_normal_orm_way_model_depends_on_orm"><a class="anchor" href="#_the_normal_orm_way_model_depends_on_orm"></a>The "Normal" ORM Way: Model Depends on ORM</h4>
<div class="paragraph">
<p>
These days, it’s unlikely that your team members are hand-rolling their own SQL queries.
Instead, you’re almost certainly using some kind of framework to generate
SQL for you based on your model objects.</p>
</div>
<div class="paragraph">
<p>
These frameworks are called <em>object-relational mappers</em> (ORMs) because they exist to
bridge the conceptual gap between the world of objects and domain modeling and
the world of databases and relational algebra.</p>
</div>
<div class="paragraph">
<p>
The most important thing an ORM gives us is <em>persistence ignorance</em>: the idea
that our fancy domain model doesn’t need to know anything about how data is
loaded or persisted. This helps keep our domain clean of direct dependencies
on particular database technologies.<sup class="footnote">[<a id="_footnoteref_3" class="footnote" href="#_footnotedef_3" title="View footnote.">3</a>]</sup></p>
</div>
<div class="paragraph">
<p>
But if you follow the typical SQLAlchemy tutorial, you’ll end up with something
like this:</p>
</div>
<div id="typical_sqlalchemy_example" class="exampleblock">
<div class="title">SQLAlchemy "declarative" syntax, model depends on ORM (orm.py)</div>
<div class="content">
<div class="listingblock skip">
<div class="content">
<pre class="pygments highlight"><code data-lang="python"><span></span><span class="tok-kn">from</span> <span class="tok-nn">sqlalchemy</span> <span class="tok-kn">import</span> <span class="tok-n">Column</span><span class="tok-p">,</span> <span class="tok-n">ForeignKey</span><span class="tok-p">,</span> <span class="tok-n">Integer</span><span class="tok-p">,</span> <span class="tok-n">String</span>
<span class="tok-kn">from</span> <span class="tok-nn">sqlalchemy.ext.declarative</span> <span class="tok-kn">import</span> <span class="tok-n">declarative_base</span>
<span class="tok-kn">from</span> <span class="tok-nn">sqlalchemy.orm</span> <span class="tok-kn">import</span> <span class="tok-n">relationship</span>
<span class="tok-n">Base</span> <span class="tok-o">=</span> <span class="tok-n">declarative_base</span><span class="tok-p">()</span>
<span class="tok-k">class</span> <span class="tok-nc">Order</span><span class="tok-p">(</span><span class="tok-n">Base</span><span class="tok-p">):</span>
<span class="tok-nb">id</span> <span class="tok-o">=</span> <span class="tok-n">Column</span><span class="tok-p">(</span><span class="tok-n">Integer</span><span class="tok-p">,</span> <span class="tok-n">primary_key</span><span class="tok-o">=</span><span class="tok-kc">True</span><span class="tok-p">)</span>
<span class="tok-k">class</span> <span class="tok-nc">OrderLine</span><span class="tok-p">(</span><span class="tok-n">Base</span><span class="tok-p">):</span>
<span class="tok-nb">id</span> <span class="tok-o">=</span> <span class="tok-n">Column</span><span class="tok-p">(</span><span class="tok-n">Integer</span><span class="tok-p">,</span> <span class="tok-n">primary_key</span><span class="tok-o">=</span><span class="tok-kc">True</span><span class="tok-p">)</span>
<span class="tok-n">sku</span> <span class="tok-o">=</span> <span class="tok-n">Column</span><span class="tok-p">(</span><span class="tok-n">String</span><span class="tok-p">(</span><span class="tok-mi">250</span><span class="tok-p">))</span>
<span class="tok-n">qty</span> <span class="tok-o">=</span> <span class="tok-n">Integer</span><span class="tok-p">(</span><span class="tok-n">String</span><span class="tok-p">(</span><span class="tok-mi">250</span><span class="tok-p">))</span>
<span class="tok-n">order_id</span> <span class="tok-o">=</span> <span class="tok-n">Column</span><span class="tok-p">(</span><span class="tok-n">Integer</span><span class="tok-p">,</span> <span class="tok-n">ForeignKey</span><span class="tok-p">(</span><span class="tok-s1">'order.id'</span><span class="tok-p">))</span>
<span class="tok-n">order</span> <span class="tok-o">=</span> <span class="tok-n">relationship</span><span class="tok-p">(</span><span class="tok-n">Order</span><span class="tok-p">)</span>
<span class="tok-k">class</span> <span class="tok-nc">Allocation</span><span class="tok-p">(</span><span class="tok-n">Base</span><span class="tok-p">):</span>
<span class="tok-o">...</span></code></pre>
</div>
</div>
</div>
</div>
<div class="paragraph">
<p>You don’t need to understand SQLAlchemy to see that our pristine model is now
full of dependencies on the ORM and is starting to look ugly as hell besides.
Can we really say this model is ignorant of the database? How can it be
separate from storage concerns when our model properties are directly coupled
to database columns?</p>
</div>
<div class="sidebarblock nobreakinside less_space">
<div class="content">
<div class="title">Django’s ORM Is Essentially the Same, but More Restrictive</div>
<div class="paragraph">
<p>
If you’re more used to Django, the preceding "declarative" SQLAlchemy snippet
translates to something like this:</p>
</div>
<div id="django_orm_example" class="exampleblock">
<div class="title">Django ORM example</div>
<div class="content">
<div class="listingblock skip">
<div class="content">
<pre class="pygments highlight"><code data-lang="python"><span></span><span class="tok-k">class</span> <span class="tok-nc">Order</span><span class="tok-p">(</span><span class="tok-n">models</span><span class="tok-o">.</span><span class="tok-n">Model</span><span class="tok-p">):</span>
<span class="tok-k">pass</span>
<span class="tok-k">class</span> <span class="tok-nc">OrderLine</span><span class="tok-p">(</span><span class="tok-n">models</span><span class="tok-o">.</span><span class="tok-n">Model</span><span class="tok-p">):</span>
<span class="tok-n">sku</span> <span class="tok-o">=</span> <span class="tok-n">models</span><span class="tok-o">.</span><span class="tok-n">CharField</span><span class="tok-p">(</span><span class="tok-n">max_length</span><span class="tok-o">=</span><span class="tok-mi">255</span><span class="tok-p">)</span>
<span class="tok-n">qty</span> <span class="tok-o">=</span> <span class="tok-n">models</span><span class="tok-o">.</span><span class="tok-n">IntegerField</span><span class="tok-p">()</span>
<span class="tok-n">order</span> <span class="tok-o">=</span> <span class="tok-n">models</span><span class="tok-o">.</span><span class="tok-n">ForeignKey</span><span class="tok-p">(</span><span class="tok-n">Order</span><span class="tok-p">)</span>
<span class="tok-k">class</span> <span class="tok-nc">Allocation</span><span class="tok-p">(</span><span class="tok-n">models</span><span class="tok-o">.</span><span class="tok-n">Model</span><span class="tok-p">):</span>
<span class="tok-o">...</span></code></pre>
</div>
</div>
</div>
</div>
<div class="paragraph">
<p>The point is the same—​our model classes inherit directly from ORM
classes, so our model depends on the ORM. We want it to be the other
way around.</p>
</div>
<div class="paragraph">
<p>Django doesn’t provide an equivalent for SQLAlchemy’s classical mapper,
but see <a href="/book/appendix_django.html">[appendix_django]</a> for examples of how to apply dependency
inversion and the Repository pattern to Django.</p>
</div>
</div>
</div>
</div>
<div class="sect3">
<h4 id="_inverting_the_dependency_orm_depends_on_model"><a class="anchor" href="#_inverting_the_dependency_orm_depends_on_model"></a>Inverting the Dependency: ORM Depends on Model</h4>
<div class="paragraph">
<p>
Well, thankfully, that’s not the only way to use SQLAlchemy. The alternative is
to define your schema separately, and to define an explicit <em>mapper</em> for how to convert
between the schema and our domain model, what SQLAlchemy calls a
<a href="https://oreil.ly/ZucTG">classical mapping</a>:</p>
</div>
<div id="sqlalchemy_classical_mapper" class="exampleblock nobreakinside less_space">
<div class="title">Explicit ORM mapping with SQLAlchemy Table objects (orm.py)</div>
<div class="content">
<div class="listingblock">
<div class="content">
<pre class="pygments highlight"><code data-lang="python"><span></span><span class="tok-kn">from</span> <span class="tok-nn">sqlalchemy.orm</span> <span class="tok-kn">import</span> <span class="tok-n">mapper</span><span class="tok-p">,</span> <span class="tok-n">relationship</span>
<span class="tok-kn">import</span> <span class="tok-nn">model</span> #<b class="conum">(1)</b>
<span class="tok-n">metadata</span> <span class="tok-o">=</span> <span class="tok-n">MetaData</span><span class="tok-p">()</span>
<span class="tok-n">order_lines</span> <span class="tok-o">=</span> <span class="tok-n">Table</span><span class="tok-p">(</span> #<b class="conum">(2)</b>
<span class="tok-s2">"order_lines"</span><span class="tok-p">,</span>
<span class="tok-n">metadata</span><span class="tok-p">,</span>
<span class="tok-n">Column</span><span class="tok-p">(</span><span class="tok-s2">"id"</span><span class="tok-p">,</span> <span class="tok-n">Integer</span><span class="tok-p">,</span> <span class="tok-n">primary_key</span><span class="tok-o">=</span><span class="tok-kc">True</span><span class="tok-p">,</span> <span class="tok-n">autoincrement</span><span class="tok-o">=</span><span class="tok-kc">True</span><span class="tok-p">),</span>
<span class="tok-n">Column</span><span class="tok-p">(</span><span class="tok-s2">"sku"</span><span class="tok-p">,</span> <span class="tok-n">String</span><span class="tok-p">(</span><span class="tok-mi">255</span><span class="tok-p">)),</span>
<span class="tok-n">Column</span><span class="tok-p">(</span><span class="tok-s2">"qty"</span><span class="tok-p">,</span> <span class="tok-n">Integer</span><span class="tok-p">,</span> <span class="tok-n">nullable</span><span class="tok-o">=</span><span class="tok-kc">False</span><span class="tok-p">),</span>
<span class="tok-n">Column</span><span class="tok-p">(</span><span class="tok-s2">"orderid"</span><span class="tok-p">,</span> <span class="tok-n">String</span><span class="tok-p">(</span><span class="tok-mi">255</span><span class="tok-p">)),</span>
<span class="tok-p">)</span>
<span class="tok-o">...</span>
<span class="tok-k">def</span> <span class="tok-nf">start_mappers</span><span class="tok-p">():</span>
<span class="tok-n">lines_mapper</span> <span class="tok-o">=</span> <span class="tok-n">mapper</span><span class="tok-p">(</span><span class="tok-n">model</span><span class="tok-o">.</span><span class="tok-n">OrderLine</span><span class="tok-p">,</span> <span class="tok-n">order_lines</span><span class="tok-p">)</span> #<b class="conum">(3)</b></code></pre>
</div>
</div>
</div>
</div>
<div class="colist arabic">
<ol>
<li>
<p>The ORM imports (or "depends on" or "knows about") the domain model, and
not the other way around.</p>
</li>
<li>
<p>We define our database tables and columns by using SQLAlchemy’s
abstractions.<sup class="footnote">[<a id="_footnoteref_4" class="footnote" href="#_footnotedef_4" title="View footnote.">4</a>]</sup></p>
</li>
<li>
<p>When we call the <code>mapper</code> function, SQLAlchemy does its magic to bind
our domain model classes to the various tables we’ve defined.</p>
</li>
</ol>
</div>
<div class="paragraph">
<p>The end result will be that, if we call <code>start_mappers</code>, we will be able to
easily load and save domain model instances from and to the database. But if
we never call that function, our domain model classes stay blissfully
unaware of the database.</p>
</div>
<div class="paragraph">
<p>This gives us all the benefits of SQLAlchemy, including the ability to use
<code>alembic</code> for migrations, and the ability to transparently query using our
domain classes, as we’ll see.</p>
</div>
<div class="paragraph">
<p>
When you’re first trying to build your ORM config, it can be useful to write
tests for it, as in the following example:</p>
</div>
<div id="orm_tests" class="exampleblock">
<div class="title">Testing the ORM directly (throwaway tests) (test_orm.py)</div>
<div class="content">
<div class="listingblock">
<div class="content">
<pre class="pygments highlight"><code data-lang="python"><span></span><span class="tok-k">def</span> <span class="tok-nf">test_orderline_mapper_can_load_lines</span><span class="tok-p">(</span><span class="tok-n">session</span><span class="tok-p">):</span> #<b class="conum">(1)</b>
<span class="tok-n">session</span><span class="tok-o">.</span><span class="tok-n">execute</span><span class="tok-p">(</span>
<span class="tok-s2">"INSERT INTO order_lines (orderid, sku, qty) VALUES "</span>
<span class="tok-s1">'("order1", "RED-CHAIR", 12),'</span>
<span class="tok-s1">'("order1", "RED-TABLE", 13),'</span>
<span class="tok-s1">'("order2", "BLUE-LIPSTICK", 14)'</span>
<span class="tok-p">)</span>
<span class="tok-n">expected</span> <span class="tok-o">=</span> <span class="tok-p">[</span>
<span class="tok-n">model</span><span class="tok-o">.</span><span class="tok-n">OrderLine</span><span class="tok-p">(</span><span class="tok-s2">"order1"</span><span class="tok-p">,</span> <span class="tok-s2">"RED-CHAIR"</span><span class="tok-p">,</span> <span class="tok-mi">12</span><span class="tok-p">),</span>
<span class="tok-n">model</span><span class="tok-o">.</span><span class="tok-n">OrderLine</span><span class="tok-p">(</span><span class="tok-s2">"order1"</span><span class="tok-p">,</span> <span class="tok-s2">"RED-TABLE"</span><span class="tok-p">,</span> <span class="tok-mi">13</span><span class="tok-p">),</span>
<span class="tok-n">model</span><span class="tok-o">.</span><span class="tok-n">OrderLine</span><span class="tok-p">(</span><span class="tok-s2">"order2"</span><span class="tok-p">,</span> <span class="tok-s2">"BLUE-LIPSTICK"</span><span class="tok-p">,</span> <span class="tok-mi">14</span><span class="tok-p">),</span>
<span class="tok-p">]</span>
<span class="tok-k">assert</span> <span class="tok-n">session</span><span class="tok-o">.</span><span class="tok-n">query</span><span class="tok-p">(</span><span class="tok-n">model</span><span class="tok-o">.</span><span class="tok-n">OrderLine</span><span class="tok-p">)</span><span class="tok-o">.</span><span class="tok-n">all</span><span class="tok-p">()</span> <span class="tok-o">==</span> <span class="tok-n">expected</span>
<span class="tok-k">def</span> <span class="tok-nf">test_orderline_mapper_can_save_lines</span><span class="tok-p">(</span><span class="tok-n">session</span><span class="tok-p">):</span>
<span class="tok-n">new_line</span> <span class="tok-o">=</span> <span class="tok-n">model</span><span class="tok-o">.</span><span class="tok-n">OrderLine</span><span class="tok-p">(</span><span class="tok-s2">"order1"</span><span class="tok-p">,</span> <span class="tok-s2">"DECORATIVE-WIDGET"</span><span class="tok-p">,</span> <span class="tok-mi">12</span><span class="tok-p">)</span>
<span class="tok-n">session</span><span class="tok-o">.</span><span class="tok-n">add</span><span class="tok-p">(</span><span class="tok-n">new_line</span><span class="tok-p">)</span>
<span class="tok-n">session</span><span class="tok-o">.</span><span class="tok-n">commit</span><span class="tok-p">()</span>
<span class="tok-n">rows</span> <span class="tok-o">=</span> <span class="tok-nb">list</span><span class="tok-p">(</span><span class="tok-n">session</span><span class="tok-o">.</span><span class="tok-n">execute</span><span class="tok-p">(</span><span class="tok-s1">'SELECT orderid, sku, qty FROM "order_lines"'</span><span class="tok-p">))</span>
<span class="tok-k">assert</span> <span class="tok-n">rows</span> <span class="tok-o">==</span> <span class="tok-p">[(</span><span class="tok-s2">"order1"</span><span class="tok-p">,</span> <span class="tok-s2">"DECORATIVE-WIDGET"</span><span class="tok-p">,</span> <span class="tok-mi">12</span><span class="tok-p">)]</span></code></pre>
</div>
</div>
</div>
</div>
<div class="colist arabic">
<ol>
<li>
<p>If you haven’t used pytest, the <code>session</code> argument to this test needs
explaining. You don’t need to worry about the details of pytest or its
fixtures for the purposes of this book, but the short explanation is that
you can define common dependencies for your tests as "fixtures," and
pytest will inject them to the tests that need them by looking at their
function arguments. In this case, it’s a SQLAlchemy database session.
</p>
</li>
</ol>
</div>
<div class="paragraph">
<p>You probably wouldn’t keep these tests around—​as you’ll see shortly, once
you’ve taken the step of inverting the dependency of ORM and domain model, it’s
only a small additional step to implement another abstraction called the
Repository pattern, which will be easier to write tests against and will
provide a simple interface for faking out later in tests.</p>
</div>
<div class="paragraph">
<p>But we’ve already achieved our objective of inverting the traditional
dependency: the domain model stays "pure" and free from infrastructure
concerns. We could throw away SQLAlchemy and use a different ORM, or a totally
different persistence system, and the domain model doesn’t need to change at
all.</p>
</div>
<div class="paragraph">
<p>Depending on what you’re doing in your domain model, and especially if you
stray far from the OO paradigm, you may find it increasingly hard to get the
ORM to produce the exact behavior you need, and you may need to modify your
domain model.<sup class="footnote">[<a id="_footnoteref_5" class="footnote" href="#_footnotedef_5" title="View footnote.">5</a>]</sup> As so often happens with
architectural decisions, you’ll need to consider a trade-off. As the
Zen of Python says, "Practicality beats purity!"</p>
</div>
<div class="paragraph">
<p>
At this point, though, our API endpoint might look something like
the following, and we could get it to work just fine:</p>
</div>
<div id="api_endpoint_with_session" class="exampleblock">
<div class="title">Using SQLAlchemy directly in our API endpoint</div>
<div class="content">
<div class="listingblock skip">
<div class="content">
<pre class="pygments highlight"><code data-lang="python"><span></span><span class="tok-nd">@flask</span><span class="tok-o">.</span><span class="tok-n">route</span><span class="tok-o">.</span><span class="tok-n">gubbins</span>
<span class="tok-k">def</span> <span class="tok-nf">allocate_endpoint</span><span class="tok-p">():</span>
<span class="tok-n">session</span> <span class="tok-o">=</span> <span class="tok-n">start_session</span><span class="tok-p">()</span>
<span class="tok-c1"># extract order line from request</span>
<span class="tok-n">line</span> <span class="tok-o">=</span> <span class="tok-n">OrderLine</span><span class="tok-p">(</span>
<span class="tok-n">request</span><span class="tok-o">.</span><span class="tok-n">json</span><span class="tok-p">[</span><span class="tok-s1">'orderid'</span><span class="tok-p">],</span>
<span class="tok-n">request</span><span class="tok-o">.</span><span class="tok-n">json</span><span class="tok-p">[</span><span class="tok-s1">'sku'</span><span class="tok-p">],</span>
<span class="tok-n">request</span><span class="tok-o">.</span><span class="tok-n">json</span><span class="tok-p">[</span><span class="tok-s1">'qty'</span><span class="tok-p">],</span>
<span class="tok-p">)</span>
<span class="tok-c1"># load all batches from the DB</span>
<span class="tok-n">batches</span> <span class="tok-o">=</span> <span class="tok-n">session</span><span class="tok-o">.</span><span class="tok-n">query</span><span class="tok-p">(</span><span class="tok-n">Batch</span><span class="tok-p">)</span><span class="tok-o">.</span><span class="tok-n">all</span><span class="tok-p">()</span>
<span class="tok-c1"># call our domain service</span>
<span class="tok-n">allocate</span><span class="tok-p">(</span><span class="tok-n">line</span><span class="tok-p">,</span> <span class="tok-n">batches</span><span class="tok-p">)</span>
<span class="tok-c1"># save the allocation back to the database</span>
<span class="tok-n">session</span><span class="tok-o">.</span><span class="tok-n">commit</span><span class="tok-p">()</span>
<span class="tok-k">return</span> <span class="tok-mi">201</span></code></pre>
</div>
</div>
</div>
</div>
</div>
</div>
<div class="sect2">
<h3 id="_introducing_the_repository_pattern"><a class="anchor" href="#_introducing_the_repository_pattern"></a>Introducing the Repository Pattern</h3>
<div class="paragraph">
<p>
The <em>Repository</em> pattern is an abstraction over persistent storage. It hides the
boring details of data access by pretending that all of our data is in memory.</p>
</div>
<div class="paragraph">
<p>If we had infinite memory in our laptops, we’d have no need for clumsy databases.
Instead, we could just use our objects whenever we liked. What would that look
like?</p>
</div>
<div id="all_my_data" class="exampleblock">
<div class="title">You have to get your data from somewhere</div>
<div class="content">
<div class="listingblock skip">
<div class="content">
<pre class="pygments highlight"><code data-lang="python"><span></span><span class="tok-kn">import</span> <span class="tok-nn">all_my_data</span>
<span class="tok-k">def</span> <span class="tok-nf">create_a_batch</span><span class="tok-p">():</span>
<span class="tok-n">batch</span> <span class="tok-o">=</span> <span class="tok-n">Batch</span><span class="tok-p">(</span><span class="tok-o">...</span><span class="tok-p">)</span>
<span class="tok-n">all_my_data</span><span class="tok-o">.</span><span class="tok-n">batches</span><span class="tok-o">.</span><span class="tok-n">add</span><span class="tok-p">(</span><span class="tok-n">batch</span><span class="tok-p">)</span>
<span class="tok-k">def</span> <span class="tok-nf">modify_a_batch</span><span class="tok-p">(</span><span class="tok-n">batch_id</span><span class="tok-p">,</span> <span class="tok-n">new_quantity</span><span class="tok-p">):</span>
<span class="tok-n">batch</span> <span class="tok-o">=</span> <span class="tok-n">all_my_data</span><span class="tok-o">.</span><span class="tok-n">batches</span><span class="tok-o">.</span><span class="tok-n">get</span><span class="tok-p">(</span><span class="tok-n">batch_id</span><span class="tok-p">)</span>
<span class="tok-n">batch</span><span class="tok-o">.</span><span class="tok-n">change_initial_quantity</span><span class="tok-p">(</span><span class="tok-n">new_quantity</span><span class="tok-p">)</span></code></pre>
</div>
</div>
</div>
</div>
<div class="paragraph">
<p>Even though our objects are in memory, we need to put them <em>somewhere</em> so we can
find them again. Our in-memory data would let us add new objects, just like a
list or a set. Because the objects are in memory, we never need to call a
<code>.save()</code> method; we just fetch the object we care about and modify it in memory.</p>
</div>
<div class="sect3">
<h4 id="_the_repository_in_the_abstract"><a class="anchor" href="#_the_repository_in_the_abstract"></a>The Repository in the Abstract</h4>
<div class="paragraph">
<p>
The simplest repository has just two methods: <code>add()</code> to put a new item in the
repository, and <code>get()</code> to return a previously added item.<sup class="footnote">[<a id="_footnoteref_6" class="footnote" href="#_footnotedef_6" title="View footnote.">6</a>]</sup>
We stick rigidly to using these methods for data access in our domain and our
service layer. This self-imposed simplicity stops us from coupling our domain
model to the database.</p>
</div>
<div class="paragraph">
<p>
Here’s what an abstract base class (ABC) for our repository would look like:</p>
</div>
<div id="abstract_repo" class="exampleblock">
<div class="title">The simplest possible repository (repository.py)</div>
<div class="content">
<div class="listingblock">
<div class="content">
<pre class="pygments highlight"><code data-lang="python"><span></span><span class="tok-k">class</span> <span class="tok-nc">AbstractRepository</span><span class="tok-p">(</span><span class="tok-n">abc</span><span class="tok-o">.</span><span class="tok-n">ABC</span><span class="tok-p">):</span>
<span class="tok-nd">@abc</span><span class="tok-o">.</span><span class="tok-n">abstractmethod</span> #<b class="conum">(1)</b>
<span class="tok-k">def</span> <span class="tok-nf">add</span><span class="tok-p">(</span><span class="tok-bp">self</span><span class="tok-p">,</span> <span class="tok-n">batch</span><span class="tok-p">:</span> <span class="tok-n">model</span><span class="tok-o">.</span><span class="tok-n">Batch</span><span class="tok-p">):</span>
<span class="tok-k">raise</span> <span class="tok-ne">NotImplementedError</span> #<b class="conum">(2)</b>
<span class="tok-nd">@abc</span><span class="tok-o">.</span><span class="tok-n">abstractmethod</span>
<span class="tok-k">def</span> <span class="tok-nf">get</span><span class="tok-p">(</span><span class="tok-bp">self</span><span class="tok-p">,</span> <span class="tok-n">reference</span><span class="tok-p">)</span> <span class="tok-o">-></span> <span class="tok-n">model</span><span class="tok-o">.</span><span class="tok-n">Batch</span><span class="tok-p">:</span>
<span class="tok-k">raise</span> <span class="tok-ne">NotImplementedError</span></code></pre>
</div>
</div>
</div>
</div>
<div class="colist arabic">
<ol>
<li>
<p>Python tip: <code>@abc.abstractmethod</code> is one of the only things that makes
ABCs actually "work" in Python. Python will refuse to let you instantiate
a class that does not implement all the <code>abstractmethods</code> defined in its
parent class.<sup class="footnote">[<a id="_footnoteref_7" class="footnote" href="#_footnotedef_7" title="View footnote.">7</a>]</sup>
</p>
</li>
<li>
<p><code>raise NotImplementedError</code> is nice, but it’s neither necessary nor sufficient.
In fact, your abstract methods can have real behavior that subclasses
can call out to, if you really want.</p>
</li>
</ol>
</div>
<div class="sidebarblock pagebreak-before less_space">
<div class="content">
<div class="title">Abstract Base Classes, Duck Typing, and Protocols</div>
<div class="paragraph">
<p>
We’re using abstract base classes in this book for didactic reasons: we hope
they help explain what the interface of the repository abstraction is.</p>
</div>
<div class="paragraph">
<p>
In real life, we’ve sometimes found ourselves deleting ABCs from our production
code, because Python makes it too easy to ignore them, and they end up
unmaintained and, at worst, misleading. In practice we often just rely on
Python’s duck typing to enable abstractions. To a Pythonista, a repository is
<em>any</em> object that has <code>add(<em>thing</em>)</code> and <code>get(<em>id</em>)</code> methods.</p>
</div>
<div class="paragraph">
<p>
An alternative to look into is <a href="https://oreil.ly/q9EPC">PEP 544 protocols</a>.
These give you typing without the possibility of inheritance, which "prefer
composition over inheritance" fans will particularly like.</p>
</div>
</div>
</div>
</div>
<div class="sect3">
<h4 id="_what_is_the_trade_off"><a class="anchor" href="#_what_is_the_trade_off"></a>What Is the Trade-Off?</h4>
<div class="quoteblock">
<blockquote>
<div class="paragraph">
<p>You know they say economists know the price of everything and the value of
nothing? Well, programmers know the benefits of everything and the trade-offs
of nothing.</p>
</div>
</blockquote>
<div class="attribution">
— Rich Hickey
</div>
</div>
<div class="paragraph">
<p>
Whenever we introduce an architectural pattern in this book, we’ll always
ask, "What do we get for this? And what does it cost us?"</p>
</div>
<div class="paragraph">
<p>Usually, at the very least, we’ll be introducing an extra layer of abstraction,
and although we may hope it will reduce complexity overall, it does add
complexity locally, and it has a cost in terms of the raw numbers of moving parts and
ongoing maintenance.</p>
</div>
<div class="paragraph">
<p>The Repository pattern is probably one of the easiest choices in the book, though,
if you’re already heading down the DDD and dependency inversion route. As far
as our code is concerned, we’re really just swapping the SQLAlchemy abstraction
(<code>session.query(Batch)</code>) for a different one (<code>batches_repo.get</code>) that we
designed.</p>
</div>
<div class="paragraph">
<p>We will have to write a few lines of code in our repository class each time we
add a new domain object that we want to retrieve, but in return we get a
simple abstraction over our storage layer, which we control. The Repository pattern would make
it easy to make fundamental changes to the way we store things (see
<a href="/book/appendix_csvs.html">[appendix_csvs]</a>), and as we’ll see, it is easy to fake out for unit tests.</p>
</div>
<div class="paragraph">
<p>
In addition, the Repository pattern is so common in the DDD world that, if you
do collaborate with programmers who have come to Python from the Java and C#
worlds, they’re likely to recognize it. <a href="#repository_pattern_diagram">Repository pattern</a> illustrates the pattern.</p>
</div>
<div id="repository_pattern_diagram" class="imageblock width-60">
<div class="content">
<img src="images/apwp_0205.png" alt="apwp 0205">
</div>
<div class="title">Figure 5. Repository pattern</div>
</div>
<div class="listingblock image-source">
<div class="content">
<pre>[ditaa, apwp_0205]
+-----------------------------+
| Application Layer |
+-----------------------------+
|^
|| /------------------\
||----------| Domain Model |
|| | Objects |
|| \------------------/
V|
+------------------------------+
| Repository |
+------------------------------+
|
V
+------------------------------+
| Database Layer |
+------------------------------+</pre>
</div>
</div>
<div class="paragraph">
<p>
As always, we start with a test. This would probably be classified as an
integration test, since we’re checking that our code (the repository) is
correctly integrated with the database; hence, the tests tend to mix
raw SQL with calls and assertions on our own code.</p>
</div>
<div class="admonitionblock tip">
<table>
<tr>
<td class="icon">
<div class="title">Tip</div>
</td>
<td class="content">
Unlike the ORM tests from earlier, these tests are good candidates for
staying part of your codebase longer term, particularly if any parts of
your domain model mean the object-relational map is nontrivial.
</td>
</tr>
</table>
</div>
<div id="repo_test_save" class="exampleblock">
<div class="title">Repository test for saving an object (test_repository.py)</div>
<div class="content">
<div class="listingblock">
<div class="content">
<pre class="pygments highlight"><code data-lang="python"><span></span><span class="tok-k">def</span> <span class="tok-nf">test_repository_can_save_a_batch</span><span class="tok-p">(</span><span class="tok-n">session</span><span class="tok-p">):</span>
<span class="tok-n">batch</span> <span class="tok-o">=</span> <span class="tok-n">model</span><span class="tok-o">.</span><span class="tok-n">Batch</span><span class="tok-p">(</span><span class="tok-s2">"batch1"</span><span class="tok-p">,</span> <span class="tok-s2">"RUSTY-SOAPDISH"</span><span class="tok-p">,</span> <span class="tok-mi">100</span><span class="tok-p">,</span> <span class="tok-n">eta</span><span class="tok-o">=</span><span class="tok-kc">None</span><span class="tok-p">)</span>
<span class="tok-n">repo</span> <span class="tok-o">=</span> <span class="tok-n">repository</span><span class="tok-o">.</span><span class="tok-n">SqlAlchemyRepository</span><span class="tok-p">(</span><span class="tok-n">session</span><span class="tok-p">)</span>
<span class="tok-n">repo</span><span class="tok-o">.</span><span class="tok-n">add</span><span class="tok-p">(</span><span class="tok-n">batch</span><span class="tok-p">)</span> #<b class="conum">(1)</b>
<span class="tok-n">session</span><span class="tok-o">.</span><span class="tok-n">commit</span><span class="tok-p">()</span> #<b class="conum">(2)</b>
<span class="tok-n">rows</span> <span class="tok-o">=</span> <span class="tok-n">session</span><span class="tok-o">.</span><span class="tok-n">execute</span><span class="tok-p">(</span> #<b class="conum">(3)</b>
<span class="tok-s1">'SELECT reference, sku, _purchased_quantity, eta FROM "batches"'</span>
<span class="tok-p">)</span>
<span class="tok-k">assert</span> <span class="tok-nb">list</span><span class="tok-p">(</span><span class="tok-n">rows</span><span class="tok-p">)</span> <span class="tok-o">==</span> <span class="tok-p">[(</span><span class="tok-s2">"batch1"</span><span class="tok-p">,</span> <span class="tok-s2">"RUSTY-SOAPDISH"</span><span class="tok-p">,</span> <span class="tok-mi">100</span><span class="tok-p">,</span> <span class="tok-kc">None</span><span class="tok-p">)]</span></code></pre>
</div>
</div>
</div>
</div>
<div class="colist arabic">
<ol>
<li>
<p><code>repo.add()</code> is the method under test here.</p>
</li>
<li>
<p>We keep the <code>.commit()</code> outside of the repository and make
it the responsibility of the caller. There are pros and cons for
this; some of our reasons will become clearer when we get to
<a href="/book/chapter_06_uow.html">[chapter_06_uow]</a>.</p>
</li>
<li>
<p>We use the raw SQL to verify that the right data has been saved.</p>
</li>
</ol>
</div>
<div class="paragraph">
<p>
The next test involves retrieving batches and allocations, so it’s more
complex:</p>
</div>
<div id="repo_test_retrieve" class="exampleblock">
<div class="title">Repository test for retrieving a complex object (test_repository.py)</div>
<div class="content">
<div class="listingblock">
<div class="content">
<pre class="pygments highlight"><code data-lang="python"><span></span><span class="tok-k">def</span> <span class="tok-nf">insert_order_line</span><span class="tok-p">(</span><span class="tok-n">session</span><span class="tok-p">):</span>
<span class="tok-n">session</span><span class="tok-o">.</span><span class="tok-n">execute</span><span class="tok-p">(</span> #<b class="conum">(1)</b>
<span class="tok-s2">"INSERT INTO order_lines (orderid, sku, qty)"</span>
<span class="tok-s1">' VALUES ("order1", "GENERIC-SOFA", 12)'</span>
<span class="tok-p">)</span>
<span class="tok-p">[[</span><span class="tok-n">orderline_id</span><span class="tok-p">]]</span> <span class="tok-o">=</span> <span class="tok-n">session</span><span class="tok-o">.</span><span class="tok-n">execute</span><span class="tok-p">(</span>
<span class="tok-s2">"SELECT id FROM order_lines WHERE orderid=:orderid AND sku=:sku"</span><span class="tok-p">,</span>
<span class="tok-nb">dict</span><span class="tok-p">(</span><span class="tok-n">orderid</span><span class="tok-o">=</span><span class="tok-s2">"order1"</span><span class="tok-p">,</span> <span class="tok-n">sku</span><span class="tok-o">=</span><span class="tok-s2">"GENERIC-SOFA"</span><span class="tok-p">),</span>
<span class="tok-p">)</span>
<span class="tok-k">return</span> <span class="tok-n">orderline_id</span>
<span class="tok-k">def</span> <span class="tok-nf">insert_batch</span><span class="tok-p">(</span><span class="tok-n">session</span><span class="tok-p">,</span> <span class="tok-n">batch_id</span><span class="tok-p">):</span> #<b class="conum">(2)</b>
<span class="tok-o">...</span>
<span class="tok-k">def</span> <span class="tok-nf">test_repository_can_retrieve_a_batch_with_allocations</span><span class="tok-p">(</span><span class="tok-n">session</span><span class="tok-p">):</span>
<span class="tok-n">orderline_id</span> <span class="tok-o">=</span> <span class="tok-n">insert_order_line</span><span class="tok-p">(</span><span class="tok-n">session</span><span class="tok-p">)</span>
<span class="tok-n">batch1_id</span> <span class="tok-o">=</span> <span class="tok-n">insert_batch</span><span class="tok-p">(</span><span class="tok-n">session</span><span class="tok-p">,</span> <span class="tok-s2">"batch1"</span><span class="tok-p">)</span>
<span class="tok-n">insert_batch</span><span class="tok-p">(</span><span class="tok-n">session</span><span class="tok-p">,</span> <span class="tok-s2">"batch2"</span><span class="tok-p">)</span>
<span class="tok-n">insert_allocation</span><span class="tok-p">(</span><span class="tok-n">session</span><span class="tok-p">,</span> <span class="tok-n">orderline_id</span><span class="tok-p">,</span> <span class="tok-n">batch1_id</span><span class="tok-p">)</span> #<b class="conum">(2)</b>
<span class="tok-n">repo</span> <span class="tok-o">=</span> <span class="tok-n">repository</span><span class="tok-o">.</span><span class="tok-n">SqlAlchemyRepository</span><span class="tok-p">(</span><span class="tok-n">session</span><span class="tok-p">)</span>
<span class="tok-n">retrieved</span> <span class="tok-o">=</span> <span class="tok-n">repo</span><span class="tok-o">.</span><span class="tok-n">get</span><span class="tok-p">(</span><span class="tok-s2">"batch1"</span><span class="tok-p">)</span>