diff --git a/module2/lessons/grouping_and_aggregating.md b/module2/lessons/grouping_and_aggregating.md index dde3facf..5c0da08b 100644 --- a/module2/lessons/grouping_and_aggregating.md +++ b/module2/lessons/grouping_and_aggregating.md @@ -568,10 +568,78 @@ Test your understanding by writing queries for the following in ActiveRecord: 1. Write a query to return each artist's name and a comma separated list of all their songs, for example "Talking Heads" would have "This must be the Place, Heaven" + ## Checks for Understanding - What are aggregate functions? Where do they appear in SQL statements? - What do calculation methods in AR return? - What does the `group by` statement do in sql? - Why do we need to include an aggregate function when using `group by`? -- When do we need to join? \ No newline at end of file +- When do we need to join? + +### Solutions +Only use these as references after you've tried the above practice queries on your own! Keep in mind that there are multiple ways to arrive at these soultions, so if your query returns the expected output but is different than the query listed below, it's still probably good! + +
+

#1: Length of the longest song

+```ruby + Song.maximum(:length) +``` +
+ +
+

#2: Length of each artist's longest song

+```ruby + Artist.select("artists.*, max(length)") + .joins(:songs) + .group("artists.id") +``` +
+ +
+

#3: Name of the artist with the longest song

+```ruby + Artist.joins(:songs) + .select("artists.name, max(length)") + .group(:name) + .order("max desc") + .limit(1) + .first + .name +``` +
+ +
+

#4: Average length of each artist's songs

+```ruby + Artist.select("artists.*, avg(length)") + .joins(:songs) + .group(:id) +``` +
+ +
+

#5: Name of the artist with the longest average length of song

+```ruby + Artist.select("artists.name, avg(length)") + .joins(:songs) + .group(:id) + .order("avg desc") + .limit(1) + .first + .name +``` +
+ +
+

#6: Names of the three artists with the least amount of total plays for all of their songs

+```ruby + Artist.select("artists.name, min(play_count)") + .joins(:songs) + .group(:id) + .order("min asc") + .limit(3) + .pluck(:name) +``` +
+ diff --git a/module2/lessons/images/m2m-albums-photos-joined.png b/module2/lessons/images/m2m-albums-photos-joined.png new file mode 100644 index 00000000..b99fce76 Binary files /dev/null and b/module2/lessons/images/m2m-albums-photos-joined.png differ diff --git a/module2/lessons/images/one-to-many-answer.png b/module2/lessons/images/one-to-many-answer.png new file mode 100644 index 00000000..430fba81 Binary files /dev/null and b/module2/lessons/images/one-to-many-answer.png differ diff --git a/module2/lessons/index.md b/module2/lessons/index.md index baf998e2..87cd8cc7 100644 --- a/module2/lessons/index.md +++ b/module2/lessons/index.md @@ -60,6 +60,7 @@ layout: page - [Many to Many Relationships](./many_to_many) - [SQL and ActiveRecord](./sql_and_active_record) - [Joins](./joins) +- [Multiple Joins / Advanced AR](./joins_2) - [Grouping and Aggregating](./grouping_and_aggregating) ## Testing and Debugging diff --git a/module2/lessons/intro_to_mvc.md b/module2/lessons/intro_to_mvc.md index 9543a60f..e799a60c 100644 --- a/module2/lessons/intro_to_mvc.md +++ b/module2/lessons/intro_to_mvc.md @@ -118,9 +118,21 @@ Controllers should limit their database actions to very simple lookups, or creat NOTE: For task 2, You should not have to create a new view. -**Let’s also quickly talk about why the 2nd path isn’t a good idea.** -### Recap + +
+

+expander arrowLet’s explore about why the 2nd path above isn’t a good idea. +

+ +When you expose an endpoint (a path / URI) for a given resource, it is a good idea to ensure that path is fully fleshed out and functional. A second endpoint can sometimes be confusing for the end user - they may be left asking, _"Which route is the correct one?"_ + +Also, if the page that is meant to be served needs to change or the paths need updating, now you have not one path but __two__ to remember to update. + +Can you think of any other reasons to limit paths to specific resources in web applications? +
+ +## Checks for Understanding - What does MVC stand for? - What are the "logic responsibilities" for each part of the MVC pattern? diff --git a/module2/lessons/joins.md b/module2/lessons/joins.md index e87f7ebe..08edb9be 100644 --- a/module2/lessons/joins.md +++ b/module2/lessons/joins.md @@ -233,6 +233,7 @@ irb(main):001:0> Artist.joins(:songs).where('songs.length > ?', 400) ``` ## Checks for Understanding +You can also answer these questions using [this form](https://forms.gle/iTQ8T9FX86uAuq6aA). 1. What are the three types of joins covered today? And, what do they return? 2. What is the SQL query to get a list of Artists who have songs that have been played more than 20 times? diff --git a/module2/lessons/joins_2.md b/module2/lessons/joins_2.md index 06069bea..3cf2aaec 100644 --- a/module2/lessons/joins_2.md +++ b/module2/lessons/joins_2.md @@ -6,6 +6,11 @@ title: Multiple Joins ## Prerequisites For success in this lesson, be sure you have reviewed the [Joins](./joins) lesson first. +## Learning Goals +* Identify scenarios requiring multiple `join` statements in a query +* Write ActiveRecord queries that join multiple tables utilizing AR associations +* Explore some drawbacks of using AR associations across multiple joins + ## Set Up Clone and check out the `joins-homework` branch of the [Set List Tutorial](https://github.com/turingschool-examples/set-list-7/tree/joins-homework). @@ -152,11 +157,69 @@ The takeaway here is, if we're not careful with our joins, it may result in some ## Further Practice Try implementing some of these queries on your own. You may want to try writing them out in SQL first, before translating them to ActiveRecord. -* Return a unique list of songs that appear on at least 1 playlist. -* Return the names of playlists that have at least 3 distinct artists. -* Return the names of artists that appear on at least 3 different playlists. +_NOTE_: We recommend adding more songs to your playlists to order to work with a larger dataset! You can try the following: +```ruby +Playlist.first.songs << Song.first +Playlist.first.songs << Song.second + +Playlist.second.songs << Song.first +# etc., or feel free to create your own songs and Playlist relationships in your seeds.rb +``` + +1. Return a unique list of songs that appear on at least 1 playlist. +2. Return the names of playlists that have at least 3 different artists. +3. Return the names of artists that appear on at least 3 different playlists. + + +### Solutions +Try the above queries in `rails c` or in a project first before comparing against these solutions. + +
+

#1: Unique list of songs that appear on at least 1 playlist

+```ruby +Song + .joins(:playlists) + .distinct +``` +

This query works because of the association on `Song` to `playlists, through: :playlist_songs`. Without this association, the query would look like:

+```ruby +Song + .joins(playlist_songs: :playlist) + .distinct +``` +

Note the multiple joins of `playlist_songs: :playlist` where `playlist` is singular on the right-hand side; this is because within the `PlaylistSong` model, we have one association of `belongs_to :playlist`.

+
+ +
+

#2: Names of playlists that have at least 3 distinct artists

+```ruby +Playlist + .joins(songs: :artist) + .select("DISTINCT artists.*, playlists.name") + .group("artists.id, playlists.name") + .having("COUNT(songs.artist_id) >= 3") + .pluck("playlists.name") +``` +

There are probably other ways to do this query! Remember that AR will order your clauses in the appropriate order for SQL, other than when you're using grouping and aggregating and want to return objetcts instead of hashes.

+
+ +
+

#3: Names of artists that appear on at least 3 different playlists

+ +

This query becomes easier to visualize when you have more data.

+```ruby +Artist + .joins(songs: :playlists) + .having("COUNT(playlists.id) >= 3") + .group(:id) + .pluck("artists.name") +``` +
## Checks for Understanding + +You can also answer these questions using [this form](https://forms.gle/PvtCtLcVx7CF2mCWA). + 1. When would we want to use multiple joins in a query? 2. What is one hazard of potential over-joining? 3. In your own words, describe the process for creating a multiple-join query. diff --git a/module2/lessons/many_to_many.md b/module2/lessons/many_to_many.md index ebe3ff5c..f39fec83 100644 --- a/module2/lessons/many_to_many.md +++ b/module2/lessons/many_to_many.md @@ -64,6 +64,12 @@ Think about the relationship between students and modules (i.e. "Mod 1: Object O Diagram what the database would look like. +
+

Activity: Diagramming students to modules

+Diagramming students to modules +

In this example, Modules are the "one" / "parent", and students would be the "many" / "children", since many students can be in only one module at a time.

+
+ # Many-to-Many Relationships Now, we're going to add playlists to our app. @@ -147,6 +153,12 @@ When you're thinking about what to call this table, think about how you're likel Diagram the DB tables you would need to create a many-to-many relationship between two tables that you think up on your own. Include some example data in your tables. If you can't come up with an example on your own, use Photographs and Albums. +
+

Activity: Diagramming a many-to-many example (albums to photos)

+Diagramming albums to photos in a many-to-many relationship +

In this example, Albums and Photos are joined by the PhotoAlbums join table.

+
+ # Many-to-Many Relationships in Rails ## Adding Playlists @@ -549,6 +561,8 @@ We should now have a passing test. Check your work in development by adding some ## Checks for Understanding +You can also answer these questions using [this form](https://forms.gle/odXSt3MqgVqq1R9RA). + - How is a one-to-many relationship set up in a database? - What does a join table do? Why would we need one? - How do we test many-to-many relationships? diff --git a/module2/lessons/mvc_in_action.md b/module2/lessons/mvc_in_action.md index 6c991f3f..9f0be67a 100644 --- a/module2/lessons/mvc_in_action.md +++ b/module2/lessons/mvc_in_action.md @@ -80,5 +80,7 @@ For additional guidance, consider the following rules: - No query logic in your Controllers or Views; this should live in your Models. - No data formatting in your Models or Controllers; this should live in your Views. -### Further Learning -A completed version of this lesson can be found [here](https://github.com/turingschool-examples/mvc-in-action-7/tree/refactor). \ No newline at end of file +### Further Learning and Review +A completed version of this lesson can be found [here](https://github.com/turingschool-examples/mvc-in-action-7/tree/refactor). + +You can review the basics of MVC while completing this exercise using [this lesson](https://backend.turing.edu/module2/lessons/intro_to_mvc). \ No newline at end of file