From 44f401a6f96a4d599bf23de772e2b0c96294606a Mon Sep 17 00:00:00 2001 From: Adam Lefevre Date: Mon, 8 Apr 2024 09:29:25 -0500 Subject: [PATCH 01/11] Add decoders and PostgresToArrowDecoder --- core/Cargo.toml | 1 + core/src/decoders.rs | 761 ++++++++++++++++++++++++++++++++++++++++++ core/src/encoders.rs | 4 +- core/src/error.rs | 39 ++- core/src/lib.rs | 260 ++++++++++++++- core/src/pg_schema.rs | 203 ++++++++++- 6 files changed, 1262 insertions(+), 6 deletions(-) create mode 100644 core/src/decoders.rs diff --git a/core/Cargo.toml b/core/Cargo.toml index 2e6d606..e458a8a 100644 --- a/core/Cargo.toml +++ b/core/Cargo.toml @@ -14,6 +14,7 @@ authors = ["Adrian Garcia Badaracco "] [dependencies] bytes = "^1.4.0" arrow-schema = ">=46.0.0" +arrow = ">=51.0.0" enum_dispatch = "0.3.11" anyhow = "1.0.70" thiserror = "1.0.40" diff --git a/core/src/decoders.rs b/core/src/decoders.rs new file mode 100644 index 0000000..f8dcd93 --- /dev/null +++ b/core/src/decoders.rs @@ -0,0 +1,761 @@ +#![allow(clippy::redundant_closure_call)] + +use arrow_array::{self, ArrayRef}; +use std::fmt::Debug; +use std::sync::Arc; +use crate::encoders::{PG_BASE_DATE_OFFSET, PG_BASE_TIMESTAMP_OFFSET_US}; +use arrow_array::types::GenericBinaryType; +use arrow_array::builder::GenericByteBuilder; +use arrow_array::{ + BooleanArray, Date32Array, DurationMicrosecondArray, Float32Array, Float64Array, + GenericStringArray, Int16Array, Int32Array, Int64Array, + Time64MicrosecondArray, TimestampMicrosecondArray +}; + +use crate::error::ErrorKind; +use crate::pg_schema::{PostgresSchema, PostgresType}; + +pub(crate) struct ConsumableBuf<'a> { + inner: &'a [u8], + consumed: usize, +} + +impl Debug for ConsumableBuf<'_> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", &self.inner[self.consumed..]) + } +} + +// const used for stringifying postgres decimals +const DEC_DIGITS: i16 = 4; +// const used for determining sign of numeric +const NUMERIC_NEG: i16 = 0x4000; + +impl ConsumableBuf<'_> { + pub fn new(inner: &'_ [u8]) -> ConsumableBuf<'_> { + ConsumableBuf { inner, consumed: 0 } + } + + pub fn consume_into_u32(&mut self) -> Result { + if self.consumed + 4 > self.inner.len() { + return Err(ErrorKind::DataSize { + found: self.inner.len() - self.consumed, + expected: 4, + }); + } + let res = u32::from_be_bytes( + self.inner[self.consumed..self.consumed + 4] + .try_into().unwrap() + ); + self.consumed += 4; + Ok(res) + } + + pub fn consume_into_u16(&mut self) -> Result { + if self.consumed + 2 > self.inner.len() { + return Err(ErrorKind::DataSize { + found: self.inner.len() - self.consumed, + expected: 2, + }); + } + let res = u16::from_be_bytes( + self.inner[self.consumed..self.consumed + 2] + .try_into().unwrap() + ); + self.consumed += 2; + Ok(res) + } + + pub fn consume_into_vec_n(&mut self, n: usize) -> Result, ErrorKind> { + if self.consumed + n > self.inner.len() { + return Err(ErrorKind::DataSize { + found: self.inner.len() - self.consumed, + expected: n, + }); + } + let data = self.inner[self.consumed..self.consumed + n].to_vec(); + self.consumed += n; + if data.len() != n { + return Err(ErrorKind::DataSize { + found: data.len(), + expected: n, + }); + } + Ok(data) + } + + pub fn remaining(&self) -> usize { + self.inner.len() - self.consumed + } + + pub fn consumed(&self) -> usize { + self.consumed + } + + pub fn swallow(&mut self, n: usize) { + self.consumed += n; + } +} + +pub(crate) trait Decode { + fn decode(&mut self, buf: &mut ConsumableBuf) -> Result<(), ErrorKind>; + fn finish(&mut self, column_len: usize) -> Result; + fn column_len(&self) -> usize; + fn name(&self) -> &str; +} + +macro_rules! impl_decode { + ($struct_name:ident, $size:expr, $transform:expr, $array_kind:ident) => { + impl Decode for $struct_name { + fn decode(&mut self, buf: &mut ConsumableBuf<'_>) -> Result<(), ErrorKind> { + let field_size = buf.consume_into_u32()?; + if field_size == u32::MAX { + self.arr.push(None); + return Ok(()); + } + if field_size != $size { + return Err(ErrorKind::DataSize { + found: field_size as usize, + expected: $size, + }); + } + + + let data = buf.consume_into_vec_n(field_size as usize)?; + // Unwrap is safe here because have checked the field size is the expected size + // above + + let value = $transform(data.try_into().unwrap()); + self.arr.push(Some(value)); + + Ok(()) + } + + fn name(&self) -> &str { + &self.name + } + + fn column_len(&self) -> usize { + self.arr.len() + } + + fn finish(&mut self, column_len: usize) -> Result { + let mut data = std::mem::take(&mut self.arr); + data.resize(column_len, None); + let array = Arc::new($array_kind::from(data)); + Ok(array as ArrayRef) + } + } + }; +} + +macro_rules! impl_decode_fallible { + ($struct_name:ident, $size:expr, $transform:expr, $array_kind:ident) => { + impl Decode for $struct_name { + fn decode(&mut self, buf: &mut ConsumableBuf<'_>) -> Result<(), ErrorKind> { + let field_size = buf.consume_into_u32()?; + + if field_size == u32::MAX { + self.arr.push(None); + return Ok(()); + } + + if field_size != $size { + return Err(ErrorKind::DataSize { + found: field_size as usize, + expected: $size, + }); + } + + let data = buf.consume_into_vec_n(field_size as usize)?; + // Unwrap is safe here because have checked the field size is the expected size + // above + match $transform(data.try_into().unwrap()) { + Ok(v) => self.arr.push(Some(v)), + Err(e) => { + // If the error is a decode error, return a decode error with the name of the field + return match e { + ErrorKind::Decode { reason, .. } => { + return Err(ErrorKind::Decode { + reason, + name: self.name.to_string(), + }) + } + _ => Err(e), + }; + } + }; + + Ok(()) + } + + fn name(&self) -> &str { + &self.name + } + + fn column_len(&self) -> usize { + self.arr.len() + } + + fn finish(&mut self, column_len: usize) -> Result { + let mut data = std::mem::take(&mut self.arr); + data.resize(column_len, None); + let array = Arc::new($array_kind::from(data)); + Ok(array as ArrayRef) + } + } + }; +} + +macro_rules! impl_decode_variable_size { + ($struct_name:ident, $transform:expr, $extra_bytes:expr, $array_kind:ident, $offset_size:ident) => { + impl Decode for $struct_name { + fn decode(&mut self, buf: &mut ConsumableBuf<'_>) -> Result<(), ErrorKind> { + let field_size = buf.consume_into_u32()?; + if field_size == u32::MAX { + self.arr.push(None); + return Ok(()); + } + + if field_size > buf.remaining() as u32 { + return Err(ErrorKind::DataSize { + found: buf.remaining() as usize, + expected: field_size as usize, + }); + } + + // Consume and any extra data that is not part of the field + // This is needed for example on jsonb fields where the first + // byte is the version number. This is more efficient than + // using remove in the transform function or creating a new + // vec from a slice of the data passed into it. + buf.swallow($extra_bytes); + + let data = buf.consume_into_vec_n(field_size as usize)?; + match $transform(data.try_into().unwrap()) { + Ok(v) => self.arr.push(Some(v)), + Err(e) => { + // If the error is a decode error, return a decode error with the name of the field + return match e { + ErrorKind::Decode { reason, .. } => { + return Err(ErrorKind::Decode { + reason, + name: self.name.to_string(), + }) + } + _ => Err(e), + }; + } + }; + + Ok(()) + } + + fn name(&self) -> &str { + &self.name + } + + fn column_len(&self) -> usize { + self.arr.len() + } + + fn finish(&mut self, column_len: usize) -> Result { + let mut data = std::mem::take(&mut self.arr); + data.resize(column_len, None); + let array = Arc::new($array_kind::<$offset_size>::from(data)); + Ok(array as ArrayRef) + } + } + }; +} + +pub struct BooleanDecoder { + name: String, + arr: Vec>, +} + +impl_decode!(BooleanDecoder, 1, |b: [u8; 1]| b[0] == 1, BooleanArray); + +pub struct Int16Decoder { + name: String, + arr: Vec>, +} + +impl_decode!(Int16Decoder, 2, i16::from_be_bytes, Int16Array); + +pub struct Int32Decoder { + name: String, + arr: Vec>, +} + +impl_decode!(Int32Decoder, 4, i32::from_be_bytes, Int32Array); + +pub struct Int64Decoder { + name: String, + arr: Vec>, +} + +impl_decode!(Int64Decoder, 8, i64::from_be_bytes, Int64Array); + +pub struct Float32Decoder { + name: String, + arr: Vec>, +} + +impl_decode!(Float32Decoder, 4, f32::from_be_bytes, Float32Array); + +pub struct Float64Decoder { + name: String, + arr: Vec>, +} + +impl_decode!(Float64Decoder, 8, f64::from_be_bytes, Float64Array); + +/// Convert Postgres timestamps (microseconds since 2000-01-01) to Arrow timestamps (mircroseconds since 1970-01-01) +#[inline(always)] +fn convert_pg_timestamp_to_arrow_timestamp_microseconds( + timestamp_us: i64, +) -> Result { + // adjust the timestamp from microseconds since 2000-01-01 to microseconds since 1970-01-01 checking for overflows and underflow + println!("timestamp_us: {}", timestamp_us); + timestamp_us + .checked_add(PG_BASE_TIMESTAMP_OFFSET_US) + .ok_or_else(|| ErrorKind::Decode { + reason: "Overflow converting microseconds since 2000-01-01 (Postgres) to microseconds since 1970-01-01 (Arrow)".to_string(), + name: "".to_string(), + }) +} + +pub struct TimestampMicrosecondDecoder { + name: String, + arr: Vec>, +} + +impl_decode_fallible!( + TimestampMicrosecondDecoder, + 8, + |b| { + let timestamp_us = i64::from_be_bytes(b); + convert_pg_timestamp_to_arrow_timestamp_microseconds(timestamp_us) + }, + TimestampMicrosecondArray +); + +/// Convert Postgres dates (days since 2000-01-01) to Arrow dates (days since 1970-01-01) +#[inline(always)] +fn convert_pg_date_to_arrow_date(date: i32) -> Result { + date.checked_add(PG_BASE_DATE_OFFSET).ok_or_else(|| ErrorKind::Decode { + reason: "Overflow converting days since 2000-01-01 (Postgres) to days since 1970-01-01 (Arrow)".to_string(), + name: "".to_string(), + }) +} + +pub struct Date32Decoder { + name: String, + arr: Vec>, +} + +impl_decode_fallible!( + Date32Decoder, + 4, + |b| { + let date = i32::from_be_bytes(b); + convert_pg_date_to_arrow_date(date) + }, + Date32Array +); + +pub struct Time64MicrosecondDecoder { + name: String, + arr: Vec>, +} + +impl_decode!( + Time64MicrosecondDecoder, + 8, + i64::from_be_bytes, + Time64MicrosecondArray +); + +/// Convert Postgres durations to Arrow durations (milliseconds) +fn convert_pg_duration_to_arrow_duration( + duration_us: i64, + duration_days: i32, + duration_months: i32, +) -> Result { + let days = (duration_days as i64) + .checked_mul(24 * 60 * 60 * 1_000_000) + .ok_or_else(|| ErrorKind::Decode { + reason: "Overflow converting days to microseconds".to_string(), + name: "".to_string(), + })?; + let months = (duration_months as i64) + .checked_mul(30 * 24 * 60 * 60 * 1_000_000) + .ok_or_else(|| ErrorKind::Decode { + reason: "Overflow converting months to microseconds".to_string(), + name: "".to_string(), + })?; + + duration_us + .checked_add(days) + .ok_or_else(|| ErrorKind::Decode { + reason: "Overflow adding days in microseconds to duration microseconds".to_string(), + name: "".to_string(), + }) + .map(|v| { + v.checked_add(months).ok_or_else(|| ErrorKind::Decode { + reason: "Overflow adding months in microseconds to duration microseconds" + .to_string(), + name: "".to_string(), + }) + })? +} + +pub struct DurationMicrosecondDecoder { + name: String, + arr: Vec>, +} + +impl_decode_fallible!( + DurationMicrosecondDecoder, + 16, + |b: [u8; 16]| { + // Unwrap here since we know the exact size of the array we are passing + let duration_us = i64::from_be_bytes(b[..8].try_into().unwrap()); + let duration_days = i32::from_be_bytes(b[8..12].try_into().unwrap()); + let duration_months = i32::from_be_bytes(b[12..16].try_into().unwrap()); + convert_pg_duration_to_arrow_duration(duration_us, duration_days, duration_months) + }, + DurationMicrosecondArray +); + +pub struct StringDecoder { + name: String, + arr: Vec>, +} + +impl_decode_variable_size!( + StringDecoder, + |b: Vec| { + String::from_utf8(b).map_err(|_| ErrorKind::Decode { + reason: "Invalid UTF-8 string".to_string(), + name: "".to_string(), + }) + }, + 0, + GenericStringArray, + i64 +); + +pub struct BinaryDecoder { + name: String, + arr: Vec>>, +} + +impl Decode for BinaryDecoder { + fn decode(&mut self, buf: &mut ConsumableBuf<'_>) -> Result<(), ErrorKind> { + let field_size = buf.consume_into_u32()?; + if field_size == u32::MAX { + self.arr.push(None); + return Ok(()); + } + + let data = buf.consume_into_vec_n(field_size as usize)?; + self.arr.push(Some(data)); + + Ok(()) + } + + fn name(&self) -> &str { + &self.name + } + + fn column_len(&self) -> usize { + self.arr.len() + } + + fn finish(&mut self, column_len: usize) -> Result { + let mut data = std::mem::take(&mut self.arr); + data.resize(column_len, None); + + let mut builder: GenericByteBuilder> = GenericByteBuilder::new(); + for v in data { + match v { + Some(v) => builder.append_value(v), + None => builder.append_null(), + } + } + let array = Arc::new(builder.finish()); + Ok(array as ArrayRef) + } +} + +pub struct JsonbDecoder { + name: String, + arr: Vec>, +} + +impl_decode_variable_size!( + JsonbDecoder, + |b: Vec| { + String::from_utf8(b).map_err(|_| ErrorKind::Decode { + reason: "Invalid UTF-8 string".to_string(), + name: "".to_string(), + }) + }, + // Remove the first byte which is the version number + // https://www.postgresql.org/docs/13/datatype-json.html + 1, + GenericStringArray, + i64 +); + +/// Logic ported from src/backend/utils/adt/numeric.c:get_str_from_var +fn parse_pg_decimal_to_string(data: Vec) -> Result { + // Decimals will be decoded to strings since rust does not have a ubiquitos + // decimal type and arrow does not implment `From` for any of them. Arrow + // does have a Decimal128 array but its only accepts i128s as input + // TODO: Seems like there could be a fast path here for simpler numbers + let ndigits = i16::from_be_bytes(data[0..2].try_into().unwrap()); + let weight = i16::from_be_bytes(data[2..4].try_into().unwrap()); + let sign = i16::from_be_bytes(data[4..6].try_into().unwrap()); + let scale = i16::from_be_bytes(data[6..8].try_into().unwrap()); + let digits: Vec = data[8..8 + ndigits as usize].chunks(2).map(|c| i16::from_be_bytes(c.try_into().unwrap())).collect(); + + // the number of digits before the decimal place + let pre_decimal = (weight + 1) * DEC_DIGITS; + + // scale is the number digits after the decimal place. + // 2 is for a possible sign and decimal point + let str_len: usize = (pre_decimal + DEC_DIGITS + 2 + scale) as usize; + + // -1 because we dont need to account for the null terminator + let mut decimal: Vec = Vec::with_capacity(str_len - 1); + + // put a negative sign if the numeric is negative + if sign == NUMERIC_NEG { + decimal.push(b'-'); + } + + let mut digits_index = 0; + // If weight is less than 0 we have a fractional number. + // Put a 0 before the decimal. + if weight < 0 { + decimal.push(b'0'); + // Otherwise put digits in the decimal string by computing the value for each place in decimal + } else { + while digits_index <= weight { + let mut dig = if digits_index < ndigits { digits[digits_index as usize] } else { 0 }; + let mut putit = digits_index > 0; + + /* below unwraps too: + d1 = dig / 1000; + dig -= d1 * 1000; + putit |= (d1 > 0); + if (putit) + *cp++ = d1 + '0'; + d1 = dig / 100; + dig -= d1 * 100; + putit |= (d1 > 0); + if (putit) + *cp++ = d1 + '0'; + d1 = dig / 10; + dig -= d1 * 10; + putit |= (d1 > 0); + if (putit) + *cp++ = d1 + '0'; + *cp++ = dig + '0'; + */ + + let mut place = 1000; + while place > 1 { + let d1 = dig / place; + dig -= d1 * place; + putit |= d1 > 0; + if putit { decimal.push(d1 as u8 + b'0') } + place /= 10; + } + decimal.push(dig as u8 + b'0'); + digits_index += 1; + } + + // If scale is > 0 we have digits after the decimal point + if scale > 0 { + decimal.push(b'.'); + } + } + + let mut i = 0; + while i < scale { + let mut dig = if digits_index >= 0 && digits_index < ndigits { digits[digits_index as usize] } else { 0 }; + let mut place = 1000; + // Same as the loop above but no putit since all digits prior to the + // scale-TH digit are significant + while place > 1 { + let d1 = dig / place; + dig -= d1 * place; + decimal.push(d1 as u8 + b'0'); + place /= 10; + } + decimal.push(dig as u8 + b'0'); + i += 1; + } + + // unwrap will not fail here as we know ever value in our decimal vec is ascii; + Ok(String::from_utf8(decimal).unwrap()) +} + +pub struct DecimalDecoder { + name: String, + arr: Vec>, +} + +impl_decode_variable_size!( + DecimalDecoder, + parse_pg_decimal_to_string, + 0, + GenericStringArray, + i64 +); + + +// +pub enum Decoder { + Boolean(BooleanDecoder), + Int16(Int16Decoder), + Int32(Int32Decoder), + Int64(Int64Decoder), + Float32(Float32Decoder), + Float64(Float64Decoder), + Decimal(DecimalDecoder), + TimestampMicrosecond(TimestampMicrosecondDecoder), + Date32(Date32Decoder), + Time64Microsecond(Time64MicrosecondDecoder), + DurationMicrosecond(DurationMicrosecondDecoder), + String(StringDecoder), + Binary(BinaryDecoder), + Jsonb(JsonbDecoder), +} +// +impl Decoder { + pub fn new(schema: &PostgresSchema) -> Vec { + schema + .iter() + .map(|(name, column)| match column.data_type { + PostgresType::Bool => Decoder::Boolean(BooleanDecoder { + name: name.to_string(), + arr: vec![], + }), + PostgresType::Int2 => Decoder::Int16(Int16Decoder { + name: name.to_string(), + arr: vec![], + }), + PostgresType::Int4 => Decoder::Int32(Int32Decoder { + name: name.to_string(), + arr: vec![], + }), + PostgresType::Int8 => Decoder::Int64(Int64Decoder { + name: name.to_string(), + arr: vec![], + }), + PostgresType::Float4 => Decoder::Float32(Float32Decoder { + name: name.to_string(), + arr: vec![], + }), + PostgresType::Float8 => Decoder::Float64(Float64Decoder { + name: name.to_string(), + arr: vec![], + }), + PostgresType::Decimal => { + Decoder::Decimal(DecimalDecoder { name: name.to_string(), arr: vec![] }) + } + PostgresType::Timestamp => { + Decoder::TimestampMicrosecond(TimestampMicrosecondDecoder { + name: name.to_string(), + arr: vec![], + }) + } + PostgresType::Date => Decoder::Date32(Date32Decoder { + name: name.to_string(), + arr: vec![], + }), + PostgresType::Time => Decoder::Time64Microsecond(Time64MicrosecondDecoder { + name: name.to_string(), + arr: vec![], + }), + PostgresType::Interval => { + Decoder::DurationMicrosecond(DurationMicrosecondDecoder { + name: name.to_string(), + arr: vec![], + }) + } + PostgresType::Text | PostgresType::Char | PostgresType::Json => Decoder::String(StringDecoder { + name: name.to_string(), + arr: vec![], + }), + PostgresType::Bytea => Decoder::Binary(BinaryDecoder { + name: name.to_string(), + arr: vec![], + }), + _ => unimplemented!(), + }) + .collect() + } + + pub(crate) fn apply(&mut self, buf: &mut ConsumableBuf) -> Result<(), ErrorKind> { + match *self { + Decoder::Boolean(ref mut decoder) => decoder.decode(buf), + Decoder::Int16(ref mut decoder) => decoder.decode(buf), + Decoder::Int32(ref mut decoder) => decoder.decode(buf), + Decoder::Int64(ref mut decoder) => decoder.decode(buf), + Decoder::Float32(ref mut decoder) => decoder.decode(buf), + Decoder::Float64(ref mut decoder) => decoder.decode(buf), + Decoder::Decimal(ref mut decoder) => decoder.decode(buf), + Decoder::TimestampMicrosecond(ref mut decoder) => decoder.decode(buf), + Decoder::Date32(ref mut decoder) => decoder.decode(buf), + Decoder::Time64Microsecond(ref mut decoder) => decoder.decode(buf), + Decoder::DurationMicrosecond(ref mut decoder) => decoder.decode(buf), + Decoder::String(ref mut decoder) => decoder.decode(buf), + Decoder::Binary(ref mut decoder) => decoder.decode(buf), + Decoder::Jsonb(ref mut decoder) => decoder.decode(buf), + } + } + + pub(crate) fn column_len(&self) -> usize { + match *self { + Decoder::Boolean(ref decoder) => decoder.column_len(), + Decoder::Int16(ref decoder) => decoder.column_len(), + Decoder::Int32(ref decoder) => decoder.column_len(), + Decoder::Int64(ref decoder) => decoder.column_len(), + Decoder::Float32(ref decoder) => decoder.column_len(), + Decoder::Float64(ref decoder) => decoder.column_len(), + Decoder::Decimal(ref decoder) => decoder.column_len(), + Decoder::TimestampMicrosecond(ref decoder) => decoder.column_len(), + Decoder::Date32(ref decoder) => decoder.column_len(), + Decoder::Time64Microsecond(ref decoder) => decoder.column_len(), + Decoder::DurationMicrosecond(ref decoder) => decoder.column_len(), + Decoder::String(ref decoder) => decoder.column_len(), + Decoder::Binary(ref decoder) => decoder.column_len(), + Decoder::Jsonb(ref decoder) => decoder.column_len(), + } + } + + pub(crate) fn finish(&mut self, column_len: usize) -> Result { + match *self { + Decoder::Boolean(ref mut decoder) => decoder.finish(column_len), + Decoder::Int16(ref mut decoder) => decoder.finish(column_len), + Decoder::Int32(ref mut decoder) => decoder.finish(column_len), + Decoder::Int64(ref mut decoder) => decoder.finish(column_len), + Decoder::Float32(ref mut decoder) => decoder.finish(column_len), + Decoder::Float64(ref mut decoder) => decoder.finish(column_len), + Decoder::Decimal(ref mut decoder) => decoder.finish(column_len), + Decoder::TimestampMicrosecond(ref mut decoder) => decoder.finish(column_len), + Decoder::Date32(ref mut decoder) => decoder.finish(column_len), + Decoder::Time64Microsecond(ref mut decoder) => decoder.finish(column_len), + Decoder::DurationMicrosecond(ref mut decoder) => decoder.finish(column_len), + Decoder::String(ref mut decoder) => decoder.finish(column_len), + Decoder::Binary(ref mut decoder) => decoder.finish(column_len), + Decoder::Jsonb(ref mut decoder) => decoder.finish(column_len), + } + } +} diff --git a/core/src/encoders.rs b/core/src/encoders.rs index b5bfa89..6f7ac30 100644 --- a/core/src/encoders.rs +++ b/core/src/encoders.rs @@ -234,7 +234,7 @@ impl_encode!( BufMut::put_f64 ); -const PG_BASE_TIMESTAMP_OFFSET_US: i64 = 946_684_800_000_000; // microseconds between 2000-01-01 at midnight (Postgres's epoch) and 1970-01-01 (Arrow's / UNIX epoch) +pub(crate) const PG_BASE_TIMESTAMP_OFFSET_US: i64 = 946_684_800_000_000; // microseconds between 2000-01-01 at midnight (Postgres's epoch) and 1970-01-01 (Arrow's / UNIX epoch) const PG_BASE_TIMESTAMP_OFFSET_MS: i64 = 946_684_800_000; // milliseconds between 2000-01-01 at midnight (Postgres's epoch) and 1970-01-01 (Arrow's / UNIX epoch) const PG_BASE_TIMESTAMP_OFFSET_S: i64 = 946_684_800; // seconds between 2000-01-01 at midnight (Postgres's epoch) and 1970-01-01 (Arrow's / UNIX epoch) @@ -320,7 +320,7 @@ impl_encode_fallible!( BufMut::put_i64 ); -const PG_BASE_DATE_OFFSET: i32 = 10_957; // Number of days between PostgreSQL's epoch (2000-01-01) and Arrow's / UNIX epoch (1970-01-01) +pub(crate) const PG_BASE_DATE_OFFSET: i32 = 10_957; // Number of days between PostgreSQL's epoch (2000-01-01) and Arrow's / UNIX epoch (1970-01-01) #[inline(always)] fn convert_arrow_date32_to_postgres_date(_field: &str, date: i32) -> Result { diff --git a/core/src/error.rs b/core/src/error.rs index 077fe31..209875a 100644 --- a/core/src/error.rs +++ b/core/src/error.rs @@ -1,4 +1,4 @@ -use arrow_schema::DataType; +use arrow_schema::{DataType, ArrowError}; use thiserror::Error; use crate::pg_schema::PostgresType; @@ -40,6 +40,43 @@ pub enum ErrorKind { EncoderMissing { field: String }, #[error("No fields match supplied encoder fields: {fields:?}")] UnknownFields { fields: Vec }, + + // Decoding + #[error("Error decoding data: {reason}")] + Decode { reason: String, name: String }, + #[error("Got invalid binary file header {bytes:?}")] + InvalidBinaryHeader { bytes: [u8; 11] }, + #[error("Got invalid binary file trailer {bytes:?}")] + InvalidBinaryTrailer { bytes: [u8; 2] }, + #[error("Reached EOF before with incomplete data. Extra data: {remaining_bytes:?}")] + IncompleteDecode { remaining_bytes: Vec }, + #[error("Got data of the wrong size: got: {found}, expected: {expected}")] + DataSize { found: usize, expected: usize }, + #[error("Invalid column specification: {spec}")] + InvalidColumnSpec { spec: String }, + #[error("Extra data found at the end of the file")] + ExtraDataFound, + #[error("Invalid column type: {typ}")] + UnsupportedColumnType { typ: String }, + #[error("Got an error in an IO Operation: {io_error:?}")] + IOError { io_error: std::io::Error }, + #[error("Got an error: {name} in Arrow while decoding: {reason}")] + ArrowErrorDecode { reason: String, name: String }, +} + +impl From for ErrorKind { + fn from(io_error: std::io::Error) -> Self { + ErrorKind::IOError { io_error } + } +} + +impl From for ErrorKind { + fn from(arrow_error: ArrowError) -> Self { + ErrorKind::ArrowErrorDecode { + reason: arrow_error.to_string(), + name: "ArrowError".to_string(), + } + } } impl ErrorKind { diff --git a/core/src/lib.rs b/core/src/lib.rs index c30e5fd..59839ea 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -1,16 +1,19 @@ use std::collections::HashMap; +use std::io::{Seek, BufRead}; -use arrow_array::RecordBatch; +use arrow_array::{Array, RecordBatch}; use arrow_schema::Fields; use arrow_schema::Schema; -use bytes::{BufMut, BytesMut}; +use bytes::{BufMut, BytesMut, Buf}; use error::ErrorKind; pub mod encoders; pub mod error; pub mod pg_schema; +pub mod decoders; use crate::encoders::{BuildEncoder, Encode, EncoderBuilder}; +use crate::decoders::{Decoder, ConsumableBuf}; use crate::pg_schema::PostgresSchema; const HEADER_MAGIC_BYTES: &[u8] = b"PGCOPY\n\xff\r\n\0"; @@ -150,6 +153,259 @@ impl ArrowToPostgresBinaryEncoder { } } +enum BatchDecodeResult { + Batch(RecordBatch), + Incomplete, + Error(ErrorKind), + PartialConsume{batch: RecordBatch, consumed: usize}, +} + +pub struct PostgresBinaryToArrowDecoder { + schema: PostgresSchema, + decoders: Vec, + source: R, + state: EncoderState, + capacity: usize, +} + +impl PostgresBinaryToArrowDecoder { + pub fn new(schema: PostgresSchema, source: R, capacity: usize) -> Result { + let decoders = Decoder::new(&schema); + Ok(PostgresBinaryToArrowDecoder { + schema, + decoders, + source, + state: EncoderState::Created, + capacity, + }) + } + + pub fn read_header(&mut self) -> Result<(), ErrorKind> { + assert_eq!(self.state, EncoderState::Created); + let mut header = [0; 11]; + self.source.read_exact(&mut header)?; + if header != HEADER_MAGIC_BYTES { + return Err(ErrorKind::InvalidBinaryHeader { bytes: header }); + } + let mut flags = [0; 4]; + self.source.read_exact(&mut flags)?; + let mut header_extension = [0; 4]; + self.source.read_exact(&mut header_extension)?; + self.state = EncoderState::Encoding; + Ok(()) + } + + pub fn decode_batches( + &mut self, + ) -> Result, ErrorKind> { + let mut batches = Vec::new(); + let mut buf = BytesMut::with_capacity(self.capacity); + let mut eof = false; + while self.state == EncoderState::Encoding { + // Read loop. Read from source until buf is full. + let mut data = self.source.fill_buf()?; + loop { + // If there is no data left in the source, break the loop and finish the batch. + // set the eof flag to true to indicate that the source has been fully read. + if data.is_empty() { + eof = true; + break; + // if data was read from the source, put it into the buffer and single + // to source that we have consumed the data by calling BufRead::consume. + } else { + buf.put(data); + let read = data.len(); + self.source.consume(read); + } + data = self.source.fill_buf()?; + + // If the remaining capacity of the buffer is less than the length of the data, + // break the loop. + let remaining = buf.capacity() - buf.len(); + if remaining < data.len() { + break; + } + } + + // If the eof flag is not set and there remains capacity in the buffer, read the + // ${remaining_capacity} bytes from the source and put them into the buffer. + let remaining = buf.capacity() - buf.len(); + if !eof && remaining > 0 { + let read = std::cmp::min(data.len(), buf.remaining()); + buf.put(&data[..read]); + self.source.consume(read); + } + + // If we have reached the end of the source decode the batch and return error if + // there is any remaining data in the buffer indicated by and IncompleteDecode + // or PartialConsume BatchDecodeResult. + if eof { + if !buf.is_empty() { + match self.decode_batch(&mut buf) { + BatchDecodeResult::Batch(batch) => batches.push(batch), + BatchDecodeResult::Incomplete => { + return Err(ErrorKind::IncompleteDecode { + remaining_bytes: buf.to_vec(), + }) + } + BatchDecodeResult::Error(e) => return Err(e), + BatchDecodeResult::PartialConsume{ batch: _, consumed: _} => { + return Err(ErrorKind::ExtraDataFound) + } + } + } + self.state = EncoderState::Finished; + // If we have not reached the end of the source, decode the batch. + } else { + match self.decode_batch(&mut buf) { + BatchDecodeResult::Batch(batch) => { + batches.push(batch); + buf.clear() + }, + // If we receive a PartialConsume BatchDecodeResult, store the batches we did + // manage to decode and continue reading from the source with the remaining + // data from the previous read in the buffer. + BatchDecodeResult::PartialConsume{ batch, consumed } => { + batches.push(batch); + let old_buf = buf; + buf = BytesMut::with_capacity(self.capacity); + buf.put(&old_buf[consumed..]); + }, + // If we receive an Incomplete BatchDecodeResult, increase the capacity of the + // buffer reading more data from the source and try to decode the batch again. + BatchDecodeResult::Incomplete => { + // println!("Increasing capacity to {}", self.capacity * 2); + // increase the capacity attribute of the decoder by a factor of 2. + self.capacity *= 2; + let old_buf = buf; + // create a new buffer with the new capacity. + buf = BytesMut::with_capacity(self.capacity); + // put all the data from the old buffer into the new buffer. + buf.put(old_buf); + } + BatchDecodeResult::Error(e) => return Err(e), + } + } + } + Ok(batches) + } + + fn decode_batch(&mut self, buf: &mut BytesMut) -> BatchDecodeResult { + // ensure that the decoder is in the correct state befpre proceeding. + assert_eq!(self.state, EncoderState::Encoding); + + // create a new ConsumableBuf from the buffer. + let mut local_buf = ConsumableBuf::new(buf); + // Keep track of the number of rows in the batch. + let mut rows = 0; + + // Each iteration of the loop reads a tuple from the data. + // If we are not able to read a tuple, return a BatchDecodeResult::Incomplete. + // If we were able to read some tuples, but not all the data in the buffer was consumed, + // return a BatchDecodeResult::PartialConsume. + while local_buf.remaining() > 0 { + // Store the number of bytes consumed before reading the tuple. + let consumed = local_buf.consumed(); + + // Read the number of columns in the tuple. This number is + // stored as a 16-bit integer. This value is the same for all + // tuples in the batch. + let tuple_len: u16 = match local_buf.consume_into_u16() { + Ok(len) => len, + Err(e) => { + println!("Error reading tuple length: {:?}", e); + return BatchDecodeResult::Error(e); + } + }; + + // If the tuple length is 0xffff we have reached the end of the + // snapshot and we can break the loop and finish the batch. + if tuple_len == 0xffff { + break + } + + // Each iteration of the loop reads a column from the tuple using the + // decoder specfied via the schema. + for decoder in self.decoders.iter_mut() { + // If local_buf has been fully consumed and we have not read any rows, + // return a BatchDecodeResult::Incomplete. + if local_buf.remaining() == 0 && rows == 0 { + // println!("Incomplete no data remaining"); + return BatchDecodeResult::Incomplete; + // If local_buf has been fully consumed and we have read some rows, + // return a BatchDecodeResult::PartialConsume, passing the number of bytes + // consumed before reading the tuple to the caller so it can know how much data + // was consumed. + } else if local_buf.remaining() == 0 { + // println!("Partial consume no data remaining"); + // println!("Finishing batch. Rows: {}", rows); + return match self.finish_batch() { + Ok(batch) => BatchDecodeResult::PartialConsume{ batch, consumed}, + Err(e) => BatchDecodeResult::Error(e), + } + } + // Apply the decoder to the local_buf. Cosume the data from the buffer as needed + match decoder.apply(&mut local_buf) { + // If the decoder was able to decode the data, continue to the next column. + Ok(_) => {} + // If we receive a DataSize error, we have reached the end of the data in + // the buffer. If we have not finished the current tuple + Err(ErrorKind::DataSize { found: _, expected: _ }) => { + // If we have not read any rows, return a BatchDecodeResult::Incomplete. + if rows == 0 { + // println!("Incomplete mid-batch"); + return BatchDecodeResult::Incomplete; + } else { + // If we have read some rows, return a BatchDecodeResult::PartialConsume, + // println!("Partial consume mid-batch"); + // println!("Finishing batch. Rows: {}", rows); + return match self.finish_batch() { + Ok(batch) => BatchDecodeResult::PartialConsume{ batch, consumed}, + Err(e) => BatchDecodeResult::Error(e), + } + } + }, + Err(e) => return BatchDecodeResult::Error(e) + } + } + // Increment the number of rows in the batch. + rows += 1; + } + + // println!("Finishing batch. Rows: {}", rows); + // Finish the batch and return the result. + match self.finish_batch() { + Ok(batch) => BatchDecodeResult::Batch(batch), + Err(e) => BatchDecodeResult::Error(e), + } + + } + + fn finish_batch( + &mut self, + ) -> Result { + let mut columns: Vec> = Vec::new(); + // Find the mininum length column in the decoders. These can be different if + // we are in a partial consume state. We will truncate the columns to the length + // of the shortest column and pick up the lost data in the next batch. + let column_len = self.decoders.iter().map(|d| d.column_len()).min().unwrap(); + // For each decoder call its finish method to coerce the data into an Arrow array. + // and append the array to the columns vector. + for decoder in self.decoders.iter_mut() { + match decoder.finish(column_len) { + Ok(array) => columns.push(array), + Err(e) => return Err(e) + } + } + // Create a new RecordBatch from the columns vector and return it. + let record_batch = + RecordBatch::try_new(self.schema.clone().into(), columns)?; + + Ok(record_batch) + } +} + + #[cfg(test)] mod tests { use std::{collections::HashMap, sync::Arc}; diff --git a/core/src/pg_schema.rs b/core/src/pg_schema.rs index 1aaa3af..515dd7d 100644 --- a/core/src/pg_schema.rs +++ b/core/src/pg_schema.rs @@ -1,3 +1,7 @@ +use arrow_schema::{Schema, Field, DataType, TimeUnit, SchemaRef}; +use std::sync::Arc; +use crate::error::ErrorKind; + #[derive(Debug, Clone, PartialEq)] pub enum TypeSize { Fixed(usize), @@ -17,6 +21,7 @@ pub enum PostgresType { Jsonb, Float4, Float8, + Decimal, Date, Time, Timestamp, @@ -41,7 +46,8 @@ impl PostgresType { PostgresType::Date => TypeSize::Fixed(4), PostgresType::Time => TypeSize::Fixed(8), PostgresType::Timestamp => TypeSize::Fixed(8), - PostgresType::Interval => TypeSize::Fixed(16), + PostgresType::Interval => TypeSize::Fixed(12), + PostgresType::Decimal => TypeSize::Variable, PostgresType::List(_) => TypeSize::Variable, } } @@ -58,6 +64,7 @@ impl PostgresType { PostgresType::Jsonb => Some(3802), PostgresType::Float4 => Some(700), PostgresType::Float8 => Some(701), + PostgresType::Decimal => Some(1700), PostgresType::Date => Some(1082), PostgresType::Time => Some(1083), PostgresType::Timestamp => Some(1114), @@ -78,6 +85,7 @@ impl PostgresType { PostgresType::Jsonb => "JSONB".to_string(), PostgresType::Float4 => "FLOAT4".to_string(), PostgresType::Float8 => "FLOAT8".to_string(), + PostgresType::Decimal => "DECIMAL".to_string(), PostgresType::Date => "DATE".to_string(), PostgresType::Time => "TIME".to_string(), PostgresType::Timestamp => "TIMESTAMP".to_string(), @@ -90,15 +98,208 @@ impl PostgresType { }; Some(v) } + + pub fn from_name(name: &str) -> Option { + match name { + "BOOL" => Some(PostgresType::Bool), + "BYTEA" => Some(PostgresType::Bytea), + "INT8" => Some(PostgresType::Int8), + "INT2" => Some(PostgresType::Int2), + "INT4" => Some(PostgresType::Int4), + "CHAR" => Some(PostgresType::Char), + "TEXT" => Some(PostgresType::Text), + "JSON" => Some(PostgresType::Json), + "JSONB" => Some(PostgresType::Jsonb), + "FLOAT4" => Some(PostgresType::Float4), + "FLOAT8" => Some(PostgresType::Float8), + "DECIMAL" => Some(PostgresType::Decimal), + "DATE" => Some(PostgresType::Date), + "TIME" => Some(PostgresType::Time), + "TIMESTAMP" => Some(PostgresType::Timestamp), + "INTERVAL" => Some(PostgresType::Interval), + _ => None, + } + } +} + +impl From for DataType { + fn from(pg_type: PostgresType) -> Self { + match pg_type { + PostgresType::Bool => DataType::Boolean, + PostgresType::Bytea => DataType::LargeBinary, + PostgresType::Int8 => DataType::Int64, + PostgresType::Int2 => DataType::Int16, + PostgresType::Int4 => DataType::Int32, + PostgresType::Char => DataType::LargeUtf8, + PostgresType::Text => DataType::LargeUtf8, + PostgresType::Json => DataType::LargeUtf8, + PostgresType::Jsonb => DataType::LargeUtf8, + PostgresType::Float4 => DataType::Float32, + PostgresType::Float8 => DataType::Float64, + PostgresType::Decimal => DataType::LargeUtf8, + PostgresType::Date => DataType::Date32, + PostgresType::Time => DataType::Time64(TimeUnit::Microsecond), + PostgresType::Timestamp => DataType::Timestamp(TimeUnit::Microsecond, None), + PostgresType::Interval => DataType::Duration(TimeUnit::Microsecond), + PostgresType::List(_) => unimplemented!(), + } + } } + #[derive(Debug, Clone, PartialEq)] pub struct Column { pub data_type: PostgresType, pub nullable: bool, } +impl Column { + pub fn from_parts(type_str: &str, nullable: &str) -> Result { + match type_str { + "boolean" => { + Ok(Column { + data_type: PostgresType::Bool, + nullable: nullable == "t", + }) + }, + "bytea" => { + Ok(Column { + data_type: PostgresType::Bytea, + nullable: nullable == "t", + }) + }, + "bigint" => { + Ok(Column { + data_type: PostgresType::Int8, + nullable: nullable == "t", + }) + }, + "smallint" => { + Ok(Column { + data_type: PostgresType::Int2, + nullable: nullable == "t", + }) + }, + "integer" => { + Ok(Column { + data_type: PostgresType::Int4, + nullable: nullable == "t", + }) + }, + "character" | "character varying" => { + Ok(Column { + data_type: PostgresType::Char, + nullable: nullable == "t", + }) + }, + "text" => { + Ok(Column { + data_type: PostgresType::Text, + nullable: nullable == "t", + }) + }, + "json" => { + Ok(Column { + data_type: PostgresType::Json, + nullable: nullable == "t", + }) + }, + "jsonb" => { + Ok(Column { + data_type: PostgresType::Jsonb, + nullable: nullable == "t", + }) + }, + "real" => { + Ok(Column { + data_type: PostgresType::Float4, + nullable: nullable == "t", + }) + }, + "double precision" => { + Ok(Column { + data_type: PostgresType::Float8, + nullable: nullable == "t", + }) + }, + "numeric" => { + Ok(Column { + data_type: PostgresType::Decimal, + nullable: nullable == "t", + }) + }, + "date" => { + Ok(Column { + data_type: PostgresType::Date, + nullable: nullable == "t", + }) + }, + "time" => { + Ok(Column { + data_type: PostgresType::Time, + nullable: nullable == "t", + }) + }, + "timestamp with time zone" | "timestamp without time zone" => { + Ok(Column { + data_type: PostgresType::Timestamp, + nullable: nullable == "t", + }) + }, + "interval" => { + Ok(Column { + data_type: PostgresType::Interval, + nullable: nullable == "t", + }) + }, + _ => { + Err(ErrorKind::UnsupportedColumnType { typ: type_str.to_string() }) + } + } + + } +} + #[derive(Debug, Clone)] pub struct PostgresSchema { pub columns: Vec<(String, Column)>, } + + +impl From for SchemaRef { + fn from(pg_schema: PostgresSchema) -> Self { + let fields: Vec = pg_schema.columns.iter().map(|(name, col)| { + Field::new(name, col.data_type.clone().into(), col.nullable) + }).collect(); + Arc::new(Schema::new(fields)) + } +} + +impl PostgresSchema { + pub fn from_reader(mut reader: R, delim: char) -> Result { + let mut schema_str = String::new(); + reader.read_to_string(&mut schema_str)?; + + let schema = schema_str.split('\n').filter(|s| !s.is_empty()).map(|s|{ + let parts: Vec<&str> = s.splitn(3, delim).collect(); + if parts.len() != 3 { + return Err(ErrorKind::InvalidColumnSpec{spec: s.to_string()}); + } + let name = parts[0]; + let typ = parts[1]; + let nullable = parts[2]; + let col = Column::from_parts(typ, nullable)?; + Ok((name.to_string(), col)) + }).collect::, ErrorKind>>().map(|columns| { + PostgresSchema { columns } + + })?; + + Ok(schema) + + } + + pub fn iter(&self) -> impl Iterator { + self.columns.iter() + } +} From 663d149a703d35d47bba486634f13732928347f4 Mon Sep 17 00:00:00 2001 From: Adam Lefevre Date: Mon, 8 Apr 2024 09:29:47 -0500 Subject: [PATCH 02/11] Add integration tests --- core/tests/decode_integration_tests.rs | 195 ++++++++++++++++++ core/tests/decoding/binary.schema | 1 + core/tests/decoding/binary_nullable.schema | 1 + core/tests/decoding/bool.schema | 1 + core/tests/decoding/bool_nullable.schema | 1 + core/tests/decoding/date32.schema | 1 + core/tests/decoding/date32_nullable.schema | 1 + core/tests/decoding/duration_us.schema | 1 + .../decoding/duration_us_nullable.schema | 1 + core/tests/decoding/float32.schema | 1 + core/tests/decoding/float32_nullable.schema | 1 + core/tests/decoding/float64.schema | 1 + core/tests/decoding/float64_nullable.schema | 1 + core/tests/decoding/int16.schema | 1 + core/tests/decoding/int16_nullable.schema | 1 + core/tests/decoding/int32.schema | 1 + core/tests/decoding/int32_nullable.schema | 1 + core/tests/decoding/int64.schema | 1 + core/tests/decoding/int64_nullable | 1 + core/tests/decoding/int64_nullable.schema | 1 + core/tests/decoding/numeric.schema | 1 + core/tests/decoding/numeric_nullable.schema | 1 + core/tests/decoding/profile.schema | 87 ++++++++ core/tests/decoding/string.schema | 1 + core/tests/decoding/string_nullable.schema | 1 + core/tests/decoding/time_us.schema | 1 + core/tests/decoding/time_us_nullable.schema | 1 + core/tests/decoding/timestamp_us_notz.schema | 1 + .../timestamp_us_notz_nullable.schema | 1 + core/tests/decoding/timestamp_us_tz.schema | 1 + .../decoding/timestamp_us_tz_nullable.schema | 1 + 31 files changed, 311 insertions(+) create mode 100644 core/tests/decode_integration_tests.rs create mode 100644 core/tests/decoding/binary.schema create mode 100644 core/tests/decoding/binary_nullable.schema create mode 100644 core/tests/decoding/bool.schema create mode 100644 core/tests/decoding/bool_nullable.schema create mode 100644 core/tests/decoding/date32.schema create mode 100644 core/tests/decoding/date32_nullable.schema create mode 100644 core/tests/decoding/duration_us.schema create mode 100644 core/tests/decoding/duration_us_nullable.schema create mode 100644 core/tests/decoding/float32.schema create mode 100644 core/tests/decoding/float32_nullable.schema create mode 100644 core/tests/decoding/float64.schema create mode 100644 core/tests/decoding/float64_nullable.schema create mode 100644 core/tests/decoding/int16.schema create mode 100644 core/tests/decoding/int16_nullable.schema create mode 100644 core/tests/decoding/int32.schema create mode 100644 core/tests/decoding/int32_nullable.schema create mode 100644 core/tests/decoding/int64.schema create mode 100644 core/tests/decoding/int64_nullable create mode 100644 core/tests/decoding/int64_nullable.schema create mode 100644 core/tests/decoding/numeric.schema create mode 100644 core/tests/decoding/numeric_nullable.schema create mode 100644 core/tests/decoding/profile.schema create mode 100644 core/tests/decoding/string.schema create mode 100644 core/tests/decoding/string_nullable.schema create mode 100644 core/tests/decoding/time_us.schema create mode 100644 core/tests/decoding/time_us_nullable.schema create mode 100644 core/tests/decoding/timestamp_us_notz.schema create mode 100644 core/tests/decoding/timestamp_us_notz_nullable.schema create mode 100644 core/tests/decoding/timestamp_us_tz.schema create mode 100644 core/tests/decoding/timestamp_us_tz_nullable.schema diff --git a/core/tests/decode_integration_tests.rs b/core/tests/decode_integration_tests.rs new file mode 100644 index 0000000..ce6a294 --- /dev/null +++ b/core/tests/decode_integration_tests.rs @@ -0,0 +1,195 @@ +use std::fs::File; +use std::path::PathBuf; +use std::io::BufReader; +use pgpq::error::ErrorKind; + +use pgpq::{PostgresBinaryToArrowDecoder, pg_schema::PostgresSchema}; + + +const KB: usize = 1024* 512; + +fn read_schema_file(path: PathBuf) -> PostgresSchema { + let file = File::open(path).unwrap(); + let reader = BufReader::new(file); + PostgresSchema::from_reader(reader, ',').unwrap() +} + +fn run_test_case(case: &str) -> Result<(), ErrorKind> { + let path = + PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!("tests/snapshots/{case}.bin")); + let schema_path = + PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!("tests/decoding/{case}.schema")); + let file = File::open(path).unwrap(); + let reader = BufReader::with_capacity(KB, file); + let schema = read_schema_file(schema_path); + println!("{:?}", schema); + let mut decoder = PostgresBinaryToArrowDecoder::new(schema, reader, KB).unwrap(); + decoder.read_header()?; + let batches = decoder.decode_batches()?; + println!("{:?}", batches); + Ok(()) +} + + +#[test] +fn test_bool() -> Result<(), ErrorKind> { + run_test_case("bool")?; + Ok(()) +} + +#[test] +fn test_int16() -> Result<(), ErrorKind> { + run_test_case("int16")?; + Ok(()) +} + +#[test] +fn test_int32() -> Result<(), ErrorKind> { + run_test_case("int32")?; + Ok(()) +} + +#[test] +fn test_int64() -> Result<(), ErrorKind> { + run_test_case("int64")?; + Ok(()) +} + +#[test] +fn test_float32() -> Result<(), ErrorKind> { + run_test_case("float32")?; + Ok(()) +} + +#[test] +fn test_float64() -> Result<(), ErrorKind> { + run_test_case("float64")?; + Ok(()) +} + +#[test] +fn test_timestamp_us_notz() -> Result<(), ErrorKind> { + run_test_case("timestamp_us_notz")?; + Ok(()) +} + +#[test] +fn test_timestamp_us_tz() -> Result<(), ErrorKind> { + run_test_case("timestamp_us_tz")?; + Ok(()) +} + +#[test] +fn test_time_us() -> Result<(), ErrorKind> { + run_test_case("time_us")?; + Ok(()) +} + +#[test] +fn test_date32() -> Result<(), ErrorKind> { + run_test_case("date32")?; + Ok(()) +} + +#[test] +fn test_duration_us() -> Result<(), ErrorKind> { + run_test_case("duration_us")?; + Ok(()) +} + + +#[test] +fn test_binary() -> Result<(), ErrorKind> { + run_test_case("binary")?; + Ok(()) +} + +#[test] +fn test_string() -> Result<(), ErrorKind> { + run_test_case("string")?; + Ok(()) +} + +#[test] +fn test_bool_nullable() -> Result<(), ErrorKind> { + run_test_case("bool_nullable")?; + Ok(()) +} + +#[test] +fn test_int16_nullable() -> Result<(), ErrorKind> { + run_test_case("int16_nullable")?; + Ok(()) +} + +#[test] +fn test_int32_nullable() -> Result<(), ErrorKind> { + run_test_case("int32_nullable")?; + Ok(()) +} + +#[test] +fn test_int64_nullable() -> Result<(), ErrorKind> { + run_test_case("int64_nullable")?; + Ok(()) +} + +#[test] +fn test_float32_nullable() -> Result<(), ErrorKind> { + run_test_case("float32_nullable")?; + Ok(()) +} + +#[test] +fn test_float64_nullable() -> Result<(), ErrorKind> { + run_test_case("float64_nullable")?; + Ok(()) +} + +#[test] +fn test_timestamp_us_notz_nullable() -> Result<(), ErrorKind> { + run_test_case("timestamp_us_notz_nullable")?; + Ok(()) +} + +#[test] +fn test_timestamp_us_tz_nullable() -> Result<(), ErrorKind> { + run_test_case("timestamp_us_tz_nullable")?; + Ok(()) +} + +#[test] +fn test_time_us_nullable() -> Result<(), ErrorKind> { + run_test_case("time_us_nullable")?; + Ok(()) +} + +#[test] +fn test_date32_nullable() -> Result<(), ErrorKind> { + run_test_case("date32_nullable")?; + Ok(()) +} + +#[test] +fn test_duration_us_nullable() -> Result<(), ErrorKind> { + run_test_case("duration_us_nullable")?; + Ok(()) +} + +#[test] +fn test_binary_nullable() -> Result<(), ErrorKind> { + run_test_case("binary_nullable")?; + Ok(()) +} + +#[test] +fn test_string_nullable() -> Result<(), ErrorKind> { + run_test_case("string_nullable")?; + Ok(()) +} + +// #[test] +// fn test_profile() -> Result<(), ErrorKind> { +// run_test_case("profile")?; +// Ok(()) +// } diff --git a/core/tests/decoding/binary.schema b/core/tests/decoding/binary.schema new file mode 100644 index 0000000..a1647a6 --- /dev/null +++ b/core/tests/decoding/binary.schema @@ -0,0 +1 @@ +binary_column,bytea,f \ No newline at end of file diff --git a/core/tests/decoding/binary_nullable.schema b/core/tests/decoding/binary_nullable.schema new file mode 100644 index 0000000..0dcd30f --- /dev/null +++ b/core/tests/decoding/binary_nullable.schema @@ -0,0 +1 @@ +binary_column,bytea,t \ No newline at end of file diff --git a/core/tests/decoding/bool.schema b/core/tests/decoding/bool.schema new file mode 100644 index 0000000..7894e7f --- /dev/null +++ b/core/tests/decoding/bool.schema @@ -0,0 +1 @@ +bool_column,boolean,f \ No newline at end of file diff --git a/core/tests/decoding/bool_nullable.schema b/core/tests/decoding/bool_nullable.schema new file mode 100644 index 0000000..320990b --- /dev/null +++ b/core/tests/decoding/bool_nullable.schema @@ -0,0 +1 @@ +bool_column,boolean,t \ No newline at end of file diff --git a/core/tests/decoding/date32.schema b/core/tests/decoding/date32.schema new file mode 100644 index 0000000..953ab7d --- /dev/null +++ b/core/tests/decoding/date32.schema @@ -0,0 +1 @@ +date32_column,date,f \ No newline at end of file diff --git a/core/tests/decoding/date32_nullable.schema b/core/tests/decoding/date32_nullable.schema new file mode 100644 index 0000000..0211de2 --- /dev/null +++ b/core/tests/decoding/date32_nullable.schema @@ -0,0 +1 @@ +date32_column,date,t \ No newline at end of file diff --git a/core/tests/decoding/duration_us.schema b/core/tests/decoding/duration_us.schema new file mode 100644 index 0000000..af9e599 --- /dev/null +++ b/core/tests/decoding/duration_us.schema @@ -0,0 +1 @@ +duration_us_column,interval,f \ No newline at end of file diff --git a/core/tests/decoding/duration_us_nullable.schema b/core/tests/decoding/duration_us_nullable.schema new file mode 100644 index 0000000..f251662 --- /dev/null +++ b/core/tests/decoding/duration_us_nullable.schema @@ -0,0 +1 @@ +duration_us_column,interval,t \ No newline at end of file diff --git a/core/tests/decoding/float32.schema b/core/tests/decoding/float32.schema new file mode 100644 index 0000000..fce1061 --- /dev/null +++ b/core/tests/decoding/float32.schema @@ -0,0 +1 @@ +float32_column,real,f \ No newline at end of file diff --git a/core/tests/decoding/float32_nullable.schema b/core/tests/decoding/float32_nullable.schema new file mode 100644 index 0000000..38f5f7e --- /dev/null +++ b/core/tests/decoding/float32_nullable.schema @@ -0,0 +1 @@ +float32_column,real,t \ No newline at end of file diff --git a/core/tests/decoding/float64.schema b/core/tests/decoding/float64.schema new file mode 100644 index 0000000..9178796 --- /dev/null +++ b/core/tests/decoding/float64.schema @@ -0,0 +1 @@ +float64_column,double precision,f \ No newline at end of file diff --git a/core/tests/decoding/float64_nullable.schema b/core/tests/decoding/float64_nullable.schema new file mode 100644 index 0000000..78c59d5 --- /dev/null +++ b/core/tests/decoding/float64_nullable.schema @@ -0,0 +1 @@ +float64_column,double precision,t \ No newline at end of file diff --git a/core/tests/decoding/int16.schema b/core/tests/decoding/int16.schema new file mode 100644 index 0000000..fcd83d9 --- /dev/null +++ b/core/tests/decoding/int16.schema @@ -0,0 +1 @@ +int16_column,smallint,f \ No newline at end of file diff --git a/core/tests/decoding/int16_nullable.schema b/core/tests/decoding/int16_nullable.schema new file mode 100644 index 0000000..06fc20a --- /dev/null +++ b/core/tests/decoding/int16_nullable.schema @@ -0,0 +1 @@ +int16_column,smallint,t \ No newline at end of file diff --git a/core/tests/decoding/int32.schema b/core/tests/decoding/int32.schema new file mode 100644 index 0000000..d464e55 --- /dev/null +++ b/core/tests/decoding/int32.schema @@ -0,0 +1 @@ +int32_column,integer,f \ No newline at end of file diff --git a/core/tests/decoding/int32_nullable.schema b/core/tests/decoding/int32_nullable.schema new file mode 100644 index 0000000..83a6a32 --- /dev/null +++ b/core/tests/decoding/int32_nullable.schema @@ -0,0 +1 @@ +int32_column,integer,t \ No newline at end of file diff --git a/core/tests/decoding/int64.schema b/core/tests/decoding/int64.schema new file mode 100644 index 0000000..17b12d4 --- /dev/null +++ b/core/tests/decoding/int64.schema @@ -0,0 +1 @@ +int64_column,bigint,f \ No newline at end of file diff --git a/core/tests/decoding/int64_nullable b/core/tests/decoding/int64_nullable new file mode 100644 index 0000000..22fad18 --- /dev/null +++ b/core/tests/decoding/int64_nullable @@ -0,0 +1 @@ +int64_column,bigint,t diff --git a/core/tests/decoding/int64_nullable.schema b/core/tests/decoding/int64_nullable.schema new file mode 100644 index 0000000..5809adb --- /dev/null +++ b/core/tests/decoding/int64_nullable.schema @@ -0,0 +1 @@ +int64_column,bigint,t \ No newline at end of file diff --git a/core/tests/decoding/numeric.schema b/core/tests/decoding/numeric.schema new file mode 100644 index 0000000..0ea6b82 --- /dev/null +++ b/core/tests/decoding/numeric.schema @@ -0,0 +1 @@ +numeric_column,numeric,f \ No newline at end of file diff --git a/core/tests/decoding/numeric_nullable.schema b/core/tests/decoding/numeric_nullable.schema new file mode 100644 index 0000000..9d7cb11 --- /dev/null +++ b/core/tests/decoding/numeric_nullable.schema @@ -0,0 +1 @@ +numeric_column,numeric,t \ No newline at end of file diff --git a/core/tests/decoding/profile.schema b/core/tests/decoding/profile.schema new file mode 100644 index 0000000..aac687d --- /dev/null +++ b/core/tests/decoding/profile.schema @@ -0,0 +1,87 @@ +id,integer,f +password,character varying,f +last_login,timestamp with time zone,t +is_superuser,boolean,f +first_name,character varying,f +last_name,character varying,f +email,character varying,f +is_staff,boolean,f +is_active,boolean,f +date_joined,timestamp with time zone,f +gender,character varying,t +birthday,date,t +address,text,t +phone,text,t +income,double precision,t +employment,text,t +refresh_status,text,t +personal_info,text,t +username,character varying,f +preferences,text,t +is_real,boolean,f +tester_type,character varying,t +auto_saving,character varying,f +admin_notes,text,t +email_account_updates,boolean,f +email_features,boolean,f +push_alerts,boolean,f +referring_profile_id,integer,t +transactions_database,character varying,f +push_savings,boolean,f +push_trends,boolean,f +last_seen,timestamp with time zone,t +last_refresh,timestamp with time zone,t +recurring_savings_amount,double precision,t +savings_method,character varying,f +features,text,t +text_enabled,boolean,f +savings_halt,boolean,f +genius_status,character varying,t +genius_enabled,boolean,f +monthly_price,double precision,t +pricing_data,text,t +support_agent_id,integer,t +support_is_unread,boolean,f +support_status,character varying,t +payment_frequency,character varying,f +pause_rainy_day_fund,boolean,f +referral_campaign_id,integer,t +messaging_service,character varying,f +incoming_phone_number_id,integer,t +phone_number_data,text,t +is_spy,boolean,f +is_support_agent,boolean,f +allow_linking_duplicate_accounts,boolean,f +text_outreach,boolean,f +blacklist_phone,boolean,f +is_suspended,boolean,f +support_team_notes,text,t +primary_linking_provider,character varying,f +deactivation_in_progress,boolean,f +previous_last_seen,timestamp with time zone,t +billshark_info,text,t +balances_database,character varying,f +device_type_raw,character varying,t +deactivated_timestamp,timestamp with time zone,t +investment_info,text,t +is_email_verified,boolean,t +fraud_status,character varying,t +email_to_update,character varying,t +kyc_stage,character varying,t +phone_to_update,text,t +instant_info,text,t +text_opt_in,boolean,t +updated_at,timestamp with time zone,t +nickname,character varying,t +income_source,character varying,t +income_type,character varying,t +occupation,text,t +is_universal_cash,boolean,t +last_queued_refresh,timestamp with time zone,t +last_seen_app,timestamp with time zone,t +last_seen_web,timestamp with time zone,t +previous_last_seen_app,timestamp with time zone,t +previous_last_seen_web,timestamp with time zone,t +refresh_logs_database,character varying,t +finished_signup_flow_timestamp,timestamp with time zone,t +suspended_reason,character varying,t diff --git a/core/tests/decoding/string.schema b/core/tests/decoding/string.schema new file mode 100644 index 0000000..9ebee6f --- /dev/null +++ b/core/tests/decoding/string.schema @@ -0,0 +1 @@ +string_column,text,f \ No newline at end of file diff --git a/core/tests/decoding/string_nullable.schema b/core/tests/decoding/string_nullable.schema new file mode 100644 index 0000000..924fcc9 --- /dev/null +++ b/core/tests/decoding/string_nullable.schema @@ -0,0 +1 @@ +string_column,text,t \ No newline at end of file diff --git a/core/tests/decoding/time_us.schema b/core/tests/decoding/time_us.schema new file mode 100644 index 0000000..2ef9fa4 --- /dev/null +++ b/core/tests/decoding/time_us.schema @@ -0,0 +1 @@ +time_us_column,time,f \ No newline at end of file diff --git a/core/tests/decoding/time_us_nullable.schema b/core/tests/decoding/time_us_nullable.schema new file mode 100644 index 0000000..029177e --- /dev/null +++ b/core/tests/decoding/time_us_nullable.schema @@ -0,0 +1 @@ +time_us_column,time,t \ No newline at end of file diff --git a/core/tests/decoding/timestamp_us_notz.schema b/core/tests/decoding/timestamp_us_notz.schema new file mode 100644 index 0000000..fee451f --- /dev/null +++ b/core/tests/decoding/timestamp_us_notz.schema @@ -0,0 +1 @@ +timestamp_us_no_tz_column,timestamp without time zone,f \ No newline at end of file diff --git a/core/tests/decoding/timestamp_us_notz_nullable.schema b/core/tests/decoding/timestamp_us_notz_nullable.schema new file mode 100644 index 0000000..4aebe00 --- /dev/null +++ b/core/tests/decoding/timestamp_us_notz_nullable.schema @@ -0,0 +1 @@ +timestamp_us_no_tz_column,timestamp without time zone,t \ No newline at end of file diff --git a/core/tests/decoding/timestamp_us_tz.schema b/core/tests/decoding/timestamp_us_tz.schema new file mode 100644 index 0000000..56a23d1 --- /dev/null +++ b/core/tests/decoding/timestamp_us_tz.schema @@ -0,0 +1 @@ +timestamp_us_tz_column,timestamp with time zone,f \ No newline at end of file diff --git a/core/tests/decoding/timestamp_us_tz_nullable.schema b/core/tests/decoding/timestamp_us_tz_nullable.schema new file mode 100644 index 0000000..d18fd98 --- /dev/null +++ b/core/tests/decoding/timestamp_us_tz_nullable.schema @@ -0,0 +1 @@ +timestamp_us_tz_column,timestamp with time zone,t \ No newline at end of file From daf6a35d449f6b03bf3f09ceff56f880d9d4068f Mon Sep 17 00:00:00 2001 From: Adam Lefevre Date: Tue, 9 Apr 2024 11:50:24 -0500 Subject: [PATCH 03/11] remove schema --- core/tests/decoding/profile.schema | 87 ------------------------------ 1 file changed, 87 deletions(-) delete mode 100644 core/tests/decoding/profile.schema diff --git a/core/tests/decoding/profile.schema b/core/tests/decoding/profile.schema deleted file mode 100644 index aac687d..0000000 --- a/core/tests/decoding/profile.schema +++ /dev/null @@ -1,87 +0,0 @@ -id,integer,f -password,character varying,f -last_login,timestamp with time zone,t -is_superuser,boolean,f -first_name,character varying,f -last_name,character varying,f -email,character varying,f -is_staff,boolean,f -is_active,boolean,f -date_joined,timestamp with time zone,f -gender,character varying,t -birthday,date,t -address,text,t -phone,text,t -income,double precision,t -employment,text,t -refresh_status,text,t -personal_info,text,t -username,character varying,f -preferences,text,t -is_real,boolean,f -tester_type,character varying,t -auto_saving,character varying,f -admin_notes,text,t -email_account_updates,boolean,f -email_features,boolean,f -push_alerts,boolean,f -referring_profile_id,integer,t -transactions_database,character varying,f -push_savings,boolean,f -push_trends,boolean,f -last_seen,timestamp with time zone,t -last_refresh,timestamp with time zone,t -recurring_savings_amount,double precision,t -savings_method,character varying,f -features,text,t -text_enabled,boolean,f -savings_halt,boolean,f -genius_status,character varying,t -genius_enabled,boolean,f -monthly_price,double precision,t -pricing_data,text,t -support_agent_id,integer,t -support_is_unread,boolean,f -support_status,character varying,t -payment_frequency,character varying,f -pause_rainy_day_fund,boolean,f -referral_campaign_id,integer,t -messaging_service,character varying,f -incoming_phone_number_id,integer,t -phone_number_data,text,t -is_spy,boolean,f -is_support_agent,boolean,f -allow_linking_duplicate_accounts,boolean,f -text_outreach,boolean,f -blacklist_phone,boolean,f -is_suspended,boolean,f -support_team_notes,text,t -primary_linking_provider,character varying,f -deactivation_in_progress,boolean,f -previous_last_seen,timestamp with time zone,t -billshark_info,text,t -balances_database,character varying,f -device_type_raw,character varying,t -deactivated_timestamp,timestamp with time zone,t -investment_info,text,t -is_email_verified,boolean,t -fraud_status,character varying,t -email_to_update,character varying,t -kyc_stage,character varying,t -phone_to_update,text,t -instant_info,text,t -text_opt_in,boolean,t -updated_at,timestamp with time zone,t -nickname,character varying,t -income_source,character varying,t -income_type,character varying,t -occupation,text,t -is_universal_cash,boolean,t -last_queued_refresh,timestamp with time zone,t -last_seen_app,timestamp with time zone,t -last_seen_web,timestamp with time zone,t -previous_last_seen_app,timestamp with time zone,t -previous_last_seen_web,timestamp with time zone,t -refresh_logs_database,character varying,t -finished_signup_flow_timestamp,timestamp with time zone,t -suspended_reason,character varying,t From 8a52b2c52402df8e0a174c5a44507237e3055aba Mon Sep 17 00:00:00 2001 From: Adam Lefevre Date: Tue, 9 Apr 2024 23:28:43 -0500 Subject: [PATCH 04/11] make tests actually check for equality and general clean up --- core/Cargo.toml | 1 - core/src/decoders.rs | 296 +++++++++++------- core/src/error.rs | 14 +- core/src/lib.rs | 90 +++--- core/src/pg_schema.rs | 255 +++++++-------- core/tests/decode_integration_tests.rs | 138 +++++--- core/tests/decoding/binary.schema | 1 - core/tests/decoding/binary_nullable.schema | 1 - core/tests/decoding/bool.schema | 2 +- core/tests/decoding/bool_nullable.schema | 2 +- core/tests/decoding/date32.schema | 2 +- core/tests/decoding/date32_nullable.schema | 2 +- core/tests/decoding/duration_us.schema | 2 +- .../decoding/duration_us_nullable.schema | 2 +- core/tests/decoding/float32.schema | 2 +- core/tests/decoding/float32_nullable.schema | 2 +- core/tests/decoding/float64.schema | 2 +- core/tests/decoding/float64_nullable.schema | 2 +- core/tests/decoding/int16.schema | 2 +- core/tests/decoding/int16_nullable.schema | 2 +- core/tests/decoding/int32.schema | 2 +- core/tests/decoding/int32_nullable.schema | 2 +- core/tests/decoding/int64.schema | 2 +- core/tests/decoding/int64_nullable | 2 +- core/tests/decoding/int64_nullable.schema | 2 +- core/tests/decoding/large_binary.schema | 1 + .../decoding/large_binary_nullable.schema | 1 + core/tests/decoding/large_string.schema | 1 + .../decoding/large_string_nullable.schema | 1 + core/tests/decoding/numeric.schema | 2 +- core/tests/decoding/numeric_nullable.schema | 2 +- core/tests/decoding/string.schema | 1 - core/tests/decoding/string_nullable.schema | 1 - core/tests/decoding/time_us.schema | 2 +- core/tests/decoding/time_us_nullable.schema | 2 +- core/tests/decoding/timestamp_us_notz.schema | 2 +- .../timestamp_us_notz_nullable.schema | 2 +- core/tests/decoding/timestamp_us_tz.schema | 2 +- .../decoding/timestamp_us_tz_nullable.schema | 2 +- py/src/pg_schema.rs | 1 + 40 files changed, 451 insertions(+), 402 deletions(-) delete mode 100644 core/tests/decoding/binary.schema delete mode 100644 core/tests/decoding/binary_nullable.schema create mode 100644 core/tests/decoding/large_binary.schema create mode 100644 core/tests/decoding/large_binary_nullable.schema create mode 100644 core/tests/decoding/large_string.schema create mode 100644 core/tests/decoding/large_string_nullable.schema delete mode 100644 core/tests/decoding/string.schema delete mode 100644 core/tests/decoding/string_nullable.schema diff --git a/core/Cargo.toml b/core/Cargo.toml index e458a8a..2e6d606 100644 --- a/core/Cargo.toml +++ b/core/Cargo.toml @@ -14,7 +14,6 @@ authors = ["Adrian Garcia Badaracco "] [dependencies] bytes = "^1.4.0" arrow-schema = ">=46.0.0" -arrow = ">=51.0.0" enum_dispatch = "0.3.11" anyhow = "1.0.70" thiserror = "1.0.40" diff --git a/core/src/decoders.rs b/core/src/decoders.rs index f8dcd93..36245f9 100644 --- a/core/src/decoders.rs +++ b/core/src/decoders.rs @@ -1,51 +1,44 @@ #![allow(clippy::redundant_closure_call)] -use arrow_array::{self, ArrayRef}; -use std::fmt::Debug; -use std::sync::Arc; use crate::encoders::{PG_BASE_DATE_OFFSET, PG_BASE_TIMESTAMP_OFFSET_US}; -use arrow_array::types::GenericBinaryType; use arrow_array::builder::GenericByteBuilder; +use arrow_array::types::GenericBinaryType; +use arrow_array::{self, ArrayRef}; use arrow_array::{ BooleanArray, Date32Array, DurationMicrosecondArray, Float32Array, Float64Array, - GenericStringArray, Int16Array, Int32Array, Int64Array, - Time64MicrosecondArray, TimestampMicrosecondArray + GenericStringArray, Int16Array, Int32Array, Int64Array, Time64MicrosecondArray, + TimestampMicrosecondArray, }; +use std::fmt::Debug; +use std::sync::Arc; use crate::error::ErrorKind; use crate::pg_schema::{PostgresSchema, PostgresType}; -pub(crate) struct ConsumableBuf<'a> { +pub(crate) struct BufferView<'a> { inner: &'a [u8], consumed: usize, } -impl Debug for ConsumableBuf<'_> { +impl Debug for BufferView<'_> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{:?}", &self.inner[self.consumed..]) } } -// const used for stringifying postgres decimals -const DEC_DIGITS: i16 = 4; -// const used for determining sign of numeric -const NUMERIC_NEG: i16 = 0x4000; - -impl ConsumableBuf<'_> { - pub fn new(inner: &'_ [u8]) -> ConsumableBuf<'_> { - ConsumableBuf { inner, consumed: 0 } +impl BufferView<'_> { + pub fn new(inner: &'_ [u8]) -> BufferView<'_> { + BufferView { inner, consumed: 0 } } pub fn consume_into_u32(&mut self) -> Result { if self.consumed + 4 > self.inner.len() { - return Err(ErrorKind::DataSize { - found: self.inner.len() - self.consumed, - expected: 4, - }); + return Err(ErrorKind::IncompleteData); } let res = u32::from_be_bytes( self.inner[self.consumed..self.consumed + 4] - .try_into().unwrap() + .try_into() + .unwrap(), ); self.consumed += 4; Ok(res) @@ -53,14 +46,12 @@ impl ConsumableBuf<'_> { pub fn consume_into_u16(&mut self) -> Result { if self.consumed + 2 > self.inner.len() { - return Err(ErrorKind::DataSize { - found: self.inner.len() - self.consumed, - expected: 2, - }); + return Err(ErrorKind::IncompleteData); } let res = u16::from_be_bytes( self.inner[self.consumed..self.consumed + 2] - .try_into().unwrap() + .try_into() + .unwrap(), ); self.consumed += 2; Ok(res) @@ -68,18 +59,12 @@ impl ConsumableBuf<'_> { pub fn consume_into_vec_n(&mut self, n: usize) -> Result, ErrorKind> { if self.consumed + n > self.inner.len() { - return Err(ErrorKind::DataSize { - found: self.inner.len() - self.consumed, - expected: n, - }); + return Err(ErrorKind::IncompleteData); } let data = self.inner[self.consumed..self.consumed + n].to_vec(); self.consumed += n; if data.len() != n { - return Err(ErrorKind::DataSize { - found: data.len(), - expected: n, - }); + return Err(ErrorKind::IncompleteData); } Ok(data) } @@ -98,29 +83,25 @@ impl ConsumableBuf<'_> { } pub(crate) trait Decode { - fn decode(&mut self, buf: &mut ConsumableBuf) -> Result<(), ErrorKind>; - fn finish(&mut self, column_len: usize) -> Result; + fn decode(&mut self, buf: &mut BufferView) -> Result<(), ErrorKind>; + fn finish(&mut self, column_len: usize) -> ArrayRef; fn column_len(&self) -> usize; - fn name(&self) -> &str; + fn name(&self) -> String; } macro_rules! impl_decode { ($struct_name:ident, $size:expr, $transform:expr, $array_kind:ident) => { impl Decode for $struct_name { - fn decode(&mut self, buf: &mut ConsumableBuf<'_>) -> Result<(), ErrorKind> { + fn decode(&mut self, buf: &mut BufferView<'_>) -> Result<(), ErrorKind> { let field_size = buf.consume_into_u32()?; if field_size == u32::MAX { self.arr.push(None); return Ok(()); } if field_size != $size { - return Err(ErrorKind::DataSize { - found: field_size as usize, - expected: $size, - }); + return Err(ErrorKind::IncompleteData); } - let data = buf.consume_into_vec_n(field_size as usize)?; // Unwrap is safe here because have checked the field size is the expected size // above @@ -131,19 +112,19 @@ macro_rules! impl_decode { Ok(()) } - fn name(&self) -> &str { - &self.name - } - fn column_len(&self) -> usize { self.arr.len() } - fn finish(&mut self, column_len: usize) -> Result { + fn name(&self) -> String { + self.name.to_string() + } + + fn finish(&mut self, column_len: usize) -> ArrayRef { let mut data = std::mem::take(&mut self.arr); data.resize(column_len, None); let array = Arc::new($array_kind::from(data)); - Ok(array as ArrayRef) + array as ArrayRef } } }; @@ -152,7 +133,7 @@ macro_rules! impl_decode { macro_rules! impl_decode_fallible { ($struct_name:ident, $size:expr, $transform:expr, $array_kind:ident) => { impl Decode for $struct_name { - fn decode(&mut self, buf: &mut ConsumableBuf<'_>) -> Result<(), ErrorKind> { + fn decode(&mut self, buf: &mut BufferView<'_>) -> Result<(), ErrorKind> { let field_size = buf.consume_into_u32()?; if field_size == u32::MAX { @@ -161,10 +142,7 @@ macro_rules! impl_decode_fallible { } if field_size != $size { - return Err(ErrorKind::DataSize { - found: field_size as usize, - expected: $size, - }); + return Err(ErrorKind::IncompleteData); } let data = buf.consume_into_vec_n(field_size as usize)?; @@ -189,19 +167,19 @@ macro_rules! impl_decode_fallible { Ok(()) } - fn name(&self) -> &str { - &self.name - } - fn column_len(&self) -> usize { self.arr.len() } - fn finish(&mut self, column_len: usize) -> Result { + fn name(&self) -> String { + self.name.to_string() + } + + fn finish(&mut self, column_len: usize) -> ArrayRef { let mut data = std::mem::take(&mut self.arr); data.resize(column_len, None); let array = Arc::new($array_kind::from(data)); - Ok(array as ArrayRef) + array as ArrayRef } } }; @@ -210,7 +188,7 @@ macro_rules! impl_decode_fallible { macro_rules! impl_decode_variable_size { ($struct_name:ident, $transform:expr, $extra_bytes:expr, $array_kind:ident, $offset_size:ident) => { impl Decode for $struct_name { - fn decode(&mut self, buf: &mut ConsumableBuf<'_>) -> Result<(), ErrorKind> { + fn decode(&mut self, buf: &mut BufferView<'_>) -> Result<(), ErrorKind> { let field_size = buf.consume_into_u32()?; if field_size == u32::MAX { self.arr.push(None); @@ -218,10 +196,7 @@ macro_rules! impl_decode_variable_size { } if field_size > buf.remaining() as u32 { - return Err(ErrorKind::DataSize { - found: buf.remaining() as usize, - expected: field_size as usize, - }); + return Err(ErrorKind::IncompleteData); } // Consume and any extra data that is not part of the field @@ -251,24 +226,25 @@ macro_rules! impl_decode_variable_size { Ok(()) } - fn name(&self) -> &str { - &self.name - } - fn column_len(&self) -> usize { self.arr.len() } - fn finish(&mut self, column_len: usize) -> Result { + fn name(&self) -> String { + self.name.to_string() + } + + fn finish(&mut self, column_len: usize) -> ArrayRef { let mut data = std::mem::take(&mut self.arr); data.resize(column_len, None); let array = Arc::new($array_kind::<$offset_size>::from(data)); - Ok(array as ArrayRef) + array as ArrayRef } } }; } +#[allow(dead_code)] pub struct BooleanDecoder { name: String, arr: Vec>, @@ -341,6 +317,50 @@ impl_decode_fallible!( TimestampMicrosecondArray ); +pub struct TimestampTzMicrosecondDecoder { + name: String, + arr: Vec>, + timezone: String, +} + +impl Decode for TimestampTzMicrosecondDecoder { + fn decode(&mut self, buf: &mut BufferView<'_>) -> Result<(), ErrorKind> { + let field_size = buf.consume_into_u32()?; + if field_size == u32::MAX { + self.arr.push(None); + return Ok(()); + } + + if field_size != 8 { + return Err(ErrorKind::IncompleteData); + } + + let data = buf.consume_into_vec_n(field_size as usize)?; + let timestamp_us = i64::from_be_bytes(data.try_into().unwrap()); + let timestamp_us = convert_pg_timestamp_to_arrow_timestamp_microseconds(timestamp_us)?; + self.arr.push(Some(timestamp_us)); + + Ok(()) + } + + fn column_len(&self) -> usize { + self.arr.len() + } + + fn name(&self) -> String { + self.name.to_string() + } + + fn finish(&mut self, column_len: usize) -> ArrayRef { + let mut data = std::mem::take(&mut self.arr); + data.resize(column_len, None); + let array = Arc::new( + TimestampMicrosecondArray::from(data).with_timezone(self.timezone.to_string()), + ); + array as ArrayRef + } +} + /// Convert Postgres dates (days since 2000-01-01) to Arrow dates (days since 1970-01-01) #[inline(always)] fn convert_pg_date_to_arrow_date(date: i32) -> Result { @@ -453,7 +473,7 @@ pub struct BinaryDecoder { } impl Decode for BinaryDecoder { - fn decode(&mut self, buf: &mut ConsumableBuf<'_>) -> Result<(), ErrorKind> { + fn decode(&mut self, buf: &mut BufferView<'_>) -> Result<(), ErrorKind> { let field_size = buf.consume_into_u32()?; if field_size == u32::MAX { self.arr.push(None); @@ -466,27 +486,26 @@ impl Decode for BinaryDecoder { Ok(()) } - fn name(&self) -> &str { - &self.name - } - fn column_len(&self) -> usize { self.arr.len() } - fn finish(&mut self, column_len: usize) -> Result { + fn name(&self) -> String { + self.name.to_string() + } + + fn finish(&mut self, column_len: usize) -> ArrayRef { let mut data = std::mem::take(&mut self.arr); data.resize(column_len, None); - let mut builder: GenericByteBuilder> = GenericByteBuilder::new(); + let mut builder: GenericByteBuilder> = GenericByteBuilder::new(); for v in data { match v { Some(v) => builder.append_value(v), None => builder.append_null(), } } - let array = Arc::new(builder.finish()); - Ok(array as ArrayRef) + Arc::new(builder.finish()) as ArrayRef } } @@ -510,6 +529,11 @@ impl_decode_variable_size!( i64 ); +// const used for stringifying postgres decimals +const DEC_DIGITS: i16 = 4; +// const used for determining sign of numeric +const NUMERIC_NEG: i16 = 0x4000; + /// Logic ported from src/backend/utils/adt/numeric.c:get_str_from_var fn parse_pg_decimal_to_string(data: Vec) -> Result { // Decimals will be decoded to strings since rust does not have a ubiquitos @@ -520,7 +544,10 @@ fn parse_pg_decimal_to_string(data: Vec) -> Result { let weight = i16::from_be_bytes(data[2..4].try_into().unwrap()); let sign = i16::from_be_bytes(data[4..6].try_into().unwrap()); let scale = i16::from_be_bytes(data[6..8].try_into().unwrap()); - let digits: Vec = data[8..8 + ndigits as usize].chunks(2).map(|c| i16::from_be_bytes(c.try_into().unwrap())).collect(); + let digits: Vec = data[8..8 + ndigits as usize] + .chunks(2) + .map(|c| i16::from_be_bytes(c.try_into().unwrap())) + .collect(); // the number of digits before the decimal place let pre_decimal = (weight + 1) * DEC_DIGITS; @@ -545,26 +572,30 @@ fn parse_pg_decimal_to_string(data: Vec) -> Result { // Otherwise put digits in the decimal string by computing the value for each place in decimal } else { while digits_index <= weight { - let mut dig = if digits_index < ndigits { digits[digits_index as usize] } else { 0 }; - let mut putit = digits_index > 0; - - /* below unwraps too: + let mut dig = if digits_index < ndigits { + digits[digits_index as usize] + } else { + 0 + }; + let mut putit = digits_index > 0; + + /* below unwraps too: d1 = dig / 1000; - dig -= d1 * 1000; - putit |= (d1 > 0); - if (putit) - *cp++ = d1 + '0'; - d1 = dig / 100; - dig -= d1 * 100; - putit |= (d1 > 0); - if (putit) - *cp++ = d1 + '0'; - d1 = dig / 10; - dig -= d1 * 10; - putit |= (d1 > 0); - if (putit) - *cp++ = d1 + '0'; - *cp++ = dig + '0'; + dig -= d1 * 1000; + putit |= (d1 > 0); + if (putit) + *cp++ = d1 + '0'; + d1 = dig / 100; + dig -= d1 * 100; + putit |= (d1 > 0); + if (putit) + *cp++ = d1 + '0'; + d1 = dig / 10; + dig -= d1 * 10; + putit |= (d1 > 0); + if (putit) + *cp++ = d1 + '0'; + *cp++ = dig + '0'; */ let mut place = 1000; @@ -572,7 +603,9 @@ fn parse_pg_decimal_to_string(data: Vec) -> Result { let d1 = dig / place; dig -= d1 * place; putit |= d1 > 0; - if putit { decimal.push(d1 as u8 + b'0') } + if putit { + decimal.push(d1 as u8 + b'0') + } place /= 10; } decimal.push(dig as u8 + b'0'); @@ -586,8 +619,12 @@ fn parse_pg_decimal_to_string(data: Vec) -> Result { } let mut i = 0; - while i < scale { - let mut dig = if digits_index >= 0 && digits_index < ndigits { digits[digits_index as usize] } else { 0 }; + while i < scale { + let mut dig = if digits_index >= 0 && digits_index < ndigits { + digits[digits_index as usize] + } else { + 0 + }; let mut place = 1000; // Same as the loop above but no putit since all digits prior to the // scale-TH digit are significant @@ -618,7 +655,6 @@ impl_decode_variable_size!( i64 ); - // pub enum Decoder { Boolean(BooleanDecoder), @@ -629,6 +665,7 @@ pub enum Decoder { Float64(Float64Decoder), Decimal(DecimalDecoder), TimestampMicrosecond(TimestampMicrosecondDecoder), + TimestampTzMicrosecond(TimestampTzMicrosecondDecoder), Date32(Date32Decoder), Time64Microsecond(Time64MicrosecondDecoder), DurationMicrosecond(DurationMicrosecondDecoder), @@ -666,15 +703,23 @@ impl Decoder { name: name.to_string(), arr: vec![], }), - PostgresType::Decimal => { - Decoder::Decimal(DecimalDecoder { name: name.to_string(), arr: vec![] }) - } + PostgresType::Decimal => Decoder::Decimal(DecimalDecoder { + name: name.to_string(), + arr: vec![], + }), PostgresType::Timestamp => { Decoder::TimestampMicrosecond(TimestampMicrosecondDecoder { name: name.to_string(), arr: vec![], }) } + PostgresType::TimestampTz(ref timezone) => { + Decoder::TimestampTzMicrosecond(TimestampTzMicrosecondDecoder { + name: name.to_string(), + arr: vec![], + timezone: timezone.to_string(), + }) + } PostgresType::Date => Decoder::Date32(Date32Decoder { name: name.to_string(), arr: vec![], @@ -689,10 +734,12 @@ impl Decoder { arr: vec![], }) } - PostgresType::Text | PostgresType::Char | PostgresType::Json => Decoder::String(StringDecoder { - name: name.to_string(), - arr: vec![], - }), + PostgresType::Text | PostgresType::Char | PostgresType::Json => { + Decoder::String(StringDecoder { + name: name.to_string(), + arr: vec![], + }) + } PostgresType::Bytea => Decoder::Binary(BinaryDecoder { name: name.to_string(), arr: vec![], @@ -702,7 +749,7 @@ impl Decoder { .collect() } - pub(crate) fn apply(&mut self, buf: &mut ConsumableBuf) -> Result<(), ErrorKind> { + pub(crate) fn apply(&mut self, buf: &mut BufferView) -> Result<(), ErrorKind> { match *self { Decoder::Boolean(ref mut decoder) => decoder.decode(buf), Decoder::Int16(ref mut decoder) => decoder.decode(buf), @@ -712,6 +759,7 @@ impl Decoder { Decoder::Float64(ref mut decoder) => decoder.decode(buf), Decoder::Decimal(ref mut decoder) => decoder.decode(buf), Decoder::TimestampMicrosecond(ref mut decoder) => decoder.decode(buf), + Decoder::TimestampTzMicrosecond(ref mut decoder) => decoder.decode(buf), Decoder::Date32(ref mut decoder) => decoder.decode(buf), Decoder::Time64Microsecond(ref mut decoder) => decoder.decode(buf), Decoder::DurationMicrosecond(ref mut decoder) => decoder.decode(buf), @@ -721,6 +769,26 @@ impl Decoder { } } + pub(crate) fn name(&self) -> String { + match *self { + Decoder::Boolean(ref decoder) => decoder.name(), + Decoder::Int16(ref decoder) => decoder.name(), + Decoder::Int32(ref decoder) => decoder.name(), + Decoder::Int64(ref decoder) => decoder.name(), + Decoder::Float32(ref decoder) => decoder.name(), + Decoder::Float64(ref decoder) => decoder.name(), + Decoder::Decimal(ref decoder) => decoder.name(), + Decoder::TimestampMicrosecond(ref decoder) => decoder.name(), + Decoder::TimestampTzMicrosecond(ref decoder) => decoder.name(), + Decoder::Date32(ref decoder) => decoder.name(), + Decoder::Time64Microsecond(ref decoder) => decoder.name(), + Decoder::DurationMicrosecond(ref decoder) => decoder.name(), + Decoder::String(ref decoder) => decoder.name(), + Decoder::Binary(ref decoder) => decoder.name(), + Decoder::Jsonb(ref decoder) => decoder.name(), + } + } + pub(crate) fn column_len(&self) -> usize { match *self { Decoder::Boolean(ref decoder) => decoder.column_len(), @@ -731,6 +799,7 @@ impl Decoder { Decoder::Float64(ref decoder) => decoder.column_len(), Decoder::Decimal(ref decoder) => decoder.column_len(), Decoder::TimestampMicrosecond(ref decoder) => decoder.column_len(), + Decoder::TimestampTzMicrosecond(ref decoder) => decoder.column_len(), Decoder::Date32(ref decoder) => decoder.column_len(), Decoder::Time64Microsecond(ref decoder) => decoder.column_len(), Decoder::DurationMicrosecond(ref decoder) => decoder.column_len(), @@ -740,7 +809,7 @@ impl Decoder { } } - pub(crate) fn finish(&mut self, column_len: usize) -> Result { + pub(crate) fn finish(&mut self, column_len: usize) -> ArrayRef { match *self { Decoder::Boolean(ref mut decoder) => decoder.finish(column_len), Decoder::Int16(ref mut decoder) => decoder.finish(column_len), @@ -750,6 +819,7 @@ impl Decoder { Decoder::Float64(ref mut decoder) => decoder.finish(column_len), Decoder::Decimal(ref mut decoder) => decoder.finish(column_len), Decoder::TimestampMicrosecond(ref mut decoder) => decoder.finish(column_len), + Decoder::TimestampTzMicrosecond(ref mut decoder) => decoder.finish(column_len), Decoder::Date32(ref mut decoder) => decoder.finish(column_len), Decoder::Time64Microsecond(ref mut decoder) => decoder.finish(column_len), Decoder::DurationMicrosecond(ref mut decoder) => decoder.finish(column_len), diff --git a/core/src/error.rs b/core/src/error.rs index 209875a..dbfcc57 100644 --- a/core/src/error.rs +++ b/core/src/error.rs @@ -1,4 +1,4 @@ -use arrow_schema::{DataType, ArrowError}; +use arrow_schema::{ArrowError, DataType}; use thiserror::Error; use crate::pg_schema::PostgresType; @@ -46,17 +46,13 @@ pub enum ErrorKind { Decode { reason: String, name: String }, #[error("Got invalid binary file header {bytes:?}")] InvalidBinaryHeader { bytes: [u8; 11] }, - #[error("Got invalid binary file trailer {bytes:?}")] - InvalidBinaryTrailer { bytes: [u8; 2] }, - #[error("Reached EOF before with incomplete data. Extra data: {remaining_bytes:?}")] + #[error("Reached EOF in the middle of a tuple. partial tuple: {remaining_bytes:?}")] IncompleteDecode { remaining_bytes: Vec }, - #[error("Got data of the wrong size: got: {found}, expected: {expected}")] - DataSize { found: usize, expected: usize }, + #[error("Expected data size was not found")] + IncompleteData, #[error("Invalid column specification: {spec}")] InvalidColumnSpec { spec: String }, - #[error("Extra data found at the end of the file")] - ExtraDataFound, - #[error("Invalid column type: {typ}")] + #[error("Invalid column type found while parsing schema: {typ}")] UnsupportedColumnType { typ: String }, #[error("Got an error in an IO Operation: {io_error:?}")] IOError { io_error: std::io::Error }, diff --git a/core/src/lib.rs b/core/src/lib.rs index 59839ea..f107497 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -1,19 +1,19 @@ use std::collections::HashMap; -use std::io::{Seek, BufRead}; +use std::io::{BufRead, Seek}; use arrow_array::{Array, RecordBatch}; use arrow_schema::Fields; use arrow_schema::Schema; -use bytes::{BufMut, BytesMut, Buf}; +use bytes::{Buf, BufMut, BytesMut}; use error::ErrorKind; +pub mod decoders; pub mod encoders; pub mod error; pub mod pg_schema; -pub mod decoders; +use crate::decoders::{BufferView, Decoder}; use crate::encoders::{BuildEncoder, Encode, EncoderBuilder}; -use crate::decoders::{Decoder, ConsumableBuf}; use crate::pg_schema::PostgresSchema; const HEADER_MAGIC_BYTES: &[u8] = b"PGCOPY\n\xff\r\n\0"; @@ -155,9 +155,9 @@ impl ArrowToPostgresBinaryEncoder { enum BatchDecodeResult { Batch(RecordBatch), - Incomplete, + Incomplete(usize), Error(ErrorKind), - PartialConsume{batch: RecordBatch, consumed: usize}, + PartialConsume { batch: RecordBatch, consumed: usize }, } pub struct PostgresBinaryToArrowDecoder { @@ -195,9 +195,7 @@ impl PostgresBinaryToArrowDecoder { Ok(()) } - pub fn decode_batches( - &mut self, - ) -> Result, ErrorKind> { + pub fn decode_batches(&mut self) -> Result, ErrorKind> { let mut batches = Vec::new(); let mut buf = BytesMut::with_capacity(self.capacity); let mut eof = false; @@ -243,15 +241,13 @@ impl PostgresBinaryToArrowDecoder { if !buf.is_empty() { match self.decode_batch(&mut buf) { BatchDecodeResult::Batch(batch) => batches.push(batch), - BatchDecodeResult::Incomplete => { + BatchDecodeResult::Error(e) => return Err(e), + BatchDecodeResult::Incomplete(consumed) + | BatchDecodeResult::PartialConsume { batch: _, consumed } => { return Err(ErrorKind::IncompleteDecode { - remaining_bytes: buf.to_vec(), + remaining_bytes: buf[consumed..].to_vec(), }) } - BatchDecodeResult::Error(e) => return Err(e), - BatchDecodeResult::PartialConsume{ batch: _, consumed: _} => { - return Err(ErrorKind::ExtraDataFound) - } } } self.state = EncoderState::Finished; @@ -261,27 +257,23 @@ impl PostgresBinaryToArrowDecoder { BatchDecodeResult::Batch(batch) => { batches.push(batch); buf.clear() - }, + } // If we receive a PartialConsume BatchDecodeResult, store the batches we did // manage to decode and continue reading from the source with the remaining // data from the previous read in the buffer. - BatchDecodeResult::PartialConsume{ batch, consumed } => { + BatchDecodeResult::PartialConsume { batch, consumed } => { batches.push(batch); let old_buf = buf; buf = BytesMut::with_capacity(self.capacity); buf.put(&old_buf[consumed..]); - }, + } // If we receive an Incomplete BatchDecodeResult, increase the capacity of the // buffer reading more data from the source and try to decode the batch again. - BatchDecodeResult::Incomplete => { + BatchDecodeResult::Incomplete(_) => { // println!("Increasing capacity to {}", self.capacity * 2); // increase the capacity attribute of the decoder by a factor of 2. + buf.reserve(self.capacity); self.capacity *= 2; - let old_buf = buf; - // create a new buffer with the new capacity. - buf = BytesMut::with_capacity(self.capacity); - // put all the data from the old buffer into the new buffer. - buf.put(old_buf); } BatchDecodeResult::Error(e) => return Err(e), } @@ -294,8 +286,8 @@ impl PostgresBinaryToArrowDecoder { // ensure that the decoder is in the correct state befpre proceeding. assert_eq!(self.state, EncoderState::Encoding); - // create a new ConsumableBuf from the buffer. - let mut local_buf = ConsumableBuf::new(buf); + // create a new BufferView from the buffer. + let mut local_buf = BufferView::new(buf); // Keep track of the number of rows in the batch. let mut rows = 0; @@ -321,7 +313,7 @@ impl PostgresBinaryToArrowDecoder { // If the tuple length is 0xffff we have reached the end of the // snapshot and we can break the loop and finish the batch. if tuple_len == 0xffff { - break + break; } // Each iteration of the loop reads a column from the tuple using the @@ -331,7 +323,7 @@ impl PostgresBinaryToArrowDecoder { // return a BatchDecodeResult::Incomplete. if local_buf.remaining() == 0 && rows == 0 { // println!("Incomplete no data remaining"); - return BatchDecodeResult::Incomplete; + return BatchDecodeResult::Incomplete(local_buf.consumed()); // If local_buf has been fully consumed and we have read some rows, // return a BatchDecodeResult::PartialConsume, passing the number of bytes // consumed before reading the tuple to the caller so it can know how much data @@ -340,32 +332,33 @@ impl PostgresBinaryToArrowDecoder { // println!("Partial consume no data remaining"); // println!("Finishing batch. Rows: {}", rows); return match self.finish_batch() { - Ok(batch) => BatchDecodeResult::PartialConsume{ batch, consumed}, + Ok(batch) => BatchDecodeResult::PartialConsume { batch, consumed }, Err(e) => BatchDecodeResult::Error(e), - } + }; } // Apply the decoder to the local_buf. Cosume the data from the buffer as needed match decoder.apply(&mut local_buf) { // If the decoder was able to decode the data, continue to the next column. Ok(_) => {} - // If we receive a DataSize error, we have reached the end of the data in - // the buffer. If we have not finished the current tuple - Err(ErrorKind::DataSize { found: _, expected: _ }) => { + // If we receive a IncompleteData error, we have reached the end of the data in + // the buffer. If we have decoded some tuples, return a BatchDecodeResult::PartialConsume, + // otherwise return a BatchDecodeResult::Incomplete. + Err(ErrorKind::IncompleteData) => { // If we have not read any rows, return a BatchDecodeResult::Incomplete. if rows == 0 { // println!("Incomplete mid-batch"); - return BatchDecodeResult::Incomplete; + return BatchDecodeResult::Incomplete(local_buf.consumed()); } else { // If we have read some rows, return a BatchDecodeResult::PartialConsume, // println!("Partial consume mid-batch"); // println!("Finishing batch. Rows: {}", rows); return match self.finish_batch() { - Ok(batch) => BatchDecodeResult::PartialConsume{ batch, consumed}, + Ok(batch) => BatchDecodeResult::PartialConsume { batch, consumed }, Err(e) => BatchDecodeResult::Error(e), - } + }; } - }, - Err(e) => return BatchDecodeResult::Error(e) + } + Err(e) => return BatchDecodeResult::Error(e), } } // Increment the number of rows in the batch. @@ -378,34 +371,27 @@ impl PostgresBinaryToArrowDecoder { Ok(batch) => BatchDecodeResult::Batch(batch), Err(e) => BatchDecodeResult::Error(e), } - } - fn finish_batch( - &mut self, - ) -> Result { - let mut columns: Vec> = Vec::new(); + fn finish_batch(&mut self) -> Result { // Find the mininum length column in the decoders. These can be different if // we are in a partial consume state. We will truncate the columns to the length // of the shortest column and pick up the lost data in the next batch. let column_len = self.decoders.iter().map(|d| d.column_len()).min().unwrap(); // For each decoder call its finish method to coerce the data into an Arrow array. // and append the array to the columns vector. - for decoder in self.decoders.iter_mut() { - match decoder.finish(column_len) { - Ok(array) => columns.push(array), - Err(e) => return Err(e) - } - } + let columns = self + .decoders + .iter_mut() + .map(|decoder| decoder.finish(column_len)) + .collect(); // Create a new RecordBatch from the columns vector and return it. - let record_batch = - RecordBatch::try_new(self.schema.clone().into(), columns)?; + let record_batch = RecordBatch::try_new(self.schema.clone().into(), columns)?; Ok(record_batch) } } - #[cfg(test)] mod tests { use std::{collections::HashMap, sync::Arc}; diff --git a/core/src/pg_schema.rs b/core/src/pg_schema.rs index 515dd7d..5a00c0a 100644 --- a/core/src/pg_schema.rs +++ b/core/src/pg_schema.rs @@ -1,6 +1,6 @@ -use arrow_schema::{Schema, Field, DataType, TimeUnit, SchemaRef}; -use std::sync::Arc; use crate::error::ErrorKind; +use arrow_schema::{DataType, Field, Schema, SchemaRef, TimeUnit}; +use std::sync::Arc; #[derive(Debug, Clone, PartialEq)] pub enum TypeSize { @@ -25,6 +25,7 @@ pub enum PostgresType { Date, Time, Timestamp, + TimestampTz(String), Interval, List(Box), } @@ -46,6 +47,7 @@ impl PostgresType { PostgresType::Date => TypeSize::Fixed(4), PostgresType::Time => TypeSize::Fixed(8), PostgresType::Timestamp => TypeSize::Fixed(8), + PostgresType::TimestampTz(_) => TypeSize::Fixed(8), PostgresType::Interval => TypeSize::Fixed(12), PostgresType::Decimal => TypeSize::Variable, PostgresType::List(_) => TypeSize::Variable, @@ -68,6 +70,7 @@ impl PostgresType { PostgresType::Date => Some(1082), PostgresType::Time => Some(1083), PostgresType::Timestamp => Some(1114), + PostgresType::TimestampTz(_) => Some(1182), PostgresType::Interval => Some(1186), PostgresType::List(_) => None, } @@ -89,6 +92,7 @@ impl PostgresType { PostgresType::Date => "DATE".to_string(), PostgresType::Time => "TIME".to_string(), PostgresType::Timestamp => "TIMESTAMP".to_string(), + PostgresType::TimestampTz(_) => "TIMESTAMP WITH ZONE".to_string(), PostgresType::Interval => "INTERVAL".to_string(), PostgresType::List(inner) => { // arrays of structs and such are not supported @@ -98,28 +102,6 @@ impl PostgresType { }; Some(v) } - - pub fn from_name(name: &str) -> Option { - match name { - "BOOL" => Some(PostgresType::Bool), - "BYTEA" => Some(PostgresType::Bytea), - "INT8" => Some(PostgresType::Int8), - "INT2" => Some(PostgresType::Int2), - "INT4" => Some(PostgresType::Int4), - "CHAR" => Some(PostgresType::Char), - "TEXT" => Some(PostgresType::Text), - "JSON" => Some(PostgresType::Json), - "JSONB" => Some(PostgresType::Jsonb), - "FLOAT4" => Some(PostgresType::Float4), - "FLOAT8" => Some(PostgresType::Float8), - "DECIMAL" => Some(PostgresType::Decimal), - "DATE" => Some(PostgresType::Date), - "TIME" => Some(PostgresType::Time), - "TIMESTAMP" => Some(PostgresType::Timestamp), - "INTERVAL" => Some(PostgresType::Interval), - _ => None, - } - } } impl From for DataType { @@ -140,13 +122,15 @@ impl From for DataType { PostgresType::Date => DataType::Date32, PostgresType::Time => DataType::Time64(TimeUnit::Microsecond), PostgresType::Timestamp => DataType::Timestamp(TimeUnit::Microsecond, None), + PostgresType::TimestampTz(timezone) => { + DataType::Timestamp(TimeUnit::Microsecond, Some(timezone.into())) + } PostgresType::Interval => DataType::Duration(TimeUnit::Microsecond), PostgresType::List(_) => unimplemented!(), } } } - #[derive(Debug, Clone, PartialEq)] pub struct Column { pub data_type: PostgresType, @@ -154,109 +138,80 @@ pub struct Column { } impl Column { - pub fn from_parts(type_str: &str, nullable: &str) -> Result { + pub fn from_parts(type_str: &str, nullable: &str, timezone: String) -> Result { match type_str { - "boolean" => { - Ok(Column { - data_type: PostgresType::Bool, - nullable: nullable == "t", - }) - }, - "bytea" => { - Ok(Column { - data_type: PostgresType::Bytea, - nullable: nullable == "t", - }) - }, - "bigint" => { - Ok(Column { - data_type: PostgresType::Int8, - nullable: nullable == "t", - }) - }, - "smallint" => { - Ok(Column { - data_type: PostgresType::Int2, - nullable: nullable == "t", - }) - }, - "integer" => { - Ok(Column { - data_type: PostgresType::Int4, - nullable: nullable == "t", - }) - }, - "character" | "character varying" => { - Ok(Column { - data_type: PostgresType::Char, - nullable: nullable == "t", - }) - }, - "text" => { - Ok(Column { - data_type: PostgresType::Text, - nullable: nullable == "t", - }) - }, - "json" => { - Ok(Column { - data_type: PostgresType::Json, - nullable: nullable == "t", - }) - }, - "jsonb" => { - Ok(Column { - data_type: PostgresType::Jsonb, - nullable: nullable == "t", - }) - }, - "real" => { - Ok(Column { - data_type: PostgresType::Float4, - nullable: nullable == "t", - }) - }, - "double precision" => { - Ok(Column { - data_type: PostgresType::Float8, - nullable: nullable == "t", - }) - }, - "numeric" => { - Ok(Column { - data_type: PostgresType::Decimal, - nullable: nullable == "t", - }) - }, - "date" => { - Ok(Column { - data_type: PostgresType::Date, - nullable: nullable == "t", - }) - }, - "time" => { - Ok(Column { - data_type: PostgresType::Time, - nullable: nullable == "t", - }) - }, - "timestamp with time zone" | "timestamp without time zone" => { - Ok(Column { - data_type: PostgresType::Timestamp, - nullable: nullable == "t", - }) - }, - "interval" => { - Ok(Column { - data_type: PostgresType::Interval, - nullable: nullable == "t", - }) - }, - _ => { - Err(ErrorKind::UnsupportedColumnType { typ: type_str.to_string() }) - } + "boolean" => Ok(Column { + data_type: PostgresType::Bool, + nullable: nullable == "t", + }), + "bytea" => Ok(Column { + data_type: PostgresType::Bytea, + nullable: nullable == "t", + }), + "bigint" => Ok(Column { + data_type: PostgresType::Int8, + nullable: nullable == "t", + }), + "smallint" => Ok(Column { + data_type: PostgresType::Int2, + nullable: nullable == "t", + }), + "integer" => Ok(Column { + data_type: PostgresType::Int4, + nullable: nullable == "t", + }), + "character" | "character varying" => Ok(Column { + data_type: PostgresType::Char, + nullable: nullable == "t", + }), + "text" => Ok(Column { + data_type: PostgresType::Text, + nullable: nullable == "t", + }), + "json" => Ok(Column { + data_type: PostgresType::Json, + nullable: nullable == "t", + }), + "jsonb" => Ok(Column { + data_type: PostgresType::Jsonb, + nullable: nullable == "t", + }), + "real" => Ok(Column { + data_type: PostgresType::Float4, + nullable: nullable == "t", + }), + "double precision" => Ok(Column { + data_type: PostgresType::Float8, + nullable: nullable == "t", + }), + "numeric" => Ok(Column { + data_type: PostgresType::Decimal, + nullable: nullable == "t", + }), + "date" => Ok(Column { + data_type: PostgresType::Date, + nullable: nullable == "t", + }), + "time" => Ok(Column { + data_type: PostgresType::Time, + nullable: nullable == "t", + }), + "timestamp without time zone" => Ok(Column { + data_type: PostgresType::Timestamp, + nullable: nullable == "t", + }), + "timestamp with time zone" => Ok(Column { + data_type: PostgresType::TimestampTz(timezone), + nullable: nullable == "t", + }), + "interval" => Ok(Column { + data_type: PostgresType::Interval, + nullable: nullable == "t", + }), + _ => Err(ErrorKind::UnsupportedColumnType { + typ: type_str.to_string(), + }), } - } } @@ -265,38 +220,46 @@ pub struct PostgresSchema { pub columns: Vec<(String, Column)>, } - impl From for SchemaRef { fn from(pg_schema: PostgresSchema) -> Self { - let fields: Vec = pg_schema.columns.iter().map(|(name, col)| { - Field::new(name, col.data_type.clone().into(), col.nullable) - }).collect(); + let fields: Vec = pg_schema + .columns + .iter() + .map(|(name, col)| Field::new(name, col.data_type.clone().into(), col.nullable)) + .collect(); Arc::new(Schema::new(fields)) } } impl PostgresSchema { - pub fn from_reader(mut reader: R, delim: char) -> Result { + pub fn from_reader( + mut reader: R, + delim: char, + timezone: String, + ) -> Result { let mut schema_str = String::new(); reader.read_to_string(&mut schema_str)?; - let schema = schema_str.split('\n').filter(|s| !s.is_empty()).map(|s|{ - let parts: Vec<&str> = s.splitn(3, delim).collect(); - if parts.len() != 3 { - return Err(ErrorKind::InvalidColumnSpec{spec: s.to_string()}); - } - let name = parts[0]; - let typ = parts[1]; - let nullable = parts[2]; - let col = Column::from_parts(typ, nullable)?; - Ok((name.to_string(), col)) - }).collect::, ErrorKind>>().map(|columns| { - PostgresSchema { columns } - - })?; + let schema = schema_str + .split('\n') + .filter(|s| !s.is_empty()) + .map(|s| { + let parts: Vec<&str> = s.splitn(3, delim).collect(); + if parts.len() != 3 { + return Err(ErrorKind::InvalidColumnSpec { + spec: s.to_string(), + }); + } + let name = parts[0]; + let typ = parts[1]; + let nullable = parts[2]; + let col = Column::from_parts(typ, nullable, timezone.to_string())?; + Ok((name.to_string(), col)) + }) + .collect::, ErrorKind>>() + .map(|columns| PostgresSchema { columns })?; Ok(schema) - } pub fn iter(&self) -> impl Iterator { diff --git a/core/tests/decode_integration_tests.rs b/core/tests/decode_integration_tests.rs index ce6a294..05406eb 100644 --- a/core/tests/decode_integration_tests.rs +++ b/core/tests/decode_integration_tests.rs @@ -1,17 +1,26 @@ +use arrow_array::RecordBatch; +use arrow_ipc::reader::FileReader; +use arrow_schema::{Field, Schema}; +use pgpq::error::ErrorKind; use std::fs::File; -use std::path::PathBuf; use std::io::BufReader; -use pgpq::error::ErrorKind; - -use pgpq::{PostgresBinaryToArrowDecoder, pg_schema::PostgresSchema}; +use std::path::PathBuf; +use std::sync::Arc; +use pgpq::{pg_schema::PostgresSchema, PostgresBinaryToArrowDecoder}; -const KB: usize = 1024* 512; +const READ_CHUNK_SIZE: usize = 1024 * 8; fn read_schema_file(path: PathBuf) -> PostgresSchema { let file = File::open(path).unwrap(); let reader = BufReader::new(file); - PostgresSchema::from_reader(reader, ',').unwrap() + PostgresSchema::from_reader(reader, ',', "America/New_York".to_string()).unwrap() +} + +fn read_arrow_file(path: PathBuf) -> Vec { + let file = File::open(path).unwrap(); + let reader = FileReader::try_new(file, None).unwrap(); + reader.collect::, _>>().unwrap() } fn run_test_case(case: &str) -> Result<(), ErrorKind> { @@ -19,177 +28,202 @@ fn run_test_case(case: &str) -> Result<(), ErrorKind> { PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!("tests/snapshots/{case}.bin")); let schema_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!("tests/decoding/{case}.schema")); + let arrow_path = + PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!("tests/testdata/{case}.arrow")); + let file = File::open(path).unwrap(); - let reader = BufReader::with_capacity(KB, file); + let reader = BufReader::with_capacity(READ_CHUNK_SIZE, file); let schema = read_schema_file(schema_path); - println!("{:?}", schema); - let mut decoder = PostgresBinaryToArrowDecoder::new(schema, reader, KB).unwrap(); + + let mut decoder = PostgresBinaryToArrowDecoder::new(schema, reader, READ_CHUNK_SIZE).unwrap(); decoder.read_header()?; - let batches = decoder.decode_batches()?; - println!("{:?}", batches); + let batches = decoder.decode_batches()?; + + let mut expected_batches = read_arrow_file(arrow_path); + + // all testdata currently has nullable set where it should not. + // This is a workaround to make the test pass. + if !case.contains("nullable") { + expected_batches = expected_batches + .into_iter() + .map(|batch| { + let new_fields: Vec> = (*(*batch.schema()).clone().fields) + .to_vec() + .clone() + .into_iter() + .map(|f| Arc::new((*f).clone().with_nullable(false))) + .collect(); + let new_schema = Schema::new(new_fields); + println!("{:?}", new_schema); + RecordBatch::try_new(Arc::new(new_schema), batch.columns().to_vec()).unwrap() + }) + .collect::>(); + } + + assert_eq!(batches.len(), expected_batches.len()); + assert_eq!(batches, expected_batches); + Ok(()) } - #[test] fn test_bool() -> Result<(), ErrorKind> { run_test_case("bool")?; - Ok(()) + Ok(()) } #[test] fn test_int16() -> Result<(), ErrorKind> { run_test_case("int16")?; - Ok(()) + Ok(()) } #[test] fn test_int32() -> Result<(), ErrorKind> { run_test_case("int32")?; - Ok(()) + Ok(()) } #[test] fn test_int64() -> Result<(), ErrorKind> { run_test_case("int64")?; - Ok(()) + Ok(()) } #[test] fn test_float32() -> Result<(), ErrorKind> { run_test_case("float32")?; - Ok(()) + Ok(()) } #[test] fn test_float64() -> Result<(), ErrorKind> { run_test_case("float64")?; - Ok(()) + Ok(()) } #[test] fn test_timestamp_us_notz() -> Result<(), ErrorKind> { run_test_case("timestamp_us_notz")?; - Ok(()) + Ok(()) } #[test] fn test_timestamp_us_tz() -> Result<(), ErrorKind> { run_test_case("timestamp_us_tz")?; - Ok(()) + Ok(()) } #[test] fn test_time_us() -> Result<(), ErrorKind> { run_test_case("time_us")?; - Ok(()) + Ok(()) } #[test] fn test_date32() -> Result<(), ErrorKind> { run_test_case("date32")?; - Ok(()) + Ok(()) } #[test] fn test_duration_us() -> Result<(), ErrorKind> { run_test_case("duration_us")?; - Ok(()) + Ok(()) } - #[test] -fn test_binary() -> Result<(), ErrorKind> { - run_test_case("binary")?; - Ok(()) +fn test_large_binary() -> Result<(), ErrorKind> { + run_test_case("large_binary")?; + Ok(()) } #[test] -fn test_string() -> Result<(), ErrorKind> { - run_test_case("string")?; - Ok(()) +fn test_large_string() -> Result<(), ErrorKind> { + run_test_case("large_string")?; + Ok(()) } #[test] fn test_bool_nullable() -> Result<(), ErrorKind> { run_test_case("bool_nullable")?; - Ok(()) + Ok(()) } #[test] fn test_int16_nullable() -> Result<(), ErrorKind> { run_test_case("int16_nullable")?; - Ok(()) + Ok(()) } #[test] fn test_int32_nullable() -> Result<(), ErrorKind> { run_test_case("int32_nullable")?; - Ok(()) + Ok(()) } #[test] fn test_int64_nullable() -> Result<(), ErrorKind> { run_test_case("int64_nullable")?; - Ok(()) + Ok(()) } #[test] fn test_float32_nullable() -> Result<(), ErrorKind> { run_test_case("float32_nullable")?; - Ok(()) + Ok(()) } #[test] fn test_float64_nullable() -> Result<(), ErrorKind> { run_test_case("float64_nullable")?; - Ok(()) + Ok(()) } #[test] fn test_timestamp_us_notz_nullable() -> Result<(), ErrorKind> { run_test_case("timestamp_us_notz_nullable")?; - Ok(()) + Ok(()) } #[test] fn test_timestamp_us_tz_nullable() -> Result<(), ErrorKind> { run_test_case("timestamp_us_tz_nullable")?; - Ok(()) + Ok(()) } #[test] fn test_time_us_nullable() -> Result<(), ErrorKind> { run_test_case("time_us_nullable")?; - Ok(()) + Ok(()) } #[test] fn test_date32_nullable() -> Result<(), ErrorKind> { run_test_case("date32_nullable")?; - Ok(()) + Ok(()) } #[test] fn test_duration_us_nullable() -> Result<(), ErrorKind> { run_test_case("duration_us_nullable")?; - Ok(()) + Ok(()) } #[test] -fn test_binary_nullable() -> Result<(), ErrorKind> { - run_test_case("binary_nullable")?; - Ok(()) +fn test_large_binary_nullable() -> Result<(), ErrorKind> { + run_test_case("large_binary_nullable")?; + Ok(()) } #[test] -fn test_string_nullable() -> Result<(), ErrorKind> { - run_test_case("string_nullable")?; - Ok(()) +fn test_large_string_nullable() -> Result<(), ErrorKind> { + run_test_case("large_string_nullable")?; + Ok(()) } -// #[test] -// fn test_profile() -> Result<(), ErrorKind> { -// run_test_case("profile")?; -// Ok(()) -// } +//#[test] +//fn test_profile() -> Result<(), ErrorKind> { +// run_test_case("profile")?; +// Ok(()) +//} diff --git a/core/tests/decoding/binary.schema b/core/tests/decoding/binary.schema deleted file mode 100644 index a1647a6..0000000 --- a/core/tests/decoding/binary.schema +++ /dev/null @@ -1 +0,0 @@ -binary_column,bytea,f \ No newline at end of file diff --git a/core/tests/decoding/binary_nullable.schema b/core/tests/decoding/binary_nullable.schema deleted file mode 100644 index 0dcd30f..0000000 --- a/core/tests/decoding/binary_nullable.schema +++ /dev/null @@ -1 +0,0 @@ -binary_column,bytea,t \ No newline at end of file diff --git a/core/tests/decoding/bool.schema b/core/tests/decoding/bool.schema index 7894e7f..a0e6dbf 100644 --- a/core/tests/decoding/bool.schema +++ b/core/tests/decoding/bool.schema @@ -1 +1 @@ -bool_column,boolean,f \ No newline at end of file +bool,boolean,f \ No newline at end of file diff --git a/core/tests/decoding/bool_nullable.schema b/core/tests/decoding/bool_nullable.schema index 320990b..5e11eac 100644 --- a/core/tests/decoding/bool_nullable.schema +++ b/core/tests/decoding/bool_nullable.schema @@ -1 +1 @@ -bool_column,boolean,t \ No newline at end of file +bool_nullable,boolean,t diff --git a/core/tests/decoding/date32.schema b/core/tests/decoding/date32.schema index 953ab7d..9fb0ee6 100644 --- a/core/tests/decoding/date32.schema +++ b/core/tests/decoding/date32.schema @@ -1 +1 @@ -date32_column,date,f \ No newline at end of file +date32,date,f \ No newline at end of file diff --git a/core/tests/decoding/date32_nullable.schema b/core/tests/decoding/date32_nullable.schema index 0211de2..f0082d7 100644 --- a/core/tests/decoding/date32_nullable.schema +++ b/core/tests/decoding/date32_nullable.schema @@ -1 +1 @@ -date32_column,date,t \ No newline at end of file +date32_nullable,date,t diff --git a/core/tests/decoding/duration_us.schema b/core/tests/decoding/duration_us.schema index af9e599..64fd6f8 100644 --- a/core/tests/decoding/duration_us.schema +++ b/core/tests/decoding/duration_us.schema @@ -1 +1 @@ -duration_us_column,interval,f \ No newline at end of file +duration_us,interval,f \ No newline at end of file diff --git a/core/tests/decoding/duration_us_nullable.schema b/core/tests/decoding/duration_us_nullable.schema index f251662..8a013b7 100644 --- a/core/tests/decoding/duration_us_nullable.schema +++ b/core/tests/decoding/duration_us_nullable.schema @@ -1 +1 @@ -duration_us_column,interval,t \ No newline at end of file +duration_us_nullable,interval,t diff --git a/core/tests/decoding/float32.schema b/core/tests/decoding/float32.schema index fce1061..1905873 100644 --- a/core/tests/decoding/float32.schema +++ b/core/tests/decoding/float32.schema @@ -1 +1 @@ -float32_column,real,f \ No newline at end of file +float32,real,f \ No newline at end of file diff --git a/core/tests/decoding/float32_nullable.schema b/core/tests/decoding/float32_nullable.schema index 38f5f7e..b3708a9 100644 --- a/core/tests/decoding/float32_nullable.schema +++ b/core/tests/decoding/float32_nullable.schema @@ -1 +1 @@ -float32_column,real,t \ No newline at end of file +float32_nullable,real,t diff --git a/core/tests/decoding/float64.schema b/core/tests/decoding/float64.schema index 9178796..9c68dd4 100644 --- a/core/tests/decoding/float64.schema +++ b/core/tests/decoding/float64.schema @@ -1 +1 @@ -float64_column,double precision,f \ No newline at end of file +float64,double precision,f \ No newline at end of file diff --git a/core/tests/decoding/float64_nullable.schema b/core/tests/decoding/float64_nullable.schema index 78c59d5..a8e547c 100644 --- a/core/tests/decoding/float64_nullable.schema +++ b/core/tests/decoding/float64_nullable.schema @@ -1 +1 @@ -float64_column,double precision,t \ No newline at end of file +float64_nullable,double precision,t diff --git a/core/tests/decoding/int16.schema b/core/tests/decoding/int16.schema index fcd83d9..fa3f2bd 100644 --- a/core/tests/decoding/int16.schema +++ b/core/tests/decoding/int16.schema @@ -1 +1 @@ -int16_column,smallint,f \ No newline at end of file +int16,smallint,f \ No newline at end of file diff --git a/core/tests/decoding/int16_nullable.schema b/core/tests/decoding/int16_nullable.schema index 06fc20a..9eb14de 100644 --- a/core/tests/decoding/int16_nullable.schema +++ b/core/tests/decoding/int16_nullable.schema @@ -1 +1 @@ -int16_column,smallint,t \ No newline at end of file +int16_nullable,smallint,t diff --git a/core/tests/decoding/int32.schema b/core/tests/decoding/int32.schema index d464e55..6409207 100644 --- a/core/tests/decoding/int32.schema +++ b/core/tests/decoding/int32.schema @@ -1 +1 @@ -int32_column,integer,f \ No newline at end of file +int32,integer,f \ No newline at end of file diff --git a/core/tests/decoding/int32_nullable.schema b/core/tests/decoding/int32_nullable.schema index 83a6a32..e88df62 100644 --- a/core/tests/decoding/int32_nullable.schema +++ b/core/tests/decoding/int32_nullable.schema @@ -1 +1 @@ -int32_column,integer,t \ No newline at end of file +int32_nullable,integer,t diff --git a/core/tests/decoding/int64.schema b/core/tests/decoding/int64.schema index 17b12d4..fc3fd4c 100644 --- a/core/tests/decoding/int64.schema +++ b/core/tests/decoding/int64.schema @@ -1 +1 @@ -int64_column,bigint,f \ No newline at end of file +int64,bigint,f \ No newline at end of file diff --git a/core/tests/decoding/int64_nullable b/core/tests/decoding/int64_nullable index 22fad18..4215f43 100644 --- a/core/tests/decoding/int64_nullable +++ b/core/tests/decoding/int64_nullable @@ -1 +1 @@ -int64_column,bigint,t +int64,bigint,t diff --git a/core/tests/decoding/int64_nullable.schema b/core/tests/decoding/int64_nullable.schema index 5809adb..7f0fdab 100644 --- a/core/tests/decoding/int64_nullable.schema +++ b/core/tests/decoding/int64_nullable.schema @@ -1 +1 @@ -int64_column,bigint,t \ No newline at end of file +int64_nullable,bigint,t diff --git a/core/tests/decoding/large_binary.schema b/core/tests/decoding/large_binary.schema new file mode 100644 index 0000000..1f89ade --- /dev/null +++ b/core/tests/decoding/large_binary.schema @@ -0,0 +1 @@ +large_binary,bytea,f diff --git a/core/tests/decoding/large_binary_nullable.schema b/core/tests/decoding/large_binary_nullable.schema new file mode 100644 index 0000000..678b1d1 --- /dev/null +++ b/core/tests/decoding/large_binary_nullable.schema @@ -0,0 +1 @@ +large_binary_nullable,bytea,t diff --git a/core/tests/decoding/large_string.schema b/core/tests/decoding/large_string.schema new file mode 100644 index 0000000..8862a5f --- /dev/null +++ b/core/tests/decoding/large_string.schema @@ -0,0 +1 @@ +large_string,text,f diff --git a/core/tests/decoding/large_string_nullable.schema b/core/tests/decoding/large_string_nullable.schema new file mode 100644 index 0000000..c9e5b40 --- /dev/null +++ b/core/tests/decoding/large_string_nullable.schema @@ -0,0 +1 @@ +large_string_nullable,text,t diff --git a/core/tests/decoding/numeric.schema b/core/tests/decoding/numeric.schema index 0ea6b82..ce2108f 100644 --- a/core/tests/decoding/numeric.schema +++ b/core/tests/decoding/numeric.schema @@ -1 +1 @@ -numeric_column,numeric,f \ No newline at end of file +numeric,numeric,f \ No newline at end of file diff --git a/core/tests/decoding/numeric_nullable.schema b/core/tests/decoding/numeric_nullable.schema index 9d7cb11..32445c4 100644 --- a/core/tests/decoding/numeric_nullable.schema +++ b/core/tests/decoding/numeric_nullable.schema @@ -1 +1 @@ -numeric_column,numeric,t \ No newline at end of file +numeric_nullable,numeric,t diff --git a/core/tests/decoding/string.schema b/core/tests/decoding/string.schema deleted file mode 100644 index 9ebee6f..0000000 --- a/core/tests/decoding/string.schema +++ /dev/null @@ -1 +0,0 @@ -string_column,text,f \ No newline at end of file diff --git a/core/tests/decoding/string_nullable.schema b/core/tests/decoding/string_nullable.schema deleted file mode 100644 index 924fcc9..0000000 --- a/core/tests/decoding/string_nullable.schema +++ /dev/null @@ -1 +0,0 @@ -string_column,text,t \ No newline at end of file diff --git a/core/tests/decoding/time_us.schema b/core/tests/decoding/time_us.schema index 2ef9fa4..e327d79 100644 --- a/core/tests/decoding/time_us.schema +++ b/core/tests/decoding/time_us.schema @@ -1 +1 @@ -time_us_column,time,f \ No newline at end of file +time_us,time,f \ No newline at end of file diff --git a/core/tests/decoding/time_us_nullable.schema b/core/tests/decoding/time_us_nullable.schema index 029177e..8e6d71f 100644 --- a/core/tests/decoding/time_us_nullable.schema +++ b/core/tests/decoding/time_us_nullable.schema @@ -1 +1 @@ -time_us_column,time,t \ No newline at end of file +time_us_nullable,time,t diff --git a/core/tests/decoding/timestamp_us_notz.schema b/core/tests/decoding/timestamp_us_notz.schema index fee451f..705cf01 100644 --- a/core/tests/decoding/timestamp_us_notz.schema +++ b/core/tests/decoding/timestamp_us_notz.schema @@ -1 +1 @@ -timestamp_us_no_tz_column,timestamp without time zone,f \ No newline at end of file +timestamp_us_notz,timestamp without time zone,f diff --git a/core/tests/decoding/timestamp_us_notz_nullable.schema b/core/tests/decoding/timestamp_us_notz_nullable.schema index 4aebe00..1a3360a 100644 --- a/core/tests/decoding/timestamp_us_notz_nullable.schema +++ b/core/tests/decoding/timestamp_us_notz_nullable.schema @@ -1 +1 @@ -timestamp_us_no_tz_column,timestamp without time zone,t \ No newline at end of file +timestamp_us_notz_nullable,timestamp without time zone,t diff --git a/core/tests/decoding/timestamp_us_tz.schema b/core/tests/decoding/timestamp_us_tz.schema index 56a23d1..64ec24b 100644 --- a/core/tests/decoding/timestamp_us_tz.schema +++ b/core/tests/decoding/timestamp_us_tz.schema @@ -1 +1 @@ -timestamp_us_tz_column,timestamp with time zone,f \ No newline at end of file +timestamp_us_tz,timestamp with time zone,f \ No newline at end of file diff --git a/core/tests/decoding/timestamp_us_tz_nullable.schema b/core/tests/decoding/timestamp_us_tz_nullable.schema index d18fd98..e16aede 100644 --- a/core/tests/decoding/timestamp_us_tz_nullable.schema +++ b/core/tests/decoding/timestamp_us_tz_nullable.schema @@ -1 +1 @@ -timestamp_us_tz_column,timestamp with time zone,t \ No newline at end of file +timestamp_us_tz_nullable,timestamp with time zone,t diff --git a/py/src/pg_schema.rs b/py/src/pg_schema.rs index c5f5a41..5588a58 100644 --- a/py/src/pg_schema.rs +++ b/py/src/pg_schema.rs @@ -229,6 +229,7 @@ impl From for PostgresType { pgpq::pg_schema::PostgresType::Time => PostgresType::Time(Time), pgpq::pg_schema::PostgresType::Timestamp => PostgresType::Timestamp(Timestamp), pgpq::pg_schema::PostgresType::Interval => PostgresType::Interval(Interval), + pgpq::pg_schema::PostgresType::Decimal => todo!(), pgpq::pg_schema::PostgresType::List(inner) => { PostgresType::List(List::new((*inner).into())) } From eefe8bab6351fd3306b24dc3e51d25afebc4d9b1 Mon Sep 17 00:00:00 2001 From: Adam Lefevre Date: Sun, 14 Apr 2024 16:36:46 -0500 Subject: [PATCH 05/11] test numeric and numeric nullable --- core/src/decoders.rs | 142 +++++++++++++----- core/src/lib.rs | 16 +- core/src/pg_schema.rs | 36 +++-- core/tests/decode_integration_tests.rs | 91 ++++++----- core/tests/decoding/binary.schema | 1 + core/tests/decoding/binary_nullable.schema | 1 + core/tests/decoding/large_binary.schema | 1 - .../decoding/large_binary_nullable.schema | 1 - core/tests/decoding/large_string.schema | 1 - .../decoding/large_string_nullable.schema | 1 - core/tests/decoding/string.schema | 1 + core/tests/decoding/string_nullable.schema | 1 + core/tests/snapshots/numeric.bin | Bin 0 -> 177 bytes core/tests/snapshots/numeric_nullable.bin | Bin 0 -> 183 bytes core/tests/testdata/numeric.arrow | Bin 0 -> 1570 bytes core/tests/testdata/numeric_nullable.arrow | Bin 0 -> 618 bytes core/tests/testdata/profile_nullable.arrow | Bin 0 -> 2055354 bytes 17 files changed, 199 insertions(+), 94 deletions(-) create mode 100644 core/tests/decoding/binary.schema create mode 100644 core/tests/decoding/binary_nullable.schema delete mode 100644 core/tests/decoding/large_binary.schema delete mode 100644 core/tests/decoding/large_binary_nullable.schema delete mode 100644 core/tests/decoding/large_string.schema delete mode 100644 core/tests/decoding/large_string_nullable.schema create mode 100644 core/tests/decoding/string.schema create mode 100644 core/tests/decoding/string_nullable.schema create mode 100644 core/tests/snapshots/numeric.bin create mode 100644 core/tests/snapshots/numeric_nullable.bin create mode 100644 core/tests/testdata/numeric.arrow create mode 100644 core/tests/testdata/numeric_nullable.arrow create mode 100644 core/tests/testdata/profile_nullable.arrow diff --git a/core/src/decoders.rs b/core/src/decoders.rs index 36245f9..593ec8f 100644 --- a/core/src/decoders.rs +++ b/core/src/decoders.rs @@ -7,7 +7,7 @@ use arrow_array::{self, ArrayRef}; use arrow_array::{ BooleanArray, Date32Array, DurationMicrosecondArray, Float32Array, Float64Array, GenericStringArray, Int16Array, Int32Array, Int64Array, Time64MicrosecondArray, - TimestampMicrosecondArray, + TimestampMicrosecondArray, NullArray }; use std::fmt::Debug; use std::sync::Arc; @@ -87,6 +87,7 @@ pub(crate) trait Decode { fn finish(&mut self, column_len: usize) -> ArrayRef; fn column_len(&self) -> usize; fn name(&self) -> String; + fn is_null(&self) -> bool; } macro_rules! impl_decode { @@ -121,11 +122,18 @@ macro_rules! impl_decode { } fn finish(&mut self, column_len: usize) -> ArrayRef { - let mut data = std::mem::take(&mut self.arr); - data.resize(column_len, None); + self.arr.resize(column_len, None); + if self.is_null() { + return Arc::new(NullArray::new(self.arr.len())) as ArrayRef; + } + let data = std::mem::take(&mut self.arr); let array = Arc::new($array_kind::from(data)); array as ArrayRef } + + fn is_null(&self) -> bool { + self.arr.iter().all(|v| v.is_none()) + } } }; } @@ -176,11 +184,18 @@ macro_rules! impl_decode_fallible { } fn finish(&mut self, column_len: usize) -> ArrayRef { - let mut data = std::mem::take(&mut self.arr); - data.resize(column_len, None); + self.arr.resize(column_len, None); + if self.is_null() { + return Arc::new(NullArray::new(self.arr.len())) as ArrayRef; + } + let data = std::mem::take(&mut self.arr); let array = Arc::new($array_kind::from(data)); array as ArrayRef } + + fn is_null(&self) -> bool { + self.arr.iter().all(|v| v.is_none()) + } } }; } @@ -235,11 +250,18 @@ macro_rules! impl_decode_variable_size { } fn finish(&mut self, column_len: usize) -> ArrayRef { - let mut data = std::mem::take(&mut self.arr); - data.resize(column_len, None); + self.arr.resize(column_len, None); + if self.is_null() { + return Arc::new(NullArray::new(self.arr.len())) as ArrayRef; + } + let data = std::mem::take(&mut self.arr); let array = Arc::new($array_kind::<$offset_size>::from(data)); array as ArrayRef } + + fn is_null(&self) -> bool { + self.arr.iter().all(|v| v.is_none()) + } } }; } @@ -293,7 +315,6 @@ fn convert_pg_timestamp_to_arrow_timestamp_microseconds( timestamp_us: i64, ) -> Result { // adjust the timestamp from microseconds since 2000-01-01 to microseconds since 1970-01-01 checking for overflows and underflow - println!("timestamp_us: {}", timestamp_us); timestamp_us .checked_add(PG_BASE_TIMESTAMP_OFFSET_US) .ok_or_else(|| ErrorKind::Decode { @@ -352,13 +373,20 @@ impl Decode for TimestampTzMicrosecondDecoder { } fn finish(&mut self, column_len: usize) -> ArrayRef { - let mut data = std::mem::take(&mut self.arr); - data.resize(column_len, None); + self.arr.resize(column_len, None); + if self.is_null() { + return Arc::new(NullArray::new(self.arr.len())) as ArrayRef; + } + let data = std::mem::take(&mut self.arr); let array = Arc::new( TimestampMicrosecondArray::from(data).with_timezone(self.timezone.to_string()), ); array as ArrayRef } + + fn is_null(&self) -> bool { + self.arr.iter().all(|v| v.is_none()) + } } /// Convert Postgres dates (days since 2000-01-01) to Arrow dates (days since 1970-01-01) @@ -464,7 +492,7 @@ impl_decode_variable_size!( }, 0, GenericStringArray, - i64 + i32 ); pub struct BinaryDecoder { @@ -495,10 +523,13 @@ impl Decode for BinaryDecoder { } fn finish(&mut self, column_len: usize) -> ArrayRef { - let mut data = std::mem::take(&mut self.arr); - data.resize(column_len, None); + self.arr.resize(column_len, None); + if self.is_null() { + return Arc::new(NullArray::new(self.arr.len())) as ArrayRef; + } - let mut builder: GenericByteBuilder> = GenericByteBuilder::new(); + let data = std::mem::take(&mut self.arr); + let mut builder: GenericByteBuilder> = GenericByteBuilder::new(); for v in data { match v { Some(v) => builder.append_value(v), @@ -507,6 +538,10 @@ impl Decode for BinaryDecoder { } Arc::new(builder.finish()) as ArrayRef } + + fn is_null(&self) -> bool { + self.arr.iter().all(|v| v.is_none()) + } } pub struct JsonbDecoder { @@ -544,7 +579,7 @@ fn parse_pg_decimal_to_string(data: Vec) -> Result { let weight = i16::from_be_bytes(data[2..4].try_into().unwrap()); let sign = i16::from_be_bytes(data[4..6].try_into().unwrap()); let scale = i16::from_be_bytes(data[6..8].try_into().unwrap()); - let digits: Vec = data[8..8 + ndigits as usize] + let digits: Vec = data[8..8 + (ndigits as usize) * (std::mem::size_of::())] .chunks(2) .map(|c| i16::from_be_bytes(c.try_into().unwrap())) .collect(); @@ -604,7 +639,7 @@ fn parse_pg_decimal_to_string(data: Vec) -> Result { dig -= d1 * place; putit |= d1 > 0; if putit { - decimal.push(d1 as u8 + b'0') + decimal.push(d1 as u8 + b'0'); } place /= 10; } @@ -612,14 +647,12 @@ fn parse_pg_decimal_to_string(data: Vec) -> Result { digits_index += 1; } - // If scale is > 0 we have digits after the decimal point - if scale > 0 { - decimal.push(b'.'); - } } - - let mut i = 0; - while i < scale { + // If scale is > 0 we have digits after the decimal point + if scale > 0 { + decimal.push(b'.'); + } + while digits_index < ndigits { let mut dig = if digits_index >= 0 && digits_index < ndigits { digits[digits_index as usize] } else { @@ -635,24 +668,42 @@ fn parse_pg_decimal_to_string(data: Vec) -> Result { place /= 10; } decimal.push(dig as u8 + b'0'); - i += 1; + digits_index += 1; } - // unwrap will not fail here as we know ever value in our decimal vec is ascii; - Ok(String::from_utf8(decimal).unwrap()) + // trim trailing zeros and return the string + Ok(trim_trailing_zeros(decimal, scale)) } -pub struct DecimalDecoder { +pub fn trim_trailing_zeros(mut v: Vec, scale: i16) -> String { + let decimal_point_idx = v.iter().position(|&c| c == b'.'); + match decimal_point_idx { + Some(idx) => { + if idx == v.len() - 1 { + v.push(b'0') + } else { + while v.len() - idx - 1 > scale as usize { + v.pop(); + } + } + }, + None => {} + }; + let result = String::from_utf8(v).unwrap(); + result +} + +pub struct NumericDecoder { name: String, arr: Vec>, } impl_decode_variable_size!( - DecimalDecoder, + NumericDecoder, parse_pg_decimal_to_string, 0, GenericStringArray, - i64 + i32 ); // @@ -663,7 +714,7 @@ pub enum Decoder { Int64(Int64Decoder), Float32(Float32Decoder), Float64(Float64Decoder), - Decimal(DecimalDecoder), + Numeric(NumericDecoder), TimestampMicrosecond(TimestampMicrosecondDecoder), TimestampTzMicrosecond(TimestampTzMicrosecondDecoder), Date32(Date32Decoder), @@ -703,7 +754,7 @@ impl Decoder { name: name.to_string(), arr: vec![], }), - PostgresType::Decimal => Decoder::Decimal(DecimalDecoder { + PostgresType::Numeric => Decoder::Numeric(NumericDecoder { name: name.to_string(), arr: vec![], }), @@ -757,7 +808,7 @@ impl Decoder { Decoder::Int64(ref mut decoder) => decoder.decode(buf), Decoder::Float32(ref mut decoder) => decoder.decode(buf), Decoder::Float64(ref mut decoder) => decoder.decode(buf), - Decoder::Decimal(ref mut decoder) => decoder.decode(buf), + Decoder::Numeric(ref mut decoder) => decoder.decode(buf), Decoder::TimestampMicrosecond(ref mut decoder) => decoder.decode(buf), Decoder::TimestampTzMicrosecond(ref mut decoder) => decoder.decode(buf), Decoder::Date32(ref mut decoder) => decoder.decode(buf), @@ -769,6 +820,7 @@ impl Decoder { } } + #[allow(dead_code)] pub(crate) fn name(&self) -> String { match *self { Decoder::Boolean(ref decoder) => decoder.name(), @@ -777,7 +829,7 @@ impl Decoder { Decoder::Int64(ref decoder) => decoder.name(), Decoder::Float32(ref decoder) => decoder.name(), Decoder::Float64(ref decoder) => decoder.name(), - Decoder::Decimal(ref decoder) => decoder.name(), + Decoder::Numeric(ref decoder) => decoder.name(), Decoder::TimestampMicrosecond(ref decoder) => decoder.name(), Decoder::TimestampTzMicrosecond(ref decoder) => decoder.name(), Decoder::Date32(ref decoder) => decoder.name(), @@ -797,7 +849,7 @@ impl Decoder { Decoder::Int64(ref decoder) => decoder.column_len(), Decoder::Float32(ref decoder) => decoder.column_len(), Decoder::Float64(ref decoder) => decoder.column_len(), - Decoder::Decimal(ref decoder) => decoder.column_len(), + Decoder::Numeric(ref decoder) => decoder.column_len(), Decoder::TimestampMicrosecond(ref decoder) => decoder.column_len(), Decoder::TimestampTzMicrosecond(ref decoder) => decoder.column_len(), Decoder::Date32(ref decoder) => decoder.column_len(), @@ -817,7 +869,7 @@ impl Decoder { Decoder::Int64(ref mut decoder) => decoder.finish(column_len), Decoder::Float32(ref mut decoder) => decoder.finish(column_len), Decoder::Float64(ref mut decoder) => decoder.finish(column_len), - Decoder::Decimal(ref mut decoder) => decoder.finish(column_len), + Decoder::Numeric(ref mut decoder) => decoder.finish(column_len), Decoder::TimestampMicrosecond(ref mut decoder) => decoder.finish(column_len), Decoder::TimestampTzMicrosecond(ref mut decoder) => decoder.finish(column_len), Decoder::Date32(ref mut decoder) => decoder.finish(column_len), @@ -828,4 +880,24 @@ impl Decoder { Decoder::Jsonb(ref mut decoder) => decoder.finish(column_len), } } + + pub(crate) fn is_null(&self) -> bool { + match *self { + Decoder::Boolean(ref decoder) => decoder.is_null(), + Decoder::Int16(ref decoder) => decoder.is_null(), + Decoder::Int32(ref decoder) => decoder.is_null(), + Decoder::Int64(ref decoder) => decoder.is_null(), + Decoder::Float32(ref decoder) => decoder.is_null(), + Decoder::Float64(ref decoder) => decoder.is_null(), + Decoder::Numeric(ref decoder) => decoder.is_null(), + Decoder::TimestampMicrosecond(ref decoder) => decoder.is_null(), + Decoder::TimestampTzMicrosecond(ref decoder) => decoder.is_null(), + Decoder::Date32(ref decoder) => decoder.is_null(), + Decoder::Time64Microsecond(ref decoder) => decoder.is_null(), + Decoder::DurationMicrosecond(ref decoder) => decoder.is_null(), + Decoder::String(ref decoder) => decoder.is_null(), + Decoder::Binary(ref decoder) => decoder.is_null(), + Decoder::Jsonb(ref decoder) => decoder.is_null(), + } + } } diff --git a/core/src/lib.rs b/core/src/lib.rs index f107497..1acffa6 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -1,7 +1,7 @@ use std::collections::HashMap; use std::io::{BufRead, Seek}; -use arrow_array::{Array, RecordBatch}; +use arrow_array::RecordBatch; use arrow_schema::Fields; use arrow_schema::Schema; use bytes::{Buf, BufMut, BytesMut}; @@ -305,7 +305,6 @@ impl PostgresBinaryToArrowDecoder { let tuple_len: u16 = match local_buf.consume_into_u16() { Ok(len) => len, Err(e) => { - println!("Error reading tuple length: {:?}", e); return BatchDecodeResult::Error(e); } }; @@ -378,6 +377,16 @@ impl PostgresBinaryToArrowDecoder { // we are in a partial consume state. We will truncate the columns to the length // of the shortest column and pick up the lost data in the next batch. let column_len = self.decoders.iter().map(|d| d.column_len()).min().unwrap(); + + // Determine which columns in the batch are fully null so that we can alter the schema + // to reflect this. + let null_columns = self + .decoders + .iter() + .filter(|decoder| decoder.is_null()) + .map(|decoder| decoder.name()) + .collect::>(); + // For each decoder call its finish method to coerce the data into an Arrow array. // and append the array to the columns vector. let columns = self @@ -385,8 +394,9 @@ impl PostgresBinaryToArrowDecoder { .iter_mut() .map(|decoder| decoder.finish(column_len)) .collect(); + // Create a new RecordBatch from the columns vector and return it. - let record_batch = RecordBatch::try_new(self.schema.clone().into(), columns)?; + let record_batch = RecordBatch::try_new(self.schema.clone().nullify_columns(&null_columns).into(), columns)?; Ok(record_batch) } diff --git a/core/src/pg_schema.rs b/core/src/pg_schema.rs index 5a00c0a..b760812 100644 --- a/core/src/pg_schema.rs +++ b/core/src/pg_schema.rs @@ -21,13 +21,14 @@ pub enum PostgresType { Jsonb, Float4, Float8, - Decimal, + Numeric, Date, Time, Timestamp, TimestampTz(String), Interval, List(Box), + Null, } impl PostgresType { @@ -49,8 +50,9 @@ impl PostgresType { PostgresType::Timestamp => TypeSize::Fixed(8), PostgresType::TimestampTz(_) => TypeSize::Fixed(8), PostgresType::Interval => TypeSize::Fixed(12), - PostgresType::Decimal => TypeSize::Variable, + PostgresType::Numeric => TypeSize::Variable, PostgresType::List(_) => TypeSize::Variable, + PostgresType::Null => TypeSize::Fixed(0), } } pub fn oid(&self) -> Option { @@ -66,13 +68,14 @@ impl PostgresType { PostgresType::Jsonb => Some(3802), PostgresType::Float4 => Some(700), PostgresType::Float8 => Some(701), - PostgresType::Decimal => Some(1700), + PostgresType::Numeric => Some(1700), PostgresType::Date => Some(1082), PostgresType::Time => Some(1083), PostgresType::Timestamp => Some(1114), PostgresType::TimestampTz(_) => Some(1182), PostgresType::Interval => Some(1186), PostgresType::List(_) => None, + PostgresType::Null => None, } } pub fn name(&self) -> Option { @@ -88,7 +91,7 @@ impl PostgresType { PostgresType::Jsonb => "JSONB".to_string(), PostgresType::Float4 => "FLOAT4".to_string(), PostgresType::Float8 => "FLOAT8".to_string(), - PostgresType::Decimal => "DECIMAL".to_string(), + PostgresType::Numeric => "DECIMAL".to_string(), PostgresType::Date => "DATE".to_string(), PostgresType::Time => "TIME".to_string(), PostgresType::Timestamp => "TIMESTAMP".to_string(), @@ -99,6 +102,7 @@ impl PostgresType { let inner_tp = inner.data_type.name().unwrap(); format!("{inner_tp}[]") } + PostgresType::Null => "NULL".to_string(), }; Some(v) } @@ -108,17 +112,17 @@ impl From for DataType { fn from(pg_type: PostgresType) -> Self { match pg_type { PostgresType::Bool => DataType::Boolean, - PostgresType::Bytea => DataType::LargeBinary, + PostgresType::Bytea => DataType::Binary, PostgresType::Int8 => DataType::Int64, PostgresType::Int2 => DataType::Int16, PostgresType::Int4 => DataType::Int32, - PostgresType::Char => DataType::LargeUtf8, - PostgresType::Text => DataType::LargeUtf8, - PostgresType::Json => DataType::LargeUtf8, - PostgresType::Jsonb => DataType::LargeUtf8, + PostgresType::Char => DataType::Utf8, + PostgresType::Text => DataType::Utf8, + PostgresType::Json => DataType::Utf8, + PostgresType::Jsonb => DataType::Utf8, PostgresType::Float4 => DataType::Float32, PostgresType::Float8 => DataType::Float64, - PostgresType::Decimal => DataType::LargeUtf8, + PostgresType::Numeric => DataType::Utf8, PostgresType::Date => DataType::Date32, PostgresType::Time => DataType::Time64(TimeUnit::Microsecond), PostgresType::Timestamp => DataType::Timestamp(TimeUnit::Microsecond, None), @@ -127,6 +131,7 @@ impl From for DataType { } PostgresType::Interval => DataType::Duration(TimeUnit::Microsecond), PostgresType::List(_) => unimplemented!(), + PostgresType::Null => DataType::Null, } } } @@ -185,7 +190,7 @@ impl Column { nullable: nullable == "t", }), "numeric" => Ok(Column { - data_type: PostgresType::Decimal, + data_type: PostgresType::Numeric, nullable: nullable == "t", }), "date" => Ok(Column { @@ -262,6 +267,15 @@ impl PostgresSchema { Ok(schema) } + pub fn nullify_columns(mut self, columns: &[String]) -> Self { + for (name, col) in self.columns.iter_mut() { + if columns.contains(name) { + col.data_type = PostgresType::Null; + } + } + self + } + pub fn iter(&self) -> impl Iterator { self.columns.iter() } diff --git a/core/tests/decode_integration_tests.rs b/core/tests/decode_integration_tests.rs index 05406eb..db04108 100644 --- a/core/tests/decode_integration_tests.rs +++ b/core/tests/decode_integration_tests.rs @@ -9,12 +9,12 @@ use std::sync::Arc; use pgpq::{pg_schema::PostgresSchema, PostgresBinaryToArrowDecoder}; -const READ_CHUNK_SIZE: usize = 1024 * 8; +const READ_CHUNK_SIZE: usize = 1024 * 1024 * 8; -fn read_schema_file(path: PathBuf) -> PostgresSchema { +fn read_schema_file(path: PathBuf, timezone: String) -> PostgresSchema { let file = File::open(path).unwrap(); let reader = BufReader::new(file); - PostgresSchema::from_reader(reader, ',', "America/New_York".to_string()).unwrap() + PostgresSchema::from_reader(reader, ',', timezone).unwrap() } fn read_arrow_file(path: PathBuf) -> Vec { @@ -23,7 +23,7 @@ fn read_arrow_file(path: PathBuf) -> Vec { reader.collect::, _>>().unwrap() } -fn run_test_case(case: &str) -> Result<(), ErrorKind> { +fn run_test_case(case: &str, timezone: String) -> Result<(), ErrorKind> { let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(format!("tests/snapshots/{case}.bin")); let schema_path = @@ -33,7 +33,7 @@ fn run_test_case(case: &str) -> Result<(), ErrorKind> { let file = File::open(path).unwrap(); let reader = BufReader::with_capacity(READ_CHUNK_SIZE, file); - let schema = read_schema_file(schema_path); + let schema = read_schema_file(schema_path, timezone); let mut decoder = PostgresBinaryToArrowDecoder::new(schema, reader, READ_CHUNK_SIZE).unwrap(); decoder.read_header()?; @@ -60,7 +60,10 @@ fn run_test_case(case: &str) -> Result<(), ErrorKind> { .collect::>(); } - assert_eq!(batches.len(), expected_batches.len()); + assert_eq!(batches.iter().map(|b| b.num_rows()).sum::(), expected_batches.iter().map(|b| b.num_rows()).sum()); + let batch_schemas = batches.iter().map(|b| b.schema()).collect::>(); + let expected_batch_schemas = expected_batches.iter().map(|b| b.schema()).collect::>(); + assert_eq!(batch_schemas, expected_batch_schemas); assert_eq!(batches, expected_batches); Ok(()) @@ -68,162 +71,168 @@ fn run_test_case(case: &str) -> Result<(), ErrorKind> { #[test] fn test_bool() -> Result<(), ErrorKind> { - run_test_case("bool")?; + run_test_case("bool", "America/New_York".to_string())?; Ok(()) } #[test] fn test_int16() -> Result<(), ErrorKind> { - run_test_case("int16")?; + run_test_case("int16", "America/New_York".to_string())?; Ok(()) } #[test] fn test_int32() -> Result<(), ErrorKind> { - run_test_case("int32")?; + run_test_case("int32", "America/New_York".to_string())?; Ok(()) } #[test] fn test_int64() -> Result<(), ErrorKind> { - run_test_case("int64")?; + run_test_case("int64", "America/New_York".to_string())?; Ok(()) } #[test] fn test_float32() -> Result<(), ErrorKind> { - run_test_case("float32")?; + run_test_case("float32", "America/New_York".to_string())?; Ok(()) } #[test] fn test_float64() -> Result<(), ErrorKind> { - run_test_case("float64")?; + run_test_case("float64", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_numeric() -> Result<(), ErrorKind> { + run_test_case("numeric", "America/New_York".to_string())?; Ok(()) } #[test] fn test_timestamp_us_notz() -> Result<(), ErrorKind> { - run_test_case("timestamp_us_notz")?; + run_test_case("timestamp_us_notz", "America/New_York".to_string())?; Ok(()) } #[test] fn test_timestamp_us_tz() -> Result<(), ErrorKind> { - run_test_case("timestamp_us_tz")?; + run_test_case("timestamp_us_tz", "America/New_York".to_string())?; Ok(()) } #[test] fn test_time_us() -> Result<(), ErrorKind> { - run_test_case("time_us")?; + run_test_case("time_us", "America/New_York".to_string())?; Ok(()) } #[test] fn test_date32() -> Result<(), ErrorKind> { - run_test_case("date32")?; + run_test_case("date32", "America/New_York".to_string())?; Ok(()) } #[test] fn test_duration_us() -> Result<(), ErrorKind> { - run_test_case("duration_us")?; + run_test_case("duration_us", "America/New_York".to_string())?; Ok(()) } #[test] -fn test_large_binary() -> Result<(), ErrorKind> { - run_test_case("large_binary")?; +fn test_binary() -> Result<(), ErrorKind> { + run_test_case("binary", "America/New_York".to_string())?; Ok(()) } #[test] -fn test_large_string() -> Result<(), ErrorKind> { - run_test_case("large_string")?; +fn test_string() -> Result<(), ErrorKind> { + run_test_case("string", "America/New_York".to_string())?; Ok(()) } #[test] fn test_bool_nullable() -> Result<(), ErrorKind> { - run_test_case("bool_nullable")?; + run_test_case("bool_nullable", "America/New_York".to_string())?; Ok(()) } #[test] fn test_int16_nullable() -> Result<(), ErrorKind> { - run_test_case("int16_nullable")?; + run_test_case("int16_nullable", "America/New_York".to_string())?; Ok(()) } #[test] fn test_int32_nullable() -> Result<(), ErrorKind> { - run_test_case("int32_nullable")?; + run_test_case("int32_nullable", "America/New_York".to_string())?; Ok(()) } #[test] fn test_int64_nullable() -> Result<(), ErrorKind> { - run_test_case("int64_nullable")?; + run_test_case("int64_nullable", "America/New_York".to_string())?; Ok(()) } #[test] fn test_float32_nullable() -> Result<(), ErrorKind> { - run_test_case("float32_nullable")?; + run_test_case("float32_nullable", "America/New_York".to_string())?; Ok(()) } #[test] fn test_float64_nullable() -> Result<(), ErrorKind> { - run_test_case("float64_nullable")?; + run_test_case("float64_nullable", "America/New_York".to_string())?; Ok(()) } #[test] fn test_timestamp_us_notz_nullable() -> Result<(), ErrorKind> { - run_test_case("timestamp_us_notz_nullable")?; + run_test_case("timestamp_us_notz_nullable", "America/New_York".to_string())?; Ok(()) } #[test] fn test_timestamp_us_tz_nullable() -> Result<(), ErrorKind> { - run_test_case("timestamp_us_tz_nullable")?; + run_test_case("timestamp_us_tz_nullable", "America/New_York".to_string())?; Ok(()) } #[test] fn test_time_us_nullable() -> Result<(), ErrorKind> { - run_test_case("time_us_nullable")?; + run_test_case("time_us_nullable", "America/New_York".to_string())?; Ok(()) } #[test] fn test_date32_nullable() -> Result<(), ErrorKind> { - run_test_case("date32_nullable")?; + run_test_case("date32_nullable", "America/New_York".to_string())?; Ok(()) } #[test] fn test_duration_us_nullable() -> Result<(), ErrorKind> { - run_test_case("duration_us_nullable")?; + run_test_case("duration_us_nullable", "America/New_York".to_string())?; Ok(()) } #[test] -fn test_large_binary_nullable() -> Result<(), ErrorKind> { - run_test_case("large_binary_nullable")?; +fn test_binary_nullable() -> Result<(), ErrorKind> { + run_test_case("binary_nullable", "America/New_York".to_string())?; Ok(()) } #[test] -fn test_large_string_nullable() -> Result<(), ErrorKind> { - run_test_case("large_string_nullable")?; +fn test_string_nullable() -> Result<(), ErrorKind> { + run_test_case("string_nullable", "America/New_York".to_string())?; Ok(()) } -//#[test] -//fn test_profile() -> Result<(), ErrorKind> { -// run_test_case("profile")?; -// Ok(()) -//} +#[test] +fn test_numeric_nullable() -> Result<(), ErrorKind> { + run_test_case("numeric_nullable", "America/New_York".to_string())?; + Ok(()) +} diff --git a/core/tests/decoding/binary.schema b/core/tests/decoding/binary.schema new file mode 100644 index 0000000..9abe242 --- /dev/null +++ b/core/tests/decoding/binary.schema @@ -0,0 +1 @@ +binary,bytea,f diff --git a/core/tests/decoding/binary_nullable.schema b/core/tests/decoding/binary_nullable.schema new file mode 100644 index 0000000..e3faaf6 --- /dev/null +++ b/core/tests/decoding/binary_nullable.schema @@ -0,0 +1 @@ +binary_nullable,bytea,t diff --git a/core/tests/decoding/large_binary.schema b/core/tests/decoding/large_binary.schema deleted file mode 100644 index 1f89ade..0000000 --- a/core/tests/decoding/large_binary.schema +++ /dev/null @@ -1 +0,0 @@ -large_binary,bytea,f diff --git a/core/tests/decoding/large_binary_nullable.schema b/core/tests/decoding/large_binary_nullable.schema deleted file mode 100644 index 678b1d1..0000000 --- a/core/tests/decoding/large_binary_nullable.schema +++ /dev/null @@ -1 +0,0 @@ -large_binary_nullable,bytea,t diff --git a/core/tests/decoding/large_string.schema b/core/tests/decoding/large_string.schema deleted file mode 100644 index 8862a5f..0000000 --- a/core/tests/decoding/large_string.schema +++ /dev/null @@ -1 +0,0 @@ -large_string,text,f diff --git a/core/tests/decoding/large_string_nullable.schema b/core/tests/decoding/large_string_nullable.schema deleted file mode 100644 index c9e5b40..0000000 --- a/core/tests/decoding/large_string_nullable.schema +++ /dev/null @@ -1 +0,0 @@ -large_string_nullable,text,t diff --git a/core/tests/decoding/string.schema b/core/tests/decoding/string.schema new file mode 100644 index 0000000..62a7265 --- /dev/null +++ b/core/tests/decoding/string.schema @@ -0,0 +1 @@ +string,text,f diff --git a/core/tests/decoding/string_nullable.schema b/core/tests/decoding/string_nullable.schema new file mode 100644 index 0000000..576a89c --- /dev/null +++ b/core/tests/decoding/string_nullable.schema @@ -0,0 +1 @@ +string_nullable,text,t diff --git a/core/tests/snapshots/numeric.bin b/core/tests/snapshots/numeric.bin new file mode 100644 index 0000000000000000000000000000000000000000..8171175f563c30cc8b936c7d4252967768a05100 GIT binary patch literal 177 zcmWG=clHm6s{(}JkBgqyc literal 0 HcmV?d00001 diff --git a/core/tests/testdata/numeric.arrow b/core/tests/testdata/numeric.arrow new file mode 100644 index 0000000000000000000000000000000000000000..1180ddea79206c2bf10cf75bade6e4b6235feec7 GIT binary patch literal 1570 zcmeHI%}(1u5Z;s!B5I)=5aPfAttzz#V%hnDfGSm7dZAJ!MAZXAVTl)HYOk%04Mb7y zeS{u)3ErTO(|0J}tk=PjIKh>PX7`(K*0Zy_Gs@xd@%NuTWB(!N?-*+_l2x|G8f=+0 zfgrW|oOfW>E&s1Z7;Y%>O^oDg0{^wX2h39*szBZiM@f{&YRnI|PpAABI3TWtx{`cn zn=27Z5Gs!%SmR9S45nvrk^&A4lmz|R8H^&{&;*w@>|&J5P)5OUkxPXN#CVuZQreE^ zDjX$2kwG4(ler_gxR#@gGK*y<0+9(UpK__NJXBZo?T?eM?E#-vl3C1xt2~xE98r*k zRH}|wi-nYS4%!{{dUDTGTZnmIQ4D+ZBwcMgP%EXLGP~1DQFnsITZ& lKVzgbl>L^XS4r;8SiLVx;NISP^{rQ5+N-}&Ux((u;St1BP(lCz literal 0 HcmV?d00001 diff --git a/core/tests/testdata/numeric_nullable.arrow b/core/tests/testdata/numeric_nullable.arrow new file mode 100644 index 0000000000000000000000000000000000000000..a9a70b7b2a55e2176a022d3b75be10aa986b2d25 GIT binary patch literal 618 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

;qjI%OSig=7jXWoY7n~R$ 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 z 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 Ao&W#< literal 0 HcmV?d00001 From 696d20133e5ba8fd6545b5ceb27b862bae2f707d Mon Sep 17 00:00:00 2001 From: Adam Lefevre Date: Sun, 14 Apr 2024 17:42:46 -0500 Subject: [PATCH 06/11] fix function name --- core/src/decoders.rs | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/core/src/decoders.rs b/core/src/decoders.rs index 593ec8f..501680f 100644 --- a/core/src/decoders.rs +++ b/core/src/decoders.rs @@ -672,15 +672,18 @@ fn parse_pg_decimal_to_string(data: Vec) -> Result { } // trim trailing zeros and return the string - Ok(trim_trailing_zeros(decimal, scale)) + Ok(truncate_and_finalize(decimal, scale)) } -pub fn trim_trailing_zeros(mut v: Vec, scale: i16) -> String { +pub fn truncate_and_finalize(mut v: Vec, scale: i16) -> String { + // if there is a decimal point do some general cleanup let decimal_point_idx = v.iter().position(|&c| c == b'.'); match decimal_point_idx { Some(idx) => { + // If the number ends in a decimal point, add a zero if idx == v.len() - 1 { v.push(b'0') + // Strip any trailing zeros after the decimal point } else { while v.len() - idx - 1 > scale as usize { v.pop(); @@ -689,8 +692,7 @@ pub fn trim_trailing_zeros(mut v: Vec, scale: i16) -> String { }, None => {} }; - let result = String::from_utf8(v).unwrap(); - result + String::from_utf8(v).unwrap() } pub struct NumericDecoder { From f7ad216a3483517f4c8d1e137659ac9500187b16 Mon Sep 17 00:00:00 2001 From: Adam Lefevre Date: Sat, 20 Apr 2024 10:46:41 -0500 Subject: [PATCH 07/11] More cleanup --- core/src/buffer_view.rs | 70 ++++++++++ core/src/decoders.rs | 280 ++++++++++++++++------------------------ core/src/error.rs | 2 + core/src/lib.rs | 52 +++++--- core/src/pg_schema.rs | 53 ++++++++ 5 files changed, 270 insertions(+), 187 deletions(-) create mode 100644 core/src/buffer_view.rs diff --git a/core/src/buffer_view.rs b/core/src/buffer_view.rs new file mode 100644 index 0000000..0cfa583 --- /dev/null +++ b/core/src/buffer_view.rs @@ -0,0 +1,70 @@ +use std::fmt::Debug; +use crate::error::ErrorKind; + +pub(crate) struct BufferView<'a> { + inner: &'a [u8], + consumed: usize, +} + +impl Debug for BufferView<'_> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", &self.inner[self.consumed..]) + } +} + +impl BufferView<'_> { + pub fn new(inner: &'_ [u8]) -> BufferView<'_> { + BufferView { inner, consumed: 0 } + } + + pub fn consume_into_u32(&mut self) -> Result { + if self.consumed + 4 > self.inner.len() { + return Err(ErrorKind::IncompleteData); + } + let res = u32::from_be_bytes( + self.inner[self.consumed..self.consumed + 4] + .try_into() + .unwrap(), + ); + self.consumed += 4; + Ok(res) + } + + pub fn consume_into_u16(&mut self) -> Result { + if self.consumed + 2 > self.inner.len() { + return Err(ErrorKind::IncompleteData); + } + let res = u16::from_be_bytes( + self.inner[self.consumed..self.consumed + 2] + .try_into() + .unwrap(), + ); + self.consumed += 2; + Ok(res) + } + + pub fn consume_into_vec_n(&mut self, n: usize) -> Result, ErrorKind> { + if self.consumed + n > self.inner.len() { + return Err(ErrorKind::IncompleteData); + } + let data = self.inner[self.consumed..self.consumed + n].to_vec(); + self.consumed += n; + if data.len() != n { + return Err(ErrorKind::IncompleteData); + } + Ok(data) + } + + pub fn remaining(&self) -> usize { + self.inner.len() - self.consumed + } + + pub fn consumed(&self) -> usize { + self.consumed + } + + pub fn swallow(&mut self, n: usize) { + self.consumed += n; + } +} + diff --git a/core/src/decoders.rs b/core/src/decoders.rs index 501680f..31bb3b7 100644 --- a/core/src/decoders.rs +++ b/core/src/decoders.rs @@ -1,6 +1,6 @@ #![allow(clippy::redundant_closure_call)] -use crate::encoders::{PG_BASE_DATE_OFFSET, PG_BASE_TIMESTAMP_OFFSET_US}; +use std::sync::Arc; use arrow_array::builder::GenericByteBuilder; use arrow_array::types::GenericBinaryType; use arrow_array::{self, ArrayRef}; @@ -9,80 +9,15 @@ use arrow_array::{ GenericStringArray, Int16Array, Int32Array, Int64Array, Time64MicrosecondArray, TimestampMicrosecondArray, NullArray }; -use std::fmt::Debug; -use std::sync::Arc; +use crate::encoders::{PG_BASE_DATE_OFFSET, PG_BASE_TIMESTAMP_OFFSET_US}; use crate::error::ErrorKind; +use crate::buffer_view::BufferView; use crate::pg_schema::{PostgresSchema, PostgresType}; -pub(crate) struct BufferView<'a> { - inner: &'a [u8], - consumed: usize, -} - -impl Debug for BufferView<'_> { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{:?}", &self.inner[self.consumed..]) - } -} - -impl BufferView<'_> { - pub fn new(inner: &'_ [u8]) -> BufferView<'_> { - BufferView { inner, consumed: 0 } - } - - pub fn consume_into_u32(&mut self) -> Result { - if self.consumed + 4 > self.inner.len() { - return Err(ErrorKind::IncompleteData); - } - let res = u32::from_be_bytes( - self.inner[self.consumed..self.consumed + 4] - .try_into() - .unwrap(), - ); - self.consumed += 4; - Ok(res) - } - - pub fn consume_into_u16(&mut self) -> Result { - if self.consumed + 2 > self.inner.len() { - return Err(ErrorKind::IncompleteData); - } - let res = u16::from_be_bytes( - self.inner[self.consumed..self.consumed + 2] - .try_into() - .unwrap(), - ); - self.consumed += 2; - Ok(res) - } - - pub fn consume_into_vec_n(&mut self, n: usize) -> Result, ErrorKind> { - if self.consumed + n > self.inner.len() { - return Err(ErrorKind::IncompleteData); - } - let data = self.inner[self.consumed..self.consumed + n].to_vec(); - self.consumed += n; - if data.len() != n { - return Err(ErrorKind::IncompleteData); - } - Ok(data) - } - - pub fn remaining(&self) -> usize { - self.inner.len() - self.consumed - } - - pub fn consumed(&self) -> usize { - self.consumed - } - pub fn swallow(&mut self, n: usize) { - self.consumed += n; - } -} - -pub(crate) trait Decode { +/// Trait defining the methods needed to decode a Postgres type into an Arrow array +pub(crate) trait Decoder { fn decode(&mut self, buf: &mut BufferView) -> Result<(), ErrorKind>; fn finish(&mut self, column_len: usize) -> ArrayRef; fn column_len(&self) -> usize; @@ -90,9 +25,10 @@ pub(crate) trait Decode { fn is_null(&self) -> bool; } + macro_rules! impl_decode { ($struct_name:ident, $size:expr, $transform:expr, $array_kind:ident) => { - impl Decode for $struct_name { + impl Decoder for $struct_name { fn decode(&mut self, buf: &mut BufferView<'_>) -> Result<(), ErrorKind> { let field_size = buf.consume_into_u32()?; if field_size == u32::MAX { @@ -104,9 +40,9 @@ macro_rules! impl_decode { } let data = buf.consume_into_vec_n(field_size as usize)?; + // // Unwrap is safe here because have checked the field size is the expected size // above - let value = $transform(data.try_into().unwrap()); self.arr.push(Some(value)); @@ -140,7 +76,7 @@ macro_rules! impl_decode { macro_rules! impl_decode_fallible { ($struct_name:ident, $size:expr, $transform:expr, $array_kind:ident) => { - impl Decode for $struct_name { + impl Decoder for $struct_name { fn decode(&mut self, buf: &mut BufferView<'_>) -> Result<(), ErrorKind> { let field_size = buf.consume_into_u32()?; @@ -154,6 +90,7 @@ macro_rules! impl_decode_fallible { } let data = buf.consume_into_vec_n(field_size as usize)?; + // Unwrap is safe here because have checked the field size is the expected size // above match $transform(data.try_into().unwrap()) { @@ -202,7 +139,7 @@ macro_rules! impl_decode_fallible { macro_rules! impl_decode_variable_size { ($struct_name:ident, $transform:expr, $extra_bytes:expr, $array_kind:ident, $offset_size:ident) => { - impl Decode for $struct_name { + impl Decoder for $struct_name { fn decode(&mut self, buf: &mut BufferView<'_>) -> Result<(), ErrorKind> { let field_size = buf.consume_into_u32()?; if field_size == u32::MAX { @@ -344,7 +281,7 @@ pub struct TimestampTzMicrosecondDecoder { timezone: String, } -impl Decode for TimestampTzMicrosecondDecoder { +impl Decoder for TimestampTzMicrosecondDecoder { fn decode(&mut self, buf: &mut BufferView<'_>) -> Result<(), ErrorKind> { let field_size = buf.consume_into_u32()?; if field_size == u32::MAX { @@ -425,7 +362,7 @@ impl_decode!( Time64MicrosecondArray ); -/// Convert Postgres durations to Arrow durations (milliseconds) +/// Convert Postgres durations to Arrow durations (microseconds) fn convert_pg_duration_to_arrow_duration( duration_us: i64, duration_days: i32, @@ -500,7 +437,7 @@ pub struct BinaryDecoder { arr: Vec>>, } -impl Decode for BinaryDecoder { +impl Decoder for BinaryDecoder { fn decode(&mut self, buf: &mut BufferView<'_>) -> Result<(), ErrorKind> { let field_size = buf.consume_into_u32()?; if field_size == u32::MAX { @@ -569,8 +506,9 @@ const DEC_DIGITS: i16 = 4; // const used for determining sign of numeric const NUMERIC_NEG: i16 = 0x4000; -/// Logic ported from src/backend/utils/adt/numeric.c:get_str_from_var +/// Parse a Postgres numeric type in binary format into a string fn parse_pg_decimal_to_string(data: Vec) -> Result { + // Logic ported from src/backend/utils/adt/numeric.c:get_str_from_var // Decimals will be decoded to strings since rust does not have a ubiquitos // decimal type and arrow does not implment `From` for any of them. Arrow // does have a Decimal128 array but its only accepts i128s as input @@ -675,7 +613,9 @@ fn parse_pg_decimal_to_string(data: Vec) -> Result { Ok(truncate_and_finalize(decimal, scale)) } -pub fn truncate_and_finalize(mut v: Vec, scale: i16) -> String { +/// truncate any trailing zeros on end of the string if they not significant. +/// If the number ends in a decimal point, add a zero +fn truncate_and_finalize(mut v: Vec, scale: i16) -> String { // if there is a decimal point do some general cleanup let decimal_point_idx = v.iter().position(|&c| c == b'.'); match decimal_point_idx { @@ -709,7 +649,7 @@ impl_decode_variable_size!( ); // -pub enum Decoder { +pub enum PostgresDecoder { Boolean(BooleanDecoder), Int16(Int16Decoder), Int32(Int32Decoder), @@ -727,73 +667,73 @@ pub enum Decoder { Jsonb(JsonbDecoder), } // -impl Decoder { +impl PostgresDecoder { pub fn new(schema: &PostgresSchema) -> Vec { schema .iter() .map(|(name, column)| match column.data_type { - PostgresType::Bool => Decoder::Boolean(BooleanDecoder { + PostgresType::Bool => PostgresDecoder::Boolean(BooleanDecoder { name: name.to_string(), arr: vec![], }), - PostgresType::Int2 => Decoder::Int16(Int16Decoder { + PostgresType::Int2 => PostgresDecoder::Int16(Int16Decoder { name: name.to_string(), arr: vec![], }), - PostgresType::Int4 => Decoder::Int32(Int32Decoder { + PostgresType::Int4 => PostgresDecoder::Int32(Int32Decoder { name: name.to_string(), arr: vec![], }), - PostgresType::Int8 => Decoder::Int64(Int64Decoder { + PostgresType::Int8 => PostgresDecoder::Int64(Int64Decoder { name: name.to_string(), arr: vec![], }), - PostgresType::Float4 => Decoder::Float32(Float32Decoder { + PostgresType::Float4 => PostgresDecoder::Float32(Float32Decoder { name: name.to_string(), arr: vec![], }), - PostgresType::Float8 => Decoder::Float64(Float64Decoder { + PostgresType::Float8 => PostgresDecoder::Float64(Float64Decoder { name: name.to_string(), arr: vec![], }), - PostgresType::Numeric => Decoder::Numeric(NumericDecoder { + PostgresType::Numeric => PostgresDecoder::Numeric(NumericDecoder { name: name.to_string(), arr: vec![], }), PostgresType::Timestamp => { - Decoder::TimestampMicrosecond(TimestampMicrosecondDecoder { + PostgresDecoder::TimestampMicrosecond(TimestampMicrosecondDecoder { name: name.to_string(), arr: vec![], }) } PostgresType::TimestampTz(ref timezone) => { - Decoder::TimestampTzMicrosecond(TimestampTzMicrosecondDecoder { + PostgresDecoder::TimestampTzMicrosecond(TimestampTzMicrosecondDecoder { name: name.to_string(), arr: vec![], timezone: timezone.to_string(), }) } - PostgresType::Date => Decoder::Date32(Date32Decoder { + PostgresType::Date => PostgresDecoder::Date32(Date32Decoder { name: name.to_string(), arr: vec![], }), - PostgresType::Time => Decoder::Time64Microsecond(Time64MicrosecondDecoder { + PostgresType::Time => PostgresDecoder::Time64Microsecond(Time64MicrosecondDecoder { name: name.to_string(), arr: vec![], }), PostgresType::Interval => { - Decoder::DurationMicrosecond(DurationMicrosecondDecoder { + PostgresDecoder::DurationMicrosecond(DurationMicrosecondDecoder { name: name.to_string(), arr: vec![], }) } PostgresType::Text | PostgresType::Char | PostgresType::Json => { - Decoder::String(StringDecoder { + PostgresDecoder::String(StringDecoder { name: name.to_string(), arr: vec![], }) } - PostgresType::Bytea => Decoder::Binary(BinaryDecoder { + PostgresType::Bytea => PostgresDecoder::Binary(BinaryDecoder { name: name.to_string(), arr: vec![], }), @@ -804,102 +744,102 @@ impl Decoder { pub(crate) fn apply(&mut self, buf: &mut BufferView) -> Result<(), ErrorKind> { match *self { - Decoder::Boolean(ref mut decoder) => decoder.decode(buf), - Decoder::Int16(ref mut decoder) => decoder.decode(buf), - Decoder::Int32(ref mut decoder) => decoder.decode(buf), - Decoder::Int64(ref mut decoder) => decoder.decode(buf), - Decoder::Float32(ref mut decoder) => decoder.decode(buf), - Decoder::Float64(ref mut decoder) => decoder.decode(buf), - Decoder::Numeric(ref mut decoder) => decoder.decode(buf), - Decoder::TimestampMicrosecond(ref mut decoder) => decoder.decode(buf), - Decoder::TimestampTzMicrosecond(ref mut decoder) => decoder.decode(buf), - Decoder::Date32(ref mut decoder) => decoder.decode(buf), - Decoder::Time64Microsecond(ref mut decoder) => decoder.decode(buf), - Decoder::DurationMicrosecond(ref mut decoder) => decoder.decode(buf), - Decoder::String(ref mut decoder) => decoder.decode(buf), - Decoder::Binary(ref mut decoder) => decoder.decode(buf), - Decoder::Jsonb(ref mut decoder) => decoder.decode(buf), + PostgresDecoder::Boolean(ref mut decoder) => decoder.decode(buf), + PostgresDecoder::Int16(ref mut decoder) => decoder.decode(buf), + PostgresDecoder::Int32(ref mut decoder) => decoder.decode(buf), + PostgresDecoder::Int64(ref mut decoder) => decoder.decode(buf), + PostgresDecoder::Float32(ref mut decoder) => decoder.decode(buf), + PostgresDecoder::Float64(ref mut decoder) => decoder.decode(buf), + PostgresDecoder::Numeric(ref mut decoder) => decoder.decode(buf), + PostgresDecoder::TimestampMicrosecond(ref mut decoder) => decoder.decode(buf), + PostgresDecoder::TimestampTzMicrosecond(ref mut decoder) => decoder.decode(buf), + PostgresDecoder::Date32(ref mut decoder) => decoder.decode(buf), + PostgresDecoder::Time64Microsecond(ref mut decoder) => decoder.decode(buf), + PostgresDecoder::DurationMicrosecond(ref mut decoder) => decoder.decode(buf), + PostgresDecoder::String(ref mut decoder) => decoder.decode(buf), + PostgresDecoder::Binary(ref mut decoder) => decoder.decode(buf), + PostgresDecoder::Jsonb(ref mut decoder) => decoder.decode(buf), } } #[allow(dead_code)] pub(crate) fn name(&self) -> String { match *self { - Decoder::Boolean(ref decoder) => decoder.name(), - Decoder::Int16(ref decoder) => decoder.name(), - Decoder::Int32(ref decoder) => decoder.name(), - Decoder::Int64(ref decoder) => decoder.name(), - Decoder::Float32(ref decoder) => decoder.name(), - Decoder::Float64(ref decoder) => decoder.name(), - Decoder::Numeric(ref decoder) => decoder.name(), - Decoder::TimestampMicrosecond(ref decoder) => decoder.name(), - Decoder::TimestampTzMicrosecond(ref decoder) => decoder.name(), - Decoder::Date32(ref decoder) => decoder.name(), - Decoder::Time64Microsecond(ref decoder) => decoder.name(), - Decoder::DurationMicrosecond(ref decoder) => decoder.name(), - Decoder::String(ref decoder) => decoder.name(), - Decoder::Binary(ref decoder) => decoder.name(), - Decoder::Jsonb(ref decoder) => decoder.name(), + PostgresDecoder::Boolean(ref decoder) => decoder.name(), + PostgresDecoder::Int16(ref decoder) => decoder.name(), + PostgresDecoder::Int32(ref decoder) => decoder.name(), + PostgresDecoder::Int64(ref decoder) => decoder.name(), + PostgresDecoder::Float32(ref decoder) => decoder.name(), + PostgresDecoder::Float64(ref decoder) => decoder.name(), + PostgresDecoder::Numeric(ref decoder) => decoder.name(), + PostgresDecoder::TimestampMicrosecond(ref decoder) => decoder.name(), + PostgresDecoder::TimestampTzMicrosecond(ref decoder) => decoder.name(), + PostgresDecoder::Date32(ref decoder) => decoder.name(), + PostgresDecoder::Time64Microsecond(ref decoder) => decoder.name(), + PostgresDecoder::DurationMicrosecond(ref decoder) => decoder.name(), + PostgresDecoder::String(ref decoder) => decoder.name(), + PostgresDecoder::Binary(ref decoder) => decoder.name(), + PostgresDecoder::Jsonb(ref decoder) => decoder.name(), } } pub(crate) fn column_len(&self) -> usize { match *self { - Decoder::Boolean(ref decoder) => decoder.column_len(), - Decoder::Int16(ref decoder) => decoder.column_len(), - Decoder::Int32(ref decoder) => decoder.column_len(), - Decoder::Int64(ref decoder) => decoder.column_len(), - Decoder::Float32(ref decoder) => decoder.column_len(), - Decoder::Float64(ref decoder) => decoder.column_len(), - Decoder::Numeric(ref decoder) => decoder.column_len(), - Decoder::TimestampMicrosecond(ref decoder) => decoder.column_len(), - Decoder::TimestampTzMicrosecond(ref decoder) => decoder.column_len(), - Decoder::Date32(ref decoder) => decoder.column_len(), - Decoder::Time64Microsecond(ref decoder) => decoder.column_len(), - Decoder::DurationMicrosecond(ref decoder) => decoder.column_len(), - Decoder::String(ref decoder) => decoder.column_len(), - Decoder::Binary(ref decoder) => decoder.column_len(), - Decoder::Jsonb(ref decoder) => decoder.column_len(), + PostgresDecoder::Boolean(ref decoder) => decoder.column_len(), + PostgresDecoder::Int16(ref decoder) => decoder.column_len(), + PostgresDecoder::Int32(ref decoder) => decoder.column_len(), + PostgresDecoder::Int64(ref decoder) => decoder.column_len(), + PostgresDecoder::Float32(ref decoder) => decoder.column_len(), + PostgresDecoder::Float64(ref decoder) => decoder.column_len(), + PostgresDecoder::Numeric(ref decoder) => decoder.column_len(), + PostgresDecoder::TimestampMicrosecond(ref decoder) => decoder.column_len(), + PostgresDecoder::TimestampTzMicrosecond(ref decoder) => decoder.column_len(), + PostgresDecoder::Date32(ref decoder) => decoder.column_len(), + PostgresDecoder::Time64Microsecond(ref decoder) => decoder.column_len(), + PostgresDecoder::DurationMicrosecond(ref decoder) => decoder.column_len(), + PostgresDecoder::String(ref decoder) => decoder.column_len(), + PostgresDecoder::Binary(ref decoder) => decoder.column_len(), + PostgresDecoder::Jsonb(ref decoder) => decoder.column_len(), } } pub(crate) fn finish(&mut self, column_len: usize) -> ArrayRef { match *self { - Decoder::Boolean(ref mut decoder) => decoder.finish(column_len), - Decoder::Int16(ref mut decoder) => decoder.finish(column_len), - Decoder::Int32(ref mut decoder) => decoder.finish(column_len), - Decoder::Int64(ref mut decoder) => decoder.finish(column_len), - Decoder::Float32(ref mut decoder) => decoder.finish(column_len), - Decoder::Float64(ref mut decoder) => decoder.finish(column_len), - Decoder::Numeric(ref mut decoder) => decoder.finish(column_len), - Decoder::TimestampMicrosecond(ref mut decoder) => decoder.finish(column_len), - Decoder::TimestampTzMicrosecond(ref mut decoder) => decoder.finish(column_len), - Decoder::Date32(ref mut decoder) => decoder.finish(column_len), - Decoder::Time64Microsecond(ref mut decoder) => decoder.finish(column_len), - Decoder::DurationMicrosecond(ref mut decoder) => decoder.finish(column_len), - Decoder::String(ref mut decoder) => decoder.finish(column_len), - Decoder::Binary(ref mut decoder) => decoder.finish(column_len), - Decoder::Jsonb(ref mut decoder) => decoder.finish(column_len), + PostgresDecoder::Boolean(ref mut decoder) => decoder.finish(column_len), + PostgresDecoder::Int16(ref mut decoder) => decoder.finish(column_len), + PostgresDecoder::Int32(ref mut decoder) => decoder.finish(column_len), + PostgresDecoder::Int64(ref mut decoder) => decoder.finish(column_len), + PostgresDecoder::Float32(ref mut decoder) => decoder.finish(column_len), + PostgresDecoder::Float64(ref mut decoder) => decoder.finish(column_len), + PostgresDecoder::Numeric(ref mut decoder) => decoder.finish(column_len), + PostgresDecoder::TimestampMicrosecond(ref mut decoder) => decoder.finish(column_len), + PostgresDecoder::TimestampTzMicrosecond(ref mut decoder) => decoder.finish(column_len), + PostgresDecoder::Date32(ref mut decoder) => decoder.finish(column_len), + PostgresDecoder::Time64Microsecond(ref mut decoder) => decoder.finish(column_len), + PostgresDecoder::DurationMicrosecond(ref mut decoder) => decoder.finish(column_len), + PostgresDecoder::String(ref mut decoder) => decoder.finish(column_len), + PostgresDecoder::Binary(ref mut decoder) => decoder.finish(column_len), + PostgresDecoder::Jsonb(ref mut decoder) => decoder.finish(column_len), } } pub(crate) fn is_null(&self) -> bool { match *self { - Decoder::Boolean(ref decoder) => decoder.is_null(), - Decoder::Int16(ref decoder) => decoder.is_null(), - Decoder::Int32(ref decoder) => decoder.is_null(), - Decoder::Int64(ref decoder) => decoder.is_null(), - Decoder::Float32(ref decoder) => decoder.is_null(), - Decoder::Float64(ref decoder) => decoder.is_null(), - Decoder::Numeric(ref decoder) => decoder.is_null(), - Decoder::TimestampMicrosecond(ref decoder) => decoder.is_null(), - Decoder::TimestampTzMicrosecond(ref decoder) => decoder.is_null(), - Decoder::Date32(ref decoder) => decoder.is_null(), - Decoder::Time64Microsecond(ref decoder) => decoder.is_null(), - Decoder::DurationMicrosecond(ref decoder) => decoder.is_null(), - Decoder::String(ref decoder) => decoder.is_null(), - Decoder::Binary(ref decoder) => decoder.is_null(), - Decoder::Jsonb(ref decoder) => decoder.is_null(), + PostgresDecoder::Boolean(ref decoder) => decoder.is_null(), + PostgresDecoder::Int16(ref decoder) => decoder.is_null(), + PostgresDecoder::Int32(ref decoder) => decoder.is_null(), + PostgresDecoder::Int64(ref decoder) => decoder.is_null(), + PostgresDecoder::Float32(ref decoder) => decoder.is_null(), + PostgresDecoder::Float64(ref decoder) => decoder.is_null(), + PostgresDecoder::Numeric(ref decoder) => decoder.is_null(), + PostgresDecoder::TimestampMicrosecond(ref decoder) => decoder.is_null(), + PostgresDecoder::TimestampTzMicrosecond(ref decoder) => decoder.is_null(), + PostgresDecoder::Date32(ref decoder) => decoder.is_null(), + PostgresDecoder::Time64Microsecond(ref decoder) => decoder.is_null(), + PostgresDecoder::DurationMicrosecond(ref decoder) => decoder.is_null(), + PostgresDecoder::String(ref decoder) => decoder.is_null(), + PostgresDecoder::Binary(ref decoder) => decoder.is_null(), + PostgresDecoder::Jsonb(ref decoder) => decoder.is_null(), } } } diff --git a/core/src/error.rs b/core/src/error.rs index dbfcc57..8450176 100644 --- a/core/src/error.rs +++ b/core/src/error.rs @@ -58,6 +58,8 @@ pub enum ErrorKind { IOError { io_error: std::io::Error }, #[error("Got an error: {name} in Arrow while decoding: {reason}")] ArrowErrorDecode { reason: String, name: String }, + #[error("ArrowType: {typ:?} not currently supported for decoding")] + UnsupportedArrowType { typ: DataType }, } impl From for ErrorKind { diff --git a/core/src/lib.rs b/core/src/lib.rs index 1acffa6..0ef2e4f 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -11,8 +11,10 @@ pub mod decoders; pub mod encoders; pub mod error; pub mod pg_schema; +mod buffer_view; -use crate::decoders::{BufferView, Decoder}; +use crate::decoders::PostgresDecoder; +use crate::buffer_view::BufferView; use crate::encoders::{BuildEncoder, Encode, EncoderBuilder}; use crate::pg_schema::PostgresSchema; @@ -162,7 +164,7 @@ enum BatchDecodeResult { pub struct PostgresBinaryToArrowDecoder { schema: PostgresSchema, - decoders: Vec, + decoders: Vec, source: R, state: EncoderState, capacity: usize, @@ -170,7 +172,7 @@ pub struct PostgresBinaryToArrowDecoder { impl PostgresBinaryToArrowDecoder { pub fn new(schema: PostgresSchema, source: R, capacity: usize) -> Result { - let decoders = Decoder::new(&schema); + let decoders = PostgresDecoder::new(&schema); Ok(PostgresBinaryToArrowDecoder { schema, decoders, @@ -180,21 +182,47 @@ impl PostgresBinaryToArrowDecoder { }) } + /// Try to create a new decoder using an arrow schema. Will fail if the types in the schema + /// are not supported by the decoder. + pub fn try_new_with_arrow_schema( + schema: Schema, + source: R, + capacity: usize, + ) -> Result { + let pg_schema = PostgresSchema::try_from(schema)?; + let decoders = PostgresDecoder::new(&pg_schema); + Ok(PostgresBinaryToArrowDecoder { + decoders, + schema: pg_schema, + source, + state: EncoderState::Created, + capacity, + }) + } + + /// Reads the header from the source and validates it. pub fn read_header(&mut self) -> Result<(), ErrorKind> { assert_eq!(self.state, EncoderState::Created); + + // Header is always 11 bytes long. b"PGCOPY\n\xff\r\n\0" let mut header = [0; 11]; self.source.read_exact(&mut header)?; if header != HEADER_MAGIC_BYTES { return Err(ErrorKind::InvalidBinaryHeader { bytes: header }); } + + // read flags and header extension both of which we ignore the values of. let mut flags = [0; 4]; self.source.read_exact(&mut flags)?; + let mut header_extension = [0; 4]; self.source.read_exact(&mut header_extension)?; + self.state = EncoderState::Encoding; Ok(()) } + /// read batches of bytes from the source and decode them into RecordBatches. pub fn decode_batches(&mut self) -> Result, ErrorKind> { let mut batches = Vec::new(); let mut buf = BytesMut::with_capacity(self.capacity); @@ -270,7 +298,6 @@ impl PostgresBinaryToArrowDecoder { // If we receive an Incomplete BatchDecodeResult, increase the capacity of the // buffer reading more data from the source and try to decode the batch again. BatchDecodeResult::Incomplete(_) => { - // println!("Increasing capacity to {}", self.capacity * 2); // increase the capacity attribute of the decoder by a factor of 2. buf.reserve(self.capacity); self.capacity *= 2; @@ -282,8 +309,10 @@ impl PostgresBinaryToArrowDecoder { Ok(batches) } + /// Decode a single batch of bytes from the buffer. This method is called by decode_batches + /// and has several different completion states each represented by a BatchDecodeResult. fn decode_batch(&mut self, buf: &mut BytesMut) -> BatchDecodeResult { - // ensure that the decoder is in the correct state befpre proceeding. + // ensure that the decoder is in the correct state before proceeding. assert_eq!(self.state, EncoderState::Encoding); // create a new BufferView from the buffer. @@ -321,15 +350,12 @@ impl PostgresBinaryToArrowDecoder { // If local_buf has been fully consumed and we have not read any rows, // return a BatchDecodeResult::Incomplete. if local_buf.remaining() == 0 && rows == 0 { - // println!("Incomplete no data remaining"); return BatchDecodeResult::Incomplete(local_buf.consumed()); // If local_buf has been fully consumed and we have read some rows, // return a BatchDecodeResult::PartialConsume, passing the number of bytes // consumed before reading the tuple to the caller so it can know how much data // was consumed. } else if local_buf.remaining() == 0 { - // println!("Partial consume no data remaining"); - // println!("Finishing batch. Rows: {}", rows); return match self.finish_batch() { Ok(batch) => BatchDecodeResult::PartialConsume { batch, consumed }, Err(e) => BatchDecodeResult::Error(e), @@ -345,12 +371,9 @@ impl PostgresBinaryToArrowDecoder { Err(ErrorKind::IncompleteData) => { // If we have not read any rows, return a BatchDecodeResult::Incomplete. if rows == 0 { - // println!("Incomplete mid-batch"); return BatchDecodeResult::Incomplete(local_buf.consumed()); } else { // If we have read some rows, return a BatchDecodeResult::PartialConsume, - // println!("Partial consume mid-batch"); - // println!("Finishing batch. Rows: {}", rows); return match self.finish_batch() { Ok(batch) => BatchDecodeResult::PartialConsume { batch, consumed }, Err(e) => BatchDecodeResult::Error(e), @@ -364,8 +387,6 @@ impl PostgresBinaryToArrowDecoder { rows += 1; } - // println!("Finishing batch. Rows: {}", rows); - // Finish the batch and return the result. match self.finish_batch() { Ok(batch) => BatchDecodeResult::Batch(batch), Err(e) => BatchDecodeResult::Error(e), @@ -395,10 +416,7 @@ impl PostgresBinaryToArrowDecoder { .map(|decoder| decoder.finish(column_len)) .collect(); - // Create a new RecordBatch from the columns vector and return it. - let record_batch = RecordBatch::try_new(self.schema.clone().nullify_columns(&null_columns).into(), columns)?; - - Ok(record_batch) + Ok(RecordBatch::try_new(self.schema.clone().nullify_columns(&null_columns).into(), columns)?) } } diff --git a/core/src/pg_schema.rs b/core/src/pg_schema.rs index b760812..84768f9 100644 --- a/core/src/pg_schema.rs +++ b/core/src/pg_schema.rs @@ -136,6 +136,36 @@ impl From for DataType { } } + +impl TryFrom for PostgresType { + type Error = ErrorKind; + fn try_from(data_type: DataType) -> Result { + let pg_type = match data_type { + DataType::Boolean => PostgresType::Bool, + DataType::Binary => PostgresType::Bytea, + DataType::Int64 => PostgresType::Int8, + DataType::Int32 => PostgresType::Int4, + DataType::Int16 => PostgresType::Int2, + DataType::Utf8 => PostgresType::Text, + DataType::Float32 => PostgresType::Float4, + DataType::Float64 => PostgresType::Float8, + DataType::Date32 => PostgresType::Date, + DataType::Time64(_) => PostgresType::Time, + DataType::Timestamp(_, tz) => { + if let Some(timezone) = tz { + PostgresType::TimestampTz(timezone.to_string()) + } else { + PostgresType::Timestamp + } + } + DataType::Duration(_) => PostgresType::Interval, + DataType::Null => PostgresType::Null, + _ => return Err(ErrorKind::UnsupportedArrowType { typ: data_type }), + }; + Ok(pg_type) + } +} + #[derive(Debug, Clone, PartialEq)] pub struct Column { pub data_type: PostgresType, @@ -236,6 +266,29 @@ impl From for SchemaRef { } } +impl TryFrom for PostgresSchema { + type Error = ErrorKind; + fn try_from(schema: Schema) -> Result { + let columns: Result, ErrorKind> = schema + .fields() + .iter() + .map(|field| { + let name = field.name().to_string(); + let data_type = field.data_type().clone(); + let nullable = field.is_nullable(); + let data_type = PostgresType::try_from(data_type)?; + let col = Column { + data_type, + nullable, + }; + Ok((name, col)) + }) + .collect(); + + Ok(PostgresSchema { columns: columns? }) + } +} + impl PostgresSchema { pub fn from_reader( mut reader: R, From b2071c9fbaa8cea1a4fcf686bdc18443cfc0a3d3 Mon Sep 17 00:00:00 2001 From: Adam Lefevre Date: Sat, 20 Apr 2024 10:48:03 -0500 Subject: [PATCH 08/11] remove file --- core/tests/testdata/profile_nullable.arrow | Bin 2055354 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 core/tests/testdata/profile_nullable.arrow diff --git a/core/tests/testdata/profile_nullable.arrow b/core/tests/testdata/profile_nullable.arrow deleted file mode 100644 index 27b26e7accc7d8f8705451c9af96bfe6debdf557..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2055354 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 z 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 Ao&W#< From 25382430bbf76ca1e363be56f04ace96be89340d Mon Sep 17 00:00:00 2001 From: Adam Lefevre Date: Sat, 4 May 2024 13:45:35 -0500 Subject: [PATCH 09/11] remove Seek bound --- core/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/src/lib.rs b/core/src/lib.rs index 0ef2e4f..b0d58d0 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -170,7 +170,7 @@ pub struct PostgresBinaryToArrowDecoder { capacity: usize, } -impl PostgresBinaryToArrowDecoder { +impl PostgresBinaryToArrowDecoder { pub fn new(schema: PostgresSchema, source: R, capacity: usize) -> Result { let decoders = PostgresDecoder::new(&schema); Ok(PostgresBinaryToArrowDecoder { From 39173a563a6e78b65b6e2fa1a34d961eda4c8097 Mon Sep 17 00:00:00 2001 From: Adam Lefevre Date: Fri, 12 Jul 2024 10:59:27 -0500 Subject: [PATCH 10/11] Get build of generic array working --- core/Cargo.toml | 1 + core/arr.bin | Bin 0 -> 109 bytes core/src/decoders.rs | 118 +++++++++++++++++++++++++++++++++++++++---- core/src/encoders.rs | 2 +- core/src/lib.rs | 10 ++-- 5 files changed, 114 insertions(+), 17 deletions(-) create mode 100644 core/arr.bin diff --git a/core/Cargo.toml b/core/Cargo.toml index 2e6d606..e5e0c2e 100644 --- a/core/Cargo.toml +++ b/core/Cargo.toml @@ -17,6 +17,7 @@ arrow-schema = ">=46.0.0" enum_dispatch = "0.3.11" anyhow = "1.0.70" thiserror = "1.0.40" +arrow = "^46.0.0" [dependencies.arrow-array] version = ">=46.0.0" diff --git a/core/arr.bin b/core/arr.bin new file mode 100644 index 0000000000000000000000000000000000000000..ca6c4cea5ea6d20f5cb0895fd60452892a5c12de GIT binary patch literal 109 zcmWG=clHm6GeJefp=^*iGZ2Gl79<*^4#Wq^foK?Jg|gWg82^I- E0C6}8hyVZp literal 0 HcmV?d00001 diff --git a/core/src/decoders.rs b/core/src/decoders.rs index 31bb3b7..eda1018 100644 --- a/core/src/decoders.rs +++ b/core/src/decoders.rs @@ -1,19 +1,22 @@ #![allow(clippy::redundant_closure_call)] use std::sync::Arc; +use arrow::compute::concat; +use arrow::buffer::{OffsetBuffer, NullBuffer}; +use arrow_schema::{DataType, Field}; use arrow_array::builder::GenericByteBuilder; use arrow_array::types::GenericBinaryType; -use arrow_array::{self, ArrayRef}; +use arrow_array::{self, ArrayRef, Array}; use arrow_array::{ BooleanArray, Date32Array, DurationMicrosecondArray, Float32Array, Float64Array, GenericStringArray, Int16Array, Int32Array, Int64Array, Time64MicrosecondArray, - TimestampMicrosecondArray, NullArray + TimestampMicrosecondArray, NullArray, GenericListArray }; use crate::encoders::{PG_BASE_DATE_OFFSET, PG_BASE_TIMESTAMP_OFFSET_US}; use crate::error::ErrorKind; use crate::buffer_view::BufferView; -use crate::pg_schema::{PostgresSchema, PostgresType}; +use crate::pg_schema::{PostgresSchema, PostgresType, Column}; /// Trait defining the methods needed to decode a Postgres type into an Arrow array @@ -648,6 +651,81 @@ impl_decode_variable_size!( i32 ); +pub struct ArrayDecoder { + name: String, + arr: Vec, + inner: Box, +} + +impl Decoder for ArrayDecoder { + fn decode(&mut self, buf: &mut BufferView<'_>) -> Result<(), ErrorKind> { + let field_size = buf.consume_into_u32()?; + if field_size == u32::MAX { + self.arr.push(Arc::new(NullArray::new(0))); + return Ok(()); + } + + let ndim = buf.consume_into_u32()?; + let _flags = buf.consume_into_u32()?; + let _elemtype = buf.consume_into_u32()?; + + let mut dims = vec![]; + for _ in 0..ndim { + let dim = buf.consume_into_u32()?; + dims.push(dim); + // consume the lbound whihc we dont need + buf.consume_into_u32()?; + } + + let nitems = dims.iter().product::() as usize; + + for _ in 0..nitems { + self.inner.decode(buf)?; + } + let array = self.inner.finish(nitems); + self.arr.push(array); + + Ok(()) + } + + fn finish(&mut self, column_len: usize) -> ArrayRef { + let data_type = self.arr[0].data_type(); + let length = self.arr[0].len(); + + let mut offsets = vec![0; length + 1]; + for i in 1..=length { + offsets[i] = offsets[i - 1] + self.arr[i - 1].len(); + } + + let array_refs: Vec<& dyn Array> = self.arr.iter().map(|a| a.as_ref()).collect(); + let nulls: Vec> = array_refs.iter().map(|a| a.nulls()).collect(); + let arrays = concat(&array_refs).unwrap(); + + let list_data = GenericListArray::::new( + Arc::new(Field::new("inner", data_type.clone(), true)), + OffsetBuffer::from_lengths(offsets), + arrays, + None, + ); + + Arc::new(list_data) as ArrayRef + } + + fn is_null(&self) -> bool { + unimplemented!() + } + + fn column_len(&self) -> usize { + self.arr.len() + } + + fn name(&self) -> String { + self.name.to_string() + } + +} + + // pub enum PostgresDecoder { Boolean(BooleanDecoder), @@ -665,13 +743,19 @@ pub enum PostgresDecoder { String(StringDecoder), Binary(BinaryDecoder), Jsonb(JsonbDecoder), + List(ArrayDecoder), } -// + + + + +pub(crate) fn create_decoders(schema: &PostgresSchema) -> Vec { + schema.iter().map(|(name, column)| PostgresDecoder::new(name, column)).collect() +} + impl PostgresDecoder { - pub fn new(schema: &PostgresSchema) -> Vec { - schema - .iter() - .map(|(name, column)| match column.data_type { + pub fn new(name: &str, column: &Column) -> Self { + match column.data_type { PostgresType::Bool => PostgresDecoder::Boolean(BooleanDecoder { name: name.to_string(), arr: vec![], @@ -737,12 +821,19 @@ impl PostgresDecoder { name: name.to_string(), arr: vec![], }), + PostgresType::List(ref inner) => { + let inner_decoder = Box::new(PostgresDecoder::new("inner", inner)); + PostgresDecoder::List(ArrayDecoder { + name: name.to_string(), + arr: vec![], + inner: inner_decoder, + }) + } _ => unimplemented!(), - }) - .collect() + } } - pub(crate) fn apply(&mut self, buf: &mut BufferView) -> Result<(), ErrorKind> { + pub(crate) fn decode(&mut self, buf: &mut BufferView) -> Result<(), ErrorKind> { match *self { PostgresDecoder::Boolean(ref mut decoder) => decoder.decode(buf), PostgresDecoder::Int16(ref mut decoder) => decoder.decode(buf), @@ -759,6 +850,7 @@ impl PostgresDecoder { PostgresDecoder::String(ref mut decoder) => decoder.decode(buf), PostgresDecoder::Binary(ref mut decoder) => decoder.decode(buf), PostgresDecoder::Jsonb(ref mut decoder) => decoder.decode(buf), + PostgresDecoder::List(ref mut decoder) => decoder.decode(buf), } } @@ -780,6 +872,7 @@ impl PostgresDecoder { PostgresDecoder::String(ref decoder) => decoder.name(), PostgresDecoder::Binary(ref decoder) => decoder.name(), PostgresDecoder::Jsonb(ref decoder) => decoder.name(), + PostgresDecoder::List(ref decoder) => decoder.name(), } } @@ -800,6 +893,7 @@ impl PostgresDecoder { PostgresDecoder::String(ref decoder) => decoder.column_len(), PostgresDecoder::Binary(ref decoder) => decoder.column_len(), PostgresDecoder::Jsonb(ref decoder) => decoder.column_len(), + PostgresDecoder::List(ref decoder) => decoder.column_len(), } } @@ -820,6 +914,7 @@ impl PostgresDecoder { PostgresDecoder::String(ref mut decoder) => decoder.finish(column_len), PostgresDecoder::Binary(ref mut decoder) => decoder.finish(column_len), PostgresDecoder::Jsonb(ref mut decoder) => decoder.finish(column_len), + PostgresDecoder::List(ref mut decoder) => decoder.finish(column_len), } } @@ -840,6 +935,7 @@ impl PostgresDecoder { PostgresDecoder::String(ref decoder) => decoder.is_null(), PostgresDecoder::Binary(ref decoder) => decoder.is_null(), PostgresDecoder::Jsonb(ref decoder) => decoder.is_null(), + PostgresDecoder::List(ref decoder) => decoder.is_null(), } } } diff --git a/core/src/encoders.rs b/core/src/encoders.rs index 6f7ac30..36ccd1e 100644 --- a/core/src/encoders.rs +++ b/core/src/encoders.rs @@ -10,7 +10,7 @@ use crate::error::ErrorKind; use crate::pg_schema::{Column, PostgresType, TypeSize}; #[inline] -fn downcast_checked<'a, T: 'static>(arr: &'a dyn Array, field: &str) -> Result<&'a T, ErrorKind> { +pub(crate) fn downcast_checked<'a, T: 'static>(arr: &'a dyn Array, field: &str) -> Result<&'a T, ErrorKind> { match arr.as_any().downcast_ref::() { Some(v) => Ok(v), None => Err(ErrorKind::mismatched_column_type( diff --git a/core/src/lib.rs b/core/src/lib.rs index b0d58d0..dac2897 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -1,5 +1,5 @@ use std::collections::HashMap; -use std::io::{BufRead, Seek}; +use std::io::BufRead; use arrow_array::RecordBatch; use arrow_schema::Fields; @@ -13,7 +13,7 @@ pub mod error; pub mod pg_schema; mod buffer_view; -use crate::decoders::PostgresDecoder; +use crate::decoders::{PostgresDecoder, create_decoders}; use crate::buffer_view::BufferView; use crate::encoders::{BuildEncoder, Encode, EncoderBuilder}; use crate::pg_schema::PostgresSchema; @@ -172,7 +172,7 @@ pub struct PostgresBinaryToArrowDecoder { impl PostgresBinaryToArrowDecoder { pub fn new(schema: PostgresSchema, source: R, capacity: usize) -> Result { - let decoders = PostgresDecoder::new(&schema); + let decoders = create_decoders(&schema); Ok(PostgresBinaryToArrowDecoder { schema, decoders, @@ -190,7 +190,7 @@ impl PostgresBinaryToArrowDecoder { capacity: usize, ) -> Result { let pg_schema = PostgresSchema::try_from(schema)?; - let decoders = PostgresDecoder::new(&pg_schema); + let decoders = create_decoders(&pg_schema); Ok(PostgresBinaryToArrowDecoder { decoders, schema: pg_schema, @@ -362,7 +362,7 @@ impl PostgresBinaryToArrowDecoder { }; } // Apply the decoder to the local_buf. Cosume the data from the buffer as needed - match decoder.apply(&mut local_buf) { + match decoder.decode(&mut local_buf) { // If the decoder was able to decode the data, continue to the next column. Ok(_) => {} // If we receive a IncompleteData error, we have reached the end of the data in From 4233e3c8f9d0ee5cd23d54c521c8dc0223004db7 Mon Sep 17 00:00:00 2001 From: Adam Lefevre Date: Sat, 13 Jul 2024 21:02:58 -0500 Subject: [PATCH 11/11] Implement list decoding and add tests --- Cargo.lock | 98 +++++++-- core/arr.bin | Bin 109 -> 0 bytes core/src/decoders.rs | 87 ++++++-- core/src/encoders.rs | 4 +- core/src/pg_schema.rs | 33 ++- core/tests/decode_integration_tests.rs | 208 +++++++++++++++++- core/tests/decoding/int64_nullable | 1 - core/tests/decoding/list_binary.schema | 1 + .../decoding/list_binary_nullable.schema | 1 + core/tests/decoding/list_bool.schema | 1 + core/tests/decoding/list_bool_nullable.schema | 1 + core/tests/decoding/list_date32.schema | 1 + .../decoding/list_date32_nullable.schema | 1 + core/tests/decoding/list_duration_us.schema | 1 + .../decoding/list_duration_us_nullable.schema | 1 + core/tests/decoding/list_float32.schema | 1 + .../decoding/list_float32_nullable.schema | 1 + core/tests/decoding/list_float64.schema | 1 + .../decoding/list_float64_nullable.schema | 1 + core/tests/decoding/list_int16.schema | 1 + .../tests/decoding/list_int16_nullable.schema | 1 + core/tests/decoding/list_int32.schema | 1 + .../tests/decoding/list_int32_nullable.schema | 1 + core/tests/decoding/list_int64.schema | 1 + .../tests/decoding/list_int64_nullable.schema | 1 + core/tests/decoding/list_numeric.schema | 1 + .../decoding/list_numeric_nullable.schema | 1 + core/tests/decoding/list_string.schema | 1 + .../decoding/list_string_nullable.schema | 1 + core/tests/decoding/list_time_us.schema | 1 + .../decoding/list_time_us_nullable.schema | 1 + .../decoding/list_timestamp_us_notz.schema | 1 + .../list_timestamp_us_notz_nullable.schema | 1 + .../decoding/list_timestamp_us_tz.schema | 1 + .../list_timestamp_us_tz_nullable.schema | 1 + 35 files changed, 409 insertions(+), 50 deletions(-) delete mode 100644 core/arr.bin delete mode 100644 core/tests/decoding/int64_nullable create mode 100644 core/tests/decoding/list_binary.schema create mode 100644 core/tests/decoding/list_binary_nullable.schema create mode 100644 core/tests/decoding/list_bool.schema create mode 100644 core/tests/decoding/list_bool_nullable.schema create mode 100644 core/tests/decoding/list_date32.schema create mode 100644 core/tests/decoding/list_date32_nullable.schema create mode 100644 core/tests/decoding/list_duration_us.schema create mode 100644 core/tests/decoding/list_duration_us_nullable.schema create mode 100644 core/tests/decoding/list_float32.schema create mode 100644 core/tests/decoding/list_float32_nullable.schema create mode 100644 core/tests/decoding/list_float64.schema create mode 100644 core/tests/decoding/list_float64_nullable.schema create mode 100644 core/tests/decoding/list_int16.schema create mode 100644 core/tests/decoding/list_int16_nullable.schema create mode 100644 core/tests/decoding/list_int32.schema create mode 100644 core/tests/decoding/list_int32_nullable.schema create mode 100644 core/tests/decoding/list_int64.schema create mode 100644 core/tests/decoding/list_int64_nullable.schema create mode 100644 core/tests/decoding/list_numeric.schema create mode 100644 core/tests/decoding/list_numeric_nullable.schema create mode 100644 core/tests/decoding/list_string.schema create mode 100644 core/tests/decoding/list_string_nullable.schema create mode 100644 core/tests/decoding/list_time_us.schema create mode 100644 core/tests/decoding/list_time_us_nullable.schema create mode 100644 core/tests/decoding/list_timestamp_us_notz.schema create mode 100644 core/tests/decoding/list_timestamp_us_notz_nullable.schema create mode 100644 core/tests/decoding/list_timestamp_us_tz.schema create mode 100644 core/tests/decoding/list_timestamp_us_tz_nullable.schema diff --git a/Cargo.lock b/Cargo.lock index 01a85e7..a0de25b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -410,14 +410,14 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" [[package]] name = "chrono" -version = "0.4.31" +version = "0.4.38" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38" +checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401" dependencies = [ "android-tzdata", "iana-time-zone", "num-traits", - "windows-targets", + "windows-targets 0.52.6", ] [[package]] @@ -1115,9 +1115,9 @@ dependencies = [ [[package]] name = "memchr" -version = "2.6.3" +version = "2.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f232d6ef707e1956a43342693d2a31e72989554d58299d7a88738cc95b0d35c" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] name = "memoffset" @@ -1255,7 +1255,7 @@ dependencies = [ "libc", "redox_syscall", "smallvec", - "windows-targets", + "windows-targets 0.48.5", ] [[package]] @@ -1680,9 +1680,9 @@ dependencies = [ [[package]] name = "ryu" -version = "1.0.15" +version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741" +checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" [[package]] name = "same-file" @@ -2114,7 +2114,7 @@ version = "0.48.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f" dependencies = [ - "windows-targets", + "windows-targets 0.48.5", ] [[package]] @@ -2123,7 +2123,7 @@ version = "0.48.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" dependencies = [ - "windows-targets", + "windows-targets 0.48.5", ] [[package]] @@ -2132,13 +2132,29 @@ version = "0.48.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" dependencies = [ - "windows_aarch64_gnullvm", - "windows_aarch64_msvc", - "windows_i686_gnu", - "windows_i686_msvc", - "windows_x86_64_gnu", - "windows_x86_64_gnullvm", - "windows_x86_64_msvc", + "windows_aarch64_gnullvm 0.48.5", + "windows_aarch64_msvc 0.48.5", + "windows_i686_gnu 0.48.5", + "windows_i686_msvc 0.48.5", + "windows_x86_64_gnu 0.48.5", + "windows_x86_64_gnullvm 0.48.5", + "windows_x86_64_msvc 0.48.5", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", + "windows_i686_gnullvm", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", ] [[package]] @@ -2147,42 +2163,90 @@ version = "0.48.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + [[package]] name = "windows_aarch64_msvc" version = "0.48.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + [[package]] name = "windows_i686_gnu" version = "0.48.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + [[package]] name = "windows_i686_msvc" version = "0.48.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + [[package]] name = "windows_x86_64_gnu" version = "0.48.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + [[package]] name = "windows_x86_64_gnullvm" version = "0.48.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + [[package]] name = "windows_x86_64_msvc" version = "0.48.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + [[package]] name = "zstd" version = "0.12.4" diff --git a/core/arr.bin b/core/arr.bin deleted file mode 100644 index ca6c4cea5ea6d20f5cb0895fd60452892a5c12de..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 109 zcmWG=clHm6GeJefp=^*iGZ2Gl79<*^4#Wq^foK?Jg|gWg82^I- E0C6}8hyVZp diff --git a/core/src/decoders.rs b/core/src/decoders.rs index eda1018..6e1a734 100644 --- a/core/src/decoders.rs +++ b/core/src/decoders.rs @@ -2,7 +2,7 @@ use std::sync::Arc; use arrow::compute::concat; -use arrow::buffer::{OffsetBuffer, NullBuffer}; +use arrow::buffer::{OffsetBuffer, NullBuffer, BooleanBuffer}; use arrow_schema::{DataType, Field}; use arrow_array::builder::GenericByteBuilder; use arrow_array::types::GenericBinaryType; @@ -207,6 +207,7 @@ macro_rules! impl_decode_variable_size { } #[allow(dead_code)] +#[derive(Debug)] pub struct BooleanDecoder { name: String, arr: Vec>, @@ -214,6 +215,7 @@ pub struct BooleanDecoder { impl_decode!(BooleanDecoder, 1, |b: [u8; 1]| b[0] == 1, BooleanArray); +#[derive(Debug)] pub struct Int16Decoder { name: String, arr: Vec>, @@ -221,6 +223,7 @@ pub struct Int16Decoder { impl_decode!(Int16Decoder, 2, i16::from_be_bytes, Int16Array); +#[derive(Debug)] pub struct Int32Decoder { name: String, arr: Vec>, @@ -228,6 +231,7 @@ pub struct Int32Decoder { impl_decode!(Int32Decoder, 4, i32::from_be_bytes, Int32Array); +#[derive(Debug)] pub struct Int64Decoder { name: String, arr: Vec>, @@ -235,6 +239,7 @@ pub struct Int64Decoder { impl_decode!(Int64Decoder, 8, i64::from_be_bytes, Int64Array); +#[derive(Debug)] pub struct Float32Decoder { name: String, arr: Vec>, @@ -242,6 +247,7 @@ pub struct Float32Decoder { impl_decode!(Float32Decoder, 4, f32::from_be_bytes, Float32Array); +#[derive(Debug)] pub struct Float64Decoder { name: String, arr: Vec>, @@ -263,6 +269,7 @@ fn convert_pg_timestamp_to_arrow_timestamp_microseconds( }) } +#[derive(Debug)] pub struct TimestampMicrosecondDecoder { name: String, arr: Vec>, @@ -278,6 +285,7 @@ impl_decode_fallible!( TimestampMicrosecondArray ); +#[derive(Debug)] pub struct TimestampTzMicrosecondDecoder { name: String, arr: Vec>, @@ -338,6 +346,7 @@ fn convert_pg_date_to_arrow_date(date: i32) -> Result { }) } +#[derive(Debug)] pub struct Date32Decoder { name: String, arr: Vec>, @@ -353,6 +362,7 @@ impl_decode_fallible!( Date32Array ); +#[derive(Debug)] pub struct Time64MicrosecondDecoder { name: String, arr: Vec>, @@ -399,6 +409,7 @@ fn convert_pg_duration_to_arrow_duration( })? } +#[derive(Debug)] pub struct DurationMicrosecondDecoder { name: String, arr: Vec>, @@ -417,6 +428,7 @@ impl_decode_fallible!( DurationMicrosecondArray ); +#[derive(Debug)] pub struct StringDecoder { name: String, arr: Vec>, @@ -435,6 +447,7 @@ impl_decode_variable_size!( i32 ); +#[derive(Debug)] pub struct BinaryDecoder { name: String, arr: Vec>>, @@ -484,6 +497,7 @@ impl Decoder for BinaryDecoder { } } +#[derive(Debug)] pub struct JsonbDecoder { name: String, arr: Vec>, @@ -638,6 +652,7 @@ fn truncate_and_finalize(mut v: Vec, scale: i16) -> String { String::from_utf8(v).unwrap() } +#[derive(Debug)] pub struct NumericDecoder { name: String, arr: Vec>, @@ -651,12 +666,14 @@ impl_decode_variable_size!( i32 ); +#[derive(Debug)] pub struct ArrayDecoder { name: String, arr: Vec, inner: Box, } + impl Decoder for ArrayDecoder { fn decode(&mut self, buf: &mut BufferView<'_>) -> Result<(), ErrorKind> { let field_size = buf.consume_into_u32()?; @@ -673,7 +690,7 @@ impl Decoder for ArrayDecoder { for _ in 0..ndim { let dim = buf.consume_into_u32()?; dims.push(dim); - // consume the lbound whihc we dont need + // consume the lbound which we dont need buf.consume_into_u32()?; } @@ -688,31 +705,56 @@ impl Decoder for ArrayDecoder { Ok(()) } - fn finish(&mut self, column_len: usize) -> ArrayRef { - let data_type = self.arr[0].data_type(); - let length = self.arr[0].len(); - - let mut offsets = vec![0; length + 1]; - for i in 1..=length { - offsets[i] = offsets[i - 1] + self.arr[i - 1].len(); + fn finish(&mut self, _column_len: usize) -> ArrayRef { + // Check if all the arrays are null and return a null array if so + if self.is_null() { + return Arc::new(NullArray::new(0)) as ArrayRef; } - let array_refs: Vec<& dyn Array> = self.arr.iter().map(|a| a.as_ref()).collect(); - let nulls: Vec> = array_refs.iter().map(|a| a.nulls()).collect(); - let arrays = concat(&array_refs).unwrap(); + let arrays = std::mem::take(&mut self.arr); - let list_data = GenericListArray::::new( - Arc::new(Field::new("inner", data_type.clone(), true)), - OffsetBuffer::from_lengths(offsets), - arrays, - None, - ); + // Build the offset buffer for the commbined ListArray using + // the lengths of the component arrays + let mut offset_values = vec![0 as i32]; + for i in 1..arrays.len() + 1 { + offset_values.push(arrays[i - 1].len() as i32 + offset_values[i - 1]); + } + let offsets = OffsetBuffer::new(offset_values.into()); + + // Concatenate the data of the component arrays + // to create the child data of the ListArray + let array_refs: Vec<& dyn Array> = arrays.iter().filter( + |a| !matches!(a.data_type(), DataType::Null) + ).map(|a| a.as_ref()).collect(); + let child_data = concat(&array_refs).unwrap(); + + // Calculate the null buffer for the ListArray + // by checking if the component arrays are null + let null_values = arrays.iter().map(|a| { + match a.data_type() { + DataType::Null => false, + _ => true, + } + }).collect::>(); - Arc::new(list_data) as ArrayRef + // If there are no nulls, return None for the null buffer + let nulls = if null_values.iter().all(|v| *v) { + None + } else { + Some(NullBuffer::from(BooleanBuffer::from(null_values))) + }; + + // Construct the ListArray from parts + Arc::new(GenericListArray::new( + Arc::new(Field::new(self.name().replace("list_", ""), arrays[0].data_type().clone(), true)), + offsets, + child_data, + nulls, + )) as ArrayRef } fn is_null(&self) -> bool { - unimplemented!() + self.arr.iter().all(|a| matches!(a.data_type(), DataType::Null)) } fn column_len(&self) -> usize { @@ -722,11 +764,11 @@ impl Decoder for ArrayDecoder { fn name(&self) -> String { self.name.to_string() } - } // +#[derive(Debug)] pub enum PostgresDecoder { Boolean(BooleanDecoder), Int16(Int16Decoder), @@ -822,7 +864,8 @@ impl PostgresDecoder { arr: vec![], }), PostgresType::List(ref inner) => { - let inner_decoder = Box::new(PostgresDecoder::new("inner", inner)); + let (name, column) = inner; + let inner_decoder = Box::new(PostgresDecoder::new(name, column)); PostgresDecoder::List(ArrayDecoder { name: name.to_string(), arr: vec![], diff --git a/core/src/encoders.rs b/core/src/encoders.rs index 36ccd1e..f89d715 100644 --- a/core/src/encoders.rs +++ b/core/src/encoders.rs @@ -1123,9 +1123,9 @@ macro_rules! impl_list_encoder_builder { } fn schema(&self) -> Column { Column { - data_type: PostgresType::List(Box::new( + data_type: PostgresType::List(("".to_string(), Box::new( self.inner_encoder_builder.schema().clone(), - )), + ))), nullable: self.field.is_nullable(), } } diff --git a/core/src/pg_schema.rs b/core/src/pg_schema.rs index 84768f9..22b6523 100644 --- a/core/src/pg_schema.rs +++ b/core/src/pg_schema.rs @@ -27,7 +27,7 @@ pub enum PostgresType { Timestamp, TimestampTz(String), Interval, - List(Box), + List((String, Box)), Null, } @@ -97,9 +97,9 @@ impl PostgresType { PostgresType::Timestamp => "TIMESTAMP".to_string(), PostgresType::TimestampTz(_) => "TIMESTAMP WITH ZONE".to_string(), PostgresType::Interval => "INTERVAL".to_string(), - PostgresType::List(inner) => { + PostgresType::List((_, column)) => { // arrays of structs and such are not supported - let inner_tp = inner.data_type.name().unwrap(); + let inner_tp = column.data_type.name().unwrap(); format!("{inner_tp}[]") } PostgresType::Null => "NULL".to_string(), @@ -108,6 +108,11 @@ impl PostgresType { } } + +impl PostgresType { +} + + impl From for DataType { fn from(pg_type: PostgresType) -> Self { match pg_type { @@ -130,7 +135,14 @@ impl From for DataType { DataType::Timestamp(TimeUnit::Microsecond, Some(timezone.into())) } PostgresType::Interval => DataType::Duration(TimeUnit::Microsecond), - PostgresType::List(_) => unimplemented!(), + PostgresType::List((name, column)) => { + let name = name.replace("list_", ""); + DataType::List(Arc::new(Field::new( + &name, + column.data_type.clone().into(), + column.nullable, + ))) + }, PostgresType::Null => DataType::Null, } } @@ -173,7 +185,7 @@ pub struct Column { } impl Column { - pub fn from_parts(type_str: &str, nullable: &str, timezone: String) -> Result { + pub fn from_parts(name: &str, type_str: &str, nullable: &str, timezone: String) -> Result { match type_str { "boolean" => Ok(Column { data_type: PostgresType::Bool, @@ -243,6 +255,15 @@ impl Column { data_type: PostgresType::Interval, nullable: nullable == "t", }), + typ if typ.ends_with("[]") => { + Ok(Column { + data_type: PostgresType::List((name.to_string(), Box::new(Column { + data_type: Column::from_parts(name, &typ[..typ.len() - 2], "f", timezone)?.data_type, + nullable: true, + }))), + nullable: nullable == "t", + }) + }, _ => Err(ErrorKind::UnsupportedColumnType { typ: type_str.to_string(), }), @@ -311,7 +332,7 @@ impl PostgresSchema { let name = parts[0]; let typ = parts[1]; let nullable = parts[2]; - let col = Column::from_parts(typ, nullable, timezone.to_string())?; + let col = Column::from_parts(name, typ, nullable, timezone.to_string())?; Ok((name.to_string(), col)) }) .collect::, ErrorKind>>() diff --git a/core/tests/decode_integration_tests.rs b/core/tests/decode_integration_tests.rs index db04108..22865b1 100644 --- a/core/tests/decode_integration_tests.rs +++ b/core/tests/decode_integration_tests.rs @@ -34,6 +34,7 @@ fn run_test_case(case: &str, timezone: String) -> Result<(), ErrorKind> { let file = File::open(path).unwrap(); let reader = BufReader::with_capacity(READ_CHUNK_SIZE, file); let schema = read_schema_file(schema_path, timezone); + println!("Schema: {:?}", schema); let mut decoder = PostgresBinaryToArrowDecoder::new(schema, reader, READ_CHUNK_SIZE).unwrap(); decoder.read_header()?; @@ -44,6 +45,7 @@ fn run_test_case(case: &str, timezone: String) -> Result<(), ErrorKind> { // all testdata currently has nullable set where it should not. // This is a workaround to make the test pass. if !case.contains("nullable") { + println!("Setting nullable to false for case: {}", case); expected_batches = expected_batches .into_iter() .map(|batch| { @@ -54,13 +56,38 @@ fn run_test_case(case: &str, timezone: String) -> Result<(), ErrorKind> { .map(|f| Arc::new((*f).clone().with_nullable(false))) .collect(); let new_schema = Schema::new(new_fields); - println!("{:?}", new_schema); RecordBatch::try_new(Arc::new(new_schema), batch.columns().to_vec()).unwrap() }) .collect::>(); } - assert_eq!(batches.iter().map(|b| b.num_rows()).sum::(), expected_batches.iter().map(|b| b.num_rows()).sum()); + // All list types are not nullable in the expected data + // This is a workaround to make the test pass. + if case.contains("list") && case.contains("nullable") { + expected_batches = expected_batches + .into_iter() + .map(|batch| { + let new_fields: Vec> = (*(*batch.schema()).clone().fields) + .to_vec() + .clone() + .into_iter() + .map(|f| { + let new_field = (*f).clone(); + let new_field = new_field.with_nullable(false); + if new_field.data_type().to_string().contains("List") { + Arc::new(new_field.with_nullable(true)) + } else { + Arc::new(new_field) + } + }) + .collect(); + let new_schema = Schema::new(new_fields); + RecordBatch::try_new(Arc::new(new_schema), batch.columns().to_vec()).unwrap() + }) + .collect::>(); + } + + assert_eq!(batches.iter().map(|b| b.num_rows()).sum::(), expected_batches.iter().map(|b| b.num_rows()).sum::()); let batch_schemas = batches.iter().map(|b| b.schema()).collect::>(); let expected_batch_schemas = expected_batches.iter().map(|b| b.schema()).collect::>(); assert_eq!(batch_schemas, expected_batch_schemas); @@ -153,6 +180,8 @@ fn test_string() -> Result<(), ErrorKind> { Ok(()) } +// nullable types + #[test] fn test_bool_nullable() -> Result<(), ErrorKind> { run_test_case("bool_nullable", "America/New_York".to_string())?; @@ -236,3 +265,178 @@ fn test_numeric_nullable() -> Result<(), ErrorKind> { run_test_case("numeric_nullable", "America/New_York".to_string())?; Ok(()) } + +// Nested types non-nullable + + +#[test] +fn test_list_int16() -> Result<(), ErrorKind> { + run_test_case("list_int16", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_int32() -> Result<(), ErrorKind> { + run_test_case("list_int32", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_int64() -> Result<(), ErrorKind> { + run_test_case("list_int64", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_float32() -> Result<(), ErrorKind> { + run_test_case("list_float32", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_float64() -> Result<(), ErrorKind> { + run_test_case("list_float64", "America/New_York".to_string())?; + Ok(()) +} + +// Needed to add expected data for list_numeric +// #[test] +// fn test_list_numeric() -> Result<(), ErrorKind> { +// run_test_case("list_numeric", "America/New_York".to_string())?; +// Ok(()) +// } + +#[test] +fn test_list_timestamp_us_notz() -> Result<(), ErrorKind> { + run_test_case("list_timestamp_us_notz", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_timestamp_us_tz() -> Result<(), ErrorKind> { + run_test_case("list_timestamp_us_tz", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_time_us() -> Result<(), ErrorKind> { + run_test_case("list_time_us", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_date32() -> Result<(), ErrorKind> { + run_test_case("list_date32", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_duration_us() -> Result<(), ErrorKind> { + run_test_case("list_duration_us", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_binary() -> Result<(), ErrorKind> { + run_test_case("list_binary", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_string() -> Result<(), ErrorKind> { + run_test_case("list_string", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_bool() -> Result<(), ErrorKind> { + run_test_case("list_bool", "America/New_York".to_string())?; + Ok(()) +} + +// Nested types nullable + +#[test] +fn test_list_bool_nullable() -> Result<(), ErrorKind> { + run_test_case("list_bool_nullable", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_int16_nullable() -> Result<(), ErrorKind> { + run_test_case("list_int16_nullable", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_int32_nullable() -> Result<(), ErrorKind> { + run_test_case("list_int32_nullable", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_int64_nullable() -> Result<(), ErrorKind> { + run_test_case("list_int64_nullable", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_float32_nullable() -> Result<(), ErrorKind> { + run_test_case("list_float32_nullable", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_float64_nullable() -> Result<(), ErrorKind> { + run_test_case("list_float64_nullable", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_timestamp_us_notz_nullable() -> Result<(), ErrorKind> { + run_test_case("list_timestamp_us_notz_nullable", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_timestamp_us_tz_nullable() -> Result<(), ErrorKind> { + run_test_case("list_timestamp_us_tz_nullable", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_time_us_nullable() -> Result<(), ErrorKind> { + run_test_case("list_time_us_nullable", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_date32_nullable() -> Result<(), ErrorKind> { + run_test_case("list_date32_nullable", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_duration_us_nullable() -> Result<(), ErrorKind> { + run_test_case("list_duration_us_nullable", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_binary_nullable() -> Result<(), ErrorKind> { + run_test_case("list_binary_nullable", "America/New_York".to_string())?; + Ok(()) +} + +#[test] +fn test_list_string_nullable() -> Result<(), ErrorKind> { + run_test_case("list_string_nullable", "America/New_York".to_string())?; + Ok(()) +} + +// Needed to add expected data for list_numeric_nullable +// #[test] +// fn test_list_numeric_nullable() -> Result<(), ErrorKind> { +// run_test_case("list_numeric_nullable", "America/New_York".to_string())?; +// Ok(()) +// } diff --git a/core/tests/decoding/int64_nullable b/core/tests/decoding/int64_nullable deleted file mode 100644 index 4215f43..0000000 --- a/core/tests/decoding/int64_nullable +++ /dev/null @@ -1 +0,0 @@ -int64,bigint,t diff --git a/core/tests/decoding/list_binary.schema b/core/tests/decoding/list_binary.schema new file mode 100644 index 0000000..05ed96b --- /dev/null +++ b/core/tests/decoding/list_binary.schema @@ -0,0 +1 @@ +list_binary,bytea[],f diff --git a/core/tests/decoding/list_binary_nullable.schema b/core/tests/decoding/list_binary_nullable.schema new file mode 100644 index 0000000..a728383 --- /dev/null +++ b/core/tests/decoding/list_binary_nullable.schema @@ -0,0 +1 @@ +list_binary_nullable,bytea[],t diff --git a/core/tests/decoding/list_bool.schema b/core/tests/decoding/list_bool.schema new file mode 100644 index 0000000..fa56254 --- /dev/null +++ b/core/tests/decoding/list_bool.schema @@ -0,0 +1 @@ +list_bool,boolean[],f diff --git a/core/tests/decoding/list_bool_nullable.schema b/core/tests/decoding/list_bool_nullable.schema new file mode 100644 index 0000000..7bb29af --- /dev/null +++ b/core/tests/decoding/list_bool_nullable.schema @@ -0,0 +1 @@ +list_bool_nullable,boolean[],t diff --git a/core/tests/decoding/list_date32.schema b/core/tests/decoding/list_date32.schema new file mode 100644 index 0000000..10f6597 --- /dev/null +++ b/core/tests/decoding/list_date32.schema @@ -0,0 +1 @@ +list_date32,date[],f diff --git a/core/tests/decoding/list_date32_nullable.schema b/core/tests/decoding/list_date32_nullable.schema new file mode 100644 index 0000000..c61c08b --- /dev/null +++ b/core/tests/decoding/list_date32_nullable.schema @@ -0,0 +1 @@ +list_date32_nullable,date[],t diff --git a/core/tests/decoding/list_duration_us.schema b/core/tests/decoding/list_duration_us.schema new file mode 100644 index 0000000..34a89bc --- /dev/null +++ b/core/tests/decoding/list_duration_us.schema @@ -0,0 +1 @@ +list_duration_us,interval[],f diff --git a/core/tests/decoding/list_duration_us_nullable.schema b/core/tests/decoding/list_duration_us_nullable.schema new file mode 100644 index 0000000..8fb3609 --- /dev/null +++ b/core/tests/decoding/list_duration_us_nullable.schema @@ -0,0 +1 @@ +list_duration_us_nullable,interval[],t diff --git a/core/tests/decoding/list_float32.schema b/core/tests/decoding/list_float32.schema new file mode 100644 index 0000000..127f883 --- /dev/null +++ b/core/tests/decoding/list_float32.schema @@ -0,0 +1 @@ +list_float32,real[],f diff --git a/core/tests/decoding/list_float32_nullable.schema b/core/tests/decoding/list_float32_nullable.schema new file mode 100644 index 0000000..0220ad4 --- /dev/null +++ b/core/tests/decoding/list_float32_nullable.schema @@ -0,0 +1 @@ +list_float32_nullable,real[],t diff --git a/core/tests/decoding/list_float64.schema b/core/tests/decoding/list_float64.schema new file mode 100644 index 0000000..1d51647 --- /dev/null +++ b/core/tests/decoding/list_float64.schema @@ -0,0 +1 @@ +list_float64,double precision[],f diff --git a/core/tests/decoding/list_float64_nullable.schema b/core/tests/decoding/list_float64_nullable.schema new file mode 100644 index 0000000..7afa553 --- /dev/null +++ b/core/tests/decoding/list_float64_nullable.schema @@ -0,0 +1 @@ +list_float64_nullable,double precision[],t diff --git a/core/tests/decoding/list_int16.schema b/core/tests/decoding/list_int16.schema new file mode 100644 index 0000000..b3cd100 --- /dev/null +++ b/core/tests/decoding/list_int16.schema @@ -0,0 +1 @@ +list_int16,smallint[],f diff --git a/core/tests/decoding/list_int16_nullable.schema b/core/tests/decoding/list_int16_nullable.schema new file mode 100644 index 0000000..b393c8f --- /dev/null +++ b/core/tests/decoding/list_int16_nullable.schema @@ -0,0 +1 @@ +list_int16_nullable,smallint[],t diff --git a/core/tests/decoding/list_int32.schema b/core/tests/decoding/list_int32.schema new file mode 100644 index 0000000..a9cdc49 --- /dev/null +++ b/core/tests/decoding/list_int32.schema @@ -0,0 +1 @@ +list_int32,integer[],f diff --git a/core/tests/decoding/list_int32_nullable.schema b/core/tests/decoding/list_int32_nullable.schema new file mode 100644 index 0000000..bd9cc8e --- /dev/null +++ b/core/tests/decoding/list_int32_nullable.schema @@ -0,0 +1 @@ +list_int32_nullable,integer[],t diff --git a/core/tests/decoding/list_int64.schema b/core/tests/decoding/list_int64.schema new file mode 100644 index 0000000..e1fb72e --- /dev/null +++ b/core/tests/decoding/list_int64.schema @@ -0,0 +1 @@ +list_int64,bigint[],f diff --git a/core/tests/decoding/list_int64_nullable.schema b/core/tests/decoding/list_int64_nullable.schema new file mode 100644 index 0000000..1af3130 --- /dev/null +++ b/core/tests/decoding/list_int64_nullable.schema @@ -0,0 +1 @@ +list_int64_nullable,bigint[],t diff --git a/core/tests/decoding/list_numeric.schema b/core/tests/decoding/list_numeric.schema new file mode 100644 index 0000000..52af8c2 --- /dev/null +++ b/core/tests/decoding/list_numeric.schema @@ -0,0 +1 @@ +list_numeric,numeric[],f diff --git a/core/tests/decoding/list_numeric_nullable.schema b/core/tests/decoding/list_numeric_nullable.schema new file mode 100644 index 0000000..294b201 --- /dev/null +++ b/core/tests/decoding/list_numeric_nullable.schema @@ -0,0 +1 @@ +list_numeric_nullable,numeric[],t diff --git a/core/tests/decoding/list_string.schema b/core/tests/decoding/list_string.schema new file mode 100644 index 0000000..b4bd045 --- /dev/null +++ b/core/tests/decoding/list_string.schema @@ -0,0 +1 @@ +list_string,text[],f diff --git a/core/tests/decoding/list_string_nullable.schema b/core/tests/decoding/list_string_nullable.schema new file mode 100644 index 0000000..5fe1da9 --- /dev/null +++ b/core/tests/decoding/list_string_nullable.schema @@ -0,0 +1 @@ +list_string_nullable,text[],t diff --git a/core/tests/decoding/list_time_us.schema b/core/tests/decoding/list_time_us.schema new file mode 100644 index 0000000..d6032a9 --- /dev/null +++ b/core/tests/decoding/list_time_us.schema @@ -0,0 +1 @@ +list_time_us,time[],f diff --git a/core/tests/decoding/list_time_us_nullable.schema b/core/tests/decoding/list_time_us_nullable.schema new file mode 100644 index 0000000..f4c40f4 --- /dev/null +++ b/core/tests/decoding/list_time_us_nullable.schema @@ -0,0 +1 @@ +list_time_us_nullable,time[],t diff --git a/core/tests/decoding/list_timestamp_us_notz.schema b/core/tests/decoding/list_timestamp_us_notz.schema new file mode 100644 index 0000000..40e94ca --- /dev/null +++ b/core/tests/decoding/list_timestamp_us_notz.schema @@ -0,0 +1 @@ +list_timestamp_us_notz,timestamp without time zone[],f diff --git a/core/tests/decoding/list_timestamp_us_notz_nullable.schema b/core/tests/decoding/list_timestamp_us_notz_nullable.schema new file mode 100644 index 0000000..18a924c --- /dev/null +++ b/core/tests/decoding/list_timestamp_us_notz_nullable.schema @@ -0,0 +1 @@ +list_timestamp_us_notz_nullable,timestamp without time zone[],t diff --git a/core/tests/decoding/list_timestamp_us_tz.schema b/core/tests/decoding/list_timestamp_us_tz.schema new file mode 100644 index 0000000..69a52d4 --- /dev/null +++ b/core/tests/decoding/list_timestamp_us_tz.schema @@ -0,0 +1 @@ +list_timestamp_us_tz,timestamp with time zone[],f diff --git a/core/tests/decoding/list_timestamp_us_tz_nullable.schema b/core/tests/decoding/list_timestamp_us_tz_nullable.schema new file mode 100644 index 0000000..abd71f8 --- /dev/null +++ b/core/tests/decoding/list_timestamp_us_tz_nullable.schema @@ -0,0 +1 @@ +list_timestamp_us_tz_nullable,timestamp with time zone[],t

;qjI%OSig=7jXWoY7n~R$ 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