Read events from one family

Author: alexdebril

repository/repository.go

@@ -55,6 +55,19 @@ func (r *Repository) Read(ctx context.Context, key string) (*data.Set, error) {
 	return r.read(ctx, key)
 }
 
+/*
+ReadFamily reads a row from the repository keeping only the desired column family and map it to a data.Set
+
+This method takes a row key and the column family as an argument, uses its internal adapter to read the row from Big Table,
+parses all cells contained in the row to turn it into a map of data.Event and finally returns the data.Set that contains all the events.
+
+Be careful, this method will perform an exact match on the column family name.
+*/
+func (r *Repository) ReadFamily(ctx context.Context, key string, family string) (*data.Set, error) {
+	familyFilter := bigtable.RowFilter(bigtable.FamilyFilter(family))
+	return r.read(ctx, key, familyFilter)
+}
+
 // ReadLast reads a row from the repository while returning only the latest cell values after
 // mapping it to a data.Set. This method takes a row key as an argument, uses its internal adapter
 // to read the row from Big Table, parses only the latest cells contained in the row to turn it into

repository/repository_test.go

@@ -332,6 +332,68 @@ func ExampleRepository_ReadLast() {
 	// Smartphone
 }
 
+func ExampleRepository_ReadFamily() {
+	ctx := context.Background()
+	client := getBigTableClient(ctx)
+	c, err := fs.ReadFile("testdata/mapping.json")
+	if err != nil {
+		log.Fatalln(err)
+	}
+	jsonMapping, err := mapping.LoadMapping(c)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	mapper := mapping.NewMapper(jsonMapping)
+	tbl := client.Open(table)
+
+	repo := NewRepository(tbl, mapper)
+	eventSet := &data.Set{Events: map[string][]*data.Event{
+		"front": {
+			{
+				RowKey: "contactz-102",
+				Date:   time.Date(2018, time.January, 1, 0, 2, 0, 0, time.UTC),
+				Cells: map[string]string{
+					"event_type":  "add_to_cart",
+					"device_type": "Computer",
+					"url":         "https://example.org/some/product",
+				},
+			},
+		},
+		"blog": {
+			{
+				RowKey: "contactz-102",
+				Date:   time.Date(2018, time.January, 1, 0, 2, 0, 0, time.UTC),
+				Cells: map[string]string{
+					"event_type":  "page_view",
+					"device_type": "Computer",
+					"url":         "https://example.org/blog/article/1",
+				},
+			},
+		},
+	}}
+
+	// insert
+	errs, err := repo.Write(ctx, eventSet)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	if len(errs) > 0 {
+		log.Fatalln(errs)
+	}
+
+	readSet, err := repo.ReadFamily(ctx, "contactz-102", "blog")
+	if err != nil {
+		log.Fatalln(err)
+	}
+	for _, event := range readSet.Events["blog"] {
+		fmt.Println(event.Cells["event_type"])
+		fmt.Println(event.Cells["device_type"])
+	}
+	// Output:
+	// page_view
+	// Computer
+}
+
 var t1 = bigtable.Time(time.Date(2020, time.January, 1, 0, 1, 0, 0, time.UTC))
 var t2 = bigtable.Time(time.Date(2020, time.January, 1, 0, 2, 0, 0, time.UTC))
 var t3 = bigtable.Time(time.Date(2020, time.January, 1, 0, 3, 0, 0, time.UTC))
@@ -489,6 +551,57 @@ func TestRepository_ReadLast(t *testing.T) {
 	}
 }
 
+func TestRepository_ReadFamily(t *testing.T) {
+	ctx := context.Background()
+	repository := &Repository{
+		adapter: mockAdapter{},
+		mapper:  getMockMapper(t),
+	}
+	eventSet, err := repository.ReadFamily(ctx, "contact-3", "front")
+	if err != nil {
+		t.Fatalf("failed to read: %v", err)
+	}
+	if len(eventSet.Events) != 1 {
+		t.Fatalf("expected 1 event family, got %d", len(eventSet.Events))
+	}
+	if v, ok := eventSet.Events["front"]; !ok {
+		t.Fatalf("expected front family, got %v", v)
+	} else {
+		if len(v) != 3 {
+			t.Fatalf("expected 3 events, got %d", len(v))
+		}
+
+		if v[0].RowKey != "contact-3" {
+			t.Fatalf("expected contact-3, got %s", v[0].RowKey)
+		}
+		if v[0].Cells["url"] != "http://someexample.url/query/string/1" {
+			t.Fatalf("expected http://someexample.url/query/string/1, got %s", v[0].Cells["url"])
+		}
+		if v[0].Cells["device_type"] != "Smartphone" {
+			t.Fatalf("expected Smartphone, got %s", v[0].Cells["device_type"])
+		}
+		// here we're testing each event_type depending on the timestamp.
+		// It's because Go doesn't guarantee the order of the map iteration
+		for _, event := range v {
+			if event.Date.Unix() == t1.Time().Unix() {
+				if event.Cells["event_type"] != "page_view" {
+					t.Fatalf("expected page_view, got %s", event.Cells["event_type"])
+				}
+			}
+			if event.Date.Unix() == t2.Time().Unix() {
+				if event.Cells["event_type"] != "add_to_cart" {
+					t.Fatalf("expected add_to_cart, got %s", event.Cells["event_type"])
+				}
+			}
+			if event.Date.Unix() == t3.Time().Unix() {
+				if event.Cells["event_type"] != "purchase" {
+					t.Fatalf("expected purchase, got %s", event.Cells["event_type"])
+				}
+			}
+		}
+	}
+}
+
 //go:embed testdata/mapping.json
 var fs embed.FS
 
@@ -626,6 +739,10 @@ func getBigTableClient(ctx context.Context) *bigtable.Client {
 		log.Fatalln(err)
 	}
 
+	if err = adminClient.CreateColumnFamily(ctx, table, "blog"); err != nil {
+		log.Fatalln(err)
+	}
+
 	client, err := bigtable.NewClient(ctx, projectID, instance, option.WithGRPCConn(conn))
 	if err != nil {
 		log.Fatalln(err)