Microseconds not matching in Ruby and PG

[algodave]

Seems like Time#usec used in Chronomodel::Conversions#time_to_utc_string sometimes returns a different number than the one actually stored in PG.

This prevents pred and succ to be computed properly.

In the following example, I'm trying to fetch the most recent history record and its predecessor, but the pred method fails as it returns nil.

record = MyModel.find(123)
# got the record
most_recent = record.history.last
# got the history record
most_recent.valid_from.usec
# => 129625
most_recent.pred
# => nil

In order to check that a predecessor actually exists, I computed it "manually" like this:

computed_pred = 
  if record.history.count > 1
    record.history[record.history.count - 2]
  else
    nil
  end

This way, I got the history record and then I checked its valid_to's microseconds:

computed_pred.valid_to.usec
# => 129625

On the Ruby side, it is the same as most_recent record's valid_from. Where's the issue then? I checked on the PG side by executing the following query:

select validity from history.my_table where id=123 order by recorded_at;

and I got a result like this:

                       validity
------------------------------------------------------
 ["2012-03-10 00:00:00","2017-02-06 09:46:31.129626")
 ["2017-02-06 09:46:31.129626",)
(2 rows)

As you can see, microseconds differ in their last digit.

What happened?

Chronomodel was able to fetch the most_recent record because it doesn't use any timestamp in that query's conditions. But, when asking for most_recent.pred it passes most_recent.valid_from to Chronomodel::Conversions#time_to_utc_string in order to build the query condition, so '2017-02-06 09:46:31.129625' is passed to PG, and then no results are returned.

I am on the improve-amend-period branch with Ruby 2.3.3, PostgreSQL 9.4.9 and am using:

activerecord (5.0.1)
pg (0.19.0)

[vjt]

Problem identified. This code needlessly uses floating-point math causing rounding errors.

>> t = '2017-02-06 09:46:31.129626'
=> "2017-02-06 09:46:31.129626"
>> t =~ ISO_DATETIME
=> 0
>> $7
=> ".129626"
>> $7.to_f
=> 0.129626
>> $7.to_f * 1_000_000
=> 129625.99999999999
>> ($7.to_f * 1_000_000).to_i
=> 129625

Changing the regexp to capture only what is after the . and then using integer-only conversion removes the problem entirely.

Now working on a test case.

[vjt]

@algodave please test and let me know, I will cut a release afterwards.