{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TypeApplications #-}

module DataFrame.IO.Parquet.Thrift where

import Control.Monad
import Data.Bits
import Data.Char
import Data.IORef
import Data.Int
import qualified Data.Map as M
import Data.Maybe
import qualified Data.Text as T
import Data.Word
import DataFrame.IO.Parquet.Binary
import DataFrame.IO.Parquet.Types
import Foreign
import System.IO

data SchemaElement = SchemaElement
    { SchemaElement -> Text
elementName :: T.Text
    , SchemaElement -> TType
elementType :: TType
    , SchemaElement -> Int32
typeLength :: Int32
    , SchemaElement -> Int32
numChildren :: Int32
    , SchemaElement -> Int32
fieldId :: Int32
    , SchemaElement -> RepetitionType
repetitionType :: RepetitionType
    , SchemaElement -> Int32
convertedType :: Int32
    , SchemaElement -> Int32
scale :: Int32
    , SchemaElement -> Int32
precision :: Int32
    , SchemaElement -> LogicalType
logicalType :: LogicalType
    }
    deriving (Int -> SchemaElement -> ShowS
[SchemaElement] -> ShowS
SchemaElement -> [Char]
(Int -> SchemaElement -> ShowS)
-> (SchemaElement -> [Char])
-> ([SchemaElement] -> ShowS)
-> Show SchemaElement
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SchemaElement -> ShowS
showsPrec :: Int -> SchemaElement -> ShowS
$cshow :: SchemaElement -> [Char]
show :: SchemaElement -> [Char]
$cshowList :: [SchemaElement] -> ShowS
showList :: [SchemaElement] -> ShowS
Show, SchemaElement -> SchemaElement -> Bool
(SchemaElement -> SchemaElement -> Bool)
-> (SchemaElement -> SchemaElement -> Bool) -> Eq SchemaElement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SchemaElement -> SchemaElement -> Bool
== :: SchemaElement -> SchemaElement -> Bool
$c/= :: SchemaElement -> SchemaElement -> Bool
/= :: SchemaElement -> SchemaElement -> Bool
Eq)

data KeyValue = KeyValue
    { KeyValue -> [Char]
key :: String
    , KeyValue -> [Char]
value :: String
    }
    deriving (Int -> KeyValue -> ShowS
[KeyValue] -> ShowS
KeyValue -> [Char]
(Int -> KeyValue -> ShowS)
-> (KeyValue -> [Char]) -> ([KeyValue] -> ShowS) -> Show KeyValue
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyValue -> ShowS
showsPrec :: Int -> KeyValue -> ShowS
$cshow :: KeyValue -> [Char]
show :: KeyValue -> [Char]
$cshowList :: [KeyValue] -> ShowS
showList :: [KeyValue] -> ShowS
Show, KeyValue -> KeyValue -> Bool
(KeyValue -> KeyValue -> Bool)
-> (KeyValue -> KeyValue -> Bool) -> Eq KeyValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyValue -> KeyValue -> Bool
== :: KeyValue -> KeyValue -> Bool
$c/= :: KeyValue -> KeyValue -> Bool
/= :: KeyValue -> KeyValue -> Bool
Eq)

data FileMetadata = FileMetaData
    { FileMetadata -> Int32
version :: Int32
    , FileMetadata -> [SchemaElement]
schema :: [SchemaElement]
    , FileMetadata -> Integer
numRows :: Integer
    , FileMetadata -> [RowGroup]
rowGroups :: [RowGroup]
    , FileMetadata -> [KeyValue]
keyValueMetadata :: [KeyValue]
    , FileMetadata -> Maybe [Char]
createdBy :: Maybe String
    , FileMetadata -> [ColumnOrder]
columnOrders :: [ColumnOrder]
    , FileMetadata -> EncryptionAlgorithm
encryptionAlgorithm :: EncryptionAlgorithm
    , FileMetadata -> [Word8]
footerSigningKeyMetadata :: [Word8]
    }
    deriving (Int -> FileMetadata -> ShowS
[FileMetadata] -> ShowS
FileMetadata -> [Char]
(Int -> FileMetadata -> ShowS)
-> (FileMetadata -> [Char])
-> ([FileMetadata] -> ShowS)
-> Show FileMetadata
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FileMetadata -> ShowS
showsPrec :: Int -> FileMetadata -> ShowS
$cshow :: FileMetadata -> [Char]
show :: FileMetadata -> [Char]
$cshowList :: [FileMetadata] -> ShowS
showList :: [FileMetadata] -> ShowS
Show, FileMetadata -> FileMetadata -> Bool
(FileMetadata -> FileMetadata -> Bool)
-> (FileMetadata -> FileMetadata -> Bool) -> Eq FileMetadata
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FileMetadata -> FileMetadata -> Bool
== :: FileMetadata -> FileMetadata -> Bool
$c/= :: FileMetadata -> FileMetadata -> Bool
/= :: FileMetadata -> FileMetadata -> Bool
Eq)

data TType
    = STOP
    | BOOL
    | BYTE
    | I16
    | I32
    | I64
    | DOUBLE
    | STRING
    | LIST
    | SET
    | MAP
    | STRUCT
    | UUID
    deriving (Int -> TType -> ShowS
[TType] -> ShowS
TType -> [Char]
(Int -> TType -> ShowS)
-> (TType -> [Char]) -> ([TType] -> ShowS) -> Show TType
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TType -> ShowS
showsPrec :: Int -> TType -> ShowS
$cshow :: TType -> [Char]
show :: TType -> [Char]
$cshowList :: [TType] -> ShowS
showList :: [TType] -> ShowS
Show, TType -> TType -> Bool
(TType -> TType -> Bool) -> (TType -> TType -> Bool) -> Eq TType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TType -> TType -> Bool
== :: TType -> TType -> Bool
$c/= :: TType -> TType -> Bool
/= :: TType -> TType -> Bool
Eq)

defaultMetadata :: FileMetadata
defaultMetadata :: FileMetadata
defaultMetadata =
    FileMetaData
        { version :: Int32
version = Int32
0
        , schema :: [SchemaElement]
schema = []
        , numRows :: Integer
numRows = Integer
0
        , rowGroups :: [RowGroup]
rowGroups = []
        , keyValueMetadata :: [KeyValue]
keyValueMetadata = []
        , createdBy :: Maybe [Char]
createdBy = Maybe [Char]
forall a. Maybe a
Nothing
        , columnOrders :: [ColumnOrder]
columnOrders = []
        , encryptionAlgorithm :: EncryptionAlgorithm
encryptionAlgorithm = EncryptionAlgorithm
ENCRYPTION_ALGORITHM_UNKNOWN
        , footerSigningKeyMetadata :: [Word8]
footerSigningKeyMetadata = []
        }

data ColumnMetaData = ColumnMetaData
    { ColumnMetaData -> ParquetType
columnType :: ParquetType
    , ColumnMetaData -> [ParquetEncoding]
columnEncodings :: [ParquetEncoding]
    , ColumnMetaData -> [[Char]]
columnPathInSchema :: [String]
    , ColumnMetaData -> CompressionCodec
columnCodec :: CompressionCodec
    , ColumnMetaData -> Int64
columnNumValues :: Int64
    , ColumnMetaData -> Int64
columnTotalUncompressedSize :: Int64
    , ColumnMetaData -> Int64
columnTotalCompressedSize :: Int64
    , ColumnMetaData -> [KeyValue]
columnKeyValueMetadata :: [KeyValue]
    , ColumnMetaData -> Int64
columnDataPageOffset :: Int64
    , ColumnMetaData -> Int64
columnIndexPageOffset :: Int64
    , ColumnMetaData -> Int64
columnDictionaryPageOffset :: Int64
    , ColumnMetaData -> ColumnStatistics
columnStatistics :: ColumnStatistics
    , ColumnMetaData -> [PageEncodingStats]
columnEncodingStats :: [PageEncodingStats]
    , ColumnMetaData -> Int64
bloomFilterOffset :: Int64
    , ColumnMetaData -> Int32
bloomFilterLength :: Int32
    , ColumnMetaData -> SizeStatistics
columnSizeStatistics :: SizeStatistics
    , ColumnMetaData -> GeospatialStatistics
columnGeospatialStatistics :: GeospatialStatistics
    }
    deriving (Int -> ColumnMetaData -> ShowS
[ColumnMetaData] -> ShowS
ColumnMetaData -> [Char]
(Int -> ColumnMetaData -> ShowS)
-> (ColumnMetaData -> [Char])
-> ([ColumnMetaData] -> ShowS)
-> Show ColumnMetaData
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ColumnMetaData -> ShowS
showsPrec :: Int -> ColumnMetaData -> ShowS
$cshow :: ColumnMetaData -> [Char]
show :: ColumnMetaData -> [Char]
$cshowList :: [ColumnMetaData] -> ShowS
showList :: [ColumnMetaData] -> ShowS
Show, ColumnMetaData -> ColumnMetaData -> Bool
(ColumnMetaData -> ColumnMetaData -> Bool)
-> (ColumnMetaData -> ColumnMetaData -> Bool) -> Eq ColumnMetaData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ColumnMetaData -> ColumnMetaData -> Bool
== :: ColumnMetaData -> ColumnMetaData -> Bool
$c/= :: ColumnMetaData -> ColumnMetaData -> Bool
/= :: ColumnMetaData -> ColumnMetaData -> Bool
Eq)

data ColumnChunk = ColumnChunk
    { ColumnChunk -> [Char]
columnChunkFilePath :: String
    , ColumnChunk -> Int64
columnChunkMetadataFileOffset :: Int64
    , ColumnChunk -> ColumnMetaData
columnMetaData :: ColumnMetaData
    , ColumnChunk -> Int64
columnChunkOffsetIndexOffset :: Int64
    , ColumnChunk -> Int32
columnChunkOffsetIndexLength :: Int32
    , ColumnChunk -> Int64
columnChunkColumnIndexOffset :: Int64
    , ColumnChunk -> Int32
columnChunkColumnIndexLength :: Int32
    , ColumnChunk -> ColumnCryptoMetadata
cryptoMetadata :: ColumnCryptoMetadata
    , ColumnChunk -> [Word8]
encryptedColumnMetadata :: [Word8]
    }
    deriving (Int -> ColumnChunk -> ShowS
[ColumnChunk] -> ShowS
ColumnChunk -> [Char]
(Int -> ColumnChunk -> ShowS)
-> (ColumnChunk -> [Char])
-> ([ColumnChunk] -> ShowS)
-> Show ColumnChunk
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ColumnChunk -> ShowS
showsPrec :: Int -> ColumnChunk -> ShowS
$cshow :: ColumnChunk -> [Char]
show :: ColumnChunk -> [Char]
$cshowList :: [ColumnChunk] -> ShowS
showList :: [ColumnChunk] -> ShowS
Show, ColumnChunk -> ColumnChunk -> Bool
(ColumnChunk -> ColumnChunk -> Bool)
-> (ColumnChunk -> ColumnChunk -> Bool) -> Eq ColumnChunk
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ColumnChunk -> ColumnChunk -> Bool
== :: ColumnChunk -> ColumnChunk -> Bool
$c/= :: ColumnChunk -> ColumnChunk -> Bool
/= :: ColumnChunk -> ColumnChunk -> Bool
Eq)

data RowGroup = RowGroup
    { RowGroup -> [ColumnChunk]
rowGroupColumns :: [ColumnChunk]
    , RowGroup -> Int64
totalByteSize :: Int64
    , RowGroup -> Int64
rowGroupNumRows :: Int64
    , RowGroup -> [SortingColumn]
rowGroupSortingColumns :: [SortingColumn]
    , RowGroup -> Int64
fileOffset :: Int64
    , RowGroup -> Int64
totalCompressedSize :: Int64
    , RowGroup -> Int16
ordinal :: Int16
    }
    deriving (Int -> RowGroup -> ShowS
[RowGroup] -> ShowS
RowGroup -> [Char]
(Int -> RowGroup -> ShowS)
-> (RowGroup -> [Char]) -> ([RowGroup] -> ShowS) -> Show RowGroup
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RowGroup -> ShowS
showsPrec :: Int -> RowGroup -> ShowS
$cshow :: RowGroup -> [Char]
show :: RowGroup -> [Char]
$cshowList :: [RowGroup] -> ShowS
showList :: [RowGroup] -> ShowS
Show, RowGroup -> RowGroup -> Bool
(RowGroup -> RowGroup -> Bool)
-> (RowGroup -> RowGroup -> Bool) -> Eq RowGroup
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RowGroup -> RowGroup -> Bool
== :: RowGroup -> RowGroup -> Bool
$c/= :: RowGroup -> RowGroup -> Bool
/= :: RowGroup -> RowGroup -> Bool
Eq)

defaultSchemaElement :: SchemaElement
defaultSchemaElement :: SchemaElement
defaultSchemaElement = Text
-> TType
-> Int32
-> Int32
-> Int32
-> RepetitionType
-> Int32
-> Int32
-> Int32
-> LogicalType
-> SchemaElement
SchemaElement Text
"" TType
STOP Int32
0 Int32
0 (-Int32
1) RepetitionType
UNKNOWN_REPETITION_TYPE Int32
0 Int32
0 Int32
0 LogicalType
LOGICAL_TYPE_UNKNOWN

emptyColumnMetadata :: ColumnMetaData
emptyColumnMetadata :: ColumnMetaData
emptyColumnMetadata = ParquetType
-> [ParquetEncoding]
-> [[Char]]
-> CompressionCodec
-> Int64
-> Int64
-> Int64
-> [KeyValue]
-> Int64
-> Int64
-> Int64
-> ColumnStatistics
-> [PageEncodingStats]
-> Int64
-> Int32
-> SizeStatistics
-> GeospatialStatistics
-> ColumnMetaData
ColumnMetaData ParquetType
PARQUET_TYPE_UNKNOWN [] [] CompressionCodec
COMPRESSION_CODEC_UNKNOWN Int64
0 Int64
0 Int64
0 [] Int64
0 Int64
0 Int64
0 ColumnStatistics
emptyColumnStatistics [] Int64
0 Int32
0 SizeStatistics
emptySizeStatistics GeospatialStatistics
emptyGeospatialStatistics

emptyColumnChunk :: ColumnChunk
emptyColumnChunk :: ColumnChunk
emptyColumnChunk = [Char]
-> Int64
-> ColumnMetaData
-> Int64
-> Int32
-> Int64
-> Int32
-> ColumnCryptoMetadata
-> [Word8]
-> ColumnChunk
ColumnChunk [Char]
"" Int64
0 ColumnMetaData
emptyColumnMetadata Int64
0 Int32
0 Int64
0 Int32
0 ColumnCryptoMetadata
COLUMN_CRYPTO_METADATA_UNKNOWN []

emptyKeyValue :: KeyValue
emptyKeyValue :: KeyValue
emptyKeyValue = KeyValue{key :: [Char]
key = [Char]
"", value :: [Char]
value = [Char]
""}

emptyRowGroup :: RowGroup
emptyRowGroup :: RowGroup
emptyRowGroup = [ColumnChunk]
-> Int64
-> Int64
-> [SortingColumn]
-> Int64
-> Int64
-> Int16
-> RowGroup
RowGroup [] Int64
0 Int64
0 [] Int64
0 Int64
0 Int16
0

compactBooleanTrue, compactI32, compactI64, compactDouble, compactBinary, compactList, compactStruct :: Word8
compactBooleanTrue :: Word8
compactBooleanTrue = Word8
0x01
compactI32 :: Word8
compactI32 = Word8
0x05
compactI64 :: Word8
compactI64 = Word8
0x06
compactDouble :: Word8
compactDouble = Word8
0x07
compactBinary :: Word8
compactBinary = Word8
0x08
compactList :: Word8
compactList = Word8
0x09
compactStruct :: Word8
compactStruct = Word8
0x0C

toTType :: Word8 -> TType
toTType :: Word8 -> TType
toTType Word8
t =
    TType -> Maybe TType -> TType
forall a. a -> Maybe a -> a
fromMaybe TType
STOP (Maybe TType -> TType) -> Maybe TType -> TType
forall a b. (a -> b) -> a -> b
$
        Word8 -> Map Word8 TType -> Maybe TType
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup (Word8
t Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f) (Map Word8 TType -> Maybe TType) -> Map Word8 TType -> Maybe TType
forall a b. (a -> b) -> a -> b
$
            [(Word8, TType)] -> Map Word8 TType
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList
                [ (Word8
compactBooleanTrue, TType
BOOL)
                , (Word8
compactI32, TType
I32)
                , (Word8
compactI64, TType
I64)
                , (Word8
compactDouble, TType
DOUBLE)
                , (Word8
compactBinary, TType
STRING)
                , (Word8
compactList, TType
LIST)
                , (Word8
compactStruct, TType
STRUCT)
                ]

readField :: Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField :: Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Word8
t <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
    if Word8
t Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0
        then Maybe (TType, Int16) -> IO (Maybe (TType, Int16))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (TType, Int16)
forall a. Maybe a
Nothing
        else do
            let modifier :: Int16
modifier = Word8 -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Word8
t Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0xf0) Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) :: Int16
            Int16
identifier <-
                if Int16
modifier Int16 -> Int16 -> Bool
forall a. Eq a => a -> a -> Bool
== Int16
0
                    then forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int16 Ptr Word8
buf IORef Int
pos
                    else Int16 -> IO Int16
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int16
lastFieldId Int16 -> Int16 -> Int16
forall a. Num a => a -> a -> a
+ Int16
modifier)
            let elemType :: TType
elemType = Word8 -> TType
toTType (Word8
t Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f)
            Maybe (TType, Int16) -> IO (Maybe (TType, Int16))
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (TType, Int16) -> IO (Maybe (TType, Int16)))
-> Maybe (TType, Int16) -> IO (Maybe (TType, Int16))
forall a b. (a -> b) -> a -> b
$ (TType, Int16) -> Maybe (TType, Int16)
forall a. a -> Maybe a
Just (TType
elemType, Int16
identifier)

skipToStructEnd :: Ptr Word8 -> IORef Int -> IO ()
skipToStructEnd :: Ptr Word8 -> IORef Int -> IO ()
skipToStructEnd Ptr Word8
buf IORef Int
pos = do
    Word8
t <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
    if Word8
t Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0
        then () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
        else do
            let modifier :: Int16
modifier = Word8 -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Word8
t Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0xf0) Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) :: Int16
            Int16
identifier <-
                if Int16
modifier Int16 -> Int16 -> Bool
forall a. Eq a => a -> a -> Bool
== Int16
0
                    then forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int16 Ptr Word8
buf IORef Int
pos
                    else Int16 -> IO Int16
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int16
0
            let elemType :: TType
elemType = Word8 -> TType
toTType (Word8
t Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f)
            TType -> Ptr Word8 -> IORef Int -> IO ()
skipFieldData TType
elemType Ptr Word8
buf IORef Int
pos
            Ptr Word8 -> IORef Int -> IO ()
skipToStructEnd Ptr Word8
buf IORef Int
pos

skipFieldData :: TType -> Ptr Word8 -> IORef Int -> IO ()
skipFieldData :: TType -> Ptr Word8 -> IORef Int -> IO ()
skipFieldData TType
fieldType Ptr Word8
buf IORef Int
pos = case TType
fieldType of
    TType
BOOL -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    TType
I32 -> forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int32 Ptr Word8
buf IORef Int
pos IO Int32 -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> IO ()
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
    TType
I64 -> forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos IO Int64 -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> IO ()
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
    TType
DOUBLE -> forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos IO Int64 -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> IO ()
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
    TType
STRING -> Ptr Word8 -> IORef Int -> IO [Word8]
readByteString Ptr Word8
buf IORef Int
pos IO [Word8] -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> IO ()
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
    TType
LIST -> Ptr Word8 -> IORef Int -> IO ()
skipList Ptr Word8
buf IORef Int
pos
    TType
STRUCT -> Ptr Word8 -> IORef Int -> IO ()
skipToStructEnd Ptr Word8
buf IORef Int
pos
    TType
_ -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

skipList :: Ptr Word8 -> IORef Int -> IO ()
skipList :: Ptr Word8 -> IORef Int -> IO ()
skipList Ptr Word8
buf IORef Int
pos = do
    Word8
sizeAndType <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
    let sizeOnly :: Int
sizeOnly = Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Word8
sizeAndType Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f) :: Int
    let elemType :: TType
elemType = Word8 -> TType
toTType Word8
sizeAndType
    Int -> IO () -> IO ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
replicateM_ Int
sizeOnly (TType -> Ptr Word8 -> IORef Int -> IO ()
skipFieldData TType
elemType Ptr Word8
buf IORef Int
pos)

readMetadata :: Handle -> Integer -> IO FileMetadata
readMetadata :: Handle -> Integer -> IO FileMetadata
readMetadata Handle
handle Integer
size = do
    Ptr Word8
metaDataBuf <- Int -> IO (Ptr Word8)
forall a. Int -> IO (Ptr a)
mallocBytes (Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
size) :: IO (Ptr Word8)
    Integer
footerOffSet <- Handle -> IO Integer
numBytesInFile Handle
handle

    Handle -> SeekMode -> Integer -> IO ()
hSeek Handle
handle SeekMode
AbsoluteSeek (Integer -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Integer) -> Integer -> Integer
forall a b. (a -> b) -> a -> b
$! Integer
footerOffSet Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
footerSize Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
size)

    Int
metadataBytesRead <- Handle -> Ptr Word8 -> Int -> IO Int
forall a. Handle -> Ptr a -> Int -> IO Int
hGetBuf Handle
handle Ptr Word8
metaDataBuf (Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
size)
    let lastFieldId :: Int16
lastFieldId = Int16
0
    let fieldStack :: [a]
fieldStack = []
    IORef Int
bufferPos <- Int -> IO (IORef Int)
forall a. a -> IO (IORef a)
newIORef (Int
0 :: Int)
    FileMetadata
metadata <- FileMetadata
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO FileMetadata
readFileMetaData FileMetadata
defaultMetadata Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
lastFieldId [Int16]
forall a. [a]
fieldStack
    Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
free Ptr Word8
metaDataBuf
    FileMetadata -> IO FileMetadata
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FileMetadata
metadata

readFileMetaData :: FileMetadata -> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO FileMetadata
readFileMetaData :: FileMetadata
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO FileMetadata
readFileMetaData FileMetadata
metadata Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> FileMetadata -> IO FileMetadata
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FileMetadata
metadata
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                Int32
version <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int32 Ptr Word8
metaDataBuf IORef Int
bufferPos
                FileMetadata
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO FileMetadata
readFileMetaData (FileMetadata
metadata{version = version}) Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
identifier [Int16]
fieldStack
            Int16
2 -> do
                Word8
sizeAndType <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
bufferPos Ptr Word8
metaDataBuf
                Int
listSize <-
                    if (Word8
sizeAndType Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
15
                        then forall a b. Integral a => Ptr b -> IORef Int -> IO a
readVarIntFromBuffer @Int Ptr Word8
metaDataBuf IORef Int
bufferPos
                        else Int -> IO Int
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> IO Int) -> Int -> IO Int
forall a b. (a -> b) -> a -> b
$ Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Word8
sizeAndType Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f)

                let elemType :: TType
elemType = Word8 -> TType
toTType Word8
sizeAndType
                [SchemaElement]
schemaElements <- Int -> IO SchemaElement -> IO [SchemaElement]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
listSize (SchemaElement
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SchemaElement
readSchemaElement SchemaElement
defaultSchemaElement Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
0 [])
                FileMetadata
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO FileMetadata
readFileMetaData (FileMetadata
metadata{schema = schemaElements}) Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
identifier [Int16]
fieldStack
            Int16
3 -> do
                Int64
numRows <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
metaDataBuf IORef Int
bufferPos
                FileMetadata
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO FileMetadata
readFileMetaData (FileMetadata
metadata{numRows = fromIntegral numRows}) Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
identifier [Int16]
fieldStack
            Int16
4 -> do
                Word8
sizeAndType <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
bufferPos Ptr Word8
metaDataBuf
                Int
listSize <-
                    if (Word8
sizeAndType Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
15
                        then forall a b. Integral a => Ptr b -> IORef Int -> IO a
readVarIntFromBuffer @Int Ptr Word8
metaDataBuf IORef Int
bufferPos
                        else Int -> IO Int
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> IO Int) -> Int -> IO Int
forall a b. (a -> b) -> a -> b
$ Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Word8
sizeAndType Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f)

                let elemType :: TType
elemType = Word8 -> TType
toTType Word8
sizeAndType
                [RowGroup]
rowGroups <- Int -> IO RowGroup -> IO [RowGroup]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
listSize (RowGroup
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO RowGroup
readRowGroup RowGroup
emptyRowGroup Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
0 [])
                FileMetadata
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO FileMetadata
readFileMetaData (FileMetadata
metadata{rowGroups = rowGroups}) Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
identifier [Int16]
fieldStack
            Int16
5 -> do
                Word8
sizeAndType <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
bufferPos Ptr Word8
metaDataBuf
                Int
listSize <-
                    if (Word8
sizeAndType Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
15
                        then forall a b. Integral a => Ptr b -> IORef Int -> IO a
readVarIntFromBuffer @Int Ptr Word8
metaDataBuf IORef Int
bufferPos
                        else Int -> IO Int
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> IO Int) -> Int -> IO Int
forall a b. (a -> b) -> a -> b
$ Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Word8
sizeAndType Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f)

                let elemType :: TType
elemType = Word8 -> TType
toTType Word8
sizeAndType
                [KeyValue]
keyValueMetadata <- Int -> IO KeyValue -> IO [KeyValue]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
listSize (KeyValue
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO KeyValue
readKeyValue KeyValue
emptyKeyValue Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
0 [])
                FileMetadata
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO FileMetadata
readFileMetaData (FileMetadata
metadata{keyValueMetadata = keyValueMetadata}) Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
identifier [Int16]
fieldStack
            Int16
6 -> do
                [Char]
createdBy <- Ptr Word8 -> IORef Int -> IO [Char]
readString Ptr Word8
metaDataBuf IORef Int
bufferPos
                FileMetadata
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO FileMetadata
readFileMetaData (FileMetadata
metadata{createdBy = Just createdBy}) Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
identifier [Int16]
fieldStack
            Int16
7 -> do
                Word8
sizeAndType <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
bufferPos Ptr Word8
metaDataBuf
                Int
listSize <-
                    if (Word8
sizeAndType Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
15
                        then forall a b. Integral a => Ptr b -> IORef Int -> IO a
readVarIntFromBuffer @Int Ptr Word8
metaDataBuf IORef Int
bufferPos
                        else Int -> IO Int
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> IO Int) -> Int -> IO Int
forall a b. (a -> b) -> a -> b
$ Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Word8
sizeAndType Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f)

                let elemType :: TType
elemType = Word8 -> TType
toTType Word8
sizeAndType
                [ColumnOrder]
columnOrders <- Int -> IO ColumnOrder -> IO [ColumnOrder]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
listSize (Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnOrder
readColumnOrder Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
0 [])
                FileMetadata
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO FileMetadata
readFileMetaData (FileMetadata
metadata{columnOrders = columnOrders}) Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
identifier [Int16]
fieldStack
            Int16
8 -> do
                EncryptionAlgorithm
encryptionAlgorithm <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO EncryptionAlgorithm
readEncryptionAlgorithm Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
0 []
                FileMetadata
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO FileMetadata
readFileMetaData (FileMetadata
metadata{encryptionAlgorithm = encryptionAlgorithm}) Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
identifier [Int16]
fieldStack
            Int16
9 -> do
                [Word8]
footerSigningKeyMetadata <- Ptr Word8 -> IORef Int -> IO [Word8]
readByteString Ptr Word8
metaDataBuf IORef Int
bufferPos
                FileMetadata
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO FileMetadata
readFileMetaData (FileMetadata
metadata{footerSigningKeyMetadata = footerSigningKeyMetadata}) Ptr Word8
metaDataBuf IORef Int
bufferPos Int16
identifier [Int16]
fieldStack
            Int16
n -> FileMetadata -> IO FileMetadata
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (FileMetadata -> IO FileMetadata)
-> FileMetadata -> IO FileMetadata
forall a b. (a -> b) -> a -> b
$ [Char] -> FileMetadata
forall a. HasCallStack => [Char] -> a
error ([Char] -> FileMetadata) -> [Char] -> FileMetadata
forall a b. (a -> b) -> a -> b
$ [Char]
"UNIMPLEMENTED " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int16 -> [Char]
forall a. Show a => a -> [Char]
show Int16
n

readSchemaElement :: SchemaElement -> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SchemaElement
readSchemaElement :: SchemaElement
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SchemaElement
readSchemaElement SchemaElement
schemaElement Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> SchemaElement -> IO SchemaElement
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SchemaElement
schemaElement
        Just (TType
STOP, Int16
_) -> SchemaElement -> IO SchemaElement
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SchemaElement
schemaElement
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                TType
schemaElemType <- Int32 -> TType
toIntegralType (Int32 -> TType) -> IO Int32 -> IO TType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                SchemaElement
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SchemaElement
readSchemaElement (SchemaElement
schemaElement{elementType = schemaElemType}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
2 -> do
                Int32
typeLength <- Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                SchemaElement
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SchemaElement
readSchemaElement (SchemaElement
schemaElement{typeLength = typeLength}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
3 -> do
                Int32
fieldRepetitionType <- Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                SchemaElement
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SchemaElement
readSchemaElement (SchemaElement
schemaElement{repetitionType = repetitionTypeFromInt fieldRepetitionType}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
4 -> do
                Int
nameSize <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readVarIntFromBuffer @Int Ptr Word8
buf IORef Int
pos
                if Int
nameSize Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0
                    then SchemaElement
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SchemaElement
readSchemaElement SchemaElement
schemaElement Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
                    else do
                        [Word8]
contents <- Int -> IO Word8 -> IO [Word8]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
nameSize (IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf)
                        SchemaElement
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SchemaElement
readSchemaElement (SchemaElement
schemaElement{elementName = T.pack (map (chr . fromIntegral) contents)}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
5 -> do
                Int32
numChildren <- Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                SchemaElement
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SchemaElement
readSchemaElement (SchemaElement
schemaElement{numChildren = numChildren}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
6 -> do
                Int32
convertedType <- Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                SchemaElement
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SchemaElement
readSchemaElement (SchemaElement
schemaElement{convertedType = convertedType}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
7 -> do
                Int32
scale <- Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                SchemaElement
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SchemaElement
readSchemaElement (SchemaElement
schemaElement{scale = scale}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
8 -> do
                Int32
precision <- Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                SchemaElement
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SchemaElement
readSchemaElement (SchemaElement
schemaElement{precision = precision}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
9 -> do
                Int32
fieldId <- Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                SchemaElement
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SchemaElement
readSchemaElement (SchemaElement
schemaElement{fieldId = fieldId}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
10 -> do
                LogicalType
logicalType <- Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readLogicalType Ptr Word8
buf IORef Int
pos Int16
0 []
                SchemaElement
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SchemaElement
readSchemaElement (SchemaElement
schemaElement{logicalType = logicalType}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
_ -> do
                TType -> Ptr Word8 -> IORef Int -> IO ()
skipFieldData TType
elemType Ptr Word8
buf IORef Int
pos
                SchemaElement
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SchemaElement
readSchemaElement SchemaElement
schemaElement Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack

readRowGroup :: RowGroup -> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO RowGroup
readRowGroup :: RowGroup
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO RowGroup
readRowGroup RowGroup
r Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> RowGroup -> IO RowGroup
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return RowGroup
r
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                Word8
sizeAndType <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
                let sizeOnly :: Int
sizeOnly = Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Word8
sizeAndType Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f) :: Int
                -- type of the contents of the list.
                let elemType :: TType
elemType = Word8 -> TType
toTType Word8
sizeAndType
                [ColumnChunk]
columnChunks <- Int -> IO ColumnChunk -> IO [ColumnChunk]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
sizeOnly (ColumnChunk
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnChunk
readColumnChunk ColumnChunk
emptyColumnChunk Ptr Word8
buf IORef Int
pos Int16
0 [])
                RowGroup
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO RowGroup
readRowGroup (RowGroup
r{rowGroupColumns = columnChunks}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
2 -> do
                Int64
totalBytes <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                RowGroup
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO RowGroup
readRowGroup (RowGroup
r{totalByteSize = totalBytes}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
3 -> do
                Int64
nRows <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                RowGroup
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO RowGroup
readRowGroup (RowGroup
r{rowGroupNumRows = nRows}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
4 -> RowGroup -> IO RowGroup
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return RowGroup
r
            Int16
5 -> do
                Int64
offset <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                RowGroup
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO RowGroup
readRowGroup (RowGroup
r{fileOffset = offset}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
6 -> do
                Int64
compressedSize <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                RowGroup
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO RowGroup
readRowGroup (RowGroup
r{totalCompressedSize = compressedSize}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
7 -> do
                Int16
ordinal <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int16 Ptr Word8
buf IORef Int
pos
                RowGroup
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO RowGroup
readRowGroup (RowGroup
r{ordinal = ordinal}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
_ -> [Char] -> IO RowGroup
forall a. HasCallStack => [Char] -> a
error ([Char] -> IO RowGroup) -> [Char] -> IO RowGroup
forall a b. (a -> b) -> a -> b
$ [Char]
"Unknown row group field: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int16 -> [Char]
forall a. Show a => a -> [Char]
show Int16
identifier

readColumnChunk :: ColumnChunk -> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnChunk
readColumnChunk :: ColumnChunk
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnChunk
readColumnChunk ColumnChunk
c Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> ColumnChunk -> IO ColumnChunk
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ColumnChunk
c
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                Int
stringSize <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readVarIntFromBuffer @Int Ptr Word8
buf IORef Int
pos
                [Char]
contents <- (Word8 -> Char) -> [Word8] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> Char
chr (Int -> Char) -> (Word8 -> Int) -> Word8 -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) ([Word8] -> [Char]) -> IO [Word8] -> IO [Char]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> IO Word8 -> IO [Word8]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
stringSize (IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf)
                ColumnChunk
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnChunk
readColumnChunk (ColumnChunk
c{columnChunkFilePath = contents}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
2 -> do
                Int64
columnChunkMetadataFileOffset <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                ColumnChunk
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnChunk
readColumnChunk (ColumnChunk
c{columnChunkMetadataFileOffset = columnChunkMetadataFileOffset}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
3 -> do
                ColumnMetaData
columnMetadata <- ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata ColumnMetaData
emptyColumnMetadata Ptr Word8
buf IORef Int
pos Int16
0 []
                ColumnChunk
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnChunk
readColumnChunk (ColumnChunk
c{columnMetaData = columnMetadata}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
4 -> do
                Int64
columnOffsetIndexOffset <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                ColumnChunk
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnChunk
readColumnChunk (ColumnChunk
c{columnChunkOffsetIndexOffset = columnOffsetIndexOffset}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
5 -> do
                Int32
columnOffsetIndexLength <- Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                ColumnChunk
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnChunk
readColumnChunk (ColumnChunk
c{columnChunkOffsetIndexLength = columnOffsetIndexLength}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
6 -> do
                Int64
columnChunkColumnIndexOffset <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                ColumnChunk
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnChunk
readColumnChunk (ColumnChunk
c{columnChunkColumnIndexOffset = columnChunkColumnIndexOffset}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
7 -> do
                Int32
columnChunkColumnIndexLength <- Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                ColumnChunk
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnChunk
readColumnChunk (ColumnChunk
c{columnChunkColumnIndexLength = columnChunkColumnIndexLength}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
_ -> ColumnChunk -> IO ColumnChunk
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ColumnChunk
c

readColumnMetadata :: ColumnMetaData -> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata :: ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata ColumnMetaData
cm Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> ColumnMetaData -> IO ColumnMetaData
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ColumnMetaData
cm
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                ParquetType
cType <- Int32 -> ParquetType
parquetTypeFromInt (Int32 -> ParquetType) -> IO Int32 -> IO ParquetType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata (ColumnMetaData
cm{columnType = cType}) Ptr Word8
buf IORef Int
pos Int16
identifier []
            Int16
2 -> do
                Word8
sizeAndType <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
                let sizeOnly :: Int
sizeOnly = Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Word8
sizeAndType Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f) :: Int
                let elemType :: TType
elemType = Word8 -> TType
toTType Word8
sizeAndType
                [ParquetEncoding]
encodings <- Int -> IO ParquetEncoding -> IO [ParquetEncoding]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
sizeOnly (Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ParquetEncoding
readParquetEncoding Ptr Word8
buf IORef Int
pos Int16
0 [])
                ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata (ColumnMetaData
cm{columnEncodings = encodings}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
3 -> do
                Word8
sizeAndType <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
                let sizeOnly :: Int
sizeOnly = Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Word8
sizeAndType Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f) :: Int
                let elemType :: TType
elemType = Word8 -> TType
toTType Word8
sizeAndType
                [[Char]]
paths <- Int -> IO [Char] -> IO [[Char]]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
sizeOnly (Ptr Word8 -> IORef Int -> IO [Char]
readString Ptr Word8
buf IORef Int
pos)
                ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata (ColumnMetaData
cm{columnPathInSchema = paths}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
4 -> do
                CompressionCodec
cType <- Int32 -> CompressionCodec
compressionCodecFromInt (Int32 -> CompressionCodec) -> IO Int32 -> IO CompressionCodec
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata (ColumnMetaData
cm{columnCodec = cType}) Ptr Word8
buf IORef Int
pos Int16
identifier []
            Int16
5 -> do
                Int64
numValues <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata (ColumnMetaData
cm{columnNumValues = numValues}) Ptr Word8
buf IORef Int
pos Int16
identifier []
            Int16
6 -> do
                Int64
columnTotalUncompressedSize <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata (ColumnMetaData
cm{columnTotalUncompressedSize = columnTotalUncompressedSize}) Ptr Word8
buf IORef Int
pos Int16
identifier []
            Int16
7 -> do
                Int64
columnTotalCompressedSize <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata (ColumnMetaData
cm{columnTotalCompressedSize = columnTotalCompressedSize}) Ptr Word8
buf IORef Int
pos Int16
identifier []
            Int16
8 -> do
                Word8
sizeAndType <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
                let sizeOnly :: Int
sizeOnly = Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Word8
sizeAndType Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f) :: Int
                let elemType :: TType
elemType = Word8 -> TType
toTType Word8
sizeAndType
                [KeyValue]
columnKeyValueMetadata <- Int -> IO KeyValue -> IO [KeyValue]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
sizeOnly (KeyValue
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO KeyValue
readKeyValue KeyValue
emptyKeyValue Ptr Word8
buf IORef Int
pos Int16
0 [])
                ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata (ColumnMetaData
cm{columnKeyValueMetadata = columnKeyValueMetadata}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
9 -> do
                Int64
columnDataPageOffset <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata (ColumnMetaData
cm{columnDataPageOffset = columnDataPageOffset}) Ptr Word8
buf IORef Int
pos Int16
identifier []
            Int16
10 -> do
                Int64
columnIndexPageOffset <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata (ColumnMetaData
cm{columnIndexPageOffset = columnIndexPageOffset}) Ptr Word8
buf IORef Int
pos Int16
identifier []
            Int16
11 -> do
                Int64
columnDictionaryPageOffset <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata (ColumnMetaData
cm{columnDictionaryPageOffset = columnDictionaryPageOffset}) Ptr Word8
buf IORef Int
pos Int16
identifier []
            Int16
12 -> do
                ColumnStatistics
stats <- ColumnStatistics
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO ColumnStatistics
readStatistics ColumnStatistics
emptyColumnStatistics Ptr Word8
buf IORef Int
pos Int16
0 []
                ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata (ColumnMetaData
cm{columnStatistics = stats}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
13 -> do
                Word8
sizeAndType <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
                let sizeOnly :: Int
sizeOnly = Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Word8
sizeAndType Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f) :: Int
                let elemType :: TType
elemType = Word8 -> TType
toTType Word8
sizeAndType
                [PageEncodingStats]
pageEncodingStats <- Int -> IO PageEncodingStats -> IO [PageEncodingStats]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
sizeOnly (PageEncodingStats
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO PageEncodingStats
readPageEncodingStats PageEncodingStats
emptyPageEncodingStats Ptr Word8
buf IORef Int
pos Int16
0 [])
                ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata (ColumnMetaData
cm{columnEncodingStats = pageEncodingStats}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
14 -> do
                Int64
bloomFilterOffset <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata (ColumnMetaData
cm{bloomFilterOffset = bloomFilterOffset}) Ptr Word8
buf IORef Int
pos Int16
identifier []
            Int16
15 -> do
                Int32
bloomFilterLength <- Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata (ColumnMetaData
cm{bloomFilterLength = bloomFilterLength}) Ptr Word8
buf IORef Int
pos Int16
identifier []
            Int16
16 -> do
                SizeStatistics
stats <- SizeStatistics
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SizeStatistics
readSizeStatistics SizeStatistics
emptySizeStatistics Ptr Word8
buf IORef Int
pos Int16
0 []
                ColumnMetaData
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnMetaData
readColumnMetadata (ColumnMetaData
cm{columnSizeStatistics = stats}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
17 -> ColumnMetaData -> IO ColumnMetaData
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ColumnMetaData -> IO ColumnMetaData)
-> ColumnMetaData -> IO ColumnMetaData
forall a b. (a -> b) -> a -> b
$ [Char] -> ColumnMetaData
forall a. HasCallStack => [Char] -> a
error [Char]
"UNIMPLEMENTED"
            Int16
_ -> ColumnMetaData -> IO ColumnMetaData
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ColumnMetaData
cm

readEncryptionAlgorithm :: Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO EncryptionAlgorithm
readEncryptionAlgorithm :: Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO EncryptionAlgorithm
readEncryptionAlgorithm Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> EncryptionAlgorithm -> IO EncryptionAlgorithm
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return EncryptionAlgorithm
ENCRYPTION_ALGORITHM_UNKNOWN
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                EncryptionAlgorithm
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO EncryptionAlgorithm
readAesGcmV1 (AesGcmV1{aadPrefix :: [Word8]
aadPrefix = [], aadFileUnique :: [Word8]
aadFileUnique = [], supplyAadPrefix :: Bool
supplyAadPrefix = Bool
False}) Ptr Word8
buf IORef Int
pos Int16
0 []
            Int16
2 -> do
                EncryptionAlgorithm
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO EncryptionAlgorithm
readAesGcmCtrV1 (AesGcmCtrV1{aadPrefix :: [Word8]
aadPrefix = [], aadFileUnique :: [Word8]
aadFileUnique = [], supplyAadPrefix :: Bool
supplyAadPrefix = Bool
False}) Ptr Word8
buf IORef Int
pos Int16
0 []
            Int16
n -> EncryptionAlgorithm -> IO EncryptionAlgorithm
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return EncryptionAlgorithm
ENCRYPTION_ALGORITHM_UNKNOWN

readColumnOrder :: Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnOrder
readColumnOrder :: Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnOrder
readColumnOrder Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> ColumnOrder -> IO ColumnOrder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ColumnOrder
COLUMN_ORDER_UNKNOWN
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                ()
_ <- Int -> IO ColumnOrder -> IO ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
replicateM_ Int
2 (Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnOrder
readTypeOrder Ptr Word8
buf IORef Int
pos Int16
0 [])
                ColumnOrder -> IO ColumnOrder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ColumnOrder
TYPE_ORDER
            Int16
_ -> ColumnOrder -> IO ColumnOrder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ColumnOrder
COLUMN_ORDER_UNKNOWN

readAesGcmCtrV1 :: EncryptionAlgorithm -> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO EncryptionAlgorithm
readAesGcmCtrV1 :: EncryptionAlgorithm
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO EncryptionAlgorithm
readAesGcmCtrV1 v :: EncryptionAlgorithm
v@(AesGcmCtrV1 [Word8]
aadPrefix [Word8]
aadFileUnique Bool
supplyAadPrefix) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> EncryptionAlgorithm -> IO EncryptionAlgorithm
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return EncryptionAlgorithm
v
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                [Word8]
aadPrefix <- Ptr Word8 -> IORef Int -> IO [Word8]
readByteString Ptr Word8
buf IORef Int
pos
                EncryptionAlgorithm
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO EncryptionAlgorithm
readAesGcmCtrV1 (EncryptionAlgorithm
v{aadPrefix = aadPrefix}) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
            Int16
2 -> do
                [Word8]
aadFileUnique <- Ptr Word8 -> IORef Int -> IO [Word8]
readByteString Ptr Word8
buf IORef Int
pos
                EncryptionAlgorithm
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO EncryptionAlgorithm
readAesGcmCtrV1 (EncryptionAlgorithm
v{aadFileUnique = aadFileUnique}) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
            Int16
3 -> do
                Word8
supplyAadPrefix <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
                EncryptionAlgorithm
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO EncryptionAlgorithm
readAesGcmCtrV1 (EncryptionAlgorithm
v{supplyAadPrefix = supplyAadPrefix == compactBooleanTrue}) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
            Int16
_ -> EncryptionAlgorithm -> IO EncryptionAlgorithm
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return EncryptionAlgorithm
ENCRYPTION_ALGORITHM_UNKNOWN

readAesGcmV1 :: EncryptionAlgorithm -> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO EncryptionAlgorithm
readAesGcmV1 :: EncryptionAlgorithm
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO EncryptionAlgorithm
readAesGcmV1 v :: EncryptionAlgorithm
v@(AesGcmV1 [Word8]
aadPrefix [Word8]
aadFileUnique Bool
supplyAadPrefix) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> EncryptionAlgorithm -> IO EncryptionAlgorithm
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return EncryptionAlgorithm
v
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                [Word8]
aadPrefix <- Ptr Word8 -> IORef Int -> IO [Word8]
readByteString Ptr Word8
buf IORef Int
pos
                EncryptionAlgorithm
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO EncryptionAlgorithm
readAesGcmV1 (EncryptionAlgorithm
v{aadPrefix = aadPrefix}) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
            Int16
2 -> do
                [Word8]
aadFileUnique <- Ptr Word8 -> IORef Int -> IO [Word8]
readByteString Ptr Word8
buf IORef Int
pos
                EncryptionAlgorithm
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO EncryptionAlgorithm
readAesGcmV1 (EncryptionAlgorithm
v{aadFileUnique = aadFileUnique}) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
            Int16
3 -> do
                Word8
supplyAadPrefix <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
                EncryptionAlgorithm
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO EncryptionAlgorithm
readAesGcmV1 (EncryptionAlgorithm
v{supplyAadPrefix = supplyAadPrefix == compactBooleanTrue}) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
            Int16
_ -> EncryptionAlgorithm -> IO EncryptionAlgorithm
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return EncryptionAlgorithm
ENCRYPTION_ALGORITHM_UNKNOWN

readTypeOrder :: Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnOrder
readTypeOrder :: Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnOrder
readTypeOrder Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> ColumnOrder -> IO ColumnOrder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ColumnOrder
TYPE_ORDER
        Just (TType
elemType, Int16
identifier) ->
            if TType
elemType TType -> TType -> Bool
forall a. Eq a => a -> a -> Bool
== TType
STOP
                then ColumnOrder -> IO ColumnOrder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ColumnOrder
TYPE_ORDER
                else Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnOrder
readTypeOrder Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack

readKeyValue :: KeyValue -> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO KeyValue
readKeyValue :: KeyValue
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO KeyValue
readKeyValue KeyValue
kv Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> KeyValue -> IO KeyValue
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return KeyValue
kv
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                [Char]
k <- Ptr Word8 -> IORef Int -> IO [Char]
readString Ptr Word8
buf IORef Int
pos
                KeyValue
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO KeyValue
readKeyValue (KeyValue
kv{key = k}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
2 -> do
                [Char]
v <- Ptr Word8 -> IORef Int -> IO [Char]
readString Ptr Word8
buf IORef Int
pos
                KeyValue
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO KeyValue
readKeyValue (KeyValue
kv{value = v}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
_ -> KeyValue -> IO KeyValue
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return KeyValue
kv

readPageEncodingStats :: PageEncodingStats -> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO PageEncodingStats
readPageEncodingStats :: PageEncodingStats
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO PageEncodingStats
readPageEncodingStats PageEncodingStats
pes Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> PageEncodingStats -> IO PageEncodingStats
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PageEncodingStats
pes
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                PageType
pType <- Int32 -> PageType
pageTypeFromInt (Int32 -> PageType) -> IO Int32 -> IO PageType
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                PageEncodingStats
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO PageEncodingStats
readPageEncodingStats (PageEncodingStats
pes{pageEncodingPageType = pType}) Ptr Word8
buf IORef Int
pos Int16
identifier []
            Int16
2 -> do
                ParquetEncoding
pEnc <- Int32 -> ParquetEncoding
parquetEncodingFromInt (Int32 -> ParquetEncoding) -> IO Int32 -> IO ParquetEncoding
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                PageEncodingStats
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO PageEncodingStats
readPageEncodingStats (PageEncodingStats
pes{pageEncoding = pEnc}) Ptr Word8
buf IORef Int
pos Int16
identifier []
            Int16
3 -> do
                Int32
encodedCount <- Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                PageEncodingStats
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO PageEncodingStats
readPageEncodingStats (PageEncodingStats
pes{pagesWithEncoding = encodedCount}) Ptr Word8
buf IORef Int
pos Int16
identifier []
            Int16
_ -> PageEncodingStats -> IO PageEncodingStats
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PageEncodingStats
pes

readParquetEncoding :: Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ParquetEncoding
readParquetEncoding :: Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ParquetEncoding
readParquetEncoding Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = Int32 -> ParquetEncoding
parquetEncodingFromInt (Int32 -> ParquetEncoding) -> IO Int32 -> IO ParquetEncoding
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos

readStatistics :: ColumnStatistics -> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO ColumnStatistics
readStatistics :: ColumnStatistics
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO ColumnStatistics
readStatistics ColumnStatistics
cs Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> ColumnStatistics -> IO ColumnStatistics
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ColumnStatistics
cs
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                [Word8]
maxInBytes <- Ptr Word8 -> IORef Int -> IO [Word8]
readByteString Ptr Word8
buf IORef Int
pos
                ColumnStatistics
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO ColumnStatistics
readStatistics (ColumnStatistics
cs{columnMax = maxInBytes}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
2 -> do
                [Word8]
minInBytes <- Ptr Word8 -> IORef Int -> IO [Word8]
readByteString Ptr Word8
buf IORef Int
pos
                ColumnStatistics
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO ColumnStatistics
readStatistics (ColumnStatistics
cs{columnMin = minInBytes}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
3 -> do
                Int64
nullCount <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                ColumnStatistics
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO ColumnStatistics
readStatistics (ColumnStatistics
cs{columnNullCount = nullCount}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
4 -> do
                Int64
distinctCount <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                ColumnStatistics
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO ColumnStatistics
readStatistics (ColumnStatistics
cs{columnDistictCount = distinctCount}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
5 -> do
                [Word8]
maxInBytes <- Ptr Word8 -> IORef Int -> IO [Word8]
readByteString Ptr Word8
buf IORef Int
pos
                ColumnStatistics
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO ColumnStatistics
readStatistics (ColumnStatistics
cs{columnMaxValue = maxInBytes}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
6 -> do
                [Word8]
minInBytes <- Ptr Word8 -> IORef Int -> IO [Word8]
readByteString Ptr Word8
buf IORef Int
pos
                ColumnStatistics
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO ColumnStatistics
readStatistics (ColumnStatistics
cs{columnMinValue = minInBytes}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
7 -> do
                Word8
isMaxValueExact <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
                ColumnStatistics
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO ColumnStatistics
readStatistics (ColumnStatistics
cs{isColumnMaxValueExact = isMaxValueExact == compactBooleanTrue}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
8 -> do
                Word8
isMinValueExact <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
                ColumnStatistics
-> Ptr Word8
-> IORef Int
-> Int16
-> [Int16]
-> IO ColumnStatistics
readStatistics (ColumnStatistics
cs{isColumnMinValueExact = isMinValueExact == compactBooleanTrue}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
_ -> ColumnStatistics -> IO ColumnStatistics
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ColumnStatistics
cs

readSizeStatistics :: SizeStatistics -> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SizeStatistics
readSizeStatistics :: SizeStatistics
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SizeStatistics
readSizeStatistics SizeStatistics
ss Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> SizeStatistics -> IO SizeStatistics
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SizeStatistics
ss
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                Int64
unencodedByteArrayDataTypes <- forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos
                SizeStatistics
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SizeStatistics
readSizeStatistics (SizeStatistics
ss{unencodedByteArrayDataTypes = unencodedByteArrayDataTypes}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
2 -> do
                Word8
sizeAndType <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
                let sizeOnly :: Int
sizeOnly = Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Word8
sizeAndType Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f) :: Int
                let elemType :: TType
elemType = Word8 -> TType
toTType Word8
sizeAndType
                [Int64]
repetitionLevelHistogram <- Int -> IO Int64 -> IO [Int64]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
sizeOnly (forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos)
                SizeStatistics
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SizeStatistics
readSizeStatistics (SizeStatistics
ss{repetitionLevelHistogram = repetitionLevelHistogram}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
3 -> do
                Word8
sizeAndType <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
                let sizeOnly :: Int
sizeOnly = Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Word8
sizeAndType Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f) :: Int
                let elemType :: TType
elemType = Word8 -> TType
toTType Word8
sizeAndType
                [Int64]
definitionLevelHistogram <- Int -> IO Int64 -> IO [Int64]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
sizeOnly (forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int64 Ptr Word8
buf IORef Int
pos)
                SizeStatistics
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO SizeStatistics
readSizeStatistics (SizeStatistics
ss{definitionLevelHistogram = definitionLevelHistogram}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
            Int16
_ -> SizeStatistics -> IO SizeStatistics
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SizeStatistics
ss

footerSize :: Integer
footerSize :: Integer
footerSize = Integer
8

toIntegralType :: Int32 -> TType
toIntegralType :: Int32 -> TType
toIntegralType Int32
n
    | Int32
n Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
== Int32
1 = TType
I32
    | Int32
n Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
== Int32
2 = TType
I64
    | Int32
n Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
== Int32
4 = TType
DOUBLE
    | Int32
n Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
== Int32
6 = TType
STRING
    | Bool
otherwise = TType
STRING

readLogicalType :: Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readLogicalType :: Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readLogicalType Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Word8
t <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
    if Word8
t Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0
        then LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
LOGICAL_TYPE_UNKNOWN
        else do
            let modifier :: Int16
modifier = Word8 -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Word8
t Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0xf0) Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) :: Int16
            Int16
identifier <-
                if Int16
modifier Int16 -> Int16 -> Bool
forall a. Eq a => a -> a -> Bool
== Int16
0
                    then forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int16 Ptr Word8
buf IORef Int
pos
                    else Int16 -> IO Int16
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int16
lastFieldId Int16 -> Int16 -> Int16
forall a. Num a => a -> a -> a
+ Int16
modifier)
            let elemType :: TType
elemType = Word8 -> TType
toTType (Word8
t Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f)
            case Int16
identifier of
                Int16
1 -> do
                    Int -> IO (Maybe (TType, Int16)) -> IO ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
replicateM_ Int
2 (Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
0 [])
                    LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
STRING_TYPE
                Int16
2 -> do
                    Int -> IO (Maybe (TType, Int16)) -> IO ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
replicateM_ Int
2 (Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
0 [])
                    LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
MAP_TYPE
                Int16
3 -> do
                    Int -> IO (Maybe (TType, Int16)) -> IO ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
replicateM_ Int
2 (Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
0 [])
                    LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
LIST_TYPE
                Int16
4 -> do
                    Int -> IO (Maybe (TType, Int16)) -> IO ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
replicateM_ Int
2 (Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
0 [])
                    LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
ENUM_TYPE
                Int16
5 -> do
                    LogicalType
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readDecimalType (DecimalType{decimalTypeScale :: Int32
decimalTypeScale = Int32
0, decimalTypePrecision :: Int32
decimalTypePrecision = Int32
0}) Ptr Word8
buf IORef Int
pos Int16
0 []
                Int16
6 -> do
                    Int -> IO (Maybe (TType, Int16)) -> IO ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
replicateM_ Int
2 (Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
0 [])
                    LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
DATE_TYPE
                Int16
7 -> do
                    LogicalType
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readTimeType (TimeType{isAdjustedToUTC :: Bool
isAdjustedToUTC = Bool
False, unit :: TimeUnit
unit = TimeUnit
MILLISECONDS}) Ptr Word8
buf IORef Int
pos Int16
0 []
                Int16
8 -> do
                    LogicalType
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readTimeType (TimestampType{isAdjustedToUTC :: Bool
isAdjustedToUTC = Bool
False, unit :: TimeUnit
unit = TimeUnit
MILLISECONDS}) Ptr Word8
buf IORef Int
pos Int16
0 []
                -- Apparently reserved for interval types
                Int16
9 -> LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
LOGICAL_TYPE_UNKNOWN
                Int16
10 -> do
                    LogicalType
intType <- LogicalType
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readIntType (IntType{intIsSigned :: Bool
intIsSigned = Bool
False, bitWidth :: Int8
bitWidth = Int8
0}) Ptr Word8
buf IORef Int
pos Int16
0 []
                    Maybe (TType, Int16)
_ <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
0 []
                    LogicalType -> IO LogicalType
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure LogicalType
intType
                Int16
11 -> do
                    Int -> IO (Maybe (TType, Int16)) -> IO ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
replicateM_ Int
2 (Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
0 [])
                    LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
LOGICAL_TYPE_UNKNOWN
                Int16
12 -> do
                    Int -> IO (Maybe (TType, Int16)) -> IO ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
replicateM_ Int
2 (Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
0 [])
                    LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
JSON_TYPE
                Int16
13 -> do
                    Int -> IO (Maybe (TType, Int16)) -> IO ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
replicateM_ Int
2 (Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
0 [])
                    LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
BSON_TYPE
                Int16
14 -> do
                    Int -> IO (Maybe (TType, Int16)) -> IO ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
replicateM_ Int
2 (Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
0 [])
                    LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
UUID_TYPE
                Int16
15 -> do
                    Int -> IO (Maybe (TType, Int16)) -> IO ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
replicateM_ Int
2 (Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
0 [])
                    LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
FLOAT16_TYPE
                Int16
16 -> do
                    LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return VariantType{specificationVersion :: Int8
specificationVersion = Int8
1}
                Int16
17 -> do
                    LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GeometryType{crs :: Text
crs = Text
""}
                Int16
18 -> do
                    LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GeographyType{crs :: Text
crs = Text
"", algorithm :: EdgeInterpolationAlgorithm
algorithm = EdgeInterpolationAlgorithm
SPHERICAL}
                Int16
_ -> LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
LOGICAL_TYPE_UNKNOWN

readIntType :: LogicalType -> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readIntType :: LogicalType
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readIntType v :: LogicalType
v@(IntType Int8
bitWidth Bool
intIsSigned) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Word8
t <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
    if Word8
t Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0
        then LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
v
        else do
            let modifier :: Int16
modifier = Word8 -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Word8
t Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0xf0) Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4) :: Int16
            Int16
identifier <-
                if Int16
modifier Int16 -> Int16 -> Bool
forall a. Eq a => a -> a -> Bool
== Int16
0
                    then forall a b. Integral a => Ptr b -> IORef Int -> IO a
readIntFromBuffer @Int16 Ptr Word8
buf IORef Int
pos
                    else Int16 -> IO Int16
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int16
lastFieldId Int16 -> Int16 -> Int16
forall a. Num a => a -> a -> a
+ Int16
modifier)

            case Int16
identifier of
                Int16
1 -> do
                    Word8
bitWidthValue <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
                    LogicalType
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readIntType (LogicalType
v{bitWidth = fromIntegral bitWidthValue}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
                Int16
2 -> do
                    let isSigned :: Bool
isSigned = (Word8
t Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f) Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
compactBooleanTrue
                    LogicalType
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readIntType (LogicalType
v{intIsSigned = isSigned}) Ptr Word8
buf IORef Int
pos Int16
identifier [Int16]
fieldStack
                Int16
_ -> [Char] -> IO LogicalType
forall a. HasCallStack => [Char] -> a
error ([Char] -> IO LogicalType) -> [Char] -> IO LogicalType
forall a b. (a -> b) -> a -> b
$ [Char]
"UNKNOWN field ID for IntType: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int16 -> [Char]
forall a. Show a => a -> [Char]
show Int16
identifier

readDecimalType :: LogicalType -> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readDecimalType :: LogicalType
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readDecimalType v :: LogicalType
v@(DecimalType Int32
p Int32
s) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
v
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                Int32
s' <- Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                LogicalType
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readDecimalType (LogicalType
v{decimalTypeScale = s'}) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
            Int16
2 -> do
                Int32
p' <- Ptr Word8 -> IORef Int -> IO Int32
forall b. Ptr b -> IORef Int -> IO Int32
readInt32FromBuffer Ptr Word8
buf IORef Int
pos
                LogicalType
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readDecimalType (LogicalType
v{decimalTypePrecision = p'}) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
            Int16
_ -> [Char] -> IO LogicalType
forall a. HasCallStack => [Char] -> a
error ([Char] -> IO LogicalType) -> [Char] -> IO LogicalType
forall a b. (a -> b) -> a -> b
$ [Char]
"UNKNOWN field ID for DecimalType" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int16 -> [Char]
forall a. Show a => a -> [Char]
show Int16
identifier

readTimeType :: LogicalType -> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readTimeType :: LogicalType
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readTimeType v :: LogicalType
v@(TimeType Bool
_ TimeUnit
_) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
v
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                -- TODO: Check for empty
                Word8
isAdjustedToUTC <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
                LogicalType
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readTimeType (LogicalType
v{isAdjustedToUTC = isAdjustedToUTC == compactBooleanTrue}) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
            Int16
2 -> do
                TimeUnit
u <- Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO TimeUnit
readUnit Ptr Word8
buf IORef Int
pos Int16
0 []
                LogicalType
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readTimeType (LogicalType
v{unit = u}) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
            Int16
_ -> [Char] -> IO LogicalType
forall a. HasCallStack => [Char] -> a
error ([Char] -> IO LogicalType) -> [Char] -> IO LogicalType
forall a b. (a -> b) -> a -> b
$ [Char]
"UNKNOWN field ID for TimeType" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int16 -> [Char]
forall a. Show a => a -> [Char]
show Int16
identifier
readTimeType v :: LogicalType
v@(TimestampType Bool
_ TimeUnit
_) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> LogicalType -> IO LogicalType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LogicalType
v
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                -- TODO: Check for empty
                Word8
isAdjustedToUTC <- IORef Int -> Ptr Word8 -> IO Word8
forall b. IORef Int -> Ptr b -> IO Word8
readAndAdvance IORef Int
pos Ptr Word8
buf
                LogicalType
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readTimeType (LogicalType
v{isAdjustedToUTC = isAdjustedToUTC == compactBooleanTrue}) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
            Int16
2 -> do
                TimeUnit
u <- Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO TimeUnit
readUnit Ptr Word8
buf IORef Int
pos Int16
0 []
                LogicalType
-> Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO LogicalType
readTimeType (LogicalType
v{unit = u}) Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
            Int16
_ -> [Char] -> IO LogicalType
forall a. HasCallStack => [Char] -> a
error ([Char] -> IO LogicalType) -> [Char] -> IO LogicalType
forall a b. (a -> b) -> a -> b
$ [Char]
"UNKNOWN field ID for TimestampType" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int16 -> [Char]
forall a. Show a => a -> [Char]
show Int16
identifier

readUnit :: Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO TimeUnit
readUnit :: Ptr Word8 -> IORef Int -> Int16 -> [Int16] -> IO TimeUnit
readUnit Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack = do
    Maybe (TType, Int16)
fieldContents <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
lastFieldId [Int16]
fieldStack
    case Maybe (TType, Int16)
fieldContents of
        Maybe (TType, Int16)
Nothing -> TimeUnit -> IO TimeUnit
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TimeUnit
TIME_UNIT_UNKNOWN
        Just (TType
elemType, Int16
identifier) -> case Int16
identifier of
            Int16
1 -> do
                Maybe (TType, Int16)
_ <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
0 []
                TimeUnit -> IO TimeUnit
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TimeUnit
MILLISECONDS
            Int16
2 -> do
                Maybe (TType, Int16)
_ <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
0 []
                TimeUnit -> IO TimeUnit
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TimeUnit
MICROSECONDS
            Int16
3 -> do
                Maybe (TType, Int16)
_ <- Ptr Word8
-> IORef Int -> Int16 -> [Int16] -> IO (Maybe (TType, Int16))
readField Ptr Word8
buf IORef Int
pos Int16
0 []
                TimeUnit -> IO TimeUnit
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TimeUnit
NANOSECONDS
            Int16
_ -> TimeUnit -> IO TimeUnit
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TimeUnit
TIME_UNIT_UNKNOWN