diff --git a/tests/ts_cluster_comprehensive.erl b/tests/ts_cluster_comprehensive.erl
index 08414eaec..3aebf59dd 100644
--- a/tests/ts_cluster_comprehensive.erl
+++ b/tests/ts_cluster_comprehensive.erl
@@ -185,10 +185,10 @@ confirm_select(C, PvalP1, PvalP2, Options) ->
             ?PKEY_P2, PvalP2,
             ?PKEY_P3, ?TIMEBASE + 10, ?PKEY_P3, ?TIMEBASE + 20])),
     io:format("Running query: ~p\n", [Query]),
-    {_Columns, Rows} = riakc_ts:query(C, Query, Options),
+    {ok, {_Columns, Rows}} = riakc_ts:query(C, Query, Options),
     io:format("Got ~b rows back\n~p\n", [length(Rows), Rows]),
     ?assertEqual(10 - 1 - 1, length(Rows)),
-    {_Columns, Rows} = riakc_ts:query(C, Query, Options),
+    {ok, {_Columns, Rows}} = riakc_ts:query(C, Query, Options),
     io:format("Got ~b rows back again\n", [length(Rows)]),
     ?assertEqual(10 - 1 - 1, length(Rows)),
     ok.
diff --git a/tests/ts_cluster_coverage.erl b/tests/ts_cluster_coverage.erl
index 68200ef0b..5b5972e76 100644
--- a/tests/ts_cluster_coverage.erl
+++ b/tests/ts_cluster_coverage.erl
@@ -58,7 +58,7 @@ test_quanta_range(Table, ExpectedData, Nodes, NumQuanta, QuantumMS) ->
                                          range=TsRange}, Acc) ->
                             {ok, Pid} = riakc_pb_socket:start_link(binary_to_list(IP),
                                                                    Port),
-                            {_, ThisQuantum} = riakc_ts:query(Pid, Qry, [], C),
+                            {ok, {_, ThisQuantum}} = riakc_ts:query(Pid, Qry, [], C),
                             riakc_pb_socket:stop(Pid),
 
                             %% Open a connection to another node and
@@ -66,7 +66,7 @@ test_quanta_range(Table, ExpectedData, Nodes, NumQuanta, QuantumMS) ->
                             %% this cover context
                             {ok, WrongPid} = riakc_pb_socket:start_link(binary_to_list(IP),
                                                                         alternate_port(Port)),
-                            ?assertEqual({[], []},
+                            ?assertEqual({ok, {[], []}},
                                          riakc_ts:query(WrongPid, Qry, [], C)),
                             riakc_pb_socket:stop(WrongPid),
 
@@ -86,7 +86,7 @@ test_quanta_range(Table, ExpectedData, Nodes, NumQuanta, QuantumMS) ->
         true ->
             ?assertMatch({error, {1001, _}}, riakc_ts:query(OtherPid, Qry));
         false ->
-            {_, StraightQueryResults} = riakc_ts:query(OtherPid, Qry),
+            {ok, {_, StraightQueryResults}} = riakc_ts:query(OtherPid, Qry),
             ?assertEqual(lists:sort(ExpectedData), lists:sort(StraightQueryResults))
     end.
 
diff --git a/tests/ts_cluster_create_table_via_sql_SUITE.erl b/tests/ts_cluster_create_table_via_sql_SUITE.erl
index ed8cce698..dda498da8 100644
--- a/tests/ts_cluster_create_table_via_sql_SUITE.erl
+++ b/tests/ts_cluster_create_table_via_sql_SUITE.erl
@@ -70,7 +70,7 @@ create_test(Ctx) ->
            enquote_varchar(?PROP_NO_QUOTES),
            enquote_varchar(?PROP_WITH_QUOTES)]),
     Got1 = riakc_ts:query(C, GoodDDL),
-    ?assertEqual({[],[]}, Got1),
+    ?assertEqual({ok, {[],[]}}, Got1),
     pass.
 
 re_create_fail_test(Ctx) ->
@@ -127,12 +127,12 @@ ddl_common() ->
     ts_util:get_ddl(small).
 
 table_described() ->
-    {[<<"Column">>,<<"Type">>,<<"Is Null">>,<<"Primary Key">>, <<"Local Key">>],
+    {ok, {[<<"Column">>,<<"Type">>,<<"Is Null">>,<<"Primary Key">>, <<"Local Key">>],
      [{<<"myfamily">>,   <<"varchar">>,   false,  1,  1},
       {<<"myseries">>,   <<"varchar">>,   false,  2,  2},
       {<<"time">>,       <<"timestamp">>, false,  3,  3},
       {<<"weather">>,    <<"varchar">>,   false, [], []},
-      {<<"temperature">>,<<"double">>,    true,  [], []}]}.
+      {<<"temperature">>,<<"double">>,    true,  [], []}]}}.
 
 enquote_varchar(P) when is_binary(P) ->
     re:replace(P, "'", "''", [global, {return, binary}]);
diff --git a/tests/ts_cluster_keys_SUITE.erl b/tests/ts_cluster_keys_SUITE.erl
index ca56c8990..5f88f93a5 100644
--- a/tests/ts_cluster_keys_SUITE.erl
+++ b/tests/ts_cluster_keys_SUITE.erl
@@ -83,7 +83,7 @@ run_query(Ctx, Query) ->
 %%%
 
 create_data_def_1(Pid) ->
-    ts_util:assert_row_sets({[],[]},riakc_ts:query(Pid, table_def_1())),
+    ts_util:assert_row_sets({ok, {[],[]}},riakc_ts:query(Pid, table_def_1())),
     ok = riakc_ts:put(Pid, <<"table1">>, [{1,1,N,1} || N <- lists:seq(1,6000)]).
 
 column_names_def_1() ->
@@ -103,7 +103,7 @@ select_exclusive_def_1_test(Ctx) ->
     Results =
          [{1,1,N,1} || N <- lists:seq(1,10)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         run_query(Ctx, Query)
     ).
 
@@ -113,7 +113,7 @@ select_exclusive_def_1_2_test(Ctx) ->
     Results =
          [{1,1,N,1} || N <- lists:seq(45,53)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         run_query(Ctx, Query)
     ).
 
@@ -123,7 +123,7 @@ select_exclusive_def_1_across_quanta_1_test(Ctx) ->
     Results =
          [{1,1,N,1} || N <- lists:seq(501,1499)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         run_query(Ctx, Query)
     ).
 
@@ -134,7 +134,7 @@ select_exclusive_def_1_across_quanta_2_test(Ctx) ->
     Results =
          [{1,1,N,1} || N <- lists:seq(501,4499)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         run_query(Ctx, Query)
     ).
 
@@ -144,7 +144,7 @@ select_inclusive_def_1_test(Ctx) ->
     Results =
          [{1,1,N,1} || N <- lists:seq(11,20)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         run_query(Ctx, Query)
     ).
 
@@ -180,7 +180,7 @@ where_clause_must_cover_the_partition_key_missing_c_test(Ctx) ->
 %%%
 
 create_data_def_2(Pid) ->
-    ts_util:assert_row_sets({[],[]}, riakc_ts:query(Pid, table_def_2())),
+    ts_util:assert_row_sets({ok, {[],[]}}, riakc_ts:query(Pid, table_def_2())),
     ok = riakc_ts:put(Pid, <<"table2">>, [{N,1,1,1} || N <- lists:seq(1,200)]).
 
 table_def_2() ->
@@ -197,7 +197,7 @@ select_exclusive_def_2_test(Ctx) ->
     Results =
          [{N,1,1,1} || N <- lists:seq(1,10)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         run_query(Ctx, Query)
     ).
 
@@ -207,7 +207,7 @@ select_inclusive_def_2_test(Ctx) ->
     Results =
          [{N,1,1,1} || N <- lists:seq(11,20)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         run_query(Ctx, Query)
     ).
 
@@ -216,7 +216,7 @@ select_inclusive_def_2_test(Ctx) ->
 %%%
 
 create_data_def_3(Pid) ->
-    ts_util:assert_row_sets({[],[]}, riakc_ts:query(Pid, table_def_3())),
+    ts_util:assert_row_sets({ok, {[],[]}}, riakc_ts:query(Pid, table_def_3())),
     ok = riakc_ts:put(Pid, <<"table3">>, [{1,N} || N <- lists:seq(1,200)]).
 
 column_names_def_3() ->
@@ -234,7 +234,7 @@ select_exclusive_def_3_test(Ctx) ->
     Results =
          [{1,N} || N <- lists:seq(1,10)],
     ts_util:assert_row_sets(
-        {column_names_def_3(), Results},
+        {ok, {column_names_def_3(), Results}},
         run_query(Ctx, Query)
     ).
 
@@ -244,7 +244,7 @@ select_inclusive_def_3_test(Ctx) ->
     Results =
          [{1,N} || N <- lists:seq(11,20)],
     ts_util:assert_row_sets(
-        {column_names_def_3(), Results},
+        {ok, {column_names_def_3(), Results}},
         run_query(Ctx, Query)
     ).
 
@@ -254,7 +254,7 @@ select_inclusive_def_3_test(Ctx) ->
 %%%
 
 create_data_def_4(Pid) ->
-    ts_util:assert_row_sets({[],[]}, riakc_ts:query(Pid, table_def_4())),
+    ts_util:assert_row_sets({ok, {[],[]}}, riakc_ts:query(Pid, table_def_4())),
     ok = riakc_ts:put(Pid, <<"table4">>, [{1,1,N} || N <- lists:seq(1,200)]).
 
 column_names_def_4() ->
@@ -273,7 +273,7 @@ select_exclusive_def_4_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(1,10)],
     ts_util:assert_row_sets(
-        {column_names_def_4(), Results},
+        {ok, {column_names_def_4(), Results}},
         run_query(Ctx, Query)
     ).
 
@@ -283,7 +283,7 @@ select_inclusive_def_4_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(11,20)],
     ts_util:assert_row_sets(
-        {column_names_def_4(), Results},
+        {ok, {column_names_def_4(), Results}},
         run_query(Ctx, Query)
     ).
 
@@ -302,14 +302,14 @@ table_def_5() ->
     "PRIMARY KEY ((a,b,c),a,b,c))".
 
 create_data_def_5(Pid) ->
-    ts_util:assert_row_sets({[],[]}, riakc_ts:query(Pid, table_def_5())),
+    ts_util:assert_row_sets({ok, {[],[]}}, riakc_ts:query(Pid, table_def_5())),
     ok = riakc_ts:put(Pid, <<"table5">>, [{1,1,N} || N <- lists:seq(1,200)]).
 
 select_def_5_test(Ctx) ->
     Query =
         "SELECT * FROM table5 WHERE a = 1 AND b = 1 AND c = 20",
     ts_util:assert_row_sets(
-        {column_names_def_5(), [{1,1,20}]},
+        {ok, {column_names_def_5(), [{1,1,20}]}},
         run_query(Ctx, Query)
     ).
 
@@ -326,7 +326,7 @@ table_def_6() ->
     "PRIMARY KEY ((a,quantum(b,1,'s'),c),a,b,c,d))".
 
 create_data_def_6(Pid) ->
-    ts_util:assert_row_sets({[],[]}, riakc_ts:query(Pid, table_def_6())),
+    ts_util:assert_row_sets({ok, {[],[]}}, riakc_ts:query(Pid, table_def_6())),
     ok = riakc_ts:put(Pid, <<"table6">>, [{1,N,1,<<"table6">>} || N <- lists:seq(1,200)]).
 
 select_def_6_test(Ctx) ->
@@ -335,7 +335,7 @@ select_def_6_test(Ctx) ->
     Results =
          [{1,N,1,<<"table6">>} || N <- lists:seq(8,13)],
     ts_util:assert_row_sets(
-        {[<<"a">>, <<"b">>, <<"c">>,<<"d">>], Results},
+        {ok, {[<<"a">>, <<"b">>, <<"c">>,<<"d">>], Results}},
         run_query(Ctx, Query)
     ).
 
@@ -352,7 +352,7 @@ table_def_7() ->
     "PRIMARY KEY ((quantum(a,1,'s'),b,c),a,b,c,d))".
 
 create_data_def_7(Pid) ->
-    ts_util:assert_row_sets({[],[]}, riakc_ts:query(Pid, table_def_7())),
+    ts_util:assert_row_sets({ok, {[],[]}}, riakc_ts:query(Pid, table_def_7())),
     ok = riakc_ts:put(Pid, <<"table7">>, [{N,1,1,<<"table7">>} || N <- lists:seq(1,200)]).
 
 select_exclusive_def_7_test(Ctx) ->
@@ -361,7 +361,7 @@ select_exclusive_def_7_test(Ctx) ->
     Results =
          [{N,1,1,<<"table7">>} || N <- lists:seq(45,54)],
     ts_util:assert_row_sets(
-        {[<<"a">>, <<"b">>, <<"c">>, <<"d">>], Results},
+        {ok, {[<<"a">>, <<"b">>, <<"c">>, <<"d">>], Results}},
         run_query(Ctx, Query)
     ).
 
@@ -371,7 +371,7 @@ select_inclusive_def_7_test(Ctx) ->
     Results =
          [{N,1,1,<<"table7">>} || N <- lists:seq(44,54)],
     ts_util:assert_row_sets(
-        {[<<"a">>, <<"b">>, <<"c">>, <<"d">>], Results},
+        {ok, {[<<"a">>, <<"b">>, <<"c">>, <<"d">>], Results}},
         run_query(Ctx, Query)
     ).
 
@@ -381,7 +381,7 @@ select_inclusive_def_7_test(Ctx) ->
 
 create_data_def_8(Pid) ->
     ts_util:assert_row_sets(
-        {[],[]},
+        {ok, {[],[]}},
         riakc_ts:query(Pid,
             "CREATE TABLE table8 ("
             "a SINT64 NOT NULL, "
@@ -507,7 +507,7 @@ multiple_quantum_functions_in_partition_key_not_allowed(Ctx) ->
 
 double_pk_double_boolean_lk_test(Ctx) ->
     ?assertEqual(
-        {[],[]},
+        {ok, {[],[]}},
         riakc_ts:query(client_pid(Ctx),
             "CREATE TABLE double_pk_double_boolean_lk_test ("
             "a DOUBLE NOT NULL, "
@@ -527,7 +527,7 @@ double_pk_double_boolean_lk_test(Ctx) ->
 
 boolean_pk_boolean_double_lk_test(Ctx) ->
     ?assertEqual(
-        {[],[]},
+        {ok, {[],[]}},
         riakc_ts:query(client_pid(Ctx),
             "CREATE TABLE boolean_pk_boolean_double_lk_test ("
             "a BOOLEAN NOT NULL, "
@@ -547,7 +547,7 @@ boolean_pk_boolean_double_lk_test(Ctx) ->
 
 all_types_create_data(Pid) ->
     ?assertEqual(
-        {[],[]},
+        {ok, {[],[]}},
         riakc_ts:query(Pid,
             "CREATE TABLE all_types ("
             "a VARCHAR NOT NULL, "
@@ -627,7 +627,7 @@ all_types_or_filter_test(Ctx) ->
 
 all_booleans_create_data(Pid) ->
     ?assertEqual(
-        {[],[]},
+        {ok, {[],[]}},
         riakc_ts:query(Pid,
             "CREATE TABLE all_booleans ("
             "a BOOLEAN NOT NULL, "
@@ -689,7 +689,7 @@ all_booleans_filter_on_d_and_f_test(Ctx) ->
 
 all_timestamps_create_data(Pid) ->
     ?assertEqual(
-        {[],[]},
+        {ok, {[],[]}},
         riakc_ts:query(Pid,
             "CREATE TABLE all_timestamps ("
             "a TIMESTAMP NOT NULL, "
diff --git a/tests/ts_cluster_quantum_boundaries_SUITE.erl b/tests/ts_cluster_quantum_boundaries_SUITE.erl
index ee1e48555..1520a0dd8 100644
--- a/tests/ts_cluster_quantum_boundaries_SUITE.erl
+++ b/tests/ts_cluster_quantum_boundaries_SUITE.erl
@@ -64,7 +64,7 @@ all() ->
 %%%
 
 create_data_def_1(Pid) ->
-    ?assertEqual({[],[]}, riakc_ts:query(Pid, table_def_1())),
+    ?assertEqual({ok, {[],[]}}, riakc_ts:query(Pid, table_def_1())),
     ok = riakc_ts:put(Pid, <<"table1">>, [{1,1,N} || N <- lists:seq(1,10000)]).
 
 column_names_def_1() ->
@@ -91,7 +91,7 @@ start_key_query_greater_than_1999_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(2000,3800)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         riakc_ts:query(client_pid(Ctx), Query)
     ).
 
@@ -101,7 +101,7 @@ start_key_query_greater_than_2000_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(2001,3800)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         riakc_ts:query(client_pid(Ctx), Query)
     ).
 
@@ -111,7 +111,7 @@ start_key_query_greater_than_2001_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(2002,3800)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         riakc_ts:query(client_pid(Ctx), Query)
     ).
 
@@ -121,7 +121,7 @@ start_key_query_greater_or_equal_to_1999_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(1999,3800)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         riakc_ts:query(client_pid(Ctx), Query)
     ).
 
@@ -131,7 +131,7 @@ start_key_query_greater_or_equal_to_2000_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(2000,3800)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         riakc_ts:query(client_pid(Ctx), Query)
     ).
 
@@ -141,7 +141,7 @@ start_key_query_greater_or_equal_to_2001_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(2002,3800)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         riakc_ts:query(client_pid(Ctx), Query)
     ).
 
@@ -155,7 +155,7 @@ end_key_query_less_than_3999_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(2500,3998)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         riakc_ts:query(client_pid(Ctx), Query)
     ).
 
@@ -165,7 +165,7 @@ end_key_query_less_than_4000_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(2500,3999)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         riakc_ts:query(client_pid(Ctx), Query)
     ).
 
@@ -175,7 +175,7 @@ end_key_query_less_than_4001_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(2500,4000)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         riakc_ts:query(client_pid(Ctx), Query)
     ).
 
@@ -185,7 +185,7 @@ end_key_query_less_than_or_equal_to_3999_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(2500,3999)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         riakc_ts:query(client_pid(Ctx), Query)
     ).
 
@@ -195,7 +195,7 @@ end_key_query_less_than_or_equal_to_4000_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(2500,4000)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         riakc_ts:query(client_pid(Ctx), Query)
     ).
 
@@ -205,7 +205,7 @@ end_key_query_less_than_or_equal_to_4001_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(2500,4001)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         riakc_ts:query(client_pid(Ctx), Query)
     ).
 
@@ -215,7 +215,7 @@ start_key_query_greater_than_500_one_quantum_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(501,699)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         riakc_ts:query(client_pid(Ctx), Query)
     ).
 
@@ -225,7 +225,7 @@ start_key_query_greater_or_equal_to_500_one_quantum_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(500,699)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         riakc_ts:query(client_pid(Ctx), Query)
     ).
 
@@ -235,7 +235,7 @@ start_key_query_greater_than_500_two_quantum_test(Ctx) ->
     Results =
          [{1,1,N} || N <- lists:seq(501,1499)],
     ts_util:assert_row_sets(
-        {column_names_def_1(), Results},
+        {ok, {column_names_def_1(), Results}},
         riakc_ts:query(client_pid(Ctx), Query)
     ).
 
diff --git a/tests/ts_cluster_random_query_pass_eqc.erl b/tests/ts_cluster_random_query_pass_eqc.erl
index 58fcb6f49..c1b74e5b1 100644
--- a/tests/ts_cluster_random_query_pass_eqc.erl
+++ b/tests/ts_cluster_random_query_pass_eqc.erl
@@ -52,7 +52,7 @@ run_query(ClusterConn, NVal, NPuts, Q, NSpans) ->
 
     {ok, _} = ts_util:create_and_activate_bucket_type(ClusterConn, DDL, Bucket, NVal),
     ok = riakc_ts:put(Conn, Bucket, Data),
-    {_, Got} = ts_util:single_query(Conn, Query),
+    {ok, {_, Got}} = ts_util:single_query(Conn, Query),
 
     ?assertEqual(Data, Got),
 
diff --git a/tests/ts_cluster_select_pass_1.erl b/tests/ts_cluster_select_pass_1.erl
index e188fc84e..6bea6d071 100644
--- a/tests/ts_cluster_select_pass_1.erl
+++ b/tests/ts_cluster_select_pass_1.erl
@@ -31,9 +31,9 @@ confirm() ->
     DDL = ts_util:get_ddl(),
     Data = ts_util:get_valid_select_data(),
     Qry = ts_util:get_valid_qry(),
-    Expected = {
+    Expected = {ok, {
         ts_util:get_cols(),
-        ts_util:exclusive_result_from_data(Data, 2, 9)},
+        ts_util:exclusive_result_from_data(Data, 2, 9)}},
     Got = ts_util:ts_query(
             ts_util:cluster_and_connect(multiple), TestType, DDL, Data, Qry),
     ?assertEqual(Expected, Got),
diff --git a/tests/ts_cluster_select_pass_2.erl b/tests/ts_cluster_select_pass_2.erl
index 14320e80e..a7ebb235f 100644
--- a/tests/ts_cluster_select_pass_2.erl
+++ b/tests/ts_cluster_select_pass_2.erl
@@ -32,9 +32,9 @@ confirm() ->
     DDL  = ts_util:get_ddl(),
     Data = ts_util:get_valid_select_data_spanning_quanta(),
     Qry  = ts_util:get_valid_qry_spanning_quanta(),
-    Expected = {
+    Expected = {ok, {
         ts_util:get_cols(),
-        ts_util:exclusive_result_from_data(Data, 2, 9)},
+        ts_util:exclusive_result_from_data(Data, 2, 9)}},
     Got = ts_util:ts_query(
             ts_util:cluster_and_connect(multiple), normal, DDL, Data, Qry),
     ?assertEqual(Expected, Got),
diff --git a/tests/ts_cluster_select_pass_3_sorted_on_key.erl b/tests/ts_cluster_select_pass_3_sorted_on_key.erl
index 4bbb2b68a..a32c140ac 100644
--- a/tests/ts_cluster_select_pass_3_sorted_on_key.erl
+++ b/tests/ts_cluster_select_pass_3_sorted_on_key.erl
@@ -35,9 +35,9 @@ confirm() ->
     Data = ts_util:get_valid_select_data(),
     ShuffledData = shuffle_list(Data),
     Qry = ts_util:get_valid_qry(),
-    Expected = {
+    Expected = {ok, {
         ts_util:get_cols(),
-        ts_util:exclusive_result_from_data(Data, 2, 9)},
+        ts_util:exclusive_result_from_data(Data, 2, 9)}},
     % write the shuffled TS records but expect the
     % unshuffled records
     Got = ts_util:ts_query(
diff --git a/tests/ts_degraded_select_pass_1.erl b/tests/ts_degraded_select_pass_1.erl
index 63acfb27c..57ee719f8 100644
--- a/tests/ts_degraded_select_pass_1.erl
+++ b/tests/ts_degraded_select_pass_1.erl
@@ -32,9 +32,9 @@ confirm() ->
     DDL = ts_util:get_ddl(),
     Data = ts_util:get_valid_select_data(),
     Qry = ts_util:get_valid_qry(),
-    Expected = {
+    Expected = {ok, {
         ts_util:get_cols(),
-        ts_util:exclusive_result_from_data(Data, 2, 9)},
+        ts_util:exclusive_result_from_data(Data, 2, 9)}},
     {[_Node|Rest], Conn} = ClusterConn = ts_util:cluster_and_connect(multiple),
     Got = ts_util:ts_query(ClusterConn, normal, DDL, Data, Qry),
     ?assertEqual(Expected, Got),
diff --git a/tests/ts_degraded_select_pass_2.erl b/tests/ts_degraded_select_pass_2.erl
index adfbbd267..49d46474e 100644
--- a/tests/ts_degraded_select_pass_2.erl
+++ b/tests/ts_degraded_select_pass_2.erl
@@ -32,9 +32,9 @@ confirm() ->
     DDL  = ts_util:get_ddl(),
     Data = ts_util:get_valid_select_data_spanning_quanta(),
     Qry  = ts_util:get_valid_qry_spanning_quanta(),
-    Expected = {
+    Expected = {ok, {
         ts_util:get_cols(),
-        ts_util:exclusive_result_from_data(Data, 2, 9)},
+        ts_util:exclusive_result_from_data(Data, 2, 9)}},
     {[_Node|Rest], Conn} = ClusterConn = ts_util:cluster_and_connect(multiple),
     Got = ts_util:ts_query(ClusterConn, normal, DDL, Data, Qry),
     ?assertEqual(Expected, Got),
diff --git a/tests/ts_simple_aggregation.erl b/tests/ts_simple_aggregation.erl
index 519e032bc..e3ea039d1 100644
--- a/tests/ts_simple_aggregation.erl
+++ b/tests/ts_simple_aggregation.erl
@@ -70,55 +70,55 @@ verify_aggregation(ClusterType) ->
     ts_util:maybe_stop_a_node(ClusterType, Cluster),
     ok = riakc_ts:put(Conn, Bucket, Data),
     Got = ts_util:single_query(Conn, Qry),
-    Expected = {[<<"COUNT(myseries)">>], [{Count}]},
+    Expected = {ok, {[<<"COUNT(myseries)">>], [{Count}]}},
     Result = ts_util:assert(test_name(ClusterType, "Count Strings"), Expected, Got),
 
     Qry2 = "SELECT COUNT(time) FROM " ++ Bucket ++ Where,
     Got2 = ts_util:single_query(Conn, Qry2),
-    Expected2 = {[<<"COUNT(time)">>], [{Count}]},
+    Expected2 = {ok, {[<<"COUNT(time)">>], [{Count}]}},
     Result2 = ts_util:assert(test_name(ClusterType, "Count Timestamps"), Expected2, Got2),
 
     Qry3 = "SELECT COUNT(pressure), count(temperature), cOuNt(precipitation) FROM " ++ Bucket ++ Where,
     Got3 = ts_util:single_query(Conn, Qry3),
-    Expected3 = {
+    Expected3 = {ok, {
       [<<"COUNT(pressure)">>,
        <<"COUNT(temperature)">>,
        <<"COUNT(precipitation)">>
       ],
       [{count_non_nulls(Column5),
         count_non_nulls(Column4),
-        count_non_nulls(Column6)}]},
+        count_non_nulls(Column6)}]}},
     Result3 = ts_util:assert(test_name(ClusterType, "Count Multiple Floats"), Expected3, Got3),
 
     Qry4 = "SELECT SUM(temperature) FROM " ++ Bucket ++ Where,
     Got4 = ts_util:single_query(Conn, Qry4),
     Sum4 = lists:sum([X || X <- Column4, is_number(X)]),
-    Expected4 = {[<<"SUM(temperature)">>],
-                 [{Sum4}]},
+    Expected4 = {ok, {[<<"SUM(temperature)">>],
+                 [{Sum4}]}},
     Result4 = ts_util:assert(test_name(ClusterType, "Single Float Sum"), Expected4, Got4),
 
     Qry5 = "SELECT SUM(temperature), sum(pressure), sUM(precipitation) FROM " ++ Bucket ++ Where,
     Got5 = ts_util:single_query(Conn, Qry5),
     Sum5 = lists:sum([X || X <- Column5, is_number(X)]),
     Sum6 = lists:sum([X || X <- Column6, is_number(X)]),
-    Expected5 = {[<<"SUM(temperature)">>, <<"SUM(pressure)">>, <<"SUM(precipitation)">>],
-                 [{Sum4, Sum5, Sum6}]},
+    Expected5 = {ok, {[<<"SUM(temperature)">>, <<"SUM(pressure)">>, <<"SUM(precipitation)">>],
+                 [{Sum4, Sum5, Sum6}]}},
     Result5 = ts_util:assert(test_name(ClusterType, "Multiple Float Sums"), Expected5, Got5),
 
     Qry6 = "SELECT MIN(temperature), MIN(pressure) FROM " ++ Bucket ++ Where,
     Got6 = ts_util:single_query(Conn, Qry6),
     Min4 = lists:min([X || X <- Column4, is_number(X)]),
     Min5 = lists:min([X || X <- Column5, is_number(X)]),
-    Expected6 = {[<<"MIN(temperature)">>, <<"MIN(pressure)">>],
-                 [{Min4, Min5}]},
+    Expected6 = {ok, {[<<"MIN(temperature)">>, <<"MIN(pressure)">>],
+                 [{Min4, Min5}]}},
     Result6 = ts_util:assert(test_name(ClusterType, "Min Floats"), Expected6, Got6),
 
     Qry7 = "SELECT MAX(temperature), MAX(pressure) FROM " ++ Bucket ++ Where,
     Got7 = ts_util:single_query(Conn, Qry7),
     Max4 = lists:max([X || X <- Column4, is_number(X)]),
     Max5 = lists:max([X || X <- Column5, is_number(X)]),
-    Expected7 = {[<<"MAX(temperature)">>, <<"MAX(pressure)">>],
-                 [{Max4, Max5}]},
+    Expected7 = {ok, {[<<"MAX(temperature)">>, <<"MAX(pressure)">>],
+                 [{Max4, Max5}]}},
     Result7 = ts_util:assert(test_name(ClusterType, "Max Floats"), Expected7, Got7),
 
     C4 = [X || X <- Column4, is_number(X)],
@@ -130,8 +130,8 @@ verify_aggregation(ClusterType) ->
     Avg5 = Sum5 / Count5,
     Qry8 = "SELECT AVG(temperature), MEAN(pressure) FROM " ++ Bucket ++ Where,
     Got8 = ts_util:single_query(Conn, Qry8),
-    Expected8 = {[<<"AVG(temperature)">>, <<"MEAN(pressure)">>],
-                 [{Avg4, Avg5}]},
+    Expected8 = {ok, {[<<"AVG(temperature)">>, <<"MEAN(pressure)">>],
+                 [{Avg4, Avg5}]}},
     Result8 = ts_util:assert(test_name(ClusterType, "Avg and Mean"), Expected8, Got8),
 
     StdDevFun4 = stddev_fun_builder(Avg4),
@@ -144,16 +144,16 @@ verify_aggregation(ClusterType) ->
            " STDDEV(temperature), STDDEV(pressure), " ++
            " STDDEV_SAMP(temperature), STDDEV_SAMP(pressure) FROM " ++ Bucket ++ Where,
     Got9 = ts_util:single_query(Conn, Qry9),
-    Expected9 = {[<<"STDDEV_POP(temperature)">>, <<"STDDEV_POP(pressure)">>,
+    Expected9 = {ok, {[<<"STDDEV_POP(temperature)">>, <<"STDDEV_POP(pressure)">>,
                   <<"STDDEV(temperature)">>, <<"STDDEV(pressure)">>,
                   <<"STDDEV_SAMP(temperature)">>, <<"STDDEV_SAMP(pressure)">>],
-                 [{StdDev4, StdDev5, StdDev4, StdDev5, Sample4, Sample5}]},
+                 [{StdDev4, StdDev5, StdDev4, StdDev5, Sample4, Sample5}]}},
     Result9 = ts_util:assert_float(test_name(ClusterType, "Standard Deviation"), Expected9, Got9),
 
     Qry10 = "SELECT SUM(temperature), MIN(pressure), AVG(pressure) FROM " ++ Bucket ++ Where,
     Got10 = ts_util:single_query(Conn, Qry10),
-    Expected10 = {[<<"SUM(temperature)">>, <<"MIN(pressure)">>, <<"AVG(pressure)">>],
-                  [{Sum4, Min5, Avg5}]},
+    Expected10 = {ok, {[<<"SUM(temperature)">>, <<"MIN(pressure)">>, <<"AVG(pressure)">>],
+                  [{Sum4, Min5, Avg5}]}},
     Result10 = ts_util:assert(test_name(ClusterType, "Mixter Maxter"), Expected10, Got10),
 
     ts_util:results([
diff --git a/tests/ts_simple_aggregation_math.erl b/tests/ts_simple_aggregation_math.erl
index 2c2d8fa0c..cd2278512 100644
--- a/tests/ts_simple_aggregation_math.erl
+++ b/tests/ts_simple_aggregation_math.erl
@@ -42,22 +42,22 @@ confirm() ->
     ClusterConn = {_Cluster, Conn} = ts_util:cluster_and_connect(single),
     FilteredTemp = lists:filter(fun(X) -> case X>10 andalso is_number(X) of true -> true; _ -> false end end, Column4),
     _FilteredSum4 = lists:sum(FilteredTemp),
-    {_, _Got} = ts_util:ts_query(ClusterConn, TestType, DDL, Data, Qry, Bucket),
+    {_, {_, _Got}} = ts_util:ts_query(ClusterConn, TestType, DDL, Data, Qry, Bucket),
     %% ?assertEqual((FilteredSum4/length(FilteredTemp)) * (9/5) + 32, Got),
 
     Qry2 = "SELECT SUM(pressure/precipitation) FROM " ++ Bucket ++ Where,
-    {_, Got2} = ts_util:single_query(Conn, Qry2),
+    {ok, {_, Got2}} = ts_util:single_query(Conn, Qry2),
     SumDiv = lists:sum(
         [Press/Precip || {Press, Precip} <- lists:zip(Column5, Column6), Press /= [], Precip /= []]),
     ?assertEqual([{SumDiv}], Got2),
 
     Qry3 = "SELECT 3+5, 2.0+8, 9/2, 9.0/2 FROM " ++ Bucket ++ Where,
-    {_, Got3} = ts_util:single_query(Conn, Qry3),
+    {ok, {_, Got3}} = ts_util:single_query(Conn, Qry3),
     Arithmetic = [{8, 10.0, 4, 4.5} || _ <- lists:seq(1, Count)],
     ?assertEqual(Arithmetic, Got3),
 
     Qry4 = "SELECT SUM(temperature+10), AVG(pressure)/10 FROM " ++ Bucket ++ Where,
-    {_, Got4} = ts_util:single_query(Conn, Qry4),
+    {ok, {_, Got4}} = ts_util:single_query(Conn, Qry4),
     SumPlus = lists:sum([X+10 || X<-Column4]),
     AvgDiv = lists:sum(Column5)/Count/10,
     ?assertEqual([{SumPlus, AvgDiv}], Got4),
@@ -90,6 +90,6 @@ div_aggregate_function_by_zero_test(Conn, Bucket, Where) ->
 negate_an_aggregation_test(Conn, Bucket, Where) ->
     Query = "SELECT -COUNT(*), COUNT(*) FROM " ++ Bucket ++ Where,
     ?assertEqual(
-        {[<<"-COUNT(*)">>, <<"COUNT(*)">>],[{-10, 10}]},
+        {ok, {[<<"-COUNT(*)">>, <<"COUNT(*)">>],[{-10, 10}]}},
         ts_util:single_query(Conn, Query)
     ).
\ No newline at end of file
diff --git a/tests/ts_simple_api.erl b/tests/ts_simple_api.erl
index baa34832a..92d815ef0 100644
--- a/tests/ts_simple_api.erl
+++ b/tests/ts_simple_api.erl
@@ -112,7 +112,7 @@ confirm_NeqOps(C) ->
 
 confirm_pass(C, Qry, Expected) ->
     Got = ts_util:single_query(C, Qry),
-    {_Cols, Records} = Got,
+    {ok, {_Cols, Records}} = Got,
     N = length(Records),
     ?assertEqual(Expected, Got),
     ?assert(N > 0).
@@ -183,9 +183,9 @@ expected(Type, Data, Fields, CompVals, CompFn) ->
     Records = recordsMatching(Type, Data, Fields, CompVals, CompFn),
     case Records of
         [] ->
-            {[],[]};
+            {ok, {[],[]}};
         _ ->
-            {ts_util:get_cols(Type), Records}
+            {ok, {ts_util:get_cols(Type), Records}}
     end.
 
 %------------------------------------------------------------
diff --git a/tests/ts_simple_describe_table.erl b/tests/ts_simple_describe_table.erl
index 0d4402aeb..87e9b989f 100644
--- a/tests/ts_simple_describe_table.erl
+++ b/tests/ts_simple_describe_table.erl
@@ -36,11 +36,11 @@ confirm() ->
     ts_util:create_and_activate_bucket_type(ClusterConn, DDL),
     Got = ts_util:single_query(Conn, Qry),
     Expected =
-        {[<<"Column">>,<<"Type">>,<<"Is Null">>,<<"Primary Key">>, <<"Local Key">>],
+        {ok, {[<<"Column">>,<<"Type">>,<<"Is Null">>,<<"Primary Key">>, <<"Local Key">>],
         [{<<"myfamily">>,  <<"varchar">>,   false,  1,  1},
         {<<"myseries">>,   <<"varchar">>,   false,  2,  2},
         {<<"time">>,       <<"timestamp">>, false,  3,  3},
         {<<"weather">>,    <<"varchar">>,   false, [], []},
-        {<<"temperature">>,<<"double">>,    true,  [], []}]},
+        {<<"temperature">>,<<"double">>,    true,  [], []}]}},
     ?assertEqual(Expected, Got),
     pass.
diff --git a/tests/ts_simple_insert.erl b/tests/ts_simple_insert.erl
index 032748d96..f7e3f0a71 100644
--- a/tests/ts_simple_insert.erl
+++ b/tests/ts_simple_insert.erl
@@ -45,12 +45,12 @@ confirm() ->
                    [ts_util:ts_insert(Conn, Table, Columns, Datum) | Acc]
                end,
     Got1 = lists:reverse(lists:foldl(Insert1Fn, [], Data1)),
-    Expected1 = lists:duplicate(10, {[],[]}),
+    Expected1 = lists:duplicate(10, {ok,{[],[]}}),
     Result1 = ts_util:assert("Insert With Columns", Expected1, Got1),
 
     Qry2 = "select * from GeoCheckin Where time >= 1 and time <= 10 and myfamily = 'family1' and myseries ='seriesX'",
     Got2 = ts_util:single_query(Conn, Qry2),
-    Expected2 = {Columns, ts_util:exclusive_result_from_data(Data1, 1, 10)},
+    Expected2 = {ok, {Columns, ts_util:exclusive_result_from_data(Data1, 1, 10)}},
     Result2 = ts_util:assert("Insert With Columns (results)", Expected2, Got2),
 
     Data3 = ts_util:get_valid_select_data(fun() -> lists:seq(11, 20) end),
@@ -62,7 +62,7 @@ confirm() ->
 
     Qry4 = "select * from GeoCheckin Where time >= 11 and time <= 20 and myfamily = 'family1' and myseries ='seriesX'",
     Got4 = ts_util:single_query(Conn, Qry4),
-    Expected4 = {Columns, ts_util:exclusive_result_from_data(Data3, 1, 10)},
+    Expected4 = {ok, {Columns, ts_util:exclusive_result_from_data(Data3, 1, 10)}},
     Result4 = ts_util:assert("Insert Without Columns (results)", Expected4, Got4),
 
     ts_util:results([
diff --git a/tests/ts_simple_select.erl b/tests/ts_simple_select.erl
index 39b321584..60be5cb93 100644
--- a/tests/ts_simple_select.erl
+++ b/tests/ts_simple_select.erl
@@ -32,8 +32,8 @@ confirm() ->
     Data = ts_util:get_valid_select_data(),
     Qry = ts_util:get_valid_qry(),
     Expected =
-        {ts_util:get_cols(small),
-         ts_util:exclusive_result_from_data(Data, 2, 9)},
+        {ok, {ts_util:get_cols(small),
+         ts_util:exclusive_result_from_data(Data, 2, 9)}},
     Got = ts_util:ts_query(
             ts_util:cluster_and_connect(single), TestType, DDL, Data, Qry),
     ?assertEqual(Expected, Got),
diff --git a/tests/ts_simple_select_double_in_key.erl b/tests/ts_simple_select_double_in_key.erl
index 1f0449e5a..7e2213905 100644
--- a/tests/ts_simple_select_double_in_key.erl
+++ b/tests/ts_simple_select_double_in_key.erl
@@ -41,7 +41,7 @@ confirm() ->
         "AND myseries = 'series' "
         "AND myfamily = 13.777744543543500002342342342342342340000000017777445435435000023423423423423423400000000177774454354350000234234234234234234000000001",
     ?assertEqual(
-        {[<<"myfamily">>, <<"myseries">>, <<"time">>], input_data()},
+        {ok, {[<<"myfamily">>, <<"myseries">>, <<"time">>], input_data()}},
         ts_util:ts_query(
             ts_util:cluster_and_connect(single), TestType, TableDef, input_data(), Query)),
     pass.
diff --git a/tests/ts_simple_select_not_found.erl b/tests/ts_simple_select_not_found.erl
index 3b1a99a9c..e600ad11d 100644
--- a/tests/ts_simple_select_not_found.erl
+++ b/tests/ts_simple_select_not_found.erl
@@ -41,7 +41,7 @@ confirm() ->
         "AND myfamily = 'family1' "
         "AND myseries = 'seriesX' "
         "AND weather = 'summer rain'",
-    Expected = {[], []},
+    Expected = {ok, {[], []}},
     Got = ts_util:ts_query(
             ts_util:cluster_and_connect(single), normal, DDL, Data, Qry),
     ?assertEqual(Expected, Got),
diff --git a/tests/ts_simple_single_key_ops.erl b/tests/ts_simple_single_key_ops.erl
index 9095d17d8..77a436e3f 100644
--- a/tests/ts_simple_single_key_ops.erl
+++ b/tests/ts_simple_single_key_ops.erl
@@ -35,7 +35,7 @@ table_def_1() ->
     "PRIMARY KEY  ((a,b,quantum(c, 1, 's')), a,b,c))".
 
 create_table_def_1(Pid) ->
-    ?assertEqual({[],[]}, riakc_ts:query(Pid, table_def_1())),
+    ?assertEqual({ok, {[],[]}}, riakc_ts:query(Pid, table_def_1())),
     ok = riakc_ts:put(Pid, <<"table1">>, [{1,2,N,4} || N <- lists:seq(1,200)]).
 
 delete_single_key_def_1_test(Pid) ->
@@ -57,8 +57,8 @@ table_def_2() ->
     "PRIMARY KEY  ((d,a,quantum(c, 1, 's')), d,a,c))".
 
 create_table_def_2(Pid) ->
-    ?assertEqual({[],[]}, riakc_ts:query(Pid, table_def_2())),
-    ok = riakc_ts:put(Pid, <<"table2">>, [[1,2,N,4] || N <- lists:seq(1,200)]).
+    ?assertEqual({ok, {[],[]}}, riakc_ts:query(Pid, table_def_2())),
+    ok = riakc_ts:put(Pid, <<"table2">>, [{1,2,N,4} || N <- lists:seq(1,200)]).
 
 delete_single_key_def_2_test(Pid) ->
     ?assertEqual(
@@ -80,7 +80,7 @@ table_def_3() ->
     "PRIMARY KEY  ((ax,a,quantum(c, 1, 's')), ax,a,c))".
 
 create_table_def_3(Pid) ->
-    ?assertEqual({[],[]}, riakc_ts:query(Pid, table_def_3())),
+    ?assertEqual({ok, {[],[]}}, riakc_ts:query(Pid, table_def_3())),
     ok = riakc_ts:put(Pid, <<"table3">>, [{1,2,3,N,4} || N <- lists:seq(1,200)]).
 
 delete_single_key_def_3_test(Pid) ->
@@ -95,7 +95,7 @@ delete_single_key_def_3_test(Pid) ->
 
 
 create_table_def_4(Pid) ->
-    ?assertEqual({[],[]}, riakc_ts:query(Pid, 
+    ?assertEqual({ok, {[],[]}}, riakc_ts:query(Pid, 
         "CREATE TABLE table4 ("
         "a SINT64 NOT NULL, "
         "b SINT64 NOT NULL, "
@@ -107,7 +107,7 @@ create_table_def_4(Pid) ->
 query_key_after_it_has_been_deleted_test(Pid) ->
     riakc_ts:delete(Pid, <<"table4">>, [1,2,4], []),
     ?assertEqual(
-        {[],[]},
+        {ok, {[],[]}},
         riakc_ts:query(Pid, "SELECT * FROM table4 WHERE a = 1 AND b = 2 AND c >= 4 AND c <= 4", [])
     ).
 
@@ -115,6 +115,6 @@ query_key_after_it_has_been_deleted_test(Pid) ->
 query_key_in_range_after_it_has_been_deleted_test(Pid) ->
     riakc_ts:delete(Pid, <<"table4">>, [1,2,15], []),
     ?assertEqual(
-        {[<<"a">>, <<"b">>, <<"c">>],[{1,2,N} || N <- lists:seq(11,19), N /= 15]},
+        {ok, {[<<"a">>, <<"b">>, <<"c">>],[{1,2,N} || N <- lists:seq(11,19), N /= 15]}},
         riakc_ts:query(Pid, "SELECT * FROM table4 WHERE a = 1 AND b = 2 AND c > 10 AND c < 20", [])
     ).
diff --git a/tests/ts_util.erl b/tests/ts_util.erl
index f04c2902a..90005718a 100644
--- a/tests/ts_util.erl
+++ b/tests/ts_util.erl
@@ -549,13 +549,13 @@ assert_error_regex_result(_, _String, _Expected, _Got) ->
 %% If `ColExpected' is the atom `rt_ignore_columns' then do not assert columns.
 assert_row_sets(_, {error,_} = Error) ->
     ct:fail(Error);
-assert_row_sets({ColExpected, Expected}, {ColsActual,Actual}) ->
-    case ColExpected of
-        rt_ignore_columns ->
-            ok;
-        _ ->
-            ?assertEqual(ColExpected,ColsActual)
-    end,
+assert_row_sets({rt_ignore_columns, Expected}, {_, {_, Actual}}) ->
+    ct_verify_rows(Expected, Actual);
+assert_row_sets({_, {ColExpected, Expected}}, {_, {ColsActual, Actual}}) ->
+    ?assertEqual(ColExpected, ColsActual),
+    ct_verify_rows(Expected, Actual).
+
+ct_verify_rows(Expected, Actual) ->
     case tdiff:diff(Expected, Actual) of
         [{eq,_}] ->
             pass;