You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kudu.apache.org by al...@apache.org on 2019/01/05 01:22:05 UTC
kudu git commit: [c++] remove -Wno-deprecated compiler's flag
Repository: kudu
Updated Branches:
refs/heads/master 08dadc9f6 -> 678dbac6f
[c++] remove -Wno-deprecated compiler's flag
Removed -Wno-deprecated compiler's flag, replaced some of the
deprecated Kudu API calls with their contemporary counterparts and
added 'pragma GCC diagnostic' blocks elsewhere.
The motivation for this change was seeing too many warnings
while building the python Kudu client.
Change-Id: I513bd49642755dbcb7ed405391fb13096ee49759
Reviewed-on: http://gerrit.cloudera.org:8080/12140
Reviewed-by: Adar Dembo <ad...@cloudera.com>
Tested-by: Kudu Jenkins
Project: http://git-wip-us.apache.org/repos/asf/kudu/repo
Commit: http://git-wip-us.apache.org/repos/asf/kudu/commit/678dbac6
Tree: http://git-wip-us.apache.org/repos/asf/kudu/tree/678dbac6
Diff: http://git-wip-us.apache.org/repos/asf/kudu/diff/678dbac6
Branch: refs/heads/master
Commit: 678dbac6fb05d0370e40e6645d4b1ec530fa0180
Parents: 08dadc9
Author: Alexey Serbin <al...@apache.org>
Authored: Fri Dec 28 18:16:17 2018 -0800
Committer: Alexey Serbin <as...@cloudera.com>
Committed: Sat Jan 5 01:21:37 2019 +0000
----------------------------------------------------------------------
CMakeLists.txt | 3 -
src/kudu/benchmarks/tpch/rpc_line_item_dao.cc | 8 ++-
src/kudu/client/client-test-util.cc | 7 +-
src/kudu/client/client-test.cc | 62 ++++++++++--------
src/kudu/client/scan_token-internal.cc | 3 +
src/kudu/client/scan_token-test.cc | 6 ++
src/kudu/client/schema.cc | 9 +++
src/kudu/client/schema.h | 9 +++
src/kudu/integration-tests/all_types-itest.cc | 3 +
src/kudu/integration-tests/alter_table-test.cc | 67 +++++++++++---------
src/kudu/integration-tests/cluster_verifier.cc | 24 +++----
.../create-table-stress-test.cc | 3 +
.../integration-tests/delete_table-itest.cc | 3 +
.../flex_partitioning-itest.cc | 3 +
.../full_stack-insert-scan-test.cc | 45 ++++++-------
src/kudu/integration-tests/fuzz-itest.cc | 2 +-
.../heavy-update-compaction-itest.cc | 42 ++++++------
.../integration-tests/linked_list-test-util.h | 11 ++--
src/kudu/integration-tests/tablet_copy-itest.cc | 3 +
src/kudu/integration-tests/test_workload.cc | 3 +
.../update_scan_delta_compact-test.cc | 43 +++++++------
src/kudu/tools/ksck_remote-test.cc | 3 +
22 files changed, 216 insertions(+), 146 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ce6d943..f3856f4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -134,9 +134,6 @@ set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-sign-compare")
# which appear in the Kudu source code due to the use of ASCII art and
# multi-line command line examples in comments.
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-comment")
-# -Wno-deprecated: we currently have a number of places using deprecated functions
-# (mostly our own functions). TODO(todd) remove or individually suppress call sites.
-set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-deprecated")
# -pthread: enable multithreaded malloc
set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -pthread")
# -fno-strict-aliasing
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/benchmarks/tpch/rpc_line_item_dao.cc
----------------------------------------------------------------------
diff --git a/src/kudu/benchmarks/tpch/rpc_line_item_dao.cc b/src/kudu/benchmarks/tpch/rpc_line_item_dao.cc
index 531ef1f..adad044 100644
--- a/src/kudu/benchmarks/tpch/rpc_line_item_dao.cc
+++ b/src/kudu/benchmarks/tpch/rpc_line_item_dao.cc
@@ -142,9 +142,12 @@ void RpcLineItemDAO::Init() {
.schema(&schema)
.num_replicas(1);
if (partition_strategy_ == RANGE) {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
table_creator
->set_range_partition_columns({tpch::kOrderKeyColName, tpch::kLineNumberColName })
.split_rows(tablet_splits_);
+#pragma GCC diagnostic pop
} else {
table_creator->add_hash_partitions({ tpch::kOrderKeyColName }, num_buckets_);
}
@@ -225,7 +228,7 @@ void RpcLineItemDAO::OpenScannerImpl(const vector<string>& columns,
gscoped_ptr<Scanner> ret(new Scanner);
ret->scanner_.reset(new KuduScanner(client_table_.get()));
ret->scanner_->SetCacheBlocks(FLAGS_tpch_cache_blocks_when_scanning);
- CHECK_OK(ret->scanner_->SetProjectedColumns(columns));
+ CHECK_OK(ret->scanner_->SetProjectedColumnNames(columns));
for (KuduPredicate* pred : preds) {
CHECK_OK(ret->scanner_->AddConjunctPredicate(pred));
}
@@ -256,7 +259,10 @@ bool RpcLineItemDAO::Scanner::HasMore() {
}
void RpcLineItemDAO::Scanner::GetNext(vector<KuduRowResult> *rows) {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
CHECK_OK(scanner_->NextBatch(rows));
+#pragma GCC diagnostic pop
}
} // namespace kudu
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/client/client-test-util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/client-test-util.cc b/src/kudu/client/client-test-util.cc
index aa03f8a..678386a 100644
--- a/src/kudu/client/client-test-util.cc
+++ b/src/kudu/client/client-test-util.cc
@@ -24,7 +24,6 @@
#include <glog/logging.h>
#include <gtest/gtest.h>
-#include "kudu/client/row_result.h"
#include "kudu/client/scan_batch.h"
#include "kudu/client/write_op.h"
#include "kudu/gutil/stl_util.h"
@@ -121,10 +120,10 @@ Status CountRowsWithRetries(KuduScanner* scanner, size_t* row_count) {
Status ScanToStrings(KuduScanner* scanner, vector<string>* row_strings) {
RETURN_NOT_OK(scanner->Open());
- vector<KuduRowResult> rows;
+ KuduScanBatch batch;
while (scanner->HasMoreRows()) {
- RETURN_NOT_OK(scanner->NextBatch(&rows));
- for (const KuduRowResult& row : rows) {
+ RETURN_NOT_OK(scanner->NextBatch(&batch));
+ for (const KuduScanBatch::RowPtr row : batch) {
row_strings->push_back(row.ToString());
}
}
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/client/client-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/client-test.cc b/src/kudu/client/client-test.cc
index e746afc..1979645 100644
--- a/src/kudu/client/client-test.cc
+++ b/src/kudu/client/client-test.cc
@@ -142,6 +142,18 @@ METRIC_DECLARE_histogram(handler_latency_kudu_master_MasterService_GetTableLocat
METRIC_DECLARE_histogram(handler_latency_kudu_master_MasterService_GetTabletLocations);
METRIC_DECLARE_histogram(handler_latency_kudu_tserver_TabletServerService_Scan);
+using base::subtle::Atomic32;
+using base::subtle::NoBarrier_AtomicIncrement;
+using base::subtle::NoBarrier_Load;
+using base::subtle::NoBarrier_Store;
+using kudu::cluster::InternalMiniCluster;
+using kudu::cluster::InternalMiniClusterOptions;
+using kudu::master::CatalogManager;
+using kudu::master::GetTableLocationsRequestPB;
+using kudu::master::GetTableLocationsResponsePB;
+using kudu::client::sp::shared_ptr;
+using kudu::tablet::TabletReplica;
+using kudu::tserver::MiniTabletServer;
using std::bind;
using std::function;
using std::map;
@@ -156,20 +168,6 @@ using strings::Substitute;
namespace kudu {
namespace client {
-using base::subtle::Atomic32;
-using base::subtle::NoBarrier_AtomicIncrement;
-using base::subtle::NoBarrier_Load;
-using base::subtle::NoBarrier_Store;
-using cluster::InternalMiniCluster;
-using cluster::InternalMiniClusterOptions;
-using master::CatalogManager;
-using master::GetTableLocationsRequestPB;
-using master::GetTableLocationsResponsePB;
-using master::TabletLocationsPB;
-using sp::shared_ptr;
-using tablet::TabletReplica;
-using tserver::MiniTabletServer;
-
class ClientTest : public KuduTest {
public:
ClientTest() {
@@ -412,7 +410,7 @@ class ClientTest : public KuduTest {
string tablet_id = GetFirstTabletId(client_table_.get());
// Flush to ensure we scan disk later
FlushTablet(tablet_id);
- ASSERT_OK(scanner.SetProjectedColumns({ "key" }));
+ ASSERT_OK(scanner.SetProjectedColumnNames({ "key" }));
LOG_TIMING(INFO, "Scanning disk with no predicates") {
ASSERT_OK(scanner.Open());
ASSERT_TRUE(scanner.HasMoreRows());
@@ -471,7 +469,7 @@ class ClientTest : public KuduTest {
void DoTestScanWithoutPredicates() {
KuduScanner scanner(client_table_.get());
- ASSERT_OK(scanner.SetProjectedColumns({ "key" }));
+ ASSERT_OK(scanner.SetProjectedColumnNames({ "key" }));
LOG_TIMING(INFO, "Scanning with no predicates") {
ASSERT_OK(scanner.Open());
@@ -570,7 +568,7 @@ class ClientTest : public KuduTest {
int32_t lower_bound, int32_t upper_bound) {
KuduScanner scanner(table);
CHECK_OK(scanner.SetSelection(selection));
- CHECK_OK(scanner.SetProjectedColumns(vector<string>()));
+ CHECK_OK(scanner.SetProjectedColumnNames({}));
if (lower_bound != kNoBound) {
CHECK_OK(scanner.AddConjunctPredicate(
client_table_->NewComparisonPredicate("key", KuduPredicate::GREATER_EQUAL,
@@ -1115,7 +1113,7 @@ INSTANTIATE_TEST_CASE_P(Params, ScanMultiTabletParamTest,
TEST_F(ClientTest, TestScanEmptyTable) {
KuduScanner scanner(client_table_.get());
- ASSERT_OK(scanner.SetProjectedColumns(vector<string>()));
+ ASSERT_OK(scanner.SetProjectedColumnNames({}));
ASSERT_OK(scanner.Open());
// There are two tablets in the table, both empty. Until we scan to
@@ -1135,7 +1133,7 @@ TEST_F(ClientTest, TestScanEmptyProjection) {
ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_table_.get(),
FLAGS_test_scan_num_rows));
KuduScanner scanner(client_table_.get());
- ASSERT_OK(scanner.SetProjectedColumns(vector<string>()));
+ ASSERT_OK(scanner.SetProjectedColumnNames({}));
ASSERT_EQ(scanner.GetProjectionSchema().num_columns(), 0);
LOG_TIMING(INFO, "Scanning with no projected columns") {
ASSERT_OK(scanner.Open());
@@ -1153,14 +1151,14 @@ TEST_F(ClientTest, TestScanEmptyProjection) {
TEST_F(ClientTest, TestProjectInvalidColumn) {
KuduScanner scanner(client_table_.get());
- Status s = scanner.SetProjectedColumns({ "column-doesnt-exist" });
+ Status s = scanner.SetProjectedColumnNames({ "column-doesnt-exist" });
ASSERT_EQ(R"(Not found: Column: "column-doesnt-exist" was not found in the table schema.)",
s.ToString());
// Test trying to use a projection where a column is used multiple times.
// TODO: consider fixing this to support returning the column multiple
// times, even though it's not very useful.
- s = scanner.SetProjectedColumns({ "key", "key" });
+ s = scanner.SetProjectedColumnNames({ "key", "key" });
ASSERT_EQ("Invalid argument: Duplicate column name: key", s.ToString());
}
@@ -1170,7 +1168,7 @@ TEST_F(ClientTest, TestScanPredicateKeyColNotProjected) {
ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_table_.get(),
FLAGS_test_scan_num_rows));
KuduScanner scanner(client_table_.get());
- ASSERT_OK(scanner.SetProjectedColumns({ "int_val" }));
+ ASSERT_OK(scanner.SetProjectedColumnNames({ "int_val" }));
ASSERT_EQ(scanner.GetProjectionSchema().num_columns(), 1);
ASSERT_EQ(scanner.GetProjectionSchema().Column(0).type(), KuduColumnSchema::INT32);
ASSERT_OK(scanner.AddConjunctPredicate(
@@ -1217,7 +1215,7 @@ TEST_F(ClientTest, TestScanPredicateNonKeyColNotProjected) {
size_t nrows = 0;
int32_t curr_key = 10;
- ASSERT_OK(scanner.SetProjectedColumns({ "key" }));
+ ASSERT_OK(scanner.SetProjectedColumnNames({ "key" }));
LOG_TIMING(INFO, "Scanning with predicate columns not projected") {
ASSERT_OK(scanner.Open());
@@ -1305,7 +1303,7 @@ TEST_F(ClientTest, TestRowPtrNoRedaction) {
NO_FATALS(InsertTestRows(client_table_.get(), FLAGS_test_scan_num_rows));
KuduScanner scanner(client_table_.get());
- ASSERT_OK(scanner.SetProjectedColumns({ "key" }));
+ ASSERT_OK(scanner.SetProjectedColumnNames({ "key" }));
ASSERT_OK(scanner.Open());
ASSERT_TRUE(scanner.HasMoreRows());
@@ -2545,9 +2543,12 @@ TEST_F(ClientTest, TestAsyncFlushResponseAfterSessionDropped) {
session = client_->NewSession();
ASSERT_OK(session->SetFlushMode(KuduSession::MANUAL_FLUSH));
ASSERT_OK(ApplyInsertToSession(session.get(), client_table_, 1, 1, "row"));
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
ASSERT_EQ(1, session->CountBufferedOperations());
session->FlushAsync(&cb);
ASSERT_EQ(0, session->CountBufferedOperations());
+#pragma GCC diagnostic pop
session.reset();
ASSERT_FALSE(s.Wait().ok());
}
@@ -2891,7 +2892,10 @@ TEST_F(ClientTest, TestSetSessionMutationBufferMaxNum) {
// pending operations.
ASSERT_OK(session->SetFlushMode(KuduSession::MANUAL_FLUSH));
ASSERT_OK(ApplyInsertToSession(session.get(), client_table_, 0, 0, "x"));
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
ASSERT_EQ(1, session->CountBufferedOperations());
+#pragma GCC diagnostic pop
ASSERT_EQ(0, session->CountPendingErrors());
ASSERT_TRUE(session->HasPendingOperations());
Status s = session->SetMutationBufferMaxNum(3);
@@ -2924,7 +2928,10 @@ TEST_F(ClientTest, TestFlushNoCurrentBatcher) {
ASSERT_OK(ApplyInsertToSession(session.get(), client_table_, 0, 0, "0"));
ASSERT_TRUE(session->HasPendingOperations());
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
ASSERT_EQ(1, session->CountBufferedOperations());
+#pragma GCC diagnostic pop
ASSERT_EQ(0, session->CountPendingErrors());
// OK, now the current batcher should be at place.
ASSERT_OK(session->Flush());
@@ -4446,12 +4453,15 @@ TEST_F(ClientTest, TestCreateTableWithTooManyTablets) {
ASSERT_OK(split2->SetInt32("key", 2));
unique_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
Status s = table_creator->table_name("foobar")
.schema(&schema_)
.set_range_partition_columns({ "key" })
.split_rows({ split1, split2 })
.num_replicas(3)
.Create();
+#pragma GCC diagnostic pop
ASSERT_TRUE(s.IsInvalidArgument());
ASSERT_STR_CONTAINS(s.ToString(),
"the requested number of tablet replicas is over the "
@@ -5450,7 +5460,7 @@ TEST_F(ClientTest, TestGetSecurityInfoFromMaster) {
struct ServiceUnavailableRetryParams {
MonoDelta usurper_sleep;
MonoDelta client_timeout;
- std::function<bool(const Status&)> status_check;
+ function<bool(const Status&)> status_check;
};
class ServiceUnavailableRetryClientTest :
@@ -5664,7 +5674,7 @@ TEST_F(ClientTest, TestSubsequentScanRequestReturnsNoData) {
// Set up a table scan.
KuduScanner scanner(client_table_.get());
- ASSERT_OK(scanner.SetProjectedColumns({ "key" }));
+ ASSERT_OK(scanner.SetProjectedColumnNames({ "key" }));
// Ensure that the new scan RPC does not return the data.
//
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/client/scan_token-internal.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/scan_token-internal.cc b/src/kudu/client/scan_token-internal.cc
index 2bfc445..787f767 100644
--- a/src/kudu/client/scan_token-internal.cc
+++ b/src/kudu/client/scan_token-internal.cc
@@ -138,12 +138,15 @@ Status KuduScanToken::Data::PBIntoScanner(KuduClient* client,
configuration->AddConjunctPredicate(std::move(*predicate));
}
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
if (message.has_lower_bound_primary_key()) {
RETURN_NOT_OK(scan_builder->AddLowerBoundRaw(message.lower_bound_primary_key()));
}
if (message.has_upper_bound_primary_key()) {
RETURN_NOT_OK(scan_builder->AddExclusiveUpperBoundRaw(message.upper_bound_primary_key()));
}
+#pragma GCC diagnostic pop
if (message.has_lower_bound_partition_key()) {
RETURN_NOT_OK(scan_builder->AddLowerBoundPartitionKeyRaw(message.lower_bound_partition_key()));
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/client/scan_token-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/scan_token-test.cc b/src/kudu/client/scan_token-test.cc
index 6cde3fd..fe94ff8 100644
--- a/src/kudu/client/scan_token-test.cc
+++ b/src/kudu/client/scan_token-test.cc
@@ -157,12 +157,15 @@ TEST_F(ScanTokenTest, TestScanTokens) {
unique_ptr<KuduPartialRow> split(schema.NewRow());
ASSERT_OK(split->SetInt64("col", 0));
unique_ptr<client::KuduTableCreator> table_creator(client_->NewTableCreator());
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
ASSERT_OK(table_creator->table_name("table")
.schema(&schema)
.add_hash_partitions({ "col" }, 4)
.split_rows({ split.release() })
.num_replicas(1)
.Create());
+#pragma GCC diagnostic pop
ASSERT_OK(client_->OpenTable("table", &table));
}
@@ -496,12 +499,15 @@ TEST_P(TimestampPropagationParamTest, Test) {
unique_ptr<KuduPartialRow> split(schema.NewRow());
ASSERT_OK(split->SetInt64(kKeyColumnName, 0));
unique_ptr<client::KuduTableCreator> creator(client_->NewTableCreator());
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
ASSERT_OK(creator->table_name(kTableName)
.schema(&schema)
.add_hash_partitions({ kKeyColumnName }, 2)
.split_rows({ split.release() })
.num_replicas(1)
.Create());
+#pragma GCC diagnostic pop
}
}
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/client/schema.cc
----------------------------------------------------------------------
diff --git a/src/kudu/client/schema.cc b/src/kudu/client/schema.cc
index f09fc10..6e7824e 100644
--- a/src/kudu/client/schema.cc
+++ b/src/kudu/client/schema.cc
@@ -367,10 +367,13 @@ Status KuduColumnSpec::ToColumnSchema(KuduColumnSchema* col) const {
block_size = data_->block_size;
}
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
*col = KuduColumnSchema(data_->name, data_->type, nullable,
default_val,
KuduColumnStorageAttributes(encoding, compression, block_size),
type_attrs);
+#pragma GCC diagnostic pop
return Status::OK();
}
@@ -548,7 +551,10 @@ Status KuduSchemaBuilder::Build(KuduSchema* schema) {
num_key_cols = key_col_indexes.size();
}
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
RETURN_NOT_OK(schema->Reset(cols, num_key_cols));
+#pragma GCC diagnostic pop
return Status::OK();
}
@@ -709,8 +715,11 @@ bool KuduSchema::Equals(const KuduSchema& other) const {
KuduColumnSchema KuduSchema::Column(size_t idx) const {
ColumnSchema col(schema_->column(idx));
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
KuduColumnStorageAttributes attrs(FromInternalEncodingType(col.attributes().encoding),
FromInternalCompressionType(col.attributes().compression));
+#pragma GCC diagnostic pop
KuduColumnTypeAttributes type_attrs(col.type_attributes().precision, col.type_attributes().scale);
return KuduColumnSchema(col.name(), FromInternalDataType(col.type_info()->type()),
col.is_nullable(), col.read_default_value(),
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/client/schema.h
----------------------------------------------------------------------
diff --git a/src/kudu/client/schema.h b/src/kudu/client/schema.h
index a243c42..217cf1f 100644
--- a/src/kudu/client/schema.h
+++ b/src/kudu/client/schema.h
@@ -250,6 +250,11 @@ class KUDU_EXPORT KuduColumnSchema {
KuduColumnSchema();
+#if defined(__clang__) || \
+ (defined(__GNUC__) && (__GNUC__ * 10000 + __GNUC_MINOR__ * 100) >= 40600)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
/// This constructor is private because clients should use the Builder API.
KuduColumnSchema(
const std::string &name,
@@ -258,6 +263,10 @@ class KUDU_EXPORT KuduColumnSchema {
const void* default_value = NULL, //NOLINT(modernize-use-nullptr)
const KuduColumnStorageAttributes& storage_attributes = KuduColumnStorageAttributes(),
const KuduColumnTypeAttributes& type_attributes = KuduColumnTypeAttributes());
+#if defined(__clang__) || \
+ (defined(__GNUC__) && (__GNUC__ * 10000 + __GNUC_MINOR__ * 100) >= 40600)
+#pragma GCC diagnostic pop
+#endif
// Owned.
ColumnSchema* col_;
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/integration-tests/all_types-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/all_types-itest.cc b/src/kudu/integration-tests/all_types-itest.cc
index e4e9575..21c09b7 100644
--- a/src/kudu/integration-tests/all_types-itest.cc
+++ b/src/kudu/integration-tests/all_types-itest.cc
@@ -334,12 +334,15 @@ class AllTypesItest : public KuduTest {
split_rows_.push_back(*row);
}
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
RETURN_NOT_OK(table_creator->table_name("all-types-table")
.schema(&schema_)
.set_range_partition_columns({ "key" })
.split_rows(split_rows)
.num_replicas(kNumTabletServers)
.Create());
+#pragma GCC diagnostic pop
return client_->OpenTable("all-types-table", &table_);
}
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/integration-tests/alter_table-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/alter_table-test.cc b/src/kudu/integration-tests/alter_table-test.cc
index 6bc7929..7ffde6c 100644
--- a/src/kudu/integration-tests/alter_table-test.cc
+++ b/src/kudu/integration-tests/alter_table-test.cc
@@ -36,6 +36,7 @@
#include "kudu/client/client-test-util.h"
#include "kudu/client/client.h"
#include "kudu/client/row_result.h"
+#include "kudu/client/scan_batch.h"
#include "kudu/client/schema.h"
#include "kudu/client/shared_ptr.h"
#include "kudu/client/value.h"
@@ -77,37 +78,38 @@ DECLARE_int32(flush_threshold_mb);
DECLARE_bool(use_hybrid_clock);
DECLARE_bool(scanner_allow_snapshot_scans_with_logical_timestamps);
-namespace kudu {
-
-using client::CountTableRows;
-using client::KuduClient;
-using client::KuduClientBuilder;
-using client::KuduColumnSchema;
-using client::KuduDelete;
-using client::KuduError;
-using client::KuduInsert;
-using client::KuduRowResult;
-using client::KuduScanner;
-using client::KuduSchema;
-using client::KuduSchemaBuilder;
-using client::KuduSession;
-using client::KuduTable;
-using client::KuduTableAlterer;
-using client::KuduTableCreator;
-using client::KuduUpdate;
-using client::KuduValue;
-using client::sp::shared_ptr;
-using cluster::InternalMiniCluster;
-using cluster::InternalMiniClusterOptions;
-using master::AlterTableRequestPB;
-using master::AlterTableResponsePB;
+using kudu::client::CountTableRows;
+using kudu::client::KuduClient;
+using kudu::client::KuduClientBuilder;
+using kudu::client::KuduColumnSchema;
+using kudu::client::KuduDelete;
+using kudu::client::KuduError;
+using kudu::client::KuduInsert;
+using kudu::client::KuduRowResult;
+using kudu::client::KuduScanBatch;
+using kudu::client::KuduScanner;
+using kudu::client::KuduSchema;
+using kudu::client::KuduSchemaBuilder;
+using kudu::client::KuduSession;
+using kudu::client::KuduTable;
+using kudu::client::KuduTableAlterer;
+using kudu::client::KuduTableCreator;
+using kudu::client::KuduUpdate;
+using kudu::client::KuduValue;
+using kudu::client::sp::shared_ptr;
+using kudu::cluster::InternalMiniCluster;
+using kudu::cluster::InternalMiniClusterOptions;
+using kudu::master::AlterTableRequestPB;
+using kudu::master::AlterTableResponsePB;
+using kudu::tablet::TabletReplica;
using std::atomic;
using std::map;
using std::pair;
using std::string;
using std::unique_ptr;
using std::vector;
-using tablet::TabletReplica;
+
+namespace kudu {
class AlterTableTest : public KuduTest {
public:
@@ -256,12 +258,15 @@ class AlterTableTest : public KuduTest {
split_rows.push_back(row);
}
gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
return table_creator->table_name(table_name)
.schema(&schema_)
.set_range_partition_columns({ "c0" })
.num_replicas(num_replicas())
.split_rows(split_rows)
.Create();
+#pragma GCC diagnostic pop
}
Status CreateTable(const string& table_name,
@@ -707,11 +712,11 @@ void AlterTableTest::VerifyRows(int start_row, int num_rows, VerifyPattern patte
ASSERT_OK(scanner.Open());
int verified = 0;
- vector<KuduRowResult> results;
+ KuduScanBatch batch;
while (scanner.HasMoreRows()) {
- ASSERT_OK(scanner.NextBatch(&results));
+ ASSERT_OK(scanner.NextBatch(&batch));
- for (const KuduRowResult& row : results) {
+ for (const KuduScanBatch::RowPtr row : batch) {
int32_t key = 0;
ASSERT_OK(row.GetInt32(0, &key));
int32_t row_idx = bswap_32(key);
@@ -1157,10 +1162,10 @@ void AlterTableTest::ScannerThread() {
uint32_t inserted_at_scanner_start = next_idx_;
CHECK_OK(scanner.Open());
int count = 0;
- vector<KuduRowResult> results;
+ KuduScanBatch batch;
while (scanner.HasMoreRows()) {
- CHECK_OK(scanner.NextBatch(&results));
- count += results.size();
+ CHECK_OK(scanner.NextBatch(&batch));
+ count += batch.NumRows();
}
LOG(INFO) << "Scanner saw " << count << " rows";
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/integration-tests/cluster_verifier.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/cluster_verifier.cc b/src/kudu/integration-tests/cluster_verifier.cc
index 6a19581..23d4145 100644
--- a/src/kudu/integration-tests/cluster_verifier.cc
+++ b/src/kudu/integration-tests/cluster_verifier.cc
@@ -15,6 +15,8 @@
// specific language governing permissions and limitations
// under the License.
+#include "kudu/integration-tests/cluster_verifier.h"
+
#include <memory>
#include <ostream>
#include <string>
@@ -24,10 +26,9 @@
#include <gtest/gtest.h>
#include "kudu/client/client.h"
+#include "kudu/client/scan_batch.h"
#include "kudu/client/shared_ptr.h"
-#include "kudu/client/row_result.h"
#include "kudu/gutil/strings/substitute.h"
-#include "kudu/integration-tests/cluster_verifier.h"
#include "kudu/integration-tests/log_verifier.h"
#include "kudu/mini-cluster/mini_cluster.h"
#include "kudu/tools/ksck.h"
@@ -39,17 +40,16 @@
#include "kudu/util/test_macros.h"
#include "kudu/util/test_util.h"
+using kudu::cluster::MiniCluster;
+using kudu::tools::Ksck;
+using kudu::tools::KsckCluster;
+using kudu::tools::RemoteKsckCluster;
using std::string;
using std::vector;
+using strings::Substitute;
namespace kudu {
-using cluster::MiniCluster;
-using strings::Substitute;
-using tools::Ksck;
-using tools::KsckCluster;
-using tools::RemoteKsckCluster;
-
ClusterVerifier::ClusterVerifier(MiniCluster* cluster)
: cluster_(cluster),
operations_timeout_(MonoDelta::FromSeconds(60)) {
@@ -136,13 +136,13 @@ Status ClusterVerifier::DoCheckRowCount(const std::string& table_name,
CHECK_OK(scanner.SetFaultTolerant());
// Allow a long scan timeout for verification.
CHECK_OK(scanner.SetTimeoutMillis(60 * 1000));
- CHECK_OK(scanner.SetProjectedColumns({}));
+ CHECK_OK(scanner.SetProjectedColumnNames({}));
RETURN_NOT_OK_PREPEND(scanner.Open(), "Unable to open scanner");
int count = 0;
- vector<client::KuduRowResult> rows;
+ client::KuduScanBatch batch;
while (scanner.HasMoreRows()) {
- RETURN_NOT_OK_PREPEND(scanner.NextBatch(&rows), "Unable to read from scanner");
- count += rows.size();
+ RETURN_NOT_OK_PREPEND(scanner.NextBatch(&batch), "Unable to read from scanner");
+ count += batch.NumRows();
}
if (mode == AT_LEAST && count < expected_row_count) {
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/integration-tests/create-table-stress-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/create-table-stress-test.cc b/src/kudu/integration-tests/create-table-stress-test.cc
index 3bf6c58..4bd3787 100644
--- a/src/kudu/integration-tests/create-table-stress-test.cc
+++ b/src/kudu/integration-tests/create-table-stress-test.cc
@@ -156,6 +156,8 @@ void CreateTableStressTest::CreateBigTable(const string& table_name, int num_tab
}
unique_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
ASSERT_OK(table_creator->table_name(table_name)
.schema(&schema_)
.set_range_partition_columns({ "key" })
@@ -163,6 +165,7 @@ void CreateTableStressTest::CreateBigTable(const string& table_name, int num_tab
.num_replicas(3)
.wait(false)
.Create());
+#pragma GCC diagnostic pop
}
TEST_F(CreateTableStressTest, CreateAndDeleteBigTable) {
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/integration-tests/delete_table-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/delete_table-itest.cc b/src/kudu/integration-tests/delete_table-itest.cc
index b63cb4a..6108f7a 100644
--- a/src/kudu/integration-tests/delete_table-itest.cc
+++ b/src/kudu/integration-tests/delete_table-itest.cc
@@ -1379,12 +1379,15 @@ TEST_P(DeleteTableTombstonedParamTest, TestTabletTombstone) {
ASSERT_OK(split_row->SetInt32(0, numeric_limits<int32_t>::max() / kNumTablets));
split_rows.push_back(split_row);
gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
ASSERT_OK(table_creator->table_name(TestWorkload::kDefaultTableName)
.split_rows(split_rows)
.schema(&client_schema)
.set_range_partition_columns({ "key" })
.num_replicas(3)
.Create());
+#pragma GCC diagnostic pop
// Start a workload on the cluster, and run it until we find WALs on disk.
TestWorkload workload(cluster_.get());
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/integration-tests/flex_partitioning-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/flex_partitioning-itest.cc b/src/kudu/integration-tests/flex_partitioning-itest.cc
index 98b2f86..b353e90 100644
--- a/src/kudu/integration-tests/flex_partitioning-itest.cc
+++ b/src/kudu/integration-tests/flex_partitioning-itest.cc
@@ -227,7 +227,10 @@ class FlexPartitioningITest : public KuduTest,
}
table_creator->set_range_partition_columns(range_partition.columns);
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
table_creator->split_rows(split_rows);
+#pragma GCC diagnostic pop
for (const auto& bound : range_partition.bounds) {
KuduPartialRow* lower = schema.NewRow();
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/integration-tests/full_stack-insert-scan-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/full_stack-insert-scan-test.cc b/src/kudu/integration-tests/full_stack-insert-scan-test.cc
index 9ca82a4..ac35ab2 100644
--- a/src/kudu/integration-tests/full_stack-insert-scan-test.cc
+++ b/src/kudu/integration-tests/full_stack-insert-scan-test.cc
@@ -33,6 +33,7 @@
#include "kudu/client/client-test-util.h"
#include "kudu/client/client.h"
#include "kudu/client/row_result.h"
+#include "kudu/client/scan_batch.h"
#include "kudu/client/schema.h"
#include "kudu/client/shared_ptr.h"
#include "kudu/client/write_op.h"
@@ -82,30 +83,30 @@ DEFINE_bool(perf_stat_scan, false, "Print \"perf stat\" results during "
"scan to stdout, disabled by default");
DECLARE_bool(enable_maintenance_manager);
+using kudu::client::KuduClient;
+using kudu::client::KuduClientBuilder;
+using kudu::client::KuduColumnSchema;
+using kudu::client::KuduInsert;
+using kudu::client::KuduRowResult;
+using kudu::client::KuduScanBatch;
+using kudu::client::KuduScanner;
+using kudu::client::KuduSchema;
+using kudu::client::KuduSchemaBuilder;
+using kudu::client::KuduSession;
+using kudu::client::KuduStatusMemberCallback;
+using kudu::client::KuduTable;
+using kudu::client::KuduTableCreator;
+using kudu::cluster::InternalMiniCluster;
+using kudu::cluster::InternalMiniClusterOptions;
using std::string;
using std::unique_ptr;
using std::vector;
+using strings::Split;
+using strings::Substitute;
namespace kudu {
namespace tablet {
-using client::KuduClient;
-using client::KuduClientBuilder;
-using client::KuduColumnSchema;
-using client::KuduInsert;
-using client::KuduRowResult;
-using client::KuduScanner;
-using client::KuduSchema;
-using client::KuduSchemaBuilder;
-using client::KuduSession;
-using client::KuduStatusMemberCallback;
-using client::KuduTable;
-using client::KuduTableCreator;
-using cluster::InternalMiniCluster;
-using cluster::InternalMiniClusterOptions;
-using strings::Split;
-using strings::Substitute;
-
class FullStackInsertScanTest : public KuduTest {
protected:
FullStackInsertScanTest()
@@ -396,19 +397,19 @@ void FullStackInsertScanTest::ScanProjection(const vector<string>& cols,
{
// Warmup codegen cache
KuduScanner scanner(reader_table_.get());
- ASSERT_OK(scanner.SetProjectedColumns(cols));
+ ASSERT_OK(scanner.SetProjectedColumnNames(cols));
ASSERT_OK(scanner.Open());
codegen::CompilationManager::GetSingleton()->Wait();
}
KuduScanner scanner(reader_table_.get());
- ASSERT_OK(scanner.SetProjectedColumns(cols));
+ ASSERT_OK(scanner.SetProjectedColumnNames(cols));
uint64_t nrows = 0;
LOG_TIMING(INFO, msg) {
ASSERT_OK(scanner.Open());
- vector<KuduRowResult> rows;
+ KuduScanBatch batch;
while (scanner.HasMoreRows()) {
- ASSERT_OK(scanner.NextBatch(&rows));
- nrows += rows.size();
+ ASSERT_OK(scanner.NextBatch(&batch));
+ nrows += batch.NumRows();
}
}
ASSERT_EQ(nrows, kNumRows);
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/integration-tests/fuzz-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/fuzz-itest.cc b/src/kudu/integration-tests/fuzz-itest.cc
index e43d990..c33b971 100644
--- a/src/kudu/integration-tests/fuzz-itest.cc
+++ b/src/kudu/integration-tests/fuzz-itest.cc
@@ -408,7 +408,7 @@ class FuzzTest : public KuduTest {
KuduScanner s(table_.get());
ASSERT_OK(s.SetReadMode(KuduScanner::ReadMode::READ_AT_SNAPSHOT));
ASSERT_OK(s.SetSnapshotRaw(timestamp));
- ASSERT_OK(s.SetOrderMode(KuduScanner::OrderMode::ORDERED));
+ ASSERT_OK(s.SetFaultTolerant());
ASSERT_OK(s.Open());
vector<ExpectedKeyValueRow> found;
while (s.HasMoreRows()) {
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/integration-tests/heavy-update-compaction-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/heavy-update-compaction-itest.cc b/src/kudu/integration-tests/heavy-update-compaction-itest.cc
index 4d86682..1168520 100644
--- a/src/kudu/integration-tests/heavy-update-compaction-itest.cc
+++ b/src/kudu/integration-tests/heavy-update-compaction-itest.cc
@@ -59,6 +59,24 @@ DEFINE_int32(scan_timeout_ms, 120 * 1000,
"Sets the scanner timeout. It may be necessary to increase the "
"timeout if the number of rounds or rows is increased.");
+using kudu::client::KuduClient;
+using kudu::client::KuduClientBuilder;
+using kudu::client::KuduColumnSchema;
+using kudu::client::KuduInsert;
+using kudu::client::KuduPredicate;
+using kudu::client::KuduRowResult;
+using kudu::client::KuduScanBatch;
+using kudu::client::KuduScanner;
+using kudu::client::KuduSchema;
+using kudu::client::KuduSchemaBuilder;
+using kudu::client::KuduSession;
+using kudu::client::KuduTable;
+using kudu::client::KuduTableCreator;
+using kudu::client::KuduUpdate;
+using kudu::client::KuduValue;
+using kudu::client::sp::shared_ptr;
+using kudu::cluster::InternalMiniCluster;
+using kudu::cluster::InternalMiniClusterOptions;
using std::string;
using std::unique_ptr;
using std::vector;
@@ -66,24 +84,6 @@ using std::vector;
namespace kudu {
namespace tablet {
-using client::KuduClient;
-using client::KuduClientBuilder;
-using client::KuduColumnSchema;
-using client::KuduInsert;
-using client::KuduPredicate;
-using client::KuduRowResult;
-using client::KuduScanner;
-using client::KuduSchema;
-using client::KuduSchemaBuilder;
-using client::KuduSession;
-using client::KuduTable;
-using client::KuduTableCreator;
-using client::KuduUpdate;
-using client::KuduValue;
-using client::sp::shared_ptr;
-using cluster::InternalMiniCluster;
-using cluster::InternalMiniClusterOptions;
-
class HeavyUpdateCompactionITest : public KuduTest {
protected:
@@ -233,11 +233,11 @@ TEST_F(HeavyUpdateCompactionITest, TestHeavyUpdateCompaction) {
LOG_TIMING(INFO, "scanning") {
ASSERT_OK(scanner.Open());
- vector<KuduRowResult> rows;
size_t final_values_offset = 0;
+ KuduScanBatch batch;
while (scanner.HasMoreRows()) {
- ASSERT_OK(scanner.NextBatch(&rows));
- for (const auto& row : rows) {
+ ASSERT_OK(scanner.NextBatch(&batch));
+ for (const KuduScanBatch::RowPtr row : batch) {
for (int idx = 1; idx <= FLAGS_num_columns; idx++) {
ASSERT_GT(final_values.size(), final_values_offset);
Slice actual_val;
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/integration-tests/linked_list-test-util.h
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/linked_list-test-util.h b/src/kudu/integration-tests/linked_list-test-util.h
index 7fa4b21..f4ecb59 100644
--- a/src/kudu/integration-tests/linked_list-test-util.h
+++ b/src/kudu/integration-tests/linked_list-test-util.h
@@ -469,6 +469,8 @@ std::vector<int64_t> LinkedListTester::GenerateSplitInts() {
Status LinkedListTester::CreateLinkedListTable() {
gscoped_ptr<client::KuduTableCreator> table_creator(client_->NewTableCreator());
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
RETURN_NOT_OK_PREPEND(table_creator->table_name(table_name_)
.schema(&schema_)
.set_range_partition_columns({ kKeyColumnName })
@@ -476,6 +478,7 @@ Status LinkedListTester::CreateLinkedListTable() {
.num_replicas(num_replicas_)
.Create(),
"Failed to create table");
+#pragma GCC diagnostic pop
return Status::OK();
}
@@ -614,7 +617,7 @@ Status LinkedListTester::VerifyLinkedListRemote(
}
client::KuduScanner scanner(table.get());
- RETURN_NOT_OK_PREPEND(scanner.SetProjectedColumns(verify_projection_), "Bad projection");
+ RETURN_NOT_OK_PREPEND(scanner.SetProjectedColumnNames(verify_projection_), "Bad projection");
RETURN_NOT_OK(scanner.SetBatchSizeBytes(0)); // Force at least one NextBatch RPC.
RETURN_NOT_OK(scanner.SetTimeoutMillis(60 * 1000 /* 60 seconds */));
@@ -639,7 +642,6 @@ Status LinkedListTester::VerifyLinkedListRemote(
verifier.StartScanTimer();
bool cb_called = false;
- std::vector<client::KuduRowResult> rows;
while (scanner.HasMoreRows()) {
// If we're doing a snapshot scan with a big enough cluster, call the callback on the scanner's
// tserver. Do this only once.
@@ -652,8 +654,9 @@ Status LinkedListTester::VerifyLinkedListRemote(
RETURN_NOT_OK(cb(down_ts));
cb_called = true;
}
- RETURN_NOT_OK_PREPEND(scanner.NextBatch(&rows), "Couldn't fetch next row batch");
- for (const client::KuduRowResult& row : rows) {
+ client::KuduScanBatch batch;
+ RETURN_NOT_OK_PREPEND(scanner.NextBatch(&batch), "Couldn't fetch next row batch");
+ for (const client::KuduScanBatch::RowPtr row : batch) {
int64_t key;
int64_t link;
bool updated;
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/integration-tests/tablet_copy-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/tablet_copy-itest.cc b/src/kudu/integration-tests/tablet_copy-itest.cc
index 135a474..b3a8a94 100644
--- a/src/kudu/integration-tests/tablet_copy-itest.cc
+++ b/src/kudu/integration-tests/tablet_copy-itest.cc
@@ -638,6 +638,8 @@ TEST_F(TabletCopyITest, TestConcurrentTabletCopys) {
ASSERT_OK(row->SetInt32(0, std::numeric_limits<int32_t>::max() / kNumTablets * (i + 1)));
splits.push_back(row);
}
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
ASSERT_OK(table_creator->table_name(TestWorkload::kDefaultTableName)
.split_rows(splits)
@@ -645,6 +647,7 @@ TEST_F(TabletCopyITest, TestConcurrentTabletCopys) {
.set_range_partition_columns({ "key" })
.num_replicas(3)
.Create());
+#pragma GCC diagnostic pop
const int kTsIndex = 0; // We'll test with the first TS.
TServerDetails* target_ts = ts_map_[cluster_->tablet_server(kTsIndex)->uuid()];
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/integration-tests/test_workload.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/test_workload.cc b/src/kudu/integration-tests/test_workload.cc
index ff555b5..4fd05e8 100644
--- a/src/kudu/integration-tests/test_workload.cc
+++ b/src/kudu/integration-tests/test_workload.cc
@@ -269,12 +269,15 @@ void TestWorkload::Setup() {
// Create the table.
gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
Status s = table_creator->table_name(table_name_)
.schema(&schema_)
.num_replicas(num_replicas_)
.set_range_partition_columns({ "key" })
.split_rows(splits)
.Create();
+#pragma GCC diagnostic pop
if (!s.ok()) {
if (!s.IsAlreadyPresent() && !s.IsServiceUnavailable()) {
// TODO(KUDU-1537): Should be fixed with Exactly Once semantics.
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/integration-tests/update_scan_delta_compact-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/update_scan_delta_compact-test.cc b/src/kudu/integration-tests/update_scan_delta_compact-test.cc
index fb017a5..f3b30ae 100644
--- a/src/kudu/integration-tests/update_scan_delta_compact-test.cc
+++ b/src/kudu/integration-tests/update_scan_delta_compact-test.cc
@@ -17,8 +17,8 @@
#include <cstdint>
#include <cstdlib>
-#include <ostream>
#include <memory>
+#include <ostream>
#include <string>
#include <vector>
@@ -30,6 +30,7 @@
#include "kudu/client/callbacks.h"
#include "kudu/client/client.h"
#include "kudu/client/row_result.h"
+#include "kudu/client/scan_batch.h"
#include "kudu/client/schema.h"
#include "kudu/client/shared_ptr.h"
#include "kudu/client/write_op.h"
@@ -61,30 +62,30 @@ DEFINE_int32(row_count, 2000, "How many rows will be used in this test for the b
DEFINE_int32(seconds_to_run, 4,
"How long this test runs for, after inserting the base data, in seconds");
+using kudu::client::KuduInsert;
+using kudu::client::KuduClient;
+using kudu::client::KuduClientBuilder;
+using kudu::client::KuduColumnSchema;
+using kudu::client::KuduRowResult;
+using kudu::client::KuduScanBatch;
+using kudu::client::KuduScanner;
+using kudu::client::KuduSchema;
+using kudu::client::KuduSchemaBuilder;
+using kudu::client::KuduSession;
+using kudu::client::KuduStatusCallback;
+using kudu::client::KuduStatusMemberCallback;
+using kudu::client::KuduTable;
+using kudu::client::KuduTableCreator;
+using kudu::client::KuduUpdate;
+using kudu::client::sp::shared_ptr;
+using kudu::cluster::InternalMiniCluster;
+using kudu::cluster::InternalMiniClusterOptions;
using std::string;
using std::vector;
namespace kudu {
namespace tablet {
-using client::KuduInsert;
-using client::KuduClient;
-using client::KuduClientBuilder;
-using client::KuduColumnSchema;
-using client::KuduRowResult;
-using client::KuduScanner;
-using client::KuduSchema;
-using client::KuduSchemaBuilder;
-using client::KuduSession;
-using client::KuduStatusCallback;
-using client::KuduStatusMemberCallback;
-using client::KuduTable;
-using client::KuduTableCreator;
-using client::KuduUpdate;
-using client::sp::shared_ptr;
-using cluster::InternalMiniCluster;
-using cluster::InternalMiniClusterOptions;
-
// This integration test tries to trigger all the update-related bits while also serving as a
// foundation for benchmarking. It first inserts 'row_count' rows and then starts two threads,
// one that continuously updates all the rows sequentially and one that scans them all, until
@@ -292,9 +293,9 @@ void UpdateScanDeltaCompactionTest::ScanRows(CountDownLatch* stop_latch) const {
}
LOG_TIMING(INFO, "Scan") {
CHECK_OK(scanner.Open());
- vector<KuduRowResult> rows;
+ KuduScanBatch batch;
while (scanner.HasMoreRows()) {
- CHECK_OK(scanner.NextBatch(&rows));
+ CHECK_OK(scanner.NextBatch(&batch));
}
}
}
http://git-wip-us.apache.org/repos/asf/kudu/blob/678dbac6/src/kudu/tools/ksck_remote-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tools/ksck_remote-test.cc b/src/kudu/tools/ksck_remote-test.cc
index 694f212..1436155 100644
--- a/src/kudu/tools/ksck_remote-test.cc
+++ b/src/kudu/tools/ksck_remote-test.cc
@@ -117,12 +117,15 @@ class RemoteKsckTest : public KuduTest {
// Create one table.
gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator());
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
ASSERT_OK(table_creator->table_name(kTableName)
.schema(&schema_)
.num_replicas(3)
.set_range_partition_columns({ "key" })
.split_rows(GenerateSplitRows())
.Create());
+#pragma GCC diagnostic pop
// Make sure we can open the table.
shared_ptr<KuduTable> client_table;
ASSERT_OK(client_->OpenTable(kTableName, &client_table));