Path resolution​

Element-wise operations with multiple arguments in EdgeDB are generally applied to the cartesian product of all the input sets.

db> 

select {'aaa', 'bbb'} ++ {'ccc', 'ddd'};

{'aaaccc', 'aaaddd', 'bbbccc', 'bbbddd'}

In some cases, this works out fine, but in others it doesn’t make sense. Take this example:

select User.first_name ++ ' ' ++ User.last_name;

Should the result of this query be every first_name in your User objects concatenated with every last_name? That’s probably not what you want.

This is why, in cases where multiple element-wise arguments share a common path (User. in this example), EdgeDB factors out the common path rather than using cartesian multiplication.

db> 

select User.first_name ++ ' ' ++ User.last_name;

{'Mina Murray', 'Jonathan Harker', 'Lucy Westenra', 'John Seward'}

We assume this is what you want, but if your goal is to get the cartesian product, you can accomplish it one of three ways. You could use detached.

edgedb> 

select User.first_name ++ ' ' ++ detached User.last_name;

{
  'Mina Murray',
  'Mina Harker',
  'Mina Westenra',
  'Mina Seward',
  'Jonathan Murray',
  'Jonathan Harker',
  'Jonathan Westenra',
  'Jonathan Seward',
  'Lucy Murray',
  'Lucy Harker',
  'Lucy Westenra',
  'Lucy Seward',
  'John Murray',
  'John Harker',
  'John Westenra',
  'John Seward',
}

You could use with to attach a different symbol to your set of User objects.

edgedb> 
....... 

with U := User
select U.first_name ++ ' ' ++ User.last_name;

{
  'Mina Murray',
  'Mina Harker',
  'Mina Westenra',
  'Mina Seward',
  'Jonathan Murray',
  'Jonathan Harker',
  'Jonathan Westenra',
  'Jonathan Seward',
  'Lucy Murray',
  'Lucy Harker',
  'Lucy Westenra',
  'Lucy Seward',
  'John Murray',
  'John Harker',
  'John Westenra',
  'John Seward',
}

Or you could leverage the effect scopes have on path resolution. More on that in the Scopes section.

The reason with works here even though the alias U refers to the exact same set is that we only assume you want the path factored in this way when you use the same symbol to refer to a set. This means operations with User.first_name and User.last_name do get the common path factored while U.first_name and User.last_name do not and are resolved with cartesian multiplication.

That may leave you still wondering why U and User did not get a common path factored. U is just an alias of select User and User is the same symbol that we use in our name query. That’s true, but EdgeDB doesn’t factor in this case because of the queries’ scopes.

edgedb> 

select ((select User.first_name), (select User.last_name));

{
  ('Mina', 'Murray'),
  ('Mina', 'Harker'),
  ('Mina', 'Westenra'),
  ('Mina', 'Seward'),
  ('Jonathan', 'Murray'),
  ('Jonathan', 'Harker'),
  ('Jonathan', 'Westenra'),
  ('Jonathan', 'Seward'),
  ('Lucy', 'Murray'),
  ('Lucy', 'Harker'),
  ('Lucy', 'Westenra'),
  ('Lucy', 'Seward'),
  ('John', 'Murray'),
  ('John', 'Harker'),
  ('John', 'Westenra'),
  ('John', 'Seward'),
}

edgedb> 
....... 
....... 

select User {
name:= (select User.first_name) ++ ' ' ++ (select User.last_name)
};

{
  default::User {name: 'Mina Murray'},
  default::User {name: 'Jonathan Harker'},
  default::User {name: 'Lucy Westenra'},
  default::User {name: 'John Seward'},
}

edgedb> 

select (Person.name, count(Person.friends));

{('Fran', 3), ('Bam', 2), ('Emma', 3), ('Geoff', 1), ('Tyra', 1)}

edgedb> 

select (array_agg(distinct Person.name), count(Person.friends));

{(['Fran', 'Bam', 'Emma', 'Geoff'], 3)}