Struct sibyl::Cursor

pub struct Cursor<'a> { /* fields omitted */ }

Cursors - implicit results and REF CURSOR - from an executed PL/SQL statement

Methods

impl<'a> Cursor<'a>

pub fn new(stmt: &'a dyn Stmt) -> Result<Self>

Creates a Cursor that can be used as an OUT argument to receive a returning REF CURSOR.

Example

use sibyl::{Cursor, Number};
use std::cmp::Ordering::Equal;

let stmt = conn.prepare("
    BEGIN
        OPEN :lowest_payed_employee FOR
            SELECT department_name, first_name, last_name, salary
             FROM (
                   SELECT first_name, last_name, salary, department_id
                        , ROW_NUMBER() OVER (ORDER BY salary) ord
                     FROM hr.employees
                  ) e
             JOIN hr.departments d
               ON d.department_id = e.department_id
            WHERE ord = 1
        ;
        OPEN :median_salary_employees FOR
            SELECT department_name, first_name, last_name, salary
              FROM (
                    SELECT first_name, last_name, salary, department_id
                         , MEDIAN(salary) OVER () median_salary
                      FROM hr.employees
                   ) e
              JOIN hr.departments d
                ON d.department_id = e.department_id
             WHERE salary = median_salary
          ORDER BY department_name, last_name, first_name
        ;
    END;
")?;

let mut lowest_payed_employee   = Cursor::new(&stmt)?;
let mut median_salary_employees = Cursor::new(&stmt)?;

stmt.execute_into(&[], &mut [
    &mut ( ":lowest_payed_employee",   &mut lowest_payed_employee   ),
    &mut ( ":median_salary_employees", &mut median_salary_employees ),
])?;

let rows = lowest_payed_employee.rows()?;

let row = rows.next()?;
assert!(row.is_some());
let row = row.unwrap();

let department_name = row.get::<&str>(0)?.unwrap();
assert_eq!(department_name, "Shipping");

let first_name = row.get::<&str>(1)?;
assert!(first_name.is_some());
let first_name = first_name.unwrap();
assert_eq!(first_name, "TJ");

let last_name = row.get::<&str>(2)?.unwrap();
assert_eq!(last_name, "Olson");

let salary = row.get::<Number>(3)?.unwrap();
let expected = Number::from_int(2100, &oracle);
assert!(salary.cmp(&expected)? == Equal);

let row = rows.next()?;
assert!(row.is_none());

let rows = median_salary_employees.rows()?;

let row = rows.next()?;
assert!(row.is_some());
let row = row.unwrap();

let department_name = row.get::<&str>(0)?.unwrap();
assert_eq!(department_name, "Sales");

let first_name = row.get::<&str>(1)?;
assert!(first_name.is_some());
let first_name = first_name.unwrap();
assert_eq!(first_name, "Amit");

let last_name = row.get::<&str>(2)?.unwrap();
assert_eq!(last_name, "Banda");

let expected = Number::from_int(6200, &oracle);

let salary = row.get::<Number>(3)?.unwrap();
assert!(salary.cmp(&expected)? == Equal);

let row = rows.next()?;
assert!(row.is_some());
let row = row.unwrap();

let department_name = row.get::<&str>(0)?.unwrap();
assert_eq!(department_name, "Sales");

let first_name = row.get::<&str>(1)?;
assert!(first_name.is_some());
let first_name = first_name.unwrap();
assert_eq!(first_name, "Charles");

let last_name = row.get::<&str>(2)?.unwrap();
assert_eq!(last_name, "Johnson");

let salary = row.get::<Number>(3)?.unwrap();
assert!(salary.cmp(&expected)? == Equal);

let row = rows.next()?;
assert!(row.is_none());

See also Statement::next_result for another method to return REF CURSORs.

pub fn rows(&self) -> Result<Rows>

Returns rows selected by this cursor

Example

use sibyl::Cursor;

let stmt = conn.prepare("
    SELECT last_name
         , CURSOR(
                SELECT department_name
                  FROM hr.departments
                 WHERE department_id IN (
                            SELECT department_id
                              FROM hr.employees
                             WHERE last_name = e.last_name)
              ORDER BY department_name
           ) AS departments
      FROM (
            SELECT distinct last_name
              FROM hr.employees
             WHERE last_name = :last_name
           ) e
")?;
let rows = stmt.query(&[ &"King" ])?;
 
let row = rows.next()?;
assert!(row.is_some());
let row = row.unwrap();
 
let last_name = row.get::<&str>(0)?.unwrap();
assert_eq!(last_name, "King");
 
let departments = row.get::<Cursor>(1)?.unwrap();
let dept_rows = departments.rows()?;
 
let dept_row = dept_rows.next()?;
assert!(dept_row.is_some());
let dept_row = dept_row.unwrap();
 
let department_name = dept_row.get::<&str>(0)?.unwrap();
assert_eq!("Executive", department_name);
 
let dept_row = dept_rows.next()?;
assert!(dept_row.is_some());
let dept_row = dept_row.unwrap();
 
let department_name = dept_row.get::<&str>(0)?.unwrap();
assert_eq!("Sales", department_name);
 
let dept_row = dept_rows.next()?;
assert!(dept_row.is_none());
 
let row = rows.next()?;
assert!(row.is_none());

Trait Implementations

impl<'_> Env for Cursor<'_>

fn env_ptr(&self) -> *mut OCIEnv

fn err_ptr(&self) -> *mut OCIError

impl<'_> ToSqlOut for Cursor<'_>

fn to_sql_output(&mut self, _col_size: usize) -> (u16, *mut c_void, usize)

Returns output buffer characteristics as a tuple of (SQLT type, buffer pointer, buffer size)

fn set_len(&mut self, _new_len: usize)

Called to set the received data length (always less than the initial capacity)

impl<'a> FromSql<'a> for Cursor<'a>

fn value(val: &ColumnValue, stmt: &'a dyn Stmt) -> Result<Self>

Converts, if possible, data stored in the column buffer into the requested type and returns the instance of it. Returns error if the conversion fails or not defined from the type of the column buffer into a requested type.

impl<'_> Conn for Cursor<'_>

fn srv_ptr(&self) -> *mut OCIServer

fn svc_ptr(&self) -> *mut OCISvcCtx

fn usr_ptr(&self) -> *mut OCISession

impl<'_> Stmt for Cursor<'_>

fn stmt_ptr(&self) -> *mut OCIStmt

fn conn(&self) -> &dyn Conn

fn get_max_col_size(&self) -> usize

fn usr_env(&self) -> &dyn UsrEnv