diff --git a/src/arrow_reader.rs b/src/arrow_reader.rs
index d52eda4c..801b7098 100644
--- a/src/arrow_reader.rs
+++ b/src/arrow_reader.rs
@@ -38,10 +38,11 @@ use crate::arrow_reader::column::NullableIterator;
 use crate::builder::BoxedArrayBuilder;
 use crate::error::{self, InvalidColumnSnafu, Result};
 use crate::proto::stream::Kind;
-use crate::proto::{StripeFooter, StripeInformation};
+use crate::proto::StripeFooter;
 use crate::reader::decompress::{Compression, Decompressor};
 use crate::reader::schema::{create_field, TypeDescription};
 use crate::reader::Reader;
+use crate::stripe::StripeMetadata;
 
 pub struct ArrowReader<R: Read> {
     cursor: Cursor<R>,
@@ -65,7 +66,7 @@ impl<R: Read> ArrowReader<R> {
     }
 
     pub fn total_row_count(&self) -> u64 {
-        self.cursor.reader.metadata().footer.number_of_rows()
+        self.cursor.reader.metadata().number_of_rows()
     }
 }
 
@@ -97,15 +98,9 @@ pub fn create_arrow_schema<R>(cursor: &Cursor<R>) -> Schema {
     let metadata = cursor
         .reader
         .metadata()
-        .footer
-        .metadata
+        .user_custom_metadata()
         .iter()
-        .map(|kv| {
-            (
-                kv.name().to_string(),
-                String::from_utf8_lossy(kv.value()).to_string(),
-            )
-        })
+        .map(|(key, value)| (key.clone(), String::from_utf8_lossy(value).to_string()))
         .collect::<HashMap<_, _>>();
 
     let fields = cursor
@@ -830,7 +825,8 @@ impl<R> Cursor<R> {
         let mut columns = Vec::with_capacity(fields.len());
         for name in fields {
             let field = r
-                .schema
+                .metadata()
+                .type_description()
                 .field(name.as_ref())
                 .context(error::FieldNotFoundSnafu {
                     name: name.as_ref(),
@@ -845,9 +841,12 @@ impl<R> Cursor<R> {
     }
 
     pub fn root(r: Reader<R>) -> Result<Self> {
-        let root = &r.metadata().footer.types[0];
-        let fields = &root.field_names.clone();
-        Self::new(r, fields)
+        let columns = r.metadata().type_description().children();
+        Ok(Self {
+            reader: r,
+            columns: Arc::new(columns),
+            stripe_offset: 0,
+        })
     }
 }
 
@@ -855,8 +854,8 @@ impl<R: Read + Seek> Iterator for Cursor<R> {
     type Item = Result<Stripe>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        if let Some(info) = self.reader.stripe(self.stripe_offset) {
-            let stripe = Stripe::new(&mut self.reader, &self.columns, self.stripe_offset, info);
+        if let Some(info) = self.reader.stripe(self.stripe_offset).cloned() {
+            let stripe = Stripe::new(&mut self.reader, &self.columns, self.stripe_offset, &info);
 
             self.stripe_offset += 1;
 
@@ -872,7 +871,6 @@ pub struct Stripe {
     pub(crate) footer: Arc<StripeFooter>,
     pub(crate) columns: Vec<Column>,
     pub(crate) stripe_offset: usize,
-    pub(crate) info: StripeInformation,
     /// <(ColumnId, Kind), Bytes>
     pub(crate) stream_map: Arc<StreamMap>,
 }
@@ -905,18 +903,15 @@ impl Stripe {
         r: &mut Reader<R>,
         column_defs: &[(String, Arc<TypeDescription>)],
         stripe: usize,
-        info: StripeInformation,
+        info: &StripeMetadata,
     ) -> Result<Self> {
         let footer = Arc::new(r.stripe_footer(stripe).clone());
 
-        let compression = Compression::from_proto(
-            r.metadata().postscript.compression(),
-            r.metadata().postscript.compression_block_size,
-        );
+        let compression = r.metadata().compression();
         //TODO(weny): add tz
         let mut columns = Vec::with_capacity(column_defs.len());
         for (name, typ) in column_defs.iter() {
-            columns.push(Column::new(name, typ, &footer, &info));
+            columns.push(Column::new(name, typ, &footer, info.number_of_rows()));
         }
 
         let mut stream_map = HashMap::new();
@@ -937,7 +932,6 @@ impl Stripe {
             footer,
             columns,
             stripe_offset: stripe,
-            info,
             stream_map: Arc::new(StreamMap {
                 inner: stream_map,
                 compression,
@@ -952,8 +946,4 @@ impl Stripe {
     pub fn stripe_offset(&self) -> usize {
         self.stripe_offset
     }
-
-    pub fn stripe_info(&self) -> &StripeInformation {
-        &self.info
-    }
 }
diff --git a/src/arrow_reader/column.rs b/src/arrow_reader/column.rs
index 761293df..53a242c1 100644
--- a/src/arrow_reader/column.rs
+++ b/src/arrow_reader/column.rs
@@ -115,10 +115,10 @@ impl Column {
         name: &str,
         column: &Arc<TypeDescription>,
         footer: &Arc<StripeFooter>,
-        stripe: &StripeInformation,
+        number_of_rows: u64,
     ) -> Self {
         Self {
-            number_of_rows: stripe.number_of_rows(),
+            number_of_rows,
             footer: footer.clone(),
             column: column.clone(),
             name: name.to_string(),
diff --git a/src/async_arrow_reader.rs b/src/async_arrow_reader.rs
index 920dd9db..6dd7082e 100644
--- a/src/async_arrow_reader.rs
+++ b/src/async_arrow_reader.rs
@@ -17,10 +17,9 @@ use crate::arrow_reader::{
     create_arrow_schema, Cursor, NaiveStripeDecoder, StreamMap, Stripe, DEFAULT_BATCH_SIZE,
 };
 use crate::error::Result;
-use crate::proto::StripeInformation;
-use crate::reader::decompress::Compression;
 use crate::reader::schema::TypeDescription;
 use crate::reader::Reader;
+use crate::stripe::StripeMetadata;
 
 pub type BoxedDecoder = Box<dyn Iterator<Item = Result<RecordBatch>> + Send>;
 
@@ -68,7 +67,7 @@ pub struct ArrowStreamReader<R: AsyncRead + AsyncSeek + Unpin + Send> {
 }
 
 impl<R: AsyncRead + AsyncSeek + Unpin + Send + 'static> StripeFactory<R> {
-    pub async fn read_next_stripe_inner(&mut self, info: StripeInformation) -> Result<Stripe> {
+    pub async fn read_next_stripe_inner(&mut self, info: &StripeMetadata) -> Result<Stripe> {
         let inner = &mut self.inner;
 
         let column_defs = inner.columns.clone();
@@ -79,10 +78,10 @@ impl<R: AsyncRead + AsyncSeek + Unpin + Send + 'static> StripeFactory<R> {
     }
 
     pub async fn read_next_stripe(mut self) -> Result<(Self, Option<Stripe>)> {
-        let info = self.inner.reader.stripe(self.inner.stripe_offset);
+        let info = self.inner.reader.stripe(self.inner.stripe_offset).cloned();
 
         if let Some(info) = info {
-            match self.read_next_stripe_inner(info).await {
+            match self.read_next_stripe_inner(&info).await {
                 Ok(stripe) => Ok((self, Some(stripe))),
                 Err(err) => Err(err),
             }
@@ -186,18 +185,15 @@ impl Stripe {
         r: &mut Reader<R>,
         column_defs: Arc<Vec<(String, Arc<TypeDescription>)>>,
         stripe: usize,
-        info: StripeInformation,
+        info: &StripeMetadata,
     ) -> Result<Self> {
         let footer = Arc::new(r.stripe_footer(stripe).clone());
 
-        let compression = Compression::from_proto(
-            r.metadata().postscript.compression(),
-            r.metadata().postscript.compression_block_size,
-        );
+        let compression = r.metadata().compression();
         //TODO(weny): add tz
         let mut columns = Vec::with_capacity(column_defs.len());
         for (name, typ) in column_defs.iter() {
-            columns.push(Column::new(name, typ, &footer, &info));
+            columns.push(Column::new(name, typ, &footer, info.number_of_rows()));
         }
 
         let mut stream_map = HashMap::new();
@@ -218,7 +214,6 @@ impl Stripe {
             footer,
             columns,
             stripe_offset: stripe,
-            info,
             stream_map: Arc::new(StreamMap {
                 inner: stream_map,
                 compression,
diff --git a/src/lib.rs b/src/lib.rs
index cc711f19..1ab9f46b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,6 +4,8 @@ pub(crate) mod builder;
 pub mod error;
 pub mod proto;
 pub mod reader;
+pub mod statistics;
+pub mod stripe;
 
 pub use arrow_reader::{ArrowReader, Cursor};
 pub use async_arrow_reader::ArrowStreamReader;
diff --git a/src/reader.rs b/src/reader.rs
index df739e96..e7f6ea2e 100644
--- a/src/reader.rs
+++ b/src/reader.rs
@@ -5,49 +5,25 @@ pub mod schema;
 
 use std::fs::File;
 use std::io::{BufReader, Read, Seek, SeekFrom};
-use std::sync::Arc;
 
 use tokio::io::{AsyncRead, AsyncSeek};
 
 use self::metadata::{read_metadata, FileMetadata};
-use self::schema::{create_schema, TypeDescription};
-use crate::arrow_reader::Cursor;
+use self::schema::TypeDescription;
 use crate::error::Result;
-use crate::proto::{StripeFooter, StripeInformation};
+use crate::proto::StripeFooter;
 use crate::reader::metadata::read_metadata_async;
+use crate::stripe::StripeMetadata;
 
 pub struct Reader<R> {
     pub(crate) inner: R,
     metadata: Box<FileMetadata>,
-    pub(crate) schema: Arc<TypeDescription>,
 }
 
 impl<R: ChunkReader> Reader<R> {
     pub fn new(mut r: R) -> Result<Self> {
         let metadata = Box::new(read_metadata(&mut r)?);
-        let schema = create_schema(&metadata.footer.types, 0)?;
-
-        Ok(Self {
-            inner: r,
-            metadata,
-            schema,
-        })
-    }
-}
-
-impl<R: Read> Reader<R> {
-    pub fn new_with_metadata(r: R, metadata: FileMetadata) -> Result<Self> {
-        let schema = create_schema(&metadata.footer.types, 0)?;
-
-        Ok(Self {
-            inner: r,
-            metadata: Box::new(metadata),
-            schema,
-        })
-    }
-
-    pub fn select(self, fields: &[&str]) -> Result<Cursor<R>> {
-        Cursor::new(self, fields)
+        Ok(Self { inner: r, metadata })
     }
 }
 
@@ -57,28 +33,22 @@ impl<R> Reader<R> {
     }
 
     pub fn schema(&self) -> &TypeDescription {
-        &self.schema
+        self.metadata.type_description()
     }
 
-    pub fn stripe(&self, index: usize) -> Option<StripeInformation> {
-        self.metadata.footer.stripes.get(index).cloned()
+    pub fn stripe(&self, index: usize) -> Option<&StripeMetadata> {
+        self.metadata.stripe_metadatas().get(index)
     }
 
     pub fn stripe_footer(&mut self, stripe: usize) -> &StripeFooter {
-        &self.metadata.stripe_footers[stripe]
+        &self.metadata.stripe_footers()[stripe]
     }
 }
 
 impl<R: AsyncRead + AsyncSeek + Unpin + Send> Reader<R> {
     pub async fn new_async(mut r: R) -> Result<Self> {
         let metadata = Box::new(read_metadata_async(&mut r).await?);
-        let schema = create_schema(&metadata.footer.types, 0)?;
-
-        Ok(Self {
-            inner: r,
-            metadata,
-            schema,
-        })
+        Ok(Self { inner: r, metadata })
     }
 }
 
diff --git a/src/reader/metadata.rs b/src/reader/metadata.rs
index fa33354f..844f938e 100644
--- a/src/reader/metadata.rs
+++ b/src/reader/metadata.rs
@@ -22,7 +22,9 @@
 //! If they are compressed then their lengths indicate their
 //! compressed lengths.
 
+use std::collections::HashMap;
 use std::io::{Read, SeekFrom};
+use std::sync::Arc;
 
 use bytes::Bytes;
 use prost::Message;
@@ -30,10 +32,13 @@ use snafu::{OptionExt, ResultExt};
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncSeek, AsyncSeekExt};
 
 use crate::error::{self, Result};
-use crate::proto::{Footer, Metadata, PostScript, StripeFooter};
+use crate::proto::{self, Footer, Metadata, PostScript, StripeFooter};
 use crate::reader::decompress::Decompressor;
+use crate::statistics::ColumnStatistics;
+use crate::stripe::StripeMetadata;
 
 use super::decompress::Compression;
+use super::schema::{create_schema, TypeDescription};
 use super::ChunkReader;
 
 const DEFAULT_FOOTER_SIZE: u64 = 16 * 1024;
@@ -41,10 +46,84 @@ const DEFAULT_FOOTER_SIZE: u64 = 16 * 1024;
 /// The file's metadata.
 #[derive(Debug)]
 pub struct FileMetadata {
-    pub postscript: PostScript,
-    pub footer: Footer,
-    pub metadata: Metadata,
-    pub stripe_footers: Vec<StripeFooter>,
+    compression: Option<Compression>,
+    type_description: Arc<TypeDescription>,
+    number_of_rows: u64,
+    /// Statistics of columns across entire file
+    column_statistics: Vec<ColumnStatistics>,
+    stripes: Vec<StripeMetadata>,
+    user_custom_metadata: HashMap<String, Vec<u8>>,
+    // TODO: for now keeping this, but ideally won't want all stripe footers here
+    //       since don't want to require parsing all stripe footers in file unless actually required
+    stripe_footers: Vec<StripeFooter>,
+}
+
+impl FileMetadata {
+    fn from_proto(
+        postscript: &proto::PostScript,
+        footer: &proto::Footer,
+        metadata: &proto::Metadata,
+        stripe_footers: Vec<StripeFooter>,
+    ) -> Result<Self> {
+        let compression =
+            Compression::from_proto(postscript.compression(), postscript.compression_block_size);
+        let type_description = create_schema(&footer.types, 0)?;
+        let number_of_rows = footer.number_of_rows();
+        let column_statistics = footer
+            .statistics
+            .iter()
+            .map(TryFrom::try_from)
+            .collect::<Result<Vec<_>>>()?;
+        let stripes = footer
+            .stripes
+            .iter()
+            .zip(metadata.stripe_stats.iter())
+            .map(TryFrom::try_from)
+            .collect::<Result<Vec<_>>>()?;
+        let user_custom_metadata = footer
+            .metadata
+            .iter()
+            .map(|kv| (kv.name().to_owned(), kv.value().to_vec()))
+            .collect::<HashMap<_, _>>();
+
+        Ok(Self {
+            compression,
+            type_description,
+            number_of_rows,
+            column_statistics,
+            stripes,
+            user_custom_metadata,
+            stripe_footers,
+        })
+    }
+
+    pub fn number_of_rows(&self) -> u64 {
+        self.number_of_rows
+    }
+
+    pub fn compression(&self) -> Option<Compression> {
+        self.compression
+    }
+
+    pub fn type_description(&self) -> &Arc<TypeDescription> {
+        &self.type_description
+    }
+
+    pub fn column_file_statistics(&self) -> &[ColumnStatistics] {
+        &self.column_statistics
+    }
+
+    pub fn stripe_metadatas(&self) -> &[StripeMetadata] {
+        &self.stripes
+    }
+
+    pub fn stripe_footers(&self) -> &[StripeFooter] {
+        &self.stripe_footers
+    }
+
+    pub fn user_custom_metadata(&self) -> &HashMap<String, Vec<u8>> {
+        &self.user_custom_metadata
+    }
 }
 
 pub fn read_metadata<R>(reader: &mut R) -> Result<FileMetadata>
@@ -121,12 +200,7 @@ where
         stripe_footers.push(deserialize_stripe_footer(&scratch, compression)?);
     }
 
-    Ok(FileMetadata {
-        postscript,
-        footer,
-        metadata,
-        stripe_footers,
-    })
+    FileMetadata::from_proto(&postscript, &footer, &metadata, stripe_footers)
 }
 
 // TODO: refactor like for sync
@@ -241,12 +315,7 @@ where
         stripe_footers.push(deserialize_stripe_footer(&scratch, compression)?);
     }
 
-    Ok(FileMetadata {
-        postscript,
-        footer,
-        metadata,
-        stripe_footers,
-    })
+    FileMetadata::from_proto(&postscript, &footer, &metadata, stripe_footers)
 }
 
 fn deserialize_footer(bytes: &[u8], compression: Option<Compression>) -> Result<Footer> {
diff --git a/src/statistics.rs b/src/statistics.rs
new file mode 100644
index 00000000..f0911898
--- /dev/null
+++ b/src/statistics.rs
@@ -0,0 +1,146 @@
+use crate::{error, proto};
+
+/// Contains statistics for a specific column, for the entire file
+/// or for a specific stripe.
+#[derive(Debug, Clone)]
+pub struct ColumnStatistics {
+    number_of_values: u64,
+    /// Use aid in 'IS NULL' predicates
+    has_null: bool,
+    type_statistics: Option<TypeStatistics>,
+}
+
+impl ColumnStatistics {
+    pub fn number_of_values(&self) -> u64 {
+        self.number_of_values
+    }
+
+    pub fn has_null(&self) -> bool {
+        self.has_null
+    }
+
+    pub fn type_statistics(&self) -> Option<&TypeStatistics> {
+        self.type_statistics.as_ref()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum TypeStatistics {
+    /// For TinyInt, SmallInt, Int and BigInt
+    Integer {
+        min: i64,
+        max: i64,
+        /// If sum overflows then recorded as None
+        sum: Option<i64>,
+    },
+    /// For Float and Double
+    Double {
+        min: f64,
+        max: f64,
+        /// If sum overflows then recorded as None
+        sum: Option<f64>,
+    },
+    String {
+        min: String,
+        max: String,
+        /// Total length of all strings
+        sum: i64,
+    },
+    /// For Boolean
+    Bucket { true_count: u64 },
+    Decimal {
+        // TODO: use our own decimal type?
+        min: String,
+        max: String,
+        sum: String,
+    },
+    Date {
+        /// Days since epoch
+        min: i32,
+        max: i32,
+    },
+    Binary {
+        // Total number of bytes across all values
+        sum: i64,
+    },
+    Timestamp {
+        /// Milliseconds since epoch
+        /// These were used before ORC-135
+        /// Where local timezone offset was included
+        min: i64,
+        max: i64,
+        /// Milliseconds since UNIX epoch
+        min_utc: i64,
+        max_utc: i64,
+    },
+    Collection {
+        min_children: u64,
+        max_children: u64,
+        total_children: u64,
+    },
+}
+
+impl TryFrom<&proto::ColumnStatistics> for ColumnStatistics {
+    type Error = error::Error;
+
+    fn try_from(value: &proto::ColumnStatistics) -> Result<Self, Self::Error> {
+        let type_statistics = if let Some(stats) = &value.int_statistics {
+            Some(TypeStatistics::Integer {
+                min: stats.minimum(),
+                max: stats.maximum(),
+                sum: stats.sum,
+            })
+        } else if let Some(stats) = &value.double_statistics {
+            Some(TypeStatistics::Double {
+                min: stats.minimum(),
+                max: stats.maximum(),
+                sum: stats.sum,
+            })
+        } else if let Some(stats) = &value.string_statistics {
+            Some(TypeStatistics::String {
+                min: stats.minimum().to_owned(),
+                max: stats.maximum().to_owned(),
+                sum: stats.sum(),
+            })
+        } else if let Some(stats) = &value.bucket_statistics {
+            // TODO: false count?
+            Some(TypeStatistics::Bucket {
+                true_count: stats.count[0], // TODO: safety check this
+            })
+        } else if let Some(stats) = &value.decimal_statistics {
+            Some(TypeStatistics::Decimal {
+                min: stats.minimum().to_owned(),
+                max: stats.maximum().to_owned(),
+                sum: stats.sum().to_owned(),
+            })
+        } else if let Some(stats) = &value.date_statistics {
+            Some(TypeStatistics::Date {
+                min: stats.minimum(),
+                max: stats.maximum(),
+            })
+        } else if let Some(stats) = &value.binary_statistics {
+            Some(TypeStatistics::Binary { sum: stats.sum() })
+        } else if let Some(stats) = &value.timestamp_statistics {
+            Some(TypeStatistics::Timestamp {
+                min: stats.minimum(),
+                max: stats.maximum(),
+                min_utc: stats.minimum_utc(),
+                max_utc: stats.maximum_utc(),
+            })
+        } else {
+            value
+                .collection_statistics
+                .as_ref()
+                .map(|stats| TypeStatistics::Collection {
+                    min_children: stats.min_children(),
+                    max_children: stats.max_children(),
+                    total_children: stats.total_children(),
+                })
+        };
+        Ok(Self {
+            number_of_values: value.number_of_values(),
+            has_null: value.has_null(),
+            type_statistics,
+        })
+    }
+}
diff --git a/src/stripe.rs b/src/stripe.rs
new file mode 100644
index 00000000..1f082c30
--- /dev/null
+++ b/src/stripe.rs
@@ -0,0 +1,69 @@
+use crate::{error, proto, statistics::ColumnStatistics};
+
+/// Stripe metadata parsed from the file tail metadata sections.
+/// Does not contain the actual stripe bytes, as those are decoded
+/// when they are required.
+#[derive(Debug, Clone)]
+pub struct StripeMetadata {
+    /// Statistics of columns across this specific stripe
+    column_statistics: Vec<ColumnStatistics>,
+    /// Byte offset of start of stripe from start of file
+    offset: u64,
+    /// Byte length of index section
+    index_length: u64,
+    /// Byte length of data section
+    data_length: u64,
+    /// Byte length of footer section
+    footer_length: u64,
+    /// Number of rows in the stripe
+    number_of_rows: u64,
+}
+
+impl StripeMetadata {
+    pub fn offset(&self) -> u64 {
+        self.offset
+    }
+
+    pub fn index_length(&self) -> u64 {
+        self.index_length
+    }
+
+    pub fn data_length(&self) -> u64 {
+        self.data_length
+    }
+
+    pub fn footer_length(&self) -> u64 {
+        self.footer_length
+    }
+
+    pub fn number_of_rows(&self) -> u64 {
+        self.number_of_rows
+    }
+
+    pub fn column_statistics(&self) -> &[ColumnStatistics] {
+        &self.column_statistics
+    }
+}
+
+impl TryFrom<(&proto::StripeInformation, &proto::StripeStatistics)> for StripeMetadata {
+    type Error = error::Error;
+
+    fn try_from(
+        value: (&proto::StripeInformation, &proto::StripeStatistics),
+    ) -> Result<Self, Self::Error> {
+        let column_statistics = value
+            .1
+            .col_stats
+            .iter()
+            .map(TryFrom::try_from)
+            .collect::<Result<Vec<_>, _>>()?;
+        Ok(Self {
+            column_statistics,
+            offset: value.0.offset(),
+            index_length: value.0.index_length(),
+            data_length: value.0.data_length(),
+            footer_length: value.0.footer_length(),
+            number_of_rows: value.0.number_of_rows(),
+        })
+    }
+}