Hacktoberfest 2026: as issues que os mantenedores marcaram para outubro, abertas e boas para iniciantes. Ver issues do Hacktoberfest

Composed query with groupBy clause in subquery fails

Aberta
  • Algo errado?
#746 0 comentários 0 reações 0 responsáveis Ver no GitHub

Ninguém assumiu esta issue ainda.

Avaliação

Dificuldade
3/5
Tempo estimado
1-2 dias
Facilidade para iniciantes
45/100
Tipo de issue
Bug
Clareza
Claramente especificada
Status de atividade
Estagnada
Stack de tecnologia
fsharp, sql
Domínio
databases

Direção de pesquisa

Comece rastreando a tradução, pelo SQLProvider, de consultas F# compostas com uma cláusula groupBy e inspecione a subconsulta gerada para a reprodução. A tarefa estará concluída quando a subconsulta IN selecionar apenas a coluna agregada solicitada, enquanto a seleção explícita da chave de agrupamento continuar incluindo-a; adicione ou execute um teste de regressão que cubra ambos os casos.

Escrita pelo modelo de indexação a partir do texto da issue.

Descrição

Describe the bug
SqlException "Only one expression can be specified in the select list when the subquery is not introduced with EXISTS." returned when using a composed query when the subquery has a groupBy clause. This is because SQLProvider includes the groupBy key in the select clause even if you haven't asked for it.

To Reproduce
Steps to reproduce the behavior:

  1. Take a query that uses a subquery with a groupBy clause, e.g.:
let test =
    let lastAddresses =
        query {
            for a in dbContext.Address do
            where (a.Deleted.IsNone)
            groupBy a.UserId into g
            select (g.Max(fun a -> a.Id))
        }
    let result =
        query {
            for a in dbContext.Address do
            where (lastAddresses.Contains(a.Id))
            select a
        }
    result
  1. Run the query, and you get the SqlException described above.
  2. Inspecting the SQL produced, you can see the problem:
SELECT *
FROM [address] as [a] 
WHERE (([a].[Id] IN (
	SELECT [a].[UserId] as '[a].[UserId]', MAX([a].[Id]) as '[a].[MAX_Id]'
	FROM [address] as [a]
	WHERE (([a].[Deleted] IS NOT NULL))
	GROUP BY [a].[UserId]))
)
  1. Basically SQLProvider is including [a].[UserId] as '[a].[UserId]' in the select clause of the subquery. The IN clause is only expecting a single column in the subquery so fails.

Expected behavior

SQLProvider should only return the columns requested in the query. The SQL produced should be:

SELECT *
FROM [address] as [a] 
WHERE (([a].[Id] IN (
	SELECT MAX([a].[Id]) as '[a].[MAX_Id]'
	FROM [address] as [a]
	WHERE (([a].[Deleted] IS NOT NULL))
	GROUP BY [a].[UserId]))
)

Additional context
If we wanted the groupBy key included in the select statement, we could do so by requesting it explicitly, so there is no reason why SQLProvider should do this for us unsolicitedly:

let test =
    let lastAddresses =
        query {
            for a in dbContext.Address do
            where (a.Deleted.IsNone)
            groupBy a.UserId into g
            select (g.Key, g.Max(fun a -> a.Id))
        }
    let result =
        query {
            for a in dbContext.Address do
            where (lastAddresses.Contains(a.Id))
            select a
        }
    result
Linguagem predominante
F#
Estrelas
627
Forks
148
Merge médio
2h 2min
PRs com merge (30d)
1

Preparar o ambiente

Abrir no Codespaces

Inicia o contêiner de desenvolvimento do projeto no navegador, com a sua própria conta do GitHub.

  • Sem Dockerfile nem arquivo Docker Compose
  • Tem um modelo de pull request
  • Sem guia de contribuição

Primeiros passos

  1. Leia a issue inteira e depois o guia de contribuição do projeto.
  2. Comente na issue dizendo que vai assumir — evita que duas pessoas façam o mesmo trabalho.
  3. Faça um fork do repositório e trabalhe em uma branch.
  4. Abra um pull request que referencie o número da issue.

Mais de fsprojects/SQLProvider

Todas as issues de fsprojects/SQLProvider

Issues semelhantes

Mais issues de Databases

Receba novas issues na sua caixa de entrada

Um resumo curto de issues do GitHub para quem está começando.