use std::net::TcpStream;
use std::thread;
use std::time::Duration;
use encoding_rs::{Encoding, EUC_KR, GB18030, UTF_8};
use crate::crypto::{compute_session_key, new_client_keypair, SymmCipher, DES_CFB, DH_P_HEX};
use crate::frame::{
CMD_BIND, CMD_EXECUTE, CMD_EXEC_COMPLETE, CMD_FETCH, CMD_HANDSHAKE, CMD_LOGIN,
CMD_SESSION_QUERY, Frame, FrameReader,
};
use crate::result::{
decode_out_value, decode_scalar, encode_date, encode_datetime, encode_datetime2,
encode_datetime2_tz, encode_datetime_tz, encode_time, encode_time_tz, parse_cols_robust,
parse_columns, parse_rows, parse_rows_param, Column, DmDate, DmDateTime, DmTime, Row, Value,
NULL_MARK, DM_BLOB, DM_CLOB,
};
use crate::{DmError, Result};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OutType {
Bool,
Int,
Float,
Str,
Date,
DateTime,
}
#[derive(Debug, Clone, PartialEq)]
pub struct OUT {
pub type_hint: Option<OutType>,
}
impl OUT {
pub fn new(type_hint: Option<OutType>) -> Self {
OUT { type_hint }
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum Param {
Null,
Bool(bool),
Int(i64),
Float(f64),
Str(String),
Bytes(Vec<u8>),
Date(DmDate),
Time(DmTime),
DateTime(DmDateTime),
Out(Option<OutType>),
}
impl Param {
pub fn out(t: Option<OutType>) -> Param {
Param::Out(t)
}
pub fn is_out(&self) -> bool {
matches!(self, Param::Out(_))
}
pub fn is_null(&self) -> bool {
matches!(self, Param::Null)
}
}
#[derive(Debug, Clone, Copy)]
pub struct ServerParam {
pub col_type: i32,
pub prec: i32,
pub scale: i32,
pub io_type: i32,
}
#[derive(Debug, Clone, PartialEq)]
pub enum ExecuteResult {
Query {
columns: Vec<Column>,
rows: Vec<Vec<Value>>,
},
Affected(u64),
Call {
affected: u64,
out: Vec<Value>,
},
}
impl ExecuteResult {
pub fn rows(&self) -> Option<&Vec<Vec<Value>>> {
match self {
ExecuteResult::Query { rows, .. } => Some(rows),
_ => None,
}
}
pub fn columns(&self) -> Option<&Vec<Column>> {
match self {
ExecuteResult::Query { columns, .. } => Some(columns),
_ => None,
}
}
pub fn affected(&self) -> Option<u64> {
match self {
ExecuteResult::Affected(n) | ExecuteResult::Call { affected: n, .. } => Some(*n),
_ => None,
}
}
}
#[derive(Debug, Clone)]
pub struct ClientConfig {
pub host: String,
pub port: u16,
pub user: String,
pub password: String,
pub app_name: String,
pub os_name: String,
pub timeout: Duration,
pub auto_reconnect: bool,
pub send_delay: Duration,
pub encoding: Option<String>,
}
impl Default for ClientConfig {
fn default() -> Self {
ClientConfig {
host: "127.0.0.1".into(),
port: 5236,
user: "SYSDBA".into(),
password: String::new(),
app_name: "rust-min".into(),
os_name: "linux".into(),
timeout: Duration::from_secs(15),
auto_reconnect: true,
send_delay: Duration::ZERO,
encoding: None,
}
}
}
fn resolve_encoding(name: Option<&str>) -> Option<&'static Encoding> {
let s = name?;
let s = s.trim();
if s.is_empty() {
return None;
}
if s.eq_ignore_ascii_case("utf8") || s.eq_ignore_ascii_case("utf-8") {
Some(UTF_8)
} else if s.eq_ignore_ascii_case("euckr") || s.eq_ignore_ascii_case("euc-kr") {
Some(EUC_KR)
} else if s.eq_ignore_ascii_case("gb18030")
|| s.eq_ignore_ascii_case("gbk")
|| s.eq_ignore_ascii_case("gb2312")
{
Some(GB18030)
} else {
None
}
}
#[derive(Debug, Clone)]
pub struct LazyState {
pub stmt: i32,
pub ncols: usize,
pub rows_raw: Vec<Row>,
pub more: bool,
pub closed: bool,
}
pub struct DmClient {
cfg: ClientConfig,
reader: Option<FrameReader>,
session_key: Option<Vec<u8>>,
cipher: Option<SymmCipher>,
stmt_id: i32,
svr_encoding: &'static Encoding,
auto_commit: bool,
in_transaction: bool,
lob_chunk_size: usize,
}
impl DmClient {
pub fn new(host: &str, port: u16, user: &str, password: &str) -> Self {
DmClient::with_config(ClientConfig {
host: host.into(),
port,
user: user.into(),
password: password.into(),
..Default::default()
})
}
pub fn from_dsn(dsn: &str) -> Result<Self> {
let dsn = dsn.trim();
let rest = dsn.strip_prefix("dm://").unwrap_or(dsn);
let (auth_host, query) = match rest.split_once('?') {
Some((a, q)) => (a, Some(q)),
None => (rest, None),
};
let (creds, hostport) = auth_host
.rsplit_once('@')
.map(|(c, h)| (Some(c), h))
.unwrap_or((None, auth_host));
let (host, port) = hostport
.rsplit_once(':')
.map(|(h, p)| (h, p.parse::<u16>().unwrap_or(5236)))
.unwrap_or((hostport, 5236));
let (user, password) = creds
.map(|c| match c.split_once(':') {
Some((u, p)) => (u.to_string(), p.to_string()),
None => (c.to_string(), String::new()),
})
.unwrap_or((String::new(), String::new()));
let mut cfg = ClientConfig {
host: host.to_string(),
port,
user,
password,
..Default::default()
};
if let Some(q) = query {
for pair in q.split('&') {
let Some((k, v)) = pair.split_once('=') else { continue };
match k.to_ascii_lowercase().as_str() {
"encoding" => cfg.encoding = Some(v.to_string()),
"timeout" => cfg.timeout = Duration::from_secs(v.parse().unwrap_or(15)),
"auto_reconnect" => cfg.auto_reconnect = v.eq_ignore_ascii_case("true") || v == "1",
"send_delay_ms" => cfg.send_delay = Duration::from_millis(v.parse().unwrap_or(0)),
"app_name" => cfg.app_name = v.to_string(),
"os_name" => cfg.os_name = v.to_string(),
_ => {}
}
}
}
Ok(DmClient::with_config(cfg))
}
pub fn connect_from_dsn(dsn: &str) -> Result<Self> {
let mut c = DmClient::from_dsn(dsn)?;
c.connect()?;
Ok(c)
}
pub fn with_config(cfg: ClientConfig) -> Self {
let enc = resolve_encoding(cfg.encoding.as_deref()).unwrap_or(GB18030);
DmClient {
cfg,
reader: None,
session_key: None,
cipher: None,
stmt_id: -1,
svr_encoding: enc,
auto_commit: true,
in_transaction: false,
lob_chunk_size: 16000,
}
}
pub fn config(&self) -> &ClientConfig {
&self.cfg
}
pub fn is_connected(&self) -> bool {
self.reader.is_some()
}
pub fn auto_commit(&self) -> bool {
self.auto_commit
}
pub fn session_key(&self) -> Option<&[u8]> {
self.session_key.as_deref()
}
pub fn server_encoding_name(&self) -> &'static str {
self.svr_encoding.name()
}
pub fn set_lob_chunk_size(&mut self, size: usize) {
self.lob_chunk_size = size;
}
fn send(&mut self, cmd: i16, opts: &[u8], body: &[u8], stmt: i32) -> Result<()> {
let r = self.reader.as_mut().ok_or_else(|| DmError::conn("连接未建立"))?;
r.send_frame(stmt, cmd, opts, body)?;
if !self.cfg.send_delay.is_zero() {
thread::sleep(self.cfg.send_delay);
}
Ok(())
}
fn read_frame(&mut self) -> Result<Frame> {
let r = self.reader.as_mut().ok_or_else(|| DmError::conn("连接未建立"))?;
r.read_frame()
}
fn recv(&mut self, expect: i16) -> Result<Frame> {
let f = self.read_frame()?;
if f.retcode != 0 {
return Err(self.server_error(&f));
}
if f.cmd != expect {
return Err(DmError::protocol(format!("期望 cmd={expect},实际 cmd={}", f.cmd)));
}
Ok(f)
}
fn server_error(&self, f: &Frame) -> DmError {
let body = &f.body;
let mut msg = self.decode_lossy(body);
let start = msg.find(|c: char| !c.is_control()).unwrap_or(0);
msg = msg[start..].trim().to_string();
DmError::server(f.retcode, msg)
}
fn check_ok(&self, f: &Frame) -> Result<()> {
if f.retcode == 0 || f.retcode == 111 || f.retcode == 100 {
Ok(())
} else {
Err(self.server_error(f))
}
}
pub fn connect(&mut self) -> Result<()> {
let stream = TcpStream::connect((self.cfg.host.as_str(), self.cfg.port))
.map_err(|e| DmError::conn(format!("连接 {}:{} 失败: {e}", self.cfg.host, self.cfg.port)))?;
stream.set_nodelay(true).ok();
stream.set_read_timeout(Some(self.cfg.timeout)).ok();
stream.set_write_timeout(Some(self.cfg.timeout)).ok();
self.reader = Some(FrameReader::new(stream));
self.handshake()?;
self.login()?;
self.stmt_id = -1; self.auto_commit = true;
self.in_transaction = false; Ok(())
}
fn ensure_connection(&mut self) -> Result<()> {
if self.reader.is_none() {
if self.in_transaction {
return Err(DmError::conn(
"连接已断开且事务未提交(自动重连已跳过,避免静默丢失事务)",
));
}
if self.cfg.auto_reconnect {
self.connect()?;
}
}
Ok(())
}
fn handshake(&mut self) -> Result<()> {
let (priv_x, pub_key) = new_client_keypair();
let mut opts = [0u8; 44];
opts[..17].copy_from_slice(&[
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, ]);
let mut body = Vec::with_capacity(81);
body.extend_from_slice(&8i32.to_le_bytes()); body.extend_from_slice(b"8.1.5.60");
body.push(0);
body.extend_from_slice(&64i32.to_le_bytes());
body.extend_from_slice(&pub_key);
self.send(CMD_HANDSHAKE, &opts, &body, 0)?;
let resp = self.recv(228)?;
if self.cfg.encoding.is_none() && resp.opts.len() >= 12 {
let code = i32::from_le_bytes(resp.opts[8..12].try_into().unwrap());
self.svr_encoding = match code {
1 => UTF_8,
2 => EUC_KR,
_ => GB18030,
};
}
let p = parse_bigint_hex(DH_P_HEX);
let b = &resp.body;
let mut server_pub: Option<Vec<u8>> = None;
let mut pos = 0usize;
while pos + 4 <= b.len() {
let ln = i32::from_le_bytes(b[pos..pos + 4].try_into().unwrap());
if ln == 64 && pos + 4 + 64 <= b.len() {
let cand = &b[pos + 4..pos + 4 + 64];
let val = num_bigint::BigUint::from_bytes_be(cand);
if val > num_bigint::BigUint::from(1u32) && val < p {
server_pub = Some(cand.to_vec());
break;
}
}
pos += 1;
}
let server_pub = server_pub.ok_or_else(|| {
DmError::protocol(format!("握手响应中未找到服务器公钥: {}", hex(&b[..b.len().min(32)])))
})?;
let key = compute_session_key(&priv_x, &server_pub);
self.session_key = Some(key.clone());
self.cipher = Some(SymmCipher::new(DES_CFB, key));
Ok(())
}
fn login(&mut self) -> Result<()> {
let mut opts = [0u8; 44];
opts[..23].copy_from_slice(&[
0x05, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, ]);
let cipher = self.cipher.as_ref().ok_or_else(|| DmError::protocol("未握手"))?;
let mut body = Vec::new();
let user_b = self.cfg.user.as_bytes();
body.extend_from_slice(&(user_b.len() as i32).to_le_bytes());
body.extend_from_slice(&cipher.encrypt(user_b, false)?);
let pwd_b = self.cfg.password.as_bytes();
body.extend_from_slice(&(pwd_b.len() as i32).to_le_bytes());
body.extend_from_slice(&cipher.encrypt(pwd_b, false)?);
body.extend_from_slice(&0i32.to_le_bytes()); let osb = self.cfg.os_name.as_bytes();
body.extend_from_slice(&(osb.len() as i32).to_le_bytes());
body.extend_from_slice(osb);
body.extend_from_slice(&0i32.to_le_bytes()); body.push(0); body.extend_from_slice(&0u16.to_le_bytes());
self.send(CMD_LOGIN, &opts, &body, 0)?;
self.recv(163)?;
Ok(())
}
fn session_query(&mut self) -> Result<i32> {
self.send(CMD_SESSION_QUERY, &[1, 0, 0, 0], &[], 0)?;
let f = self.read_frame()?;
if f.retcode != 0 {
return Err(self.server_error(&f));
}
Ok(f.stmt_id)
}
fn execute_opts(&self, has_params: bool) -> [u8; 44] {
let auto = if self.auto_commit { 1 } else { 0 };
let mut opts = [0u8; 44];
opts[0] = auto; opts[1] = if has_params { 0 } else { 1 };
opts[3] = 1;
opts[7..15].copy_from_slice(&i64::MAX.to_le_bytes()); if !has_params {
opts[18] = 1; }
opts
}
pub fn execute(&mut self, sql: &str, params: &[Param]) -> Result<ExecuteResult> {
self.ensure_connection()?;
let stmt = self.session_query()?;
let is_query = is_query_sql(sql);
let opts = self.execute_opts(!params.is_empty());
let mut sql_bytes = self.encode_str(sql);
sql_bytes.push(0);
self.send(CMD_EXECUTE, &opts, &sql_bytes, stmt)?;
let out_indices: Vec<usize> = params
.iter()
.enumerate()
.filter(|(_, p)| p.is_out())
.map(|(i, _)| i)
.collect();
let mut prep_frames: Vec<Frame> = Vec::with_capacity(2);
let mut server_params: Option<Vec<ServerParam>> = None;
if !params.is_empty() {
let f = self.read_frame()?;
if f.retcode != 0 && f.retcode != 111 {
return Err(self.server_error(&f));
}
if !is_query && f.cmd == 0 {
server_params = Some(parse_server_params(&f.body));
}
if params.iter().any(|p| lob_len(p, self.svr_encoding) >= 8188) {
self.write_lob_params(stmt, server_params.as_deref(), params)?;
}
self.bind_params(stmt, params, is_query, None, server_params.as_deref())?;
prep_frames.push(f);
if !is_query {
let f13 = self.read_frame()?;
if f13.retcode != 0 && f13.retcode != 111 && f13.retcode != 100 {
return Err(self.server_error(&f13));
}
prep_frames.push(f13);
self.send(CMD_EXEC_COMPLETE, &[0u8; 44], &[], stmt)?;
}
}
let mut frames: Vec<Frame> = prep_frames;
for _ in 0..4 {
if frames.iter().any(|x| x.cmd == 187) {
break;
}
let f = self.read_frame()?;
if f.retcode != 0 && f.retcode != 111 && f.retcode != 100 {
return Err(self.server_error(&f));
}
let is187 = f.cmd == 187;
frames.push(f);
if is187 {
break;
}
}
let mut result: Option<ExecuteResult> = None;
'outer: for f in &frames {
if f.cmd == 187 && f.length > 30 {
let ncols = le_u16(&f.opts, 2) as usize;
let nrows = le_u16(&f.opts, 4) as usize;
if ncols > 0 && ncols <= 1000 {
let (cols, pos) = parse_columns(&f.body, 0, ncols, self.svr_encoding)?;
let mut rows_raw = parse_rows(&f.body, pos, ncols, nrows)?;
if nrows == 0xFFFF {
let start_pos = rows_raw.len() as i64;
let more = self.fetch_more(stmt, start_pos, ncols)?;
rows_raw.extend(more);
let _ = self.send(CMD_FETCH, &[], &[], stmt).and_then(|_| self.read_frame());
}
let rows = self.decode_rows(&cols, &rows_raw, stmt)?;
result = Some(ExecuteResult::Query { columns: cols, rows });
break 'outer;
}
} else if f.cmd == 0 && f.length > 30 && !params.is_empty() && is_query {
let ncols = le_u16(&f.opts, 4) as usize;
if ncols > 0 && ncols <= 1000 {
let cols = parse_cols_robust(&f.body, params.len(), ncols, self.svr_encoding)?;
for f2 in &frames {
if f2.cmd == 187 {
let ncols2 = le_u16(&f2.opts, 2) as usize;
let nrows2 = le_u16(&f2.opts, 4) as usize;
let mut rows_raw: Vec<Row>;
if ncols2 > 0 && ncols2 <= 1000 {
let (_, pos2) = parse_columns(&f2.body, 0, ncols2, self.svr_encoding)?;
rows_raw = parse_rows_param(&f2.body, pos2, ncols2)?;
} else {
rows_raw = parse_rows_param(&f2.body, 0, ncols)?;
}
if nrows2 == 0xFFFF {
let start_pos = rows_raw.len() as i64;
let more = self.fetch_more(stmt, start_pos, ncols)?;
rows_raw.extend(more);
}
let _ = self.send(CMD_FETCH, &[], &[], stmt).and_then(|_| self.read_frame());
let rows = self.decode_rows(&cols, &rows_raw, stmt)?;
let _ = self.send(CMD_EXEC_COMPLETE, &[0u8; 44], &[], stmt).and_then(|_| self.read_frame());
result = Some(ExecuteResult::Query { columns: cols, rows });
break 'outer;
}
}
}
} else if f.cmd == 187 {
let affected = le_i64(&f.opts, 4) as u64;
if !out_indices.is_empty() && f.length > 4 {
let out = self.parse_out_values(&f.body, &out_indices, server_params.as_deref());
if !params.is_empty() && !is_query {
let _ = self.read_frame(); }
result = Some(ExecuteResult::Call { affected, out });
} else {
if !params.is_empty() && !is_query {
let _ = self.read_frame();
}
result = Some(ExecuteResult::Affected(affected));
}
break 'outer;
}
}
if params.is_empty() {
let _ = self.send(CMD_EXEC_COMPLETE, &[0u8; 44], &[], stmt).and_then(|_| self.read_frame());
}
result.ok_or_else(|| DmError::protocol("执行未产生有效结果帧"))
}
pub fn execute_lazy(&mut self, sql: &str, params: &[Param]) -> Result<(Vec<Column>, LazyState)> {
self.ensure_connection()?;
let stmt = self.session_query()?;
if !is_query_sql(sql) {
return Err(DmError::arg("execute_lazy 仅支持查询"));
}
let opts = self.execute_opts(true);
let mut sql_bytes = self.encode_str(sql);
sql_bytes.push(0);
self.send(CMD_EXECUTE, &opts, &sql_bytes, stmt)?;
let prep_frame = self.read_frame()?;
if prep_frame.retcode != 0 && prep_frame.retcode != 111 {
return Err(self.server_error(&prep_frame));
}
self.bind_params(stmt, params, true, None, None)?;
let ncols = le_u16(&prep_frame.opts, 4) as usize;
let cols = parse_cols_robust(&prep_frame.body, params.len(), ncols, self.svr_encoding)?;
let f = self.read_frame()?;
if f.retcode != 0 && f.retcode != 111 {
return Err(self.server_error(&f));
}
let ncols2 = le_u16(&f.opts, 2) as usize;
let nrows2 = le_u16(&f.opts, 4) as usize;
let rows_raw = if ncols2 > 0 && ncols2 <= 1000 {
let (_, pos2) = parse_columns(&f.body, 0, ncols2, self.svr_encoding)?;
parse_rows_param(&f.body, pos2, ncols2)?
} else {
parse_rows_param(&f.body, 0, ncols)?
};
let more = nrows2 == 0xFFFF;
Ok((
cols,
LazyState { stmt, ncols, rows_raw, more, closed: false },
))
}
pub fn fetch_more(&mut self, stmt: i32, start_pos: i64, ncols: usize) -> Result<Vec<Row>> {
const MAX_FETCH_ITERS: u32 = 1_000_000;
let mut all: Vec<Row> = Vec::new();
let mut start = start_pos;
for _ in 0..MAX_FETCH_ITERS {
let mut opts = [0u8; 44];
opts[..8].copy_from_slice(&start.to_le_bytes());
opts[8..16].copy_from_slice(&i64::MAX.to_le_bytes());
self.send(7, &opts, &[], stmt)?;
let f = self.read_frame()?;
if f.retcode != 0 && f.retcode != 111 && f.retcode != 100 {
return Err(self.server_error(&f));
}
let total = le_i64(&f.opts, 0);
let rows = parse_rows_param(&f.body, 0, ncols)?;
let n = rows.len();
if n == 0 {
break; }
start += n as i64;
all.extend(rows);
if total != i64::MAX && total > 0 && start >= total {
break;
}
}
Ok(all)
}
pub fn close_lazy(&mut self, state: &mut LazyState) -> Result<()> {
if state.closed {
return Ok(());
}
let stmt = state.stmt;
let _ = self.send(CMD_FETCH, &[], &[], stmt).and_then(|_| self.read_frame());
let _ = self.send(CMD_EXEC_COMPLETE, &[0u8; 44], &[], stmt).and_then(|_| self.read_frame());
state.closed = true;
Ok(())
}
pub fn executemany(&mut self, sql: &str, params_list: &[Vec<Param>]) -> Result<u64> {
self.ensure_connection()?;
let stmt = self.session_query()?;
if is_query_sql(sql) {
return Err(DmError::arg("executemany 仅支持 DML"));
}
let opts = self.execute_opts(true);
let mut sql_bytes = self.encode_str(sql);
sql_bytes.push(0);
self.send(CMD_EXECUTE, &opts, &sql_bytes, stmt)?;
let prep = self.read_frame()?;
if prep.retcode != 0 && prep.retcode != 111 {
return Err(self.server_error(&prep));
}
let server_params = if prep.cmd == 0 {
Some(parse_server_params(&prep.body))
} else {
None
};
self.bind_params(stmt, ¶ms_list[0], false, Some(params_list), server_params.as_deref())?;
let f13 = self.read_frame()?;
if f13.retcode != 0 && f13.retcode != 111 && f13.retcode != 100 {
return Err(self.server_error(&f13));
}
self.send(CMD_EXEC_COMPLETE, &[0u8; 44], &[], stmt)?;
let mut affected = 0u64;
if f13.cmd == 187 {
affected = le_u16(&f13.opts, 4) as u64;
let _ = self.read_frame(); } else {
for _ in 0..4 {
let f = self.read_frame()?;
if f.retcode != 0 && f.retcode != 111 && f.retcode != 100 {
return Err(self.server_error(&f));
}
if f.cmd == 187 {
affected = le_u16(&f.opts, 4) as u64;
let _ = self.read_frame(); break;
}
}
}
Ok(affected)
}
pub(crate) fn decode_rows(&mut self, cols: &[Column], rows: &[Row], stmt: i32) -> Result<Vec<Vec<Value>>> {
let mut out = Vec::with_capacity(rows.len());
for r in rows {
let mut v = Vec::with_capacity(r.len());
for (i, cell) in r.iter().enumerate() {
let val = match cell {
None => Value::Null,
Some(raw) => {
let col = if i < cols.len() { &cols[i] } else { continue; };
self.decode_value(raw, col, Some(stmt))?
}
};
v.push(val);
}
out.push(v);
}
Ok(out)
}
fn decode_value(&mut self, raw: &[u8], col: &Column, stmt: Option<i32>) -> Result<Value> {
if col.col_type == DM_CLOB || col.col_type == DM_BLOB {
return self.read_lob(raw, col, stmt);
}
decode_scalar(raw, col, self.svr_encoding)
}
fn read_lob(&mut self, raw: &[u8], col: &Column, stmt: Option<i32>) -> Result<Value> {
if raw.is_empty() {
return Ok(if col.col_type == DM_CLOB {
Value::Str(String::new())
} else {
Value::Bytes(Vec::new())
});
}
let data: Vec<u8> = if raw[0] == 0x01 && raw.len() >= 43 {
let length = u32::from_le_bytes(raw[9..13].try_into().unwrap()) as usize;
raw[43..(43 + length).min(raw.len())].to_vec()
} else {
self.read_offrow_lob(raw, col, stmt)?
};
if col.col_type == DM_CLOB {
let (s, _, _) = self.svr_encoding.decode(&data);
Ok(Value::Str(s.into_owned()))
} else {
Ok(Value::Bytes(data))
}
}
fn read_offrow_lob(&mut self, desc: &[u8], col: &Column, stmt: Option<i32>) -> Result<Vec<u8>> {
if desc.len() < 43 {
return Ok(Vec::new());
}
let blob_id = i64::from_le_bytes(desc[1..9].try_into().unwrap());
let length = u32::from_le_bytes(desc[9..13].try_into().unwrap()) as i64;
let group_id = i16::from_le_bytes(desc[13..15].try_into().unwrap());
let file_id = i16::from_le_bytes(desc[15..17].try_into().unwrap());
let page_no = i32::from_le_bytes(desc[17..21].try_into().unwrap());
let tab_id = i32::from_le_bytes(desc[21..25].try_into().unwrap());
let col_id = i16::from_le_bytes(desc[25..27].try_into().unwrap());
let row_id = i64::from_le_bytes(desc[27..35].try_into().unwrap());
let ex_group = i16::from_le_bytes(desc[35..37].try_into().unwrap());
let ex_file = i16::from_le_bytes(desc[37..39].try_into().unwrap());
let ex_page = i32::from_le_bytes(desc[39..43].try_into().unwrap());
let is_clob = col.col_type == DM_CLOB;
let lob_flag: u8 = if is_clob { 1 } else { 0 };
let mut length = length;
let req_unit: i64 = if is_clob { 16000 } else { 32000 };
if is_clob {
length = self.lob_char_len(
lob_flag, blob_id, group_id, file_id, page_no, tab_id, col_id, row_id,
ex_group, ex_file, ex_page, stmt,
)?;
}
let mut all: Vec<u8> = Vec::new();
let mut offset: i64 = 0;
let mut cur_file = file_id;
let mut cur_page = page_no;
let mut total_offset: i32 = 0;
while offset < length {
let req = req_unit.min(length - offset);
let mut body = Vec::with_capacity(59);
body.push(lob_flag);
body.extend_from_slice(&tab_id.to_le_bytes());
body.extend_from_slice(&col_id.to_le_bytes());
body.extend_from_slice(&blob_id.to_le_bytes());
body.extend_from_slice(&group_id.to_le_bytes());
body.extend_from_slice(&file_id.to_le_bytes());
body.extend_from_slice(&page_no.to_le_bytes());
body.extend_from_slice(&cur_file.to_le_bytes());
body.extend_from_slice(&cur_page.to_le_bytes());
body.extend_from_slice(&total_offset.to_le_bytes());
body.extend_from_slice(&offset.to_le_bytes());
body.extend_from_slice(&req.to_le_bytes());
body.extend_from_slice(&row_id.to_le_bytes());
body.extend_from_slice(&ex_group.to_le_bytes());
body.extend_from_slice(&ex_file.to_le_bytes());
body.extend_from_slice(&ex_page.to_le_bytes());
self.send(32, &[], &body, stmt.unwrap_or(0))?;
let f = self.read_frame()?;
if f.retcode != 0 && f.retcode != 111 {
return Err(self.server_error(&f));
}
if f.body.len() < 15 {
break;
}
let read_over = f.body[0];
let dlen = i32::from_le_bytes(f.body[1..5].try_into().unwrap());
if dlen <= 0 {
break;
}
let dlen = dlen as usize;
let end = (15 + dlen).min(f.body.len());
all.extend_from_slice(&f.body[15..end]);
cur_file = i16::from_le_bytes(f.body[5..7].try_into().unwrap());
cur_page = i32::from_le_bytes(f.body[7..11].try_into().unwrap());
total_offset = i32::from_le_bytes(f.body[11..15].try_into().unwrap());
offset += if is_clob { req } else { dlen as i64 };
if read_over != 0 {
break;
}
}
if is_clob {
Ok(all)
} else {
Ok(all[..(length as usize).min(all.len())].to_vec())
}
}
#[allow(clippy::too_many_arguments)] fn lob_char_len(
&mut self,
lob_flag: u8,
blob_id: i64,
group_id: i16,
file_id: i16,
page_no: i32,
tab_id: i32,
col_id: i16,
row_id: i64,
ex_group: i16,
ex_file: i16,
ex_page: i32,
stmt: Option<i32>,
) -> Result<i64> {
let mut body = Vec::with_capacity(39);
body.push(lob_flag);
body.extend_from_slice(&blob_id.to_le_bytes());
body.extend_from_slice(&group_id.to_le_bytes());
body.extend_from_slice(&file_id.to_le_bytes());
body.extend_from_slice(&page_no.to_le_bytes());
body.extend_from_slice(&tab_id.to_le_bytes());
body.extend_from_slice(&col_id.to_le_bytes());
body.extend_from_slice(&row_id.to_le_bytes());
body.extend_from_slice(&ex_group.to_le_bytes());
body.extend_from_slice(&ex_file.to_le_bytes());
body.extend_from_slice(&ex_page.to_le_bytes());
self.send(29, &[], &body, stmt.unwrap_or(0))?;
let f = self.read_frame()?;
if f.retcode != 0 && f.retcode != 111 {
return Err(self.server_error(&f));
}
if f.body.len() >= 8 {
return Ok(i64::from_le_bytes(f.body[..8].try_into().unwrap()));
}
if f.body.len() >= 4 {
return Ok(i32::from_le_bytes(f.body[..4].try_into().unwrap()) as i64);
}
Ok(0)
}
fn parse_out_values(
&mut self,
body: &[u8],
out_indices: &[usize],
server_params: Option<&[ServerParam]>,
) -> Vec<Value> {
let mut values = Vec::new();
let mut pos = 0usize;
for &idx in out_indices {
if pos + 2 > body.len() {
values.push(Value::Null);
break;
}
let ln = u16::from_le_bytes(body[pos..pos + 2].try_into().unwrap());
pos += 2;
if ln == NULL_MARK {
values.push(Value::Null);
continue;
}
if pos + ln as usize > body.len() {
values.push(Value::Null);
break;
}
let raw = &body[pos..pos + ln as usize];
pos += ln as usize;
let sp = server_params.and_then(|s| s.get(idx));
let ct = sp.map(|x| x.col_type).unwrap_or(2);
values.push(decode_out_value(raw, ct, self.svr_encoding));
}
values
}
fn bind_params(
&mut self,
stmt: i32,
params: &[Param],
is_query: bool,
batch_list: Option<&[Vec<Param>]>,
server_params: Option<&[ServerParam]>,
) -> Result<()> {
let groups: Vec<&[Param]> = match batch_list {
Some(bl) => bl.iter().map(|g| g.as_slice()).collect(),
None => vec![params],
};
let first = groups[0];
let n_params = first.len();
let n_batch = groups.len();
let mut opts = [0u8; 44];
opts[0] = if self.auto_commit { 1 } else { 0 };
opts[1..3].copy_from_slice(&(n_params as u16).to_le_bytes());
opts[3] = 1;
opts[4..12].copy_from_slice(&(n_batch as i64).to_le_bytes());
opts[20..28].copy_from_slice(&i64::MAX.to_le_bytes()); opts[28] = 1;
opts[32..36].copy_from_slice(&(-1i32).to_le_bytes());
let mut desc = Vec::with_capacity(n_params * 13);
let mut encoders: Vec<Option<ParamEncoder>> = Vec::with_capacity(n_params);
for (i, p) in first.iter().enumerate() {
if let Param::Out(hint) = p {
let sp = server_params.and_then(|s| s.get(i));
let ct = sp.map(|x| x.col_type).unwrap_or_else(|| out_type_hint(*hint));
let prec = sp.map(|x| x.prec).unwrap_or_else(|| out_type_prec(*hint));
let scale = sp.map(|x| x.scale).unwrap_or(0);
desc.extend_from_slice(&1i8.to_le_bytes());
desc.extend_from_slice(&ct.to_le_bytes());
desc.extend_from_slice(&prec.to_le_bytes());
desc.extend_from_slice(&scale.to_le_bytes());
encoders.push(None);
continue;
}
let is_lob = lob_len(p, self.svr_encoding) >= 8188;
if is_lob {
let ct: i32 = if matches!(p, Param::Str(_)) { 19 } else { 12 };
desc.extend_from_slice(&0i8.to_le_bytes());
desc.extend_from_slice(&ct.to_le_bytes());
desc.extend_from_slice(&0x7FFF_FFFFi32.to_le_bytes());
desc.extend_from_slice(&0i32.to_le_bytes());
encoders.push(Some(ParamEncoder::from_type(ct)));
} else if let Some(sp) = server_params.and_then(|s| s.get(i)) {
desc.extend_from_slice(&0i8.to_le_bytes());
desc.extend_from_slice(&sp.col_type.to_le_bytes());
desc.extend_from_slice(&sp.prec.to_le_bytes());
desc.extend_from_slice(&sp.scale.to_le_bytes());
encoders.push(Some(ParamEncoder::from_type(sp.col_type)));
} else {
let (ct, prec, scale, enc) = param_type(p, is_query, self.svr_encoding);
desc.extend_from_slice(&0i8.to_le_bytes());
desc.extend_from_slice(&ct.to_le_bytes());
desc.extend_from_slice(&prec.to_le_bytes());
desc.extend_from_slice(&scale.to_le_bytes());
encoders.push(Some(enc));
}
}
let mut data = Vec::new();
for group in &groups {
for (i, p) in group.iter().enumerate() {
if p.is_out() {
continue; }
if p.is_null() {
data.extend_from_slice(&NULL_MARK.to_le_bytes());
} else {
let enc = encoders
.get(i)
.and_then(|e| e.clone())
.unwrap_or_else(|| param_type(p, is_query, self.svr_encoding).3);
let raw = enc.encode(p, self.svr_encoding)?;
if lob_len(p, self.svr_encoding) >= 8188 {
data.extend_from_slice(&0u16.to_le_bytes()); } else {
data.extend_from_slice(&(raw.len() as u16).to_le_bytes());
data.extend_from_slice(&raw);
}
}
}
}
let mut body = desc;
body.extend_from_slice(&data);
self.send(CMD_BIND, &opts, &body, stmt)?;
Ok(())
}
fn write_lob_params(
&mut self,
stmt: i32,
server_params: Option<&[ServerParam]>,
params: &[Param],
) -> Result<()> {
let mut desc = Vec::new();
for (i, p) in params.iter().enumerate() {
let raw_len = lob_len(p, self.svr_encoding);
if raw_len >= 8188 {
let ct: i32 = if matches!(p, Param::Str(_)) { 19 } else { 12 };
desc.extend_from_slice(&0i8.to_le_bytes());
desc.extend_from_slice(&ct.to_le_bytes());
desc.extend_from_slice(&0x7FFF_FFFFi32.to_le_bytes());
desc.extend_from_slice(&0i32.to_le_bytes());
} else {
let sp = server_params.and_then(|s| s.get(i));
let ct = sp.map(|x| x.col_type).unwrap_or(2);
let prec = sp.map(|x| x.prec).unwrap_or(0);
let scale = sp.map(|x| x.scale).unwrap_or(0);
desc.extend_from_slice(&0i8.to_le_bytes());
desc.extend_from_slice(&ct.to_le_bytes());
desc.extend_from_slice(&prec.to_le_bytes());
desc.extend_from_slice(&scale.to_le_bytes());
}
}
let mut opts90 = [0u8; 44];
opts90[..2].copy_from_slice(&(params.len() as u16).to_le_bytes());
self.send(90, &opts90, &desc, stmt)?;
let f = self.read_frame()?;
if f.retcode != 0 && f.retcode != 111 && f.retcode != 100 {
return Err(self.server_error(&f));
}
for (i, p) in params.iter().enumerate() {
if lob_len(p, self.svr_encoding) < 8188 {
continue;
}
let data: Vec<u8> = match p {
Param::Str(s) => self.encode_str(s),
Param::Bytes(b) => b.clone(),
_ => Vec::new(),
};
let mut opts14 = [0u8; 44];
opts14[0] = i as u8; let mut off = 0;
while off < data.len() {
let mut end = (off + self.lob_chunk_size).min(data.len());
if self.svr_encoding == GB18030 || self.svr_encoding == EUC_KR {
while end < data.len() && end > off
&& (0x81..=0xFE).contains(&data[end - 1])
&& (0x40..=0xFE).contains(&data[end])
&& data[end] != 0x7F
{
end -= 1;
}
} else {
while end < data.len() && end > off && (0x80..=0xBF).contains(&data[end]) {
end -= 1;
}
}
let chunk = &data[off..end];
let mut body = Vec::with_capacity(8 + chunk.len());
body.extend_from_slice(&(chunk.len() as i32).to_le_bytes());
body.extend_from_slice(&(-1i32).to_le_bytes());
body.extend_from_slice(chunk);
self.send(14, &opts14, &body, stmt)?;
let f = self.read_frame()?;
if f.retcode != 0 && f.retcode != 111 && f.retcode != 100 {
return Err(self.server_error(&f));
}
off = end;
}
}
Ok(())
}
pub fn begin(&mut self) -> Result<()> {
self.send(52, &1i32.to_le_bytes(), &[], 0)?;
let f = self.read_frame()?;
self.check_ok(&f)?;
self.auto_commit = false;
self.in_transaction = true;
Ok(())
}
pub fn commit(&mut self) -> Result<()> {
self.send(8, &[], &[], 0)?;
let f = self.read_frame()?;
self.check_ok(&f)?;
self.auto_commit = true;
self.in_transaction = false;
Ok(())
}
pub fn rollback(&mut self) -> Result<()> {
self.send(9, &[], &[], 0)?;
let f = self.read_frame()?;
self.check_ok(&f)?;
self.auto_commit = true;
self.in_transaction = false;
Ok(())
}
pub fn set_iso_level(&mut self, level: i32) -> Result<()> {
self.send(52, &level.to_le_bytes(), &[], 0)?;
let f = self.read_frame()?;
self.check_ok(&f)?;
Ok(())
}
pub fn close(&mut self) {
self.reader = None;
}
fn encode_str(&self, s: &str) -> Vec<u8> {
enc_str(self.svr_encoding, s)
}
fn decode_lossy(&self, b: &[u8]) -> String {
let (s, _, _) = self.svr_encoding.decode(b);
s.into_owned()
}
}
pub(crate) fn is_query_sql(sql: &str) -> bool {
let s = sql.trim_start();
let up = s.to_ascii_uppercase();
up.starts_with("SELECT")
|| up.starts_with("WITH")
|| up.starts_with("DESC")
|| up.starts_with("SHOW")
}
pub(crate) fn enc_str(enc: &'static Encoding, s: &str) -> Vec<u8> {
enc.encode(s).0.into_owned()
}
pub(crate) fn lob_len(p: &Param, enc: &'static Encoding) -> usize {
match p {
Param::Str(s) => enc_str(enc, s).len(),
Param::Bytes(b) => b.len(),
_ => 0,
}
}
fn param_type(p: &Param, is_query: bool, enc: &'static Encoding) -> (i32, i32, i32, ParamEncoder) {
match p {
Param::Bool(_) => (7, 4, 0, ParamEncoder::Int),
Param::Int(_) => {
if is_query {
(8, 8, 0, ParamEncoder::BigInt)
} else {
(7, 4, 0, ParamEncoder::Int)
}
}
Param::Float(_) => (11, 8, 0, ParamEncoder::Double),
Param::Date(_) => (14, 3, 0, ParamEncoder::Date),
Param::DateTime(dt) => {
if dt.time.timezone_minutes.is_some() {
(23, 8, 0, ParamEncoder::DateTimeTz)
} else {
(16, 8, 0, ParamEncoder::DateTime)
}
}
Param::Time(t) => {
if t.timezone_minutes.is_some() {
(22, 5, 0, ParamEncoder::TimeTz)
} else {
(15, 5, 0, ParamEncoder::Time)
}
}
Param::Bytes(b) => (17, b.len() as i32, 0, ParamEncoder::Bytes),
Param::Str(s) => {
let len = enc_str(enc, s).len();
let prec = if is_query { 8188 } else { 50.max(len as i32) };
(2, prec, 0, ParamEncoder::Str)
}
Param::Null => {
(2, 8188, 0, ParamEncoder::Str)
}
Param::Out(_) => (2, 0, 0, ParamEncoder::Str),
}
}
fn out_type_hint(hint: Option<OutType>) -> i32 {
match hint {
Some(OutType::Bool) => 13,
Some(OutType::Int) => 8,
Some(OutType::Float) => 11,
Some(OutType::Str) => 2,
Some(OutType::Date) => 14,
Some(OutType::DateTime) => 16,
None => 2,
}
}
fn out_type_prec(hint: Option<OutType>) -> i32 {
match hint {
Some(OutType::Int) => 8,
Some(OutType::Str) => 32767,
Some(OutType::DateTime) => 8,
Some(OutType::Date) => 3,
_ => 8,
}
}
pub fn parse_server_params(body: &[u8]) -> Vec<ServerParam> {
let mut params = Vec::new();
let n = body.len();
let mut pos = 0usize;
while pos + 31 <= n {
let col_type = le_i32(body, pos);
let prec = le_i32(body, pos + 4);
let scale = le_i32(body, pos + 8);
pos += 16;
if pos + 2 > n {
break;
}
pos += 2; pos += 4; if pos + 2 > n {
break;
}
let io_type = body[pos] as i32;
pos += 2; if pos + 8 > n {
break;
}
let nlen = i16::from_le_bytes(body[pos..pos + 2].try_into().unwrap());
let tlen = i16::from_le_bytes(body[pos + 2..pos + 4].try_into().unwrap());
let tblen = i16::from_le_bytes(body[pos + 4..pos + 6].try_into().unwrap());
let slen = i16::from_le_bytes(body[pos + 6..pos + 8].try_into().unwrap());
pos += 8;
let total = (nlen + tlen + tblen + slen) as i64;
if pos + total as usize > n {
break;
}
pos += total as usize;
params.push(ServerParam { col_type, prec, scale, io_type });
if !(0..=40).contains(&col_type) {
break;
}
}
params
}
#[derive(Debug, Clone, PartialEq)]
enum ParamEncoder {
Str,
TinyInt,
SmallInt,
Int,
BigInt,
Real,
Double,
Bool,
Date,
Time,
TimeTz,
DateTime,
DateTimeTz,
DateTime2,
DateTime2Tz,
Bytes,
}
impl ParamEncoder {
fn from_type(col_type: i32) -> Self {
match col_type {
0 | 1 | 2 | 19 => ParamEncoder::Str, 5 => ParamEncoder::TinyInt,
6 => ParamEncoder::SmallInt,
7 => ParamEncoder::Int,
8 => ParamEncoder::BigInt,
10 => ParamEncoder::Real,
11 => ParamEncoder::Double,
13 => ParamEncoder::Bool,
14 => ParamEncoder::Date,
15 => ParamEncoder::Time,
22 => ParamEncoder::TimeTz, 16 => ParamEncoder::DateTime,
23 => ParamEncoder::DateTimeTz, 26 => ParamEncoder::DateTime2, 27 => ParamEncoder::DateTime2Tz, 12 | 17 | 18 => ParamEncoder::Bytes, _ => ParamEncoder::Str,
}
}
fn encode(&self, p: &Param, enc: &'static Encoding) -> Result<Vec<u8>> {
match self {
ParamEncoder::Str => match p {
Param::Str(s) => Ok(enc_str(enc, s)),
Param::Bytes(b) => Ok(b.clone()),
_ => Ok(enc_str(enc, &to_string_value(p))),
},
ParamEncoder::TinyInt => Ok((to_i64(p)? as i8).to_le_bytes().to_vec()),
ParamEncoder::SmallInt => Ok((to_i64(p)? as i16).to_le_bytes().to_vec()),
ParamEncoder::Int => Ok((to_i64(p)? as i32).to_le_bytes().to_vec()),
ParamEncoder::BigInt => Ok(to_i64(p)?.to_le_bytes().to_vec()),
ParamEncoder::Real => Ok((to_f64(p)? as f32).to_le_bytes().to_vec()),
ParamEncoder::Double => Ok(to_f64(p)?.to_le_bytes().to_vec()),
ParamEncoder::Bool => Ok(vec![if to_bool(p) { 1 } else { 0 }]),
ParamEncoder::Date => Ok(encode_date(&to_date(p)?).to_vec()),
ParamEncoder::Time => Ok(encode_time(&to_time(p)?).to_vec()),
ParamEncoder::TimeTz => Ok(encode_time_tz(&to_time(p)?)),
ParamEncoder::DateTime => Ok(encode_datetime(&to_datetime(p)?)),
ParamEncoder::DateTimeTz => Ok(encode_datetime_tz(&to_datetime(p)?)),
ParamEncoder::DateTime2 => Ok(encode_datetime2(&to_datetime(p)?)),
ParamEncoder::DateTime2Tz => Ok(encode_datetime2_tz(&to_datetime(p)?)),
ParamEncoder::Bytes => match p {
Param::Bytes(b) => Ok(b.clone()),
_ => Ok(to_string_value(p).into_bytes()),
},
}
}
}
fn to_i64(p: &Param) -> Result<i64> {
match p {
Param::Int(v) => Ok(*v),
Param::Bool(b) => Ok(*b as i64),
Param::Float(f) => Ok(*f as i64),
Param::Str(s) => s.trim().parse::<i64>().map_err(|_| DmError::arg(format!("无法将 '{s}' 转为整数"))),
Param::Null => Ok(0),
_ => Err(DmError::arg(format!("无法将 {p:?} 转为整数"))),
}
}
fn to_f64(p: &Param) -> Result<f64> {
match p {
Param::Float(f) => Ok(*f),
Param::Int(v) => Ok(*v as f64),
Param::Bool(b) => Ok((*b as i64) as f64),
Param::Str(s) => s.trim().parse::<f64>().map_err(|_| DmError::arg(format!("无法将 '{s}' 转为浮点"))),
_ => Err(DmError::arg(format!("无法将 {p:?} 转为浮点"))),
}
}
fn to_bool(p: &Param) -> bool {
match p {
Param::Bool(b) => *b,
Param::Int(v) => *v != 0,
Param::Float(f) => *f != 0.0,
Param::Str(s) => !s.is_empty() && s != "0" && !s.eq_ignore_ascii_case("false"),
_ => false,
}
}
fn to_date(p: &Param) -> Result<DmDate> {
match p {
Param::Date(d) => Ok(*d),
Param::DateTime(dt) => Ok(dt.date),
Param::Str(s) => parse_date_str(s),
_ => Err(DmError::arg(format!("无法将 {p:?} 转为日期"))),
}
}
fn to_time(p: &Param) -> Result<DmTime> {
match p {
Param::Time(t) => Ok(*t),
Param::DateTime(dt) => Ok(dt.time),
Param::Str(s) => parse_time_str(s),
_ => Err(DmError::arg(format!("无法将 {p:?} 转为时间"))),
}
}
fn to_datetime(p: &Param) -> Result<DmDateTime> {
match p {
Param::DateTime(dt) => Ok(*dt),
Param::Date(d) => Ok(DmDateTime::new(*d, DmTime::new(0, 0, 0, 0))),
Param::Str(s) => {
let d = parse_date_str(&s[..s.len().min(10)])?;
let t = if s.len() > 10 {
parse_time_str(&s[11..])?
} else {
DmTime::new(0, 0, 0, 0)
};
Ok(DmDateTime::new(d, t))
}
_ => Err(DmError::arg(format!("无法将 {p:?} 转为日期时间"))),
}
}
fn to_string_value(p: &Param) -> String {
match p {
Param::Str(s) => s.clone(),
Param::Int(v) => v.to_string(),
Param::Float(f) => f.to_string(),
Param::Bool(b) => b.to_string(),
Param::Date(d) => d.to_string(),
Param::Time(t) => t.to_string(),
Param::DateTime(dt) => dt.to_string(),
Param::Bytes(b) => String::from_utf8_lossy(b).into_owned(),
Param::Null => "".to_string(),
Param::Out(_) => "".to_string(),
}
}
fn parse_date_str(s: &str) -> Result<DmDate> {
let parts: Vec<&str> = s.trim().split('-').collect();
if parts.len() != 3 {
return Err(DmError::arg(format!("日期格式错误: '{s}'")));
}
let year: i32 = parts[0].parse().map_err(|_| DmError::arg(format!("日期格式错误: '{s}'")))?;
let month: u8 = parts[1].parse().map_err(|_| DmError::arg(format!("日期格式错误: '{s}'")))?;
let day: u8 = parts[2].parse().map_err(|_| DmError::arg(format!("日期格式错误: '{s}'")))?;
Ok(DmDate::new(year, month, day))
}
fn parse_time_str(s: &str) -> Result<DmTime> {
let s = s.trim();
let (hms, frac) = match s.split_once('.') {
Some((h, f)) => (h, Some(f)),
None => (s, None),
};
let parts: Vec<&str> = hms.split(':').collect();
if parts.len() < 2 {
return Err(DmError::arg(format!("时间格式错误: '{s}'")));
}
let hour: u8 = parts[0].parse().map_err(|_| DmError::arg(format!("时间格式错误: '{s}'")))?;
let minute: u8 = parts[1].parse().map_err(|_| DmError::arg(format!("时间格式错误: '{s}'")))?;
let second: u8 = if parts.len() > 2 { parts[2].parse().map_err(|_| DmError::arg(format!("时间格式错误: '{s}'")))? } else { 0 };
let microsecond: u32 = match frac {
Some(f) => {
let mut f = f.to_string();
while f.len() < 6 {
f.push('0');
}
f[..6].parse().unwrap_or(0)
}
None => 0,
};
Ok(DmTime::new(hour, minute, second, microsecond))
}
fn le_i32(b: &[u8], pos: usize) -> i32 {
i32::from_le_bytes(b[pos..pos + 4].try_into().unwrap())
}
fn le_u16(b: &[u8], pos: usize) -> u16 {
u16::from_le_bytes(b[pos..pos + 2].try_into().unwrap())
}
fn le_i64(b: &[u8], pos: usize) -> i64 {
i64::from_le_bytes(b[pos..pos + 8].try_into().unwrap())
}
fn parse_bigint_hex(hex: &str) -> num_bigint::BigUint {
num_bigint::BigUint::parse_bytes(hex.as_bytes(), 16).expect("hex 解析失败")
}
fn hex(b: &[u8]) -> String {
b.iter().map(|x| format!("{x:02x}")).collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn is_query_detection() {
assert!(is_query_sql(" SELECT * FROM t"));
assert!(is_query_sql("WITH x AS (...) SELECT 1"));
assert!(is_query_sql("DESC t"));
assert!(is_query_sql("SHOW TABLES"));
assert!(!is_query_sql("INSERT INTO t VALUES (1)"));
assert!(!is_query_sql("CALL proc(1)"));
assert!(!is_query_sql("UPDATE t SET a=1"));
}
#[test]
fn param_type_guess() {
let (ct, prec, scale, enc) = param_type(&Param::Int(1), true, GB18030);
assert_eq!((ct, prec, scale), (8, 8, 0));
assert_eq!(enc.encode(&Param::Int(1), GB18030).unwrap(), 1i64.to_le_bytes());
let (ct, prec, scale, _) = param_type(&Param::Int(1), false, GB18030);
assert_eq!((ct, prec, scale), (7, 4, 0));
let (ct, prec, _, _) = param_type(&Param::Str("测试".into()), false, GB18030);
assert_eq!(ct, 2);
assert_eq!(prec, 50);
let (ct, prec, _, _) = param_type(&Param::Str("测试".into()), false, UTF_8);
assert_eq!(ct, 2);
assert_eq!(prec, 50);
let s = "中".repeat(30); let (_ct, prec, _, _) = param_type(&Param::Str(s.clone()), false, UTF_8);
assert_eq!(prec, 90);
let (_ct, prec, _, _) = param_type(&Param::Str(s.clone()), false, GB18030);
assert_eq!(prec, 60);
let (_ct, prec, _, _) = param_type(&Param::Str("x".repeat(100).as_str().into()), false, GB18030);
assert_eq!(prec, 100);
let (ct, prec, _, _) = param_type(&Param::Str("x".into()), true, GB18030);
assert_eq!(ct, 2);
assert_eq!(prec, 8188);
let mut tt = DmTime::new(12, 34, 56, 0);
tt.timezone_minutes = Some(480);
let (ct, prec, scale, enc) = param_type(&Param::Time(tt), false, GB18030);
assert_eq!((ct, prec, scale), (22, 5, 0));
assert_eq!(enc.encode(&Param::Time(tt), GB18030).unwrap(), encode_time_tz(&tt));
let mut dtz = DmDateTime::new(DmDate::new(2026, 8, 14), DmTime::new(12, 34, 56, 0));
dtz.time.timezone_minutes = Some(480);
let (ct, prec, scale, enc) = param_type(&Param::DateTime(dtz), false, GB18030);
assert_eq!((ct, prec, scale), (23, 8, 0));
assert_eq!(enc.encode(&Param::DateTime(dtz), GB18030).unwrap(), encode_datetime_tz(&dtz));
let (ct, _, _, _) = param_type(&Param::Time(DmTime::new(1, 2, 3, 0)), false, GB18030);
assert_eq!(ct, 15);
let (ct, _, _, _) = param_type(&Param::DateTime(DmDateTime::new(DmDate::new(2026, 1, 1), DmTime::new(0, 0, 0, 0))), false, GB18030);
assert_eq!(ct, 16);
let (ct, _, _, _) = param_type(&Param::Date(DmDate::new(2026, 8, 12)), false, GB18030);
assert_eq!(ct, 14);
let (ct, _, _, _) = param_type(&Param::Float(1.5), false, GB18030);
assert_eq!(ct, 11);
let (ct, _, _, _) = param_type(&Param::Bytes(vec![1, 2]), false, GB18030);
assert_eq!(ct, 17);
let (ct, _, _, _) = param_type(&Param::Bool(true), false, GB18030);
assert_eq!(ct, 7);
let (ct, _, _, _) = param_type(&Param::Null, false, GB18030);
assert_eq!(ct, 2);
}
#[test]
fn encoding_resolve_and_length() {
assert_eq!(resolve_encoding(None), None);
assert_eq!(resolve_encoding(Some("")), None);
assert_eq!(resolve_encoding(Some("utf-8")), Some(UTF_8));
assert_eq!(resolve_encoding(Some("UTF8")), Some(UTF_8));
assert_eq!(resolve_encoding(Some("gb18030")), Some(GB18030));
assert_eq!(resolve_encoding(Some("GBK")), Some(GB18030));
assert_eq!(resolve_encoding(Some("euc-kr")), Some(EUC_KR));
assert_eq!(resolve_encoding(Some("latin1")), None);
let s = "中文测试";
assert_eq!(enc_str(UTF_8, s).len(), 12);
assert_eq!(enc_str(GB18030, s).len(), 8);
assert_eq!(lob_len(&Param::Str(s.into()), UTF_8), 12);
assert_eq!(lob_len(&Param::Str(s.into()), GB18030), 8);
fn detect(opts: &[u8]) -> &'static Encoding {
let code = i32::from_le_bytes(opts[8..12].try_into().unwrap());
match code {
1 => UTF_8,
2 => EUC_KR,
_ => GB18030,
}
}
let mut opts = [0u8; 44];
assert_eq!(detect(&opts), GB18030); opts[8..12].copy_from_slice(&1i32.to_le_bytes());
assert_eq!(detect(&opts), UTF_8);
opts[8..12].copy_from_slice(&2i32.to_le_bytes());
assert_eq!(detect(&opts), EUC_KR);
}
#[test]
fn utf8_char_boundary_align() {
let s = "一二三四五六七八九十"; let data = enc_str(UTF_8, s);
let mut end = 7usize.min(data.len()); while end < data.len() && end > 0 && (0x80..=0xBF).contains(&data[end]) {
end -= 1;
}
assert_eq!(end, 6);
assert_eq!(&data[..end], "一二".as_bytes());
}
#[test]
fn server_params_parse() {
let body = hex2b(
"0700000004000000000000000100000000000000000000000000030000000000494e5413000000ffffff7f000000000100000000000000000000000000040000000000434c4f4200",
);
let params = parse_server_params(&body);
assert_eq!(params.len(), 2);
assert_eq!(params[0].col_type, 7);
assert_eq!(params[0].prec, 4);
assert_eq!(params[0].scale, 0);
assert_eq!(params[1].col_type, 19); assert_eq!(params[1].prec, 0x7FFF_FFFF);
}
fn hex2b(s: &str) -> Vec<u8> {
(0..s.len())
.step_by(2)
.map(|i| u8::from_str_radix(&s[i..i + 2], 16).unwrap())
.collect()
}
#[test]
fn execute_opts_match_capture() {
let c = DmClient::new("h", 1, "u", "p");
let o = c.execute_opts(false);
assert_eq!(
&o[..19],
&[
0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0x7f, 0x00, 0x00, 0x00, 0x01
]
);
let o = c.execute_opts(true);
assert_eq!(
&o[..19],
&[
0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0x7f, 0x00, 0x00, 0x00, 0x00
]
);
}
#[test]
fn bind_opts_match_capture() {
let mut c = DmClient::new("h", 1, "u", "p");
c.auto_commit = true;
let params = [Param::Int(1)];
let mut opts = [0u8; 44];
opts[0] = 1;
opts[1..3].copy_from_slice(&1u16.to_le_bytes());
opts[3] = 1;
opts[4..12].copy_from_slice(&1i64.to_le_bytes());
opts[20..28].copy_from_slice(&i64::MAX.to_le_bytes());
opts[28] = 1;
opts[32..36].copy_from_slice(&(-1i32).to_le_bytes());
assert_eq!(&opts[0..12], &[0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
assert_eq!(&opts[20..36], &[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]);
let _ = ¶ms;
}
#[test]
fn date_str_parse() {
let d = parse_date_str("2026-08-12").unwrap();
assert_eq!(d, DmDate::new(2026, 8, 12));
let t = parse_time_str("12:34:56.789").unwrap();
assert_eq!(t, DmTime::new(12, 34, 56, 789000));
let dt = to_datetime(&Param::Str("2030-06-15 08:09:10.111222".into())).unwrap();
assert_eq!(dt, DmDateTime::new(DmDate::new(2030, 6, 15), DmTime::new(8, 9, 10, 111222)));
}
}