numeric postgres type

[thejohnnybot]

I keep getting this error and im using the lastest version of rust and postgres?

'

' panicked at 'error retrieving column 6: WrongType(Numeric)'

the postgres type is numeric for the column

I am just using simple:

let lien_face_value: f32 = row.get(6);

any help greatly appreciated;

[sfackler]

rust-postgres is fairly strict with respect to which Postgres type it will convert to Rust types and vice versa. The Postgres REAL type is compatible with the Rust f32 type, but the Postgres NUMERIC type has arbitrary precision so rust-postgres won't convert between them.

[thejohnnybot]

@sfackler is there another option I could implement or is it that numeric type is not supported and I should change the type if possible?

[sfackler]

You could implement ToSql and FromSql for some type that handles NUMERIC values, or you could use REAL instead or NUMERIC.

[ArtemGr]

For reference, here's an example converting the on-the-wire Numeric to String:

// Stringifies a PostgreSQL Numeric from its wire format.
fn numeric_to_string (bytes: &[u8]) -> Result<String, String> {
  use byteorder::{BigEndian, ReadBytesExt};
  use std::io::Cursor;

  // http://www.postgresql.org/message-id/491DC5F3D279CD4EB4B157DDD62237F404E27FE9@zipwire.esri.com
  // http://www.postgresql.org/message-id/16572.1091489720@sss.pgh.pa.us
  // https://github.com/postgres/postgres/blob/46166197c3b3748c3266c694d7c2f5a312ea928e/src/backend/utils/adt/numeric.c#L821
  let mut cur = Cursor::new (bytes);
  let ndigits = try_s! (cur.read_i16::<BigEndian>());
  let weight = try_s! (cur.read_i16::<BigEndian>());
  let sign = try_s! (cur.read_u16::<BigEndian>());
  let dscale = try_s! (cur.read_i16::<BigEndian>());
  let mut digits = Vec::with_capacity (ndigits as usize);
  for _ in 0 .. ndigits {
    // i16 - https://github.com/postgres/postgres/blob/46166197c3b3748c3266c694d7c2f5a312ea928e/src/backend/utils/adt/numeric.c#L99
    digits.push (try_s! (cur.read_i16::<BigEndian>()));
  }
  // 4 - https://github.com/postgres/postgres/blob/46166197c3b3748c3266c694d7c2f5a312ea928e/src/backend/utils/adt/numeric.c#L95
  let DEC_DIGITS = 4;
  // https://github.com/postgres/postgres/blob/71fc49dfe1d99bd83cd99c2e7a39f93e07d19310/src/interfaces/ecpg/include/pgtypes_numeric.h#L5
  let NUMERIC_NEG = 0x4000;
  // https://github.com/postgres/postgres/blob/46166197c3b3748c3266c694d7c2f5a312ea928e/src/backend/utils/adt/numeric.c#L206
  let NUMERIC_NAN = -16384;
  if sign == NUMERIC_NAN {return Ok (String::from ("NaN"))}
  // --- A port of `get_str_from_var` ---
  let mut string = Vec::with_capacity ((((weight + 1) * DEC_DIGITS) + 1 + dscale + DEC_DIGITS + 2) as usize);
  // Output a dash for negative values.
  if sign == NUMERIC_NEG {string.push (b'-');}
  // Output all digits before the decimal point.
  let mut d;
  if weight < 0 {
    d = weight + 1;
    string.push (b'0');
  } else {
    d = 0; while d <= weight {
      let mut dig: i16 = if d < ndigits {digits[d as usize]} else {0};
      // In the first digit, suppress extra leading decimal zeroes.
      assert! (DEC_DIGITS == 4);
      let mut putit = d > 0;
      let mut d1 = dig / 1000;
      dig -= d1 * 1000;
      putit |= d1 > 0;
      if putit {string.push (d1 as u8 + b'0');}
      d1 = dig / 100;
      dig -= d1 * 100;
      putit |= d1 > 0;
      if putit {string.push (d1 as u8 + b'0');}
      d1 = dig / 10;
      dig -= d1 * 10;
      putit |= d1 > 0;
      if putit {string.push (d1 as u8 + b'0');}
      string.push (dig as u8 + b'0');
      d += 1;
    }
  }
  // If requested, output a decimal point and all the digits that follow it.
  // We initially put out a multiple of DEC_DIGITS digits, then truncate if needed.
  if dscale > 0 {
    string.push (b'.');
    let mut i = 0; while i < dscale {
      let mut dig = if d >= 0 && d < ndigits {digits[d as usize]} else {0};
      assert! (DEC_DIGITS == 4);
      let mut d1 = dig / 1000;
      dig -= d1 * 1000;
      string.push (d1 as u8 + b'0');
      d1 = dig / 100;
      dig -= d1 * 100;
      string.push (d1 as u8 + b'0');
      d1 = dig / 10;
      dig -= d1 * 10;
      string.push (d1 as u8 + b'0');
      string.push (dig as u8 + b'0');
      d += 1; i += DEC_DIGITS;
    }
    while *string.last().expect ("!last") == b'0' {string.pop();}
  }
  Ok (unsafe {String::from_utf8_unchecked (string)})
}

[jbg]

for people arriving from Google, note that the rust-decimal crate does provide ToSql and FromSql implementations for its Decimal type and it seems to work well.

[ianthetechie]

Thank you for your comment @jbg. Saved me a good bit of time googling ;)

[blastrider]

for people arriving from Google, note that the rust-decimal crate does provide ToSql and FromSql implementations for its Decimal type and it seems to work well.

Thank you, you are a brother ! :)