xapian-applications/omega/datevalue.cc

   1 /** @file
   2  * @brief date filtering using value ranges
   3  */
   4 /* Copyright (C) 2006,2015,2021 Olly Betts
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  19  */
  20
  21 #include <config.h>
  22
  23 #include "datevalue.h"
  24
  25 #include <cstdlib>
  26 #include <cstring>
  27 #include <ctime>
  28
  29 #include <xapian.h>
  30
  31 #include "timegm.h"
  32 #include "values.h"
  33
  34 using namespace std;
  35
  36 class DateRangeLimit {
  37     struct tm tm;
  38
  39     static int DIGIT(char ch) { return ch - '0'; }
  40
  41     static int DIGIT2(const char *p) {
  42         return DIGIT(p[0]) * 10 + DIGIT(p[1]);
  43     }
  44
  45     static int DIGIT4(const char *p) {
  46         return DIGIT2(p) * 100 + DIGIT2(p + 2);
  47     }
  48
  49     int is_leap_year() const {
  50         int y = tm.tm_year;
  51         return (y % 4 == 0 && (y % 100 != 0 || y % 400 == 100));
  52     }
  53
  54     int month_length() const {
  55         static const int usual_month_length[12] = {
  56             31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  57         };
  58         if (tm.tm_mon == 1 && is_leap_year()) return 29;
  59         return usual_month_length[tm.tm_mon];
  60     }
  61
  62   public:
  63     DateRangeLimit() { tm.tm_sec = -1; }
  64
  65     DateRangeLimit(const string & str, bool start);
  66
  67     explicit DateRangeLimit(time_t secs) {
  68 #ifdef HAVE_GMTIME_R
  69         if (gmtime_r(&secs, &tm) == NULL) {
  70             tm.tm_sec = -1;
  71         }
  72 #else
  73         // Not thread-safe, but that isn't important for our uses here.
  74         struct tm * r = gmtime(&secs);
  75         if (r) {
  76             tm = *r;
  77         } else {
  78             tm.tm_sec = -1;
  79         }
  80 #endif
  81     }
  82
  83     bool is_set() const { return tm.tm_sec >= 0; }
  84
  85     DateRangeLimit operator-(int span) {
  86         if (!is_set()) return *this;
  87         return DateRangeLimit(timegm(&tm) - span);
  88     }
  89
  90     DateRangeLimit operator+(int span) {
  91         if (!is_set()) return *this;
  92         return DateRangeLimit(timegm(&tm) + span);
  93     }
  94
  95     string format(bool start) const;
  96
  97     string bin4(bool start) {
  98         if (!is_set()) {
  99             return start ? string() : string(4, '\xff');
 100         }
 101         time_t s = timegm(&tm);
 102         if (s <= 0) {
 103             return string();
 104         }
 105         if (sizeof(time_t) > 4 && s >= 0xffffffff) {
 106             return string(4, '\xff');
 107         }
 108         return int_to_binary_string(uint32_t(s));
 109     }
 110 };
 111
 112 DateRangeLimit::DateRangeLimit(const string & str, bool start)
 113 {
 114     if (str.empty()) {
 115         tm.tm_sec = -1;
 116         return;
 117     }
 118
 119     memset(&tm, 0, sizeof(struct tm));
 120     if (start) {
 121         tm.tm_mday = 1;
 122     } else {
 123         tm.tm_mon = 11;
 124         tm.tm_hour = 23;
 125         tm.tm_min = 59;
 126         tm.tm_sec = 59;
 127     }
 128     const char * p = str.data();
 129     tm.tm_year = DIGIT4(p) - 1900;
 130
 131     if (str.size() >= 6) {
 132         tm.tm_mon = DIGIT2(p + 4) - 1;
 133         if (str.size() >= 8) {
 134             tm.tm_mday = DIGIT2(p + 6);
 135             if (str.size() >= 10) {
 136                 tm.tm_hour = DIGIT2(p + 8);
 137                 if (str.size() >= 12) {
 138                     tm.tm_min = DIGIT2(p + 10);
 139                     if (str.size() >= 14) {
 140                         tm.tm_sec = DIGIT2(p + 12);
 141                     }
 142                 }
 143             }
 144             return;
 145         }
 146     }
 147
 148     if (!start) tm.tm_mday = month_length();
 149 }
 150
 151 string
 152 DateRangeLimit::format(bool start) const
 153 {
 154     if (!is_set()) {
 155         return start ? string() : string(1, '~');
 156     }
 157
 158     char fmt[] = "%Y%m%d%H%M%S";
 159     size_t fmt_len = sizeof(fmt) - 1;
 160
 161     if (start) {
 162         if (tm.tm_sec == 0) {
 163             if (tm.tm_min == 0) {
 164                 if (tm.tm_hour == 0) {
 165                     if (tm.tm_mday <= 1) {
 166                         if (tm.tm_mon == 0) {
 167                             fmt_len = 2;
 168                         } else {
 169                             fmt_len = 4;
 170                         }
 171                     } else {
 172                         fmt_len = 6;
 173                     }
 174                 } else {
 175                     fmt_len = 8;
 176                 }
 177             } else {
 178                 fmt_len = 10;
 179             }
 180         }
 181     } else {
 182         // If there's a leap second right after a range end, it'll just get
 183         // treated as being in the range.  This doesn't seem like a big
 184         // issue, and if we worry about getting that case right, we can never
 185         // contract a range unless it ends on second 60, or we know when all
 186         // the leap seconds are.
 187         if (tm.tm_sec >= 59) {
 188             if (tm.tm_min >= 59) {
 189                 if (tm.tm_hour >= 23) {
 190                     if (tm.tm_mday >= month_length()) {
 191                         if (tm.tm_mon >= 11) {
 192                             fmt_len = 2;
 193                         } else {
 194                             fmt_len = 4;
 195                         }
 196                     } else {
 197                         fmt_len = 6;
 198                     }
 199                 } else {
 200                     fmt_len = 8;
 201                 }
 202             } else {
 203                 fmt_len = 10;
 204             }
 205         }
 206     }
 207     fmt[fmt_len] = '\0';
 208     char buf[15];
 209     size_t len = strftime(buf, sizeof(buf), fmt, &tm);
 210     if (start) {
 211         while (len && buf[len - 1] == '0') --len;
 212     } else {
 213         while (len && buf[len - 1] == '9') --len;
 214         if (len < 14) {
 215             // Append a character that will sort after any valid extra
 216             // precision.
 217             buf[len++] = '~';
 218         }
 219     }
 220     return string(buf, len);
 221 }
 222
 223 Xapian::Query
 224 date_value_range(bool as_time_t,
 225                  Xapian::valueno slot,
 226                  const std::string & date_start,
 227                  const std::string & date_end,
 228                  const std::string & date_span)
 229 {
 230     DateRangeLimit start(date_start, true);
 231     DateRangeLimit end(date_end, false);
 232
 233     if (!date_span.empty()) {
 234         time_t span = atoi(date_span.c_str()) * (24 * 60 * 60) - 1;
 235         if (end.is_set()) {
 236             // If START, END and SPAN are all set, we (somewhat arbitrarily)
 237             // ignore START.
 238             start = end - span;
 239         } else if (start.is_set()) {
 240             end = start + span;
 241         } else {
 242             // Only SPAN is set, so go back from now.
 243             time_t now = time(NULL);
 244             end = DateRangeLimit(now);
 245             start = end - span;
 246         }
 247     }
 248
 249     if (as_time_t) {
 250         return Xapian::Query(Xapian::Query::OP_VALUE_RANGE, slot,
 251                              start.bin4(true), end.bin4(false));
 252     }
 253
 254     return Xapian::Query(Xapian::Query::OP_VALUE_RANGE, slot,
 255                          start.format(true), end.format(false));
 256 }