schema.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_CLIENT_SCHEMA_H
#define KUDU_CLIENT_SCHEMA_H
 
// NOTE: using stdint.h instead of cstdint because this file is supposed
//       to be processed by a compiler lacking C++11 support.
#include <stdint.h>
 
#include <cstddef>
#include <string>
#include <vector>
 
#ifdef KUDU_HEADERS_NO_STUBS
#include <gtest/gtest_prod.h>
 
#include "kudu/gutil/port.h"
#else
#include "kudu/client/stubs.h"
#endif
 
#include "kudu/util/kudu_export.h"
#include "kudu/util/status.h"
 
namespace kudu {
 
class ColumnSchema;
class KuduPartialRow;
class Schema;
class Slice;
struct ColumnSchemaDelta;
 
namespace tools {
class RemoteKsckCluster;
class ReplicaDumper;
}
 
namespace client {
 
namespace internal {
class GetTableSchemaRpc;
class LookupRpc;
class MetaCache;
class MetaCacheEntry;
class WriteRpc;
} // namespace internal
 
class KuduSchema;
class KuduValue;
 
class KUDU_EXPORT KuduColumnTypeAttributes {
 public:
  KuduColumnTypeAttributes();
 
  KuduColumnTypeAttributes(const KuduColumnTypeAttributes& other);
 
  KuduColumnTypeAttributes(int8_t precision, int8_t scale);
 
  explicit KuduColumnTypeAttributes(uint16_t length);
 
  ~KuduColumnTypeAttributes();
 
 
  KuduColumnTypeAttributes& operator=(const KuduColumnTypeAttributes& other);
 
  void CopyFrom(const KuduColumnTypeAttributes& other);
 
  int8_t precision() const;
 
  int8_t scale() const;
 
  uint16_t length() const;
 
 private:
  friend class KuduColumnSchema;
  friend class KuduColumnSpec;
  friend class KuduSchema;
 
  KuduColumnTypeAttributes(int8_t precision, int8_t scale, uint16_t length);
 
  class KUDU_NO_EXPORT Data;
 
  // Owned.
  Data* data_;
};
 
class KUDU_EXPORT KuduColumnStorageAttributes {
 public:
  enum EncodingType {
    AUTO_ENCODING = 0,
    PLAIN_ENCODING = 1,
    PREFIX_ENCODING = 2,
    RLE = 4,
    DICT_ENCODING = 5,
    BIT_SHUFFLE = 6,
 
    GROUP_VARINT = 3
  };
 
  enum CompressionType {
    DEFAULT_COMPRESSION = 0,
    NO_COMPRESSION = 1,
    SNAPPY = 2,
    LZ4 = 3,
    ZLIB = 4,
  };
 
 
  explicit KuduColumnStorageAttributes(
      EncodingType encoding = AUTO_ENCODING,
      CompressionType compression = DEFAULT_COMPRESSION,
      int32_t block_size = 0)
      ATTRIBUTE_DEPRECATED("this constructor will be private in a future release")
      : encoding_(encoding),
        compression_(compression),
        block_size_(block_size) {
  }
 
  const EncodingType encoding() const {
    return encoding_;
  }
 
  const CompressionType compression() const {
    return compression_;
  }
 
  std::string ToString() const;
 
  static Status StringToEncodingType(const std::string& encoding,
      EncodingType* type);
 
  static Status StringToCompressionType(const std::string& compression,
      CompressionType* type);
 
 private:
  EncodingType encoding_;
  CompressionType compression_;
  int32_t block_size_;
};
 
class KUDU_EXPORT KuduColumnSchema {
 public:
  enum DataType {
    INT8 = 0,
    INT16 = 1,
    INT32 = 2,
    INT64 = 3,
    STRING = 4,
    BOOL = 5,
    FLOAT = 6,
    DOUBLE = 7,
    BINARY = 8,
    UNIXTIME_MICROS = 9,
    DECIMAL = 10,
    VARCHAR = 11,
    TIMESTAMP = UNIXTIME_MICROS, 
    DATE = 12
  };
 
  static std::string DataTypeToString(DataType type);
 
  static Status StringToDataType(const std::string& type_str, DataType* type);
 
  KuduColumnSchema(const KuduColumnSchema& other);
  ~KuduColumnSchema();
 
  KuduColumnSchema& operator=(const KuduColumnSchema& other);
 
  void CopyFrom(const KuduColumnSchema& other);
 
  bool Equals(const KuduColumnSchema& other) const
      ATTRIBUTE_DEPRECATED("use operator==(const KuduColumnSchema&) instead");
 
  bool operator==(const KuduColumnSchema& rhs) const;
 
  bool operator!=(const KuduColumnSchema& rhs) const;
 
  const std::string& name() const;
 
  DataType type() const;
 
  bool is_nullable() const;
 
  KuduColumnTypeAttributes type_attributes() const;
 
  KuduColumnStorageAttributes storage_attributes() const;
 
  const std::string& comment() const;
 
 private:
  friend class KuduColumnSpec;
  friend class KuduSchema;
  friend class KuduSchemaBuilder;
  // KuduTableAlterer::Data needs to be a friend. Friending the parent class
  // is transitive to nested classes. See https://s.apache.org/inner-class-friends
  friend class KuduTableAlterer;
 
#ifdef KUDU_HEADERS_NO_STUBS
  FRIEND_TEST(KuduColumnSchemaTest, TestEquals);
#endif
 
  KuduColumnSchema();
 
#if defined(__clang__) || \
  (defined(__GNUC__) && (__GNUC__ * 10000 + __GNUC_MINOR__ * 100) >= 40600)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
  KuduColumnSchema(
      const std::string &name,
      DataType type,
      bool is_nullable = false,
      const void* default_value = NULL, //NOLINT(modernize-use-nullptr)
      const KuduColumnStorageAttributes& storage_attributes = KuduColumnStorageAttributes(),
      const KuduColumnTypeAttributes& type_attributes = KuduColumnTypeAttributes(),
      const std::string& comment = "");
#if defined(__clang__) || \
  (defined(__GNUC__) && (__GNUC__ * 10000 + __GNUC_MINOR__ * 100) >= 40600)
#pragma GCC diagnostic pop
#endif
 
  // Owned.
  ColumnSchema* col_;
};
 
class KUDU_EXPORT KuduColumnSpec {
 public:
  KuduColumnSpec* Default(KuduValue* value);
 
  KuduColumnSpec* Compression(KuduColumnStorageAttributes::CompressionType compression);
 
  KuduColumnSpec* Encoding(KuduColumnStorageAttributes::EncodingType encoding);
 
  KuduColumnSpec* BlockSize(int32_t block_size);
 
 
  KuduColumnSpec* Precision(int8_t precision);
 
  KuduColumnSpec* Scale(int8_t scale);
 
 
  KuduColumnSpec* Length(uint16_t length);
 
 
  KuduColumnSpec* PrimaryKey();
 
  KuduColumnSpec* NotNull();
 
  KuduColumnSpec* Nullable();
 
  KuduColumnSpec* Type(KuduColumnSchema::DataType type);
 
 
  KuduColumnSpec* RemoveDefault();
 
  KuduColumnSpec* RenameTo(const std::string& new_name);
 
  KuduColumnSpec* Comment(const std::string& comment);
 
 private:
  class KUDU_NO_EXPORT Data;
 
  friend class KuduSchemaBuilder;
  friend class KuduTableAlterer;
 
  // This class should always be owned and deleted by one of its friends,
  // not the user.
  ~KuduColumnSpec();
 
  explicit KuduColumnSpec(const std::string& col_name);
 
  Status ToColumnSchema(KuduColumnSchema* col) const;
 
  Status ToColumnSchemaDelta(ColumnSchemaDelta* col_delta) const;
 
  Slice DefaultValueAsSlice() const;
 
  // Owned.
  Data* data_;
};
 
class KUDU_EXPORT KuduSchemaBuilder {
 public:
  KuduSchemaBuilder();
  ~KuduSchemaBuilder();
 
  KuduColumnSpec* AddColumn(const std::string& name);
 
  KuduSchemaBuilder* SetPrimaryKey(const std::vector<std::string>& key_col_names);
 
  Status Build(KuduSchema* schema);
 
 private:
  class KUDU_NO_EXPORT Data;
 
  // Owned.
  Data* data_;
};
 
class KUDU_EXPORT KuduSchema {
 public:
  KuduSchema();
 
  KuduSchema(const KuduSchema& other);
  ~KuduSchema();
 
 
  KuduSchema& operator=(const KuduSchema& other);
 
  void CopyFrom(const KuduSchema& other);
 
  Status Reset(const std::vector<KuduColumnSchema>& columns, int key_columns)
      ATTRIBUTE_DEPRECATED("this method will be removed in a future release")
      WARN_UNUSED_RESULT;
 
  bool Equals(const KuduSchema& other) const
      ATTRIBUTE_DEPRECATED("use operator==(const KuduSchema&) instead");
 
  bool operator==(const KuduSchema& rhs) const;
 
  bool operator!=(const KuduSchema& rhs) const;
 
  KuduColumnSchema Column(size_t idx) const;
 
  bool HasColumn(const std::string& col_name, KuduColumnSchema* col_schema) const;
 
  size_t num_columns() const;
 
  void GetPrimaryKeyColumnIndexes(std::vector<int>* indexes) const;
 
  KuduPartialRow* NewRow() const;
 
  std::string ToString() const;
 
 
  static KuduSchema FromSchema(const Schema& schema) KUDU_NO_EXPORT;
 
  static Schema ToSchema(const KuduSchema& kudu_schema) KUDU_NO_EXPORT;
 
 
 private:
  friend class ClientTest;
  friend class KuduClient;
  friend class KuduScanner;
  friend class KuduScanToken;
  friend class KuduScanTokenBuilder;
  friend class KuduSchemaBuilder;
  friend class KuduTable;
  friend class KuduTableCreator;
  friend class KuduWriteOperation;
  friend class ScanConfiguration;
  friend class internal::GetTableSchemaRpc;
  friend class internal::LookupRpc;
  friend class internal::MetaCache;
  friend class internal::MetaCacheEntry;
  friend class internal::WriteRpc;
  friend class tools::RemoteKsckCluster;
  friend class tools::ReplicaDumper;
 
  // For use by KuduSchema::FromSchema.
  explicit KuduSchema(const Schema& schema);
#if __cplusplus >= 201103
  explicit KuduSchema(Schema&& schema);
#endif
 
  // Private since we don't want users to rely on the first N columns
  // being the keys.
  size_t num_key_columns() const;
 
  // Owned.
  Schema* schema_;
};
 
} // namespace client
} // namespace kudu
#endif // KUDU_CLIENT_SCHEMA_H