anchor.diff:  %%      DDL.  On success, 'ok' is returned, else an @{error, Reason@}
   %%      tuple.
   %%
  -%%      Note: Type validation is done on the first record only.  If
  -%%      any subsequent record contains fewer or more elements than
  -%%      there are columns, or some element fails to convert to the
  -%%      appropriate type, the rest of the records will not get
  -%%      inserted.
  +%%      put/3 uses the default encoding for communication with the
  +%%      server (set by riak_pb_socket:use_native_encoding/2)
  +
   put(Pid, TableName, Measurements) ->
       put(Pid, TableName, [], Measurements).
   
  --spec put(Pid::pid(), Table::table_name(), ColumnNames::[ts_columnname()], Data::[[ts_value()]]) ->
  +-spec put(Pid::pid(), Table::table_name(), [ts_columnname()] | [[ts_value()]], [[ts_value()]] | boolean()) ->
                    ok | {error, Reason::term()}.
   %% @doc Make data records from Data and insert them, individually,
   %%      into a time-series Table, using client Pid. Each record is a
  
positive.code: %%
  %%      As of 2015-11-05, ColumnNames parameter is ignored, the function
  %%      expects the full set of fields in each element of Data.
  put(Pid, TableName, ColumnNames, Measurements) ->
      Message = riakc_ts_put_operator:serialize(use_native_encoding(Pid), TableName, ColumnNames, Measurements),
      Response = server_call(Pid, Message),
      riakc_ts_put_operator:deserialize(Response).
  
  
negative.code: %%      first element, and a list of records, each represented as a
  %%      list of values, in the second element, or an @{error, Reason@}
  %%      tuple.
  %%
  %%      query/2 always uses the default encoding for communication
  %%      with the server (set by riak_pb_socket:use_native_encoding/2)
  
  query(Pid, QueryText) ->
      query(Pid, QueryText, []).
  
  -spec query(Pid::pid(), Query::string(), [{binary(), binary()}] | boolean()) ->
                     {ColumnNames::[binary()], Rows::[tuple()]} | {error, term()}.
  %% @doc Execute a "SELECT ..." Query with client.  The result returned
  %%      is a tuple containing a list of columns as binaries in the
  %%      first element, and a list of records, each represented as a
  %%      list of values, in the second element, or an @{error, Reason@}
  %%      tuple.
  %%
  %%      query/3 switches on the last argument:
  %%
  %%        When a list of interpolations is specified, a query using
  %%        interpolations is sent to the server using the default
  %%        encoding (set by riak_pb_socket:use_native_encoding/2)
  %%   
  %%        When a boolean is specified, query/3 acts just like query/2
  %%        but uses the boolean to determine the encoding type
  %%
  
  query(Pid, QueryText, true) ->
  	query(Pid, QueryText, [], true);
  query(Pid, QueryText, false) ->
  	query(Pid, QueryText, [], false);
  query(Pid, QueryText, Interpolations) ->
  	query(Pid, QueryText, Interpolations, use_native_encoding(Pid)).
  
  -spec query(Pid::pid(), Query::string(), Interpolations::[{binary(), binary()}], term()) ->
                     {ColumnNames::[binary()], Rows::[tuple()]} | {error, term()}.
  %% @doc Execute a "SELECT ..." Query with client.  The result returned
  %%      is a tuple containing a list of columns as binaries in the
  %%      first element, and a list of records, each represented as a
  %%      list of values, in the second element, or an @{error, Reason@}
  %%      tuple.
  %%
  %%      query/4 switches in the last argument:
  %%
  %%        When these are: (interpolations, cover), a query using an
  %%        explicit coverage list is sent to the server, using the
  %%        default encoding (set by riak_pb_socket:use_native_encoding/2)
  %%   
  %%        When these are: (interpolations, boolean), query/4 acts just
  %%        like query/3 but uses the boolean to determine the encoding
  %%        type
  %%
  
  query(Pid, QueryText, Interpolations, true) ->
  	get_query_response_nocover(Pid, QueryText, Interpolations, true);
  query(Pid, QueryText, Interpolations, false) ->
  	get_query_response_nocover(Pid, QueryText, Interpolations, false);
  query(Pid, QueryText, Interpolations, Cover) ->
  	query(Pid, QueryText, Interpolations, Cover, use_native_encoding(Pid)).
  
  get_query_response_nocover(Pid, QueryText, Interpolations, UseNativeEncoding) ->
      Message = riakc_ts_query_operator:serialize(UseNativeEncoding, QueryText, Interpolations),
      Response = server_call(Pid, Message),
      riakc_ts_query_operator:deserialize(Response).
  
  -spec query(Pid::pid(), Query::string(), Interpolations::[{binary(), binary()}], Cover::term(), UseNativeEncoding::boolean()) ->
                     {ColumnNames::[binary()], Rows::[tuple()]} | {error, term()}.
  %% @doc Execute a "SELECT ..." Query with client.  The result returned
  %%      is a tuple containing a list of columns as binaries in the
  %%      first element, and a list of records, each represented as a
  %%      list of values, in the second element, or an @{error, Reason@}
  %%      tuple.
  %%
  %%      query/5 acts like query/4 with interpolations and coverage
  %%      list, but additionally specifies the encoding
  
  query(Pid, QueryText, Interpolations, Cover, false) ->
      Message = riakc_ts_query_operator:serialize(false, QueryText, Interpolations),
      Response = server_call(Pid, Message#tsqueryreq{cover_context=Cover}),
      riakc_ts_query_operator:deserialize(Response);
  query(Pid, QueryText, Interpolations, Cover, true) ->
      Message = riakc_ts_query_operator:serialize(true, QueryText, Interpolations),
      Response = server_call(Pid, Message#tsttbqueryreq{cover_context=Cover}),
      riakc_ts_query_operator:deserialize(Response).
  
  %% @doc Generate a parallel coverage plan for the specified query
  get_coverage(Pid, Table, QueryText) ->
  