reftable: generic interface to tables

Signed-off-by: Han-Wen Nienhuys <hanwen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/Makefile b/Makefile
index 05be43355a6a1501df85bd99213ed859e3978c02..18093366acb5a0dca6efbf592384902819075d45 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -2462,6 +2462,9 @@ REFTABLE_OBJS += reftable/block.o
 REFTABLE_OBJS += reftable/blocksource.o
 REFTABLE_OBJS += reftable/publicbasics.o
 REFTABLE_OBJS += reftable/record.o
+REFTABLE_OBJS += reftable/refname.o
+REFTABLE_OBJS += reftable/generic.o
+REFTABLE_OBJS += reftable/stack.o
 REFTABLE_OBJS += reftable/tree.o
 REFTABLE_OBJS += reftable/writer.o
 

diff --git a/reftable/generic.c b/reftable/generic.c
new file mode 100644 (file)
index 0000000..7a8a738
--- /dev/null
+++ b/reftable/generic.c
@@ -0,0 +1,169 @@
+/*
+Copyright 2020 Google LLC
+
+Use of this source code is governed by a BSD-style
+license that can be found in the LICENSE file or at
+https://developers.google.com/open-source/licenses/bsd
+*/
+
+#include "basics.h"
+#include "record.h"
+#include "generic.h"
+#include "reftable-iterator.h"
+#include "reftable-generic.h"
+
+int reftable_table_seek_ref(struct reftable_table *tab,
+                           struct reftable_iterator *it, const char *name)
+{
+       struct reftable_ref_record ref = {
+               .refname = (char *)name,
+       };
+       struct reftable_record rec = { NULL };
+       reftable_record_from_ref(&rec, &ref);
+       return tab->ops->seek_record(tab->table_arg, it, &rec);
+}
+
+int reftable_table_seek_log(struct reftable_table *tab,
+                           struct reftable_iterator *it, const char *name)
+{
+       struct reftable_log_record log = {
+               .refname = (char *)name,
+               .update_index = ~((uint64_t)0),
+       };
+       struct reftable_record rec = { NULL };
+       reftable_record_from_log(&rec, &log);
+       return tab->ops->seek_record(tab->table_arg, it, &rec);
+}
+
+int reftable_table_read_ref(struct reftable_table *tab, const char *name,
+                           struct reftable_ref_record *ref)
+{
+       struct reftable_iterator it = { NULL };
+       int err = reftable_table_seek_ref(tab, &it, name);
+       if (err)
+               goto done;
+
+       err = reftable_iterator_next_ref(&it, ref);
+       if (err)
+               goto done;
+
+       if (strcmp(ref->refname, name) ||
+           reftable_ref_record_is_deletion(ref)) {
+               reftable_ref_record_release(ref);
+               err = 1;
+               goto done;
+       }
+
+done:
+       reftable_iterator_destroy(&it);
+       return err;
+}
+
+int reftable_table_print(struct reftable_table *tab) {
+       struct reftable_iterator it = { NULL };
+       struct reftable_ref_record ref = { NULL };
+       struct reftable_log_record log = { NULL };
+       uint32_t hash_id = reftable_table_hash_id(tab);
+       int err = reftable_table_seek_ref(tab, &it, "");
+       if (err < 0) {
+               return err;
+       }
+
+       while (1) {
+               err = reftable_iterator_next_ref(&it, &ref);
+               if (err > 0) {
+                       break;
+               }
+               if (err < 0) {
+                       return err;
+               }
+               reftable_ref_record_print(&ref, hash_id);
+       }
+       reftable_iterator_destroy(&it);
+       reftable_ref_record_release(&ref);
+
+       err = reftable_table_seek_log(tab, &it, "");
+       if (err < 0) {
+               return err;
+       }
+       while (1) {
+               err = reftable_iterator_next_log(&it, &log);
+               if (err > 0) {
+                       break;
+               }
+               if (err < 0) {
+                       return err;
+               }
+               reftable_log_record_print(&log, hash_id);
+       }
+       reftable_iterator_destroy(&it);
+       reftable_log_record_release(&log);
+       return 0;
+}
+
+uint64_t reftable_table_max_update_index(struct reftable_table *tab)
+{
+       return tab->ops->max_update_index(tab->table_arg);
+}
+
+uint64_t reftable_table_min_update_index(struct reftable_table *tab)
+{
+       return tab->ops->min_update_index(tab->table_arg);
+}
+
+uint32_t reftable_table_hash_id(struct reftable_table *tab)
+{
+       return tab->ops->hash_id(tab->table_arg);
+}
+
+void reftable_iterator_destroy(struct reftable_iterator *it)
+{
+       if (!it->ops) {
+               return;
+       }
+       it->ops->close(it->iter_arg);
+       it->ops = NULL;
+       FREE_AND_NULL(it->iter_arg);
+}
+
+int reftable_iterator_next_ref(struct reftable_iterator *it,
+                              struct reftable_ref_record *ref)
+{
+       struct reftable_record rec = { NULL };
+       reftable_record_from_ref(&rec, ref);
+       return iterator_next(it, &rec);
+}
+
+int reftable_iterator_next_log(struct reftable_iterator *it,
+                              struct reftable_log_record *log)
+{
+       struct reftable_record rec = { NULL };
+       reftable_record_from_log(&rec, log);
+       return iterator_next(it, &rec);
+}
+
+int iterator_next(struct reftable_iterator *it, struct reftable_record *rec)
+{
+       return it->ops->next(it->iter_arg, rec);
+}
+
+static int empty_iterator_next(void *arg, struct reftable_record *rec)
+{
+       return 1;
+}
+
+static void empty_iterator_close(void *arg)
+{
+}
+
+static struct reftable_iterator_vtable empty_vtable = {
+       .next = &empty_iterator_next,
+       .close = &empty_iterator_close,
+};
+
+void iterator_set_empty(struct reftable_iterator *it)
+{
+       assert(!it->ops);
+       it->iter_arg = NULL;
+       it->ops = &empty_vtable;
+}

diff --git a/reftable/generic.h b/reftable/generic.h
new file mode 100644 (file)
index 0000000..98886a0
--- /dev/null
+++ b/reftable/generic.h
@@ -0,0 +1,32 @@
+/*
+Copyright 2020 Google LLC
+
+Use of this source code is governed by a BSD-style
+license that can be found in the LICENSE file or at
+https://developers.google.com/open-source/licenses/bsd
+*/
+
+#ifndef GENERIC_H
+#define GENERIC_H
+
+#include "record.h"
+#include "reftable-generic.h"
+
+/* generic interface to reftables */
+struct reftable_table_vtable {
+       int (*seek_record)(void *tab, struct reftable_iterator *it,
+                          struct reftable_record *);
+       uint32_t (*hash_id)(void *tab);
+       uint64_t (*min_update_index)(void *tab);
+       uint64_t (*max_update_index)(void *tab);
+};
+
+struct reftable_iterator_vtable {
+       int (*next)(void *iter_arg, struct reftable_record *rec);
+       void (*close)(void *iter_arg);
+};
+
+void iterator_set_empty(struct reftable_iterator *it);
+int iterator_next(struct reftable_iterator *it, struct reftable_record *rec);
+
+#endif

diff --git a/reftable/reftable-generic.h b/reftable/reftable-generic.h
new file mode 100644 (file)
index 0000000..d239751
--- /dev/null
+++ b/reftable/reftable-generic.h
@@ -0,0 +1,47 @@
+/*
+Copyright 2020 Google LLC
+
+Use of this source code is governed by a BSD-style
+license that can be found in the LICENSE file or at
+https://developers.google.com/open-source/licenses/bsd
+*/
+
+#ifndef REFTABLE_GENERIC_H
+#define REFTABLE_GENERIC_H
+
+#include "reftable-iterator.h"
+
+struct reftable_table_vtable;
+
+/*
+ * Provides a unified API for reading tables, either merged tables, or single
+ * readers. */
+struct reftable_table {
+       struct reftable_table_vtable *ops;
+       void *table_arg;
+};
+
+int reftable_table_seek_log(struct reftable_table *tab,
+                           struct reftable_iterator *it, const char *name);
+
+int reftable_table_seek_ref(struct reftable_table *tab,
+                           struct reftable_iterator *it, const char *name);
+
+/* returns the hash ID from a generic reftable_table */
+uint32_t reftable_table_hash_id(struct reftable_table *tab);
+
+/* returns the max update_index covered by this table. */
+uint64_t reftable_table_max_update_index(struct reftable_table *tab);
+
+/* returns the min update_index covered by this table. */
+uint64_t reftable_table_min_update_index(struct reftable_table *tab);
+
+/* convenience function to read a single ref. Returns < 0 for error, 0
+   for success, and 1 if ref not found. */
+int reftable_table_read_ref(struct reftable_table *tab, const char *name,
+                           struct reftable_ref_record *ref);
+
+/* dump table contents onto stdout for debugging */
+int reftable_table_print(struct reftable_table *tab);
+
+#endif

diff --git a/reftable/reftable-iterator.h b/reftable/reftable-iterator.h
new file mode 100644 (file)
index 0000000..d3eee7a
--- /dev/null
+++ b/reftable/reftable-iterator.h
@@ -0,0 +1,39 @@
+/*
+Copyright 2020 Google LLC
+
+Use of this source code is governed by a BSD-style
+license that can be found in the LICENSE file or at
+https://developers.google.com/open-source/licenses/bsd
+*/
+
+#ifndef REFTABLE_ITERATOR_H
+#define REFTABLE_ITERATOR_H
+
+#include "reftable-record.h"
+
+struct reftable_iterator_vtable;
+
+/* iterator is the generic interface for walking over data stored in a
+ * reftable.
+ */
+struct reftable_iterator {
+       struct reftable_iterator_vtable *ops;
+       void *iter_arg;
+};
+
+/* reads the next reftable_ref_record. Returns < 0 for error, 0 for OK and > 0:
+ * end of iteration.
+ */
+int reftable_iterator_next_ref(struct reftable_iterator *it,
+                              struct reftable_ref_record *ref);
+
+/* reads the next reftable_log_record. Returns < 0 for error, 0 for OK and > 0:
+ * end of iteration.
+ */
+int reftable_iterator_next_log(struct reftable_iterator *it,
+                              struct reftable_log_record *log);
+
+/* releases resources associated with an iterator. */
+void reftable_iterator_destroy(struct reftable_iterator *it);
+
+#endif

diff --git a/reftable/reftable.c b/reftable/reftable.c
new file mode 100644 (file)
index 0000000..0e4607a
--- /dev/null
+++ b/reftable/reftable.c
@@ -0,0 +1,115 @@
+/*
+Copyright 2020 Google LLC
+
+Use of this source code is governed by a BSD-style
+license that can be found in the LICENSE file or at
+https://developers.google.com/open-source/licenses/bsd
+*/
+
+#include "basics.h"
+#include "record.h"
+#include "generic.h"
+#include "reftable-iterator.h"
+#include "reftable-generic.h"
+
+int reftable_table_seek_ref(struct reftable_table *tab,
+                           struct reftable_iterator *it, const char *name)
+{
+       struct reftable_ref_record ref = {
+               .refname = (char *)name,
+       };
+       struct reftable_record rec = { NULL };
+       reftable_record_from_ref(&rec, &ref);
+       return tab->ops->seek_record(tab->table_arg, it, &rec);
+}
+
+int reftable_table_read_ref(struct reftable_table *tab, const char *name,
+                           struct reftable_ref_record *ref)
+{
+       struct reftable_iterator it = { NULL };
+       int err = reftable_table_seek_ref(tab, &it, name);
+       if (err)
+               goto done;
+
+       err = reftable_iterator_next_ref(&it, ref);
+       if (err)
+               goto done;
+
+       if (strcmp(ref->refname, name) ||
+           reftable_ref_record_is_deletion(ref)) {
+               reftable_ref_record_release(ref);
+               err = 1;
+               goto done;
+       }
+
+done:
+       reftable_iterator_destroy(&it);
+       return err;
+}
+
+uint64_t reftable_table_max_update_index(struct reftable_table *tab)
+{
+       return tab->ops->max_update_index(tab->table_arg);
+}
+
+uint64_t reftable_table_min_update_index(struct reftable_table *tab)
+{
+       return tab->ops->min_update_index(tab->table_arg);
+}
+
+uint32_t reftable_table_hash_id(struct reftable_table *tab)
+{
+       return tab->ops->hash_id(tab->table_arg);
+}
+
+void reftable_iterator_destroy(struct reftable_iterator *it)
+{
+       if (!it->ops) {
+               return;
+       }
+       it->ops->close(it->iter_arg);
+       it->ops = NULL;
+       FREE_AND_NULL(it->iter_arg);
+}
+
+int reftable_iterator_next_ref(struct reftable_iterator *it,
+                              struct reftable_ref_record *ref)
+{
+       struct reftable_record rec = { NULL };
+       reftable_record_from_ref(&rec, ref);
+       return iterator_next(it, &rec);
+}
+
+int reftable_iterator_next_log(struct reftable_iterator *it,
+                              struct reftable_log_record *log)
+{
+       struct reftable_record rec = { NULL };
+       reftable_record_from_log(&rec, log);
+       return iterator_next(it, &rec);
+}
+
+int iterator_next(struct reftable_iterator *it, struct reftable_record *rec)
+{
+       return it->ops->next(it->iter_arg, rec);
+}
+
+static int empty_iterator_next(void *arg, struct reftable_record *rec)
+{
+       return 1;
+}
+
+static void empty_iterator_close(void *arg)
+{
+}
+
+static struct reftable_iterator_vtable empty_vtable = {
+       .next = &empty_iterator_next,
+       .close = &empty_iterator_close,
+};
+
+void iterator_set_empty(struct reftable_iterator *it)
+{
+       assert(!it->ops);
+       it->iter_arg = NULL;
+       it->ops = &empty_vtable;
+}