Merge pull request #50 from launchbadge/rl-refactor-types

Refactor HasSqlType to provide an array of compatible types

Author: mehcode

sqlx-core/src/database.rs

@@ -1,13 +1,15 @@
+use std::fmt::Display;
+
 use crate::arguments::Arguments;
 use crate::connection::Connection;
 use crate::row::Row;
-use crate::types::HasTypeMetadata;
+use crate::types::TypeInfo;
 
 /// A database driver.
 ///
 /// This trait encapsulates a complete driver implementation to a specific
 /// database (e.g., MySQL, Postgres).
-pub trait Database: HasTypeMetadata + 'static {
+pub trait Database: 'static {
     /// The concrete `Connection` implementation for this database.
     type Connection: Connection<Database = Self>;
 
@@ -16,4 +18,10 @@ pub trait Database: HasTypeMetadata + 'static {
 
     /// The concrete `Row` implementation for this database.
     type Row: Row<Database = Self>;
+
+    /// The concrete `TypeInfo` implementation for this database.
+    type TypeInfo: TypeInfo;
+
+    /// The Rust type of table identifiers for this database.
+    type TableId: Display + Clone;
 }

sqlx-core/src/describe.rs

@@ -1,6 +1,5 @@
 //! Types for returning SQL type information about queries.
 
-use crate::types::HasTypeMetadata;
 use crate::Database;
 use std::fmt::{self, Debug};
 
@@ -11,7 +10,7 @@ where
     DB: Database + ?Sized,
 {
     /// The expected types for the parameters of the query.
-    pub param_types: Box<[<DB as HasTypeMetadata>::TypeId]>,
+    pub param_types: Box<[DB::TypeInfo]>,
 
     /// The type and table information, if any for the results of the query.
     pub result_columns: Box<[Column<DB>]>,
@@ -20,7 +19,7 @@ where
 impl<DB> Debug for Describe<DB>
 where
     DB: Database,
-    <DB as HasTypeMetadata>::TypeId: Debug,
+    DB::TypeInfo: Debug,
     Column<DB>: Debug,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -38,21 +37,21 @@ where
     DB: Database + ?Sized,
 {
     pub name: Option<Box<str>>,
-    pub table_id: Option<<DB as HasTypeMetadata>::TableId>,
-    pub type_id: <DB as HasTypeMetadata>::TypeId,
+    pub table_id: Option<DB::TableId>,
+    pub type_info: DB::TypeInfo,
 }
 
 impl<DB> Debug for Column<DB>
 where
     DB: Database + ?Sized,
-    <DB as HasTypeMetadata>::TableId: Debug,
-    <DB as HasTypeMetadata>::TypeId: Debug,
+    DB::TableId: Debug,
+    DB::TypeInfo: Debug,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("Column")
             .field("name", &self.name)
             .field("table_id", &self.table_id)
-            .field("type_id", &self.type_id)
+            .field("type_id", &self.type_info)
             .finish()
     }
 }

sqlx-core/src/encode.rs

@@ -74,7 +74,7 @@ where
 
     fn size_hint(&self) -> usize {
         if self.is_some() {
-            mem::size_of::<T>()
+            (*self).size_hint()
         } else {
             0
         }

sqlx-core/src/executor.rs

@@ -64,7 +64,7 @@ pub trait Executor {
         Box::pin(async move { s.try_next().await?.ok_or(crate::Error::NotFound) })
     }
 
-    /// Analyze the SQL query and report the inferred bind parameter types and returned columns.
+    #[doc(hidden)]
     fn describe<'e, 'q: 'e>(
         &'e mut self,
         query: &'q str,

sqlx-core/src/lib.rs

@@ -20,7 +20,10 @@ mod url;
 
 #[macro_use]
 pub mod arguments;
+
+#[doc(hidden)]
 pub mod decode;
+
 pub mod describe;
 pub mod encode;
 pub mod pool;

sqlx-core/src/mysql/arguments.rs

@@ -1,12 +1,12 @@
 use crate::arguments::Arguments;
 use crate::encode::{Encode, IsNull};
-use crate::mysql::types::MySqlTypeMetadata;
+use crate::mysql::types::MySqlTypeInfo;
 use crate::mysql::MySql;
 use crate::types::HasSqlType;
 
 #[derive(Default)]
 pub struct MySqlArguments {
-    pub(crate) param_types: Vec<MySqlTypeMetadata>,
+    pub(crate) param_types: Vec<MySqlTypeInfo>,
     pub(crate) params: Vec<u8>,
     pub(crate) null_bitmap: Vec<u8>,
 }
@@ -38,10 +38,10 @@ impl Arguments for MySqlArguments {
         Self::Database: HasSqlType<T>,
         T: Encode<Self::Database>,
     {
-        let metadata = <MySql as HasSqlType<T>>::metadata();
+        let type_id = <MySql as HasSqlType<T>>::type_info();
         let index = self.param_types.len();
 
-        self.param_types.push(metadata);
+        self.param_types.push(type_id);
         self.null_bitmap.resize((index / 8) + 1, 0);
 
         if let IsNull::Yes = value.encode_nullable(&mut self.params) {

sqlx-core/src/mysql/database.rs

@@ -9,6 +9,10 @@ impl Database for MySql {
     type Arguments = super::MySqlArguments;
 
     type Row = super::MySqlRow;
+
+    type TypeInfo = super::MySqlTypeInfo;
+
+    type TableId = Box<str>;
 }
 
 impl_into_arguments_for_database!(MySql);

sqlx-core/src/mysql/executor.rs

@@ -8,9 +8,9 @@ use crate::describe::{Column, Describe};
 use crate::executor::Executor;
 use crate::mysql::protocol::{
     Capabilities, ColumnCount, ColumnDefinition, ComQuery, ComStmtExecute, ComStmtPrepare,
-    ComStmtPrepareOk, Cursor, Decode, EofPacket, OkPacket, Row, Type,
+    ComStmtPrepareOk, Cursor, Decode, EofPacket, OkPacket, Row, TypeId,
 };
-use crate::mysql::{MySql, MySqlArguments, MySqlConnection, MySqlRow};
+use crate::mysql::{MySql, MySqlArguments, MySqlConnection, MySqlRow, MySqlTypeInfo};
 
 enum Step {
     Command(u64),
@@ -48,14 +48,14 @@ impl MySqlConnection {
         }
     }
 
-    async fn receive_column_types(&mut self, count: usize) -> crate::Result<Box<[Type]>> {
-        let mut columns: Vec<Type> = Vec::with_capacity(count);
+    async fn receive_column_types(&mut self, count: usize) -> crate::Result<Box<[TypeId]>> {
+        let mut columns: Vec<TypeId> = Vec::with_capacity(count);
 
         for _ in 0..count {
             let column: ColumnDefinition =
                 ColumnDefinition::decode(self.receive().await?.packet())?;
 
-            columns.push(column.r#type);
+            columns.push(column.type_id);
         }
 
         if count > 0 {
@@ -145,7 +145,7 @@ impl MySqlConnection {
         .await
     }
 
-    async fn step(&mut self, columns: &[Type], binary: bool) -> crate::Result<Option<Step>> {
+    async fn step(&mut self, columns: &[TypeId], binary: bool) -> crate::Result<Option<Step>> {
         let capabilities = self.capabilities;
         ret_if_none!(self.try_receive().await?);
 
@@ -244,7 +244,7 @@ impl MySqlConnection {
 
         for _ in 0..prepare_ok.params {
             let param = ColumnDefinition::decode(self.receive().await?.packet())?;
-            param_types.push(param.r#type.0);
+            param_types.push(MySqlTypeInfo::from_column_def(&param));
         }
 
         if prepare_ok.params > 0 {
@@ -254,11 +254,9 @@ impl MySqlConnection {
         for _ in 0..prepare_ok.columns {
             let column = ColumnDefinition::decode(self.receive().await?.packet())?;
             result_columns.push(Column::<MySql> {
+                type_info: MySqlTypeInfo::from_column_def(&column),
                 name: column.column_alias.or(column.column),
-
                 table_id: column.table_alias.or(column.table),
-
-                type_id: column.r#type.0,
             });
         }
 

sqlx-core/src/mysql/mod.rs

@@ -20,6 +20,8 @@ pub use connection::MySqlConnection;
 
 pub use error::MySqlError;
 
+pub use types::MySqlTypeInfo;
+
 pub use row::MySqlRow;
 
 /// An alias for [`Pool`], specialized for **MySQL**.

sqlx-core/src/mysql/protocol/column_def.rs

@@ -2,7 +2,7 @@ use byteorder::LittleEndian;
 
 use crate::io::Buf;
 use crate::mysql::io::BufExt;
-use crate::mysql::protocol::{Decode, FieldFlags, Type};
+use crate::mysql::protocol::{Decode, FieldFlags, TypeId};
 
 // https://dev.mysql.com/doc/dev/mysql-server/8.0.12/page_protocol_com_query_response_text_resultset_column_definition.html
 // https://mariadb.com/kb/en/resultset/#column-definition-packet
@@ -20,7 +20,7 @@ pub struct ColumnDefinition {
 
     pub max_size: u32,
 
-    pub r#type: Type,
+    pub type_id: TypeId,
 
     pub flags: FieldFlags,
 
@@ -57,7 +57,7 @@ impl Decode for ColumnDefinition {
         let char_set = buf.get_u16::<LittleEndian>()?;
         let max_size = buf.get_u32::<LittleEndian>()?;
 
-        let r#type = buf.get_u8()?;
+        let type_id = buf.get_u8()?;
         let flags = buf.get_u16::<LittleEndian>()?;
         let decimals = buf.get_u8()?;
 
@@ -69,7 +69,7 @@ impl Decode for ColumnDefinition {
             column_alias,
             char_set,
             max_size,
-            r#type: Type(r#type),
+            type_id: TypeId(type_id),
             flags: FieldFlags::from_bits_truncate(flags),
             decimals,
         })