diff --git a/bazel/external/clickhouse_cpp.BUILD b/bazel/external/clickhouse_cpp.BUILD new file mode 100644 index 00000000000..625dfb16ee1 --- /dev/null +++ b/bazel/external/clickhouse_cpp.BUILD @@ -0,0 +1,64 @@ +# Copyright 2018- The Pixie Authors. +# +# Licensed 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. +# +# SPDX-License-Identifier: Apache-2.0 + +load("@rules_foreign_cc//foreign_cc:defs.bzl", "cmake") + +licenses(["notice"]) + +exports_files(["LICENSE"]) + +filegroup( + name = "all", + srcs = glob(["**"]), +) + +cmake( + name = "clickhouse_cpp", + build_args = [ + "--", # <- Pass remaining options to the native tool. + "-j`nproc`", + "-l`nproc`", + ], + cache_entries = { + "BUILD_BENCHMARK": "OFF", + "BUILD_TESTS": "OFF", + "BUILD_SHARED_LIBS": "OFF", + "CMAKE_BUILD_TYPE": "Release", + "WITH_OPENSSL": "OFF", # Disable OpenSSL for now + "WITH_SYSTEM_ABSEIL": "OFF", # Use bundled abseil + "WITH_SYSTEM_LZ4": "OFF", # Use bundled for now + "WITH_SYSTEM_CITYHASH": "OFF", # Use bundled for now + "WITH_SYSTEM_ZSTD": "OFF", # Use bundled for now + "CMAKE_POSITION_INDEPENDENT_CODE": "ON", + }, + lib_source = ":all", + out_static_libs = [ + "libclickhouse-cpp-lib.a", + "liblz4.a", + "libcityhash.a", + "libzstdstatic.a", + "libabsl_int128.a", + ], + targets = [ + "clickhouse-cpp-lib", + "lz4", + "cityhash", + "zstdstatic", + "absl_int128", + ], + visibility = ["//visibility:public"], + working_directory = "", +) \ No newline at end of file diff --git a/bazel/repositories.bzl b/bazel/repositories.bzl index 3733b97aeb5..feb8804c711 100644 --- a/bazel/repositories.bzl +++ b/bazel/repositories.bzl @@ -153,6 +153,7 @@ def _cc_deps(): _bazel_repo("com_github_ariafallah_csv_parser", build_file = "//bazel/external:csv_parser.BUILD") _bazel_repo("com_github_arun11299_cpp_jwt", build_file = "//bazel/external:cpp_jwt.BUILD") _bazel_repo("com_github_cameron314_concurrentqueue", build_file = "//bazel/external:concurrentqueue.BUILD") + _bazel_repo("com_github_clickhouse_clickhouse_cpp", build_file = "//bazel/external:clickhouse_cpp.BUILD") _bazel_repo("com_github_cyan4973_xxhash", build_file = "//bazel/external:xxhash.BUILD") _bazel_repo("com_github_nlohmann_json", build_file = "//bazel/external:nlohmann_json.BUILD") _bazel_repo("com_github_packetzero_dnsparser", build_file = "//bazel/external:dnsparser.BUILD") diff --git a/bazel/repository_locations.bzl b/bazel/repository_locations.bzl index 6c5236fff83..4584d725f9b 100644 --- a/bazel/repository_locations.bzl +++ b/bazel/repository_locations.bzl @@ -76,6 +76,11 @@ REPOSITORY_LOCATIONS = dict( strip_prefix = "concurrentqueue-1.0.3", urls = ["https://github.com/cameron314/concurrentqueue/archive/refs/tags/v1.0.3.tar.gz"], ), + com_github_clickhouse_clickhouse_cpp = dict( + sha256 = "1029a1bb0da8a72db1662a0418267742e66c82bb3e6b0ed116623a2fa8c65a58", + strip_prefix = "clickhouse-cpp-22dc9441cd807156511c6dcf97b1b878bd663d77", + urls = ["https://github.com/ClickHouse/clickhouse-cpp/archive/22dc9441cd807156511c6dcf97b1b878bd663d77.tar.gz"], + ), com_github_cyan4973_xxhash = dict( sha256 = "952ebbf5b11fbf59ae5d760a562d1e9112278f244340ad7714e8556cbe54f7f7", strip_prefix = "xxHash-0.7.3", diff --git a/src/carnot/plan/operators.cc b/src/carnot/plan/operators.cc index 357cc318423..68aece51d4e 100644 --- a/src/carnot/plan/operators.cc +++ b/src/carnot/plan/operators.cc @@ -83,6 +83,10 @@ std::unique_ptr Operator::FromProto(const planpb::Operator& pb, int64_ return CreateOperator(id, pb.udtf_source_op()); case planpb::EMPTY_SOURCE_OPERATOR: return CreateOperator(id, pb.empty_source_op()); + case planpb::CLICKHOUSE_SOURCE_OPERATOR: + return CreateOperator(id, pb.clickhouse_source_op()); + case planpb::CLICKHOUSE_EXPORT_SINK_OPERATOR: + return CreateOperator(id, pb.clickhouse_sink_op()); case planpb::OTEL_EXPORT_SINK_OPERATOR: return CreateOperator(id, pb.otel_sink_op()); default: @@ -709,6 +713,67 @@ StatusOr EmptySourceOperator::OutputRelation( return r; } +/** + * ClickHouseSourceOperator implementation. + */ + +std::string ClickHouseSourceOperator::DebugString() const { + return absl::Substitute(R"(Op:ClickHouseSource( + host=$0 + port=$1 + username=$2 + batch_size=$3 + start_time=$4 + end_time=$5 + timestamp_column=$6 + partition_column=$7 +)", + pb_.host(), pb_.port(), pb_.username(), pb_.batch_size(), + pb_.start_time(), pb_.end_time(), pb_.timestamp_column(), + pb_.partition_column()); +} + +Status ClickHouseSourceOperator::Init(const planpb::ClickHouseSourceOperator& pb) { + pb_ = pb; + is_initialized_ = true; + return Status::OK(); +} + +StatusOr ClickHouseSourceOperator::OutputRelation( + const table_store::schema::Schema&, const PlanState&, + const std::vector& input_ids) const { + DCHECK(is_initialized_) << "Not initialized"; + if (!input_ids.empty()) { + return error::InvalidArgument("Source operator cannot have any inputs"); + } + table_store::schema::Relation r; + for (int i = 0; i < pb_.column_types_size(); ++i) { + r.AddColumn(static_cast(pb_.column_types(i)), pb_.column_names(i)); + } + return r; +} + +/** + * ClickHouse Export Sink Operator Implementation. + */ + +Status ClickHouseExportSinkOperator::Init(const planpb::ClickHouseExportSinkOperator& pb) { + pb_ = pb; + is_initialized_ = true; + return Status::OK(); +} + +StatusOr ClickHouseExportSinkOperator::OutputRelation( + const table_store::schema::Schema&, const PlanState&, const std::vector&) const { + DCHECK(is_initialized_) << "Not initialized"; + // There are no outputs. + return table_store::schema::Relation(); +} + +std::string ClickHouseExportSinkOperator::DebugString() const { + return absl::Substitute("Op:ClickHouseExportSink(table=$0)", pb_.table_name()); +} + /** * OTel Export Sink Operator Implementation. */ diff --git a/src/carnot/plan/operators.h b/src/carnot/plan/operators.h index 8586f6eb976..d77b5d6b18c 100644 --- a/src/carnot/plan/operators.h +++ b/src/carnot/plan/operators.h @@ -359,6 +359,69 @@ class EmptySourceOperator : public Operator { std::vector column_idxs_; }; +class ClickHouseSourceOperator : public Operator { + public: + explicit ClickHouseSourceOperator(int64_t id) + : Operator(id, planpb::CLICKHOUSE_SOURCE_OPERATOR) {} + ~ClickHouseSourceOperator() override = default; + + StatusOr OutputRelation( + const table_store::schema::Schema& schema, const PlanState& state, + const std::vector& input_ids) const override; + Status Init(const planpb::ClickHouseSourceOperator& pb); + std::string DebugString() const override; + + std::string host() const { return pb_.host(); } + int32_t port() const { return pb_.port(); } + std::string username() const { return pb_.username(); } + std::string password() const { return pb_.password(); } + std::string database() const { return pb_.database(); } + std::string query() const { return pb_.query(); } + int32_t batch_size() const { return pb_.batch_size(); } + bool streaming() const { return pb_.streaming(); } + std::vector column_names() const { + return std::vector(pb_.column_names().begin(), pb_.column_names().end()); + } + std::vector column_types() const { + std::vector types; + types.reserve(pb_.column_types_size()); + for (const auto& type : pb_.column_types()) { + types.push_back(static_cast(type)); + } + return types; + } + std::string timestamp_column() const { return pb_.timestamp_column(); } + std::string partition_column() const { return pb_.partition_column(); } + int64_t start_time() const { return pb_.start_time(); } + int64_t end_time() const { return pb_.end_time(); } + + private: + planpb::ClickHouseSourceOperator pb_; +}; + +class ClickHouseExportSinkOperator : public Operator { + public: + explicit ClickHouseExportSinkOperator(int64_t id) + : Operator(id, planpb::CLICKHOUSE_EXPORT_SINK_OPERATOR) {} + ~ClickHouseExportSinkOperator() override = default; + + StatusOr OutputRelation( + const table_store::schema::Schema& schema, const PlanState& state, + const std::vector& input_ids) const override; + Status Init(const planpb::ClickHouseExportSinkOperator& pb); + std::string DebugString() const override; + + const planpb::ClickHouseConfig& clickhouse_config() const { return pb_.clickhouse_config(); } + const std::string& table_name() const { return pb_.table_name(); } + const ::google::protobuf::RepeatedPtrField& + column_mappings() const { + return pb_.column_mappings(); + } + + private: + planpb::ClickHouseExportSinkOperator pb_; +}; + class OTelExportSinkOperator : public Operator { public: explicit OTelExportSinkOperator(int64_t id) : Operator(id, planpb::OTEL_EXPORT_SINK_OPERATOR) {} diff --git a/src/carnot/plan/plan_fragment.cc b/src/carnot/plan/plan_fragment.cc index 05a589f4276..462c4ca1cb2 100644 --- a/src/carnot/plan/plan_fragment.cc +++ b/src/carnot/plan/plan_fragment.cc @@ -98,6 +98,13 @@ Status PlanFragmentWalker::CallWalkFn(const Operator& op) { case planpb::OperatorType::OTEL_EXPORT_SINK_OPERATOR: PX_RETURN_IF_ERROR(CallAs(on_otel_sink_walk_fn_, op)); break; + case planpb::OperatorType::CLICKHOUSE_SOURCE_OPERATOR: + PX_RETURN_IF_ERROR(CallAs(on_clickhouse_source_walk_fn_, op)); + break; + case planpb::OperatorType::CLICKHOUSE_EXPORT_SINK_OPERATOR: + PX_RETURN_IF_ERROR( + CallAs(on_clickhouse_export_sink_walk_fn_, op)); + break; default: LOG(FATAL) << absl::Substitute("Operator does not exist: $0", magic_enum::enum_name(op_type)); return error::InvalidArgument("Operator does not exist: $0", magic_enum::enum_name(op_type)); diff --git a/src/carnot/plan/plan_fragment.h b/src/carnot/plan/plan_fragment.h index 39b1cea9ceb..f80090d9c30 100644 --- a/src/carnot/plan/plan_fragment.h +++ b/src/carnot/plan/plan_fragment.h @@ -76,6 +76,8 @@ class PlanFragmentWalker { using UDTFSourceWalkFn = std::function; using EmptySourceWalkFn = std::function; using OTelSinkWalkFn = std::function; + using ClickHouseSourceWalkFn = std::function; + using ClickHouseExportSinkWalkFn = std::function; /** * Register callback for when a memory source operator is encountered. @@ -181,6 +183,17 @@ class PlanFragmentWalker { on_otel_sink_walk_fn_ = fn; return *this; } + + PlanFragmentWalker& OnClickHouseSource(const ClickHouseSourceWalkFn& fn) { + on_clickhouse_source_walk_fn_ = fn; + return *this; + } + + PlanFragmentWalker& OnClickHouseExportSink(const ClickHouseExportSinkWalkFn& fn) { + on_clickhouse_export_sink_walk_fn_ = fn; + return *this; + } + /** * Perform a walk of the plan fragment operators in a topologically-sorted order. * @param plan_fragment The plan fragment to walk. @@ -206,6 +219,8 @@ class PlanFragmentWalker { UDTFSourceWalkFn on_udtf_source_walk_fn_; EmptySourceWalkFn on_empty_source_walk_fn_; OTelSinkWalkFn on_otel_sink_walk_fn_; + ClickHouseSourceWalkFn on_clickhouse_source_walk_fn_; + ClickHouseExportSinkWalkFn on_clickhouse_export_sink_walk_fn_; }; } // namespace plan diff --git a/src/carnot/planner/distributedpb/distributed_plan.pb.go b/src/carnot/planner/distributedpb/distributed_plan.pb.go index 64787d1782a..c285696167d 100755 --- a/src/carnot/planner/distributedpb/distributed_plan.pb.go +++ b/src/carnot/planner/distributedpb/distributed_plan.pb.go @@ -581,6 +581,89 @@ func (m *OTelEndpointConfig) GetTimeout() int64 { return 0 } +type ClickHouseConfig struct { + Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"` + Host string `protobuf:"bytes,2,opt,name=host,proto3" json:"host,omitempty"` + Port int32 `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"` + Username string `protobuf:"bytes,4,opt,name=username,proto3" json:"username,omitempty"` + Password string `protobuf:"bytes,5,opt,name=password,proto3" json:"password,omitempty"` + Database string `protobuf:"bytes,6,opt,name=database,proto3" json:"database,omitempty"` +} + +func (m *ClickHouseConfig) Reset() { *m = ClickHouseConfig{} } +func (*ClickHouseConfig) ProtoMessage() {} +func (*ClickHouseConfig) Descriptor() ([]byte, []int) { + return fileDescriptor_30dce4250507a2af, []int{8} +} +func (m *ClickHouseConfig) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ClickHouseConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ClickHouseConfig.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ClickHouseConfig) XXX_Merge(src proto.Message) { + xxx_messageInfo_ClickHouseConfig.Merge(m, src) +} +func (m *ClickHouseConfig) XXX_Size() int { + return m.Size() +} +func (m *ClickHouseConfig) XXX_DiscardUnknown() { + xxx_messageInfo_ClickHouseConfig.DiscardUnknown(m) +} + +var xxx_messageInfo_ClickHouseConfig proto.InternalMessageInfo + +func (m *ClickHouseConfig) GetHostname() string { + if m != nil { + return m.Hostname + } + return "" +} + +func (m *ClickHouseConfig) GetHost() string { + if m != nil { + return m.Host + } + return "" +} + +func (m *ClickHouseConfig) GetPort() int32 { + if m != nil { + return m.Port + } + return 0 +} + +func (m *ClickHouseConfig) GetUsername() string { + if m != nil { + return m.Username + } + return "" +} + +func (m *ClickHouseConfig) GetPassword() string { + if m != nil { + return m.Password + } + return "" +} + +func (m *ClickHouseConfig) GetDatabase() string { + if m != nil { + return m.Database + } + return "" +} + type PluginConfig struct { StartTimeNs int64 `protobuf:"varint,1,opt,name=start_time_ns,json=startTimeNs,proto3" json:"start_time_ns,omitempty"` EndTimeNs int64 `protobuf:"varint,2,opt,name=end_time_ns,json=endTimeNs,proto3" json:"end_time_ns,omitempty"` @@ -589,7 +672,7 @@ type PluginConfig struct { func (m *PluginConfig) Reset() { *m = PluginConfig{} } func (*PluginConfig) ProtoMessage() {} func (*PluginConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_30dce4250507a2af, []int{8} + return fileDescriptor_30dce4250507a2af, []int{9} } func (m *PluginConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -639,7 +722,7 @@ type DebugInfo struct { func (m *DebugInfo) Reset() { *m = DebugInfo{} } func (*DebugInfo) ProtoMessage() {} func (*DebugInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_30dce4250507a2af, []int{9} + return fileDescriptor_30dce4250507a2af, []int{10} } func (m *DebugInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -683,7 +766,7 @@ type DebugInfo_OTelDebugAttribute struct { func (m *DebugInfo_OTelDebugAttribute) Reset() { *m = DebugInfo_OTelDebugAttribute{} } func (*DebugInfo_OTelDebugAttribute) ProtoMessage() {} func (*DebugInfo_OTelDebugAttribute) Descriptor() ([]byte, []int) { - return fileDescriptor_30dce4250507a2af, []int{9, 0} + return fileDescriptor_30dce4250507a2af, []int{10, 0} } func (m *DebugInfo_OTelDebugAttribute) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -734,13 +817,14 @@ type LogicalPlannerState struct { RedactionOptions *RedactionOptions `protobuf:"bytes,7,opt,name=redaction_options,json=redactionOptions,proto3" json:"redaction_options,omitempty"` OTelEndpointConfig *OTelEndpointConfig `protobuf:"bytes,8,opt,name=otel_endpoint_config,json=otelEndpointConfig,proto3" json:"otel_endpoint_config,omitempty"` PluginConfig *PluginConfig `protobuf:"bytes,9,opt,name=plugin_config,json=pluginConfig,proto3" json:"plugin_config,omitempty"` + ClickhouseConfig *ClickHouseConfig `protobuf:"bytes,11,opt,name=clickhouse_config,json=clickhouseConfig,proto3" json:"clickhouse_config,omitempty"` DebugInfo *DebugInfo `protobuf:"bytes,10,opt,name=debug_info,json=debugInfo,proto3" json:"debug_info,omitempty"` } func (m *LogicalPlannerState) Reset() { *m = LogicalPlannerState{} } func (*LogicalPlannerState) ProtoMessage() {} func (*LogicalPlannerState) Descriptor() ([]byte, []int) { - return fileDescriptor_30dce4250507a2af, []int{10} + return fileDescriptor_30dce4250507a2af, []int{11} } func (m *LogicalPlannerState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -818,6 +902,13 @@ func (m *LogicalPlannerState) GetPluginConfig() *PluginConfig { return nil } +func (m *LogicalPlannerState) GetClickhouseConfig() *ClickHouseConfig { + if m != nil { + return m.ClickhouseConfig + } + return nil +} + func (m *LogicalPlannerState) GetDebugInfo() *DebugInfo { if m != nil { return m.DebugInfo @@ -833,7 +924,7 @@ type LogicalPlannerResult struct { func (m *LogicalPlannerResult) Reset() { *m = LogicalPlannerResult{} } func (*LogicalPlannerResult) ProtoMessage() {} func (*LogicalPlannerResult) Descriptor() ([]byte, []int) { - return fileDescriptor_30dce4250507a2af, []int{11} + return fileDescriptor_30dce4250507a2af, []int{12} } func (m *LogicalPlannerResult) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -888,6 +979,7 @@ func init() { proto.RegisterType((*RedactionOptions)(nil), "px.carnot.planner.distributedpb.RedactionOptions") proto.RegisterType((*OTelEndpointConfig)(nil), "px.carnot.planner.distributedpb.OTelEndpointConfig") proto.RegisterMapType((map[string]string)(nil), "px.carnot.planner.distributedpb.OTelEndpointConfig.HeadersEntry") + proto.RegisterType((*ClickHouseConfig)(nil), "px.carnot.planner.distributedpb.ClickHouseConfig") proto.RegisterType((*PluginConfig)(nil), "px.carnot.planner.distributedpb.PluginConfig") proto.RegisterType((*DebugInfo)(nil), "px.carnot.planner.distributedpb.DebugInfo") proto.RegisterType((*DebugInfo_OTelDebugAttribute)(nil), "px.carnot.planner.distributedpb.DebugInfo.OTelDebugAttribute") @@ -900,104 +992,111 @@ func init() { } var fileDescriptor_30dce4250507a2af = []byte{ - // 1549 bytes of a gzipped FileDescriptorProto + // 1651 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0x4f, 0x6f, 0x1b, 0xc7, - 0x15, 0xd7, 0x8a, 0x94, 0x48, 0x3e, 0x92, 0x12, 0x3d, 0xa2, 0x5c, 0x96, 0x48, 0x48, 0x97, 0x48, - 0x50, 0xc1, 0x76, 0x97, 0xa9, 0x12, 0x34, 0x69, 0x80, 0xb4, 0x11, 0x45, 0xc9, 0x62, 0xac, 0x26, - 0xea, 0x50, 0x06, 0x02, 0x1f, 0xba, 0x18, 0x72, 0x87, 0xe4, 0x22, 0xcb, 0xdd, 0xd5, 0xce, 0xac, - 0x21, 0xb5, 0x28, 0xd0, 0x1e, 0x7b, 0x6a, 0x3f, 0x46, 0x4f, 0xbd, 0xf5, 0xda, 0x6b, 0x7b, 0xf4, - 0x31, 0x27, 0x21, 0xa6, 0x2f, 0x3d, 0xe6, 0x0b, 0x14, 0x28, 0xe6, 0xcd, 0x2e, 0xb5, 0xa4, 0x09, - 0x48, 0x6e, 0x2f, 0xe4, 0xcc, 0x7b, 0xbf, 0xf7, 0x67, 0xe6, 0xbd, 0xdf, 0xcc, 0x2c, 0x7c, 0x2c, - 0xc2, 0x61, 0x7b, 0xc8, 0x42, 0xcf, 0x97, 0xed, 0xc0, 0x65, 0x9e, 0xc7, 0xc3, 0xb6, 0xed, 0x08, - 0x19, 0x3a, 0x83, 0x48, 0x72, 0x3b, 0x18, 0xa4, 0x67, 0x96, 0x42, 0x98, 0x41, 0xe8, 0x4b, 0x9f, - 0x34, 0x83, 0x4b, 0x53, 0xdb, 0x99, 0xb1, 0x9d, 0xb9, 0x60, 0x57, 0xaf, 0x8e, 0xfd, 0xb1, 0x8f, - 0xd8, 0xb6, 0x1a, 0x69, 0xb3, 0x7a, 0x53, 0xc5, 0x63, 0x81, 0xd3, 0xd6, 0x9a, 0x28, 0x72, 0x54, - 0x0c, 0xf5, 0x17, 0x03, 0xde, 0x59, 0x4a, 0x28, 0x18, 0xb4, 0x6f, 0xa2, 0xd6, 0xdf, 0x47, 0xad, - 0x3f, 0x9d, 0xfa, 0x5e, 0x7b, 0xc0, 0x04, 0x6f, 0x0b, 0xc9, 0x64, 0x24, 0x82, 0x41, 0x3c, 0x88, - 0x61, 0x0f, 0x15, 0x4c, 0x4c, 0x58, 0xc8, 0xed, 0xf6, 0xc0, 0xf5, 0xfd, 0xe9, 0xc8, 0x71, 0x25, - 0x0f, 0x83, 0x41, 0x7a, 0x16, 0x63, 0xdf, 0x4b, 0x61, 0xa7, 0x5c, 0x32, 0x9b, 0x49, 0x16, 0x0c, - 0xe6, 0xc3, 0x74, 0x60, 0xc9, 0x06, 0x2e, 0xb7, 0x84, 0xf4, 0x43, 0xde, 0x16, 0xc3, 0x09, 0x9f, - 0x2a, 0xa0, 0x1e, 0x68, 0x58, 0x6b, 0x66, 0x40, 0xe9, 0x57, 0xb1, 0x65, 0xcf, 0x1b, 0xf9, 0xe4, - 0x29, 0x6c, 0x27, 0x9e, 0xac, 0x91, 0xc3, 0x5d, 0x5b, 0xd4, 0x8c, 0x07, 0x99, 0xbd, 0xad, 0xfd, - 0x96, 0x19, 0x5c, 0x9a, 0x3a, 0xac, 0x79, 0x13, 0xd6, 0x4c, 0x8c, 0xcf, 0xaf, 0x02, 0x4e, 0xb7, - 0x12, 0xc5, 0x31, 0x5a, 0x92, 0xdf, 0xc1, 0xee, 0xe5, 0xe5, 0x84, 0x89, 0xc9, 0xcf, 0x3e, 0xb2, - 0x70, 0x21, 0x96, 0x5e, 0x49, 0x6d, 0xfd, 0x81, 0xb1, 0x57, 0xdc, 0x7f, 0x9c, 0x72, 0xb9, 0xb0, - 0x6a, 0xf3, 0xeb, 0xaf, 0x4f, 0xd0, 0xaa, 0xa3, 0xa4, 0xc7, 0x28, 0xed, 0xfc, 0x60, 0x76, 0xdd, - 0xdc, 0x59, 0xa1, 0x38, 0x59, 0xa3, 0x3b, 0x49, 0x94, 0x34, 0x3e, 0x0f, 0x9b, 0xda, 0x5f, 0xeb, - 0xbb, 0x2c, 0xc0, 0x21, 0x56, 0x08, 0x97, 0xf8, 0x01, 0x54, 0x2f, 0x22, 0x1e, 0x5e, 0x59, 0x83, - 0xd0, 0xff, 0x86, 0x87, 0x16, 0xb3, 0xed, 0x90, 0x0b, 0xb5, 0x4e, 0x63, 0xaf, 0x40, 0x09, 0xea, - 0x3a, 0xa8, 0x3a, 0xd0, 0x1a, 0xf2, 0x31, 0xe4, 0xd9, 0x98, 0x7b, 0xd2, 0x72, 0xec, 0x1a, 0x60, - 0xea, 0xdb, 0x2a, 0x75, 0xdd, 0x0c, 0xe6, 0xb3, 0x67, 0xbd, 0x6e, 0xa7, 0x38, 0xbb, 0x6e, 0xe6, - 0x0e, 0x14, 0xa8, 0xd7, 0xa5, 0x39, 0x44, 0xf7, 0x6c, 0xf2, 0x73, 0xd8, 0x9e, 0x30, 0x61, 0x8d, - 0xc3, 0x60, 0x68, 0x09, 0x1e, 0xbe, 0x88, 0x97, 0x9e, 0xef, 0xdc, 0x9b, 0x5d, 0x37, 0xcb, 0x27, - 0x4c, 0x3c, 0xa1, 0x67, 0x87, 0x7d, 0x54, 0xd0, 0xf2, 0x84, 0x89, 0x27, 0x61, 0x30, 0xd4, 0x53, - 0xb2, 0x0f, 0x25, 0x34, 0x4b, 0xb2, 0xcb, 0xa8, 0xec, 0x3a, 0xdb, 0xb3, 0xeb, 0x66, 0x51, 0x19, - 0xc5, 0xa9, 0xd1, 0xa2, 0x02, 0x25, 0x79, 0xbe, 0x07, 0x5b, 0x2a, 0x1c, 0x16, 0x0f, 0xab, 0x5e, - 0xcb, 0xaa, 0x68, 0xb4, 0x34, 0x61, 0xa2, 0xcb, 0x24, 0xeb, 0x2b, 0x19, 0x79, 0x1f, 0xb6, 0x82, - 0xd0, 0x1f, 0x72, 0x21, 0xb8, 0xc6, 0xd6, 0x36, 0x10, 0x55, 0x9e, 0x4b, 0x15, 0x96, 0x7c, 0x04, - 0xf7, 0xd9, 0x70, 0xc8, 0x03, 0x29, 0xac, 0x90, 0x4f, 0x7d, 0xc9, 0x2d, 0xe1, 0x47, 0xe1, 0x90, - 0x8b, 0xda, 0x26, 0xc2, 0xab, 0xb1, 0x96, 0xa2, 0xb2, 0xaf, 0x75, 0xa4, 0x07, 0xa0, 0xbb, 0xce, - 0xf1, 0x46, 0x7e, 0x2d, 0xf7, 0x20, 0xb3, 0x57, 0xdc, 0x7f, 0x68, 0xde, 0xc2, 0x3d, 0xf3, 0x5c, - 0x99, 0xa8, 0xe2, 0xd0, 0x82, 0x4c, 0x86, 0xe4, 0x1d, 0xc8, 0x32, 0xe1, 0xd8, 0xb5, 0xfc, 0x03, - 0x63, 0xaf, 0xdc, 0xc9, 0xcf, 0xae, 0x9b, 0xd9, 0x83, 0x7e, 0xaf, 0x4b, 0x51, 0x4a, 0x28, 0x94, - 0xe7, 0x8d, 0x8a, 0xb1, 0x0a, 0x58, 0x98, 0x9f, 0xdc, 0x1a, 0x2b, 0xdd, 0xee, 0xb4, 0x34, 0x4d, - 0x37, 0xff, 0x27, 0xb0, 0x25, 0x84, 0x6b, 0x49, 0x16, 0x8e, 0xb9, 0xf4, 0xd8, 0x94, 0xd7, 0x8a, - 0xb8, 0xeb, 0x58, 0xad, 0x7e, 0xff, 0xf4, 0x1c, 0x15, 0x5f, 0xb2, 0x29, 0xa7, 0x65, 0x21, 0xdc, - 0xf3, 0x39, 0xae, 0x35, 0x81, 0xc2, 0x7c, 0x0d, 0xa4, 0x0a, 0x1b, 0xb8, 0x8a, 0xb8, 0xa3, 0xf4, - 0x84, 0x3c, 0x82, 0x7b, 0x38, 0x90, 0xce, 0x6f, 0x99, 0x74, 0x7c, 0xcf, 0xfa, 0x86, 0x5f, 0x61, - 0x37, 0x14, 0x68, 0x65, 0x41, 0xf1, 0x94, 0x5f, 0x91, 0x1a, 0xe4, 0xb4, 0x4c, 0x15, 0x3e, 0xb3, - 0x57, 0xa0, 0xc9, 0xb4, 0xf5, 0x67, 0x03, 0xa0, 0x8f, 0x14, 0xc6, 0x58, 0x04, 0xb2, 0x98, 0xa8, - 0x0e, 0x85, 0x63, 0xf2, 0x19, 0xe4, 0x43, 0xee, 0xa2, 0xaf, 0x98, 0x69, 0x3f, 0x52, 0xbb, 0x92, - 0x3a, 0x0d, 0xcc, 0xe4, 0x34, 0x30, 0x69, 0x0c, 0xa4, 0x73, 0x13, 0x62, 0x02, 0xe8, 0x6e, 0x77, - 0x1d, 0x21, 0x31, 0xfc, 0x9b, 0xfd, 0x4e, 0x0b, 0x08, 0x39, 0x75, 0x84, 0x6c, 0xfd, 0xcd, 0x80, - 0x4a, 0xf7, 0x66, 0x8b, 0xfb, 0x92, 0x49, 0x4e, 0x4e, 0xa1, 0xa8, 0xab, 0xa0, 0x8b, 0x63, 0xa0, - 0x97, 0x47, 0xb7, 0x16, 0xe7, 0x86, 0xa6, 0x14, 0x86, 0x37, 0x94, 0x3d, 0x85, 0xa2, 0xce, 0x58, - 0x7b, 0x5b, 0xbf, 0xa3, 0xb7, 0x9b, 0x7d, 0xa2, 0x20, 0xe6, 0xe3, 0xd6, 0x3f, 0x33, 0xb0, 0x9d, - 0x4a, 0xf8, 0xcc, 0x65, 0x1e, 0x09, 0x81, 0x5c, 0x0c, 0x12, 0xb2, 0x59, 0xd2, 0xc7, 0xab, 0x23, - 0x4e, 0xfb, 0xe8, 0xd6, 0x40, 0x4b, 0xde, 0xcc, 0x5f, 0x0f, 0x62, 0x4a, 0x9e, 0xfb, 0x6a, 0x7e, - 0xe4, 0xc9, 0xf0, 0x8a, 0x6e, 0x5f, 0x2c, 0x4a, 0xc9, 0x0b, 0xa8, 0x2e, 0xc6, 0xb4, 0xd9, 0x58, - 0x1d, 0x31, 0x7a, 0x79, 0xc7, 0xff, 0x4f, 0xd4, 0x2e, 0x1b, 0xf7, 0x6c, 0x1d, 0xb6, 0x72, 0xb1, - 0x24, 0x26, 0x3f, 0x86, 0x8c, 0xcd, 0xc6, 0x78, 0xa2, 0x14, 0xf7, 0x77, 0x97, 0xc2, 0x28, 0xbf, - 0x07, 0x4f, 0xa8, 0x42, 0xd4, 0x9f, 0x43, 0x75, 0xd5, 0x4a, 0x48, 0x05, 0x32, 0xaa, 0x79, 0x75, - 0xcf, 0xa9, 0x21, 0x79, 0x0c, 0x1b, 0x2f, 0x98, 0x1b, 0xf1, 0xb8, 0xdf, 0xee, 0xbf, 0xe9, 0x54, - 0x59, 0x53, 0x0d, 0xfa, 0x74, 0xfd, 0x13, 0xa3, 0x7e, 0x08, 0xbb, 0x2b, 0xf3, 0x5d, 0xe1, 0xbc, - 0x9a, 0x76, 0x9e, 0x4d, 0x39, 0x69, 0xfd, 0xd1, 0x80, 0x0a, 0xe5, 0x36, 0x1b, 0xaa, 0xc6, 0xfd, - 0x2a, 0x50, 0xbf, 0x82, 0x3c, 0x06, 0x12, 0x09, 0x6e, 0x8d, 0x22, 0xd7, 0xb5, 0xc2, 0x44, 0x89, - 0xfe, 0xf2, 0xb4, 0x12, 0x09, 0x7e, 0x1c, 0xb9, 0xee, 0xdc, 0x88, 0xfc, 0x12, 0xde, 0x55, 0xe8, - 0xe0, 0x32, 0xc6, 0x5a, 0x81, 0xe3, 0x58, 0x03, 0x2e, 0xa4, 0xc5, 0x47, 0x23, 0x3f, 0x94, 0xfa, - 0xc0, 0xa6, 0xb5, 0x48, 0xf0, 0xb3, 0x4b, 0x6d, 0x76, 0xe6, 0x38, 0x1d, 0x2e, 0xe4, 0x11, 0xea, - 0x5b, 0xff, 0x31, 0x80, 0x7c, 0x75, 0xce, 0xdd, 0x23, 0xcf, 0x0e, 0x7c, 0xc7, 0x93, 0x87, 0xbe, - 0x37, 0x72, 0xc6, 0xe4, 0x87, 0x90, 0x89, 0x42, 0x57, 0x2f, 0xa3, 0x93, 0x9b, 0x5d, 0x37, 0x33, - 0xcf, 0xe8, 0x29, 0x55, 0x32, 0xf2, 0x1c, 0x72, 0x13, 0xce, 0x6c, 0x1e, 0x8a, 0xb8, 0xd4, 0x9f, - 0xdf, 0x5a, 0xea, 0x37, 0x03, 0x98, 0x27, 0xda, 0x85, 0x2e, 0x72, 0xe2, 0x90, 0xd4, 0x21, 0xef, - 0x78, 0x82, 0x0f, 0xa3, 0x90, 0x63, 0x81, 0xf3, 0x74, 0x3e, 0xc7, 0x43, 0xc5, 0x99, 0x72, 0x3f, - 0x92, 0x78, 0x2f, 0x64, 0x68, 0x32, 0xad, 0x7f, 0x0a, 0xa5, 0xb4, 0xbb, 0xdb, 0x6a, 0x50, 0x48, - 0xd7, 0x80, 0x42, 0xe9, 0xcc, 0x8d, 0xc6, 0x8e, 0x17, 0x2f, 0xbc, 0x05, 0x65, 0x21, 0x59, 0x28, - 0x2d, 0xe5, 0xdc, 0xf2, 0xf4, 0xbd, 0x9a, 0xa1, 0x45, 0x14, 0x9e, 0x3b, 0x53, 0xfe, 0xa5, 0x20, - 0x0d, 0x28, 0x72, 0xcf, 0x9e, 0x23, 0xd6, 0x11, 0x51, 0xe0, 0x9e, 0xad, 0xf5, 0xad, 0x7f, 0x18, - 0x50, 0xe8, 0xf2, 0x41, 0x34, 0x46, 0xf6, 0x5f, 0xc0, 0xae, 0x2f, 0xb9, 0x6b, 0xd9, 0x4a, 0x62, - 0x31, 0x19, 0xef, 0x8b, 0x88, 0xe9, 0xf9, 0xd9, 0xed, 0x44, 0x49, 0x5c, 0xe1, 0x3e, 0xe2, 0xec, - 0x20, 0xf1, 0x42, 0x77, 0x94, 0xef, 0x45, 0x99, 0xa8, 0xff, 0x42, 0xd7, 0x74, 0x51, 0xbc, 0xf2, - 0xb0, 0x5d, 0xb9, 0x31, 0xad, 0xbf, 0x6f, 0xc0, 0xce, 0xa9, 0x3f, 0x76, 0x86, 0xcc, 0x3d, 0xd3, - 0x29, 0xe9, 0x63, 0xf1, 0x37, 0x70, 0x2f, 0xfd, 0x3e, 0x55, 0x8f, 0xc0, 0x84, 0x33, 0x3f, 0x7d, - 0x1b, 0xbe, 0xa3, 0x37, 0x5a, 0xb1, 0x97, 0x8f, 0xdd, 0xcf, 0xa1, 0xa4, 0x6c, 0x2d, 0x5f, 0x73, - 0x21, 0xe6, 0xf8, 0xbb, 0xab, 0xe9, 0x18, 0x13, 0x86, 0x16, 0x83, 0x9b, 0x89, 0x7a, 0x1d, 0x84, - 0x5c, 0x44, 0xae, 0x9c, 0xbf, 0x3c, 0xb2, 0xb8, 0xb0, 0xb2, 0x96, 0x26, 0x4f, 0x8d, 0xa7, 0xb0, - 0x1b, 0xc3, 0x96, 0x6e, 0xcc, 0x0d, 0x6c, 0x78, 0x7c, 0xac, 0x51, 0x04, 0x2c, 0xde, 0x9b, 0x3b, - 0xda, 0xaa, 0x9f, 0xbe, 0x3d, 0xd5, 0xae, 0xcc, 0x89, 0x3a, 0x4f, 0x3d, 0x77, 0xc7, 0x5d, 0x59, - 0xe6, 0x3f, 0xad, 0x84, 0xcb, 0x27, 0xc2, 0xef, 0xa1, 0x8a, 0x0d, 0xc4, 0x63, 0x06, 0x59, 0x43, - 0x6c, 0x55, 0x7c, 0x59, 0x14, 0xf7, 0x3f, 0xfc, 0x1f, 0xd8, 0xd7, 0xb9, 0x3f, 0xbb, 0x6e, 0xae, - 0xa0, 0x3d, 0x25, 0x2a, 0xd0, 0xd2, 0x51, 0x40, 0xa1, 0x1c, 0x20, 0x43, 0x92, 0xb8, 0x77, 0x7d, - 0xaa, 0xa4, 0x79, 0x45, 0x4b, 0x41, 0x9a, 0x65, 0x3d, 0x00, 0x4d, 0x07, 0xbc, 0x10, 0xf5, 0xa3, - 0xf4, 0xe1, 0xdd, 0x89, 0x40, 0x0b, 0x76, 0x32, 0xfc, 0x22, 0x9b, 0x37, 0x2a, 0xeb, 0x5f, 0x64, - 0xf3, 0x9b, 0x95, 0x5c, 0xeb, 0x4f, 0x06, 0x54, 0x17, 0xfb, 0x56, 0x17, 0x91, 0x3c, 0x82, 0x4d, - 0xfd, 0xc5, 0x82, 0xcd, 0x5f, 0xdc, 0xdf, 0xc1, 0xb7, 0x7b, 0xfc, 0x31, 0x63, 0xf6, 0x71, 0x40, - 0x63, 0x08, 0xe9, 0x42, 0x16, 0xaf, 0x4f, 0xdd, 0xd8, 0x1f, 0xbc, 0xed, 0x45, 0x46, 0xd1, 0xba, - 0x73, 0xf8, 0xf2, 0x55, 0x63, 0xed, 0xdb, 0x57, 0x8d, 0xb5, 0xef, 0x5f, 0x35, 0x8c, 0x3f, 0xcc, - 0x1a, 0xc6, 0x5f, 0x67, 0x0d, 0xe3, 0x5f, 0xb3, 0x86, 0xf1, 0x72, 0xd6, 0x30, 0xbe, 0x9b, 0x35, - 0x8c, 0x7f, 0xcf, 0x1a, 0x6b, 0xdf, 0xcf, 0x1a, 0xc6, 0x5f, 0x5e, 0x37, 0xd6, 0x5e, 0xbe, 0x6e, - 0xac, 0x7d, 0xfb, 0xba, 0xb1, 0xf6, 0xbc, 0xbc, 0xe0, 0x7a, 0xb0, 0x89, 0xdf, 0x39, 0x1f, 0xfe, - 0x37, 0x00, 0x00, 0xff, 0xff, 0x01, 0xc0, 0xd4, 0xed, 0x38, 0x0e, 0x00, 0x00, + 0x15, 0xd7, 0x8a, 0xb4, 0x44, 0x3e, 0x8a, 0x12, 0x3d, 0xa2, 0x5c, 0x96, 0x48, 0x48, 0x97, 0x48, + 0x50, 0xc1, 0x76, 0x97, 0xa9, 0x12, 0x34, 0x69, 0x80, 0xb4, 0x11, 0x25, 0xdb, 0x52, 0xac, 0x26, + 0xea, 0x50, 0x06, 0x02, 0x1f, 0xb2, 0x18, 0x72, 0x47, 0xe4, 0xc2, 0xcb, 0xdd, 0xd5, 0xcc, 0xac, + 0x2b, 0xb5, 0x28, 0xd0, 0x1e, 0x7b, 0x6a, 0x2f, 0xfd, 0x0e, 0x45, 0x0f, 0xfd, 0x08, 0xbd, 0xb6, + 0x47, 0x1f, 0x73, 0x12, 0x62, 0xfa, 0xd2, 0x63, 0xbe, 0x40, 0x81, 0x62, 0xde, 0xec, 0xae, 0x96, + 0x34, 0x01, 0x29, 0xcd, 0x45, 0x9a, 0x79, 0xef, 0xf7, 0x7e, 0xef, 0xcd, 0xbe, 0x3f, 0x33, 0x84, + 0x0f, 0xa5, 0x18, 0x76, 0x87, 0x4c, 0x04, 0xa1, 0xea, 0x46, 0x3e, 0x0b, 0x02, 0x2e, 0xba, 0xae, + 0x27, 0x95, 0xf0, 0x06, 0xb1, 0xe2, 0x6e, 0x34, 0xc8, 0xef, 0x1c, 0x8d, 0xb0, 0x23, 0x11, 0xaa, + 0x90, 0xb4, 0xa3, 0x73, 0xdb, 0xd8, 0xd9, 0x89, 0x9d, 0x3d, 0x63, 0xd7, 0xac, 0x8f, 0xc2, 0x51, + 0x88, 0xd8, 0xae, 0x5e, 0x19, 0xb3, 0x66, 0x5b, 0xfb, 0x63, 0x91, 0xd7, 0x35, 0x9a, 0x38, 0xf6, + 0xb4, 0x0f, 0xfd, 0x2f, 0x01, 0xbc, 0x35, 0x17, 0x50, 0x34, 0xe8, 0x5e, 0x79, 0x6d, 0xbe, 0x8b, + 0xda, 0x70, 0x32, 0x09, 0x83, 0xee, 0x80, 0x49, 0xde, 0x95, 0x8a, 0xa9, 0x58, 0x46, 0x83, 0x64, + 0x91, 0xc0, 0xee, 0x69, 0x98, 0x1c, 0x33, 0xc1, 0xdd, 0xee, 0xc0, 0x0f, 0xc3, 0xc9, 0xa9, 0xe7, + 0x2b, 0x2e, 0xa2, 0x41, 0x7e, 0x97, 0x60, 0xdf, 0xc9, 0x61, 0x27, 0x5c, 0x31, 0x97, 0x29, 0x16, + 0x0d, 0xb2, 0x65, 0xde, 0xb1, 0x62, 0x03, 0x9f, 0x3b, 0x52, 0x85, 0x82, 0x77, 0xe5, 0x70, 0xcc, + 0x27, 0x1a, 0x68, 0x16, 0x06, 0xd6, 0x99, 0x5a, 0xb0, 0xf6, 0xab, 0xc4, 0xf2, 0x30, 0x38, 0x0d, + 0xc9, 0x13, 0xd8, 0x48, 0x99, 0x9c, 0x53, 0x8f, 0xfb, 0xae, 0x6c, 0x58, 0x77, 0x0b, 0xdb, 0xeb, + 0x3b, 0x1d, 0x3b, 0x3a, 0xb7, 0x8d, 0x5b, 0xfb, 0xca, 0xad, 0x9d, 0x1a, 0x9f, 0x5c, 0x44, 0x9c, + 0xae, 0xa7, 0x8a, 0x47, 0x68, 0x49, 0x7e, 0x07, 0x5b, 0xe7, 0xe7, 0x63, 0x26, 0xc7, 0x3f, 0xfb, + 0xc0, 0xc1, 0x83, 0x38, 0xe6, 0x24, 0x8d, 0xe5, 0xbb, 0xd6, 0x76, 0x65, 0xe7, 0x41, 0x8e, 0x72, + 0xe6, 0xd4, 0xf6, 0x97, 0x5f, 0x1e, 0xa0, 0x55, 0x4f, 0x4b, 0x1f, 0xa1, 0xb4, 0xf7, 0x83, 0xe9, + 0x65, 0x7b, 0x73, 0x81, 0xe2, 0x60, 0x89, 0x6e, 0xa6, 0x5e, 0xf2, 0xf8, 0x12, 0xac, 0x18, 0xbe, + 0xce, 0x37, 0x45, 0x80, 0x3d, 0xcc, 0x10, 0x1e, 0xf1, 0x3d, 0xa8, 0x9f, 0xc5, 0x5c, 0x5c, 0x38, + 0x03, 0x11, 0x3e, 0xe7, 0xc2, 0x61, 0xae, 0x2b, 0xb8, 0xd4, 0xe7, 0xb4, 0xb6, 0xcb, 0x94, 0xa0, + 0xae, 0x87, 0xaa, 0x5d, 0xa3, 0x21, 0x1f, 0x42, 0x89, 0x8d, 0x78, 0xa0, 0x1c, 0xcf, 0x6d, 0x00, + 0x86, 0xbe, 0xa1, 0x43, 0x37, 0xc5, 0x60, 0x3f, 0x7d, 0x7a, 0xb8, 0xdf, 0xab, 0x4c, 0x2f, 0xdb, + 0xab, 0xbb, 0x1a, 0x74, 0xb8, 0x4f, 0x57, 0x11, 0x7d, 0xe8, 0x92, 0x9f, 0xc3, 0xc6, 0x98, 0x49, + 0x67, 0x24, 0xa2, 0xa1, 0x23, 0xb9, 0x78, 0x91, 0x1c, 0xbd, 0xd4, 0xbb, 0x3d, 0xbd, 0x6c, 0x57, + 0x0f, 0x98, 0x7c, 0x4c, 0x8f, 0xf7, 0xfa, 0xa8, 0xa0, 0xd5, 0x31, 0x93, 0x8f, 0x45, 0x34, 0x34, + 0x5b, 0xb2, 0x03, 0x6b, 0x68, 0x96, 0x46, 0x57, 0xd0, 0xd1, 0xf5, 0x36, 0xa6, 0x97, 0xed, 0x8a, + 0x36, 0x4a, 0x42, 0xa3, 0x15, 0x0d, 0x4a, 0xe3, 0x7c, 0x07, 0xd6, 0xb5, 0x3b, 0x4c, 0x1e, 0x66, + 0xbd, 0x51, 0xd4, 0xde, 0xe8, 0xda, 0x98, 0xc9, 0x7d, 0xa6, 0x58, 0x5f, 0xcb, 0xc8, 0xbb, 0xb0, + 0x1e, 0x89, 0x70, 0xc8, 0xa5, 0xe4, 0x06, 0xdb, 0xb8, 0x85, 0xa8, 0x6a, 0x26, 0xd5, 0x58, 0xf2, + 0x01, 0xdc, 0x61, 0xc3, 0x21, 0x8f, 0x94, 0x74, 0x04, 0x9f, 0x84, 0x8a, 0x3b, 0x32, 0x8c, 0xc5, + 0x90, 0xcb, 0xc6, 0x0a, 0xc2, 0xeb, 0x89, 0x96, 0xa2, 0xb2, 0x6f, 0x74, 0xe4, 0x10, 0xc0, 0x54, + 0x9d, 0x17, 0x9c, 0x86, 0x8d, 0xd5, 0xbb, 0x85, 0xed, 0xca, 0xce, 0x3d, 0xfb, 0x9a, 0xde, 0xb3, + 0x4f, 0xb4, 0x89, 0x4e, 0x0e, 0x2d, 0xab, 0x74, 0x49, 0xde, 0x82, 0x22, 0x93, 0x9e, 0xdb, 0x28, + 0xdd, 0xb5, 0xb6, 0xab, 0xbd, 0xd2, 0xf4, 0xb2, 0x5d, 0xdc, 0xed, 0x1f, 0xee, 0x53, 0x94, 0x12, + 0x0a, 0xd5, 0xac, 0x50, 0xd1, 0x57, 0x19, 0x13, 0xf3, 0x93, 0x6b, 0x7d, 0xe5, 0xcb, 0x9d, 0xae, + 0x4d, 0xf2, 0xc5, 0xff, 0x11, 0xac, 0x4b, 0xe9, 0x3b, 0x8a, 0x89, 0x11, 0x57, 0x01, 0x9b, 0xf0, + 0x46, 0x05, 0xbf, 0x3a, 0x66, 0xab, 0xdf, 0x3f, 0x3a, 0x41, 0xc5, 0xe7, 0x6c, 0xc2, 0x69, 0x55, + 0x4a, 0xff, 0x24, 0xc3, 0x75, 0xc6, 0x50, 0xce, 0xce, 0x40, 0xea, 0x70, 0x0b, 0x4f, 0x91, 0x54, + 0x94, 0xd9, 0x90, 0xfb, 0x70, 0x1b, 0x17, 0xca, 0xfb, 0x2d, 0x53, 0x5e, 0x18, 0x38, 0xcf, 0xf9, + 0x05, 0x56, 0x43, 0x99, 0xd6, 0x66, 0x14, 0x4f, 0xf8, 0x05, 0x69, 0xc0, 0xaa, 0x91, 0xe9, 0xc4, + 0x17, 0xb6, 0xcb, 0x34, 0xdd, 0x76, 0xfe, 0x6c, 0x01, 0xf4, 0xb1, 0x85, 0xd1, 0x17, 0x81, 0x22, + 0x06, 0x6a, 0x5c, 0xe1, 0x9a, 0x7c, 0x02, 0x25, 0xc1, 0x7d, 0xe4, 0x4a, 0x3a, 0xed, 0x47, 0xfa, + 0xab, 0xe4, 0xa6, 0x81, 0x9d, 0x4e, 0x03, 0x9b, 0x26, 0x40, 0x9a, 0x99, 0x10, 0x1b, 0xc0, 0x54, + 0xbb, 0xef, 0x49, 0x85, 0xee, 0xdf, 0xac, 0x77, 0x5a, 0x46, 0xc8, 0x91, 0x27, 0x55, 0xe7, 0x1f, + 0x16, 0xd4, 0xf6, 0xaf, 0x3e, 0x71, 0x5f, 0x31, 0xc5, 0xc9, 0x11, 0x54, 0x4c, 0x16, 0x4c, 0x72, + 0x2c, 0x64, 0xb9, 0x7f, 0x6d, 0x72, 0xae, 0xda, 0x94, 0xc2, 0xf0, 0xaa, 0x65, 0x8f, 0xa0, 0x62, + 0x22, 0x36, 0x6c, 0xcb, 0x37, 0x64, 0xbb, 0xfa, 0x4e, 0x14, 0x64, 0xb6, 0xee, 0xfc, 0xab, 0x00, + 0x1b, 0xb9, 0x80, 0x8f, 0x7d, 0x16, 0x10, 0x01, 0xe4, 0x6c, 0x90, 0x36, 0x9b, 0xa3, 0x42, 0xbc, + 0x3a, 0x92, 0xb0, 0x1f, 0x5e, 0xeb, 0x68, 0x8e, 0xcd, 0xfe, 0xf5, 0x20, 0x69, 0xc9, 0x93, 0x50, + 0xef, 0x1f, 0x06, 0x4a, 0x5c, 0xd0, 0x8d, 0xb3, 0x59, 0x29, 0x79, 0x01, 0xf5, 0x59, 0x9f, 0x2e, + 0x1b, 0xe9, 0x11, 0x63, 0x8e, 0xf7, 0xe8, 0xfb, 0x78, 0xdd, 0x67, 0xa3, 0x43, 0xd7, 0xb8, 0xad, + 0x9d, 0xcd, 0x89, 0xc9, 0x8f, 0xa1, 0xe0, 0xb2, 0x11, 0x4e, 0x94, 0xca, 0xce, 0xd6, 0x9c, 0x1b, + 0xcd, 0xbb, 0xfb, 0x98, 0x6a, 0x44, 0xf3, 0x19, 0xd4, 0x17, 0x9d, 0x84, 0xd4, 0xa0, 0xa0, 0x8b, + 0xd7, 0xd4, 0x9c, 0x5e, 0x92, 0x07, 0x70, 0xeb, 0x05, 0xf3, 0x63, 0x9e, 0xd4, 0xdb, 0x9d, 0x37, + 0x49, 0xb5, 0x35, 0x35, 0xa0, 0x8f, 0x97, 0x3f, 0xb2, 0x9a, 0x7b, 0xb0, 0xb5, 0x30, 0xde, 0x05, + 0xe4, 0xf5, 0x3c, 0x79, 0x31, 0x47, 0xd2, 0xf9, 0xa3, 0x05, 0x35, 0xca, 0x5d, 0x36, 0xd4, 0x85, + 0xfb, 0x45, 0xa4, 0xff, 0x4a, 0xf2, 0x00, 0x48, 0x2c, 0xb9, 0x73, 0x1a, 0xfb, 0xbe, 0x23, 0x52, + 0x25, 0xf2, 0x95, 0x68, 0x2d, 0x96, 0xfc, 0x51, 0xec, 0xfb, 0x99, 0x11, 0xf9, 0x25, 0xbc, 0xad, + 0xd1, 0xd1, 0x79, 0x82, 0x75, 0x22, 0xcf, 0x73, 0x06, 0x5c, 0x2a, 0x87, 0x9f, 0x9e, 0x86, 0x42, + 0x99, 0x81, 0x4d, 0x1b, 0xb1, 0xe4, 0xc7, 0xe7, 0xc6, 0xec, 0xd8, 0xf3, 0x7a, 0x5c, 0xaa, 0x87, + 0xa8, 0xef, 0xfc, 0xd7, 0x02, 0xf2, 0xc5, 0x09, 0xf7, 0x1f, 0x06, 0x6e, 0x14, 0x7a, 0x81, 0xda, + 0x0b, 0x83, 0x53, 0x6f, 0x44, 0x7e, 0x08, 0x85, 0x58, 0xf8, 0xe6, 0x18, 0xbd, 0xd5, 0xe9, 0x65, + 0xbb, 0xf0, 0x94, 0x1e, 0x51, 0x2d, 0x23, 0xcf, 0x60, 0x75, 0xcc, 0x99, 0xcb, 0x85, 0x4c, 0x52, + 0xfd, 0xe9, 0xb5, 0xa9, 0x7e, 0xd3, 0x81, 0x7d, 0x60, 0x28, 0x4c, 0x92, 0x53, 0x42, 0xd2, 0x84, + 0x92, 0x17, 0x48, 0x3e, 0x8c, 0x05, 0xc7, 0x04, 0x97, 0x68, 0xb6, 0xc7, 0xa1, 0xe2, 0x4d, 0x78, + 0x18, 0x2b, 0xbc, 0x17, 0x0a, 0x34, 0xdd, 0x36, 0x3f, 0x86, 0xb5, 0x3c, 0xdd, 0x75, 0x39, 0x28, + 0xe7, 0x73, 0xf0, 0x77, 0x0b, 0x6a, 0x7b, 0xbe, 0x37, 0x7c, 0x7e, 0x10, 0xc6, 0x92, 0x27, 0xa7, + 0x6f, 0x42, 0x69, 0x1c, 0x4a, 0x95, 0x1b, 0x4d, 0xd9, 0x5e, 0x8f, 0x2c, 0xbd, 0x4e, 0x98, 0x70, + 0xad, 0x65, 0x91, 0xfe, 0xd8, 0x3a, 0xe4, 0x5b, 0x14, 0xd7, 0x9a, 0x23, 0x96, 0x5c, 0x20, 0x47, + 0xd1, 0x70, 0xa4, 0x7b, 0xad, 0x8b, 0x98, 0x94, 0xbf, 0x09, 0x85, 0x8b, 0xb7, 0x57, 0x99, 0x66, + 0x7b, 0xad, 0xd3, 0x13, 0x5d, 0x3f, 0xb7, 0xf0, 0xaa, 0x2a, 0xd3, 0x6c, 0xdf, 0xa1, 0xb0, 0x76, + 0xec, 0xc7, 0x23, 0x2f, 0x48, 0xe2, 0xec, 0x40, 0x55, 0x2a, 0x26, 0x94, 0xa3, 0xbf, 0x84, 0x13, + 0x98, 0x47, 0x40, 0x81, 0x56, 0x50, 0x78, 0xe2, 0x4d, 0xf8, 0xe7, 0x92, 0xb4, 0xa0, 0xc2, 0x03, + 0x37, 0x43, 0x2c, 0x23, 0xa2, 0xcc, 0x03, 0xd7, 0xe8, 0x3b, 0xff, 0xb4, 0xa0, 0xbc, 0xcf, 0x07, + 0xf1, 0x08, 0x47, 0xd5, 0x19, 0x6c, 0x85, 0x8a, 0xfb, 0x8e, 0xab, 0x25, 0x0e, 0x53, 0x49, 0x12, + 0x65, 0x32, 0x4b, 0x3e, 0xb9, 0xbe, 0xab, 0x53, 0x2a, 0x4c, 0x3a, 0xee, 0x76, 0x53, 0x16, 0xba, + 0xa9, 0xb9, 0x67, 0x65, 0xb2, 0xf9, 0x0b, 0x53, 0x80, 0xb3, 0xe2, 0x85, 0x37, 0xc3, 0xc2, 0x2c, + 0x76, 0xfe, 0xba, 0x02, 0x9b, 0x47, 0xe1, 0xc8, 0x1b, 0x32, 0xff, 0xd8, 0x84, 0x64, 0x66, 0xf8, + 0x57, 0x70, 0x3b, 0xff, 0x98, 0xd6, 0x2f, 0xd6, 0xb4, 0xc1, 0x7f, 0xfa, 0x5d, 0x86, 0x13, 0xb2, + 0xd1, 0x9a, 0x3b, 0x7f, 0x47, 0x7c, 0x0a, 0x6b, 0xda, 0xd6, 0x09, 0x4d, 0xe3, 0x26, 0x03, 0xe9, + 0xed, 0xc5, 0xb3, 0x23, 0xe9, 0x6e, 0x5a, 0x89, 0xae, 0x36, 0xfa, 0x29, 0x23, 0xb8, 0x8c, 0x7d, + 0x95, 0x3d, 0x93, 0x4c, 0xa1, 0x54, 0x8d, 0x34, 0x7d, 0x17, 0x3d, 0x81, 0xad, 0x04, 0x36, 0x77, + 0xbd, 0x63, 0xe9, 0x98, 0x97, 0x25, 0x45, 0xc0, 0xec, 0x25, 0xbf, 0x69, 0xac, 0xfa, 0xf9, 0xab, + 0x5e, 0x7f, 0x95, 0x6c, 0xaa, 0x64, 0xa1, 0xaf, 0xde, 0xf0, 0xab, 0xcc, 0x0f, 0x2b, 0x5a, 0x13, + 0xf3, 0xe3, 0xeb, 0xf7, 0x50, 0xc7, 0x02, 0xe2, 0x49, 0xbb, 0x3b, 0x43, 0x2c, 0x55, 0x7c, 0x06, + 0x55, 0x76, 0xde, 0xff, 0x3f, 0x46, 0x45, 0xef, 0xce, 0xf4, 0xb2, 0xbd, 0x60, 0x46, 0x51, 0xa2, + 0x1d, 0xcd, 0xcd, 0x2d, 0x0a, 0xd5, 0x08, 0x3b, 0x24, 0xf5, 0x7b, 0xd3, 0x77, 0x55, 0xbe, 0xaf, + 0xe8, 0x5a, 0x94, 0xef, 0xb2, 0xaf, 0xe0, 0xf6, 0x50, 0x4f, 0x88, 0xb1, 0x9e, 0x10, 0x29, 0x6f, + 0xe5, 0x86, 0x9f, 0x6c, 0x7e, 0xb6, 0xd0, 0xda, 0x15, 0x57, 0xc2, 0x7f, 0x08, 0x60, 0xda, 0x0d, + 0x5f, 0x07, 0xe6, 0x85, 0x7e, 0xef, 0xe6, 0x8d, 0x46, 0xcb, 0x6e, 0xba, 0xfc, 0xac, 0x58, 0xb2, + 0x6a, 0xcb, 0x9f, 0x15, 0x4b, 0x2b, 0xb5, 0xd5, 0xce, 0x9f, 0x2c, 0xa8, 0xcf, 0xf6, 0x85, 0x29, + 0x12, 0x72, 0x1f, 0x56, 0xcc, 0xcf, 0x37, 0x6c, 0xae, 0xca, 0xce, 0x26, 0xfe, 0x90, 0x49, 0x7e, + 0xd9, 0xd9, 0x7d, 0x5c, 0xd0, 0x04, 0x42, 0xf6, 0xa1, 0x88, 0x6f, 0x09, 0xd3, 0x38, 0xef, 0x7d, + 0xd7, 0x5b, 0x9d, 0xa2, 0x75, 0x6f, 0xef, 0xe5, 0xab, 0xd6, 0xd2, 0xd7, 0xaf, 0x5a, 0x4b, 0xdf, + 0xbe, 0x6a, 0x59, 0x7f, 0x98, 0xb6, 0xac, 0xbf, 0x4d, 0x5b, 0xd6, 0xbf, 0xa7, 0x2d, 0xeb, 0xe5, + 0xb4, 0x65, 0x7d, 0x33, 0x6d, 0x59, 0xff, 0x99, 0xb6, 0x96, 0xbe, 0x9d, 0xb6, 0xac, 0xbf, 0xbc, + 0x6e, 0x2d, 0xbd, 0x7c, 0xdd, 0x5a, 0xfa, 0xfa, 0x75, 0x6b, 0xe9, 0x59, 0x75, 0x86, 0x7a, 0xb0, + 0x82, 0x3f, 0xfa, 0xde, 0xff, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x09, 0xb7, 0x07, 0x45, + 0x0f, 0x00, 0x00, } func (this *MetadataInfo) Equal(that interface{}) bool { @@ -1333,6 +1432,45 @@ func (this *OTelEndpointConfig) Equal(that interface{}) bool { } return true } +func (this *ClickHouseConfig) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*ClickHouseConfig) + if !ok { + that2, ok := that.(ClickHouseConfig) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Hostname != that1.Hostname { + return false + } + if this.Host != that1.Host { + return false + } + if this.Port != that1.Port { + return false + } + if this.Username != that1.Username { + return false + } + if this.Password != that1.Password { + return false + } + if this.Database != that1.Database { + return false + } + return true +} func (this *PluginConfig) Equal(that interface{}) bool { if that == nil { return this == nil @@ -1456,6 +1594,9 @@ func (this *LogicalPlannerState) Equal(that interface{}) bool { if !this.PluginConfig.Equal(that1.PluginConfig) { return false } + if !this.ClickhouseConfig.Equal(that1.ClickhouseConfig) { + return false + } if !this.DebugInfo.Equal(that1.DebugInfo) { return false } @@ -1652,6 +1793,21 @@ func (this *OTelEndpointConfig) GoString() string { s = append(s, "}") return strings.Join(s, "") } +func (this *ClickHouseConfig) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 10) + s = append(s, "&distributedpb.ClickHouseConfig{") + s = append(s, "Hostname: "+fmt.Sprintf("%#v", this.Hostname)+",\n") + s = append(s, "Host: "+fmt.Sprintf("%#v", this.Host)+",\n") + s = append(s, "Port: "+fmt.Sprintf("%#v", this.Port)+",\n") + s = append(s, "Username: "+fmt.Sprintf("%#v", this.Username)+",\n") + s = append(s, "Password: "+fmt.Sprintf("%#v", this.Password)+",\n") + s = append(s, "Database: "+fmt.Sprintf("%#v", this.Database)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} func (this *PluginConfig) GoString() string { if this == nil { return "nil" @@ -1690,7 +1846,7 @@ func (this *LogicalPlannerState) GoString() string { if this == nil { return "nil" } - s := make([]string, 0, 12) + s := make([]string, 0, 13) s = append(s, "&distributedpb.LogicalPlannerState{") if this.DistributedState != nil { s = append(s, "DistributedState: "+fmt.Sprintf("%#v", this.DistributedState)+",\n") @@ -1709,6 +1865,9 @@ func (this *LogicalPlannerState) GoString() string { if this.PluginConfig != nil { s = append(s, "PluginConfig: "+fmt.Sprintf("%#v", this.PluginConfig)+",\n") } + if this.ClickhouseConfig != nil { + s = append(s, "ClickhouseConfig: "+fmt.Sprintf("%#v", this.ClickhouseConfig)+",\n") + } if this.DebugInfo != nil { s = append(s, "DebugInfo: "+fmt.Sprintf("%#v", this.DebugInfo)+",\n") } @@ -2274,6 +2433,69 @@ func (m *OTelEndpointConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *ClickHouseConfig) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClickHouseConfig) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ClickHouseConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Database) > 0 { + i -= len(m.Database) + copy(dAtA[i:], m.Database) + i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.Database))) + i-- + dAtA[i] = 0x32 + } + if len(m.Password) > 0 { + i -= len(m.Password) + copy(dAtA[i:], m.Password) + i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.Password))) + i-- + dAtA[i] = 0x2a + } + if len(m.Username) > 0 { + i -= len(m.Username) + copy(dAtA[i:], m.Username) + i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.Username))) + i-- + dAtA[i] = 0x22 + } + if m.Port != 0 { + i = encodeVarintDistributedPlan(dAtA, i, uint64(m.Port)) + i-- + dAtA[i] = 0x18 + } + if len(m.Host) > 0 { + i -= len(m.Host) + copy(dAtA[i:], m.Host) + i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.Host))) + i-- + dAtA[i] = 0x12 + } + if len(m.Hostname) > 0 { + i -= len(m.Hostname) + copy(dAtA[i:], m.Hostname) + i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.Hostname))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *PluginConfig) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -2401,6 +2623,18 @@ func (m *LogicalPlannerState) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.ClickhouseConfig != nil { + { + size, err := m.ClickhouseConfig.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDistributedPlan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x5a + } if m.DebugInfo != nil { { size, err := m.DebugInfo.MarshalToSizedBuffer(dAtA[:i]) @@ -2772,6 +3006,38 @@ func (m *OTelEndpointConfig) Size() (n int) { return n } +func (m *ClickHouseConfig) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Hostname) + if l > 0 { + n += 1 + l + sovDistributedPlan(uint64(l)) + } + l = len(m.Host) + if l > 0 { + n += 1 + l + sovDistributedPlan(uint64(l)) + } + if m.Port != 0 { + n += 1 + sovDistributedPlan(uint64(m.Port)) + } + l = len(m.Username) + if l > 0 { + n += 1 + l + sovDistributedPlan(uint64(l)) + } + l = len(m.Password) + if l > 0 { + n += 1 + l + sovDistributedPlan(uint64(l)) + } + l = len(m.Database) + if l > 0 { + n += 1 + l + sovDistributedPlan(uint64(l)) + } + return n +} + func (m *PluginConfig) Size() (n int) { if m == nil { return 0 @@ -2857,6 +3123,10 @@ func (m *LogicalPlannerState) Size() (n int) { l = m.DebugInfo.Size() n += 1 + l + sovDistributedPlan(uint64(l)) } + if m.ClickhouseConfig != nil { + l = m.ClickhouseConfig.Size() + n += 1 + l + sovDistributedPlan(uint64(l)) + } return n } @@ -3045,6 +3315,21 @@ func (this *OTelEndpointConfig) String() string { }, "") return s } +func (this *ClickHouseConfig) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ClickHouseConfig{`, + `Hostname:` + fmt.Sprintf("%v", this.Hostname) + `,`, + `Host:` + fmt.Sprintf("%v", this.Host) + `,`, + `Port:` + fmt.Sprintf("%v", this.Port) + `,`, + `Username:` + fmt.Sprintf("%v", this.Username) + `,`, + `Password:` + fmt.Sprintf("%v", this.Password) + `,`, + `Database:` + fmt.Sprintf("%v", this.Database) + `,`, + `}`, + }, "") + return s +} func (this *PluginConfig) String() string { if this == nil { return "nil" @@ -3095,6 +3380,7 @@ func (this *LogicalPlannerState) String() string { `OTelEndpointConfig:` + strings.Replace(this.OTelEndpointConfig.String(), "OTelEndpointConfig", "OTelEndpointConfig", 1) + `,`, `PluginConfig:` + strings.Replace(this.PluginConfig.String(), "PluginConfig", "PluginConfig", 1) + `,`, `DebugInfo:` + strings.Replace(this.DebugInfo.String(), "DebugInfo", "DebugInfo", 1) + `,`, + `ClickhouseConfig:` + strings.Replace(this.ClickhouseConfig.String(), "ClickHouseConfig", "ClickHouseConfig", 1) + `,`, `}`, }, "") return s @@ -4705,6 +4991,235 @@ func (m *OTelEndpointConfig) Unmarshal(dAtA []byte) error { } return nil } +func (m *ClickHouseConfig) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDistributedPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClickHouseConfig: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClickHouseConfig: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDistributedPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthDistributedPlan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDistributedPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hostname = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDistributedPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthDistributedPlan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDistributedPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Host = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) + } + m.Port = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDistributedPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Port |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDistributedPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthDistributedPlan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDistributedPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Username = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDistributedPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthDistributedPlan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDistributedPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Password = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Database", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDistributedPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthDistributedPlan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthDistributedPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Database = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDistributedPlan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDistributedPlan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *PluginConfig) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -5300,6 +5815,42 @@ func (m *LogicalPlannerState) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClickhouseConfig", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDistributedPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDistributedPlan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDistributedPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ClickhouseConfig == nil { + m.ClickhouseConfig = &ClickHouseConfig{} + } + if err := m.ClickhouseConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDistributedPlan(dAtA[iNdEx:]) diff --git a/src/carnot/planner/distributedpb/distributed_plan.proto b/src/carnot/planner/distributedpb/distributed_plan.proto index b5a4e8d08a1..581b8748d37 100644 --- a/src/carnot/planner/distributedpb/distributed_plan.proto +++ b/src/carnot/planner/distributedpb/distributed_plan.proto @@ -142,6 +142,23 @@ message OTelEndpointConfig { int64 timeout = 4; } +// ClickHouseConfig contains the connection parameters for ClickHouse. +message ClickHouseConfig { + // The hostname of the node executing the query. + string hostname = 1; + // The ClickHouse server host. + string host = 2; + // The ClickHouse server port. + int32 port = 3; + // The ClickHouse username. + string username = 4; + // The ClickHouse password. + string password = 5; + // The ClickHouse database name. + string database = 6; +} + + message PluginConfig { // The start_time of the script in nanoseconds. int64 start_time_ns = 1; @@ -183,6 +200,8 @@ message LogicalPlannerState { // PluginConfig contains plugin related configuration. PluginConfig plugin_config = 9; + ClickHouseConfig clickhouse_config = 11; + // Debug options for the compiler. DebugInfo debug_info = 10; } diff --git a/src/carnot/planner/plannerpb/service.pb.go b/src/carnot/planner/plannerpb/service.pb.go index 172eeb1cd81..c7a23641ce0 100755 --- a/src/carnot/planner/plannerpb/service.pb.go +++ b/src/carnot/planner/plannerpb/service.pb.go @@ -146,6 +146,7 @@ func (m *FuncToExecute_ArgValue) GetValue() string { type Configs struct { OTelEndpointConfig *Configs_OTelEndpointConfig `protobuf:"bytes,1,opt,name=otel_endpoint_config,json=otelEndpointConfig,proto3" json:"otel_endpoint_config,omitempty"` PluginConfig *Configs_PluginConfig `protobuf:"bytes,2,opt,name=plugin_config,json=pluginConfig,proto3" json:"plugin_config,omitempty"` + ClickhouseConfig *Configs_ClickHouseConfig `protobuf:"bytes,3,opt,name=clickhouse_config,json=clickhouseConfig,proto3" json:"clickhouse_config,omitempty"` } func (m *Configs) Reset() { *m = Configs{} } @@ -194,6 +195,13 @@ func (m *Configs) GetPluginConfig() *Configs_PluginConfig { return nil } +func (m *Configs) GetClickhouseConfig() *Configs_ClickHouseConfig { + if m != nil { + return m.ClickhouseConfig + } + return nil +} + type Configs_OTelEndpointConfig struct { URL string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"` Headers map[string]string `protobuf:"bytes,2,rep,name=headers,proto3" json:"headers,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` @@ -312,6 +320,89 @@ func (m *Configs_PluginConfig) GetEndTimeNs() int64 { return 0 } +type Configs_ClickHouseConfig struct { + Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"` + Host string `protobuf:"bytes,2,opt,name=host,proto3" json:"host,omitempty"` + Port int32 `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"` + Username string `protobuf:"bytes,4,opt,name=username,proto3" json:"username,omitempty"` + Password string `protobuf:"bytes,5,opt,name=password,proto3" json:"password,omitempty"` + Database string `protobuf:"bytes,6,opt,name=database,proto3" json:"database,omitempty"` +} + +func (m *Configs_ClickHouseConfig) Reset() { *m = Configs_ClickHouseConfig{} } +func (*Configs_ClickHouseConfig) ProtoMessage() {} +func (*Configs_ClickHouseConfig) Descriptor() ([]byte, []int) { + return fileDescriptor_710b3465b5cdfdeb, []int{1, 2} +} +func (m *Configs_ClickHouseConfig) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Configs_ClickHouseConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Configs_ClickHouseConfig.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Configs_ClickHouseConfig) XXX_Merge(src proto.Message) { + xxx_messageInfo_Configs_ClickHouseConfig.Merge(m, src) +} +func (m *Configs_ClickHouseConfig) XXX_Size() int { + return m.Size() +} +func (m *Configs_ClickHouseConfig) XXX_DiscardUnknown() { + xxx_messageInfo_Configs_ClickHouseConfig.DiscardUnknown(m) +} + +var xxx_messageInfo_Configs_ClickHouseConfig proto.InternalMessageInfo + +func (m *Configs_ClickHouseConfig) GetHostname() string { + if m != nil { + return m.Hostname + } + return "" +} + +func (m *Configs_ClickHouseConfig) GetHost() string { + if m != nil { + return m.Host + } + return "" +} + +func (m *Configs_ClickHouseConfig) GetPort() int32 { + if m != nil { + return m.Port + } + return 0 +} + +func (m *Configs_ClickHouseConfig) GetUsername() string { + if m != nil { + return m.Username + } + return "" +} + +func (m *Configs_ClickHouseConfig) GetPassword() string { + if m != nil { + return m.Password + } + return "" +} + +func (m *Configs_ClickHouseConfig) GetDatabase() string { + if m != nil { + return m.Database + } + return "" +} + type QueryRequest struct { LogicalPlannerState *distributedpb.LogicalPlannerState `protobuf:"bytes,5,opt,name=logical_planner_state,json=logicalPlannerState,proto3" json:"logical_planner_state,omitempty"` QueryStr string `protobuf:"bytes,1,opt,name=query_str,json=queryStr,proto3" json:"query_str,omitempty"` @@ -857,6 +948,7 @@ func init() { proto.RegisterType((*Configs_OTelEndpointConfig)(nil), "px.carnot.planner.plannerpb.Configs.OTelEndpointConfig") proto.RegisterMapType((map[string]string)(nil), "px.carnot.planner.plannerpb.Configs.OTelEndpointConfig.HeadersEntry") proto.RegisterType((*Configs_PluginConfig)(nil), "px.carnot.planner.plannerpb.Configs.PluginConfig") + proto.RegisterType((*Configs_ClickHouseConfig)(nil), "px.carnot.planner.plannerpb.Configs.ClickHouseConfig") proto.RegisterType((*QueryRequest)(nil), "px.carnot.planner.plannerpb.QueryRequest") proto.RegisterType((*QueryResponse)(nil), "px.carnot.planner.plannerpb.QueryResponse") proto.RegisterType((*CompileMutationsRequest)(nil), "px.carnot.planner.plannerpb.CompileMutationsRequest") @@ -873,77 +965,83 @@ func init() { } var fileDescriptor_710b3465b5cdfdeb = []byte{ - // 1108 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x56, 0x51, 0x6f, 0x1b, 0xc5, - 0x13, 0xf7, 0xd9, 0x69, 0x63, 0x8f, 0x9d, 0xfe, 0xd3, 0x4d, 0xfe, 0xe0, 0xba, 0xe2, 0x12, 0x9d, - 0x0a, 0x0a, 0x01, 0xce, 0x90, 0x06, 0x82, 0x2a, 0x01, 0xc2, 0x4d, 0x20, 0x54, 0xa5, 0x84, 0x4b, - 0xda, 0x87, 0xaa, 0xe2, 0x74, 0xbe, 0x9b, 0xb8, 0x27, 0xce, 0x7b, 0xd7, 0xdd, 0xbd, 0xca, 0xe1, - 0x85, 0x16, 0x89, 0x77, 0x24, 0xbe, 0x02, 0x42, 0x20, 0x3e, 0x03, 0xef, 0x3c, 0xe6, 0xb1, 0x4f, - 0x11, 0x71, 0x24, 0xc4, 0x63, 0x3f, 0x02, 0xda, 0xdd, 0xbb, 0xc4, 0x49, 0xdc, 0xc4, 0x89, 0x78, - 0xe4, 0xe9, 0x66, 0x67, 0x67, 0x7e, 0x33, 0xfb, 0x9b, 0x99, 0xdd, 0x83, 0x79, 0xce, 0xfc, 0xa6, - 0xef, 0x31, 0x1a, 0x8b, 0x66, 0x12, 0x79, 0x94, 0x22, 0xcb, 0xbf, 0x49, 0xbb, 0xc9, 0x91, 0x3d, - 0x0e, 0x7d, 0xb4, 0x13, 0x16, 0x8b, 0x98, 0x5c, 0x4d, 0x7a, 0xb6, 0x36, 0xb5, 0x33, 0x13, 0x7b, - 0xdf, 0xb4, 0xf1, 0xc1, 0x10, 0xa0, 0x60, 0x8b, 0x7a, 0xdd, 0xd0, 0x77, 0x05, 0xf3, 0xfc, 0x90, - 0x76, 0x9a, 0x21, 0x6b, 0x46, 0x71, 0x27, 0xf4, 0xbd, 0x28, 0x69, 0xe7, 0x92, 0xc6, 0x6e, 0xbc, - 0xaa, 0xdc, 0xe3, 0x6e, 0x37, 0xa6, 0xcd, 0xb6, 0xc7, 0xb1, 0xc9, 0x85, 0x27, 0x52, 0x2e, 0x73, - 0x50, 0x42, 0x66, 0x36, 0xdd, 0x89, 0x3b, 0xb1, 0x12, 0x9b, 0x52, 0xca, 0xb4, 0x4b, 0xc3, 0x62, - 0x87, 0x5c, 0xb0, 0xb0, 0x9d, 0x0a, 0x0c, 0x92, 0xf6, 0xe0, 0xca, 0x95, 0x16, 0xda, 0xd1, 0xfa, - 0xcb, 0x80, 0x89, 0x4f, 0x52, 0xea, 0x6f, 0xc4, 0x2b, 0x3d, 0xf4, 0x53, 0x81, 0xe4, 0x2a, 0x54, - 0x36, 0x53, 0xea, 0xbb, 0xd4, 0xeb, 0x62, 0xdd, 0x98, 0x35, 0xe6, 0x2a, 0x4e, 0x59, 0x2a, 0xee, - 0x78, 0x5d, 0x24, 0x0e, 0x80, 0xc7, 0x3a, 0xee, 0x63, 0x2f, 0x4a, 0x91, 0xd7, 0x8b, 0xb3, 0xa5, - 0xb9, 0xea, 0xc2, 0x75, 0xfb, 0x04, 0x56, 0xec, 0x43, 0xe0, 0xf6, 0xc7, 0xac, 0x73, 0x4f, 0xfa, - 0x3a, 0x15, 0x2f, 0x93, 0x38, 0xb1, 0x61, 0x2a, 0x4e, 0x45, 0x92, 0x0a, 0x57, 0x78, 0xed, 0x08, - 0xdd, 0x84, 0xe1, 0x66, 0xd8, 0xab, 0x97, 0x54, 0xe8, 0xcb, 0x7a, 0x6b, 0x43, 0xee, 0xac, 0xa9, - 0x8d, 0xc6, 0x22, 0x94, 0x73, 0x18, 0x42, 0x60, 0x6c, 0x20, 0x4f, 0x25, 0x93, 0x69, 0xb8, 0xa0, - 0xf2, 0xab, 0x17, 0x95, 0x52, 0x2f, 0xac, 0xdf, 0xc7, 0x60, 0xfc, 0x66, 0x4c, 0x37, 0xc3, 0x0e, - 0x27, 0x4f, 0x0d, 0x98, 0x8e, 0x05, 0x46, 0x2e, 0xd2, 0x20, 0x89, 0x43, 0x2a, 0x5c, 0x5f, 0xed, - 0x28, 0x98, 0xea, 0xc2, 0xd2, 0x89, 0x07, 0xca, 0x40, 0xec, 0x2f, 0x36, 0x30, 0x5a, 0xc9, 0xfc, - 0xb5, 0xae, 0xf5, 0x52, 0x7f, 0x67, 0x86, 0x1c, 0xd7, 0x3b, 0x44, 0x06, 0x3b, 0xac, 0x23, 0xf7, - 0x60, 0x22, 0x89, 0xd2, 0x4e, 0x48, 0xf3, 0xd8, 0x45, 0x15, 0xfb, 0x9d, 0x91, 0x62, 0xaf, 0x29, - 0xcf, 0x0c, 0xbd, 0x96, 0x0c, 0xac, 0x1a, 0x4f, 0x8b, 0x30, 0x24, 0x05, 0x72, 0x05, 0x4a, 0x29, - 0x8b, 0x34, 0x4f, 0xad, 0xf1, 0xfe, 0xce, 0x4c, 0xe9, 0xae, 0x73, 0xdb, 0x91, 0x3a, 0xf2, 0x15, - 0x8c, 0x3f, 0x44, 0x2f, 0x40, 0x96, 0x17, 0x74, 0xf9, 0x9c, 0xe7, 0xb7, 0x57, 0x35, 0xcc, 0x0a, - 0x15, 0x6c, 0xcb, 0xc9, 0x41, 0x49, 0x03, 0xca, 0x21, 0xe5, 0xe8, 0xa7, 0x0c, 0x55, 0x51, 0xcb, - 0xce, 0xfe, 0x9a, 0xd4, 0x61, 0x5c, 0x84, 0x5d, 0x8c, 0x53, 0x51, 0x1f, 0x9b, 0x35, 0xe6, 0x4a, - 0x4e, 0xbe, 0x6c, 0xdc, 0x80, 0xda, 0x20, 0x1c, 0x99, 0x84, 0xd2, 0xd7, 0xb8, 0x95, 0x15, 0x5a, - 0x8a, 0xc3, 0xeb, 0x7c, 0xa3, 0xf8, 0xbe, 0xd1, 0x70, 0xa0, 0x36, 0xc8, 0x10, 0xb1, 0x60, 0x82, - 0x0b, 0x8f, 0x09, 0x57, 0x82, 0xbb, 0x94, 0x2b, 0x94, 0x92, 0x53, 0x55, 0xca, 0x8d, 0xb0, 0x8b, - 0x77, 0x38, 0x31, 0xa1, 0x8a, 0x34, 0xd8, 0xb7, 0x28, 0x2a, 0x8b, 0x0a, 0xd2, 0x40, 0xef, 0x5b, - 0x3f, 0x17, 0xa1, 0xf6, 0x65, 0x8a, 0x6c, 0xcb, 0xc1, 0x47, 0x29, 0x72, 0x41, 0x1e, 0xc2, 0xff, - 0xb3, 0x01, 0x76, 0x33, 0x72, 0x5c, 0x39, 0xa8, 0x58, 0xbf, 0xa0, 0x0a, 0xb9, 0x38, 0x84, 0xc4, - 0x43, 0x13, 0x69, 0xdf, 0xd6, 0xde, 0x6b, 0x7a, 0x73, 0x5d, 0xfa, 0x3a, 0x53, 0xd1, 0x71, 0xa5, - 0x9c, 0xc8, 0x47, 0x32, 0xb2, 0xcb, 0x05, 0xcb, 0x27, 0x52, 0x29, 0xd6, 0x05, 0x23, 0x9f, 0x01, - 0x60, 0x0f, 0x7d, 0x57, 0x8e, 0x28, 0xaf, 0x97, 0x54, 0x01, 0xe7, 0x47, 0x9f, 0x48, 0xa7, 0x22, - 0xbd, 0xa5, 0x8a, 0x93, 0x0f, 0x61, 0x5c, 0xf7, 0x22, 0x57, 0xc5, 0xa8, 0x2e, 0x5c, 0x1b, 0xa5, - 0x11, 0x9c, 0xdc, 0xe9, 0xd6, 0x58, 0xb9, 0x38, 0x59, 0xb2, 0xbe, 0x33, 0x60, 0x22, 0x23, 0x8a, - 0x27, 0x31, 0xe5, 0x48, 0xde, 0x80, 0x8b, 0xfa, 0x0a, 0xcb, 0xe6, 0x6b, 0x4a, 0xc2, 0xe6, 0xb7, - 0x9b, 0xbd, 0xae, 0x04, 0x27, 0x33, 0x21, 0xcb, 0x30, 0x26, 0x43, 0x64, 0xe3, 0xf0, 0xf6, 0xa9, - 0x2c, 0x2e, 0x1f, 0xac, 0x24, 0x69, 0x8e, 0xf2, 0xb6, 0x7e, 0x2b, 0xc2, 0xcb, 0x37, 0xe3, 0x6e, - 0x12, 0x46, 0xf8, 0x79, 0x2a, 0x3c, 0x11, 0xc6, 0x94, 0xff, 0x57, 0xb8, 0x17, 0x14, 0xce, 0x7a, - 0x0d, 0x26, 0x97, 0x31, 0x42, 0x81, 0x1b, 0xcc, 0xf3, 0x51, 0x4d, 0xf4, 0xb0, 0x9b, 0xd5, 0x7a, - 0x00, 0x35, 0xed, 0x7b, 0x37, 0x09, 0xe4, 0xf9, 0x46, 0x9c, 0x49, 0x72, 0x0d, 0x2e, 0x79, 0x1d, - 0xa4, 0xc2, 0x4d, 0xe2, 0x40, 0xbf, 0x2b, 0xfa, 0x72, 0xaf, 0x29, 0xed, 0x5a, 0x1c, 0xc8, 0xb7, - 0xc5, 0xfa, 0xb5, 0x08, 0xff, 0x3b, 0x52, 0x33, 0x72, 0x1f, 0x2e, 0xc8, 0xa7, 0x13, 0xb3, 0x76, - 0x68, 0x0d, 0xab, 0xcd, 0xe1, 0x27, 0xd6, 0x0e, 0x99, 0x9d, 0x3f, 0xac, 0x07, 0xc7, 0x59, 0xc6, - 0x24, 0x8a, 0xb7, 0xba, 0x48, 0xc5, 0x6a, 0xc1, 0xd1, 0x90, 0xe4, 0x01, 0x5c, 0x0e, 0xd4, 0xa9, - 0x95, 0xab, 0xb6, 0x53, 0x89, 0x55, 0x17, 0xde, 0x3a, 0x91, 0xbf, 0xa3, 0x5c, 0xad, 0x16, 0x9c, - 0xc9, 0xe0, 0x28, 0x7f, 0x6b, 0x30, 0xa1, 0xe9, 0x75, 0x53, 0x45, 0x56, 0x56, 0x99, 0xd7, 0x47, - 0xa8, 0x8c, 0x66, 0x77, 0xb5, 0xe0, 0xd4, 0xfc, 0x81, 0x75, 0x0b, 0xa0, 0xdc, 0xcd, 0x78, 0xb1, - 0x7e, 0x34, 0xa0, 0x7e, 0xbc, 0xbf, 0xcf, 0x33, 0x6f, 0xb7, 0xa0, 0x92, 0xa3, 0xe6, 0xf7, 0xff, - 0x9b, 0xa7, 0xe4, 0x78, 0x28, 0xac, 0x73, 0xe0, 0x6e, 0xfd, 0x64, 0xc0, 0x95, 0x4f, 0x91, 0x22, - 0xf3, 0x04, 0xca, 0xe7, 0x61, 0xdd, 0x67, 0x61, 0x22, 0x4e, 0x9d, 0x3b, 0xe3, 0xdf, 0x9e, 0xbb, - 0x57, 0x00, 0x92, 0x5e, 0xe4, 0x72, 0x15, 0x3e, 0x6b, 0xc5, 0x4a, 0xd2, 0xcb, 0xf2, 0xb1, 0xbe, - 0x81, 0xc6, 0xb0, 0x2c, 0xcf, 0xc3, 0x5e, 0x13, 0xaa, 0xea, 0x47, 0x62, 0x30, 0x54, 0xeb, 0x52, - 0x7f, 0x67, 0x06, 0x06, 0x90, 0x41, 0x9a, 0x68, 0x79, 0xe1, 0x49, 0x09, 0x2e, 0xe5, 0xb9, 0xea, - 0x5f, 0x4b, 0x82, 0x72, 0xaa, 0x14, 0xa7, 0xea, 0xda, 0x24, 0x27, 0xb7, 0xc8, 0xe0, 0x1b, 0xd4, - 0x98, 0x1f, 0xc5, 0x34, 0x3b, 0xd7, 0xb7, 0x30, 0x79, 0xb4, 0x63, 0xc8, 0xe2, 0x59, 0x2a, 0x9d, - 0x5f, 0xa0, 0x8d, 0x77, 0xcf, 0xe8, 0x95, 0x25, 0xf0, 0xbd, 0x01, 0xe4, 0x38, 0xef, 0xe4, 0xbd, - 0x13, 0xd1, 0x5e, 0xd8, 0x4e, 0x8d, 0xa5, 0x33, 0xfb, 0xe9, 0x3c, 0x5a, 0x1f, 0x6d, 0xef, 0x9a, - 0x85, 0x67, 0xbb, 0x66, 0xe1, 0xf9, 0xae, 0x69, 0x3c, 0xe9, 0x9b, 0xc6, 0x2f, 0x7d, 0xd3, 0xf8, - 0xa3, 0x6f, 0x1a, 0xdb, 0x7d, 0xd3, 0xf8, 0xb3, 0x6f, 0x1a, 0x7f, 0xf7, 0xcd, 0xc2, 0xf3, 0xbe, - 0x69, 0xfc, 0xb0, 0x67, 0x16, 0xb6, 0xf7, 0xcc, 0xc2, 0xb3, 0x3d, 0xb3, 0x70, 0xbf, 0xb2, 0x8f, - 0xdd, 0xbe, 0xa8, 0x7e, 0x9d, 0xaf, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, 0xa7, 0x05, 0x48, 0x4a, - 0x3a, 0x0c, 0x00, 0x00, + // 1205 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x57, 0x5b, 0x6f, 0x1b, 0xc5, + 0x17, 0xf7, 0xda, 0xb9, 0xd8, 0xc7, 0x4e, 0xff, 0xee, 0xb4, 0x7f, 0x70, 0xb7, 0x62, 0x5b, 0xad, + 0x0a, 0x0a, 0x01, 0xd6, 0x90, 0xa6, 0x04, 0x55, 0x02, 0x84, 0x93, 0x40, 0xa8, 0x4a, 0x09, 0x9b, + 0xb4, 0x0f, 0x55, 0xc5, 0x6a, 0xbd, 0x3b, 0x71, 0x56, 0x5d, 0xef, 0x6c, 0x67, 0x66, 0x8b, 0xc3, + 0x0b, 0x2d, 0x12, 0xef, 0x48, 0x7c, 0x05, 0x84, 0xb8, 0x7c, 0x11, 0x9e, 0x50, 0x1e, 0xfb, 0x14, + 0x11, 0x47, 0x42, 0x3c, 0xf6, 0x23, 0xa0, 0xb9, 0x6c, 0xe2, 0x24, 0x6e, 0xe2, 0x44, 0x3c, 0xf2, + 0xe4, 0x73, 0xfd, 0x9d, 0x33, 0xe7, 0x9c, 0x39, 0xb3, 0x86, 0x19, 0x46, 0x83, 0x66, 0xe0, 0xd3, + 0x84, 0xf0, 0x66, 0x1a, 0xfb, 0x49, 0x82, 0x69, 0xfe, 0x9b, 0xb6, 0x9b, 0x0c, 0xd3, 0xc7, 0x51, + 0x80, 0x9d, 0x94, 0x12, 0x4e, 0xd0, 0xe5, 0xb4, 0xe7, 0x28, 0x53, 0x47, 0x9b, 0x38, 0x7b, 0xa6, + 0xe6, 0xfb, 0x43, 0x80, 0xc2, 0xcd, 0xc4, 0xef, 0x46, 0x81, 0xc7, 0xa9, 0x1f, 0x44, 0x49, 0xa7, + 0x19, 0xd1, 0x66, 0x4c, 0x3a, 0x51, 0xe0, 0xc7, 0x69, 0x3b, 0xa7, 0x14, 0xb6, 0xf9, 0xaa, 0x74, + 0x27, 0xdd, 0x2e, 0x49, 0x9a, 0x6d, 0x9f, 0xe1, 0x26, 0xe3, 0x3e, 0xcf, 0x98, 0xc8, 0x41, 0x12, + 0xda, 0xec, 0x62, 0x87, 0x74, 0x88, 0x24, 0x9b, 0x82, 0xd2, 0xd2, 0xf9, 0x61, 0xb1, 0x23, 0xc6, + 0x69, 0xd4, 0xce, 0x38, 0x0e, 0xd3, 0xf6, 0x20, 0xe7, 0x09, 0x0b, 0xe5, 0x68, 0xff, 0x65, 0xc0, + 0xd4, 0xc7, 0x59, 0x12, 0xac, 0x91, 0xa5, 0x1e, 0x0e, 0x32, 0x8e, 0xd1, 0x65, 0xa8, 0xac, 0x67, + 0x49, 0xe0, 0x25, 0x7e, 0x17, 0x37, 0x8c, 0xab, 0xc6, 0x74, 0xc5, 0x2d, 0x0b, 0xc1, 0x1d, 0xbf, + 0x8b, 0x91, 0x0b, 0xe0, 0xd3, 0x8e, 0xf7, 0xd8, 0x8f, 0x33, 0xcc, 0x1a, 0xc5, 0xab, 0xa5, 0xe9, + 0xea, 0xec, 0x75, 0xe7, 0x98, 0xaa, 0x38, 0x07, 0xc0, 0x9d, 0x8f, 0x68, 0xe7, 0x9e, 0xf0, 0x75, + 0x2b, 0xbe, 0xa6, 0x18, 0x72, 0xe0, 0x02, 0xc9, 0x78, 0x9a, 0x71, 0x8f, 0xfb, 0xed, 0x18, 0x7b, + 0x29, 0xc5, 0xeb, 0x51, 0xaf, 0x51, 0x92, 0xa1, 0xcf, 0x2b, 0xd5, 0x9a, 0xd0, 0xac, 0x48, 0x85, + 0x39, 0x07, 0xe5, 0x1c, 0x06, 0x21, 0x18, 0x1b, 0xc8, 0x53, 0xd2, 0xe8, 0x22, 0x8c, 0xcb, 0xfc, + 0x1a, 0x45, 0x29, 0x54, 0x8c, 0xfd, 0xc7, 0x04, 0x4c, 0x2e, 0x90, 0x64, 0x3d, 0xea, 0x30, 0xf4, + 0xd4, 0x80, 0x8b, 0x84, 0xe3, 0xd8, 0xc3, 0x49, 0x98, 0x92, 0x28, 0xe1, 0x5e, 0x20, 0x35, 0x12, + 0xa6, 0x3a, 0x3b, 0x7f, 0xec, 0x81, 0x34, 0x88, 0xf3, 0xf9, 0x1a, 0x8e, 0x97, 0xb4, 0xbf, 0x92, + 0xb5, 0x5e, 0xea, 0x6f, 0x5f, 0x41, 0x47, 0xe5, 0x2e, 0x12, 0xc1, 0x0e, 0xca, 0xd0, 0x3d, 0x98, + 0x4a, 0xe3, 0xac, 0x13, 0x25, 0x79, 0xec, 0xa2, 0x8c, 0xfd, 0xce, 0x48, 0xb1, 0x57, 0xa4, 0xa7, + 0x46, 0xaf, 0xa5, 0x03, 0x1c, 0x6a, 0xc3, 0xf9, 0x20, 0x8e, 0x82, 0x87, 0x1b, 0x24, 0x63, 0x38, + 0xc7, 0x2e, 0x49, 0xec, 0x1b, 0x23, 0x61, 0x2f, 0x08, 0xef, 0x65, 0xe1, 0xad, 0xf1, 0xeb, 0xfb, + 0x78, 0x4a, 0x62, 0x3e, 0x2d, 0xc2, 0x90, 0x63, 0xa2, 0x4b, 0x50, 0xca, 0x68, 0xac, 0x7a, 0xd1, + 0x9a, 0xec, 0x6f, 0x5f, 0x29, 0xdd, 0x75, 0x6f, 0xbb, 0x42, 0x86, 0xbe, 0x84, 0xc9, 0x0d, 0xec, + 0x87, 0x98, 0xe6, 0x43, 0xb3, 0x78, 0xc6, 0x1a, 0x3b, 0xcb, 0x0a, 0x66, 0x29, 0xe1, 0x74, 0xd3, + 0xcd, 0x41, 0x91, 0x09, 0xe5, 0x28, 0x61, 0x38, 0xc8, 0x28, 0x96, 0x87, 0x2d, 0xbb, 0x7b, 0x3c, + 0x6a, 0xc0, 0x24, 0x8f, 0xba, 0x98, 0x64, 0xbc, 0x31, 0x76, 0xd5, 0x98, 0x2e, 0xb9, 0x39, 0x6b, + 0xde, 0x84, 0xda, 0x20, 0x1c, 0xaa, 0x43, 0xe9, 0x21, 0xde, 0xd4, 0xc3, 0x24, 0xc8, 0xe1, 0xb3, + 0x74, 0xb3, 0xf8, 0x9e, 0x61, 0xba, 0x50, 0x1b, 0xec, 0x02, 0xb2, 0x61, 0x8a, 0x71, 0x9f, 0x72, + 0x4f, 0x80, 0x7b, 0x09, 0x93, 0x28, 0x25, 0xb7, 0x2a, 0x85, 0x6b, 0x51, 0x17, 0xdf, 0x61, 0xc8, + 0x82, 0x2a, 0x4e, 0xc2, 0x3d, 0x8b, 0xa2, 0xb4, 0xa8, 0xe0, 0x24, 0x54, 0x7a, 0xf3, 0x57, 0x03, + 0xea, 0x87, 0xcb, 0x2f, 0x8e, 0xb6, 0x41, 0x18, 0x1f, 0xbc, 0x8e, 0x39, 0x2f, 0xc6, 0x5f, 0xd0, + 0x3a, 0x3b, 0x49, 0x0b, 0x59, 0x4a, 0x28, 0x97, 0x65, 0x18, 0x77, 0x25, 0x2d, 0x30, 0x32, 0x86, + 0xa9, 0xc4, 0x18, 0x53, 0x18, 0x39, 0x2f, 0x74, 0xa9, 0xcf, 0xd8, 0x57, 0x84, 0x86, 0x8d, 0x71, + 0xa5, 0xcb, 0x79, 0xa1, 0x0b, 0x7d, 0xee, 0x8b, 0x75, 0xd4, 0x98, 0x50, 0xba, 0x9c, 0xb7, 0x7f, + 0x2a, 0x42, 0xed, 0x8b, 0x0c, 0xd3, 0x4d, 0x17, 0x3f, 0xca, 0x30, 0xe3, 0x68, 0x03, 0xfe, 0xaf, + 0x37, 0x9a, 0xa7, 0x3b, 0xe9, 0x89, 0xcd, 0x85, 0x25, 0x6a, 0x75, 0x76, 0x6e, 0x48, 0xc7, 0x0f, + 0xac, 0x28, 0xe7, 0xb6, 0xf2, 0x5e, 0x51, 0xca, 0x55, 0xe1, 0xeb, 0x5e, 0x88, 0x8f, 0x0a, 0xc5, + 0x8a, 0x7a, 0x24, 0x22, 0x7b, 0x8c, 0xd3, 0xbc, 0x26, 0x52, 0xb0, 0xca, 0x29, 0xfa, 0x14, 0x00, + 0xf7, 0x70, 0xe0, 0x89, 0x9d, 0xc5, 0x1a, 0x25, 0x39, 0x6d, 0x33, 0xa3, 0xaf, 0x28, 0xb7, 0x22, + 0xbc, 0x85, 0x88, 0xa1, 0x0f, 0x60, 0x52, 0x5d, 0x20, 0x26, 0xab, 0x56, 0x9d, 0xbd, 0x36, 0xca, + 0xd4, 0xba, 0xb9, 0xd3, 0xad, 0xb1, 0x72, 0xb1, 0x5e, 0xb2, 0xbf, 0x35, 0x60, 0x4a, 0x17, 0x8a, + 0xa5, 0x24, 0x61, 0x18, 0xbd, 0x01, 0x13, 0x6a, 0xa7, 0xeb, 0x85, 0x73, 0x41, 0xc0, 0xe6, 0xeb, + 0xde, 0x59, 0x95, 0x84, 0xab, 0x4d, 0xd0, 0x22, 0x8c, 0x89, 0x10, 0x7a, 0x3f, 0xbc, 0x7d, 0x62, + 0x15, 0x17, 0xf7, 0x39, 0x51, 0x34, 0x57, 0x7a, 0xdb, 0xbf, 0x15, 0xe1, 0xe5, 0x05, 0xd2, 0x4d, + 0xa3, 0x18, 0x7f, 0x96, 0x71, 0x9f, 0x47, 0x24, 0x61, 0xff, 0x35, 0xee, 0x05, 0x8d, 0xb3, 0x5f, + 0x83, 0xfa, 0x22, 0x8e, 0x31, 0xc7, 0x6b, 0xd4, 0x0f, 0xb0, 0x5c, 0x3f, 0xc3, 0x9e, 0x1a, 0xfb, + 0x01, 0xd4, 0x94, 0xef, 0xdd, 0x34, 0x14, 0xe7, 0x1b, 0x71, 0x81, 0xa0, 0x6b, 0x70, 0xce, 0xef, + 0xe0, 0x84, 0x7b, 0x29, 0x09, 0xd5, 0x43, 0xab, 0x5e, 0xbb, 0x9a, 0x94, 0xae, 0x90, 0x50, 0x3c, + 0xb6, 0xf6, 0x2f, 0x45, 0xf8, 0xdf, 0xa1, 0x9e, 0xa1, 0xfb, 0x30, 0x2e, 0xbe, 0x25, 0xb0, 0x1e, + 0x87, 0xd6, 0xb0, 0xde, 0x1c, 0xfc, 0xe6, 0x70, 0x22, 0xea, 0xe4, 0x5f, 0x1a, 0xfb, 0xc7, 0x59, + 0xc4, 0x69, 0x4c, 0x36, 0xbb, 0x38, 0xe1, 0xcb, 0x05, 0x57, 0x41, 0xa2, 0x07, 0x70, 0x3e, 0x94, + 0xa7, 0x96, 0xae, 0xca, 0x4e, 0x3f, 0x1d, 0x6f, 0x1d, 0x5b, 0xbf, 0xc3, 0xb5, 0x5a, 0x2e, 0xb8, + 0xf5, 0xf0, 0x70, 0xfd, 0x56, 0x60, 0x4a, 0x95, 0xd7, 0xcb, 0x64, 0xb1, 0x74, 0x67, 0x5e, 0x1f, + 0xa1, 0x33, 0xaa, 0xba, 0xcb, 0x05, 0xb7, 0x16, 0x0c, 0xf0, 0x2d, 0x80, 0x72, 0x57, 0xd7, 0xc5, + 0xfe, 0xc1, 0x80, 0xc6, 0xd1, 0xf9, 0x3e, 0xcb, 0x7d, 0xbb, 0x05, 0x95, 0x1c, 0x35, 0x7f, 0xac, + 0xde, 0x3c, 0x21, 0xc7, 0x03, 0x61, 0xdd, 0x7d, 0x77, 0xfb, 0x47, 0x03, 0x2e, 0x7d, 0x82, 0x13, + 0x4c, 0x7d, 0x8e, 0xc5, 0x5b, 0xb6, 0x1a, 0xd0, 0x28, 0xe5, 0x27, 0xde, 0x3b, 0xe3, 0xdf, 0xbe, + 0x77, 0xaf, 0x00, 0xa4, 0xbd, 0xd8, 0x63, 0x32, 0xbc, 0x1e, 0xc5, 0x4a, 0xda, 0xd3, 0xf9, 0xd8, + 0x5f, 0x83, 0x39, 0x2c, 0xcb, 0xb3, 0x54, 0xaf, 0x09, 0x55, 0xf9, 0x65, 0x35, 0x18, 0xaa, 0x75, + 0xae, 0xbf, 0x7d, 0x05, 0x06, 0x90, 0x41, 0x98, 0x28, 0x7a, 0xf6, 0x49, 0x09, 0xce, 0xe5, 0xb9, + 0xaa, 0x6f, 0x6d, 0x84, 0xc5, 0xad, 0x92, 0x35, 0x95, 0x6b, 0x13, 0x1d, 0x3f, 0x22, 0x83, 0x6f, + 0x90, 0x39, 0x33, 0x8a, 0xa9, 0x3e, 0xd7, 0x37, 0x50, 0x3f, 0x3c, 0x31, 0x68, 0xee, 0x34, 0x9d, + 0xce, 0x17, 0xa8, 0x79, 0xe3, 0x94, 0x5e, 0x3a, 0x81, 0xef, 0x0c, 0x40, 0x47, 0xeb, 0x8e, 0xde, + 0x3d, 0x16, 0xed, 0x85, 0xe3, 0x64, 0xce, 0x9f, 0xda, 0x4f, 0xe5, 0xd1, 0xfa, 0x70, 0x6b, 0xc7, + 0x2a, 0x3c, 0xdb, 0xb1, 0x0a, 0xcf, 0x77, 0x2c, 0xe3, 0x49, 0xdf, 0x32, 0x7e, 0xee, 0x5b, 0xc6, + 0xef, 0x7d, 0xcb, 0xd8, 0xea, 0x5b, 0xc6, 0x9f, 0x7d, 0xcb, 0xf8, 0xbb, 0x6f, 0x15, 0x9e, 0xf7, + 0x2d, 0xe3, 0xfb, 0x5d, 0xab, 0xb0, 0xb5, 0x6b, 0x15, 0x9e, 0xed, 0x5a, 0x85, 0xfb, 0x95, 0x3d, + 0xec, 0xf6, 0x84, 0xfc, 0x2f, 0x71, 0xfd, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8b, 0xee, 0x54, + 0x71, 0x4b, 0x0d, 0x00, 0x00, } func (this *FuncToExecute) Equal(that interface{}) bool { @@ -1033,6 +1131,9 @@ func (this *Configs) Equal(that interface{}) bool { if !this.PluginConfig.Equal(that1.PluginConfig) { return false } + if !this.ClickhouseConfig.Equal(that1.ClickhouseConfig) { + return false + } return true } func (this *Configs_OTelEndpointConfig) Equal(that interface{}) bool { @@ -1100,6 +1201,45 @@ func (this *Configs_PluginConfig) Equal(that interface{}) bool { } return true } +func (this *Configs_ClickHouseConfig) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*Configs_ClickHouseConfig) + if !ok { + that2, ok := that.(Configs_ClickHouseConfig) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Hostname != that1.Hostname { + return false + } + if this.Host != that1.Host { + return false + } + if this.Port != that1.Port { + return false + } + if this.Username != that1.Username { + return false + } + if this.Password != that1.Password { + return false + } + if this.Database != that1.Database { + return false + } + return true +} func (this *QueryRequest) Equal(that interface{}) bool { if that == nil { return this == nil @@ -1474,7 +1614,7 @@ func (this *Configs) GoString() string { if this == nil { return "nil" } - s := make([]string, 0, 6) + s := make([]string, 0, 7) s = append(s, "&plannerpb.Configs{") if this.OTelEndpointConfig != nil { s = append(s, "OTelEndpointConfig: "+fmt.Sprintf("%#v", this.OTelEndpointConfig)+",\n") @@ -1482,6 +1622,9 @@ func (this *Configs) GoString() string { if this.PluginConfig != nil { s = append(s, "PluginConfig: "+fmt.Sprintf("%#v", this.PluginConfig)+",\n") } + if this.ClickhouseConfig != nil { + s = append(s, "ClickhouseConfig: "+fmt.Sprintf("%#v", this.ClickhouseConfig)+",\n") + } s = append(s, "}") return strings.Join(s, "") } @@ -1521,6 +1664,21 @@ func (this *Configs_PluginConfig) GoString() string { s = append(s, "}") return strings.Join(s, "") } +func (this *Configs_ClickHouseConfig) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 10) + s = append(s, "&plannerpb.Configs_ClickHouseConfig{") + s = append(s, "Hostname: "+fmt.Sprintf("%#v", this.Hostname)+",\n") + s = append(s, "Host: "+fmt.Sprintf("%#v", this.Host)+",\n") + s = append(s, "Port: "+fmt.Sprintf("%#v", this.Port)+",\n") + s = append(s, "Username: "+fmt.Sprintf("%#v", this.Username)+",\n") + s = append(s, "Password: "+fmt.Sprintf("%#v", this.Password)+",\n") + s = append(s, "Database: "+fmt.Sprintf("%#v", this.Database)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} func (this *QueryRequest) GoString() string { if this == nil { return "nil" @@ -1942,6 +2100,18 @@ func (m *Configs) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.ClickhouseConfig != nil { + { + size, err := m.ClickhouseConfig.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintService(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } if m.PluginConfig != nil { { size, err := m.PluginConfig.MarshalToSizedBuffer(dAtA[:i]) @@ -2066,6 +2236,69 @@ func (m *Configs_PluginConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *Configs_ClickHouseConfig) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Configs_ClickHouseConfig) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Configs_ClickHouseConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Database) > 0 { + i -= len(m.Database) + copy(dAtA[i:], m.Database) + i = encodeVarintService(dAtA, i, uint64(len(m.Database))) + i-- + dAtA[i] = 0x32 + } + if len(m.Password) > 0 { + i -= len(m.Password) + copy(dAtA[i:], m.Password) + i = encodeVarintService(dAtA, i, uint64(len(m.Password))) + i-- + dAtA[i] = 0x2a + } + if len(m.Username) > 0 { + i -= len(m.Username) + copy(dAtA[i:], m.Username) + i = encodeVarintService(dAtA, i, uint64(len(m.Username))) + i-- + dAtA[i] = 0x22 + } + if m.Port != 0 { + i = encodeVarintService(dAtA, i, uint64(m.Port)) + i-- + dAtA[i] = 0x18 + } + if len(m.Host) > 0 { + i -= len(m.Host) + copy(dAtA[i:], m.Host) + i = encodeVarintService(dAtA, i, uint64(len(m.Host))) + i-- + dAtA[i] = 0x12 + } + if len(m.Hostname) > 0 { + i -= len(m.Hostname) + copy(dAtA[i:], m.Hostname) + i = encodeVarintService(dAtA, i, uint64(len(m.Hostname))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *QueryRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -2616,6 +2849,10 @@ func (m *Configs) Size() (n int) { l = m.PluginConfig.Size() n += 1 + l + sovService(uint64(l)) } + if m.ClickhouseConfig != nil { + l = m.ClickhouseConfig.Size() + n += 1 + l + sovService(uint64(l)) + } return n } @@ -2661,6 +2898,38 @@ func (m *Configs_PluginConfig) Size() (n int) { return n } +func (m *Configs_ClickHouseConfig) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Hostname) + if l > 0 { + n += 1 + l + sovService(uint64(l)) + } + l = len(m.Host) + if l > 0 { + n += 1 + l + sovService(uint64(l)) + } + if m.Port != 0 { + n += 1 + sovService(uint64(m.Port)) + } + l = len(m.Username) + if l > 0 { + n += 1 + l + sovService(uint64(l)) + } + l = len(m.Password) + if l > 0 { + n += 1 + l + sovService(uint64(l)) + } + l = len(m.Database) + if l > 0 { + n += 1 + l + sovService(uint64(l)) + } + return n +} + func (m *QueryRequest) Size() (n int) { if m == nil { return 0 @@ -2908,6 +3177,7 @@ func (this *Configs) String() string { s := strings.Join([]string{`&Configs{`, `OTelEndpointConfig:` + strings.Replace(fmt.Sprintf("%v", this.OTelEndpointConfig), "Configs_OTelEndpointConfig", "Configs_OTelEndpointConfig", 1) + `,`, `PluginConfig:` + strings.Replace(fmt.Sprintf("%v", this.PluginConfig), "Configs_PluginConfig", "Configs_PluginConfig", 1) + `,`, + `ClickhouseConfig:` + strings.Replace(fmt.Sprintf("%v", this.ClickhouseConfig), "Configs_ClickHouseConfig", "Configs_ClickHouseConfig", 1) + `,`, `}`, }, "") return s @@ -2946,6 +3216,21 @@ func (this *Configs_PluginConfig) String() string { }, "") return s } +func (this *Configs_ClickHouseConfig) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Configs_ClickHouseConfig{`, + `Hostname:` + fmt.Sprintf("%v", this.Hostname) + `,`, + `Host:` + fmt.Sprintf("%v", this.Host) + `,`, + `Port:` + fmt.Sprintf("%v", this.Port) + `,`, + `Username:` + fmt.Sprintf("%v", this.Username) + `,`, + `Password:` + fmt.Sprintf("%v", this.Password) + `,`, + `Database:` + fmt.Sprintf("%v", this.Database) + `,`, + `}`, + }, "") + return s +} func (this *QueryRequest) String() string { if this == nil { return "nil" @@ -3464,6 +3749,42 @@ func (m *Configs) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClickhouseConfig", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthService + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ClickhouseConfig == nil { + m.ClickhouseConfig = &Configs_ClickHouseConfig{} + } + if err := m.ClickhouseConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipService(dAtA[iNdEx:]) @@ -3821,6 +4142,235 @@ func (m *Configs_PluginConfig) Unmarshal(dAtA []byte) error { } return nil } +func (m *Configs_ClickHouseConfig) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ClickHouseConfig: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClickHouseConfig: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthService + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hostname = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthService + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Host = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) + } + m.Port = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Port |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthService + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Username = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthService + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Password = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Database", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthService + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Database = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipService(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthService + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *QueryRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/src/carnot/planner/plannerpb/service.proto b/src/carnot/planner/plannerpb/service.proto index a9b33d825f8..4c3fd9a99a8 100644 --- a/src/carnot/planner/plannerpb/service.proto +++ b/src/carnot/planner/plannerpb/service.proto @@ -75,6 +75,22 @@ message Configs { int64 end_time_ns = 2; } PluginConfig plugin_config = 2; + // ClickHouseConfig contains information about ClickHouse connection parameters. + message ClickHouseConfig { + // The hostname of the node executing the query. + string hostname = 1; + // The ClickHouse server host. + string host = 2; + // The ClickHouse server port. + int32 port = 3; + // The ClickHouse username. + string username = 4; + // The ClickHouse password. + string password = 5; + // The ClickHouse database name. + string database = 6; + } + ClickHouseConfig clickhouse_config = 3; } // QueryRequest is the body of the request made to the planner. diff --git a/src/carnot/planpb/plan.pb.go b/src/carnot/planpb/plan.pb.go index ce6671091c1..bb5a6584aea 100755 --- a/src/carnot/planpb/plan.pb.go +++ b/src/carnot/planpb/plan.pb.go @@ -34,20 +34,22 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type OperatorType int32 const ( - OPERATOR_TYPE_UNKNOWN OperatorType = 0 - MEMORY_SOURCE_OPERATOR OperatorType = 1000 - GRPC_SOURCE_OPERATOR OperatorType = 1100 - UDTF_SOURCE_OPERATOR OperatorType = 1200 - EMPTY_SOURCE_OPERATOR OperatorType = 1300 - MAP_OPERATOR OperatorType = 2000 - AGGREGATE_OPERATOR OperatorType = 2100 - FILTER_OPERATOR OperatorType = 2200 - LIMIT_OPERATOR OperatorType = 2300 - UNION_OPERATOR OperatorType = 2400 - JOIN_OPERATOR OperatorType = 2500 - MEMORY_SINK_OPERATOR OperatorType = 9000 - GRPC_SINK_OPERATOR OperatorType = 9100 - OTEL_EXPORT_SINK_OPERATOR OperatorType = 9200 + OPERATOR_TYPE_UNKNOWN OperatorType = 0 + MEMORY_SOURCE_OPERATOR OperatorType = 1000 + GRPC_SOURCE_OPERATOR OperatorType = 1100 + UDTF_SOURCE_OPERATOR OperatorType = 1200 + EMPTY_SOURCE_OPERATOR OperatorType = 1300 + CLICKHOUSE_SOURCE_OPERATOR OperatorType = 1400 + MAP_OPERATOR OperatorType = 2000 + AGGREGATE_OPERATOR OperatorType = 2100 + FILTER_OPERATOR OperatorType = 2200 + LIMIT_OPERATOR OperatorType = 2300 + UNION_OPERATOR OperatorType = 2400 + JOIN_OPERATOR OperatorType = 2500 + MEMORY_SINK_OPERATOR OperatorType = 9000 + GRPC_SINK_OPERATOR OperatorType = 9100 + OTEL_EXPORT_SINK_OPERATOR OperatorType = 9200 + CLICKHOUSE_EXPORT_SINK_OPERATOR OperatorType = 9300 ) var OperatorType_name = map[int32]string{ @@ -56,6 +58,7 @@ var OperatorType_name = map[int32]string{ 1100: "GRPC_SOURCE_OPERATOR", 1200: "UDTF_SOURCE_OPERATOR", 1300: "EMPTY_SOURCE_OPERATOR", + 1400: "CLICKHOUSE_SOURCE_OPERATOR", 2000: "MAP_OPERATOR", 2100: "AGGREGATE_OPERATOR", 2200: "FILTER_OPERATOR", @@ -65,23 +68,26 @@ var OperatorType_name = map[int32]string{ 9000: "MEMORY_SINK_OPERATOR", 9100: "GRPC_SINK_OPERATOR", 9200: "OTEL_EXPORT_SINK_OPERATOR", + 9300: "CLICKHOUSE_EXPORT_SINK_OPERATOR", } var OperatorType_value = map[string]int32{ - "OPERATOR_TYPE_UNKNOWN": 0, - "MEMORY_SOURCE_OPERATOR": 1000, - "GRPC_SOURCE_OPERATOR": 1100, - "UDTF_SOURCE_OPERATOR": 1200, - "EMPTY_SOURCE_OPERATOR": 1300, - "MAP_OPERATOR": 2000, - "AGGREGATE_OPERATOR": 2100, - "FILTER_OPERATOR": 2200, - "LIMIT_OPERATOR": 2300, - "UNION_OPERATOR": 2400, - "JOIN_OPERATOR": 2500, - "MEMORY_SINK_OPERATOR": 9000, - "GRPC_SINK_OPERATOR": 9100, - "OTEL_EXPORT_SINK_OPERATOR": 9200, + "OPERATOR_TYPE_UNKNOWN": 0, + "MEMORY_SOURCE_OPERATOR": 1000, + "GRPC_SOURCE_OPERATOR": 1100, + "UDTF_SOURCE_OPERATOR": 1200, + "EMPTY_SOURCE_OPERATOR": 1300, + "CLICKHOUSE_SOURCE_OPERATOR": 1400, + "MAP_OPERATOR": 2000, + "AGGREGATE_OPERATOR": 2100, + "FILTER_OPERATOR": 2200, + "LIMIT_OPERATOR": 2300, + "UNION_OPERATOR": 2400, + "JOIN_OPERATOR": 2500, + "MEMORY_SINK_OPERATOR": 9000, + "GRPC_SINK_OPERATOR": 9100, + "OTEL_EXPORT_SINK_OPERATOR": 9200, + "CLICKHOUSE_EXPORT_SINK_OPERATOR": 9300, } func (OperatorType) EnumDescriptor() ([]byte, []int) { @@ -526,6 +532,8 @@ type Operator struct { // *Operator_UdtfSourceOp // *Operator_EmptySourceOp // *Operator_OTelSinkOp + // *Operator_ClickhouseSourceOp + // *Operator_ClickhouseSinkOp Op isOperator_Op `protobuf_oneof:"op"` } @@ -607,20 +615,28 @@ type Operator_EmptySourceOp struct { type Operator_OTelSinkOp struct { OTelSinkOp *OTelExportSinkOperator `protobuf:"bytes,14,opt,name=otel_sink_op,json=otelSinkOp,proto3,oneof" json:"otel_sink_op,omitempty"` } - -func (*Operator_MemSourceOp) isOperator_Op() {} -func (*Operator_MapOp) isOperator_Op() {} -func (*Operator_AggOp) isOperator_Op() {} -func (*Operator_MemSinkOp) isOperator_Op() {} -func (*Operator_FilterOp) isOperator_Op() {} -func (*Operator_LimitOp) isOperator_Op() {} -func (*Operator_UnionOp) isOperator_Op() {} -func (*Operator_GRPCSourceOp) isOperator_Op() {} -func (*Operator_GRPCSinkOp) isOperator_Op() {} -func (*Operator_JoinOp) isOperator_Op() {} -func (*Operator_UdtfSourceOp) isOperator_Op() {} -func (*Operator_EmptySourceOp) isOperator_Op() {} -func (*Operator_OTelSinkOp) isOperator_Op() {} +type Operator_ClickhouseSourceOp struct { + ClickhouseSourceOp *ClickHouseSourceOperator `protobuf:"bytes,15,opt,name=clickhouse_source_op,json=clickhouseSourceOp,proto3,oneof" json:"clickhouse_source_op,omitempty"` +} +type Operator_ClickhouseSinkOp struct { + ClickhouseSinkOp *ClickHouseExportSinkOperator `protobuf:"bytes,16,opt,name=clickhouse_sink_op,json=clickhouseSinkOp,proto3,oneof" json:"clickhouse_sink_op,omitempty"` +} + +func (*Operator_MemSourceOp) isOperator_Op() {} +func (*Operator_MapOp) isOperator_Op() {} +func (*Operator_AggOp) isOperator_Op() {} +func (*Operator_MemSinkOp) isOperator_Op() {} +func (*Operator_FilterOp) isOperator_Op() {} +func (*Operator_LimitOp) isOperator_Op() {} +func (*Operator_UnionOp) isOperator_Op() {} +func (*Operator_GRPCSourceOp) isOperator_Op() {} +func (*Operator_GRPCSinkOp) isOperator_Op() {} +func (*Operator_JoinOp) isOperator_Op() {} +func (*Operator_UdtfSourceOp) isOperator_Op() {} +func (*Operator_EmptySourceOp) isOperator_Op() {} +func (*Operator_OTelSinkOp) isOperator_Op() {} +func (*Operator_ClickhouseSourceOp) isOperator_Op() {} +func (*Operator_ClickhouseSinkOp) isOperator_Op() {} func (m *Operator) GetOp() isOperator_Op { if m != nil { @@ -727,6 +743,20 @@ func (m *Operator) GetOTelSinkOp() *OTelExportSinkOperator { return nil } +func (m *Operator) GetClickhouseSourceOp() *ClickHouseSourceOperator { + if x, ok := m.GetOp().(*Operator_ClickhouseSourceOp); ok { + return x.ClickhouseSourceOp + } + return nil +} + +func (m *Operator) GetClickhouseSinkOp() *ClickHouseExportSinkOperator { + if x, ok := m.GetOp().(*Operator_ClickhouseSinkOp); ok { + return x.ClickhouseSinkOp + } + return nil +} + // XXX_OneofWrappers is for the internal use of the proto package. func (*Operator) XXX_OneofWrappers() []interface{} { return []interface{}{ @@ -743,6 +773,8 @@ func (*Operator) XXX_OneofWrappers() []interface{} { (*Operator_UdtfSourceOp)(nil), (*Operator_EmptySourceOp)(nil), (*Operator_OTelSinkOp)(nil), + (*Operator_ClickhouseSourceOp)(nil), + (*Operator_ClickhouseSinkOp)(nil), } } @@ -1810,6 +1842,153 @@ func (m *EmptySourceOperator) GetColumnTypes() []typespb.DataType { return nil } +type ClickHouseSourceOperator struct { + Host string `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"` + Port int32 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"` + Username string `protobuf:"bytes,3,opt,name=username,proto3" json:"username,omitempty"` + Password string `protobuf:"bytes,4,opt,name=password,proto3" json:"password,omitempty"` + Database string `protobuf:"bytes,5,opt,name=database,proto3" json:"database,omitempty"` + Query string `protobuf:"bytes,6,opt,name=query,proto3" json:"query,omitempty"` + ColumnNames []string `protobuf:"bytes,7,rep,name=column_names,json=columnNames,proto3" json:"column_names,omitempty"` + ColumnTypes []typespb.DataType `protobuf:"varint,8,rep,packed,name=column_types,json=columnTypes,proto3,enum=px.types.DataType" json:"column_types,omitempty"` + BatchSize int32 `protobuf:"varint,9,opt,name=batch_size,json=batchSize,proto3" json:"batch_size,omitempty"` + Streaming bool `protobuf:"varint,10,opt,name=streaming,proto3" json:"streaming,omitempty"` + TimestampColumn string `protobuf:"bytes,11,opt,name=timestamp_column,json=timestampColumn,proto3" json:"timestamp_column,omitempty"` + PartitionColumn string `protobuf:"bytes,12,opt,name=partition_column,json=partitionColumn,proto3" json:"partition_column,omitempty"` + StartTime int64 `protobuf:"varint,13,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + EndTime int64 `protobuf:"varint,14,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"` +} + +func (m *ClickHouseSourceOperator) Reset() { *m = ClickHouseSourceOperator{} } +func (*ClickHouseSourceOperator) ProtoMessage() {} +func (*ClickHouseSourceOperator) Descriptor() ([]byte, []int) { + return fileDescriptor_e5dcfc8666ec3f33, []int{18} +} +func (m *ClickHouseSourceOperator) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ClickHouseSourceOperator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ClickHouseSourceOperator.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ClickHouseSourceOperator) XXX_Merge(src proto.Message) { + xxx_messageInfo_ClickHouseSourceOperator.Merge(m, src) +} +func (m *ClickHouseSourceOperator) XXX_Size() int { + return m.Size() +} +func (m *ClickHouseSourceOperator) XXX_DiscardUnknown() { + xxx_messageInfo_ClickHouseSourceOperator.DiscardUnknown(m) +} + +var xxx_messageInfo_ClickHouseSourceOperator proto.InternalMessageInfo + +func (m *ClickHouseSourceOperator) GetHost() string { + if m != nil { + return m.Host + } + return "" +} + +func (m *ClickHouseSourceOperator) GetPort() int32 { + if m != nil { + return m.Port + } + return 0 +} + +func (m *ClickHouseSourceOperator) GetUsername() string { + if m != nil { + return m.Username + } + return "" +} + +func (m *ClickHouseSourceOperator) GetPassword() string { + if m != nil { + return m.Password + } + return "" +} + +func (m *ClickHouseSourceOperator) GetDatabase() string { + if m != nil { + return m.Database + } + return "" +} + +func (m *ClickHouseSourceOperator) GetQuery() string { + if m != nil { + return m.Query + } + return "" +} + +func (m *ClickHouseSourceOperator) GetColumnNames() []string { + if m != nil { + return m.ColumnNames + } + return nil +} + +func (m *ClickHouseSourceOperator) GetColumnTypes() []typespb.DataType { + if m != nil { + return m.ColumnTypes + } + return nil +} + +func (m *ClickHouseSourceOperator) GetBatchSize() int32 { + if m != nil { + return m.BatchSize + } + return 0 +} + +func (m *ClickHouseSourceOperator) GetStreaming() bool { + if m != nil { + return m.Streaming + } + return false +} + +func (m *ClickHouseSourceOperator) GetTimestampColumn() string { + if m != nil { + return m.TimestampColumn + } + return "" +} + +func (m *ClickHouseSourceOperator) GetPartitionColumn() string { + if m != nil { + return m.PartitionColumn + } + return "" +} + +func (m *ClickHouseSourceOperator) GetStartTime() int64 { + if m != nil { + return m.StartTime + } + return 0 +} + +func (m *ClickHouseSourceOperator) GetEndTime() int64 { + if m != nil { + return m.EndTime + } + return 0 +} + type OTelLog struct { Attributes []*OTelAttribute `protobuf:"bytes,1,rep,name=attributes,proto3" json:"attributes,omitempty"` TimeColumnIndex int64 `protobuf:"varint,2,opt,name=time_column_index,json=timeColumnIndex,proto3" json:"time_column_index,omitempty"` @@ -1822,7 +2001,7 @@ type OTelLog struct { func (m *OTelLog) Reset() { *m = OTelLog{} } func (*OTelLog) ProtoMessage() {} func (*OTelLog) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{18} + return fileDescriptor_e5dcfc8666ec3f33, []int{19} } func (m *OTelLog) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1911,7 +2090,7 @@ type OTelSpan struct { func (m *OTelSpan) Reset() { *m = OTelSpan{} } func (*OTelSpan) ProtoMessage() {} func (*OTelSpan) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{19} + return fileDescriptor_e5dcfc8666ec3f33, []int{20} } func (m *OTelSpan) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2046,7 +2225,7 @@ type OTelMetricGauge struct { func (m *OTelMetricGauge) Reset() { *m = OTelMetricGauge{} } func (*OTelMetricGauge) ProtoMessage() {} func (*OTelMetricGauge) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{20} + return fileDescriptor_e5dcfc8666ec3f33, []int{21} } func (m *OTelMetricGauge) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2130,7 +2309,7 @@ type OTelMetricSummary struct { func (m *OTelMetricSummary) Reset() { *m = OTelMetricSummary{} } func (*OTelMetricSummary) ProtoMessage() {} func (*OTelMetricSummary) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{21} + return fileDescriptor_e5dcfc8666ec3f33, []int{22} } func (m *OTelMetricSummary) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2188,7 +2367,7 @@ type OTelMetricSummary_ValueAtQuantile struct { func (m *OTelMetricSummary_ValueAtQuantile) Reset() { *m = OTelMetricSummary_ValueAtQuantile{} } func (*OTelMetricSummary_ValueAtQuantile) ProtoMessage() {} func (*OTelMetricSummary_ValueAtQuantile) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{21, 0} + return fileDescriptor_e5dcfc8666ec3f33, []int{22, 0} } func (m *OTelMetricSummary_ValueAtQuantile) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2243,7 +2422,7 @@ type OTelAttribute struct { func (m *OTelAttribute) Reset() { *m = OTelAttribute{} } func (*OTelAttribute) ProtoMessage() {} func (*OTelAttribute) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{22} + return fileDescriptor_e5dcfc8666ec3f33, []int{23} } func (m *OTelAttribute) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2334,7 +2513,7 @@ type OTelAttribute_Column struct { func (m *OTelAttribute_Column) Reset() { *m = OTelAttribute_Column{} } func (*OTelAttribute_Column) ProtoMessage() {} func (*OTelAttribute_Column) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{22, 0} + return fileDescriptor_e5dcfc8666ec3f33, []int{23, 0} } func (m *OTelAttribute_Column) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2400,7 +2579,7 @@ type OTelMetric struct { func (m *OTelMetric) Reset() { *m = OTelMetric{} } func (*OTelMetric) ProtoMessage() {} func (*OTelMetric) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{23} + return fileDescriptor_e5dcfc8666ec3f33, []int{24} } func (m *OTelMetric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2520,7 +2699,7 @@ type OTelEndpointConfig struct { func (m *OTelEndpointConfig) Reset() { *m = OTelEndpointConfig{} } func (*OTelEndpointConfig) ProtoMessage() {} func (*OTelEndpointConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{24} + return fileDescriptor_e5dcfc8666ec3f33, []int{25} } func (m *OTelEndpointConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2577,6 +2756,89 @@ func (m *OTelEndpointConfig) GetTimeout() int64 { return 0 } +type ClickHouseConfig struct { + Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"` + Host string `protobuf:"bytes,2,opt,name=host,proto3" json:"host,omitempty"` + Port int32 `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"` + Username string `protobuf:"bytes,4,opt,name=username,proto3" json:"username,omitempty"` + Password string `protobuf:"bytes,5,opt,name=password,proto3" json:"password,omitempty"` + Database string `protobuf:"bytes,6,opt,name=database,proto3" json:"database,omitempty"` +} + +func (m *ClickHouseConfig) Reset() { *m = ClickHouseConfig{} } +func (*ClickHouseConfig) ProtoMessage() {} +func (*ClickHouseConfig) Descriptor() ([]byte, []int) { + return fileDescriptor_e5dcfc8666ec3f33, []int{26} +} +func (m *ClickHouseConfig) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ClickHouseConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ClickHouseConfig.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ClickHouseConfig) XXX_Merge(src proto.Message) { + xxx_messageInfo_ClickHouseConfig.Merge(m, src) +} +func (m *ClickHouseConfig) XXX_Size() int { + return m.Size() +} +func (m *ClickHouseConfig) XXX_DiscardUnknown() { + xxx_messageInfo_ClickHouseConfig.DiscardUnknown(m) +} + +var xxx_messageInfo_ClickHouseConfig proto.InternalMessageInfo + +func (m *ClickHouseConfig) GetHostname() string { + if m != nil { + return m.Hostname + } + return "" +} + +func (m *ClickHouseConfig) GetHost() string { + if m != nil { + return m.Host + } + return "" +} + +func (m *ClickHouseConfig) GetPort() int32 { + if m != nil { + return m.Port + } + return 0 +} + +func (m *ClickHouseConfig) GetUsername() string { + if m != nil { + return m.Username + } + return "" +} + +func (m *ClickHouseConfig) GetPassword() string { + if m != nil { + return m.Password + } + return "" +} + +func (m *ClickHouseConfig) GetDatabase() string { + if m != nil { + return m.Database + } + return "" +} + type OTelResource struct { Attributes []*OTelAttribute `protobuf:"bytes,1,rep,name=attributes,proto3" json:"attributes,omitempty"` } @@ -2584,7 +2846,7 @@ type OTelResource struct { func (m *OTelResource) Reset() { *m = OTelResource{} } func (*OTelResource) ProtoMessage() {} func (*OTelResource) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{25} + return fileDescriptor_e5dcfc8666ec3f33, []int{27} } func (m *OTelResource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2631,7 +2893,7 @@ type OTelExportSinkOperator struct { func (m *OTelExportSinkOperator) Reset() { *m = OTelExportSinkOperator{} } func (*OTelExportSinkOperator) ProtoMessage() {} func (*OTelExportSinkOperator) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{26} + return fileDescriptor_e5dcfc8666ec3f33, []int{28} } func (m *OTelExportSinkOperator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2695,6 +2957,126 @@ func (m *OTelExportSinkOperator) GetLogs() []*OTelLog { return nil } +type ClickHouseExportSinkOperator struct { + ClickhouseConfig *ClickHouseConfig `protobuf:"bytes,1,opt,name=clickhouse_config,json=clickhouseConfig,proto3" json:"clickhouse_config,omitempty"` + TableName string `protobuf:"bytes,2,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"` + ColumnMappings []*ClickHouseExportSinkOperator_ColumnMapping `protobuf:"bytes,3,rep,name=column_mappings,json=columnMappings,proto3" json:"column_mappings,omitempty"` +} + +func (m *ClickHouseExportSinkOperator) Reset() { *m = ClickHouseExportSinkOperator{} } +func (*ClickHouseExportSinkOperator) ProtoMessage() {} +func (*ClickHouseExportSinkOperator) Descriptor() ([]byte, []int) { + return fileDescriptor_e5dcfc8666ec3f33, []int{29} +} +func (m *ClickHouseExportSinkOperator) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ClickHouseExportSinkOperator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ClickHouseExportSinkOperator.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ClickHouseExportSinkOperator) XXX_Merge(src proto.Message) { + xxx_messageInfo_ClickHouseExportSinkOperator.Merge(m, src) +} +func (m *ClickHouseExportSinkOperator) XXX_Size() int { + return m.Size() +} +func (m *ClickHouseExportSinkOperator) XXX_DiscardUnknown() { + xxx_messageInfo_ClickHouseExportSinkOperator.DiscardUnknown(m) +} + +var xxx_messageInfo_ClickHouseExportSinkOperator proto.InternalMessageInfo + +func (m *ClickHouseExportSinkOperator) GetClickhouseConfig() *ClickHouseConfig { + if m != nil { + return m.ClickhouseConfig + } + return nil +} + +func (m *ClickHouseExportSinkOperator) GetTableName() string { + if m != nil { + return m.TableName + } + return "" +} + +func (m *ClickHouseExportSinkOperator) GetColumnMappings() []*ClickHouseExportSinkOperator_ColumnMapping { + if m != nil { + return m.ColumnMappings + } + return nil +} + +type ClickHouseExportSinkOperator_ColumnMapping struct { + InputColumnIndex int32 `protobuf:"varint,1,opt,name=input_column_index,json=inputColumnIndex,proto3" json:"input_column_index,omitempty"` + ClickhouseColumnName string `protobuf:"bytes,2,opt,name=clickhouse_column_name,json=clickhouseColumnName,proto3" json:"clickhouse_column_name,omitempty"` + ColumnType typespb.DataType `protobuf:"varint,3,opt,name=column_type,json=columnType,proto3,enum=px.types.DataType" json:"column_type,omitempty"` +} + +func (m *ClickHouseExportSinkOperator_ColumnMapping) Reset() { + *m = ClickHouseExportSinkOperator_ColumnMapping{} +} +func (*ClickHouseExportSinkOperator_ColumnMapping) ProtoMessage() {} +func (*ClickHouseExportSinkOperator_ColumnMapping) Descriptor() ([]byte, []int) { + return fileDescriptor_e5dcfc8666ec3f33, []int{29, 0} +} +func (m *ClickHouseExportSinkOperator_ColumnMapping) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ClickHouseExportSinkOperator_ColumnMapping) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ClickHouseExportSinkOperator_ColumnMapping.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ClickHouseExportSinkOperator_ColumnMapping) XXX_Merge(src proto.Message) { + xxx_messageInfo_ClickHouseExportSinkOperator_ColumnMapping.Merge(m, src) +} +func (m *ClickHouseExportSinkOperator_ColumnMapping) XXX_Size() int { + return m.Size() +} +func (m *ClickHouseExportSinkOperator_ColumnMapping) XXX_DiscardUnknown() { + xxx_messageInfo_ClickHouseExportSinkOperator_ColumnMapping.DiscardUnknown(m) +} + +var xxx_messageInfo_ClickHouseExportSinkOperator_ColumnMapping proto.InternalMessageInfo + +func (m *ClickHouseExportSinkOperator_ColumnMapping) GetInputColumnIndex() int32 { + if m != nil { + return m.InputColumnIndex + } + return 0 +} + +func (m *ClickHouseExportSinkOperator_ColumnMapping) GetClickhouseColumnName() string { + if m != nil { + return m.ClickhouseColumnName + } + return "" +} + +func (m *ClickHouseExportSinkOperator_ColumnMapping) GetColumnType() typespb.DataType { + if m != nil { + return m.ColumnType + } + return typespb.DATA_TYPE_UNKNOWN +} + type ScalarExpression struct { // Types that are valid to be assigned to Value: // @@ -2707,7 +3089,7 @@ type ScalarExpression struct { func (m *ScalarExpression) Reset() { *m = ScalarExpression{} } func (*ScalarExpression) ProtoMessage() {} func (*ScalarExpression) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{27} + return fileDescriptor_e5dcfc8666ec3f33, []int{30} } func (m *ScalarExpression) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2810,7 +3192,7 @@ type ScalarValue struct { func (m *ScalarValue) Reset() { *m = ScalarValue{} } func (*ScalarValue) ProtoMessage() {} func (*ScalarValue) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{28} + return fileDescriptor_e5dcfc8666ec3f33, []int{31} } func (m *ScalarValue) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2951,7 +3333,7 @@ type ScalarFunc struct { func (m *ScalarFunc) Reset() { *m = ScalarFunc{} } func (*ScalarFunc) ProtoMessage() {} func (*ScalarFunc) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{29} + return fileDescriptor_e5dcfc8666ec3f33, []int{32} } func (m *ScalarFunc) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3026,7 +3408,7 @@ type AggregateExpression struct { func (m *AggregateExpression) Reset() { *m = AggregateExpression{} } func (*AggregateExpression) ProtoMessage() {} func (*AggregateExpression) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{30} + return fileDescriptor_e5dcfc8666ec3f33, []int{33} } func (m *AggregateExpression) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3101,7 +3483,7 @@ type AggregateExpression_Arg struct { func (m *AggregateExpression_Arg) Reset() { *m = AggregateExpression_Arg{} } func (*AggregateExpression_Arg) ProtoMessage() {} func (*AggregateExpression_Arg) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{30, 0} + return fileDescriptor_e5dcfc8666ec3f33, []int{33, 0} } func (m *AggregateExpression_Arg) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3184,7 +3566,7 @@ type Column struct { func (m *Column) Reset() { *m = Column{} } func (*Column) ProtoMessage() {} func (*Column) Descriptor() ([]byte, []int) { - return fileDescriptor_e5dcfc8666ec3f33, []int{31} + return fileDescriptor_e5dcfc8666ec3f33, []int{34} } func (m *Column) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3255,6 +3637,7 @@ func init() { proto.RegisterType((*JoinOperator_ParentColumn)(nil), "px.carnot.planpb.JoinOperator.ParentColumn") proto.RegisterType((*UDTFSourceOperator)(nil), "px.carnot.planpb.UDTFSourceOperator") proto.RegisterType((*EmptySourceOperator)(nil), "px.carnot.planpb.EmptySourceOperator") + proto.RegisterType((*ClickHouseSourceOperator)(nil), "px.carnot.planpb.ClickHouseSourceOperator") proto.RegisterType((*OTelLog)(nil), "px.carnot.planpb.OTelLog") proto.RegisterType((*OTelSpan)(nil), "px.carnot.planpb.OTelSpan") proto.RegisterType((*OTelMetricGauge)(nil), "px.carnot.planpb.OTelMetricGauge") @@ -3265,8 +3648,11 @@ func init() { proto.RegisterType((*OTelMetric)(nil), "px.carnot.planpb.OTelMetric") proto.RegisterType((*OTelEndpointConfig)(nil), "px.carnot.planpb.OTelEndpointConfig") proto.RegisterMapType((map[string]string)(nil), "px.carnot.planpb.OTelEndpointConfig.HeadersEntry") + proto.RegisterType((*ClickHouseConfig)(nil), "px.carnot.planpb.ClickHouseConfig") proto.RegisterType((*OTelResource)(nil), "px.carnot.planpb.OTelResource") proto.RegisterType((*OTelExportSinkOperator)(nil), "px.carnot.planpb.OTelExportSinkOperator") + proto.RegisterType((*ClickHouseExportSinkOperator)(nil), "px.carnot.planpb.ClickHouseExportSinkOperator") + proto.RegisterType((*ClickHouseExportSinkOperator_ColumnMapping)(nil), "px.carnot.planpb.ClickHouseExportSinkOperator.ColumnMapping") proto.RegisterType((*ScalarExpression)(nil), "px.carnot.planpb.ScalarExpression") proto.RegisterType((*ScalarValue)(nil), "px.carnot.planpb.ScalarValue") proto.RegisterType((*ScalarFunc)(nil), "px.carnot.planpb.ScalarFunc") @@ -3278,213 +3664,238 @@ func init() { func init() { proto.RegisterFile("src/carnot/planpb/plan.proto", fileDescriptor_e5dcfc8666ec3f33) } var fileDescriptor_e5dcfc8666ec3f33 = []byte{ - // 3294 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x39, 0x4b, 0x6c, 0x1b, 0xc7, - 0xd9, 0x5c, 0x92, 0xe2, 0xe3, 0xe3, 0x53, 0x63, 0xc9, 0x96, 0x69, 0x9b, 0x72, 0x18, 0xfb, 0xb7, - 0xe2, 0x3f, 0xa1, 0x6c, 0xd9, 0xf1, 0xef, 0x38, 0xce, 0x9f, 0x50, 0x12, 0x25, 0x51, 0x91, 0x44, - 0x75, 0x44, 0x25, 0x4d, 0x1b, 0x74, 0xb1, 0xe2, 0x8e, 0xd6, 0x1b, 0x93, 0xbb, 0x9b, 0x7d, 0xd8, - 0x52, 0x80, 0xa2, 0x29, 0x7a, 0xe9, 0x21, 0x87, 0x1e, 0x7a, 0x28, 0x7a, 0x6f, 0x91, 0x4b, 0x8b, - 0x1c, 0x7a, 0xec, 0xa1, 0x05, 0x0a, 0xa4, 0x87, 0x22, 0x70, 0x7b, 0xca, 0xc9, 0x88, 0x95, 0x8b, - 0x0f, 0x45, 0x91, 0xde, 0x7b, 0x28, 0xe6, 0xb1, 0xe4, 0x52, 0xbb, 0xb2, 0x94, 0xb4, 0x28, 0xd0, - 0x83, 0xc4, 0x9d, 0xef, 0x35, 0xdf, 0x7b, 0xbe, 0xd9, 0x85, 0xf3, 0x8e, 0xdd, 0x9d, 0xed, 0x2a, - 0xb6, 0x61, 0xba, 0xb3, 0x56, 0x4f, 0x31, 0xac, 0x1d, 0xf6, 0x53, 0xb7, 0x6c, 0xd3, 0x35, 0x51, - 0xd9, 0xda, 0xab, 0x73, 0x64, 0x9d, 0x23, 0x2b, 0x13, 0x9a, 0xa9, 0x99, 0x0c, 0x39, 0x4b, 0x9f, - 0x38, 0x5d, 0xa5, 0xaa, 0x99, 0xa6, 0xd6, 0x23, 0xb3, 0x6c, 0xb5, 0xe3, 0xed, 0xce, 0x3e, 0xb4, - 0x15, 0xcb, 0x22, 0xb6, 0x23, 0xf0, 0xd3, 0x74, 0x17, 0xc5, 0xd2, 0x39, 0xc1, 0xac, 0xe7, 0xe9, - 0xaa, 0xb5, 0xc3, 0x7e, 0x04, 0xc1, 0x25, 0x4a, 0xe0, 0xdc, 0x53, 0x6c, 0xa2, 0xce, 0xba, 0xfb, - 0x16, 0x71, 0xf8, 0x7f, 0x6b, 0x87, 0xff, 0x72, 0xaa, 0xda, 0x0f, 0x25, 0xc8, 0x6d, 0xf6, 0x14, - 0xa3, 0x6d, 0xb9, 0xba, 0x69, 0x38, 0x68, 0x0a, 0xd2, 0x64, 0xcf, 0xea, 0x29, 0xba, 0x31, 0x15, - 0xbf, 0x28, 0xcd, 0x64, 0xb0, 0xbf, 0xa4, 0x18, 0xc5, 0x50, 0x7a, 0xfb, 0x1f, 0x90, 0xa9, 0x04, - 0xc7, 0x88, 0x25, 0xba, 0x0d, 0x67, 0xfb, 0xca, 0x9e, 0x6c, 0x7a, 0xae, 0xe5, 0xb9, 0xb2, 0x6d, - 0x3e, 0x74, 0x64, 0x8b, 0xd8, 0xb2, 0xab, 0xec, 0xf4, 0xc8, 0x54, 0xf2, 0xa2, 0x34, 0x93, 0xc0, - 0x93, 0x7d, 0x65, 0xaf, 0xcd, 0xf0, 0xd8, 0x7c, 0xe8, 0x6c, 0x12, 0xbb, 0x43, 0x91, 0xab, 0xc9, - 0x8c, 0x54, 0x8e, 0xd7, 0x9e, 0x24, 0x20, 0x49, 0x75, 0x40, 0x57, 0x20, 0xa1, 0x2a, 0xda, 0x94, - 0x74, 0x51, 0x9a, 0xc9, 0xcd, 0x4d, 0xd6, 0x0f, 0x7b, 0xaa, 0xbe, 0xd8, 0x58, 0xc6, 0x94, 0x02, - 0xdd, 0x84, 0x31, 0xc3, 0x54, 0x89, 0x33, 0x15, 0xbf, 0x98, 0x98, 0xc9, 0xcd, 0x55, 0xc3, 0xa4, - 0x54, 0xde, 0x92, 0xad, 0x68, 0x7d, 0x62, 0xb8, 0x98, 0x13, 0xa3, 0x37, 0x20, 0x4f, 0xb1, 0xb2, - 0xc9, 0x6d, 0x65, 0xaa, 0xe5, 0xe6, 0x2e, 0x44, 0x33, 0x0b, 0x87, 0xe0, 0x9c, 0x15, 0xf0, 0xce, - 0x16, 0x20, 0xdd, 0xe8, 0x9a, 0x7d, 0xdd, 0xd0, 0x64, 0x45, 0x23, 0x86, 0x2b, 0xeb, 0xaa, 0x33, - 0x35, 0xc6, 0x94, 0x28, 0x51, 0x39, 0x3c, 0x0c, 0xf5, 0xed, 0xed, 0xd6, 0xe2, 0xfc, 0xc4, 0xc1, - 0xe3, 0xe9, 0x72, 0x4b, 0x90, 0x37, 0x28, 0x75, 0x6b, 0xd1, 0xc1, 0x65, 0x7d, 0x04, 0xa2, 0x3a, - 0xc8, 0x83, 0x0b, 0x64, 0x8f, 0x74, 0x3d, 0xba, 0x85, 0xec, 0xb8, 0x8a, 0xeb, 0x39, 0xb2, 0x4a, - 0x1c, 0x57, 0x37, 0x14, 0xae, 0x67, 0x8a, 0xc9, 0xbf, 0x1e, 0xad, 0x67, 0xbd, 0xe9, 0xf3, 0x6e, - 0x31, 0xd6, 0xc5, 0x21, 0x27, 0x3e, 0x47, 0x8e, 0xc4, 0x39, 0x95, 0x5d, 0xa8, 0x1c, 0xcd, 0x8a, - 0x9e, 0x83, 0xbc, 0x66, 0x5b, 0x5d, 0x59, 0x51, 0x55, 0x9b, 0x38, 0x0e, 0x8b, 0x49, 0x16, 0xe7, - 0x28, 0xac, 0xc1, 0x41, 0xe8, 0x32, 0x14, 0x1d, 0xa7, 0x27, 0xbb, 0x8a, 0xad, 0x11, 0xd7, 0x50, - 0xfa, 0x84, 0x65, 0x4c, 0x16, 0x17, 0x1c, 0xa7, 0xd7, 0x19, 0x00, 0x57, 0x93, 0x99, 0x44, 0x39, - 0x59, 0xdb, 0x87, 0x7c, 0x30, 0x24, 0xa8, 0x08, 0x71, 0x5d, 0x65, 0x52, 0x93, 0x38, 0xae, 0xab, - 0x7e, 0xe8, 0xe3, 0xc7, 0x86, 0xfe, 0x9a, 0x1f, 0xfa, 0x04, 0xf3, 0x4a, 0x25, 0xda, 0x2b, 0x1b, - 0xa6, 0x4a, 0x44, 0xd8, 0x6b, 0xbf, 0x90, 0x20, 0xb1, 0xd8, 0x58, 0x46, 0x37, 0x7c, 0x4e, 0x89, - 0x71, 0x5e, 0x88, 0xdc, 0x84, 0xfe, 0x05, 0x98, 0x2b, 0x3a, 0xa4, 0x05, 0x24, 0xa4, 0x32, 0xb5, - 0xdf, 0xb4, 0x5d, 0xa2, 0xca, 0x96, 0x62, 0x13, 0xc3, 0xa5, 0x09, 0x95, 0x98, 0x49, 0xe2, 0x02, - 0x87, 0x6e, 0x72, 0x20, 0xba, 0x02, 0x25, 0x41, 0xd6, 0xbd, 0xa7, 0xf7, 0x54, 0x9b, 0x18, 0x4c, - 0xf5, 0x24, 0x16, 0xdc, 0x0b, 0x02, 0x5a, 0x5b, 0x82, 0x8c, 0xaf, 0x7a, 0x68, 0xaf, 0xab, 0x10, - 0x37, 0x2d, 0xe1, 0x9d, 0x08, 0x93, 0xdb, 0x16, 0xb1, 0x15, 0xd7, 0xb4, 0x71, 0xdc, 0xb4, 0x6a, - 0x3f, 0xca, 0x40, 0xc6, 0x07, 0xa0, 0xff, 0x83, 0xb4, 0x69, 0xc9, 0xb4, 0xe2, 0x99, 0xb4, 0x62, - 0x54, 0xad, 0xf8, 0xc4, 0x9d, 0x7d, 0x8b, 0xe0, 0x94, 0x69, 0xd1, 0x5f, 0xb4, 0x06, 0x85, 0x3e, - 0xe9, 0xcb, 0x8e, 0xe9, 0xd9, 0x5d, 0x22, 0x0f, 0x36, 0xff, 0x9f, 0x30, 0xfb, 0x3a, 0xe9, 0x9b, - 0xf6, 0xfe, 0x16, 0x23, 0xf4, 0x45, 0xad, 0xc4, 0x70, 0xae, 0x4f, 0xfa, 0x3e, 0x10, 0xdd, 0x82, - 0x54, 0x5f, 0xb1, 0xa8, 0x98, 0xc4, 0x51, 0x45, 0xb7, 0xae, 0x58, 0x01, 0xee, 0xb1, 0x3e, 0x5d, - 0xa2, 0xbb, 0x90, 0x52, 0x34, 0x8d, 0xf2, 0xf1, 0x62, 0x7d, 0x3e, 0xcc, 0xd7, 0xd0, 0x34, 0x9b, - 0x68, 0x8a, 0x1b, 0xdc, 0x7b, 0x4c, 0xd1, 0xb4, 0xb6, 0x85, 0x96, 0x20, 0xc7, 0x6c, 0xd0, 0x8d, - 0xfb, 0x54, 0xc4, 0x18, 0x13, 0x71, 0xe9, 0x48, 0x0b, 0x74, 0xe3, 0x7e, 0x40, 0x46, 0x96, 0xea, - 0xcf, 0x40, 0xe8, 0x75, 0xc8, 0xee, 0xea, 0x3d, 0x97, 0xd8, 0x54, 0x4a, 0x8a, 0x49, 0xb9, 0x18, - 0x96, 0xb2, 0xc4, 0x48, 0x02, 0x12, 0x32, 0xbb, 0x02, 0x82, 0xee, 0x42, 0xa6, 0xa7, 0xf7, 0x75, - 0x97, 0xf2, 0xa7, 0x19, 0xff, 0x74, 0x98, 0x7f, 0x8d, 0x52, 0x04, 0xd8, 0xd3, 0x3d, 0x0e, 0xa0, - 0xdc, 0x9e, 0x41, 0x9b, 0x83, 0x69, 0x4d, 0x65, 0x8e, 0xe2, 0xde, 0xa6, 0x14, 0x41, 0x6e, 0x8f, - 0x03, 0xd0, 0xf7, 0xa0, 0xc8, 0x2a, 0x79, 0x18, 0xc9, 0xec, 0x51, 0x7e, 0x58, 0xc6, 0x9b, 0x0b, - 0xa3, 0x71, 0x9c, 0x2f, 0x1f, 0x3c, 0x9e, 0xce, 0x07, 0xe1, 0x2b, 0x31, 0xcc, 0x3a, 0xc3, 0x20, - 0xb4, 0x6f, 0x8b, 0x4e, 0xe1, 0x7b, 0xf9, 0x29, 0x37, 0xb0, 0x76, 0x84, 0xf8, 0x80, 0x93, 0xe7, - 0x8b, 0x07, 0x8f, 0xa7, 0x61, 0x08, 0x5d, 0x89, 0x61, 0x60, 0xa2, 0xb9, 0xd7, 0x5f, 0x81, 0xf4, - 0x7b, 0xa6, 0xce, 0xac, 0xce, 0x31, 0x91, 0x11, 0xa9, 0xbb, 0x6a, 0xea, 0x41, 0xa3, 0x53, 0xef, - 0xb1, 0x35, 0x5a, 0x83, 0xa2, 0xa7, 0xba, 0xbb, 0x01, 0x9b, 0xf3, 0x47, 0xd9, 0xbc, 0xbd, 0xd8, - 0x59, 0x0a, 0xe5, 0x6e, 0x9e, 0x72, 0x0f, 0x2c, 0x6c, 0x43, 0x89, 0xf4, 0x2d, 0x77, 0x3f, 0x20, - 0xae, 0xc0, 0xc4, 0x5d, 0x0e, 0x8b, 0x6b, 0x52, 0xc2, 0x90, 0xbc, 0x02, 0x09, 0x82, 0xd1, 0xbb, - 0x90, 0x37, 0x5d, 0xd2, 0x1b, 0xb8, 0xac, 0xc8, 0xa4, 0xcd, 0x44, 0x54, 0x66, 0x87, 0xf4, 0x9a, - 0x7b, 0x96, 0x69, 0xbb, 0x61, 0xbf, 0x51, 0xdc, 0xd0, 0x6f, 0x54, 0x1e, 0x5f, 0xcd, 0x27, 0x69, - 0xaf, 0xa8, 0xfd, 0x39, 0x0e, 0x13, 0x51, 0x95, 0x89, 0x10, 0x24, 0x59, 0xb3, 0xe6, 0x1d, 0x9d, - 0x3d, 0xa3, 0x69, 0xc8, 0x75, 0xcd, 0x9e, 0xd7, 0x37, 0x64, 0x5d, 0xdd, 0xe3, 0xa7, 0x6a, 0x02, - 0x03, 0x07, 0xb5, 0xd4, 0x3d, 0x87, 0x1e, 0x07, 0x82, 0x80, 0xd2, 0xf3, 0xe6, 0x9b, 0xc5, 0x82, - 0x69, 0x83, 0x82, 0xd0, 0xcb, 0x03, 0x12, 0x36, 0x5f, 0xb0, 0x66, 0x58, 0x9c, 0x43, 0xd4, 0x28, - 0x3e, 0x70, 0x2c, 0x2a, 0xae, 0xc2, 0x5a, 0x8c, 0x60, 0xa3, 0xcf, 0x0e, 0xba, 0x03, 0xe0, 0xb8, - 0x8a, 0xed, 0xca, 0xae, 0xde, 0x27, 0xa2, 0x44, 0xcf, 0xd5, 0xf9, 0xf0, 0x53, 0xf7, 0x87, 0x9f, - 0x7a, 0xcb, 0x70, 0x6f, 0xdd, 0x7c, 0x4b, 0xe9, 0x79, 0x04, 0x67, 0x19, 0x79, 0x47, 0xef, 0xd3, - 0xc1, 0x23, 0xeb, 0xb8, 0xb4, 0xbd, 0x51, 0xd6, 0xd4, 0xf1, 0xac, 0x19, 0x4a, 0xcd, 0x38, 0x4f, - 0x43, 0x8a, 0x8d, 0x27, 0x2e, 0x2b, 0xc7, 0x2c, 0x16, 0x2b, 0x74, 0x9e, 0x4a, 0xb4, 0x89, 0x42, - 0x0f, 0x68, 0x56, 0x6b, 0x19, 0x3c, 0x04, 0xd4, 0x3e, 0x93, 0x00, 0x85, 0x7b, 0x45, 0xa4, 0x47, - 0x0f, 0x7b, 0x23, 0x7e, 0x32, 0x6f, 0x9c, 0xc0, 0xcf, 0xab, 0x30, 0x29, 0x48, 0x1c, 0xd2, 0x57, - 0x0c, 0x57, 0xef, 0x8e, 0x38, 0xfc, 0xf4, 0x70, 0x8b, 0x2d, 0x81, 0x67, 0xdb, 0x9c, 0xe2, 0x4c, - 0x41, 0x98, 0x53, 0x33, 0x00, 0x85, 0x6b, 0x3e, 0xa4, 0xbb, 0xf4, 0xcd, 0x74, 0x8f, 0x87, 0x74, - 0xaf, 0x7d, 0x96, 0x84, 0xf2, 0xe1, 0x2e, 0xc0, 0x06, 0xcb, 0x91, 0x29, 0xc3, 0x5f, 0xa2, 0xdb, - 0xa3, 0xad, 0x4b, 0x57, 0xd9, 0xe9, 0x91, 0x3c, 0xdc, 0x94, 0x5a, 0x8b, 0xa3, 0x4d, 0xa9, 0xa5, - 0xa2, 0x2d, 0xc8, 0x8b, 0x71, 0x74, 0x38, 0x85, 0xe6, 0xe6, 0xea, 0xc7, 0xf7, 0xa4, 0x3a, 0x26, - 0x8e, 0xd7, 0x73, 0xd9, 0x78, 0x4a, 0x0f, 0x31, 0x2e, 0x85, 0x2d, 0x91, 0x06, 0xa8, 0x6b, 0x1a, - 0x06, 0xe9, 0xba, 0xbc, 0x19, 0xf3, 0xe9, 0x8c, 0xa7, 0xec, 0xed, 0x13, 0x88, 0xa6, 0x80, 0x85, - 0x81, 0x00, 0x7f, 0xc0, 0x1c, 0xef, 0x1e, 0x06, 0x55, 0xfe, 0x22, 0x41, 0x2e, 0xa0, 0x07, 0xba, - 0x00, 0xc0, 0xcc, 0x90, 0x03, 0x69, 0x96, 0x65, 0x90, 0x8d, 0xff, 0x9a, 0x5c, 0xab, 0xfc, 0x3f, - 0x4c, 0x46, 0x3a, 0x20, 0x62, 0x8e, 0x94, 0x22, 0xe6, 0xc8, 0xf9, 0x02, 0xe4, 0x02, 0x53, 0xf1, - 0x6a, 0x32, 0x13, 0x2f, 0x27, 0x6a, 0x0f, 0x20, 0x17, 0x98, 0x1b, 0xd0, 0x22, 0xe4, 0xc8, 0x9e, - 0x45, 0x73, 0x87, 0x85, 0x86, 0x0f, 0x7a, 0x11, 0x27, 0xd1, 0x56, 0x57, 0xe9, 0x29, 0x76, 0x73, - 0x40, 0x8a, 0x83, 0x6c, 0x27, 0x49, 0xe4, 0x5f, 0xc7, 0x61, 0x3c, 0x34, 0x78, 0xa0, 0xd7, 0x20, - 0xf5, 0x80, 0x36, 0x1a, 0x7f, 0xe7, 0xcb, 0xcf, 0x98, 0x56, 0x02, 0x9b, 0x0b, 0x26, 0x74, 0x0d, - 0x52, 0x9a, 0x6d, 0x7a, 0x96, 0x7f, 0xad, 0x99, 0x0a, 0xb3, 0x2f, 0x30, 0x1d, 0xb0, 0xa0, 0xa3, - 0x7d, 0x9b, 0x3d, 0x8d, 0x44, 0x10, 0x18, 0x88, 0x07, 0x70, 0x1a, 0x72, 0x4c, 0xb8, 0x20, 0x48, - 0x72, 0x02, 0x06, 0xe2, 0x04, 0x15, 0xc8, 0x3c, 0xd4, 0x0d, 0xd5, 0x7c, 0x48, 0x54, 0x96, 0xc9, - 0x19, 0x3c, 0x58, 0x53, 0x66, 0x4b, 0xb1, 0x5d, 0x5d, 0xe9, 0xc9, 0x8a, 0xa6, 0xb1, 0x06, 0x9b, - 0xc1, 0x20, 0x40, 0x0d, 0x4d, 0x43, 0x2f, 0x40, 0x79, 0x57, 0x37, 0x94, 0x9e, 0xfe, 0x01, 0x91, - 0x6d, 0x96, 0xaf, 0x0e, 0xeb, 0xa7, 0x19, 0x5c, 0xf2, 0xe1, 0x3c, 0x8d, 0x9d, 0xda, 0x8f, 0x25, - 0x28, 0x8e, 0x0e, 0x48, 0x68, 0x1e, 0x60, 0xe8, 0x75, 0x71, 0xe9, 0x3b, 0x49, 0xac, 0x02, 0x5c, - 0x68, 0x0e, 0xd2, 0x3c, 0x2c, 0xc7, 0xfb, 0xcc, 0x27, 0xac, 0x7d, 0x28, 0x41, 0x61, 0x64, 0xd6, - 0x42, 0x13, 0x30, 0xc6, 0x66, 0x2d, 0xa6, 0x44, 0x02, 0xf3, 0xc5, 0x37, 0x91, 0x4d, 0x73, 0x59, - 0xd9, 0x31, 0x6d, 0x5e, 0xad, 0x8e, 0xdd, 0x75, 0xc4, 0xac, 0x5f, 0x18, 0x40, 0xb7, 0xec, 0xae, - 0x53, 0x7b, 0x2a, 0x41, 0x61, 0x64, 0x60, 0x0b, 0xe5, 0x9c, 0x14, 0x2e, 0xc6, 0xb7, 0xa0, 0x24, - 0x48, 0xfa, 0x8a, 0x65, 0xe9, 0x86, 0xe6, 0xeb, 0xf5, 0xd2, 0x31, 0xd3, 0xa0, 0xd0, 0x72, 0x9d, - 0x73, 0xe1, 0x62, 0x37, 0xb8, 0x74, 0xd0, 0x25, 0x28, 0x0e, 0xee, 0xec, 0x3b, 0x8a, 0xdb, 0xbd, - 0xc7, 0xbb, 0x2c, 0xce, 0xdb, 0xfc, 0xaa, 0x3e, 0x4f, 0x61, 0x95, 0x5b, 0x50, 0x18, 0x11, 0x43, - 0x4d, 0xf5, 0x67, 0x06, 0x43, 0x25, 0x7b, 0x42, 0xe7, 0x04, 0x2e, 0x88, 0xb1, 0x81, 0x03, 0x6b, - 0x9f, 0x26, 0x21, 0x1f, 0x9c, 0xd2, 0xd0, 0xab, 0x90, 0x0c, 0x5c, 0x47, 0xae, 0x3c, 0x7b, 0xa6, - 0x63, 0x0b, 0xd6, 0x53, 0x18, 0x13, 0x52, 0xe0, 0x14, 0x79, 0xdf, 0x53, 0x7a, 0xba, 0xbb, 0x2f, - 0x77, 0x4d, 0x43, 0xd5, 0x79, 0x0f, 0xe6, 0x7e, 0xb8, 0x76, 0x8c, 0xac, 0xa6, 0xe0, 0x5c, 0xf0, - 0x19, 0x31, 0x22, 0x87, 0x41, 0x0e, 0xc2, 0x50, 0x14, 0x47, 0x87, 0x1f, 0x7d, 0x7e, 0xd3, 0xfc, - 0xdf, 0x63, 0xa4, 0xf3, 0xfb, 0x9e, 0x48, 0x88, 0x02, 0x17, 0xb1, 0x20, 0xd2, 0xe2, 0x70, 0x74, - 0x93, 0xe1, 0xe8, 0x86, 0xa3, 0x30, 0x16, 0x11, 0x85, 0x3e, 0x8c, 0x87, 0xac, 0x40, 0x57, 0x61, - 0xbc, 0x47, 0x76, 0x7d, 0x7d, 0x79, 0x38, 0xc4, 0xdd, 0xb1, 0x44, 0x11, 0x0b, 0xc3, 0x80, 0xa0, - 0x17, 0x01, 0xd9, 0xba, 0x76, 0xef, 0x10, 0x71, 0x9c, 0x11, 0x97, 0x19, 0x26, 0x40, 0x5d, 0xe9, - 0x40, 0x3e, 0x68, 0x16, 0xb5, 0x83, 0xdf, 0x75, 0x47, 0x36, 0xc9, 0x71, 0x18, 0xdf, 0x60, 0x68, - 0x6a, 0x50, 0x74, 0x2e, 0x90, 0x14, 0xb5, 0x97, 0x21, 0xe3, 0x87, 0x15, 0x65, 0x61, 0xac, 0xb5, - 0xb1, 0xd1, 0xc4, 0xe5, 0x18, 0x2a, 0x02, 0xac, 0x35, 0x97, 0x3a, 0x72, 0x7b, 0xbb, 0xd3, 0xc4, - 0x65, 0x89, 0xae, 0x97, 0xb6, 0xd7, 0xd6, 0xc4, 0x3a, 0x51, 0xdb, 0x05, 0x14, 0x1e, 0xd6, 0x23, - 0x87, 0xaf, 0xbb, 0x00, 0x8a, 0xad, 0xc9, 0xa2, 0x17, 0xc7, 0x8f, 0xba, 0xee, 0xf3, 0xce, 0x22, - 0xa6, 0x4a, 0xc5, 0xd6, 0xd8, 0x93, 0x53, 0x33, 0xe1, 0x54, 0xc4, 0x14, 0x7f, 0x92, 0x0a, 0xfd, - 0x66, 0x07, 0x71, 0xed, 0x57, 0x71, 0x48, 0xd3, 0x69, 0x7e, 0xcd, 0xd4, 0xd0, 0xeb, 0x00, 0x8a, - 0xeb, 0xda, 0xfa, 0x8e, 0xe7, 0x0e, 0x8e, 0x91, 0xe9, 0xe8, 0x8b, 0x41, 0xc3, 0xa7, 0xc3, 0x01, - 0x16, 0x9a, 0x0c, 0x74, 0x1c, 0x0e, 0xc7, 0x37, 0x81, 0x4b, 0x14, 0x11, 0x4c, 0x86, 0x57, 0xa1, - 0x62, 0xee, 0x38, 0xc4, 0x7e, 0x40, 0x54, 0x39, 0xcc, 0x94, 0x60, 0x4c, 0x67, 0x7c, 0x8a, 0xce, - 0x21, 0xe6, 0x2b, 0x50, 0x72, 0xc8, 0x03, 0x62, 0xd3, 0x52, 0x34, 0xbc, 0xfe, 0x0e, 0xb1, 0xc5, - 0xbb, 0xbe, 0xa2, 0x0f, 0xde, 0x60, 0x50, 0xf4, 0x3c, 0x14, 0x06, 0x84, 0x2e, 0xd9, 0x73, 0x59, - 0x62, 0x67, 0x71, 0xde, 0x07, 0x76, 0xc8, 0x9e, 0x4b, 0xd5, 0xde, 0x31, 0xd5, 0xfd, 0x51, 0x0d, - 0x52, 0x5c, 0x6d, 0x8a, 0x08, 0xec, 0x5c, 0xfb, 0x28, 0x09, 0x19, 0x76, 0xfb, 0xb1, 0x14, 0x9a, - 0x92, 0x39, 0x1a, 0x0f, 0xd9, 0x71, 0x6d, 0x3a, 0xb3, 0xb3, 0x34, 0xa0, 0x17, 0x22, 0x0a, 0xdc, - 0x62, 0x30, 0xf4, 0x22, 0x8c, 0x33, 0x92, 0xb0, 0x4b, 0x56, 0x62, 0xb8, 0x44, 0x51, 0x41, 0xbb, - 0x46, 0x23, 0x90, 0xf8, 0xfa, 0x11, 0x58, 0x84, 0x49, 0xd7, 0x56, 0xd8, 0xbc, 0x3a, 0xba, 0x25, - 0x73, 0xcf, 0xfc, 0xf8, 0xc1, 0xe3, 0xe9, 0x42, 0x87, 0x12, 0xb4, 0x16, 0x45, 0xb7, 0x40, 0x8c, - 0xbe, 0xa5, 0x06, 0xd5, 0x68, 0xc0, 0x84, 0x63, 0x29, 0x46, 0x48, 0xc8, 0x18, 0x13, 0xc2, 0x26, - 0x60, 0x6a, 0xff, 0x40, 0xc6, 0x38, 0xa5, 0x1e, 0x15, 0xd1, 0x81, 0x73, 0xa2, 0x5a, 0x23, 0x25, - 0x31, 0xef, 0xce, 0x9f, 0x3e, 0x78, 0x3c, 0x8d, 0x78, 0x91, 0x8f, 0xc8, 0x3b, 0x63, 0x0d, 0x61, - 0x23, 0x52, 0x5f, 0x86, 0x33, 0xc3, 0x0b, 0xdb, 0xa8, 0xc4, 0x34, 0x8b, 0xd7, 0xc4, 0xe0, 0x82, - 0x16, 0x64, 0xbb, 0x0e, 0x93, 0xc4, 0x88, 0x4a, 0xb3, 0x0c, 0x63, 0x42, 0xc4, 0x08, 0x65, 0xd8, - 0x05, 0x80, 0xfb, 0xba, 0xa1, 0xf2, 0x3a, 0x66, 0x6f, 0x2d, 0x12, 0x38, 0x4b, 0x21, 0xac, 0x50, - 0xe7, 0x53, 0xbc, 0xf2, 0x6b, 0xdf, 0x87, 0x12, 0x0d, 0xc6, 0x3a, 0x71, 0x6d, 0xbd, 0xbb, 0xac, - 0x78, 0x1a, 0x41, 0x75, 0x40, 0xbb, 0x3d, 0x53, 0x89, 0x68, 0x89, 0x34, 0xe4, 0x65, 0x86, 0x0b, - 0xee, 0x74, 0x15, 0xca, 0xba, 0xe1, 0x46, 0x27, 0x48, 0x51, 0x37, 0x82, 0xb4, 0xf3, 0x45, 0xc8, - 0xf3, 0x91, 0x8a, 0x53, 0xd7, 0x7e, 0x19, 0x87, 0xf1, 0xe1, 0xfe, 0x5b, 0x5e, 0xbf, 0xaf, 0xd8, - 0xfb, 0xb4, 0xcf, 0x76, 0x4d, 0xcf, 0x88, 0xd2, 0x00, 0x97, 0x19, 0x26, 0xb8, 0xff, 0x0c, 0x94, - 0x1d, 0xaf, 0x1f, 0x55, 0xb3, 0x45, 0xc7, 0xeb, 0x07, 0x29, 0xdf, 0x85, 0xd2, 0xfb, 0x1e, 0x9d, - 0xaa, 0x7b, 0xc4, 0xef, 0x6f, 0x3c, 0x45, 0x6f, 0x44, 0xa7, 0xe8, 0x88, 0x56, 0x75, 0xe6, 0xb8, - 0x86, 0xfb, 0x2d, 0x21, 0x01, 0x17, 0x7d, 0x59, 0xbc, 0xf5, 0x55, 0xbe, 0x0b, 0xa5, 0x43, 0x24, - 0x74, 0x40, 0xf4, 0x89, 0x98, 0xfa, 0x12, 0x1e, 0xac, 0xa9, 0x91, 0x41, 0x57, 0x8c, 0x28, 0x5e, - 0x66, 0x98, 0x60, 0xd9, 0x7e, 0x12, 0x87, 0xc2, 0x48, 0xd5, 0x44, 0xf6, 0xee, 0x37, 0x20, 0xc5, - 0xa5, 0x1d, 0xfd, 0xc2, 0x71, 0x44, 0x88, 0x18, 0x6e, 0x56, 0x62, 0x58, 0xf0, 0xa1, 0xe7, 0x21, - 0xcf, 0x9b, 0x81, 0x48, 0x9c, 0x84, 0x68, 0x09, 0x39, 0x0e, 0x65, 0x06, 0x56, 0x7e, 0x2e, 0x41, - 0x4a, 0x1c, 0x6a, 0x37, 0x06, 0x2f, 0x3f, 0x02, 0x73, 0x49, 0x54, 0xd3, 0x86, 0x61, 0xd3, 0x8e, - 0x3c, 0xe6, 0x12, 0x23, 0xc7, 0x1c, 0xba, 0x0d, 0x67, 0xbb, 0x8a, 0x21, 0xef, 0x10, 0xf9, 0x3d, - 0xc7, 0x34, 0x64, 0x62, 0x74, 0x4d, 0x95, 0xa8, 0xb2, 0x62, 0xdb, 0xca, 0xbe, 0xf8, 0x84, 0x32, - 0xd9, 0x55, 0x8c, 0x79, 0xb2, 0xea, 0x98, 0x46, 0x93, 0x63, 0x1b, 0x14, 0x39, 0x9f, 0x86, 0x31, - 0xa6, 0x7a, 0xed, 0xd3, 0x38, 0xc0, 0x30, 0x8a, 0x91, 0xfe, 0xba, 0xc8, 0xae, 0x45, 0x5d, 0x5b, - 0x67, 0xb7, 0x29, 0xf1, 0x0a, 0x3e, 0x08, 0xa2, 0x5c, 0x9e, 0xa1, 0xbb, 0xdc, 0x0f, 0x98, 0x3d, - 0x1f, 0x6a, 0x72, 0xc9, 0x7f, 0xd3, 0x31, 0x33, 0x16, 0x7d, 0xcc, 0xbc, 0x02, 0x63, 0x1a, 0x2d, - 0xcb, 0x29, 0xc2, 0x22, 0xfa, 0xdc, 0xb3, 0x32, 0x95, 0xd5, 0xef, 0x4a, 0x0c, 0x73, 0x0e, 0xf4, - 0x3a, 0xa4, 0x1d, 0x9e, 0xbb, 0x53, 0xbb, 0x47, 0xbd, 0x00, 0x0e, 0xa5, 0xf9, 0x4a, 0x0c, 0xfb, - 0x5c, 0xb4, 0x49, 0xa8, 0x8a, 0xab, 0xd4, 0xfe, 0x26, 0x01, 0x62, 0x6f, 0xd3, 0x0c, 0xd5, 0x32, - 0x59, 0x45, 0x1b, 0xbb, 0xba, 0x86, 0xce, 0x42, 0xc2, 0xb3, 0x7b, 0xdc, 0xa1, 0xf3, 0xe9, 0x83, - 0xc7, 0xd3, 0x89, 0x6d, 0xbc, 0x86, 0x29, 0x0c, 0xbd, 0x09, 0xe9, 0x7b, 0x44, 0x51, 0x89, 0xed, - 0x4f, 0x10, 0xd7, 0x8f, 0x78, 0x3f, 0x37, 0x22, 0xb1, 0xbe, 0xc2, 0x79, 0x9a, 0x86, 0x6b, 0xef, - 0x63, 0x5f, 0x02, 0xad, 0x22, 0xdd, 0x70, 0x48, 0xd7, 0xb3, 0xfd, 0xaf, 0x67, 0x83, 0x35, 0x9a, - 0x82, 0x34, 0xf5, 0x98, 0xe9, 0xb9, 0xe2, 0x00, 0xf5, 0x97, 0x95, 0x3b, 0x90, 0x0f, 0x8a, 0x43, - 0x65, 0x48, 0xdc, 0x27, 0xfb, 0x22, 0xfc, 0xf4, 0x91, 0xde, 0x5c, 0x78, 0x92, 0xf3, 0xb8, 0xf3, - 0xc5, 0x9d, 0xf8, 0x6d, 0xa9, 0xd6, 0x86, 0x3c, 0xd5, 0x0e, 0x13, 0xfe, 0xf2, 0xe4, 0x5f, 0x1e, - 0x2c, 0x6a, 0xbf, 0x8d, 0xc3, 0xe9, 0xe8, 0xf7, 0x91, 0x68, 0x1d, 0x4a, 0x44, 0x78, 0x81, 0x4e, - 0xe5, 0xbb, 0xba, 0xff, 0x0d, 0xef, 0xd2, 0x49, 0x5c, 0x86, 0x8b, 0x64, 0x34, 0x28, 0x77, 0x20, - 0x63, 0x0b, 0xb5, 0x45, 0x13, 0xa8, 0x46, 0xcb, 0xf1, 0x8d, 0xc3, 0x03, 0x7a, 0x74, 0x0b, 0xd2, - 0x7d, 0x96, 0x0b, 0x7e, 0x5f, 0x3c, 0xff, 0xac, 0x84, 0xc1, 0x3e, 0x31, 0xba, 0x06, 0x63, 0xf4, - 0x90, 0xf4, 0x6b, 0xa1, 0x12, 0xcd, 0x45, 0x4f, 0x43, 0xcc, 0x09, 0xd1, 0x4b, 0x90, 0xec, 0x99, - 0x9a, 0xff, 0xf5, 0xef, 0x6c, 0x34, 0xc3, 0x9a, 0xa9, 0x61, 0x46, 0x56, 0xfb, 0x9d, 0x04, 0xe5, - 0xc3, 0x57, 0x59, 0xf4, 0x2a, 0x64, 0xba, 0xa6, 0xe1, 0xb8, 0x8a, 0xe1, 0x0a, 0x8f, 0x3d, 0x7b, - 0x4c, 0x5d, 0x89, 0xe1, 0x01, 0x03, 0x9a, 0x3b, 0xd4, 0x29, 0x8f, 0xbc, 0x9e, 0x06, 0x7a, 0xe3, - 0x1c, 0x24, 0x77, 0x3d, 0xa3, 0x2b, 0xbe, 0xc2, 0x9c, 0x3f, 0x6a, 0xb3, 0x25, 0xcf, 0xe8, 0xae, - 0xc4, 0x30, 0xa3, 0x1d, 0x76, 0xa3, 0xdf, 0xc7, 0x21, 0x17, 0x50, 0x06, 0xcd, 0x42, 0x96, 0xd6, - 0xd6, 0x71, 0x6d, 0x33, 0xa3, 0x8a, 0x27, 0x34, 0x0d, 0xb0, 0x63, 0x9a, 0x3d, 0x79, 0x98, 0xb2, - 0x99, 0x95, 0x18, 0xce, 0x52, 0x18, 0x97, 0xf8, 0x1c, 0xe4, 0x74, 0xc3, 0xbd, 0x75, 0x33, 0xd0, - 0xb9, 0xe9, 0x11, 0x0c, 0xfa, 0xe0, 0x1d, 0x2e, 0xba, 0x0c, 0x05, 0x76, 0x7c, 0x0f, 0x88, 0x68, - 0xcd, 0x48, 0x2b, 0x31, 0x9c, 0x17, 0x60, 0x4e, 0x76, 0xf8, 0x10, 0x18, 0x8b, 0x38, 0x04, 0xd0, - 0x0c, 0xb0, 0x5e, 0x75, 0xeb, 0xa6, 0x6c, 0x38, 0x82, 0x2e, 0x25, 0xb6, 0x2c, 0x70, 0xc4, 0x86, - 0xc3, 0x29, 0x6f, 0x43, 0xc1, 0xd3, 0x0d, 0xf7, 0xfa, 0xdc, 0x6d, 0x41, 0xc7, 0x3f, 0x72, 0x8c, - 0x0f, 0xcd, 0xdd, 0x6e, 0x31, 0x34, 0xfb, 0x78, 0xc0, 0x29, 0xf9, 0x94, 0xe2, 0x7b, 0x6f, 0x35, - 0x99, 0xc9, 0x94, 0xb3, 0xb5, 0x2f, 0x24, 0x80, 0xa1, 0x8f, 0x23, 0x3b, 0xfa, 0x1d, 0xc8, 0xea, - 0x86, 0xee, 0xca, 0x8a, 0xad, 0x9d, 0xf0, 0xf2, 0x92, 0xa1, 0xf4, 0x0d, 0x5b, 0x73, 0xd0, 0x2d, - 0x48, 0x32, 0xb6, 0xc4, 0x89, 0xdf, 0x7c, 0x31, 0x7a, 0xf1, 0xbd, 0x91, 0xb7, 0x9f, 0xb8, 0xae, - 0xa2, 0x3b, 0x50, 0xa2, 0x70, 0x79, 0x10, 0x5f, 0x9e, 0xe7, 0xd1, 0x01, 0x2e, 0x50, 0x52, 0x7f, - 0xe5, 0xd4, 0xfe, 0x1e, 0x87, 0x53, 0x11, 0xaf, 0xb9, 0x06, 0xb6, 0x26, 0x8e, 0xb2, 0x35, 0xf9, - 0xf5, 0x6c, 0x7d, 0x4d, 0xd8, 0xca, 0x0b, 0xf0, 0x85, 0x13, 0xbd, 0x6b, 0xab, 0x37, 0x6c, 0x6d, - 0xc4, 0xe4, 0xd4, 0xb3, 0x4c, 0x4e, 0x9f, 0xd0, 0xe4, 0xca, 0x0f, 0x20, 0xd1, 0xb0, 0xb5, 0xff, - 0x78, 0x39, 0x0f, 0x4b, 0x73, 0x6e, 0x30, 0xcd, 0x50, 0x2f, 0x9b, 0x2a, 0x11, 0x57, 0x73, 0xf6, - 0x4c, 0x4f, 0x89, 0xe0, 0x65, 0x9c, 0x2f, 0xae, 0xfe, 0x35, 0x0e, 0xf9, 0xe0, 0xa7, 0x5f, 0x74, - 0x16, 0x26, 0xdb, 0x9b, 0x4d, 0xdc, 0xe8, 0xb4, 0xb1, 0xdc, 0x79, 0x67, 0xb3, 0x29, 0x6f, 0x6f, - 0xbc, 0xb9, 0xd1, 0x7e, 0x7b, 0xa3, 0x1c, 0x43, 0xe7, 0xe0, 0xf4, 0x7a, 0x73, 0xbd, 0x8d, 0xdf, - 0x91, 0xb7, 0xda, 0xdb, 0x78, 0xa1, 0x29, 0xfb, 0x84, 0xe5, 0xa7, 0x69, 0x74, 0x16, 0x26, 0x96, - 0xf1, 0xe6, 0x42, 0x08, 0xf5, 0xa7, 0x0c, 0x45, 0xd1, 0x3b, 0x7b, 0x08, 0xf5, 0x49, 0x16, 0x55, - 0x60, 0xb2, 0xb9, 0xbe, 0xd9, 0x09, 0x4b, 0xfc, 0x29, 0xa0, 0x71, 0xc8, 0xaf, 0x37, 0x36, 0x87, - 0xa0, 0x47, 0x25, 0x74, 0x06, 0x50, 0x63, 0x79, 0x19, 0x37, 0x97, 0x1b, 0x9d, 0x00, 0xed, 0x6f, - 0xca, 0x68, 0x02, 0x4a, 0x4b, 0xad, 0xb5, 0x4e, 0x13, 0x0f, 0xa1, 0x3f, 0x1b, 0x47, 0xa7, 0xa0, - 0xb8, 0xd6, 0x5a, 0x6f, 0x75, 0x86, 0xc0, 0x7f, 0x30, 0xe0, 0xf6, 0x46, 0xab, 0xbd, 0x31, 0x04, - 0x7e, 0x81, 0x10, 0x82, 0xc2, 0x6a, 0xbb, 0x15, 0x80, 0xfd, 0xe1, 0x14, 0x55, 0xdb, 0x37, 0xb7, - 0xb5, 0xf1, 0xe6, 0x10, 0xf5, 0xf1, 0x12, 0xd5, 0x83, 0x1b, 0x3b, 0x82, 0xf8, 0x68, 0x19, 0x55, - 0xe1, 0x6c, 0xbb, 0xd3, 0x5c, 0x93, 0x9b, 0xdf, 0xde, 0x6c, 0xe3, 0xce, 0x21, 0xfc, 0x57, 0xcb, - 0xf3, 0x77, 0x1f, 0x3d, 0xa9, 0xc6, 0x3e, 0x7f, 0x52, 0x8d, 0x7d, 0xf5, 0xa4, 0x2a, 0x7d, 0x78, - 0x50, 0x95, 0x3e, 0x3e, 0xa8, 0x4a, 0x7f, 0x3c, 0xa8, 0x4a, 0x8f, 0x0e, 0xaa, 0xd2, 0x17, 0x07, - 0x55, 0xe9, 0xe9, 0x41, 0x35, 0xf6, 0xd5, 0x41, 0x55, 0xfa, 0xc9, 0x97, 0xd5, 0xd8, 0xa3, 0x2f, - 0xab, 0xb1, 0xcf, 0xbf, 0xac, 0xc6, 0xbe, 0x93, 0xe2, 0xa1, 0xdf, 0x49, 0xb1, 0xef, 0x59, 0x37, - 0xfe, 0x19, 0x00, 0x00, 0xff, 0xff, 0xd2, 0xa5, 0x24, 0xbc, 0x5d, 0x24, 0x00, 0x00, + // 3683 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x3a, 0x4b, 0x6c, 0x1c, 0x47, + 0x76, 0x33, 0xd3, 0xf3, 0x7d, 0xf3, 0x65, 0x89, 0x94, 0xa9, 0xb1, 0x35, 0x94, 0xdb, 0x72, 0x2c, + 0x2b, 0x5e, 0xca, 0xa6, 0x65, 0x45, 0x2b, 0x6b, 0xe3, 0x1d, 0x92, 0x43, 0x72, 0x64, 0x92, 0xc3, + 0x14, 0x87, 0xbb, 0xd9, 0x64, 0xe1, 0x46, 0x73, 0xba, 0xd8, 0x6a, 0x6b, 0xa6, 0xbb, 0xdd, 0x1f, + 0x8b, 0x34, 0x10, 0x64, 0x73, 0xcb, 0x61, 0x0f, 0x39, 0xe4, 0x10, 0xe4, 0x94, 0x4b, 0x02, 0x23, + 0x40, 0x82, 0x05, 0x92, 0x63, 0x0e, 0x09, 0x12, 0x60, 0x73, 0x08, 0x16, 0xce, 0xe7, 0xb0, 0x27, + 0xc1, 0xa6, 0x2f, 0x3e, 0x05, 0xce, 0x2d, 0x87, 0x1c, 0x82, 0xfa, 0x74, 0x4f, 0xf7, 0x74, 0x0f, + 0x45, 0x3b, 0x41, 0x80, 0x1c, 0x6c, 0x4e, 0xbd, 0x5f, 0xbd, 0x5f, 0xbd, 0xf7, 0xaa, 0x5a, 0xf0, + 0x92, 0xeb, 0x8c, 0xee, 0x8c, 0x54, 0xc7, 0xb4, 0xbc, 0x3b, 0xf6, 0x58, 0x35, 0xed, 0x63, 0xf6, + 0x67, 0xd5, 0x76, 0x2c, 0xcf, 0x42, 0x2d, 0xfb, 0x74, 0x95, 0x23, 0x57, 0x39, 0xb2, 0xbd, 0xa8, + 0x5b, 0xba, 0xc5, 0x90, 0x77, 0xe8, 0x2f, 0x4e, 0xd7, 0xee, 0xe8, 0x96, 0xa5, 0x8f, 0xc9, 0x1d, + 0xb6, 0x3a, 0xf6, 0x4f, 0xee, 0x3c, 0x75, 0x54, 0xdb, 0x26, 0x8e, 0x2b, 0xf0, 0x2b, 0x74, 0x17, + 0xd5, 0x36, 0x38, 0xc1, 0x1d, 0xdf, 0x37, 0x34, 0xfb, 0x98, 0xfd, 0x11, 0x04, 0x37, 0x29, 0x81, + 0xfb, 0x58, 0x75, 0x88, 0x76, 0xc7, 0x3b, 0xb3, 0x89, 0xcb, 0xff, 0x6f, 0x1f, 0xf3, 0xbf, 0x9c, + 0x4a, 0xfe, 0xbd, 0x2c, 0x54, 0x0f, 0xc6, 0xaa, 0x39, 0xb0, 0x3d, 0xc3, 0x32, 0x5d, 0xb4, 0x0c, + 0x25, 0x72, 0x6a, 0x8f, 0x55, 0xc3, 0x5c, 0xce, 0xdd, 0xc8, 0xde, 0x2a, 0xe3, 0x60, 0x49, 0x31, + 0xaa, 0xa9, 0x8e, 0xcf, 0x3e, 0x21, 0xcb, 0x12, 0xc7, 0x88, 0x25, 0xba, 0x0f, 0xd7, 0x26, 0xea, + 0xa9, 0x62, 0xf9, 0x9e, 0xed, 0x7b, 0x8a, 0x63, 0x3d, 0x75, 0x15, 0x9b, 0x38, 0x8a, 0xa7, 0x1e, + 0x8f, 0xc9, 0x72, 0xfe, 0x46, 0xf6, 0x96, 0x84, 0x97, 0x26, 0xea, 0xe9, 0x80, 0xe1, 0xb1, 0xf5, + 0xd4, 0x3d, 0x20, 0xce, 0x90, 0x22, 0x1f, 0xe5, 0xcb, 0xd9, 0x56, 0x4e, 0xfe, 0x42, 0x82, 0x3c, + 0xd5, 0x01, 0xbd, 0x06, 0x92, 0xa6, 0xea, 0xcb, 0xd9, 0x1b, 0xd9, 0x5b, 0xd5, 0xb5, 0xa5, 0xd5, + 0x59, 0x4f, 0xad, 0x6e, 0x76, 0xb7, 0x31, 0xa5, 0x40, 0x77, 0xa1, 0x60, 0x5a, 0x1a, 0x71, 0x97, + 0x73, 0x37, 0xa4, 0x5b, 0xd5, 0xb5, 0x4e, 0x92, 0x94, 0xca, 0xdb, 0x72, 0x54, 0x7d, 0x42, 0x4c, + 0x0f, 0x73, 0x62, 0xf4, 0x7d, 0xa8, 0x51, 0xac, 0x62, 0x71, 0x5b, 0x99, 0x6a, 0xd5, 0xb5, 0xeb, + 0xe9, 0xcc, 0xc2, 0x21, 0xb8, 0x6a, 0x47, 0xbc, 0x73, 0x08, 0xc8, 0x30, 0x47, 0xd6, 0xc4, 0x30, + 0x75, 0x45, 0xd5, 0x89, 0xe9, 0x29, 0x86, 0xe6, 0x2e, 0x17, 0x98, 0x12, 0x4d, 0x2a, 0x87, 0x87, + 0x61, 0xf5, 0xe8, 0xa8, 0xbf, 0xb9, 0xbe, 0x78, 0xfe, 0x6c, 0xa5, 0xd5, 0x17, 0xe4, 0x5d, 0x4a, + 0xdd, 0xdf, 0x74, 0x71, 0xcb, 0x88, 0x41, 0x34, 0x17, 0xf9, 0x70, 0x9d, 0x9c, 0x92, 0x91, 0x4f, + 0xb7, 0x50, 0x5c, 0x4f, 0xf5, 0x7c, 0x57, 0xd1, 0x88, 0xeb, 0x19, 0xa6, 0xca, 0xf5, 0x2c, 0x32, + 0xf9, 0x6f, 0xa5, 0xeb, 0xb9, 0xda, 0x0b, 0x78, 0x0f, 0x19, 0xeb, 0xe6, 0x94, 0x13, 0xbf, 0x48, + 0xe6, 0xe2, 0xdc, 0xf6, 0x09, 0xb4, 0xe7, 0xb3, 0xa2, 0x97, 0xa1, 0xa6, 0x3b, 0xf6, 0x48, 0x51, + 0x35, 0xcd, 0x21, 0xae, 0xcb, 0x62, 0x52, 0xc1, 0x55, 0x0a, 0xeb, 0x72, 0x10, 0x7a, 0x15, 0x1a, + 0xae, 0x3b, 0x56, 0x3c, 0xd5, 0xd1, 0x89, 0x67, 0xaa, 0x13, 0xc2, 0x32, 0xa6, 0x82, 0xeb, 0xae, + 0x3b, 0x1e, 0x86, 0xc0, 0x47, 0xf9, 0xb2, 0xd4, 0xca, 0xcb, 0x67, 0x50, 0x8b, 0x86, 0x04, 0x35, + 0x20, 0x67, 0x68, 0x4c, 0x6a, 0x1e, 0xe7, 0x0c, 0x2d, 0x08, 0x7d, 0xee, 0xb9, 0xa1, 0x7f, 0x33, + 0x08, 0xbd, 0xc4, 0xbc, 0xd2, 0x4e, 0xf7, 0xca, 0xbe, 0xa5, 0x11, 0x11, 0x76, 0xf9, 0x4f, 0xb3, + 0x20, 0x6d, 0x76, 0xb7, 0xd1, 0xdb, 0x01, 0x67, 0x96, 0x71, 0x5e, 0x4f, 0xdd, 0x84, 0xfe, 0x17, + 0x61, 0x6e, 0x1b, 0x50, 0x12, 0x90, 0x84, 0xca, 0xd4, 0x7e, 0xcb, 0xf1, 0x88, 0xa6, 0xd8, 0xaa, + 0x43, 0x4c, 0x8f, 0x26, 0x94, 0x74, 0x2b, 0x8f, 0xeb, 0x1c, 0x7a, 0xc0, 0x81, 0xe8, 0x35, 0x68, + 0x0a, 0xb2, 0xd1, 0x63, 0x63, 0xac, 0x39, 0xc4, 0x64, 0xaa, 0xe7, 0xb1, 0xe0, 0xde, 0x10, 0x50, + 0x79, 0x0b, 0xca, 0x81, 0xea, 0x89, 0xbd, 0x6e, 0x43, 0xce, 0xb2, 0x85, 0x77, 0x52, 0x4c, 0x1e, + 0xd8, 0xc4, 0x51, 0x3d, 0xcb, 0xc1, 0x39, 0xcb, 0x96, 0xff, 0xbe, 0x02, 0xe5, 0x00, 0x80, 0x7e, + 0x0d, 0x4a, 0x96, 0xad, 0xd0, 0x13, 0xcf, 0xa4, 0x35, 0xd2, 0xce, 0x4a, 0x40, 0x3c, 0x3c, 0xb3, + 0x09, 0x2e, 0x5a, 0x36, 0xfd, 0x8b, 0x76, 0xa1, 0x3e, 0x21, 0x13, 0xc5, 0xb5, 0x7c, 0x67, 0x44, + 0x94, 0x70, 0xf3, 0x5f, 0x49, 0xb2, 0xef, 0x91, 0x89, 0xe5, 0x9c, 0x1d, 0x32, 0xc2, 0x40, 0xd4, + 0x4e, 0x06, 0x57, 0x27, 0x64, 0x12, 0x00, 0xd1, 0x3d, 0x28, 0x4e, 0x54, 0x9b, 0x8a, 0x91, 0xe6, + 0x1d, 0xba, 0x3d, 0xd5, 0x8e, 0x70, 0x17, 0x26, 0x74, 0x89, 0x1e, 0x42, 0x51, 0xd5, 0x75, 0xca, + 0xc7, 0x0f, 0xeb, 0x2b, 0x49, 0xbe, 0xae, 0xae, 0x3b, 0x44, 0x57, 0xbd, 0xe8, 0xde, 0x05, 0x55, + 0xd7, 0x07, 0x36, 0xda, 0x82, 0x2a, 0xb3, 0xc1, 0x30, 0x9f, 0x50, 0x11, 0x05, 0x26, 0xe2, 0xe6, + 0x5c, 0x0b, 0x0c, 0xf3, 0x49, 0x44, 0x46, 0x85, 0xea, 0xcf, 0x40, 0xe8, 0x3d, 0xa8, 0x9c, 0x18, + 0x63, 0x8f, 0x38, 0x54, 0x4a, 0x91, 0x49, 0xb9, 0x91, 0x94, 0xb2, 0xc5, 0x48, 0x22, 0x12, 0xca, + 0x27, 0x02, 0x82, 0x1e, 0x42, 0x79, 0x6c, 0x4c, 0x0c, 0x8f, 0xf2, 0x97, 0x18, 0xff, 0x4a, 0x92, + 0x7f, 0x97, 0x52, 0x44, 0xd8, 0x4b, 0x63, 0x0e, 0xa0, 0xdc, 0xbe, 0x49, 0x8b, 0x83, 0x65, 0x2f, + 0x97, 0xe7, 0x71, 0x1f, 0x51, 0x8a, 0x28, 0xb7, 0xcf, 0x01, 0xe8, 0x03, 0x68, 0xb0, 0x93, 0x3c, + 0x8d, 0x64, 0x65, 0x9e, 0x1f, 0xb6, 0xf1, 0xc1, 0x46, 0x3c, 0x8e, 0xeb, 0xad, 0xf3, 0x67, 0x2b, + 0xb5, 0x28, 0x7c, 0x27, 0x83, 0x59, 0x65, 0x08, 0x43, 0xfb, 0x43, 0x51, 0x29, 0x02, 0x2f, 0x7f, + 0xc5, 0x0d, 0x94, 0xe7, 0x88, 0x8f, 0x38, 0x79, 0xbd, 0x71, 0xfe, 0x6c, 0x05, 0xa6, 0xd0, 0x9d, + 0x0c, 0x06, 0x26, 0x9a, 0x7b, 0xfd, 0xbb, 0x50, 0xfa, 0xd0, 0x32, 0x98, 0xd5, 0x55, 0x26, 0x32, + 0x25, 0x75, 0x1f, 0x59, 0x46, 0xd4, 0xe8, 0xe2, 0x87, 0x6c, 0x8d, 0x76, 0xa1, 0xe1, 0x6b, 0xde, + 0x49, 0xc4, 0xe6, 0xda, 0x3c, 0x9b, 0x8f, 0x36, 0x87, 0x5b, 0x89, 0xdc, 0xad, 0x51, 0xee, 0xd0, + 0xc2, 0x01, 0x34, 0xc9, 0xc4, 0xf6, 0xce, 0x22, 0xe2, 0xea, 0x4c, 0xdc, 0xab, 0x49, 0x71, 0x3d, + 0x4a, 0x98, 0x90, 0x57, 0x27, 0x51, 0x30, 0xfa, 0x31, 0xd4, 0x2c, 0x8f, 0x8c, 0x43, 0x97, 0x35, + 0x98, 0xb4, 0x5b, 0x29, 0x27, 0x73, 0x48, 0xc6, 0xbd, 0x53, 0xdb, 0x72, 0xbc, 0xa4, 0xdf, 0x28, + 0x6e, 0xea, 0x37, 0x2a, 0x4f, 0xf8, 0xed, 0x03, 0x58, 0x1c, 0x8d, 0x8d, 0xd1, 0x93, 0xc7, 0x96, + 0xef, 0x92, 0x88, 0xce, 0x4d, 0xb6, 0xcb, 0xed, 0xe4, 0x2e, 0x1b, 0x94, 0x7a, 0x87, 0x52, 0x27, + 0x14, 0x47, 0x53, 0x49, 0xa1, 0xf6, 0x1f, 0x00, 0x8a, 0xca, 0x17, 0x36, 0xb4, 0x98, 0xf4, 0xd5, + 0x8b, 0xa4, 0x27, 0x2d, 0xd9, 0xc9, 0xe0, 0x56, 0x64, 0x07, 0x86, 0x59, 0xcf, 0xd3, 0x5a, 0x27, + 0xff, 0x73, 0x0e, 0x16, 0xd3, 0x2a, 0x0b, 0x42, 0x90, 0x67, 0xcd, 0x86, 0x77, 0x24, 0xf6, 0x1b, + 0xad, 0x40, 0x75, 0x64, 0x8d, 0xfd, 0x89, 0xa9, 0x18, 0xda, 0x29, 0x9f, 0x0a, 0x24, 0x0c, 0x1c, + 0xd4, 0xd7, 0x4e, 0x5d, 0xda, 0xce, 0x04, 0x01, 0xa5, 0xe7, 0xcd, 0xa3, 0x82, 0x05, 0xd3, 0x3e, + 0x05, 0xa1, 0x77, 0x42, 0x12, 0x36, 0x1f, 0xb1, 0x62, 0xde, 0x58, 0x43, 0xd4, 0x20, 0x3e, 0x30, + 0x6d, 0xaa, 0x9e, 0xca, 0x4a, 0xa4, 0x60, 0xa3, 0xbf, 0x5d, 0xf4, 0x00, 0xc0, 0xf5, 0x54, 0xc7, + 0x53, 0x3c, 0x63, 0x42, 0x44, 0x89, 0x79, 0x71, 0x95, 0x0f, 0x6f, 0xab, 0xc1, 0xf0, 0xb6, 0xda, + 0x37, 0xbd, 0x7b, 0x77, 0x7f, 0xa0, 0x8e, 0x7d, 0x82, 0x2b, 0x8c, 0x7c, 0x68, 0x4c, 0xe8, 0xe0, + 0x54, 0x71, 0x3d, 0x5a, 0x9e, 0x29, 0x6b, 0xf1, 0xf9, 0xac, 0x65, 0x4a, 0xcd, 0x38, 0xaf, 0x42, + 0x91, 0x8d, 0x57, 0x1e, 0x2b, 0x27, 0x15, 0x2c, 0x56, 0xe8, 0x25, 0x2a, 0xd1, 0x21, 0x2a, 0x1d, + 0x30, 0x58, 0xad, 0x28, 0xe3, 0x29, 0x40, 0xfe, 0x45, 0x16, 0x50, 0xb2, 0xd6, 0xa5, 0x7a, 0x74, + 0xd6, 0x1b, 0xb9, 0xcb, 0x79, 0xe3, 0x12, 0x7e, 0x7e, 0x04, 0x4b, 0x82, 0xc4, 0x25, 0x13, 0xd5, + 0xf4, 0x8c, 0x51, 0xcc, 0xe1, 0x57, 0xa7, 0x5b, 0x1c, 0x0a, 0x3c, 0xdb, 0xe6, 0x0a, 0x67, 0x8a, + 0xc2, 0x5c, 0xd9, 0x04, 0x94, 0xac, 0x59, 0x09, 0xdd, 0xb3, 0xdf, 0x4e, 0xf7, 0x5c, 0x42, 0x77, + 0xf9, 0x17, 0x79, 0x68, 0xcd, 0x56, 0x31, 0x36, 0x18, 0xc7, 0xa6, 0xa4, 0x60, 0x89, 0xee, 0xc7, + 0x4b, 0xaf, 0xa1, 0xb1, 0xee, 0x97, 0x9f, 0x2d, 0xaa, 0xfd, 0xcd, 0x78, 0x51, 0xed, 0x6b, 0xe8, + 0x10, 0x6a, 0x62, 0x9c, 0x9e, 0x4e, 0xd1, 0xa9, 0xa7, 0x6b, 0x56, 0x9b, 0x55, 0x4c, 0x5c, 0x7f, + 0xec, 0xb1, 0xf1, 0x9a, 0x36, 0x61, 0x2e, 0x85, 0x2d, 0x91, 0x0e, 0x68, 0x64, 0x99, 0x26, 0x19, + 0x79, 0xbc, 0x99, 0xf0, 0xe9, 0x92, 0xa7, 0xec, 0xfd, 0x4b, 0x88, 0xa6, 0x80, 0x8d, 0x50, 0x40, + 0x30, 0x20, 0x2f, 0x8c, 0x66, 0x41, 0xed, 0x7f, 0xc9, 0x42, 0x35, 0xa2, 0x07, 0xba, 0x0e, 0xc0, + 0xcc, 0x50, 0x22, 0x69, 0x56, 0x61, 0x90, 0xfd, 0xff, 0x37, 0xb9, 0xd6, 0xfe, 0x75, 0x58, 0x4a, + 0x75, 0x40, 0xca, 0x1c, 0x9c, 0x4d, 0x99, 0x83, 0xd7, 0xeb, 0x50, 0x8d, 0x4c, 0xf5, 0x8f, 0xf2, + 0xe5, 0x5c, 0x4b, 0x92, 0x3f, 0x86, 0x6a, 0x64, 0xee, 0x41, 0x9b, 0x50, 0x25, 0xa7, 0x36, 0xcd, + 0x1d, 0x16, 0x1a, 0x3e, 0xa8, 0xa6, 0x74, 0xd2, 0xc3, 0x91, 0x3a, 0x56, 0x9d, 0x5e, 0x48, 0x8a, + 0xa3, 0x6c, 0x97, 0x49, 0xe4, 0xbf, 0xcc, 0xc1, 0x42, 0x62, 0x70, 0x42, 0xdf, 0x83, 0xe2, 0xc7, + 0xb4, 0xd0, 0x04, 0x3b, 0xbf, 0x7a, 0xc1, 0xb4, 0x15, 0xd9, 0x5c, 0x30, 0xa1, 0x37, 0xa1, 0xa8, + 0x3b, 0x96, 0x6f, 0x07, 0xd7, 0xb2, 0xe5, 0x94, 0x66, 0xc0, 0x74, 0xc0, 0x82, 0x8e, 0xd6, 0x6d, + 0xf6, 0x2b, 0x16, 0x41, 0x60, 0x20, 0x1e, 0xc0, 0x15, 0xa8, 0x32, 0xe1, 0x82, 0x20, 0xcf, 0x09, + 0x18, 0x88, 0x13, 0xb4, 0xa1, 0xfc, 0xd4, 0x30, 0x35, 0xeb, 0x29, 0xd1, 0x58, 0x26, 0x97, 0x71, + 0xb8, 0xa6, 0xcc, 0xb6, 0xea, 0x78, 0x86, 0x3a, 0x56, 0x54, 0x5d, 0x67, 0x05, 0xb6, 0x8c, 0x41, + 0x80, 0xba, 0xba, 0x8e, 0x5e, 0x87, 0xd6, 0x89, 0x61, 0xaa, 0x63, 0xe3, 0x13, 0xa2, 0x38, 0x2c, + 0x5f, 0x5d, 0x56, 0x4f, 0xcb, 0xb8, 0x19, 0xc0, 0x79, 0x1a, 0xbb, 0xf2, 0xef, 0x67, 0xa1, 0x11, + 0x1f, 0xf0, 0xd0, 0x3a, 0xc0, 0xd4, 0xeb, 0xe2, 0xd2, 0x7a, 0x99, 0x58, 0x45, 0xb8, 0xd0, 0x1a, + 0x94, 0x78, 0x58, 0x9e, 0xef, 0xb3, 0x80, 0x50, 0xfe, 0x49, 0x16, 0xea, 0xb1, 0x59, 0x11, 0x2d, + 0x42, 0x81, 0xcd, 0x8a, 0x4c, 0x09, 0x09, 0xf3, 0xc5, 0xb7, 0x91, 0x4d, 0x73, 0x59, 0x3d, 0xb6, + 0x1c, 0x7e, 0x5a, 0x5d, 0x67, 0xe4, 0x8a, 0xbb, 0x4a, 0x3d, 0x84, 0x1e, 0x3a, 0x23, 0x57, 0xfe, + 0x2a, 0x0b, 0xf5, 0xd8, 0xc0, 0x99, 0xc8, 0xb9, 0x6c, 0xf2, 0x30, 0xfe, 0x00, 0x9a, 0x82, 0x64, + 0xa2, 0xda, 0xb6, 0x61, 0xea, 0x81, 0x5e, 0xdf, 0x79, 0xce, 0x34, 0x2b, 0xb4, 0xdc, 0xe3, 0x5c, + 0xb8, 0x31, 0x8a, 0x2e, 0x5d, 0x74, 0x13, 0x1a, 0xe1, 0x9b, 0xc3, 0xb1, 0xea, 0x8d, 0x1e, 0xf3, + 0x2a, 0x8b, 0x6b, 0x0e, 0x7f, 0x6a, 0x58, 0xa7, 0xb0, 0xf6, 0x3d, 0xa8, 0xc7, 0xc4, 0x50, 0x53, + 0x83, 0x99, 0xc1, 0xd4, 0xc8, 0xa9, 0xd0, 0x59, 0xc2, 0x75, 0x31, 0x36, 0x70, 0xa0, 0xfc, 0xf3, + 0x3c, 0xd4, 0xa2, 0x53, 0x26, 0x7a, 0x17, 0xf2, 0x91, 0xeb, 0xd4, 0x6b, 0x17, 0xcf, 0xa4, 0x6c, + 0xc1, 0x6a, 0x0a, 0x63, 0x42, 0x2a, 0x5c, 0x21, 0x1f, 0xf9, 0xea, 0xd8, 0xf0, 0xce, 0x94, 0x91, + 0x65, 0x6a, 0x06, 0xaf, 0xc1, 0xdc, 0x0f, 0x6f, 0x3e, 0x47, 0x56, 0x4f, 0x70, 0x6e, 0x04, 0x8c, + 0x18, 0x91, 0x59, 0x90, 0x8b, 0x30, 0x34, 0x44, 0xeb, 0x08, 0xa2, 0xcf, 0x6f, 0xca, 0xbf, 0xfa, + 0x1c, 0xe9, 0xfc, 0xbe, 0x2a, 0x12, 0xa2, 0xce, 0x45, 0x6c, 0x88, 0xb4, 0x98, 0x8d, 0x6e, 0x3e, + 0x19, 0xdd, 0x64, 0x14, 0x0a, 0x29, 0x51, 0x98, 0xc0, 0x42, 0xc2, 0x0a, 0x74, 0x1b, 0x16, 0xc6, + 0xe4, 0x24, 0xd0, 0x97, 0x87, 0x43, 0xdc, 0x7d, 0x9b, 0x14, 0xb1, 0x31, 0x0d, 0x08, 0x7a, 0x03, + 0x90, 0x63, 0xe8, 0x8f, 0x67, 0x88, 0x73, 0x8c, 0xb8, 0xc5, 0x30, 0x11, 0xea, 0xf6, 0x10, 0x6a, + 0x51, 0xb3, 0xa8, 0x1d, 0xfc, 0xae, 0x1e, 0xdb, 0xa4, 0xca, 0x61, 0x7c, 0x83, 0xa9, 0xa9, 0x51, + 0xd1, 0xd5, 0x48, 0x52, 0xc8, 0xef, 0x40, 0x39, 0x08, 0x2b, 0xaa, 0x40, 0xa1, 0xbf, 0xbf, 0xdf, + 0xc3, 0xad, 0x0c, 0x6a, 0x00, 0xec, 0xf6, 0xb6, 0x86, 0xca, 0xe0, 0x68, 0xd8, 0xc3, 0xad, 0x2c, + 0x5d, 0x6f, 0x1d, 0xed, 0xee, 0x8a, 0xb5, 0x24, 0x9f, 0x00, 0x4a, 0x5e, 0x36, 0x52, 0x87, 0xaf, + 0x87, 0x00, 0xaa, 0xa3, 0x2b, 0xa2, 0x16, 0xe7, 0xe6, 0x3d, 0x57, 0xf0, 0xca, 0x22, 0xa6, 0x4a, + 0xd5, 0xd1, 0xd9, 0x2f, 0x57, 0xb6, 0xe0, 0x4a, 0xca, 0x2d, 0xe4, 0x32, 0x27, 0xf4, 0xdb, 0x35, + 0x62, 0xf9, 0x5f, 0x25, 0x58, 0x9e, 0x77, 0x87, 0xa0, 0xf6, 0x3d, 0xb6, 0x5c, 0x2f, 0xb0, 0x8f, + 0xfe, 0xa6, 0x30, 0x7a, 0x13, 0x60, 0xbe, 0x2d, 0x60, 0xf6, 0x9b, 0x16, 0x72, 0xdf, 0x25, 0x0e, + 0xf3, 0x85, 0xc4, 0x68, 0xc3, 0x35, 0xc5, 0xd9, 0xaa, 0xeb, 0x3e, 0xb5, 0x1c, 0x8d, 0x4d, 0x42, + 0x15, 0x1c, 0xae, 0x29, 0x4e, 0x53, 0x3d, 0xf5, 0x58, 0x75, 0xf9, 0xf4, 0x5d, 0xc1, 0xe1, 0x9a, + 0xd6, 0xc5, 0x8f, 0x7c, 0xe2, 0x9c, 0xb1, 0xd2, 0x5f, 0xc1, 0x7c, 0x91, 0x70, 0x44, 0xe9, 0xf9, + 0x8e, 0x28, 0x5f, 0x6e, 0x22, 0xb9, 0x0e, 0xc0, 0x52, 0x5f, 0x71, 0x8d, 0x4f, 0x08, 0xbb, 0x66, + 0x17, 0x70, 0x85, 0x41, 0x0e, 0x8d, 0x4f, 0x48, 0x7c, 0x38, 0x87, 0x99, 0xe1, 0x9c, 0x36, 0x23, + 0x7a, 0x0f, 0x70, 0x3d, 0x75, 0x62, 0x8b, 0xec, 0x66, 0xf7, 0xde, 0x0a, 0x6e, 0x86, 0x70, 0x91, + 0xc6, 0xaf, 0x43, 0x8b, 0x75, 0x31, 0x36, 0xc7, 0x09, 0xd2, 0x1a, 0x27, 0x0d, 0xe1, 0x82, 0xf4, + 0x7a, 0xec, 0x7a, 0x52, 0x67, 0xfd, 0x21, 0x72, 0x03, 0xb9, 0x06, 0x65, 0x62, 0x6a, 0x1c, 0xd9, + 0x60, 0xc8, 0x12, 0x31, 0x35, 0x8a, 0x92, 0xff, 0x22, 0x07, 0x25, 0x7a, 0xc7, 0xdc, 0xb5, 0x74, + 0xf4, 0x1e, 0x80, 0xea, 0x79, 0x8e, 0x71, 0xec, 0x7b, 0xe1, 0x70, 0xb0, 0x92, 0x7e, 0x5d, 0xed, + 0x06, 0x74, 0x38, 0xc2, 0x42, 0x8f, 0x38, 0xdd, 0x23, 0x79, 0x6a, 0x25, 0x6e, 0x5d, 0xf4, 0x88, + 0xbf, 0x0b, 0x6d, 0xeb, 0xd8, 0x25, 0xce, 0xc7, 0x84, 0x2b, 0x16, 0x67, 0x92, 0x18, 0xd3, 0x0b, + 0x01, 0xc5, 0x70, 0x86, 0xf9, 0x35, 0x68, 0xba, 0xe4, 0x63, 0xe2, 0xd0, 0x02, 0x6b, 0xfa, 0x93, + 0x63, 0xe2, 0x88, 0x17, 0xe8, 0x46, 0x00, 0xde, 0x67, 0x50, 0xf4, 0x0a, 0xd4, 0x43, 0x42, 0x8f, + 0x9c, 0x7a, 0x22, 0x79, 0x6a, 0x01, 0x70, 0x48, 0x4e, 0x3d, 0xaa, 0xf6, 0xb1, 0xa5, 0x9d, 0xc5, + 0x35, 0x28, 0x72, 0xb5, 0x29, 0x22, 0xb2, 0xb3, 0xfc, 0xd3, 0x3c, 0x94, 0xd9, 0x9d, 0xdc, 0x56, + 0x69, 0xa1, 0xa9, 0xd2, 0xe4, 0x52, 0x5c, 0xcf, 0xa1, 0xc1, 0x66, 0xc9, 0x4f, 0xaf, 0xe9, 0x14, + 0x78, 0xc8, 0x60, 0xe8, 0x0d, 0x58, 0x60, 0x24, 0x49, 0x97, 0xec, 0x64, 0x70, 0x93, 0xa2, 0xa2, + 0x76, 0xc5, 0x23, 0x20, 0x7d, 0xf3, 0x08, 0x6c, 0xc2, 0x92, 0xe7, 0xa8, 0xec, 0x16, 0x12, 0xdf, + 0x92, 0xb9, 0x67, 0x7d, 0xe1, 0xfc, 0xd9, 0x4a, 0x7d, 0x48, 0x09, 0xfa, 0x9b, 0xa2, 0x07, 0x20, + 0x46, 0xdf, 0xd7, 0xa2, 0x6a, 0x74, 0x61, 0xd1, 0xb5, 0x55, 0x33, 0x21, 0xa4, 0xc0, 0x84, 0xb0, + 0x7b, 0x0d, 0xb5, 0x3f, 0x94, 0xb1, 0x40, 0xa9, 0xe3, 0x22, 0x86, 0xf0, 0xa2, 0xa8, 0xc1, 0xa9, + 0x92, 0x98, 0x77, 0xd7, 0xaf, 0x9e, 0x3f, 0x5b, 0x41, 0xbc, 0x74, 0xc7, 0xe4, 0xbd, 0x60, 0x4f, + 0x61, 0x31, 0xa9, 0xef, 0xc0, 0x0b, 0xd3, 0x3c, 0x8f, 0x4b, 0x2c, 0xb1, 0x78, 0x2d, 0x86, 0x49, + 0x1f, 0x65, 0x7b, 0x0b, 0x96, 0x82, 0xfc, 0x8f, 0x33, 0x95, 0x19, 0x13, 0x12, 0x87, 0x21, 0xca, + 0x72, 0x1d, 0xe0, 0x89, 0x61, 0x6a, 0xbc, 0x3a, 0xb3, 0x43, 0x2e, 0xe1, 0x0a, 0x85, 0xb0, 0xf2, + 0xbb, 0x5e, 0xe4, 0xf5, 0x5c, 0xfe, 0x1d, 0x68, 0xd2, 0x60, 0xec, 0x11, 0xcf, 0x31, 0x46, 0xdb, + 0xaa, 0xaf, 0x13, 0xb4, 0x0a, 0xe8, 0x64, 0x6c, 0xa9, 0x29, 0x8d, 0x8e, 0x86, 0xbc, 0xc5, 0x70, + 0xd1, 0x9d, 0x6e, 0x43, 0xcb, 0x30, 0xbd, 0xf4, 0x04, 0x69, 0x18, 0x66, 0x94, 0x76, 0xbd, 0x01, + 0x35, 0x3e, 0x28, 0x73, 0x6a, 0xf9, 0xcf, 0x72, 0xb0, 0x30, 0xdd, 0xff, 0xd0, 0x9f, 0x4c, 0x54, + 0xe7, 0x8c, 0x76, 0xcf, 0x91, 0xe5, 0x9b, 0x69, 0x1a, 0xe0, 0x16, 0xc3, 0x44, 0xf7, 0xbf, 0x05, + 0x2d, 0xd7, 0x9f, 0xa4, 0x9d, 0xd9, 0x86, 0xeb, 0x4f, 0xa2, 0x94, 0x3f, 0x86, 0xe6, 0x47, 0x3e, + 0xbd, 0x2b, 0x8d, 0x49, 0xd0, 0xb5, 0x78, 0x8a, 0xbe, 0x9d, 0x9e, 0xa2, 0x31, 0xad, 0x56, 0x99, + 0xe3, 0xba, 0xde, 0x6f, 0x08, 0x09, 0xb8, 0x11, 0xc8, 0xe2, 0x0d, 0xad, 0xfd, 0xdb, 0xd0, 0x9c, + 0x21, 0xa1, 0x55, 0x3f, 0x20, 0x62, 0xea, 0x67, 0x71, 0xb8, 0xa6, 0x46, 0x46, 0x5d, 0x11, 0x53, + 0xbc, 0xc5, 0x30, 0xd1, 0x63, 0xfb, 0xb3, 0x1c, 0xd4, 0x63, 0xa7, 0x26, 0xb5, 0x23, 0x7f, 0x1f, + 0x8a, 0xa2, 0xce, 0xce, 0x7d, 0x06, 0x8f, 0x09, 0x11, 0x23, 0xeb, 0x4e, 0x06, 0x0b, 0x3e, 0xf4, + 0x0a, 0xd4, 0x78, 0x31, 0x10, 0x89, 0x23, 0x89, 0x92, 0x50, 0xe5, 0x50, 0x66, 0x60, 0xfb, 0x8f, + 0xb3, 0x50, 0x14, 0x85, 0xfb, 0xed, 0xf0, 0x49, 0x2b, 0x32, 0x6d, 0xa6, 0x75, 0x20, 0x98, 0x76, + 0xa0, 0xd4, 0xe1, 0x45, 0x8a, 0x0d, 0x2f, 0xe8, 0x3e, 0x5c, 0x1b, 0xa9, 0xa6, 0x72, 0x4c, 0x94, + 0x0f, 0x5d, 0xcb, 0x54, 0x88, 0x39, 0xb2, 0x34, 0xa2, 0x29, 0xaa, 0xe3, 0xa8, 0x67, 0xe2, 0xc3, + 0xde, 0xd2, 0x48, 0x35, 0xd7, 0xc9, 0x23, 0xd7, 0x32, 0x7b, 0x1c, 0xdb, 0xa5, 0xc8, 0xf5, 0x12, + 0x14, 0x98, 0xea, 0xf2, 0xcf, 0x73, 0x00, 0xd3, 0x28, 0xa6, 0xfa, 0xeb, 0x06, 0xbb, 0xec, 0x8e, + 0x1c, 0x83, 0xdd, 0x91, 0xc5, 0x87, 0xa1, 0x28, 0x88, 0x72, 0xf9, 0xa6, 0xe1, 0x89, 0x5e, 0xcf, + 0x7e, 0xcf, 0x14, 0xb9, 0xfc, 0xff, 0x52, 0x9b, 0x29, 0xa4, 0xb7, 0x99, 0xef, 0x42, 0x41, 0xa7, + 0xc7, 0x72, 0x99, 0xb0, 0x88, 0xbe, 0x7c, 0x51, 0xa6, 0xb2, 0xf3, 0xbb, 0x93, 0xc1, 0x9c, 0x03, + 0xbd, 0x07, 0x25, 0x97, 0xe7, 0xee, 0xf2, 0xc9, 0xbc, 0xcf, 0x12, 0x89, 0x34, 0xdf, 0xc9, 0xe0, + 0x80, 0x8b, 0x16, 0x09, 0x3a, 0xa4, 0xc8, 0xff, 0x9e, 0x05, 0xc4, 0xde, 0x78, 0x4d, 0xcd, 0xb6, + 0xd8, 0x89, 0x36, 0x4f, 0x0c, 0x1d, 0x5d, 0x03, 0xc9, 0x77, 0xc6, 0xdc, 0xa1, 0xeb, 0xa5, 0xf3, + 0x67, 0x2b, 0xd2, 0x11, 0xde, 0xc5, 0x14, 0x86, 0xde, 0x87, 0xd2, 0x63, 0xa2, 0x6a, 0xc4, 0x09, + 0xe6, 0xc2, 0xb7, 0xe6, 0xbc, 0x1a, 0xc7, 0x24, 0xae, 0xee, 0x70, 0x9e, 0x9e, 0xe9, 0x39, 0x67, + 0x38, 0x90, 0x40, 0x4f, 0x91, 0x61, 0xba, 0x64, 0xe4, 0x3b, 0xc1, 0x37, 0xdd, 0x70, 0x8d, 0x96, + 0xa1, 0x44, 0x3d, 0x66, 0xf9, 0x9e, 0x68, 0xa0, 0xc1, 0xb2, 0xfd, 0x00, 0x6a, 0x51, 0x71, 0xa8, + 0x05, 0xd2, 0x13, 0x72, 0x26, 0xc2, 0x4f, 0x7f, 0xd2, 0xb9, 0x8b, 0x27, 0x39, 0x8f, 0x3b, 0x5f, + 0x3c, 0xc8, 0xdd, 0xcf, 0xca, 0x7f, 0x9e, 0x85, 0xd6, 0x74, 0x54, 0x14, 0xe6, 0xb6, 0xa1, 0x4c, + 0xc7, 0xc2, 0x48, 0x12, 0x85, 0xeb, 0x70, 0x7c, 0xcc, 0xa5, 0x8c, 0x8f, 0xd2, 0x9c, 0xf1, 0x31, + 0x7f, 0xc1, 0xf8, 0x58, 0xb8, 0x60, 0x7c, 0x2c, 0xc6, 0xc7, 0x47, 0x79, 0x00, 0x35, 0xea, 0x4a, + 0x4c, 0xf8, 0xfb, 0xdd, 0xff, 0x78, 0x0a, 0x92, 0xff, 0x26, 0x07, 0x57, 0xd3, 0x9f, 0xf4, 0xd1, + 0x1e, 0x34, 0x89, 0x08, 0x19, 0xbd, 0x18, 0x9e, 0x18, 0xc1, 0x67, 0xf0, 0x9b, 0x97, 0x89, 0x2f, + 0x6e, 0x90, 0x78, 0x06, 0x3d, 0x80, 0xb2, 0x23, 0xd4, 0x16, 0x15, 0xab, 0x93, 0x2e, 0x27, 0x30, + 0x0e, 0x87, 0xf4, 0xe8, 0x1e, 0x94, 0x26, 0x2c, 0x71, 0x83, 0x22, 0xfe, 0xd2, 0x45, 0xd9, 0x8d, + 0x03, 0x62, 0xf4, 0x26, 0x14, 0x68, 0x47, 0x0f, 0x0e, 0x6e, 0x3b, 0x9d, 0x8b, 0xb6, 0x6e, 0xcc, + 0x09, 0xd1, 0x77, 0x20, 0x3f, 0xb6, 0xf4, 0xe0, 0x03, 0xfa, 0xb5, 0x74, 0x86, 0x5d, 0x4b, 0xc7, + 0x8c, 0x4c, 0xfe, 0x13, 0x09, 0x5e, 0xba, 0xe8, 0x6b, 0x02, 0x1a, 0xc0, 0x42, 0xe4, 0xcb, 0x44, + 0xcc, 0x8d, 0xf2, 0x45, 0x1f, 0x26, 0x84, 0x13, 0x23, 0x9f, 0x22, 0x84, 0x1b, 0xe3, 0x0f, 0x97, + 0xb9, 0xd9, 0x87, 0x4b, 0x92, 0x7c, 0xd1, 0xe0, 0x1e, 0x7b, 0xf8, 0xcd, 0x3e, 0x83, 0x5c, 0xfc, + 0xc0, 0xd1, 0xfe, 0x34, 0x3b, 0xfb, 0x76, 0xf1, 0x06, 0x20, 0xc3, 0x9c, 0x5e, 0xf1, 0x23, 0x7d, + 0xbc, 0x80, 0x5b, 0x0c, 0x13, 0xad, 0x74, 0x77, 0xe1, 0x6a, 0xcc, 0x2d, 0xe1, 0xdd, 0x47, 0x58, + 0xb4, 0x18, 0xb5, 0x3b, 0xb8, 0x04, 0xcd, 0x36, 0x20, 0xe9, 0x32, 0x0d, 0x48, 0xfe, 0xdb, 0x2c, + 0xb4, 0x66, 0x1f, 0xbc, 0xd0, 0xbb, 0x50, 0x1e, 0x59, 0xa6, 0xeb, 0xa9, 0xa6, 0x27, 0xa2, 0x71, + 0xf1, 0x65, 0x76, 0x27, 0x83, 0x43, 0x06, 0xb4, 0x36, 0xd3, 0x79, 0xe7, 0x3e, 0x62, 0x45, 0x7a, + 0xed, 0x1a, 0xe4, 0x4f, 0x7c, 0x73, 0x24, 0xbe, 0x35, 0xbf, 0x34, 0x6f, 0xb3, 0x2d, 0xdf, 0x1c, + 0xed, 0x64, 0x30, 0xa3, 0x9d, 0x76, 0xb7, 0xbf, 0xcb, 0x41, 0x35, 0xa2, 0x0c, 0xba, 0x03, 0x15, + 0x5a, 0x11, 0x9e, 0xd7, 0x86, 0x59, 0xd9, 0x60, 0x4d, 0x78, 0x05, 0xe0, 0xd8, 0xb2, 0xc6, 0xca, + 0xb4, 0x04, 0x96, 0x77, 0x32, 0xb8, 0x42, 0x61, 0x5c, 0xe2, 0xcb, 0x50, 0x35, 0x4c, 0xef, 0xde, + 0xdd, 0xc8, 0x24, 0x40, 0x47, 0x3a, 0x30, 0xc2, 0x2f, 0x3d, 0xe8, 0x55, 0xa8, 0xb3, 0x71, 0x30, + 0x24, 0xa2, 0x35, 0x2d, 0xbb, 0x93, 0xc1, 0x35, 0x01, 0xe6, 0x64, 0xb3, 0x43, 0x45, 0x21, 0x65, + 0xa8, 0x40, 0xb7, 0x80, 0xf5, 0xbe, 0x7b, 0x77, 0x15, 0xd3, 0x15, 0x74, 0x45, 0xb1, 0x65, 0x9d, + 0x23, 0xf6, 0x5d, 0x4e, 0x79, 0x1f, 0xea, 0xbe, 0x61, 0x7a, 0x6f, 0xad, 0xdd, 0x17, 0x74, 0xfc, + 0x53, 0xee, 0xc2, 0xd4, 0xdc, 0xa3, 0x3e, 0x43, 0xb3, 0x4f, 0xa4, 0x9c, 0x92, 0x4f, 0xbd, 0x81, + 0xf7, 0x1e, 0xe5, 0xcb, 0xe5, 0x56, 0x45, 0xfe, 0x3c, 0x0b, 0x30, 0xf5, 0x71, 0xea, 0x84, 0xf0, + 0x00, 0x2a, 0x86, 0x69, 0x78, 0x8a, 0xea, 0xe8, 0x97, 0x7c, 0xe2, 0x28, 0x53, 0xfa, 0xae, 0xa3, + 0xbb, 0xe8, 0x1e, 0xe4, 0x19, 0x9b, 0x74, 0xe9, 0xf7, 0x71, 0x46, 0x2f, 0xfe, 0x55, 0x05, 0x6f, + 0x67, 0x39, 0x43, 0x43, 0x0f, 0xa0, 0x49, 0xe1, 0x4a, 0x18, 0x5f, 0x5e, 0x8a, 0xd2, 0x03, 0x5c, + 0xa7, 0xa4, 0xc1, 0xca, 0x95, 0xff, 0x23, 0x07, 0x57, 0x52, 0x1e, 0xc3, 0x43, 0x5b, 0xa5, 0x79, + 0xb6, 0xe6, 0xbf, 0x99, 0xad, 0xdf, 0x13, 0xb6, 0xf2, 0x1a, 0xf9, 0xfa, 0xa5, 0x5e, 0xe4, 0x57, + 0xbb, 0x8e, 0x1e, 0x33, 0xb9, 0x78, 0x91, 0xc9, 0xa5, 0x4b, 0x9a, 0xdc, 0xfe, 0x5d, 0x90, 0xba, + 0x8e, 0xfe, 0x7f, 0x7e, 0x9c, 0xa7, 0x47, 0x73, 0x2d, 0x9c, 0x8e, 0xa9, 0x97, 0x2d, 0x8d, 0x88, + 0x07, 0x3c, 0xf6, 0x9b, 0x4e, 0x1d, 0xd1, 0x27, 0x3b, 0xbe, 0xb8, 0xfd, 0x57, 0x12, 0xd4, 0xa2, + 0xff, 0xc0, 0x05, 0x5d, 0x83, 0xa5, 0xc1, 0x41, 0x0f, 0x77, 0x87, 0x03, 0xac, 0x0c, 0x7f, 0x74, + 0xd0, 0x53, 0x8e, 0xf6, 0xdf, 0xdf, 0x1f, 0xfc, 0x70, 0xbf, 0x95, 0x41, 0x2f, 0xc2, 0xd5, 0xbd, + 0xde, 0xde, 0x00, 0xff, 0x48, 0x39, 0x1c, 0x1c, 0xe1, 0x8d, 0x9e, 0x12, 0x10, 0xb6, 0xbe, 0x2a, + 0xa1, 0x6b, 0xb0, 0xb8, 0x8d, 0x0f, 0x36, 0x12, 0xa8, 0x7f, 0x2a, 0x53, 0xd4, 0xd1, 0xe6, 0x70, + 0x2b, 0x81, 0xfa, 0x59, 0x05, 0xb5, 0x61, 0xa9, 0xb7, 0x77, 0x30, 0x4c, 0x4a, 0xfc, 0x43, 0x40, + 0x2b, 0xd0, 0xde, 0xd8, 0xed, 0x6f, 0xbc, 0xbf, 0x33, 0x38, 0x3a, 0xec, 0x25, 0x08, 0xfe, 0x13, + 0xd0, 0x02, 0xd4, 0xf6, 0xba, 0x07, 0x53, 0xd0, 0x67, 0x4d, 0xf4, 0x02, 0xa0, 0xee, 0xf6, 0x36, + 0xee, 0x6d, 0x77, 0x87, 0x11, 0xda, 0xbf, 0x6e, 0xa1, 0x45, 0x68, 0x6e, 0xf5, 0x77, 0x87, 0x3d, + 0x3c, 0x85, 0xfe, 0xd1, 0x02, 0xba, 0x02, 0x8d, 0xdd, 0xfe, 0x5e, 0x7f, 0x38, 0x05, 0xfe, 0x17, + 0x03, 0x1e, 0xed, 0xf7, 0x07, 0xfb, 0x53, 0xe0, 0xe7, 0x08, 0x21, 0xa8, 0x3f, 0x1a, 0xf4, 0x23, + 0xb0, 0x7f, 0xb8, 0x42, 0xed, 0x0a, 0xfc, 0xd1, 0xdf, 0x7f, 0x7f, 0x8a, 0xfa, 0x74, 0x8b, 0xea, + 0xc1, 0xbd, 0x11, 0x43, 0xfc, 0x74, 0x1b, 0x75, 0xe0, 0xda, 0x60, 0xd8, 0xdb, 0x55, 0x7a, 0xbf, + 0x79, 0x30, 0xc0, 0xc3, 0x19, 0xfc, 0xd7, 0xdb, 0xe8, 0x26, 0xac, 0x44, 0x8c, 0x4e, 0xa5, 0xfa, + 0xb7, 0x9d, 0xf5, 0x87, 0x9f, 0x7d, 0xd1, 0xc9, 0xfc, 0xf2, 0x8b, 0x4e, 0xe6, 0xeb, 0x2f, 0x3a, + 0xd9, 0x9f, 0x9c, 0x77, 0xb2, 0x9f, 0x9e, 0x77, 0xb2, 0xff, 0x78, 0xde, 0xc9, 0x7e, 0x76, 0xde, + 0xc9, 0x7e, 0x7e, 0xde, 0xc9, 0x7e, 0x75, 0xde, 0xc9, 0x7c, 0x7d, 0xde, 0xc9, 0xfe, 0xc1, 0x97, + 0x9d, 0xcc, 0x67, 0x5f, 0x76, 0x32, 0xbf, 0xfc, 0xb2, 0x93, 0xf9, 0xad, 0x22, 0xcf, 0xa0, 0xe3, + 0x22, 0xfb, 0x78, 0xfe, 0xf6, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0xa6, 0x01, 0x0f, 0xea, 0x8a, + 0x29, 0x00, 0x00, } func (x OperatorType) String() string { @@ -4085,6 +4496,54 @@ func (this *Operator_OTelSinkOp) Equal(that interface{}) bool { } return true } +func (this *Operator_ClickhouseSourceOp) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*Operator_ClickhouseSourceOp) + if !ok { + that2, ok := that.(Operator_ClickhouseSourceOp) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.ClickhouseSourceOp.Equal(that1.ClickhouseSourceOp) { + return false + } + return true +} +func (this *Operator_ClickhouseSinkOp) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*Operator_ClickhouseSinkOp) + if !ok { + that2, ok := that.(Operator_ClickhouseSinkOp) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.ClickhouseSinkOp.Equal(that1.ClickhouseSinkOp) { + return false + } + return true +} func (this *MemorySourceOperator) Equal(that interface{}) bool { if that == nil { return this == nil @@ -4800,6 +5259,79 @@ func (this *EmptySourceOperator) Equal(that interface{}) bool { } return true } +func (this *ClickHouseSourceOperator) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*ClickHouseSourceOperator) + if !ok { + that2, ok := that.(ClickHouseSourceOperator) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Host != that1.Host { + return false + } + if this.Port != that1.Port { + return false + } + if this.Username != that1.Username { + return false + } + if this.Password != that1.Password { + return false + } + if this.Database != that1.Database { + return false + } + if this.Query != that1.Query { + return false + } + if len(this.ColumnNames) != len(that1.ColumnNames) { + return false + } + for i := range this.ColumnNames { + if this.ColumnNames[i] != that1.ColumnNames[i] { + return false + } + } + if len(this.ColumnTypes) != len(that1.ColumnTypes) { + return false + } + for i := range this.ColumnTypes { + if this.ColumnTypes[i] != that1.ColumnTypes[i] { + return false + } + } + if this.BatchSize != that1.BatchSize { + return false + } + if this.Streaming != that1.Streaming { + return false + } + if this.TimestampColumn != that1.TimestampColumn { + return false + } + if this.PartitionColumn != that1.PartitionColumn { + return false + } + if this.StartTime != that1.StartTime { + return false + } + if this.EndTime != that1.EndTime { + return false + } + return true +} func (this *OTelLog) Equal(that interface{}) bool { if that == nil { return this == nil @@ -5335,6 +5867,45 @@ func (this *OTelEndpointConfig) Equal(that interface{}) bool { } return true } +func (this *ClickHouseConfig) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*ClickHouseConfig) + if !ok { + that2, ok := that.(ClickHouseConfig) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Hostname != that1.Hostname { + return false + } + if this.Host != that1.Host { + return false + } + if this.Port != that1.Port { + return false + } + if this.Username != that1.Username { + return false + } + if this.Password != that1.Password { + return false + } + if this.Database != that1.Database { + return false + } + return true +} func (this *OTelResource) Equal(that interface{}) bool { if that == nil { return this == nil @@ -5415,6 +5986,71 @@ func (this *OTelExportSinkOperator) Equal(that interface{}) bool { } return true } +func (this *ClickHouseExportSinkOperator) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*ClickHouseExportSinkOperator) + if !ok { + that2, ok := that.(ClickHouseExportSinkOperator) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.ClickhouseConfig.Equal(that1.ClickhouseConfig) { + return false + } + if this.TableName != that1.TableName { + return false + } + if len(this.ColumnMappings) != len(that1.ColumnMappings) { + return false + } + for i := range this.ColumnMappings { + if !this.ColumnMappings[i].Equal(that1.ColumnMappings[i]) { + return false + } + } + return true +} +func (this *ClickHouseExportSinkOperator_ColumnMapping) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*ClickHouseExportSinkOperator_ColumnMapping) + if !ok { + that2, ok := that.(ClickHouseExportSinkOperator_ColumnMapping) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.InputColumnIndex != that1.InputColumnIndex { + return false + } + if this.ClickhouseColumnName != that1.ClickhouseColumnName { + return false + } + if this.ColumnType != that1.ColumnType { + return false + } + return true +} func (this *ScalarExpression) Equal(that interface{}) bool { if that == nil { return this == nil @@ -6005,7 +6641,7 @@ func (this *Operator) GoString() string { if this == nil { return "nil" } - s := make([]string, 0, 18) + s := make([]string, 0, 20) s = append(s, "&planpb.Operator{") s = append(s, "OpType: "+fmt.Sprintf("%#v", this.OpType)+",\n") if this.Op != nil { @@ -6118,6 +6754,22 @@ func (this *Operator_OTelSinkOp) GoString() string { `OTelSinkOp:` + fmt.Sprintf("%#v", this.OTelSinkOp) + `}`}, ", ") return s } +func (this *Operator_ClickhouseSourceOp) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&planpb.Operator_ClickhouseSourceOp{` + + `ClickhouseSourceOp:` + fmt.Sprintf("%#v", this.ClickhouseSourceOp) + `}`}, ", ") + return s +} +func (this *Operator_ClickhouseSinkOp) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&planpb.Operator_ClickhouseSinkOp{` + + `ClickhouseSinkOp:` + fmt.Sprintf("%#v", this.ClickhouseSinkOp) + `}`}, ", ") + return s +} func (this *MemorySourceOperator) GoString() string { if this == nil { return "nil" @@ -6368,6 +7020,29 @@ func (this *EmptySourceOperator) GoString() string { s = append(s, "}") return strings.Join(s, "") } +func (this *ClickHouseSourceOperator) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 18) + s = append(s, "&planpb.ClickHouseSourceOperator{") + s = append(s, "Host: "+fmt.Sprintf("%#v", this.Host)+",\n") + s = append(s, "Port: "+fmt.Sprintf("%#v", this.Port)+",\n") + s = append(s, "Username: "+fmt.Sprintf("%#v", this.Username)+",\n") + s = append(s, "Password: "+fmt.Sprintf("%#v", this.Password)+",\n") + s = append(s, "Database: "+fmt.Sprintf("%#v", this.Database)+",\n") + s = append(s, "Query: "+fmt.Sprintf("%#v", this.Query)+",\n") + s = append(s, "ColumnNames: "+fmt.Sprintf("%#v", this.ColumnNames)+",\n") + s = append(s, "ColumnTypes: "+fmt.Sprintf("%#v", this.ColumnTypes)+",\n") + s = append(s, "BatchSize: "+fmt.Sprintf("%#v", this.BatchSize)+",\n") + s = append(s, "Streaming: "+fmt.Sprintf("%#v", this.Streaming)+",\n") + s = append(s, "TimestampColumn: "+fmt.Sprintf("%#v", this.TimestampColumn)+",\n") + s = append(s, "PartitionColumn: "+fmt.Sprintf("%#v", this.PartitionColumn)+",\n") + s = append(s, "StartTime: "+fmt.Sprintf("%#v", this.StartTime)+",\n") + s = append(s, "EndTime: "+fmt.Sprintf("%#v", this.EndTime)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} func (this *OTelLog) GoString() string { if this == nil { return "nil" @@ -6576,6 +7251,21 @@ func (this *OTelEndpointConfig) GoString() string { s = append(s, "}") return strings.Join(s, "") } +func (this *ClickHouseConfig) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 10) + s = append(s, "&planpb.ClickHouseConfig{") + s = append(s, "Hostname: "+fmt.Sprintf("%#v", this.Hostname)+",\n") + s = append(s, "Host: "+fmt.Sprintf("%#v", this.Host)+",\n") + s = append(s, "Port: "+fmt.Sprintf("%#v", this.Port)+",\n") + s = append(s, "Username: "+fmt.Sprintf("%#v", this.Username)+",\n") + s = append(s, "Password: "+fmt.Sprintf("%#v", this.Password)+",\n") + s = append(s, "Database: "+fmt.Sprintf("%#v", this.Database)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} func (this *OTelResource) GoString() string { if this == nil { return "nil" @@ -6612,6 +7302,34 @@ func (this *OTelExportSinkOperator) GoString() string { s = append(s, "}") return strings.Join(s, "") } +func (this *ClickHouseExportSinkOperator) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&planpb.ClickHouseExportSinkOperator{") + if this.ClickhouseConfig != nil { + s = append(s, "ClickhouseConfig: "+fmt.Sprintf("%#v", this.ClickhouseConfig)+",\n") + } + s = append(s, "TableName: "+fmt.Sprintf("%#v", this.TableName)+",\n") + if this.ColumnMappings != nil { + s = append(s, "ColumnMappings: "+fmt.Sprintf("%#v", this.ColumnMappings)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *ClickHouseExportSinkOperator_ColumnMapping) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&planpb.ClickHouseExportSinkOperator_ColumnMapping{") + s = append(s, "InputColumnIndex: "+fmt.Sprintf("%#v", this.InputColumnIndex)+",\n") + s = append(s, "ClickhouseColumnName: "+fmt.Sprintf("%#v", this.ClickhouseColumnName)+",\n") + s = append(s, "ColumnType: "+fmt.Sprintf("%#v", this.ColumnType)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} func (this *ScalarExpression) GoString() string { if this == nil { return "nil" @@ -7450,16 +8168,16 @@ func (m *Operator_OTelSinkOp) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } -func (m *Operator_GRPCSinkOp) MarshalTo(dAtA []byte) (int, error) { +func (m *Operator_ClickhouseSourceOp) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Operator_GRPCSinkOp) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Operator_ClickhouseSourceOp) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.GRPCSinkOp != nil { + if m.ClickhouseSourceOp != nil { { - size, err := m.GRPCSinkOp.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.ClickhouseSourceOp.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -7467,30 +8185,74 @@ func (m *Operator_GRPCSinkOp) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintPlan(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x3e - i-- - dAtA[i] = 0xc2 + dAtA[i] = 0x7a } return len(dAtA) - i, nil } -func (m *MemorySourceOperator) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *MemorySourceOperator) MarshalTo(dAtA []byte) (int, error) { +func (m *Operator_ClickhouseSinkOp) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MemorySourceOperator) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Operator_ClickhouseSinkOp) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - _ = i + if m.ClickhouseSinkOp != nil { + { + size, err := m.ClickhouseSinkOp.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPlan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + return len(dAtA) - i, nil +} +func (m *Operator_GRPCSinkOp) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Operator_GRPCSinkOp) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.GRPCSinkOp != nil { + { + size, err := m.GRPCSinkOp.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPlan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3e + i-- + dAtA[i] = 0xc2 + } + return len(dAtA) - i, nil +} +func (m *MemorySourceOperator) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MemorySourceOperator) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MemorySourceOperator) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l if m.Streaming { @@ -7535,20 +8297,20 @@ func (m *MemorySourceOperator) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0x2a } if len(m.ColumnTypes) > 0 { - dAtA25 := make([]byte, len(m.ColumnTypes)*10) - var j24 int + dAtA27 := make([]byte, len(m.ColumnTypes)*10) + var j26 int for _, num := range m.ColumnTypes { for num >= 1<<7 { - dAtA25[j24] = uint8(uint64(num)&0x7f | 0x80) + dAtA27[j26] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j24++ + j26++ } - dAtA25[j24] = uint8(num) - j24++ + dAtA27[j26] = uint8(num) + j26++ } - i -= j24 - copy(dAtA[i:], dAtA25[:j24]) - i = encodeVarintPlan(dAtA, i, uint64(j24)) + i -= j26 + copy(dAtA[i:], dAtA27[:j26]) + i = encodeVarintPlan(dAtA, i, uint64(j26)) i-- dAtA[i] = 0x22 } @@ -7562,21 +8324,21 @@ func (m *MemorySourceOperator) MarshalToSizedBuffer(dAtA []byte) (int, error) { } } if len(m.ColumnIdxs) > 0 { - dAtA27 := make([]byte, len(m.ColumnIdxs)*10) - var j26 int + dAtA29 := make([]byte, len(m.ColumnIdxs)*10) + var j28 int for _, num1 := range m.ColumnIdxs { num := uint64(num1) for num >= 1<<7 { - dAtA27[j26] = uint8(uint64(num)&0x7f | 0x80) + dAtA29[j28] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j26++ + j28++ } - dAtA27[j26] = uint8(num) - j26++ + dAtA29[j28] = uint8(num) + j28++ } - i -= j26 - copy(dAtA[i:], dAtA27[:j26]) - i = encodeVarintPlan(dAtA, i, uint64(j26)) + i -= j28 + copy(dAtA[i:], dAtA29[:j28]) + i = encodeVarintPlan(dAtA, i, uint64(j28)) i-- dAtA[i] = 0x12 } @@ -7611,20 +8373,20 @@ func (m *MemorySinkOperator) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l if len(m.ColumnSemanticTypes) > 0 { - dAtA29 := make([]byte, len(m.ColumnSemanticTypes)*10) - var j28 int + dAtA31 := make([]byte, len(m.ColumnSemanticTypes)*10) + var j30 int for _, num := range m.ColumnSemanticTypes { for num >= 1<<7 { - dAtA29[j28] = uint8(uint64(num)&0x7f | 0x80) + dAtA31[j30] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j28++ + j30++ } - dAtA29[j28] = uint8(num) - j28++ + dAtA31[j30] = uint8(num) + j30++ } - i -= j28 - copy(dAtA[i:], dAtA29[:j28]) - i = encodeVarintPlan(dAtA, i, uint64(j28)) + i -= j30 + copy(dAtA[i:], dAtA31[:j30]) + i = encodeVarintPlan(dAtA, i, uint64(j30)) i-- dAtA[i] = 0x22 } @@ -7638,20 +8400,20 @@ func (m *MemorySinkOperator) MarshalToSizedBuffer(dAtA []byte) (int, error) { } } if len(m.ColumnTypes) > 0 { - dAtA31 := make([]byte, len(m.ColumnTypes)*10) - var j30 int + dAtA33 := make([]byte, len(m.ColumnTypes)*10) + var j32 int for _, num := range m.ColumnTypes { for num >= 1<<7 { - dAtA31[j30] = uint8(uint64(num)&0x7f | 0x80) + dAtA33[j32] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j30++ + j32++ } - dAtA31[j30] = uint8(num) - j30++ + dAtA33[j32] = uint8(num) + j32++ } - i -= j30 - copy(dAtA[i:], dAtA31[:j30]) - i = encodeVarintPlan(dAtA, i, uint64(j30)) + i -= j32 + copy(dAtA[i:], dAtA33[:j32]) + i = encodeVarintPlan(dAtA, i, uint64(j32)) i-- dAtA[i] = 0x12 } @@ -7695,20 +8457,20 @@ func (m *GRPCSourceOperator) MarshalToSizedBuffer(dAtA []byte) (int, error) { } } if len(m.ColumnTypes) > 0 { - dAtA33 := make([]byte, len(m.ColumnTypes)*10) - var j32 int + dAtA35 := make([]byte, len(m.ColumnTypes)*10) + var j34 int for _, num := range m.ColumnTypes { for num >= 1<<7 { - dAtA33[j32] = uint8(uint64(num)&0x7f | 0x80) + dAtA35[j34] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j32++ + j34++ } - dAtA33[j32] = uint8(num) - j32++ + dAtA35[j34] = uint8(num) + j34++ } - i -= j32 - copy(dAtA[i:], dAtA33[:j32]) - i = encodeVarintPlan(dAtA, i, uint64(j32)) + i -= j34 + copy(dAtA[i:], dAtA35[:j34]) + i = encodeVarintPlan(dAtA, i, uint64(j34)) i-- dAtA[i] = 0xa } @@ -7820,20 +8582,20 @@ func (m *GRPCSinkOperator_ResultTable) MarshalToSizedBuffer(dAtA []byte) (int, e var l int _ = l if len(m.ColumnSemanticTypes) > 0 { - dAtA37 := make([]byte, len(m.ColumnSemanticTypes)*10) - var j36 int + dAtA39 := make([]byte, len(m.ColumnSemanticTypes)*10) + var j38 int for _, num := range m.ColumnSemanticTypes { for num >= 1<<7 { - dAtA37[j36] = uint8(uint64(num)&0x7f | 0x80) + dAtA39[j38] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j36++ + j38++ } - dAtA37[j36] = uint8(num) - j36++ + dAtA39[j38] = uint8(num) + j38++ } - i -= j36 - copy(dAtA[i:], dAtA37[:j36]) - i = encodeVarintPlan(dAtA, i, uint64(j36)) + i -= j38 + copy(dAtA[i:], dAtA39[:j38]) + i = encodeVarintPlan(dAtA, i, uint64(j38)) i-- dAtA[i] = 0x22 } @@ -7847,20 +8609,20 @@ func (m *GRPCSinkOperator_ResultTable) MarshalToSizedBuffer(dAtA []byte) (int, e } } if len(m.ColumnTypes) > 0 { - dAtA39 := make([]byte, len(m.ColumnTypes)*10) - var j38 int + dAtA41 := make([]byte, len(m.ColumnTypes)*10) + var j40 int for _, num := range m.ColumnTypes { for num >= 1<<7 { - dAtA39[j38] = uint8(uint64(num)&0x7f | 0x80) + dAtA41[j40] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j38++ + j40++ } - dAtA39[j38] = uint8(num) - j38++ + dAtA41[j40] = uint8(num) + j40++ } - i -= j38 - copy(dAtA[i:], dAtA39[:j38]) - i = encodeVarintPlan(dAtA, i, uint64(j38)) + i -= j40 + copy(dAtA[i:], dAtA41[:j40]) + i = encodeVarintPlan(dAtA, i, uint64(j40)) i-- dAtA[i] = 0x12 } @@ -8119,20 +8881,20 @@ func (m *LimitOperator) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l if len(m.AbortableSrcs) > 0 { - dAtA42 := make([]byte, len(m.AbortableSrcs)*10) - var j41 int + dAtA44 := make([]byte, len(m.AbortableSrcs)*10) + var j43 int for _, num := range m.AbortableSrcs { for num >= 1<<7 { - dAtA42[j41] = uint8(uint64(num)&0x7f | 0x80) + dAtA44[j43] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j41++ + j43++ } - dAtA42[j41] = uint8(num) - j41++ + dAtA44[j43] = uint8(num) + j43++ } - i -= j41 - copy(dAtA[i:], dAtA42[:j41]) - i = encodeVarintPlan(dAtA, i, uint64(j41)) + i -= j43 + copy(dAtA[i:], dAtA44[:j43]) + i = encodeVarintPlan(dAtA, i, uint64(j43)) i-- dAtA[i] = 0x1a } @@ -8230,21 +8992,21 @@ func (m *UnionOperator_ColumnMapping) MarshalToSizedBuffer(dAtA []byte) (int, er var l int _ = l if len(m.ColumnIndexes) > 0 { - dAtA44 := make([]byte, len(m.ColumnIndexes)*10) - var j43 int + dAtA46 := make([]byte, len(m.ColumnIndexes)*10) + var j45 int for _, num1 := range m.ColumnIndexes { num := uint64(num1) for num >= 1<<7 { - dAtA44[j43] = uint8(uint64(num)&0x7f | 0x80) + dAtA46[j45] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j43++ + j45++ } - dAtA44[j43] = uint8(num) - j43++ + dAtA46[j45] = uint8(num) + j45++ } - i -= j43 - copy(dAtA[i:], dAtA44[:j43]) - i = encodeVarintPlan(dAtA, i, uint64(j43)) + i -= j45 + copy(dAtA[i:], dAtA46[:j45]) + i = encodeVarintPlan(dAtA, i, uint64(j45)) i-- dAtA[i] = 0xa } @@ -8452,20 +9214,20 @@ func (m *EmptySourceOperator) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l if len(m.ColumnTypes) > 0 { - dAtA46 := make([]byte, len(m.ColumnTypes)*10) - var j45 int + dAtA48 := make([]byte, len(m.ColumnTypes)*10) + var j47 int for _, num := range m.ColumnTypes { for num >= 1<<7 { - dAtA46[j45] = uint8(uint64(num)&0x7f | 0x80) + dAtA48[j47] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j45++ + j47++ } - dAtA46[j45] = uint8(num) - j45++ + dAtA48[j47] = uint8(num) + j47++ } - i -= j45 - copy(dAtA[i:], dAtA46[:j45]) - i = encodeVarintPlan(dAtA, i, uint64(j45)) + i -= j47 + copy(dAtA[i:], dAtA48[:j47]) + i = encodeVarintPlan(dAtA, i, uint64(j47)) i-- dAtA[i] = 0x12 } @@ -8481,6 +9243,135 @@ func (m *EmptySourceOperator) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *ClickHouseSourceOperator) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClickHouseSourceOperator) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ClickHouseSourceOperator) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.EndTime != 0 { + i = encodeVarintPlan(dAtA, i, uint64(m.EndTime)) + i-- + dAtA[i] = 0x70 + } + if m.StartTime != 0 { + i = encodeVarintPlan(dAtA, i, uint64(m.StartTime)) + i-- + dAtA[i] = 0x68 + } + if len(m.PartitionColumn) > 0 { + i -= len(m.PartitionColumn) + copy(dAtA[i:], m.PartitionColumn) + i = encodeVarintPlan(dAtA, i, uint64(len(m.PartitionColumn))) + i-- + dAtA[i] = 0x62 + } + if len(m.TimestampColumn) > 0 { + i -= len(m.TimestampColumn) + copy(dAtA[i:], m.TimestampColumn) + i = encodeVarintPlan(dAtA, i, uint64(len(m.TimestampColumn))) + i-- + dAtA[i] = 0x5a + } + if m.Streaming { + i-- + if m.Streaming { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x50 + } + if m.BatchSize != 0 { + i = encodeVarintPlan(dAtA, i, uint64(m.BatchSize)) + i-- + dAtA[i] = 0x48 + } + if len(m.ColumnTypes) > 0 { + dAtA50 := make([]byte, len(m.ColumnTypes)*10) + var j49 int + for _, num := range m.ColumnTypes { + for num >= 1<<7 { + dAtA50[j49] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j49++ + } + dAtA50[j49] = uint8(num) + j49++ + } + i -= j49 + copy(dAtA[i:], dAtA50[:j49]) + i = encodeVarintPlan(dAtA, i, uint64(j49)) + i-- + dAtA[i] = 0x42 + } + if len(m.ColumnNames) > 0 { + for iNdEx := len(m.ColumnNames) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.ColumnNames[iNdEx]) + copy(dAtA[i:], m.ColumnNames[iNdEx]) + i = encodeVarintPlan(dAtA, i, uint64(len(m.ColumnNames[iNdEx]))) + i-- + dAtA[i] = 0x3a + } + } + if len(m.Query) > 0 { + i -= len(m.Query) + copy(dAtA[i:], m.Query) + i = encodeVarintPlan(dAtA, i, uint64(len(m.Query))) + i-- + dAtA[i] = 0x32 + } + if len(m.Database) > 0 { + i -= len(m.Database) + copy(dAtA[i:], m.Database) + i = encodeVarintPlan(dAtA, i, uint64(len(m.Database))) + i-- + dAtA[i] = 0x2a + } + if len(m.Password) > 0 { + i -= len(m.Password) + copy(dAtA[i:], m.Password) + i = encodeVarintPlan(dAtA, i, uint64(len(m.Password))) + i-- + dAtA[i] = 0x22 + } + if len(m.Username) > 0 { + i -= len(m.Username) + copy(dAtA[i:], m.Username) + i = encodeVarintPlan(dAtA, i, uint64(len(m.Username))) + i-- + dAtA[i] = 0x1a + } + if m.Port != 0 { + i = encodeVarintPlan(dAtA, i, uint64(m.Port)) + i-- + dAtA[i] = 0x10 + } + if len(m.Host) > 0 { + i -= len(m.Host) + copy(dAtA[i:], m.Host) + i = encodeVarintPlan(dAtA, i, uint64(len(m.Host))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *OTelLog) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -9083,7 +9974,7 @@ func (m *OTelEndpointConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *OTelResource) Marshal() (dAtA []byte, err error) { +func (m *ClickHouseConfig) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -9093,25 +9984,88 @@ func (m *OTelResource) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *OTelResource) MarshalTo(dAtA []byte) (int, error) { +func (m *ClickHouseConfig) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *OTelResource) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ClickHouseConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.Attributes) > 0 { - for iNdEx := len(m.Attributes) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Attributes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPlan(dAtA, i, uint64(size)) + if len(m.Database) > 0 { + i -= len(m.Database) + copy(dAtA[i:], m.Database) + i = encodeVarintPlan(dAtA, i, uint64(len(m.Database))) + i-- + dAtA[i] = 0x32 + } + if len(m.Password) > 0 { + i -= len(m.Password) + copy(dAtA[i:], m.Password) + i = encodeVarintPlan(dAtA, i, uint64(len(m.Password))) + i-- + dAtA[i] = 0x2a + } + if len(m.Username) > 0 { + i -= len(m.Username) + copy(dAtA[i:], m.Username) + i = encodeVarintPlan(dAtA, i, uint64(len(m.Username))) + i-- + dAtA[i] = 0x22 + } + if m.Port != 0 { + i = encodeVarintPlan(dAtA, i, uint64(m.Port)) + i-- + dAtA[i] = 0x18 + } + if len(m.Host) > 0 { + i -= len(m.Host) + copy(dAtA[i:], m.Host) + i = encodeVarintPlan(dAtA, i, uint64(len(m.Host))) + i-- + dAtA[i] = 0x12 + } + if len(m.Hostname) > 0 { + i -= len(m.Hostname) + copy(dAtA[i:], m.Hostname) + i = encodeVarintPlan(dAtA, i, uint64(len(m.Hostname))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *OTelResource) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *OTelResource) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OTelResource) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Attributes) > 0 { + for iNdEx := len(m.Attributes) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Attributes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPlan(dAtA, i, uint64(size)) } i-- dAtA[i] = 0xa @@ -9209,6 +10163,102 @@ func (m *OTelExportSinkOperator) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } +func (m *ClickHouseExportSinkOperator) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClickHouseExportSinkOperator) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ClickHouseExportSinkOperator) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ColumnMappings) > 0 { + for iNdEx := len(m.ColumnMappings) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ColumnMappings[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPlan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if len(m.TableName) > 0 { + i -= len(m.TableName) + copy(dAtA[i:], m.TableName) + i = encodeVarintPlan(dAtA, i, uint64(len(m.TableName))) + i-- + dAtA[i] = 0x12 + } + if m.ClickhouseConfig != nil { + { + size, err := m.ClickhouseConfig.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPlan(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClickHouseExportSinkOperator_ColumnMapping) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ClickHouseExportSinkOperator_ColumnMapping) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ClickHouseExportSinkOperator_ColumnMapping) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ColumnType != 0 { + i = encodeVarintPlan(dAtA, i, uint64(m.ColumnType)) + i-- + dAtA[i] = 0x18 + } + if len(m.ClickhouseColumnName) > 0 { + i -= len(m.ClickhouseColumnName) + copy(dAtA[i:], m.ClickhouseColumnName) + i = encodeVarintPlan(dAtA, i, uint64(len(m.ClickhouseColumnName))) + i-- + dAtA[i] = 0x12 + } + if m.InputColumnIndex != 0 { + i = encodeVarintPlan(dAtA, i, uint64(m.InputColumnIndex)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func (m *ScalarExpression) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -9451,20 +10501,20 @@ func (m *ScalarFunc) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l if len(m.ArgsDataTypes) > 0 { - dAtA57 := make([]byte, len(m.ArgsDataTypes)*10) - var j56 int + dAtA62 := make([]byte, len(m.ArgsDataTypes)*10) + var j61 int for _, num := range m.ArgsDataTypes { for num >= 1<<7 { - dAtA57[j56] = uint8(uint64(num)&0x7f | 0x80) + dAtA62[j61] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j56++ + j61++ } - dAtA57[j56] = uint8(num) - j56++ + dAtA62[j61] = uint8(num) + j61++ } - i -= j56 - copy(dAtA[i:], dAtA57[:j56]) - i = encodeVarintPlan(dAtA, i, uint64(j56)) + i -= j61 + copy(dAtA[i:], dAtA62[:j61]) + i = encodeVarintPlan(dAtA, i, uint64(j61)) i-- dAtA[i] = 0x2a } @@ -9532,20 +10582,20 @@ func (m *AggregateExpression) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l if len(m.ArgsDataTypes) > 0 { - dAtA59 := make([]byte, len(m.ArgsDataTypes)*10) - var j58 int + dAtA64 := make([]byte, len(m.ArgsDataTypes)*10) + var j63 int for _, num := range m.ArgsDataTypes { for num >= 1<<7 { - dAtA59[j58] = uint8(uint64(num)&0x7f | 0x80) + dAtA64[j63] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j58++ + j63++ } - dAtA59[j58] = uint8(num) - j58++ + dAtA64[j63] = uint8(num) + j63++ } - i -= j58 - copy(dAtA[i:], dAtA59[:j58]) - i = encodeVarintPlan(dAtA, i, uint64(j58)) + i -= j63 + copy(dAtA[i:], dAtA64[:j63]) + i = encodeVarintPlan(dAtA, i, uint64(j63)) i-- dAtA[i] = 0x3a } @@ -10018,6 +11068,30 @@ func (m *Operator_OTelSinkOp) Size() (n int) { } return n } +func (m *Operator_ClickhouseSourceOp) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ClickhouseSourceOp != nil { + l = m.ClickhouseSourceOp.Size() + n += 1 + l + sovPlan(uint64(l)) + } + return n +} +func (m *Operator_ClickhouseSinkOp) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ClickhouseSinkOp != nil { + l = m.ClickhouseSinkOp.Size() + n += 2 + l + sovPlan(uint64(l)) + } + return n +} func (m *Operator_GRPCSinkOp) Size() (n int) { if m == nil { return 0 @@ -10471,6 +11545,71 @@ func (m *EmptySourceOperator) Size() (n int) { return n } +func (m *ClickHouseSourceOperator) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Host) + if l > 0 { + n += 1 + l + sovPlan(uint64(l)) + } + if m.Port != 0 { + n += 1 + sovPlan(uint64(m.Port)) + } + l = len(m.Username) + if l > 0 { + n += 1 + l + sovPlan(uint64(l)) + } + l = len(m.Password) + if l > 0 { + n += 1 + l + sovPlan(uint64(l)) + } + l = len(m.Database) + if l > 0 { + n += 1 + l + sovPlan(uint64(l)) + } + l = len(m.Query) + if l > 0 { + n += 1 + l + sovPlan(uint64(l)) + } + if len(m.ColumnNames) > 0 { + for _, s := range m.ColumnNames { + l = len(s) + n += 1 + l + sovPlan(uint64(l)) + } + } + if len(m.ColumnTypes) > 0 { + l = 0 + for _, e := range m.ColumnTypes { + l += sovPlan(uint64(e)) + } + n += 1 + sovPlan(uint64(l)) + l + } + if m.BatchSize != 0 { + n += 1 + sovPlan(uint64(m.BatchSize)) + } + if m.Streaming { + n += 2 + } + l = len(m.TimestampColumn) + if l > 0 { + n += 1 + l + sovPlan(uint64(l)) + } + l = len(m.PartitionColumn) + if l > 0 { + n += 1 + l + sovPlan(uint64(l)) + } + if m.StartTime != 0 { + n += 1 + sovPlan(uint64(m.StartTime)) + } + if m.EndTime != 0 { + n += 1 + sovPlan(uint64(m.EndTime)) + } + return n +} + func (m *OTelLog) Size() (n int) { if m == nil { return 0 @@ -10763,6 +11902,38 @@ func (m *OTelEndpointConfig) Size() (n int) { return n } +func (m *ClickHouseConfig) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Hostname) + if l > 0 { + n += 1 + l + sovPlan(uint64(l)) + } + l = len(m.Host) + if l > 0 { + n += 1 + l + sovPlan(uint64(l)) + } + if m.Port != 0 { + n += 1 + sovPlan(uint64(m.Port)) + } + l = len(m.Username) + if l > 0 { + n += 1 + l + sovPlan(uint64(l)) + } + l = len(m.Password) + if l > 0 { + n += 1 + l + sovPlan(uint64(l)) + } + l = len(m.Database) + if l > 0 { + n += 1 + l + sovPlan(uint64(l)) + } + return n +} + func (m *OTelResource) Size() (n int) { if m == nil { return 0 @@ -10813,43 +11984,85 @@ func (m *OTelExportSinkOperator) Size() (n int) { return n } -func (m *ScalarExpression) Size() (n int) { +func (m *ClickHouseExportSinkOperator) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Value != nil { - n += m.Value.Size() + if m.ClickhouseConfig != nil { + l = m.ClickhouseConfig.Size() + n += 1 + l + sovPlan(uint64(l)) + } + l = len(m.TableName) + if l > 0 { + n += 1 + l + sovPlan(uint64(l)) + } + if len(m.ColumnMappings) > 0 { + for _, e := range m.ColumnMappings { + l = e.Size() + n += 1 + l + sovPlan(uint64(l)) + } } return n } -func (m *ScalarExpression_Constant) Size() (n int) { +func (m *ClickHouseExportSinkOperator_ColumnMapping) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Constant != nil { - l = m.Constant.Size() + if m.InputColumnIndex != 0 { + n += 1 + sovPlan(uint64(m.InputColumnIndex)) + } + l = len(m.ClickhouseColumnName) + if l > 0 { n += 1 + l + sovPlan(uint64(l)) } + if m.ColumnType != 0 { + n += 1 + sovPlan(uint64(m.ColumnType)) + } return n } -func (m *ScalarExpression_Column) Size() (n int) { + +func (m *ScalarExpression) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Column != nil { - l = m.Column.Size() - n += 1 + l + sovPlan(uint64(l)) + if m.Value != nil { + n += m.Value.Size() } return n } -func (m *ScalarExpression_Func) Size() (n int) { + +func (m *ScalarExpression_Constant) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Constant != nil { + l = m.Constant.Size() + n += 1 + l + sovPlan(uint64(l)) + } + return n +} +func (m *ScalarExpression_Column) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Column != nil { + l = m.Column.Size() + n += 1 + l + sovPlan(uint64(l)) + } + return n +} +func (m *ScalarExpression_Func) Size() (n int) { if m == nil { return 0 } @@ -11299,6 +12512,26 @@ func (this *Operator_OTelSinkOp) String() string { }, "") return s } +func (this *Operator_ClickhouseSourceOp) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Operator_ClickhouseSourceOp{`, + `ClickhouseSourceOp:` + strings.Replace(fmt.Sprintf("%v", this.ClickhouseSourceOp), "ClickHouseSourceOperator", "ClickHouseSourceOperator", 1) + `,`, + `}`, + }, "") + return s +} +func (this *Operator_ClickhouseSinkOp) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Operator_ClickhouseSinkOp{`, + `ClickhouseSinkOp:` + strings.Replace(fmt.Sprintf("%v", this.ClickhouseSinkOp), "ClickHouseExportSinkOperator", "ClickHouseExportSinkOperator", 1) + `,`, + `}`, + }, "") + return s +} func (this *Operator_GRPCSinkOp) String() string { if this == nil { return "nil" @@ -11580,6 +12813,29 @@ func (this *EmptySourceOperator) String() string { }, "") return s } +func (this *ClickHouseSourceOperator) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ClickHouseSourceOperator{`, + `Host:` + fmt.Sprintf("%v", this.Host) + `,`, + `Port:` + fmt.Sprintf("%v", this.Port) + `,`, + `Username:` + fmt.Sprintf("%v", this.Username) + `,`, + `Password:` + fmt.Sprintf("%v", this.Password) + `,`, + `Database:` + fmt.Sprintf("%v", this.Database) + `,`, + `Query:` + fmt.Sprintf("%v", this.Query) + `,`, + `ColumnNames:` + fmt.Sprintf("%v", this.ColumnNames) + `,`, + `ColumnTypes:` + fmt.Sprintf("%v", this.ColumnTypes) + `,`, + `BatchSize:` + fmt.Sprintf("%v", this.BatchSize) + `,`, + `Streaming:` + fmt.Sprintf("%v", this.Streaming) + `,`, + `TimestampColumn:` + fmt.Sprintf("%v", this.TimestampColumn) + `,`, + `PartitionColumn:` + fmt.Sprintf("%v", this.PartitionColumn) + `,`, + `StartTime:` + fmt.Sprintf("%v", this.StartTime) + `,`, + `EndTime:` + fmt.Sprintf("%v", this.EndTime) + `,`, + `}`, + }, "") + return s +} func (this *OTelLog) String() string { if this == nil { return "nil" @@ -11806,6 +13062,21 @@ func (this *OTelEndpointConfig) String() string { }, "") return s } +func (this *ClickHouseConfig) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ClickHouseConfig{`, + `Hostname:` + fmt.Sprintf("%v", this.Hostname) + `,`, + `Host:` + fmt.Sprintf("%v", this.Host) + `,`, + `Port:` + fmt.Sprintf("%v", this.Port) + `,`, + `Username:` + fmt.Sprintf("%v", this.Username) + `,`, + `Password:` + fmt.Sprintf("%v", this.Password) + `,`, + `Database:` + fmt.Sprintf("%v", this.Database) + `,`, + `}`, + }, "") + return s +} func (this *OTelResource) String() string { if this == nil { return "nil" @@ -11850,6 +13121,35 @@ func (this *OTelExportSinkOperator) String() string { }, "") return s } +func (this *ClickHouseExportSinkOperator) String() string { + if this == nil { + return "nil" + } + repeatedStringForColumnMappings := "[]*ClickHouseExportSinkOperator_ColumnMapping{" + for _, f := range this.ColumnMappings { + repeatedStringForColumnMappings += strings.Replace(fmt.Sprintf("%v", f), "ClickHouseExportSinkOperator_ColumnMapping", "ClickHouseExportSinkOperator_ColumnMapping", 1) + "," + } + repeatedStringForColumnMappings += "}" + s := strings.Join([]string{`&ClickHouseExportSinkOperator{`, + `ClickhouseConfig:` + strings.Replace(this.ClickhouseConfig.String(), "ClickHouseConfig", "ClickHouseConfig", 1) + `,`, + `TableName:` + fmt.Sprintf("%v", this.TableName) + `,`, + `ColumnMappings:` + repeatedStringForColumnMappings + `,`, + `}`, + }, "") + return s +} +func (this *ClickHouseExportSinkOperator_ColumnMapping) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ClickHouseExportSinkOperator_ColumnMapping{`, + `InputColumnIndex:` + fmt.Sprintf("%v", this.InputColumnIndex) + `,`, + `ClickhouseColumnName:` + fmt.Sprintf("%v", this.ClickhouseColumnName) + `,`, + `ColumnType:` + fmt.Sprintf("%v", this.ColumnType) + `,`, + `}`, + }, "") + return s +} func (this *ScalarExpression) String() string { if this == nil { return "nil" @@ -13522,6 +14822,76 @@ func (m *Operator) Unmarshal(dAtA []byte) error { } m.Op = &Operator_OTelSinkOp{v} iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClickhouseSourceOp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ClickHouseSourceOperator{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Op = &Operator_ClickhouseSourceOp{v} + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClickhouseSinkOp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ClickHouseExportSinkOperator{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Op = &Operator_ClickhouseSinkOp{v} + iNdEx = postIndex case 1000: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field GRPCSinkOp", wireType) @@ -16420,7 +17790,7 @@ func (m *EmptySourceOperator) Unmarshal(dAtA []byte) error { } return nil } -func (m *OTelLog) Unmarshal(dAtA []byte) error { +func (m *ClickHouseSourceOperator) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16443,17 +17813,17 @@ func (m *OTelLog) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: OTelLog: wiretype end group for non-group") + return fmt.Errorf("proto: ClickHouseSourceOperator: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: OTelLog: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ClickHouseSourceOperator: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -16463,31 +17833,29 @@ func (m *OTelLog) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthPlan } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthPlan } if postIndex > l { return io.ErrUnexpectedEOF } - m.Attributes = append(m.Attributes, &OTelAttribute{}) - if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Host = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TimeColumnIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) } - m.TimeColumnIndex = 0 + m.Port = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -16497,16 +17865,16 @@ func (m *OTelLog) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TimeColumnIndex |= int64(b&0x7F) << shift + m.Port |= int32(b&0x7F) << shift if b < 0x80 { break } } case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ObservedTimeColumnIndex", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType) } - m.ObservedTimeColumnIndex = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -16516,16 +17884,29 @@ func (m *OTelLog) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ObservedTimeColumnIndex |= int64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Username = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SeverityNumber", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType) } - m.SeverityNumber = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -16535,14 +17916,27 @@ func (m *OTelLog) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SeverityNumber |= int64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Password = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SeverityText", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Database", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -16570,13 +17964,13 @@ func (m *OTelLog) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.SeverityText = string(dAtA[iNdEx:postIndex]) + m.Database = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field BodyColumnIndex", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) } - m.BodyColumnIndex = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -16586,79 +17980,42 @@ func (m *OTelLog) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.BodyColumnIndex |= int64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - default: - iNdEx = preIndex - skippy, err := skipPlan(dAtA[iNdEx:]) - if err != nil { - return err + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPlan } - if (skippy < 0) || (iNdEx+skippy) < 0 { + postIndex := iNdEx + intStringLen + if postIndex < 0 { return ErrInvalidLengthPlan } - if (iNdEx + skippy) > l { + if postIndex > l { return io.ErrUnexpectedEOF } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *OTelSpan) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPlan + m.Query = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ColumnNames", wireType) } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: OTelSpan: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: OTelSpan: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NameString", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPlan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } intStringLen := int(stringLen) if intStringLen < 0 { @@ -16671,67 +18028,82 @@ func (m *OTelSpan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = &OTelSpan_NameString{string(dAtA[iNdEx:postIndex])} + m.ColumnNames = append(m.ColumnNames, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field NameColumnIndex", wireType) - } - var v int64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPlan + case 8: + if wireType == 0 { + var v typespb.DataType + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= typespb.DataType(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { - return io.ErrUnexpectedEOF + m.ColumnTypes = append(m.ColumnTypes, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - b := dAtA[iNdEx] - iNdEx++ - v |= int64(b&0x7F) << shift - if b < 0x80 { - break + if packedLen < 0 { + return ErrInvalidLengthPlan } - } - m.Name = &OTelSpan_NameColumnIndex{v} - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPlan + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthPlan } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break + var elementCount int + if elementCount != 0 && len(m.ColumnTypes) == 0 { + m.ColumnTypes = make([]typespb.DataType, 0, elementCount) } + for iNdEx < postIndex { + var v typespb.DataType + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= typespb.DataType(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ColumnTypes = append(m.ColumnTypes, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field ColumnTypes", wireType) } - if msglen < 0 { - return ErrInvalidLengthPlan - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPlan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Attributes = append(m.Attributes, &OTelAttribute{}) - if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: + case 9: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TraceIDColumn", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BatchSize", wireType) } - m.TraceIDColumn = 0 + m.BatchSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -16741,16 +18113,16 @@ func (m *OTelSpan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TraceIDColumn |= int64(b&0x7F) << shift + m.BatchSize |= int32(b&0x7F) << shift if b < 0x80 { break } } - case 5: + case 10: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SpanIDColumn", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Streaming", wireType) } - m.SpanIDColumn = 0 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -16760,16 +18132,17 @@ func (m *OTelSpan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SpanIDColumn |= int64(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ParentSpanIDColumn", wireType) + m.Streaming = bool(v != 0) + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TimestampColumn", wireType) } - m.ParentSpanIDColumn = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -16779,16 +18152,29 @@ func (m *OTelSpan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ParentSpanIDColumn |= int64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field StartTimeColumnIndex", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPlan } - m.StartTimeColumnIndex = 0 + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TimestampColumn = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PartitionColumn", wireType) + } + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -16798,16 +18184,29 @@ func (m *OTelSpan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.StartTimeColumnIndex |= int64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 8: + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PartitionColumn = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field EndTimeColumnIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) } - m.EndTimeColumnIndex = 0 + m.StartTime = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -16817,16 +18216,16 @@ func (m *OTelSpan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.EndTimeColumnIndex |= int64(b&0x7F) << shift + m.StartTime |= int64(b&0x7F) << shift if b < 0x80 { break } } - case 9: + case 14: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field KindValue", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EndTime", wireType) } - m.KindValue = 0 + m.EndTime = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -16836,7 +18235,7 @@ func (m *OTelSpan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.KindValue |= int64(b&0x7F) << shift + m.EndTime |= int64(b&0x7F) << shift if b < 0x80 { break } @@ -16862,7 +18261,7 @@ func (m *OTelSpan) Unmarshal(dAtA []byte) error { } return nil } -func (m *OTelMetricGauge) Unmarshal(dAtA []byte) error { +func (m *OTelLog) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16885,17 +18284,17 @@ func (m *OTelMetricGauge) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: OTelMetricGauge: wiretype end group for non-group") + return fmt.Errorf("proto: OTelLog: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: OTelMetricGauge: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: OTelLog: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field FloatColumnIndex", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) } - var v int64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -16905,17 +18304,31 @@ func (m *OTelMetricGauge) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - m.ValueColumn = &OTelMetricGauge_FloatColumnIndex{v} + if msglen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Attributes = append(m.Attributes, &OTelAttribute{}) + if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IntColumnIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TimeColumnIndex", wireType) } - var v int64 + m.TimeColumnIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -16925,67 +18338,16 @@ func (m *OTelMetricGauge) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int64(b&0x7F) << shift + m.TimeColumnIndex |= int64(b&0x7F) << shift if b < 0x80 { break } } - m.ValueColumn = &OTelMetricGauge_IntColumnIndex{v} - default: - iNdEx = preIndex - skippy, err := skipPlan(dAtA[iNdEx:]) - if err != nil { - return err + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ObservedTimeColumnIndex", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPlan - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *OTelMetricSummary) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPlan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: OTelMetricSummary: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: OTelMetricSummary: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CountColumnIndex", wireType) - } - m.CountColumnIndex = 0 + m.ObservedTimeColumnIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -16995,16 +18357,16 @@ func (m *OTelMetricSummary) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.CountColumnIndex |= int64(b&0x7F) << shift + m.ObservedTimeColumnIndex |= int64(b&0x7F) << shift if b < 0x80 { break } } - case 2: + case 4: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SumColumnIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SeverityNumber", wireType) } - m.SumColumnIndex = 0 + m.SeverityNumber = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -17014,16 +18376,16 @@ func (m *OTelMetricSummary) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SumColumnIndex |= int64(b&0x7F) << shift + m.SeverityNumber |= int64(b&0x7F) << shift if b < 0x80 { break } } - case 3: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field QuantileValues", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SeverityText", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -17033,92 +18395,29 @@ func (m *OTelMetricSummary) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthPlan } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthPlan } if postIndex > l { return io.ErrUnexpectedEOF } - m.QuantileValues = append(m.QuantileValues, &OTelMetricSummary_ValueAtQuantile{}) - if err := m.QuantileValues[len(m.QuantileValues)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.SeverityText = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipPlan(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPlan - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *OTelMetricSummary_ValueAtQuantile) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPlan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: ValueAtQuantile: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ValueAtQuantile: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field Quantile", wireType) - } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF - } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.Quantile = float64(math.Float64frombits(v)) - case 2: + case 6: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ValueColumnIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BodyColumnIndex", wireType) } - m.ValueColumnIndex = 0 + m.BodyColumnIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -17128,7 +18427,7 @@ func (m *OTelMetricSummary_ValueAtQuantile) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ValueColumnIndex |= int64(b&0x7F) << shift + m.BodyColumnIndex |= int64(b&0x7F) << shift if b < 0x80 { break } @@ -17154,7 +18453,7 @@ func (m *OTelMetricSummary_ValueAtQuantile) Unmarshal(dAtA []byte) error { } return nil } -func (m *OTelAttribute) Unmarshal(dAtA []byte) error { +func (m *OTelSpan) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17177,15 +18476,15 @@ func (m *OTelAttribute) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: OTelAttribute: wiretype end group for non-group") + return fmt.Errorf("proto: OTelSpan: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: OTelAttribute: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: OTelSpan: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field NameString", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -17213,13 +18512,13 @@ func (m *OTelAttribute) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + m.Name = &OTelSpan_NameString{string(dAtA[iNdEx:postIndex])} iNdEx = postIndex case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Column", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NameColumnIndex", wireType) } - var msglen int + var v int64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -17229,32 +18528,17 @@ func (m *OTelAttribute) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + v |= int64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPlan - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPlan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &OTelAttribute_Column{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Value = &OTelAttribute_Column_{v} - iNdEx = postIndex + m.Name = &OTelSpan_NameColumnIndex{v} case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StringValue", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -17264,79 +18548,31 @@ func (m *OTelAttribute) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthPlan } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthPlan } if postIndex > l { return io.ErrUnexpectedEOF } - m.Value = &OTelAttribute_StringValue{string(dAtA[iNdEx:postIndex])} - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipPlan(dAtA[iNdEx:]) - if err != nil { + m.Attributes = append(m.Attributes, &OTelAttribute{}) + if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPlan - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *OTelAttribute_Column) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPlan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: Column: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Column: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 4: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ColumnType", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TraceIDColumn", wireType) } - m.ColumnType = 0 + m.TraceIDColumn = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -17346,14 +18582,619 @@ func (m *OTelAttribute_Column) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ColumnType |= typespb.DataType(b&0x7F) << shift + m.TraceIDColumn |= int64(b&0x7F) << shift if b < 0x80 { break } } - case 2: + case 5: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ColumnIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SpanIDColumn", wireType) + } + m.SpanIDColumn = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SpanIDColumn |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentSpanIDColumn", wireType) + } + m.ParentSpanIDColumn = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ParentSpanIDColumn |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartTimeColumnIndex", wireType) + } + m.StartTimeColumnIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartTimeColumnIndex |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndTimeColumnIndex", wireType) + } + m.EndTimeColumnIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EndTimeColumnIndex |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field KindValue", wireType) + } + m.KindValue = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.KindValue |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipPlan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPlan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OTelMetricGauge) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OTelMetricGauge: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OTelMetricGauge: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FloatColumnIndex", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ValueColumn = &OTelMetricGauge_FloatColumnIndex{v} + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IntColumnIndex", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ValueColumn = &OTelMetricGauge_IntColumnIndex{v} + default: + iNdEx = preIndex + skippy, err := skipPlan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPlan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OTelMetricSummary) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OTelMetricSummary: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OTelMetricSummary: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CountColumnIndex", wireType) + } + m.CountColumnIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CountColumnIndex |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SumColumnIndex", wireType) + } + m.SumColumnIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SumColumnIndex |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field QuantileValues", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.QuantileValues = append(m.QuantileValues, &OTelMetricSummary_ValueAtQuantile{}) + if err := m.QuantileValues[len(m.QuantileValues)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPlan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPlan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OTelMetricSummary_ValueAtQuantile) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ValueAtQuantile: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValueAtQuantile: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Quantile", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.Quantile = float64(math.Float64frombits(v)) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ValueColumnIndex", wireType) + } + m.ValueColumnIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ValueColumnIndex |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipPlan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPlan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OTelAttribute) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OTelAttribute: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OTelAttribute: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Column", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &OTelAttribute_Column{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &OTelAttribute_Column_{v} + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringValue", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = &OTelAttribute_StringValue{string(dAtA[iNdEx:postIndex])} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPlan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPlan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OTelAttribute_Column) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Column: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Column: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ColumnType", wireType) + } + m.ColumnType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ColumnType |= typespb.DataType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ColumnIndex", wireType) } m.ColumnIndex = 0 for shift := uint(0); ; shift += 7 { @@ -17365,14 +19206,512 @@ func (m *OTelAttribute_Column) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ColumnIndex |= int64(b&0x7F) << shift + m.ColumnIndex |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CanBeJsonEncodedArray", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.CanBeJsonEncodedArray = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipPlan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPlan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OTelMetric) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OTelMetric: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OTelMetric: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Unit", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Unit = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Attributes = append(m.Attributes, &OTelAttribute{}) + if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TimeColumnIndex", wireType) + } + m.TimeColumnIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TimeColumnIndex |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 101: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Gauge", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &OTelMetricGauge{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &OTelMetric_Gauge{v} + iNdEx = postIndex + case 102: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Summary", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &OTelMetricSummary{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Data = &OTelMetric_Summary{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPlan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPlan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OTelEndpointConfig) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OTelEndpointConfig: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OTelEndpointConfig: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.URL = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Headers", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Headers == nil { + m.Headers = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthPlan + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthPlan + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthPlan + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return ErrInvalidLengthPlan + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := skipPlan(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPlan + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Headers[mapkey] = mapvalue + iNdEx = postIndex case 3: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CanBeJsonEncodedArray", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Insecure", wireType) } var v int for shift := uint(0); ; shift += 7 { @@ -17389,7 +19728,26 @@ func (m *OTelAttribute_Column) Unmarshal(dAtA []byte) error { break } } - m.CanBeJsonEncodedArray = bool(v != 0) + m.Insecure = bool(v != 0) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType) + } + m.Timeout = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Timeout |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipPlan(dAtA[iNdEx:]) @@ -17411,7 +19769,7 @@ func (m *OTelAttribute_Column) Unmarshal(dAtA []byte) error { } return nil } -func (m *OTelMetric) Unmarshal(dAtA []byte) error { +func (m *ClickHouseConfig) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17434,15 +19792,15 @@ func (m *OTelMetric) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: OTelMetric: wiretype end group for non-group") + return fmt.Errorf("proto: ClickHouseConfig: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: OTelMetric: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ClickHouseConfig: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -17470,11 +19828,11 @@ func (m *OTelMetric) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + m.Hostname = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -17502,11 +19860,30 @@ func (m *OTelMetric) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Description = string(dAtA[iNdEx:postIndex]) + m.Host = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) + } + m.Port = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Port |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Unit", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -17534,13 +19911,13 @@ func (m *OTelMetric) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Unit = string(dAtA[iNdEx:postIndex]) + m.Username = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 4: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -17550,50 +19927,29 @@ func (m *OTelMetric) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthPlan } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthPlan } if postIndex > l { return io.ErrUnexpectedEOF } - m.Attributes = append(m.Attributes, &OTelAttribute{}) - if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Password = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TimeColumnIndex", wireType) - } - m.TimeColumnIndex = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPlan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.TimeColumnIndex |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 101: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Gauge", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Database", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -17603,30 +19959,77 @@ func (m *OTelMetric) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthPlan } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthPlan } if postIndex > l { return io.ErrUnexpectedEOF } - v := &OTelMetricGauge{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Database = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPlan(dAtA[iNdEx:]) + if err != nil { return err } - m.Data = &OTelMetric_Gauge{v} - iNdEx = postIndex - case 102: + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPlan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OTelResource) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OTelResource: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OTelResource: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Summary", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -17653,11 +20056,10 @@ func (m *OTelMetric) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &OTelMetricSummary{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Attributes = append(m.Attributes, &OTelAttribute{}) + if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Data = &OTelMetric_Summary{v} iNdEx = postIndex default: iNdEx = preIndex @@ -17680,7 +20082,7 @@ func (m *OTelMetric) Unmarshal(dAtA []byte) error { } return nil } -func (m *OTelEndpointConfig) Unmarshal(dAtA []byte) error { +func (m *OTelExportSinkOperator) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17703,17 +20105,17 @@ func (m *OTelEndpointConfig) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: OTelEndpointConfig: wiretype end group for non-group") + return fmt.Errorf("proto: OTelExportSinkOperator: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: OTelEndpointConfig: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: OTelExportSinkOperator: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EndpointConfig", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -17723,156 +20125,69 @@ func (m *OTelEndpointConfig) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthPlan } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthPlan } if postIndex > l { return io.ErrUnexpectedEOF } - m.URL = string(dAtA[iNdEx:postIndex]) + if m.EndpointConfig == nil { + m.EndpointConfig = &OTelEndpointConfig{} + } + if err := m.EndpointConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Headers", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { - return ErrIntOverflowPlan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthPlan - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPlan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Headers == nil { - m.Headers = make(map[string]string) - } - var mapkey string - var mapvalue string - for iNdEx < postIndex { - entryPreIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPlan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - if fieldNum == 1 { - var stringLenmapkey uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPlan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLenmapkey |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLenmapkey := int(stringLenmapkey) - if intStringLenmapkey < 0 { - return ErrInvalidLengthPlan - } - postStringIndexmapkey := iNdEx + intStringLenmapkey - if postStringIndexmapkey < 0 { - return ErrInvalidLengthPlan - } - if postStringIndexmapkey > l { - return io.ErrUnexpectedEOF - } - mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) - iNdEx = postStringIndexmapkey - } else if fieldNum == 2 { - var stringLenmapvalue uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPlan - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLenmapvalue |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLenmapvalue := int(stringLenmapvalue) - if intStringLenmapvalue < 0 { - return ErrInvalidLengthPlan - } - postStringIndexmapvalue := iNdEx + intStringLenmapvalue - if postStringIndexmapvalue < 0 { - return ErrInvalidLengthPlan - } - if postStringIndexmapvalue > l { - return io.ErrUnexpectedEOF - } - mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) - iNdEx = postStringIndexmapvalue - } else { - iNdEx = entryPreIndex - skippy, err := skipPlan(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPlan - } - if (iNdEx + skippy) > postIndex { - return io.ErrUnexpectedEOF - } - iNdEx += skippy + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break } } - m.Headers[mapkey] = mapvalue + if msglen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Resource == nil { + m.Resource = &OTelResource{} + } + if err := m.Resource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Insecure", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType) } - var v int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -17882,17 +20197,31 @@ func (m *OTelEndpointConfig) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - m.Insecure = bool(v != 0) + if msglen < 0 { + return ErrInvalidLengthPlan + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPlan + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Metrics = append(m.Metrics, &OTelMetric{}) + if err := m.Metrics[len(m.Metrics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spans", wireType) } - m.Timeout = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -17902,64 +20231,29 @@ func (m *OTelEndpointConfig) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Timeout |= int64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - default: - iNdEx = preIndex - skippy, err := skipPlan(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { + if msglen < 0 { return ErrInvalidLengthPlan } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *OTelResource) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPlan + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPlan } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.Spans = append(m.Spans, &OTelSpan{}) + if err := m.Spans[len(m.Spans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: OTelResource: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: OTelResource: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -17986,8 +20280,8 @@ func (m *OTelResource) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Attributes = append(m.Attributes, &OTelAttribute{}) - if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Logs = append(m.Logs, &OTelLog{}) + if err := m.Logs[len(m.Logs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -18012,7 +20306,7 @@ func (m *OTelResource) Unmarshal(dAtA []byte) error { } return nil } -func (m *OTelExportSinkOperator) Unmarshal(dAtA []byte) error { +func (m *ClickHouseExportSinkOperator) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18035,15 +20329,15 @@ func (m *OTelExportSinkOperator) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: OTelExportSinkOperator: wiretype end group for non-group") + return fmt.Errorf("proto: ClickHouseExportSinkOperator: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: OTelExportSinkOperator: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ClickHouseExportSinkOperator: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EndpointConfig", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ClickhouseConfig", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -18070,18 +20364,18 @@ func (m *OTelExportSinkOperator) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.EndpointConfig == nil { - m.EndpointConfig = &OTelEndpointConfig{} + if m.ClickhouseConfig == nil { + m.ClickhouseConfig = &ClickHouseConfig{} } - if err := m.EndpointConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ClickhouseConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -18091,31 +20385,27 @@ func (m *OTelExportSinkOperator) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthPlan } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthPlan } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Resource == nil { - m.Resource = &OTelResource{} - } - if err := m.Resource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.TableName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ColumnMappings", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -18142,16 +20432,66 @@ func (m *OTelExportSinkOperator) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Metrics = append(m.Metrics, &OTelMetric{}) - if err := m.Metrics[len(m.Metrics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.ColumnMappings = append(m.ColumnMappings, &ClickHouseExportSinkOperator_ColumnMapping{}) + if err := m.ColumnMappings[len(m.ColumnMappings)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Spans", wireType) + default: + iNdEx = preIndex + skippy, err := skipPlan(dAtA[iNdEx:]) + if err != nil { + return err } - var msglen int + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPlan + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClickHouseExportSinkOperator_ColumnMapping) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ColumnMapping: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ColumnMapping: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field InputColumnIndex", wireType) + } + m.InputColumnIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -18161,31 +20501,16 @@ func (m *OTelExportSinkOperator) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.InputColumnIndex |= int32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPlan - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPlan - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Spans = append(m.Spans, &OTelSpan{}) - if err := m.Spans[len(m.Spans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 5: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ClickhouseColumnName", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPlan @@ -18195,26 +20520,43 @@ func (m *OTelExportSinkOperator) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthPlan } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthPlan } if postIndex > l { return io.ErrUnexpectedEOF } - m.Logs = append(m.Logs, &OTelLog{}) - if err := m.Logs[len(m.Logs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.ClickhouseColumnName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ColumnType", wireType) + } + m.ColumnType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlan + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ColumnType |= typespb.DataType(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipPlan(dAtA[iNdEx:]) diff --git a/src/carnot/planpb/plan.proto b/src/carnot/planpb/plan.proto index c7bcb552dda..738b4793c08 100644 --- a/src/carnot/planpb/plan.proto +++ b/src/carnot/planpb/plan.proto @@ -104,6 +104,7 @@ enum OperatorType { GRPC_SOURCE_OPERATOR = 1100; UDTF_SOURCE_OPERATOR = 1200; EMPTY_SOURCE_OPERATOR = 1300; + CLICKHOUSE_SOURCE_OPERATOR = 1400; // Regular operators are range 2000 - 10000. MAP_OPERATOR = 2000; AGGREGATE_OPERATOR = 2100; @@ -115,6 +116,7 @@ enum OperatorType { MEMORY_SINK_OPERATOR = 9000; GRPC_SINK_OPERATOR = 9100; OTEL_EXPORT_SINK_OPERATOR = 9200; + CLICKHOUSE_EXPORT_SINK_OPERATOR = 9300; } // The Logical operation performed. Each operator needs and entry in this @@ -149,6 +151,10 @@ message Operator { EmptySourceOperator empty_source_op = 13; // OTelExportSinkOperator writes the input table to an OpenTelemetry endpoint. OTelExportSinkOperator otel_sink_op = 14 [ (gogoproto.customname) = "OTelSinkOp" ]; + // ClickHouseSourceOperator reads data from a ClickHouse database. + ClickHouseSourceOperator clickhouse_source_op = 15; + // ClickHouseExportSinkOperator writes the input table to a ClickHouse database. + ClickHouseExportSinkOperator clickhouse_sink_op = 16; } } @@ -358,6 +364,44 @@ message EmptySourceOperator { repeated px.types.DataType column_types = 2; } +// Source operator that queries a ClickHouse database. +message ClickHouseSourceOperator { + // Connection parameters + string host = 1; + int32 port = 2; + string username = 3; + string password = 4; + string database = 5; + + // Query to execute + string query = 6; + + // The names for the columns (can be auto-detected from query) + repeated string column_names = 7; + // The types of the columns (can be auto-detected from query) + repeated px.types.DataType column_types = 8; + + // Batch size for fetching results + int32 batch_size = 9; + + // Whether to stream results (future enhancement) + bool streaming = 10; + + // Column name to use for timestamp-based filtering and ordering + // This column should be of DateTime or DateTime64 type + string timestamp_column = 11; + + // Column name to use for partitioning + // The underlying ClickHouse table should be partitioned by this column + string partition_column = 12; + + // Start time for time-based filtering (nanoseconds since epoch) + int64 start_time = 13; + + // End time for time-based filtering (nanoseconds since epoch) + int64 end_time = 14; +} + // OTelLog maps operator columns to each field in the OpenTelemetry Log configuration. // The mapping ensures that each row of the table will be a separate log. // Maps to the config described here: @@ -524,6 +568,22 @@ message OTelEndpointConfig { int64 timeout = 4; } +// ClickHouseConfig contains the connection parameters for ClickHouse. +message ClickHouseConfig { + // The hostname of the node executing the query. + string hostname = 1; + // The ClickHouse server host. + string host = 2; + // The ClickHouse server port. + int32 port = 3; + // The ClickHouse username. + string username = 4; + // The ClickHouse password. + string password = 5; + // The ClickHouse database name. + string database = 6; +} + // Defines a resource. Discussed in depth in the OpenTelemetry spec. // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/resource/sdk.md message OTelResource { @@ -547,6 +607,24 @@ message OTelExportSinkOperator { repeated OTelLog logs = 5; } +message ClickHouseExportSinkOperator { + // ClickHouse connection parameters + ClickHouseConfig clickhouse_config = 1; + // Target table name to insert data into + string table_name = 2; + // Column mapping: maps input column indices to ClickHouse table columns + repeated ColumnMapping column_mappings = 3; + + message ColumnMapping { + // Index of the column in the input row batch + int32 input_column_index = 1; + // Name of the column in the ClickHouse table + string clickhouse_column_name = 2; + // Data type of the column + px.types.DataType column_type = 3; + } +} + // Scalar expression is any single valued expression. message ScalarExpression { oneof value { diff --git a/src/carnot/planpb/test_proto.h b/src/carnot/planpb/test_proto.h index 0ca5a1c37a4..227d5ad7dd2 100644 --- a/src/carnot/planpb/test_proto.h +++ b/src/carnot/planpb/test_proto.h @@ -195,6 +195,26 @@ column_names: "usage" streaming: false )"; +constexpr char kClickHouseSourceOperator[] = R"( +host: "localhost" +port: 9000 +username: "default" +password: "test_password" +database: "default" +query: "SELECT id, name, value FROM test_table" +batch_size: 2 +streaming: false +column_names: "id" +column_names: "name" +column_names: "value" +column_types: INT64 +column_types: STRING +column_types: FLOAT64 +timestamp_column: "timestamp" +start_time: 1000000000000000000 +end_time: 9223372036854775807 +)"; + constexpr char kBlockingAggOperator1[] = R"( windowed: false values { @@ -1024,6 +1044,64 @@ constexpr char kPlanWithTwoSourcesWithLimits[] = R"proto( } )proto"; +constexpr char kPlanWithOTelExport[] = R"proto( + id: 1, + dag { + nodes { + id: 1 + sorted_children: 2 + } + nodes { + id: 2 + sorted_parents: 1 + } + } + nodes { + id: 1 + op { + op_type: MEMORY_SOURCE_OPERATOR + mem_source_op { + name: "numbers" + column_idxs: 0 + column_types: INT64 + column_names: "a" + column_idxs: 1 + column_types: BOOLEAN + column_names: "b" + column_idxs: 2 + column_types: FLOAT64 + column_names: "c" + } + } + } + nodes { + id: 2 + op { + op_type: OTEL_EXPORT_SINK_OPERATOR + otel_sink_op { + endpoint_config { + url: "0.0.0.0:55690" + headers { + key: "apikey" + value: "12345" + } + timeout: 5 + } + resource { + attributes { + name: "service.name" + column { + column_type: STRING + column_index: 1 + can_be_json_encoded_array: true + } + } + } + } + } + } +)proto"; + constexpr char kOneLimit3Sources[] = R"proto( id: 1, dag { @@ -1328,6 +1406,14 @@ planpb::Operator CreateTestSource1PB(const std::string& table_name = "cpu") { return op; } +planpb::Operator CreateClickHouseSourceOperatorPB() { + planpb::Operator op; + auto op_proto = absl::Substitute(kOperatorProtoTmpl, "CLICKHOUSE_SOURCE_OPERATOR", + "clickhouse_source_op", kClickHouseSourceOperator); + CHECK(google::protobuf::TextFormat::MergeFromString(op_proto, &op)) << "Failed to parse proto"; + return op; +} + planpb::Operator CreateTestStreamingSource1PB(const std::string& table_name = "cpu") { planpb::Operator op; auto mem_proto = absl::Substitute(kStreamingMemSourceOperator1, table_name); @@ -1378,6 +1464,32 @@ planpb::Operator CreateTestSink1PB() { return op; } +// Create a test ClickHouse source operator with hardcoded values +planpb::Operator CreateTestClickHouseSourcePB() { + constexpr char kClickHouseSourceOperator[] = R"( + host: "localhost" + port: 9000 + username: "default" + password: "test_password" + database: "default" + query: "SELECT id, name, value FROM test_table ORDER BY id" + batch_size: 1024 + streaming: false + column_names: "id" + column_names: "name" + column_names: "value" + column_types: UINT64 + column_types: STRING + column_types: FLOAT64 + )"; + + planpb::Operator op; + auto op_proto = absl::Substitute(kOperatorProtoTmpl, "CLICKHOUSE_SOURCE_OPERATOR", + "clickhouse_source_op", kClickHouseSourceOperator); + CHECK(google::protobuf::TextFormat::MergeFromString(op_proto, &op)) << "Failed to parse proto"; + return op; +} + planpb::Operator CreateTestSink2PB() { planpb::Operator op; auto op_proto = absl::Substitute(kOperatorProtoTmpl, "MEMORY_SINK_OPERATOR", "mem_sink_op",