Added memory database

Author: alexsanjoseph

riemann/database.go

@@ -0,0 +1,18 @@
+package riemann
+
+type RiemannDivisorSum struct {
+	N            int
+	DivisorSum   int
+	WitnessValue float64
+}
+
+type SummaryStats struct {
+	LargestComputedN    RiemannDivisorSum
+	LargestWitnessValue RiemannDivisorSum
+}
+
+type DivisorDb interface {
+	Load() []RiemannDivisorSum
+	Upsert([]RiemannDivisorSum)
+	Summarize() SummaryStats
+}

riemann/in_memory_database.go

@@ -0,0 +1,44 @@
+package riemann
+
+type InMemoryDivisorDb struct {
+	Data map[int]RiemannDivisorSum
+}
+
+func (imdb InMemoryDivisorDb) Load() []RiemannDivisorSum {
+	output := []RiemannDivisorSum{}
+	for _, value := range imdb.Data {
+		output = append(output, value)
+	}
+	return output
+}
+
+func (imdb InMemoryDivisorDb) Upsert(rds []RiemannDivisorSum) {
+	for _, value := range rds {
+		imdb.Data[value.N] = value
+	}
+}
+
+func (imdb InMemoryDivisorDb) Summarize() SummaryStats {
+	if len(imdb.Data) == 0 {
+		return SummaryStats{
+			LargestWitnessValue: RiemannDivisorSum{},
+			LargestComputedN:    RiemannDivisorSum{},
+		}
+	}
+	largest_computed_n := RiemannDivisorSum{N: -1}
+	largest_witness_value := RiemannDivisorSum{WitnessValue: -1}
+
+	for _, rds := range imdb.Data {
+		if rds.N > largest_computed_n.N {
+			largest_computed_n = rds
+		}
+		if int(rds.WitnessValue) > int(largest_witness_value.WitnessValue) {
+			largest_witness_value = rds
+		}
+	}
+	return SummaryStats{
+		LargestWitnessValue: largest_witness_value,
+		LargestComputedN:    largest_computed_n,
+	}
+
+}

riemann/in_memory_database_test.go

@@ -0,0 +1,94 @@
+package riemann_test
+
+import (
+	"sort"
+
+	"github.com/alexsanjoseph/riemann-divisor-sum-go/riemann"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("In Memory Database Tests", func() {
+
+	It("is initially empty", func() {
+		var db = riemann.DivisorDb(riemann.InMemoryDivisorDb{Data: make(map[int]riemann.RiemannDivisorSum)})
+		loadedData := db.Load()
+		Expect(len(loadedData)).To(Equal(0))
+	})
+
+	It("Upserts correctly", func() {
+		var db = riemann.DivisorDb(riemann.InMemoryDivisorDb{Data: make(map[int]riemann.RiemannDivisorSum)})
+		records := []riemann.RiemannDivisorSum{
+			{N: 1, DivisorSum: 1, WitnessValue: 1},
+			{N: 2, DivisorSum: 2, WitnessValue: 2},
+		}
+		By("upserting fine from empty", func() {
+			db.Upsert(records)
+			loadedData := db.Load()
+			sort.Slice(loadedData, func(p, q int) bool {
+				return loadedData[p].N < loadedData[q].N
+			})
+			Expect(loadedData).To(Equal(records))
+		})
+
+		By("upserting fine from non-empty", func() {
+			newRecords := []riemann.RiemannDivisorSum{
+				{N: 3, DivisorSum: 3, WitnessValue: 3},
+				{N: 4, DivisorSum: 4, WitnessValue: 4},
+			}
+			db.Upsert(newRecords)
+			loadedData := db.Load()
+			sort.Slice(loadedData, func(p, q int) bool {
+				return loadedData[p].N < loadedData[q].N
+			})
+			Expect(loadedData).To(Equal(append(records, newRecords...)))
+		})
+
+		By("overriding existing docs when upserted", func() {
+			newRecords := []riemann.RiemannDivisorSum{
+				{N: 3, DivisorSum: 3, WitnessValue: 10},
+				{N: 5, DivisorSum: 5, WitnessValue: 5},
+			}
+			expectedNewRecords := []riemann.RiemannDivisorSum{
+				{N: 3, DivisorSum: 3, WitnessValue: 10},
+				{N: 4, DivisorSum: 4, WitnessValue: 4},
+				{N: 5, DivisorSum: 5, WitnessValue: 5},
+			}
+			db.Upsert(newRecords)
+			loadedData := db.Load()
+			sort.Slice(loadedData, func(p, q int) bool {
+				return loadedData[p].N < loadedData[q].N
+			})
+			Expect(loadedData).To(Equal(append(records, expectedNewRecords...)))
+		})
+
+	})
+
+	It("Summarizes", func() {
+		var db = riemann.DivisorDb(riemann.InMemoryDivisorDb{Data: make(map[int]riemann.RiemannDivisorSum)})
+		By("correctly summarizing empty data", func() {
+			summaryData := db.Summarize()
+			expectedSummaryData := riemann.SummaryStats{
+				LargestWitnessValue: riemann.RiemannDivisorSum{},
+				LargestComputedN:    riemann.RiemannDivisorSum{},
+			}
+			Expect(summaryData).To(Equal(expectedSummaryData))
+		})
+
+		By("correctly summarizing non-empty data", func() {
+			records := []riemann.RiemannDivisorSum{
+				{N: 1, DivisorSum: 1, WitnessValue: 10},
+				{N: 2, DivisorSum: 2, WitnessValue: 20},
+				{N: 3, DivisorSum: 2, WitnessValue: 3},
+			}
+			db.Upsert(records)
+			summaryData := db.Summarize()
+			expectedSummaryData := riemann.SummaryStats{
+				LargestWitnessValue: riemann.RiemannDivisorSum{N: 2, DivisorSum: 2, WitnessValue: 20},
+				LargestComputedN:    riemann.RiemannDivisorSum{N: 3, DivisorSum: 2, WitnessValue: 3},
+			}
+			Expect(summaryData).To(Equal(expectedSummaryData))
+		})
+	})
+
+})