How would you use the aliases? In SQL you wouldn't be able to do:

select u.Name as UserName from Users u where UserName like 'a%' -- it will complain that it doesn't know the column UserName

So you can't use the alias anyway. (I prefer option 2)

I like the second option better. As mentioned, in SQL you would not be able to use aliases in the same query (in the where/order by/group by/etc clauses) either. In nested queries it should not make a difference.

Why isn't putting the 'select' between 'from' and 'where' an option? I would argue that LINQ does this, not just for Intellisense purposes, but because it's the actual order one generally thinks of things. One generally picks tables before one pick fields from said tables... one generally pick fields before constraining a field. More abstractly: one references something before introducing restrictions (i.e. projections/constraints).

pick -> picks

I'm curious. Are you still supporting lucene style queries or is it only SQL style now?

Also, I like the 2nd option better so that you can provide good intellisense support.

Another option is to put the select in between the from and where

from Users u
select u.Name as UserName, u.Address.City as City
where UserName = :user

That allows you get the intelli-sense that you need while allowing aliases to still be used in the where clause.

I'd suggest taking a leaf from prior art ...

from Users u
where u.Email = :email
let UserName = u.Name, City = u.Address.City
select UserName, City

I like the second option better, and also what several people suggested - to put the select in between the from and where. But -- why not just allow all options? It shouldn't matter to the parser, and each user can use his preferred style.

Why not support both schemes?

Users only benefit from intellisense if they use your tooling. If statements are prepared elsewhere, traditional syntax is probably prefered.

In your tools users of option 2 will have a better experience.

BTW. I prefer option 2.

This is what it would look like in Azure Log Analytics (v.next) / Application Insights Analytics:

Users
| where Email == :email // Or something, depending on what ':email' means in RavenDB
| project UserName=Name, City=Address.City

I think putting the select between the from and where makes no sense - it doesn't work like than in either SQL or LINQ. In SQL the select clause is evaluated after where but before group by, that's where the aliases can be used (and in having, which comes after group by). Why not do the same? If the query language won't support group by, then leave select at the end.

I used arangodb for a project and I really liked how they designed the aql even is totally javascript driven I found it really natural.....

There is also this driver http://www.arangoclient.net/ that it's great to "linq" arangodb

So I prefer the second one with the select at the bottom :)

Why not just use Linq syntax allowing users to have just one single query language?

When I used to write simple SELECT statement I always started by just typing the SELECT keyword and I then jump directly to the FROM clause where I sometimes elaborate a JOIN.

Here is what used to do in a pseudo algorithm:

• Type SELECT
• Elaborate the FROM clause where I reason about eventual JOINS, UNIONS...
• Elaborate the SELECT statement where I reason about what columns I want in the result