Beginning with EdgeDB 6.0, we are phasing out our historical (and somewhat notorious) “path scoping” algorithm in favor of a much simpler algorithm that nevertheless behaves identically on most idiomatic EdgeQL queries.

EdgeDB 6.0 will contain features to support migration to and testing of the new semantics. We expect the migration to be relatively painless for most users.

Discussion of rationale for this change is available in the RFC.

This section describes the path scoping algorithm used exclusively until EdgeDB 5.0 and by default in EdgeDB 6.0. It will be removed in EdgeDB 7.0.

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'}

However, 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)}