+− THE DAILY DIFFdev & AI news
NEEDS REVIEW

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.

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

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.

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

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.

Veja esta parte 2:07 · Polars documentation

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

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

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.

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

É 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'.

Veja 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 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

  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