diff --git a/docs-mintlify/admin/users-and-permissions/manage-users.mdx b/docs-mintlify/admin/users-and-permissions/manage-users.mdx index 0bc97d85964ac..da0c2e51895af 100644 --- a/docs-mintlify/admin/users-and-permissions/manage-users.mdx +++ b/docs-mintlify/admin/users-and-permissions/manage-users.mdx @@ -102,6 +102,21 @@ You cannot delete your own account. Deleting a user is irreversible. +## User preferences + +Each user can customize their Cube Cloud experience through the +**Preferences** page, accessible from the user menu. These settings are +saved to the user's account and apply across all devices. + +| Preference | Description | Default | +| --- | --- | --- | +| Theme | Choose between System, Light, or Dark visual theme | System | +| Sidebar drawer | Show only icons and expand the sidebar on hover | Off | +| Pointer cursors | Use pointer cursors on interactive elements | On | +| Code editor | Switch to the new CodeMirror-based code editor for data models | Off | +| New message scrolling | Automatically scroll to new messages in chat | On | +| Alternating row colors | Highlight alternating rows in data tables | Off | + ## Provisioning users via SCIM If your organization uses an identity provider such as [Okta][ref-okta] or diff --git a/docs-mintlify/cube-tracking.js b/docs-mintlify/cube-tracking.js new file mode 100644 index 0000000000000..66b38a4f3e03d --- /dev/null +++ b/docs-mintlify/cube-tracking.js @@ -0,0 +1,85 @@ +(function () { + var COOKIE_NAME = 'cubedev_anonymous'; + var MAX_AGE = 365 * 24 * 60 * 60; + var TRACK_URL = 'https://track.cube.dev/track'; + var IDENTITY_URL = 'https://identity.cube.dev'; + + function getCookie(name) { + var match = document.cookie.match(new RegExp('(?:^|; )' + name + '=([^;]*)')); + return match ? decodeURIComponent(match[1]) : null; + } + + function setCookie(name, value, maxAge, domain) { + var cookie = encodeURIComponent(name) + '=' + encodeURIComponent(value) + + '; max-age=' + maxAge + '; path=/; SameSite=Lax'; + if (domain) cookie += '; domain=' + domain; + document.cookie = cookie; + } + + function getTopDomain() { + var parts = location.hostname.split('.'); + if (parts.length <= 1) return location.hostname; + for (var i = parts.length - 2; i >= 0; i--) { + var candidate = parts.slice(i).join('.'); + setCookie('__tld__', '1', 10, '.' + candidate); + if (getCookie('__tld__')) { + setCookie('__tld__', '', -1, '.' + candidate); + return candidate; + } + } + return location.hostname; + } + + function newUUID() { + if (typeof crypto !== 'undefined' && crypto.randomUUID) { + return crypto.randomUUID(); + } + return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) { + var r = (Math.random() * 16) | 0; + return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16); + }); + } + + function getAnonymousId(domain, callback) { + var existing = getCookie(COOKIE_NAME); + if (existing) return callback(existing); + + fetch(IDENTITY_URL, { credentials: 'include' }) + .then(function (r) { return r.status < 400 ? r.text() : Promise.reject(); }) + .catch(function () { return newUUID(); }) + .then(function (id) { + setCookie(COOKIE_NAME, id, MAX_AGE, domain ? '.' + domain : null); + callback(id); + }); + } + + function trackPage() { + var topDomain = getTopDomain(); + getAnonymousId(topDomain, function (anonymousId) { + var payload = [{ + event: 'page', + href: location.href, + pathname: location.pathname, + search: location.search, + hash: location.hash, + referrer: document.referrer, + id: newUUID(), + clientAnonymousId: anonymousId, + clientTimestamp: new Date().toJSON(), + sentAt: new Date().toJSON(), + }]; + + fetch(TRACK_URL, { + method: 'POST', + body: JSON.stringify(payload), + headers: { 'Content-Type': 'application/json' }, + }).catch(function () {}); + }); + } + + if (document.readyState === 'loading') { + document.addEventListener('DOMContentLoaded', trackPage); + } else { + trackPage(); + } +})(); diff --git a/docs-mintlify/docs.json b/docs-mintlify/docs.json index 609b130ce30aa..397139a676302 100644 --- a/docs-mintlify/docs.json +++ b/docs-mintlify/docs.json @@ -3,9 +3,9 @@ "theme": "mint", "name": "Cube Documentation", "colors": { - "primary": "#7A77FF", + "primary": "#5339CF", "light": "#A5A3FF", - "dark": "#5856D6" + "dark": "#716EEE" }, "favicon": "/favicon.svg", "banner": { @@ -598,6 +598,11 @@ } ] }, + "integrations": { + "gtm": { + "tagId": "GTM-52W7VM2" + } + }, "styling": { "codeblocks": "dark" }, diff --git a/packages/cubejs-backend-native/Cargo.lock b/packages/cubejs-backend-native/Cargo.lock index 0c8ebd2345743..b5bb97e712466 100644 --- a/packages/cubejs-backend-native/Cargo.lock +++ b/packages/cubejs-backend-native/Cargo.lock @@ -785,7 +785,6 @@ dependencies = [ "anyhow", "chrono", "cubeshared", - "flatbuffers 23.5.26", "indexmap 2.7.1", "itertools 0.13.0", "neon", @@ -797,7 +796,7 @@ dependencies = [ name = "cubeshared" version = "0.1.0" dependencies = [ - "flatbuffers 23.5.26", + "flatbuffers 25.12.19", ] [[package]] @@ -1136,11 +1135,11 @@ dependencies = [ [[package]] name = "flatbuffers" -version = "23.5.26" +version = "25.12.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4dac53e22462d78c16d64a1cd22371b54cc3fe94aa15e7886a2fa6e5d1ab8640" +checksum = "35f6839d7b3b98adde531effaf34f0c2badc6f4735d26fe74709d8e513a96ef3" dependencies = [ - "bitflags 1.3.2", + "bitflags 2.8.0", "rustc_version", ] diff --git a/rust/cubeorchestrator/Cargo.lock b/rust/cubeorchestrator/Cargo.lock index ee41e9c189688..3bc48b61ed7d8 100644 --- a/rust/cubeorchestrator/Cargo.lock +++ b/rust/cubeorchestrator/Cargo.lock @@ -61,9 +61,9 @@ dependencies = [ [[package]] name = "bitflags" -version = "1.3.2" +version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" +checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3" [[package]] name = "bumpalo" @@ -111,7 +111,6 @@ dependencies = [ "anyhow", "chrono", "cubeshared", - "flatbuffers", "indexmap", "itertools", "neon", @@ -140,9 +139,9 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" [[package]] name = "flatbuffers" -version = "23.5.26" +version = "25.12.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4dac53e22462d78c16d64a1cd22371b54cc3fe94aa15e7886a2fa6e5d1ab8640" +checksum = "35f6839d7b3b98adde531effaf34f0c2badc6f4735d26fe74709d8e513a96ef3" dependencies = [ "bitflags", "rustc_version", diff --git a/rust/cubeorchestrator/Cargo.toml b/rust/cubeorchestrator/Cargo.toml index d1030cc40a1a6..f1c400bb7bfaa 100644 --- a/rust/cubeorchestrator/Cargo.toml +++ b/rust/cubeorchestrator/Cargo.toml @@ -11,7 +11,6 @@ serde_json = "1.0.133" anyhow = "1.0" itertools = "0.13.0" indexmap = { version = "2.0", features = ["serde"] } -flatbuffers = "23.5.26" [dependencies.neon] version = "=1" diff --git a/rust/cubeorchestrator/src/query_message_parser.rs b/rust/cubeorchestrator/src/query_message_parser.rs index 989612097772c..6cf9cd38124d1 100644 --- a/rust/cubeorchestrator/src/query_message_parser.rs +++ b/rust/cubeorchestrator/src/query_message_parser.rs @@ -3,7 +3,7 @@ use crate::{ transport::JsRawData, }; use cubeshared::codegen::{root_as_http_message_with_opts, HttpCommand}; -use flatbuffers::VerifierOptions; +use cubeshared::flatbuffers::VerifierOptions; use indexmap::IndexMap; use neon::prelude::Finalize; @@ -158,7 +158,7 @@ mod tests { root_as_http_message_unchecked, HttpColumnValue, HttpColumnValueArgs, HttpCommand, HttpMessage, HttpMessageArgs, HttpResultSet, HttpResultSetArgs, HttpRow, HttpRowArgs, }; - use flatbuffers::FlatBufferBuilder; + use cubeshared::flatbuffers::FlatBufferBuilder; /// Helper function to create a test HttpMessage with a given number of rows and columns fn create_test_message(num_rows: usize, num_columns: usize) -> Vec { @@ -320,7 +320,7 @@ mod tests { #[test] fn test_parse_with_custom_verifier_options() { use cubeshared::codegen::root_as_http_message_with_opts; - use flatbuffers::VerifierOptions; + use cubeshared::flatbuffers::VerifierOptions; // Test that custom verifier options can handle large datasets let msg_data = create_test_message(33_000, 40); diff --git a/rust/cubeshared/Cargo.lock b/rust/cubeshared/Cargo.lock index e7d949fe75ccd..e33ae78b2a053 100644 --- a/rust/cubeshared/Cargo.lock +++ b/rust/cubeshared/Cargo.lock @@ -1,12 +1,12 @@ # This file is automatically @generated by Cargo. # It is not intended for manual editing. -version = 3 +version = 4 [[package]] name = "bitflags" -version = "1.3.2" +version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" +checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3" [[package]] name = "cubeshared" @@ -17,9 +17,9 @@ dependencies = [ [[package]] name = "flatbuffers" -version = "23.5.26" +version = "25.12.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4dac53e22462d78c16d64a1cd22371b54cc3fe94aa15e7886a2fa6e5d1ab8640" +checksum = "35f6839d7b3b98adde531effaf34f0c2badc6f4735d26fe74709d8e513a96ef3" dependencies = [ "bitflags", "rustc_version", diff --git a/rust/cubeshared/Cargo.toml b/rust/cubeshared/Cargo.toml index b40a0b5739708..be27718d74677 100644 --- a/rust/cubeshared/Cargo.toml +++ b/rust/cubeshared/Cargo.toml @@ -4,4 +4,4 @@ version = "0.1.0" edition = "2021" [dependencies] -flatbuffers = "23.1.21" +flatbuffers = "25.12.19" diff --git a/rust/cubeshared/src/codegen/http_message_generated.rs b/rust/cubeshared/src/codegen/http_message_generated.rs index 62dcb3467b810..a4ec6b6fe1191 100644 --- a/rust/cubeshared/src/codegen/http_message_generated.rs +++ b/rust/cubeshared/src/codegen/http_message_generated.rs @@ -1,8 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify - // @generated - -extern crate flatbuffers; +extern crate alloc; #[deprecated( since = "2.0.0", @@ -55,8 +53,8 @@ impl HttpCommand { } } } -impl core::fmt::Debug for HttpCommand { - fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { +impl ::core::fmt::Debug for HttpCommand { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) } else { @@ -64,24 +62,24 @@ impl core::fmt::Debug for HttpCommand { } } } -impl<'a> flatbuffers::Follow<'a> for HttpCommand { +impl<'a> ::flatbuffers::Follow<'a> for HttpCommand { type Inner = Self; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = flatbuffers::read_scalar_at::(buf, loc); + let b = unsafe { ::flatbuffers::read_scalar_at::(buf, loc) }; Self(b) } } -impl flatbuffers::Push for HttpCommand { +impl ::flatbuffers::Push for HttpCommand { type Output = HttpCommand; #[inline] unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - flatbuffers::emplace_scalar::(dst, self.0); + unsafe { ::flatbuffers::emplace_scalar::(dst, self.0) }; } } -impl flatbuffers::EndianScalar for HttpCommand { +impl ::flatbuffers::EndianScalar for HttpCommand { type Scalar = u8; #[inline] fn to_little_endian(self) -> u8 { @@ -95,51 +93,56 @@ impl flatbuffers::EndianScalar for HttpCommand { } } -impl<'a> flatbuffers::Verifiable for HttpCommand { +impl<'a> ::flatbuffers::Verifiable for HttpCommand { #[inline] fn run_verifier( - v: &mut flatbuffers::Verifier, + v: &mut ::flatbuffers::Verifier, pos: usize, - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { u8::run_verifier(v, pos) } } -impl flatbuffers::SimpleToVerifyInSlice for HttpCommand {} +impl ::flatbuffers::SimpleToVerifyInSlice for HttpCommand {} pub struct HttpCommandUnionTableOffset {} pub enum HttpMessageOffset {} #[derive(Copy, Clone, PartialEq)] pub struct HttpMessage<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for HttpMessage<'a> { +impl<'a> ::flatbuffers::Follow<'a> for HttpMessage<'a> { type Inner = HttpMessage<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: flatbuffers::Table::new(buf, loc), + _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, } } } impl<'a> HttpMessage<'a> { - pub const VT_MESSAGE_ID: flatbuffers::VOffsetT = 4; - pub const VT_COMMAND_TYPE: flatbuffers::VOffsetT = 6; - pub const VT_COMMAND: flatbuffers::VOffsetT = 8; - pub const VT_CONNECTION_ID: flatbuffers::VOffsetT = 10; + pub const VT_MESSAGE_ID: ::flatbuffers::VOffsetT = 4; + pub const VT_COMMAND_TYPE: ::flatbuffers::VOffsetT = 6; + pub const VT_COMMAND: ::flatbuffers::VOffsetT = 8; + pub const VT_CONNECTION_ID: ::flatbuffers::VOffsetT = 10; #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { HttpMessage { _tab: table } } #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + pub fn create< + 'bldr: 'args, + 'args: 'mut_bldr, + 'mut_bldr, + A: ::flatbuffers::Allocator + 'bldr, + >( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args HttpMessageArgs<'args>, - ) -> flatbuffers::WIPOffset> { + ) -> ::flatbuffers::WIPOffset> { let mut builder = HttpMessageBuilder::new(_fbb); if let Some(x) = args.connection_id { builder.add_connection_id(x); @@ -175,13 +178,13 @@ impl<'a> HttpMessage<'a> { } } #[inline] - pub fn command(&self) -> Option> { + pub fn command(&self) -> Option<::flatbuffers::Table<'a>> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { self._tab - .get::>>( + .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>( HttpMessage::VT_COMMAND, None, ) @@ -194,7 +197,7 @@ impl<'a> HttpMessage<'a> { // which contains a valid value in this slot unsafe { self._tab - .get::>(HttpMessage::VT_CONNECTION_ID, None) + .get::<::flatbuffers::ForwardsUOffset<&str>>(HttpMessage::VT_CONNECTION_ID, None) } } #[inline] @@ -243,12 +246,12 @@ impl<'a> HttpMessage<'a> { } } -impl flatbuffers::Verifiable for HttpMessage<'_> { +impl ::flatbuffers::Verifiable for HttpMessage<'_> { #[inline] fn run_verifier( - v: &mut flatbuffers::Verifier, + v: &mut ::flatbuffers::Verifier, pos: usize, - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { v.visit_table(pos)? .visit_field::("message_id", Self::VT_MESSAGE_ID, false)? .visit_union::( @@ -259,24 +262,24 @@ impl flatbuffers::Verifiable for HttpMessage<'_> { false, |key, v, pos| match key { HttpCommand::HttpQuery => v - .verify_union_variant::>( + .verify_union_variant::<::flatbuffers::ForwardsUOffset>( "HttpCommand::HttpQuery", pos, ), HttpCommand::HttpResultSet => v - .verify_union_variant::>( + .verify_union_variant::<::flatbuffers::ForwardsUOffset>( "HttpCommand::HttpResultSet", pos, ), HttpCommand::HttpError => v - .verify_union_variant::>( + .verify_union_variant::<::flatbuffers::ForwardsUOffset>( "HttpCommand::HttpError", pos, ), _ => Ok(()), }, )? - .visit_field::>( + .visit_field::<::flatbuffers::ForwardsUOffset<&str>>( "connection_id", Self::VT_CONNECTION_ID, false, @@ -288,8 +291,8 @@ impl flatbuffers::Verifiable for HttpMessage<'_> { pub struct HttpMessageArgs<'a> { pub message_id: u32, pub command_type: HttpCommand, - pub command: Option>, - pub connection_id: Option>, + pub command: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>, + pub connection_id: Option<::flatbuffers::WIPOffset<&'a str>>, } impl<'a> Default for HttpMessageArgs<'a> { #[inline] @@ -303,11 +306,11 @@ impl<'a> Default for HttpMessageArgs<'a> { } } -pub struct HttpMessageBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, +pub struct HttpMessageBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } -impl<'a: 'b, 'b> HttpMessageBuilder<'a, 'b> { +impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> HttpMessageBuilder<'a, 'b, A> { #[inline] pub fn add_message_id(&mut self, message_id: u32) { self.fbb_ @@ -322,19 +325,24 @@ impl<'a: 'b, 'b> HttpMessageBuilder<'a, 'b> { ); } #[inline] - pub fn add_command(&mut self, command: flatbuffers::WIPOffset) { + pub fn add_command( + &mut self, + command: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>, + ) { self.fbb_ - .push_slot_always::>(HttpMessage::VT_COMMAND, command); + .push_slot_always::<::flatbuffers::WIPOffset<_>>(HttpMessage::VT_COMMAND, command); } #[inline] - pub fn add_connection_id(&mut self, connection_id: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>( + pub fn add_connection_id(&mut self, connection_id: ::flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( HttpMessage::VT_CONNECTION_ID, connection_id, ); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HttpMessageBuilder<'a, 'b> { + pub fn new( + _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + ) -> HttpMessageBuilder<'a, 'b, A> { let start = _fbb.start_table(); HttpMessageBuilder { fbb_: _fbb, @@ -342,14 +350,14 @@ impl<'a: 'b, 'b> HttpMessageBuilder<'a, 'b> { } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> ::flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) + ::flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for HttpMessage<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { +impl ::core::fmt::Debug for HttpMessage<'_> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut ds = f.debug_struct("HttpMessage"); ds.field("message_id", &self.message_id()); ds.field("command_type", &self.command_type()); @@ -397,33 +405,38 @@ pub enum HttpQueryOffset {} #[derive(Copy, Clone, PartialEq)] pub struct HttpQuery<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for HttpQuery<'a> { +impl<'a> ::flatbuffers::Follow<'a> for HttpQuery<'a> { type Inner = HttpQuery<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: flatbuffers::Table::new(buf, loc), + _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, } } } impl<'a> HttpQuery<'a> { - pub const VT_QUERY: flatbuffers::VOffsetT = 4; - pub const VT_TRACE_OBJ: flatbuffers::VOffsetT = 6; - pub const VT_INLINE_TABLES: flatbuffers::VOffsetT = 8; + pub const VT_QUERY: ::flatbuffers::VOffsetT = 4; + pub const VT_TRACE_OBJ: ::flatbuffers::VOffsetT = 6; + pub const VT_INLINE_TABLES: ::flatbuffers::VOffsetT = 8; #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { HttpQuery { _tab: table } } #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + pub fn create< + 'bldr: 'args, + 'args: 'mut_bldr, + 'mut_bldr, + A: ::flatbuffers::Allocator + 'bldr, + >( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args HttpQueryArgs<'args>, - ) -> flatbuffers::WIPOffset> { + ) -> ::flatbuffers::WIPOffset> { let mut builder = HttpQueryBuilder::new(_fbb); if let Some(x) = args.inline_tables { builder.add_inline_tables(x); @@ -444,7 +457,7 @@ impl<'a> HttpQuery<'a> { // which contains a valid value in this slot unsafe { self._tab - .get::>(HttpQuery::VT_QUERY, None) + .get::<::flatbuffers::ForwardsUOffset<&str>>(HttpQuery::VT_QUERY, None) } } #[inline] @@ -454,50 +467,50 @@ impl<'a> HttpQuery<'a> { // which contains a valid value in this slot unsafe { self._tab - .get::>(HttpQuery::VT_TRACE_OBJ, None) + .get::<::flatbuffers::ForwardsUOffset<&str>>(HttpQuery::VT_TRACE_OBJ, None) } } #[inline] pub fn inline_tables( &self, - ) -> Option>>> { + ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { - self._tab.get::>, + self._tab.get::<::flatbuffers::ForwardsUOffset< + ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>, >>(HttpQuery::VT_INLINE_TABLES, None) } } } -impl flatbuffers::Verifiable for HttpQuery<'_> { +impl ::flatbuffers::Verifiable for HttpQuery<'_> { #[inline] fn run_verifier( - v: &mut flatbuffers::Verifier, + v: &mut ::flatbuffers::Verifier, pos: usize, - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { v.visit_table(pos)? - .visit_field::>("query", Self::VT_QUERY, false)? - .visit_field::>( + .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("query", Self::VT_QUERY, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<&str>>( "trace_obj", Self::VT_TRACE_OBJ, false, )? - .visit_field::>, + .visit_field::<::flatbuffers::ForwardsUOffset< + ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>, >>("inline_tables", Self::VT_INLINE_TABLES, false)? .finish(); Ok(()) } } pub struct HttpQueryArgs<'a> { - pub query: Option>, - pub trace_obj: Option>, + pub query: Option<::flatbuffers::WIPOffset<&'a str>>, + pub trace_obj: Option<::flatbuffers::WIPOffset<&'a str>>, pub inline_tables: Option< - flatbuffers::WIPOffset< - flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>>, + ::flatbuffers::WIPOffset< + ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>, >, >, } @@ -512,35 +525,37 @@ impl<'a> Default for HttpQueryArgs<'a> { } } -pub struct HttpQueryBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, +pub struct HttpQueryBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } -impl<'a: 'b, 'b> HttpQueryBuilder<'a, 'b> { +impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> HttpQueryBuilder<'a, 'b, A> { #[inline] - pub fn add_query(&mut self, query: flatbuffers::WIPOffset<&'b str>) { + pub fn add_query(&mut self, query: ::flatbuffers::WIPOffset<&'b str>) { self.fbb_ - .push_slot_always::>(HttpQuery::VT_QUERY, query); + .push_slot_always::<::flatbuffers::WIPOffset<_>>(HttpQuery::VT_QUERY, query); } #[inline] - pub fn add_trace_obj(&mut self, trace_obj: flatbuffers::WIPOffset<&'b str>) { + pub fn add_trace_obj(&mut self, trace_obj: ::flatbuffers::WIPOffset<&'b str>) { self.fbb_ - .push_slot_always::>(HttpQuery::VT_TRACE_OBJ, trace_obj); + .push_slot_always::<::flatbuffers::WIPOffset<_>>(HttpQuery::VT_TRACE_OBJ, trace_obj); } #[inline] pub fn add_inline_tables( &mut self, - inline_tables: flatbuffers::WIPOffset< - flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, + inline_tables: ::flatbuffers::WIPOffset< + ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset>>, >, ) { - self.fbb_.push_slot_always::>( + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( HttpQuery::VT_INLINE_TABLES, inline_tables, ); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HttpQueryBuilder<'a, 'b> { + pub fn new( + _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + ) -> HttpQueryBuilder<'a, 'b, A> { let start = _fbb.start_table(); HttpQueryBuilder { fbb_: _fbb, @@ -548,14 +563,14 @@ impl<'a: 'b, 'b> HttpQueryBuilder<'a, 'b> { } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> ::flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) + ::flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for HttpQuery<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { +impl ::core::fmt::Debug for HttpQuery<'_> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut ds = f.debug_struct("HttpQuery"); ds.field("query", &self.query()); ds.field("trace_obj", &self.trace_obj()); @@ -567,34 +582,39 @@ pub enum HttpTableOffset {} #[derive(Copy, Clone, PartialEq)] pub struct HttpTable<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for HttpTable<'a> { +impl<'a> ::flatbuffers::Follow<'a> for HttpTable<'a> { type Inner = HttpTable<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: flatbuffers::Table::new(buf, loc), + _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, } } } impl<'a> HttpTable<'a> { - pub const VT_NAME: flatbuffers::VOffsetT = 4; - pub const VT_COLUMNS: flatbuffers::VOffsetT = 6; - pub const VT_TYPES: flatbuffers::VOffsetT = 8; - pub const VT_CSV_ROWS: flatbuffers::VOffsetT = 10; + pub const VT_NAME: ::flatbuffers::VOffsetT = 4; + pub const VT_COLUMNS: ::flatbuffers::VOffsetT = 6; + pub const VT_TYPES: ::flatbuffers::VOffsetT = 8; + pub const VT_CSV_ROWS: ::flatbuffers::VOffsetT = 10; #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { HttpTable { _tab: table } } #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + pub fn create< + 'bldr: 'args, + 'args: 'mut_bldr, + 'mut_bldr, + A: ::flatbuffers::Allocator + 'bldr, + >( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args HttpTableArgs<'args>, - ) -> flatbuffers::WIPOffset> { + ) -> ::flatbuffers::WIPOffset> { let mut builder = HttpTableBuilder::new(_fbb); if let Some(x) = args.csv_rows { builder.add_csv_rows(x); @@ -618,30 +638,32 @@ impl<'a> HttpTable<'a> { // which contains a valid value in this slot unsafe { self._tab - .get::>(HttpTable::VT_NAME, None) + .get::<::flatbuffers::ForwardsUOffset<&str>>(HttpTable::VT_NAME, None) } } #[inline] pub fn columns( &self, - ) -> Option>> { + ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { - self._tab.get::>, + self._tab.get::<::flatbuffers::ForwardsUOffset< + ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>, >>(HttpTable::VT_COLUMNS, None) } } #[inline] - pub fn types(&self) -> Option>> { + pub fn types( + &self, + ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { - self._tab.get::>, + self._tab.get::<::flatbuffers::ForwardsUOffset< + ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>, >>(HttpTable::VT_TYPES, None) } } @@ -652,26 +674,26 @@ impl<'a> HttpTable<'a> { // which contains a valid value in this slot unsafe { self._tab - .get::>(HttpTable::VT_CSV_ROWS, None) + .get::<::flatbuffers::ForwardsUOffset<&str>>(HttpTable::VT_CSV_ROWS, None) } } } -impl flatbuffers::Verifiable for HttpTable<'_> { +impl ::flatbuffers::Verifiable for HttpTable<'_> { #[inline] fn run_verifier( - v: &mut flatbuffers::Verifier, + v: &mut ::flatbuffers::Verifier, pos: usize, - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { v.visit_table(pos)? - .visit_field::>("name", Self::VT_NAME, false)? - .visit_field::>, + .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)? + .visit_field::<::flatbuffers::ForwardsUOffset< + ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>, >>("columns", Self::VT_COLUMNS, false)? - .visit_field::>, + .visit_field::<::flatbuffers::ForwardsUOffset< + ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>, >>("types", Self::VT_TYPES, false)? - .visit_field::>( + .visit_field::<::flatbuffers::ForwardsUOffset<&str>>( "csv_rows", Self::VT_CSV_ROWS, false, @@ -681,14 +703,18 @@ impl flatbuffers::Verifiable for HttpTable<'_> { } } pub struct HttpTableArgs<'a> { - pub name: Option>, + pub name: Option<::flatbuffers::WIPOffset<&'a str>>, pub columns: Option< - flatbuffers::WIPOffset>>, + ::flatbuffers::WIPOffset< + ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>, + >, >, pub types: Option< - flatbuffers::WIPOffset>>, + ::flatbuffers::WIPOffset< + ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>, + >, >, - pub csv_rows: Option>, + pub csv_rows: Option<::flatbuffers::WIPOffset<&'a str>>, } impl<'a> Default for HttpTableArgs<'a> { #[inline] @@ -702,43 +728,45 @@ impl<'a> Default for HttpTableArgs<'a> { } } -pub struct HttpTableBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, +pub struct HttpTableBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } -impl<'a: 'b, 'b> HttpTableBuilder<'a, 'b> { +impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> HttpTableBuilder<'a, 'b, A> { #[inline] - pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { + pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) { self.fbb_ - .push_slot_always::>(HttpTable::VT_NAME, name); + .push_slot_always::<::flatbuffers::WIPOffset<_>>(HttpTable::VT_NAME, name); } #[inline] pub fn add_columns( &mut self, - columns: flatbuffers::WIPOffset< - flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<&'b str>>, + columns: ::flatbuffers::WIPOffset< + ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>, >, ) { self.fbb_ - .push_slot_always::>(HttpTable::VT_COLUMNS, columns); + .push_slot_always::<::flatbuffers::WIPOffset<_>>(HttpTable::VT_COLUMNS, columns); } #[inline] pub fn add_types( &mut self, - types: flatbuffers::WIPOffset< - flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<&'b str>>, + types: ::flatbuffers::WIPOffset< + ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>, >, ) { self.fbb_ - .push_slot_always::>(HttpTable::VT_TYPES, types); + .push_slot_always::<::flatbuffers::WIPOffset<_>>(HttpTable::VT_TYPES, types); } #[inline] - pub fn add_csv_rows(&mut self, csv_rows: flatbuffers::WIPOffset<&'b str>) { + pub fn add_csv_rows(&mut self, csv_rows: ::flatbuffers::WIPOffset<&'b str>) { self.fbb_ - .push_slot_always::>(HttpTable::VT_CSV_ROWS, csv_rows); + .push_slot_always::<::flatbuffers::WIPOffset<_>>(HttpTable::VT_CSV_ROWS, csv_rows); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HttpTableBuilder<'a, 'b> { + pub fn new( + _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + ) -> HttpTableBuilder<'a, 'b, A> { let start = _fbb.start_table(); HttpTableBuilder { fbb_: _fbb, @@ -746,14 +774,14 @@ impl<'a: 'b, 'b> HttpTableBuilder<'a, 'b> { } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> ::flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) + ::flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for HttpTable<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { +impl ::core::fmt::Debug for HttpTable<'_> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut ds = f.debug_struct("HttpTable"); ds.field("name", &self.name()); ds.field("columns", &self.columns()); @@ -766,31 +794,36 @@ pub enum HttpErrorOffset {} #[derive(Copy, Clone, PartialEq)] pub struct HttpError<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for HttpError<'a> { +impl<'a> ::flatbuffers::Follow<'a> for HttpError<'a> { type Inner = HttpError<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: flatbuffers::Table::new(buf, loc), + _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, } } } impl<'a> HttpError<'a> { - pub const VT_ERROR: flatbuffers::VOffsetT = 4; + pub const VT_ERROR: ::flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { HttpError { _tab: table } } #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + pub fn create< + 'bldr: 'args, + 'args: 'mut_bldr, + 'mut_bldr, + A: ::flatbuffers::Allocator + 'bldr, + >( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args HttpErrorArgs<'args>, - ) -> flatbuffers::WIPOffset> { + ) -> ::flatbuffers::WIPOffset> { let mut builder = HttpErrorBuilder::new(_fbb); if let Some(x) = args.error { builder.add_error(x); @@ -805,25 +838,25 @@ impl<'a> HttpError<'a> { // which contains a valid value in this slot unsafe { self._tab - .get::>(HttpError::VT_ERROR, None) + .get::<::flatbuffers::ForwardsUOffset<&str>>(HttpError::VT_ERROR, None) } } } -impl flatbuffers::Verifiable for HttpError<'_> { +impl ::flatbuffers::Verifiable for HttpError<'_> { #[inline] fn run_verifier( - v: &mut flatbuffers::Verifier, + v: &mut ::flatbuffers::Verifier, pos: usize, - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { v.visit_table(pos)? - .visit_field::>("error", Self::VT_ERROR, false)? + .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("error", Self::VT_ERROR, false)? .finish(); Ok(()) } } pub struct HttpErrorArgs<'a> { - pub error: Option>, + pub error: Option<::flatbuffers::WIPOffset<&'a str>>, } impl<'a> Default for HttpErrorArgs<'a> { #[inline] @@ -832,18 +865,20 @@ impl<'a> Default for HttpErrorArgs<'a> { } } -pub struct HttpErrorBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, +pub struct HttpErrorBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } -impl<'a: 'b, 'b> HttpErrorBuilder<'a, 'b> { +impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> HttpErrorBuilder<'a, 'b, A> { #[inline] - pub fn add_error(&mut self, error: flatbuffers::WIPOffset<&'b str>) { + pub fn add_error(&mut self, error: ::flatbuffers::WIPOffset<&'b str>) { self.fbb_ - .push_slot_always::>(HttpError::VT_ERROR, error); + .push_slot_always::<::flatbuffers::WIPOffset<_>>(HttpError::VT_ERROR, error); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HttpErrorBuilder<'a, 'b> { + pub fn new( + _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + ) -> HttpErrorBuilder<'a, 'b, A> { let start = _fbb.start_table(); HttpErrorBuilder { fbb_: _fbb, @@ -851,14 +886,14 @@ impl<'a: 'b, 'b> HttpErrorBuilder<'a, 'b> { } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> ::flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) + ::flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for HttpError<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { +impl ::core::fmt::Debug for HttpError<'_> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut ds = f.debug_struct("HttpError"); ds.field("error", &self.error()); ds.finish() @@ -868,32 +903,37 @@ pub enum HttpResultSetOffset {} #[derive(Copy, Clone, PartialEq)] pub struct HttpResultSet<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for HttpResultSet<'a> { +impl<'a> ::flatbuffers::Follow<'a> for HttpResultSet<'a> { type Inner = HttpResultSet<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: flatbuffers::Table::new(buf, loc), + _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, } } } impl<'a> HttpResultSet<'a> { - pub const VT_COLUMNS: flatbuffers::VOffsetT = 4; - pub const VT_ROWS: flatbuffers::VOffsetT = 6; + pub const VT_COLUMNS: ::flatbuffers::VOffsetT = 4; + pub const VT_ROWS: ::flatbuffers::VOffsetT = 6; #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { HttpResultSet { _tab: table } } #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + pub fn create< + 'bldr: 'args, + 'args: 'mut_bldr, + 'mut_bldr, + A: ::flatbuffers::Allocator + 'bldr, + >( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args HttpResultSetArgs<'args>, - ) -> flatbuffers::WIPOffset> { + ) -> ::flatbuffers::WIPOffset> { let mut builder = HttpResultSetBuilder::new(_fbb); if let Some(x) = args.rows { builder.add_rows(x); @@ -907,43 +947,43 @@ impl<'a> HttpResultSet<'a> { #[inline] pub fn columns( &self, - ) -> Option>> { + ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { - self._tab.get::>, + self._tab.get::<::flatbuffers::ForwardsUOffset< + ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>, >>(HttpResultSet::VT_COLUMNS, None) } } #[inline] pub fn rows( &self, - ) -> Option>>> { + ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { - self._tab.get::>, + self._tab.get::<::flatbuffers::ForwardsUOffset< + ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>, >>(HttpResultSet::VT_ROWS, None) } } } -impl flatbuffers::Verifiable for HttpResultSet<'_> { +impl ::flatbuffers::Verifiable for HttpResultSet<'_> { #[inline] fn run_verifier( - v: &mut flatbuffers::Verifier, + v: &mut ::flatbuffers::Verifier, pos: usize, - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { v.visit_table(pos)? - .visit_field::>, + .visit_field::<::flatbuffers::ForwardsUOffset< + ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>, >>("columns", Self::VT_COLUMNS, false)? - .visit_field::>, + .visit_field::<::flatbuffers::ForwardsUOffset< + ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>, >>("rows", Self::VT_ROWS, false)? .finish(); Ok(()) @@ -951,10 +991,14 @@ impl flatbuffers::Verifiable for HttpResultSet<'_> { } pub struct HttpResultSetArgs<'a> { pub columns: Option< - flatbuffers::WIPOffset>>, + ::flatbuffers::WIPOffset< + ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>, + >, >, pub rows: Option< - flatbuffers::WIPOffset>>>, + ::flatbuffers::WIPOffset< + ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>, + >, >, } impl<'a> Default for HttpResultSetArgs<'a> { @@ -967,33 +1011,35 @@ impl<'a> Default for HttpResultSetArgs<'a> { } } -pub struct HttpResultSetBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, +pub struct HttpResultSetBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } -impl<'a: 'b, 'b> HttpResultSetBuilder<'a, 'b> { +impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> HttpResultSetBuilder<'a, 'b, A> { #[inline] pub fn add_columns( &mut self, - columns: flatbuffers::WIPOffset< - flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<&'b str>>, + columns: ::flatbuffers::WIPOffset< + ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>, >, ) { self.fbb_ - .push_slot_always::>(HttpResultSet::VT_COLUMNS, columns); + .push_slot_always::<::flatbuffers::WIPOffset<_>>(HttpResultSet::VT_COLUMNS, columns); } #[inline] pub fn add_rows( &mut self, - rows: flatbuffers::WIPOffset< - flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, + rows: ::flatbuffers::WIPOffset< + ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset>>, >, ) { self.fbb_ - .push_slot_always::>(HttpResultSet::VT_ROWS, rows); + .push_slot_always::<::flatbuffers::WIPOffset<_>>(HttpResultSet::VT_ROWS, rows); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HttpResultSetBuilder<'a, 'b> { + pub fn new( + _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + ) -> HttpResultSetBuilder<'a, 'b, A> { let start = _fbb.start_table(); HttpResultSetBuilder { fbb_: _fbb, @@ -1001,14 +1047,14 @@ impl<'a: 'b, 'b> HttpResultSetBuilder<'a, 'b> { } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> ::flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) + ::flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for HttpResultSet<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { +impl ::core::fmt::Debug for HttpResultSet<'_> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut ds = f.debug_struct("HttpResultSet"); ds.field("columns", &self.columns()); ds.field("rows", &self.rows()); @@ -1019,31 +1065,36 @@ pub enum HttpRowOffset {} #[derive(Copy, Clone, PartialEq)] pub struct HttpRow<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for HttpRow<'a> { +impl<'a> ::flatbuffers::Follow<'a> for HttpRow<'a> { type Inner = HttpRow<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: flatbuffers::Table::new(buf, loc), + _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, } } } impl<'a> HttpRow<'a> { - pub const VT_VALUES: flatbuffers::VOffsetT = 4; + pub const VT_VALUES: ::flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { HttpRow { _tab: table } } #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + pub fn create< + 'bldr: 'args, + 'args: 'mut_bldr, + 'mut_bldr, + A: ::flatbuffers::Allocator + 'bldr, + >( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args HttpRowArgs<'args>, - ) -> flatbuffers::WIPOffset> { + ) -> ::flatbuffers::WIPOffset> { let mut builder = HttpRowBuilder::new(_fbb); if let Some(x) = args.values { builder.add_values(x); @@ -1054,27 +1105,28 @@ impl<'a> HttpRow<'a> { #[inline] pub fn values( &self, - ) -> Option>>> { + ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> + { // Safety: // Created from valid Table for this object // which contains a valid value in this slot unsafe { - self._tab.get::>, + self._tab.get::<::flatbuffers::ForwardsUOffset< + ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>, >>(HttpRow::VT_VALUES, None) } } } -impl flatbuffers::Verifiable for HttpRow<'_> { +impl ::flatbuffers::Verifiable for HttpRow<'_> { #[inline] fn run_verifier( - v: &mut flatbuffers::Verifier, + v: &mut ::flatbuffers::Verifier, pos: usize, - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { v.visit_table(pos)? - .visit_field::>, + .visit_field::<::flatbuffers::ForwardsUOffset< + ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>, >>("values", Self::VT_VALUES, false)? .finish(); Ok(()) @@ -1082,8 +1134,8 @@ impl flatbuffers::Verifiable for HttpRow<'_> { } pub struct HttpRowArgs<'a> { pub values: Option< - flatbuffers::WIPOffset< - flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>>, + ::flatbuffers::WIPOffset< + ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>, >, >, } @@ -1094,23 +1146,23 @@ impl<'a> Default for HttpRowArgs<'a> { } } -pub struct HttpRowBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, +pub struct HttpRowBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } -impl<'a: 'b, 'b> HttpRowBuilder<'a, 'b> { +impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> HttpRowBuilder<'a, 'b, A> { #[inline] pub fn add_values( &mut self, - values: flatbuffers::WIPOffset< - flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, + values: ::flatbuffers::WIPOffset< + ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset>>, >, ) { self.fbb_ - .push_slot_always::>(HttpRow::VT_VALUES, values); + .push_slot_always::<::flatbuffers::WIPOffset<_>>(HttpRow::VT_VALUES, values); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HttpRowBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> HttpRowBuilder<'a, 'b, A> { let start = _fbb.start_table(); HttpRowBuilder { fbb_: _fbb, @@ -1118,14 +1170,14 @@ impl<'a: 'b, 'b> HttpRowBuilder<'a, 'b> { } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> ::flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) + ::flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for HttpRow<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { +impl ::core::fmt::Debug for HttpRow<'_> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut ds = f.debug_struct("HttpRow"); ds.field("values", &self.values()); ds.finish() @@ -1135,31 +1187,36 @@ pub enum HttpColumnValueOffset {} #[derive(Copy, Clone, PartialEq)] pub struct HttpColumnValue<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: ::flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for HttpColumnValue<'a> { +impl<'a> ::flatbuffers::Follow<'a> for HttpColumnValue<'a> { type Inner = HttpColumnValue<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { - _tab: flatbuffers::Table::new(buf, loc), + _tab: unsafe { ::flatbuffers::Table::new(buf, loc) }, } } } impl<'a> HttpColumnValue<'a> { - pub const VT_STRING_VALUE: flatbuffers::VOffsetT = 4; + pub const VT_STRING_VALUE: ::flatbuffers::VOffsetT = 4; #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self { HttpColumnValue { _tab: table } } #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + pub fn create< + 'bldr: 'args, + 'args: 'mut_bldr, + 'mut_bldr, + A: ::flatbuffers::Allocator + 'bldr, + >( + _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>, args: &'args HttpColumnValueArgs<'args>, - ) -> flatbuffers::WIPOffset> { + ) -> ::flatbuffers::WIPOffset> { let mut builder = HttpColumnValueBuilder::new(_fbb); if let Some(x) = args.string_value { builder.add_string_value(x); @@ -1174,19 +1231,19 @@ impl<'a> HttpColumnValue<'a> { // which contains a valid value in this slot unsafe { self._tab - .get::>(HttpColumnValue::VT_STRING_VALUE, None) + .get::<::flatbuffers::ForwardsUOffset<&str>>(HttpColumnValue::VT_STRING_VALUE, None) } } } -impl flatbuffers::Verifiable for HttpColumnValue<'_> { +impl ::flatbuffers::Verifiable for HttpColumnValue<'_> { #[inline] fn run_verifier( - v: &mut flatbuffers::Verifier, + v: &mut ::flatbuffers::Verifier, pos: usize, - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> { v.visit_table(pos)? - .visit_field::>( + .visit_field::<::flatbuffers::ForwardsUOffset<&str>>( "string_value", Self::VT_STRING_VALUE, false, @@ -1196,7 +1253,7 @@ impl flatbuffers::Verifiable for HttpColumnValue<'_> { } } pub struct HttpColumnValueArgs<'a> { - pub string_value: Option>, + pub string_value: Option<::flatbuffers::WIPOffset<&'a str>>, } impl<'a> Default for HttpColumnValueArgs<'a> { #[inline] @@ -1205,20 +1262,22 @@ impl<'a> Default for HttpColumnValueArgs<'a> { } } -pub struct HttpColumnValueBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, +pub struct HttpColumnValueBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> { + fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>, } -impl<'a: 'b, 'b> HttpColumnValueBuilder<'a, 'b> { +impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> HttpColumnValueBuilder<'a, 'b, A> { #[inline] - pub fn add_string_value(&mut self, string_value: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>( + pub fn add_string_value(&mut self, string_value: ::flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>( HttpColumnValue::VT_STRING_VALUE, string_value, ); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HttpColumnValueBuilder<'a, 'b> { + pub fn new( + _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + ) -> HttpColumnValueBuilder<'a, 'b, A> { let start = _fbb.start_table(); HttpColumnValueBuilder { fbb_: _fbb, @@ -1226,14 +1285,14 @@ impl<'a: 'b, 'b> HttpColumnValueBuilder<'a, 'b> { } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> ::flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) + ::flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for HttpColumnValue<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { +impl ::core::fmt::Debug for HttpColumnValue<'_> { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut ds = f.debug_struct("HttpColumnValue"); ds.field("string_value", &self.string_value()); ds.finish() @@ -1246,8 +1305,10 @@ impl core::fmt::Debug for HttpColumnValue<'_> { /// catch every error, or be maximally performant. For the /// previous, unchecked, behavior use /// `root_as_http_message_unchecked`. -pub fn root_as_http_message(buf: &[u8]) -> Result, flatbuffers::InvalidFlatbuffer> { - flatbuffers::root::(buf) +pub fn root_as_http_message( + buf: &[u8], +) -> Result, ::flatbuffers::InvalidFlatbuffer> { + ::flatbuffers::root::(buf) } #[inline] /// Verifies that a buffer of bytes contains a size prefixed @@ -1258,8 +1319,8 @@ pub fn root_as_http_message(buf: &[u8]) -> Result, flatbuffers:: /// `size_prefixed_root_as_http_message_unchecked`. pub fn size_prefixed_root_as_http_message( buf: &[u8], -) -> Result, flatbuffers::InvalidFlatbuffer> { - flatbuffers::size_prefixed_root::(buf) +) -> Result, ::flatbuffers::InvalidFlatbuffer> { + ::flatbuffers::size_prefixed_root::(buf) } #[inline] /// Verifies, with the given options, that a buffer of bytes @@ -1269,10 +1330,10 @@ pub fn size_prefixed_root_as_http_message( /// previous, unchecked, behavior use /// `root_as_http_message_unchecked`. pub fn root_as_http_message_with_opts<'b, 'o>( - opts: &'o flatbuffers::VerifierOptions, + opts: &'o ::flatbuffers::VerifierOptions, buf: &'b [u8], -) -> Result, flatbuffers::InvalidFlatbuffer> { - flatbuffers::root_with_opts::>(opts, buf) +) -> Result, ::flatbuffers::InvalidFlatbuffer> { + ::flatbuffers::root_with_opts::>(opts, buf) } #[inline] /// Verifies, with the given verifier options, that a buffer of @@ -1282,37 +1343,37 @@ pub fn root_as_http_message_with_opts<'b, 'o>( /// previous, unchecked, behavior use /// `root_as_http_message_unchecked`. pub fn size_prefixed_root_as_http_message_with_opts<'b, 'o>( - opts: &'o flatbuffers::VerifierOptions, + opts: &'o ::flatbuffers::VerifierOptions, buf: &'b [u8], -) -> Result, flatbuffers::InvalidFlatbuffer> { - flatbuffers::size_prefixed_root_with_opts::>(opts, buf) +) -> Result, ::flatbuffers::InvalidFlatbuffer> { + ::flatbuffers::size_prefixed_root_with_opts::>(opts, buf) } #[inline] /// Assumes, without verification, that a buffer of bytes contains a HttpMessage and returns it. /// # Safety /// Callers must trust the given bytes do indeed contain a valid `HttpMessage`. pub unsafe fn root_as_http_message_unchecked(buf: &[u8]) -> HttpMessage<'_> { - flatbuffers::root_unchecked::(buf) + unsafe { ::flatbuffers::root_unchecked::(buf) } } #[inline] /// Assumes, without verification, that a buffer of bytes contains a size prefixed HttpMessage and returns it. /// # Safety /// Callers must trust the given bytes do indeed contain a valid size prefixed `HttpMessage`. pub unsafe fn size_prefixed_root_as_http_message_unchecked(buf: &[u8]) -> HttpMessage<'_> { - flatbuffers::size_prefixed_root_unchecked::(buf) + unsafe { ::flatbuffers::size_prefixed_root_unchecked::(buf) } } #[inline] -pub fn finish_http_message_buffer<'a, 'b>( - fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, - root: flatbuffers::WIPOffset>, +pub fn finish_http_message_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( + fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + root: ::flatbuffers::WIPOffset>, ) { fbb.finish(root, None); } #[inline] -pub fn finish_size_prefixed_http_message_buffer<'a, 'b>( - fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, - root: flatbuffers::WIPOffset>, +pub fn finish_size_prefixed_http_message_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>( + fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, + root: ::flatbuffers::WIPOffset>, ) { fbb.finish_size_prefixed(root, None); } diff --git a/rust/cubeshared/src/lib.rs b/rust/cubeshared/src/lib.rs index 24ccbddd82ed0..4703b86d9ef93 100644 --- a/rust/cubeshared/src/lib.rs +++ b/rust/cubeshared/src/lib.rs @@ -1 +1,3 @@ pub mod codegen; + +pub use flatbuffers; diff --git a/rust/cubeshared/tests/wire_compat.rs b/rust/cubeshared/tests/wire_compat.rs new file mode 100644 index 0000000000000..298f94441f272 --- /dev/null +++ b/rust/cubeshared/tests/wire_compat.rs @@ -0,0 +1,131 @@ +//! Wire-format compatibility tests. +//! +//! Tests verify the new code can still deserialize old responses, +//! guarding against accidental wire-format regressions. + +use cubeshared::codegen::{root_as_http_message, HttpCommand}; + +// HttpMessage { message_id=42, command=HttpQuery { +// query="SELECT 1", trace_obj="trace-abc", +// inline_tables=[HttpTable { name="inline_t", columns=["a","b"], +// types=["Int32","Utf8"], csv_rows="1,foo\n2,bar\n" }] +// }, connection_id="conn-1" } +const HTTP_QUERY_V23: &[u8] = &[ + 0x10, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x14, 0x00, 0x08, 0x00, 0x07, 0x00, 0x0c, 0x00, 0x10, 0x00, + 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x2a, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x63, 0x6f, 0x6e, 0x6e, 0x2d, 0x31, 0x00, 0x00, + 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x08, 0x00, 0x0c, 0x00, 0x0a, 0x00, 0x00, 0x00, + 0xa8, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x10, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x14, 0x00, 0x04, 0x00, 0x08, 0x00, 0x0c, 0x00, 0x10, 0x00, + 0x0c, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, + 0x14, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x74, + 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x31, 0x2c, 0x66, 0x6f, 0x6f, 0x0a, 0x32, 0x2c, + 0x62, 0x61, 0x72, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x55, 0x74, 0x66, 0x38, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x10, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x74, 0x72, 0x61, 0x63, + 0x65, 0x2d, 0x61, 0x62, 0x63, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x53, 0x45, 0x4c, 0x45, + 0x43, 0x54, 0x20, 0x31, 0x00, 0x00, 0x00, 0x00, +]; + +// HttpMessage { message_id=7, command=HttpResultSet { +// columns=["id","name"], +// rows=[ HttpRow { values=[{string_value="1"}, {string_value="alice"}] }, +// HttpRow { values=[{string_value="2"}, {string_value="bob"}] } ] +// }, connection_id="conn-2" } +const HTTP_RESULT_SET_V23: &[u8] = &[ + 0x10, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x14, 0x00, 0x08, 0x00, 0x07, 0x00, 0x0c, 0x00, 0x10, 0x00, + 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x07, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x63, 0x6f, 0x6e, 0x6e, 0x2d, 0x32, 0x00, 0x00, + 0x08, 0x00, 0x0c, 0x00, 0x04, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0xa6, 0xff, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0xba, 0xff, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x62, 0x6f, 0x62, 0x00, 0xca, 0xff, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x32, 0x00, 0x00, 0x00, 0xda, 0xff, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xee, 0xff, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x61, 0x6c, 0x69, 0x63, 0x65, 0x00, 0x06, 0x00, 0x08, 0x00, 0x04, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x6e, 0x61, 0x6d, 0x65, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x69, 0x64, 0x00, 0x00, +]; + +// HttpMessage { message_id=99, command=HttpError { error="boom: divide by zero" }, +// connection_id="conn-3" } +const HTTP_ERROR_V23: &[u8] = &[ + 0x10, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x14, 0x00, 0x08, 0x00, 0x07, 0x00, 0x0c, 0x00, 0x10, 0x00, + 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x63, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x63, 0x6f, 0x6e, 0x6e, 0x2d, 0x33, 0x00, 0x00, + 0x00, 0x00, 0x06, 0x00, 0x08, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x14, 0x00, 0x00, 0x00, 0x62, 0x6f, 0x6f, 0x6d, 0x3a, 0x20, 0x64, 0x69, 0x76, 0x69, 0x64, 0x65, + 0x20, 0x62, 0x79, 0x20, 0x7a, 0x65, 0x72, 0x6f, 0x00, 0x00, 0x00, 0x00, +]; + +#[test] +fn deserialize_v23_http_query() { + let msg = root_as_http_message(HTTP_QUERY_V23).expect("parse v23 HttpQuery"); + assert_eq!(msg.message_id(), 42); + assert_eq!(msg.connection_id(), Some("conn-1")); + assert_eq!(msg.command_type(), HttpCommand::HttpQuery); + + let q = msg + .command_as_http_query() + .expect("HttpQuery union variant"); + assert_eq!(q.query(), Some("SELECT 1")); + assert_eq!(q.trace_obj(), Some("trace-abc")); + + let tables = q.inline_tables().expect("inline_tables vector"); + assert_eq!(tables.len(), 1); + let t = tables.get(0); + assert_eq!(t.name(), Some("inline_t")); + assert_eq!(t.csv_rows(), Some("1,foo\n2,bar\n")); + + let cols = t.columns().expect("columns vector"); + assert_eq!(cols.iter().collect::>(), vec!["a", "b"]); + let types = t.types().expect("types vector"); + assert_eq!(types.iter().collect::>(), vec!["Int32", "Utf8"]); +} + +#[test] +fn deserialize_v23_http_result_set() { + let msg = root_as_http_message(HTTP_RESULT_SET_V23).expect("parse v23 HttpResultSet"); + assert_eq!(msg.message_id(), 7); + assert_eq!(msg.connection_id(), Some("conn-2")); + assert_eq!(msg.command_type(), HttpCommand::HttpResultSet); + + let rs = msg + .command_as_http_result_set() + .expect("HttpResultSet union variant"); + + let cols = rs.columns().expect("columns vector"); + assert_eq!(cols.iter().collect::>(), vec!["id", "name"]); + + let rows = rs.rows().expect("rows vector"); + assert_eq!(rows.len(), 2); + + let row_strings: Vec> = rows + .iter() + .map(|r| { + r.values() + .expect("values vector") + .iter() + .map(|v| v.string_value().unwrap_or("")) + .collect() + }) + .collect(); + assert_eq!(row_strings, vec![vec!["1", "alice"], vec!["2", "bob"]]); +} + +#[test] +fn deserialize_v23_http_error() { + let msg = root_as_http_message(HTTP_ERROR_V23).expect("parse v23 HttpError"); + assert_eq!(msg.message_id(), 99); + assert_eq!(msg.connection_id(), Some("conn-3")); + assert_eq!(msg.command_type(), HttpCommand::HttpError); + + let e = msg + .command_as_http_error() + .expect("HttpError union variant"); + assert_eq!(e.error(), Some("boom: divide by zero")); +} diff --git a/rust/cubestore/Cargo.lock b/rust/cubestore/Cargo.lock index b51cee2ce7e4c..bb1cfe05b619e 100644 --- a/rust/cubestore/Cargo.lock +++ b/rust/cubestore/Cargo.lock @@ -735,9 +735,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.5.0" +version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1" +checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3" [[package]] name = "blake2" @@ -1518,7 +1518,7 @@ dependencies = [ name = "cubeshared" version = "0.1.0" dependencies = [ - "flatbuffers 23.1.21", + "flatbuffers 25.12.19", ] [[package]] @@ -1557,7 +1557,6 @@ dependencies = [ "deepsize", "deflate", "enum_primitive", - "flatbuffers 23.1.21", "flexbuffers", "futures", "futures-timer 3.0.2", @@ -2484,9 +2483,9 @@ checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99" [[package]] name = "flatbuffers" -version = "23.1.21" +version = "24.12.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77f5399c2c9c50ae9418e522842ad362f61ee48b346ac106807bd355a8a7c619" +checksum = "4f1baf0dbf96932ec9a3038d57900329c015b0bfb7b63d904f3bc27e2b02a096" dependencies = [ "bitflags 1.3.2", "rustc_version", @@ -2494,11 +2493,11 @@ dependencies = [ [[package]] name = "flatbuffers" -version = "24.12.23" +version = "25.12.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4f1baf0dbf96932ec9a3038d57900329c015b0bfb7b63d904f3bc27e2b02a096" +checksum = "35f6839d7b3b98adde531effaf34f0c2badc6f4735d26fe74709d8e513a96ef3" dependencies = [ - "bitflags 1.3.2", + "bitflags 2.11.1", "rustc_version", ] @@ -3613,7 +3612,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0c2a198fb6b0eada2a8df47933734e6d35d350665a33a3593d7164fa52c75c19" dependencies = [ "cfg-if 1.0.0", - "windows-targets 0.48.5", + "windows-targets 0.52.4", ] [[package]] @@ -4343,7 +4342,7 @@ version = "0.10.66" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9529f4786b70a3e8c61e11179af17ab6188ad8d0ded78c5529441ed39d4bd9c1" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.11.1", "cfg-if 1.0.0", "foreign-types", "libc", @@ -5305,7 +5304,7 @@ version = "0.5.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.11.1", ] [[package]] @@ -5554,7 +5553,7 @@ version = "0.38.32" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "65e04861e65f21776e67888bfbea442b3642beaa0138fdb1dd7a84a52dffdb89" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.11.1", "errno", "libc", "linux-raw-sys", @@ -6734,8 +6733,8 @@ version = "1.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675" dependencies = [ - "cfg-if 0.1.10", - "rand 0.6.5", + "cfg-if 1.0.0", + "rand 0.8.5", "static_assertions", ] @@ -7370,7 +7369,7 @@ version = "0.39.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.11.1", ] [[package]] diff --git a/rust/cubestore/cubestore/Cargo.toml b/rust/cubestore/cubestore/Cargo.toml index 0fb07a0b0080f..ff3099920bce9 100644 --- a/rust/cubestore/cubestore/Cargo.toml +++ b/rust/cubestore/cubestore/Cargo.toml @@ -80,7 +80,6 @@ tempfile = "3.10.1" pin-project-lite = "0.2.4" paste = "1.0.4" memchr = "2" -flatbuffers = "23.1.21" http-auth-basic = "0.1.2" tracing = "0.1.25" tracing-futures = { version = "0.2.5" } diff --git a/rust/cubestore/cubestore/flatbuffers-codegen.sh b/rust/cubestore/cubestore/flatbuffers-codegen.sh deleted file mode 100755 index f0196a790e0e4..0000000000000 --- a/rust/cubestore/cubestore/flatbuffers-codegen.sh +++ /dev/null @@ -1,4 +0,0 @@ -#!/bin/bash - -cd src/codegen -flatc --rust http_message.fbs diff --git a/rust/cubestore/cubestore/src/cluster/mod.rs b/rust/cubestore/cubestore/src/cluster/mod.rs index 8faccd219c1a2..f6500a0e969eb 100644 --- a/rust/cubestore/cubestore/src/cluster/mod.rs +++ b/rust/cubestore/cubestore/src/cluster/mod.rs @@ -49,7 +49,6 @@ use datafusion::arrow::record_batch::RecordBatch; use datafusion::cube_ext; use datafusion::error::DataFusionError; use datafusion::physical_plan::{RecordBatchStream, SendableRecordBatchStream}; -use flatbuffers::bitflags::_core::pin::Pin; use futures::future::join_all; use futures::future::BoxFuture; use futures::task::{Context, Poll}; @@ -69,6 +68,7 @@ use serde::{Deserialize, Serialize}; use std::collections::hash_map::DefaultHasher; use std::collections::HashMap; use std::hash::{Hash, Hasher}; +use std::pin::Pin; use std::sync::Weak; use std::sync::{Arc, Mutex}; use std::time::Duration; diff --git a/rust/cubestore/cubestore/src/http/mod.rs b/rust/cubestore/cubestore/src/http/mod.rs index ec12f732cc3e2..56fd30f21cde7 100644 --- a/rust/cubestore/cubestore/src/http/mod.rs +++ b/rust/cubestore/cubestore/src/http/mod.rs @@ -17,8 +17,8 @@ use cubeshared::codegen::{ HttpMessageArgs, HttpQuery, HttpQueryArgs, HttpResultSet, HttpResultSetArgs, HttpRow, HttpRowArgs, }; +use cubeshared::flatbuffers::{FlatBufferBuilder, ForwardsUOffset, Vector, WIPOffset}; use datafusion::cube_ext; -use flatbuffers::{FlatBufferBuilder, ForwardsUOffset, Vector, WIPOffset}; use futures::{AsyncWriteExt, SinkExt, Stream, StreamExt}; use futures_timer::Delay; use hex::ToHex; @@ -909,8 +909,8 @@ mod tests { use cubeshared::codegen::{ HttpMessageArgs, HttpQuery, HttpQueryArgs, HttpTable, HttpTableArgs, }; + use cubeshared::flatbuffers::{FlatBufferBuilder, ForwardsUOffset, Vector, WIPOffset}; use datafusion::cube_ext; - use flatbuffers::{FlatBufferBuilder, ForwardsUOffset, Vector, WIPOffset}; use futures_util::{SinkExt, StreamExt}; use indoc::indoc; use log::trace; @@ -986,7 +986,7 @@ mod tests { 3,,2020-01-03T00:00:00.000Z 4,four, "}; - let mut builder = flatbuffers::FlatBufferBuilder::with_capacity(1024); + let mut builder = cubeshared::flatbuffers::FlatBufferBuilder::with_capacity(1024); let query_offset = builder.create_string("query"); let mut inline_tables_offsets = Vec::with_capacity(1); let name_offset = builder.create_string("table"); diff --git a/rust/cubestore/cubestore/src/lib.rs b/rust/cubestore/cubestore/src/lib.rs index f4e862298bea8..63f7dd9992291 100644 --- a/rust/cubestore/cubestore/src/lib.rs +++ b/rust/cubestore/cubestore/src/lib.rs @@ -196,8 +196,8 @@ impl From for CubeError { } } -impl From for CubeError { - fn from(v: flatbuffers::InvalidFlatbuffer) -> Self { +impl From for CubeError { + fn from(v: cubeshared::flatbuffers::InvalidFlatbuffer) -> Self { CubeError::from_debug_error(v) } } diff --git a/rust/cubestore/cubestore/src/queryplanner/check_memory.rs b/rust/cubestore/cubestore/src/queryplanner/check_memory.rs index 395a07046c8e3..9dca9c36ea9e2 100644 --- a/rust/cubestore/cubestore/src/queryplanner/check_memory.rs +++ b/rust/cubestore/cubestore/src/queryplanner/check_memory.rs @@ -8,9 +8,9 @@ use datafusion::physical_plan::{ DisplayAs, DisplayFormatType, ExecutionPlan, PlanProperties, RecordBatchStream, SendableRecordBatchStream, }; -use flatbuffers::bitflags::_core::any::Any; use futures::stream::Stream; use futures::StreamExt; +use std::any::Any; use std::fmt::Formatter; use std::pin::Pin; use std::sync::Arc; diff --git a/rust/cubestore/cubestore/src/queryplanner/planning.rs b/rust/cubestore/cubestore/src/queryplanner/planning.rs index 3e329151e1d7b..0fcad901c5983 100644 --- a/rust/cubestore/cubestore/src/queryplanner/planning.rs +++ b/rust/cubestore/cubestore/src/queryplanner/planning.rs @@ -28,9 +28,9 @@ use datafusion::physical_plan::empty::EmptyExec; use datafusion::physical_plan::{ DisplayAs, DisplayFormatType, ExecutionPlan, PlanProperties, SendableRecordBatchStream, }; -use flatbuffers::bitflags::_core::any::Any; -use flatbuffers::bitflags::_core::fmt::Formatter; use itertools::{EitherOrBoth, Itertools}; +use std::any::Any; +use std::fmt::Formatter; use crate::cluster::{Cluster, WorkerPlanningParams}; use crate::metastore::multi_index::MultiPartition; diff --git a/rust/cubestore/cubestore/src/queryplanner/tail_limit.rs b/rust/cubestore/cubestore/src/queryplanner/tail_limit.rs index 7ebda2065a545..4f64a28a45d83 100644 --- a/rust/cubestore/cubestore/src/queryplanner/tail_limit.rs +++ b/rust/cubestore/cubestore/src/queryplanner/tail_limit.rs @@ -11,10 +11,10 @@ use datafusion::physical_plan::{ DisplayAs, DisplayFormatType, ExecutionPlan, PlanProperties, RecordBatchStream, SendableRecordBatchStream, }; -use flatbuffers::bitflags::_core::any::Any; use futures::stream::Stream; use futures::Future; use pin_project_lite::pin_project; +use std::any::Any; use std::fmt::Formatter; use std::pin::Pin; use std::sync::Arc; diff --git a/rust/cubestore/cubestore/src/queryplanner/topk/execute.rs b/rust/cubestore/cubestore/src/queryplanner/topk/execute.rs index 16a7865ea3701..7c3b2a54e9948 100644 --- a/rust/cubestore/cubestore/src/queryplanner/topk/execute.rs +++ b/rust/cubestore/cubestore/src/queryplanner/topk/execute.rs @@ -24,12 +24,12 @@ use datafusion::physical_plan::{ PhysicalExpr, PlanProperties, SendableRecordBatchStream, }; use datafusion::scalar::ScalarValue; -use flatbuffers::bitflags::_core::cmp::Ordering; use futures::{Stream, StreamExt}; use itertools::Itertools; use smallvec::smallvec; use smallvec::SmallVec; use std::any::Any; +use std::cmp::Ordering; use std::collections::BTreeSet; use std::collections::HashSet; use std::fmt::{self, Debug}; diff --git a/rust/cubestore/cubestore/src/queryplanner/trace_data_loaded.rs b/rust/cubestore/cubestore/src/queryplanner/trace_data_loaded.rs index 963ee9d2991a7..8df321c93e637 100644 --- a/rust/cubestore/cubestore/src/queryplanner/trace_data_loaded.rs +++ b/rust/cubestore/cubestore/src/queryplanner/trace_data_loaded.rs @@ -8,9 +8,9 @@ use datafusion::physical_plan::{ DisplayAs, DisplayFormatType, ExecutionPlan, PlanProperties, RecordBatchStream, SendableRecordBatchStream, }; -use flatbuffers::bitflags::_core::any::Any; use futures::stream::Stream; use futures::StreamExt; +use std::any::Any; use std::fmt::Formatter; use std::pin::Pin; use std::sync::atomic::{AtomicUsize, Ordering}; diff --git a/rust/cubestore/cubestore/src/sql/cache.rs b/rust/cubestore/cubestore/src/sql/cache.rs index 5666f9708c1b3..b1fdd3b586d58 100644 --- a/rust/cubestore/cubestore/src/sql/cache.rs +++ b/rust/cubestore/cubestore/src/sql/cache.rs @@ -300,10 +300,10 @@ mod tests { use crate::CubeError; use datafusion::common::DFSchema; use datafusion::logical_expr::{EmptyRelation, LogicalPlan}; - use flatbuffers::bitflags::_core::sync::atomic::AtomicI64; use futures::future::join_all; use futures_timer::Delay; use std::collections::HashMap; + use std::sync::atomic::AtomicI64; use std::sync::atomic::Ordering; use std::sync::Arc; use std::time::Duration;