mirror of
https://github.com/git/git.git
synced 2025-12-12 20:36:24 +01:00
b8ca235ca5
The merged table provides access to a reftable stack by merging the contents of those tables into a virtual table. These subtables are being tracked via `struct reftable_table`, which is a generic interface for accessing either a single reftable or a merged reftable. So in theory, it would be possible for the merged table to merge together other merged tables. This is somewhat nonsensical though: we only ever set up a merged table over normal reftables, and there is no reason to do otherwise. This generic interface thus makes the code way harder to follow and reason about than really necessary. The abstraction layer may also have an impact on performance, even though the extra set of vtable function calls probably doesn't really matter. Refactor the merged tables to use a `struct reftable_reader` for each of the subtables instead, which gives us direct access to the underlying tables. Adjust names accordingly. Signed-off-by: Patrick Steinhardt <ps@pks.im> Signed-off-by: Junio C Hamano <gitster@pobox.com>
68 lines
2.3 KiB
C
68 lines
2.3 KiB
C
/*
|
|
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_MERGED_H
|
|
#define REFTABLE_MERGED_H
|
|
|
|
#include "reftable-iterator.h"
|
|
|
|
/*
|
|
* Merged tables
|
|
*
|
|
* A ref database kept in a sequence of table files. The merged_table presents a
|
|
* unified view to reading (seeking, iterating) a sequence of immutable tables.
|
|
*
|
|
* The merged tables are on purpose kept disconnected from their actual storage
|
|
* (eg. files on disk), because it is useful to merge tables aren't files. For
|
|
* example, the per-workspace and global ref namespace can be implemented as a
|
|
* merged table of two stacks of file-backed reftables.
|
|
*/
|
|
|
|
/* A merged table is implements seeking/iterating over a stack of tables. */
|
|
struct reftable_merged_table;
|
|
|
|
/* A generic reftable; see below. */
|
|
struct reftable_table;
|
|
struct reftable_reader;
|
|
|
|
/*
|
|
* reftable_merged_table_new creates a new merged table. The readers must be
|
|
* kept alive as long as the merged table is still in use.
|
|
*/
|
|
int reftable_merged_table_new(struct reftable_merged_table **dest,
|
|
struct reftable_reader **readers, size_t n,
|
|
uint32_t hash_id);
|
|
|
|
/* Initialize a merged table iterator for reading refs. */
|
|
void reftable_merged_table_init_ref_iterator(struct reftable_merged_table *mt,
|
|
struct reftable_iterator *it);
|
|
|
|
/* Initialize a merged table iterator for reading logs. */
|
|
void reftable_merged_table_init_log_iterator(struct reftable_merged_table *mt,
|
|
struct reftable_iterator *it);
|
|
|
|
/* returns the max update_index covered by this merged table. */
|
|
uint64_t
|
|
reftable_merged_table_max_update_index(struct reftable_merged_table *mt);
|
|
|
|
/* returns the min update_index covered by this merged table. */
|
|
uint64_t
|
|
reftable_merged_table_min_update_index(struct reftable_merged_table *mt);
|
|
|
|
/* releases memory for the merged_table */
|
|
void reftable_merged_table_free(struct reftable_merged_table *m);
|
|
|
|
/* return the hash ID of the merged table. */
|
|
uint32_t reftable_merged_table_hash_id(struct reftable_merged_table *m);
|
|
|
|
/* create a generic table from reftable_merged_table */
|
|
void reftable_table_from_merged_table(struct reftable_table *tab,
|
|
struct reftable_merged_table *table);
|
|
|
|
#endif
|