http://git-wip-us.apache.org/repos/asf/accumulo/blob/3298263a/proxy/src/main/cpp/proxy_types.cpp ---------------------------------------------------------------------- diff --git a/proxy/src/main/cpp/proxy_types.cpp b/proxy/src/main/cpp/proxy_types.cpp index 8473802..54694bb 100644 --- a/proxy/src/main/cpp/proxy_types.cpp +++ b/proxy/src/main/cpp/proxy_types.cpp @@ -106,6 +106,22 @@ const char* _kScanStateNames[] = { }; const std::map<int, const char*> _ScanState_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kScanStateValues, _kScanStateNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); +int _kConditionalStatusValues[] = { + ConditionalStatus::ACCEPTED, + ConditionalStatus::REJECTED, + ConditionalStatus::VIOLATED, + ConditionalStatus::UNKNOWN, + ConditionalStatus::INVISIBLE_VISIBILITY +}; +const char* _kConditionalStatusNames[] = { + "ACCEPTED", + "REJECTED", + "VIOLATED", + "UNKNOWN", + "INVISIBLE_VISIBILITY" +}; +const std::map<int, const char*> _ConditionalStatus_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(5, _kConditionalStatusValues, _kConditionalStatusNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + int _kCompactionTypeValues[] = { CompactionType::MINOR, CompactionType::MERGE, @@ -404,6 +420,101 @@ void swap(ColumnUpdate &a, ColumnUpdate &b) { swap(a.__isset, b.__isset); } +const char* DiskUsage::ascii_fingerprint = "D26F4F5E2867D41CF7E0391263932D6B"; +const uint8_t DiskUsage::binary_fingerprint[16] = {0xD2,0x6F,0x4F,0x5E,0x28,0x67,0xD4,0x1C,0xF7,0xE0,0x39,0x12,0x63,0x93,0x2D,0x6B}; + +uint32_t DiskUsage::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->tables.clear(); + uint32_t _size0; + ::apache::thrift::protocol::TType _etype3; + xfer += iprot->readListBegin(_etype3, _size0); + this->tables.resize(_size0); + uint32_t _i4; + for (_i4 = 0; _i4 < _size0; ++_i4) + { + xfer += iprot->readString(this->tables[_i4]); + } + xfer += iprot->readListEnd(); + } + this->__isset.tables = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->usage); + this->__isset.usage = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t DiskUsage::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("DiskUsage"); + + xfer += oprot->writeFieldBegin("tables", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tables.size())); + std::vector<std::string> ::const_iterator _iter5; + for (_iter5 = this->tables.begin(); _iter5 != this->tables.end(); ++_iter5) + { + xfer += oprot->writeString((*_iter5)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("usage", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->usage); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(DiskUsage &a, DiskUsage &b) { + using ::std::swap; + swap(a.tables, b.tables); + swap(a.usage, b.usage); + swap(a.__isset, b.__isset); +} + const char* KeyValue::ascii_fingerprint = "0D0CA44F233F983E00E94228C31ABBD4"; const uint8_t KeyValue::binary_fingerprint[16] = {0x0D,0x0C,0xA4,0x4F,0x23,0x3F,0x98,0x3E,0x00,0xE9,0x42,0x28,0xC3,0x1A,0xBB,0xD4}; @@ -506,14 +617,14 @@ uint32_t ScanResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->results.clear(); - uint32_t _size0; - ::apache::thrift::protocol::TType _etype3; - xfer += iprot->readListBegin(_etype3, _size0); - this->results.resize(_size0); - uint32_t _i4; - for (_i4 = 0; _i4 < _size0; ++_i4) + uint32_t _size6; + ::apache::thrift::protocol::TType _etype9; + xfer += iprot->readListBegin(_etype9, _size6); + this->results.resize(_size6); + uint32_t _i10; + for (_i10 = 0; _i10 < _size6; ++_i10) { - xfer += this->results[_i4].read(iprot); + xfer += this->results[_i10].read(iprot); } xfer += iprot->readListEnd(); } @@ -549,10 +660,10 @@ uint32_t ScanResult::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("results", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->results.size())); - std::vector<KeyValue> ::const_iterator _iter5; - for (_iter5 = this->results.begin(); _iter5 != this->results.end(); ++_iter5) + std::vector<KeyValue> ::const_iterator _iter11; + for (_iter11 = this->results.begin(); _iter11 != this->results.end(); ++_iter11) { - xfer += (*_iter5).write(oprot); + xfer += (*_iter11).write(oprot); } xfer += oprot->writeListEnd(); } @@ -802,17 +913,17 @@ uint32_t IteratorSetting::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size6; - ::apache::thrift::protocol::TType _ktype7; - ::apache::thrift::protocol::TType _vtype8; - xfer += iprot->readMapBegin(_ktype7, _vtype8, _size6); - uint32_t _i10; - for (_i10 = 0; _i10 < _size6; ++_i10) + uint32_t _size12; + ::apache::thrift::protocol::TType _ktype13; + ::apache::thrift::protocol::TType _vtype14; + xfer += iprot->readMapBegin(_ktype13, _vtype14, _size12); + uint32_t _i16; + for (_i16 = 0; _i16 < _size12; ++_i16) { - std::string _key11; - xfer += iprot->readString(_key11); - std::string& _val12 = this->properties[_key11]; - xfer += iprot->readString(_val12); + std::string _key17; + xfer += iprot->readString(_key17); + std::string& _val18 = this->properties[_key17]; + xfer += iprot->readString(_val18); } xfer += iprot->readMapEnd(); } @@ -852,11 +963,11 @@ uint32_t IteratorSetting::write(::apache::thrift::protocol::TProtocol* oprot) co xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 4); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->properties.size())); - std::map<std::string, std::string> ::const_iterator _iter13; - for (_iter13 = this->properties.begin(); _iter13 != this->properties.end(); ++_iter13) + std::map<std::string, std::string> ::const_iterator _iter19; + for (_iter19 = this->properties.begin(); _iter19 != this->properties.end(); ++_iter19) { - xfer += oprot->writeString(_iter13->first); - xfer += oprot->writeString(_iter13->second); + xfer += oprot->writeString(_iter19->first); + xfer += oprot->writeString(_iter19->second); } xfer += oprot->writeMapEnd(); } @@ -903,15 +1014,15 @@ uint32_t ScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_SET) { { this->authorizations.clear(); - uint32_t _size14; - ::apache::thrift::protocol::TType _etype17; - xfer += iprot->readSetBegin(_etype17, _size14); - uint32_t _i18; - for (_i18 = 0; _i18 < _size14; ++_i18) + uint32_t _size20; + ::apache::thrift::protocol::TType _etype23; + xfer += iprot->readSetBegin(_etype23, _size20); + uint32_t _i24; + for (_i24 = 0; _i24 < _size20; ++_i24) { - std::string _elem19; - xfer += iprot->readBinary(_elem19); - this->authorizations.insert(_elem19); + std::string _elem25; + xfer += iprot->readBinary(_elem25); + this->authorizations.insert(_elem25); } xfer += iprot->readSetEnd(); } @@ -932,14 +1043,14 @@ uint32_t ScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->columns.clear(); - uint32_t _size20; - ::apache::thrift::protocol::TType _etype23; - xfer += iprot->readListBegin(_etype23, _size20); - this->columns.resize(_size20); - uint32_t _i24; - for (_i24 = 0; _i24 < _size20; ++_i24) + uint32_t _size26; + ::apache::thrift::protocol::TType _etype29; + xfer += iprot->readListBegin(_etype29, _size26); + this->columns.resize(_size26); + uint32_t _i30; + for (_i30 = 0; _i30 < _size26; ++_i30) { - xfer += this->columns[_i24].read(iprot); + xfer += this->columns[_i30].read(iprot); } xfer += iprot->readListEnd(); } @@ -952,14 +1063,14 @@ uint32_t ScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->iterators.clear(); - uint32_t _size25; - ::apache::thrift::protocol::TType _etype28; - xfer += iprot->readListBegin(_etype28, _size25); - this->iterators.resize(_size25); - uint32_t _i29; - for (_i29 = 0; _i29 < _size25; ++_i29) + uint32_t _size31; + ::apache::thrift::protocol::TType _etype34; + xfer += iprot->readListBegin(_etype34, _size31); + this->iterators.resize(_size31); + uint32_t _i35; + for (_i35 = 0; _i35 < _size31; ++_i35) { - xfer += this->iterators[_i29].read(iprot); + xfer += this->iterators[_i35].read(iprot); } xfer += iprot->readListEnd(); } @@ -996,10 +1107,10 @@ uint32_t ScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) const xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_SET, 1); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size())); - std::set<std::string> ::const_iterator _iter30; - for (_iter30 = this->authorizations.begin(); _iter30 != this->authorizations.end(); ++_iter30) + std::set<std::string> ::const_iterator _iter36; + for (_iter36 = this->authorizations.begin(); _iter36 != this->authorizations.end(); ++_iter36) { - xfer += oprot->writeBinary((*_iter30)); + xfer += oprot->writeBinary((*_iter36)); } xfer += oprot->writeSetEnd(); } @@ -1014,10 +1125,10 @@ uint32_t ScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) const xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size())); - std::vector<ScanColumn> ::const_iterator _iter31; - for (_iter31 = this->columns.begin(); _iter31 != this->columns.end(); ++_iter31) + std::vector<ScanColumn> ::const_iterator _iter37; + for (_iter37 = this->columns.begin(); _iter37 != this->columns.end(); ++_iter37) { - xfer += (*_iter31).write(oprot); + xfer += (*_iter37).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1027,10 +1138,10 @@ uint32_t ScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) const xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size())); - std::vector<IteratorSetting> ::const_iterator _iter32; - for (_iter32 = this->iterators.begin(); _iter32 != this->iterators.end(); ++_iter32) + std::vector<IteratorSetting> ::const_iterator _iter38; + for (_iter38 = this->iterators.begin(); _iter38 != this->iterators.end(); ++_iter38) { - xfer += (*_iter32).write(oprot); + xfer += (*_iter38).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1083,15 +1194,15 @@ uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_SET) { { this->authorizations.clear(); - uint32_t _size33; - ::apache::thrift::protocol::TType _etype36; - xfer += iprot->readSetBegin(_etype36, _size33); - uint32_t _i37; - for (_i37 = 0; _i37 < _size33; ++_i37) + uint32_t _size39; + ::apache::thrift::protocol::TType _etype42; + xfer += iprot->readSetBegin(_etype42, _size39); + uint32_t _i43; + for (_i43 = 0; _i43 < _size39; ++_i43) { - std::string _elem38; - xfer += iprot->readBinary(_elem38); - this->authorizations.insert(_elem38); + std::string _elem44; + xfer += iprot->readBinary(_elem44); + this->authorizations.insert(_elem44); } xfer += iprot->readSetEnd(); } @@ -1104,14 +1215,14 @@ uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->ranges.clear(); - uint32_t _size39; - ::apache::thrift::protocol::TType _etype42; - xfer += iprot->readListBegin(_etype42, _size39); - this->ranges.resize(_size39); - uint32_t _i43; - for (_i43 = 0; _i43 < _size39; ++_i43) + uint32_t _size45; + ::apache::thrift::protocol::TType _etype48; + xfer += iprot->readListBegin(_etype48, _size45); + this->ranges.resize(_size45); + uint32_t _i49; + for (_i49 = 0; _i49 < _size45; ++_i49) { - xfer += this->ranges[_i43].read(iprot); + xfer += this->ranges[_i49].read(iprot); } xfer += iprot->readListEnd(); } @@ -1124,14 +1235,14 @@ uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->columns.clear(); - uint32_t _size44; - ::apache::thrift::protocol::TType _etype47; - xfer += iprot->readListBegin(_etype47, _size44); - this->columns.resize(_size44); - uint32_t _i48; - for (_i48 = 0; _i48 < _size44; ++_i48) + uint32_t _size50; + ::apache::thrift::protocol::TType _etype53; + xfer += iprot->readListBegin(_etype53, _size50); + this->columns.resize(_size50); + uint32_t _i54; + for (_i54 = 0; _i54 < _size50; ++_i54) { - xfer += this->columns[_i48].read(iprot); + xfer += this->columns[_i54].read(iprot); } xfer += iprot->readListEnd(); } @@ -1144,14 +1255,14 @@ uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->iterators.clear(); - uint32_t _size49; - ::apache::thrift::protocol::TType _etype52; - xfer += iprot->readListBegin(_etype52, _size49); - this->iterators.resize(_size49); - uint32_t _i53; - for (_i53 = 0; _i53 < _size49; ++_i53) + uint32_t _size55; + ::apache::thrift::protocol::TType _etype58; + xfer += iprot->readListBegin(_etype58, _size55); + this->iterators.resize(_size55); + uint32_t _i59; + for (_i59 = 0; _i59 < _size55; ++_i59) { - xfer += this->iterators[_i53].read(iprot); + xfer += this->iterators[_i59].read(iprot); } xfer += iprot->readListEnd(); } @@ -1188,10 +1299,10 @@ uint32_t BatchScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_SET, 1); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size())); - std::set<std::string> ::const_iterator _iter54; - for (_iter54 = this->authorizations.begin(); _iter54 != this->authorizations.end(); ++_iter54) + std::set<std::string> ::const_iterator _iter60; + for (_iter60 = this->authorizations.begin(); _iter60 != this->authorizations.end(); ++_iter60) { - xfer += oprot->writeBinary((*_iter54)); + xfer += oprot->writeBinary((*_iter60)); } xfer += oprot->writeSetEnd(); } @@ -1201,10 +1312,10 @@ uint32_t BatchScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("ranges", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->ranges.size())); - std::vector<Range> ::const_iterator _iter55; - for (_iter55 = this->ranges.begin(); _iter55 != this->ranges.end(); ++_iter55) + std::vector<Range> ::const_iterator _iter61; + for (_iter61 = this->ranges.begin(); _iter61 != this->ranges.end(); ++_iter61) { - xfer += (*_iter55).write(oprot); + xfer += (*_iter61).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1214,10 +1325,10 @@ uint32_t BatchScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size())); - std::vector<ScanColumn> ::const_iterator _iter56; - for (_iter56 = this->columns.begin(); _iter56 != this->columns.end(); ++_iter56) + std::vector<ScanColumn> ::const_iterator _iter62; + for (_iter62 = this->columns.begin(); _iter62 != this->columns.end(); ++_iter62) { - xfer += (*_iter56).write(oprot); + xfer += (*_iter62).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1227,10 +1338,10 @@ uint32_t BatchScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size())); - std::vector<IteratorSetting> ::const_iterator _iter57; - for (_iter57 = this->iterators.begin(); _iter57 != this->iterators.end(); ++_iter57) + std::vector<IteratorSetting> ::const_iterator _iter63; + for (_iter63 = this->iterators.begin(); _iter63 != this->iterators.end(); ++_iter63) { - xfer += (*_iter57).write(oprot); + xfer += (*_iter63).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1507,6 +1618,371 @@ void swap(Column &a, Column &b) { swap(a.__isset, b.__isset); } +const char* Condition::ascii_fingerprint = "C4022914C22D89E33B1A46A7D511C58F"; +const uint8_t Condition::binary_fingerprint[16] = {0xC4,0x02,0x29,0x14,0xC2,0x2D,0x89,0xE3,0x3B,0x1A,0x46,0xA7,0xD5,0x11,0xC5,0x8F}; + +uint32_t Condition::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->column.read(iprot); + this->__isset.column = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->timestamp); + this->__isset.timestamp = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->value); + this->__isset.value = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->iterators.clear(); + uint32_t _size64; + ::apache::thrift::protocol::TType _etype67; + xfer += iprot->readListBegin(_etype67, _size64); + this->iterators.resize(_size64); + uint32_t _i68; + for (_i68 = 0; _i68 < _size64; ++_i68) + { + xfer += this->iterators[_i68].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.iterators = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Condition::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("Condition"); + + xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->column.write(oprot); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.timestamp) { + xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->timestamp); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.value) { + xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeBinary(this->value); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.iterators) { + xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size())); + std::vector<IteratorSetting> ::const_iterator _iter69; + for (_iter69 = this->iterators.begin(); _iter69 != this->iterators.end(); ++_iter69) + { + xfer += (*_iter69).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Condition &a, Condition &b) { + using ::std::swap; + swap(a.column, b.column); + swap(a.timestamp, b.timestamp); + swap(a.value, b.value); + swap(a.iterators, b.iterators); + swap(a.__isset, b.__isset); +} + +const char* ConditionalUpdates::ascii_fingerprint = "1C1808872D1A8E04F114974ADD77F356"; +const uint8_t ConditionalUpdates::binary_fingerprint[16] = {0x1C,0x18,0x08,0x87,0x2D,0x1A,0x8E,0x04,0xF1,0x14,0x97,0x4A,0xDD,0x77,0xF3,0x56}; + +uint32_t ConditionalUpdates::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 2: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->conditions.clear(); + uint32_t _size70; + ::apache::thrift::protocol::TType _etype73; + xfer += iprot->readListBegin(_etype73, _size70); + this->conditions.resize(_size70); + uint32_t _i74; + for (_i74 = 0; _i74 < _size70; ++_i74) + { + xfer += this->conditions[_i74].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.conditions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->updates.clear(); + uint32_t _size75; + ::apache::thrift::protocol::TType _etype78; + xfer += iprot->readListBegin(_etype78, _size75); + this->updates.resize(_size75); + uint32_t _i79; + for (_i79 = 0; _i79 < _size75; ++_i79) + { + xfer += this->updates[_i79].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.updates = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ConditionalUpdates::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ConditionalUpdates"); + + xfer += oprot->writeFieldBegin("conditions", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->conditions.size())); + std::vector<Condition> ::const_iterator _iter80; + for (_iter80 = this->conditions.begin(); _iter80 != this->conditions.end(); ++_iter80) + { + xfer += (*_iter80).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("updates", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->updates.size())); + std::vector<ColumnUpdate> ::const_iterator _iter81; + for (_iter81 = this->updates.begin(); _iter81 != this->updates.end(); ++_iter81) + { + xfer += (*_iter81).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ConditionalUpdates &a, ConditionalUpdates &b) { + using ::std::swap; + swap(a.conditions, b.conditions); + swap(a.updates, b.updates); + swap(a.__isset, b.__isset); +} + +const char* ConditionalWriterOptions::ascii_fingerprint = "2A7184C7CE319A61E12C337D8EAB3FB9"; +const uint8_t ConditionalWriterOptions::binary_fingerprint[16] = {0x2A,0x71,0x84,0xC7,0xCE,0x31,0x9A,0x61,0xE1,0x2C,0x33,0x7D,0x8E,0xAB,0x3F,0xB9}; + +uint32_t ConditionalWriterOptions::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->maxMemory); + this->__isset.maxMemory = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->timeoutMs); + this->__isset.timeoutMs = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->threads); + this->__isset.threads = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_SET) { + { + this->authorizations.clear(); + uint32_t _size82; + ::apache::thrift::protocol::TType _etype85; + xfer += iprot->readSetBegin(_etype85, _size82); + uint32_t _i86; + for (_i86 = 0; _i86 < _size82; ++_i86) + { + std::string _elem87; + xfer += iprot->readBinary(_elem87); + this->authorizations.insert(_elem87); + } + xfer += iprot->readSetEnd(); + } + this->__isset.authorizations = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ConditionalWriterOptions::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ConditionalWriterOptions"); + + if (this->__isset.maxMemory) { + xfer += oprot->writeFieldBegin("maxMemory", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->maxMemory); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.timeoutMs) { + xfer += oprot->writeFieldBegin("timeoutMs", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->timeoutMs); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.threads) { + xfer += oprot->writeFieldBegin("threads", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(this->threads); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.authorizations) { + xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_SET, 4); + { + xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size())); + std::set<std::string> ::const_iterator _iter88; + for (_iter88 = this->authorizations.begin(); _iter88 != this->authorizations.end(); ++_iter88) + { + xfer += oprot->writeBinary((*_iter88)); + } + xfer += oprot->writeSetEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ConditionalWriterOptions &a, ConditionalWriterOptions &b) { + using ::std::swap; + swap(a.maxMemory, b.maxMemory); + swap(a.timeoutMs, b.timeoutMs); + swap(a.threads, b.threads); + swap(a.authorizations, b.authorizations); + swap(a.__isset, b.__isset); +} + const char* ActiveScan::ascii_fingerprint = "1B97541CB4E900A054266BBBEE61D004"; const uint8_t ActiveScan::binary_fingerprint[16] = {0x1B,0x97,0x54,0x1C,0xB4,0xE9,0x00,0xA0,0x54,0x26,0x6B,0xBB,0xEE,0x61,0xD0,0x04}; @@ -1572,9 +2048,9 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast58; - xfer += iprot->readI32(ecast58); - this->type = (ScanType::type)ecast58; + int32_t ecast89; + xfer += iprot->readI32(ecast89); + this->type = (ScanType::type)ecast89; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -1582,9 +2058,9 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast59; - xfer += iprot->readI32(ecast59); - this->state = (ScanState::type)ecast59; + int32_t ecast90; + xfer += iprot->readI32(ecast90); + this->state = (ScanState::type)ecast90; this->__isset.state = true; } else { xfer += iprot->skip(ftype); @@ -1602,14 +2078,14 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->columns.clear(); - uint32_t _size60; - ::apache::thrift::protocol::TType _etype63; - xfer += iprot->readListBegin(_etype63, _size60); - this->columns.resize(_size60); - uint32_t _i64; - for (_i64 = 0; _i64 < _size60; ++_i64) + uint32_t _size91; + ::apache::thrift::protocol::TType _etype94; + xfer += iprot->readListBegin(_etype94, _size91); + this->columns.resize(_size91); + uint32_t _i95; + for (_i95 = 0; _i95 < _size91; ++_i95) { - xfer += this->columns[_i64].read(iprot); + xfer += this->columns[_i95].read(iprot); } xfer += iprot->readListEnd(); } @@ -1622,14 +2098,14 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->iterators.clear(); - uint32_t _size65; - ::apache::thrift::protocol::TType _etype68; - xfer += iprot->readListBegin(_etype68, _size65); - this->iterators.resize(_size65); - uint32_t _i69; - for (_i69 = 0; _i69 < _size65; ++_i69) + uint32_t _size96; + ::apache::thrift::protocol::TType _etype99; + xfer += iprot->readListBegin(_etype99, _size96); + this->iterators.resize(_size96); + uint32_t _i100; + for (_i100 = 0; _i100 < _size96; ++_i100) { - xfer += this->iterators[_i69].read(iprot); + xfer += this->iterators[_i100].read(iprot); } xfer += iprot->readListEnd(); } @@ -1642,14 +2118,14 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->authorizations.clear(); - uint32_t _size70; - ::apache::thrift::protocol::TType _etype73; - xfer += iprot->readListBegin(_etype73, _size70); - this->authorizations.resize(_size70); - uint32_t _i74; - for (_i74 = 0; _i74 < _size70; ++_i74) + uint32_t _size101; + ::apache::thrift::protocol::TType _etype104; + xfer += iprot->readListBegin(_etype104, _size101); + this->authorizations.resize(_size101); + uint32_t _i105; + for (_i105 = 0; _i105 < _size101; ++_i105) { - xfer += iprot->readBinary(this->authorizations[_i74]); + xfer += iprot->readBinary(this->authorizations[_i105]); } xfer += iprot->readListEnd(); } @@ -1709,10 +2185,10 @@ uint32_t ActiveScan::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 9); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size())); - std::vector<Column> ::const_iterator _iter75; - for (_iter75 = this->columns.begin(); _iter75 != this->columns.end(); ++_iter75) + std::vector<Column> ::const_iterator _iter106; + for (_iter106 = this->columns.begin(); _iter106 != this->columns.end(); ++_iter106) { - xfer += (*_iter75).write(oprot); + xfer += (*_iter106).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1721,10 +2197,10 @@ uint32_t ActiveScan::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 10); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size())); - std::vector<IteratorSetting> ::const_iterator _iter76; - for (_iter76 = this->iterators.begin(); _iter76 != this->iterators.end(); ++_iter76) + std::vector<IteratorSetting> ::const_iterator _iter107; + for (_iter107 = this->iterators.begin(); _iter107 != this->iterators.end(); ++_iter107) { - xfer += (*_iter76).write(oprot); + xfer += (*_iter107).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1733,10 +2209,10 @@ uint32_t ActiveScan::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_LIST, 11); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size())); - std::vector<std::string> ::const_iterator _iter77; - for (_iter77 = this->authorizations.begin(); _iter77 != this->authorizations.end(); ++_iter77) + std::vector<std::string> ::const_iterator _iter108; + for (_iter108 = this->authorizations.begin(); _iter108 != this->authorizations.end(); ++_iter108) { - xfer += oprot->writeBinary((*_iter77)); + xfer += oprot->writeBinary((*_iter108)); } xfer += oprot->writeListEnd(); } @@ -1806,14 +2282,14 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->inputFiles.clear(); - uint32_t _size78; - ::apache::thrift::protocol::TType _etype81; - xfer += iprot->readListBegin(_etype81, _size78); - this->inputFiles.resize(_size78); - uint32_t _i82; - for (_i82 = 0; _i82 < _size78; ++_i82) + uint32_t _size109; + ::apache::thrift::protocol::TType _etype112; + xfer += iprot->readListBegin(_etype112, _size109); + this->inputFiles.resize(_size109); + uint32_t _i113; + for (_i113 = 0; _i113 < _size109; ++_i113) { - xfer += iprot->readString(this->inputFiles[_i82]); + xfer += iprot->readString(this->inputFiles[_i113]); } xfer += iprot->readListEnd(); } @@ -1832,9 +2308,9 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast83; - xfer += iprot->readI32(ecast83); - this->type = (CompactionType::type)ecast83; + int32_t ecast114; + xfer += iprot->readI32(ecast114); + this->type = (CompactionType::type)ecast114; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -1842,9 +2318,9 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast84; - xfer += iprot->readI32(ecast84); - this->reason = (CompactionReason::type)ecast84; + int32_t ecast115; + xfer += iprot->readI32(ecast115); + this->reason = (CompactionReason::type)ecast115; this->__isset.reason = true; } else { xfer += iprot->skip(ftype); @@ -1878,14 +2354,14 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->iterators.clear(); - uint32_t _size85; - ::apache::thrift::protocol::TType _etype88; - xfer += iprot->readListBegin(_etype88, _size85); - this->iterators.resize(_size85); - uint32_t _i89; - for (_i89 = 0; _i89 < _size85; ++_i89) + uint32_t _size116; + ::apache::thrift::protocol::TType _etype119; + xfer += iprot->readListBegin(_etype119, _size116); + this->iterators.resize(_size116); + uint32_t _i120; + for (_i120 = 0; _i120 < _size116; ++_i120) { - xfer += this->iterators[_i89].read(iprot); + xfer += this->iterators[_i120].read(iprot); } xfer += iprot->readListEnd(); } @@ -1921,10 +2397,10 @@ uint32_t ActiveCompaction::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("inputFiles", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->inputFiles.size())); - std::vector<std::string> ::const_iterator _iter90; - for (_iter90 = this->inputFiles.begin(); _iter90 != this->inputFiles.end(); ++_iter90) + std::vector<std::string> ::const_iterator _iter121; + for (_iter121 = this->inputFiles.begin(); _iter121 != this->inputFiles.end(); ++_iter121) { - xfer += oprot->writeString((*_iter90)); + xfer += oprot->writeString((*_iter121)); } xfer += oprot->writeListEnd(); } @@ -1957,10 +2433,10 @@ uint32_t ActiveCompaction::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 10); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size())); - std::vector<IteratorSetting> ::const_iterator _iter91; - for (_iter91 = this->iterators.begin(); _iter91 != this->iterators.end(); ++_iter91) + std::vector<IteratorSetting> ::const_iterator _iter122; + for (_iter122 = this->iterators.begin(); _iter122 != this->iterators.end(); ++_iter122) { - xfer += (*_iter91).write(oprot); + xfer += (*_iter122).write(oprot); } xfer += oprot->writeListEnd(); }
http://git-wip-us.apache.org/repos/asf/accumulo/blob/3298263a/proxy/src/main/cpp/proxy_types.h ---------------------------------------------------------------------- diff --git a/proxy/src/main/cpp/proxy_types.h b/proxy/src/main/cpp/proxy_types.h index 5b0c554..aec9f2b 100644 --- a/proxy/src/main/cpp/proxy_types.h +++ b/proxy/src/main/cpp/proxy_types.h @@ -92,6 +92,18 @@ struct ScanState { extern const std::map<int, const char*> _ScanState_VALUES_TO_NAMES; +struct ConditionalStatus { + enum type { + ACCEPTED = 0, + REJECTED = 1, + VIOLATED = 2, + UNKNOWN = 3, + INVISIBLE_VISIBILITY = 4 + }; +}; + +extern const std::map<int, const char*> _ConditionalStatus_VALUES_TO_NAMES; + struct CompactionType { enum type { MINOR = 0, @@ -307,6 +319,57 @@ class ColumnUpdate { void swap(ColumnUpdate &a, ColumnUpdate &b); +typedef struct _DiskUsage__isset { + _DiskUsage__isset() : tables(false), usage(false) {} + bool tables; + bool usage; +} _DiskUsage__isset; + +class DiskUsage { + public: + + static const char* ascii_fingerprint; // = "D26F4F5E2867D41CF7E0391263932D6B"; + static const uint8_t binary_fingerprint[16]; // = {0xD2,0x6F,0x4F,0x5E,0x28,0x67,0xD4,0x1C,0xF7,0xE0,0x39,0x12,0x63,0x93,0x2D,0x6B}; + + DiskUsage() : usage(0) { + } + + virtual ~DiskUsage() throw() {} + + std::vector<std::string> tables; + int64_t usage; + + _DiskUsage__isset __isset; + + void __set_tables(const std::vector<std::string> & val) { + tables = val; + } + + void __set_usage(const int64_t val) { + usage = val; + } + + bool operator == (const DiskUsage & rhs) const + { + if (!(tables == rhs.tables)) + return false; + if (!(usage == rhs.usage)) + return false; + return true; + } + bool operator != (const DiskUsage &rhs) const { + return !(*this == rhs); + } + + bool operator < (const DiskUsage & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(DiskUsage &a, DiskUsage &b); + typedef struct _KeyValue__isset { _KeyValue__isset() : key(false), value(false) {} bool key; @@ -946,6 +1009,212 @@ class Column { void swap(Column &a, Column &b); +typedef struct _Condition__isset { + _Condition__isset() : column(false), timestamp(false), value(false), iterators(false) {} + bool column; + bool timestamp; + bool value; + bool iterators; +} _Condition__isset; + +class Condition { + public: + + static const char* ascii_fingerprint; // = "C4022914C22D89E33B1A46A7D511C58F"; + static const uint8_t binary_fingerprint[16]; // = {0xC4,0x02,0x29,0x14,0xC2,0x2D,0x89,0xE3,0x3B,0x1A,0x46,0xA7,0xD5,0x11,0xC5,0x8F}; + + Condition() : timestamp(0), value() { + } + + virtual ~Condition() throw() {} + + Column column; + int64_t timestamp; + std::string value; + std::vector<IteratorSetting> iterators; + + _Condition__isset __isset; + + void __set_column(const Column& val) { + column = val; + } + + void __set_timestamp(const int64_t val) { + timestamp = val; + __isset.timestamp = true; + } + + void __set_value(const std::string& val) { + value = val; + __isset.value = true; + } + + void __set_iterators(const std::vector<IteratorSetting> & val) { + iterators = val; + __isset.iterators = true; + } + + bool operator == (const Condition & rhs) const + { + if (!(column == rhs.column)) + return false; + if (__isset.timestamp != rhs.__isset.timestamp) + return false; + else if (__isset.timestamp && !(timestamp == rhs.timestamp)) + return false; + if (__isset.value != rhs.__isset.value) + return false; + else if (__isset.value && !(value == rhs.value)) + return false; + if (__isset.iterators != rhs.__isset.iterators) + return false; + else if (__isset.iterators && !(iterators == rhs.iterators)) + return false; + return true; + } + bool operator != (const Condition &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Condition & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(Condition &a, Condition &b); + +typedef struct _ConditionalUpdates__isset { + _ConditionalUpdates__isset() : conditions(false), updates(false) {} + bool conditions; + bool updates; +} _ConditionalUpdates__isset; + +class ConditionalUpdates { + public: + + static const char* ascii_fingerprint; // = "1C1808872D1A8E04F114974ADD77F356"; + static const uint8_t binary_fingerprint[16]; // = {0x1C,0x18,0x08,0x87,0x2D,0x1A,0x8E,0x04,0xF1,0x14,0x97,0x4A,0xDD,0x77,0xF3,0x56}; + + ConditionalUpdates() { + } + + virtual ~ConditionalUpdates() throw() {} + + std::vector<Condition> conditions; + std::vector<ColumnUpdate> updates; + + _ConditionalUpdates__isset __isset; + + void __set_conditions(const std::vector<Condition> & val) { + conditions = val; + } + + void __set_updates(const std::vector<ColumnUpdate> & val) { + updates = val; + } + + bool operator == (const ConditionalUpdates & rhs) const + { + if (!(conditions == rhs.conditions)) + return false; + if (!(updates == rhs.updates)) + return false; + return true; + } + bool operator != (const ConditionalUpdates &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ConditionalUpdates & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(ConditionalUpdates &a, ConditionalUpdates &b); + +typedef struct _ConditionalWriterOptions__isset { + _ConditionalWriterOptions__isset() : maxMemory(false), timeoutMs(false), threads(false), authorizations(false) {} + bool maxMemory; + bool timeoutMs; + bool threads; + bool authorizations; +} _ConditionalWriterOptions__isset; + +class ConditionalWriterOptions { + public: + + static const char* ascii_fingerprint; // = "2A7184C7CE319A61E12C337D8EAB3FB9"; + static const uint8_t binary_fingerprint[16]; // = {0x2A,0x71,0x84,0xC7,0xCE,0x31,0x9A,0x61,0xE1,0x2C,0x33,0x7D,0x8E,0xAB,0x3F,0xB9}; + + ConditionalWriterOptions() : maxMemory(0), timeoutMs(0), threads(0) { + } + + virtual ~ConditionalWriterOptions() throw() {} + + int64_t maxMemory; + int64_t timeoutMs; + int32_t threads; + std::set<std::string> authorizations; + + _ConditionalWriterOptions__isset __isset; + + void __set_maxMemory(const int64_t val) { + maxMemory = val; + __isset.maxMemory = true; + } + + void __set_timeoutMs(const int64_t val) { + timeoutMs = val; + __isset.timeoutMs = true; + } + + void __set_threads(const int32_t val) { + threads = val; + __isset.threads = true; + } + + void __set_authorizations(const std::set<std::string> & val) { + authorizations = val; + __isset.authorizations = true; + } + + bool operator == (const ConditionalWriterOptions & rhs) const + { + if (__isset.maxMemory != rhs.__isset.maxMemory) + return false; + else if (__isset.maxMemory && !(maxMemory == rhs.maxMemory)) + return false; + if (__isset.timeoutMs != rhs.__isset.timeoutMs) + return false; + else if (__isset.timeoutMs && !(timeoutMs == rhs.timeoutMs)) + return false; + if (__isset.threads != rhs.__isset.threads) + return false; + else if (__isset.threads && !(threads == rhs.threads)) + return false; + if (__isset.authorizations != rhs.__isset.authorizations) + return false; + else if (__isset.authorizations && !(authorizations == rhs.authorizations)) + return false; + return true; + } + bool operator != (const ConditionalWriterOptions &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ConditionalWriterOptions & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(ConditionalWriterOptions &a, ConditionalWriterOptions &b); + typedef struct _ActiveScan__isset { _ActiveScan__isset() : client(false), user(false), table(false), age(false), idleTime(false), type(false), state(false), extent(false), columns(false), iterators(false), authorizations(false) {} bool client; http://git-wip-us.apache.org/repos/asf/accumulo/blob/3298263a/proxy/src/main/python/AccumuloProxy-remote ---------------------------------------------------------------------- diff --git a/proxy/src/main/python/AccumuloProxy-remote b/proxy/src/main/python/AccumuloProxy-remote index ac4d1e8..b7056c8 100644 --- a/proxy/src/main/python/AccumuloProxy-remote +++ b/proxy/src/main/python/AccumuloProxy-remote @@ -51,6 +51,7 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help': print ' void deleteRows(string login, string tableName, string startRow, string endRow)' print ' void exportTable(string login, string tableName, string exportDir)' print ' void flushTable(string login, string tableName, string startRow, string endRow, bool wait)' + print ' getDiskUsage(string login, tables)' print ' getLocalityGroups(string login, string tableName)' print ' IteratorSetting getIteratorSetting(string login, string tableName, string iteratorName, IteratorScope scope)' print ' string getMaxRow(string login, string tableName, auths, string startRow, bool startInclusive, string endRow, bool endInclusive)' @@ -62,8 +63,8 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help': print ' listIterators(string login, string tableName)' print ' listConstraints(string login, string tableName)' print ' void mergeTablets(string login, string tableName, string startRow, string endRow)' - print ' void offlineTable(string login, string tableName)' - print ' void onlineTable(string login, string tableName)' + print ' void offlineTable(string login, string tableName, bool wait)' + print ' void onlineTable(string login, string tableName, bool wait)' print ' void removeConstraint(string login, string tableName, i32 constraint)' print ' void removeIterator(string login, string tableName, string iterName, scopes)' print ' void removeTableProperty(string login, string tableName, string property)' @@ -107,6 +108,10 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help': print ' void update(string writer, cells)' print ' void flush(string writer)' print ' void closeWriter(string writer)' + print ' ConditionalStatus updateRowConditionally(string login, string tableName, string row, ConditionalUpdates updates)' + print ' string createConditionalWriter(string login, string tableName, ConditionalWriterOptions options)' + print ' updateRowsConditionally(string conditionalWriter, updates)' + print ' void closeConditionalWriter(string conditionalWriter)' print ' Range getRowRange(string row)' print ' Key getFollowing(Key key, PartialKey part)' print '' @@ -244,6 +249,12 @@ elif cmd == 'flushTable': sys.exit(1) pp.pprint(client.flushTable(args[0],args[1],args[2],args[3],eval(args[4]),)) +elif cmd == 'getDiskUsage': + if len(args) != 2: + print 'getDiskUsage requires 2 args' + sys.exit(1) + pp.pprint(client.getDiskUsage(args[0],eval(args[1]),)) + elif cmd == 'getLocalityGroups': if len(args) != 2: print 'getLocalityGroups requires 2 args' @@ -311,16 +322,16 @@ elif cmd == 'mergeTablets': pp.pprint(client.mergeTablets(args[0],args[1],args[2],args[3],)) elif cmd == 'offlineTable': - if len(args) != 2: - print 'offlineTable requires 2 args' + if len(args) != 3: + print 'offlineTable requires 3 args' sys.exit(1) - pp.pprint(client.offlineTable(args[0],args[1],)) + pp.pprint(client.offlineTable(args[0],args[1],eval(args[2]),)) elif cmd == 'onlineTable': - if len(args) != 2: - print 'onlineTable requires 2 args' + if len(args) != 3: + print 'onlineTable requires 3 args' sys.exit(1) - pp.pprint(client.onlineTable(args[0],args[1],)) + pp.pprint(client.onlineTable(args[0],args[1],eval(args[2]),)) elif cmd == 'removeConstraint': if len(args) != 3: @@ -580,6 +591,30 @@ elif cmd == 'closeWriter': sys.exit(1) pp.pprint(client.closeWriter(args[0],)) +elif cmd == 'updateRowConditionally': + if len(args) != 4: + print 'updateRowConditionally requires 4 args' + sys.exit(1) + pp.pprint(client.updateRowConditionally(args[0],args[1],args[2],eval(args[3]),)) + +elif cmd == 'createConditionalWriter': + if len(args) != 3: + print 'createConditionalWriter requires 3 args' + sys.exit(1) + pp.pprint(client.createConditionalWriter(args[0],args[1],eval(args[2]),)) + +elif cmd == 'updateRowsConditionally': + if len(args) != 2: + print 'updateRowsConditionally requires 2 args' + sys.exit(1) + pp.pprint(client.updateRowsConditionally(args[0],eval(args[1]),)) + +elif cmd == 'closeConditionalWriter': + if len(args) != 1: + print 'closeConditionalWriter requires 1 args' + sys.exit(1) + pp.pprint(client.closeConditionalWriter(args[0],)) + elif cmd == 'getRowRange': if len(args) != 1: print 'getRowRange requires 1 args'
