Polars 2.0: por que as junções já não mantêm a ordem das linhas
O Polars 2.0 executa a coleta num motor de streaming por padrão.
O Polars 2.0 executa a coleta num motor de streaming por padrão. Para junção, group_by e unpivot, a versão já não garante a ordem das linhas de entrada, a menos que se defina explicitamente maintain_order ou sort. Na nossa execução no polars 2.0.0, uma junção interna de 2.000.000 linhas devolveu as linhas fora da ordem de entrada por padrão e manteve a ordem com maintain_order definido. A versão também ativa o out-of-core spilling e faz com que as reivindicações de benchmark sejam as do próprio fornecedor.
Ler a edição escrita (Inglês) ↗
O que este vídeo aborda
- Chamar collect() numa consulta lazy agora usa o motor de streaming por padrão, o que não garante a ordem das linhas para join, group_by e unpivot.
- O guia de migração diz que a ordem já não é a ordem pré-2.0 e não é garantida; recomenda uma ordenação explícita se depender dela.
- Na nossa execução, uma junção interna padrão devolveu a ordem de entrada Falso; maintain_order="left_right" na junção devolveu Verdadeiro. Uma máquina, uma execução, uma forma de junção.
- O out-of-core spilling está ativado por padrão: começa em cerca de 80 % da RAM, com um orçamento de disco padrão de 64 GB. Junções e group_by out-of-core estão no roteiro.
- collect_schema() deteta uma coluna em falta antes que quaisquer dados sejam lidos, mas uma conversão que falha num único valor só falha em collect().
- A comparação TPC-H e TPC-DS é a própria execução do fornecedor em dados derivados, e a sua nota de rodapé diz que os resultados não são comparáveis a benchmarks oficiais.
Perguntas e respostas
Porque é que as junções do Polars 2.0 deixaram de manter as linhas na ordem de entrada?
A chamada de 'collect' numa consulta preguiçosa usa agora o motor de streaming por predefinição. O streaming divide a consulta em blocos que correm em paralelo, e os blocos terminam quando terminam. Para 'join', 'group_by' e 'unpivot', a versão não promete, portanto, uma ordem de linhas de saída. Os testes que comparam a saída com um ficheiro guardado linha a linha são os primeiros a serem afetados.
Como posso obter a ordem antiga das linhas depois de atualizar para o Polars 2.0?
Adicione uma ordenação explícita após a junção, que é o que o guia de migração recomenda, ou defina o argumento 'maintain_order' na junção. Na execução do episódio no Polars 2.0.0, uma junção interna padrão devolveu linhas fora da ordem de entrada, enquanto 'maintain_order' definido como 'left_right' manteve a ordem. Isso foi uma máquina, uma execução e uma forma de junção.
O Polars 2.0 consegue processar dados maiores do que a memória?
Parcialmente. O 'spilling' fora do núcleo está ativado por predefinição, começando em cerca de 80% da RAM com um orçamento de disco padrão de 64 GB. 'Sort', funções de janela e muitas expressões podem agora fazer 'spill'. As junções e 'group-bys' fora do núcleo estão no roteiro, pelo que essas operações ainda não fazem 'spill'.
Posso confiar nas comparações de desempenho do Polars 2.0 com o DuckDB e o DataFusion?
Trate-as como as próprias afirmações do fornecedor. O Polars afirma que vence o DataFusion e o DuckDB em TPC-H e TPC-DS, mas os números vêm das suas próprias execuções em dados derivados, e a sua nota de rodapé diz que os resultados não são comparáveis a benchmarks oficiais. O Polars também afirma que os threads extra da máquina grande abrandam as consultas pequenas.
É seguro atualizar os pipelines Polars existentes para a versão 2.0?
O veredito do The Daily Diff foi NEEDS REVIEW. O episódio revisaria cada junção antes de atualizar, porque qualquer junção sem uma ordenação depois dela é uma decisão de ordem de linha nunca tomada. A tipagem mais rigorosa ajuda um pouco, já que a verificação do esquema deteta uma coluna em falta antes de os dados serem lidos, mas uma conversão que falha numa única linha só falha no 'collect'.
Transcrição traduzida
Traduzido da narração original em inglês. Áudio e legendas disponíveis são controlados pelo YouTube.
Por que a ordem padrão mudou?
0:00 Você acha que uma junção devolve suas linhas na ordem em que as escreveu. O Polars 2.0 parou de prometer isso, por padrão, de propósito. Neste vídeo: por que a mudança padrão? O que isso trouxe? E qual dos seus scripts quebra primeiro? Este é o The Daily Diff, nos bastidores. Polars é uma biblioteca DataFrame de código aberto: um motor de tabela que você chama do Python,
0:20 com seu núcleo escrito em Rust. É gratuito sob a licença MIT, e você o instala com pip install polars. Um detalhe primeiro. O interruptor que traz a ordem antiga de volta é um argumento para a própria junção. Voltarei a ele no final. Desde a versão 2.0, collect executa o motor de streaming por padrão. Streaming divide a consulta em blocos que são executados em paralelo, e os blocos terminam quando terminam.
0:42 Para join, group by e unpivot, a versão não promete uma ordem. Quem é atingido primeiro? Quem compara a saída com um arquivo salvo, linha por linha. Esse teste pode passar no seu laptop e falhar em uma máquina diferente. A seguir, o guia de migração.
O que o guia de migração promete?
0:57 Ele diz que a ordem exata das linhas mostrada acima não é garantida. Portanto, se você depende da ordem, ordene explicitamente. O out-of-core também está ativado por padrão. Ele começa a despejar para o disco em cerca de oitenta por cento da RAM, com um orçamento de sessenta e quatro gigabytes. Sort, funções de janela e muitas expressões podem despejar agora. Joins e group-bys estão a caminho.
O benchmark é uma luta justa?
1:17 Polars diz que supera DataFusion e DuckDB nos benchmarks TPC-H e TPC-DS. Os números vêm de suas próprias execuções, em dados derivados, e sua nota de rodapé diz que não são comparáveis a resultados oficiais. Seus próprios números dizem que Polars fica cerca de três ponto oito vezes mais rápido de dezasseis núcleos para cento e noventa e dois, no TPC-H. Eles também dizem que os threads extras da máquina grande atrasam as pequenas consultas.
O que vemos quando o executamos?
1:41 Executamos a mesma junção duas vezes no Polars 2.0.0. A execução padrão embaralha as linhas. Com a bandeira, a ordem de entrada sobrevive. Encontre as junções que alimentam um teste. Qualquer junção sem uma ordenação posterior é uma decisão de ordem de linha que você nunca tomou. Polars 2.0 é mais rigoroso com os tipos.
Mais rigoroso significa mais cedo?
1:58 A verificação de esquema deteta uma coluna ausente antes que qualquer dado seja lido. Não pode detetar uma conversão que falha numa linha, porque esse erro aguarda os dados. Agora o ciclo que abri.
Como faço para ter a ordem antiga de volta?
2:08 O interruptor vive na junção. Defina maintain_order na junção, ou adicione uma ordenação depois dela. O guia sugere a ordenação. A bandeira de junção manteve a ordem na nossa execução, com a ordem do lado esquerdo mantida como esquerda, direita. Veredito, nos bastidores: NEEDS REVIEW.
Qual é o veredicto?
2:22 Eu revisaria cada junção antes de atualizar. Tem alguma pergunta sobre isso? Coloque-a nos comentários. E essa é a diferença de hoje. Eu sou o Niko da Axrisi. Faça o merge com responsabilidade.
Fontes
- Release of Polars 2.0Polars (pola.rs)
- Polars 2.0 upgrade guidePolars documentation
- Polars homepagePolars (pola.rs)
- polars-2.0-benchmark repositoryPolars on GitHub
- Release of Polars 2.0 (Hacker News discussion)Hacker News



