itsscb/sqlx
1
0
Fork 0
mirror of https://github.com/launchbadge/sqlx.git synced 2025-10-02 15:25:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add connection to serialization

Browse Source
This commit is contained in:
Daniel Akhterov 2019-07-09 20:25:19 -07:00
parent a203177c90
commit b20c120d87
16 changed files with 95 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
mason-mariadb/src/connection/mod.rs
View File

@ -5,7 +5,7 @@ use crate::protocol::{
deserialize::Deserialize,
encode::Encoder,
packets::{com_ping::ComPing, com_quit::ComQuit, ok::OkPacket},
serialize::{Serialize, Serializer},
serialize::Serialize,
server::Message as ServerMessage,
types::{Capabilities, ServerStatusFlag},
};
@ -100,7 +100,7 @@ impl Connection {
self.encoder.clear();
self.encoder.alloc_packet_header();
self.encoder.seq_no(self.seq_no);
Serializer::new(self).serialize(message)?;
message.serialize(self)?;
self.encoder.encode_length();
self.stream.inner.write_all(&self.encoder.buf).await?;

15
mason-mariadb/src/protocol/packets/auth_switch_request.rs
View File

@ -1,4 +1,5 @@
use super::super::{encode::Encoder, serialize::Serialize, types::Capabilities};
use super::super::serialize::Serialize;
use crate::connection::Connection;
use bytes::Bytes;
use failure::Error;
@ -9,14 +10,10 @@ pub struct AuthenticationSwitchRequestPacket {
}
impl Serialize for AuthenticationSwitchRequestPacket {
fn serialize(
&self,
encoder: &mut Encoder,
_server_capabilities: &Capabilities,
) -> Result<(), Error> {
encoder.encode_int_1(0xFE);
encoder.encode_string_null(&self.auth_plugin_name);
encoder.encode_byte_eof(&self.auth_plugin_data);
fn serialize(&self, conn: &mut Connection) -> Result<(), Error> {
conn.encoder.encode_int_1(0xFE);
conn.encoder.encode_string_null(&self.auth_plugin_name);
conn.encoder.encode_byte_eof(&self.auth_plugin_data);
Ok(())
}

13
mason-mariadb/src/protocol/packets/com_debug.rs
View File

@ -1,17 +1,12 @@
use super::super::{
client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
};
use super::super::{client::TextProtocol, serialize::Serialize};
use crate::connection::Connection;
use failure::Error;
pub struct ComDebug();
impl Serialize for ComDebug {
fn serialize<'a, 'b>(
&self,
encoder: &mut Encoder,
_server_capabilities: &Capabilities,
) -> Result<(), Error> {
encoder.encode_int_1(TextProtocol::ComDebug.into());
fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
conn.encoder.encode_int_1(TextProtocol::ComDebug.into());
Ok(())
}

15
mason-mariadb/src/protocol/packets/com_init_db.rs
View File

@ -1,6 +1,5 @@
use super::super::{
client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
};
use super::super::{client::TextProtocol, serialize::Serialize};
use crate::connection::Connection;
use bytes::Bytes;
use failure::Error;
@ -9,13 +8,9 @@ pub struct ComInitDb {
}
impl Serialize for ComInitDb {
fn serialize<'a, 'b>(
&self,
encoder: &mut Encoder,
_server_capabilities: &Capabilities,
) -> Result<(), Error> {
encoder.encode_int_1(TextProtocol::ComInitDb.into());
encoder.encode_string_null(&self.schema_name);
fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
conn.encoder.encode_int_1(TextProtocol::ComInitDb.into());
conn.encoder.encode_string_null(&self.schema_name);
Ok(())
}

13
mason-mariadb/src/protocol/packets/com_ping.rs
View File

@ -1,17 +1,12 @@
use super::super::{
client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
};
use super::super::{client::TextProtocol, serialize::Serialize};
use crate::connection::Connection;
use failure::Error;
pub struct ComPing();
impl Serialize for ComPing {
fn serialize<'a, 'b>(
&self,
encoder: &mut Encoder,
_server_capabilities: &Capabilities,
) -> Result<(), Error> {
encoder.encode_int_1(TextProtocol::ComPing.into());
fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
conn.encoder.encode_int_1(TextProtocol::ComPing.into());
Ok(())
}

15
mason-mariadb/src/protocol/packets/com_process_kill.rs
View File

@ -1,6 +1,5 @@
use super::super::{
client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
};
use super::super::{client::TextProtocol, serialize::Serialize};
use crate::connection::Connection;
use failure::Error;
pub struct ComProcessKill {
@ -8,13 +7,9 @@ pub struct ComProcessKill {
}
impl Serialize for ComProcessKill {
fn serialize<'a, 'b>(
&self,
encoder: &mut Encoder,
_server_capabilities: &Capabilities,
) -> Result<(), Error> {
encoder.encode_int_1(TextProtocol::ComProcessKill.into());
encoder.encode_int_4(self.process_id);
fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
conn.encoder.encode_int_1(TextProtocol::ComProcessKill.into());
conn.encoder.encode_int_4(self.process_id);
Ok(())
}

15
mason-mariadb/src/protocol/packets/com_query.rs
View File

@ -1,6 +1,5 @@
use super::super::{
client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
};
use super::super::{client::TextProtocol, serialize::Serialize};
use crate::connection::Connection;
use bytes::Bytes;
use failure::Error;
@ -9,13 +8,9 @@ pub struct ComQuery {
}
impl Serialize for ComQuery {
fn serialize<'a, 'b>(
&self,
encoder: &mut Encoder,
_server_capabilities: &Capabilities,
) -> Result<(), Error> {
encoder.encode_int_1(TextProtocol::ComQuery.into());
encoder.encode_string_eof(&self.sql_statement);
fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
conn.encoder.encode_int_1(TextProtocol::ComQuery.into());
conn.encoder.encode_string_eof(&self.sql_statement);
Ok(())
}

13
mason-mariadb/src/protocol/packets/com_quit.rs
View File

@ -1,17 +1,12 @@
use super::super::{
client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
};
use super::super::{client::TextProtocol, serialize::Serialize};
use crate::connection::Connection;
use failure::Error;
pub struct ComQuit();
impl Serialize for ComQuit {
fn serialize<'a, 'b>(
&self,
encoder: &mut Encoder,
_server_capabilities: &Capabilities,
) -> Result<(), Error> {
encoder.encode_int_1(TextProtocol::ComQuit.into());
fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
conn.encoder.encode_int_1(TextProtocol::ComQuit.into());
Ok(())
}

13
mason-mariadb/src/protocol/packets/com_reset_conn.rs
View File

@ -1,17 +1,12 @@
use super::super::{
client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
};
use super::super::{client::TextProtocol, serialize::Serialize};
use crate::connection::Connection;
use failure::Error;
pub struct ComResetConnection();
impl Serialize for ComResetConnection {
fn serialize<'a, 'b>(
&self,
encoder: &mut Encoder,
_server_capabilities: &Capabilities,
) -> Result<(), Error> {
encoder.encode_int_1(TextProtocol::ComResetConnection.into());
fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
conn.encoder.encode_int_1(TextProtocol::ComResetConnection.into());
Ok(())
}

15
mason-mariadb/src/protocol/packets/com_set_option.rs
View File

@ -1,6 +1,5 @@
use super::super::{
client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
};
use super::super::{client::TextProtocol, serialize::Serialize};
use crate::connection::Connection;
use failure::Error;
#[derive(Clone, Copy)]
@ -14,13 +13,9 @@ pub struct ComSetOption {
}
impl Serialize for ComSetOption {
fn serialize<'a, 'b>(
&self,
encoder: &mut Encoder,
_server_capabilities: &Capabilities,
) -> Result<(), Error> {
encoder.encode_int_1(TextProtocol::ComSetOption.into());
encoder.encode_int_2(self.option.into());
fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
conn.encoder.encode_int_1(TextProtocol::ComSetOption.into());
conn.encoder.encode_int_2(self.option.into());
Ok(())
}

13
mason-mariadb/src/protocol/packets/com_shutdown.rs
View File

@ -1,4 +1,5 @@
use super::super::{client::TextProtocol, encode::*, serialize::Serialize, types::Capabilities};
use super::super::{client::TextProtocol, serialize::Serialize};
use crate::connection::Connection;
use failure::Error;
#[derive(Clone, Copy)]
@ -11,13 +12,9 @@ pub struct ComShutdown {
}
impl Serialize for ComShutdown {
fn serialize<'a, 'b>(
&self,
encoder: &mut Encoder,
_server_capabilities: &Capabilities,
) -> Result<(), Error> {
encoder.encode_int_1(TextProtocol::ComShutdown.into());
encoder.encode_int_1(self.option.into());
fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
conn.encoder.encode_int_1(TextProtocol::ComShutdown.into());
conn.encoder.encode_int_1(self.option.into());
Ok(())
}

13
mason-mariadb/src/protocol/packets/com_sleep.rs
View File

@ -1,17 +1,12 @@
use super::super::{
client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
};
use super::super::{client::TextProtocol, serialize::Serialize};
use crate::connection::Connection;
use failure::Error;
pub struct ComSleep();
impl Serialize for ComSleep {
fn serialize<'a, 'b>(
&self,
encoder: &mut Encoder,
_server_capabilities: &Capabilities,
) -> Result<(), Error> {
encoder.encode_int_1(TextProtocol::ComSleep.into());
fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
conn.encoder.encode_int_1(TextProtocol::ComSleep.into());
Ok(())
}

13
mason-mariadb/src/protocol/packets/com_statistics.rs
View File

@ -1,17 +1,12 @@
use super::super::{
client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
};
use super::super::{client::TextProtocol, serialize::Serialize};
use crate::connection::Connection;
use failure::Error;
pub struct ComStatistics();
impl Serialize for ComStatistics {
fn serialize<'a, 'b>(
&self,
encoder: &mut Encoder,
_server_capabilities: &Capabilities,
) -> Result<(), Error> {
encoder.encode_int_1(TextProtocol::ComStatistics.into());
fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
conn.encoder.encode_int_1(TextProtocol::ComStatistics.into());
Ok(())
}

54
mason-mariadb/src/protocol/packets/handshake_response.rs
View File

@ -1,4 +1,5 @@
use super::super::{encode::Encoder, serialize::Serialize, types::Capabilities};
use super::super::{serialize::Serialize, types::Capabilities};
use crate::connection::Connection;
use bytes::Bytes;
use failure::Error;
@ -19,66 +20,63 @@ pub struct HandshakeResponsePacket {
}
impl Serialize for HandshakeResponsePacket {
fn serialize<'a, 'b>(
&self,
encoder: &mut Encoder,
server_capabilities: &Capabilities,
) -> Result<(), Error> {
encoder.encode_int_4(self.capabilities.bits() as u32);
encoder.encode_int_4(self.max_packet_size);
encoder.encode_int_1(self.collation);
fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
conn.encoder.encode_int_4(self.capabilities.bits() as u32);
conn.encoder.encode_int_4(self.max_packet_size);
conn.encoder.encode_int_1(self.collation);
// Filler
encoder.encode_byte_fix(&Bytes::from_static(&[0u8; 19]), 19);
conn.encoder.encode_byte_fix(&Bytes::from_static(&[0u8; 19]), 19);
if !(*server_capabilities & Capabilities::CLIENT_MYSQL).is_empty()
if !(conn.capabilities & Capabilities::CLIENT_MYSQL).is_empty()
&& !(self.capabilities & Capabilities::CLIENT_MYSQL).is_empty()
{
if let Some(capabilities) = self.extended_capabilities {
encoder.encode_int_4(capabilities.bits() as u32);
conn.encoder.encode_int_4(capabilities.bits() as u32);
}
} else {
encoder.encode_byte_fix(&Bytes::from_static(&[0u8; 4]), 4);
conn.encoder.encode_byte_fix(&Bytes::from_static(&[0u8; 4]), 4);
}
encoder.encode_string_null(&self.username);
conn.encoder.encode_string_null(&self.username);
if !(*server_capabilities & Capabilities::PLUGIN_AUTH_LENENC_CLIENT_DATA).is_empty() {
if !(conn.capabilities & Capabilities::PLUGIN_AUTH_LENENC_CLIENT_DATA).is_empty() {
if let Some(auth_data) = &self.auth_data {
encoder.encode_string_lenenc(&auth_data);
conn.encoder.encode_string_lenenc(&auth_data);
}
} else if !(*server_capabilities & Capabilities::SECURE_CONNECTION).is_empty() {
} else if !(conn.capabilities & Capabilities::SECURE_CONNECTION).is_empty() {
if let Some(auth_response) = &self.auth_response {
encoder.encode_int_1(self.auth_response_len.unwrap());
encoder.encode_string_fix(&auth_response, self.auth_response_len.unwrap() as usize);
conn.encoder.encode_int_1(self.auth_response_len.unwrap());
conn.encoder
.encode_string_fix(&auth_response, self.auth_response_len.unwrap() as usize);
}
} else {
encoder.encode_int_1(0);
conn.encoder.encode_int_1(0);
}
if !(*server_capabilities & Capabilities::CONNECT_WITH_DB).is_empty() {
if !(conn.capabilities & Capabilities::CONNECT_WITH_DB).is_empty() {
if let Some(database) = &self.database {
// string<NUL>
encoder.encode_string_null(&database);
conn.encoder.encode_string_null(&database);
}
}
if !(*server_capabilities & Capabilities::PLUGIN_AUTH).is_empty() {
if !(conn.capabilities & Capabilities::PLUGIN_AUTH).is_empty() {
if let Some(auth_plugin_name) = &self.auth_plugin_name {
// string<NUL>
encoder.encode_string_null(&auth_plugin_name);
conn.encoder.encode_string_null(&auth_plugin_name);
}
}
if !(*server_capabilities & Capabilities::CONNECT_ATTRS).is_empty() {
if !(conn.capabilities & Capabilities::CONNECT_ATTRS).is_empty() {
if let (Some(conn_attr_len), Some(conn_attr)) = (&self.conn_attr_len, &self.conn_attr) {
// int<lenenc>
encoder.encode_int_lenenc(Some(conn_attr_len));
conn.encoder.encode_int_lenenc(Some(conn_attr_len));
// Loop
for (key, value) in conn_attr {
encoder.encode_string_lenenc(&key);
encoder.encode_string_lenenc(&value);
conn.encoder.encode_string_lenenc(&key);
conn.encoder.encode_string_lenenc(&value);
}
}
}

23
mason-mariadb/src/protocol/packets/ssl_request.rs
View File

@ -1,4 +1,5 @@
use super::super::{encode::Encoder, serialize::Serialize, types::Capabilities};
use super::super::{serialize::Serialize, types::Capabilities};
use crate::connection::Connection;
use bytes::Bytes;
use failure::Error;
@ -11,26 +12,22 @@ pub struct SSLRequestPacket {
}
impl Serialize for SSLRequestPacket {
fn serialize<'a, 'b>(
&self,
encoder: &mut Encoder,
server_capabilities: &Capabilities,
) -> Result<(), Error> {
encoder.encode_int_4(self.capabilities.bits() as u32);
encoder.encode_int_4(self.max_packet_size);
encoder.encode_int_1(self.collation);
fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
conn.encoder.encode_int_4(self.capabilities.bits() as u32);
conn.encoder.encode_int_4(self.max_packet_size);
conn.encoder.encode_int_1(self.collation);
// Filler
encoder.encode_byte_fix(&Bytes::from_static(&[0u8; 19]), 19);
conn.encoder.encode_byte_fix(&Bytes::from_static(&[0u8; 19]), 19);
if !(*server_capabilities & Capabilities::CLIENT_MYSQL).is_empty()
if !(conn.capabilities & Capabilities::CLIENT_MYSQL).is_empty()
&& !(self.capabilities & Capabilities::CLIENT_MYSQL).is_empty()
{
if let Some(capabilities) = self.extended_capabilities {
encoder.encode_int_4(capabilities.bits() as u32);
conn.encoder.encode_int_4(capabilities.bits() as u32);
}
} else {
encoder.encode_byte_fix(&Bytes::from_static(&[0u8; 4]), 4);
conn.encoder.encode_byte_fix(&Bytes::from_static(&[0u8; 4]), 4);
}
Ok(())

26
mason-mariadb/src/protocol/serialize.rs
View File

@ -1,28 +1,6 @@
use super::{super::connection::Connection, encode::Encoder, types::Capabilities};
use super::super::connection::Connection;
use failure::Error;
pub trait Serialize {
fn serialize<'a, 'b>(
&self,
encoder: &'b mut Encoder,
server_capabilities: &Capabilities,
) -> Result<(), Error>;
}
pub struct Serializer<'a> {
pub conn: &'a mut Connection,
}
impl<'a> Serializer<'a> {
#[inline]
pub fn new(conn: &'a mut Connection) -> Self {
Serializer {
conn,
}
}
#[inline]
pub fn serialize<S: Serialize>(&mut self, message: S) -> Result<(), Error> {
message.serialize(&mut self.conn.encoder, &self.conn.capabilities)
}
fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error>;
}