scan_batch.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_SCAN_BATCH_H
#define KUDU_CLIENT_SCAN_BATCH_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 <iterator>
#include <string>
 
#ifdef KUDU_HEADERS_NO_STUBS
#include "kudu/gutil/macros.h"
#include "kudu/gutil/port.h"
#else
#include "kudu/client/stubs.h"
#endif
 
#include "kudu/util/int128.h"
#include "kudu/util/kudu_export.h"
#include "kudu/util/slice.h"
#include "kudu/util/status.h"
 
namespace kudu {
class Schema;
 
namespace tools {
class ReplicaDumper;
class TableScanner;
} // namespace tools
 
namespace client {
class KuduSchema;
 
class KUDU_EXPORT KuduScanBatch {
 public:
  class RowPtr;
 
  class const_iterator;
 
  typedef RowPtr value_type;
 
  KuduScanBatch();
  ~KuduScanBatch();
 
  int NumRows() const;
 
  KuduScanBatch::RowPtr Row(int idx) const;
 
  const_iterator begin() const;
  const_iterator end() const;
 
  const KuduSchema* projection_schema() const;
 
 
  Slice direct_data() const;
 
  Slice indirect_data() const;
 
 private:
  class KUDU_NO_EXPORT Data;
  friend class KuduScanner;
  friend class tools::ReplicaDumper;
 
  Data* data_;
  DISALLOW_COPY_AND_ASSIGN(KuduScanBatch);
};
 
class KUDU_EXPORT KuduScanBatch::RowPtr {
 public:
  RowPtr() : schema_(NULL), row_data_(NULL) {}
 
 
  const RowPtr* operator->() const {
    return this;
  }
  bool IsNull(const Slice& col_name) const;
 
  bool IsNull(int col_idx) const;
 
  Status IsDeleted(bool* val) const WARN_UNUSED_RESULT KUDU_NO_EXPORT;
 
 
  Status GetBool(const Slice& col_name, bool* val) const WARN_UNUSED_RESULT;
  Status GetInt8(const Slice& col_name, int8_t* val) const WARN_UNUSED_RESULT;
  Status GetInt16(const Slice& col_name, int16_t* val) const WARN_UNUSED_RESULT;
  Status GetInt32(const Slice& col_name, int32_t* val) const WARN_UNUSED_RESULT;
  Status GetInt64(const Slice& col_name, int64_t* val) const WARN_UNUSED_RESULT;
  Status GetUnixTimeMicros(const Slice& col_name,
                           int64_t* micros_since_utc_epoch) const WARN_UNUSED_RESULT;
  Status GetDate(const Slice& col_name, int32_t* days_since_unix_epoch) const WARN_UNUSED_RESULT;
  Status GetFloat(const Slice& col_name, float* val) const WARN_UNUSED_RESULT;
  Status GetDouble(const Slice& col_name, double* val) const WARN_UNUSED_RESULT;
#if KUDU_INT128_SUPPORTED
  Status GetUnscaledDecimal(const Slice& col_name, int128_t* val) const WARN_UNUSED_RESULT;
#endif
 
 
  Status GetBool(int col_idx, bool* val) const WARN_UNUSED_RESULT;
  Status GetInt8(int col_idx, int8_t* val) const WARN_UNUSED_RESULT;
  Status GetInt16(int col_idx, int16_t* val) const WARN_UNUSED_RESULT;
  Status GetInt32(int col_idx, int32_t* val) const WARN_UNUSED_RESULT;
  Status GetInt64(int col_idx, int64_t* val) const WARN_UNUSED_RESULT;
  Status GetUnixTimeMicros(int col_idx, int64_t* micros_since_utc_epoch) const WARN_UNUSED_RESULT;
  Status GetDate(int col_idx, int32_t* days_since_unix_epoch) const WARN_UNUSED_RESULT;
  Status GetFloat(int col_idx, float* val) const WARN_UNUSED_RESULT;
  Status GetDouble(int col_idx, double* val) const WARN_UNUSED_RESULT;
#if KUDU_INT128_SUPPORTED
  Status GetUnscaledDecimal(int col_idx, int128_t* val) const WARN_UNUSED_RESULT;
#endif
 
 
  Status GetString(const Slice& col_name, Slice* val) const WARN_UNUSED_RESULT;
  Status GetBinary(const Slice& col_name, Slice* val) const WARN_UNUSED_RESULT;
  Status GetVarchar(const Slice& col_name, Slice* val) const WARN_UNUSED_RESULT;
 
 
  Status GetString(int col_idx, Slice* val) const WARN_UNUSED_RESULT;
  Status GetBinary(int col_idx, Slice* val) const WARN_UNUSED_RESULT;
  Status GetVarchar(int col_idx, Slice* val) const WARN_UNUSED_RESULT;
 
  const void* cell(int col_idx) const;
 
  std::string ToString() const;
 
 private:
  friend class KuduScanBatch;
  friend class tools::TableScanner;
  template<typename KeyTypeWrapper> friend struct SliceKeysTestSetup;
  template<typename KeyTypeWrapper> friend struct IntKeysTestSetup;
 
  // Only invoked by KuduScanner.
  RowPtr(const Schema* schema,
         const uint8_t* row_data)
      : schema_(schema),
        row_data_(row_data) {
  }
 
  template<typename T>
  Status Get(const Slice& col_name, typename T::cpp_type* val) const;
 
  template<typename T>
  Status Get(int col_idx, typename T::cpp_type* val) const;
 
  const Schema* schema_;
  const uint8_t* row_data_;
};
 
// std::iterator has been deprecated in C++17, but this code should still be
// compilable by legacy C++98 compilers as well. It's also necessary to keep
// backward compatibility with the ABI provided by earlier Kudu releases,
// so modifiying the inheritance chain isn't an option. Instead of removing
// the inheritance from std::iterator<...> and explicitly defining the types
// required by the STL iterator traits, the deprecation warnings are silenced.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
class KUDU_EXPORT KuduScanBatch::const_iterator
    : public std::iterator<std::forward_iterator_tag, KuduScanBatch::RowPtr> {
 public:
  ~const_iterator() {}
 
  KuduScanBatch::RowPtr operator*() const {
    return batch_->Row(idx_);
  }
 
 
  KuduScanBatch::RowPtr operator->() const {
    return batch_->Row(idx_);
  }
 
  const_iterator& operator++() {
    ++idx_;
    return *this;
  }
 
  const_iterator operator++(int) {
    const_iterator tmp(batch_, idx_);
    ++idx_;
    return tmp;
  }
 
  bool operator==(const const_iterator& other) const {
    return (idx_ == other.idx_) && (batch_ == other.batch_);
  }
 
  bool operator!=(const const_iterator& other) const {
    return !(*this == other);
  }
 
 private:
  friend class KuduScanBatch;
  const_iterator(const KuduScanBatch* b, int idx)
      : batch_(b),
        idx_(idx) {
  }
 
  const KuduScanBatch* const batch_;
  int idx_;
};
#pragma GCC diagnostic pop
 
inline KuduScanBatch::const_iterator KuduScanBatch::begin() const {
  return const_iterator(this, 0);
}
 
inline KuduScanBatch::const_iterator KuduScanBatch::end() const {
  return const_iterator(this, NumRows());
}
 
} // namespace client
} // namespace kudu
 
#endif