ignoring_gravity's questions

Digamos que eu tenha os seguintes dados:

import duckdb
rel = duckdb.sql("""
    FROM VALUES
        ([{'a': 'foo', 'b': 'bta'}]),
        ([]),
        ([{'a': 'jun', 'b': 'jul'}, {'a':'nov', 'b': 'obt'}])
        df(my_col)
    SELECT *
""")

que se parece com isto:

┌──────────────────────────────────────────────┐
│                    my_col                    │
│        struct(a varchar, b varchar)[]        │
├──────────────────────────────────────────────┤
│ [{'a': foo, 'b': bta}]                       │
│ []                                           │
│ [{'a': jun, 'b': jul}, {'a': nov, 'b': obt}] │
└──────────────────────────────────────────────┘

Gostaria de manter todas as linhas onde para qualquer um dos itens em um dos elementos de 'my_col', o campo 'a'contém a substring'bt'

Então, saída esperada:

┌──────────────────────────────────────────────┐
│                    my_col                    │
│        struct(a varchar, b varchar)[]        │
├──────────────────────────────────────────────┤
│ [{'a': foo, 'b': bta}]                       │
│ [{'a': jun, 'b': jul}, {'a': nov, 'b': obt}] │
└──────────────────────────────────────────────┘

Como posso escrever uma consulta SQL para fazer isso?

Em Polars / pandas / PyArrow, posso instanciar um objeto de um dict, por exemplo

In [12]: pl.DataFrame({'a': [1,2,3], 'b': [4,5,6]})
Out[12]:
shape: (3, 2)
┌─────┬─────┐
│ a   ┆ b   │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪═════╡
│ 1   ┆ 4   │
│ 2   ┆ 5   │
│ 3   ┆ 6   │
└─────┴─────┘

Existe uma maneira de fazer isso no DuckDB, sem passar pelo pandas / pyarrow / etc.?

Diga que eu tenho

import duckdb

rel = duckdb.sql('select * from values (1, 4), (1, 5), (2, 6) df(a, b)')
rel

Out[3]: 
┌───────┬───────┐
│   a   │   b   │
│ int32 │ int32 │
├───────┼───────┤
│     1 │     4 │
│     1 │     5 │
│     2 │     6 │
└───────┴───────┘

Posso agrupar por a e encontrar a média de 'b' fazendo:

rel.aggregate(
    [duckdb.FunctionExpression('mean', duckdb.ColumnExpression('b'))],
    group_expr='a',
)

┌─────────┐
│ mean(b) │
│ double  │
├─────────┤
│     4.5 │
│     6.0 │
└─────────┘

que funciona maravilhosamente

Existe uma maneira semelhante de criar uma agregação "n_unique"? Estou procurando algo como

rel.aggregate(
    [duckdb.FunctionExpression('count_distinct', duckdb.ColumnExpression('b'))],
    group_expr='a',
)

mas isso não existe. Tem algo que exista?

Diga que eu tenho

data = {'id': [1, 1, 1, 2, 2, 2],
 'd': [1, 2, 3, 1, 2, 3],
 'sales': [1, 4, 2, 3, 1, 2]}

Quero calcular uma soma contínua com janela de 2 particionada por 'id' ordenada por 'd'

Usando SQL eu posso fazer:

duckdb.sql("""
select *, sum(sales) over w as rolling_sales
from df
window w as (partition by id order by d rows between 1 preceding and current row)
""")
Out[21]:
┌───────┬───────┬───────┬───────────────┐
│  id   │   d   │ sales │ rolling_sales │
│ int64 │ int64 │ int64 │    int128     │
├───────┼───────┼───────┼───────────────┤
│     1 │     1 │     1 │             1 │
│     1 │     2 │     4 │             5 │
│     1 │     3 │     2 │             6 │
│     2 │     1 │     3 │             3 │
│     2 │     2 │     1 │             4 │
│     2 │     3 │     2 │             3 │
└───────┴───────┴───────┴───────────────┘

Isso funciona muito bem, mas como posso fazer isso usando a API Relacional do Python?

Eu cheguei até aqui

rel = duckdb.sql('select * from df')
rel.sum(
    'sales',
    projected_columns='*',
    window_spec='over (partition by id order by d rows between 1 preceding and current row)'
)

o que dá

┌───────────────────────────────────────────────────────────────────────────────────────┐
│ sum(sales) OVER (PARTITION BY id ORDER BY d ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) │
│                                        int128                                         │
├───────────────────────────────────────────────────────────────────────────────────────┤
│                                                                                     3 │
│                                                                                     4 │
│                                                                                     3 │
│                                                                                     1 │
│                                                                                     5 │
│                                                                                     6 │
└───────────────────────────────────────────────────────────────────────────────────────┘

Isso é próximo, mas não está totalmente correto. Como faço para que o nome da última coluna seja rolling_sales?

Digamos que eu tenha:

import pyarrow as pa

arr = pa.array([1, 3, 2, 2, 1, 3])

Gostaria de substituir os valores de acordo com {1: 'one', 2: 'two', 3: 'three'}e terminar com:

<pyarrow.lib.LargeStringArray object at 0x7f8dd0b3c820>
[
  "one",
  "three",
  "two",
  "two",
  "one",
  "three"
]

Posso fazer isso através do Polars:

In [19]: pl.from_arrow(arr).replace_strict({1: 'one', 2: 'two', 3: 'three'}, return_dtype=pl.String).to_arrow()
Out[19]:
<pyarrow.lib.LargeStringArray object at 0x7f8dd0b3c820>
[
  "one",
  "three",
  "two",
  "two",
  "one",
  "three"
]

Existe uma maneira de fazer isso apenas com o PyArrow?

Diga que eu tenho

In [3]: import pyarrow as pa

In [4]: ca = pa.chunked_array([[1,2,3], [4,5,6]])

Gostaria de extrair elementos [1, 4, 2]e terminar com

<pyarrow.lib.Int64Array object at 0x7f6eb43c2d40>
[
  2,
  5,
  3
]

como se eu estivesse fazendo indexação no estilo NumPy

Digamos que eu tenha:

data = {
    'id': ['a', 'a', 'a', 'b', 'b', 'b', 'b'],
    'd': [1,2,3,0,1,2,3],
    'sales': [5,1,3,4,1,2,3],
}

Gostaria de adicionar uma coluna com uma média móvel com tamanho de janela 2, com min_periods=2, sobre'id'

Em Polars, eu posso fazer:

import polars as pl

df = pl.DataFrame(data)
df.with_columns(sales_rolling = pl.col('sales').rolling_mean(2).over('id'))

shape: (7, 4)
┌─────┬─────┬───────┬───────────────┐
│ id  ┆ d   ┆ sales ┆ sales_rolling │
│ --- ┆ --- ┆ ---   ┆ ---           │
│ str ┆ i64 ┆ i64   ┆ f64           │
╞═════╪═════╪═══════╪═══════════════╡
│ a   ┆ 1   ┆ 5     ┆ null          │
│ a   ┆ 2   ┆ 1     ┆ 3.0           │
│ a   ┆ 3   ┆ 3     ┆ 2.0           │
│ b   ┆ 0   ┆ 4     ┆ null          │
│ b   ┆ 1   ┆ 1     ┆ 2.5           │
│ b   ┆ 2   ┆ 2     ┆ 1.5           │
│ b   ┆ 3   ┆ 3     ┆ 2.5           │
└─────┴─────┴───────┴───────────────┘

Qual é o equivalente do DuckDB? Eu tentei

import duckdb

duckdb.sql("""
    select
        *,
        mean(sales) over (
            partition by id 
            order by d
            range between 1 preceding and 0 following
        ) as sales_rolling 
    from df
""").sort('id', 'd')

mas pegue

┌─────────┬───────┬───────┬───────────────┐
│   id    │   d   │ sales │ sales_rolling │
│ varchar │ int64 │ int64 │    double     │
├─────────┼───────┼───────┼───────────────┤
│ a       │     1 │     5 │           5.0 │
│ a       │     2 │     1 │           3.0 │
│ a       │     3 │     3 │           2.0 │
│ b       │     0 │     4 │           4.0 │
│ b       │     1 │     1 │           2.5 │
│ b       │     2 │     2 │           1.5 │
│ b       │     3 │     3 │           2.5 │
└─────────┴───────┴───────┴───────────────┘

Isso é muito próximo, mas o duckdb ainda calcula a média móvel quando há apenas um único valor na janela. Como posso replicar o min_periods=2comportamento (padrão) do Polars?

Em Polars, posso usar zip_widthpara tirar valores de s1ou s2de acordo com uma máscara:

In [1]: import polars as pl

In [2]: import pyarrow as pa

In [3]: import pyarrow as pc

In [4]: s1 = pl.Series([1,2,3])

In [5]: mask = pl.Series([True, False, False])

In [6]: s2 = pl.Series([4, 5, 6])

In [7]: s1.zip_with(mask, s2)
Out[7]:
shape: (3,)
Series: '' [i64]
[
        1
        5
        6
]

Como posso fazer isso com PyArrow? Eu tentei pyarrow.compute.replace_with_mask, mas funciona de maneira diferente:

In [10]: import pyarrow.compute as pc

In [11]: import pyarrow as pa

In [12]: a1 = pa.array([1,2,3])

In [13]: mask = pa.array([True, False, False])

In [14]: a2 = pa.array([4,5,6])

In [15]: pc.replace_with_mask(a1, pc.invert(mask), a2)
Out[15]:
<pyarrow.lib.Int64Array object at 0x7f69d411afe0>
[
  1,
  4,
  5
]

Como replicar zip_withno PyArrow?

Diga que eu tenho

In [22]: import pyarrow as pa

In [23]: t = pa.table({'a': ['one', 'two', 'three']})

e gostaria de acrescentar '_frobenius'a cada elemento de'a'

Resultado esperado:

pyarrow.Table
a: string
----
a: [["one_frobenius","two_frobenius","three_frobenius"]]

Aqui está meu exemplo:

In [1]: import pandas as pd

In [2]: df = pd.DataFrame({'a': [1,2,3], 'b': [4,5,6]})

In [3]: df1 = df.rename(columns={'b': 'b'}, copy=False)

In [4]: df1.isetitem(1, [7,8,9])

In [5]: df
Out[5]:
   a  b
0  1  4
1  2  5
2  3  6

In [6]: df1
Out[6]:
   a  b
0  1  7
1  2  8
2  3  9

Se df1fosse derivado de dfwith copy=False, então eu esperava que uma modificação no local df1também afetasse df. Mas isso não acontece. Por que?

Estou usando o pandas versão 2.2.1, sem opções (por exemplo, copiar na gravação) habilitadas