Historical errata for Programming Ecto

Last paragraph: “Repo.aggregate(Artist, :count, :id)”

Should be: “MusicDB.Repo.aggregate(Artist, :count, :id)”

But I still get an error on execution: “ (Protocol.UndefinedError) protocol Ecto.Queryable not implemented for Artist, the given module does not exist. ”

Change code references to full path, i.e. MusicDB.Repo, MusicDB.Artist, or use an alias.

“You can open up an IEx session with iex -S mix as we did in the last section,
and type or copy/paste the code directly into the console. This works great
for one- or two-line examples.” No code in previous section

“If you just ran this command in IEx (and we hope you have), you just deleted
all the records in the tracks table. Oops. But remember that you can restore
all the app’s sample data by exiting out of IEx and running mix ecto.reset on
the command line.
This error is telling us that one or more of our artists records cannot be deleted
because there are other records that refer to them. ”

What error?

“To start, you’ll need Elixir 1.4 or greater, and a database that can support
Ecto 2.2 (we recommend Postgres, but you can also use MySQL)”

I don’t think MySQL can be used with the given source code, since the table “albums_with_embeds” has an array, and MySQL does not support them (?). In fact, I get the following error when running “mix ecto migrate” under MariaDB 10.2.14 :

(ArgumentError) Array type is not supported by MySQL
(ecto) lib/ecto/adapters/mysql/connection.ex:806: Ecto.Adapters.MySQL.Connection.error!/2
(ecto) lib/ecto/adapters/mysql/connection.ex:692: Ecto.Adapters.MySQL.Connection.column_type/2
(ecto) lib/ecto/adapters/mysql/connection.ex:622: Ecto.Adapters.MySQL.Connection.column_definition/2
(ecto) lib/ecto/adapters/mysql/connection.ex:769: Ecto.Adapters.MySQL.Connection.intersperse_map/4
(ecto) lib/ecto/adapters/mysql/connection.ex:529: Ecto.Adapters.MySQL.Connection.execute_ddl/1
(ecto) lib/ecto/adapters/mysql.ex:107: Ecto.Adapters.MySQL.execute_ddl/3

Next to last paragraph.
The add function… There’s no sensisble default…

Spell check.

First paragraph, second sentence.

This is so to that…

Last sentence of “Making Changes” section.

These work the same way ask they do in associations,…

Running the `mix do deps.get, compile` command yields an error with Elixir 1.5.2 or it seems potentially with any Elixir version down to 1.4 despite the statement “To start, you’ll need Elixir 1.4 or greater, and a database that can support Ecto 2.2 (we recommend Postgres …”

The error:
```

(Mix) You’re trying to run :music_db on Elixir v1.5.2 but it has declared in its mix.exs file it supports only Elixir ~> 1.6
```

The downloaded source has `mix.exs` dependency set to `~> 1.6` when I think it should have been `~> 1.4`. Otherwise, the text would need to be amended accordingly.

The following configuration allows the user to set up environment variables to configure the database. Since homebrew uses the username for the login, I tend to fallback to the username before defaulting to “postgres”. I’m not sure how well formatting will work here, but assuming at least pre tags work:

get_one_of = fn (vs, default) ->
  Enum.reduce(vs, nil, &(&2 || System.get_env(&1))) || default
end

config :music_db, MusicDB.Repo,
  adapter:   Ecto.Adapters.Postgres,
  username:  get_one_of.(["MUSIC_DB_USER", "USER"], "postgres"),
  password:  get_one_of.(["MUSIC_DB_PSWD", "USER"], "postgres"),
  database:  get_one_of.(["MUSIC_DB_NAME"], "music_db_#{Mix.env}"),
  hostname:  get_one_of.(["MUSIC_DB_HOST"], "localhost"),
  port:      get_one_of.(["MUSIC_DB_PORT"], 5432),
  pool_size: 10

Thank you,
Brett

track = Repo.one(from t in Track, where: t.title == “The Moontrane”)

What is exactly Repo.one when deleting? This isn’t “exactly” like inserting operation , the insert and insert all did not user Repo.one at all. What’s the behavior if we actually deleted two records? The document states: “Raises if more than one entry.” What does that even mean? How does that error looks like?

Text refers to ‘add_compositions_table’ as camel case. Should be snake case.

Hi,

firstly I love the book - it’s great. That said … :)

I think putting Ecto.Migration first seems a more natural order as that is how one would deal with learning how to interact with a database - How do I create schema in the database - How do I modify schema in the database - How do I create/retrieve/delete records - How do I modify records.

The example in the book is great - but I personally learn by doing my own examples - getting in and making mistakes and seeing how it fits together … especially with something that has multiple sections/modules like Ecto - it felt odd having to wait to get to Migrations before I worked out how that worked with ecto.

if not a complete reordering … maybe a section up front about how the Ecto modules map to the standard database operations - and that jumping ahead to Ecto.Migration wouldn’t interfer with the understanding when you come back to the book order.

Thanks for the book - it’s great.

Jonathan.

“This uses the :id type to indicate that it is an integer-based primary key, and
we add the :autogenerate option to tell Ecto that the database will be generating
this value for us.”

the previous example line “field :track_id, :id, primary_key: true” is actually missing the mentioned :autogenerate option

“This uses the :id type to indicate that it is an integer-based primary key, and we add the :autogenerate option to tell Ecto that the database will be generating this value for us.”

The code this is referencing doesn’t use ``:autogenerate`

The child specification at the top of the page should probably use the Elixir >= 1.5 child specification style, since it was introduced on the previous page. So instead of `supervisor(MyApp.Repo, [])`, just `MyApp.Repo`.

“helps prevent runaway situations where our is code making”

It should be “where our code is making”.

Can you include the migration for the “albums_genres” join table? (or at least the mix task)

Thanks!

“users who needs to use Elixir” should rather be “users who need to use Elixir”

In the first paragraph of “Resetting The Sample Data” section, there is:

“As we work through the examples in the book, we’ll making”

and should be

“As we work through the examples in the book, we’ll be making”

In first paragraph on the page (after example of output from database), there is:

“this shortcut doesn’t appear the documentation”

and should be:

“this shortcut doesn’t appear in the documentation”

Seeding the sample data doesn’t work - there is no such file lib/music_db/note.ex:

(UndefinedFunctionError) function MusicDB.Note.schema/1 is undefined (module MusicDB.Note is not available)
MusicDB.Note.schema(:primary_key)
(ecto) lib/ecto/changeset/relation.ex:138: Ecto.Changeset.Relation.change/3
(ecto) lib/ecto/repo/schema.ex:597: anonymous fn/4 in Ecto.Repo.Schema.surface_changes/3
(elixir) lib/enum.ex:1899: Enum.“reduce/3-lists^foldl/2-0”/3
(ecto) lib/ecto/repo/schema.ex:584: Ecto.Repo.Schema.surface_changes/3
(ecto) lib/ecto/repo/schema.ex:189: Ecto.Repo.Schema.do_insert/4
(ecto) lib/ecto/repo/schema.ex:125: Ecto.Repo.Schema.insert!/4
priv/repo/seeds.exs:15: (file)

“We’re also going assume” -> “going to assume”

“Ecto will take this data structure and convert it into a SQL statement for us” -> “into an SQL statement”

End of the page ^(“Bill” <> “Evans”) should probably contain a space between the names.

1. date comparision
   -> comparison

“We’ll be covering schemas in depth in the next chapter, but for now, we’ll write our queries without schemas.”

how about

“We’ll be covering schemas in depth in the next chapter, but for now, we’ll write our queries without them.” - would not repeating “schema” read better?

“After you’ve had some experience writing queries, adding schemas will make much more sense, and you’ll have a better sense of when they help and when they don’t.”

here repetition of “sense” close to each other sounds a bit odd… How about:

“After you’ve had some experience writing queries, adding schemas will make much more sense, and you’ll have a better (feeling/understanding) of when they help and when they don’t.”

“As you might have guessed, the two where clauses are combined via AND, resulting in a query that looks for albums that are are associated with both..”
-> double “are”

“In either case, if you set the value to :nothing, deleting a parent record with child records will mostly likely fail.”
-> “most likely fail”

“The data we’ve been using so far has been generated in our code. In most cases however, the data you want to apply will coming from…”
-> “will be coming from”

“we wouldn’t want two records both called “jazz,” for example"
-> “jazz”,

“We’ll add unique_constraint to our changeset make sure the name value is unique”
-> “changeset to make sure”

“You could check for validations errors”
-> “validation errors”

form = %{artist_name…
written twice with only one sentence in between.

“… even if you app doesn’t use a database.”
-> “your app”

“(recall that this the usual way to create a changeset when working with internal data)”
-> “… this is the usual way…”

“When we try to run this code, the output is surprising…”

I didn’t get an error message because changeset/2 is already defined in the sample code.

" Open up lib/music_db/artist.ex and change the has_many :albums line so it looks like this:"

That line is in the sample code already
“has_many(:albums, Album, on_replace: :nilify)”

“The first way is provide another function”
-> “is to provide”

“Here’s where two approaches really diverge.”
-> “where the two approaches”

Missing “it” in the end of the second paragraph: “If your code feels clumsy, or too complicated, try another approach and see <> works better.”

“… it determined that it should the drop the table”
-> “it should drop the table” (without "the)

In order to make “from” and “Repo” work additionally these lines need to be added:
import Ecto.Query
alias MusicDB.Repo

“For example, here’s a SQL query”
-> “an SQL query”

“—- into a SQL statement”
-> “an SQL statement” (if not pronounced as /ˈsiːkwəl/)

The code did not do as expected. I downloaded the code unzipped it and edited my config.exs for the username and password. Then ran mix deps.get, and mix compile no problems so far. Then ran mix ecto.setup. It appears there were 8 tables created in the database. The command did not finished successfully though. Excerpt below. The error is: “ (UndefinedFunctionError) function MusicDB.Note.schema/1 is undefined (module MusicDB.Note is not available)
”

…
07:41:16.799 [info] == Migrated in 0.0s

07:41:16.828 [info] == Running MusicDB.Repo.Migrations.AddAlbumsGenresTable.change/0 forward

07:41:16.829 [info] create table albums_genres

07:41:16.839 [info] create index albums_genres_album_id_index

07:41:16.848 [info] create index albums_genres_genre_id_index

07:41:16.854 [info] == Migrated in 0.0s

07:41:16.881 [info] == Running MusicDB.Repo.Migrations.AddLogsTable.change/0 forward

07:41:16.881 [info] create table logs

07:41:16.896 [info] == Migrated in 0.0s

07:41:16.922 [info] == Running MusicDB.Repo.Migrations.AddAlbumsWithEmbeds.change/0 forward

07:41:16.922 [info] create table albums_with_embeds

07:41:16.934 [info] == Migrated in 0.0s

07:41:17.114 [debug] QUERY OK db=3.2ms queue=99.0ms
begin []

07:41:17.120 [debug] QUERY OK db=3.6ms
INSERT INTO “genres” (“name”,“wiki_tag”,“inserted_at”,“updated_at”) VALUES ($1,$2,$3,$4) RETURNING “id” [“jazz”, “Jazz”, {{2018, 8, 19}, {14, 41, 17, 114782}}, {{2018, 8, 19}, {14, 41, 17, 114792}}]

07:41:17.122 [debug] QUERY OK db=1.7ms
commit []

07:41:17.122 [debug] QUERY OK db=0.7ms
begin []

07:41:17.125 [debug] QUERY OK db=2.2ms
INSERT INTO “genres” (“name”,“wiki_tag”,“inserted_at”,“updated_at”) VALUES ($1,$2,$3,$4) RETURNING “id” [“live”, “Concert”, {{2018, 8, 19}, {14, 41, 17, 122988}}, {{2018, 8, 19}, {14, 41, 17, 122997}}]

07:41:17.127 [debug] QUERY OK db=1.6ms
commit []

(UndefinedFunctionError) function MusicDB.Note.schema/1 is undefined (module MusicDB.Note is not available)
MusicDB.Note.schema(:primary_key)
(ecto) lib/ecto/changeset/relation.ex:138: Ecto.Changeset.Relation.change/3
(ecto) lib/ecto/repo/schema.ex:597: anonymous fn/4 in Ecto.Repo.Schema.surface_changes/3
(elixir) lib/enum.ex:1925: Enum.“reduce/3-lists^foldl/2-0”/3
(ecto) lib/ecto/repo/schema.ex:584: Ecto.Repo.Schema.surface_changes/3
(ecto) lib/ecto/repo/schema.ex:189: Ecto.Repo.Schema.do_insert/4
(ecto) lib/ecto/repo/schema.ex:125: Ecto.Repo.Schema.insert!/4
priv/repo/seeds.exs:15: (file)
✘-1 ~/Documents/src/elixir/pragprog/ecto
07:41 $ iex -S mix
Erlang/OTP 21 [erts-10.0.4] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [hipe] [dtrace]

Interactive Elixir (1.7.2) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> MusicDB.Repo.aggregate(“artists”, :count, :id)

07:44:19.540 [debug] QUERY OK source=“artists” db=2.7ms
SELECT count(a0.“id”) FROM “artists” AS a0 []
0

Task ‘mix ecto.setup’ fails.

(UndefinedFunctionError) function MusicDB.Note.schema/1 is undefined (module MusicDB.Note is not available)
MusicDB.Note.schema(:primary_key)
(ecto) lib/ecto/changeset/relation.ex:138: Ecto.Changeset.Relation.change/3
(ecto) lib/ecto/repo/schema.ex:597: anonymous fn/4 in Ecto.Repo.Schema.surface_changes/3
(elixir) lib/enum.ex:1925: Enum.“reduce/3-lists^foldl/2-0”/3
(ecto) lib/ecto/repo/schema.ex:584: Ecto.Repo.Schema.surface_changes/3
(ecto) lib/ecto/repo/schema.ex:189: Ecto.Repo.Schema.do_insert/4
(ecto) lib/ecto/repo/schema.ex:125: Ecto.Repo.Schema.insert!/4
priv/repo/seeds.exs:15: (file)

In the section on Changing Timestamps.

trying to create timestamps with a timezone fails with:

timestamps(type: :utc_datetime)

Results in Postgres are still Sanz timezone.

Instead call:
timestamps(type: :timestamptz)

If instead you pass [type:

Array type is not supported by MySQL

When running mix ecto.setup I get the following error:

13:11:11.566 [info] == Running MusicDB.Repo.Migrations.AddAlbumsWithEmbeds.change/0 forward

13:11:11.566 [info] create table albums_with_embeds

(ArgumentError) Array type is not supported by MySQL
(ecto) lib/ecto/adapters/mysql/connection.ex:806: Ecto.Adapters.MySQL.Connection.error!/2
(ecto) lib/ecto/adapters/mysql/connection.ex:692: Ecto.Adapters.MySQL.Connection.column_type/2
(ecto) lib/ecto/adapters/mysql/connection.ex:622: Ecto.Adapters.MySQL.Connection.column_definition/2
(ecto) lib/ecto/adapters/mysql/connection.ex:769: Ecto.Adapters.MySQL.Connection.intersperse_map/4
(ecto) lib/ecto/adapters/mysql/connection.ex:529: Ecto.Adapters.MySQL.Connection.execute_ddl/1
(ecto) lib/ecto/adapters/mysql.ex:107: Ecto.Adapters.MySQL.execute_ddl/3
(ecto) lib/ecto/migration/runner.ex:104: anonymous fn/2 in Ecto.Migration.Runner.flush/0
(elixir) lib/enum.ex:1925: Enum.“reduce/3-lists^foldl/2-0”/3

Sadly, I am learning ecto to work with an existing MySQL DB. Postgres is not an option.

First paragraph of “Optimizing Associations With Embedded Schemas” section says:

“Ecto’s protection against N+1 queries helps prevent runaway situations where our is code is”

there is one extra “is”

The section starting Approach #1: Multiple Foreign Keys - all of it.

See SQL Antipatterns by Bill Karin, Pragmatic Bookshelf. Chapter 7.

This is not a good idea!

The two examples probably need to be swapped.

> Here’s how we could add and retrieve a note for an Artist record:
> album = Repo.get_by(Album, title: “Kind Of Blue”)

>To add a note for an Album record, we can do the exact same thing.
> artist = Repo.get_by(Artist, name: “Bobby Hutcherson”)

In the snippet “priv/examples/changeset_10.exs”, in the query, there is defined association to preload:

Repo.one(from a in Artist, where: a.name == “Miles Davis”, preload: :albums)

and in the comment to it mentions the error risen by Ecto:

#=> (RuntimeError) attempting to cast or change association `albums`
#=> from `MusicDB.Artist` that was not loaded. Please preload your
#=> associations before manipulating them through changesets

But it’s not the case, because the association was properly preloaded

In the third paragraph of “Making Changes To Your Database” chapter, there is:

“A migration is a set of commands, created in Elixir, that contains”

should be:

“A migration is a set of commands, created in Elixir, that contain” (“contain” vs “contains”, as it is in relation to plural “commands”)

In the paragraph after example output of ecto rollback, there is this sentence:

“it determined that it should the drop the table”

which consists of one extraneous “the”, and should read as:

“it determined that it should drop the table”

Following example:

changeset = Repo.one(from a in Artist, where: a.name == “Miles Davis”, preload: :albums) |> change |> put_assoc(:albums, [%Album{title: “Miles Ahead”}]) Repo.update(changeset)

does work properly as it has :preload :albums while the result in the book is showing the error:
#=> (RuntimeError) attempting to cast or change association `albums` #=> from `MusicDB.Artist` that was not loaded. Please preload your #=> associations before manipulating them through changesets

In the code sample “priv/examples/changeset_10.exs” the query passed to `Repo.one` includes the keyword item `preload: :albums`

However, the paragraphs that immediately follow that sample suggest that you should get an error back from Ecto because the albums have not been preloaded. The next code sample purports to rectify this situation by piping the changeset through “Repo.preload(:albums)”

If you strictly follow through the examples then you do not get the error that the text suggests you should. :-)

Following the paragraph that begins “The problem is that we want make changes to the albums association…”, there is a code sample which goes on to pipe the result of a query through “Repo.preload(:albums)” then creates a changeset using “put_assoc”

The text goes on to mention that this code sample should raise because the `on_replace:` value of the Albums association for an Artist has its value set to “:raise”.

In the version of the code that I downloaded, the line of the Artist’s schema that defines the albums association is:

has_many(:albums, Album, on_replace: :nilify)

(note :nilify instead of :raise) As a result, I did not see the error called out in the text.

Near the top of the page, after the end of the code sample is the sentence:

“It’s OK if the ids don’t match exactly, but the titles should be the same.”

When I first read that I thought “why in the heck would the two albums have the same id?”

Thats when I realized it was not saying “It’s OK if the ids [of the two albums] don’t match [one another]”, but instead was saying, “It’s OK if the ids [of the albums you get back] don’t match [the ids of the albums we show in the code sample]” :-)

Perhaps this could be clarified: “It’s OK if the ids of your albums don’t match our ids”, or “It’s OK if the ids you get back don’t match the ones shown above”

This is a VERY small issue so I promise my feelings won’t be hurt if you just don’t care :-)

“When we try to run this code, the output is surprising…”

I didn’t get an error message because changeset/2 is already defined in the sample code.
—Andreas Pehnack

I know that, this book mainly focused on Ecto 2.x, but I wish you will update it to cover changes in Ecto 3.x. I used Ecto 3.0.x and in the example in that page[92] you show that if error occurred inside Multi operations, like Multi.error in that example, this will return map with operations that executed till this error occurrence and then Ecto will rollback the database, But in Ecto 3.0.x this doesn’t happen, I got empty %{} and I read docs and it tells that it doesn’t run any operations as long as there is error in changeset or occurred by Multi.error. Thanks and I hope you will update the book to cover Ecto 3.

In fourth line over “Displaying Changeset Errors” title, it is written:

If it succeeds, we redirect the user to the homepage.

This is wrong, it should redirect the user to his page or profile page. Or should written “redirect to show the newly created user” or something like that. But not homepage as homepage understood as root “/”

During the explanation on many-to-many relationships, you mention that we cannot use the simple many_to_many relationship if we want to store extra fields in the join table. It would be extremely helpful if you could provide an example of what having extra fields in the join table would look like and how you would insert, query, and update that type of data.

We’ll take you though what we believe is the optimal path for learning the major components[..]

Should be through instead of though.

In the first sentence of the third paragraph of the Introduction:

“SQL is powerful—there’s a reason it’s stuck around a long as it has—but generating it manually is tedious and error-prone.”

Typo: “there’s a reason it’s stuck around —>[a]<— long as it has”
Correct: “there’s a reason it’s stuck around —>[as]<— long as it has”

Does this include Ecto 3.0 and its new features?

“here we’re deleting all the records that a mispelled title”

should read

“here we’re deleting all the records that have a mispelled title”

“The first step is to take the raw input data that you want to apply to do the database and generate an Ecto.Changeset struct.”

should (presumably) read:

“The first step is to take the raw input data that you want to apply to the database and generate an Ecto.Changeset struct.” (note the dropped “do”)

The file referenced in the sentence at the bottom of the page - “You worked with these values in the previous section when you modified config/dev.exs to match your local database installation.” - is incorrect. The file modified in the previous section is config/config.exs, not config/dev.exs.

You worked with these values in the previous section when you modified config/dev.exs

With the attached code, we modified config/config.exs and not config/dev.exs as mentioned above

… the value should contains the values…

Should read

… the value should contain the values

On a Kindle, so not sure of the exact page, but it is in the section of chapter 7 titled: “What is a supervision tree?”

It reads “…and as programs increase in complexity, there can many groups of processes…”

There should be a “be” between “can” and “many”

Again, on a Kindle so hard to know which page exactly, but it’s in the Wrapping Up section of Chapter 8.

The line "Forms are a much bigger topic that we can really cover here, so if you’d like learn more, we…

Should be:

“Forms are a much bigger topic than we can really cover here, so if you’d like to learn more, we…”

At the bottom of page 37, the function allows you to pass in “query” as the first parameter but that is only going to work when set to “albums” because the join on the “tracks” foreign key is hardcoded to “album_id”.

I’m just learning this stuff so if I’m wrong that will be just as helpful to know. Please let me know either way. :)

The bottom of page 32 reads:

Now let’s say that somewhere else in our code, we wanted a list of the tracks on those albums, and not just the album titles. We’d have to rewrite the query to look like this:

The above sets the expectation that the query on the top of 33 will have a select statement as follows:

select: [a.title, t.title]

If the query at the top of page 33 is correct, I’d suggest that you change the copy at the bottom of page 32 to read:

Now let’s say that somewhere else in our code, we wanted a list of the tracks on those albums. We’d have to rewrite the query to look like this:

If the copy at the bottom of page 32 is correct (which makes more sense to me):

you could change the select values.

I feel like you are setting up the reader to get all excited to nest one query into another but the section never gets there. I was expecting something like this at some point:

q = from a in albums_by_miles,
join: t in “tracks”,
on: t.album_id == a.id,
select: [a.title, t.title]

In the next section (Named Bindings) you could revisit the same query as follows:

albums_by_miles = from a in “albums”, as: :albums,
join: ar in “artists”,
on: a.artist_id ar.id, where: ar.name “Miles Davis”

q = from [albums: a] in albums_by_miles,
join: t in “tracks”,
on: t.album_id == a.id,
select: [a.title, t.title]

In addition to giving the reader another chance to digest the fact that you can reference one query in another query because “in” macro does more than just strings, you also show that you don’t have to bind a name to both from and join which isn’t called out anywhere in the section.

The callout area on protocols is super confusing to me as a first time reader of this book. I have a moderate level of familiarity with Elixir and in my opinion the discussion here dives too deep, too fast without connecting the dots.

• You refer to the Enumerables protocol but it’s invoked in Elixir as Enum.

Consider the following passage:

A good example is Enumerable. Enumerable defines functions like count and member, and any data type that provides definitions for those functions can be used in any function that expects Enumerable.

Huh?

I think it might be helpful to include the actual code you would use, as follows:

A good example is Enumerable. The Enumerable protocol provides functions like Enum.count and Enum.member. Any data type (e.g. list, map, range) that can implement an Enumerable protocol can be used in any Enumerable function (Enum.*).

My own understanding of protocols is that they are one level higher than a function: a set of algorithms that can do work on a set of data types. I don’t know if this is technically correct, but dumbing it down to this level before diving into something more technical would be useful in my opinion.

Consider the following paragraph:

So far, we’ve always been using strings on the right side of the in expression (for example, from a in “albums”). That string has always represented the name of a table in our database. But the in expression is actually looking for something broader than that: it’s looking for any data type that has implemented the Ecto.Queryable protocol.

Suggested changes for better comprehension:

So far, we’ve used a string on the right side of the in expression to represent a table name (for example, from a in “albums”), but the in expression supports more than just the string data type. The Ecto.Queryable protocol can also be implemented by the %Ecto.Query{} data type which in this case is created using the from macro.

Last sentence of the first paragraph:

From:

You create the mappings with an elegant, concise DSL, then use associations to connect related structures together.

To:

Ecto is Elixir’s elegant, concise domain-specific language (DSL) that lets you create data structure mappings that can connect related structures together.

Reasoning:
It’s unclear in the first version that DSL is referring back to Ecto.
I think it’s good to use the full version before introducing an acronym.
It might make sense to make this the second sentence of the paragraph as it might flow better to go from the most general case to the most specific.

Top paragraph suggested text change:

Now’s the time. -> Now’s that time.

Question about technical details here on page 46 3rd paragraph down:

“Finally, the return value is a schema struct. Instead of getting back a list or a map, we get a %Track{} struct, populated with the values from the corresponding database record:”

Doesn’t a schema-less query return %Ecto.Query{} not “a list or a map”?

Second paragraph of Many-to-Many Associations doesn’t include an example of one album having many genres which of the two is probably more in need of an example because it is less intuitive.

Existing copy:

A good example of a many-to-many relationship is assigning genres to albums. Genres describe the musical style of an album, for example jazz, classical, rock, blues, death polka, and so on. We want to be able to assign more than one genre for each album. But we also…

Suggested copy:

A good example of a many-to-many relationship is assigning genres to albums. Genres describe the musical style of an album, for example jazz, classical, rock, blues, death polka, and so on. We want to be able to assign more than one genre for each album. For example, Yo-Yo Ma’s cover of Empire State of Mind is both classical and hip hop. But we also…

Source: www(dot)youtube(dot)com/watch?v=elm16AXW_sE

“album.tracks” doesn’t get the error you listed for the version of the code that I downloaded. I get the following error:

(UndefinedFunctionError) function MusicDB.Album.tracks/0 is undefined or private
(music_db) MusicDB.Album.tracks()

I think you guys meant -> %Album{}.tracks

album.tracks gives the following error:

(UndefinedFunctionError) function MusicDB.Album.tracks/0 is undefined or private
(music_db) MusicDB.Album.tracks()

I think you meant -> %Albums{}.tracks

album.tracks gives the following error:

(UndefinedFunctionError)…

I think you meant -> %Albums{}.tracks

album.tracks doesn’t give the error listed in the book for the version of the code I downloaded.

I think you meant -> %Albums{}.tracks

album(dot)tracks doesn’t give the error listed in the book for the version of the code I downloaded.

I think you meant -> (percent sign)Albums{}(dot)tracks

table name doesn’t seem internally consistent:

mix ecto.gen.migration add_composition_artists_table

mix ecto.gen.migration add_compositions_artists_table <- seems more consistent with the chapter and also the coverage of many to many relationships on page 53 where the table is named albums_genres (both plural)

Make table name compositions_artists_table instead of using “composition” (singular)

Seems more consistent with the chapter and with treatment on page 53

“Working with Associations in Queries”

“In some ways, that seems like the right thing to do. We have an album record and we want the associated tracks, so it makes sense that the library would make things easy for us and go fetch the tracks when we ask for them. The trouble is that it can lead to performance problems as the database grows. Consider the following pseudocode:”

​ \talbums = get_album_records_from_database()
​ \tfor album ​in​ albums ​do​
​ \t print album.title
​ \t for tracks ​in​ album.tracks ​do​ ​# tracks are lazy loaded here​
​ \t print ​“​​ * ​​#{​track.title​}​​ ”​
​ \t ​end​
​ \t​end

This is just pseudocode but I think the list comprehension on line 4 should read:

for track in album.tracks do

The message displayed after running ` mix ecto.setup` does not match, it should be as it is in ` seeds.exe`` :
``` Success! Sample data has been added.` instead of ` Sample data successfully loaded.``

You are sending to config/dev.exs file when talking about matching the local database installation:
“You worked with these values in the previous section when you modified config/dev.exs to match your local database installation”.

But it’s config/config.exs that you mentioned previously on page 6:
“2)In your favorite editor, open ‘config/config.exs‘ and look at the section
starting with:
…
”

When I first saw this query, I thought it was a typo - but it is not. It works fine:

Repo.all(from a in Artist, preload: [albums: :tracks])

Even though the above works, I would prefer the following, which also works:

Repo.all(from a in Artist, preload: [:albums, :tracks])

My reasoning? When the nested association was introduced a few pages earlier on p. 52, it was done in a manner consistent with my suggestion:

schema “artists” do
# field definitions here…

has_many :albums, MusicDB.Album
has_many :tracks, through: [:albums, :tracks]
end

Paragraph starts with “When using order, “ “order” should be
“order_by”.

Lots of deprecation warnings when the MusicDB application is first compiled, specifically for the ecto package. Do you have a more current dependencies listing somewhere? Or should I update the versions of the packages on my own?

==> ecto
Compiling 54 files (.ex)
warning: Code.ensure_compiled?/1 is deprecated. Use Code.ensure_compiled/1 instead (see the proper disclaimers in its docs)
lib/ecto/association.ex:820: Ecto.Association.BelongsTo.after_compile_validation/2

warning: Code.ensure_compiled?/1 is deprecated. Use Code.ensure_compiled/1 instead (see the proper disclaimers in its docs)
Found at 2 locations:
lib/ecto/association.ex:974: Ecto.Association.ManyToMany.after_compile_validation/2
lib/ecto/association.ex:980: Ecto.Association.ManyToMany.after_compile_validation/2

warning: Inspect.Algebra.surround_many/5 is deprecated. Use Inspect.Algebra.container_doc/6 instead
lib/ecto/query/inspect.ex:Inspect.Ecto.Query.DynamicExpr.inspect/2

warning: Inspect.Algebra.surround_many/5 is deprecated. Use Inspect.Algebra.container_doc/6 instead
lib/ecto/changeset.ex:Inspect.Ecto.Changeset.inspect/2

warning: Code.ensure_compiled?/1 is deprecated. Use Code.ensure_compiled/1 instead (see the proper disclaimers in its docs)
lib/ecto/association.ex:523: Ecto.Association.Has.after_compile_validation/2

warning: Code.ensure_compiled?/1 is deprecated. Use Code.ensure_compiled/1 instead (see the proper disclaimers in its docs)
lib/ecto/repo/supervisor.ex:70: Ecto.Repo.Supervisor.compile_config/2

warning: Supervisor.Spec.supervise/2 is deprecated. Use the new child specifications outlined in the Supervisor module instead
lib/ecto/repo/supervisor.ex:204: Ecto.Repo.Supervisor.supervisor_init/2

warning: Inspect.Algebra.surround_many/5 is deprecated. Use Inspect.Algebra.container_doc/6 instead
lib/ecto/query/inspect.ex:Inspect.Ecto.Query.inspect/2

warning: Code.ensure_compiled?/1 is deprecated. Use Code.ensure_compiled/1 instead (see the proper disclaimers in its docs)
lib/ecto/schema.ex:1968: Ecto.Schema.check_field_type!/3

Kindle loc 6581.

“this can be advantage”