self-join

So, I'm working on an app where I want to users to be able to group objects in "folders". Basically: User has_many :foos Foos don't have to be in a folder, but they can be. In that case: Folder has_many :foos and Foo belongs_to :folder Now, I'd like to be able to set up folders so they can be nested. I think this is something like... Folder has_many :folders I have heard that this kind of self-referential relationship is no big deal, but I don't really get how it works. I haven't been able to figure out how this is supposed to be declared in the model and what columns I need to provide in the

I have a User that can have collection of users he likes... Another user can have collection of users he likes.... If User A likes User B and if User B likes User A, then they get to hang out. I need to send each other their contact info. How do we represent such a model in Entity Framework Code First? public class User { public int UserId { get; set; } public int? UserLikeId { get; set; } public virtual UserLike UserLike { get; set; } } public class UserLike { public int UserLikeId { get; set; } public int UserId { get; set; } public virtual User User { get; set; } public virtual ICollection

I'm attempting to collect details about backup activity from a ProgreSQL DB table on a backup appliance (Avamar). The table has several columns including: client_name, dataset, plugin_name, type, completed_ts, status_code, bytes_modified and more. Simplified example: | session_id | client_name | dataset | plugin_name | type | completed_ts | status_code | bytes_modified | |------------|-------------|---------|---------------------|------------------|----------------------|-------------|----------------| | 1 | server01 | Windows | Windows File System | Scheduled Backup | 2017-12-05T01:00:00Z |

I have the following table: myTable: +----+----------+ | id | parentID | +----+----------+ | 1 | null | | 2 | 1 | | 3 | 1 | | 4 | 2 | | 5 | 4 | ----------------- i would like to get all rows tracing back until there's no parentID anymore. So ".... WHERE id=5" would give me: 5, 4, 2, 1 You are organizing your hierarchical data using the adjacency list model . The fact that such recursive operations are difficult is in fact one major drawback of this model. Some DBMSes, such as SQL Server 2005, Postgres 8.4 and Oracle 11g, support recursive queries using common table expressions with the WITH

Given the following tables: Student +----+-------+ | id | Name | +----+-------+ | 1 | Chris | | 2 | Joe | | 3 | Jack | +----+-------+ Enrollment +---------------+------------+-----------+----------+ | enrollment_id | student_id | course_id | complete | +---------------+------------+-----------+----------+ | 1 | 1 | 55 | true | | 2 | 1 | 66 | true | | 3 | 1 | 77 | true | | 4 | 2 | 55 | true | | 5 | 2 | 66 | false | | 6 | 3 | 55 | false | | 7 | 3 | 66 | true | +---------------+------------+-----------+----------+ I would like the following +----+-------+-----------+-----------+-----------+ | id

If I have a table that I'd like to cross join to itself, how can I remove the duplicate rows? Or to put it another way, how can I do a "order doesn't matter" cross join? So for example, if I have a table T: field | ------- A | B | C | and I cross join to itself so that i don't get the A | A rows T as t1 cross join T as t2 on t1.field != t2.field I would get the following: field | field ------+------- A | B A | C B | A B | C C | A C | B However, to me A, B is the same as B, A. Is there a good way to remove these duplicates? In other words, I want the combinations not the permutations. T as t1

I would like to create a structure of Users having many friends , also of class User : class User < ActiveRecord::Base has_and_belongs_to_many :friends, class_name: "User" end I do not need any details of their relationship thus I do not use :through with kind of class Friendship . But now I cannot find any way how to create corresponding database (neither with migration file nor using rails g model User username:string ... command). Any ideas? Paul Richter Here are some resources which may be helpful: RailsCasts episode #163 Self-Referential Association regarding self-referential many-to-many