flatten.go

flatten.go - Overview

This file defines the flatten command, which compacts all LSM (Log-Structured Merge Tree) tables in a Badger database into a single level. This process essentially defragments the database, potentially improving read performance at the cost of a write-intensive operation.

Detailed Documentation

var flattenCmd

var flattenCmd = &cobra.Command{
	Use:   "flatten",
	Short: "Flatten the LSM tree.",
	Long: `
This command would compact all the LSM tables into one level.
`,
	RunE: flatten,
}

• Purpose: Defines the Cobra command flatten. This command is used to trigger the flattening operation on a Badger database.
  • Use: Command name which is "flatten".
  • Short: Short description of the command.
  • Long: Long description of the command.
  • RunE: Function to execute when the command is called, which is flatten.

var fo

var fo = struct {
	keyPath         string
	numWorkers      int
	numVersions     int
	compressionType uint32
}{}

• Purpose: Defines a struct fo to hold flags related to the flatten operation.
  • keyPath: Path to the encryption key file (string).
  • numWorkers: Number of concurrent compactors (int).
  • numVersions: Number of versions to keep per key (int).
  • compressionType: Compression type to use (uint32).

func init()

func init() {
	RootCmd.AddCommand(flattenCmd)
	flattenCmd.Flags().IntVarP(&fo.numWorkers, "num-workers", "w", 1,
		"Number of concurrent compactors to run. More compactors would use more"+
			" server resources to potentially achieve faster compactions.")
	flattenCmd.Flags().IntVarP(&fo.numVersions, "num_versions", "", 0,
		"Option to configure the maximum number of versions per key. "+
			"Values <= 0 will be considered to have the max number of versions.")
	flattenCmd.Flags().StringVar(&fo.keyPath, "encryption-key-file", "",
		"Path of the encryption key file.")
	flattenCmd.Flags().Uint32VarP(&fo.compressionType, "compression", "", 1,
		"Option to configure the compression type in output DB. "+
			"0 to disable, 1 for Snappy, and 2 for ZSTD.")
}

• Purpose: Initializes the flattenCmd by adding it to the root command and defining its flags.
  • Adds flattenCmd to the RootCmd.
  • Defines flags for:
    • num-workers: Number of concurrent compactors.
    • num_versions: Number of versions to keep per key.
    • encryption-key-file: Path to the encryption key file.
    • compression: Compression type.

func flatten(cmd *cobra.Command, args []string) error

func flatten(cmd *cobra.Command, args []string) error {
	if fo.numVersions <= 0 {
		// Keep all versions.
		fo.numVersions = math.MaxInt32
	}
	encKey, err := getKey(fo.keyPath)
	if err != nil {
		return err
	}
	if fo.compressionType > 2 {
		return errors.New(
			"compression value must be one of 0 (disabled), 1 (Snappy), or 2 (ZSTD)")
	}
	opt := badger.DefaultOptions(sstDir).
		WithValueDir(vlogDir).
		WithNumVersionsToKeep(fo.numVersions).
		WithNumCompactors(0).
		WithBlockCacheSize(100 << 20).
		WithIndexCacheSize(200 << 20).
		WithCompression(options.CompressionType(fo.compressionType)).
		WithEncryptionKey(encKey)
	fmt.Printf("Opening badger with options = %+v\n", opt)
	db, err := badger.Open(opt)
	if err != nil {
		return err
	}
	defer db.Close()

	return db.Flatten(fo.numWorkers)
}

• Purpose: Executes the database flattening operation.
  • Parameters:
    • cmd: *cobra.Command - The Cobra command object.
    • args: []string - Command line arguments.
  • Returns: error - An error if the operation fails, nil otherwise.
  • Sets fo.numVersions to math.MaxInt32 if it's less than or equal to 0.
  • Gets the encryption key using the getKey function.
  • Validates the compression type.
  • Creates a badger.Options object with specified configurations.
  • Opens the Badger database.
  • Calls the db.Flatten method to flatten the database.

Code Examples

None

Getting Started Relevance