Kudu C++ client API
Loading...
Searching...
No Matches
client.h
1// Licensed to the Apache Software Foundation (ASF) under one
2// or more contributor license agreements. See the NOTICE file
3// distributed with this work for additional information
4// regarding copyright ownership. The ASF licenses this file
5// to you under the Apache License, Version 2.0 (the
6// "License"); you may not use this file except in compliance
7// with the License. You may obtain a copy of the License at
8//
9// http://www.apache.org/licenses/LICENSE-2.0
10//
11// Unless required by applicable law or agreed to in writing,
12// software distributed under the License is distributed on an
13// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14// KIND, either express or implied. See the License for the
15// specific language governing permissions and limitations
16// under the License.
17
24
25#ifndef KUDU_CLIENT_CLIENT_H
26#define KUDU_CLIENT_CLIENT_H
27
28#include <stdint.h>
29
30#include <cstddef>
31#include <map>
32// Not safe to include <memory>; this header must remain compatible with C++98.
33//
34// IWYU pragma: no_include <memory>
35#include <string>
36#include <vector>
37
38#include "kudu/client/row_result.h"
39#include "kudu/client/scan_predicate.h"
40#include "kudu/client/schema.h"
41#include "kudu/client/shared_ptr.h" // IWYU pragma: keep
42#ifdef KUDU_HEADERS_NO_STUBS
43#include <gtest/gtest_prod.h>
44
45#include "kudu/gutil/macros.h"
46#include "kudu/gutil/port.h"
47#else
48#include "kudu/client/stubs.h"
49#endif
50#include "kudu/util/kudu_export.h"
51#include "kudu/util/slice.h"
52#include "kudu/util/status.h"
53
54namespace kudu {
55
56class AlterTableTest;
57class AuthzTokenTest;
58class ClientStressTest_TestUniqueClientIds_Test;
59class DisableWriteWhenExceedingQuotaTest;
60class KuduPartialRow;
61class MetaCacheLookupStressTest_PerfSynthetic_Test;
62class MonoDelta;
63class Partition;
64class PartitionSchema;
65class SecurityUnknownTskTest;
66class TxnId;
67
68namespace client {
69class KuduClient;
70class KuduTable;
71} // namespace client
72
73namespace tablet {
74class FuzzTest;
75} // namespace tablet
76
77namespace transactions {
78class CoordinatorRpc;
79class ParticipantRpc;
80class TxnSystemClient;
81} // namespace transactions
82
83namespace tools {
84class LeaderMasterProxy;
85class RemoteKsckCluster;
86class TableAlter;
87class TableLister;
88} // namespace tools
89
90namespace client {
91
92class KuduColumnarScanBatch;
93class KuduDelete;
94class KuduDeleteIgnore;
95class KuduInsert;
96class KuduInsertIgnore;
97class KuduLoggingCallback;
98class KuduPartitioner;
99class KuduScanBatch;
100class KuduSession;
101class KuduStatusCallback;
102class KuduTableAlterer;
103class KuduTableCreator;
104class KuduTableStatistics;
105class KuduTablet;
106class KuduTabletServer;
107class KuduUpdate;
108class KuduUpdateIgnore;
109class KuduUpsert;
110class KuduUpsertIgnore;
111class KuduValue;
112class KuduWriteOperation;
113class ResourceMetrics;
114
115namespace internal {
116class Batcher;
117class ErrorCollector;
118class GetTableSchemaRpc;
119class LookupRpc;
120class MetaCache;
121class RemoteTablet;
122class RemoteTabletServer;
123class ReplicaController;
124class RetrieveAuthzTokenRpc;
125class ScanBatchDataInterface;
126class TabletInfoProvider;
127class WriteRpc;
128template <class ReqClass, class RespClass>
129class AsyncLeaderMasterRpc; // IWYU pragma: keep
130template <class ReqClass, class RespClass>
131class AsyncRandomTxnManagerRpc; // IWYU pragma: keep
132} // namespace internal
133
146void KUDU_EXPORT InstallLoggingCallback(KuduLoggingCallback* cb);
147
154void KUDU_EXPORT UninstallLoggingCallback();
155
171void KUDU_EXPORT SetVerboseLogLevel(int level);
172
182Status KUDU_EXPORT SetInternalSignalNumber(int signum) WARN_UNUSED_RESULT;
183
195Status KUDU_EXPORT DisableSaslInitialization() WARN_UNUSED_RESULT;
196
197
220Status KUDU_EXPORT DisableOpenSSLInitialization() WARN_UNUSED_RESULT;
221
224std::string KUDU_EXPORT GetShortVersionString();
225
228std::string KUDU_EXPORT GetAllVersionInfo();
229
234class KUDU_EXPORT KuduClientBuilder {
235 public:
238
241 OPTIONAL,
243
244 REQUIRED_REMOTE,
246
247 REQUIRED
249 };
250
255
261 KuduClientBuilder& master_server_addrs(const std::vector<std::string>& addrs);
262
270 KuduClientBuilder& add_master_server_addr(const std::string& addr);
271
282
291
306
317 KuduClientBuilder& jwt(const std::string& jwt);
318
332
338 KuduClientBuilder& trusted_certificate(const std::string& cert_pem);
339
349 KuduClientBuilder& num_reactors(int num_reactors);
350
361 KuduClientBuilder& sasl_protocol_name(const std::string& sasl_protocol_name);
362
372 KuduClientBuilder& require_authentication(bool require_authentication);
373
392
403 Status Build(sp::shared_ptr<KuduClient>* client);
404
405 private:
406 class KUDU_NO_EXPORT Data;
407
408 friend class internal::ReplicaController;
409
410 // Owned.
411 Data* data_;
412
413 DISALLOW_COPY_AND_ASSIGN(KuduClientBuilder);
414};
415
433class KUDU_EXPORT KuduTransaction :
434 public sp::enable_shared_from_this<KuduTransaction> {
435 public:
437
450 Status CreateSession(sp::shared_ptr<KuduSession>* session) WARN_UNUSED_RESULT;
451
468 Status Commit() WARN_UNUSED_RESULT;
469
484 Status StartCommit() WARN_UNUSED_RESULT;
485
513 Status IsCommitComplete(bool* is_complete,
514 Status* completion_status) WARN_UNUSED_RESULT;
515
519 Status Rollback() WARN_UNUSED_RESULT;
520
530 class KUDU_EXPORT SerializationOptions {
531 public:
534
576 bool keepalive() const;
577
590
591 private:
592 friend class KuduTransaction;
593 class KUDU_NO_EXPORT Data;
594
595 Data* data_; // Owned.
596
597 DISALLOW_COPY_AND_ASSIGN(SerializationOptions);
598 };
599
626 std::string* serialized_txn,
627 const SerializationOptions& options = SerializationOptions()) const WARN_UNUSED_RESULT;
628
644 static Status Deserialize(const sp::shared_ptr<KuduClient>& client,
645 const std::string& serialized_txn,
646 sp::shared_ptr<KuduTransaction>* txn) WARN_UNUSED_RESULT;
647 private:
648 DISALLOW_COPY_AND_ASSIGN(KuduTransaction);
649
650 friend class KuduClient;
651 friend class KuduSession;
652 FRIEND_TEST(ClientTest, TxnIdOfTransactionalSession);
653 FRIEND_TEST(ClientTest, TxnToken);
654
655 class KUDU_NO_EXPORT Data;
656
657 explicit KuduTransaction(const sp::shared_ptr<KuduClient>& client);
658 Data* data_; // Owned.
659};
660
687class KUDU_EXPORT KuduClient : public sp::enable_shared_from_this<KuduClient> {
688 public:
689 ~KuduClient();
690
696
705 Status IsCreateTableInProgress(const std::string& table_name,
706 bool* create_in_progress);
707
725 Status DeleteTable(const std::string& table_name);
726
742
748 Status SoftDeleteTable(const std::string& table_name,
749 uint32_t reserve_seconds = 0);
750
752
767 Status DeleteTableInCatalogs(const std::string& table_name,
768 bool modify_external_catalogs,
769 int32_t reserve_seconds = -1) KUDU_NO_EXPORT;
770
779 Status RecallTable(const std::string& table_id, const std::string& new_table_name = "");
780
782
789 KuduTableAlterer* NewTableAlterer(const std::string& table_name);
790
799 Status IsAlterTableInProgress(const std::string& table_name,
800 bool* alter_in_progress);
808 Status GetTableSchema(const std::string& table_name,
809 KuduSchema* schema);
810
817 Status ListTabletServers(std::vector<KuduTabletServer*>* tablet_servers);
818
827 Status ListTables(std::vector<std::string>* tables,
828 const std::string& filter = "");
829
838 Status ListSoftDeletedTables(std::vector<std::string>* tables,
839 const std::string& filter = "");
840
848 Status TableExists(const std::string& table_name, bool* exists);
849
866 Status OpenTable(const std::string& table_name,
867 sp::shared_ptr<KuduTable>* table);
868
874 sp::shared_ptr<KuduSession> NewSession();
875
899 Status NewTransaction(sp::shared_ptr<KuduTransaction>* txn) WARN_UNUSED_RESULT;
900
902
915 Status GetTablet(const std::string& tablet_id,
916 KuduTablet** tablet) KUDU_NO_EXPORT;
917
925 Status GetTableStatistics(const std::string& table_name,
926 KuduTableStatistics** statistics);
927
935 std::string GetMasterAddresses() const KUDU_NO_EXPORT;
936
938
942
943 CLOSEST_REPLICA,
948
949 FIRST_REPLICA
950 };
951
954 bool IsMultiMaster() const;
955
958
961
964
967 static const uint64_t kNoTimestamp;
968
980
995 void SetLatestObservedTimestamp(uint64_t ht_timestamp);
996
1008 Status ExportAuthenticationCredentials(std::string* authn_creds) const;
1009
1011
1017 std::string GetHiveMetastoreUris() const KUDU_NO_EXPORT;
1018
1024 bool GetHiveMetastoreSaslEnabled() const KUDU_NO_EXPORT;
1025
1035 std::string GetHiveMetastoreUuid() const KUDU_NO_EXPORT;
1036
1043 std::string location() const KUDU_NO_EXPORT;
1044
1048 std::string cluster_id() const KUDU_NO_EXPORT;
1050
1051 private:
1052 class KUDU_NO_EXPORT Data;
1053
1054 template <class ReqClass, class RespClass>
1055 friend class internal::AsyncLeaderMasterRpc;
1056 template <class ReqClass, class RespClass>
1057 friend class internal::AsyncRandomTxnManagerRpc;
1058
1059 friend class ClientTest;
1060 friend class ConnectToClusterBaseTest;
1061 friend class KuduClientBuilder;
1062 friend class KuduPartitionerBuilder;
1063 friend class KuduTransaction;
1064 friend class KuduScanToken;
1065 friend class KuduScanTokenBuilder;
1066 friend class KuduScanner;
1067 friend class KuduSession;
1068 friend class KuduTable;
1069 friend class KuduTableAlterer;
1070 friend class KuduTableCreator;
1071 friend class internal::Batcher;
1072 friend class internal::GetTableSchemaRpc;
1073 friend class internal::LookupRpc;
1074 friend class internal::MetaCache;
1075 friend class internal::RemoteTablet;
1076 friend class internal::RemoteTabletServer;
1077 friend class internal::RetrieveAuthzTokenRpc;
1078 friend class internal::TabletInfoProvider;
1079 friend class internal::WriteRpc;
1080 friend class kudu::AuthzTokenTest;
1081 friend class kudu::DisableWriteWhenExceedingQuotaTest;
1082 friend class kudu::SecurityUnknownTskTest;
1083 friend class transactions::CoordinatorRpc;
1084 friend class transactions::ParticipantRpc;
1085 friend class transactions::TxnSystemClient;
1086 friend class tools::LeaderMasterProxy;
1087 friend class tools::RemoteKsckCluster;
1088 friend class tools::TableLister;
1089 friend class ScanTokenTest;
1090
1091 FRIEND_TEST(kudu::ClientStressTest, TestUniqueClientIds);
1092 FRIEND_TEST(kudu::MetaCacheLookupStressTest, PerfSynthetic);
1093 FRIEND_TEST(ClientTest, ClearCacheAndConcurrentWorkload);
1094 FRIEND_TEST(ClientTest, ConnectionNegotiationTimeout);
1095 FRIEND_TEST(ClientTest, TestBasicIdBasedLookup);
1096 FRIEND_TEST(ClientTest, TestCacheAuthzTokens);
1097 FRIEND_TEST(ClientTest, TestGetSecurityInfoFromMaster);
1098 FRIEND_TEST(ClientTest, TestGetTabletServerBlacklist);
1099 FRIEND_TEST(ClientTest, TestGetTabletServerDeterministic);
1100 FRIEND_TEST(ClientTest, TestMasterDown);
1101 FRIEND_TEST(ClientTest, TestMasterLookupPermits);
1102 FRIEND_TEST(ClientTest, TestMetaCacheExpiry);
1103 FRIEND_TEST(ClientTest, TestMetaCacheExpiryById);
1104 FRIEND_TEST(ClientTest, TestMetaCacheExpiryWithKeysAndIds);
1105 FRIEND_TEST(ClientTest, TestMetaCacheLookupNoLeaders);
1106 FRIEND_TEST(ClientTest, TestMetaCacheWithKeysAndIds);
1107 FRIEND_TEST(ClientTest, TestNonCoveringRangePartitions);
1108 FRIEND_TEST(ClientTest, TestRetrieveAuthzTokenInParallel);
1109 FRIEND_TEST(ClientTest, TestReplicatedTabletWritesWithLeaderElection);
1110 FRIEND_TEST(ClientTest, TestScanFaultTolerance);
1111 FRIEND_TEST(ClientTest, TestScanTimeout);
1112 FRIEND_TEST(ClientTest, TestWriteWithDeadMaster);
1113 FRIEND_TEST(MasterFailoverTest, TestPauseAfterCreateTableIssued);
1114 FRIEND_TEST(MultiTServerClientTest, TestSetReplicationFactor);
1115
1116 KuduClient();
1117
1118 // Owned.
1119 Data* data_;
1120
1121 DISALLOW_COPY_AND_ASSIGN(KuduClient);
1122};
1123
1125class KUDU_EXPORT KuduTabletServer {
1126 public:
1128
1131 const std::string& uuid() const;
1132
1135 const std::string& hostname() const;
1136
1139 uint16_t port() const;
1140
1142
1147 const std::string& location() const KUDU_NO_EXPORT;
1149
1150 private:
1151 class KUDU_NO_EXPORT Data;
1152
1153 friend class KuduClient;
1154 friend class KuduScanner;
1155 friend class KuduScanTokenBuilder;
1156
1158
1159 // Owned.
1160 Data* data_;
1161
1162 DISALLOW_COPY_AND_ASSIGN(KuduTabletServer);
1163};
1164
1166class KUDU_EXPORT KuduReplica {
1167 public:
1168 ~KuduReplica();
1169
1174 bool is_leader() const;
1175
1177 const KuduTabletServer& ts() const;
1178
1179 private:
1180 friend class KuduClient;
1181 friend class KuduScanTokenBuilder;
1182 friend class internal::ReplicaController;
1183
1184 class KUDU_NO_EXPORT Data;
1185
1186 KuduReplica();
1187
1188 // Owned.
1189 Data* data_;
1190
1191 DISALLOW_COPY_AND_ASSIGN(KuduReplica);
1192};
1193
1195class KUDU_EXPORT KuduTablet {
1196 public:
1197 ~KuduTablet();
1198
1201 const std::string& id() const;
1202
1208 const std::vector<const KuduReplica*>& replicas() const;
1209
1210 private:
1211 friend class KuduClient;
1212 friend class KuduScanTokenBuilder;
1213
1214 class KUDU_NO_EXPORT Data;
1215
1216 KuduTablet();
1217
1218 // Owned.
1219 Data* data_;
1220
1221 DISALLOW_COPY_AND_ASSIGN(KuduTablet);
1222};
1223
1225class KUDU_EXPORT KuduTableCreator {
1226 public:
1228
1240 KuduTableCreator& table_name(const std::string& name);
1241
1253
1270 KuduTableCreator& add_hash_partitions(const std::vector<std::string>& columns,
1271 int32_t num_buckets);
1272
1288 KuduTableCreator& add_hash_partitions(const std::vector<std::string>& columns,
1289 int32_t num_buckets,
1290 int32_t seed);
1291
1304 KuduTableCreator& set_range_partition_columns(const std::vector<std::string>& columns);
1305
1311
1341 KuduPartialRow* upper_bound,
1342 RangePartitionBound lower_bound_type = INCLUSIVE_BOUND,
1343 RangePartitionBound upper_bound_type = EXCLUSIVE_BOUND);
1344
1361 class KuduRangePartition* partition);
1362
1372
1380 KuduTableCreator& set_owner(const std::string& owner);
1381
1387 KuduTableCreator& set_comment(const std::string& comment);
1388
1394 KuduTableCreator& split_rows(const std::vector<const KuduPartialRow*>& split_rows)
1395 ATTRIBUTE_DEPRECATED("use add_range_partition_split() instead");
1396
1407
1419 KuduTableCreator& dimension_label(const std::string& dimension_label);
1420
1428 KuduTableCreator& extra_configs(const std::map<std::string, std::string>& extra_configs);
1429
1440
1449
1464
1465 private:
1466 class KUDU_NO_EXPORT Data;
1467
1468 friend class KuduClient;
1469 friend class transactions::TxnSystemClient;
1470
1471 explicit KuduTableCreator(KuduClient* client);
1472
1473 // Owned.
1474 Data* data_;
1475
1476 DISALLOW_COPY_AND_ASSIGN(KuduTableCreator);
1477};
1478
1485class KUDU_EXPORT KuduRangePartition {
1486 public:
1502 KuduPartialRow* upper_bound,
1503 KuduTableCreator::RangePartitionBound lower_bound_type =
1504 KuduTableCreator::INCLUSIVE_BOUND,
1505 KuduTableCreator::RangePartitionBound upper_bound_type =
1506 KuduTableCreator::EXCLUSIVE_BOUND);
1507
1509
1528 Status add_hash_partitions(const std::vector<std::string>& columns,
1529 int32_t num_buckets,
1530 int32_t seed = 0);
1531 private:
1532 class KUDU_NO_EXPORT Data;
1533
1534 friend class KuduTableCreator;
1535 friend class KuduTableAlterer;
1536
1537 // Owned.
1538 Data* data_;
1539
1540 DISALLOW_COPY_AND_ASSIGN(KuduRangePartition);
1541};
1542
1544class KUDU_EXPORT KuduTableStatistics {
1545 public:
1548
1553 int64_t on_disk_size() const;
1554
1559 int64_t live_row_count() const;
1560
1567 int64_t on_disk_size_limit() const;
1568
1575 int64_t live_row_count_limit() const;
1576
1580 std::string ToString() const;
1581
1582 private:
1583 class KUDU_NO_EXPORT Data;
1584
1585 friend class KuduClient;
1586
1587 // Owned.
1588 Data* data_;
1589
1590 DISALLOW_COPY_AND_ASSIGN(KuduTableStatistics);
1591};
1592
1613class KUDU_EXPORT KuduTable : public sp::enable_shared_from_this<KuduTable> {
1614 public:
1615 ~KuduTable();
1616
1618 const std::string& name() const;
1619
1627 const std::string& id() const;
1628
1630 const KuduSchema& schema() const;
1631
1633 const std::string& comment() const;
1634
1636 int num_replicas() const;
1637
1639 const std::string& owner() const;
1640
1645
1650
1655
1660
1665
1670
1675
1680
1706 KuduValue* value);
1707
1740 std::vector<KuduBloomFilter*>* bloom_filters);
1741
1746
1783 const std::vector<Slice>& bloom_filters);
1785
1810 std::vector<KuduValue*>* values);
1811
1823
1835
1839
1841 const PartitionSchema& partition_schema() const;
1842
1844 const std::map<std::string, std::string>& extra_configs() const;
1845
1847
1857 Status ListPartitions(std::vector<Partition>* partitions) KUDU_NO_EXPORT;
1858
1860
1861 private:
1862 class KUDU_NO_EXPORT Data;
1863
1864 friend class KuduClient;
1865 friend class KuduPartitioner;
1866 friend class KuduScanToken;
1867 friend class KuduScanner;
1868
1869 KuduTable(const sp::shared_ptr<KuduClient>& client,
1870 const std::string& name,
1871 const std::string& id,
1872 int num_replicas,
1873 const std::string& owner,
1874 const std::string& comment,
1875 const KuduSchema& schema,
1876 const PartitionSchema& partition_schema,
1877 const std::map<std::string, std::string>& extra_configs);
1878
1879 // Owned.
1880 Data* data_;
1881
1882 DISALLOW_COPY_AND_ASSIGN(KuduTable);
1883};
1884
1896class KUDU_EXPORT KuduTableAlterer {
1897 public:
1899
1905 KuduTableAlterer* RenameTo(const std::string& new_name);
1906
1912 KuduTableAlterer* SetOwner(const std::string& new_owner);
1913
1919 KuduTableAlterer* SetComment(const std::string& new_comment);
1920
1930 KuduColumnSpec* AddColumn(const std::string& name);
1931
1940 KuduColumnSpec* AlterColumn(const std::string& name);
1941
1949 KuduTableAlterer* DropColumn(const std::string& name);
1950
1983 KuduPartialRow* lower_bound,
1984 KuduPartialRow* upper_bound,
1985 KuduTableCreator::RangePartitionBound lower_bound_type = KuduTableCreator::INCLUSIVE_BOUND,
1986 KuduTableCreator::RangePartitionBound upper_bound_type = KuduTableCreator::EXCLUSIVE_BOUND);
1987
2006
2042 KuduPartialRow* lower_bound,
2043 KuduPartialRow* upper_bound,
2044 const std::string& dimension_label,
2045 KuduTableCreator::RangePartitionBound lower_bound_type = KuduTableCreator::INCLUSIVE_BOUND,
2046 KuduTableCreator::RangePartitionBound upper_bound_type = KuduTableCreator::EXCLUSIVE_BOUND);
2047
2076 KuduPartialRow* lower_bound,
2077 KuduPartialRow* upper_bound,
2078 KuduTableCreator::RangePartitionBound lower_bound_type = KuduTableCreator::INCLUSIVE_BOUND,
2079 KuduTableCreator::RangePartitionBound upper_bound_type = KuduTableCreator::EXCLUSIVE_BOUND);
2080
2090 KuduTableAlterer* AlterExtraConfig(const std::map<std::string, std::string>& extra_configs);
2091
2104 KuduTableAlterer* SetTableDiskSizeLimit(int64_t disk_size_limit);
2105
2118 KuduTableAlterer* SetTableRowCountLimit(int64_t row_count_limit);
2119
2130
2143
2145
2154 KuduTableAlterer* modify_external_catalogs(bool modify_external_catalogs) KUDU_NO_EXPORT;
2155
2157
2163
2164 private:
2165 class KUDU_NO_EXPORT Data;
2166
2167 friend class KuduClient;
2168 friend class tools::TableAlter;
2169 friend class kudu::AlterTableTest;
2170
2171 FRIEND_TEST(MultiTServerClientTest, TestSetReplicationFactor);
2172
2174 const std::string& name);
2175
2176 // Owned.
2177 Data* data_;
2178
2179 DISALLOW_COPY_AND_ASSIGN(KuduTableAlterer);
2180};
2181
2187class KUDU_EXPORT KuduError {
2188 public:
2189 ~KuduError();
2190
2192 const Status& status() const;
2193
2196
2205
2217
2218 private:
2219 class KUDU_NO_EXPORT Data;
2220
2221 friend class internal::Batcher;
2222 friend class internal::ErrorCollector;
2223 friend class KuduSession;
2224
2225 KuduError(KuduWriteOperation* failed_op, const Status& error);
2226
2227 // Owned.
2228 Data* data_;
2229
2230 DISALLOW_COPY_AND_ASSIGN(KuduError);
2231};
2232
2233
2292class KUDU_EXPORT KuduSession : public sp::enable_shared_from_this<KuduSession> {
2293 public:
2294 ~KuduSession();
2295
2303
2331
2344 MANUAL_FLUSH
2346
2355 Status SetFlushMode(FlushMode m) WARN_UNUSED_RESULT;
2356
2395
2402 WARN_UNUSED_RESULT;
2403
2421 Status SetMutationBufferSpace(size_t size_bytes) WARN_UNUSED_RESULT;
2422
2447 WARN_UNUSED_RESULT;
2448
2470 Status SetMutationBufferFlushInterval(unsigned int millis) WARN_UNUSED_RESULT;
2471
2496 Status SetMutationBufferMaxNum(unsigned int max_num) WARN_UNUSED_RESULT;
2497
2503 void SetTimeoutMillis(int millis);
2504
2508
2532 Status Apply(KuduWriteOperation* write_op) WARN_UNUSED_RESULT;
2533
2548 Status Flush() WARN_UNUSED_RESULT;
2549
2590 void FlushAsync(KuduStatusCallback* cb);
2591
2594 Status Close() WARN_UNUSED_RESULT;
2595
2604 bool HasPendingOperations() const;
2605
2627 int CountBufferedOperations() const
2628 ATTRIBUTE_DEPRECATED("this method is experimental and will disappear "
2629 "in a future release");
2630
2655 Status SetErrorBufferSpace(size_t size_bytes);
2656
2666 int CountPendingErrors() const;
2667
2678 void GetPendingErrors(std::vector<KuduError*>* errors, bool* overflowed);
2679
2681 KuduClient* client() const;
2682
2684 const ResourceMetrics& GetWriteOpMetrics() const;
2685
2686 private:
2687 class KUDU_NO_EXPORT Data;
2688
2689 friend class ClientTest;
2690 friend class KuduClient;
2691 friend class KuduTransaction;
2692 friend class internal::Batcher;
2693 friend class tablet::FuzzTest;
2694 FRIEND_TEST(ClientTest, TestAutoFlushBackgroundAndErrorCollector);
2695 FRIEND_TEST(ClientTest, TestAutoFlushBackgroundApplyBlocks);
2696 FRIEND_TEST(ClientTest, TxnIdOfTransactionalSession);
2697
2698 explicit KuduSession(const sp::shared_ptr<KuduClient>& client);
2699 KuduSession(const sp::shared_ptr<KuduClient>& client, const TxnId& txn_id);
2700
2701 // Owned.
2702 Data* data_;
2703
2704 DISALLOW_COPY_AND_ASSIGN(KuduSession);
2705};
2706
2707
2712class KUDU_EXPORT KuduScanner {
2713 public:
2724
2745
2756 READ_YOUR_WRITES
2758
2769
2774 ORDERED
2776
2780 enum { kScanTimeoutMillis = 30000 };
2781
2787 explicit KuduScanner(KuduTable* table);
2788 ~KuduScanner();
2789
2799 Status SetProjectedColumnNames(const std::vector<std::string>& col_names)
2800 WARN_UNUSED_RESULT;
2801
2811 Status SetProjectedColumnIndexes(const std::vector<int>& col_indexes)
2812 WARN_UNUSED_RESULT;
2813
2819 Status SetProjectedColumns(const std::vector<std::string>& col_names)
2820 WARN_UNUSED_RESULT
2821 ATTRIBUTE_DEPRECATED("use SetProjectedColumnNames() instead");
2822
2831 Status AddConjunctPredicate(KuduPredicate* pred) WARN_UNUSED_RESULT;
2832
2842
2851 ATTRIBUTE_DEPRECATED("use AddLowerBound() instead");
2852
2862
2871 ATTRIBUTE_DEPRECATED("use AddExclusiveUpperBound() instead");
2872
2882
2892
2899 Status SetCacheBlocks(bool cache_blocks);
2900
2903
2923
2932 void Close();
2933
2942 bool HasMoreRows() const;
2943
2955 Status NextBatch(std::vector<KuduRowResult>* rows)
2956 ATTRIBUTE_DEPRECATED("use NextBatch(KuduScanBatch*) instead");
2957
2970
2983
2993
2996
3003 Status SetBatchSizeBytes(uint32_t batch_size);
3004
3013 WARN_UNUSED_RESULT;
3014
3020 Status SetReadMode(ReadMode read_mode) WARN_UNUSED_RESULT;
3021
3027 Status SetOrderMode(OrderMode order_mode) WARN_UNUSED_RESULT
3028 ATTRIBUTE_DEPRECATED("use SetFaultTolerant() instead");
3029
3042 Status SetFaultTolerant() WARN_UNUSED_RESULT;
3043
3049 Status SetSnapshotMicros(uint64_t snapshot_timestamp_micros) WARN_UNUSED_RESULT;
3050
3060 Status SetSnapshotRaw(uint64_t snapshot_timestamp) WARN_UNUSED_RESULT;
3061
3063
3078 Status SetDiffScan(uint64_t start_timestamp, uint64_t end_timestamp)
3079 WARN_UNUSED_RESULT KUDU_NO_EXPORT;
3080
3082
3088 Status SetTimeoutMillis(int millis);
3089
3091 KuduSchema GetProjectionSchema() const;
3092
3094 sp::shared_ptr<KuduTable> GetKuduTable();
3095
3103
3105 static const uint64_t NO_FLAGS = 0;
3112 static const uint64_t PAD_UNIXTIME_MICROS_TO_16_BYTES = 1 << 0;
3113
3121 static const uint64_t COLUMNAR_LAYOUT = 1 << 1;
3122
3150 Status SetRowFormatFlags(uint64_t flags);
3152
3158 Status SetLimit(int64_t limit) WARN_UNUSED_RESULT;
3159
3165 std::string ToString() const;
3166
3167 private:
3168 class KUDU_NO_EXPORT Data;
3169
3170 Status NextBatch(internal::ScanBatchDataInterface* batch);
3171
3172 friend class KuduScanToken;
3173 friend class FlexPartitioningTest;
3174 FRIEND_TEST(ClientTest, TestBlockScannerHijackingAttempts);
3175 FRIEND_TEST(ClientTest, TestScanCloseProxy);
3176 FRIEND_TEST(ClientTest, TestScanFaultTolerance);
3177 FRIEND_TEST(ClientTest, TestScanNoBlockCaching);
3178 FRIEND_TEST(ClientTest, TestScanTimeout);
3179 FRIEND_TEST(ClientTest, TestReadAtSnapshotNoTimestampSet);
3180 FRIEND_TEST(ConsistencyITest, TestSnapshotScanTimestampReuse);
3181 FRIEND_TEST(ScanTokenTest, TestScanTokens);
3182 FRIEND_TEST(ScanTokenTest, TestScanTokens_NonUniquePrimaryKey);
3183
3184 // Owned.
3185 Data* data_;
3186
3187 DISALLOW_COPY_AND_ASSIGN(KuduScanner);
3188};
3189
3210class KUDU_EXPORT KuduScanToken {
3211 public:
3212
3214
3225 Status IntoKuduScanner(KuduScanner** scanner) const WARN_UNUSED_RESULT;
3226
3228 const KuduTablet& tablet() const;
3229
3238 Status Serialize(std::string* buf) const WARN_UNUSED_RESULT;
3239
3252 const std::string& serialized_token,
3253 KuduScanner** scanner) WARN_UNUSED_RESULT;
3254
3255 private:
3256 class KUDU_NO_EXPORT Data;
3257
3258 friend class KuduScanTokenBuilder;
3259
3260 KuduScanToken();
3261
3262 // Owned.
3263 Data* data_;
3264
3265 DISALLOW_COPY_AND_ASSIGN(KuduScanToken);
3266};
3267
3271class KUDU_EXPORT KuduScanTokenBuilder {
3272 public:
3273
3281
3291 Status SetProjectedColumnNames(const std::vector<std::string>& col_names)
3292 WARN_UNUSED_RESULT;
3293
3295 Status SetProjectedColumnIndexes(const std::vector<int>& col_indexes)
3296 WARN_UNUSED_RESULT;
3297
3299 Status AddConjunctPredicate(KuduPredicate* pred) WARN_UNUSED_RESULT;
3300
3302 Status AddLowerBound(const KuduPartialRow& key) WARN_UNUSED_RESULT;
3303
3312 Status AddUpperBound(const KuduPartialRow& key) WARN_UNUSED_RESULT;
3313
3315 Status SetCacheBlocks(bool cache_blocks) WARN_UNUSED_RESULT;
3316
3323 Status SetBatchSizeBytes(uint32_t batch_size) WARN_UNUSED_RESULT;
3324
3333 WARN_UNUSED_RESULT;
3334
3336 Status SetReadMode(KuduScanner::ReadMode read_mode) WARN_UNUSED_RESULT;
3337
3339 Status SetFaultTolerant() WARN_UNUSED_RESULT;
3340
3342 Status SetSnapshotMicros(uint64_t snapshot_timestamp_micros)
3343 WARN_UNUSED_RESULT;
3344
3346 Status SetSnapshotRaw(uint64_t snapshot_timestamp) WARN_UNUSED_RESULT;
3347
3349
3351 Status SetDiffScan(uint64_t start_timestamp, uint64_t end_timestamp)
3352 WARN_UNUSED_RESULT KUDU_NO_EXPORT;
3354
3356 Status SetTimeoutMillis(int millis) WARN_UNUSED_RESULT;
3357
3365 Status IncludeTableMetadata(bool include_metadata) WARN_UNUSED_RESULT;
3366
3374 Status IncludeTabletMetadata(bool include_metadata) WARN_UNUSED_RESULT;
3375
3386 void SetSplitSizeBytes(uint64_t split_size_bytes);
3387
3396 Status Build(std::vector<KuduScanToken*>* tokens) WARN_UNUSED_RESULT;
3397
3398 private:
3399 class KUDU_NO_EXPORT Data;
3400
3401 // Owned.
3402 Data* data_;
3403
3404 DISALLOW_COPY_AND_ASSIGN(KuduScanTokenBuilder);
3405};
3406
3408class KUDU_EXPORT KuduPartitionerBuilder {
3409 public:
3414 explicit KuduPartitionerBuilder(sp::shared_ptr<KuduTable> table);
3416
3423
3443 private:
3444 class KUDU_NO_EXPORT Data;
3445
3446 // Owned.
3447 Data* data_;
3448
3449 DISALLOW_COPY_AND_ASSIGN(KuduPartitionerBuilder);
3450};
3451
3462class KUDU_EXPORT KuduPartitioner {
3463 public:
3465
3469 int NumPartitions() const;
3470
3482 Status PartitionRow(const KuduPartialRow& row, int* partition);
3483 private:
3484 class KUDU_NO_EXPORT Data;
3485
3486 friend class KuduPartitionerBuilder;
3487
3488 explicit KuduPartitioner(Data* data);
3489 Data* data_; // Owned.
3490
3491 DISALLOW_COPY_AND_ASSIGN(KuduPartitioner);
3492};
3493
3494
3495} // namespace client
3496} // namespace kudu
3497#endif
A row which may only contain values for a subset of the columns.
Definition partial_row.h:72
A representation of a time interval.
Definition monotime.h:58
A wrapper around externally allocated data.
Definition slice.h:51
A representation of an operation's outcome.
Definition status.h:165
A "factory" for KuduClient objects.
Definition client.h:234
KuduClientBuilder & encryption_policy(EncryptionPolicy encryption_policy)
KuduClientBuilder & sasl_protocol_name(const std::string &sasl_protocol_name)
KuduClientBuilder & require_authentication(bool require_authentication)
Status Build(sp::shared_ptr< KuduClient > *client)
KuduClientBuilder & default_rpc_timeout(const MonoDelta &timeout)
KuduClientBuilder & master_server_addrs(const std::vector< std::string > &addrs)
KuduClientBuilder & clear_master_server_addrs()
EncryptionPolicy
Policy for on-the-wire encryption.
Definition client.h:240
KuduClientBuilder & import_authentication_credentials(std::string authn_creds)
KuduClientBuilder & jwt(const std::string &jwt)
KuduClientBuilder & default_admin_operation_timeout(const MonoDelta &timeout)
KuduClientBuilder & num_reactors(int num_reactors)
Set the number of reactors for the RPC messenger.
KuduClientBuilder & trusted_certificate(const std::string &cert_pem)
KuduClientBuilder & add_master_server_addr(const std::string &addr)
KuduClientBuilder & connection_negotiation_timeout(const MonoDelta &timeout)
A handle for a connection to a cluster.
Definition client.h:687
void SetLatestObservedTimestamp(uint64_t ht_timestamp)
static const uint64_t kNoTimestamp
Definition client.h:967
bool IsMultiMaster() const
KuduTableCreator * NewTableCreator()
Status IsCreateTableInProgress(const std::string &table_name, bool *create_in_progress)
const MonoDelta & default_admin_operation_timeout() const
MonoDelta connection_negotiation_timeout() const
const MonoDelta & default_rpc_timeout() const
Status DeleteTable(const std::string &table_name)
uint64_t GetLatestObservedTimestamp() const
Status SoftDeleteTable(const std::string &table_name, uint32_t reserve_seconds=0)
Status ExportAuthenticationCredentials(std::string *authn_creds) const
ReplicaSelection
Policy with which to choose amongst multiple replicas.
Definition client.h:940
@ LEADER_ONLY
Select the LEADER replica.
Definition client.h:941
Builder API for specifying or altering a column within a table schema.
Definition schema.h:370
A batch of columnar data returned from a scanner.
Definition columnar_scan_batch.h:51
A single row delete ignore to be sent to the cluster.
Definition write_op.h:331
A single row delete to be sent to the cluster.
Definition write_op.h:305
This class represents an error which occurred in a write operation.
Definition client.h:2187
KuduWriteOperation * release_failed_op()
const KuduWriteOperation & failed_op() const
bool was_possibly_successful() const
const Status & status() const
A single row insert ignore to be sent to the cluster, duplicate row errors are ignored.
Definition write_op.h:172
A single row insert to be sent to the cluster.
Definition write_op.h:145
The interface for all logging callbacks.
Definition callbacks.h:44
Builder for Partitioner instances.
Definition client.h:3408
KuduPartitionerBuilder(sp::shared_ptr< KuduTable > table)
Status Build(KuduPartitioner **partitioner)
KuduPartitionerBuilder * SetBuildTimeout(MonoDelta timeout)
Definition client.h:3462
Status PartitionRow(const KuduPartialRow &row, int *partition)
A representation of comparison predicate for Kudu queries.
Definition scan_predicate.h:43
ComparisonOp
Supported comparison operators.
Definition scan_predicate.h:46
Definition client.h:1485
Status add_hash_partitions(const std::vector< std::string > &columns, int32_t num_buckets, int32_t seed=0)
KuduRangePartition(KuduPartialRow *lower_bound, KuduPartialRow *upper_bound, KuduTableCreator::RangePartitionBound lower_bound_type=KuduTableCreator::INCLUSIVE_BOUND, KuduTableCreator::RangePartitionBound upper_bound_type=KuduTableCreator::EXCLUSIVE_BOUND)
In-memory representation of a remote tablet's replica.
Definition client.h:1166
const KuduTabletServer & ts() const
A batch of zero or more rows returned by a scan operation.
Definition scan_batch.h:84
Builds scan tokens for a table.
Definition client.h:3271
Status SetProjectedColumnIndexes(const std::vector< int > &col_indexes) WARN_UNUSED_RESULT
Status SetProjectedColumnNames(const std::vector< std::string > &col_names) WARN_UNUSED_RESULT
Status SetSelection(KuduClient::ReplicaSelection selection) WARN_UNUSED_RESULT
Status SetBatchSizeBytes(uint32_t batch_size) WARN_UNUSED_RESULT
Status SetFaultTolerant() WARN_UNUSED_RESULT
Status SetCacheBlocks(bool cache_blocks) WARN_UNUSED_RESULT
KuduScanTokenBuilder(KuduTable *table)
Status AddConjunctPredicate(KuduPredicate *pred) WARN_UNUSED_RESULT
Status AddUpperBound(const KuduPartialRow &key) WARN_UNUSED_RESULT
Status SetReadMode(KuduScanner::ReadMode read_mode) WARN_UNUSED_RESULT
Status AddLowerBound(const KuduPartialRow &key) WARN_UNUSED_RESULT
A scan descriptor limited to a single physical contiguous location.
Definition client.h:3210
Status Serialize(std::string *buf) const WARN_UNUSED_RESULT
const KuduTablet & tablet() const
Status IntoKuduScanner(KuduScanner **scanner) const WARN_UNUSED_RESULT
static Status DeserializeIntoScanner(KuduClient *client, const std::string &serialized_token, KuduScanner **scanner) WARN_UNUSED_RESULT
This class is a representation of a single scan.
Definition client.h:2712
Status SetFaultTolerant() WARN_UNUSED_RESULT
Status SetReadMode(ReadMode read_mode) WARN_UNUSED_RESULT
KuduScanner(KuduTable *table)
ReadMode
The read modes for scanners.
Definition client.h:2715
@ READ_AT_SNAPSHOT
Definition client.h:2744
@ READ_LATEST
Definition client.h:2723
OrderMode
Definition client.h:2762
@ UNORDERED
Definition client.h:2768
Status NextBatch(std::vector< KuduRowResult > *rows)
Status AddConjunctPredicate(KuduPredicate *pred) WARN_UNUSED_RESULT
Status SetCacheBlocks(bool cache_blocks)
Status AddExclusiveUpperBound(const KuduPartialRow &key)
Status SetProjectedColumns(const std::vector< std::string > &col_names) WARN_UNUSED_RESULT
Status NextBatch(KuduColumnarScanBatch *batch)
Status AddLowerBound(const KuduPartialRow &key)
Status SetProjectedColumnIndexes(const std::vector< int > &col_indexes) WARN_UNUSED_RESULT
Status SetOrderMode(OrderMode order_mode) WARN_UNUSED_RESULT
Status AddExclusiveUpperBoundPartitionKeyRaw(const Slice &partition_key)
Status AddExclusiveUpperBoundRaw(const Slice &key)
Status AddLowerBoundPartitionKeyRaw(const Slice &partition_key)
Status SetProjectedColumnNames(const std::vector< std::string > &col_names) WARN_UNUSED_RESULT
Status GetCurrentServer(KuduTabletServer **server)
const ResourceMetrics & GetResourceMetrics() const
Status NextBatch(KuduScanBatch *batch)
Status SetSelection(KuduClient::ReplicaSelection selection) WARN_UNUSED_RESULT
Status SetBatchSizeBytes(uint32_t batch_size)
Status AddLowerBoundRaw(const Slice &key)
A representation of a table's schema.
Definition schema.h:688
Representation of a Kudu client session.
Definition client.h:2292
void SetTimeoutMillis(int millis)
Status SetExternalConsistencyMode(ExternalConsistencyMode m) WARN_UNUSED_RESULT
Status Flush() WARN_UNUSED_RESULT
Status SetMutationBufferFlushWatermark(double watermark_pct) WARN_UNUSED_RESULT
Status SetFlushMode(FlushMode m) WARN_UNUSED_RESULT
ExternalConsistencyMode
The possible external consistency modes on which Kudu operates.
Definition client.h:2358
@ CLIENT_PROPAGATED
Definition client.h:2377
Status SetMutationBufferFlushInterval(unsigned int millis) WARN_UNUSED_RESULT
FlushMode
Modes of flush operations.
Definition client.h:2297
@ AUTO_FLUSH_BACKGROUND
Definition client.h:2330
@ AUTO_FLUSH_SYNC
Definition client.h:2302
Status SetMutationBufferMaxNum(unsigned int max_num) WARN_UNUSED_RESULT
Status Apply(KuduWriteOperation *write_op) WARN_UNUSED_RESULT
Status SetMutationBufferSpace(size_t size_bytes) WARN_UNUSED_RESULT
The interface for all status callbacks.
Definition callbacks.h:161
Alters an existing table based on the provided steps.
Definition client.h:1896
KuduColumnSpec * AddColumn(const std::string &name)
KuduTableAlterer * timeout(const MonoDelta &timeout)
KuduTableAlterer * AddRangePartition(KuduPartialRow *lower_bound, KuduPartialRow *upper_bound, KuduTableCreator::RangePartitionBound lower_bound_type=KuduTableCreator::INCLUSIVE_BOUND, KuduTableCreator::RangePartitionBound upper_bound_type=KuduTableCreator::EXCLUSIVE_BOUND)
KuduTableAlterer * DropRangePartition(KuduPartialRow *lower_bound, KuduPartialRow *upper_bound, KuduTableCreator::RangePartitionBound lower_bound_type=KuduTableCreator::INCLUSIVE_BOUND, KuduTableCreator::RangePartitionBound upper_bound_type=KuduTableCreator::EXCLUSIVE_BOUND)
KuduTableAlterer * SetOwner(const std::string &new_owner)
KuduTableAlterer * AddRangePartitionWithDimension(KuduPartialRow *lower_bound, KuduPartialRow *upper_bound, const std::string &dimension_label, KuduTableCreator::RangePartitionBound lower_bound_type=KuduTableCreator::INCLUSIVE_BOUND, KuduTableCreator::RangePartitionBound upper_bound_type=KuduTableCreator::EXCLUSIVE_BOUND)
KuduTableAlterer * SetTableDiskSizeLimit(int64_t disk_size_limit)
KuduTableAlterer * AddRangePartition(KuduRangePartition *partition)
KuduTableAlterer * DropColumn(const std::string &name)
KuduTableAlterer * SetTableRowCountLimit(int64_t row_count_limit)
KuduTableAlterer * AlterExtraConfig(const std::map< std::string, std::string > &extra_configs)
KuduTableAlterer * wait(bool wait)
KuduTableAlterer * RenameTo(const std::string &new_name)
KuduColumnSpec * AlterColumn(const std::string &name)
KuduTableAlterer * SetComment(const std::string &new_comment)
A helper class to create a new table with the desired options.
Definition client.h:1225
KuduTableCreator & timeout(const MonoDelta &timeout)
KuduTableCreator & add_range_partition_split(KuduPartialRow *split_row)
RangePartitionBound
Range partition bound type.
Definition client.h:1307
@ INCLUSIVE_BOUND
An inclusive bound.
Definition client.h:1309
@ EXCLUSIVE_BOUND
An exclusive bound.
Definition client.h:1308
KuduTableCreator & add_hash_partitions(const std::vector< std::string > &columns, int32_t num_buckets, int32_t seed)
KuduTableCreator & add_hash_partitions(const std::vector< std::string > &columns, int32_t num_buckets)
KuduTableCreator & set_range_partition_columns(const std::vector< std::string > &columns)
KuduTableCreator & table_name(const std::string &name)
KuduTableCreator & split_rows(const std::vector< const KuduPartialRow * > &split_rows)
KuduTableCreator & add_range_partition(KuduPartialRow *lower_bound, KuduPartialRow *upper_bound, RangePartitionBound lower_bound_type=INCLUSIVE_BOUND, RangePartitionBound upper_bound_type=EXCLUSIVE_BOUND)
KuduTableCreator & dimension_label(const std::string &dimension_label)
KuduTableCreator & num_replicas(int n_replicas)
KuduTableCreator & set_owner(const std::string &owner)
KuduTableCreator & schema(const KuduSchema *schema)
KuduTableCreator & set_comment(const std::string &comment)
KuduTableCreator & extra_configs(const std::map< std::string, std::string > &extra_configs)
KuduTableCreator & add_custom_range_partition(class KuduRangePartition *partition)
KuduTableCreator & wait(bool wait)
In-memory statistics of table.
Definition client.h:1544
A representation of a table on a particular cluster.
Definition client.h:1613
KuduDelete * NewDelete()
KuduUpsert * NewUpsert()
KuduUpsertIgnore * NewUpsertIgnore()
KuduPredicate * NewInBloomFilterPredicate(const Slice &col_name, std::vector< KuduBloomFilter * > *bloom_filters)
KuduDeleteIgnore * NewDeleteIgnore()
KuduUpdate * NewUpdate()
KuduPredicate * NewIsNullPredicate(const Slice &col_name)
const std::map< std::string, std::string > & extra_configs() const
KuduInsertIgnore * NewInsertIgnore()
KuduUpdateIgnore * NewUpdateIgnore()
const std::string & name() const
KuduPredicate * NewInBloomFilterPredicate(const Slice &col_name, const std::vector< Slice > &bloom_filters)
KuduPredicate * NewInListPredicate(const Slice &col_name, std::vector< KuduValue * > *values)
const std::string & id() const
const PartitionSchema & partition_schema() const
KuduPredicate * NewIsNotNullPredicate(const Slice &col_name)
KuduPredicate * NewComparisonPredicate(const Slice &col_name, KuduPredicate::ComparisonOp op, KuduValue *value)
KuduClient * client() const
KuduInsert * NewInsert()
const KuduSchema & schema() const
const std::string & comment() const
const std::string & owner() const
In-memory representation of a remote tablet server.
Definition client.h:1125
const std::string & hostname() const
const std::string & uuid() const
In-memory representation of a remote tablet.
Definition client.h:1195
const std::string & id() const
const std::vector< const KuduReplica * > & replicas() const
SerializationOptions & enable_keepalive(bool enable)
Definition client.h:434
Status Commit() WARN_UNUSED_RESULT
Status Serialize(std::string *serialized_txn, const SerializationOptions &options=SerializationOptions()) const WARN_UNUSED_RESULT
Status CreateSession(sp::shared_ptr< KuduSession > *session) WARN_UNUSED_RESULT
A single row update ignore to be sent to the cluster, missing row errors and errors on updating immut...
Definition write_op.h:279
A single row update to be sent to the cluster.
Definition write_op.h:252
A single row upsert ignore to be sent to the cluster, errors on updating immutable cells are ignored.
Definition write_op.h:225
A single row upsert to be sent to the cluster.
Definition write_op.h:198
A constant cell value with a specific type.
Definition value.h:37
A single-row write operation to be sent to a Kudu table.
Definition write_op.h:66
A generic catalog of simple metrics.
Definition resource_metrics.h:41
Smart pointer typedefs for externally-faced code.