+− THE DAILY DIFFdev & AI news
NEEDS REVIEW

Polars 2.0: por que as junções não mantêm mais a ordem das linhas

Polars 2.0 executa collect em um mecanismo de streaming por padrão.

Want to see our stories first on Google? Add us to your preferred sources — it helps us grow.

Polars 2.0 executa collect em um mecanismo de streaming por padrão. Para join, group_by e unpivot, o lançamento não garante mais a ordem das linhas de entrada, a menos que você defina maintain_order ou sort explicitamente. Em nossa execução no polars 2.0.0, uma junção interna de 2.000.000 de linhas retornou as linhas fora da ordem de entrada por padrão e manteve a ordem com maintain_order definido. O lançamento também ativa o "spilling" fora do núcleo e torna as alegações de benchmark do próprio fornecedor.

Leia a edição escrita (Inglês) ↗

O que este vídeo aborda

  • Chamar collect() em uma consulta "lazy" agora usa o mecanismo de streaming por padrão, que não garante a ordem das linhas para join, group_by e unpivot.
  • O guia de migração diz que a ordem não é mais a ordem pré-2.0 e não é garantida; ele recomenda uma classificação explícita se você depender dela.
  • Em nossa execução, uma junção interna padrão retornou ordem de entrada Falso; maintain_order="left_right" na junção retornou Verdadeiro. Uma máquina, uma execução, uma forma de junção.
  • O "spilling" fora do núcleo está ativado por padrão: ele começa em cerca de 80% da RAM, com um orçamento de disco padrão de 64 GB. Junções e group_by fora do núcleo estão no roteiro.
  • collect_schema() detecta uma coluna ausente antes que qualquer dado seja lido, mas um "cast" que falha em apenas um valor só falha em collect().
  • A comparação TPC-H e TPC-DS é a própria execução do fornecedor em dados derivados, e sua nota de rodapé diz que os resultados não são comparáveis a benchmarks oficiais.

Perguntas e respostas

Por que as junções do Polars 2.0 não mantêm mais as linhas na ordem de entrada?

Chamar 'collect' em uma consulta 'lazy' agora usa o motor de 'streaming' por padrão. O 'streaming' divide a consulta em blocos que são executados em paralelo, e os blocos terminam quando terminam. Para 'join', 'group_by' e 'unpivot', o lançamento, portanto, não promete uma ordem de linha de saída. Testes que comparam a saída a um arquivo salvo linha por linha são os primeiros a provavelmente quebrar.

Assista a esta parte 0:00 · Polars (pola.rs) · Polars documentation

Como faço para recuperar a antiga ordem das linhas após atualizar para o Polars 2.0?

Adicione uma classificaçã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 retornou 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.

Assista a esta parte 2:07 · Polars documentation

O Polars 2.0 pode processar dados maiores que a memória?

Parcialmente. O 'spilling' fora do núcleo está ativado por padrão, começando em cerca de 80% da RAM com um orçamento de disco padrão de 64 GB. Classificações, funções de janela e muitas expressões podem fazer 'spill' agora. Junções e 'group-bys' fora do núcleo estão no roteiro, então essas operações ainda não fazem 'spill'.

Assista a esta parte 0:56 · Polars (pola.rs) · Polars documentation

Posso confiar nas comparações de benchmark do Polars 2.0 com DuckDB e DataFusion?

Trate-as como as próprias afirmações do fornecedor. Polars afirma que supera DataFusion e DuckDB em TPC-H e TPC-DS, mas os números vêm de suas próprias execuções em dados derivados, e sua nota de rodapé diz que os resultados não são comparáveis a benchmarks oficiais. Polars também diz que os threads extras da máquina grande diminuem a velocidade de consultas pequenas.

Assista a esta parte 1:17 · Polars (pola.rs) · Polars on GitHub

É seguro atualizar 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 classificação após ela é uma decisão de ordem de linha nunca tomada. A tipagem mais rigorosa ajuda um pouco, já que a verificação de esquema detecta uma coluna ausente antes que os dados sejam lidos, mas uma conversão que falha em uma única linha só falha no 'collect'.

Assista a esta parte 2:20 · Polars documentation · Polars (pola.rs)

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 você as escreveu. Polars 2.0 parou de prometer isso, por padrão, de propósito. Neste vídeo: por que o padrão mudou? O que isso trouxe? E qual dos seus scripts quebra primeiro? Este é o The Daily Diff, por baixo do capô. Polars é uma biblioteca de DataFrame de código aberto: um mecanismo 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. A chave que traz a ordem antiga de volta é um argumento para a própria junção. Voltarei a isso no final. Desde 2.0, collect executa o mecanismo 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 junção, agrupamento e "unpivot", o lançamento não promete uma ordem. Quem é atingido primeiro? Quem compara a saída a um arquivo salvo, linha por linha. Esse teste pode passar no seu laptop e falhar em uma máquina diferente. Em seguida, 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, classifique explicitamente. O "out-of-core" também está ativado por padrão. Ele começa a "espalhar" para o disco em cerca de oitenta por cento da RAM, com um orçamento de sessenta e quatro gigabytes. Classificação, funções de janela e muitas expressões podem "espalhar" agora. Junções e agrupamentos estão chegando.

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 3,8 vezes mais rápido de dezesseis núcleos para cento e noventa e dois, no TPC-H. Eles também dizem que os threads extras da máquina grande diminuem as consultas pequenas.

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 flag, a ordem de entrada sobrevive. Encontre as junções que alimentam um teste. Qualquer junção sem uma classificação depois dela é 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 detecta uma coluna ausente antes que qualquer dado seja lido. Não consegue detectar um "cast" que falha em uma linha, porque esse erro espera pelos dados. Agora o loop que abri.

Como faço para recuperar a ordem antiga?

2:08 A chave está na junção. Defina maintain_order na junção ou adicione uma classificação depois dela. O guia sugere a classificação. A flag de junção manteve a ordem em nossa execução, com a ordem do lado esquerdo mantida como esquerda, direita. Veredito, por baixo do capô: NEEDS REVIEW.

Qual é o veredito?

2:22 Eu revisaria cada junção antes de fazer o upgrade. Tem alguma pergunta sobre isso? Coloque-a nos comentários. E esse é o diff de hoje. Sou Niko da Axrisi. Faça o merge com responsabilidade.

Fontes

  1. Release of Polars 2.0Polars (pola.rs)
  2. Polars 2.0 upgrade guidePolars documentation
  3. Polars homepagePolars (pola.rs)
  4. polars-2.0-benchmark repositoryPolars on GitHub
  5. Release of Polars 2.0 (Hacker News discussion)Hacker News

Niko from Axrisi

Nikoloz Turazashvili · Vexrail · Axrisi

LinkedIn · dev.to · GitHub · X · Substack

Vídeos relacionados