# Rust-oracle
This is an [Oracle database][] driver for [Rust][] based on [ODPI-C][].
## Change Log
See [ChangeLog.md](https://github.com/kubo/rust-oracle/blob/master/ChangeLog.md).
## Build-time Requirements
* Rust 1.19 or later
* C compiler. See `Compile-time Requirements` in [this document](https://github.com/alexcrichton/cc-rs#compile-time-requirements).
## Run-time Requirements
* Oracle client 11.2 or later. See [ODPI-C installation document][].
## Usage
Put this in your `Cargo.toml`:
```text
[dependencies]
oracle = "0.2.0"
```
When you need to fetch or bind [chrono](https://docs.rs/chrono/0.4/chrono/)
data types, enable `chrono` feature:
```text
[dependencies]
oracle = { version = "0.2.0", features = ["chrono"] }
```
Then put this in your crate root:
```rust
extern crate oracle;
```
## Examples
Executes select statements and get rows:
```rust
use oracle::{Connection, Error};
// Connect to a database.
let conn = Connection::connect("scott", "tiger", "//localhost/XE", &[])?;
let sql = "select ename, sal, comm from emp where deptno = :1";
// Select a table with a bind variable.
for row_result in &rows {
let row = row_result?;
// get a column value by position (0-based)
let ename: String = row.get(0)?;
// get a column by name (case-insensitive)
let sal: i32 = row.get("sal")?;
// Use `Option<...>` to get a nullable column.
// Otherwise, `Err(Error::NullValue)` is returned
// for null values.
let comm: Option<i32> = row.get(2)?;
println!(" {:14}| {:>10} | {:>10} |",
ename,
sal,
comm.map_or("".to_string(), |v| v.to_string()));
}
// Another way to fetch rows.
// The rows iterator returns Result<(String, i32, Option<i32>)>.
for row_result in &rows {
let (ename, sal, comm) = row_result?;
println!(" {:14}| {:>10} | {:>10} |",
ename,
sal,
comm.map_or("".to_string(), |v| v.to_string()));
}
```
Executes select statements and get the first rows:
```rust
use oracle::Connection;
// Connect to a database.
let conn = Connection::connect("scott", "tiger", "//localhost/XE", &[])?;
let sql = "select ename, sal, comm from emp where empno = :1";
// Print the first row.
let row = conn.query_row(sql, &[&7369])?;
let ename: String = row.get("empno")?;
let sal: i32 = row.get("sal")?;
let comm: Option<i32> = row.get("comm")?;
ename,
sal,
comm.map_or("".to_string(), |v| v.to_string()));
// When no rows are found, conn.query_row() returns `Err(Error::NoDataFound)`.
// Get the first row as a tupple
let row = conn.query_row_as::<(String, i32, Option<i32>)>(sql, &[&7566])?;
row.0,
row.1,
row.2.map_or("".to_string(), |v| v.to_string()));
```
Executes non-select statements:
```rust
use oracle::Connection;
// Connect to a database.
let conn = Connection::connect("scott", "tiger", "//localhost/XE", &[])?;
conn.execute("create table person (id number(38), name varchar2(40))", &[])?;
// Execute a statement with positional parameters.
conn.execute("insert into person values (:1, :2)",
&[&1, // first parameter
&"John" // second parameter
])?;
// Execute a statement with named parameters.
conn.execute_named("insert into person values (:id, :name)",
&[("id", &2), // 'id' parameter
("name", &"Smith"), // 'name' parameter
])?;
// Commit the transaction.
conn.commit()?;
// Delete rows
conn.execute("delete from person", &[])?;
// Rollback the transaction.
conn.rollback()?;
```
Prints column information:
```rust
use oracle::Connection;
// Connect to a database.
let conn = Connection::connect("scott", "tiger", "//localhost/XE", &[])?;
let sql = "select ename, sal, comm from emp where 1 = 2";
let rows = conn.query(sql, &[])?;
// Print column names
for info in rows.column_info() {
print!(" {:14}|", info.name());
}
println!("");
// Print column types
for info in rows.column_info() {
print!(" {:14}|", info.oracle_type().to_string());
}
println!("");
```
Prepared statement:
```rust
use oracle::Connection;
let conn = Connection::connect("scott", "tiger", "//localhost/XE", &[])?;
// Create a prepared statement
let mut stmt = conn.prepare("insert into person values (:1, :2)", &[])?;
// Insert one row
stmt.execute(&[&1, &"John"])?;
// Insert another row
stmt.execute(&[&2, &"Smith"])?;
```
This is more efficient than two `conn.execute()`.
An SQL statement is executed in the DBMS as follows:
* step 1. Parse the SQL statement and create an execution plan.
* step 2. Execute the plan with bind parameters.
When a prepared statement is used, step 1 is called only once.
## NLS_LANG parameter
[NLS_LANG][] consists of three components: [language][], [territory][] and
charset. However the charset component is ignored and UTF-8(AL32UTF8) is used
as charset because rust characters are UTF-8.
The territory component specifies numeric format, date format and so on.
However it affects only conversion in Oracle. See the following example:
```rust
use oracle::Connection;
// The territory is France.
std::env::set_var("NLS_LANG", "french_france.AL32UTF8");
let conn = Connection::connect("scott", "tiger", "", &[])?;
// 10.1 is converted to a string in Oracle and fetched as a string.
let result = conn.query_row_as::<String>("select to_char(10.1) from dual", &[])?;
assert_eq!(result, "10,1"); // The decimal mark depends on the territory.
// 10.1 is fetched as a number and converted to a string in rust-oracle
let result = conn.query_row_as::<String>("select 10.1 from dual", &[])?;
assert_eq!(result, "10.1"); // The decimal mark is always period(.).
```
Note that NLS_LANG must be set before first rust-oracle function execution if
required.
## TODO
* Connection pooling
* Read and write LOB as stream
* REF CURSOR, BOOLEAN
* Scrollable cursors
* Batch DML
* Better Oracle object type support
## License
Rust-oracle and ODPI-C bundled in rust-oracle are under the terms of:
1. [the Universal Permissive License v 1.0 or at your option, any later version](http://oss.oracle.com/licenses/upl); and/or
2. [the Apache License v 2.0](http://www.apache.org/licenses/LICENSE-2.0).
[Rust]: https://www.rust-lang.org/
[ODPI-C]: https://oracle.github.io/odpi/
[ODPI-C installation document]: https://oracle.github.io/odpi/doc/installation.html
[Oracle database]: https://www.oracle.com/database/index.html
[NLS_LANG]: http://www.oracle.com/technetwork/products/globalization/nls-lang-099431.html
[language]: http://www.oracle.com/technetwork/database/database-technologies/globalization/nls-lang-099431.html#_Toc110410559
[territory]: http://www.oracle.com/technetwork/database/database-technologies/globalization/nls-lang-099431.html#_Toc110410560