Skip to content

Commit eeed7c5

Browse files
sfacklersfackler
committed
UPdate to postgres 0.15
1 parent 9c54112 commit eeed7c5

File tree

2 files changed

+53
-40
lines changed

2 files changed

+53
-40
lines changed

‎Cargo.toml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -10,4 +10,4 @@ readme = "README.md"
1010
keywords = ["database", "sql", "postgres"]
1111

1212
[dependencies]
13-
postgres = "0.14"
13+
postgres = "0.15"

‎src/lib.rs‎

Lines changed: 52 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -36,7 +36,6 @@ extern crate postgres;
3636

3737
use postgres::{Result, GenericConnection};
3838
use postgres::transaction::Transaction;
39-
use postgres::error::Error;
4039
use postgres::types::Oid;
4140
use std::cmp;
4241
use std::fmt;
@@ -54,13 +53,13 @@ pub trait LargeObjectExt {
5453

5554
impl<T: GenericConnection> LargeObjectExt for T {
5655
fn create_large_object(&self) -> Result<Oid> {
57-
let stmt = try!(self.prepare_cached("SELECT pg_catalog.lo_create(0)"));
56+
let stmt = self.prepare_cached("SELECT pg_catalog.lo_create(0)")?;
5857
let r = stmt.query(&[]).map(|r| r.iter().next().unwrap().get(0));
5958
r
6059
}
6160

6261
fn delete_large_object(&self, oid: Oid) -> Result<()> {
63-
let stmt = try!(self.prepare_cached("SELECT pg_catalog.lo_unlink($1)"));
62+
let stmt = self.prepare_cached("SELECT pg_catalog.lo_unlink($1)")?;
6463
stmt.execute(&[&oid]).map(|_| ())
6564
}
6665
}
@@ -103,8 +102,12 @@ impl<'conn> LargeObjectTransactionExt for Transaction<'conn> {
103102
let minor: i32 = version.next().unwrap().parse().unwrap();
104103
let has_64 = major > 9 || (major == 9 && minor >= 3);
105104

106-
let stmt = try!(self.prepare_cached("SELECT pg_catalog.lo_open($1, $2)"));
107-
let fd = try!(stmt.query(&[&oid, &mode.to_i32()])).iter().next().unwrap().get(0);
105+
let stmt = self.prepare_cached("SELECT pg_catalog.lo_open($1, $2)")?;
106+
let fd = stmt.query(&[&oid, &mode.to_i32()])?
107+
.iter()
108+
.next()
109+
.unwrap()
110+
.get(0);
108111
Ok(LargeObject {
109112
trans: self,
110113
fd: fd,
@@ -114,15 +117,6 @@ impl<'conn> LargeObjectTransactionExt for Transaction<'conn> {
114117
}
115118
}
116119

117-
macro_rules! try_io {
118-
($e:expr) => {
119-
match $e {
120-
Ok(ok) => ok,
121-
Err(e) => return Err(io::Error::new(io::ErrorKind::Other, e))
122-
}
123-
}
124-
}
125-
126120
/// Represents an open large object.
127121
pub struct LargeObject<'a> {
128122
trans: &'a Transaction<'a>,
@@ -134,9 +128,9 @@ pub struct LargeObject<'a> {
134128
impl<'a> fmt::Debug for LargeObject<'a> {
135129
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
136130
fmt.debug_struct("LargeObject")
137-
.field("fd", &self.fd)
138-
.field("transaction", &self.trans)
139-
.finish()
131+
.field("fd", &self.fd)
132+
.field("transaction", &self.trans)
133+
.finish()
140134
}
141135
}
142136

@@ -158,17 +152,25 @@ impl<'a> LargeObject<'a> {
158152
/// null bytes to the specified size.
159153
pub fn truncate(&mut self, len: i64) -> Result<()> {
160154
if self.has_64 {
161-
let stmt = try!(self.trans.prepare_cached("SELECT pg_catalog.lo_truncate64($1, $2)"));
155+
let stmt = self.trans.prepare_cached(
156+
"SELECT pg_catalog.lo_truncate64($1, $2)",
157+
)?;
162158
stmt.execute(&[&self.fd, &len]).map(|_| ())
163159
} else {
164160
let len = if len <= i32::max_value() as i64 {
165161
len as i32
166162
} else {
167-
return Err(Error::Io(io::Error::new(io::ErrorKind::InvalidInput,
168-
"The database does not support objects larger \
169-
than 2GB")));
163+
return Err(
164+
io::Error::new(
165+
io::ErrorKind::InvalidInput,
166+
"The database does not support objects larger \
167+
than 2GB",
168+
).into(),
169+
);
170170
};
171-
let stmt = try!(self.trans.prepare_cached("SELECT pg_catalog.lo_truncate($1, $2)"));
171+
let stmt = self.trans.prepare_cached(
172+
"SELECT pg_catalog.lo_truncate($1, $2)",
173+
)?;
172174
stmt.execute(&[&self.fd, &len]).map(|_| ())
173175
}
174176
}
@@ -179,7 +181,7 @@ impl<'a> LargeObject<'a> {
179181
}
180182

181183
self.finished = true;
182-
let stmt = try!(self.trans.prepare_cached("SELECT pg_catalog.lo_close($1)"));
184+
let stmt = self.trans.prepare_cached("SELECT pg_catalog.lo_close($1)")?;
183185
stmt.execute(&[&self.fd]).map(|_| ())
184186
}
185187

@@ -194,18 +196,22 @@ impl<'a> LargeObject<'a> {
194196

195197
impl<'a> io::Read for LargeObject<'a> {
196198
fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
197-
let stmt = try_io!(self.trans.prepare_cached("SELECT pg_catalog.loread($1, $2)"));
199+
let stmt = self.trans.prepare_cached(
200+
"SELECT pg_catalog.loread($1, $2)",
201+
)?;
198202
let cap = cmp::min(buf.len(), i32::MAX as usize) as i32;
199-
let rows = try_io!(stmt.query(&[&self.fd, &cap]));
203+
let rows = stmt.query(&[&self.fd, &cap])?;
200204
buf.write(rows.get(0).get_bytes(0).unwrap())
201205
}
202206
}
203207

204208
impl<'a> io::Write for LargeObject<'a> {
205209
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
206-
let stmt = try_io!(self.trans.prepare_cached("SELECT pg_catalog.lowrite($1, $2)"));
210+
let stmt = self.trans.prepare_cached(
211+
"SELECT pg_catalog.lowrite($1, $2)",
212+
)?;
207213
let cap = cmp::min(buf.len(), i32::MAX as usize);
208-
try_io!(stmt.execute(&[&self.fd, &&buf[..cap]]));
214+
stmt.execute(&[&self.fd, &&buf[..cap]])?;
209215
Ok(cap)
210216
}
211217

@@ -221,8 +227,10 @@ impl<'a> io::Seek for LargeObject<'a> {
221227
let pos = if pos <= i64::max_value as u64 {
222228
pos as i64
223229
} else {
224-
return Err(io::Error::new(io::ErrorKind::InvalidInput,
225-
"cannot seek more than 2^63 bytes"));
230+
return Err(io::Error::new(
231+
io::ErrorKind::InvalidInput,
232+
"cannot seek more than 2^63 bytes",
233+
));
226234
};
227235
(0, pos)
228236
}
@@ -231,20 +239,25 @@ impl<'a> io::Seek for LargeObject<'a> {
231239
};
232240

233241
if self.has_64 {
234-
let stmt = try_io!(self.trans
235-
.prepare_cached("SELECT pg_catalog.lo_lseek64($1, $2, $3)"));
236-
let rows = try_io!(stmt.query(&[&self.fd, &pos, &kind]));
242+
let stmt = self.trans.prepare_cached(
243+
"SELECT pg_catalog.lo_lseek64($1, $2, $3)",
244+
)?;
245+
let rows = stmt.query(&[&self.fd, &pos, &kind])?;
237246
let pos: i64 = rows.iter().next().unwrap().get(0);
238247
Ok(pos as u64)
239248
} else {
240249
let pos = if pos <= i32::max_value() as i64 {
241250
pos as i32
242251
} else {
243-
return Err(io::Error::new(io::ErrorKind::InvalidInput,
244-
"cannot seek more than 2^31 bytes"));
252+
return Err(io::Error::new(
253+
io::ErrorKind::InvalidInput,
254+
"cannot seek more than 2^31 bytes",
255+
));
245256
};
246-
let stmt = try_io!(self.trans.prepare_cached("SELECT pg_catalog.lo_lseek($1, $2, $3)"));
247-
let rows = try_io!(stmt.query(&[&self.fd, &pos, &kind]));
257+
let stmt = self.trans.prepare_cached(
258+
"SELECT pg_catalog.lo_lseek($1, $2, $3)",
259+
)?;
260+
let rows = stmt.query(&[&self.fd, &pos, &kind])?;
248261
let pos: i32 = rows.iter().next().unwrap().get(0);
249262
Ok(pos as u64)
250263
}
@@ -254,7 +267,7 @@ impl<'a> io::Seek for LargeObject<'a> {
254267
#[cfg(test)]
255268
mod test {
256269
use postgres::{Connection, TlsMode};
257-
use postgres::error::{Error, SqlState};
270+
use postgres::error::UNDEFINED_OBJECT;
258271

259272
use {LargeObjectExt, LargeObjectTransactionExt, Mode};
260273

@@ -270,7 +283,7 @@ mod test {
270283
let conn = Connection::connect("postgres://postgres@localhost", TlsMode::None).unwrap();
271284
match conn.delete_large_object(0) {
272285
Ok(()) => panic!("unexpected success"),
273-
Err(Error::Db(ref e)) if e.code == SqlState::UndefinedObject => {}
286+
Err(ref e) if e.code() == Some(&UNDEFINED_OBJECT) => {}
274287
Err(e) => panic!("unexpected error: {:?}", e),
275288
}
276289
}
@@ -281,7 +294,7 @@ mod test {
281294
let trans = conn.transaction().unwrap();
282295
match trans.open_large_object(0, Mode::Read) {
283296
Ok(_) => panic!("unexpected success"),
284-
Err(Error::Db(ref e)) if e.code == SqlState::UndefinedObject => {}
297+
Err(ref e) if e.code() == Some(&UNDEFINED_OBJECT) => {}
285298
Err(e) => panic!("unexpected error: {:?}", e),
286299
};
287300
}

0 commit comments

Comments
 (0)