polars-arrow 0.44.2

Minimal implementation of the Arrow specification forked from arrow2
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

[package]
name = "polars-arrow"
version = { workspace = true }
authors = [
  "Jorge C. Leitao <jorgecarleitao@gmail.com>",
  "Apache Arrow <dev@arrow.apache.org>",
  "Ritchie Vink <ritchie46@gmail.com>",
]
edition = { workspace = true }
homepage = { workspace = true }
license = "MIT AND Apache-2.0"
repository = { workspace = true }
description = "Minimal implementation of the Arrow specification forked from arrow2"

[dependencies]
atoi = { workspace = true, optional = true }
bytemuck = { workspace = true, features = ["must_cast"] }
chrono = { workspace = true }
# for timezone support
chrono-tz = { workspace = true, optional = true }
dyn-clone = { version = "1" }
either = { workspace = true }
hashbrown = { workspace = true }
num-traits = { workspace = true }
parking_lot = { workspace = true }
polars-error = { workspace = true }
polars-schema = { workspace = true }
polars-utils = { workspace = true }
serde = { workspace = true, optional = true }
simdutf8 = { workspace = true }

ethnum = { workspace = true }

# To efficiently cast numbers to strings
atoi_simd = { workspace = true, optional = true }
fast-float = { workspace = true, optional = true }
itoa = { workspace = true, optional = true }
itoap = { workspace = true, optional = true }
ryu = { workspace = true, optional = true }

regex = { workspace = true, optional = true }
regex-syntax = { version = "0.8", optional = true }
streaming-iterator = { workspace = true }

indexmap = { workspace = true, optional = true }

arrow-format = { workspace = true, optional = true, features = ["ipc"] }

hex = { workspace = true, optional = true }

# for IPC compression
lz4 = { version = "1.24", optional = true }
zstd = { workspace = true, optional = true }

# to write to parquet as a stream
futures = { workspace = true, optional = true }

# avro support
avro-schema = { workspace = true, optional = true }

# for division/remainder optimization at runtime
strength_reduce = { workspace = true, optional = true }

# For instruction multiversioning
multiversion = { workspace = true, optional = true }

# Faster hashing
ahash = { workspace = true }

# For async arrow flight conversion
async-stream = { version = "0.3", optional = true }
tokio = { workspace = true, optional = true, features = ["io-util"] }

strum_macros = { workspace = true }

[dev-dependencies]
criterion = "0.5"
crossbeam-channel = { workspace = true }
doc-comment = "0.3"
flate2 = { workspace = true, default-features = true }
# used to run formal property testing
proptest = { version = "1", default-features = false, features = ["std"] }
# use for flaky testing
rand = { workspace = true }
# use for generating and testing random data samples
sample-arrow2 = "0.17"
sample-std = "0.2"
sample-test = "0.2"
# used to test async readers
tokio = { workspace = true, features = ["macros", "rt", "fs", "io-util"] }
tokio-util = { workspace = true, features = ["compat"] }

[build-dependencies]
version_check = { workspace = true }

[target.wasm32-unknown-unknown.dependencies]
getrandom = { version = "0.2", features = ["js"] }

[features]
default = []
full = [
  "io_ipc",
  "io_flight",
  "io_ipc_compression",
  "io_avro",
  "io_avro_compression",
  "io_avro_async",
  "regex-syntax",
  "compute",
  "serde",
  # parses timezones used in timestamp conversions
  "chrono-tz",
]
io_ipc = ["arrow-format", "polars-error/arrow-format"]
io_ipc_compression = ["lz4", "zstd", "io_ipc"]
io_flight = ["io_ipc", "arrow-format/flight-data", "async-stream", "futures", "tokio"]

io_avro = ["avro-schema", "polars-error/avro-schema"]
io_avro_compression = [
  "avro-schema/compression",
]
io_avro_async = ["avro-schema/async"]

# the compute kernels. Disabling this significantly reduces compile time.
compute_aggregate = ["multiversion"]
compute_arithmetics_decimal = ["strength_reduce"]
compute_arithmetics = ["strength_reduce", "compute_arithmetics_decimal"]
compute_bitwise = []
compute_boolean = []
compute_boolean_kleene = []
compute_cast = ["compute_take", "ryu", "atoi_simd", "itoa", "fast-float"]
compute_comparison = ["compute_take", "compute_boolean"]
compute_hash = ["multiversion"]
compute_take = []
compute_temporal = []
compute = [
  "compute_aggregate",
  "compute_arithmetics",
  "compute_bitwise",
  "compute_boolean",
  "compute_boolean_kleene",
  "compute_cast",
  "compute_comparison",
  "compute_hash",
  "compute_take",
  "compute_temporal",
]
serde = ["dep:serde", "polars-schema/serde", "polars-utils/serde"]
simd = []

# polars-arrow
timezones = [
  "chrono-tz",
]
dtype-array = []
dtype-decimal = ["atoi", "itoap"]
bigidx = ["polars-utils/bigidx"]
nightly = []
performant = []
strings = []
temporal = []

[package.metadata.docs.rs]
features = ["full"]
rustdoc-args = ["--cfg", "docsrs"]

[package.metadata.cargo-all-features]
allowlist = ["compute", "compute_sort", "compute_hash", "compute_nullif"]