| # 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. |
| |
| # distutils: language = c++ |
| |
| from libc.stdint cimport * |
| from libcpp cimport bool as c_bool |
| from libcpp.string cimport string |
| from libcpp.vector cimport vector |
| from libcpp.map cimport map |
| |
| # This must be included for cerr and other things to work |
| cdef extern from "<iostream>": |
| pass |
| |
| #---------------------------------------------------------------------- |
| # Smart pointers and such |
| |
| cdef extern from "kudu/client/shared_ptr.h" namespace "kudu::client::sp" nogil: |
| |
| cdef cppclass shared_ptr[T]: |
| T* get() |
| void reset() |
| void reset(T* p) |
| |
| cdef extern from "kudu/util/status.h" namespace "kudu" nogil: |
| |
| # We can later add more of the common status factory methods as needed |
| cdef Status Status_OK "Status::OK"() |
| |
| cdef cppclass Status: |
| Status() |
| |
| string ToString() |
| |
| Slice message() |
| |
| c_bool ok() |
| c_bool IsNotFound() |
| c_bool IsCorruption() |
| c_bool IsNotSupported() |
| c_bool IsIOError() |
| c_bool IsInvalidArgument() |
| c_bool IsAlreadyPresent() |
| c_bool IsRuntimeError() |
| c_bool IsNetworkError() |
| c_bool IsIllegalState() |
| c_bool IsNotAuthorized() |
| c_bool IsAborted() |
| |
| cdef extern from "kudu/util/int128.h" namespace "kudu": |
| # see https://gist.github.com/ricrogz/7f9c405450689866139c49476b959044 |
| # This can be defined on the Python side even if it's not defined on the |
| # C++ side. |
| ctypedef int int128_t |
| |
| cdef extern from "kudu/util/monotime.h" namespace "kudu" nogil: |
| |
| # These classes are not yet needed directly but will need to be completed |
| # from the C++ API |
| cdef cppclass MonoDelta: |
| MonoDelta() |
| |
| @staticmethod |
| MonoDelta FromSeconds(double seconds) |
| |
| @staticmethod |
| MonoDelta FromMilliseconds(int64_t ms) |
| |
| @staticmethod |
| MonoDelta FromMicroseconds(int64_t us) |
| |
| @staticmethod |
| MonoDelta FromNanoseconds(int64_t ns) |
| |
| c_bool Initialized() |
| c_bool LessThan(const MonoDelta& other) |
| c_bool MoreThan(const MonoDelta& other) |
| c_bool Equals(const MonoDelta& other) |
| |
| string ToString() |
| |
| double ToSeconds() |
| int64_t ToMilliseconds() |
| int64_t ToMicroseconds() |
| int64_t ToNanoseconds() |
| |
| # TODO, when needed |
| # void ToTimeVal(struct timeval *tv) |
| # void ToTimeSpec(struct timespec *ts) |
| |
| # @staticmethod |
| # void NanosToTimeSpec(int64_t nanos, struct timespec* ts); |
| |
| |
| cdef cppclass MonoTime: |
| pass |
| |
| |
| cdef extern from "kudu/client/schema.h" namespace "kudu::client" nogil: |
| |
| enum DataType" kudu::client::KuduColumnSchema::DataType": |
| KUDU_INT8 " kudu::client::KuduColumnSchema::INT8" |
| KUDU_INT16 " kudu::client::KuduColumnSchema::INT16" |
| KUDU_INT32 " kudu::client::KuduColumnSchema::INT32" |
| KUDU_INT64 " kudu::client::KuduColumnSchema::INT64" |
| KUDU_STRING " kudu::client::KuduColumnSchema::STRING" |
| KUDU_BOOL " kudu::client::KuduColumnSchema::BOOL" |
| KUDU_FLOAT " kudu::client::KuduColumnSchema::FLOAT" |
| KUDU_DOUBLE " kudu::client::KuduColumnSchema::DOUBLE" |
| KUDU_BINARY " kudu::client::KuduColumnSchema::BINARY" |
| KUDU_UNIXTIME_MICROS " kudu::client::KuduColumnSchema::UNIXTIME_MICROS" |
| KUDU_DECIMAL " kudu::client::KuduColumnSchema::DECIMAL" |
| KUDU_VARCHAR " kudu::client::KuduColumnSchema::VARCHAR" |
| KUDU_DATE " kudu::client::KuduColumnSchema::DATE" |
| |
| enum EncodingType" kudu::client::KuduColumnStorageAttributes::EncodingType": |
| EncodingType_AUTO " kudu::client::KuduColumnStorageAttributes::AUTO_ENCODING" |
| EncodingType_PLAIN " kudu::client::KuduColumnStorageAttributes::PLAIN_ENCODING" |
| EncodingType_PREFIX " kudu::client::KuduColumnStorageAttributes::PREFIX_ENCODING" |
| EncodingType_BIT_SHUFFLE " kudu::client::KuduColumnStorageAttributes::BIT_SHUFFLE" |
| EncodingType_RLE " kudu::client::KuduColumnStorageAttributes::RLE" |
| EncodingType_DICT " kudu::client::KuduColumnStorageAttributes::DICT_ENCODING" |
| |
| enum CompressionType" kudu::client::KuduColumnStorageAttributes::CompressionType": |
| CompressionType_DEFAULT " kudu::client::KuduColumnStorageAttributes::DEFAULT_COMPRESSION" |
| CompressionType_NONE " kudu::client::KuduColumnStorageAttributes::NO_COMPRESSION" |
| CompressionType_SNAPPY " kudu::client::KuduColumnStorageAttributes::SNAPPY" |
| CompressionType_LZ4 " kudu::client::KuduColumnStorageAttributes::LZ4" |
| CompressionType_ZLIB " kudu::client::KuduColumnStorageAttributes::ZLIB" |
| |
| cdef struct KuduColumnStorageAttributes: |
| KuduColumnStorageAttributes() |
| |
| EncodingType encoding |
| CompressionType compression |
| string ToString() |
| |
| cdef cppclass KuduColumnTypeAttributes: |
| KuduColumnTypeAttributes() |
| KuduColumnTypeAttributes(const KuduColumnTypeAttributes& other) |
| KuduColumnTypeAttributes(int8_t precision, int8_t scale) |
| KuduColumnTypeAttributes(uint16_t length) |
| |
| int8_t precision() |
| int8_t scale() |
| uint16_t length() |
| |
| c_bool Equals(KuduColumnTypeAttributes& other) |
| void CopyFrom(KuduColumnTypeAttributes& other) |
| |
| cdef cppclass KuduColumnSchema: |
| KuduColumnSchema(const KuduColumnSchema& other) |
| KuduColumnSchema(const string& name, DataType type) |
| KuduColumnSchema(const string& name, DataType type, c_bool is_nullable) |
| KuduColumnSchema(const string& name, DataType type, c_bool is_nullable, |
| const void* default_value) |
| |
| string& name() |
| c_bool is_nullable() |
| DataType type() |
| KuduColumnTypeAttributes type_attributes() |
| |
| c_bool Equals(KuduColumnSchema& other) |
| void CopyFrom(KuduColumnSchema& other) |
| |
| cdef cppclass KuduSchema: |
| KuduSchema() |
| KuduSchema(const KuduSchema& schema) |
| KuduSchema(vector[KuduColumnSchema]& columns, int key_columns) |
| |
| c_bool Equals(const KuduSchema& other) |
| KuduColumnSchema Column(size_t idx) |
| size_t num_columns() |
| |
| void GetPrimaryKeyColumnIndexes(vector[int]* indexes) |
| |
| KuduPartialRow* NewRow() |
| |
| cdef cppclass KuduColumnSpec: |
| |
| KuduColumnSpec* Default(C_KuduValue* value) |
| KuduColumnSpec* RemoveDefault() |
| |
| KuduColumnSpec* Compression(CompressionType compression) |
| KuduColumnSpec* Encoding(EncodingType encoding) |
| KuduColumnSpec* BlockSize(int32_t block_size) |
| |
| KuduColumnSpec* PrimaryKey() |
| KuduColumnSpec* NotNull() |
| KuduColumnSpec* Nullable() |
| KuduColumnSpec* Type(DataType type_) |
| |
| KuduColumnSpec* Precision(int8_t precision); |
| KuduColumnSpec* Scale(int8_t scale); |
| KuduColumnSpec* Length(uint16_t length); |
| |
| KuduColumnSpec* RenameTo(const string& new_name) |
| |
| |
| cdef cppclass KuduSchemaBuilder: |
| |
| KuduColumnSpec* AddColumn(string& name) |
| KuduSchemaBuilder* SetPrimaryKey(vector[string]& key_col_names); |
| |
| Status Build(KuduSchema* schema) |
| |
| cdef extern from "kudu/client/scan_batch.h" namespace "kudu::client" nogil: |
| |
| cdef cppclass KuduScanBatch: |
| int NumRows() const; |
| KuduRowPtr Row(int idx) const; |
| const KuduSchema* projection_schema() const; |
| |
| cdef cppclass KuduRowPtr " kudu::client::KuduScanBatch::RowPtr": |
| c_bool IsNull(Slice& col_name) |
| c_bool IsNull(int col_idx) |
| |
| # These getters return a bad Status if the type does not match, |
| # the value is unset, or the value is NULL. Otherwise they return |
| # the current set value in *val. |
| Status GetBool(Slice& col_name, c_bool* val) |
| Status GetBool(int col_idx, c_bool* val) |
| |
| Status GetInt8(Slice& col_name, int8_t* val) |
| Status GetInt8(int col_idx, int8_t* val) |
| |
| Status GetInt16(Slice& col_name, int16_t* val) |
| Status GetInt16(int col_idx, int16_t* val) |
| |
| Status GetInt32(Slice& col_name, int32_t* val) |
| Status GetInt32(int col_idx, int32_t* val) |
| |
| Status GetInt64(Slice& col_name, int64_t* val) |
| Status GetInt64(int col_idx, int64_t* val) |
| |
| Status GetUnixTimeMicros(const Slice& col_name, |
| int64_t* micros_since_utc_epoch) |
| Status GetUnixTimeMicros(int col_idx, |
| int64_t* micros_since_utc_epoch) |
| |
| |
| Status GetFloat(Slice& col_name, float* val) |
| Status GetFloat(int col_idx, float* val) |
| |
| Status GetDouble(Slice& col_name, double* val) |
| Status GetDouble(int col_idx, double* val) |
| |
| Status GetUnscaledDecimal(Slice& col_name, int128_t* val) |
| Status GetUnscaledDecimal(int col_idx, int128_t* val) |
| |
| Status GetString(Slice& col_name, Slice* val) |
| Status GetString(int col_idx, Slice* val) |
| |
| Status GetBinary(const Slice& col_name, Slice* val) |
| Status GetBinary(int col_idx, Slice* val) |
| |
| Status GetVarchar(const Slice& col_name, Slice* val) |
| Status GetVarchar(int col_idx, Slice* val) |
| |
| Status GetDate(Slice& col_name, int32_t* val) |
| Status GetDate(int col_idx, int32_t* val) |
| |
| const void* cell(int col_idx) |
| string ToString() |
| |
| cdef extern from "kudu/util/slice.h" namespace "kudu" nogil: |
| |
| cdef cppclass Slice: |
| Slice() |
| Slice(const uint8_t* data, size_t n) |
| Slice(const char* data, size_t n) |
| |
| Slice(string& s) |
| Slice(const char* s) |
| |
| # Many other constructors have been omitted; we can return and add them |
| # as needed for the code generation. |
| |
| const uint8_t* data() |
| uint8_t* mutable_data() |
| size_t size() |
| c_bool empty() |
| |
| uint8_t operator[](size_t n) |
| |
| void clear() |
| void remove_prefix(size_t n) |
| void truncate(size_t n) |
| |
| Status check_size(size_t expected_size) |
| |
| string ToString() |
| |
| string ToDebugString() |
| string ToDebugString(size_t max_len) |
| |
| int compare(Slice& b) |
| |
| c_bool starts_with(Slice& x) |
| |
| void relocate(uint8_t* d) |
| |
| # Many other API methods omitted |
| |
| |
| cdef extern from "kudu/common/partial_row.h" namespace "kudu" nogil: |
| |
| cdef cppclass KuduPartialRow: |
| # Schema must not be garbage-collected |
| # KuduPartialRow(const Schema* schema) |
| |
| #---------------------------------------------------------------------- |
| # Setters |
| |
| # Slice setters |
| Status SetBool(Slice& col_name, c_bool val) |
| |
| Status SetInt8(Slice& col_name, int8_t val) |
| Status SetInt16(Slice& col_name, int16_t val) |
| Status SetInt32(Slice& col_name, int32_t val) |
| Status SetInt64(Slice& col_name, int64_t val) |
| |
| Status SetUnixTimeMicros(const Slice& col_name, |
| int64_t micros_since_utc_epoch) |
| Status SetUnixTimeMicros(int col_idx, int64_t micros_since_utc_epoch) |
| |
| Status SetDouble(Slice& col_name, double val) |
| Status SetFloat(Slice& col_name, float val) |
| |
| Status SetUnscaledDecimal(const Slice& col_name, int128_t val) |
| |
| # Integer setters |
| Status SetBool(int col_idx, c_bool val) |
| |
| Status SetInt8(int col_idx, int8_t val) |
| Status SetInt16(int col_idx, int16_t val) |
| Status SetInt32(int col_idx, int32_t val) |
| Status SetInt64(int col_idx, int64_t val) |
| |
| Status SetDouble(int col_idx, double val) |
| Status SetFloat(int col_idx, float val) |
| |
| Status SetUnscaledDecimal(int col_idx, int128_t val) |
| |
| # Set, but does not copy string |
| Status SetString(Slice& col_name, Slice& val) |
| Status SetString(int col_idx, Slice& val) |
| |
| Status SetStringCopy(Slice& col_name, Slice& val) |
| Status SetStringCopy(int col_idx, Slice& val) |
| |
| Status SetBinary(Slice& col_name, Slice& val) |
| Status SetBinary(int col_idx, Slice&val) |
| |
| Status SetBinaryCopy(const Slice& col_name, const Slice& val) |
| Status SetBinaryCopy(int col_idx, const Slice& val) |
| |
| Status SetVarchar(Slice& col_name, Slice& val) |
| Status SetVarchar(int col_idx, Slice& val) |
| |
| Status SetDate(Slice& col_name, int32_t val) |
| Status SetDate(int col_idx, int32_t val) |
| |
| Status SetNull(Slice& col_name) |
| Status SetNull(int col_idx) |
| |
| Status Unset(Slice& col_name) |
| Status Unset(int col_idx) |
| |
| #---------------------------------------------------------------------- |
| # Getters |
| |
| c_bool IsColumnSet(Slice& col_name) |
| c_bool IsColumnSet(int col_idx) |
| |
| c_bool IsNull(Slice& col_name) |
| c_bool IsNull(int col_idx) |
| |
| Status GetBool(Slice& col_name, c_bool* val) |
| Status GetBool(int col_idx, c_bool* val) |
| |
| Status GetInt8(Slice& col_name, int8_t* val) |
| Status GetInt8(int col_idx, int8_t* val) |
| |
| Status GetInt16(Slice& col_name, int16_t* val) |
| Status GetInt16(int col_idx, int16_t* val) |
| |
| Status GetInt32(Slice& col_name, int32_t* val) |
| Status GetInt32(int col_idx, int32_t* val) |
| |
| Status GetInt64(Slice& col_name, int64_t* val) |
| Status GetInt64(int col_idx, int64_t* val) |
| |
| Status GetUnixTimeMicros(const Slice& col_name, |
| int64_t* micros_since_utc_epoch) |
| Status GetUnixTimeMicros(int col_idx, int64_t* micros_since_utc_epoch) |
| |
| Status GetDouble(Slice& col_name, double* val) |
| Status GetDouble(int col_idx, double* val) |
| |
| Status GetFloat(Slice& col_name, float* val) |
| Status GetFloat(int col_idx, float* val) |
| |
| Status GetUnscaledDecimal(Slice& col_name, int128_t* val) |
| Status GetUnscaledDecimal(int col_idx, int128_t* val) |
| |
| # Gets the string but does not copy the value. Callers should |
| # copy the resulting Slice if necessary. |
| Status GetString(Slice& col_name, Slice* val) |
| Status GetString(int col_idx, Slice* val) |
| |
| Status GetBinary(const Slice& col_name, Slice* val) |
| Status GetBinary(int col_idx, Slice* val) |
| |
| Status GetVarchar(Slice& col_name, Slice* val) |
| Status GetVarchar(int col_idx, Slice* val) |
| |
| Status EncodeRowKey(string* encoded_key) |
| string ToEncodedRowKeyOrDie() |
| |
| # Return true if all of the key columns have been specified |
| # for this mutation. |
| c_bool IsKeySet() |
| |
| # Return true if all columns have been specified. |
| c_bool AllColumnsSet() |
| string ToString() |
| |
| # const Schema* schema() |
| |
| |
| cdef extern from "kudu/client/write_op.h" namespace "kudu::client" nogil: |
| |
| enum WriteType" kudu::client::KuduWriteOperation::Type": |
| INSERT " kudu::client::KuduWriteOperation::INSERT" |
| UPDATE " kudu::client::KuduWriteOperation::UPDATE" |
| DELETE " kudu::client::KuduWriteOperation::DELETE" |
| UPSERT " kudu::client::KuduWriteOperation::UPSERT" |
| INSERT_IGNORE " kudu::client::KuduWriteOperation::INSERT_IGNORE" |
| UPDATE_IGNORE " kudu::client::KuduWriteOperation::UPDATE_IGNORE" |
| DELETE_IGNORE " kudu::client::KuduWriteOperation::DELETE_IGNORE" |
| |
| cdef cppclass KuduWriteOperation: |
| KuduPartialRow& row() |
| KuduPartialRow* mutable_row() |
| |
| # This is a pure virtual function implemented on each of the cppclass |
| # subclasses |
| string ToString() |
| |
| # Also a pure virtual |
| WriteType type() |
| |
| cdef cppclass KuduInsert(KuduWriteOperation): |
| pass |
| |
| cdef cppclass KuduInsertIgnore(KuduWriteOperation): |
| pass |
| |
| cdef cppclass KuduUpsert(KuduWriteOperation): |
| pass |
| |
| cdef cppclass KuduDelete(KuduWriteOperation): |
| pass |
| |
| cdef cppclass KuduDeleteIgnore(KuduWriteOperation): |
| pass |
| |
| cdef cppclass KuduUpdate(KuduWriteOperation): |
| pass |
| |
| cdef cppclass KuduUpdateIgnore(KuduWriteOperation): |
| pass |
| |
| |
| cdef extern from "kudu/client/scan_predicate.h" namespace "kudu::client" nogil: |
| enum ComparisonOp" kudu::client::KuduPredicate::ComparisonOp": |
| KUDU_LESS_EQUAL " kudu::client::KuduPredicate::LESS_EQUAL" |
| KUDU_GREATER_EQUAL " kudu::client::KuduPredicate::GREATER_EQUAL" |
| KUDU_EQUAL " kudu::client::KuduPredicate::EQUAL" |
| KUDU_LESS " kudu::client::KuduPredicate::LESS" |
| KUDU_GREATER " kudu::client::KuduPredicate::GREATER" |
| |
| cdef cppclass KuduPredicate: |
| KuduPredicate* Clone() |
| |
| |
| cdef extern from "kudu/client/value.h" namespace "kudu::client" nogil: |
| |
| cdef cppclass C_KuduValue "kudu::client::KuduValue": |
| @staticmethod |
| C_KuduValue* FromInt(int64_t val); |
| |
| @staticmethod |
| C_KuduValue* FromFloat(float val); |
| |
| @staticmethod |
| C_KuduValue* FromDouble(double val); |
| |
| @staticmethod |
| C_KuduValue* FromBool(c_bool val); |
| |
| @staticmethod |
| C_KuduValue* FromDecimal(int128_t val, int8_t scale); |
| |
| @staticmethod |
| C_KuduValue* CopyString(const Slice& s); |
| |
| |
| cdef extern from "kudu/client/client.h" namespace "kudu::client" nogil: |
| |
| enum ReplicaSelection" kudu::client::KuduClient::ReplicaSelection": |
| ReplicaSelection_Leader " kudu::client::KuduClient::LEADER_ONLY" |
| ReplicaSelection_Closest " kudu::client::KuduClient::CLOSEST_REPLICA" |
| ReplicaSelection_First " kudu::client::KuduClient::FIRST_REPLICA" |
| |
| enum ReadMode" kudu::client::KuduScanner::ReadMode": |
| ReadMode_Latest " kudu::client::KuduScanner::READ_LATEST" |
| ReadMode_Snapshot " kudu::client::KuduScanner::READ_AT_SNAPSHOT" |
| ReadMode_ReadYourWrites " kudu::client::KuduScanner::READ_YOUR_WRITES" |
| |
| enum RangePartitionBound" kudu::client::KuduTableCreator::RangePartitionBound": |
| PartitionType_Exclusive " kudu::client::KuduTableCreator::EXCLUSIVE_BOUND" |
| PartitionType_Inclusive " kudu::client::KuduTableCreator::INCLUSIVE_BOUND" |
| |
| enum EncryptionPolicy" kudu::client::KuduClientBuilder::EncryptionPolicy": |
| EncryptionPolicy_Optional " kudu::client::KuduClientBuilder::EncryptionPolicy::OPTIONAL" |
| EncryptionPolicy_RequiredRemote " kudu::client::KuduClientBuilder::EncryptionPolicy::REQUIRED_REMOTE" |
| EncryptionPolicy_Required " kudu::client::KuduClientBuilder::EncryptionPolicy::REQUIRED" |
| |
| Status DisableOpenSSLInitialization() |
| |
| cdef cppclass KuduClient: |
| |
| Status DeleteTable(const string& table_name) |
| Status OpenTable(const string& table_name, |
| shared_ptr[KuduTable]* table) |
| Status GetTableSchema(const string& table_name, KuduSchema* schema) |
| |
| KuduTableCreator* NewTableCreator() |
| Status IsCreateTableInProgress(const string& table_name, |
| c_bool* create_in_progress) |
| |
| c_bool IsMultiMaster() |
| |
| Status ListTables(vector[string]* tables) |
| Status ListTables(vector[string]* tables, const string& filter) |
| |
| Status ListTabletServers(vector[KuduTabletServer*]* tablet_servers) |
| |
| Status TableExists(const string& table_name, c_bool* exists) |
| |
| KuduTableAlterer* NewTableAlterer(const string& table_name) |
| Status IsAlterTableInProgress(const string& table_name, |
| c_bool* alter_in_progress) |
| uint64_t GetLatestObservedTimestamp() |
| |
| shared_ptr[KuduSession] NewSession() |
| |
| cdef cppclass KuduClientBuilder: |
| KuduClientBuilder() |
| KuduClientBuilder& master_server_addrs(const vector[string]& addrs) |
| KuduClientBuilder& add_master_server_addr(const string& addr) |
| |
| KuduClientBuilder& default_admin_operation_timeout( |
| const MonoDelta& timeout) |
| |
| KuduClientBuilder& default_rpc_timeout(const MonoDelta& timeout) |
| |
| KuduClientBuilder& sasl_protocol_name(const string& sasl_protocol_name) |
| |
| KuduClientBuilder& require_authentication(c_bool require_authentication) |
| |
| KuduClientBuilder& encryption_policy(EncryptionPolicy encryption_policy) |
| |
| Status Build(shared_ptr[KuduClient]* client) |
| |
| cdef cppclass KuduTabletServer: |
| KuduTabletServer() |
| string& uuid() |
| string& hostname() |
| uint16_t port() |
| |
| cdef cppclass KuduRangePartition: |
| KuduRangePartition(KuduPartialRow* lower_bound, |
| KuduPartialRow* upper_bound, |
| RangePartitionBound lower_bound_type, |
| RangePartitionBound upper_bound_type) |
| Status add_hash_partitions(vector[string]& columns, |
| int num_buckets, |
| int seed) |
| |
| cdef cppclass KuduTableCreator: |
| |
| KuduTableCreator& table_name(string& name) |
| KuduTableCreator& schema(KuduSchema* schema) |
| KuduTableCreator& add_hash_partitions(vector[string]& columns, |
| int num_buckets) |
| KuduTableCreator& add_hash_partitions(vector[string]& columns, |
| int num_buckets, |
| int seed) |
| KuduTableCreator& set_range_partition_columns(vector[string]& columns) |
| KuduTableCreator& add_range_partition(KuduPartialRow* lower_bound, |
| KuduPartialRow* upper_bound, |
| RangePartitionBound lower_bound_type, |
| RangePartitionBound upper_bound_type) |
| KuduTableCreator& add_custom_range_partition(KuduRangePartition* p) |
| KuduTableCreator& add_range_partition_split(KuduPartialRow* split_row) |
| KuduTableCreator& split_rows(vector[const KuduPartialRow*]& split_rows) |
| KuduTableCreator& num_replicas(int n_replicas) |
| KuduTableCreator& wait(c_bool wait) |
| KuduTableCreator& set_owner(const string& owner) |
| KuduTableCreator& set_comment(const string& comment) |
| |
| Status Create() |
| |
| cdef cppclass KuduTableAlterer: |
| KuduTableAlterer& RenameTo(const string& new_name) |
| KuduColumnSpec* AddColumn(const string& name) |
| KuduColumnSpec* AlterColumn(const string& name) |
| KuduTableAlterer& DropColumn(const string& name) |
| KuduTableAlterer& AddRangePartition(KuduPartialRow* lower_bound, |
| KuduPartialRow* upper_bound, |
| RangePartitionBound lower_bound_type, |
| RangePartitionBound upper_bound_type) |
| KuduTableAlterer& AddRangePartition(KuduRangePartition* p) |
| KuduTableAlterer& DropRangePartition(KuduPartialRow* lower_bound, |
| KuduPartialRow* upper_bound, |
| RangePartitionBound lower_bound_type, |
| RangePartitionBound upper_bound_type) |
| KuduTableAlterer& SetOwner(const string& new_owner) |
| KuduTableAlterer& SetComment(const string& new_comment) |
| |
| KuduTableAlterer& wait(c_bool wait) |
| |
| Status Alter() |
| |
| # Instances of KuduTable are not directly instantiated by users of the |
| # client. |
| cdef cppclass KuduTable: |
| |
| string& name() |
| string& id() |
| string& owner() |
| string& comment() |
| KuduSchema& schema() |
| int num_replicas() |
| |
| KuduInsert* NewInsert() |
| KuduInsertIgnore* NewInsertIgnore() |
| KuduUpsert* NewUpsert() |
| KuduUpdate* NewUpdate() |
| KuduUpdateIgnore* NewUpdateIgnore() |
| KuduDelete* NewDelete() |
| KuduDeleteIgnore* NewDeleteIgnore() |
| |
| KuduPredicate* NewComparisonPredicate(const Slice& col_name, |
| ComparisonOp op, |
| C_KuduValue* value); |
| KuduPredicate* NewInListPredicate(const Slice& col_name, |
| vector[C_KuduValue*]* values) |
| KuduPredicate* NewIsNotNullPredicate(const Slice& col_name) |
| KuduPredicate* NewIsNullPredicate(const Slice& col_name) |
| |
| KuduClient* client() |
| # const PartitionSchema& partition_schema() |
| |
| enum FlushMode" kudu::client::KuduSession::FlushMode": |
| FlushMode_AutoSync " kudu::client::KuduSession::AUTO_FLUSH_SYNC" |
| FlushMode_AutoBackground " kudu::client::KuduSession::AUTO_FLUSH_BACKGROUND" |
| FlushMode_Manual " kudu::client::KuduSession::MANUAL_FLUSH" |
| |
| cdef cppclass KuduSession: |
| |
| Status SetFlushMode(FlushMode m) |
| |
| Status SetMutationBufferSpace(size_t size) |
| Status SetMutationBufferFlushWatermark(double watermark_pct) |
| Status SetMutationBufferFlushInterval(unsigned int millis) |
| Status SetMutationBufferMaxNum(unsigned int max_num) |
| |
| void SetTimeoutMillis(int millis) |
| |
| void SetPriority(int priority) |
| |
| Status Apply(KuduWriteOperation* write_op) |
| Status Apply(KuduInsert* write_op) |
| Status Apply(KuduInsertIgnore* write_op) |
| Status Apply(KuduUpsert* write_op) |
| Status Apply(KuduUpdate* write_op) |
| Status Apply(KuduUpdateIgnore* write_op) |
| Status Apply(KuduDelete* write_op) |
| Status Apply(KuduDeleteIgnore* write_op) |
| |
| # This is thread-safe |
| Status Flush() |
| |
| # TODO: Will need to decide on a strategy for exposing the session's |
| # async API to Python |
| |
| # Status ApplyAsync(KuduWriteOperation* write_op, |
| # KuduStatusCallback cb) |
| # Status ApplyAsync(KuduInsert* write_op, |
| # KuduStatusCallback cb) |
| # Status ApplyAsync(KuduUpdate* write_op, |
| # KuduStatusCallback cb) |
| # Status ApplyAsync(KuduDelete* write_op, |
| # KuduStatusCallback cb) |
| # void FlushAsync(KuduStatusCallback& cb) |
| |
| |
| Status Close() |
| c_bool HasPendingOperations() |
| int CountBufferedOperations() |
| |
| int CountPendingErrors() |
| void GetPendingErrors(vector[C_KuduError*]* errors, c_bool* overflowed) |
| |
| KuduClient* client() |
| |
| |
| cdef cppclass KuduScanner: |
| KuduScanner(KuduTable* table) |
| |
| Status AddConjunctPredicate(KuduPredicate* pred) |
| |
| Status Open() |
| void Close() |
| |
| c_bool HasMoreRows() |
| Status NextBatch(KuduScanBatch* batch) |
| Status SetBatchSizeBytes(uint32_t batch_size) |
| Status SetSelection(ReplicaSelection selection) |
| Status SetCacheBlocks(c_bool cache_blocks) |
| Status SetReadMode(ReadMode read_mode) |
| Status SetSnapshotMicros(uint64_t snapshot_timestamp_micros) |
| Status SetTimeoutMillis(int millis) |
| Status SetProjectedColumnNames(const vector[string]& col_names) |
| Status SetProjectedColumnIndexes(const vector[int]& col_indexes) |
| Status SetFaultTolerant() |
| Status AddLowerBound(const KuduPartialRow& key) |
| Status AddExclusiveUpperBound(const KuduPartialRow& key) |
| Status SetLimit(int64_t limit) |
| Status KeepAlive() |
| Status GetCurrentServer(KuduTabletServer** server) |
| |
| KuduSchema GetProjectionSchema() |
| const ResourceMetrics& GetResourceMetrics() |
| string ToString() |
| |
| cdef cppclass KuduScanToken: |
| KuduScanToken() |
| |
| const KuduTablet& tablet() |
| |
| Status IntoKuduScanner(KuduScanner** scanner) |
| Status Serialize(string* buf) |
| Status DeserializeIntoScanner(KuduClient* client, |
| const string& serialized_token, |
| KuduScanner** scanner) |
| |
| cdef cppclass KuduScanTokenBuilder: |
| KuduScanTokenBuilder(KuduTable* table) |
| |
| Status SetProjectedColumnNames(const vector[string]& col_names) |
| Status SetProjectedColumnIndexes(const vector[int]& col_indexes) |
| Status SetBatchSizeBytes(uint32_t batch_size) |
| Status SetReadMode(ReadMode read_mode) |
| Status SetFaultTolerant() |
| Status SetSnapshotMicros(uint64_t snapshot_timestamp_micros) |
| Status SetSelection(ReplicaSelection selection) |
| Status SetTimeoutMillis(int millis) |
| Status AddConjunctPredicate(KuduPredicate* pred) |
| Status AddLowerBound(const KuduPartialRow& key) |
| Status AddUpperBound(const KuduPartialRow& key) |
| Status SetCacheBlocks(c_bool cache_blocks) |
| Status Build(vector[KuduScanToken*]* tokens) |
| |
| cdef cppclass KuduTablet: |
| KuduTablet() |
| |
| const string& id() |
| const vector[const KuduReplica*]& replicas() |
| |
| cdef cppclass KuduReplica: |
| KuduReplica() |
| |
| c_bool is_leader() |
| const KuduTabletServer& ts() |
| |
| cdef cppclass C_KuduError " kudu::client::KuduError": |
| |
| Status& status() |
| |
| KuduWriteOperation& failed_op() |
| KuduWriteOperation* release_failed_op() |
| |
| c_bool was_possibly_successful() |
| |
| cdef extern from "kudu/client/resource_metrics.h" namespace "kudu::client" nogil: |
| |
| cdef cppclass ResourceMetrics: |
| ResourceMetrics() |
| |
| map[string, int64_t] Get() |
| int64_t GetMetric(const string& name) |
