1use encoding_rs::Encoding;
4
5use crate::Result;
6
7pub const DM_CHAR: i32 = 0;
9pub const DM_VARCHAR2: i32 = 1;
10pub const DM_VARCHAR: i32 = 2;
11pub const DM_BIT: i32 = 3;
12pub const DM_TINYINT: i32 = 5;
13pub const DM_SMALLINT: i32 = 6;
14pub const DM_INT: i32 = 7;
15pub const DM_BIGINT: i32 = 8;
16pub const DM_DECIMAL: i32 = 9;
17pub const DM_REAL: i32 = 10;
18pub const DM_DOUBLE: i32 = 11;
19pub const DM_BLOB: i32 = 12;
20pub const DM_BOOLEAN: i32 = 13;
21pub const DM_DATE: i32 = 14;
22pub const DM_TIME: i32 = 15;
23pub const DM_DATETIME: i32 = 16;
24pub const DM_BINARY: i32 = 17;
25pub const DM_VARBINARY: i32 = 18;
26pub const DM_CLOB: i32 = 19;
27pub const DM_INTERVAL_YM: i32 = 20;
28pub const DM_INTERVAL_DT: i32 = 21;
29pub const DM_TIME_TZ: i32 = 22;
30pub const DM_DATETIME_TZ: i32 = 23;
31pub const DM_XDEC_INT32: i32 = 24;
32pub const DM_XDEC_INT64: i32 = 25;
33pub const DM_DATETIME2: i32 = 26;
34pub const DM_DATETIME2_TZ: i32 = 27;
35pub const NULL_MARK: u16 = 0xFFFE;
40pub const LOB_MARK: u16 = 0xFFFF;
42
43#[derive(Debug, Clone, Copy, PartialEq, Eq)]
45pub struct DmDate {
46 pub year: i32,
47 pub month: u8,
48 pub day: u8,
49}
50
51impl DmDate {
52 pub fn new(year: i32, month: u8, day: u8) -> Self {
53 DmDate { year, month, day }
54 }
55}
56
57impl std::fmt::Display for DmDate {
58 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
59 write!(f, "{:04}-{:02}-{:02}", self.year, self.month, self.day)
60 }
61}
62
63#[derive(Debug, Clone, Copy, PartialEq, Eq)]
65pub struct DmTime {
66 pub hour: u8,
67 pub minute: u8,
68 pub second: u8,
69 pub microsecond: u32,
70 pub timezone_minutes: Option<i16>,
72}
73
74impl DmTime {
75 pub fn new(hour: u8, minute: u8, second: u8, microsecond: u32) -> Self {
76 DmTime { hour, minute, second, microsecond, timezone_minutes: None }
77 }
78}
79
80fn fmt_tz(tz: i16) -> String {
81 let sign = if tz < 0 { "-" } else { "+" };
82 let a = tz.unsigned_abs() as i32;
83 format!("{sign}{:02}:{:02}", a / 60, a % 60)
84}
85
86impl std::fmt::Display for DmTime {
87 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
88 write!(
89 f,
90 "{:02}:{:02}:{:02}.{:06}",
91 self.hour, self.minute, self.second, self.microsecond
92 )?;
93 if let Some(tz) = self.timezone_minutes {
94 write!(f, " {}", fmt_tz(tz))?;
95 }
96 Ok(())
97 }
98}
99
100#[derive(Debug, Clone, Copy, PartialEq, Eq)]
102pub struct DmDateTime {
103 pub date: DmDate,
104 pub time: DmTime,
105}
106
107impl DmDateTime {
108 pub fn new(date: DmDate, time: DmTime) -> Self {
109 DmDateTime { date, time }
110 }
111}
112
113impl std::fmt::Display for DmDateTime {
114 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
115 write!(f, "{} {}", self.date, self.time)
116 }
117}
118
119#[derive(Debug, Clone, PartialEq)]
121pub enum Value {
122 Null,
123 Bool(bool),
124 TinyInt(i8),
125 SmallInt(i16),
126 Int(i32),
127 BigInt(i64),
128 Real(f32),
129 Double(f64),
130 Decimal(String),
132 Str(String),
133 Bytes(Vec<u8>),
134 Date(DmDate),
135 Time(DmTime),
136 DateTime(DmDateTime),
137 Interval(String),
138 Raw(Vec<u8>),
140}
141
142impl Value {
143 pub fn as_str(&self) -> Option<&str> {
144 match self {
145 Value::Str(s) => Some(s),
146 _ => None,
147 }
148 }
149 pub fn as_i64(&self) -> Option<i64> {
150 match self {
151 Value::Int(v) => Some(*v as i64),
152 Value::BigInt(v) => Some(*v),
153 Value::SmallInt(v) => Some(*v as i64),
154 Value::TinyInt(v) => Some(*v as i64),
155 Value::Bool(b) => Some(*b as i64),
156 Value::Double(f) => Some(*f as i64),
157 Value::Real(f) => Some(*f as i64),
158 _ => None,
159 }
160 }
161 pub fn as_f64(&self) -> Option<f64> {
162 match self {
163 Value::Double(f) => Some(*f),
164 Value::Real(f) => Some(*f as f64),
165 Value::Int(v) => Some(*v as f64),
166 Value::BigInt(v) => Some(*v as f64),
167 _ => None,
168 }
169 }
170 pub fn as_bytes(&self) -> Option<&[u8]> {
171 match self {
172 Value::Bytes(b) => Some(b),
173 Value::Raw(b) => Some(b),
174 _ => None,
175 }
176 }
177}
178
179#[derive(Debug, Clone, PartialEq)]
181pub struct Column {
182 pub col_type: i32,
183 pub prec: i32,
184 pub scale: i32,
185 pub nullable: bool,
186 pub name: String,
187 pub type_name: String,
188 pub table_name: String,
189 pub schema_name: String,
190 pub lob: bool,
191}
192
193pub type Row = Vec<Option<Vec<u8>>>;
195
196fn le_i32(b: &[u8], pos: usize) -> i32 {
197 i32::from_le_bytes(b[pos..pos + 4].try_into().unwrap())
198}
199
200fn le_u16(b: &[u8], pos: usize) -> u16 {
201 u16::from_le_bytes(b[pos..pos + 2].try_into().unwrap())
202}
203
204fn read_str_at(body: &[u8], pos: &mut usize, len: usize, enc: &'static Encoding) -> String {
205 if *pos + len > body.len() {
206 *pos = body.len();
207 return String::new();
208 }
209 let (s, _, _) = enc.decode(&body[*pos..*pos + len]);
210 *pos += len;
211 s.into_owned()
212}
213
214pub fn parse_cols_robust(
222 body: &[u8],
223 n_params: usize,
224 ncols: usize,
225 enc: &'static Encoding,
226) -> Result<Vec<Column>> {
227 let valid = |cols: &[Column]| -> bool {
228 if cols.len() != ncols {
229 return false;
230 }
231 for c in cols {
232 if !(0..=40).contains(&c.col_type) {
233 return false;
234 }
235 if !(0..=1_000_000).contains(&c.prec) {
236 return false;
237 }
238 if c.name.is_empty()
239 || c.name.chars().any(|ch| ch.is_control())
240 || !c.name.chars().any(|ch| ch.is_alphanumeric())
241 {
242 return false;
243 }
244 }
245 true
246 };
247 for (per, off) in [(32usize, 0i32), (32, 8), (16, 0), (16, 8), (0, 0), (32, -8), (16, -8)] {
248 let pos = (n_params * per) as i64 + off as i64;
249 if pos < 0 || pos + 30 > body.len() as i64 {
250 continue;
251 }
252 if let Ok((cols, _)) = parse_columns(body, pos as usize, ncols, enc) {
253 if valid(&cols) {
254 return Ok(cols);
255 }
256 }
257 }
258 let scan_end = body.len().saturating_sub(30).min(256);
260 for pos in (0..scan_end).step_by(2) {
261 if let Ok((cols, _)) = parse_columns(body, pos, ncols, enc) {
262 if valid(&cols) {
263 return Ok(cols);
264 }
265 }
266 }
267 let (cols, _) = parse_columns(body, n_params * 32, ncols, enc)?;
269 Ok(cols)
270}
271
272pub fn parse_columns(
278 body: &[u8],
279 mut pos: usize,
280 count: usize,
281 enc: &'static Encoding,
282) -> Result<(Vec<Column>, usize)> {
283 let mut cols = Vec::with_capacity(count);
284 for _ in 0..count {
285 if pos + 32 > body.len() {
286 break;
287 }
288 let col_type = le_i32(body, pos);
289 let prec = le_i32(body, pos + 4);
290 let scale = le_i32(body, pos + 8);
291 let nullable = le_i32(body, pos + 12) != 0;
292 pos += 24; if pos + 8 > body.len() {
294 break;
295 }
296 let nl = le_u16(body, pos) as usize;
297 let tl = le_u16(body, pos + 2) as usize;
298 let tbl = le_u16(body, pos + 4) as usize;
299 let sl = le_u16(body, pos + 6) as usize;
300 pos += 8;
301 let name = read_str_at(body, &mut pos, nl, enc);
302 let type_name = read_str_at(body, &mut pos, tl, enc);
303 let table_name = read_str_at(body, &mut pos, tbl, enc);
304 let schema_name = read_str_at(body, &mut pos, sl, enc);
305 if pos + 2 > body.len() {
307 break;
308 }
309 let bn = le_u16(body, pos) as usize;
310 pos += 2;
311 pos = (pos + bn).min(body.len());
312 let lob = col_type == DM_BLOB || col_type == DM_CLOB;
313 if lob {
314 pos += 6;
316 }
317 cols.push(Column {
318 col_type,
319 prec,
320 scale,
321 nullable,
322 name,
323 type_name,
324 table_name,
325 schema_name,
326 lob,
327 });
328 }
329 Ok((cols, pos))
330}
331
332pub fn parse_rows(
337 body: &[u8],
338 mut pos: usize,
339 ncols: usize,
340 nrows: usize,
341) -> Result<Vec<Row>> {
342 let mut rows = Vec::with_capacity(nrows);
343 let header = 10; for _ in 0..nrows {
345 if pos + header > body.len() {
346 break;
347 }
348 pos += header;
349 if pos + 2 * ncols > body.len() {
350 break;
351 }
352 pos += 2 * ncols; let mut row = Vec::with_capacity(ncols);
354 for _ in 0..ncols {
355 if pos + 2 > body.len() {
356 row.push(None);
357 break;
358 }
359 let ln = le_u16(body, pos);
360 pos += 2;
361 match ln {
362 NULL_MARK => row.push(None),
363 LOB_MARK => {
364 if pos + 4 <= body.len() {
366 let real = le_i32(body, pos);
367 pos += 4;
368 if real > 0 && pos + real as usize <= body.len() {
369 row.push(Some(body[pos..pos + real as usize].to_vec()));
370 pos += real as usize;
371 } else {
372 row.push(None);
373 }
374 } else {
375 row.push(None);
376 }
377 }
378 n => {
379 let n = n as usize;
380 if pos + n > body.len() {
381 row.push(None);
382 break;
383 }
384 row.push(Some(body[pos..pos + n].to_vec()));
385 pos += n;
386 }
387 }
388 }
389 rows.push(row);
390 }
391 Ok(rows)
392}
393
394pub fn parse_rows_param(body: &[u8], mut pos: usize, ncols: usize) -> Result<Vec<Row>> {
396 let mut rows = Vec::new();
397 while pos + 2 <= body.len() {
398 let rlen = le_u16(body, pos) as usize;
399 let row_end = pos + rlen;
400 if rlen == 0 || row_end <= pos + 2 || row_end > body.len() {
402 break; }
404 let mut p = pos + 2 + 2 + 6; p += 2 * ncols; let mut row = Vec::with_capacity(ncols);
407 for _ in 0..ncols {
408 if p + 2 > row_end {
409 row.push(None);
410 break;
411 }
412 let ln = le_u16(body, p);
413 p += 2;
414 match ln {
415 NULL_MARK => row.push(None),
416 LOB_MARK => {
417 if p + 4 <= row_end {
418 let real = le_i32(body, p);
419 p += 4;
420 if real > 0 && p + real as usize <= row_end {
421 row.push(Some(body[p..p + real as usize].to_vec()));
422 p += real as usize;
423 } else {
424 row.push(None);
425 }
426 } else {
427 row.push(None);
428 }
429 }
430 n => {
431 let n = n as usize;
432 if p + n > row_end {
433 row.push(None);
434 break;
435 }
436 row.push(Some(body[p..p + n].to_vec()));
437 p += n;
438 }
439 }
440 }
441 rows.push(row);
442 pos = row_end;
443 }
444 Ok(rows)
445}
446
447pub fn decode_scalar(raw: &[u8], col: &Column, enc: &'static Encoding) -> Result<Value> {
449 if raw.is_empty() {
450 match col.col_type {
452 DM_CHAR | DM_VARCHAR2 | DM_VARCHAR | DM_CLOB => return Ok(Value::Str(String::new())),
453 _ => return Ok(Value::Bytes(Vec::new())),
454 }
455 }
456 let t = col.col_type;
457 let v = match t {
458 DM_CHAR | DM_VARCHAR2 | DM_VARCHAR => {
459 let (s, _, _) = enc.decode(raw);
460 Value::Str(s.into_owned())
461 }
462 DM_BOOLEAN | DM_BIT => Value::Bool(raw[0] != 0),
463 DM_TINYINT => Value::TinyInt(raw[0] as i8),
464 DM_SMALLINT => Value::SmallInt(i16::from_le_bytes(raw[..2].try_into().unwrap())),
465 DM_INT => Value::Int(le_i32(raw, 0)),
466 DM_BIGINT => Value::BigInt(i64::from_le_bytes(raw[..8].try_into().unwrap())),
467 DM_REAL => Value::Real(f32::from_le_bytes(raw[..4].try_into().unwrap())),
468 DM_DOUBLE => Value::Double(f64::from_le_bytes(raw[..8].try_into().unwrap())),
469 DM_DECIMAL => Value::Decimal(decode_decimal(raw)),
470 DM_DATE => Value::Date(decode_date(raw)),
471 DM_TIME => Value::Time(decode_time(raw)),
472 DM_TIME_TZ => Value::Time(decode_time_tz(raw)),
473 DM_DATETIME => Value::DateTime(decode_datetime(raw)),
474 DM_DATETIME2 => Value::DateTime(decode_datetime2(raw)),
475 DM_DATETIME_TZ => Value::DateTime(decode_datetime_tz(raw)),
476 DM_DATETIME2_TZ => Value::DateTime(decode_datetime2_tz(raw)),
477 DM_INTERVAL_YM => Value::Interval(decode_interval_ym(raw)),
478 DM_INTERVAL_DT => Value::Interval(decode_interval_dt(raw)),
479 DM_BINARY | DM_VARBINARY | DM_BLOB => Value::Bytes(raw.to_vec()),
480 _ => Value::Raw(raw.to_vec()),
481 };
482 Ok(v)
483}
484
485pub fn decode_decimal(raw: &[u8]) -> String {
491 if raw.is_empty() || raw[0] == 0x80 {
492 return "0".to_string();
493 }
494 let (sign, exp): (i32, i32) = if raw[0] & 0x80 != 0 {
495 (1, raw[0] as i32 - 0xC1)
496 } else {
497 (-1, 0x3E - raw[0] as i32)
498 };
499 let mut digits = String::new();
500 for &b in &raw[1..] {
501 let d = if sign > 0 { b as i32 - 1 } else { 101 - b as i32 };
502 if !(0..=99).contains(&d) {
503 break;
504 }
505 digits.push_str(&format!("{d:02}"));
506 }
507 if digits.is_empty() {
508 return "0".to_string();
509 }
510 let weight = exp * 2 - (digits.len() as i32 - 2);
512 let s = if weight >= 0 {
513 format!("{}{}", digits, "0".repeat(weight as usize))
514 } else {
515 let n = digits.len() as i32 + weight;
516 if n <= 0 {
517 format!("0.{}{}", "0".repeat((-n) as usize), digits)
518 } else {
519 format!("{}.{}", &digits[..n as usize], &digits[n as usize..])
520 }
521 };
522 let s = if sign < 0 {
523 format!("-{s}")
524 } else {
525 s
526 };
527 py_decimal_str(&s)
528}
529
530fn py_decimal_str(s: &str) -> String {
533 let (neg, body) = match s.strip_prefix('-') {
534 Some(b) => (true, b),
535 None => (false, s),
536 };
537 let (int_part, frac_part) = match body.split_once('.') {
538 Some((i, f)) => (i, f),
539 None => (body, ""),
540 };
541 let mut combined = String::with_capacity(int_part.len() + frac_part.len());
542 combined.push_str(int_part);
543 combined.push_str(frac_part);
544 let stripped = combined.trim_start_matches('0');
546 let coeff = if stripped.is_empty() { "0" } else { stripped };
547 let exp: i64 = -(frac_part.len() as i64);
549 let leftdigits = exp + coeff.len() as i64;
551 let dotplace: i64 = if exp <= 0 && leftdigits > -6 {
552 leftdigits
553 } else {
554 1
555 };
556 let (intpart, fracpart) = if dotplace <= 0 {
557 (String::from("0"), format!(".{}{}", "0".repeat((-dotplace) as usize), coeff))
558 } else if dotplace >= coeff.len() as i64 {
559 (
560 format!("{}{}", coeff, "0".repeat((dotplace - coeff.len() as i64) as usize)),
561 String::new(),
562 )
563 } else {
564 (
565 coeff[..dotplace as usize].to_string(),
566 format!(".{}", &coeff[dotplace as usize..]),
567 )
568 };
569 let exp_part = if leftdigits == dotplace {
570 String::new()
571 } else {
572 format!("E{:+}", leftdigits - dotplace)
573 };
574 format!("{}{}{}{}", if neg { "-" } else { "" }, intpart, fracpart, exp_part)
575}
576
577pub fn decode_date(raw: &[u8]) -> DmDate {
579 let b0 = raw[0] as i32;
580 let b1 = raw[1] as i32;
581 let b2 = raw[2] as i32;
582 let mut year = (b0 | (b1 << 8)) & 0x7FFF;
583 if year > 9999 {
584 year = (year | 0x8000) & 0xFFFF;
585 year -= 65536;
586 }
587 let month = ((b1 >> 7) & 0x1) + ((b2 & 0x07) << 1);
588 let day = ((b2 & 0xF8) >> 3) & 0x1F;
589 DmDate {
590 year,
591 month: if month == 0 { 1 } else { month as u8 },
592 day: if day == 0 { 1 } else { day as u8 },
593 }
594}
595
596pub fn decode_time(raw: &[u8]) -> DmTime {
598 let b0 = raw[0] as u32;
599 let b1 = raw[1] as u32;
600 let b2 = raw[2] as u32;
601 let b3 = raw[3] as u32;
602 let b4 = raw[4] as u32;
603 let hour = b0 & 0x1F;
604 let minute = ((b0 >> 5) & 0x07) + ((b1 & 0x07) << 3);
605 let second = ((b1 >> 3) & 0x1F) + ((b2 & 0x01) << 5);
606 let nsec = (((b2 >> 1) & 0x7F) + (b3 << 7) + ((b4 & 0x1F) << 15)) * 1000;
607 DmTime {
608 hour: hour as u8,
609 minute: minute as u8,
610 second: second as u8,
611 microsecond: nsec / 1000,
612 timezone_minutes: None,
613 }
614}
615
616pub fn decode_time_tz(raw: &[u8]) -> DmTime {
618 let mut t = decode_time(&raw[..5.min(raw.len())]);
619 if raw.len() >= 7 {
620 t.timezone_minutes = Some(i16::from_le_bytes([raw[5], raw[6]]));
621 }
622 t
623}
624
625pub fn decode_datetime(raw: &[u8]) -> DmDateTime {
627 if raw.len() >= 8 {
628 DmDateTime {
629 date: decode_date(&raw[..3]),
630 time: decode_time(&raw[3..8]),
631 }
632 } else {
633 DmDateTime {
634 date: DmDate::new(1, 1, 1),
635 time: DmTime::new(0, 0, 0, 0),
636 }
637 }
638}
639
640pub fn decode_datetime2(raw: &[u8]) -> DmDateTime {
642 if raw.len() >= 9 {
643 let b = |i: usize| raw[3 + i] as u32; let nsec = ((b(2) >> 1) & 0x7F) + (b(3) << 7) + (b(4) << 15) + ((b(5) & 0x7F) << 23);
645 let date = decode_date(&raw[..3]);
646 let mut time = decode_time(&raw[3..8]);
647 time.microsecond = nsec / 1000;
648 DmDateTime { date, time }
649 } else {
650 decode_datetime(raw)
651 }
652}
653
654pub fn decode_datetime_tz(raw: &[u8]) -> DmDateTime {
656 let mut dt = decode_datetime(&raw[..8.min(raw.len())]);
657 if raw.len() >= 10 {
658 dt.time.timezone_minutes = Some(i16::from_le_bytes([raw[8], raw[9]]));
659 }
660 dt
661}
662
663pub fn decode_datetime2_tz(raw: &[u8]) -> DmDateTime {
665 let mut dt = decode_datetime2(&raw[..9.min(raw.len())]);
666 if raw.len() >= 11 {
667 dt.time.timezone_minutes = Some(i16::from_le_bytes([raw[9], raw[10]]));
668 }
669 dt
670}
671
672pub fn decode_interval_ym(raw: &[u8]) -> String {
674 if raw.len() < 8 {
675 return String::new();
676 }
677 let years = le_i32(raw, 0);
678 let months = le_i32(raw, 4);
679 format!("{years}-{months}")
680}
681
682pub fn decode_interval_dt(raw: &[u8]) -> String {
684 if raw.len() < 20 {
685 return String::new();
686 }
687 let days = le_i32(raw, 0);
688 let hours = le_i32(raw, 4);
689 let minutes = le_i32(raw, 8);
690 let seconds = le_i32(raw, 12);
691 let frac = le_i32(raw, 16);
692 format!("{days} {hours:02}:{minutes:02}:{seconds:02}.{frac:06}")
693}
694
695pub fn encode_date(d: &DmDate) -> [u8; 3] {
699 let y = d.year;
700 let m = d.month as i32;
701 let dd = d.day as i32;
702 [
703 (y & 0xFF) as u8,
704 (((y >> 8) & 0x7F) | ((m & 1) << 7)) as u8,
705 (((m >> 1) & 0x07) | ((dd & 0x1F) << 3)) as u8,
706 ]
707}
708
709pub fn encode_time(t: &DmTime) -> [u8; 5] {
711 let us = t.microsecond;
712 let b0 = (t.hour as u32) | ((t.minute as u32 & 0x07) << 5);
713 let b1 = (t.minute as u32 >> 3) | ((t.second as u32) << 3);
714 let b2 = (t.second as u32 >> 5) | ((us & 0x7F) << 1);
715 let b3 = (us >> 7) & 0xFF;
716 let b4 = (us >> 15) & 0x1F;
717 [
718 (b0 & 0xFF) as u8,
719 (b1 & 0xFF) as u8,
720 (b2 & 0xFF) as u8,
721 b3 as u8,
722 b4 as u8,
723 ]
724}
725
726pub fn encode_datetime(dt: &DmDateTime) -> Vec<u8> {
728 let mut out = encode_date(&dt.date).to_vec();
729 out.extend_from_slice(&encode_time(&dt.time));
730 out
731}
732
733pub fn encode_time_tz(t: &DmTime) -> Vec<u8> {
735 let mut out = encode_time(t).to_vec();
736 out.extend_from_slice(&t.timezone_minutes.unwrap_or(0).to_le_bytes());
737 out
738}
739
740pub fn encode_datetime_tz(dt: &DmDateTime) -> Vec<u8> {
742 let mut out = encode_datetime(dt);
743 out.extend_from_slice(&dt.time.timezone_minutes.unwrap_or(0).to_le_bytes());
744 out
745}
746
747pub fn encode_datetime2(dt: &DmDateTime) -> Vec<u8> {
751 let mut out = encode_date(&dt.date).to_vec();
752 let t = &dt.time;
753 let nsec = (t.microsecond as u64) * 1000;
754 let b0 = (t.hour as u32) | ((t.minute as u32 & 0x07) << 5);
755 let b1 = (t.minute as u32 >> 3) | ((t.second as u32) << 3);
756 let b2 = (t.second as u32 >> 5) | (((nsec & 0x7F) as u32) << 1);
757 out.extend_from_slice(&[
758 b0 as u8,
759 b1 as u8,
760 b2 as u8,
761 ((nsec >> 7) & 0xFF) as u8,
762 ((nsec >> 15) & 0xFF) as u8,
763 ((nsec >> 23) & 0x7F) as u8,
764 ]);
765 out
766}
767
768pub fn encode_datetime2_tz(dt: &DmDateTime) -> Vec<u8> {
770 let mut out = encode_datetime2(dt);
771 out.extend_from_slice(&dt.time.timezone_minutes.unwrap_or(0).to_le_bytes());
772 out
773}
774
775pub fn decode_out_value(raw: &[u8], col_type: i32, enc: &'static Encoding) -> Value {
779 match col_type {
780 5..=8 => Value::BigInt(le_i64(raw)),
781 10 => Value::Real(f32::from_le_bytes(raw[..4].try_into().unwrap())),
782 11 => Value::Double(f64::from_le_bytes(raw[..8].try_into().unwrap())),
783 14 => Value::Date(decode_date(raw)),
784 15 => Value::Time(decode_time(raw)),
785 16 => Value::DateTime(decode_datetime(raw)),
786 2 | 19 => {
787 let (s, _, _) = enc.decode(raw);
788 Value::Str(s.into_owned())
789 }
790 12 | 17 | 18 => Value::Bytes(raw.to_vec()),
791 _ => Value::Raw(raw.to_vec()),
792 }
793}
794
795fn le_i64(b: &[u8]) -> i64 {
796 let mut buf = [0u8; 8];
797 let n = b.len().min(8);
798 buf[..n].copy_from_slice(&b[..n]);
799 i64::from_le_bytes(buf)
800}
801
802#[cfg(test)]
803mod tests {
804 use super::*;
805
806 #[test]
807 fn date_decode_reference() {
808 let d = decode_date(&[0xEA, 0x07, 0x64]);
809 assert_eq!(d, DmDate::new(2026, 8, 12));
810 let d = decode_date(&encode_date(&DmDate::new(1, 1, 1)));
812 assert_eq!(d, DmDate::new(1, 1, 1));
813 }
814
815 #[test]
816 fn date_encode_reference() {
817 assert_eq!(encode_date(&DmDate::new(2026, 8, 12)), [0xEA, 0x07, 0x64]);
818 assert_eq!(encode_date(&DmDate::new(1999, 2, 28)), [0xCF, 0x07, 0xE1]);
819 }
820
821 #[test]
822 fn time_roundtrip_reference() {
823 let t = decode_time(&[0x77, 0xDF, 0x7F, 0x84, 0x1E]);
825 assert_eq!(t, DmTime::new(23, 59, 59, 999999));
826 let t2 = decode_time(&[0x4C, 0xC4, 0x11, 0x14, 0x18]);
827 assert_eq!(t2, DmTime::new(12, 34, 56, 789000));
828 for t in [
830 DmTime::new(23, 59, 59, 999999),
831 DmTime::new(12, 34, 56, 789000),
832 DmTime::new(0, 0, 0, 0),
833 ] {
834 assert_eq!(decode_time(&encode_time(&t)), t);
835 }
836 }
837
838 #[test]
839 fn datetime_roundtrip() {
840 let dt = DmDateTime::new(DmDate::new(2030, 6, 15), DmTime::new(8, 9, 10, 111222));
841 let b = encode_datetime(&dt);
842 assert_eq!(b, vec![0xEE, 0x07, 0x7B, 0x28, 0x51, 0xEC, 0x64, 0x03]);
843 assert_eq!(decode_datetime(&b), dt);
844 let max = DmDateTime::new(DmDate::new(9999, 12, 31), DmTime::new(23, 59, 59, 999999));
846 assert_eq!(encode_datetime(&max), vec![0x0F, 0x27, 0xFE, 0x77, 0xDF, 0x7F, 0x84, 0x1E]);
847 assert_eq!(decode_datetime(&encode_datetime(&max)), max);
848 }
849
850 #[test]
851 fn decimal_decode_reference() {
852 assert_eq!(decode_decimal(&[0xC1, 0x02, 0x33]), "1.50");
854 assert_eq!(decode_decimal(&[0x80]), "0");
855 assert_eq!(decode_decimal(&[0xC1, 0x00]), "0");
856 assert_eq!(decode_decimal(&[0xC0, 0x01]), "0.00");
857 assert_eq!(decode_decimal(&[0x3D, 0x02, 0x33]), "-9950");
859 assert_eq!(decode_decimal(&[0x3E, 0x63, 0x66]), "-2");
860 }
861
862 #[test]
863 fn interval_decode() {
864 let mut b = Vec::new();
865 for v in [1i32, 2, 0] {
866 b.extend_from_slice(&v.to_le_bytes());
867 }
868 b.push(0);
869 assert_eq!(decode_interval_ym(&b), "1-2");
870
871 let mut b = Vec::new();
872 for v in [1i32, 2, 3, 4, 567890, 0] {
873 b.extend_from_slice(&v.to_le_bytes());
874 }
875 b.push(0);
876 assert_eq!(decode_interval_dt(&b), "1 02:03:04.567890");
877 }
878
879 #[test]
880 fn parse_columns_real_capture() {
881 let body = [
883 0x07, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
884 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x07, 0x00,
885 0x00, 0x00, 0x00, 0x00, 0x31, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x00, 0x00,
886 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x04, 0x00,
887 0x01, 0x00, 0x00, 0x00,
888 ];
889 let enc: &'static Encoding = encoding_rs::GB18030;
890 let (cols, pos) = parse_columns(&body, 0, 1, enc).unwrap();
891 assert_eq!(cols.len(), 1);
892 assert_eq!(cols[0].col_type, DM_INT);
893 assert_eq!(cols[0].prec, 4);
894 assert_eq!(cols[0].name, "1");
895 assert_eq!(cols[0].type_name, "INTEGER");
896 assert_eq!(cols[0].table_name, "");
897 assert_eq!(cols[0].schema_name, "");
898 let rows = parse_rows(&body, pos, 1, 1).unwrap();
900 assert_eq!(rows, vec![vec![Some(vec![1, 0, 0, 0])]]);
901 }
902
903 #[test]
904 fn parse_rows_param_real_capture() {
905 let body = hex2b(
907 "610002000000000000000c00530001020403000000000028000000000000000000000002040000010002000000000000000000000000000000d5e2cac74c4f42b2e2cad4c4dac8dda3acb0fcbaacd6d0cec4bacd456e676c697368bbecbacfa1a3",
908 );
909 let rows = parse_rows_param(&body, 0, 1).unwrap();
910 assert_eq!(rows.len(), 1);
911 let cell = rows[0][0].as_ref().unwrap();
912 assert_eq!(cell.len(), 83);
913 assert_eq!(cell[0], 0x01); assert_eq!(u32::from_le_bytes(cell[9..13].try_into().unwrap()), 40);
916 let (s, _, _) = encoding_rs::GB18030.decode(&cell[43..]);
918 assert_eq!(s, "这是LOB测试内容,包含中文和English混合。");
919 }
920
921 fn hex2b(s: &str) -> Vec<u8> {
922 (0..s.len())
923 .step_by(2)
924 .map(|i| u8::from_str_radix(&s[i..i + 2], 16).unwrap())
925 .collect()
926 }
927
928 #[test]
929 fn gb18030_scalar_decode() {
930 let enc: &'static Encoding = encoding_rs::GB18030;
931 let (s, _, _) = enc.decode(&[0xb2, 0xe2, 0xca, 0xd4]);
932 assert_eq!(s, "测试");
933 let (s, _, _) = enc.decode(&[0x95, 0x32, 0x82, 0x36]);
935 assert_eq!(s, "\u{20000}");
936 }
937
938 #[test]
939 fn tz_and_datetime2_decode() {
940 let t = decode_time_tz(&hex2b("4cc4111418e001"));
943 assert_eq!((t.hour, t.minute, t.second, t.microsecond), (12, 34, 56, 789000));
944 assert_eq!(t.timezone_minutes, Some(480));
945 assert!(t.to_string().ends_with("+08:00"), "{}", t);
946 let t2 = decode_time_tz(&hex2b("4cc4111418d4fe"));
947 assert_eq!(t2.timezone_minutes, Some(-300));
948 assert!(t2.to_string().ends_with("-05:00"), "{}", t2);
949
950 let dt = decode_datetime_tz(&hex2b("ea07744cc4111418e001"));
952 assert_eq!((dt.date.year, dt.date.month, dt.date.day), (2026, 8, 14));
953 assert_eq!(dt.time.hour, 12);
954 assert_eq!(dt.time.timezone_minutes, Some(480));
955 assert!(dt.to_string().ends_with("+08:00"), "{}", dt);
956
957 let dt2 = decode_datetime2(&hex2b("ea07744cc4815e0e5e"));
959 assert_eq!(dt2.date.year, 2026);
960 assert_eq!(dt2.time.microsecond, 789000);
961 assert_eq!(dt2.time.timezone_minutes, None);
962
963 let dtz = decode_datetime2_tz(&hex2b("ea07744cc4815e0e5ee001"));
965 assert_eq!(dtz.time.microsecond, 789000);
966 assert_eq!(dtz.time.timezone_minutes, Some(480));
967 assert!(dtz.to_string().ends_with("+08:00"));
968 }
969
970 #[test]
971 fn tz_and_datetime2_encode_roundtrip() {
972 let mut t = DmTime::new(12, 34, 56, 789000);
974 t.timezone_minutes = Some(480);
975 assert_eq!(encode_time_tz(&t), hex2b("4cc4111418e001"));
976 assert_eq!(decode_time_tz(&encode_time_tz(&t)), t);
977
978 let mut dt = DmDateTime::new(DmDate::new(2026, 8, 14), DmTime::new(12, 34, 56, 789000));
980 dt.time.timezone_minutes = Some(-300);
981 assert_eq!(encode_datetime_tz(&dt), hex2b("ea07744cc4111418d4fe"));
982 assert_eq!(decode_datetime_tz(&encode_datetime_tz(&dt)), dt);
983
984 let dt2 = DmDateTime::new(DmDate::new(2026, 8, 14), DmTime::new(12, 34, 56, 789000));
986 assert_eq!(encode_datetime2(&dt2), hex2b("ea07744cc4815e0e5e"));
987 assert_eq!(decode_datetime2(&encode_datetime2(&dt2)), dt2);
988
989 let mut dtz = dt2;
991 dtz.time.timezone_minutes = Some(480);
992 assert_eq!(encode_datetime2_tz(&dtz), hex2b("ea07744cc4815e0e5ee001"));
993 assert_eq!(decode_datetime2_tz(&encode_datetime2_tz(&dtz)), dtz);
994
995 let plain = DmTime::new(1, 2, 3, 0);
997 assert_eq!(encode_time_tz(&plain).len(), 7);
998 assert_eq!(&encode_time_tz(&plain)[5..], &[0u8, 0]);
999 }
1000
1001 #[test]
1002 fn dml_affected_i64() {
1003 let o = [0u8; 44];
1006 let _ = &o;
1007 assert_eq!(le_i64(&100_000i64.to_le_bytes()), 100_000);
1008 }
1009}