src/kudu/common/encoded_key.h

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
#ifndef KUDU_COMMON_ENCODED_KEY_H
#define KUDU_COMMON_ENCODED_KEY_H

#include <string>
#include <vector>

#include "kudu/common/schema.h"
#include "kudu/util/faststring.h"

namespace kudu {

class ConstContiguousRow;

class EncodedKey {
 public:
  // Constructs a new EncodedKey.
  // This class takes over the value of 'data' and contents of
  // raw_keys. Note that num_key_cols is the number of key columns for
  // the schema, but this may be different from the size of raw_keys
  // in which case raw_keys represents the supplied prefix of a
  // composite key.
  EncodedKey(faststring *data,
             vector<const void *> *raw_keys,
             size_t num_key_cols);

  static gscoped_ptr<EncodedKey> FromContiguousRow(const ConstContiguousRow& row);

  // Decode the encoded key specified in 'encoded', which must correspond to the
  // provided schema.
  // The returned row data is allocated from 'arena' and returned in '*result'.
  // If allocation fails or the encoding is invalid, returns a bad Status.
  static Status DecodeEncodedString(const Schema& schema,
                                    Arena* arena,
                                    const Slice& encoded,
                                    gscoped_ptr<EncodedKey> *result);

  // Given an EncodedKey, increment it to the next lexicographically greater EncodedKey.
  static Status IncrementEncodedKey(const Schema& tablet_schema,
                                    gscoped_ptr<EncodedKey>* key,
                                    Arena* arena);

  const Slice &encoded_key() const { return encoded_key_; }

  const vector<const void *> &raw_keys() const { return raw_keys_; }

  size_t num_key_columns() const { return num_key_cols_; }

  std::string Stringify(const Schema &schema) const;

  // Tests whether this EncodedKey is within the bounds given by 'start'
  // and 'end'.
  //
  // The empty bound has special significance: it's both the lowest value
  // (if in 'start') and the highest (if in 'end').
  bool InRange(const Slice& start, const Slice& end) const {
    return (start.compare(encoded_key_) <= 0 &&
            (end.empty() || encoded_key_.compare(end) < 0));
  }

  static std::string RangeToString(const EncodedKey* lower,
                                   const EncodedKey* upper);

  static std::string RangeToStringWithSchema(const EncodedKey* lower,
                                             const EncodedKey* upper,
                                             const Schema& schema);


 private:
  const int num_key_cols_;
  Slice encoded_key_;
  gscoped_ptr<uint8_t[]> data_;
  vector<const void *> raw_keys_;
};

// A builder for encoded key: creates an encoded key from
// one or more key columns specified as raw pointers.
class EncodedKeyBuilder {
 public:
  // 'schema' must remain valid for the lifetime of the EncodedKeyBuilder.
  explicit EncodedKeyBuilder(const Schema* schema);

  void Reset();

  void AddColumnKey(const void *raw_key);

  EncodedKey *BuildEncodedKey();

  void AssignCopy(const EncodedKeyBuilder &other);

 private:
  DISALLOW_COPY_AND_ASSIGN(EncodedKeyBuilder);

  const Schema* schema_;
  faststring encoded_key_;
  const size_t num_key_cols_;
  size_t idx_;
  vector<const void *> raw_keys_;
};

} // namespace kudu
#endif