Trait sibyl::ToSql

source ·
pub trait ToSql: Send + Sync {
    // Required method
    fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>; // Provided method fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize> { ... } }
Expand description

A trait for types that can be used as SQL arguments

Required Methods§

source

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

Binds itself to the SQL parameter placeholder

Parameters
  • pos - zero-based index of the parameter placeholder to which the value will be bound
  • params - Statement parameters as defined in the SQL
  • stmt - statement to which the argument value will be bound
  • err - OCI error structure

Note that the specified position might be ignored if the argument also provides the specific placeholder name to which the value should be bound.

Returns

The index of the placeholder for the next argument.

Provided Methods§

source

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

A callback that is called to update OUT (or INOUT) argumetns. For example, to set the length of the received data.

Implementations on Foreign Types§

source§

impl ToSql for &[Date<'_>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&Date<'_>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut Date<'_>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[Raw<'_>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&Raw<'_>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut Raw<'_>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[Number<'_>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&Number<'_>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut Number<'_>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[Varchar<'_>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&Varchar<'_>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut Varchar<'_>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[DateTime<'_, OCITimestamp>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&DateTime<'_, OCITimestamp>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut DateTime<'_, OCITimestamp>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[DateTime<'_, OCITimestampTZ>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&DateTime<'_, OCITimestampTZ>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut DateTime<'_, OCITimestampTZ>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[DateTime<'_, OCITimestampLTZ>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&DateTime<'_, OCITimestampLTZ>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut DateTime<'_, OCITimestampLTZ>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[Interval<'_, OCIIntervalYearToMonth>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&Interval<'_, OCIIntervalYearToMonth>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut Interval<'_, OCIIntervalYearToMonth>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[Interval<'_, OCIIntervalDayToSecond>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&Interval<'_, OCIIntervalDayToSecond>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut Interval<'_, OCIIntervalDayToSecond>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[RowID]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&RowID]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut RowID]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for i8

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &i8

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut i8

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<i8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&i8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&mut i8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<i8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&i8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&mut i8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<i8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&i8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&mut i8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for i16

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &i16

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut i16

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<i16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&i16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&mut i16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<i16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&i16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&mut i16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<i16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&i16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&mut i16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for i32

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &i32

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut i32

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<i32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&i32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&mut i32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<i32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&i32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&mut i32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<i32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&i32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&mut i32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for i64

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &i64

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut i64

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<i64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&i64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&mut i64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<i64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&i64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&mut i64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<i64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&i64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&mut i64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for isize

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &isize

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut isize

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<isize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&isize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&mut isize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<isize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&isize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&mut isize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<isize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&isize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&mut isize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for u8

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &u8

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut u8

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<u8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&u8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&mut u8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<u8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&u8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&mut u8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<u8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&u8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&mut u8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for u16

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &u16

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut u16

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<u16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&u16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&mut u16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<u16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&u16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&mut u16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<u16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&u16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&mut u16>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for u32

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &u32

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut u32

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<u32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&u32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&mut u32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<u32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&u32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&mut u32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<u32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&u32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&mut u32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for u64

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &u64

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut u64

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<u64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&u64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&mut u64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<u64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&u64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&mut u64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<u64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&u64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&mut u64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for usize

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &usize

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut usize

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<usize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&usize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&mut usize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<usize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&usize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&mut usize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<usize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&usize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&mut usize>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for f32

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &f32

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut f32

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<f32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&f32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&mut f32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<f32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&f32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&mut f32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<f32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&f32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&mut f32>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for f64

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &f64

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut f64

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<f64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&f64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&mut f64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<f64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&f64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&mut f64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<f64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&f64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&mut f64>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &[i8]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&i8]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut i8]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[i16]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&i16]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut i16]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[i32]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&i32]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut i32]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[i64]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&i64]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut i64]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[isize]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&isize]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut isize]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[u16]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&u16]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut u16]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[u32]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&u32]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut u32]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[u64]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&u64]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut u64]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[usize]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&usize]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut usize]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[f32]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&f32]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut f32]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[f64]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&f64]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut f64]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &str

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &&str

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&str>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&str>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<&str>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for Option<&&str>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&&str>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<&&str>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &[&str]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&&str]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for String

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &String

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut String

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for Option<String>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&String>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&mut String>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &Option<String>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&String>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&mut String>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<String>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&String>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<&mut String>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &[String]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&String]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [String]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut String]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &[u8]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &&[u8]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut [u8]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut &mut [u8]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &[&[u8]]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&&[u8]]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut [u8]]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut &mut [u8]]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for Option<&[u8]>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&[u8]>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<&[u8]>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&&[u8]>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&&[u8]>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<&&[u8]>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&mut [u8]>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&mut [u8]>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<&mut [u8]>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for Option<&mut &mut [u8]>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&mut &mut [u8]>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<&mut &mut [u8]>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for Vec<u8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &Vec<u8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Vec<u8>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &[Vec<u8>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &[&Vec<u8>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for &mut [Vec<u8>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut [&mut Vec<u8>]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for Option<Vec<u8>>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&Vec<u8>>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for Option<&mut Vec<u8>>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &Option<Vec<u8>>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&Vec<u8>>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &Option<&mut Vec<u8>>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<Vec<u8>>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Option<&Vec<u8>>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &mut Option<&mut Vec<u8>>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for bool

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &bool

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl ToSql for &[bool]

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, _params: &Params) -> Result<usize>

source§

impl ToSql for ()

source§

fn bind_to(
&mut self,
pos: usize,
_params: &mut Params,
_stmt: &OCIStmt,
_err: &OCIError
) -> Result<usize>

source§

impl<T> ToSql for Option<T>where
T: OracleDataType,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<T> ToSql for &Option<T>where
T: OracleDataType,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

impl<T> ToSql for &mut Option<T>where
T: OracleDataType,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for Vec<&mut dyn ToSql>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl ToSql for &mut Vec<&mut dyn ToSql>

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<T> ToSql for (&str, T)where
T: ToSql,

source§

fn bind_to(
&mut self,
_pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, _pos: usize, params: &Params) -> Result<usize>

source§

impl<T1, T2> ToSql for ((&str, T1), (&str, T2))where
T1: ToSql,
T2: ToSql,

source§

fn bind_to(
&mut self,
_pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, _pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C> ToSql for (A, B, C)where
A: ToSql,
B: ToSql,
C: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D> ToSql for (A, B, C, D)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E> ToSql for (A, B, C, D, E)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F> ToSql for (A, B, C, D, E, F)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G> ToSql for (A, B, C, D, E, F, G)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H> ToSql for (A, B, C, D, E, F, G, H)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I> ToSql for (A, B, C, D, E, F, G, H, I)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J> ToSql for (A, B, C, D, E, F, G, H, I, J)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J, K> ToSql for (A, B, C, D, E, F, G, H, I, J, K)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,
K: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J, K, L> ToSql for (A, B, C, D, E, F, G, H, I, J, K, L)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,
K: ToSql,
L: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> ToSql for (A, B, C, D, E, F, G, H, I, J, K, L, M)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,
K: ToSql,
L: ToSql,
M: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> ToSql for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,
K: ToSql,
L: ToSql,
M: ToSql,
N: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> ToSql for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,
K: ToSql,
L: ToSql,
M: ToSql,
N: ToSql,
O: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> ToSql for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,
K: ToSql,
L: ToSql,
M: ToSql,
N: ToSql,
O: ToSql,
P: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> ToSql for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,
K: ToSql,
L: ToSql,
M: ToSql,
N: ToSql,
O: ToSql,
P: ToSql,
Q: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> ToSql for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,
K: ToSql,
L: ToSql,
M: ToSql,
N: ToSql,
O: ToSql,
P: ToSql,
Q: ToSql,
R: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> ToSql for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,
K: ToSql,
L: ToSql,
M: ToSql,
N: ToSql,
O: ToSql,
P: ToSql,
Q: ToSql,
R: ToSql,
S: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> ToSql for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,
K: ToSql,
L: ToSql,
M: ToSql,
N: ToSql,
O: ToSql,
P: ToSql,
Q: ToSql,
R: ToSql,
S: ToSql,
T: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> ToSql for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,
K: ToSql,
L: ToSql,
M: ToSql,
N: ToSql,
O: ToSql,
P: ToSql,
Q: ToSql,
R: ToSql,
S: ToSql,
T: ToSql,
U: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> ToSql for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,
K: ToSql,
L: ToSql,
M: ToSql,
N: ToSql,
O: ToSql,
P: ToSql,
Q: ToSql,
R: ToSql,
S: ToSql,
T: ToSql,
U: ToSql,
V: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> ToSql for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,
K: ToSql,
L: ToSql,
M: ToSql,
N: ToSql,
O: ToSql,
P: ToSql,
Q: ToSql,
R: ToSql,
S: ToSql,
T: ToSql,
U: ToSql,
V: ToSql,
W: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> ToSql for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,
K: ToSql,
L: ToSql,
M: ToSql,
N: ToSql,
O: ToSql,
P: ToSql,
Q: ToSql,
R: ToSql,
S: ToSql,
T: ToSql,
U: ToSql,
V: ToSql,
W: ToSql,
X: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> ToSql for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,
K: ToSql,
L: ToSql,
M: ToSql,
N: ToSql,
O: ToSql,
P: ToSql,
Q: ToSql,
R: ToSql,
S: ToSql,
T: ToSql,
U: ToSql,
V: ToSql,
W: ToSql,
X: ToSql,
Y: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

source§

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> ToSql for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)where
A: ToSql,
B: ToSql,
C: ToSql,
D: ToSql,
E: ToSql,
F: ToSql,
G: ToSql,
H: ToSql,
I: ToSql,
J: ToSql,
K: ToSql,
L: ToSql,
M: ToSql,
N: ToSql,
O: ToSql,
P: ToSql,
Q: ToSql,
R: ToSql,
S: ToSql,
T: ToSql,
U: ToSql,
V: ToSql,
W: ToSql,
X: ToSql,
Y: ToSql,
Z: ToSql,

source§

fn bind_to(
&mut self,
pos: usize,
params: &mut Params,
stmt: &OCIStmt,
err: &OCIError
) -> Result<usize>

source§

fn update_from_bind(&mut self, pos: usize, params: &Params) -> Result<usize>

Implementors§

source§

impl ToSql for &Date<'_>

source§

impl ToSql for &DateTime<'_, OCITimestamp>

source§

impl ToSql for &DateTime<'_, OCITimestampLTZ>

source§

impl ToSql for &DateTime<'_, OCITimestampTZ>

source§

impl ToSql for &Interval<'_, OCIIntervalDayToSecond>

source§

impl ToSql for &Interval<'_, OCIIntervalYearToMonth>

source§

impl ToSql for &Number<'_>

source§

impl ToSql for &Raw<'_>

source§

impl ToSql for &RowID

source§

impl ToSql for &Varchar<'_>

source§

impl ToSql for &mut Cursor<'_>

source§

impl ToSql for &mut Date<'_>

source§

impl ToSql for &mut DateTime<'_, OCITimestamp>

source§

impl ToSql for &mut DateTime<'_, OCITimestampLTZ>

source§

impl ToSql for &mut DateTime<'_, OCITimestampTZ>

source§

impl ToSql for &mut Interval<'_, OCIIntervalDayToSecond>

source§

impl ToSql for &mut Interval<'_, OCIIntervalYearToMonth>

source§

impl ToSql for &mut Number<'_>

source§

impl ToSql for &mut Raw<'_>

source§

impl ToSql for &mut RowID

source§

impl ToSql for &mut Varchar<'_>

source§

impl ToSql for Date<'_>

source§

impl ToSql for DateTime<'_, OCITimestamp>

source§

impl ToSql for DateTime<'_, OCITimestampLTZ>

source§

impl ToSql for DateTime<'_, OCITimestampTZ>

source§

impl ToSql for Interval<'_, OCIIntervalDayToSecond>

source§

impl ToSql for Interval<'_, OCIIntervalYearToMonth>

source§

impl ToSql for Number<'_>

source§

impl ToSql for Raw<'_>

source§

impl ToSql for RowID

source§

impl ToSql for Varchar<'_>

source§

impl<T> ToSql for &LOB<'_, T>where
T: DescriptorType<OCIType = OCILobLocator>,

source§

impl<T> ToSql for &Nvl<T>where
T: ToSql + SqlType,

source§

impl<T> ToSql for &mut LOB<'_, T>where
T: DescriptorType<OCIType = OCILobLocator>,

source§

impl<T> ToSql for &mut Nvl<T>where
T: ToSql + SqlType,

source§

impl<T> ToSql for Nvl<T>where
T: ToSql + SqlType,