ctx = SessionContext()

# create a RecordBatch and a new DataFrame from it

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2, 3]), pa.array([4, 5, 6]), pa.array([8, 5, 8])],

names=["a", "b", "c"],

)

ctx = SessionContext()

# create a RecordBatch and a new DataFrame from it

batch = pa.RecordBatch.from_arrays(

[pa.array([{"c": 1}, {"c": 2}, {"c": 3}]), pa.array([4, 5, 6])],

names=["a", "b"],

)

ctx = SessionContext()

# create a RecordBatch and a new DataFrame from it

# Intentionally make each array of different length

batch = pa.RecordBatch.from_arrays(

[pa.array([[1], [2, 3], [4, 5, 6], None]), pa.array([7, 8, 9, 10])],

names=["a", "b"],

)

ctx = SessionContext()

# create a RecordBatch and a new DataFrame from it

batch = pa.RecordBatch.from_arrays(

[

pa.array([0, 1, 2, 3, 4, 5, 6]),

pa.array([7, None, 7, 8, 9, None, 9]),

pa.array(["A", "A", "A", "A", "B", "B", "B"]),

],

names=["a", "b", "c"],

)

df_1 = df.select(

column("a") + column("b"),

column("a") - column("b"),

)

# execute and collect the first (and only) batch

result = df_1.collect()[0]

assert result.column(0) == pa.array([5, 7, 9])

assert result.column(1) == pa.array([-3, -3, -3])

df_2 = df.select("b", "a")

# execute and collect the first (and only) batch

result = df_2.collect()[0]

assert result.column(0) == pa.array([4, 5, 6])

df = df.select(column("b"), "a")

# execute and collect the first (and only) batch

result = df.collect()[0]

assert result.column(0) == pa.array([4, 5, 6])

df1 = df.filter(column("a") > literal(2)).select(

column("a") + column("b"),

column("a") - column("b"),

)

# execute and collect the first (and only) batch

result = df1.collect()[0]

assert result.column(0) == pa.array([9])

assert result.column(1) == pa.array([-3])

df.show()

# verify that if there is no filter applied, internal dataframe is unchanged

df2 = df.filter()

assert df.df == df2.df

df3 = df.filter(column("a") > literal(1), column("b") != literal(6))

result = df3.collect()[0]

assert result.column(0) == pa.array([2])

assert result.column(1) == pa.array([5])

df = df.sort(column("b").sort(ascending=False))

table = pa.Table.from_batches(df.collect())

expected = {"a": [3, 2, 1], "b": [6, 5, 4], "c": [8, 5, 8]}

df = df.drop("c")

# execute and collect the first (and only) batch

result = df.collect()[0]

assert df.schema().names == ["a", "b"]

assert result.column(0) == pa.array([1, 2, 3])

df = df.limit(1)

# execute and collect the first (and only) batch

result = df.collect()[0]

assert len(result.column(0)) == 1

# only 3 rows, but limit past the end to ensure that offset is working

df = df.limit(5, offset=2)

# execute and collect the first (and only) batch

result = df.collect()[0]

assert len(result.column(0)) == 1

df = df.head(1)

# execute and collect the first (and only) batch

result = df.collect()[0]

assert result.column(0) == pa.array([1])

assert result.column(1) == pa.array([4])

df = df.tail(1)

# execute and collect the first (and only) batch

result = df.collect()[0]

assert result.column(0) == pa.array([3])

assert result.column(1) == pa.array([6])

df = df.with_column("c", column("a") + column("b"))

# execute and collect the first (and only) batch

result = df.collect()[0]

assert result.schema.field(0).name == "a"

assert result.schema.field(1).name == "b"

assert result.schema.field(2).name == "c"

assert result.column(0) == pa.array([1, 2, 3])

assert result.column(1) == pa.array([4, 5, 6])

df = df.with_columns(

(column("a") + column("b")).alias("c"),

(column("a") + column("b")).alias("d"),

[

(column("a") + column("b")).alias("e"),

(column("a") + column("b")).alias("f"),

],

g=(column("a") + column("b")),

)

# execute and collect the first (and only) batch

result = df.collect()[0]

assert result.schema.field(0).name == "a"

assert result.schema.field(1).name == "b"

assert result.schema.field(2).name == "c"

assert result.schema.field(3).name == "d"

assert result.schema.field(4).name == "e"

assert result.schema.field(5).name == "f"

assert result.schema.field(6).name == "g"

assert result.column(0) == pa.array([1, 2, 3])

assert result.column(1) == pa.array([4, 5, 6])

assert result.column(2) == pa.array([5, 7, 9])

assert result.column(3) == pa.array([5, 7, 9])

assert result.column(4) == pa.array([5, 7, 9])

assert result.column(5) == pa.array([5, 7, 9])

df = df.cast({"a": pa.float16(), "b": pa.list_(pa.uint32())})

expected = pa.schema(

[("a", pa.float16()), ("b", pa.list_(pa.uint32())), ("c", pa.int64())]

)

df = df.with_column("c", column("a") + column("b")).with_column_renamed("c", "sum")

result = df.collect()[0]

assert result.schema.field(0).name == "a"

assert result.schema.field(1).name == "b"

nested_df = nested_df.unnest_columns("a")

# execute and collect the first (and only) batch

result = nested_df.collect()[0]

assert result.column(0) == pa.array([1, 2, 3, 4, 5, 6, None])

nested_df = nested_df.unnest_columns("a", preserve_nulls=False)

# execute and collect the first (and only) batch

result = nested_df.collect()[0]

assert result.column(0) == pa.array([1, 2, 3, 4, 5, 6])

ctx = SessionContext()

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2, 3]), pa.array([4, 5, 6])],

names=["a", "b"],

)

df = ctx.create_dataframe([[batch]], "l")

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2]), pa.array([8, 10])],

names=["a", "c"],

)

df1 = ctx.create_dataframe([[batch]], "r")

df2 = df.join(df1, on="a", how="inner")

df2.show()

df2 = df2.sort(column("l.a"))

table = pa.Table.from_batches(df2.collect())

expected = {"a": [1, 2], "c": [8, 10], "b": [4, 5]}

assert table.to_pydict() == expected

df2 = df.join(df1, left_on="a", right_on="a", how="inner")

df2.show()

df2 = df2.sort(column("l.a"))

table = pa.Table.from_batches(df2.collect())

expected = {"a": [1, 2], "c": [8, 10], "b": [4, 5]}

assert table.to_pydict() == expected

# Verify we don't make a breaking change to pre-43.0.0

# where users would pass join_keys as a positional argument

df2 = df.join(df1, (["a"], ["a"]), how="inner") # type: ignore

df2.show()

df2 = df2.sort(column("l.a"))

table = pa.Table.from_batches(df2.collect())

expected = {"a": [1, 2], "c": [8, 10], "b": [4, 5]}

ctx = SessionContext()

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2, 3]), pa.array([4, 5, 6])],

names=["a", "b"],

)

df = ctx.create_dataframe([[batch]], "l")

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2]), pa.array([8, 10])],

names=["a", "c"],

)

df1 = ctx.create_dataframe([[batch]], "r")

with pytest.deprecated_call():

df2 = df.join(df1, join_keys=(["a"], ["a"]), how="inner")

df2.show()

df2 = df2.sort(column("l.a"))

table = pa.Table.from_batches(df2.collect())

expected = {"a": [1, 2], "c": [8, 10], "b": [4, 5]}

assert table.to_pydict() == expected

with pytest.raises(

ValueError, match=r"`left_on` or `right_on` should not provided with `on`"

):

df2 = df.join(df1, on="a", how="inner", right_on="test") # type: ignore

with pytest.raises(

ValueError, match=r"`left_on` and `right_on` should both be provided."

):

df2 = df.join(df1, left_on="a", how="inner") # type: ignore

with pytest.raises(

ValueError, match=r"either `on` or `left_on` and `right_on` should be provided."

):

ctx = SessionContext()

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2, 3]), pa.array([4, 5, 6])],

names=["a", "b"],

)

df = ctx.create_dataframe([[batch]], "l")

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2]), pa.array([-8, 10])],

names=["a", "c"],

)

df1 = ctx.create_dataframe([[batch]], "r")

df2 = df.join_on(df1, column("l.a").__eq__(column("r.a")), how="inner")

df2.show()

df2 = df2.sort(column("l.a"))

table = pa.Table.from_batches(df2.collect())

expected = {"a": [1, 2], "c": [-8, 10], "b": [4, 5]}

assert table.to_pydict() == expected

df3 = df.join_on(

df1,

column("l.a").__eq__(column("r.a")),

column("l.a").__lt__(column("r.c")),

how="inner",

)

df3.show()

df3 = df3.sort(column("l.a"))

table = pa.Table.from_batches(df3.collect())

expected = {"a": [2], "c": [10], "b": [5]}

ctx = SessionContext()

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2, 3, 1, 2, 3]), pa.array([4, 5, 6, 4, 5, 6])],

names=["a", "b"],

)

df_a = ctx.create_dataframe([[batch]]).distinct().sort(column("a"))

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2, 3]), pa.array([4, 5, 6])],

names=["a", "b"],

)

df_b = ctx.create_dataframe([[batch]]).sort(column("a"))

(

"row",

f.row_number(order_by=[column("b"), column("a").sort(ascending=False)]),

[4, 2, 3, 5, 7, 1, 6],

),

(

"row_w_params",

f.row_number(

order_by=[column("b"), column("a")],

partition_by=[column("c")],

),

[2, 1, 3, 4, 2, 1, 3],

),

("rank", f.rank(order_by=[column("b")]), [3, 1, 3, 5, 6, 1, 6]),

(

"rank_w_params",

f.rank(order_by=[column("b"), column("a")], partition_by=[column("c")]),

[2, 1, 3, 4, 2, 1, 3],

),

(

"dense_rank",

f.dense_rank(order_by=[column("b")]),

[2, 1, 2, 3, 4, 1, 4],

),

(

"dense_rank_w_params",

f.dense_rank(order_by=[column("b"), column("a")], partition_by=[column("c")]),

[2, 1, 3, 4, 2, 1, 3],

),

(

"percent_rank",

f.round(f.percent_rank(order_by=[column("b")]), literal(3)),

[0.333, 0.0, 0.333, 0.667, 0.833, 0.0, 0.833],

),

(

"percent_rank_w_params",

f.round(

f.percent_rank(

order_by=[column("b"), column("a")], partition_by=[column("c")]

),

literal(3),

),

[0.333, 0.0, 0.667, 1.0, 0.5, 0.0, 1.0],

),

(

"cume_dist",

f.round(f.cume_dist(order_by=[column("b")]), literal(3)),

[0.571, 0.286, 0.571, 0.714, 1.0, 0.286, 1.0],

),

(

"cume_dist_w_params",

f.round(

f.cume_dist(

order_by=[column("b"), column("a")], partition_by=[column("c")]

),

literal(3),

),

[0.5, 0.25, 0.75, 1.0, 0.667, 0.333, 1.0],

),

(

"ntile",

f.ntile(2, order_by=[column("b")]),

[1, 1, 1, 2, 2, 1, 2],

),

(

"ntile_w_params",

f.ntile(2, order_by=[column("b"), column("a")], partition_by=[column("c")]),

[1, 1, 2, 2, 1, 1, 2],

),

("lead", f.lead(column("b"), order_by=[column("b")]), [7, None, 8, 9, 9, 7, None]),

(

"lead_w_params",

f.lead(

column("b"),

shift_offset=2,

default_value=-1,

order_by=[column("b"), column("a")],

partition_by=[column("c")],

),

[8, 7, -1, -1, -1, 9, -1],

),

("lag", f.lag(column("b"), order_by=[column("b")]), [None, None, 7, 7, 8, None, 9]),

(

"lag_w_params",

f.lag(

column("b"),

shift_offset=2,

default_value=-1,

order_by=[column("b"), column("a")],

partition_by=[column("c")],

),

[-1, -1, None, 7, -1, -1, None],

),

(

"first_value",

f.first_value(column("a")).over(

Window(partition_by=[column("c")], order_by=[column("b")])

),

[1, 1, 1, 1, 5, 5, 5],

),

(

"last_value",

f.last_value(column("a")).over(

Window(

partition_by=[column("c")],

order_by=[column("b")],

window_frame=WindowFrame("rows", None, None),

)

),

[3, 3, 3, 3, 6, 6, 6],

),

(

"3rd_value",

f.nth_value(column("b"), 3).over(Window(order_by=[column("a")])),

[None, None, 7, 7, 7, 7, 7],

),

(

"avg",

f.round(f.avg(column("b")).over(Window(order_by=[column("a")])), literal(3)),

[7.0, 7.0, 7.0, 7.333, 7.75, 7.75, 8.0],

),

df = partitioned_df.select(

column("a"), column("b"), column("c"), f.alias(expr, name)

)

df.sort(column("a")).show()

table = pa.Table.from_batches(df.collect())

expected = {

"a": [0, 1, 2, 3, 4, 5, 6],

"b": [7, None, 7, 8, 9, None, 9],

"c": ["A", "A", "A", "A", "B", "B", "B"],

name: result,

}

# ref: https://github.com/apache/datafusion-python/issues/688

window_frame = WindowFrame("rows", None, None)

col_a = column("a")

# Using `f.window` with or without an unbounded window_frame produces the same

# results. These tests are included as a regression check but can be removed when

# f.window() is deprecated in favor of using the .over() approach.

no_frame = f.window("avg", [col_a]).alias("no_frame")

with_frame = f.window("avg", [col_a], window_frame=window_frame).alias("with_frame")

df_1 = partitioned_df.select(col_a, no_frame, with_frame)

expected = {

"a": [0, 1, 2, 3, 4, 5, 6],

"no_frame": [3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0],

"with_frame": [3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0],

}

assert df_1.sort(col_a).to_pydict() == expected

# When order is not set, the default frame should be unounded preceeding to

# unbounded following. When order is set, the default frame is unbounded preceeding

# to current row.

no_order = f.avg(col_a).over(Window()).alias("over_no_order")

with_order = f.avg(col_a).over(Window(order_by=[col_a])).alias("over_with_order")

df_2 = partitioned_df.select(col_a, no_order, with_order)

expected = {

"a": [0, 1, 2, 3, 4, 5, 6],

"over_no_order": [3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0],

"over_with_order": [0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0],

}

ctx = SessionContext()

path = tmp_path / "test.csv"

table = pa.Table.from_arrays(

[

[1, 2, 3, 4],

["a", "b", "c", "d"],

[1.1, 2.2, 3.3, 4.4],

],

names=["int", "str", "float"],

)

write_csv(table, path)

ctx.register_csv("csv", path)

df = ctx.table("csv")

df = struct_df.select(

column("a")["c"] + column("b"),

column("a")["c"] - column("b"),

)

# execute and collect the first (and only) batch

result = df.collect()[0]

assert result.column(0) == pa.array([5, 7, 9])

df = df.select(

column("a") + column("b"),

column("a") - column("b"),

)

plan = aggregate_df.logical_plan()

expected = "Projection: test.c1, sum(test.c2)"

assert expected == plan.display()

expected = (

"Projection: test.c1, sum(test.c2)\n"

" Aggregate: groupBy=[[test.c1]], aggr=[[sum(test.c2)]]\n"

" TableScan: test"

)

plan = aggregate_df.optimized_logical_plan()

expected = "Aggregate: groupBy=[[test.c1]], aggr=[[sum(test.c2)]]"

assert expected == plan.display()

expected = (

"Aggregate: groupBy=[[test.c1]], aggr=[[sum(test.c2)]]\n"

" TableScan: test projection=[c1, c2]"

)

plan = aggregate_df.execution_plan()

expected = (

"AggregateExec: mode=FinalPartitioned, gby=[c1@0 as c1], aggr=[sum(test.c2)]\n" # noqa: E501

)

assert expected == plan.display()

# Check the number of partitions is as expected.

assert isinstance(plan.partition_count, int)

expected = (

"ProjectionExec: expr=[c1@0 as c1, SUM(test.c2)@1 as SUM(test.c2)]\n"

" Aggregate: groupBy=[[test.c1]], aggr=[[SUM(test.c2)]]\n"

" TableScan: test projection=[c1, c2]"

)

indent = plan.display_indent()

# indent plan will be different for everyone due to absolute path

# to filename, so we just check for some expected content

assert "AggregateExec:" in indent

assert "CoalesceBatchesExec:" in indent

assert "RepartitionExec:" in indent

assert "CsvExec:" in indent

ctx = SessionContext()

stream = ctx.execute(plan, 0)

# get the one and only batch

batch = stream.next()

assert batch is not None

# there should be no more batches

batch = stream.next()

ctx = SessionContext()

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2, 3]), pa.array([4, 5, 6])],

names=["a", "b"],

)

df_a = ctx.create_dataframe([[batch]])

batch = pa.RecordBatch.from_arrays(

[pa.array([3, 4, 5]), pa.array([6, 7, 8])],

names=["a", "b"],

)

df_b = ctx.create_dataframe([[batch]])

batch = pa.RecordBatch.from_arrays(

[pa.array([3]), pa.array([6])],

names=["a", "b"],

)

df_c = ctx.create_dataframe([[batch]]).sort(column("a"))

df_a_i_b = df_a.intersect(df_b).sort(column("a"))

ctx = SessionContext()

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2, 3]), pa.array([4, 5, 6])],

names=["a", "b"],

)

df_a = ctx.create_dataframe([[batch]])

batch = pa.RecordBatch.from_arrays(

[pa.array([3, 4, 5]), pa.array([6, 7, 8])],

names=["a", "b"],

)

df_b = ctx.create_dataframe([[batch]])

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2]), pa.array([4, 5])],

names=["a", "b"],

)

df_c = ctx.create_dataframe([[batch]]).sort(column("a"))

df_a_e_b = df_a.except_all(df_b).sort(column("a"))

ctx = SessionContext()

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2, 3]), pa.array([4, 5, 6])],

names=["a", "b"],

)

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2, 3]), pa.array([4, 5, 6])],

names=["a", "b"],

)

df_a = ctx.create_dataframe([[batch]])

batch = pa.RecordBatch.from_arrays(

[pa.array([3, 4, 5]), pa.array([6, 7, 8])],

names=["a", "b"],

)

df_b = ctx.create_dataframe([[batch]])

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2, 3, 3, 4, 5]), pa.array([4, 5, 6, 6, 7, 8])],

names=["a", "b"],

)

df_c = ctx.create_dataframe([[batch]]).sort(column("a"))

df_a_u_b = df_a.union(df_b).sort(column("a"))

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2, 3]), pa.array([4, 5, 6])],

names=["a", "b"],

)

df_a = ctx.create_dataframe([[batch]])

batch = pa.RecordBatch.from_arrays(

[pa.array([3, 4, 5]), pa.array([6, 7, 8])],

names=["a", "b"],

)

df_b = ctx.create_dataframe([[batch]])

batch = pa.RecordBatch.from_arrays(

[pa.array([1, 2, 3, 4, 5]), pa.array([4, 5, 6, 7, 8])],

names=["a", "b"],

)

df_c = ctx.create_dataframe([[batch]]).sort(column("a"))

df_a_u_b = df_a.union(df_b, True).sort(column("a"))

assert df_c.collect() == df_a_u_b.collect()

# Skip test if pandas is not installed

pd = pytest.importorskip("pandas")

# Convert datafusion dataframe to pandas dataframe

pandas_df = df.to_pandas()

assert isinstance(pandas_df, pd.DataFrame)

assert pandas_df.shape == (3, 3)

# Skip test if pandas is not installed

pd = pytest.importorskip("pandas")

# Convert empty datafusion dataframe to pandas dataframe

pandas_df = df.limit(0).to_pandas()

assert isinstance(pandas_df, pd.DataFrame)

assert pandas_df.shape == (0, 3)

# Skip test if polars is not installed

pl = pytest.importorskip("polars")

# Convert datafusion dataframe to polars dataframe

polars_df = df.to_polars()

assert isinstance(polars_df, pl.DataFrame)

assert polars_df.shape == (3, 3)

# Skip test if polars is not installed

pl = pytest.importorskip("polars")

# Convert empty datafusion dataframe to polars dataframe

polars_df = df.limit(0).to_polars()

assert isinstance(polars_df, pl.DataFrame)

assert polars_df.shape == (0, 3)

# Convert datafusion dataframe to pyarrow Table

pyarrow_table = df.to_arrow_table()

assert isinstance(pyarrow_table, pa.Table)

assert pyarrow_table.shape == (3, 3)

stream = df.execute_stream()

for s in stream:

print(type(s))

assert all(batch is not None for batch in stream)

stream = df.execute_stream()

if schema:

pyarrow_table = pa.Table.from_batches(

(batch.to_pyarrow() for batch in stream), schema=df.schema()

)

else:

pyarrow_table = pa.Table.from_batches((batch.to_pyarrow() for batch in stream))

assert isinstance(pyarrow_table, pa.Table)

assert pyarrow_table.shape == (3, 3)

streams = df.execute_stream_partitioned()

assert all(batch is not None for stream in streams for batch in stream)

assert all(

not list(stream) for stream in streams

# Convert empty datafusion dataframe to pyarrow Table

pyarrow_table = df.limit(0).to_arrow_table()

assert isinstance(pyarrow_table, pa.Table)

assert pyarrow_table.shape == (0, 3)

# Convert datafusion dataframe to Python list

pylist = df.to_pylist()

assert isinstance(pylist, list)

assert pylist == [

{"a": 1, "b": 4, "c": 8},

{"a": 2, "b": 5, "c": 5},

{"a": 3, "b": 6, "c": 8},

# Convert datafusion dataframe to Python dictionary