diff --git a/cmd/prometheus/main.go b/cmd/prometheus/main.go
index ce49a9dd9..b405ef670 100644
--- a/cmd/prometheus/main.go
+++ b/cmd/prometheus/main.go
@@ -1190,7 +1190,7 @@ func (n notReadyAppender) AppendExemplar(ref uint64, l labels.Labels, e exemplar
 	return 0, tsdb.ErrNotReady
 }
 
-func (n notReadyAppender) AppendHistogram(ref uint64, l labels.Labels, t int64, sh histogram.Histogram) (uint64, error) {
+func (n notReadyAppender) AppendHistogram(ref uint64, l labels.Labels, t int64, h *histogram.Histogram) (uint64, error) {
 	return 0, tsdb.ErrNotReady
 }
 
diff --git a/cmd/promtool/unittest.go b/cmd/promtool/unittest.go
index 3ddec3152..4c197d074 100644
--- a/cmd/promtool/unittest.go
+++ b/cmd/promtool/unittest.go
@@ -460,7 +460,7 @@ func query(ctx context.Context, qs string, t time.Time, engine *promql.Engine, q
 		return v, nil
 	case promql.Scalar:
 		return promql.Vector{promql.Sample{
-			Point:  promql.Point(v),
+			Point:  promql.Point{T: v.T, V: v.V},
 			Metric: labels.Labels{},
 		}}, nil
 	default:
diff --git a/pkg/textparse/interface.go b/pkg/textparse/interface.go
index e55e628b6..25f0ec9ab 100644
--- a/pkg/textparse/interface.go
+++ b/pkg/textparse/interface.go
@@ -30,7 +30,7 @@ type Parser interface {
 
 	// Histogram returns the bytes of a series with a sparse histogram as a
 	// value, the timestamp if set, and the histogram in the current sample.
-	Histogram() ([]byte, *int64, histogram.Histogram)
+	Histogram() ([]byte, *int64, *histogram.Histogram)
 
 	// Help returns the metric name and help text in the current entry.
 	// Must only be called after Next returned a help entry.
diff --git a/pkg/textparse/openmetricsparse.go b/pkg/textparse/openmetricsparse.go
index 265ca22b1..b51321ff4 100644
--- a/pkg/textparse/openmetricsparse.go
+++ b/pkg/textparse/openmetricsparse.go
@@ -114,10 +114,10 @@ func (p *OpenMetricsParser) Series() ([]byte, *int64, float64) {
 	return p.series, nil, p.val
 }
 
-// Histogram always returns (nil, nil, histogram.Histogram{}) because
-// OpenMetrics does not support sparse histograms.
-func (p *OpenMetricsParser) Histogram() ([]byte, *int64, histogram.Histogram) {
-	return nil, nil, histogram.Histogram{}
+// Histogram always returns (nil, nil, nil) because OpenMetrics does not support
+// sparse histograms.
+func (p *OpenMetricsParser) Histogram() ([]byte, *int64, *histogram.Histogram) {
+	return nil, nil, nil
 }
 
 // Help returns the metric name and help text in the current entry.
diff --git a/pkg/textparse/promparse.go b/pkg/textparse/promparse.go
index c7059a2b1..0190ef6eb 100644
--- a/pkg/textparse/promparse.go
+++ b/pkg/textparse/promparse.go
@@ -169,10 +169,10 @@ func (p *PromParser) Series() ([]byte, *int64, float64) {
 	return p.series, nil, p.val
 }
 
-// Histogram always returns (nil, nil, histogram.Histogram{}) because the
-// Prometheus text format does not support sparse histograms.
-func (p *PromParser) Histogram() ([]byte, *int64, histogram.Histogram) {
-	return nil, nil, histogram.Histogram{}
+// Histogram always returns (nil, nil, nil) because the Prometheus text format
+// does not support sparse histograms.
+func (p *PromParser) Histogram() ([]byte, *int64, *histogram.Histogram) {
+	return nil, nil, nil
 }
 
 // Help returns the metric name and help text in the current entry.
diff --git a/pkg/textparse/protobufparse.go b/pkg/textparse/protobufparse.go
index 5a43108f1..b0bcf7ed0 100644
--- a/pkg/textparse/protobufparse.go
+++ b/pkg/textparse/protobufparse.go
@@ -135,7 +135,7 @@ func (p *ProtobufParser) Series() ([]byte, *int64, float64) {
 // Histogram returns the bytes of a series with a sparse histogram as a
 // value, the timestamp if set, and the sparse histogram in the current
 // sample.
-func (p *ProtobufParser) Histogram() ([]byte, *int64, histogram.Histogram) {
+func (p *ProtobufParser) Histogram() ([]byte, *int64, *histogram.Histogram) {
 	var (
 		m  = p.mf.GetMetric()[p.metricPos]
 		ts = m.GetTimestampMs()
@@ -161,12 +161,12 @@ func (p *ProtobufParser) Histogram() ([]byte, *int64, histogram.Histogram) {
 		sh.NegativeSpans[i].Length = span.GetLength()
 	}
 	if ts != 0 {
-		return p.metricBytes.Bytes(), &ts, sh
+		return p.metricBytes.Bytes(), &ts, &sh
 	}
 	// Nasty hack: Assume that ts==0 means no timestamp. That's not true in
 	// general, but proto3 has no distinction between unset and
 	// default. Need to avoid in the final format.
-	return p.metricBytes.Bytes(), nil, sh
+	return p.metricBytes.Bytes(), nil, &sh
 }
 
 // Help returns the metric name and help text in the current entry.
diff --git a/pkg/textparse/protobufparse_test.go b/pkg/textparse/protobufparse_test.go
index 9df8c4e63..c92c148fe 100644
--- a/pkg/textparse/protobufparse_test.go
+++ b/pkg/textparse/protobufparse_test.go
@@ -266,7 +266,7 @@ metric: <
 		help    string
 		unit    string
 		comment string
-		shs     histogram.Histogram
+		shs     *histogram.Histogram
 		e       []exemplar.Exemplar
 	}{
 		{
@@ -332,7 +332,7 @@ metric: <
 		{
 			m: "test_histogram",
 			t: 1234568,
-			shs: histogram.Histogram{
+			shs: &histogram.Histogram{
 				Count:         175,
 				ZeroCount:     2,
 				Sum:           0.0008280461746287094,
diff --git a/promql/engine.go b/promql/engine.go
index f1c48f610..afe870f2d 100644
--- a/promql/engine.go
+++ b/promql/engine.go
@@ -1748,7 +1748,7 @@ func (ev *evaluator) matrixIterSlice(it *storage.BufferedSeriesIterator, mint, m
 					ev.error(ErrTooManySamples(env))
 				}
 				ev.currentSamples++
-				out = append(out, Point{T: t, H: &h})
+				out = append(out, Point{T: t, H: h})
 			}
 		}
 	} else {
@@ -1775,7 +1775,7 @@ func (ev *evaluator) matrixIterSlice(it *storage.BufferedSeriesIterator, mint, m
 				if ev.currentSamples >= ev.maxSamples {
 					ev.error(ErrTooManySamples(env))
 				}
-				out = append(out, Point{T: t, H: &h})
+				out = append(out, Point{T: t, H: h})
 				ev.currentSamples++
 			}
 		} else {
diff --git a/promql/engine_test.go b/promql/engine_test.go
index 941250a41..fe1d017bc 100644
--- a/promql/engine_test.go
+++ b/promql/engine_test.go
@@ -2460,5 +2460,5 @@ func TestSparseHistogramRate(t *testing.T) {
 	require.NoError(t, err)
 	res := qry.Exec(test.Context())
 	require.NoError(t, res.Err)
-	fmt.Println(res)
+	// fmt.Println(res)
 }
diff --git a/promql/value.go b/promql/value.go
index 4f52b3199..5e3863379 100644
--- a/promql/value.go
+++ b/promql/value.go
@@ -300,9 +300,9 @@ func (ssi *storageSeriesIterator) At() (t int64, v float64) {
 	return p.T, p.V
 }
 
-func (ssi *storageSeriesIterator) AtHistogram() (int64, histogram.Histogram) {
+func (ssi *storageSeriesIterator) AtHistogram() (int64, *histogram.Histogram) {
 	p := ssi.points[ssi.curr]
-	return p.T, *p.H
+	return p.T, p.H
 }
 
 func (ssi *storageSeriesIterator) ChunkEncoding() chunkenc.Encoding {
diff --git a/scrape/helpers_test.go b/scrape/helpers_test.go
index 16eb8e272..a46350a6e 100644
--- a/scrape/helpers_test.go
+++ b/scrape/helpers_test.go
@@ -35,7 +35,7 @@ func (a nopAppender) Append(uint64, labels.Labels, int64, float64) (uint64, erro
 func (a nopAppender) AppendExemplar(uint64, labels.Labels, exemplar.Exemplar) (uint64, error) {
 	return 0, nil
 }
-func (a nopAppender) AppendHistogram(uint64, labels.Labels, int64, histogram.Histogram) (uint64, error) {
+func (a nopAppender) AppendHistogram(uint64, labels.Labels, int64, *histogram.Histogram) (uint64, error) {
 	return 0, nil
 }
 func (a nopAppender) Commit() error   { return nil }
@@ -49,7 +49,7 @@ type sample struct {
 
 type histogramSample struct {
 	t int64
-	h histogram.Histogram
+	h *histogram.Histogram
 }
 
 // collectResultAppender records all samples that were added through the appender.
@@ -96,7 +96,7 @@ func (a *collectResultAppender) AppendExemplar(ref uint64, l labels.Labels, e ex
 	return a.next.AppendExemplar(ref, l, e)
 }
 
-func (a *collectResultAppender) AppendHistogram(ref uint64, l labels.Labels, t int64, h histogram.Histogram) (uint64, error) {
+func (a *collectResultAppender) AppendHistogram(ref uint64, l labels.Labels, t int64, h *histogram.Histogram) (uint64, error) {
 	a.pendingHistograms = append(a.pendingHistograms, histogramSample{h: h, t: t})
 	if a.next == nil {
 		return 0, nil
diff --git a/scrape/scrape.go b/scrape/scrape.go
index 8ffb98742..a44ad0c85 100644
--- a/scrape/scrape.go
+++ b/scrape/scrape.go
@@ -1440,7 +1440,7 @@ loop:
 			met                      []byte
 			parsedTimestamp          *int64
 			val                      float64
-			h                        histogram.Histogram
+			h                        *histogram.Histogram
 		)
 		if et, err = p.Next(); err != nil {
 			if err == io.EOF {
diff --git a/storage/buffer.go b/storage/buffer.go
index 93cd9da00..cad7e6653 100644
--- a/storage/buffer.go
+++ b/storage/buffer.go
@@ -120,7 +120,7 @@ func (b *BufferedSeriesIterator) Next() bool {
 	// Add current element to buffer before advancing.
 	if b.it.ChunkEncoding() == chunkenc.EncHistogram {
 		t, h := b.it.AtHistogram()
-		b.buf.add(sample{t: t, h: &h})
+		b.buf.add(sample{t: t, h: h})
 	} else {
 		t, v := b.it.At()
 		b.buf.add(sample{t: t, v: v})
@@ -144,7 +144,7 @@ func (b *BufferedSeriesIterator) Values() (int64, float64) {
 }
 
 // HistogramValues returns the current histogram element of the iterator.
-func (b *BufferedSeriesIterator) HistogramValues() (int64, histogram.Histogram) {
+func (b *BufferedSeriesIterator) HistogramValues() (int64, *histogram.Histogram) {
 	return b.it.AtHistogram()
 }
 
@@ -230,7 +230,7 @@ func (it *sampleRingIterator) At() (int64, float64) {
 	return it.r.at(it.i)
 }
 
-func (it *sampleRingIterator) AtHistogram() (int64, histogram.Histogram) {
+func (it *sampleRingIterator) AtHistogram() (int64, *histogram.Histogram) {
 	return it.r.atHistogram(it.i)
 }
 
@@ -244,10 +244,10 @@ func (r *sampleRing) at(i int) (int64, float64) {
 	return s.t, s.v
 }
 
-func (r *sampleRing) atHistogram(i int) (int64, histogram.Histogram) {
+func (r *sampleRing) atHistogram(i int) (int64, *histogram.Histogram) {
 	j := (r.f + i) % len(r.buf)
 	s := r.buf[j]
-	return s.t, *s.h
+	return s.t, s.h
 }
 
 func (r *sampleRing) atSample(i int) sample {
diff --git a/storage/buffer_test.go b/storage/buffer_test.go
index 2d7b3f1e9..5cb8aeab8 100644
--- a/storage/buffer_test.go
+++ b/storage/buffer_test.go
@@ -55,7 +55,7 @@ func TestSampleRing(t *testing.T) {
 		},
 	}
 	for _, c := range cases {
-		r := newSampleRing(c.delta, c.size)
+		r := newSampleRing(c.delta, c.size, chunkenc.EncNone)
 
 		input := []sample{}
 		for _, t := range c.input {
@@ -66,7 +66,7 @@ func TestSampleRing(t *testing.T) {
 		}
 
 		for i, s := range input {
-			r.add(s.t, s.v)
+			r.add(s)
 			buffered := r.samples()
 
 			for _, sold := range input[:i] {
@@ -106,7 +106,7 @@ func TestBufferedSeriesIterator(t *testing.T) {
 		require.Equal(t, ev, v, "value mismatch")
 	}
 	prevSampleEq := func(ets int64, ev float64, eok bool) {
-		ts, v, ok := it.PeekBack(1)
+		ts, v, _, ok := it.PeekBack(1)
 		require.Equal(t, eok, ok, "exist mismatch")
 		require.Equal(t, ets, ts, "timestamp mismatch")
 		require.Equal(t, ev, v, "value mismatch")
@@ -196,8 +196,8 @@ type mockSeriesIterator struct {
 
 func (m *mockSeriesIterator) Seek(t int64) bool    { return m.seek(t) }
 func (m *mockSeriesIterator) At() (int64, float64) { return m.at() }
-func (m *mockSeriesIterator) AtHistogram() (int64, histogram.Histogram) {
-	return 0, histogram.Histogram{}
+func (m *mockSeriesIterator) AtHistogram() (int64, *histogram.Histogram) {
+	return 0, nil
 }
 func (m *mockSeriesIterator) ChunkEncoding() chunkenc.Encoding {
 	return chunkenc.EncXOR
@@ -219,8 +219,8 @@ func (it *fakeSeriesIterator) At() (int64, float64) {
 	return it.idx * it.step, 123 // Value doesn't matter.
 }
 
-func (it *fakeSeriesIterator) AtHistogram() (int64, histogram.Histogram) {
-	return it.idx * it.step, histogram.Histogram{} // Value doesn't matter.
+func (it *fakeSeriesIterator) AtHistogram() (int64, *histogram.Histogram) {
+	return it.idx * it.step, &histogram.Histogram{} // Value doesn't matter.
 }
 
 func (it *fakeSeriesIterator) ChunkEncoding() chunkenc.Encoding {
diff --git a/storage/fanout.go b/storage/fanout.go
index ccb123895..672756d96 100644
--- a/storage/fanout.go
+++ b/storage/fanout.go
@@ -173,7 +173,7 @@ func (f *fanoutAppender) AppendExemplar(ref uint64, l labels.Labels, e exemplar.
 	return ref, nil
 }
 
-func (f *fanoutAppender) AppendHistogram(ref uint64, l labels.Labels, t int64, h histogram.Histogram) (uint64, error) {
+func (f *fanoutAppender) AppendHistogram(ref uint64, l labels.Labels, t int64, h *histogram.Histogram) (uint64, error) {
 	ref, err := f.primary.AppendHistogram(ref, l, t, h)
 	if err != nil {
 		return ref, err
diff --git a/storage/interface.go b/storage/interface.go
index be55a5bb2..f15b1c00d 100644
--- a/storage/interface.go
+++ b/storage/interface.go
@@ -222,7 +222,7 @@ type HistogramAppender interface {
 	// numbers are ephemeral and may be rejected in calls to Append() at any
 	// point. Adding the sample via Append() returns a new reference number.
 	// If the reference is 0 it must not be used for caching.
-	AppendHistogram(ref uint64, l labels.Labels, t int64, h histogram.Histogram) (uint64, error)
+	AppendHistogram(ref uint64, l labels.Labels, t int64, h *histogram.Histogram) (uint64, error)
 }
 
 // SeriesSet contains a set of series.
diff --git a/storage/merge.go b/storage/merge.go
index 7bae3a8d9..daa12108a 100644
--- a/storage/merge.go
+++ b/storage/merge.go
@@ -486,7 +486,7 @@ func (c *chainSampleIterator) At() (t int64, v float64) {
 	return c.curr.At()
 }
 
-func (c *chainSampleIterator) AtHistogram() (int64, histogram.Histogram) {
+func (c *chainSampleIterator) AtHistogram() (int64, *histogram.Histogram) {
 	if c.curr == nil {
 		panic("chainSampleIterator.AtHistogram() called before first .Next() or after .Next() returned false.")
 	}
diff --git a/storage/merge_test.go b/storage/merge_test.go
index 23eab0f70..62aa4376e 100644
--- a/storage/merge_test.go
+++ b/storage/merge_test.go
@@ -62,116 +62,116 @@ func TestMergeQuerierWithChainMerger(t *testing.T) {
 		{
 			name: "one querier, two series",
 			querierSeries: [][]Series{{
-				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}}),
-				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0}, sample{1, 1}, sample{2, 2}}),
+				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}}),
+				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}}),
 			}},
 			expected: NewMockSeriesSet(
-				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}}),
-				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0}, sample{1, 1}, sample{2, 2}}),
+				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}}),
+				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}}),
 			),
 		},
 		{
 			name: "two queriers, one different series each",
 			querierSeries: [][]Series{{
-				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}}),
+				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}}),
 			}, {
-				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0}, sample{1, 1}, sample{2, 2}}),
+				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}}),
 			}},
 			expected: NewMockSeriesSet(
-				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}}),
-				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0}, sample{1, 1}, sample{2, 2}}),
+				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}}),
+				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}}),
 			),
 		},
 		{
 			name: "two time unsorted queriers, two series each",
 			querierSeries: [][]Series{{
-				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{5, 5}, sample{6, 6}}),
-				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0}, sample{1, 1}, sample{2, 2}}),
+				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{5, 5, nil}, sample{6, 6, nil}}),
+				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}}),
 			}, {
-				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}}),
-				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{3, 3}, sample{4, 4}}),
+				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}}),
+				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{3, 3, nil}, sample{4, 4, nil}}),
 			}},
 			expected: NewMockSeriesSet(
 				NewListSeries(
 					labels.FromStrings("bar", "baz"),
-					[]tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{5, 5}, sample{6, 6}},
+					[]tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{5, 5, nil}, sample{6, 6, nil}},
 				),
 				NewListSeries(
 					labels.FromStrings("foo", "bar"),
-					[]tsdbutil.Sample{sample{0, 0}, sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{4, 4}},
+					[]tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{4, 4, nil}},
 				),
 			),
 		},
 		{
 			name: "five queriers, only two queriers have two time unsorted series each",
 			querierSeries: [][]Series{{}, {}, {
-				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{5, 5}, sample{6, 6}}),
-				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0}, sample{1, 1}, sample{2, 2}}),
+				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{5, 5, nil}, sample{6, 6, nil}}),
+				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}}),
 			}, {
-				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}}),
-				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{3, 3}, sample{4, 4}}),
+				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}}),
+				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{3, 3, nil}, sample{4, 4, nil}}),
 			}, {}},
 			expected: NewMockSeriesSet(
 				NewListSeries(
 					labels.FromStrings("bar", "baz"),
-					[]tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{5, 5}, sample{6, 6}},
+					[]tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{5, 5, nil}, sample{6, 6, nil}},
 				),
 				NewListSeries(
 					labels.FromStrings("foo", "bar"),
-					[]tsdbutil.Sample{sample{0, 0}, sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{4, 4}},
+					[]tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{4, 4, nil}},
 				),
 			),
 		},
 		{
 			name: "two queriers, only two queriers have two time unsorted series each, with 3 noop and one nil querier together",
 			querierSeries: [][]Series{{}, {}, {
-				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{5, 5}, sample{6, 6}}),
-				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0}, sample{1, 1}, sample{2, 2}}),
+				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{5, 5, nil}, sample{6, 6, nil}}),
+				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}}),
 			}, {
-				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}}),
-				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{3, 3}, sample{4, 4}}),
+				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}}),
+				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{3, 3, nil}, sample{4, 4, nil}}),
 			}, {}},
 			extraQueriers: []Querier{NoopQuerier(), NoopQuerier(), nil, NoopQuerier()},
 			expected: NewMockSeriesSet(
 				NewListSeries(
 					labels.FromStrings("bar", "baz"),
-					[]tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{5, 5}, sample{6, 6}},
+					[]tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{5, 5, nil}, sample{6, 6, nil}},
 				),
 				NewListSeries(
 					labels.FromStrings("foo", "bar"),
-					[]tsdbutil.Sample{sample{0, 0}, sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{4, 4}},
+					[]tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{4, 4, nil}},
 				),
 			),
 		},
 		{
 			name: "two queriers, with two series, one is overlapping",
 			querierSeries: [][]Series{{}, {}, {
-				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{2, 21}, sample{3, 31}, sample{5, 5}, sample{6, 6}}),
-				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0}, sample{1, 1}, sample{2, 2}}),
+				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{2, 21, nil}, sample{3, 31, nil}, sample{5, 5, nil}, sample{6, 6, nil}}),
+				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}}),
 			}, {
-				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 22}, sample{3, 32}}),
-				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{3, 3}, sample{4, 4}}),
+				NewListSeries(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 22, nil}, sample{3, 32, nil}}),
+				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{3, 3, nil}, sample{4, 4, nil}}),
 			}, {}},
 			expected: NewMockSeriesSet(
 				NewListSeries(
 					labels.FromStrings("bar", "baz"),
-					[]tsdbutil.Sample{sample{1, 1}, sample{2, 21}, sample{3, 31}, sample{5, 5}, sample{6, 6}},
+					[]tsdbutil.Sample{sample{1, 1, nil}, sample{2, 21, nil}, sample{3, 31, nil}, sample{5, 5, nil}, sample{6, 6, nil}},
 				),
 				NewListSeries(
 					labels.FromStrings("foo", "bar"),
-					[]tsdbutil.Sample{sample{0, 0}, sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{4, 4}},
+					[]tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{4, 4, nil}},
 				),
 			),
 		},
 		{
 			name: "two queries, one with NaN samples series",
 			querierSeries: [][]Series{{
-				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, math.NaN()}}),
+				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, math.NaN(), nil}}),
 			}, {
-				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{1, 1}}),
+				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{1, 1, nil}}),
 			}},
 			expected: NewMockSeriesSet(
-				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, math.NaN()}, sample{1, 1}}),
+				NewListSeries(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, math.NaN(), nil}, sample{1, 1, nil}}),
 			),
 		},
 	} {
@@ -245,108 +245,108 @@ func TestMergeChunkQuerierWithNoVerticalChunkSeriesMerger(t *testing.T) {
 		{
 			name: "one querier, two series",
 			chkQuerierSeries: [][]ChunkSeries{{
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}}, []tsdbutil.Sample{sample{3, 3}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0}, sample{1, 1}}, []tsdbutil.Sample{sample{2, 2}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}}, []tsdbutil.Sample{sample{3, 3, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}}, []tsdbutil.Sample{sample{2, 2, nil}}),
 			}},
 			expected: NewMockChunkSeriesSet(
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}}, []tsdbutil.Sample{sample{3, 3}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0}, sample{1, 1}}, []tsdbutil.Sample{sample{2, 2}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}}, []tsdbutil.Sample{sample{3, 3, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}}, []tsdbutil.Sample{sample{2, 2, nil}}),
 			),
 		},
 		{
 			name: "two secondaries, one different series each",
 			chkQuerierSeries: [][]ChunkSeries{{
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}}, []tsdbutil.Sample{sample{3, 3}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}}, []tsdbutil.Sample{sample{3, 3, nil}}),
 			}, {
-				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0}, sample{1, 1}}, []tsdbutil.Sample{sample{2, 2}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}}, []tsdbutil.Sample{sample{2, 2, nil}}),
 			}},
 			expected: NewMockChunkSeriesSet(
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}}, []tsdbutil.Sample{sample{3, 3}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0}, sample{1, 1}}, []tsdbutil.Sample{sample{2, 2}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}}, []tsdbutil.Sample{sample{3, 3, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}}, []tsdbutil.Sample{sample{2, 2, nil}}),
 			),
 		},
 		{
 			name: "two secondaries, two not in time order series each",
 			chkQuerierSeries: [][]ChunkSeries{{
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{5, 5}}, []tsdbutil.Sample{sample{6, 6}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0}, sample{1, 1}}, []tsdbutil.Sample{sample{2, 2}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{5, 5, nil}}, []tsdbutil.Sample{sample{6, 6, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}}, []tsdbutil.Sample{sample{2, 2, nil}}),
 			}, {
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}}, []tsdbutil.Sample{sample{3, 3}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{3, 3}}, []tsdbutil.Sample{sample{4, 4}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}}, []tsdbutil.Sample{sample{3, 3, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{3, 3, nil}}, []tsdbutil.Sample{sample{4, 4, nil}}),
 			}},
 			expected: NewMockChunkSeriesSet(
 				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"),
-					[]tsdbutil.Sample{sample{1, 1}, sample{2, 2}},
-					[]tsdbutil.Sample{sample{3, 3}},
-					[]tsdbutil.Sample{sample{5, 5}},
-					[]tsdbutil.Sample{sample{6, 6}},
+					[]tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}},
+					[]tsdbutil.Sample{sample{3, 3, nil}},
+					[]tsdbutil.Sample{sample{5, 5, nil}},
+					[]tsdbutil.Sample{sample{6, 6, nil}},
 				),
 				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"),
-					[]tsdbutil.Sample{sample{0, 0}, sample{1, 1}},
-					[]tsdbutil.Sample{sample{2, 2}},
-					[]tsdbutil.Sample{sample{3, 3}},
-					[]tsdbutil.Sample{sample{4, 4}},
+					[]tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}},
+					[]tsdbutil.Sample{sample{2, 2, nil}},
+					[]tsdbutil.Sample{sample{3, 3, nil}},
+					[]tsdbutil.Sample{sample{4, 4, nil}},
 				),
 			),
 		},
 		{
 			name: "five secondaries, only two have two not in time order series each",
 			chkQuerierSeries: [][]ChunkSeries{{}, {}, {
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{5, 5}}, []tsdbutil.Sample{sample{6, 6}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0}, sample{1, 1}}, []tsdbutil.Sample{sample{2, 2}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{5, 5, nil}}, []tsdbutil.Sample{sample{6, 6, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}}, []tsdbutil.Sample{sample{2, 2, nil}}),
 			}, {
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}}, []tsdbutil.Sample{sample{3, 3}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{3, 3}}, []tsdbutil.Sample{sample{4, 4}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}}, []tsdbutil.Sample{sample{3, 3, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{3, 3, nil}}, []tsdbutil.Sample{sample{4, 4, nil}}),
 			}, {}},
 			expected: NewMockChunkSeriesSet(
 				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"),
-					[]tsdbutil.Sample{sample{1, 1}, sample{2, 2}},
-					[]tsdbutil.Sample{sample{3, 3}},
-					[]tsdbutil.Sample{sample{5, 5}},
-					[]tsdbutil.Sample{sample{6, 6}},
+					[]tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}},
+					[]tsdbutil.Sample{sample{3, 3, nil}},
+					[]tsdbutil.Sample{sample{5, 5, nil}},
+					[]tsdbutil.Sample{sample{6, 6, nil}},
 				),
 				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"),
-					[]tsdbutil.Sample{sample{0, 0}, sample{1, 1}},
-					[]tsdbutil.Sample{sample{2, 2}},
-					[]tsdbutil.Sample{sample{3, 3}},
-					[]tsdbutil.Sample{sample{4, 4}},
+					[]tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}},
+					[]tsdbutil.Sample{sample{2, 2, nil}},
+					[]tsdbutil.Sample{sample{3, 3, nil}},
+					[]tsdbutil.Sample{sample{4, 4, nil}},
 				),
 			),
 		},
 		{
 			name: "two secondaries, with two not in time order series each, with 3 noop queries and one nil together",
 			chkQuerierSeries: [][]ChunkSeries{{
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{5, 5}}, []tsdbutil.Sample{sample{6, 6}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0}, sample{1, 1}}, []tsdbutil.Sample{sample{2, 2}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{5, 5, nil}}, []tsdbutil.Sample{sample{6, 6, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}}, []tsdbutil.Sample{sample{2, 2, nil}}),
 			}, {
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}}, []tsdbutil.Sample{sample{3, 3}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{3, 3}}, []tsdbutil.Sample{sample{4, 4}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}}, []tsdbutil.Sample{sample{3, 3, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{3, 3, nil}}, []tsdbutil.Sample{sample{4, 4, nil}}),
 			}},
 			extraQueriers: []ChunkQuerier{NoopChunkedQuerier(), NoopChunkedQuerier(), nil, NoopChunkedQuerier()},
 			expected: NewMockChunkSeriesSet(
 				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"),
-					[]tsdbutil.Sample{sample{1, 1}, sample{2, 2}},
-					[]tsdbutil.Sample{sample{3, 3}},
-					[]tsdbutil.Sample{sample{5, 5}},
-					[]tsdbutil.Sample{sample{6, 6}},
+					[]tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}},
+					[]tsdbutil.Sample{sample{3, 3, nil}},
+					[]tsdbutil.Sample{sample{5, 5, nil}},
+					[]tsdbutil.Sample{sample{6, 6, nil}},
 				),
 				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"),
-					[]tsdbutil.Sample{sample{0, 0}, sample{1, 1}},
-					[]tsdbutil.Sample{sample{2, 2}},
-					[]tsdbutil.Sample{sample{3, 3}},
-					[]tsdbutil.Sample{sample{4, 4}},
+					[]tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}},
+					[]tsdbutil.Sample{sample{2, 2, nil}},
+					[]tsdbutil.Sample{sample{3, 3, nil}},
+					[]tsdbutil.Sample{sample{4, 4, nil}},
 				),
 			),
 		},
 		{
 			name: "two queries, one with NaN samples series",
 			chkQuerierSeries: [][]ChunkSeries{{
-				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, math.NaN()}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, math.NaN(), nil}}),
 			}, {
-				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{1, 1}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{1, 1, nil}}),
 			}},
 			expected: NewMockChunkSeriesSet(
-				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, math.NaN()}}, []tsdbutil.Sample{sample{1, 1}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("foo", "bar"), []tsdbutil.Sample{sample{0, math.NaN(), nil}}, []tsdbutil.Sample{sample{1, 1, nil}}),
 			),
 		},
 	} {
@@ -399,9 +399,9 @@ func TestCompactingChunkSeriesMerger(t *testing.T) {
 		{
 			name: "single series",
 			input: []ChunkSeries{
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}}, []tsdbutil.Sample{sample{3, 3}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}}, []tsdbutil.Sample{sample{3, 3, nil}}),
 			},
-			expected: NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}}, []tsdbutil.Sample{sample{3, 3}}),
+			expected: NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}}, []tsdbutil.Sample{sample{3, 3, nil}}),
 		},
 		{
 			name: "two empty series",
@@ -414,55 +414,55 @@ func TestCompactingChunkSeriesMerger(t *testing.T) {
 		{
 			name: "two non overlapping",
 			input: []ChunkSeries{
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}}, []tsdbutil.Sample{sample{3, 3}, sample{5, 5}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{7, 7}, sample{9, 9}}, []tsdbutil.Sample{sample{10, 10}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}}, []tsdbutil.Sample{sample{3, 3, nil}, sample{5, 5, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{7, 7, nil}, sample{9, 9, nil}}, []tsdbutil.Sample{sample{10, 10, nil}}),
 			},
-			expected: NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}}, []tsdbutil.Sample{sample{3, 3}, sample{5, 5}}, []tsdbutil.Sample{sample{7, 7}, sample{9, 9}}, []tsdbutil.Sample{sample{10, 10}}),
+			expected: NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}}, []tsdbutil.Sample{sample{3, 3, nil}, sample{5, 5, nil}}, []tsdbutil.Sample{sample{7, 7, nil}, sample{9, 9, nil}}, []tsdbutil.Sample{sample{10, 10, nil}}),
 		},
 		{
 			name: "two overlapping",
 			input: []ChunkSeries{
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}}, []tsdbutil.Sample{sample{3, 3}, sample{8, 8}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{7, 7}, sample{9, 9}}, []tsdbutil.Sample{sample{10, 10}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}}, []tsdbutil.Sample{sample{3, 3, nil}, sample{8, 8, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{7, 7, nil}, sample{9, 9, nil}}, []tsdbutil.Sample{sample{10, 10, nil}}),
 			},
-			expected: NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}}, []tsdbutil.Sample{sample{3, 3}, sample{7, 7}, sample{8, 8}, sample{9, 9}}, []tsdbutil.Sample{sample{10, 10}}),
+			expected: NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}}, []tsdbutil.Sample{sample{3, 3, nil}, sample{7, 7, nil}, sample{8, 8, nil}, sample{9, 9, nil}}, []tsdbutil.Sample{sample{10, 10, nil}}),
 		},
 		{
 			name: "two duplicated",
 			input: []ChunkSeries{
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{5, 5}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{2, 2}, sample{3, 3}, sample{5, 5}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{5, 5, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{2, 2, nil}, sample{3, 3, nil}, sample{5, 5, nil}}),
 			},
-			expected: NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{5, 5}}),
+			expected: NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{5, 5, nil}}),
 		},
 		{
 			name: "three overlapping",
 			input: []ChunkSeries{
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{5, 5}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{2, 2}, sample{3, 3}, sample{6, 6}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{0, 0}, sample{4, 4}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{5, 5, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{2, 2, nil}, sample{3, 3, nil}, sample{6, 6, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{0, 0, nil}, sample{4, 4, nil}}),
 			},
-			expected: NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{0, 0}, sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{4, 4}, sample{5, 5}, sample{6, 6}}),
+			expected: NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{4, 4, nil}, sample{5, 5, nil}, sample{6, 6, nil}}),
 		},
 		{
 			name: "three in chained overlap",
 			input: []ChunkSeries{
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{5, 5}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{4, 4}, sample{6, 66}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{6, 6}, sample{10, 10}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{5, 5, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{4, 4, nil}, sample{6, 66, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{6, 6, nil}, sample{10, 10, nil}}),
 			},
-			expected: NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{4, 4}, sample{5, 5}, sample{6, 66}, sample{10, 10}}),
+			expected: NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{4, 4, nil}, sample{5, 5, nil}, sample{6, 66, nil}, sample{10, 10, nil}}),
 		},
 		{
 			name: "three in chained overlap complex",
 			input: []ChunkSeries{
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{0, 0}, sample{5, 5}}, []tsdbutil.Sample{sample{10, 10}, sample{15, 15}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{2, 2}, sample{20, 20}}, []tsdbutil.Sample{sample{25, 25}, sample{30, 30}}),
-				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{18, 18}, sample{26, 26}}, []tsdbutil.Sample{sample{31, 31}, sample{35, 35}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{0, 0, nil}, sample{5, 5, nil}}, []tsdbutil.Sample{sample{10, 10, nil}, sample{15, 15, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{2, 2, nil}, sample{20, 20, nil}}, []tsdbutil.Sample{sample{25, 25, nil}, sample{30, 30, nil}}),
+				NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"), []tsdbutil.Sample{sample{18, 18, nil}, sample{26, 26, nil}}, []tsdbutil.Sample{sample{31, 31, nil}, sample{35, 35, nil}}),
 			},
 			expected: NewListChunkSeriesFromSamples(labels.FromStrings("bar", "baz"),
-				[]tsdbutil.Sample{sample{0, 0}, sample{2, 2}, sample{5, 5}, sample{10, 10}, sample{15, 15}, sample{18, 18}, sample{20, 20}, sample{25, 25}, sample{26, 26}, sample{30, 30}},
-				[]tsdbutil.Sample{sample{31, 31}, sample{35, 35}},
+				[]tsdbutil.Sample{sample{0, 0, nil}, sample{2, 2, nil}, sample{5, 5, nil}, sample{10, 10, nil}, sample{15, 15, nil}, sample{18, 18, nil}, sample{20, 20, nil}, sample{25, 25, nil}, sample{26, 26, nil}, sample{30, 30, nil}},
+				[]tsdbutil.Sample{sample{31, 31, nil}, sample{35, 35, nil}},
 			),
 		},
 		{
@@ -598,37 +598,37 @@ func TestChainSampleIterator(t *testing.T) {
 	}{
 		{
 			input: []chunkenc.Iterator{
-				NewListSeriesIterator(samples{sample{0, 0}, sample{1, 1}}),
+				NewListSeriesIterator(samples{sample{0, 0, nil}, sample{1, 1, nil}}),
 			},
-			expected: []tsdbutil.Sample{sample{0, 0}, sample{1, 1}},
+			expected: []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}},
 		},
 		{
 			input: []chunkenc.Iterator{
-				NewListSeriesIterator(samples{sample{0, 0}, sample{1, 1}}),
-				NewListSeriesIterator(samples{sample{2, 2}, sample{3, 3}}),
+				NewListSeriesIterator(samples{sample{0, 0, nil}, sample{1, 1, nil}}),
+				NewListSeriesIterator(samples{sample{2, 2, nil}, sample{3, 3, nil}}),
 			},
-			expected: []tsdbutil.Sample{sample{0, 0}, sample{1, 1}, sample{2, 2}, sample{3, 3}},
+			expected: []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}},
 		},
 		{
 			input: []chunkenc.Iterator{
-				NewListSeriesIterator(samples{sample{0, 0}, sample{3, 3}}),
-				NewListSeriesIterator(samples{sample{1, 1}, sample{4, 4}}),
-				NewListSeriesIterator(samples{sample{2, 2}, sample{5, 5}}),
+				NewListSeriesIterator(samples{sample{0, 0, nil}, sample{3, 3, nil}}),
+				NewListSeriesIterator(samples{sample{1, 1, nil}, sample{4, 4, nil}}),
+				NewListSeriesIterator(samples{sample{2, 2, nil}, sample{5, 5, nil}}),
 			},
 			expected: []tsdbutil.Sample{
-				sample{0, 0}, sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{4, 4}, sample{5, 5}},
+				sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{4, 4, nil}, sample{5, 5, nil}},
 		},
 		// Overlap.
 		{
 			input: []chunkenc.Iterator{
-				NewListSeriesIterator(samples{sample{0, 0}, sample{1, 1}}),
-				NewListSeriesIterator(samples{sample{0, 0}, sample{2, 2}}),
-				NewListSeriesIterator(samples{sample{2, 2}, sample{3, 3}}),
+				NewListSeriesIterator(samples{sample{0, 0, nil}, sample{1, 1, nil}}),
+				NewListSeriesIterator(samples{sample{0, 0, nil}, sample{2, 2, nil}}),
+				NewListSeriesIterator(samples{sample{2, 2, nil}, sample{3, 3, nil}}),
 				NewListSeriesIterator(samples{}),
 				NewListSeriesIterator(samples{}),
 				NewListSeriesIterator(samples{}),
 			},
-			expected: []tsdbutil.Sample{sample{0, 0}, sample{1, 1}, sample{2, 2}, sample{3, 3}},
+			expected: []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}},
 		},
 	} {
 		merged := NewChainSampleIterator(tc.input)
@@ -646,42 +646,42 @@ func TestChainSampleIteratorSeek(t *testing.T) {
 	}{
 		{
 			input: []chunkenc.Iterator{
-				NewListSeriesIterator(samples{sample{0, 0}, sample{1, 1}, sample{2, 2}}),
+				NewListSeriesIterator(samples{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}}),
 			},
 			seek:     1,
-			expected: []tsdbutil.Sample{sample{1, 1}, sample{2, 2}},
+			expected: []tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}},
 		},
 		{
 			input: []chunkenc.Iterator{
-				NewListSeriesIterator(samples{sample{0, 0}, sample{1, 1}}),
-				NewListSeriesIterator(samples{sample{2, 2}, sample{3, 3}}),
+				NewListSeriesIterator(samples{sample{0, 0, nil}, sample{1, 1, nil}}),
+				NewListSeriesIterator(samples{sample{2, 2, nil}, sample{3, 3, nil}}),
 			},
 			seek:     2,
-			expected: []tsdbutil.Sample{sample{2, 2}, sample{3, 3}},
+			expected: []tsdbutil.Sample{sample{2, 2, nil}, sample{3, 3, nil}},
 		},
 		{
 			input: []chunkenc.Iterator{
-				NewListSeriesIterator(samples{sample{0, 0}, sample{3, 3}}),
-				NewListSeriesIterator(samples{sample{1, 1}, sample{4, 4}}),
-				NewListSeriesIterator(samples{sample{2, 2}, sample{5, 5}}),
+				NewListSeriesIterator(samples{sample{0, 0, nil}, sample{3, 3, nil}}),
+				NewListSeriesIterator(samples{sample{1, 1, nil}, sample{4, 4, nil}}),
+				NewListSeriesIterator(samples{sample{2, 2, nil}, sample{5, 5, nil}}),
 			},
 			seek:     2,
-			expected: []tsdbutil.Sample{sample{2, 2}, sample{3, 3}, sample{4, 4}, sample{5, 5}},
+			expected: []tsdbutil.Sample{sample{2, 2, nil}, sample{3, 3, nil}, sample{4, 4, nil}, sample{5, 5, nil}},
 		},
 		{
 			input: []chunkenc.Iterator{
-				NewListSeriesIterator(samples{sample{0, 0}, sample{2, 2}, sample{3, 3}}),
-				NewListSeriesIterator(samples{sample{0, 0}, sample{1, 1}, sample{2, 2}}),
+				NewListSeriesIterator(samples{sample{0, 0, nil}, sample{2, 2, nil}, sample{3, 3, nil}}),
+				NewListSeriesIterator(samples{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}}),
 			},
 			seek:     0,
-			expected: []tsdbutil.Sample{sample{0, 0}, sample{1, 1}, sample{2, 2}, sample{3, 3}},
+			expected: []tsdbutil.Sample{sample{0, 0, nil}, sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}},
 		},
 	} {
 		merged := NewChainSampleIterator(tc.input)
 		actual := []tsdbutil.Sample{}
 		if merged.Seek(tc.seek) {
 			t, v := merged.At()
-			actual = append(actual, sample{t, v})
+			actual = append(actual, sample{t, v, nil})
 		}
 		s, err := ExpandSamples(merged, nil)
 		require.NoError(t, err)
diff --git a/storage/remote/codec.go b/storage/remote/codec.go
index 9e414ad83..666e847f8 100644
--- a/storage/remote/codec.go
+++ b/storage/remote/codec.go
@@ -370,11 +370,11 @@ func (c *concreteSeriesIterator) At() (t int64, v float64) {
 	return s.Timestamp, s.Value
 }
 
-// AtHistogram always returns (0, histogram.Histogram{}) because there is no
-// support for histogram values yet.
+// AtHistogram always returns (0, nil) because there is no support for histogram
+// values yet.
 // TODO(beorn7): Fix that for histogram support in remote storage.
-func (c *concreteSeriesIterator) AtHistogram() (int64, histogram.Histogram) {
-	return 0, histogram.Histogram{}
+func (c *concreteSeriesIterator) AtHistogram() (int64, *histogram.Histogram) {
+	return 0, nil
 }
 
 func (c *concreteSeriesIterator) ChunkEncoding() chunkenc.Encoding {
diff --git a/storage/remote/write.go b/storage/remote/write.go
index 69fe36361..c47bc0e98 100644
--- a/storage/remote/write.go
+++ b/storage/remote/write.go
@@ -241,7 +241,7 @@ func (t *timestampTracker) AppendExemplar(_ uint64, _ labels.Labels, _ exemplar.
 	return 0, nil
 }
 
-func (t *timestampTracker) AppendHistogram(_ uint64, _ labels.Labels, ts int64, _ histogram.Histogram) (uint64, error) {
+func (t *timestampTracker) AppendHistogram(_ uint64, _ labels.Labels, ts int64, _ *histogram.Histogram) (uint64, error) {
 	t.histograms++
 	if ts > t.highestTimestamp {
 		t.highestTimestamp = ts
diff --git a/storage/remote/write_handler_test.go b/storage/remote/write_handler_test.go
index 72603f297..2d91d4f41 100644
--- a/storage/remote/write_handler_test.go
+++ b/storage/remote/write_handler_test.go
@@ -188,7 +188,7 @@ func (m *mockAppendable) AppendExemplar(_ uint64, l labels.Labels, e exemplar.Ex
 	return 0, nil
 }
 
-func (*mockAppendable) AppendHistogram(ref uint64, l labels.Labels, t int64, h histogram.Histogram) (uint64, error) {
+func (*mockAppendable) AppendHistogram(ref uint64, l labels.Labels, t int64, h *histogram.Histogram) (uint64, error) {
 	// TODO(beorn7): Noop until we implement sparse histograms over remote write.
 	return 0, nil
 }
diff --git a/storage/series.go b/storage/series.go
index 6e5b178df..cd3531efb 100644
--- a/storage/series.go
+++ b/storage/series.go
@@ -91,9 +91,9 @@ func (it *listSeriesIterator) At() (int64, float64) {
 	return s.T(), s.V()
 }
 
-func (it *listSeriesIterator) AtHistogram() (int64, histogram.Histogram) {
+func (it *listSeriesIterator) AtHistogram() (int64, *histogram.Histogram) {
 	s := it.samples.Get(it.idx)
-	return s.T(), *s.H()
+	return s.T(), s.H()
 }
 
 func (it *listSeriesIterator) ChunkEncoding() chunkenc.Encoding {
@@ -302,13 +302,12 @@ func ExpandSamples(iter chunkenc.Iterator, newSampleFn func(t int64, v float64,
 	}
 
 	var result []tsdbutil.Sample
-	if iter.ChunkEncoding() == chunkenc.EncHistogram {
-		for iter.Next() {
+	for iter.Next() {
+		// Only after Next() returned true, it is safe to ask for the ChunkEncoding.
+		if iter.ChunkEncoding() == chunkenc.EncHistogram {
 			t, h := iter.AtHistogram()
-			result = append(result, newSampleFn(t, 0, &h))
-		}
-	} else {
-		for iter.Next() {
+			result = append(result, newSampleFn(t, 0, h))
+		} else {
 			t, v := iter.At()
 			// NaNs can't be compared normally, so substitute for another value.
 			if math.IsNaN(v) {
diff --git a/tsdb/block_test.go b/tsdb/block_test.go
index 54cfbc2c4..31ba76ea6 100644
--- a/tsdb/block_test.go
+++ b/tsdb/block_test.go
@@ -179,7 +179,7 @@ func TestCorruptedChunk(t *testing.T) {
 				require.NoError(t, os.RemoveAll(tmpdir))
 			}()
 
-			series := storage.NewListSeries(labels.FromStrings("a", "b"), []tsdbutil.Sample{sample{1, 1}})
+			series := storage.NewListSeries(labels.FromStrings("a", "b"), []tsdbutil.Sample{sample{1, 1, nil}})
 			blockDir := createBlock(t, tmpdir, []storage.Series{series})
 			files, err := sequenceFiles(chunkDir(blockDir))
 			require.NoError(t, err)
@@ -226,7 +226,7 @@ func TestLabelValuesWithMatchers(t *testing.T) {
 		seriesEntries = append(seriesEntries, storage.NewListSeries(labels.Labels{
 			{Name: "unique", Value: fmt.Sprintf("value%d", i)},
 			{Name: "tens", Value: fmt.Sprintf("value%d", i/10)},
-		}, []tsdbutil.Sample{sample{100, 0}}))
+		}, []tsdbutil.Sample{sample{100, 0, nil}}))
 	}
 
 	blockDir := createBlock(t, tmpdir, seriesEntries)
@@ -389,7 +389,7 @@ func BenchmarkLabelValuesWithMatchers(b *testing.B) {
 			{Name: "unique", Value: fmt.Sprintf("value%d", i)},
 			{Name: "tens", Value: fmt.Sprintf("value%d", i/(metricCount/10))},
 			{Name: "ninety", Value: fmt.Sprintf("value%d", i/(metricCount/10)/9)}, // "0" for the first 90%, then "1"
-		}, []tsdbutil.Sample{sample{100, 0}}))
+		}, []tsdbutil.Sample{sample{100, 0, nil}}))
 	}
 
 	blockDir := createBlock(b, tmpdir, seriesEntries)
@@ -427,13 +427,13 @@ func TestLabelNamesWithMatchers(t *testing.T) {
 	for i := 0; i < 100; i++ {
 		seriesEntries = append(seriesEntries, storage.NewListSeries(labels.Labels{
 			{Name: "unique", Value: fmt.Sprintf("value%d", i)},
-		}, []tsdbutil.Sample{sample{100, 0}}))
+		}, []tsdbutil.Sample{sample{100, 0, nil}}))
 
 		if i%10 == 0 {
 			seriesEntries = append(seriesEntries, storage.NewListSeries(labels.Labels{
 				{Name: "unique", Value: fmt.Sprintf("value%d", i)},
 				{Name: "tens", Value: fmt.Sprintf("value%d", i/10)},
-			}, []tsdbutil.Sample{sample{100, 0}}))
+			}, []tsdbutil.Sample{sample{100, 0, nil}}))
 		}
 
 		if i%20 == 0 {
@@ -441,7 +441,7 @@ func TestLabelNamesWithMatchers(t *testing.T) {
 				{Name: "unique", Value: fmt.Sprintf("value%d", i)},
 				{Name: "tens", Value: fmt.Sprintf("value%d", i/10)},
 				{Name: "twenties", Value: fmt.Sprintf("value%d", i/20)},
-			}, []tsdbutil.Sample{sample{100, 0}}))
+			}, []tsdbutil.Sample{sample{100, 0, nil}}))
 		}
 
 	}
diff --git a/tsdb/chunkenc/chunk.go b/tsdb/chunkenc/chunk.go
index 8069b0ecd..5fe8c08f7 100644
--- a/tsdb/chunkenc/chunk.go
+++ b/tsdb/chunkenc/chunk.go
@@ -82,7 +82,7 @@ type Chunk interface {
 // Appender adds sample pairs to a chunk.
 type Appender interface {
 	Append(int64, float64)
-	AppendHistogram(t int64, h histogram.Histogram)
+	AppendHistogram(t int64, h *histogram.Histogram)
 }
 
 // Iterator is a simple iterator that can only get the next value.
@@ -102,8 +102,7 @@ type Iterator interface {
 	At() (int64, float64)
 	// AtHistogram returns the current timestamp/histogram pair.
 	// Before the iterator has advanced AtHistogram behaviour is unspecified.
-	// TODO(beorn7): Maybe return *histogram.Histogram? It's a fairly large struct.
-	AtHistogram() (int64, histogram.Histogram)
+	AtHistogram() (int64, *histogram.Histogram)
 	// Err returns the current error. It should be used only after iterator is
 	// exhausted, that is `Next` or `Seek` returns false.
 	Err() error
@@ -120,8 +119,8 @@ type nopIterator struct{}
 
 func (nopIterator) Seek(int64) bool      { return false }
 func (nopIterator) At() (int64, float64) { return math.MinInt64, 0 }
-func (nopIterator) AtHistogram() (int64, histogram.Histogram) {
-	return math.MinInt64, histogram.Histogram{}
+func (nopIterator) AtHistogram() (int64, *histogram.Histogram) {
+	return math.MinInt64, nil
 }
 func (nopIterator) Next() bool              { return false }
 func (nopIterator) Err() error              { return nil }
diff --git a/tsdb/chunkenc/histogram.go b/tsdb/chunkenc/histogram.go
index cff7d5cc6..c7f94795c 100644
--- a/tsdb/chunkenc/histogram.go
+++ b/tsdb/chunkenc/histogram.go
@@ -245,7 +245,7 @@ func (a *HistogramAppender) Append(int64, float64) {
 // The method returns an additional boolean set to true if it is not appendable
 // because of a counter reset. If the given sample is stale, it is always ok to
 // append. If counterReset is true, okToAppend is always false.
-func (a *HistogramAppender) Appendable(h histogram.Histogram) (
+func (a *HistogramAppender) Appendable(h *histogram.Histogram) (
 	positiveInterjections, negativeInterjections []Interjection,
 	okToAppend bool, counterReset bool,
 ) {
@@ -369,14 +369,14 @@ func counterResetInAnyBucket(oldBuckets, newBuckets []int64, oldSpans, newSpans
 // the histogram is properly structured, e.g. the number of buckets used
 // corresponds to the number conveyed by the span structures. First call
 // Appendable() and act accordingly!
-func (a *HistogramAppender) AppendHistogram(t int64, h histogram.Histogram) {
+func (a *HistogramAppender) AppendHistogram(t int64, h *histogram.Histogram) {
 	var tDelta, cntDelta, zCntDelta int64
 	num := binary.BigEndian.Uint16(a.b.bytes())
 
 	if value.IsStaleNaN(h.Sum) {
 		// Emptying out other fields to write no buckets, and an empty
 		// layout in case of first histogram in the chunk.
-		h = histogram.Histogram{Sum: h.Sum}
+		h = &histogram.Histogram{Sum: h.Sum}
 	}
 
 	switch num {
@@ -401,7 +401,7 @@ func (a *HistogramAppender) AppendHistogram(t int64, h histogram.Histogram) {
 		// Now store the actual data.
 		putVarbitInt(a.b, t)
 		putVarbitUint(a.b, h.Count)
-		putVarbitUint(a.b, h.ZeroCount) //
+		putVarbitUint(a.b, h.ZeroCount)
 		a.b.writeBits(math.Float64bits(h.Sum), 64)
 		for _, b := range h.PositiveBuckets {
 			putVarbitInt(a.b, b)
@@ -582,11 +582,11 @@ func (it *histogramIterator) ChunkEncoding() Encoding {
 	return EncHistogram
 }
 
-func (it *histogramIterator) AtHistogram() (int64, histogram.Histogram) {
+func (it *histogramIterator) AtHistogram() (int64, *histogram.Histogram) {
 	if value.IsStaleNaN(it.sum) {
-		return it.t, histogram.Histogram{Sum: it.sum}
+		return it.t, &histogram.Histogram{Sum: it.sum}
 	}
-	return it.t, histogram.Histogram{
+	return it.t, &histogram.Histogram{
 		Count:           it.cnt,
 		ZeroCount:       it.zCnt,
 		Sum:             it.sum,
diff --git a/tsdb/chunkenc/histogram_test.go b/tsdb/chunkenc/histogram_test.go
index ca5ea7239..e4a9cbe64 100644
--- a/tsdb/chunkenc/histogram_test.go
+++ b/tsdb/chunkenc/histogram_test.go
@@ -30,7 +30,7 @@ func TestHistogramChunkSameBuckets(t *testing.T) {
 	require.Equal(t, 0, c.NumSamples())
 
 	ts := int64(1234567890)
-	h := histogram.Histogram{
+	h := &histogram.Histogram{
 		Count:         5,
 		ZeroCount:     2,
 		Sum:           18.4,
@@ -48,6 +48,7 @@ func TestHistogramChunkSameBuckets(t *testing.T) {
 
 	// Add an updated histogram.
 	ts += 16
+	h = h.Copy()
 	h.Count += 9
 	h.ZeroCount++
 	h.Sum = 24.4
@@ -61,6 +62,7 @@ func TestHistogramChunkSameBuckets(t *testing.T) {
 	require.NoError(t, err)
 
 	ts += 14
+	h = h.Copy()
 	h.Count += 13
 	h.ZeroCount += 2
 	h.Sum = 24.4
@@ -113,7 +115,7 @@ func TestHistogramChunkSameBuckets(t *testing.T) {
 
 type res struct {
 	t int64
-	h histogram.Histogram
+	h *histogram.Histogram
 }
 
 // Mimics the scenario described for compareSpans().
@@ -126,7 +128,7 @@ func TestHistogramChunkBucketChanges(t *testing.T) {
 	require.Equal(t, 0, c.NumSamples())
 
 	ts1 := int64(1234567890)
-	h1 := histogram.Histogram{
+	h1 := &histogram.Histogram{
 		Count:         5,
 		ZeroCount:     2,
 		Sum:           18.4,
@@ -147,7 +149,7 @@ func TestHistogramChunkBucketChanges(t *testing.T) {
 
 	// Add a new histogram that has expanded buckets.
 	ts2 := ts1 + 16
-	h2 := h1
+	h2 := h1.Copy()
 	h2.PositiveSpans = []histogram.Span{
 		{Offset: 0, Length: 3},
 		{Offset: 1, Length: 1},
@@ -202,7 +204,7 @@ func TestHistoChunkAppendable(t *testing.T) {
 	require.Equal(t, 0, c.NumSamples())
 
 	ts := int64(1234567890)
-	h1 := histogram.Histogram{
+	h1 := &histogram.Histogram{
 		Count:         5,
 		ZeroCount:     2,
 		Sum:           18.4,
diff --git a/tsdb/chunkenc/xor.go b/tsdb/chunkenc/xor.go
index 9b52ed57a..62cf4396a 100644
--- a/tsdb/chunkenc/xor.go
+++ b/tsdb/chunkenc/xor.go
@@ -150,7 +150,7 @@ type xorAppender struct {
 	trailing uint8
 }
 
-func (a *xorAppender) AppendHistogram(t int64, h histogram.Histogram) {
+func (a *xorAppender) AppendHistogram(t int64, h *histogram.Histogram) {
 	panic("appended a histogram to an xor chunk")
 }
 
@@ -253,8 +253,8 @@ func (it *xorIterator) At() (int64, float64) {
 	return it.t, it.val
 }
 
-func (it *xorIterator) AtHistogram() (int64, histogram.Histogram) {
-	panic("cannot call xorIterator.AtHistogram().")
+func (it *xorIterator) AtHistogram() (int64, *histogram.Histogram) {
+	panic("cannot call xorIterator.AtHistogram")
 }
 
 func (it *xorIterator) ChunkEncoding() Encoding {
diff --git a/tsdb/compact_test.go b/tsdb/compact_test.go
index b0df493f7..dd9e426a5 100644
--- a/tsdb/compact_test.go
+++ b/tsdb/compact_test.go
@@ -1326,20 +1326,20 @@ func TestHeadCompactionWithHistograms(t *testing.T) {
 	require.NoError(t, head.Init(0))
 	app := head.Appender(context.Background())
 
-	type timedHist struct {
+	type timedHistogram struct {
 		t int64
-		h histogram.Histogram
+		h *histogram.Histogram
 	}
 
 	// Ingest samples.
 	numHistograms := 120 * 4
 	timeStep := DefaultBlockDuration / int64(numHistograms)
-	expHists := make([]timedHist, 0, numHistograms)
+	expHists := make([]timedHistogram, 0, numHistograms)
 	l := labels.Labels{{Name: "a", Value: "b"}}
 	for i, h := range GenerateTestHistograms(numHistograms) {
 		_, err := app.AppendHistogram(0, l, int64(i)*timeStep, h)
 		require.NoError(t, err)
-		expHists = append(expHists, timedHist{int64(i) * timeStep, h})
+		expHists = append(expHists, timedHistogram{int64(i) * timeStep, h})
 	}
 	require.NoError(t, app.Commit())
 
@@ -1372,10 +1372,10 @@ func TestHeadCompactionWithHistograms(t *testing.T) {
 	require.False(t, ss.Next())
 
 	it := s.Iterator()
-	actHists := make([]timedHist, 0, len(expHists))
+	actHists := make([]timedHistogram, 0, len(expHists))
 	for it.Next() {
 		t, h := it.AtHistogram()
-		actHists = append(actHists, timedHist{t, h.Copy()})
+		actHists = append(actHists, timedHistogram{t, h.Copy()})
 	}
 
 	require.Equal(t, expHists, actHists)
@@ -1455,7 +1455,7 @@ func TestSparseHistogramSpaceSavings(t *testing.T) {
 
 				var allSparseSeries []struct {
 					baseLabels labels.Labels
-					hists      []histogram.Histogram
+					hists      []*histogram.Histogram
 				}
 
 				for sid, schema := range allSchemas {
@@ -1467,7 +1467,7 @@ func TestSparseHistogramSpaceSavings(t *testing.T) {
 						}
 						allSparseSeries = append(allSparseSeries, struct {
 							baseLabels labels.Labels
-							hists      []histogram.Histogram
+							hists      []*histogram.Histogram
 						}{baseLabels: lbls, hists: generateCustomHistograms(numHistograms, c.numBuckets, c.numSpans, c.gapBetweenSpans, schema)})
 					}
 				}
@@ -1613,9 +1613,9 @@ Savings: Index=%.2f%%, Chunks=%.2f%%, Total=%.2f%%
 	}
 }
 
-func generateCustomHistograms(numHists, numBuckets, numSpans, gapBetweenSpans, schema int) (r []histogram.Histogram) {
+func generateCustomHistograms(numHists, numBuckets, numSpans, gapBetweenSpans, schema int) (r []*histogram.Histogram) {
 	// First histogram with all the settings.
-	h := histogram.Histogram{
+	h := &histogram.Histogram{
 		Sum:    1000 * rand.Float64(),
 		Schema: int32(schema),
 	}
@@ -1708,11 +1708,11 @@ func TestSparseHistogramCompactionAndQuery(t *testing.T) {
 	})
 	db.DisableCompactions()
 
-	type timedHist struct {
+	type timedHistogram struct {
 		t int64
-		h histogram.Histogram
+		h *histogram.Histogram
 	}
-	expHists := make(map[string][]timedHist)
+	expHists := make(map[string][]timedHistogram)
 
 	series1Histograms := GenerateTestHistograms(20)
 	series2Histograms := GenerateTestHistograms(20)
@@ -1728,8 +1728,8 @@ func TestSparseHistogramCompactionAndQuery(t *testing.T) {
 		require.NoError(t, err)
 
 		l1, l2 := lbls1.String(), lbls2.String()
-		expHists[l1] = append(expHists[l1], timedHist{t: ts, h: series1Histograms[idx1]})
-		expHists[l2] = append(expHists[l2], timedHist{t: ts, h: series2Histograms[idx2]})
+		expHists[l1] = append(expHists[l1], timedHistogram{t: ts, h: series1Histograms[idx1]})
+		expHists[l2] = append(expHists[l2], timedHistogram{t: ts, h: series2Histograms[idx2]})
 	}
 
 	testQuery := func() {
@@ -1740,13 +1740,13 @@ func TestSparseHistogramCompactionAndQuery(t *testing.T) {
 		}()
 
 		ss := q.Select(false, nil, labels.MustNewMatcher(labels.MatchRegexp, "a", ".*"))
-		actHists := make(map[string][]timedHist)
+		actHists := make(map[string][]timedHistogram)
 		for ss.Next() {
 			s := ss.At()
 			it := s.Iterator()
 			for it.Next() {
 				ts, h := it.AtHistogram()
-				actHists[s.Labels().String()] = append(actHists[s.Labels().String()], timedHist{ts, h.Copy()})
+				actHists[s.Labels().String()] = append(actHists[s.Labels().String()], timedHistogram{ts, h.Copy()})
 			}
 			require.NoError(t, it.Err())
 		}
diff --git a/tsdb/db_test.go b/tsdb/db_test.go
index 26ead3fc3..baa8dd4ea 100644
--- a/tsdb/db_test.go
+++ b/tsdb/db_test.go
@@ -420,7 +420,7 @@ Outer:
 
 		expSamples := make([]tsdbutil.Sample, 0, len(c.remaint))
 		for _, ts := range c.remaint {
-			expSamples = append(expSamples, sample{ts, smpls[ts]})
+			expSamples = append(expSamples, sample{ts, smpls[ts], nil})
 		}
 
 		expss := newMockSeriesSet([]storage.Series{
@@ -536,7 +536,7 @@ func TestSkippingInvalidValuesInSameTxn(t *testing.T) {
 	ssMap := query(t, q, labels.MustNewMatcher(labels.MatchEqual, "a", "b"))
 
 	require.Equal(t, map[string][]tsdbutil.Sample{
-		labels.New(labels.Label{Name: "a", Value: "b"}).String(): {sample{0, 1}},
+		labels.New(labels.Label{Name: "a", Value: "b"}).String(): {sample{0, 1, nil}},
 	}, ssMap)
 
 	// Append Out of Order Value.
@@ -553,7 +553,7 @@ func TestSkippingInvalidValuesInSameTxn(t *testing.T) {
 	ssMap = query(t, q, labels.MustNewMatcher(labels.MatchEqual, "a", "b"))
 
 	require.Equal(t, map[string][]tsdbutil.Sample{
-		labels.New(labels.Label{Name: "a", Value: "b"}).String(): {sample{0, 1}, sample{10, 3}},
+		labels.New(labels.Label{Name: "a", Value: "b"}).String(): {sample{0, 1, nil}, sample{10, 3, nil}},
 	}, ssMap)
 }
 
@@ -716,7 +716,7 @@ Outer:
 
 		expSamples := make([]tsdbutil.Sample, 0, len(c.remaint))
 		for _, ts := range c.remaint {
-			expSamples = append(expSamples, sample{ts, smpls[ts]})
+			expSamples = append(expSamples, sample{ts, smpls[ts], nil})
 		}
 
 		expss := newMockSeriesSet([]storage.Series{
@@ -821,7 +821,7 @@ func TestDB_e2e(t *testing.T) {
 		for i := 0; i < numDatapoints; i++ {
 			v := rand.Float64()
 
-			series = append(series, sample{ts, v})
+			series = append(series, sample{ts, v, nil})
 
 			_, err := app.Append(0, lset, ts, v)
 			require.NoError(t, err)
@@ -1066,7 +1066,7 @@ func TestTombstoneClean(t *testing.T) {
 
 		expSamples := make([]tsdbutil.Sample, 0, len(c.remaint))
 		for _, ts := range c.remaint {
-			expSamples = append(expSamples, sample{ts, smpls[ts]})
+			expSamples = append(expSamples, sample{ts, smpls[ts], nil})
 		}
 
 		expss := newMockSeriesSet([]storage.Series{
@@ -2541,11 +2541,11 @@ func TestDBQueryDoesntSeeAppendsAfterCreation(t *testing.T) {
 // TestChunkWriter_ReadAfterWrite ensures that chunk segment are cut at the set segment size and
 // that the resulted segments includes the expected chunks data.
 func TestChunkWriter_ReadAfterWrite(t *testing.T) {
-	chk1 := tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 1}})
-	chk2 := tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 2}})
-	chk3 := tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 3}})
-	chk4 := tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 4}})
-	chk5 := tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 5}})
+	chk1 := tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 1, nil}})
+	chk2 := tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 2, nil}})
+	chk3 := tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 3, nil}})
+	chk4 := tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 4, nil}})
+	chk5 := tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 5, nil}})
 	chunkSize := len(chk1.Chunk.Bytes()) + chunks.MaxChunkLengthFieldSize + chunks.ChunkEncodingSize + crc32.Size
 
 	tests := []struct {
@@ -2746,11 +2746,11 @@ func TestRangeForTimestamp(t *testing.T) {
 // Regression test for https://github.com/prometheus/prometheus/pull/6514.
 func TestChunkReader_ConcurrentReads(t *testing.T) {
 	chks := []chunks.Meta{
-		tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 1}}),
-		tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 2}}),
-		tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 3}}),
-		tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 4}}),
-		tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 5}}),
+		tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 1, nil}}),
+		tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 2, nil}}),
+		tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 3, nil}}),
+		tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 4, nil}}),
+		tsdbutil.ChunkFromSamples([]tsdbutil.Sample{sample{1, 5, nil}}),
 	}
 
 	tempDir, err := ioutil.TempDir("", "test_chunk_writer")
@@ -2815,7 +2815,7 @@ func TestCompactHead(t *testing.T) {
 		val := rand.Float64()
 		_, err := app.Append(0, labels.FromStrings("a", "b"), int64(i), val)
 		require.NoError(t, err)
-		expSamples = append(expSamples, sample{int64(i), val})
+		expSamples = append(expSamples, sample{int64(i), val, nil})
 	}
 	require.NoError(t, app.Commit())
 
@@ -2842,7 +2842,7 @@ func TestCompactHead(t *testing.T) {
 		series := seriesSet.At().Iterator()
 		for series.Next() {
 			time, val := series.At()
-			actSamples = append(actSamples, sample{int64(time), val})
+			actSamples = append(actSamples, sample{int64(time), val, nil})
 		}
 		require.NoError(t, series.Err())
 	}
diff --git a/tsdb/head.go b/tsdb/head.go
index 93e6d568b..7e95b4bf3 100644
--- a/tsdb/head.go
+++ b/tsdb/head.go
@@ -1490,7 +1490,7 @@ func (s *stripeSeries) getOrSet(hash uint64, lset labels.Labels, createSeries fu
 
 type histogramSample struct {
 	t int64
-	h histogram.Histogram
+	h *histogram.Histogram
 }
 
 type sample struct {
@@ -1499,10 +1499,11 @@ type sample struct {
 	h *histogram.Histogram
 }
 
-func newSample(t int64, v float64) tsdbutil.Sample { return sample{t, v, nil} }
-func (s sample) T() int64                          { return s.t }
-func (s sample) V() float64                        { return s.v }
-func (s sample) H() *histogram.Histogram           { return s.h }
+func newSample(t int64, v float64, h *histogram.Histogram) tsdbutil.Sample { return sample{t, v, h} }
+
+func (s sample) T() int64                { return s.t }
+func (s sample) V() float64              { return s.v }
+func (s sample) H() *histogram.Histogram { return s.h }
 
 // memSeries is the in-memory representation of a series. None of its methods
 // are goroutine safe and it is the caller's responsibility to lock it.
@@ -1661,9 +1662,9 @@ func (h *Head) updateWALReplayStatusRead(current int) {
 	h.stats.WALReplayStatus.Current = current
 }
 
-func GenerateTestHistograms(n int) (r []histogram.Histogram) {
+func GenerateTestHistograms(n int) (r []*histogram.Histogram) {
 	for i := 0; i < n; i++ {
-		r = append(r, histogram.Histogram{
+		r = append(r, &histogram.Histogram{
 			Count:         5 + uint64(i*4),
 			ZeroCount:     2 + uint64(i),
 			ZeroThreshold: 0.001,
diff --git a/tsdb/head_append.go b/tsdb/head_append.go
index 6ff989f5e..14a7db77d 100644
--- a/tsdb/head_append.go
+++ b/tsdb/head_append.go
@@ -67,7 +67,7 @@ func (a *initAppender) AppendExemplar(ref uint64, l labels.Labels, e exemplar.Ex
 	return a.app.AppendExemplar(ref, l, e)
 }
 
-func (a *initAppender) AppendHistogram(ref uint64, l labels.Labels, t int64, h histogram.Histogram) (uint64, error) {
+func (a *initAppender) AppendHistogram(ref uint64, l labels.Labels, t int64, h *histogram.Histogram) (uint64, error) {
 	if a.app != nil {
 		return a.app.AppendHistogram(ref, l, t, h)
 	}
@@ -270,7 +270,7 @@ func (a *headAppender) Append(ref uint64, lset labels.Labels, t int64, v float64
 	}
 
 	if value.IsStaleNaN(v) && s.histogramSeries {
-		return a.AppendHistogram(ref, lset, t, histogram.Histogram{Sum: v})
+		return a.AppendHistogram(ref, lset, t, &histogram.Histogram{Sum: v})
 	}
 
 	s.Lock()
@@ -322,7 +322,7 @@ func (s *memSeries) appendable(t int64, v float64) error {
 }
 
 // appendableHistogram checks whether the given sample is valid for appending to the series.
-func (s *memSeries) appendableHistogram(t int64, sh histogram.Histogram) error {
+func (s *memSeries) appendableHistogram(t int64, h *histogram.Histogram) error {
 	c := s.head()
 	if c == nil {
 		return nil
@@ -334,7 +334,7 @@ func (s *memSeries) appendableHistogram(t int64, sh histogram.Histogram) error {
 	if t < c.maxTime {
 		return storage.ErrOutOfOrderSample
 	}
-	// TODO: do it for histogram.
+	// TODO(beorn7): do it for histogram.
 	// We are allowing exact duplicates as we can encounter them in valid cases
 	// like federation and erroring out at that time would be extremely noisy.
 	//if math.Float64bits(s.sampleBuf[3].v) != math.Float64bits(v) {
@@ -372,7 +372,7 @@ func (a *headAppender) AppendExemplar(ref uint64, _ labels.Labels, e exemplar.Ex
 	return s.ref, nil
 }
 
-func (a *headAppender) AppendHistogram(ref uint64, lset labels.Labels, t int64, h histogram.Histogram) (uint64, error) {
+func (a *headAppender) AppendHistogram(ref uint64, lset labels.Labels, t int64, h *histogram.Histogram) (uint64, error) {
 	if t < a.minValidTime {
 		a.head.metrics.outOfBoundSamples.Inc()
 		return 0, storage.ErrOutOfBounds
@@ -606,7 +606,7 @@ func (s *memSeries) append(t int64, v float64, appendID uint64, chunkDiskMapper
 
 // appendHistogram adds the histogram.
 // It is unsafe to call this concurrently with s.iterator(...) without holding the series lock.
-func (s *memSeries) appendHistogram(t int64, h histogram.Histogram, appendID uint64, chunkDiskMapper *chunks.ChunkDiskMapper) (sampleInOrder, chunkCreated bool) {
+func (s *memSeries) appendHistogram(t int64, h *histogram.Histogram, appendID uint64, chunkDiskMapper *chunks.ChunkDiskMapper) (sampleInOrder, chunkCreated bool) {
 	// Head controls the execution of recoding, so that we own the proper chunk reference afterwards.
 	// We check for Appendable before appendPreprocessor because in case it ends up creating a new chunk,
 	// we need to know if there was also a counter reset or not to set the meta properly.
diff --git a/tsdb/head_read.go b/tsdb/head_read.go
index 7c20c43ad..48a294ade 100644
--- a/tsdb/head_read.go
+++ b/tsdb/head_read.go
@@ -519,7 +519,7 @@ func (it *memSafeIterator) At() (int64, float64) {
 	return s.t, s.v
 }
 
-func (it *memSafeIterator) AtHistogram() (int64, histogram.Histogram) {
+func (it *memSafeIterator) AtHistogram() (int64, *histogram.Histogram) {
 	if it.total-it.i > 4 {
 		return it.Iterator.AtHistogram()
 	}
diff --git a/tsdb/head_test.go b/tsdb/head_test.go
index 7831ad9d8..a8cb10dc4 100644
--- a/tsdb/head_test.go
+++ b/tsdb/head_test.go
@@ -331,11 +331,11 @@ func TestHead_ReadWAL(t *testing.T) {
 				require.NoError(t, c.Err())
 				return x
 			}
-			require.Equal(t, []sample{{100, 2}, {101, 5}}, expandChunk(s10.iterator(0, nil, head.chunkDiskMapper, nil)))
-			require.Equal(t, []sample{{101, 6}}, expandChunk(s50.iterator(0, nil, head.chunkDiskMapper, nil)))
+			require.Equal(t, []sample{{100, 2, nil}, {101, 5, nil}}, expandChunk(s10.iterator(0, nil, head.chunkDiskMapper, nil)))
+			require.Equal(t, []sample{{101, 6, nil}}, expandChunk(s50.iterator(0, nil, head.chunkDiskMapper, nil)))
 			// The samples before the new series record should be discarded since a duplicate record
 			// is only possible when old samples were compacted.
-			require.Equal(t, []sample{{101, 7}}, expandChunk(s100.iterator(0, nil, head.chunkDiskMapper, nil)))
+			require.Equal(t, []sample{{101, 7, nil}}, expandChunk(s100.iterator(0, nil, head.chunkDiskMapper, nil)))
 
 			q, err := head.ExemplarQuerier(context.Background())
 			require.NoError(t, err)
@@ -401,8 +401,8 @@ func TestHead_WALMultiRef(t *testing.T) {
 	// The samples before the new ref should be discarded since Head truncation
 	// happens only after compacting the Head.
 	require.Equal(t, map[string][]tsdbutil.Sample{`{foo="bar"}`: {
-		sample{1700, 3},
-		sample{2000, 4},
+		sample{1700, 3, nil},
+		sample{2000, 4, nil},
 	}}, series)
 }
 
@@ -798,7 +798,7 @@ func TestDeleteUntilCurMax(t *testing.T) {
 	it = exps.Iterator()
 	resSamples, err := storage.ExpandSamples(it, newSample)
 	require.NoError(t, err)
-	require.Equal(t, []tsdbutil.Sample{sample{11, 1}}, resSamples)
+	require.Equal(t, []tsdbutil.Sample{sample{11, 1, nil}}, resSamples)
 	for res.Next() {
 	}
 	require.NoError(t, res.Err())
@@ -913,7 +913,7 @@ func TestDelete_e2e(t *testing.T) {
 			v := rand.Float64()
 			_, err := app.Append(0, ls, ts, v)
 			require.NoError(t, err)
-			series = append(series, sample{ts, v})
+			series = append(series, sample{ts, v, nil})
 			ts += rand.Int63n(timeInterval) + 1
 		}
 		seriesMap[labels.New(l...).String()] = series
@@ -2397,7 +2397,7 @@ func TestDataMissingOnQueryDuringCompaction(t *testing.T) {
 		ref, err = app.Append(ref, labels.FromStrings("a", "b"), ts, float64(i))
 		require.NoError(t, err)
 		maxt = ts
-		expSamples = append(expSamples, sample{ts, float64(i)})
+		expSamples = append(expSamples, sample{ts, float64(i), nil})
 	}
 	require.NoError(t, app.Commit())
 
@@ -2541,7 +2541,7 @@ func TestAppendHistogram(t *testing.T) {
 
 			type timedHistogram struct {
 				t int64
-				h histogram.Histogram
+				h *histogram.Histogram
 			}
 			expHistograms := make([]timedHistogram, 0, numHistograms)
 			for i, h := range GenerateTestHistograms(numHistograms) {
@@ -2588,7 +2588,7 @@ func TestHistogramInWAL(t *testing.T) {
 
 	type timedHistogram struct {
 		t int64
-		h histogram.Histogram
+		h *histogram.Histogram
 	}
 	expHistograms := make([]timedHistogram, 0, numHistograms)
 	for i, h := range GenerateTestHistograms(numHistograms) {
@@ -2728,7 +2728,7 @@ func TestChunkSnapshot(t *testing.T) {
 			// 240 samples should m-map at least 1 chunk.
 			for ts := int64(1); ts <= 240; ts++ {
 				val := rand.Float64()
-				expSeries[lblStr] = append(expSeries[lblStr], sample{ts, val})
+				expSeries[lblStr] = append(expSeries[lblStr], sample{ts, val, nil})
 				ref, err := app.Append(0, lbls, ts, val)
 				require.NoError(t, err)
 
@@ -2788,7 +2788,7 @@ func TestChunkSnapshot(t *testing.T) {
 			// 240 samples should m-map at least 1 chunk.
 			for ts := int64(241); ts <= 480; ts++ {
 				val := rand.Float64()
-				expSeries[lblStr] = append(expSeries[lblStr], sample{ts, val})
+				expSeries[lblStr] = append(expSeries[lblStr], sample{ts, val, nil})
 				ref, err := app.Append(0, lbls, ts, val)
 				require.NoError(t, err)
 
@@ -2977,7 +2977,7 @@ func TestHistogramStaleSample(t *testing.T) {
 
 	type timedHistogram struct {
 		t int64
-		h histogram.Histogram
+		h *histogram.Histogram
 	}
 	expHistograms := make([]timedHistogram, 0, numHistograms)
 
@@ -3011,6 +3011,7 @@ func TestHistogramStaleSample(t *testing.T) {
 				require.True(t, value.IsStaleNaN(ah.h.Sum))
 				// To make require.Equal work.
 				ah.h.Sum = 0
+				eh.h = eh.h.Copy()
 				eh.h.Sum = 0
 			}
 			require.Equal(t, eh, ah)
@@ -3028,7 +3029,7 @@ func TestHistogramStaleSample(t *testing.T) {
 	// +1 so that delta-of-delta is not 0.
 	_, err := app.Append(0, l, 100*int64(len(expHistograms))+1, math.Float64frombits(value.StaleNaN))
 	require.NoError(t, err)
-	expHistograms = append(expHistograms, timedHistogram{100*int64(len(expHistograms)) + 1, histogram.Histogram{Sum: math.Float64frombits(value.StaleNaN)}})
+	expHistograms = append(expHistograms, timedHistogram{100*int64(len(expHistograms)) + 1, &histogram.Histogram{Sum: math.Float64frombits(value.StaleNaN)}})
 	require.NoError(t, app.Commit())
 
 	// Only 1 chunk in the memory, no m-mapped chunk.
@@ -3050,7 +3051,7 @@ func TestHistogramStaleSample(t *testing.T) {
 	// +1 so that delta-of-delta is not 0.
 	_, err = app.Append(0, l, 100*int64(len(expHistograms))+1, math.Float64frombits(value.StaleNaN))
 	require.NoError(t, err)
-	expHistograms = append(expHistograms, timedHistogram{100*int64(len(expHistograms)) + 1, histogram.Histogram{Sum: math.Float64frombits(value.StaleNaN)}})
+	expHistograms = append(expHistograms, timedHistogram{100*int64(len(expHistograms)) + 1, &histogram.Histogram{Sum: math.Float64frombits(value.StaleNaN)}})
 	require.NoError(t, app.Commit())
 
 	// Total 2 chunks, 1 m-mapped.
@@ -3069,7 +3070,7 @@ func TestHistogramCounterResetHeader(t *testing.T) {
 	require.NoError(t, head.Init(0))
 
 	ts := int64(0)
-	appendHistogram := func(h histogram.Histogram) {
+	appendHistogram := func(h *histogram.Histogram) {
 		ts++
 		app := head.Appender(context.Background())
 		_, err := app.AppendHistogram(0, l, ts, h)
diff --git a/tsdb/querier.go b/tsdb/querier.go
index ec6310da5..5739fbdc5 100644
--- a/tsdb/querier.go
+++ b/tsdb/querier.go
@@ -649,9 +649,11 @@ func (p *populateWithDelSeriesIterator) Seek(t int64) bool {
 }
 
 func (p *populateWithDelSeriesIterator) At() (int64, float64) { return p.curr.At() }
-func (p *populateWithDelSeriesIterator) AtHistogram() (int64, histogram.Histogram) {
+
+func (p *populateWithDelSeriesIterator) AtHistogram() (int64, *histogram.Histogram) {
 	return p.curr.AtHistogram()
 }
+
 func (p *populateWithDelSeriesIterator) ChunkEncoding() chunkenc.Encoding {
 	return p.curr.ChunkEncoding()
 }
@@ -714,7 +716,7 @@ func (p *populateWithDelChunkSeriesIterator) Next() bool {
 	var (
 		t int64
 		v float64
-		h histogram.Histogram
+		h *histogram.Histogram
 	)
 	if p.currDelIter.ChunkEncoding() == chunkenc.EncHistogram {
 		if hc, ok := p.currChkMeta.Chunk.(*chunkenc.HistogramChunk); ok {
@@ -870,7 +872,7 @@ func (it *DeletedIterator) At() (int64, float64) {
 	return it.Iter.At()
 }
 
-func (it *DeletedIterator) AtHistogram() (int64, histogram.Histogram) {
+func (it *DeletedIterator) AtHistogram() (int64, *histogram.Histogram) {
 	t, h := it.Iter.AtHistogram()
 	return t, h
 }
diff --git a/tsdb/querier_test.go b/tsdb/querier_test.go
index 514b1f5b9..9ae34e726 100644
--- a/tsdb/querier_test.go
+++ b/tsdb/querier_test.go
@@ -277,24 +277,24 @@ func TestBlockQuerier(t *testing.T) {
 			ms:   []*labels.Matcher{labels.MustNewMatcher(labels.MatchRegexp, "a", ".*")},
 			exp: newMockSeriesSet([]storage.Series{
 				storage.NewListSeries(labels.Labels{{Name: "a", Value: "a"}},
-					[]tsdbutil.Sample{sample{1, 2}, sample{2, 3}, sample{3, 4}, sample{5, 2}, sample{6, 3}, sample{7, 4}},
+					[]tsdbutil.Sample{sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 4, nil}, sample{5, 2, nil}, sample{6, 3, nil}, sample{7, 4, nil}},
 				),
 				storage.NewListSeries(labels.Labels{{Name: "a", Value: "a"}, {Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{5, 3}, sample{6, 6}},
+					[]tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{5, 3, nil}, sample{6, 6, nil}},
 				),
 				storage.NewListSeries(labels.Labels{{Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{1, 3}, sample{2, 2}, sample{3, 6}, sample{5, 1}, sample{6, 7}, sample{7, 2}},
+					[]tsdbutil.Sample{sample{1, 3, nil}, sample{2, 2, nil}, sample{3, 6, nil}, sample{5, 1, nil}, sample{6, 7, nil}, sample{7, 2, nil}},
 				),
 			}),
 			expChks: newMockChunkSeriesSet([]storage.ChunkSeries{
 				storage.NewListChunkSeriesFromSamples(labels.Labels{{Name: "a", Value: "a"}},
-					[]tsdbutil.Sample{sample{1, 2}, sample{2, 3}, sample{3, 4}}, []tsdbutil.Sample{sample{5, 2}, sample{6, 3}, sample{7, 4}},
+					[]tsdbutil.Sample{sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 4, nil}}, []tsdbutil.Sample{sample{5, 2, nil}, sample{6, 3, nil}, sample{7, 4, nil}},
 				),
 				storage.NewListChunkSeriesFromSamples(labels.Labels{{Name: "a", Value: "a"}, {Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}}, []tsdbutil.Sample{sample{5, 3}, sample{6, 6}},
+					[]tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}}, []tsdbutil.Sample{sample{5, 3, nil}, sample{6, 6, nil}},
 				),
 				storage.NewListChunkSeriesFromSamples(labels.Labels{{Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{1, 3}, sample{2, 2}, sample{3, 6}}, []tsdbutil.Sample{sample{5, 1}, sample{6, 7}, sample{7, 2}},
+					[]tsdbutil.Sample{sample{1, 3, nil}, sample{2, 2, nil}, sample{3, 6, nil}}, []tsdbutil.Sample{sample{5, 1, nil}, sample{6, 7, nil}, sample{7, 2, nil}},
 				),
 			}),
 		},
@@ -304,18 +304,18 @@ func TestBlockQuerier(t *testing.T) {
 			ms:   []*labels.Matcher{labels.MustNewMatcher(labels.MatchEqual, "a", "a")},
 			exp: newMockSeriesSet([]storage.Series{
 				storage.NewListSeries(labels.Labels{{Name: "a", Value: "a"}},
-					[]tsdbutil.Sample{sample{2, 3}, sample{3, 4}, sample{5, 2}, sample{6, 3}},
+					[]tsdbutil.Sample{sample{2, 3, nil}, sample{3, 4, nil}, sample{5, 2, nil}, sample{6, 3, nil}},
 				),
 				storage.NewListSeries(labels.Labels{{Name: "a", Value: "a"}, {Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{2, 2}, sample{3, 3}, sample{5, 3}, sample{6, 6}},
+					[]tsdbutil.Sample{sample{2, 2, nil}, sample{3, 3, nil}, sample{5, 3, nil}, sample{6, 6, nil}},
 				),
 			}),
 			expChks: newMockChunkSeriesSet([]storage.ChunkSeries{
 				storage.NewListChunkSeriesFromSamples(labels.Labels{{Name: "a", Value: "a"}},
-					[]tsdbutil.Sample{sample{2, 3}, sample{3, 4}}, []tsdbutil.Sample{sample{5, 2}, sample{6, 3}},
+					[]tsdbutil.Sample{sample{2, 3, nil}, sample{3, 4, nil}}, []tsdbutil.Sample{sample{5, 2, nil}, sample{6, 3, nil}},
 				),
 				storage.NewListChunkSeriesFromSamples(labels.Labels{{Name: "a", Value: "a"}, {Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{2, 2}, sample{3, 3}}, []tsdbutil.Sample{sample{5, 3}, sample{6, 6}},
+					[]tsdbutil.Sample{sample{2, 2, nil}, sample{3, 3, nil}}, []tsdbutil.Sample{sample{5, 3, nil}, sample{6, 6, nil}},
 				),
 			}),
 		},
@@ -363,24 +363,24 @@ func TestBlockQuerier_AgainstHeadWithOpenChunks(t *testing.T) {
 			ms:   []*labels.Matcher{labels.MustNewMatcher(labels.MatchRegexp, "a", ".*")},
 			exp: newMockSeriesSet([]storage.Series{
 				storage.NewListSeries(labels.Labels{{Name: "a", Value: "a"}},
-					[]tsdbutil.Sample{sample{1, 2}, sample{2, 3}, sample{3, 4}, sample{5, 2}, sample{6, 3}, sample{7, 4}},
+					[]tsdbutil.Sample{sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 4, nil}, sample{5, 2, nil}, sample{6, 3, nil}, sample{7, 4, nil}},
 				),
 				storage.NewListSeries(labels.Labels{{Name: "a", Value: "a"}, {Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{5, 3}, sample{6, 6}},
+					[]tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{5, 3, nil}, sample{6, 6, nil}},
 				),
 				storage.NewListSeries(labels.Labels{{Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{1, 3}, sample{2, 2}, sample{3, 6}, sample{5, 1}, sample{6, 7}, sample{7, 2}},
+					[]tsdbutil.Sample{sample{1, 3, nil}, sample{2, 2, nil}, sample{3, 6, nil}, sample{5, 1, nil}, sample{6, 7, nil}, sample{7, 2, nil}},
 				),
 			}),
 			expChks: newMockChunkSeriesSet([]storage.ChunkSeries{
 				storage.NewListChunkSeriesFromSamples(labels.Labels{{Name: "a", Value: "a"}},
-					[]tsdbutil.Sample{sample{1, 2}, sample{2, 3}, sample{3, 4}, sample{5, 2}, sample{6, 3}, sample{7, 4}},
+					[]tsdbutil.Sample{sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 4, nil}, sample{5, 2, nil}, sample{6, 3, nil}, sample{7, 4, nil}},
 				),
 				storage.NewListChunkSeriesFromSamples(labels.Labels{{Name: "a", Value: "a"}, {Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}, sample{5, 3}, sample{6, 6}},
+					[]tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}, sample{5, 3, nil}, sample{6, 6, nil}},
 				),
 				storage.NewListChunkSeriesFromSamples(labels.Labels{{Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{1, 3}, sample{2, 2}, sample{3, 6}, sample{5, 1}, sample{6, 7}, sample{7, 2}},
+					[]tsdbutil.Sample{sample{1, 3, nil}, sample{2, 2, nil}, sample{3, 6, nil}, sample{5, 1, nil}, sample{6, 7, nil}, sample{7, 2, nil}},
 				),
 			}),
 		},
@@ -390,18 +390,18 @@ func TestBlockQuerier_AgainstHeadWithOpenChunks(t *testing.T) {
 			ms:   []*labels.Matcher{labels.MustNewMatcher(labels.MatchEqual, "a", "a")},
 			exp: newMockSeriesSet([]storage.Series{
 				storage.NewListSeries(labels.Labels{{Name: "a", Value: "a"}},
-					[]tsdbutil.Sample{sample{2, 3}, sample{3, 4}, sample{5, 2}, sample{6, 3}},
+					[]tsdbutil.Sample{sample{2, 3, nil}, sample{3, 4, nil}, sample{5, 2, nil}, sample{6, 3, nil}},
 				),
 				storage.NewListSeries(labels.Labels{{Name: "a", Value: "a"}, {Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{2, 2}, sample{3, 3}, sample{5, 3}, sample{6, 6}},
+					[]tsdbutil.Sample{sample{2, 2, nil}, sample{3, 3, nil}, sample{5, 3, nil}, sample{6, 6, nil}},
 				),
 			}),
 			expChks: newMockChunkSeriesSet([]storage.ChunkSeries{
 				storage.NewListChunkSeriesFromSamples(labels.Labels{{Name: "a", Value: "a"}},
-					[]tsdbutil.Sample{sample{2, 3}, sample{3, 4}, sample{5, 2}, sample{6, 3}},
+					[]tsdbutil.Sample{sample{2, 3, nil}, sample{3, 4, nil}, sample{5, 2, nil}, sample{6, 3, nil}},
 				),
 				storage.NewListChunkSeriesFromSamples(labels.Labels{{Name: "a", Value: "a"}, {Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{2, 2}, sample{3, 3}, sample{5, 3}, sample{6, 6}},
+					[]tsdbutil.Sample{sample{2, 2, nil}, sample{3, 3, nil}, sample{5, 3, nil}, sample{6, 6, nil}},
 				),
 			}),
 		},
@@ -442,22 +442,22 @@ var testData = []seriesSamples{
 	{
 		lset: map[string]string{"a": "a"},
 		chunks: [][]sample{
-			{{1, 2}, {2, 3}, {3, 4}},
-			{{5, 2}, {6, 3}, {7, 4}},
+			{{1, 2, nil}, {2, 3, nil}, {3, 4, nil}},
+			{{5, 2, nil}, {6, 3, nil}, {7, 4, nil}},
 		},
 	},
 	{
 		lset: map[string]string{"a": "a", "b": "b"},
 		chunks: [][]sample{
-			{{1, 1}, {2, 2}, {3, 3}},
-			{{5, 3}, {6, 6}},
+			{{1, 1, nil}, {2, 2, nil}, {3, 3, nil}},
+			{{5, 3, nil}, {6, 6, nil}},
 		},
 	},
 	{
 		lset: map[string]string{"b": "b"},
 		chunks: [][]sample{
-			{{1, 3}, {2, 2}, {3, 6}},
-			{{5, 1}, {6, 7}, {7, 2}},
+			{{1, 3, nil}, {2, 2, nil}, {3, 6, nil}},
+			{{5, 1, nil}, {6, 7, nil}, {7, 2, nil}},
 		},
 	},
 }
@@ -504,24 +504,24 @@ func TestBlockQuerierDelete(t *testing.T) {
 			ms:   []*labels.Matcher{labels.MustNewMatcher(labels.MatchRegexp, "a", ".*")},
 			exp: newMockSeriesSet([]storage.Series{
 				storage.NewListSeries(labels.Labels{{Name: "a", Value: "a"}},
-					[]tsdbutil.Sample{sample{5, 2}, sample{6, 3}, sample{7, 4}},
+					[]tsdbutil.Sample{sample{5, 2, nil}, sample{6, 3, nil}, sample{7, 4, nil}},
 				),
 				storage.NewListSeries(labels.Labels{{Name: "a", Value: "a"}, {Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{5, 3}},
+					[]tsdbutil.Sample{sample{5, 3, nil}},
 				),
 				storage.NewListSeries(labels.Labels{{Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{1, 3}, sample{2, 2}, sample{3, 6}, sample{5, 1}},
+					[]tsdbutil.Sample{sample{1, 3, nil}, sample{2, 2, nil}, sample{3, 6, nil}, sample{5, 1, nil}},
 				),
 			}),
 			expChks: newMockChunkSeriesSet([]storage.ChunkSeries{
 				storage.NewListChunkSeriesFromSamples(labels.Labels{{Name: "a", Value: "a"}},
-					[]tsdbutil.Sample{sample{5, 2}, sample{6, 3}, sample{7, 4}},
+					[]tsdbutil.Sample{sample{5, 2, nil}, sample{6, 3, nil}, sample{7, 4, nil}},
 				),
 				storage.NewListChunkSeriesFromSamples(labels.Labels{{Name: "a", Value: "a"}, {Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{5, 3}},
+					[]tsdbutil.Sample{sample{5, 3, nil}},
 				),
 				storage.NewListChunkSeriesFromSamples(labels.Labels{{Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{1, 3}, sample{2, 2}, sample{3, 6}}, []tsdbutil.Sample{sample{5, 1}},
+					[]tsdbutil.Sample{sample{1, 3, nil}, sample{2, 2, nil}, sample{3, 6, nil}}, []tsdbutil.Sample{sample{5, 1, nil}},
 				),
 			}),
 		},
@@ -531,18 +531,18 @@ func TestBlockQuerierDelete(t *testing.T) {
 			ms:   []*labels.Matcher{labels.MustNewMatcher(labels.MatchEqual, "a", "a")},
 			exp: newMockSeriesSet([]storage.Series{
 				storage.NewListSeries(labels.Labels{{Name: "a", Value: "a"}},
-					[]tsdbutil.Sample{sample{5, 2}, sample{6, 3}},
+					[]tsdbutil.Sample{sample{5, 2, nil}, sample{6, 3, nil}},
 				),
 				storage.NewListSeries(labels.Labels{{Name: "a", Value: "a"}, {Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{5, 3}},
+					[]tsdbutil.Sample{sample{5, 3, nil}},
 				),
 			}),
 			expChks: newMockChunkSeriesSet([]storage.ChunkSeries{
 				storage.NewListChunkSeriesFromSamples(labels.Labels{{Name: "a", Value: "a"}},
-					[]tsdbutil.Sample{sample{5, 2}, sample{6, 3}},
+					[]tsdbutil.Sample{sample{5, 2, nil}, sample{6, 3, nil}},
 				),
 				storage.NewListChunkSeriesFromSamples(labels.Labels{{Name: "a", Value: "a"}, {Name: "b", Value: "b"}},
-					[]tsdbutil.Sample{sample{5, 3}},
+					[]tsdbutil.Sample{sample{5, 3, nil}},
 				),
 			}),
 		},
@@ -625,57 +625,57 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) {
 		{
 			name: "one chunk",
 			chks: [][]tsdbutil.Sample{
-				{sample{1, 2}, sample{2, 3}, sample{3, 5}, sample{6, 1}},
+				{sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 5, nil}, sample{6, 1, nil}},
 			},
 
 			expected: []tsdbutil.Sample{
-				sample{1, 2}, sample{2, 3}, sample{3, 5}, sample{6, 1},
+				sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 5, nil}, sample{6, 1, nil},
 			},
 			expectedChks: []chunks.Meta{
 				tsdbutil.ChunkFromSamples([]tsdbutil.Sample{
-					sample{1, 2}, sample{2, 3}, sample{3, 5}, sample{6, 1},
+					sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 5, nil}, sample{6, 1, nil},
 				}),
 			},
 		},
 		{
 			name: "two full chunks",
 			chks: [][]tsdbutil.Sample{
-				{sample{1, 2}, sample{2, 3}, sample{3, 5}, sample{6, 1}},
-				{sample{7, 89}, sample{9, 8}},
+				{sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 5, nil}, sample{6, 1, nil}},
+				{sample{7, 89, nil}, sample{9, 8, nil}},
 			},
 
 			expected: []tsdbutil.Sample{
-				sample{1, 2}, sample{2, 3}, sample{3, 5}, sample{6, 1}, sample{7, 89}, sample{9, 8},
+				sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 5, nil}, sample{6, 1, nil}, sample{7, 89, nil}, sample{9, 8, nil},
 			},
 			expectedChks: []chunks.Meta{
 				tsdbutil.ChunkFromSamples([]tsdbutil.Sample{
-					sample{1, 2}, sample{2, 3}, sample{3, 5}, sample{6, 1},
+					sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 5, nil}, sample{6, 1, nil},
 				}),
 				tsdbutil.ChunkFromSamples([]tsdbutil.Sample{
-					sample{7, 89}, sample{9, 8},
+					sample{7, 89, nil}, sample{9, 8, nil},
 				}),
 			},
 		},
 		{
 			name: "three full chunks",
 			chks: [][]tsdbutil.Sample{
-				{sample{1, 2}, sample{2, 3}, sample{3, 5}, sample{6, 1}},
-				{sample{7, 89}, sample{9, 8}},
-				{sample{10, 22}, sample{203, 3493}},
+				{sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 5, nil}, sample{6, 1, nil}},
+				{sample{7, 89, nil}, sample{9, 8, nil}},
+				{sample{10, 22, nil}, sample{203, 3493, nil}},
 			},
 
 			expected: []tsdbutil.Sample{
-				sample{1, 2}, sample{2, 3}, sample{3, 5}, sample{6, 1}, sample{7, 89}, sample{9, 8}, sample{10, 22}, sample{203, 3493},
+				sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 5, nil}, sample{6, 1, nil}, sample{7, 89, nil}, sample{9, 8, nil}, sample{10, 22, nil}, sample{203, 3493, nil},
 			},
 			expectedChks: []chunks.Meta{
 				tsdbutil.ChunkFromSamples([]tsdbutil.Sample{
-					sample{1, 2}, sample{2, 3}, sample{3, 5}, sample{6, 1},
+					sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 5, nil}, sample{6, 1, nil},
 				}),
 				tsdbutil.ChunkFromSamples([]tsdbutil.Sample{
-					sample{7, 89}, sample{9, 8},
+					sample{7, 89, nil}, sample{9, 8, nil},
 				}),
 				tsdbutil.ChunkFromSamples([]tsdbutil.Sample{
-					sample{10, 22}, sample{203, 3493},
+					sample{10, 22, nil}, sample{203, 3493, nil},
 				}),
 			},
 		},
@@ -690,8 +690,8 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) {
 		{
 			name: "two chunks and seek beyond chunks",
 			chks: [][]tsdbutil.Sample{
-				{sample{1, 2}, sample{3, 5}, sample{6, 1}},
-				{sample{7, 89}, sample{9, 8}},
+				{sample{1, 2, nil}, sample{3, 5, nil}, sample{6, 1, nil}},
+				{sample{7, 89, nil}, sample{9, 8, nil}},
 			},
 			seek: 10,
 
@@ -700,27 +700,27 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) {
 		{
 			name: "two chunks and seek on middle of first chunk",
 			chks: [][]tsdbutil.Sample{
-				{sample{1, 2}, sample{3, 5}, sample{6, 1}},
-				{sample{7, 89}, sample{9, 8}},
+				{sample{1, 2, nil}, sample{3, 5, nil}, sample{6, 1, nil}},
+				{sample{7, 89, nil}, sample{9, 8, nil}},
 			},
 			seek: 2,
 
 			seekSuccess: true,
 			expected: []tsdbutil.Sample{
-				sample{3, 5}, sample{6, 1}, sample{7, 89}, sample{9, 8},
+				sample{3, 5, nil}, sample{6, 1, nil}, sample{7, 89, nil}, sample{9, 8, nil},
 			},
 		},
 		{
 			name: "two chunks and seek before first chunk",
 			chks: [][]tsdbutil.Sample{
-				{sample{1, 2}, sample{3, 5}, sample{6, 1}},
-				{sample{7, 89}, sample{9, 8}},
+				{sample{1, 2, nil}, sample{3, 5, nil}, sample{6, 1, nil}},
+				{sample{7, 89, nil}, sample{9, 8, nil}},
 			},
 			seek: -32,
 
 			seekSuccess: true,
 			expected: []tsdbutil.Sample{
-				sample{1, 2}, sample{3, 5}, sample{6, 1}, sample{7, 89}, sample{9, 8},
+				sample{1, 2, nil}, sample{3, 5, nil}, sample{6, 1, nil}, sample{7, 89, nil}, sample{9, 8, nil},
 			},
 		},
 		// Deletion / Trim cases.
@@ -732,60 +732,60 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) {
 		{
 			name: "two chunks with trimmed first and last samples from edge chunks",
 			chks: [][]tsdbutil.Sample{
-				{sample{1, 2}, sample{2, 3}, sample{3, 5}, sample{6, 1}},
-				{sample{7, 89}, sample{9, 8}},
+				{sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 5, nil}, sample{6, 1, nil}},
+				{sample{7, 89, nil}, sample{9, 8, nil}},
 			},
 			intervals: tombstones.Intervals{{Mint: math.MinInt64, Maxt: 2}}.Add(tombstones.Interval{Mint: 9, Maxt: math.MaxInt64}),
 
 			expected: []tsdbutil.Sample{
-				sample{3, 5}, sample{6, 1}, sample{7, 89},
+				sample{3, 5, nil}, sample{6, 1, nil}, sample{7, 89, nil},
 			},
 			expectedChks: []chunks.Meta{
 				tsdbutil.ChunkFromSamples([]tsdbutil.Sample{
-					sample{3, 5}, sample{6, 1},
+					sample{3, 5, nil}, sample{6, 1, nil},
 				}),
 				tsdbutil.ChunkFromSamples([]tsdbutil.Sample{
-					sample{7, 89},
+					sample{7, 89, nil},
 				}),
 			},
 		},
 		{
 			name: "two chunks with trimmed middle sample of first chunk",
 			chks: [][]tsdbutil.Sample{
-				{sample{1, 2}, sample{2, 3}, sample{3, 5}, sample{6, 1}},
-				{sample{7, 89}, sample{9, 8}},
+				{sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 5, nil}, sample{6, 1, nil}},
+				{sample{7, 89, nil}, sample{9, 8, nil}},
 			},
 			intervals: tombstones.Intervals{{Mint: 2, Maxt: 3}},
 
 			expected: []tsdbutil.Sample{
-				sample{1, 2}, sample{6, 1}, sample{7, 89}, sample{9, 8},
+				sample{1, 2, nil}, sample{6, 1, nil}, sample{7, 89, nil}, sample{9, 8, nil},
 			},
 			expectedChks: []chunks.Meta{
 				tsdbutil.ChunkFromSamples([]tsdbutil.Sample{
-					sample{1, 2}, sample{6, 1},
+					sample{1, 2, nil}, sample{6, 1, nil},
 				}),
 				tsdbutil.ChunkFromSamples([]tsdbutil.Sample{
-					sample{7, 89}, sample{9, 8},
+					sample{7, 89, nil}, sample{9, 8, nil},
 				}),
 			},
 		},
 		{
 			name: "two chunks with deletion across two chunks",
 			chks: [][]tsdbutil.Sample{
-				{sample{1, 2}, sample{2, 3}, sample{3, 5}, sample{6, 1}},
-				{sample{7, 89}, sample{9, 8}},
+				{sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 5, nil}, sample{6, 1, nil}},
+				{sample{7, 89, nil}, sample{9, 8, nil}},
 			},
 			intervals: tombstones.Intervals{{Mint: 6, Maxt: 7}},
 
 			expected: []tsdbutil.Sample{
-				sample{1, 2}, sample{2, 3}, sample{3, 5}, sample{9, 8},
+				sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 5, nil}, sample{9, 8, nil},
 			},
 			expectedChks: []chunks.Meta{
 				tsdbutil.ChunkFromSamples([]tsdbutil.Sample{
-					sample{1, 2}, sample{2, 3}, sample{3, 5},
+					sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 5, nil},
 				}),
 				tsdbutil.ChunkFromSamples([]tsdbutil.Sample{
-					sample{9, 8},
+					sample{9, 8, nil},
 				}),
 			},
 		},
@@ -793,15 +793,15 @@ func TestPopulateWithTombSeriesIterators(t *testing.T) {
 		{
 			name: "two chunks with trimmed first and last samples from edge chunks, seek from middle of first chunk",
 			chks: [][]tsdbutil.Sample{
-				{sample{1, 2}, sample{2, 3}, sample{3, 5}, sample{6, 1}},
-				{sample{7, 89}, sample{9, 8}},
+				{sample{1, 2, nil}, sample{2, 3, nil}, sample{3, 5, nil}, sample{6, 1, nil}},
+				{sample{7, 89, nil}, sample{9, 8, nil}},
 			},
 			intervals: tombstones.Intervals{{Mint: math.MinInt64, Maxt: 2}}.Add(tombstones.Interval{Mint: 9, Maxt: math.MaxInt64}),
 
 			seek:        3,
 			seekSuccess: true,
 			expected: []tsdbutil.Sample{
-				sample{3, 5}, sample{6, 1}, sample{7, 89},
+				sample{3, 5, nil}, sample{6, 1, nil}, sample{7, 89, nil},
 			},
 		},
 	}
@@ -857,8 +857,8 @@ func rmChunkRefs(chks []chunks.Meta) {
 func TestPopulateWithDelSeriesIterator_DoubleSeek(t *testing.T) {
 	f, chkMetas := createFakeReaderAndNotPopulatedChunks(
 		[]tsdbutil.Sample{},
-		[]tsdbutil.Sample{sample{1, 1}, sample{2, 2}, sample{3, 3}},
-		[]tsdbutil.Sample{sample{4, 4}, sample{5, 5}},
+		[]tsdbutil.Sample{sample{1, 1, nil}, sample{2, 2, nil}, sample{3, 3, nil}},
+		[]tsdbutil.Sample{sample{4, 4, nil}, sample{5, 5, nil}},
 	)
 
 	it := newPopulateWithDelGenericSeriesIterator(f, chkMetas, nil).toSeriesIterator()
@@ -875,7 +875,7 @@ func TestPopulateWithDelSeriesIterator_DoubleSeek(t *testing.T) {
 func TestPopulateWithDelSeriesIterator_SeekInCurrentChunk(t *testing.T) {
 	f, chkMetas := createFakeReaderAndNotPopulatedChunks(
 		[]tsdbutil.Sample{},
-		[]tsdbutil.Sample{sample{1, 2}, sample{3, 4}, sample{5, 6}, sample{7, 8}},
+		[]tsdbutil.Sample{sample{1, 2, nil}, sample{3, 4, nil}, sample{5, 6, nil}, sample{7, 8, nil}},
 		[]tsdbutil.Sample{},
 	)
 
@@ -893,7 +893,7 @@ func TestPopulateWithDelSeriesIterator_SeekInCurrentChunk(t *testing.T) {
 
 func TestPopulateWithDelSeriesIterator_SeekWithMinTime(t *testing.T) {
 	f, chkMetas := createFakeReaderAndNotPopulatedChunks(
-		[]tsdbutil.Sample{sample{1, 6}, sample{5, 6}, sample{6, 8}},
+		[]tsdbutil.Sample{sample{1, 6, nil}, sample{5, 6, nil}, sample{6, 8, nil}},
 	)
 
 	it := newPopulateWithDelGenericSeriesIterator(f, chkMetas, nil).toSeriesIterator()
@@ -905,7 +905,7 @@ func TestPopulateWithDelSeriesIterator_SeekWithMinTime(t *testing.T) {
 // Seek gets called and advances beyond the max time, which was just accepted as a valid sample.
 func TestPopulateWithDelSeriesIterator_NextWithMinTime(t *testing.T) {
 	f, chkMetas := createFakeReaderAndNotPopulatedChunks(
-		[]tsdbutil.Sample{sample{1, 6}, sample{5, 6}, sample{7, 8}},
+		[]tsdbutil.Sample{sample{1, 6, nil}, sample{5, 6, nil}, sample{7, 8, nil}},
 	)
 
 	it := newPopulateWithDelGenericSeriesIterator(
diff --git a/tsdb/record/record.go b/tsdb/record/record.go
index 25c2107b8..0a3e3c2f4 100644
--- a/tsdb/record/record.go
+++ b/tsdb/record/record.go
@@ -74,7 +74,7 @@ type RefExemplar struct {
 type RefHistogram struct {
 	Ref uint64
 	T   int64
-	H   histogram.Histogram
+	H   *histogram.Histogram
 }
 
 // Decoder decodes series, sample, and tombstone records.
@@ -253,7 +253,7 @@ func (d *Decoder) Histograms(rec []byte, histograms []RefHistogram) ([]RefHistog
 		rh := RefHistogram{
 			Ref: baseRef + uint64(dref),
 			T:   baseTime + dtime,
-			H: histogram.Histogram{
+			H: &histogram.Histogram{
 				Schema:        0,
 				ZeroThreshold: 0,
 				ZeroCount:     0,
diff --git a/tsdb/tsdbutil/buffer.go b/tsdb/tsdbutil/buffer.go
index 5569c0047..28cb04a7b 100644
--- a/tsdb/tsdbutil/buffer.go
+++ b/tsdb/tsdbutil/buffer.go
@@ -165,9 +165,9 @@ func (it *sampleRingIterator) At() (int64, float64) {
 	return it.r.at(it.i)
 }
 
-func (it *sampleRingIterator) AtHistogram() (int64, histogram.Histogram) {
+func (it *sampleRingIterator) AtHistogram() (int64, *histogram.Histogram) {
 	// TODO(beorn7): Add proper histogram support.
-	return 0, histogram.Histogram{}
+	return 0, nil
 }
 
 func (it *sampleRingIterator) ChunkEncoding() chunkenc.Encoding {
diff --git a/tsdb/tsdbutil/buffer_test.go b/tsdb/tsdbutil/buffer_test.go
index 8ff8fa086..de0e40308 100644
--- a/tsdb/tsdbutil/buffer_test.go
+++ b/tsdb/tsdbutil/buffer_test.go
@@ -152,12 +152,9 @@ func (it *listSeriesIterator) At() (int64, float64) {
 	return s.t, s.v
 }
 
-func (it *listSeriesIterator) AtHistogram() (int64, histogram.Histogram) {
+func (it *listSeriesIterator) AtHistogram() (int64, *histogram.Histogram) {
 	s := it.list[it.idx]
-	if s.h == nil {
-		return s.t, histogram.Histogram{}
-	}
-	return s.t, *s.h
+	return s.t, s.h
 }
 
 func (it *listSeriesIterator) ChunkEncoding() chunkenc.Encoding {
diff --git a/web/federate.go b/web/federate.go
index f97579ad4..8d2af396d 100644
--- a/web/federate.go
+++ b/web/federate.go
@@ -115,7 +115,8 @@ func (h *Handler) federation(w http.ResponseWriter, req *http.Request) {
 		if ok {
 			t, v = it.Values()
 		} else {
-			t, v, ok = it.PeekBack(1)
+			// TODO(beorn7): Handle histograms.
+			t, v, _, ok = it.PeekBack(1)
 			if !ok {
 				continue
 			}
@@ -220,6 +221,7 @@ func (h *Handler) federation(w http.ResponseWriter, req *http.Request) {
 
 		protMetric.TimestampMs = proto.Int64(s.T)
 		protMetric.Untyped.Value = proto.Float64(s.V)
+		// TODO(beorn7): Handle histograms.
 
 		protMetricFam.Metric = append(protMetricFam.Metric, protMetric)
 	}