Skip to content

Commit 1524cd1

Browse files
sfacklersfackler
committed
Update rust-postgres version and drop old io
1 parent a6be930 commit 1524cd1

File tree

2 files changed

+18
-166
lines changed

2 files changed

+18
-166
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.6.5"
13+
postgres = "0.7"

‎src/lib.rs‎

Lines changed: 17 additions & 165 deletions
Original file line numberDiff line numberDiff line change
@@ -6,32 +6,31 @@
66
//! extern crate postgres;
77
//! extern crate postgres_large_object;
88
//!
9-
//! use std::old_path::Path;
10-
//! use std::old_io::fs::File;
11-
//! use std::old_io::util;
9+
//! use std::fs::File;
10+
//! use std::io;
1211
//!
1312
//! use postgres::{Connection, SslMode};
1413
//! use postgres_large_object::{LargeObjectExt, LargeObjectTransactionExt, Mode};
1514
//!
1615
//! fn main() {
1716
//! let conn = Connection::connect("postgres://postgres@localhost", &SslMode::None).unwrap();
1817
//!
19-
//! let mut file = File::open(&Path::new("vacation_photos.tar.gz")).unwrap();
18+
//! let mut file = File::open("vacation_photos.tar.gz").unwrap();
2019
//! let trans = conn.transaction().unwrap();
2120
//! let oid = trans.create_large_object().unwrap();
2221
//! {
2322
//! let mut large_object = trans.open_large_object(oid, Mode::Write).unwrap();
24-
//! util::copy(&mut file, &mut large_object).unwrap();
23+
//! io::copy(&mut file, &mut large_object).unwrap();
2524
//! }
2625
//! trans.commit().unwrap();
2726
//!
28-
//! let mut file = File::create(&Path::new("vacation_photos_copy.tar.gz")).unwrap();
27+
//! let mut file = File::create("vacation_photos_copy.tar.gz").unwrap();
2928
//! let trans = conn.transaction().unwrap();
3029
//! let mut large_object = trans.open_large_object(oid, Mode::Read).unwrap();
31-
//! util::copy(&mut large_object, &mut file).unwrap();
30+
//! io::copy(&mut large_object, &mut file).unwrap();
3231
//! }
3332
//! ```
34-
#![feature(unsafe_destructor, io, old_io, core)]
33+
#![feature(unsafe_destructor, io, core)]
3534
#![doc(html_root_url="https://sfackler.github.io/rust-postgres-large-object/doc")]
3635

3736
extern crate postgres;
@@ -40,7 +39,6 @@ use std::cmp;
4039
use std::fmt;
4140
use std::i32;
4241
use std::num::FromPrimitive;
43-
use std::old_io::{self, IoResult, IoError, IoErrorKind, SeekStyle};
4442
use std::io;
4543
use std::slice::bytes;
4644

@@ -58,7 +56,7 @@ pub trait LargeObjectExt: GenericConnection {
5856
impl<T: GenericConnection> LargeObjectExt for T {
5957
fn create_large_object(&self) -> Result<Oid> {
6058
let stmt = try!(self.prepare_cached("SELECT pg_catalog.lo_create(0)"));
61-
stmt.query(&[]).map(|mut r| r.next().unwrap().get(0))
59+
stmt.query(&[]).map(|r| r.iter().next().unwrap().get(0))
6260
}
6361

6462
fn delete_large_object(&self, oid: Oid) -> Result<()> {
@@ -106,7 +104,7 @@ impl<'conn> LargeObjectTransactionExt for Transaction<'conn> {
106104
let has_64 = major > 9 || (major == 9 && minor >= 3);
107105

108106
let stmt = try!(self.prepare_cached("SELECT pg_catalog.lo_open($1, $2)"));
109-
let fd = try!(stmt.query(&[&oid, &mode.to_i32()])).next().unwrap().get(0);
107+
let fd = try!(stmt.query(&[&oid, &mode.to_i32()])).iter().next().unwrap().get(0);
110108
Ok(LargeObject {
111109
trans: self,
112110
fd: fd,
@@ -116,19 +114,6 @@ impl<'conn> LargeObjectTransactionExt for Transaction<'conn> {
116114
}
117115
}
118116

119-
macro_rules! try_old_io {
120-
($e:expr) => {
121-
match $e {
122-
Ok(ok) => ok,
123-
Err(e) => return Err(IoError {
124-
kind: IoErrorKind::OtherIoError,
125-
desc: "error communicating with server",
126-
detail: Some(format!("{}", e)),
127-
})
128-
}
129-
}
130-
}
131-
132117
macro_rules! try_io {
133118
($e:expr) => {
134119
match $e {
@@ -173,11 +158,11 @@ impl<'a> LargeObject<'a> {
173158
} else {
174159
let len: i32 = match FromPrimitive::from_i64(len) {
175160
Some(len) => len,
176-
None => return Err(Error::IoError(IoError {
177-
kind: IoErrorKind::InvalidInput,
178-
desc: "The database does not support objects larger than 2GB",
179-
detail: None,
180-
})),
161+
None => return Err(Error::IoError(io::Error::new(
162+
io::ErrorKind::InvalidInput,
163+
"The database does not support objects larger than 2GB",
164+
None,
165+
))),
181166
};
182167
let stmt = try!(self.trans.prepare_cached("SELECT pg_catalog.lo_truncate($1, $2)"));
183168
stmt.execute(&[&self.fd, &len]).map(|_| ())
@@ -203,48 +188,18 @@ impl<'a> LargeObject<'a> {
203188
}
204189
}
205190

206-
impl<'a> Reader for LargeObject<'a> {
207-
fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
208-
let stmt = try_old_io!(self.trans.prepare_cached("SELECT pg_catalog.loread($1, $2)"));
209-
let cap = cmp::min(buf.len(), i32::MAX as usize) as i32;
210-
let row = try_old_io!(stmt.query(&[&self.fd, &cap])).next().unwrap();
211-
let out = row.get_bytes(0).unwrap();
212-
213-
if !buf.is_empty() && out.is_empty() {
214-
return Err(old_io::standard_error(IoErrorKind::EndOfFile));
215-
}
216-
217-
bytes::copy_memory(buf, &out);
218-
Ok(out.len())
219-
}
220-
}
221-
222191
impl<'a> io::Read for LargeObject<'a> {
223192
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
224193
let stmt = try_io!(self.trans.prepare_cached("SELECT pg_catalog.loread($1, $2)"));
225194
let cap = cmp::min(buf.len(), i32::MAX as usize) as i32;
226-
let row = try_io!(stmt.query(&[&self.fd, &cap])).next().unwrap();
195+
let row = try_io!(stmt.query(&[&self.fd, &cap])).into_iter().next().unwrap();
227196
let out = row.get_bytes(0).unwrap();
228197

229198
bytes::copy_memory(buf, &out);
230199
Ok(out.len())
231200
}
232201
}
233202

234-
impl<'a> Writer for LargeObject<'a> {
235-
fn write_all(&mut self, mut buf: &[u8]) -> IoResult<()> {
236-
let stmt = try_old_io!(self.trans.prepare_cached("SELECT pg_catalog.lowrite($1, $2)"));
237-
238-
while !buf.is_empty() {
239-
let cap = cmp::min(buf.len(), i32::MAX as usize);
240-
try_old_io!(stmt.execute(&[&self.fd, &&buf[..cap]]));
241-
buf = &buf[cap..];
242-
}
243-
244-
Ok(())
245-
}
246-
}
247-
248203
impl<'a> io::Write for LargeObject<'a> {
249204
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
250205
let stmt = try_io!(self.trans.prepare_cached("SELECT pg_catalog.lowrite($1, $2)"));
@@ -258,44 +213,6 @@ impl<'a> io::Write for LargeObject<'a> {
258213
}
259214
}
260215

261-
impl<'a> Seek for LargeObject<'a> {
262-
fn tell(&self) -> IoResult<u64> {
263-
if self.has_64 {
264-
let stmt = try_old_io!(self.trans.prepare_cached("SELECT pg_catalog.lo_tell64($1)"));
265-
Ok(try_old_io!(stmt.query(&[&self.fd])).next().unwrap().get::<_, i64>(0) as u64)
266-
} else {
267-
let stmt = try_old_io!(self.trans.prepare_cached("SELECT pg_catalog.lo_tell($1)"));
268-
Ok(try_old_io!(stmt.query(&[&self.fd])).next().unwrap().get::<_, i32>(0) as u64)
269-
}
270-
}
271-
272-
fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
273-
let kind = match style {
274-
SeekStyle::SeekSet => 0,
275-
SeekStyle::SeekCur => 1,
276-
SeekStyle::SeekEnd => 2,
277-
};
278-
279-
if self.has_64 {
280-
let stmt = try_old_io!(self.trans.prepare_cached("SELECT pg_catalog.lo_lseek64($1, $2, $3)"));
281-
try_old_io!(stmt.execute(&[&self.fd, &pos, &kind]));
282-
} else {
283-
let pos: i32 = match FromPrimitive::from_i64(pos) {
284-
Some(pos) => pos,
285-
None => return Err(IoError {
286-
kind: IoErrorKind::InvalidInput,
287-
desc: "The database does not support seeks larger than 2GB",
288-
detail: None,
289-
}),
290-
};
291-
let stmt = try_old_io!(self.trans.prepare_cached("SELECT pg_catalog.lo_lseek($1, $2, $3)"));
292-
try_old_io!(stmt.execute(&[&self.fd, &pos, &kind]));
293-
}
294-
295-
Ok(())
296-
}
297-
}
298-
299216
impl<'a> io::Seek for LargeObject<'a> {
300217
fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
301218
let (kind, pos) = match pos {
@@ -314,7 +231,7 @@ impl<'a> io::Seek for LargeObject<'a> {
314231

315232
if self.has_64 {
316233
let stmt = try_io!(self.trans.prepare_cached("SELECT pg_catalog.lo_lseek64($1, $2, $3)"));
317-
Ok(try_io!(stmt.query(&[&self.fd, &pos, &kind])).next().unwrap().get::<_, i64>(0) as u64)
234+
Ok(try_io!(stmt.query(&[&self.fd, &pos, &kind])).iter().next().unwrap().get::<_, i64>(0) as u64)
318235
} else {
319236
let pos: i32 = match FromPrimitive::from_i64(pos) {
320237
Some(pos) => pos,
@@ -323,7 +240,7 @@ impl<'a> io::Seek for LargeObject<'a> {
323240
None)),
324241
};
325242
let stmt = try_io!(self.trans.prepare_cached("SELECT pg_catalog.lo_lseek($1, $2, $3)"));
326-
Ok(try_io!(stmt.query(&[&self.fd, &pos, &kind])).next().unwrap().get::<_, i32>(0) as u64)
243+
Ok(try_io!(stmt.query(&[&self.fd, &pos, &kind])).iter().next().unwrap().get::<_, i32>(0) as u64)
327244
}
328245
}
329246
}
@@ -373,19 +290,6 @@ mod test {
373290
lo.finish().unwrap();
374291
}
375292

376-
#[test]
377-
fn test_write_read_old_io() {
378-
use std::old_io::{Writer, Reader};
379-
380-
let conn = Connection::connect("postgres://postgres@localhost", &SslMode::None).unwrap();
381-
let trans = conn.transaction().unwrap();
382-
let oid = trans.create_large_object().unwrap();
383-
let mut lo = trans.open_large_object(oid, Mode::Write).unwrap();
384-
lo.write_all(b"hello world!!!").unwrap();
385-
let mut lo = trans.open_large_object(oid, Mode::Read).unwrap();
386-
assert_eq!(b"hello world!!!", lo.read_to_end().unwrap());
387-
}
388-
389293
#[test]
390294
fn test_write_read() {
391295
use std::io::{Write, Read};
@@ -401,29 +305,6 @@ mod test {
401305
assert_eq!(b"hello world!!!", out);
402306
}
403307

404-
#[test]
405-
fn test_seek_tell_old_io() {
406-
use std::old_io::{Writer, Reader, Seek, SeekStyle};
407-
408-
let conn = Connection::connect("postgres://postgres@localhost", &SslMode::None).unwrap();
409-
let trans = conn.transaction().unwrap();
410-
let oid = trans.create_large_object().unwrap();
411-
let mut lo = trans.open_large_object(oid, Mode::Write).unwrap();
412-
lo.write_all(b"hello world!!!").unwrap();
413-
414-
assert_eq!(14, lo.tell().unwrap());
415-
lo.seek(1, SeekStyle::SeekSet).unwrap();
416-
assert_eq!(1, lo.tell().unwrap());
417-
assert_eq!(b'e', lo.read_u8().unwrap());
418-
assert_eq!(2, lo.tell().unwrap());
419-
lo.seek(-4, SeekStyle::SeekEnd).unwrap();
420-
assert_eq!(10, lo.tell().unwrap());
421-
assert_eq!(b'd', lo.read_u8().unwrap());
422-
lo.seek(-3, SeekStyle::SeekCur).unwrap();
423-
assert_eq!(8, lo.tell().unwrap());
424-
assert_eq!(b'r', lo.read_u8().unwrap());
425-
}
426-
427308
#[test]
428309
fn test_seek_tell() {
429310
use std::io::{Write, Read, Seek, SeekFrom};
@@ -448,17 +329,6 @@ mod test {
448329
assert_eq!(b'r', buf[0]);
449330
}
450331

451-
#[test]
452-
fn test_write_with_read_fd_old_io() {
453-
use std::old_io::Writer;
454-
455-
let conn = Connection::connect("postgres://postgres@localhost", &SslMode::None).unwrap();
456-
let trans = conn.transaction().unwrap();
457-
let oid = trans.create_large_object().unwrap();
458-
let mut lo = trans.open_large_object(oid, Mode::Read).unwrap();
459-
assert!(lo.write_all(b"hello world!!!").is_err());
460-
}
461-
462332
#[test]
463333
fn test_write_with_read_fd() {
464334
use std::io::Write;
@@ -470,24 +340,6 @@ mod test {
470340
assert!(lo.write_all(b"hello world!!!").is_err());
471341
}
472342

473-
#[test]
474-
fn test_truncate_old_io() {
475-
use std::old_io::{Seek, SeekStyle, Writer, Reader};
476-
477-
let conn = Connection::connect("postgres://postgres@localhost", &SslMode::None).unwrap();
478-
let trans = conn.transaction().unwrap();
479-
let oid = trans.create_large_object().unwrap();
480-
let mut lo = trans.open_large_object(oid, Mode::Write).unwrap();
481-
lo.write_all(b"hello world!!!").unwrap();
482-
483-
lo.truncate(5).unwrap();
484-
lo.seek(0, SeekStyle::SeekSet).unwrap();
485-
assert_eq!(b"hello", lo.read_to_end().unwrap());
486-
lo.truncate(10).unwrap();
487-
lo.seek(0, SeekStyle::SeekSet).unwrap();
488-
assert_eq!(b"hello\0\0\0\0\0", lo.read_to_end().unwrap());
489-
}
490-
491343
#[test]
492344
fn test_truncate() {
493345
use std::io::{Seek, SeekFrom, Write, Read};

0 commit comments

Comments
 (0)