anchor.diff:                                            (select ((max release-date))
                                                     (where version
                                                            (<= release-date
  -                                                             (- (to_universal_time "now") (* 86400 ,(1- day)))))))
  +                                                             (- (to_universal_time "today") (* 86400 ,(1- day)))))))
                                          is-release
                                          (= ,impl i-name)))
                                  (release-date) :desc))
  
positive.code:                                    b-name v-name
                                     (pg-result
                                      (pg-exec *dbconn*
                                               (translate
                                                `(select (v-version (avg seconds) release-date)
                                                         (order-by (group-by (where (join result version
                                                                                          :on (and (= v-name i-name) (= v-version version)))
                                                                                    (and
                                                                                     (between date
                                                                                              (- (to_universal_time "now") (* 86400 ,(1+ day)))
                                                                                              (- (to_universal_time "now") (* 86400 ,day)))
                                                                                     (not (= b-name ,b-name))
                                                                                     (= v_name ,v-name)
                                                                                     (= m_name ,host)))
                                                                             (v-version release-date))
  
negative.code:       (iterate (for day from 1 to *go-back-days*)
                 (for entry =
                      (iterate (for (v-name b-name stddev) in-relation
                                     (translate
                                     `(select (v-name b-name (stddev seconds))
                                              (having
                                               (group-by (where result
                                                                (and
                                                                 (between date
                                                                          (- (to_universal_time "today") (* 86400 ,(1+ day)))
                                                                          (- (to_universal_time "today") (* 86400 ,day)))
                                                                 (not (in b-name ,*ignore-benchmarks*))
                                                                 (= v_name ,implementation)
                                                                 (= m_name ,host)))
  