arrow-julia.git
17 months agoEnsure dict encoded index types match from record batch to record batch (#148)
Jacob Quinn [Fri, 12 Mar 2021 05:16:34 +0000 (22:16 -0700)] 
Ensure dict encoded index types match from record batch to record batch (#148)

Fixes #144. The core issue here was the initial record batch had a
dict-encoded column that ended up having an index type of Int8. However,
in a subsequent record batch, we use a different code path for dict
encoded columns because we need to check if a dictionary delta message
needs to be sent (i.e. there are new pooled values that need to be
serialized). The problem was in this code path, the index type was
computed from the total length of the input column instead of matching
what was already serialized in the initial schema message.

This does open up the question of another possible failure: if an
initial dict encoded column is serialized with an index type of Int8,
yet subsequent record batches end up including enough unique values that
this index type will be overflowed. I've added in an error check for
this case. Currently it's a fatal error that will stop the `Arrow.write`
process completely. I'm not quite sure what the best recommendation
would be in that case; ultimately the user needs to either widen the
first record batch column index type, but perhaps we should allow
passing a dict-encoded index type to the overall `Arrow.write` function
so users can easily specify what that type should be.

The other change that had to be made in this PR is on the reading side,
since we're now tracking the index type in the DictEncoding type itself,
which probably not coincidentally is what the arrow-json struct already
does. For reading, we already have access to the dictionary field, so
it's just a matter of deserializing the index type before constructing
the DictEncoding struct.

17 months agoIntroduce new `maxdepth` keyword argument for setting a limit on nesting (#147)
Jacob Quinn [Wed, 10 Mar 2021 23:40:26 +0000 (16:40 -0700)] 
Introduce new `maxdepth` keyword argument for setting a limit on nesting (#147)

level limit

Alternative fix for #143. This is a more general fix than just
specializing CategoricalArrays. This should prevent more general cases
of the same issue: i.e. someone accidently passes a recursive data
structure and `Arrow.write` gets stuck trying to recursively serialize.

17 months agoimplement Base.IteratorSize for Stream, fixes #141 (#142)
Damien Drix [Fri, 5 Mar 2021 06:06:42 +0000 (06:06 +0000)] 
implement Base.IteratorSize for Stream, fixes #141 (#142)

18 months agofix accidental invocation of _unsafe_load_tuple (#124) v1.2.4
Jarrett Revels [Fri, 5 Feb 2021 04:52:00 +0000 (23:52 -0500)] 
fix accidental invocation of _unsafe_load_tuple (#124)

* fix accidental invocation of _unsafe_load_tuple

* bump Project.toml

18 months agoBump version v1.2.3
Jacob Quinn [Thu, 4 Feb 2021 06:51:37 +0000 (23:51 -0700)] 
Bump version

18 months agoUse pool length in signed int conversion (#122)
Douglas Bates [Thu, 4 Feb 2021 06:51:14 +0000 (00:51 -0600)] 
Use pool length in signed int conversion (#122)

18 months agoBump version v1.2.2
Jacob Quinn [Sun, 31 Jan 2021 06:20:11 +0000 (23:20 -0700)] 
Bump version

18 months agoRework dict encoding of PooledArray/CategoricalArray to fix outstandi… (#119)
Jacob Quinn [Sun, 31 Jan 2021 06:18:44 +0000 (23:18 -0700)] 
Rework dict encoding of PooledArray/CategoricalArray to fix outstandi‚Ķ (#119)

* Rework dict encoding of PooledArray/CategoricalArray to fix outstanding issues

Fixes #117, #116, and #113. For #116, we just need to special case if user happens to pass in a DictEncoded themselves. We need to pass it through to the `toarrowvector` method that no-ops. For #113, we require the new functionality in PooledArrays that allows passing the `signed` and `compress` keyword arguments to ensure we get signed refs for our dict encoding. For #117, we add CategoricalArrays as a test dependency and ensure that if it contains any `missing` value, we *don't* recode the indices values down by 1, since the `missing` ref is 0, so other refs can already be considered "offsets". If there are no `missing`, then we still need to recode down since refs should always start from 0 in arrow format.

* PooledArrays 1.0 compat

* Update src/arraytypes/dictencoding.jl

Co-authored-by: Milan Bouchet-Valat <nalimilan@club.fr>
* Check refpool

* Fix test

Co-authored-by: Milan Bouchet-Valat <nalimilan@club.fr>
18 months agoMake compressed writing threadsafe (#118)
Jacob Quinn [Sat, 30 Jan 2021 07:04:34 +0000 (00:04 -0700)] 
Make compressed writing threadsafe (#118)

Fixes #82. The problem when trying to write arrow using multiple threads and compression was there was only a single compressor object that each thread was simultaneously trying to use. This PR ensures there is a compressor object per thread that will be used per thread.

18 months agoBump version v1.2.1
Jacob Quinn [Mon, 25 Jan 2021 18:39:49 +0000 (11:39 -0700)] 
Bump version

18 months agoFix copy on DictEncode (#111)
Jacob Quinn [Mon, 25 Jan 2021 18:39:08 +0000 (11:39 -0700)] 
Fix copy on DictEncode (#111)

Fixes #102. The issue comes up because DataFrames constructor tries to
make a copy of input columns by default when constructing; for
DictEncode, it's just a wrapper to signal that a column should be
copied, so we just make a shallow copy.

18 months agoDon't use ChainedVector as DictEncoding data array unless necessary (#110)
Jacob Quinn [Sat, 23 Jan 2021 04:27:09 +0000 (21:27 -0700)] 
Don't use ChainedVector as DictEncoding data array unless necessary (#110)

Fixes #109. The issue here was when reading arrow record batches with
dict encoded columns, we eagerly used `ChainedVector` for the underlying
array backing the `DictEncoding` in case there were subsequent
record batches that added additional elements to the dict encoding. This
is too eager though, since it's probably common, like for "feather"
files, where the dict encoding values are always known and provided in
the first record batch. In fact, several language implementations don't
even support these kind of "delta" dict updates in subsequent record
batches. This PR, therefore, uses a regular array for the dict encoding
backing for the first record batch, and only promotes to a ChainedVector
if we happen to get a delta update.

18 months agobump Project.toml to v1.2.0 (#107) v1.2.0
Jarrett Revels [Tue, 19 Jan 2021 18:12:53 +0000 (13:12 -0500)] 
bump Project.toml to v1.2.0 (#107)

18 months agoadd isbitstype optimized path for FixedSizeList getindex (#104)
Jarrett Revels [Tue, 12 Jan 2021 06:29:34 +0000 (01:29 -0500)] 
add isbitstype optimized path for FixedSizeList getindex (#104)

* add isbitstype optimized path for FixedSizeList getindex

* reuse _unsafe_cast strategy from #103

* rebase + DRY _unsafe_cast

18 months agochange UUID <-> Arrow mapping to (de)serialize to/from 16-byte FixedSizeBinary (...
Jarrett Revels [Mon, 11 Jan 2021 22:51:20 +0000 (17:51 -0500)] 
change UUID <-> Arrow mapping to (de)serialize to/from 16-byte FixedSizeBinary (#103)

* change UUID <-> Arrow mapping to (de)serialize to/from 16-byte FixedSizeBinary

* fix tests

* optimize UInt128 <-> NTuple{16,UInt8} casting

Co-authored-by: SimonDanisch <sdanisch@protonmail.com>
Co-authored-by: SimonDanisch <sdanisch@protonmail.com>
19 months agoAdd missing license
Jacob Quinn [Thu, 7 Jan 2021 05:28:13 +0000 (22:28 -0700)] 
Add missing license

19 months agoAdmin cleanup
Jacob Quinn [Thu, 7 Jan 2021 05:10:39 +0000 (22:10 -0700)] 
Admin cleanup

19 months agoAdd BitIntegers compat (#100) v1.1.0
Jacob Quinn [Wed, 6 Jan 2021 04:40:57 +0000 (21:40 -0700)] 
Add BitIntegers compat (#100)

19 months agobump Project.toml to v1.1.0 (#94)
Jarrett Revels [Tue, 5 Jan 2021 23:59:32 +0000 (18:59 -0500)] 
bump Project.toml to v1.1.0 (#94)

19 months agoFix copy on DictEncoding arrays with missing values (#99)
Jacob Quinn [Tue, 5 Jan 2021 23:59:19 +0000 (16:59 -0700)] 
Fix copy on DictEncoding arrays with missing values (#99)

The copy code for DictEncoding erroneously tried to special-case
`missing` when copying, which is unnecessary since `missing` is just
treated like any other regular ref value. By removing the special-cased
branch of code, we avoid treating it differently and the code copies the
`DictEncoding` array as a `PooledArray` as expected.

19 months agoUpdate make.jl (#97)
Eric Hanson [Tue, 5 Jan 2021 23:51:06 +0000 (00:51 +0100)] 
Update make.jl (#97)

19 months agoconvert Arrow-flavored eltypes to Julia-flavored eltypes on copy (#98)
Jarrett Revels [Tue, 5 Jan 2021 23:30:27 +0000 (18:30 -0500)] 
convert Arrow-flavored eltypes to Julia-flavored eltypes on copy (#98)

* convert Arrow-flavored eltypes to Julia-flavored eltypes on copy

* Update src/arraytypes/primitive.jl

Co-authored-by: Jacob Quinn <quinn.jacobd@gmail.com>
19 months agoAdd warning for `Arrow.ArrowTypes.registertype!` (#96)
Eric Hanson [Tue, 5 Jan 2021 05:43:27 +0000 (06:43 +0100)] 
Add warning for `Arrow.ArrowTypes.registertype!` (#96)

19 months agoadd default UUID <-> UInt128 Arrow type mapping (#89)
Jarrett Revels [Wed, 30 Dec 2020 06:13:44 +0000 (01:13 -0500)] 
add default UUID <-> UInt128 Arrow type mapping (#89)

* add default UUID <-> UInt128 Arrow type mapping

* add UUIDs to non-standard types table test state

* add test for  deprecation path for old UUID autoconversion

19 months agoadd `ArrowTypes.default` methods and tests for dates (#86)
Eric Hanson [Thu, 24 Dec 2020 06:03:29 +0000 (07:03 +0100)] 
add `ArrowTypes.default` methods and tests for dates (#86)

19 months agoSupport new Decimal256 type (#79)
Jacob Quinn [Wed, 16 Dec 2020 21:02:37 +0000 (14:02 -0700)] 
Support new Decimal256 type (#79)

* Support new Decimal256 type

* Fix tests, update manual

19 months agoUpdate README & ci
Jacob Quinn [Sat, 12 Dec 2020 06:31:43 +0000 (23:31 -0700)] 
Update README & ci

20 months agoBump version v1.0.3
Jacob Quinn [Wed, 2 Dec 2020 06:22:20 +0000 (23:22 -0700)] 
Bump version

20 months agoFix Union type deserialization (#77)
Jacob Quinn [Wed, 2 Dec 2020 06:21:51 +0000 (23:21 -0700)] 
Fix Union type deserialization (#77)

* Fix Union type deserialization

Fixes #76. I think this was just a relic of old code from early work on
the package, but `juliaeltype` is meant to return "julia" types, not
arrow types.

* remove unintended change

20 months agoBump version v1.0.2
Jacob Quinn [Sat, 28 Nov 2020 20:19:28 +0000 (13:19 -0700)] 
Bump version

20 months agoFinish support for automatic custom struct deserialization (#73)
Jacob Quinn [Sat, 28 Nov 2020 20:18:27 +0000 (13:18 -0700)] 
Finish support for automatic custom struct deserialization (#73)

* Finish support for automatic custom struct deserialization

As pointed out on a slack post, we were supporting automatic custom
struct _serialization_, but not deserialization; the custom structs were
just deserialized as `NamedTuple`s. In this PR, I propose using the
custom extension type machinery to ensure custom structs can be
deserialized. Currently this will all happend automatically for the
user, but I'd like to update the documentation around how users should
approach using arrow for custom types, because they _should_ get in the
habit of calling `ArrowTypes.registertype!` to ensure their serialized
custom struct can always be deserialized. For example, if a user
serializes and deserialized a custom struct in the same Julia session,
it will currently "just work", but if the custom struct column is
serialized in a session, then deserialized in a new session, where the
type hasn't been defined or registered, the column will be deserialized
as `NamedTuple`.

* remove unnecessary definition

* Switch CI to github actions and update docs for custom structs

* Update CI

20 months agoReword error message when input file doesn't exist; fixes #71
Jacob Quinn [Sun, 22 Nov 2020 05:50:38 +0000 (22:50 -0700)] 
Reword error message when input file doesn't exist; fixes #71

20 months agoAdd custom extension type nullability test
Jacob Quinn [Fri, 20 Nov 2020 04:38:15 +0000 (21:38 -0700)] 
Add custom extension type nullability test

20 months agoBump version v1.0.1
Jacob Quinn [Thu, 19 Nov 2020 17:37:34 +0000 (10:37 -0700)] 
Bump version

20 months agoCheck field nullability for custom extension types (#69)
Jacob Quinn [Thu, 19 Nov 2020 17:36:57 +0000 (10:36 -0700)] 
Check field nullability for custom extension types (#69)

For custom extension types (currently automatically supported for `Char`
and `Symbol` types), we were failing to take into account whether the
field was nullable or not; this led to the case where a column might be
`['a', missing]`, but when deserializing, the column type was just
`Char` instead of `Union{Char, Missing}`. The fix is to enhance the
`ArrowTypes.extensiontype` function to also take the `field` argument
and check the nullability before returning.

20 months agoUpdate Project.toml v1.0.0
Jacob Quinn [Thu, 19 Nov 2020 06:51:53 +0000 (23:51 -0700)] 
Update Project.toml

20 months agoUpdate README.md
Jacob Quinn [Thu, 19 Nov 2020 06:51:19 +0000 (23:51 -0700)] 
Update README.md

20 months agoAuto-convert DateTime to arrow Timestamp instead of millisecond Date; left over bug...
Jacob Quinn [Thu, 19 Nov 2020 06:50:09 +0000 (23:50 -0700)] 
Auto-convert DateTime to arrow Timestamp instead of millisecond Date; left over bug from when we switched to fully supporting Timestamps (#66)

20 months agoAdd validity check for columns with different lengths; fixes #60 (#65)
Jacob Quinn [Thu, 19 Nov 2020 06:22:47 +0000 (23:22 -0700)] 
Add validity check for columns with different lengths; fixes #60 (#65)

20 months agofixed docs link (#64)
ExpandingMan [Wed, 18 Nov 2020 06:25:25 +0000 (01:25 -0500)] 
fixed docs link (#64)

20 months agoget documentation going (#62)
ExpandingMan [Mon, 16 Nov 2020 23:19:44 +0000 (18:19 -0500)] 
get documentation going (#62)

* get documentation going

* fixed site name

21 months agoCreate TagBot.yml
Jacob Quinn [Tue, 10 Nov 2020 06:08:54 +0000 (23:08 -0700)] 
Create TagBot.yml

21 months agoBump version v0.4.1
Jacob Quinn [Wed, 4 Nov 2020 00:23:59 +0000 (17:23 -0700)] 
Bump version

21 months agoSeveral fixes for writing large Arrow tables (#57)
Jacob Quinn [Wed, 4 Nov 2020 00:23:25 +0000 (17:23 -0700)] 
Several fixes for writing large Arrow tables (#57)

* Switch FlatBuffer Array type to use Int64 for byte position

Fixes #56. The issue was the underlying flatbuffer array type was using
an `UInt32` for the byte position where the flatbuffer array was
located; in super large files, this overflowed. As this Array field is a
Julia-side controlled type, we can easily switch to an Int64 to avoid
this issue all together.

* A few optimizations when writing

The bitpack encoding algorithm was allocating, which caused very large
tables to slow down considerably with so much memory recycling.
Rewriting it to avoid allocations leads to drastically fewer allocations
and much faster writing performance. For non-optimized array writing, we
also switch to writing to a buffer first to avoid hitting the global IO
lock too much, which can also hurt performance on large files.

* A few fixes for dictionary encoding writing

Just a few minor cleanups to ensure dictionary encoding types are
consistent, and that variable names work correctly between writing
first-time dictionary encodings and deltas.

* a few fixes

21 months agoAdd TimeZones compat v0.4.0
Jacob Quinn [Wed, 28 Oct 2020 15:03:29 +0000 (09:03 -0600)] 
Add TimeZones compat

21 months agoBump version
Jacob Quinn [Wed, 28 Oct 2020 14:44:25 +0000 (08:44 -0600)] 
Bump version

21 months agoCompute and set our PooledArray ref type manually
Jacob Quinn [Wed, 28 Oct 2020 07:11:20 +0000 (01:11 -0600)] 
Compute and set our PooledArray ref type manually

Should fix #52. The issue here is a little tricky, and I'm not sure
we're 100% doing things correct yet. Part of the problem, however, is
that when a user requests a column to be `DictEncode`-ed, we were just
calling `PooledArray(x)` to do the pooling for us, but PooledArrays uses
unsigned integer types as the ref type by default. The arrow format
encourages the use of *signed* integers, however, so when we were
serializing the *type* of the dict-encoded indices, we serialized the
*signed* version, even if the indices were unsigned. That's bad because
the indices may have "fit" in the unsigned type domain (like UInt8), but
not been valid in the signed domain (like 129 for Int8). So one change
made here is we don't auto-convert to the signed type, we just used
whatever the indices type is. The second change, to try and follow what
the arrow format encourages, is we'll compute our own ref type using the
`encodingtype` function, which produces a signed integer type, and pass
that to `PooledArray`.

21 months agoCheck if input file is valid before reading arrow data
Jacob Quinn [Wed, 28 Oct 2020 07:08:25 +0000 (01:08 -0600)] 
Check if input file is valid before reading arrow data

Fixes #49.

21 months agoEnsure any AbstractString is serialized correctly
Jacob Quinn [Wed, 28 Oct 2020 06:49:08 +0000 (00:49 -0600)] 
Ensure any AbstractString is serialized correctly

Fixes #53. The issue here is we had a couple of spots where `String` was
hard-coded instead of checking if a type was `<: AbstractString`. This
lead to the original issue in #53 where `SubString{String}` was
serialized as "binary" instead of as a string.

21 months agoFix travis docs job
Jacob Quinn [Wed, 28 Oct 2020 06:35:37 +0000 (00:35 -0600)] 
Fix travis docs job

21 months agoDocs update (#54)
Jacob Quinn [Wed, 28 Oct 2020 06:31:19 +0000 (00:31 -0600)] 
Docs update (#54)

* Big round of doc updates

* docs infra

* fix travis

21 months agoAdd TimeZones dependency for auto-converting Timestamp (#50)
Jacob Quinn [Mon, 26 Oct 2020 15:21:02 +0000 (09:21 -0600)] 
Add TimeZones dependency for auto-converting Timestamp (#50)

Implements #17. We now convert all Timestamp objects to ZonedDateTime
via auto-conversion (can be turned off by `convert=false`). The one
piece of awkwardness here is that it is currently assumed that with a
`Vector{ZonedDateTime}`, it is assumed that each element will have the
same timezone. Probably ok in practice, but frankly it'd be nicer if
there was a `ZonedDateTime` type that could be parameterized by the
timezone itself so that could be enforced via type parameter.

21 months agoPrevent infinite loop while writing on CategoricalArrays (#44)
Jacob Quinn [Fri, 23 Oct 2020 20:06:31 +0000 (14:06 -0600)] 
Prevent infinite loop while writing on CategoricalArrays (#44)

Supporting CategoricalArrays is a bit tricky. Ideally, we could use the
same interface as PooledArrays and just rely on `DataAPI.refarray` and
`DataAPI.refpool`, but alas, a `CategoricalArray` returns a
`CategoricalRefPool` from `DataAPI.refpool`, with `CategoricalValue`
elements. The core issue comes when we try to serialize the pool, which
is a recursive process: recursive until we reach a known "leaf" type, at
which point the recursion stops. Unfortunately, a `CategoricalValue`
isn't a known leaf type, so it's treated as a `StructType`, where each
of its fields are serialized. One of the fields is the
`CategoricalRefPool`, so we get stuck in a never-ending recursive loop
serializing `CategoricalValue`s and `CategoricalRefPool`s.

This PR proposes a quick hack where we check the `DataType` name for
`:CategoricalRefPool` or `:CategoricalArray` and if so, just unwrap the
values so the recursion will be broken. It's obviously a little hacky,
but also avoids taking on the always-problematic CategoricalArrays
dependency.

21 months agoUse threaded tasks to read record batches in parallel for Arrow.Table (#47)
Jacob Quinn [Fri, 23 Oct 2020 06:58:06 +0000 (00:58 -0600)] 
Use threaded tasks to read record batches in parallel for Arrow.Table (#47)

21 months agoPass "ArrowVector" through arrowvector calls (#46)
Jacob Quinn [Fri, 23 Oct 2020 04:20:07 +0000 (22:20 -0600)] 
Pass "ArrowVector" through arrowvector calls (#46)

If users construct `ArrowVector` types themselves, or read, then write,
we can be a bit more efficient by not making copies.

21 months agoRefactor nested dict encoding and isdelta dictionary batch support (#43)
Jacob Quinn [Thu, 22 Oct 2020 13:34:04 +0000 (07:34 -0600)] 
Refactor nested dict encoding and isdelta dictionary batch support (#43)

Fixes #32 among other issues. Turns out the probably-rare-in-practice
data race mentioned in #32 was the least of the worries. While digging
into things, I realized we weren't doing isDelta dictionary batches
right at all. In particular, we were basically writing each record
batch/dictionary batch independent of each other, but using the same
dictionary batch ids. We didn't have tests failures because we weren't
testing isDelta batches anyway :P.

In this PR, everything is cleaned up quite a bit. We now generate a
dictionary encoding id based on the column index, nesting level, and
field index (in the case of structs and unions). This allows us to
re-use the same constructed dict encodings from batch to batch, and also
allows us to support the use-case of re-using a single dict encoding
across multiple columns if so desired (user would just pass in their own
`DictEncode` column pointing to the same id). We also avoid race
conditions by putting a lock around dict encodings so different threads
writing will have to take turns.

21 months agoAdded a Note about Large Numbers of Columns (#42)
TheCedarPrince [Sun, 18 Oct 2020 03:59:11 +0000 (23:59 -0400)] 
Added a Note about Large Numbers of Columns (#42)

* Added information about large numbers of columns

* Update README.md

Co-authored-by: Jacob Quinn <quinn.jacobd@gmail.com>
21 months agoIntroduce BoolVector for Bool column types (#40)
Jacob Quinn [Wed, 14 Oct 2020 19:32:50 +0000 (13:32 -0600)] 
Introduce BoolVector for Bool column types (#40)

Fixes #38. From back in the original feather days, I remember that bool
columns were always bitpacked. Unfortunately, the arrow spec doesn't
really point this bitpacking out very obviously (it's mentioned in
passing as a possibility). This PR introduces a new BoolVector type and
corresponding `ArrowTypes.BoolType` that ensures Bool columns will be
written bitpacked, and read similarly.

21 months agoRearrange code by array type (#39)
Jacob Quinn [Wed, 14 Oct 2020 14:19:17 +0000 (08:19 -0600)] 
Rearrange code by array type (#39)

Code for the various array types was a little all over the place. This
PR consolidates arraytype-specific code into new per-arraytype files.
This also simplifies a few things I noticed reviewing the code: removing
unnecessary utils, stop passing eltypes to arraytype-specific
`arrowvector` methods, reuse `ToList` for `MapType` and get rid of
`ToMap`, and clarify a few of the ArrowTypes interfaces. This should
simplify things a bit for adding support for bitpacked Bool arrays and
supporting CategoricalArrays.

22 months agoSwitch license to apache-2 in preparation for code donation (#36)
Jacob Quinn [Thu, 8 Oct 2020 04:12:06 +0000 (22:12 -0600)] 
Switch license to apache-2 in preparation for code donation (#36)

22 months agoAllow specifying custom alignment for buffer writing padding (#35)
Jacob Quinn [Tue, 6 Oct 2020 15:50:58 +0000 (09:50 -0600)] 
Allow specifying custom alignment for buffer writing padding (#35)

* Allow specifying custom alignment for buffer writing padding

Implements #31. Pretty easy, just have to thread the new `alignment`
keyword down everywhere.

* Update docs and add test

22 months agoAllow passing custom lz4 & zstd compressors to Arrow.write (#34)
Jacob Quinn [Tue, 6 Oct 2020 07:20:40 +0000 (01:20 -0600)] 
Allow passing custom lz4 & zstd compressors to Arrow.write (#34)

* Allow passing custom lz4 & zstd compressors to Arrow.write

* update docs

22 months agoTypo fix in README (#33)
John Myles White [Mon, 5 Oct 2020 02:45:19 +0000 (22:45 -0400)] 
Typo fix in README (#33)

22 months agocompat bounds for codecs v0.3.0
Jacob Quinn [Sat, 3 Oct 2020 22:05:29 +0000 (16:05 -0600)] 
compat bounds for codecs

22 months agoFix docs
Jacob Quinn [Sat, 3 Oct 2020 21:38:29 +0000 (15:38 -0600)] 
Fix docs

22 months agoTry to fix travis badge again
Jacob Quinn [Sat, 3 Oct 2020 21:37:18 +0000 (15:37 -0600)] 
Try to fix travis badge again

22 months agoUpdate travis badge
Jacob Quinn [Sat, 3 Oct 2020 21:36:21 +0000 (15:36 -0600)] 
Update travis badge

22 months agoUpdate docs
Jacob Quinn [Sat, 3 Oct 2020 21:34:41 +0000 (15:34 -0600)] 
Update docs

22 months agoClean up versions
Jacob Quinn [Sat, 3 Oct 2020 17:22:25 +0000 (11:22 -0600)] 
Clean up versions

22 months agoMinor cleanup
Jacob Quinn [Sat, 3 Oct 2020 07:48:51 +0000 (01:48 -0600)] 
Minor cleanup

22 months agoVarious fixes and mechanics to test round-tripping w/ pyarrow (#30)
Jacob Quinn [Fri, 2 Oct 2020 23:29:56 +0000 (17:29 -0600)] 
Various fixes and mechanics to test round-tripping w/ pyarrow (#30)

This doesn't actually hook up pyarrow roundtrip testing, but you can run
the pyarrowrountrip.jl test file if you have python3 and pyarrow
installed locally (along with PyCall.jl on the julia side). It then
tests most of our testtables.jl testing tables by writing them in julia,
passing written bytes to pyarrow, reading them via pyarrow, writing them
back out, then reading in on julia side. The fixes were pretty minor,
but feels much better knowing all these exmaples work well (and will be
easy to test in the future).

22 months agoCleanup and actually run integration tests with testing suite (#29)
Jacob Quinn [Fri, 2 Oct 2020 04:09:12 +0000 (22:09 -0600)] 
Cleanup and actually run integration tests with testing suite (#29)

* Cleanup and actually run integration tests with testing suite

The initial integration tests were throw together before the latest big
refactoring, and I didn't bother to see if they worked or not before
merging since we weren't actually running the tests anyway. Here,
ArrowJSON module is cleaned up and the integration tests are actually
run to ensure everything passes/works.

* fix test deps

22 months agoAdd Arrow.Stream struct for iterating record bactches (#28)
Jacob Quinn [Thu, 1 Oct 2020 18:20:01 +0000 (12:20 -0600)] 
Add Arrow.Stream struct for iterating record bactches (#28)

* Add Arrow.Stream struct for iterating record bactches

Implements #23. `Arrow.Stream` will basically take the same arguments as
`Arrow.Table`, but upon construction, will only parse the first ipc
message which must be a schema message. It then returns the
`Arrow.Stream` object, which itself can be iterated, with each iteration
producing a `Arrow.Table` consisting of the columns of a record batch
message. This allows defining `Tables.partitions` on `Arrow.Stream`
which will allow other Tables.jl sinks to process record batches as
partitions when operating on data.

* fix test

22 months agoBig refactoring to simplify code and implement more parts of the spec (#26)
Jacob Quinn [Thu, 1 Oct 2020 05:03:14 +0000 (23:03 -0600)] 
Big refactoring to simplify code and implement more parts of the spec (#26)

* Big refactoring to simplify code and implement more parts of the spec

In particular this PR:
  * Changes the flow of writing so that input columns are converted to
  their "arrow" equivalent, most of the time lazily, so that the actual
  writing is much simpler and just deals with each array type
  * Introduces an ArrowTypes module that defines the ArrowType trait,
  which types can overload to signal what kind of arrow type they should
  be converted to. This isn't super fleshed out quite yet as we need to
  figure out the acutal requirements for the different arrow types, but
  it's a start
  * Support reading/writing compressed arrow buffers automatically
  (reading) and via keyword arg (writing, `compress=:lz4` or
  `compress=:zstd`
  * support nested dict encoding (fixes #15)
  * fixes #24; not exactly sure what the issue was, but it doesn't
  happen on this branch
  * reorganizes tests so that for each kind of "table", we do IPC test,
  compressed buffers test, and file test

22 months agoSupport large list type writing (#22)
Jacob Quinn [Thu, 17 Sep 2020 15:18:52 +0000 (09:18 -0600)] 
Support large list type writing (#22)

* Support large list type writing

Implements #14. It took a few different tries, but it turns out this
isn't too bad to support. Basically, we check incoming columns if they
need to be large list types, and wrap them in a new `LargeList{T}` type,
which the writing methods can intercept to write the type, fieldnodes,
and buffers out correctly with.

* fix tests

22 months agoImplement optimized copy for Primitive/DictEncoded ArrowVector types (#21)
Jacob Quinn [Tue, 15 Sep 2020 22:58:36 +0000 (16:58 -0600)] 
Implement optimized copy for Primitive/DictEncoded ArrowVector types (#21)

* Implement optimized copy for Primitive/DictEncoded ArrowVector types

Closes #19. If a Primitive array type doesn't have missing values, we
can optimize the copy by just copying the underlying storage array. For
DictEncoded, we take a dependency on PooledArrays to convert the compact
DictEncoded form to the equally compact PooledArray form. The other
arrow array types are left as-is, since the default copy method is
good/performance enough.

22 months agoSupport custom metadata for schema and columns (#20)
Jacob Quinn [Tue, 15 Sep 2020 15:16:57 +0000 (09:16 -0600)] 
Support custom metadata for schema and columns (#20)

Closes #13. This PR adds two new functions: `Arrow.getmetadata(x)` and
`Arrow.setmetadata!(x, ::Dict{String, String})`, which allows, rather
obviously, setting metadata for an arbitrary object and then retrieving
that metadata. By utilizing these functions, users can get/set custom
metadata that is serialized in the arrow format at the schema level and
field (column) level. More specifically, to set arrow schema custom
metadata, a user would call `Arrow.setmetadata!(tbl, meta)` on their
table object `tbl`. To retrive arrow schema custom metadata, one can
call `tbl = Arrow.Table(...); meta = Arrow.getmetadata(tbl)`. Similarly
for column/field-level metadata, one can call `Arrow.setmetadata!(col,
colmeta)` to cause custom metadata to be serialized in the arrow
message, and call `Arrow.getmetadata(tbl.colX)` to retrive custom
metadata for a specific column in an `Arrow.Table`.

Note that technically the arrow `Message` and `Footer` objects also
allow setting custom metadata, but those are not addressed at all in
this PR since they seem to be less useful/urgent.

22 months agoImplement json apache arrow testing integration code (#18)
Jacob Quinn [Sun, 13 Sep 2020 05:03:41 +0000 (23:03 -0600)] 
Implement json apache arrow testing integration code (#18)

* Implement json apache arrow testing integration code

* Fix tests

* Try to fix pre-1.3

22 months agoCheck if column implements DataAPI.refarray for dict encoding (#12)
Jacob Quinn [Wed, 2 Sep 2020 18:26:16 +0000 (12:26 -0600)] 
Check if column implements DataAPI.refarray for dict encoding (#12)

* Check if column implements DataAPI.refarray for dict encoding

Fixes #2. The `DataAPI.refarray` and `DataAPI.refpool` are meant to
allow custom array types to signal that they internally store integer
ref indices along with a value pool. This is a great integration with
the arrow format, which has a specific "dict encoded" format that
follows this same format (integer indices w/ value pool). So here we
leverage that by checking if an incoming column implements the interface
and, if so, signal that it should be dict encoded in the arrow format.

* Remove @show and add PooledArrays as test dep

* fix tests

* Fix tests

22 months agoAllow initial support for custom extension types (#11)
Jacob Quinn [Tue, 1 Sep 2020 15:32:19 +0000 (09:32 -0600)] 
Allow initial support for custom extension types (#11)

* Allow initial support for custom extension types

Fixes #10. This PR is large mainly because it adds fairly generic
support for custom field metadata. We then use that support to add
custom type extension for Symbol/Char vectors. We could perhaps factor
this a bit more to make it even more generic for custom types, but I
think this gets us pretty darn far.

* Fix dict encoded

22 months agoUpdate README.md (#9)
Graham Stark [Sun, 30 Aug 2020 01:16:20 +0000 (02:16 +0100)] 
Update README.md (#9)

I think this is the link to the memory layout doc.

22 months agoGet map working & tested (#8)
Jacob Quinn [Sat, 29 Aug 2020 15:55:50 +0000 (09:55 -0600)] 
Get map working & tested (#8)

* Get map working & tested

22 months agoremove docs for now
Jacob Quinn [Fri, 28 Aug 2020 22:59:31 +0000 (16:59 -0600)] 
remove docs for now

22 months agowork around weird 32-bit bug
Jacob Quinn [Fri, 28 Aug 2020 22:49:10 +0000 (16:49 -0600)] 
work around weird 32-bit bug

22 months agofix ambiguity
Jacob Quinn [Fri, 28 Aug 2020 22:05:11 +0000 (16:05 -0600)] 
fix ambiguity

22 months agofix 32-bit
Jacob Quinn [Fri, 28 Aug 2020 21:54:16 +0000 (15:54 -0600)] 
fix 32-bit

22 months agofix 32-bit
Jacob Quinn [Fri, 28 Aug 2020 21:48:49 +0000 (15:48 -0600)] 
fix 32-bit

22 months agofix for 32-bit
Jacob Quinn [Fri, 28 Aug 2020 21:45:36 +0000 (15:45 -0600)] 
fix for 32-bit

22 months agofix
Jacob Quinn [Fri, 28 Aug 2020 21:39:50 +0000 (15:39 -0600)] 
fix

22 months agofixes for compat
Jacob Quinn [Fri, 28 Aug 2020 21:31:37 +0000 (15:31 -0600)] 
fixes for compat

22 months agoCompat for tables
Jacob Quinn [Fri, 28 Aug 2020 21:09:30 +0000 (15:09 -0600)] 
Compat for tables

22 months ago1.0 compat
Jacob Quinn [Fri, 28 Aug 2020 21:03:09 +0000 (15:03 -0600)] 
1.0 compat

22 months agoFix a few things
Jacob Quinn [Fri, 28 Aug 2020 21:01:52 +0000 (15:01 -0600)] 
Fix a few things

22 months agotake out log
Jacob Quinn [Fri, 28 Aug 2020 20:54:55 +0000 (14:54 -0600)] 
take out log

22 months agoAuto-convert TimeTypes to/from arrow time types
Jacob Quinn [Fri, 28 Aug 2020 20:47:52 +0000 (14:47 -0600)] 
Auto-convert TimeTypes to/from arrow time types

These are pretty cheap conversions and makes the Date, Time, Timestamp,
and Duration arrow types must more friendly to work with. I'm not sure
Interval has a real clear mapping, so it's left out for now (it also
mentions that Interval isn't even required for full arrow
compatibility). The last arrow type that doesn't currently map to a
native Julia type is Decimal. That will take a bit more digging because
the spec isn't very detailed on it's exact representation. I plan on
asking the arrow mailing list for more details and we can do that later.

22 months agoUpdate readme w/ basic usage
Jacob Quinn [Fri, 28 Aug 2020 13:03:57 +0000 (07:03 -0600)] 
Update readme w/ basic usage

22 months agoUpdate readme w/ basic usage
Jacob Quinn [Fri, 28 Aug 2020 13:01:51 +0000 (07:01 -0600)] 
Update readme w/ basic usage

22 months agoPure Julia implementation of apache arrow format
Jacob Quinn [Fri, 28 Aug 2020 12:56:31 +0000 (06:56 -0600)] 
Pure Julia implementation of apache arrow format

22 months agodelete hidden files
Jacob Quinn [Sat, 3 Oct 2020 08:03:50 +0000 (02:03 -0600)] 
delete hidden files

22 months agodelete old files
Jacob Quinn [Sat, 3 Oct 2020 07:54:09 +0000 (01:54 -0600)] 
delete old files