#one-to-many

[justicemath]

Types of relations

Types of Relations in math

There are many types of relations in maths. Understanding relations in math will help you appreciate many other math topics as well as programming. Let’s talk about 4 main types of relations. These are many-to-many relation, one-to-many relation, many-to-one relation, and one-to-one relation. We will address them one by one with examples.

 Types of relations:…

View On WordPress

[php-mysql-tutorial]

Tables relationships

There are 3 types of table relationships: 1. One-to-one relationships 2. One-to-many relationships 3. Many-to-many relationships

More info on table relationships.

In a one-to-one relationship, each row in one database table is linked to one and only one other row in another table. In a one-to-one relationship between Table A and Table B, each row in Table A is linked to another row in Table B. The number of rows in Table A must equal the number of rows in Table B.  For example, if we have two related tables: one for students' bio data and another for students' emergency contact.  These two tables are linked by student's ID.  There is only one row of data for each student in both tables.

In a one-to-many relationship, each row in the related to table can be related to many rows in the relating table.  For example, one table for every Singapore addresses and another for every citizen information. Assuming everyone has only one official address, for every address, there may be one or more citizen staying there.

In a many-to-many relationship, one or more rows in a table can be related to 0, 1 or many rows in another table.  For example, one table for teachers teaching info and another for class info.  Every teachers may teach one or more classes while every class may have one or more teachers.

Example of using diagrams to illustrate the above three types of relationship.

[ Content Page ]

[rollingonrails-blog]

Relationship Types

Allows us to work with the data between our models and tables in an object oriented way.

Relational Database Association:

One-to-One (not used often)

has\_one/belongs\_to

Note to remove the association you can assign nil to it

And to remove the associated record from the database .destroy

One-to-Many (used most often)

has\_many/belongs\_to

belong\_to is where the foreign key goes

Defined Operations:

subject.pages << page #append operator, since pages is a collection of objects

subject.pages = [page, page, page] #you can use equal operator, but you need to provide an array of values

subject.pages.delete(page) #removes the relationship, but does not delete the associated record

subject.pages.destroy(page) #removes the relationship and deletes the associated record

subject.pages.clear #removes the relationships, but not the records

subject.pages.empty?

subject.pages.size

Many-to-Many

has\_many and belongs\_to/has\_many and belongs\_to = has\_and\_belongs\_to\_many

utilizes a joined table (WITH NO ID: , :id => false in it's migration)

Join Table Naming Convention

both table names

alphabetical order

E.g.: BlogPost - Category => BlogPost_Category

Many-to-Many (Rich Joins)

has a Joined table with extra rows

requires ID

Use a descriptive name (no following many-to-many Rails conventions)

require a model (rail generate model [YourModelName])

requires an id for the model

remember to add foreign keys to tables that you want to join

add an index on the combined foreign keys

has\_many/has\_many = belong\_to + belongs\_to

has\_many on the tables to be joined

belongs\_to + belongs\_to on the connecting table (remember, belong\_to goes where the foreign key is)

Note: you can have a different name for the relationship field in your model file, if you specify the way to find the original, E.g.: belongs_to: editor :class_name => "AdminUser", :foreign_key => "admin_user_id". Belongs_to requires a :foreign_key to be specified as well as :class_name.

Note: use .reload on the ActiveRelation object to update it from the db.

Traversing A Rich Join

Allows "reaching across" a rich join, treating it like an HABTM join

E.g.

AdminUser has_many :sections, :through => :section_edits

Section has_many :admin_users, :through => :section_edits

_**Note: ** All the differences between Simple Many-to-Many and Rich Many-to-Many is that the later has a fully functional MODEL._