{"id":538,"date":"2024-12-27T12:01:39","date_gmt":"2024-12-27T12:01:39","guid":{"rendered":"https:\/\/datadandies.nl\/?p=538"},"modified":"2025-01-11T06:53:46","modified_gmt":"2025-01-11T06:53:46","slug":"why-many-to-many-relationships-are-evil","status":"publish","type":"post","link":"https:\/\/datadandies.nl\/index.php\/2024\/12\/27\/why-many-to-many-relationships-are-evil\/","title":{"rendered":"Why many-to-many relationships are evil – Junction tables \/ Bridge tables"},"content":{"rendered":"\n

Why does Power BI hate many-to-many relationships? <\/p>\n\n\n\n

Despite the title (that did its job in getting your attention) many-to-many relationships *-* are not necessarily evil. However, modeling your data in a manner that avoids many-to-many relationships helps in a lot of scenarios with data consistency, among other things.<\/p>\n\n\n\n

Let’s dive into this using the ancient author-book example. <\/p>\n\n\n\n

I have added the T-SQL scripts so you can follow along if you want. Strap on folks, it will be a long and a bumpy ride. <\/p>\n\n\n\n

Let’s start with creating a table for the authors, inserting two authors and check the table out. <\/p>\n\n\n\n

<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
--Data modeling example about handling many-to-many relationships with a junction table. <\/span><\/span>\n--Creating table for authors of books.<\/span><\/span>\nCREATE<\/span> <\/span>TABLE<\/span> <\/span>TEST<\/span>.DataModeling.Authors <\/span><\/span>\n\t(<\/span><\/span>\n\t\tAuthorName <\/span>VARCHAR<\/span>(<\/span>400<\/span>) <\/span>PRIMARY KEY<\/span>,<\/span><\/span>\n\t\tNationality <\/span>VARCHAR<\/span>(<\/span>400<\/span>)<\/span><\/span>\n\t)<\/span><\/span>\n\t<\/span><\/span>\n\t<\/span>--Inserting 2 authors into the Authors table.<\/span><\/span>\nINSERT INTO<\/span> TEST.DataModeling.Authors <\/span>VALUES<\/span> <\/span><\/span>\n\t(<\/span>'David'<\/span>, <\/span>'NL'<\/span>), (<\/span>'Harry'<\/span>, <\/span>'EN'<\/span>)<\/span><\/span>\n\t<\/span><\/span>\n--Checking out the table.<\/span><\/span>\nSELECT<\/span> * <\/span>FROM<\/span> TEST.DataModeling.Authors<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
\"\"<\/figure>\n\n\n\n
 Now let’s create the table for books, insert three books and check the table out. <\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
--Creating table for books.<\/span><\/span>\nCREATE<\/span> <\/span>TABLE<\/span> <\/span>TEST<\/span>.DataModeling.Books <\/span><\/span>\n\t(<\/span><\/span>\n\t\tBookTitle <\/span>VARCHAR<\/span>(<\/span>400<\/span>) <\/span>PRIMARY KEY<\/span>,\t<\/span><\/span>\n\t\tPages <\/span>INT<\/span>,<\/span><\/span>\n\t\tAuthorName <\/span>VARCHAR<\/span>(<\/span>400<\/span>)<\/span><\/span>\n\t)<\/span><\/span>\n\t<\/span><\/span>\n\t<\/span>--Inserting 3 books into the Books table.<\/span><\/span>\nINSERT INTO<\/span> TEST.DataModeling.Books <\/span>VALUES<\/span> <\/span><\/span>\n\t(<\/span>'David book 1'<\/span>, <\/span>10<\/span>, <\/span>'David'<\/span>), (<\/span>'David book 2'<\/span>, <\/span>20<\/span>, <\/span>'David'<\/span>), (<\/span>'Harry book'<\/span>, <\/span>30<\/span>, <\/span>'Harry'<\/span>)<\/span><\/span>\n<\/span>\n--Checking out the table.<\/span><\/span>\nSELECT<\/span> * <\/span>FROM<\/span> TEST.DataModeling.Books<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Looking good so far. However, what if we have a book with two authors? <\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
--So far so good. However, what if authors David and Harry are BOTH author of a book? Now things will get tricky.<\/span><\/span>\nINSERT INTO<\/span> TEST.DataModeling.Books <\/span>VALUES<\/span> <\/span><\/span>\n\t(<\/span>'David & Harry book'<\/span>, <\/span>40<\/span>, <\/span>'David & Harry'<\/span>)<\/span><\/span>\n\t<\/span><\/span>\n--Checking out the table: we have a problem. Value "David & Harry" in column "AuthorName" from table "Books" does not exist in table "Authors".<\/span><\/span>\n--Inserting value "David & Harry" in table "Authors" would introduce a host of problems: do we add extra columns for Nationality since David and Harry have different nationalities? Not really a scalable solution.<\/span><\/span>\n--Now imagine you have a third book that is written by good ol' Harry and a new author. Do we add two rows in the "Authors" table? One for the new author and one for the combination of Harry and the new author?<\/span><\/span>\n--How do we use these tables to answer questions from the business like: how many authors are there? A simple COUNT(*) of the "Authors" table returns wrong results. <\/span><\/span>\n--COUNT(DISTINCT AuthorName) returns wrong results as well! Also queries to identify the contribution of individual authors become complex without manual parsing. <\/span><\/span>\nSELECT<\/span> * <\/span>FROM<\/span> TEST.DataModeling.Books<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
\"\"<\/figure>\n\n\n\n
As described in the comments in the block of code above, we have a problem. Things got a whole lot more complicated. We can however solve this and create a more flexible data model by creating a junction table (also called a bridge table). In this case, a junction table is a combination of all existing combinations between books and authors. Let’s try and make this happen. <\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
--Starting with a clean slate, let's empty the "Books" table. <\/span><\/span>\nTRUNCATE<\/span> <\/span>TABLE<\/span> TEST.DataModeling.Books<\/span><\/span>\n<\/span>\n--The next step is to remove the "AuthorName" column from the "Books" table. We now have an empty "Books" table with only the columns "BookTitle" and "Pages".<\/span><\/span>\nALTER<\/span> <\/span>TABLE<\/span> TEST.DataModeling.Books <\/span>DROP<\/span> COLUMN AuthorName<\/span><\/span>\n<\/span>\n--Authors table remains the same.<\/span><\/span>\n<\/span>\n--Insert the existing books into the "Books" table.<\/span><\/span>\nINSERT INTO<\/span> TEST.DataModeling.Books (BookTitle, Pages) <\/span>VALUES<\/span> <\/span><\/span>\n\t(<\/span>'David book 1'<\/span>, <\/span>10<\/span>),<\/span><\/span>\n\t(<\/span>'David book 2'<\/span>, <\/span>20<\/span>),<\/span><\/span>\n\t(<\/span>'Harry book'<\/span>, <\/span>30<\/span>),<\/span><\/span>\n\t(<\/span>'David & Harry book'<\/span>, <\/span>40<\/span>)<\/span><\/span>\n<\/span>\n--Checking out the new "Books" table.<\/span><\/span>\nSELECT<\/span> * <\/span>FROM<\/span> TEST.DataModeling.Books<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
\"\"<\/figure>\n\n\n\n
As you can see above, in order for us to be able to create a junction table, we first need to alter the “Books” table. We truncated the “Books” table and dropped the column “AuthorName”. Let’s also take a peek at what the unchanged “Authors” table looks like. <\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
--Checking out the unchanged "Authors" table.<\/span><\/span>\nSELECT<\/span> * <\/span>FROM<\/span> TEST.DataModeling.Authors<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Looking good. Next step is to create the junction table: the table where the existing combinations of books and authors will live.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
--Now let's create the junction table called "BookAuthors".<\/span><\/span>\nCREATE<\/span> <\/span>TABLE<\/span> <\/span>TEST<\/span>.DataModeling.BookAuthors<\/span><\/span>\n(<\/span><\/span>\n    BookTitle <\/span>VARCHAR<\/span>(<\/span>400<\/span>),<\/span><\/span>\n    AuthorName <\/span>VARCHAR<\/span>(<\/span>400<\/span>),<\/span><\/span>\n    <\/span>CONSTRAINT<\/span> PK_BookAuthors <\/span>PRIMARY KEY<\/span> (BookTitle, AuthorName),<\/span><\/span>\n    <\/span>CONSTRAINT<\/span> FK_BookAuthors_Books <\/span>FOREIGN KEY<\/span> (BookTitle) <\/span>REFERENCES<\/span> TEST.DataModeling.Books(BookTitle),<\/span><\/span>\n    <\/span>CONSTRAINT<\/span> FK_BookAuthors_Authors <\/span>FOREIGN KEY<\/span> (AuthorName) <\/span>REFERENCES<\/span> TEST.DataModeling.Authors(AuthorName)<\/span><\/span>\n)<\/span><\/span>\n<\/span>\n-- Insert the relationships between books and authors into the junction table.<\/span><\/span>\nINSERT INTO<\/span> TEST.DataModeling.BookAuthors (BookTitle, AuthorName) <\/span>VALUES<\/span><\/span>\n\t(<\/span>'David book 1'<\/span>, <\/span>'David'<\/span>),<\/span><\/span>\n\t(<\/span>'David book 2'<\/span>, <\/span>'David'<\/span>),<\/span><\/span>\n\t(<\/span>'Harry book'<\/span>, <\/span>'Harry'<\/span>),<\/span><\/span>\n\t(<\/span>'David & Harry book'<\/span>, <\/span>'David'<\/span>),<\/span><\/span>\n\t(<\/span>'David & Harry book'<\/span>, <\/span>'Harry'<\/span>)<\/span><\/span>\n<\/span>\n--Checking out the junction table "BookAuthors.<\/span><\/span>\nSELECT<\/span> * <\/span>FROM<\/span> TEST.DataModeling.BookAuthors<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
\"\"<\/figure>\n\n\n\n
That is more like it. Now most questions from the business can be answered in an easy manner. For example, would you like to know how many authors there are? <\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
--How many authors are there? A simple COUNT(*) will answer this question.<\/span><\/span>\nSELECT<\/span> <\/span>COUNT<\/span>(*) <\/span>AS<\/span> COUNT_AUTHORS <\/span>FROM<\/span> TEST.DataModeling.Authors<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
\"\"<\/figure>\n\n\n\n
What about how many books there are?<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
--How many books are there? A simple COUNT(*) will answer this question.<\/span><\/span>\nSELECT<\/span> <\/span>COUNT<\/span>(*) <\/span>AS<\/span> COUNT_BOOKS <\/span>FROM<\/span> TEST.DataModeling.Books<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Let’s see how many books were written bij author David. <\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
--Show me all books by a certain author.<\/span><\/span>\nSELECT<\/span> <\/span><\/span>\n\tBookAuthors.AuthorName, <\/span><\/span>\n\tBooks.BookTitle <\/span><\/span>\nFROM<\/span> TEST.DataModeling.BookAuthors<\/span><\/span>\nJOIN<\/span> TEST.DataModeling.Books <\/span>ON<\/span> BookAuthors.BookTitle = Books.BookTitle<\/span><\/span>\nWHERE<\/span> BookAuthors.AuthorName = <\/span>'David'<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Let’s turn it around! Which author(s) wrote the book “David & Harry book”?<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
--Show me all authors that have written a certain book.<\/span><\/span>\nSELECT<\/span> <\/span><\/span>\n\tAuthors.AuthorName, <\/span><\/span>\n\tAuthors.Nationality<\/span><\/span>\nFROM<\/span> TEST.DataModeling.Authors<\/span><\/span>\nJOIN<\/span> TEST.DataModeling.BookAuthors <\/span>ON<\/span> Authors.AuthorName = BookAuthors.AuthorName<\/span><\/span>\nWHERE<\/span> BookAuthors.BookTitle = <\/span>'David & Harry book'<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Pretty nifty, indeed!<\/p>\n\n\n\n
For your convenience, I have gathered all the T-SQL statements from above into a single script which can be found below. <\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
--Data modeling example about handling many-to-many relationships with a junction table. <\/span><\/span>\n<\/span>\n--Drop junction table in order to be able to create the "Authors" and "Books" tables anew (avoiding the error: "cannot drop table because it is references by a FOREIGN KEY constraint")<\/span><\/span>\nDROP<\/span> <\/span>TABLE<\/span> <\/span>IF<\/span> <\/span>EXISTS<\/span> TEST.DataModeling.BookAuthors<\/span><\/span>\n<\/span>\n--Creating table for authors of books.<\/span><\/span>\nDROP<\/span> <\/span>TABLE<\/span> TEST.DataModeling.Authors <\/span><\/span>\n<\/span>\nCREATE<\/span> <\/span>TABLE<\/span> <\/span>TEST<\/span>.DataModeling.Authors <\/span><\/span>\n\t(<\/span><\/span>\n\t\tAuthorName <\/span>VARCHAR<\/span>(<\/span>400<\/span>) <\/span>PRIMARY KEY<\/span>,<\/span><\/span>\n\t\tNationality <\/span>VARCHAR<\/span>(<\/span>400<\/span>)<\/span><\/span>\n\t)<\/span><\/span>\n<\/span>\n--Inserting 2 authors into the Authors table.<\/span><\/span>\nINSERT INTO<\/span> TEST.DataModeling.Authors <\/span>VALUES<\/span> <\/span><\/span>\n\t(<\/span>'David'<\/span>, <\/span>'NL'<\/span>), (<\/span>'Harry'<\/span>, <\/span>'EN'<\/span>)<\/span><\/span>\n<\/span>\n--Checking out the table.<\/span><\/span>\nSELECT<\/span> * <\/span>FROM<\/span> TEST.DataModeling.Authors<\/span><\/span>\n<\/span>\n--Creating table for books.<\/span><\/span>\nDROP<\/span> <\/span>TABLE<\/span> TEST.DataModeling.Books <\/span><\/span>\n<\/span>\nCREATE<\/span> <\/span>TABLE<\/span> <\/span>TEST<\/span>.DataModeling.Books <\/span><\/span>\n\t(<\/span><\/span>\n\t\tBookTitle <\/span>VARCHAR<\/span>(<\/span>400<\/span>) <\/span>PRIMARY KEY<\/span>,\t<\/span><\/span>\n\t\tPages <\/span>INT<\/span>,<\/span><\/span>\n\t\tAuthorName <\/span>VARCHAR<\/span>(<\/span>400<\/span>)<\/span><\/span>\n\t)<\/span><\/span>\n<\/span>\n--Inserting 3 books into the Books table.<\/span><\/span>\nINSERT INTO<\/span> TEST.DataModeling.Books <\/span>VALUES<\/span> <\/span><\/span>\n\t(<\/span>'David book 1'<\/span>, <\/span>10<\/span>, <\/span>'David'<\/span>), (<\/span>'David book 2'<\/span>, <\/span>20<\/span>, <\/span>'David'<\/span>), (<\/span>'Harry book'<\/span>, <\/span>30<\/span>, <\/span>'Harry'<\/span>)<\/span><\/span>\n<\/span>\n--Checking out the table.<\/span><\/span>\nSELECT<\/span> * <\/span>FROM<\/span> TEST.DataModeling.Books<\/span><\/span>\n<\/span>\n--So far so good. However, what if authors David and Harry are BOTH author of a book? Now things will get tricky.<\/span><\/span>\nINSERT INTO<\/span> TEST.DataModeling.Books <\/span>VALUES<\/span> <\/span><\/span>\n\t(<\/span>'David & Harry book'<\/span>, <\/span>40<\/span>, <\/span>'David & Harry'<\/span>)<\/span><\/span>\n<\/span>\n--Checking out the table: we have a problem. Value "David & Harry" in column "AuthorName" from table "Books" does not exist in table "Authors".<\/span><\/span>\n--Inserting value "David & Harry" in table "Authors" would introduce a host of problems: do we add extra columns for Nationality since David and Harry have different nationalities? Not really a scalable solution.<\/span><\/span>\n--Now imagine you have a third book that is written by good ol' Harry and a new author. Do we add two rows in the "Authors" table? One for the new author and one for the combination of Harry and the new author?<\/span><\/span>\n--How do we use these tables to answer questions from the business like: how many authors are there? A simple COUNT(*) of the "Authors" table returns wrong results. <\/span><\/span>\n--COUNT(DISTINCT AuthorName) returns wrong results as well! Also queries to identify the contribution of individual authors become complex without manual parsing. <\/span><\/span>\nSELECT<\/span> * <\/span>FROM<\/span> TEST.DataModeling.Books<\/span><\/span>\n<\/span>\n--An elegant way of solving this, is by creating a junction table.<\/span><\/span>\n<\/span>\n--Starting with a clean slate, let's empty the "Books" table. <\/span><\/span>\nTRUNCATE<\/span> <\/span>TABLE<\/span> TEST.DataModeling.Books<\/span><\/span>\n<\/span>\n--The next step is to remove the "AuthorName" column from the "Books" table. We now have an empty "Books" table with only the columns "BookTitle" and "Pages".<\/span><\/span>\nALTER<\/span> <\/span>TABLE<\/span> TEST.DataModeling.Books <\/span>DROP<\/span> COLUMN AuthorName<\/span><\/span>\n<\/span>\n--Authors table remains the same.<\/span><\/span>\n<\/span>\n--Insert the existing books into the "Books" table.<\/span><\/span>\nINSERT INTO<\/span> TEST.DataModeling.Books (BookTitle, Pages) <\/span>VALUES<\/span> <\/span><\/span>\n\t(<\/span>'David book 1'<\/span>, <\/span>10<\/span>),<\/span><\/span>\n\t(<\/span>'David book 2'<\/span>, <\/span>20<\/span>),<\/span><\/span>\n\t(<\/span>'Harry book'<\/span>, <\/span>30<\/span>),<\/span><\/span>\n\t(<\/span>'David & Harry book'<\/span>, <\/span>40<\/span>)<\/span><\/span>\n<\/span>\n--Checking out the new "Books" table.<\/span><\/span>\nSELECT<\/span> * <\/span>FROM<\/span> TEST.DataModeling.Books<\/span><\/span>\n<\/span>\n--Checking out the unchanged "Authors" table.<\/span><\/span>\nSELECT<\/span> * <\/span>FROM<\/span> TEST.DataModeling.Authors<\/span><\/span>\n<\/span>\n--Now let's create the junction table called "BookAuthors".<\/span><\/span>\nCREATE<\/span> <\/span>TABLE<\/span> <\/span>TEST<\/span>.DataModeling.BookAuthors<\/span><\/span>\n(<\/span><\/span>\n    BookTitle <\/span>VARCHAR<\/span>(<\/span>400<\/span>),<\/span><\/span>\n    AuthorName <\/span>VARCHAR<\/span>(<\/span>400<\/span>),<\/span><\/span>\n    <\/span>CONSTRAINT<\/span> PK_BookAuthors <\/span>PRIMARY KEY<\/span> (BookTitle, AuthorName),<\/span><\/span>\n    <\/span>CONSTRAINT<\/span> FK_BookAuthors_Books <\/span>FOREIGN KEY<\/span> (BookTitle) <\/span>REFERENCES<\/span> TEST.DataModeling.Books(BookTitle),<\/span><\/span>\n    <\/span>CONSTRAINT<\/span> FK_BookAuthors_Authors <\/span>FOREIGN KEY<\/span> (AuthorName) <\/span>REFERENCES<\/span> TEST.DataModeling.Authors(AuthorName)<\/span><\/span>\n)<\/span><\/span>\n<\/span>\n-- Insert the relationships between books and authors into the junction table.<\/span><\/span>\nINSERT INTO<\/span> TEST.DataModeling.BookAuthors (BookTitle, AuthorName) <\/span>VALUES<\/span><\/span>\n\t(<\/span>'David book 1'<\/span>, <\/span>'David'<\/span>),<\/span><\/span>\n\t(<\/span>'David book 2'<\/span>, <\/span>'David'<\/span>),<\/span><\/span>\n\t(<\/span>'Harry book'<\/span>, <\/span>'Harry'<\/span>),<\/span><\/span>\n\t(<\/span>'David & Harry book'<\/span>, <\/span>'David'<\/span>),<\/span><\/span>\n\t(<\/span>'David & Harry book'<\/span>, <\/span>'Harry'<\/span>)<\/span><\/span>\n<\/span>\n--Checking out the junction table "BookAuthors.<\/span><\/span>\nSELECT<\/span> * <\/span>FROM<\/span> TEST.DataModeling.BookAuthors<\/span><\/span>\n<\/span>\n--Now we have a data model that allows for easy answers to most business questions.<\/span><\/span>\n--How many authors are there? A simple COUNT(*) will answer this question.<\/span><\/span>\nSELECT<\/span> <\/span>COUNT<\/span>(*) <\/span>AS<\/span> COUNT_AUTHORS <\/span>FROM<\/span> TEST.DataModeling.Authors<\/span><\/span>\n<\/span>\n--How many books are there? A simple COUNT(*) will answer this question.<\/span><\/span>\nSELECT<\/span> <\/span>COUNT<\/span>(*) <\/span>AS<\/span> COUNT_BOOKS <\/span>FROM<\/span> TEST.DataModeling.Books<\/span><\/span>\n<\/span>\n--Show me all books by a certain author.<\/span><\/span>\nSELECT<\/span> <\/span><\/span>\n\tBookAuthors.AuthorName, <\/span><\/span>\n\tBooks.BookTitle <\/span><\/span>\nFROM<\/span> TEST.DataModeling.BookAuthors<\/span><\/span>\nJOIN<\/span> TEST.DataModeling.Books <\/span>ON<\/span> BookAuthors.BookTitle = Books.BookTitle<\/span><\/span>\nWHERE<\/span> BookAuthors.AuthorName = <\/span>'David'<\/span><\/span>\n<\/span>\n--Show me all authors that have written a certain book.<\/span><\/span>\nSELECT<\/span> <\/span><\/span>\n\tAuthors.AuthorName, <\/span><\/span>\n\tAuthors.Nationality<\/span><\/span>\nFROM<\/span> TEST.DataModeling.Authors<\/span><\/span>\nJOIN<\/span> TEST.DataModeling.BookAuthors <\/span>ON<\/span> Authors.AuthorName = BookAuthors.AuthorName<\/span><\/span>\nWHERE<\/span> BookAuthors.BookTitle = <\/span>'David & Harry book'<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n","protected":false},"excerpt":{"rendered":"
Why does Power BI hate many-to-many relationships? Despite the title (that did its job in getting your attention) many-to-many relationships *-* are not necessarily evil. However, modeling your data in a manner that avoids many-to-many relationships helps in a lot of scenarios with data consistency, among other things. Let’s dive into this using the ancient…<\/p>\n
Read More<\/a><\/p>\n","protected":false},"author":1,"featured_media":554,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[16,3,4],"class_list":["post-538","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-blog","tag-datamodeling","tag-powerbi","tag-sql"],"_links":{"self":[{"href":"https:\/\/datadandies.nl\/index.php\/wp-json\/wp\/v2\/posts\/538","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/datadandies.nl\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/datadandies.nl\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/datadandies.nl\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/datadandies.nl\/index.php\/wp-json\/wp\/v2\/comments?post=538"}],"version-history":[{"count":11,"href":"https:\/\/datadandies.nl\/index.php\/wp-json\/wp\/v2\/posts\/538\/revisions"}],"predecessor-version":[{"id":585,"href":"https:\/\/datadandies.nl\/index.php\/wp-json\/wp\/v2\/posts\/538\/revisions\/585"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/datadandies.nl\/index.php\/wp-json\/wp\/v2\/media\/554"}],"wp:attachment":[{"href":"https:\/\/datadandies.nl\/index.php\/wp-json\/wp\/v2\/media?parent=538"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/datadandies.nl\/index.php\/wp-json\/wp\/v2\/categories?post=538"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/datadandies.nl\/index.php\/wp-json\/wp\/v2\/tags?post=538"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}