bug with scan token and non-covering range partitions?

scantoken_noncoveringrange.cc

#include "kudu/client/client.h"

using namespace std;

using std::string;
using kudu::client::sp::shared_ptr;
using kudu::client::KuduClient;
using kudu::client::KuduClientBuilder;
using kudu::client::KuduColumnSchema;
using kudu::client::KuduInsert;
using kudu::client::KuduScanToken;
using kudu::client::KuduScanTokenBuilder;
using kudu::client::KuduSchema;
using kudu::client::KuduSchemaBuilder;
using kudu::client::KuduSession;
using kudu::client::KuduTable;
using kudu::client::KuduTableCreator;
using kudu::Slice;
using kudu::Status;
using kudu::KuduPartialRow;

int main(const int argc, const char **argv) {
  kudu::client::SetVerboseLogLevel(0);
  shared_ptr<KuduClient> client;
  KUDU_CHECK_OK(KuduClientBuilder().add_master_server_addr("localhost:7051").Build(&client));

  // delete if exists
  bool exists;
  KUDU_CHECK_OK(client->TableExists("categories", &exists));
  if (exists) {
    KUDU_CHECK_OK(client->DeleteTable("categories"));
  }

  // schema
  KuduSchema categories_schema;
  KuduSchemaBuilder categories_builder;
  categories_builder.AddColumn("key")->Type(KuduColumnSchema::INT32)->NotNull();
  categories_builder.AddColumn("province")->Type(KuduColumnSchema::STRING)->NotNull();
  categories_builder.SetPrimaryKey({ "key", "province" });
  KUDU_CHECK_OK(categories_builder.Build(&categories_schema));

  // create
  const string categories_name = "categories";
  unique_ptr<KuduTableCreator> categories_tc(client->NewTableCreator());
  categories_tc->set_range_partition_columns({ "province" });
  const vector<string> provinces = { "AB", "BC", "MB", "NB", "NL", "NS", "NT",
                                     "NU", "ON", "PE", "QC", "SK", "YT" };
  for (const auto& province : provinces) {
    unique_ptr<KuduPartialRow> province_begin(categories_schema.NewRow());
    KUDU_CHECK_OK(province_begin->SetStringCopy("province", province));
    unique_ptr<KuduPartialRow> province_end(categories_schema.NewRow());
    KUDU_CHECK_OK(province_end->SetStringCopy("province", province));
    categories_tc->add_range_partition(province_begin.release(), province_end.release(),
                                       KuduTableCreator::INCLUSIVE_BOUND, KuduTableCreator::INCLUSIVE_BOUND);
  }
  KUDU_CHECK_OK(categories_tc->table_name(categories_name)
                    .schema(&categories_schema)
                    .wait(true)
                    .Create());

  bool created;
  KUDU_CHECK_OK(client->TableExists(categories_name, &created));
  created ? KUDU_LOG(INFO) << "Created table " << categories_name :
            KUDU_LOG(INFO) << "Failed to create table " << categories_name;

  shared_ptr<KuduTable> categories_table;
  KUDU_CHECK_OK(client->OpenTable(categories_name, &categories_table));

  shared_ptr<KuduSession> session = client->NewSession();
  KUDU_CHECK_OK(session->SetFlushMode(KuduSession::MANUAL_FLUSH));
  session->SetTimeoutMillis(5000);

  // insert
  for (const auto& province : provinces) {
    KuduInsert* categories_insert = categories_table->NewInsert();
    KuduPartialRow* row = categories_insert->mutable_row();
    KUDU_CHECK_OK(row->SetInt32("key", 691));
    KUDU_CHECK_OK(row->SetStringCopy("province", province));
    KUDU_CHECK_OK(session->Apply(categories_insert));
  }
  KUDU_CHECK_OK(session->Flush());
  KUDU_LOG(INFO) << "Inserted " << provinces.size() << " rows into " << categories_name;

  // bug? error about non-covered range YT -> (end)
  KuduScanTokenBuilder categories_token_builder(categories_table.get());
  KUDU_CHECK_OK(categories_token_builder.SetFaultTolerant());
  KUDU_CHECK_OK(categories_token_builder.SetProjectedColumnNames({ "province" }));
  vector<KuduScanToken*> categories_tokens;
  KUDU_CHECK_OK(categories_token_builder.Build(&categories_tokens));

  // error:
  // Check failed: _s.ok() Bad status: Not found: No tablet covering the requested range partition: NonCoveredRange { lower_bound: (string province=YT\000), upper_bound: (<end>), ttl: 3599915ms }

  return 0;
}