diff --git a/postgres/src/test.rs b/postgres/src/test.rs
index edf467bbf..61f6cc818 100644
--- a/postgres/src/test.rs
+++ b/postgres/src/test.rs
@@ -24,15 +24,67 @@ fn get_connection_string() -> String {
     )
 }
 
+#[test]
+fn full_crud() {
+    let mut client = Client::connect(&get_connection_string(), NoTls).unwrap();
+
+    client
+        .batch_execute(
+            "CREATE TEMPORARY TABLE foo(
+                id INT,
+                name TEXT,
+                price FLOAT,
+                isperson BOOL,
+                guid UUID,
+                num NUMERIC
+            )",
+        )
+        .unwrap();
+
+    let mut transaction = client.transaction().unwrap();
+    transaction
+        .batch_execute("INSERT INTO foo (id, name, price, isperson, guid, num) VALUES (1, 'steven', 2.0, true, '123e4567-e89b-12d3-a456-426655440000', 42)")
+        .unwrap();
+    transaction.commit().unwrap();
+
+    let stmt = client.prepare("SELECT name FROM foo").unwrap();
+    let rows = client.query(&stmt, &[]).unwrap();
+
+    assert_eq!(rows.len(), 1);
+    assert_eq!(rows[0].get::<_, &str>(0), "steven");
+
+    let mut transaction = client.transaction().unwrap();
+    transaction
+        .execute("UPDATE foo SET name = 'john' WHERE id = 1", &[])
+        .unwrap();
+    transaction.commit().unwrap();
+
+    let stmt = client.prepare("SELECT name FROM foo").unwrap();
+    let rows = client.query(&stmt, &[]).unwrap();
+
+    assert_eq!(rows.len(), 1);
+    assert_eq!(rows[0].get::<_, &str>(0), "john");
+
+    let mut transaction = client.transaction().unwrap();
+    transaction
+        .execute("DELETE FROM foo WHERE id = 1", &[])
+        .unwrap();
+    transaction.commit().unwrap();
+
+    let stmt = client.prepare("SELECT name FROM foo").unwrap();
+    let rows = client.query(&stmt, &[]).unwrap();
+    assert_eq!(rows.len(), 0);
+}
+
 #[test]
 fn prepare() {
     let mut client = Client::connect(&get_connection_string(), NoTls).unwrap();
 
     let stmt = client.prepare("SELECT 1::INT, $1::TEXT").unwrap();
-    assert_eq!(stmt.params(), &[Type::TEXT]);
+    assert_eq!(stmt.params(), &[Type::VARCHAR]);
     assert_eq!(stmt.columns().len(), 2);
-    assert_eq!(stmt.columns()[0].type_(), &Type::INT4);
-    assert_eq!(stmt.columns()[1].type_(), &Type::TEXT);
+    assert_eq!(stmt.columns()[0].type_(), &Type::INT8);
+    assert_eq!(stmt.columns()[1].type_(), &Type::VARCHAR);
 }
 
 #[test]
@@ -49,7 +101,7 @@ fn query_prepared() {
 fn query_unprepared() {
     let mut client = Client::connect(&get_connection_string(), NoTls).unwrap();
 
-    let rows = client.query("SELECT $1::TEXT", &[&"hello"]).unwrap();
+    let rows = client.query("SELECT 'hello'", &[]).unwrap();
     assert_eq!(rows.len(), 1);
     assert_eq!(rows[0].get::<_, &str>(0), "hello");
 }
@@ -59,20 +111,20 @@ fn transaction_commit() {
     let mut client = Client::connect(&get_connection_string(), NoTls).unwrap();
 
     client
-        .simple_query("CREATE TEMPORARY TABLE foo (id SERIAL PRIMARY KEY)")
+        .simple_query("CREATE TEMPORARY TABLE foo (id INT)")
         .unwrap();
 
     let mut transaction = client.transaction().unwrap();
 
     transaction
-        .execute("INSERT INTO foo DEFAULT VALUES", &[])
+        .execute("INSERT INTO foo (id) VALUES (1)", &[])
         .unwrap();
 
     transaction.commit().unwrap();
 
     let rows = client.query("SELECT * FROM foo", &[]).unwrap();
     assert_eq!(rows.len(), 1);
-    assert_eq!(rows[0].get::<_, i32>(0), 1);
+    assert_eq!(rows[0].get::<_, i64>(0), 1);
 }
 
 #[test]
@@ -80,13 +132,13 @@ fn transaction_rollback() {
     let mut client = Client::connect(&get_connection_string(), NoTls).unwrap();
 
     client
-        .simple_query("CREATE TEMPORARY TABLE foo (id SERIAL PRIMARY KEY)")
+        .simple_query("CREATE TEMPORARY TABLE foo (id INT)")
         .unwrap();
 
     let mut transaction = client.transaction().unwrap();
 
     transaction
-        .execute("INSERT INTO foo DEFAULT VALUES", &[])
+        .execute("INSERT INTO foo (id) VALUES (2)", &[])
         .unwrap();
 
     transaction.rollback().unwrap();
@@ -100,7 +152,7 @@ fn transaction_drop() {
     let mut client = Client::connect(&get_connection_string(), NoTls).unwrap();
 
     client
-        .simple_query("CREATE TEMPORARY TABLE foo (id SERIAL PRIMARY KEY)")
+        .simple_query("CREATE TEMPORARY TABLE foo (id INT)")
         .unwrap();
 
     let mut transaction = client.transaction().unwrap();
@@ -116,6 +168,7 @@ fn transaction_drop() {
 }
 
 #[test]
+#[ignore]
 fn transaction_drop_immediate_rollback() {
     let mut client = Client::connect(&get_connection_string(), NoTls).unwrap();
     let mut client2 = Client::connect(&get_connection_string(), NoTls).unwrap();
@@ -166,7 +219,7 @@ fn nested_transactions() {
         .query("SELECT id FROM foo ORDER BY id", &[])
         .unwrap();
     assert_eq!(rows.len(), 1);
-    assert_eq!(rows[0].get::<_, i32>(0), 1);
+    assert_eq!(rows[0].get::<_, i64>(0), 1);
 
     let mut transaction3 = transaction.transaction().unwrap();
 
@@ -186,9 +239,9 @@ fn nested_transactions() {
 
     let rows = client.query("SELECT id FROM foo ORDER BY id", &[]).unwrap();
     assert_eq!(rows.len(), 3);
-    assert_eq!(rows[0].get::<_, i32>(0), 1);
-    assert_eq!(rows[1].get::<_, i32>(0), 3);
-    assert_eq!(rows[2].get::<_, i32>(0), 4);
+    assert_eq!(rows[0].get::<_, i64>(0), 1);
+    assert_eq!(rows[1].get::<_, i64>(0), 3);
+    assert_eq!(rows[2].get::<_, i64>(0), 4);
 }
 
 #[test]
@@ -217,7 +270,7 @@ fn savepoints() {
         .query("SELECT id FROM foo ORDER BY id", &[])
         .unwrap();
     assert_eq!(rows.len(), 1);
-    assert_eq!(rows[0].get::<_, i32>(0), 1);
+    assert_eq!(rows[0].get::<_, i64>(0), 1);
 
     let mut savepoint2 = transaction.savepoint("savepoint2").unwrap();
 
@@ -237,9 +290,9 @@ fn savepoints() {
 
     let rows = client.query("SELECT id FROM foo ORDER BY id", &[]).unwrap();
     assert_eq!(rows.len(), 3);
-    assert_eq!(rows[0].get::<_, i32>(0), 1);
-    assert_eq!(rows[1].get::<_, i32>(0), 3);
-    assert_eq!(rows[2].get::<_, i32>(0), 4);
+    assert_eq!(rows[0].get::<_, i64>(0), 1);
+    assert_eq!(rows[1].get::<_, i64>(0), 3);
+    assert_eq!(rows[2].get::<_, i64>(0), 4);
 }
 
 #[test]
@@ -247,11 +300,11 @@ fn copy_in() {
     let mut client = Client::connect(&get_connection_string(), NoTls).unwrap();
 
     client
-        .simple_query("CREATE TEMPORARY TABLE foo (id INT, name TEXT)")
+        .simple_query("CREATE TEMPORARY TABLE foo (id INT, name VARCHAR)")
         .unwrap();
 
     let mut writer = client.copy_in("COPY foo FROM stdin").unwrap();
-    writer.write_all(b"1\tsteven\n2\ttimothy").unwrap();
+    writer.write_all(b"1|steven\n2|timothy").unwrap();
     writer.finish().unwrap();
 
     let rows = client
@@ -259,9 +312,9 @@ fn copy_in() {
         .unwrap();
 
     assert_eq!(rows.len(), 2);
-    assert_eq!(rows[0].get::<_, i32>(0), 1);
+    assert_eq!(rows[0].get::<_, i64>(0), 1);
     assert_eq!(rows[0].get::<_, &str>(1), "steven");
-    assert_eq!(rows[1].get::<_, i32>(0), 2);
+    assert_eq!(rows[1].get::<_, i64>(0), 2);
     assert_eq!(rows[1].get::<_, &str>(1), "timothy");
 }
 
@@ -270,11 +323,11 @@ fn copy_in_abort() {
     let mut client = Client::connect(&get_connection_string(), NoTls).unwrap();
 
     client
-        .simple_query("CREATE TEMPORARY TABLE foo (id INT, name TEXT)")
+        .simple_query("CREATE TEMPORARY TABLE foo (id INT, name VARCHAR)")
         .unwrap();
 
     let mut writer = client.copy_in("COPY foo FROM stdin").unwrap();
-    writer.write_all(b"1\tsteven\n2\ttimothy").unwrap();
+    writer.write_all(b"1|steven\n2|timothy").unwrap();
     drop(writer);
 
     let rows = client
@@ -285,15 +338,16 @@ fn copy_in_abort() {
 }
 
 #[test]
+#[ignore]
 fn binary_copy_in() {
     let mut client = Client::connect(&get_connection_string(), NoTls).unwrap();
 
     client
-        .simple_query("CREATE TEMPORARY TABLE foo (id INT, name TEXT)")
+        .simple_query("CREATE TEMPORARY TABLE foo (id INT, name VARCHAR)")
         .unwrap();
 
     let writer = client.copy_in("COPY foo FROM stdin BINARY").unwrap();
-    let mut writer = BinaryCopyInWriter::new(writer, &[Type::INT4, Type::TEXT]);
+    let mut writer = BinaryCopyInWriter::new(writer, &[Type::INT4, Type::VARCHAR]);
     writer.write(&[&1i32, &"steven"]).unwrap();
     writer.write(&[&2i32, &"timothy"]).unwrap();
     writer.finish().unwrap();
@@ -310,6 +364,7 @@ fn binary_copy_in() {
 }
 
 #[test]
+#[ignore]
 fn copy_out() {
     let mut client = Client::connect(&get_connection_string(), NoTls).unwrap();
 
@@ -331,6 +386,7 @@ fn copy_out() {
 }
 
 #[test]
+#[ignore]
 fn binary_copy_out() {
     let mut client = Client::connect(&get_connection_string(), NoTls).unwrap();
 
@@ -363,7 +419,9 @@ fn portal() {
     client
         .simple_query(
             "CREATE TEMPORARY TABLE foo (id INT);
-             INSERT INTO foo (id) VALUES (1), (2), (3);",
+             INSERT INTO foo (id) VALUES (1); 
+             INSERT INTO foo (id) VALUES (2);
+             INSERT INTO foo (id) VALUES (3);",
         )
         .unwrap();
 
@@ -373,14 +431,16 @@ fn portal() {
         .bind("SELECT * FROM foo ORDER BY id", &[])
         .unwrap();
 
-    let rows = transaction.query_portal(&portal, 2).unwrap();
-    assert_eq!(rows.len(), 2);
-    assert_eq!(rows[0].get::<_, i32>(0), 1);
-    assert_eq!(rows[1].get::<_, i32>(0), 2);
+    let rows = transaction.query_portal(&portal, 3).unwrap();
+    assert_eq!(rows.len(), 3);
+    assert_eq!(rows[0].get::<_, i64>(0), 1);
+    assert_eq!(rows[1].get::<_, i64>(0), 2);
+    assert_eq!(rows[2].get::<_, i64>(0), 3);
 
+    // Vertica gets all rows, not just two for the query
     let rows = transaction.query_portal(&portal, 2).unwrap();
-    assert_eq!(rows.len(), 1);
-    assert_eq!(rows[0].get::<_, i32>(0), 3);
+    assert_eq!(rows.len(), 3);
+    assert_eq!(rows[0].get::<_, i64>(0), 1);
 }
 
 #[test]
@@ -402,6 +462,7 @@ fn cancel_query() {
 }
 
 #[test]
+#[ignore]
 fn notifications_iter() {
     let mut client = Client::connect(&get_connection_string(), NoTls).unwrap();
 
@@ -422,6 +483,7 @@ fn notifications_iter() {
 }
 
 #[test]
+#[ignore]
 fn notifications_blocking_iter() {
     let mut client = Client::connect(&get_connection_string(), NoTls).unwrap();
 
@@ -455,6 +517,7 @@ fn notifications_blocking_iter() {
 }
 
 #[test]
+#[ignore]
 fn notifications_timeout_iter() {
     let mut client = Client::connect(&get_connection_string(), NoTls).unwrap();